TopoCore.h

Go to the documentation of this file.

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

#ifndef __DDS__Topology__
#define __DDS__Topology__

// DDS Topo
#include "TopoCollection.h"
#include "TopoDef.h"
#include "TopoElement.h"
#include "TopoGroup.h"
#include "TopoTask.h"
// STD
#include <map>
#include <ostream>
#include <set>
#include <string>

namespace dds
{
    namespace topology_api
    {
        class CTopoCore
        {
          public:
            using IdSet_t = std::set<Id_t>;

            using IdPathToIdMap_t = std::map<std::string, Id_t>;

            using Ptr_t = std::shared_ptr<CTopoCore>;

          public:
            CTopoCore();

            virtual ~CTopoCore();

            void init(const std::string& _fileName);

            void init(const std::string& _fileName, const std::string& _schemaFileName);

            void init(std::istream& _stream);

            void init(std::istream& _stream, const std::string& _schemaFileName);

            void getDifference(const CTopoCore& _topology,
                               IdSet_t& _removedTasks,
                               IdSet_t& _removedCollections,
                               IdSet_t& _addedTasks,
                               IdSet_t& _addedCollections);

            void setXMLValidationDisabled(bool _val);

            std::string getName() const;
            std::string getFilepath() const;
            uint32_t getHash() const;
            CTopoGroup::Ptr_t getMainGroup() const;
            const STopoRuntimeTask& getRuntimeTaskById(Id_t _id) const;
            const STopoRuntimeCollection& getRuntimeCollectionById(Id_t _id) const;
            const STopoRuntimeTask& getRuntimeTaskByIdPath(const std::string& _idPath) const;
            const STopoRuntimeCollection& getRuntimeCollectionByIdPath(const std::string& _idPath) const;
            const STopoRuntimeTask& getRuntimeTask(const std::string& _path) const;
            const STopoRuntimeCollection& getRuntimeCollection(const std::string& _path) const;
            std::pair<size_t, size_t> getRequiredNofAgents(size_t _defaultNumSlots) const;
            size_t getTotalNofTasks() const;

            STopoRuntimeTask::FilterIteratorPair_t getRuntimeTaskIterator(
                const STopoRuntimeTask::Map_t& _map, STopoRuntimeTask::Condition_t _condition) const;
            STopoRuntimeTask::FilterIteratorPair_t getRuntimeTaskIterator(
                STopoRuntimeTask::Condition_t _condition = nullptr) const;
            STopoRuntimeCollection::FilterIteratorPair_t getRuntimeCollectionIterator(
                STopoRuntimeCollection::Condition_t _condition = nullptr) const;
            STopoRuntimeTask::FilterIteratorPair_t getRuntimeTaskIteratorForPropertyName(
                const std::string& _propertyName, Id_t _taskId) const;
            STopoRuntimeTask::FilterIteratorPair_t getRuntimeTaskIteratorMatchingPath(
                const std::string& _pathPattern) const;
            STopoRuntimeCollection::FilterIteratorPair_t getRuntimeCollectionIteratorMatchingPath(
                const std::string& _pathPattern) const;

            const STopoRuntimeTask::Map_t& getIdToRuntimeTaskMap() const;
            const STopoRuntimeCollection::Map_t& getIdToRuntimeCollectionMap() const;
            const IdPathToIdMap_t& getTaskIdPathToIdMap() const;
            const IdPathToIdMap_t& getCollectionIdPathToIdMap() const;

            std::string stringOfTasks(const IdSet_t& _ids) const;
            std::string stringOfCollections(const IdSet_t& _ids) const;

            virtual std::string toString() const;

            friend std::ostream& operator<<(std::ostream& _strm, const CTopoCore& _topology);

          private:
            void FillTopoIndexToTopoElementMap(const CTopoElement::Ptr_t& _element);
            void FillIdToTopoElementMap(const CTopoElement::Ptr_t& _element);
            uint32_t CalculateHash(std::istream& _stream);
            Id_t calculateId(const std::string& _idPath, const std::string& _hashString);

            CTopoGroup::Ptr_t m_main{ nullptr }; 

            STopoRuntimeTask::Map_t m_idToRuntimeTaskMap; 
            STopoRuntimeCollection::Map_t
                m_idToRuntimeCollectionMap;      
            IdPathToIdMap_t m_taskIdPathToIdMap; 
            IdPathToIdMap_t m_collectionIdPathToIdMap; 
            std::map<std::string, size_t> m_counterMap;
            std::string m_currentCollectionIdPath;
            Id_t m_currentCollectionId{ 0 };

            bool m_bXMLValidationDisabled{ false }; 
            std::string m_name;                     
            uint32_t m_hash{ 0 };                   
            std::string m_filepath;                 
        };
    } // namespace topology_api
} // namespace dds
#endif /* defined(__DDS__Topology__) */