gz/physics/SpecifyData.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_SPECIFYDATA_HH_
#define GZ_PHYSICS_SPECIFYDATA_HH_
 
#include "gz/physics/detail/PrivateSpecifyData.hh"
 
namespace ignition
{
  namespace physics
  {
    template <typename Expected>
    class ExpectData<Expected> : public virtual CompositeData
    {
      public: ExpectData();
 
      public: ExpectData(const ExpectData &_other);
 
      public: ExpectData& operator=(const ExpectData &_other) = default;
 
 
      public: virtual ~ExpectData() = default;
 
      public: template <typename Data>
      Data &Get();
 
      public: template <typename Data, typename... Args>
      InsertResult<Data> InsertOrAssign(Args&&... _args);
 
      public: template <typename Data, typename... Args>
      InsertResult<Data> Insert(Args&&... _args);
 
      public: template <typename Data>
      bool Remove();
 
      public: template <typename Data>
      Data *Query(const QueryMode _mode = QueryMode::NORMAL);
 
      public: template <typename Data>
      const Data *Query(const QueryMode _mode = QueryMode::NORMAL) const;
 
      public: template <typename Data>
      bool Has() const;
 
      public: template <typename Data>
      DataStatus StatusOf() const;
 
      public: template <typename Data>
      bool Unquery() const;
 
      public: template <typename Data, typename... Args>
      Data &MakeRequired(Args&&... _args);
 
      public: template <typename Data>
      bool Requires() const;
 
      public: template <typename Data>
      static constexpr bool Expects();
 
      protected: detail::PrivateExpectData<Expected> privateExpectData;
 
      // This allows outside users to identify this expected data type at
      // compile time, which can be useful for doing template metaprogramming.
      public: using Specification = ExpectData<Expected>;
      public: using ExpectedData = Expected;
      public: using RequiredData = void;
 
      public: using SubSpecification1 = void;
      public: using SubSpecification2 = void;
    };
 
    template <typename Required>
    class RequireData<Required> : public virtual ExpectData<Required>
    {
      // This allows outside users to identify this Required data type at
      // compile time, which can be useful for doing template metaprogramming.
      public: using Specification = RequireData<Required>;
      public: using RequiredData = Required;
 
      public: RequireData();
 
      public: virtual ~RequireData() = default;
 
      // Do not shadow the ExpectData<Required> implementation
      using ExpectData<Required>::Get;
 
      public: template <typename Data>
      const Data &Get() const;
 
      public: template <typename Data>
      static constexpr bool AlwaysRequires();
 
      protected: detail::PrivateRequireData<Required> privateRequireData;
    };
 
    template <typename... Specifications>
    class SpecifyData;
 
 
    // ----------------------- Utility Templates ----------------------------
 
    template <typename Specification>
    constexpr std::size_t CountUpperLimitOfExpectedData();
 
    template <typename Specification>
    constexpr std::size_t CountUpperLimitOfRequiredData();
 
    template <typename Specification, template<typename> class SpecFinder>
    constexpr std::size_t CountUpperLimitOfSpecifiedData();
 
 
    template <typename Specification>
    struct FindExpected
    {
      using Data = typename Specification::ExpectedData;
    };
 
    template <>
    struct FindExpected<void>
    {
      using Data = void;
    };
 
 
    template <typename Specification>
    struct FindRequired
    {
      using Data = typename Specification::RequiredData;
    };
 
    template <>
    struct FindRequired<void>
    {
      using Data = void;
    };
 
 
    template <typename Data, typename Specification>
    struct IsExpectedBy : std::integral_constant<
        bool, Specification::template Expects<Data>() > { };
 
    template <typename Data>
    struct IsExpectedBy<Data, void> : std::false_type { };
 
    template <typename Data, typename Specification>
    struct IsRequiredBy : std::integral_constant<
        bool, Specification::template AlwaysRequires<Data>() > { };
 
    template <typename Data>
    struct IsRequiredBy<Data, void> : std::false_type { };
  }
}
 
#include "gz/physics/detail/SpecifyData.hh"
 
#endif