SerializationTraits.h

Go to the documentation of this file.

// Copyright 2015 Sensics, Inc.
//
// 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 INCLUDED_SerializationTraits_h_GUID_DF0CDFE0_097F_41B2_2DAE_7D4033D28D43
#define INCLUDED_SerializationTraits_h_GUID_DF0CDFE0_097F_41B2_2DAE_7D4033D28D43

// Internal Includes
#include <osvr/Common/AlignmentPadding.h>
#include <osvr/Common/Endianness.h>
#include <osvr/Common/SerializationTags.h>
#include <osvr/Util/BoolC.h>
#include <osvr/Util/Vec2C.h>
#include <osvr/Util/Vec3C.h>
#include <osvr/Util/TypeSafeId.h>

// Library/third-party includes
#include <boost/call_traits.hpp>
#include <boost/noncopyable.hpp>

// Standard includes
#include <string>
#include <vector>
#include <type_traits>

namespace osvr {
namespace common {

    namespace serialization {

        template <typename Tag>
        using MissingSerializationTraitsForTagOrType =
            std::integral_constant<bool, std::is_same<Tag, Tag>::value>;

        template <typename Tag, typename Dummy = void>
        struct SerializationTraits {
            static_assert(!MissingSerializationTraitsForTagOrType<Tag>::value,
                          "You must implement a SerializationTraits "
                          "specialization for this type/tag, or at least a "
                          "SimpleStructSerialization!");
        };

        template <typename T, typename BufferType,
                  typename Tag = DefaultSerializationTag<T> >
        inline void serializeRaw(BufferType &buf, T const &v,
                                 Tag const &tag = Tag()) {
            SerializationTraits<Tag>::serialize(buf, v, tag);
        }

        template <typename T, typename BufferReaderType,
                  typename Tag = DefaultSerializationTag<T> >
        inline void deserializeRaw(BufferReaderType &reader, T &v,
                                   Tag const &tag = Tag()) {
            SerializationTraits<Tag>::deserialize(reader, v, tag);
        }

        template <typename T, typename Tag = DefaultSerializationTag<T> >
        inline size_t getBufferSpaceRequiredRaw(size_t existingBufferSize,
                                                T const &v,
                                                Tag const &tag = Tag()) {
            return SerializationTraits<Tag>::spaceRequired(existingBufferSize,
                                                           v, tag);
        }

        template <typename T> struct BaseSerializationTraits {
            typedef T type;
            typedef typename boost::call_traits<type>::param_type param_type;
            typedef typename boost::call_traits<type>::value_type value_type;
            typedef typename boost::call_traits<type>::reference reference_type;
        };

        template <typename T> struct SimpleStructSerialization;

        struct SimpleStructSerializationBase {
            typedef void is_specialized;
        };

        template <typename T>
        struct SerializationTraits<
            DefaultSerializationTag<T>,
            typename SimpleStructSerialization<T>::is_specialized>
            : BaseSerializationTraits<T> {

            typedef BaseSerializationTraits<T> Base;
            typedef DefaultSerializationTag<T> tag_type;

            typedef SimpleStructSerialization<T> SimpleSerialization;

            template <typename BufferType>
            static void serialize(BufferType &buf,
                                  typename Base::param_type val,
                                  tag_type const &) {
                StructSerializeFunctor<BufferType> f(buf);
                SimpleSerialization::apply(f, val);
            }

            template <typename BufferReaderType>
            static void deserialize(BufferReaderType &buf,
                                    typename Base::reference_type val,
                                    tag_type const &) {
                StructDeserializeFunctor<BufferReaderType> f(buf);
                SimpleSerialization::apply(f, val);
            }

            static size_t spaceRequired(size_t existingBytes,
                                        typename Base::param_type val,
                                        tag_type const &) {
                StructSpaceRequirementFunctor f(existingBytes);
                SimpleSerialization::apply(f, val);
                return f.get();
            }

          private:
            template <typename BufferType>
            class StructSerializeFunctor : boost::noncopyable {
              public:
                StructSerializeFunctor(BufferType &buf) : m_buf(buf) {}

                template <typename U> void operator()(U const &val) {
                    serializeRaw(m_buf, val);
                }

                template <typename U, typename Tag>
                void operator()(U const &val, Tag &t) {
                    serializeRaw(m_buf, val, t);
                }

              private:
                BufferType &m_buf;
            };

            template <typename BufferReaderType>
            class StructDeserializeFunctor : boost::noncopyable {
              public:
                StructDeserializeFunctor(BufferReaderType &buf) : m_buf(buf) {}

                template <typename U> void operator()(U &val) {
                    deserializeRaw(m_buf, val);
                }

                template <typename U, typename Tag>
                void operator()(U &val, Tag &t) {
                    deserializeRaw(m_buf, val, t);
                }

              private:
                BufferReaderType &m_buf;
            };

            class StructSpaceRequirementFunctor : boost::noncopyable {
              public:
                StructSpaceRequirementFunctor(size_t existingBytes)
                    : m_initialBytes(existingBytes), m_bytes(existingBytes) {}

                template <typename U> void operator()(U const &val) {
                    m_bytes += getBufferSpaceRequiredRaw(m_bytes, val);
                }

                template <typename U, typename Tag>
                void operator()(U const &val, Tag &t) {
                    m_bytes += getBufferSpaceRequiredRaw(m_bytes, val, t);
                }

                size_t get() const { return m_bytes - m_initialBytes; }

              private:
                size_t m_initialBytes;
                size_t m_bytes;
            };
        };

        template <typename T, size_t Alignment>
        struct ArithmeticSerializationTraits : BaseSerializationTraits<T> {
            typedef BaseSerializationTraits<T> Base;
            typedef T type;
            template <typename BufferType, typename Tag>
            static void serialize(BufferType &buf,
                                  typename Base::param_type val, Tag const &) {
                buf.appendAligned(hton(val), Alignment);
            }

            template <typename BufferReaderType, typename Tag>
            static void deserialize(BufferReaderType &buf,
                                    typename Base::reference_type val,
                                    Tag const &) {
                buf.readAligned(val, Alignment);
                val = ntoh(val);
            }

            template <typename Tag>
            static size_t spaceRequired(size_t existingBytes,
                                        typename Base::param_type,
                                        Tag const &) {
                return computeAlignmentPadding(Alignment, existingBytes) +
                       sizeof(T);
            }
        };

        template <typename T>
        struct SerializationTraits<
            DefaultSerializationTag<T>,
            typename std::enable_if<std::is_arithmetic<T>::value &&
                                    !std::is_same<bool, T>::value>::type>
            : ArithmeticSerializationTraits<T, sizeof(T)> {

            static_assert(std::alignment_of<T>::value == sizeof(T),
                          "Arithmetic types are assumed to have an alignment "
                          "equal to their size");
        };

        template <>
        struct SerializationTraits<DefaultSerializationTag<bool>, void>
            : BaseSerializationTraits<bool> {

            typedef BaseSerializationTraits<bool> Base;
            typedef DefaultSerializationTag<bool> tag_type;

            template <typename BufferType>
            static void serialize(BufferType &buf, Base::param_type val,
                                  tag_type const &) {
                serializeRaw(
                    buf, static_cast<OSVR_CBool>(val ? OSVR_TRUE : OSVR_FALSE));
            }
            template <typename BufferReaderType>
            static void deserialize(BufferReaderType &reader,
                                    Base::reference_type val,
                                    tag_type const &) {
                OSVR_CBool cVal;
                deserializeRaw(reader, cVal);
                val = (cVal == OSVR_TRUE);
            }
        };
        template <typename EnumType, typename IntegerType>
        struct SerializationTraits<EnumAsIntegerTag<EnumType, IntegerType>,
                                   void> : BaseSerializationTraits<EnumType> {
            typedef BaseSerializationTraits<EnumType> Base;
            typedef EnumAsIntegerTag<EnumType, IntegerType> tag_type;

            template <typename BufferType>
            static void serialize(BufferType &buf,
                                  typename Base::param_type val,
                                  tag_type const &) {
                serializeRaw(buf, static_cast<IntegerType>(val));
            }

            template <typename BufferReaderType>
            static void deserialize(BufferReaderType &reader,
                                    typename Base::reference_type val,
                                    tag_type const &) {
                IntegerType intVal;
                deserializeRaw(reader, intVal);
                val = static_cast<EnumType>(intVal);
            }
        };

        template <>
        struct SerializationTraits<DefaultSerializationTag<std::string>, void>
            : BaseSerializationTraits<std::string> {

            typedef BaseSerializationTraits<std::string> Base;
            typedef DefaultSerializationTag<std::string> tag_type;

            typedef uint32_t length_type;

            template <typename BufferType>
            static void serialize(BufferType &buf, Base::param_type val,
                                  tag_type const &) {
                length_type len = val.length();
                serializeRaw(buf, len);
                buf.append(val.c_str(), len);
            }

            template <typename BufferReaderType>
            static void deserialize(BufferReaderType &reader,
                                    Base::reference_type val,
                                    tag_type const &) {
                length_type len;
                deserializeRaw(reader, len);
                auto iter = reader.readBytes(len);
                val.assign(iter, iter + len);
            }

            static size_t spaceRequired(size_t existingBytes,
                                        Base::param_type val,
                                        tag_type const &) {
                return getBufferSpaceRequiredRaw(existingBytes, length_type()) +
                       val.length();
            }
        };

        template <>
        struct SerializationTraits<StringOnlyMessageTag, void>
            : BaseSerializationTraits<std::string> {

            typedef BaseSerializationTraits<std::string> Base;
            typedef StringOnlyMessageTag tag_type;

            template <typename BufferType>
            static void serialize(BufferType &buf, Base::param_type val,
                                  tag_type const &) {
                buf.append(val.c_str(), val.length());
            }

            template <typename BufferReaderType>
            static void deserialize(BufferReaderType &reader,
                                    Base::reference_type val,
                                    tag_type const &) {
                auto len = reader.bytesRemaining();
                auto iter = reader.readBytes(len);
                val.assign(iter, iter + len);
            }

            static size_t spaceRequired(size_t, Base::param_type val,
                                        tag_type const &) {
                return val.length();
            }
        };

        template <> struct SerializationTraits<AlignedDataBufferTag, void> {
            typedef AlignedDataBufferTag tag_type;

            template <typename BufferType, typename DataType>
            static void serialize(BufferType &buf, DataType const *val,
                                  tag_type const &tag) {
                auto dataPtr =
                    reinterpret_cast<typename BufferType::ElementType const *>(
                        val);
                buf.appendAligned(dataPtr, tag.length(), tag.alignment());
            }

            template <typename BufferReaderType, typename DataType>
            static void deserialize(BufferReaderType &reader, DataType *val,
                                    tag_type const &tag) {
                auto len = tag.length();
                auto iter = reader.readBytesAligned(len, tag.alignment());
                std::copy(iter, iter + len, val);
            }

            template <typename DataType>
            static size_t spaceRequired(size_t existingBytes, DataType *,
                                        tag_type const &tag) {
                return computeAlignmentPadding(tag.alignment(), existingBytes) +
                       tag.length();
            }
        };

        template <typename ValueType>
        struct SerializationTraits<
            DefaultSerializationTag<std::vector<ValueType>>, void>
            : BaseSerializationTraits<std::vector<ValueType>> {
            using value_type = std::vector<ValueType>;
            using param_type = value_type const &;
            using reference_type = value_type &;
            typedef BaseSerializationTraits<std::vector<ValueType>> Base;
            typedef DefaultSerializationTag<std::vector<ValueType>> tag_type;

            template <typename BufferType>
            static void serialize(BufferType &buf, param_type val,
                                  tag_type const &) {
                serializeRaw(buf, static_cast<uint32_t>(val.size()));
                for (auto &elt : val) {
                    serializeRaw(buf, elt);
                }
            }

            template <typename BufferReaderType>
            static void deserialize(BufferReaderType &buf, reference_type val,
                                    tag_type const &) {
                uint32_t n;
                deserializeRaw(buf, n);
                val.clear();
                val.reserve(n);
                for (uint32_t i = 0; i < n; ++i) {
                    ValueType elt;
                    deserializeRaw(buf, elt);
                    val.push_back(elt);
                }
            }

            static size_t spaceRequired(size_t existingBytes, param_type val,
                                        tag_type const &) {
                size_t bytes = existingBytes;
                bytes += getBufferSpaceRequiredRaw(
                    bytes, static_cast<uint32_t>(val.size()));
                for (auto &elt : val) {
                    bytes += getBufferSpaceRequiredRaw(bytes, elt);
                }
                return bytes - existingBytes;
            }
        };

        template <>
        struct SimpleStructSerialization<OSVR_Vec2>
            : SimpleStructSerializationBase {
            template <typename F, typename T> static void apply(F &f, T &val) {
                f(val.data[0]);
                f(val.data[1]);
            }
        };

        template <>
        struct SimpleStructSerialization<OSVR_Vec3>
            : SimpleStructSerializationBase {
            template <typename F, typename T> static void apply(F &f, T &val) {
                f(val.data[0]);
                f(val.data[1]);
                f(val.data[2]);
            }
        };

        template <typename Tag>
        struct SimpleStructSerialization<util::TypeSafeId<Tag>>
            : SimpleStructSerializationBase {
            template <typename F, typename T> static void apply(F &f, T &val) {
                f(val.value());
            }
        };

    } // namespace serialization

} // namespace common
} // namespace osvr
#endif // INCLUDED_SerializationTraits_h_GUID_DF0CDFE0_097F_41B2_2DAE_7D4033D28D43