opspace/include/opspace/Factory.hpp

Go to the documentation of this file.

/*
 * Copyright (C) 2011 The Board of Trustees of The Leland Stanford Junior University. All rights reserved.
 *
 * Author: Roland Philippsen
 *         http://cs.stanford.edu/group/manips/
 *
 * This program 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.
 *
 * This program 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 OPSPACE_FACTORY_HPP
#define OPSPACE_FACTORY_HPP

#include <jspace/Status.hpp>
#include <boost/shared_ptr.hpp>
#include <vector>
#include <map>


namespace opspace {
  
  using jspace::Status;
  
  class Task;
  class Skill;
  class ReflectionRegistry;
  
  
  template<typename base_type>
  struct ShopAPI {
    virtual ~ShopAPI() {}
    virtual base_type * create(std::string const & name) = 0;
  };
  
  template<typename task_subtype>
  struct TaskShop : public ShopAPI<Task> {
    virtual Task * create(std::string const & name) { return new task_subtype(name); }
  };
  
  template<typename skill_subtype>
  struct SkillShop : public ShopAPI<Skill> {
    virtual Skill * create(std::string const & name) { return new skill_subtype(name); }
  };
  
  
  class Factory
  {
  public:
    typedef std::vector<boost::shared_ptr<Task> > task_table_t;
    typedef std::vector<boost::shared_ptr<Skill> > skill_table_t;
    
    static void setDebugStream(std::ostream * dbg);
    
    template<typename task_subtype>
    static void addTaskType(std::string const & type) {
      task_shop__[type].reset(new TaskShop<task_subtype>());
    }
    
    template<typename skill_subtype>
    static void addSkillType(std::string const & type) {
      skill_shop__[type].reset(new SkillShop<skill_subtype>());
    }
    
    static Task * createTask(std::string const & type, std::string const & name);
    
    static Skill * createSkill(std::string const & type, std::string const & name);
    
    Status parseString(std::string const & yaml_string);
    
    Status parseFile(std::string const & yaml_filename);
    
    Status parseStream(std::istream & yaml_istream);
    
    task_table_t const & getTaskTable() const;
    
    skill_table_t const & getSkillTable() const;
    
    boost::shared_ptr<Task> findTask(std::string const & name) const;
    boost::shared_ptr<Skill> findSkill(std::string const & name) const;
    
    ReflectionRegistry * createRegistry();
    
    void dump(std::ostream & os,
        std::string const & title,
        std::string const & prefix) const;
    
  protected:
    typedef std::map<std::string, boost::shared_ptr<ShopAPI<Task> > > task_shop_t;
    typedef std::map<std::string, boost::shared_ptr<ShopAPI<Skill> > > skill_shop_t;

    static std::ostream * dbg__;
    static task_shop_t task_shop__;
    static skill_shop_t skill_shop__;
    
    task_table_t task_table_;
    skill_table_t skill_table_;
  };
  
}

#endif // OPSPACE_FACTORY_HPP

---