TopoTask.h

Go to the documentation of this file.

// Copyright 2014 GSI, Inc. All rights reserved.
//
//
//

#ifndef __DDS__TopoTask__
#define __DDS__TopoTask__

// DDS
#include "TopoDef.h"
#include "TopoElement.h"
#include "TopoProperty.h"
#include "TopoRequirement.h"
#include "TopoTrigger.h"
// STD
#include <memory>
#include <string>
// BOOST
#include <boost/iterator/filter_iterator.hpp>

namespace dds
{
    namespace topology_api
    {
        class CTopoTask : public CTopoElement
        {
          public:
            using Ptr_t = std::shared_ptr<CTopoTask>;
            using PtrVector_t = std::vector<CTopoTask::Ptr_t>;

            CTopoTask(const std::string& _name);

            virtual ~CTopoTask();

            const std::string& getExe() const;
            const std::string& getEnv() const;
            bool isExeReachable() const;
            bool isEnvReachable() const;
            size_t getNofProperties() const;
            size_t getNofRequirements() const;
            size_t getNofTriggers() const;
            const CTopoProperty::PtrMap_t& getProperties() const;
            const CTopoRequirement::PtrVector_t& getRequirements() const;
            const CTopoTrigger::PtrVector_t& getTriggers() const;
            CTopoProperty::Ptr_t getProperty(const std::string& _id) const;

            void setExe(const std::string& _exe);
            void setEnv(const std::string& _env);
            void setExeReachable(bool _exeReachable);
            void setEnvReachable(bool _envReachable);
            CTopoProperty::Ptr_t addProperty(const std::string& _name);
            CTopoRequirement::Ptr_t addRequirement(const std::string& _name);
            CTopoTrigger::Ptr_t addTrigger(const std::string& _name);

            // Parent collection and group ID
            std::string getParentCollectionId() const;
            std::string getParentGroupId() const;

            size_t getTotalCounter() const;

            virtual size_t getNofTasks() const;

            virtual size_t getTotalNofTasks() const;

            virtual void initFromPropertyTree(const boost::property_tree::ptree& _pt);

            virtual void saveToPropertyTree(boost::property_tree::ptree& _pt);

            virtual std::string toString() const;

            friend std::ostream& operator<<(std::ostream& _strm, const CTopoTask& _task);

            virtual std::string hashString() const;

          private:
            std::string m_exe;                            
            std::string m_env;                            
            bool m_exeReachable{ true };                  
            bool m_envReachable{ true };                  
            CTopoProperty::PtrMap_t m_properties;         
            CTopoRequirement::PtrVector_t m_requirements; 
            CTopoTrigger::PtrVector_t m_triggers;         
        };

        struct STopoRuntimeTask
        {
            typedef std::map<Id_t, STopoRuntimeTask> Map_t;
            typedef std::function<bool(std::pair<Id_t, const STopoRuntimeTask&>)> Condition_t;
            typedef boost::filter_iterator<STopoRuntimeTask::Condition_t, STopoRuntimeTask::Map_t::const_iterator>
                FilterIterator_t;
            typedef std::pair<STopoRuntimeTask::FilterIterator_t, STopoRuntimeTask::FilterIterator_t>
                FilterIteratorPair_t;

            STopoRuntimeTask()
                : m_task(nullptr)
                , m_taskIndex(0)
                , m_collectionIndex(std::numeric_limits<uint32_t>::max())
                , m_taskPath()
                , m_taskCollectionId(0)
            {
            }
            CTopoTask::Ptr_t m_task;
            size_t m_taskIndex;
            size_t m_collectionIndex;
            std::string m_taskPath;
            Id_t m_taskCollectionId;
        };
    } // namespace topology_api
} // namespace dds
#endif /* defined(__DDS__TopoTask__) */