EntityComponentManager.hh

Go to the documentation of this file.

/*
 * Copyright (C) 2018 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 IGNITION_GAZEBO_ENTITYCOMPONENTMANAGER_HH_
#define IGNITION_GAZEBO_ENTITYCOMPONENTMANAGER_HH_

#include <ignition/msgs/serialized.pb.h>
#include <ignition/msgs/serialized_map.pb.h>

#include <map>
#include <memory>
#include <set>
#include <string>
#include <typeinfo>
#include <type_traits>
#include <unordered_set>
#include <utility>
#include <vector>

#include <ignition/common/Console.hh>
#include <ignition/math/graph/Graph.hh>
#include "ignition/gazebo/Entity.hh"
#include "ignition/gazebo/Export.hh"
#include "ignition/gazebo/Types.hh"

#include "ignition/gazebo/components/Component.hh"
#include "ignition/gazebo/detail/View.hh"

namespace ignition
{
  namespace gazebo
  {
    // Inline bracket to help doxygen filtering.
    inline namespace IGNITION_GAZEBO_VERSION_NAMESPACE {
    // Forward declarations.
    class IGNITION_GAZEBO_HIDDEN EntityComponentManagerPrivate;

    using EntityGraph = math::graph::DirectedGraph<Entity, bool>;

    class IGNITION_GAZEBO_VISIBLE EntityComponentManager
    {
      public: EntityComponentManager();

      public: ~EntityComponentManager();

      public: Entity CreateEntity();

      public: size_t EntityCount() const;

      public: void RequestRemoveEntity(const Entity _entity,
          bool _recursive = true);

      public: void RequestRemoveEntities();

      public: bool HasEntity(const Entity _entity) const;

      public: Entity ParentEntity(const Entity _entity) const;

      public: bool SetParentEntity(const Entity _child, const Entity _parent);

      public: bool HasComponentType(const ComponentTypeId _typeId) const;

      public: bool EntityHasComponent(const Entity _entity,
                  const ComponentKey &_key) const;

      public: bool EntityHasComponentType(const Entity _entity,
                  const ComponentTypeId &_typeId) const;

      public: bool EntityMatches(Entity _entity,
        const std::set<ComponentTypeId> &_types) const;

      public: bool RemoveComponent(
                  const Entity _entity, const ComponentKey &_key);

      public: bool RemoveComponent(
                  const Entity _entity, const ComponentTypeId &_typeId);

      public: template<typename ComponentTypeT>
              bool RemoveComponent(Entity _entity);

      public: void RebuildViews();

      public: template<typename ComponentTypeT>
              ComponentKey CreateComponent(const Entity _entity,
                  const ComponentTypeT &_data);

      public: template<typename ComponentTypeT>
              const ComponentTypeT *Component(const Entity _entity) const;

      public: template<typename ComponentTypeT>
              ComponentTypeT *Component(const Entity _entity);

      public: template<typename ComponentTypeT>
              const ComponentTypeT *Component(const ComponentKey &_key) const;

      public: template<typename ComponentTypeT>
              ComponentTypeT *Component(const ComponentKey &_key);

      public: template<typename ComponentTypeT>
              const ComponentTypeT *First() const;

      public: template<typename ComponentTypeT>
              ComponentTypeT *First();

      public: template<typename ...ComponentTypeTs>
              Entity EntityByComponents(
                   const ComponentTypeTs &..._desiredComponents) const;

      public: template<typename ...ComponentTypeTs>
              std::vector<Entity> EntitiesByComponents(
                   const ComponentTypeTs &..._desiredComponents) const;

      public: template<typename ...ComponentTypeTs>
              std::vector<Entity> ChildrenByComponents(Entity _parent,
                   const ComponentTypeTs &..._desiredComponents) const;

      private: template <typename T>
               struct identity;  // NOLINT

      public: template<typename ...ComponentTypeTs>
              void EachNoCache(typename identity<std::function<
                  bool(const Entity &_entity,
                       const ComponentTypeTs *...)>>::type _f) const;

      public: template<typename ...ComponentTypeTs>
              void EachNoCache(typename identity<std::function<
                  bool(const Entity &_entity,
                       ComponentTypeTs *...)>>::type _f);

      public: template<typename ...ComponentTypeTs>
              void Each(typename identity<std::function<
                  bool(const Entity &_entity,
                       const ComponentTypeTs *...)>>::type _f) const;

      public: template<typename ...ComponentTypeTs>
              void Each(typename identity<std::function<
                  bool(const Entity &_entity,
                       ComponentTypeTs *...)>>::type _f);

      public: template <class Function, class... ComponentTypeTs>
      static void ForEach(Function _f, const ComponentTypeTs &... _components);

      public: template <typename... ComponentTypeTs>
              void EachNew(typename identity<std::function<
                           bool(const Entity &_entity,
                                ComponentTypeTs *...)>>::type _f);

      public: template <typename... ComponentTypeTs>
              void EachNew(typename identity<std::function<
                           bool(const Entity &_entity,
                                const ComponentTypeTs *...)>>::type _f) const;

      public: template<typename ...ComponentTypeTs>
              void EachRemoved(typename identity<std::function<
                  bool(const Entity &_entity,
                       const ComponentTypeTs *...)>>::type _f) const;

      public: const EntityGraph &Entities() const;

      public: std::unordered_set<Entity> Descendants(Entity _entity) const;

      public: msgs::SerializedState State(
          const std::unordered_set<Entity> &_entities = {},
          const std::unordered_set<ComponentTypeId> &_types = {}) const;

      public: msgs::SerializedState ChangedState() const;

      public: bool HasNewEntities() const;

      public: bool HasEntitiesMarkedForRemoval() const;

      public: bool HasOneTimeComponentChanges() const;

      public: void SetState(const msgs::SerializedState &_stateMsg);

      public: gazebo::ComponentState ComponentState(const Entity _entity,
          const ComponentTypeId _typeId) const;

      protected: void ClearNewlyCreatedEntities();

      protected: void ProcessRemoveEntityRequests();

      private: bool IsNewEntity(const Entity _entity) const;

      private: bool IsMarkedForRemoval(const Entity _entity) const;

      private: bool RemoveEntity(const Entity _entity);

      private: components::BaseComponent *First(
                   const ComponentTypeId _componentTypeId);

      private: ComponentKey CreateComponentImplementation(
                   const Entity _entity,
                   const ComponentTypeId _componentTypeId,
                   const components::BaseComponent *_data);

      private: const components::BaseComponent *ComponentImplementation(
                   const Entity _entity,
                   const ComponentTypeId _type) const;

      private: components::BaseComponent *ComponentImplementation(
                   const Entity _entity,
                   const ComponentTypeId _type);

      private: const components::BaseComponent *ComponentImplementation(
                   const ComponentKey &_key) const;

      private: components::BaseComponent *ComponentImplementation(
                   const ComponentKey &_key);

      private: template<typename FirstComponent,
                        typename ...RemainingComponents,
                        typename std::enable_if<
                          sizeof...(RemainingComponents) == 0, int>::type = 0>
          void AddComponentsToView(detail::View &_view,
               const Entity _entity) const;

      private: template<typename FirstComponent,
                        typename ...RemainingComponents,
                        typename std::enable_if<
                          sizeof...(RemainingComponents) != 0, int>::type = 0>
          void AddComponentsToView(detail::View &_view,
              const Entity _entity) const;

      private: template<typename ...ComponentTypeTs>
          detail::View &FindView() const;

      private: bool FindView(const std::set<ComponentTypeId> &_types,
          std::map<detail::ComponentTypeKey,
          detail::View>::iterator &_iter) const;

      private: std::map<detail::ComponentTypeKey, detail::View>::iterator
          AddView(const std::set<ComponentTypeId> &_types,
              detail::View &&_view) const;

      private: void UpdateViews(const Entity _entity);

      private: ComponentId EntityComponentIdFromType(
          const Entity _entity, const ComponentTypeId _type) const;

      private: void AddEntityToMessage(msgs::SerializedState &_msg,
          Entity _entity,
          const std::unordered_set<ComponentTypeId> &_types = {}) const;

      private: std::unique_ptr<EntityComponentManagerPrivate> dataPtr;

      // Make runners friends so that they can manage entity creation and
      // removal. This should be safe since runners are internal
      // to Gazebo.
      friend class GuiRunner;
      friend class SimulationRunner;

      // Make network managers friends so they have control over component
      // states. Like the runners, the managers are internal.
      friend class NetworkManagerPrimary;
      friend class NetworkManagerSecondary;

      // Make View a friend so that it can access components.
      // This should be safe since View is internal to Gazebo.
      friend class detail::View;

      // The following function are here for ABI compatibility.


      public: void State(
                  msgs::SerializedStateMap &_state,
                  const std::unordered_set<Entity> &_entities = {},
                  const std::unordered_set<ComponentTypeId> &_types = {},
                  bool _full = false) const;

      public: void ChangedState(msgs::SerializedStateMap &_state) const;

      public: void SetState(const msgs::SerializedStateMap &_stateMsg);

      public: void SetChanged(
          const Entity _entity, const ComponentTypeId _type,
          gazebo::ComponentState _c = ComponentState::OneTimeChange);

      protected: void SetAllComponentsUnchanged();

      private: void AddEntityToMessage(msgs::SerializedStateMap &_msg,
          Entity _entity,
          const std::unordered_set<ComponentTypeId> &_types = {},
          bool _full = false) const;
    };
    }
  }
}

#include "ignition/gazebo/detail/EntityComponentManager.hh"

#endif