gz/sim/components/Factory.hh

Go to the documentation of this file.

/*
 * Copyright (C) 2019 Open Source Robotics Foundation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
*/
#ifndef GZ_GAZEBO_COMPONENTS_FACTORY_HH_
#define GZ_GAZEBO_COMPONENTS_FACTORY_HH_
 
#include <cstdint>
#include <cstring>
#include <map>
#include <memory>
#include <string>
#include <vector>
 
#include <gz/common/SingletonT.hh>
#include <gz/common/Util.hh>
#include <gz/sim/components/Component.hh>
#include <gz/sim/detail/ComponentStorageBase.hh>
#include <gz/sim/config.hh>
#include <gz/sim/Export.hh>
#include <gz/sim/Types.hh>
 
namespace ignition
{
namespace gazebo
{
// Inline bracket to help doxygen filtering.
inline namespace IGNITION_GAZEBO_VERSION_NAMESPACE {
namespace components
{
  class IGNITION_GAZEBO_VISIBLE ComponentDescriptorBase
  {
    public: virtual ~ComponentDescriptorBase() = default;
 
    public: virtual std::unique_ptr<BaseComponent> Create() const = 0;
  };
 
  template <typename ComponentTypeT>
  class IGNITION_GAZEBO_VISIBLE ComponentDescriptor
    : public ComponentDescriptorBase
  {
    public: std::unique_ptr<BaseComponent> Create() const override
    {
      return std::make_unique<ComponentTypeT>();
    }
  };
 
  class IGNITION_GAZEBO_VISIBLE StorageDescriptorBase
  {
    public: virtual ~StorageDescriptorBase() = default;
 
    public: virtual std::unique_ptr<ComponentStorageBase> Create() const  = 0;
  };
 
  template <typename ComponentTypeT>
  class IGNITION_GAZEBO_VISIBLE StorageDescriptor
    : public StorageDescriptorBase
  {
    public: std::unique_ptr<ComponentStorageBase> Create() const override
    {
      return std::make_unique<ComponentStorage<ComponentTypeT>>();
    }
  };
 
  class IGNITION_GAZEBO_VISIBLE Factory
      : public gz::common::SingletonT<Factory>
  {
    public: template<typename ComponentTypeT>
    void Register(const std::string &_type, ComponentDescriptorBase *_compDesc,
      StorageDescriptorBase *_storageDesc)
    {
      // Every time a plugin which uses a component type is loaded, it attempts
      // to register it again, so we skip it.
      if (ComponentTypeT::typeId != 0)
      {
        return;
      }
 
      auto typeHash = gz::common::hash64(_type);
 
      // Initialize static member variable - we need to set these
      // static members for every shared lib that uses the component, but we
      // only add them to the maps below once.
      ComponentTypeT::typeId = typeHash;
      ComponentTypeT::typeName = _type;
 
      // Check if component has already been registered by another library
      auto runtimeName = typeid(ComponentTypeT).name();
      auto runtimeNameIt = this->runtimeNamesById.find(typeHash);
      if (runtimeNameIt != this->runtimeNamesById.end())
      {
        // Warn user if type was previously registered with a different name.
        // We're leaving the ID set in case this is a false difference across
        // libraries.
        if (runtimeNameIt->second != runtimeName)
        {
          std::cerr
            << "Registered components of different types with same name: type ["
            << runtimeNameIt->second << "] and type [" << runtimeName
            << "] with name [" << _type << "]. Second type will not work."
            << std::endl;
        }
        return;
      }
 
      // This happens at static initialization time, so we can't use common
      // console
      std::string debugEnv;
      gz::common::env("IGN_DEBUG_COMPONENT_FACTORY", debugEnv);
      if (debugEnv == "true")
      {
        std::cout << "Registering [" << ComponentTypeT::typeName << "]"
                  << std::endl;
      }
 
      // Keep track of all types
      this->compsById[ComponentTypeT::typeId] = _compDesc;
      this->storagesById[ComponentTypeT::typeId] = _storageDesc;
      namesById[ComponentTypeT::typeId] = ComponentTypeT::typeName;
      runtimeNamesById[ComponentTypeT::typeId] = runtimeName;
    }
 
    public: template<typename ComponentTypeT>
    void Unregister()
    {
      this->Unregister(ComponentTypeT::typeId);
 
      ComponentTypeT::typeId = 0;
    }
 
    public: void Unregister(ComponentTypeId _typeId)
    {
      // Not registered
      if (_typeId == 0)
      {
        return;
      }
 
      {
        auto it = this->compsById.find(_typeId);
        if (it != this->compsById.end())
        {
          delete it->second;
          this->compsById.erase(it);
        }
      }
 
      {
        auto it = this->storagesById.find(_typeId);
        if (it != this->storagesById.end())
        {
          delete it->second;
          this->storagesById.erase(it);
        }
      }
 
      {
        auto it = namesById.find(_typeId);
        if (it != namesById.end())
        {
          namesById.erase(it);
        }
      }
 
      {
        auto it = runtimeNamesById.find(_typeId);
        if (it != runtimeNamesById.end())
        {
          runtimeNamesById.erase(it);
        }
      }
    }
 
    public: template<typename ComponentTypeT>
    std::unique_ptr<ComponentTypeT> New()
    {
      return std::unique_ptr<ComponentTypeT>(static_cast<ComponentTypeT *>(
            this->New(ComponentTypeT::typeId).release()));
    }
 
    public: std::unique_ptr<components::BaseComponent> New(
        const ComponentTypeId &_type)
    {
      // Create a new component if a FactoryFn has been assigned to this type.
      std::unique_ptr<components::BaseComponent> comp;
      auto it = this->compsById.find(_type);
      if (it != this->compsById.end() && nullptr != it->second)
        comp = it->second->Create();
 
      return comp;
    }
 
    public: std::unique_ptr<ComponentStorageBase> NewStorage(
        const ComponentTypeId &_typeId)
    {
      std::unique_ptr<ComponentStorageBase> storage;
      auto it = this->storagesById.find(_typeId);
      if (it != this->storagesById.end() && nullptr != it->second)
        storage = it->second->Create();
 
      return storage;
    }
 
    public: std::vector<ComponentTypeId> TypeIds() const
    {
      std::vector<ComponentTypeId> types;
 
      // Return the list of all known component types.
      for (const auto &comp : this->compsById)
        types.push_back(comp.first);
 
      return types;
    }
 
    public: bool HasType(ComponentTypeId _typeId)
    {
      return this->compsById.find(_typeId) != this->compsById.end();
    }
 
    public: std::string Name(ComponentTypeId _typeId) const
    {
      if (this->namesById.find(_typeId) != this->namesById.end())
        return namesById.at(_typeId);
 
      return "";
    }
 
    private: std::map<ComponentTypeId, ComponentDescriptorBase *> compsById;
 
    private: std::map<ComponentTypeId, StorageDescriptorBase *> storagesById;
 
    public: inline static std::map<ComponentTypeId, std::string> namesById;
 
    public: inline static std::map<ComponentTypeId, std::string>
        runtimeNamesById;
  };
 
  #define IGN_GAZEBO_REGISTER_COMPONENT(_compType, _classname) \
  class IGNITION_GAZEBO_VISIBLE IgnGazeboComponents##_classname \
  { \
    public: IgnGazeboComponents##_classname() \
    { \
      if (_classname::typeId != 0) \
        return; \
      using namespace ignition;\
      using Desc = gz::sim::components::ComponentDescriptor<_classname>; \
      using StorageDesc = gz::sim::components::StorageDescriptor<_classname>; \
      gz::sim::components::Factory::Instance()->Register<_classname>(\
        _compType, new Desc(), new StorageDesc());\
    } \
  }; \
  static IgnGazeboComponents##_classname\
    IgnitionGazeboComponentsInitializer##_classname;
}
}
}
}
 
#endif