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_SIM_COMPONENTS_FACTORY_HH_
#define GZ_SIM_COMPONENTS_FACTORY_HH_
 
#include <algorithm>
#include <cstdint>
#include <cstring>
#include <deque>
#include <map>
#include <memory>
#include <string>
#include <utility>
#include <vector>
 
#include <gz/common/SingletonT.hh>
#include <gz/common/Util.hh>
#include <gz/sim/components/Component.hh>
#include <gz/sim/config.hh>
#include <gz/sim/Export.hh>
#include <gz/sim/Types.hh>
#include <gz/utils/NeverDestroyed.hh>
 
namespace gz
{
namespace sim
{
// Inline bracket to help doxygen filtering.
inline namespace GZ_SIM_VERSION_NAMESPACE {
namespace components
{
  class ComponentDescriptorBase
  {
    public: virtual ~ComponentDescriptorBase() = default;
 
    public: virtual std::unique_ptr<BaseComponent> Create() const = 0;
 
    public: virtual std::unique_ptr<BaseComponent> Create(
                const components::BaseComponent *_data) const = 0;
  };
 
  template <typename ComponentTypeT>
  class ComponentDescriptor
    : public ComponentDescriptorBase
  {
    public: std::unique_ptr<BaseComponent> Create() const override
    {
      return std::make_unique<ComponentTypeT>();
    }
 
    public: virtual std::unique_ptr<BaseComponent> Create(
                const components::BaseComponent *_data) const override
    {
      ComponentTypeT comp(*static_cast<const ComponentTypeT *>(_data));
      return std::make_unique<ComponentTypeT>(comp);
    }
  };
 
  struct RegistrationObjectId
  {
    explicit RegistrationObjectId(void *_ptr)
        : id(reinterpret_cast<std::uintptr_t>(_ptr))
    {
    }
 
    explicit RegistrationObjectId(std::uintptr_t _ptrAddress)
        : id(_ptrAddress)
    {
    }
 
    bool operator==(const RegistrationObjectId &_other) const
    {
      return this->id == _other.id;
    }
 
    std::uintptr_t id;
  };
 
 
  class ComponentDescriptorQueue
  {
    public: bool GZ_SIM_HIDDEN Empty()
    {
      return this->queue.empty();
    }
 
    public: void GZ_SIM_HIDDEN Add(RegistrationObjectId _regObjId,
                     ComponentDescriptorBase *_comp)
    {
      this->queue.push_front({_regObjId, _comp});
    }
 
    public: void GZ_SIM_HIDDEN Remove(RegistrationObjectId  _regObjId)
    {
      auto compIt = std::find_if(this->queue.rbegin(), this->queue.rend(),
                                 [&](const auto &_item)
                                 { return _item.first == _regObjId; });
 
      if (compIt != this->queue.rend())
      {
        ComponentDescriptorBase *compDesc = compIt->second;
        this->queue.erase(std::prev(compIt.base()));
        delete compDesc;
      }
    }
 
    public: GZ_SIM_HIDDEN std::unique_ptr<BaseComponent> Create() const
    {
      if (!this->queue.empty())
      {
        return this->queue.front().second->Create();
      }
      return {};
    }
 
    public: GZ_SIM_HIDDEN std::unique_ptr<BaseComponent> Create(
        const components::BaseComponent *_data) const
    {
      if (!this->queue.empty())
      {
        return this->queue.front().second->Create(_data);
      }
      return {};
    }
 
    private: std::deque<std::pair<RegistrationObjectId,
                                  ComponentDescriptorBase *>> queue;
  };
 
  class Factory
  {
    public: Factory(Factory &) = delete;
    public: Factory(const Factory &) = delete;
    public: void operator=(const Factory &) = delete;
    public: void operator=(Factory &&) = delete;
 
    public: GZ_SIM_VISIBLE static Factory *Instance();
 
    public: template <typename ComponentTypeT>
    void Register(const char *_type, ComponentDescriptorBase *_compDesc,
                  RegistrationObjectId  _regObjId)
    {
      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("GZ_DEBUG_COMPONENT_FACTORY", debugEnv);
 
      if (debugEnv == "true")
      {
        std::cout << "Registering [" << ComponentTypeT::typeName << "]"
                  << std::endl;
      }
 
      // Keep track of all types
      this->compsById[ComponentTypeT::typeId].Add(_regObjId, _compDesc);
      namesById[ComponentTypeT::typeId] = ComponentTypeT::typeName;
      runtimeNamesById[ComponentTypeT::typeId] = runtimeName;
    }
 
    public: template<typename ComponentTypeT>
    void Unregister(RegistrationObjectId  _regObjId)
    {
      this->Unregister(ComponentTypeT::typeId, _regObjId);
    }
 
    public: void Unregister(ComponentTypeId _typeId,
                            RegistrationObjectId _regObjId)
    {
      auto it = this->compsById.find(_typeId);
      if (it != this->compsById.end())
      {
        it->second.Remove(_regObjId);
 
        if (it->second.Empty())
        {
          this->compsById.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())
      {
        comp = it->second.Create();
      }
      return comp;
    }
 
    public: std::unique_ptr<components::BaseComponent> New(
        const ComponentTypeId &_type, const components::BaseComponent *_data)
    {
      std::unique_ptr<components::BaseComponent> comp;
 
      if (nullptr == _data)
      {
        gzerr << "Requested to create a new component instance with null "
          << "data." << std::endl;
      }
      else if (_type != _data->TypeId())
      {
        gzerr << "The typeID of _type [" << _type << "] does not match the "
          << "typeID of _data [" << _data->TypeId() << "]." << std::endl;
      }
      else
      {
        auto it = this->compsById.find(_type);
        if (it != this->compsById.end())
        {
          comp = it->second.Create(_data);
        }
      }
 
      return comp;
    }
 
    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 "";
    }
 
    // Since the copy constructors are deleted, we need to explicitly declare a
    // default constructor.
    private: Factory() = default;
    friend gz::utils::NeverDestroyed<Factory>;
    private: std::map<ComponentTypeId, ComponentDescriptorQueue> compsById;
 
    public: std::map<ComponentTypeId, std::string> namesById;
 
    public: std::map<ComponentTypeId, std::string>
        runtimeNamesById;
  };
 
  #define GZ_SIM_REGISTER_COMPONENT(_compType, _classname) \
  class GzSimComponents##_classname \
  { \
    public: GzSimComponents##_classname() \
    { \
      using namespace gz;\
      using Desc = sim::components::ComponentDescriptor<_classname>; \
      sim::components::Factory::Instance()->Register<_classname>(\
        _compType, new Desc(), sim::components::RegistrationObjectId(this));\
    } \
    public: GzSimComponents##_classname( \
                const GzSimComponents##_classname&) = delete; \
    public: GzSimComponents##_classname( \
                GzSimComponents##_classname&) = delete; \
    public: ~GzSimComponents##_classname() \
    { \
      using namespace gz; \
      sim::components::Factory::Instance()->Unregister<_classname>( \
          sim::components::RegistrationObjectId(this)); \
    } \
  }; \
  static GzSimComponents##_classname\
    GzSimComponentsInitializer##_classname;
}
}
}
}
 
#endif