TMetricMapTypesRegistry.h

Go to the documentation of this file.

/* +------------------------------------------------------------------------+
   |                     Mobile Robot Programming Toolkit (MRPT)            |
   |                          http://www.mrpt.org/                          |
   |                                                                        |
   | Copyright (c) 2005-2018, Individual contributors, see AUTHORS file     |
   | See: http://www.mrpt.org/Authors - All rights reserved.                |
   | Released under BSD License. See details in http://www.mrpt.org/License |
   +------------------------------------------------------------------------+ */
 
#pragma once
 
#include <mrpt/obs/obs_frwds.h>
#include <map>
#include <string>
#include <functional>
 
namespace mrpt
{
namespace maps
{
struct TMetricMapInitializer;
namespace internal
{
using MapDefCtorFunctor =
        std::function<mrpt::maps::TMetricMapInitializer*(void)>;
using MapCtorFromDefFunctor = std::function<mrpt::maps::CMetricMap*(
        const mrpt::maps::TMetricMapInitializer&)>;
 
/** Class factory & registry for map classes. Used from
 * mrpt::maps::TMetricMapInitializer */
struct TMetricMapTypesRegistry
{
   public:
        static TMetricMapTypesRegistry& Instance();
        /** Return the index of the class in the list (not important, just used as a
         * trick to initialize static members) */
        size_t doRegister(
                const std::string& name, MapDefCtorFunctor func1,
                MapCtorFromDefFunctor func2);
        /** Return nullptr if not found */
        mrpt::maps::TMetricMapInitializer* factoryMapDefinition(
                const std::string& className) const;
        /** Return nullptr if not found */
        mrpt::maps::CMetricMap* factoryMapObjectFromDefinition(
                const mrpt::maps::TMetricMapInitializer& mi) const;
        using TListRegisteredMaps = std::map<
                std::string, std::pair<MapDefCtorFunctor, MapCtorFromDefFunctor>>;
        const TListRegisteredMaps& getAllRegistered() const { return m_registry; }
 
   private:
        TMetricMapTypesRegistry() {}  // Access thru singleton in Instance()
        TListRegisteredMaps m_registry;
};
 
/** Add a MAP_DEFINITION_START() ... MAP_DEFINITION_END() block inside the
 * declaration of each metric map */
#define MAP_DEFINITION_START(_CLASS_NAME_)                               \
   public:                                                               \
        /** @name Map Definition Interface stuff (see                        \
         * mrpt::maps::TMetricMapInitializer) @{ */                          \
        struct TMapDefinitionBase : public mrpt::maps::TMetricMapInitializer \
        {                                                                    \
                TMapDefinitionBase()                                             \
                        : TMetricMapInitializer(CLASS_ID(_CLASS_NAME_)) {}           \
        };                                                                   \
        struct TMapDefinition : public TMapDefinitionBase                    \
        {
#define MAP_DEFINITION_END(_CLASS_NAME_)                                     \
        TMapDefinition();                                                        \
                                                                             \
   protected:                                                                \
        void loadFromConfigFile_map_specific(                                    \
                const mrpt::config::CConfigFileBase& source,                         \
                const std::string& sectionNamePrefix) override;                      \
        void dumpToTextStream_map_specific(std::ostream& out) const override;    \
        }                                                                        \
        ;                                                                        \
        /** Returns default map definition initializer. See                      \
         * mrpt::maps::TMetricMapInitializer */                                  \
        static mrpt::maps::TMetricMapInitializer* MapDefinition();               \
        /** Constructor from a map definition structure: initializes the map and \
         * its parameters accordingly */                                         \
        static _CLASS_NAME_* CreateFromMapDefinition(                            \
                const mrpt::maps::TMetricMapInitializer& def);                       \
        static mrpt::maps::CMetricMap* internal_CreateFromMapDefinition(         \
                const mrpt::maps::TMetricMapInitializer& def);                       \
        /** ID used to initialize class registration (just ignore it) */         \
        static const size_t m_private_map_register_id;                           \
/** @} */
 
/** Registers one map class into TMetricMapInitializer factory.
 * One or several alternative class names can be provided, separated with
 * whitespaces or commas */
#define MAP_DEFINITION_REGISTER(_CLASSNAME_STRINGS, _CLASSNAME_WITH_NS)       \
        const size_t _CLASSNAME_WITH_NS::m_private_map_register_id =              \
                mrpt::maps::internal::TMetricMapTypesRegistry::Instance().doRegister( \
                        _CLASSNAME_STRINGS, &_CLASSNAME_WITH_NS::MapDefinition,           \
                        &_CLASSNAME_WITH_NS::internal_CreateFromMapDefinition);           \
        mrpt::maps::TMetricMapInitializer* _CLASSNAME_WITH_NS::MapDefinition()    \
        {                                                                         \
                return new _CLASSNAME_WITH_NS::TMapDefinition;                        \
        }                                                                         \
        _CLASSNAME_WITH_NS* _CLASSNAME_WITH_NS::CreateFromMapDefinition(          \
                const mrpt::maps::TMetricMapInitializer& def)                         \
        {                                                                         \
                return dynamic_cast<_CLASSNAME_WITH_NS*>(                             \
                        _CLASSNAME_WITH_NS::internal_CreateFromMapDefinition(def));       \
        }
 
}  // namespace internal
}  // namespace maps
}  // namespace mrpt