ComponentLoader.hpp

/***************************************************************************
  tag: Peter Soetens  Thu Jul 3 15:35:28 CEST 2008  ComponentLoader.hpp

                        ComponentLoader.hpp -  description
                           -------------------
    begin                : Thu July 03 2008
    copyright            : (C) 2008 Peter Soetens
    email                : peter.soetens@fmtc.be

 ***************************************************************************
 *   This library 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 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library 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 library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place,                                    *
 *   Suite 330, Boston, MA  02111-1307  USA                                *
 *                                                                         *
 ***************************************************************************/


#ifndef OCL_COMPONENT_LOADER_HPP
#define OCL_COMPONENT_LOADER_HPP

#include <string>
#include <map>
#include <vector>
#include <ocl/OCL.hpp>

namespace RTT {
  class TaskContext;
}

namespace OCL
{
    typedef RTT::TaskContext* (*ComponentLoaderSignature)(std::string instance_name);
    typedef std::map<std::string,ComponentLoaderSignature> FactoryMap;

    class ComponentFactories
    {
        OCL_HIDE static FactoryMap* Factories;
    public:
        OCL_HIDE static FactoryMap& Instance() {
      if ( Factories == 0)
        Factories = new FactoryMap();
      return *Factories;
    }
    };

    template<class C>
    class ComponentLoader
    {
    public:
        ComponentLoader(std::string type_name)
        {
            ComponentFactories::Instance()[type_name] = &ComponentLoader<C>::createComponent;
        }

        static RTT::TaskContext* createComponent(std::string instance_name)
        {
            return new C(instance_name);
        }
    };
}

// Helper macros.
#define ORO_CONCAT_LINE2(x,y) x##y
#define ORO_CONCAT_LINE1(x,y) ORO_CONCAT_LINE2(x,y)
#define ORO_CONCAT_LINE(x) ORO_CONCAT_LINE1(x,__LINE__)

#define ORO_LIST_COMPONENT_TYPE_str(s) ORO_LIST_COMPONENT_TYPE__str(s)
#define ORO_LIST_COMPONENT_TYPE__str(s) #s

// ORO_CREATE_COMPONENT and ORO_CREATE_COMPONENT_TYPE are only used in shared libraries.
#if defined(OCL_DLL_EXPORT) || defined(RTT_COMPONENT)

#define ORO_CREATE_COMPONENT(CNAME) \
extern "C" { \
  OCL_EXPORT RTT::TaskContext* createComponent(std::string instance_name); \
  RTT::TaskContext* createComponent(std::string instance_name) \
  { \
    return new CNAME(instance_name); \
  } \
  OCL_EXPORT std::string getComponentType(); \
  std::string getComponentType() \
  { \
    return ORO_LIST_COMPONENT_TYPE_str(CNAME); \
  } \
} /* extern "C" */

#define ORO_CREATE_COMPONENT_TYPE() \
OCL::FactoryMap* OCL::ComponentFactories::Factories = 0;    \
extern "C" { \
  OCL_EXPORT RTT::TaskContext* createComponentType(std::string instance_name, std::string type_name) \
  { \
    if( OCL::ComponentFactories::Instance().count(type_name) ) \
      return OCL::ComponentFactories::Instance()[type_name](instance_name); \
    return 0; \
  } \
  OCL_EXPORT std::vector<std::string> getComponentTypeNames() \
  { \
    std::vector<std::string> ret; \
    OCL::FactoryMap::iterator it; \
    for(it = OCL::ComponentFactories::Instance().begin(); it != OCL::ComponentFactories::Instance().end(); ++it) { \
        ret.push_back(it->first); \
    } \
    return ret; \
  } \
  OCL_EXPORT OCL::FactoryMap* getComponentFactoryMap() { return &OCL::ComponentFactories::Instance(); } \
} /* extern "C" */

#else

#if !defined(OCL_STATIC) && !defined(RTT_STATIC)
#warning "You're compiling with static library settings. The resulting component library \
 will not be loadable at runtime with the deployer.\
 Compile with -DRTT_COMPONENT to enable dynamic loadable components, \
 or use -DRTT_STATIC to suppress this warning."
#endif

// Static OCL library:
// Identical to ORO_LIST_COMPONENT_TYPE:
#define ORO_CREATE_COMPONENT(CLASS_NAME) namespace { namespace ORO_CONCAT_LINE(LOADER_) { OCL::ComponentLoader<CLASS_NAME> m_cloader(ORO_LIST_COMPONENT_TYPE_str(CLASS_NAME)); } }
#define ORO_CREATE_COMPONENT_TYPE() __attribute__((weak)) OCL::FactoryMap* OCL::ComponentFactories::Factories = 0;

#endif

#define ORO_LIST_COMPONENT_TYPE(CLASS_NAME) namespace { namespace ORO_CONCAT_LINE(LOADER_) { OCL::ComponentLoader<CLASS_NAME> m_cloader(ORO_LIST_COMPONENT_TYPE_str(CLASS_NAME)); } }


#endif

//#undef ORO_CLOADER_CONCAT

---