types.hpp

Go to the documentation of this file.

//===- include/pstore/serialize/types.hpp -----------------*- mode: C++ -*-===//
//*  _                          *
//* | |_ _   _ _ __   ___  ___  *
//* | __| | | | '_ \ / _ \/ __| *
//* | |_| |_| | |_) |  __/\__ \ *
//*  \__|\__, | .__/ \___||___/ *
//*      |___/|_|               *
//===----------------------------------------------------------------------===//
//
// Part of the pstore project, under the Apache License v2.0 with LLVM Exceptions.
// See https://github.com/SNSystems/pstore/blob/master/LICENSE.txt for license
// information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//











#ifndef PSTORE_SERIALIZE_TYPES_HPP
#define PSTORE_SERIALIZE_TYPES_HPP

#include <algorithm>
#include <cstring>

#include "pstore/serialize/common.hpp"
#include "pstore/support/gsl.hpp"
#include "pstore/support/portab.hpp"

namespace pstore {
    namespace serialize {

        template <typename Archive>
        using archive_result_type = typename std::remove_reference<Archive>::type::result_type;


        template <typename Ty, typename Enable = void>
        struct serializer {
            template <typename Archive>
            static auto write (Archive && archive, Ty const & v) -> archive_result_type<Archive> {
                return v.write (std::forward<Archive> (archive));
            }

            template <typename Archive>
            static void read (Archive && archive, Ty & v) {
                PSTORE_ASSERT (reinterpret_cast<std::uintptr_t> (&v) % alignof (Ty) == 0);
                new (&v) Ty (std::forward<Archive> (archive));
            }
        };


        namespace details {

            struct getn_helper {
            public:
                template <typename Archive, typename Span>
                static void getn (Archive && archive, Span span) {
                    getn_helper::invoke<Archive, Span> (std::forward<Archive> (archive), span,
                                                        nullptr);
                }

            private:
                template <typename Archive, typename Span>
                static void invoke (Archive && archive, Span span, ...) {
                    for (auto & v : span) {
                        archive.get (v);
                    }
                }

                template <typename Archive, typename Span>
                static void
                invoke (Archive && archive, Span span,
                        decltype (&std::remove_reference<Archive>::type::template getn<Span>)) {
                    archive.getn (span);
                }
            };

            struct readn_helper {
            public:
                template <typename Archive, typename SpanType>
                static void readn (Archive && archive, SpanType span) {
                    readn_helper::invoke (std::forward<Archive> (archive), span, nullptr);
                }

            private:
                template <typename Archive, typename SpanType>
                static void invoke (Archive && archive, SpanType span, ...) {
                    for (auto & v : span) {
                        serializer<typename SpanType::element_type>::read (
                            std::forward<Archive> (archive), v);
                    }
                }

                template <typename Archive, typename SpanType>
                static void
                invoke (Archive && archive, SpanType span,
                        decltype (&serializer<typename SpanType::element_type>::template readn<
                                  typename std::remove_reference<Archive>::type, SpanType>)) {
                    serializer<typename SpanType::element_type>::readn (
                        std::forward<Archive> (archive), span);
                }
            };


            //*             _ _              _        _                *
            //* __ __ ___ _(_) |_ ___ _ _   | |_  ___| |_ __  ___ _ _  *
            //* \ V  V / '_| |  _/ -_) ' \  | ' \/ -_) | '_ \/ -_) '_| *
            //*  \_/\_/|_| |_|\__\___|_||_| |_||_\___|_| .__/\___|_|   *
            //*                                        |_|             *

            struct writen_helper {
            public:
                template <typename Archive, typename SpanType>
                static auto writen (Archive && archive, SpanType span)
                    -> archive_result_type<Archive> {
                    return writen_helper::invoke (std::forward<Archive> (archive), span, nullptr);
                }

            private:
                template <typename Archive, typename SpanType>
                static auto invoke (Archive && archive, SpanType span, ...)
                    -> archive_result_type<Archive> {
                    // A simmple implementation of writen() which loops over the span calling
                    // write() for each element.
                    sticky_assign<archive_result_type<Archive>> r;
                    for (auto & v : span) {
                        r = serializer<typename SpanType::element_type>::write (
                            std::forward<Archive> (archive), v);
                    }
                    return r.get ();
                }

                // This overload is called if Archive has a writen() method. SFINAE means that we
                // fall back to the ellipsis overload if it does not.
                template <typename Archive, typename SpanType>
                static auto
                invoke (Archive && archive, SpanType span,
                        decltype (&serializer<typename SpanType::element_type>::template writen<
                                  typename std::remove_reference<Archive>::type, SpanType>))
                    -> archive_result_type<Archive> {
                    return serializer<typename SpanType::element_type>::writen (
                        std::forward<Archive> (archive), span);
                }
            };

        } // namespace details

        template <typename Ty>
        struct serializer<Ty, typename std::enable_if<std::is_trivial<Ty>::value>::type> {
            template <typename Archive>
            static auto write (Archive && archive, Ty const & v) -> archive_result_type<Archive> {
                return archive.put (v);
            }

            template <typename Archive, typename SpanType>
            static auto writen (Archive && archive, SpanType span) -> archive_result_type<Archive> {
                static_assert (std::is_same<typename SpanType::element_type, Ty>::value,
                               "span type does not match the serializer type");
                return archive.putn (span);
            }

            template <typename Archive>
            static void read (Archive && archive, Ty & out) {
                PSTORE_ASSERT (reinterpret_cast<std::uintptr_t> (&out) % alignof (Ty) == 0);
                archive.get (out);
            }

            template <typename Archive, typename Span>
            static void readn (Archive && archive, Span span) {
                static_assert (std::is_same<typename Span::element_type, Ty>::value,
                               "span type does not match the serializer type");
                details::getn_helper::getn (std::forward<Archive> (archive), span);
            }
        };


        template <typename T1, typename T2>
        struct is_compatible : std::false_type {};
        template <typename T>
        struct is_compatible<T, T> : std::true_type {};

        template <typename T1, typename T2>
        struct is_compatible<T1 const, T2> : is_compatible<T1, T2> {};
        template <typename T1, typename T2>
        struct is_compatible<T1, T2 const> : is_compatible<T1, T2> {};
        template <typename T1, typename T2>
        struct is_compatible<T1 const, T2 const> : is_compatible<T1, T2> {};


        // TODO: enable when we're able to switch to C++1z.
        // template <typename T1, typename T2>
        // constexpr bool is_compatible_v = is_compatible<T1, T2>::value;

        template <typename Archive, typename ElementType>
        void read_uninit (Archive && archive, ElementType & uninit) {
            serializer<ElementType>::read (std::forward<Archive> (archive), uninit);
        }
        template <typename Archive, typename ElementType>
        void read_uninit (Archive && archive, gsl::span<ElementType, 1> uninit_span) {
            static_assert (uninit_span.size () == 1, "Expected span to be 1 in specialization");
            serializer<ElementType>::read (std::forward<Archive> (archive), uninit_span[0]);
        }

        template <typename Archive, typename ElementType, std::ptrdiff_t Extent>
        void read_uninit (Archive && archive, gsl::span<ElementType, Extent> uninit_span) {
            details::readn_helper::readn (std::forward<Archive> (archive), uninit_span);
        }


#ifndef NDEBUG
        template <std::ptrdiff_t SpanExtent>
        void flood (gsl::span<std::uint8_t, SpanExtent> sp) noexcept {
            static std::array<std::uint8_t, 4> const deadbeef{{0xDE, 0xAD, 0xBE, 0xEF}};

            auto it = std::begin (sp);
            auto end = std::end (sp);

            for (auto uint32_count = sp.size () / 4U; uint32_count > 0U; --uint32_count) {
                *(it++) = deadbeef[0];
                *(it++) = deadbeef[1];
                *(it++) = deadbeef[2];
                *(it++) = deadbeef[3];
            }

            auto index = std::size_t{0};
            for (; it != end; ++it) {
                *it = deadbeef.at (index);
                index = (index + 1) % deadbeef.size ();
            }
        }
#else
        template <std::ptrdiff_t SpanExtent>
        inline void flood (gsl::span<std::uint8_t, SpanExtent>) noexcept {}
#endif
        template <typename T>
        inline void flood (T * const t) noexcept {
            flood (gsl::make_span (reinterpret_cast<std::uint8_t *> (t), sizeof (T)));
        }


        namespace details {

            // A simplified definition of std::aligned_storage to workaround a bug in Visual Studio
            // 2017 prior to v15.8. Microsoft's fix for that bug introduces a binary
            // incompatibility. In order to avoid introducing that incompatibility to projects using
            // pstore, we have our own version of aligned_storage here. (See the description of
            // Microsoft's "_ENABLE_EXTENDED_ALIGNED_STORAGE" macro.)
            template <std::size_t Len, std::size_t Align>
            struct aligned_storage {
                struct alignas (Align) type {
                    std::uint8_t _[(Len + Align - 1) / Align * Align];
                };

                PSTORE_STATIC_ASSERT (alignof (type) >= Align);
                PSTORE_STATIC_ASSERT (sizeof (type) >= Len);
            };

        } // end namespace details

        //*                  _  *
        //*  _ _ ___ __ _ __| | *
        //* | '_/ -_) _` / _` | *
        //* |_| \___\__,_\__,_| *
        //*                     *
        template <typename Ty, typename Archive>
        Ty read (Archive && archive) {
            using T2 = typename std::remove_const<Ty>::type;
            typename details::aligned_storage<sizeof (T2), alignof (T2)>::type uninit_buffer;
            flood (&uninit_buffer);

            // Deserialize into the uninitialized buffer.
            auto & t2 = reinterpret_cast<T2 &> (uninit_buffer);
            read_uninit (std::forward<Archive> (archive), t2);

            // This object will destroy the remains of the T2 instance in uninit_buffer.
            auto dtor = [] (T2 * p) { p->~T2 (); };
            std::unique_ptr<T2, decltype (dtor)> d (&t2, dtor);
            return std::move (t2);
        }

        template <typename Archive, typename Ty>
        void read (Archive && archive, gsl::span<Ty, 1> span) {
            PSTORE_ASSERT (span.size () == 1U);
            span[0] = read<Ty> (std::forward<Archive> (archive));
        }

        template <typename Archive, typename ElementType, std::ptrdiff_t Extent>
        void read (Archive && archive, gsl::span<ElementType, Extent> span) {
            for (auto & element : span) {
                element.~ElementType ();
            }
            read_uninit (std::forward<Archive> (archive), span);
        }


        //*             _ _        *
        //* __ __ ___ _(_) |_ ___  *
        //* \ V  V / '_| |  _/ -_) *
        //*  \_/\_/|_| |_|\__\___| *
        //*                        *
        template <typename Archive, typename Ty>
        auto write (Archive && archive, Ty const & ty) -> archive_result_type<Archive> {
            return serializer<Ty>::write (std::forward<Archive> (archive), ty);
        }

        template <typename Archive, typename ElementType, std::ptrdiff_t Extent>
        auto write (Archive && archive, gsl::span<ElementType, Extent> sp)
            -> archive_result_type<Archive> {
            return details::writen_helper::writen (std::forward<Archive> (archive), sp);
        }

        template <typename Archive, typename ElementType>
        auto write (Archive && archive, gsl::span<ElementType, 1> sp)
            -> archive_result_type<Archive> {
            static_assert (sp.size () == 1, "Expected size to be 1 in specialization");
            return serializer<ElementType>::write (std::forward<Archive> (archive), sp[0]);
        }

        template <typename Archive, typename Ty, typename... Args>
        auto write (Archive && archive, Ty const & ty, Args const &... args)
            -> archive_result_type<Archive> {
            auto result = write (std::forward<Archive> (archive), ty);
            write (std::forward<Archive> (archive), args...);
            return result;
        }

    } // namespace serialize
} // namespace pstore


namespace pstore {
    namespace serialize {


        template <typename Archive, typename InputIterator>
        void write_range (Archive && archive, InputIterator begin, InputIterator end) {

            auto const distance = std::distance (begin, end);
            PSTORE_ASSERT (distance >= 0);
            write (archive, static_cast<std::size_t> (distance));

            using value_type = typename std::iterator_traits<InputIterator>::value_type;
            std::for_each (begin, end, [&archive] (value_type const & value) {
                write (std::forward<Archive> (archive), value);
            });
        }


        template <typename Ty, typename Archive, typename OutputIterator>
        OutputIterator read_range (Archive && archive, OutputIterator output) {
            auto distance = read<std::size_t> (std::forward<Archive> (archive));
            while (distance-- > 0) {
                *output = read<Ty> (std::forward<Archive> (archive));
                ++output;
            }
            return output;
        }
    } // namespace serialize
} // namespace pstore
#endif // PSTORE_SERIALIZE_TYPES_HPP