factory.h

Go to the documentation of this file.

 
#ifndef FACTORY_H
#define FACTORY_H
 
#include <argos3/core/utility/configuration/argos_exception.h>
#include <map>
#include <iostream>
#include <string>
#include <cstdlib>
 
namespace argos {
 
   template<typename TYPE>
   class CFactory {
 
   public:
      typedef TYPE* TCreator();
 
      struct STypeInfo {
         TCreator* Creator;
         std::string Author;
         std::string Version;
         std::string BriefDescription;
         std::string LongDescription;
         std::string Status;
      };
 
      typedef std::map<std::string, STypeInfo*> TTypeMap;
 
   public:
      static TTypeMap& GetTypeMap();
 
      static void Register(const std::string& str_label,
                           const std::string& str_author,
                           const std::string& str_version,
                           const std::string& str_brief_desc,
                           const std::string& str_long_desc,
                           const std::string& str_status,
                           TCreator* pc_creator);
      static TYPE* New(const std::string& str_label);
 
      static bool Exists(const std::string& str_label);
 
      static void Print(std::ostream& c_os);
 
      static void Destroy();
   };
 
/*
 * Include the actual template implementation
 */
#include <argos3/core/utility/plugins/factory_impl.h>
 
#define REGISTER_SYMBOL(BASECLASS,                                      \
                        CLASSNAME,                                      \
                        LABEL,                                          \
                        AUTHOR,                                         \
                        VERSION,                                        \
                        BRIEF_DESCRIPTION,                              \
                        LONG_DESCRIPTION,                               \
                        STATUS)                                         \
   namespace argos {                                                    \
      extern "C" {                                                      \
         BASECLASS* BASECLASS ## CLASSNAME ## Creator() {               \
            return new CLASSNAME;                                       \
         }                                                              \
      }                                                                 \
      class C ## BASECLASS ## CLASSNAME ## Proxy {                      \
      public:                                                           \
      C ## BASECLASS ## CLASSNAME ## Proxy() {                          \
         CFactory<BASECLASS>::                                          \
            Register(LABEL,                                             \
                     AUTHOR,                                            \
                     VERSION,                                           \
                     BRIEF_DESCRIPTION,                                 \
                     LONG_DESCRIPTION,                                  \
                     STATUS,                                            \
                     BASECLASS ## CLASSNAME ## Creator);                \
      }                                                                 \
      };                                                                \
      C ## BASECLASS ## CLASSNAME ## Proxy BASECLASS ## CLASSNAME ## _p; \
   }
 
}
 
#endif