Serialization.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_Serialization_h_GUID_339B4851_CA90_41A6_E1CC_4F94A18614AC
#define INCLUDED_Serialization_h_GUID_339B4851_CA90_41A6_E1CC_4F94A18614AC

// Internal Includes
#include <osvr/Common/SerializationTraits.h>
#include <osvr/Common/BufferTraits.h>

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

// Standard includes
#include <string>

namespace osvr {
namespace common {

    namespace serialization {

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

            template <typename T> void operator()(T const &v) {
                apply<T, DefaultSerializationTag<T> >(v);
            }

            template <typename Tag, typename T>
            void operator()(T const &v, Tag const &tag = Tag()) {
                apply<T, Tag>(v, tag);
            }

            std::true_type isSerialize() const { return std::true_type(); }

            std::false_type isDeserialize() const { return std::false_type(); }

          private:
            template <typename T, typename Tag>
            void apply(typename boost::call_traits<T>::param_type v,
                       Tag const &tag = Tag()) {
                serializeRaw(m_buf, v, tag);
            }
            BufferType &m_buf;
        };

        template <typename BufferReaderType>
        class DeserializeFunctor : boost::noncopyable {
          public:
            DeserializeFunctor(BufferReaderType &reader) : m_reader(reader) {}

            template <typename T> void operator()(T &v) {
                apply<T, DefaultSerializationTag<T> >(v);
            }

            template <typename Tag, typename T>
            void operator()(T &v, Tag const &tag = Tag()) {
                apply<T, Tag>(v, tag);
            }

            template <typename Tag, typename T>
            void operator()(T *v, Tag const &tag = Tag()) {
                apply<T *, Tag>(v, tag);
            }

            std::false_type isSerialize() const { return std::false_type(); }
            std::true_type isDeserialize() const { return std::true_type(); }

          private:
            template <typename T, typename Tag>
            void apply(typename boost::call_traits<T>::reference v,
                       Tag const &tag = Tag()) {
                deserializeRaw(m_reader, v, tag);
            }
            BufferReaderType &m_reader;
        };

    } // namespace serialization

    template <typename BufferType, typename MessageClass>
    void serialize(BufferType &buf, MessageClass &msg) {
        static_assert(is_buffer<BufferType>::value,
                      "First argument must be a buffer object");
        serialization::SerializeFunctor<BufferType> functor(buf);
        msg.processMessage(functor);
    }
    template <typename BufferReaderType, typename MessageClass>
    void deserialize(BufferReaderType &reader, MessageClass &msg) {
        static_assert(is_buffer_reader<BufferReaderType>::value,
                      "First argument must be a buffer reader object");
        serialization::DeserializeFunctor<BufferReaderType> functor(reader);
        msg.processMessage(functor);
    }
} // namespace common
} // namespace osvr

#endif // INCLUDED_Serialization_h_GUID_339B4851_CA90_41A6_E1CC_4F94A18614AC