gz/physics/CompositeData.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_COMPOSITEDATA_HH_
#define GZ_PHYSICS_COMPOSITEDATA_HH_
 
#include <string>
#include <map>
#include <set>
 
#include <gz/utils/SuppressWarning.hh>
 
#include "gz/physics/Cloneable.hh"
#include "gz/physics/Export.hh"
 
namespace ignition
{
  namespace physics
  {
    // Forward declarations
    namespace detail
    {
      template <typename> class PrivateExpectData;
      template <typename> class PrivateRequireData;
    }
 
    class IGNITION_PHYSICS_VISIBLE CompositeData
    {
      public: CompositeData();
 
      public: virtual ~CompositeData() = default;
 
      public: template <typename Data>
      Data &Get();
 
      public: template <typename Data>
      struct InsertResult
      {
        public: Data &data;
 
        public: const bool inserted;
 
        // We explicitly delete the copy assignment operator, because we don't
        // want someone to inadvertently assign a value to the data that's being
        // referenced (users must do so explicitly by calling on the `data`
        // member variable). Note that this operator is already implicitly
        // deleted by having the const bool member variable, but we are also
        // deleting it explicitly for clarity.
        public: InsertResult &operator=(const InsertResult&) = delete;
      };
 
      public: template <typename Data, typename... Args>
      InsertResult<Data> Insert(Args &&..._args);
 
      public: template <typename Data, typename... Args>
      InsertResult<Data> InsertOrAssign(Args &&... _args);
 
      public: template <typename Data>
      bool Remove();
 
      enum class QueryMode : int
      {
        NORMAL = 0,
 
        SILENT
      };
 
      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;
 
      struct IGNITION_PHYSICS_VISIBLE DataStatus
      {
        public: bool exists;
 
        public: bool queried;
 
        public: bool required;
 
        DataStatus();
      };
 
      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();
 
      public: template <typename Data>
      static constexpr bool AlwaysRequires();
 
      public: std::size_t EntryCount() const;
 
      public: std::size_t UnqueriedEntryCount() const;
 
      public: void ResetQueries() const;
 
      public: std::set<std::string> AllEntries() const;
 
      public: std::set<std::string> UnqueriedEntries() const;
 
      public: CompositeData &Copy(const CompositeData &_other,
                                  const bool _mergeRequirements = false);
 
      public: CompositeData &Copy(CompositeData &&_other,
                                  const bool _mergeRequirements = false);
 
      public: CompositeData &Merge(const CompositeData &_other,
                                   const bool _mergeRequirements = false);
 
      public: CompositeData &Merge(CompositeData &&_other,
                                   const bool _mergeRequirements = false);
 
      public: CompositeData(const CompositeData &_other);
 
      public: CompositeData(CompositeData &&_other);
 
      public: CompositeData &operator=(const CompositeData &_other);
 
      public: CompositeData &operator=(CompositeData &&_other);
 
      public: struct DataEntry;
 
      // We make this typedef public so that helper functions can use it without
      // being friends of the class.
      public: using MapOfData = std::map<std::string, DataEntry>;
 
      IGN_UTILS_WARN_IGNORE__DLL_INTERFACE_MISSING
      protected: MapOfData dataMap;
      IGN_UTILS_WARN_RESUME__DLL_INTERFACE_MISSING
 
      protected: std::size_t numEntries;
 
      protected: mutable std::size_t numQueries;
 
      // Declare friendship
      template <typename> friend class detail::PrivateExpectData;
      template <typename> friend class detail::PrivateRequireData;
    };
  }
}
 
#include "gz/physics/detail/CompositeData.hh"
 
#endif