gz/sim/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 GZ_SIM_ENTITYCOMPONENTMANAGER_HH_
#define GZ_SIM_ENTITYCOMPONENTMANAGER_HH_
 
#include <gz/msgs/serialized.pb.h>
#include <gz/msgs/serialized_map.pb.h>
 
#include <map>
#include <memory>
#include <optional>
#include <set>
#include <string>
#include <typeinfo>
#include <type_traits>
#include <unordered_set>
#include <unordered_map>
#include <utility>
#include <vector>
 
#include <gz/common/Console.hh>
#include <gz/math/graph/Graph.hh>
#include "gz/sim/Entity.hh"
#include "gz/sim/Export.hh"
#include "gz/sim/Types.hh"
 
#include "gz/sim/components/Component.hh"
#include "gz/sim/detail/View.hh"
 
namespace gz
{
  namespace sim
  {
    // Inline bracket to help doxygen filtering.
    inline namespace GZ_SIM_VERSION_NAMESPACE {
    // Forward declarations.
    class GZ_SIM_HIDDEN EntityComponentManagerPrivate;
    class EntityComponentManagerDiff;
 
    using EntityGraph = math::graph::DirectedGraph<Entity, bool>;
 
    class GZ_SIM_VISIBLE EntityComponentManager
    {
      public: EntityComponentManager();
 
      public: ~EntityComponentManager();
 
      public: void CopyFrom(const EntityComponentManager &_fromEcm);
 
      public: Entity CreateEntity();
 
      public: Entity Clone(Entity _entity, Entity _parent,
                  const std::string &_name, bool _allowRename);
 
      public: size_t EntityCount() const;
 
      public: void RequestRemoveEntity(const Entity _entity,
          bool _recursive = true);
 
      public: void PinEntity(const Entity _entity, bool _recursive = true);
 
      public: void UnpinEntity(const Entity _entity, bool _recursive = true);
 
      public: void UnpinAllEntities();
 
      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 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 ComponentTypeId &_typeId);
 
      public: template<typename ComponentTypeT>
              bool RemoveComponent(Entity _entity);
 
      public: void RebuildViews();
 
      public: template<typename ComponentTypeT>
              ComponentTypeT *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>
              ComponentTypeT *ComponentDefault(Entity _entity,
              const typename ComponentTypeT::Type &_default =
                  typename ComponentTypeT::Type());
 
      public: template<typename ComponentTypeT>
              std::optional<typename ComponentTypeT::Type> ComponentData(
              const Entity _entity) const;
 
      public: template<typename ComponentTypeT>
              bool SetComponentData(const Entity _entity,
              const typename ComponentTypeT::Type &_data);
 
      public: std::unordered_set<ComponentTypeId> ComponentTypes(
          Entity _entity) const;
 
      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
 
      private: Entity CloneImpl(Entity _entity, Entity _parent,
                  const std::string &_name, bool _allowRename);
 
      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: bool HasPeriodicComponentChanges() const;
 
      public: std::unordered_set<ComponentTypeId>
          ComponentTypesWithPeriodicChanges() const;
 
      public: void UpdatePeriodicChangeCache(std::unordered_map<ComponentTypeId,
        std::unordered_set<Entity>>&) const;
 
      public: void SetState(const msgs::SerializedState &_stateMsg);
 
      public: void State(
                  msgs::SerializedStateMap &_state,
                  const std::unordered_set<Entity> &_entities = {},
                  const std::unordered_set<ComponentTypeId> &_types = {},
                  bool _full = false) const;
 
      public: void PeriodicStateFromCache(
                  msgs::SerializedStateMap &_state,
                  const std::unordered_map<ComponentTypeId,
                        std::unordered_set<Entity>> &_cache) const;
 
      public: void ChangedState(msgs::SerializedStateMap &_state) const;
 
      public: void SetState(const msgs::SerializedStateMap &_stateMsg);
 
      public: void SetChanged(
          const Entity _entity, const ComponentTypeId _type,
          sim::ComponentState _c = ComponentState::OneTimeChange);
 
      public: sim::ComponentState ComponentState(const Entity _entity,
          const ComponentTypeId _typeId) const;
 
      public: void SetEntityCreateOffset(uint64_t _offset);
 
      public: void ResetTo(const EntityComponentManager &_other);
 
      public: bool HasRemovedComponents() const;
 
      protected: void ClearNewlyCreatedEntities();
 
      protected: void ClearRemovedComponents();
 
      protected: void ProcessRemoveEntityRequests();
 
      protected: void SetAllComponentsUnchanged();
 
      protected: EntityComponentManagerDiff ComputeEntityDiff(
                     const EntityComponentManager &_other) const;
 
      protected: void ApplyEntityDiff(const EntityComponentManager &_other,
                                      const EntityComponentManagerDiff &_diff);
 
      private: bool IsNewEntity(const Entity _entity) const;
 
      private: bool IsMarkedForRemoval(const Entity _entity) const;
 
      private: bool 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: template<typename ...ComponentTypeTs>
          detail::View *FindView() const;
 
      private: std::pair<detail::BaseView *, std::mutex *> FindView(
                   const std::vector<ComponentTypeId> &_types) const;
 
      private: detail::BaseView *AddView(
                   const detail::ComponentTypeKey &_types,
                   std::unique_ptr<detail::BaseView> _view) const;
 
      private: void AddEntityToMessage(msgs::SerializedState &_msg,
          Entity _entity,
          const std::unordered_set<ComponentTypeId> &_types = {}) const;
 
      private: std::unique_ptr<EntityComponentManagerPrivate> dataPtr;
 
      private: void AddEntityToMessage(msgs::SerializedStateMap &_msg,
          Entity _entity,
          const std::unordered_set<ComponentTypeId> &_types = {},
          bool _full = false) const;
 
      private: void LockAddingEntitiesToViews(bool _lock);
 
      private: bool LockAddingEntitiesToViews() const;
 
      // 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;
    };
    }
  }
}
 
#include "gz/sim/detail/EntityComponentManager.hh"
 
#endif