Algorithm.h

Go to the documentation of this file.

// -*- C++ -*-

#ifndef __ALGORITHM_H__
#define __ALGORITHM_H__

#include <map>
#include <vector>
#include <iostream>

#include "Configuration.h"
#include "Roadmap.h"

namespace PathEngine {
    class PathPlanner;

    class Algorithm {
    protected:
        Configuration start_;

        Configuration goal_;

        std::map<std::string, std::string> properties_;

        bool isRunning_;

        std::vector<Configuration> path_;

        PathPlanner* planner_;

        RoadmapPtr roadmap_;

        bool verbose_;

        bool ignoreCollisionAtStart_;

        bool ignoreCollisionAtGoal_;

    public:
        Algorithm(PathPlanner* planner);

        virtual ~Algorithm();

        void setProperty(const std::string& key, const std::string& value); 

        void setProperties(const std::map<std::string, std::string> &properties);

        void getProperties(std::vector<std::string> &names,
                           std::vector<std::string> &values);

        void setStartConfiguration(const Configuration &pos) {start_ = pos;}

        void setGoalConfiguration(const Configuration &pos) {goal_ = pos;}

        bool tryDirectConnection();

        virtual bool calcPath() = 0;

        void stopPlanning(){isRunning_ = false;}

        const std::vector<Configuration>& getPath() {return path_;}

        RoadmapPtr getRoadmap() { return roadmap_; } 

        bool preparePlanning();

        void verbose(bool b) { verbose_ = b; }

        void ignoreCollisionAtGoal(bool b) { ignoreCollisionAtGoal_ = b; }

        void ignoreCollisionAtStart(bool b) { ignoreCollisionAtStart_ = b; }
    };

    typedef Algorithm* (*AlgorithmNewFunc)(PathPlanner* planner);

    typedef void (*AlgorithmDeleteFunc)(Algorithm* algorithm);

    template <class _New>
    Algorithm* AlgorithmCreate(PathPlanner* planner) {
        return new _New(planner);
    }

    template <class _Delete>
    void AlgorithmDelete(Algorithm* algorithm) {
        delete algorithm;
    }
};

#endif // __ALGORITHM_H__