TopologyManager.hpp

Go to the documentation of this file.

#pragma once

#include <boost/shared_ptr.hpp>
#include "map"

#include "ObjectRelation.hpp"
#include "utility/LogHelper.hpp"
#include "utility/DocumentationHelper.hpp"

#include "ConnectivityChecker.hpp"
#include "Topology.hpp"

#include "Evaluator.hpp"
#include "TreeValidator.hpp"
#include "TopologyGenerator.hpp"
#include "ObjectRelation.hpp"
#include "../combinatorial_optimization/NeighbourhoodFunction.hpp"

namespace ISM {

class TopologyManager : public NeighbourhoodFunction<TopologyPtr>
{
        public:
                TopologyManager(EvaluatorPtr evaluator, TreeValidatorPtr treeValidator,
                                TopologyGeneratorPtr topologyGenerator, DocumentationHelperPtr documentationHelper)
                        : mEvaluator(evaluator)
                        , mTreeValidator(treeValidator)
                        , mTopologyGenerator(topologyGenerator)
                        , mDocumentationHelper(documentationHelper)
                {}

                TopologyPtr getNextNeighbour();
                bool hasNextNeighbour();
                void setReferenceInstance(TopologyPtr instance);

                std::vector<TopologyPtr> prepareStartTopologies(std::vector<TopologyPtr>& startTopologies);
                void setUp(const std::string & patternName);

                std::vector<std::vector<std::pair<TopologyPtr, unsigned int>>> getHistory();

                TopologyPtr getFullyMeshedTopology(bool storeFullyMeshedISM = false);
                std::vector<TopologyPtr> getStarTopologies();

                void addStartTopologiesToHistory(std::vector<TopologyPtr> startTopologies);
                TreePtr evaluateTopology(TopologyPtr& topology, const std::string filename = "");

                TopologyPtr getRandomTopology();

        private:
                EvaluatorPtr mEvaluator;
                TreeValidatorPtr mTreeValidator;
                TopologyGeneratorPtr mTopologyGenerator;
                DocumentationHelperPtr mDocumentationHelper;

                bool mHasNextInstance;

                std::map<std::string, std::map<std::string, TopologyPtr>> mPatternToTopologyIdToTopolgy;
                std::string mCurrentPatternName;

                std::vector<TopologyPtr> mNeighbourTopologies;
                unsigned mNeighbourIndex;

                std::map<std::string, unsigned int> mPatternToTopologyIndexCounter;

                int mHistoryIndex = 0;
                std::vector<std::vector<std::pair<TopologyPtr, unsigned int>>> mHistory;
                unsigned int mNumTopology = 0;

                void prepareTopology(TopologyPtr& topology);

                void calculateNeighbours(TopologyPtr topology);

                void markSelectedTopology(TopologyPtr selectedTopology);

                //Console output
                void logAlreadyAnalysed(TopologyPtr topology);
                void logSelectedTopology(TopologyPtr selectedTopology);

}; typedef boost::shared_ptr<TopologyManager> TopologyManagerPtr;

}