hyper_graph_action.h

Go to the documentation of this file.

// g2o - General Graph Optimization
// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, W. Burgard
// 
// g2o is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published
// by the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// g2o is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Lesser General Public License for more details.
// 
// You should have received a copy of the GNU Lesser General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

#ifndef HYPER_GRAPH_ACTION_H
#define HYPER_GRAPH_ACTION_H

#include "hyper_graph.h"

#include <typeinfo>
#include <iosfwd>
#include <set>
#include <string>

namespace g2o {

  class HyperGraphAction {
    public:
      class Parameters {
        public:
          virtual ~Parameters();
      };

      class ParametersIteration : public Parameters {
        public:
          explicit ParametersIteration(int iter);
          int iteration;
      };

      virtual ~HyperGraphAction();

      virtual HyperGraphAction* operator()(const HyperGraph* graph, Parameters* parameters = 0);
  };

  class HyperGraphElementAction{
    public:
      struct Parameters{
        virtual ~Parameters();
      };
      typedef std::map<std::string, HyperGraphElementAction*> ActionMap;
      HyperGraphElementAction(const std::string& typeName_="");

      virtual HyperGraphElementAction* operator()(HyperGraph::HyperGraphElement* element, Parameters* parameters);

      virtual HyperGraphElementAction* operator()(const HyperGraph::HyperGraphElement* element, Parameters* parameters);

      virtual ~HyperGraphElementAction();

      const std::string& typeName() const { return _typeName;}

      const std::string& name() const{ return _name;}
    protected:
      std::string _typeName;
      std::string _name;
  };

  class HyperGraphElementActionCollection: public HyperGraphElementAction{
    public:
      HyperGraphElementActionCollection(const std::string& name_);
      virtual ~HyperGraphElementActionCollection();
      virtual HyperGraphElementAction* operator()(HyperGraph::HyperGraphElement* element, Parameters* parameters);
      virtual HyperGraphElementAction* operator()(const HyperGraph::HyperGraphElement* element, Parameters* parameters);
      ActionMap& actionMap() {return _actionMap;}
      bool registerAction(HyperGraphElementAction* action);
    protected:
      ActionMap _actionMap;
  };

  class HyperGraphActionLibrary{
    public:
      static HyperGraphActionLibrary* instance();
      static void destroy();

      // returns a pointer to a collection indexed by name
      HyperGraphElementAction* actionByName(const std::string& name);
      // registers a basic action in the pool. If necessary a container is created
      bool registerAction(HyperGraphElementAction* action);
      inline HyperGraphElementAction::ActionMap& actionMap() {return _actionMap;}
    protected:
      HyperGraphActionLibrary();
      ~HyperGraphActionLibrary();
      HyperGraphElementAction::ActionMap _actionMap;
    private:
      static HyperGraphActionLibrary* actionLibInstance;
  };

  void applyAction(HyperGraph* graph, HyperGraphElementAction* action, HyperGraphElementAction::Parameters* parameters=0, const std::string& typeName="");

  class WriteGnuplotAction: public HyperGraphElementAction{
    public:
      struct Parameters: public HyperGraphElementAction::Parameters{
        std::ostream* os;
      };
      WriteGnuplotAction(const std::string& typeName_);
  };

  class DrawAction : public HyperGraphElementAction{
    public:
      DrawAction(const std::string& typeName_);
  };
  
};

#endif