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

#include <cstdint>
#include <memory>
#include <string>
#include <sstream>
#include <utility>

#include <ignition/common/Console.hh>

#include <ignition/gazebo/config.hh>
#include <ignition/gazebo/Export.hh>
#include <ignition/gazebo/Types.hh>

template<typename T> struct IsSharedPtr:
  std::false_type
{
};

template<typename T> struct IsSharedPtr<std::shared_ptr<T>>:
  std::true_type
{
};

template<typename DataType, typename Identifier,
  typename Stream =
  decltype(std::declval<std::ostream &>() << std::declval<DataType const &>()),
  typename std::enable_if<
    !IsSharedPtr<DataType>::value &&
    std::is_convertible<Stream, std::ostream &>::value,
    int>::type = 0>
std::ostream &toStream(std::ostream &_out, DataType const &_data)
{
  _out << _data;
  return _out;
}

template<typename DataType, typename Identifier,
  typename Stream =
  decltype(std::declval<std::ostream &>() << std::declval<
    typename DataType::element_type const &>()),
  typename std::enable_if<
    IsSharedPtr<DataType>::value &&
    std::is_convertible<Stream, std::ostream &>::value,
    int>::type = 0>
std::ostream &toStream(std::ostream &_out, DataType const &_data)
{
  _out << *_data;
  return _out;
}

template<typename DataType, typename Identifier, typename... Ignored>
std::ostream &toStream(std::ostream &_out, DataType const &,
    Ignored const &..., ...)
{
  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;
}

template<typename DataType, typename Identifier,
  typename Stream =
  decltype(std::declval<std::istream &>() >> std::declval<DataType &>()),
  typename std::enable_if<
      !IsSharedPtr<DataType>::value &&
      std::is_convertible<Stream, std::istream &>::value,
      int>::type = 0>
std::istream &fromStream(std::istream &_in, DataType &_data)
{
  _in >> _data;
  return _in;
}

template<typename DataType, typename Identifier,
  typename Stream =
  decltype(std::declval<std::istream &>() >> std::declval<
    typename DataType::element_type &>()),
  typename std::enable_if<
    IsSharedPtr<DataType>::value &&
    std::is_convertible<Stream, std::istream &>::value,
    int>::type = 0>
std::istream &fromStream(std::istream &_in, DataType &_data)
{
  _in >> *_data;
  return _in;
}

template<typename DataType, typename Identifier, typename... Ignored>
std::istream &fromStream(std::istream &_in, DataType const &,
    Ignored const &..., ...)
{
  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 ignition
{
namespace gazebo
{
// Inline bracket to help doxygen filtering.
inline namespace IGNITION_GAZEBO_VERSION_NAMESPACE {
namespace components
{
  // Forward declarations.
  template<typename DataType> class ComponentPrivate;

  using NoData = std::add_lvalue_reference<void>;

  class BaseComponent
  {
    public: BaseComponent() = default;

    public: virtual ~BaseComponent() = default;

    public: friend std::ostream &operator<<(
                std::ostream &_out, const BaseComponent &_component)
    {
      _component.Serialize(_out);
      return _out;
    }

    public: friend std::istream &operator>>(
                std::istream &_in, BaseComponent &_component)
    {
      _component.Deserialize(_in);
      return _in;
    }

    protected: virtual void Serialize(std::ostream &/*_out*/) const
    {
      ignwarn << "Trying to serialize copmponent which hasn't implemented "
              << "the `Serialize` function. Component will not be serialized."
              << std::endl;
    };

    protected: virtual void Deserialize(std::istream &/*_in*/)
    {
      ignwarn << "Trying to deserialize copmponent which hasn't implemented "
              << "the `Deserialize` function. Component will not be "
              << "deserialized." << std::endl;
    };

    public: virtual ComponentTypeId TypeId() const = 0;
  };

  template <typename DataType, typename Identifier>
  class Component: public BaseComponent
  {
    public: Component();

    public: explicit Component(const DataType &_data);

    public: explicit Component(DataType &&_data);

    public: Component(const Component &_component);

    public: Component(Component &&_component) noexcept = default;

    public: ~Component() override = default;

    public: Component &operator=(
                Component &&_component) noexcept = default;

    public: Component &operator=(const Component &_component);

    public: bool operator==(const Component &_component) const;

    public: bool operator!=(const Component &_component) const;

    // 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: const DataType &Data() const;

    private: std::unique_ptr<ComponentPrivate<DataType>> dataPtr;

    public: inline static ComponentTypeId typeId{0};
  };

  template <typename Identifier>
  class Component<NoData, Identifier> : public BaseComponent
  {
    public: bool operator==(const Component<NoData, Identifier> &) const;

    public: bool operator!=(const Component<NoData, Identifier> &) const;

    public: friend std::ostream &operator<<(std::ostream &_out,
        const Component<NoData, Identifier> &)
    {
      return _out;
    }

    public: friend std::istream &operator>>(std::istream &_in,
        Component<NoData, Identifier> &)
    {
      return _in;
    }

    // Documentation inherited
    public: uint64_t TypeId() const override;

    public: inline static ComponentTypeId typeId{0};
  };

  template <typename DataType>
  class ComponentPrivate
  {
    public: ComponentPrivate() = default;

    public: explicit ComponentPrivate(DataType _data)
            : data(std::move(_data))
    {
    }

    public: DataType data;
  };

  template <typename DataType, typename Identifier>
  Component<DataType, Identifier>::Component()
    : dataPtr(std::make_unique<ComponentPrivate<DataType>>())
  {
  }

  template <typename DataType, typename Identifier>
  Component<DataType, Identifier>::Component(const DataType &_data)
    : dataPtr(std::make_unique<ComponentPrivate<DataType>>(_data))
  {
  }

  template <typename DataType, typename Identifier>
  Component<DataType, Identifier>::Component(DataType &&_data)
    : dataPtr(std::make_unique<ComponentPrivate<DataType>>(std::move(_data)))
  {
  }

  template <typename DataType, typename Identifier>
  Component<DataType, Identifier>::Component(
      const Component<DataType, Identifier> &_component)
      : dataPtr(std::make_unique<ComponentPrivate<DataType>>(
            _component.Data()))
  {
  }

  template <typename DataType, typename Identifier>
  DataType &Component<DataType, Identifier>::Data()
  {
    return this->dataPtr->data;
  }

  template <typename DataType, typename Identifier>
  const DataType &Component<DataType, Identifier>::Data() const
  {
    return this->dataPtr->data;
  }

  template <typename DataType, typename Identifier>
  Component<DataType, Identifier> &Component<DataType, Identifier>::
  operator=(const Component<DataType, Identifier> &_component)
  {
    this->dataPtr->data = _component.Data();
    return *this;
  }

  template <typename DataType, typename Identifier>
  bool Component<DataType, Identifier>::
  operator==(const Component<DataType, Identifier> &_component) const
  {
    return this->dataPtr->data == _component.Data();
  }

  template <typename DataType, typename Identifier>
  bool Component<DataType, Identifier>::
  operator!=(const Component<DataType, Identifier> &_component) const
  {
    return this->dataPtr->data != _component.Data();
  }

  template <typename DataType, typename Identifier>
  void Component<DataType, Identifier>::Serialize(std::ostream &_out) const
  {
    toStream<DataType, Identifier>(_out, this->Data());
  }

  template <typename DataType, typename Identifier>
  void Component<DataType, Identifier>::Deserialize(std::istream &_in)
  {
    fromStream<DataType, Identifier>(_in, this->Data());
  }

  template <typename DataType, typename Identifier>
  ComponentTypeId Component<DataType, Identifier>::TypeId() const
  {
    return typeId;
  }

  template <typename Identifier>
  bool Component<NoData, Identifier>::operator==(
      const Component<NoData, Identifier> &) const
  {
    return true;
  }

  template <typename Identifier>
  bool Component<NoData, Identifier>::operator!=(
      const Component<NoData, Identifier> &) const
  {
    return false;
  }

  template <typename Identifier>
  ComponentTypeId Component<NoData, Identifier>::TypeId() const
  {
    return typeId;
  }
}
}
}
}
#endif