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 IGNITION_PHYSICS_SPECIFYDATA_HH_
#define IGNITION_PHYSICS_SPECIFYDATA_HH_

#include "ignition/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 "ignition/physics/detail/SpecifyData.hh"

#endif