gz/physics/GetEntities.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_PHYSICS_GETENTITIES_HH_
#define GZ_PHYSICS_GETENTITIES_HH_
 
#include <string>
 
#include <gz/physics/FeatureList.hh>
 
namespace ignition
{
  namespace physics
  {
    class IGNITION_PHYSICS_VISIBLE GetEngineInfo : public virtual Feature
    {
      public: template <typename PolicyT, typename FeaturesT>
      class Engine : public virtual Feature::Engine<PolicyT, FeaturesT>
      {
        public: const std::string &GetName() const;
 
        public: std::size_t GetIndex() const;
      };
 
      public: template <typename PolicyT>
      class Implementation : public virtual Feature::Implementation<PolicyT>
      {
        public: virtual const std::string &GetEngineName(
            const Identity &_engineID) const = 0;
 
        public: virtual std::size_t GetEngineIndex(
            const Identity &_engineID) const = 0;
      };
    };
 
    class IGNITION_PHYSICS_VISIBLE GetWorldFromEngine : public virtual Feature
    {
      public: template <typename PolicyT, typename FeaturesT>
      class Engine : public virtual Feature::Engine<PolicyT, FeaturesT>
      {
        // typedefs for the type of World that this engine can return.
        public: using WorldPtrType = WorldPtr<PolicyT, FeaturesT>;
        public: using ConstWorldPtrType = ConstWorldPtr<PolicyT, FeaturesT>;
 
        public: std::size_t GetWorldCount() const;
 
        public: WorldPtrType GetWorld(std::size_t _index);
 
        public: ConstWorldPtrType GetWorld(std::size_t _index) const;
 
        public: WorldPtrType GetWorld(const std::string &_name);
 
        public: ConstWorldPtrType GetWorld(const std::string &_name) const;
      };
 
      public: template <typename PolicyT, typename FeaturesT>
      class World : public virtual Feature::World<PolicyT, FeaturesT>
      {
        // typedefs for the type of Engine that this World can return
        public: using EnginePtrType = EnginePtr<PolicyT, FeaturesT>;
        public: using ConstEnginePtrType = ConstEnginePtr<PolicyT, FeaturesT>;
 
        public: const std::string &GetName() const;
 
        public: std::size_t GetIndex() const;
 
        public: EnginePtrType GetEngine();
 
        public: ConstEnginePtrType GetEngine() const;
      };
 
      public: template <typename PolicyT>
      class Implementation : public virtual Feature::Implementation<PolicyT>
      {
        public: virtual std::size_t GetWorldCount(
            const Identity &_engineID) const = 0;
 
        public: virtual Identity GetWorld(
            const Identity &_engineID, std::size_t _worldIndex) const = 0;
 
        public: virtual Identity GetWorld(
            const Identity &_engineID, const std::string &_worldName) const = 0;
 
        public: virtual const std::string &GetWorldName(
            const Identity &_worldID) const = 0;
 
        public: virtual std::size_t GetWorldIndex(
            const Identity &_worldID) const = 0;
 
        public: virtual Identity GetEngineOfWorld(
            const Identity &_worldID) const = 0;
      };
    };
 
    class IGNITION_PHYSICS_VISIBLE GetModelFromWorld : public virtual Feature
    {
      public: template <typename PolicyT, typename FeaturesT>
      class World : public virtual Feature::World<PolicyT, FeaturesT>
      {
        // typedefs for the type of Model that this World can return
        public: using ModelPtrType = ModelPtr<PolicyT, FeaturesT>;
        public: using ConstModelPtrType = ConstModelPtr<PolicyT, FeaturesT>;
 
        public: std::size_t GetModelCount() const;
 
        public: ModelPtrType GetModel(std::size_t _index);
 
        public: ConstModelPtrType GetModel(std::size_t _index) const;
 
        public: ModelPtrType GetModel(const std::string &_name);
 
        public: ConstModelPtrType GetModel(const std::string &_name) const;
      };
 
      public: template <typename PolicyT, typename FeaturesT>
      class Model : public virtual Feature::Model<PolicyT, FeaturesT>
      {
        // typedefs for the type of World that this Model can return
        public: using WorldPtrType = WorldPtr<PolicyT, FeaturesT>;
        public: using ConstWorldPtrType = ConstWorldPtr<PolicyT, FeaturesT>;
 
        public: const std::string &GetName() const;
 
        public: std::size_t GetIndex() const;
 
        public: WorldPtrType GetWorld();
 
        public: ConstWorldPtrType GetWorld() const;
      };
 
      public: template <typename PolicyT>
      class Implementation : public virtual Feature::Implementation<PolicyT>
      {
        public: virtual std::size_t GetModelCount(
            const Identity &_worldID) const = 0;
 
        public: virtual Identity GetModel(
            const Identity &_worldID, std::size_t _modelIndex) const = 0;
 
        public: virtual Identity GetModel(
            const Identity &_worldID, const std::string &_modelName) const = 0;
 
        public: virtual const std::string &GetModelName(
            const Identity &_modelID) const = 0;
 
        public: virtual std::size_t GetModelIndex(
            const Identity &_modelID) const = 0;
 
        public: virtual Identity GetWorldOfModel(
            const Identity &_modelID) const = 0;
      };
    };
 
    class IGNITION_PHYSICS_VISIBLE GetNestedModelFromModel
        : public virtual FeatureWithRequirements<GetModelFromWorld>
    {
      public: template <typename PolicyT, typename FeaturesT>
      class Model : public virtual Feature::Model<PolicyT, FeaturesT>
      {
        // typedefs for the type of Model that this Model can return
        public: using ModelPtrType = ModelPtr<PolicyT, FeaturesT>;
        public: using ConstModelPtrType = ConstModelPtr<PolicyT, FeaturesT>;
 
        public: std::size_t GetNestedModelCount() const;
 
        public: ModelPtrType GetNestedModel(std::size_t _index);
 
        public: ConstModelPtrType GetNestedModel(std::size_t _index) const;
 
        public: ModelPtrType GetNestedModel(const std::string &_name);
 
        public: ConstModelPtrType GetNestedModel(
                    const std::string &_name) const;
      };
 
      public: template <typename PolicyT>
      class Implementation : public virtual Feature::Implementation<PolicyT>
      {
        public: virtual std::size_t GetNestedModelCount(
            const Identity &_modelID) const = 0;
 
        public: virtual Identity GetNestedModel(
            const Identity &_modelID, std::size_t _modelIndex) const = 0;
 
        public: virtual Identity GetNestedModel(
            const Identity &_modelID, const std::string &_modelName) const = 0;
      };
    };
 
    class IGNITION_PHYSICS_VISIBLE GetLinkFromModel : public virtual Feature
    {
      public: template <typename PolicyT, typename FeaturesT>
      class Model : public virtual Feature::Model<PolicyT, FeaturesT>
      {
        // typedefs for the type of Link that this Model can return
        public: using LinkPtrType = LinkPtr<PolicyT, FeaturesT>;
        public: using ConstLinkPtrType = ConstLinkPtr<PolicyT, FeaturesT>;
 
        public: std::size_t GetLinkCount() const;
 
        public: LinkPtrType GetLink(std::size_t _index);
 
        public: ConstLinkPtrType GetLink(std::size_t _index) const;
 
        public: LinkPtrType GetLink(const std::string &_name);
 
        public: ConstLinkPtrType GetLink(const std::string &_name) const;
      };
 
      public: template <typename PolicyT, typename FeaturesT>
      class Link : public virtual Feature::Link<PolicyT, FeaturesT>
      {
        // typedefs for the type of Model that this Link can return
        public: using ModelPtrType = ModelPtr<PolicyT, FeaturesT>;
        public: using ConstModelPtrType = ConstModelPtr<PolicyT, FeaturesT>;
 
        public: const std::string &GetName() const;
 
        public: std::size_t GetIndex() const;
 
        public: ModelPtrType GetModel();
 
        public: ConstModelPtrType GetModel() const;
      };
 
      public: template <typename PolicyT>
      class Implementation : public virtual Feature::Implementation<PolicyT>
      {
        public: virtual std::size_t GetLinkCount(
            const Identity &_modelID) const = 0;
 
        public: virtual Identity GetLink(
            const Identity &_modelID, std::size_t _linkIndex) const = 0;
 
        public: virtual Identity GetLink(
            const Identity &_modelID, const std::string &_linkName) const = 0;
 
        public: virtual const std::string &GetLinkName(
            const Identity &_linkID) const = 0;
 
        public: virtual std::size_t GetLinkIndex(
            const Identity &_linkID) const = 0;
 
        public: virtual Identity GetModelOfLink(
            const Identity &_linkID) const = 0;
      };
    };
 
    class IGNITION_PHYSICS_VISIBLE GetJointFromModel : public virtual Feature
    {
      public: template <typename PolicyT, typename FeaturesT>
      class Model : public virtual Feature::Model<PolicyT, FeaturesT>
      {
        // typedefs for the type of Joint that this Model can return
        public: using JointPtrType = JointPtr<PolicyT, FeaturesT>;
        public: using ConstJointPtrType = ConstJointPtr<PolicyT, FeaturesT>;
 
        public: std::size_t GetJointCount() const;
 
        public: JointPtrType GetJoint(std::size_t _index);
 
        public: ConstJointPtrType GetJoint(std::size_t _index) const;
 
        public: JointPtrType GetJoint(const std::string &_name);
 
        public: ConstJointPtrType GetJoint(const std::string &_name) const;
      };
 
      public: template <typename PolicyT, typename FeaturesT>
      class Joint : public virtual Feature::Joint<PolicyT, FeaturesT>
      {
        // typedefs for the type of Model that this Link can return
        public: using ModelPtrType = ModelPtr<PolicyT, FeaturesT>;
        public: using ConstModelPtrType = ConstModelPtr<PolicyT, FeaturesT>;
 
        public: const std::string &GetName() const;
 
        public: std::size_t GetIndex() const;
 
        public: ModelPtrType GetModel();
 
        public: ConstModelPtrType GetModel() const;
      };
 
      public: template <typename PolicyT>
      class Implementation : public virtual Feature::Implementation<PolicyT>
      {
        public: virtual std::size_t GetJointCount(
            const Identity &_modelID) const = 0;
 
        public: virtual Identity GetJoint(
            const Identity &_modelID, std::size_t _jointIndex) const = 0;
 
        public: virtual Identity GetJoint(
            const Identity &_modelID, const std::string &_jointName) const = 0;
 
        public: virtual const std::string &GetJointName(
            const Identity &_jointID) const = 0;
 
        public: virtual std::size_t GetJointIndex(
            const Identity &_jointID) const = 0;
 
        public: virtual Identity GetModelOfJoint(
            const Identity &_jointID) const = 0;
      };
    };
 
    class IGNITION_PHYSICS_VISIBLE GetShapeFromLink : public virtual Feature
    {
      public: template <typename PolicyT, typename FeaturesT>
      class Link : public virtual Feature::Link<PolicyT, FeaturesT>
      {
        // typedefs for the type of Shape that this Link can return
        public: using ShapePtrType = ShapePtr<PolicyT, FeaturesT>;
        public: using ConstShapePtrType = ConstShapePtr<PolicyT, FeaturesT>;
 
        public: std::size_t GetShapeCount() const;
 
        public: ShapePtrType GetShape(std::size_t _index);
 
        public: ConstShapePtrType GetShape(std::size_t _index) const;
 
        public: ShapePtrType GetShape(const std::string &_name);
 
        public: ConstShapePtrType GetShape(const std::string &_name) const;
      };
 
      public: template <typename PolicyT, typename FeaturesT>
      class Shape : public virtual Feature::Shape<PolicyT, FeaturesT>
      {
        // typedefs for the type of Link that this Shape can return
        public: using LinkPtrType = LinkPtr<PolicyT, FeaturesT>;
        public: using ConstLinkPtrType = ConstLinkPtr<PolicyT, FeaturesT>;
 
        public: const std::string &GetName() const;
 
        public: std::size_t GetIndex() const;
 
        public: LinkPtrType GetLink();
 
        public: ConstLinkPtrType GetLink() const;
      };
 
      public: template <typename PolicyT>
      class Implementation : public virtual Feature::Implementation<PolicyT>
      {
        public: virtual std::size_t GetShapeCount(
            const Identity &_linkID) const = 0;
 
        public: virtual Identity GetShape(
            const Identity &_linkID, std::size_t _shapeIndex) const = 0;
 
        public: virtual Identity GetShape(
            const Identity &_linkID, const std::string &_shapeName) const = 0;
 
        public: virtual const std::string &GetShapeName(
            const Identity &_shapeID) const = 0;
 
        public: virtual std::size_t GetShapeIndex(
            const Identity &_shapeID) const = 0;
 
        public: virtual Identity GetLinkOfShape(
            const Identity &_shapeID) const = 0;
      };
    };
 
    struct GetEntities : FeatureList<
      GetEngineInfo,
      GetWorldFromEngine,
      GetModelFromWorld,
      GetNestedModelFromModel,
      GetLinkFromModel,
      GetJointFromModel,
      GetShapeFromLink
    > { };
  }
}
 
#include <gz/physics/detail/GetEntities.hh>
 
#endif