gz/sim/components/Component.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_GAZEBO_COMPONENTS_COMPONENT_HH_
#define GZ_GAZEBO_COMPONENTS_COMPONENT_HH_
 
#include <cstdint>
#include <memory>
#include <string>
#include <sstream>
#include <utility>
 
#include <gz/common/Console.hh>
 
#include <gz/sim/config.hh>
#include <gz/sim/Export.hh>
#include <gz/sim/Types.hh>
 
namespace ignition
{
namespace gazebo
{
// namespace ignition
// Inline bracket to help doxygen filtering.
inline namespace IGNITION_GAZEBO_VERSION_NAMESPACE {
namespace traits
{
  template <typename T>
  struct IsSharedPtr : std::false_type
  {
  };
 
  template <typename T>
  struct IsSharedPtr<std::shared_ptr<T>> : std::true_type
  {
  };
 
  template <typename Stream, typename DataType>
  class IsOutStreamable
  {
    private: template <typename StreamArg, typename DataTypeArg>
    static auto Test(int _test)
        -> decltype(std::declval<StreamArg &>()
                    << std::declval<const DataTypeArg &>(), std::true_type());
 
    private: template <typename, typename>
    static auto Test(...) -> std::false_type;
 
    public: static constexpr bool value =  // NOLINT
                decltype(Test<Stream, DataType>(true))::value;
  };
 
  template <typename Stream, typename DataType>
  class IsInStreamable
  {
    private: template <typename StreamArg, typename DataTypeArg>
    static auto Test(int _test)
      -> decltype(std::declval<StreamArg &>() >> std::declval<DataTypeArg &>(),
                  std::true_type());
 
    private: template <typename, typename>
    static auto Test(...) -> std::false_type;
 
    public: static constexpr bool value =  // NOLINT
                decltype(Test<Stream, DataType>(0))::value;
  };
}
 
namespace serializers
{
  template <typename DataType>
  class DefaultSerializer
  {
    public: static std::ostream &Serialize(std::ostream &_out,
                                           const DataType &_data)
    {
      // cppcheck-suppress syntaxError
      if constexpr (traits::IsSharedPtr<DataType>::value) // NOLINT
      {
        if constexpr (traits::IsOutStreamable<std::ostream,
                                   typename DataType::element_type>::value)
        {
          _out << *_data;
        }
        else
        {
          static bool warned{false};
          if (!warned)
          {
            ignwarn << "Trying to serialize component with data type ["
                    << typeid(DataType).name() << "], which doesn't have "
                    << "`operator<<`. Component will not be serialized."
                    << std::endl;
            warned = true;
          }
        }
      }
      else if constexpr (traits::IsOutStreamable<std::ostream, DataType>::value)
      {
        _out << _data;
      }
      else
      {
        static bool warned{false};
        if (!warned)
        {
          ignwarn << "Trying to serialize component with data type ["
                  << typeid(DataType).name() << "], which doesn't have "
                  << "`operator<<`. Component will not be serialized."
                  << std::endl;
          warned = true;
        }
      }
      return _out;
    }
 
    public: static std::istream &Deserialize(std::istream &_in,
                                             DataType &_data)
    {
      if constexpr (traits::IsSharedPtr<DataType>::value)
      {
        if constexpr (traits::IsInStreamable<std::istream,
                                   typename DataType::element_type>::value)
        {
          _in >> *_data;
        }
        else
        {
          static bool warned{false};
          if (!warned)
          {
            ignwarn << "Trying to deserialize component with data type ["
                    << typeid(DataType).name() << "], which doesn't have "
                    << "`operator>>`. Component will not be deserialized."
                    << std::endl;
            warned = true;
          }
        }
      }
      else if constexpr (traits::IsInStreamable<std::istream, DataType>::value)
      {
        _in >> _data;
      }
      else
      {
        static bool warned{false};
        if (!warned)
        {
          ignwarn << "Trying to deserialize component with data type ["
                  << typeid(DataType).name() << "], which doesn't have "
                  << "`operator>>`. Component will not be deserialized."
                  << std::endl;
          warned = true;
        }
      }
      return _in;
    }
  };
}
 
namespace components
{
  using NoData = std::add_lvalue_reference<void>;
}
 
namespace serializers
{
  template<> class DefaultSerializer<components::NoData>
  {
    public: static std::ostream &Serialize(std::ostream &_out)
    {
      _out << "-";
      return _out;
    }
 
    public: static std::istream &Deserialize(std::istream &_in)
    {
      return _in;
    }
  };
}
 
namespace components
{
  class BaseComponent
  {
    public: BaseComponent() = default;
 
    public: virtual ~BaseComponent() = default;
 
    public: virtual void Serialize(std::ostream &_out) const
    {
      // This will avoid a doxygen warning
      (void)_out;
      static bool warned{false};
      if (!warned)
      {
        ignwarn << "Trying to serialize component of type [" << this->TypeId()
                << "], which hasn't implemented the `Serialize` function. "
                << "Component will not be serialized." << std::endl;
        warned = true;
      }
    };
 
    public: virtual void Deserialize(std::istream &_in)
    {
      // This will avoid a doxygen warning
      (void)_in;
      static bool warned{false};
      if (!warned)
      {
        ignwarn << "Trying to deserialize component of type ["
                << this->TypeId() << "], which hasn't implemented the "
                << "`Deserialize` function. Component will not be deserialized."
                << std::endl;
        warned = true;
      }
    };
 
    public: virtual ComponentTypeId TypeId() const = 0;
 
    public: virtual std::unique_ptr<BaseComponent> Clone() = 0;
  };
 
  template <typename DataType, typename Identifier,
            typename Serializer = serializers::DefaultSerializer<DataType>>
  class Component : public BaseComponent
  {
    public: using Type = DataType;
 
    public: Component() = default;
 
    public: explicit Component(DataType _data);
 
    public: ~Component() override = default;
 
    public: bool operator==(const Component &_component) const;
 
    public: bool operator!=(const Component &_component) const;
 
    // Documentation inherited
    public: std::unique_ptr<BaseComponent> Clone() override;
 
    // Documentation inherited
    public: ComponentTypeId TypeId() const override;
 
    // Documentation inherited
    public: void Serialize(std::ostream &_out) const override;
 
    // Documentation inherited
    public: void Deserialize(std::istream &_in) override;
 
    public: DataType &Data();
 
    public: bool SetData(const DataType &_data,
                const std::function<
                  bool(const DataType &, const DataType &)> &_eql);
 
    public: const DataType &Data() const;
 
    private: DataType data;
 
    public: inline static ComponentTypeId typeId{0};
 
    // TODO(azeey) Change to const char* in Harmonic to prevent static
    // initialization order fiasco.
    public: inline static std::string typeName;
  };
 
  template <typename Identifier, typename Serializer>
  class Component<NoData, Identifier, Serializer> : public BaseComponent
  {
    public: bool operator==(const Component<NoData, Identifier,
                            Serializer> &_component) const;
 
    public: bool operator!=(const Component<NoData, Identifier,
                            Serializer> &_component) const;
 
    // Documentation inherited
    public: std::unique_ptr<BaseComponent> Clone() override;
 
    // Documentation inherited
    public: ComponentTypeId TypeId() const override;
 
    // Documentation inherited
    public: void Serialize(std::ostream &_out) const override;
 
    // Documentation inherited
    public: void Deserialize(std::istream &_in) override;
 
    public: inline static ComponentTypeId typeId{0};
 
    // TODO(azeey) Change to const char* in Harmonic to prevent static
    // initialization order fiasco.
    public: inline static std::string typeName;
  };
 
  template <typename DataType, typename Identifier, typename Serializer>
  Component<DataType, Identifier, Serializer>::Component(DataType _data)
    : data(std::move(_data))
  {
  }
 
  template <typename DataType, typename Identifier, typename Serializer>
  DataType &Component<DataType, Identifier, Serializer>::Data()
  {
    return this->data;
  }
 
  template <typename DataType, typename Identifier, typename Serializer>
  bool Component<DataType, Identifier, Serializer>::SetData(
      const DataType &_data,
      const std::function<bool(const DataType &, const DataType &)> &_eql)
  {
    bool result = !_eql(_data, this->data);
    this->data = _data;
    return result;
  }
 
  template <typename DataType, typename Identifier, typename Serializer>
  const DataType &Component<DataType, Identifier, Serializer>::Data() const
  {
    return this->data;
  }
 
  template <typename DataType, typename Identifier, typename Serializer>
  bool Component<DataType, Identifier, Serializer>::operator==(
      const Component<DataType, Identifier, Serializer> &_component) const
  {
    return this->data == _component.Data();
  }
 
  template <typename DataType, typename Identifier, typename Serializer>
  bool Component<DataType, Identifier, Serializer>::operator!=(
      const Component<DataType, Identifier, Serializer> &_component) const
  {
    return this->data != _component.Data();
  }
 
  template <typename DataType, typename Identifier, typename Serializer>
  void Component<DataType, Identifier, Serializer>::Serialize(
      std::ostream &_out) const
  {
    Serializer::Serialize(_out, this->Data());
  }
 
  template <typename DataType, typename Identifier, typename Serializer>
  void Component<DataType, Identifier, Serializer>::Deserialize(
      std::istream &_in)
  {
    Serializer::Deserialize(_in, this->Data());
  }
 
  template <typename DataType, typename Identifier, typename Serializer>
  std::unique_ptr<BaseComponent>
  Component<DataType, Identifier, Serializer>::Clone()
  {
    Component<DataType, Identifier, Serializer> clonedComp(this->Data());
    return std::make_unique<Component<DataType, Identifier, Serializer>>(
        clonedComp);
  }
 
  template <typename DataType, typename Identifier, typename Serializer>
  ComponentTypeId Component<DataType, Identifier, Serializer>::TypeId() const
  {
    return typeId;
  }
 
  template <typename Identifier, typename Serializer>
  bool Component<NoData, Identifier, Serializer>::operator==(
      const Component<NoData, Identifier, Serializer> &) const
  {
    return true;
  }
 
  template <typename Identifier, typename Serializer>
  bool Component<NoData, Identifier, Serializer>::operator!=(
      const Component<NoData, Identifier, Serializer> &) const
  {
    return false;
  }
 
  template <typename Identifier, typename Serializer>
  std::unique_ptr<BaseComponent>
  Component<NoData, Identifier, Serializer>::Clone()
  {
    return std::make_unique<Component<NoData, Identifier, Serializer>>();
  }
 
  template <typename Identifier, typename Serializer>
  ComponentTypeId Component<NoData, Identifier, Serializer>::TypeId() const
  {
    return typeId;
  }
 
  template <typename Identifier, typename Serializer>
  void Component<NoData, Identifier, Serializer>::Serialize(
      std::ostream &_out) const
  {
    Serializer::Serialize(_out);
  }
 
  template <typename Identifier, typename Serializer>
  void Component<NoData, Identifier, Serializer>::Deserialize(
      std::istream &_in)
  {
    Serializer::Deserialize(_in);
  }
}
}
}
}
#endif