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>

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
    {
      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*/)
    {
      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;
  };

  template <typename DataType, typename Identifier,
            typename Serializer = serializers::DefaultSerializer<DataType>>
  class Component : public BaseComponent
  {
    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: 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};

    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> &) const;

    public: bool operator!=(const Component<NoData, Identifier,
                            Serializer> &) 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: inline static ComponentTypeId typeId{0};

    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>
  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>
  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