Entity.hh

Go to the documentation of this file.

/*
 * Copyright (C) 2017 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_PHYSICS_ENTITY_HH_
#define GZ_PHYSICS_ENTITY_HH_
 
#include <optional>
#include <limits>
#include <memory>
 
#include <gz/physics/Export.hh>
#include <gz/physics/detail/Identity.hh>
 
namespace gz
{
  namespace physics
  {
    // Forward declaration
    namespace detail { template <typename, typename> struct DeterminePlugin; }
    template <typename> struct RequestFeatures;
 
    const std::size_t INVALID_ENTITY_ID =
        std::numeric_limits<std::size_t>::max();
 
    template <typename EntityT>
    class EntityPtr
    {
      public: EntityPtr() = default;
      public: EntityPtr(EntityPtr&&) = default;
      public: EntityPtr &operator=(EntityPtr&&) = default;
      public: ~EntityPtr() = default;
      // Special handling for copy construction and copy assignment
      public: EntityPtr(const EntityPtr&);
      public: EntityPtr &operator=(const EntityPtr&);
 
      public: EntityPtr(std::nullptr_t);
 
      public: EntityPtr(std::nullopt_t);
 
      public: EntityPtr &operator=(std::nullptr_t);
 
      public: EntityPtr &operator=(std::nullopt_t);
 
      public: template <typename Pimpl>
      EntityPtr(const std::shared_ptr<Pimpl> &_pimpl,
                const Identity &_identity);
 
      public: template <typename OtherEntityT>
      EntityPtr(const EntityPtr<OtherEntityT> &_other);
 
      public: template <typename OtherEntityT>
      EntityPtr &operator=(const EntityPtr<OtherEntityT> &_other);
 
      public: EntityT * operator->() const;
 
      public: EntityT & operator*() const;
 
      public: bool Valid() const;
 
      public: operator bool() const;
 
      public: std::size_t Hash() const;
 
      public: template <typename OtherEntityT>
      bool operator ==(const EntityPtr<OtherEntityT> &_other) const;
 
      public: template <typename OtherEntityT>
      bool operator <(const EntityPtr<OtherEntityT> &_other) const;
 
      public: template <typename OtherEntityT>
      bool operator >(const EntityPtr<OtherEntityT> &_other) const;
 
      public: template <typename OtherEntityT>
      bool operator !=(const EntityPtr<OtherEntityT> &_other) const;
 
      public: template <typename OtherEntityT>
      bool operator <=(const EntityPtr<OtherEntityT> &_other) const;
 
      public: template <typename OtherEntityT>
      bool operator >=(const EntityPtr<OtherEntityT> &_other) const;
 
      private: mutable std::optional<std::remove_const_t<EntityT>> entity;
 
 
      // Declare these friendships so we can cast between different Entity types
      template <typename> friend class EntityPtr;
      template <typename> friend struct RequestFeatures;
    };
 
    template <typename PolicyT, typename FeaturesT>
    class Entity
    {
      public: using Policy = PolicyT;
      public: using Features = FeaturesT;
      public: using Pimpl =
          typename detail::DeterminePlugin<Policy, Features>::type;
 
      public: const Identity &FullIdentity() const;
 
      public: std::size_t EntityID() const;
 
      public: const std::shared_ptr<void> &EntityReference() const;
 
      // Notes for developers:
      // - We provide a default constructor for this class so that the feature
      // entity classes (which get virtually inherited) do not each need to
      // call on the constructor of Entity. That would make it difficult
      // to implement and maintain all the constructors of the different object
      // feature classes.
      // - Since all the features are virtually inherited, only the "final"
      // inheriting class constructor needs to actually call this constructor.
      // - The default argument for the identity will have an INVALID_ENTITY_ID
      // value (which is the result of default-constructing Identity). If the
      // Identity of an Entity is invalid, that implies that there is a bug in
      // the construction of that Entity.
      protected: Entity(
          const std::shared_ptr<Pimpl> &_pimpl = nullptr,
          const Identity &_identity = Identity());
 
      protected: Entity(
          std::shared_ptr<Pimpl> &&_pimpl,
          const Identity &_identity);
 
      protected: template <typename FeatureT>
      typename FeatureT::template Implementation<PolicyT> *Interface();
 
      protected: template <typename FeatureT>
      const typename FeatureT::template Implementation<PolicyT> *Interface()
          const;
 
      protected: std::shared_ptr<Pimpl> pimpl;
 
      protected: Identity identity;
 
      public: virtual ~Entity() = default;
 
      // Allow EntityPtr to cast between EntityTypes
      template <typename> friend class EntityPtr;
      template <typename> friend struct RequestFeatures;
    };
  }
}
 
#include <gz/physics/detail/Entity.hh>
 
#endif