standard_types.hpp

Go to the documentation of this file.

//===- include/pstore/serialize/standard_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_STANDARD_TYPES_HPP
#define PSTORE_SERIALIZE_STANDARD_TYPES_HPP

#include <atomic>
#include <map>
#include <set>

#include "pstore/serialize/types.hpp"
#include "pstore/support/varint.hpp"

namespace pstore {
    namespace serialize {

        struct string_helper {
            template <typename Archive, typename StringType>
            static auto write (Archive && archive, StringType const & str)
                -> archive_result_type<Archive> {
                auto const length = str.length ();

                // Encode the string length as a variable-length integer.
                std::array<std::uint8_t, varint::max_output_length> encoded_length;
                auto first = std::begin (encoded_length);
                auto last = varint::encode (length, first);
                auto length_bytes = std::distance (first, last);
                PSTORE_ASSERT (length_bytes > 0 &&
                               static_cast<std::size_t> (length_bytes) <= encoded_length.size ());
                if (length_bytes == 1) {
                    *(last++) = 0;
                }
                // Emit the string length.
                auto const resl = serialize::write (std::forward<Archive> (archive),
                                                    gsl::make_span (&(*first), &(*last)));

                // Emit the string body.
                serialize::write (std::forward<Archive> (archive), gsl::make_span (str));
                return resl;
            }

            template <typename Archive>
            static std::size_t read_length (Archive && archive) {
                std::array<std::uint8_t, varint::max_output_length> encoded_length{{0}};
                // First read the two initial bytes. These contain the variable length value
                // but might not be enough for the entire value.
                static_assert (varint::max_output_length >= 2,
                               "maximum encoded varint length must be >= 2");
                serialize::read_uninit (std::forward<Archive> (archive),
                                        gsl::make_span (encoded_length.data (), 2));

                auto const varint_length = varint::decode_size (std::begin (encoded_length));
                PSTORE_ASSERT (varint_length > 0);
                // Was that initial read of 2 bytes enough? If not get the rest of the
                // length value.
                if (varint_length > 2) {
                    PSTORE_ASSERT (varint_length <= encoded_length.size ());
                    serialize::read_uninit (
                        std::forward<Archive> (archive),
                        gsl::make_span (encoded_length.data () + 2, varint_length - 2));
                }

                return varint::decode (encoded_length.data (), varint_length);
            }
        };

        template <>
        struct serializer<std::string> {
            using value_type = std::string;

            template <typename Archive>
            static auto write (Archive && archive, value_type const & str)
                -> archive_result_type<Archive> {
                return string_helper::write (std::forward<Archive> (archive), str);
            }

            template <typename Archive>
            static void read (Archive && archive, value_type & str) {
                // Read the body of the string.
                new (&str) value_type;

                // Deleter will ensure that the string is destroyed on exit if an exception is
                // raised here.
                auto dtor = [] (value_type * const p) {
                    using string = std::string;
                    p->~string ();
                };
                std::unique_ptr<value_type, decltype (dtor)> deleter (&str, dtor);

                auto const length = string_helper::read_length (std::forward<Archive> (archive));
                str.resize (length);

#ifdef PSTORE_HAVE_NON_CONST_STD_STRING_DATA
                char * const data = str.data ();
#else
                // TODO: this is technically undefined behaviour. Remove once we've got access to
                // the C++17 library on our platforms.
                auto * const data = const_cast<char *> (str.data ());
#endif
                // Now read the body of the string.
                serialize::read_uninit (
                    std::forward<Archive> (archive),
                    gsl::make_span (data, static_cast<std::ptrdiff_t> (length)));

                // Release ownership from the deleter so that the initialized object is returned to
                // the caller.
                deleter.release ();
            }
        };

        template <>
        struct serializer<std::string const> {
            using value_type = std::string;
            template <typename Archive>
            static auto write (Archive && archive, value_type const & str)
                -> archive_result_type<Archive> {
                return serializer::write (std::forward<Archive> (archive), str);
            }
            template <typename Archive>
            static void read (Archive && archive, value_type & str) {
                serialize::read_uninit (std::forward<Archive> (archive), str);
            }
        };

        template <typename Container>
        struct container_archive_helper {


            template <typename Archive>
            static auto write (Archive && archive, Container const & ty)
                -> archive_result_type<Archive> {
                // TODO: size_t is not a fixed-size type. Prefer uintXX_t.
                auto result =
                    serialize::write (std::forward<Archive> (archive), std::size_t{ty.size ()});
                for (typename Container::value_type const & m : ty) {
                    serialize::write (std::forward<Archive> (archive), m);
                }
                return result;
            }

            using insert_callback = std::function<void (typename Container::value_type const &)>;


            template <typename Archive>
            static void read (Archive && archive, insert_callback inserter) {
                Container result;
                // TODO: size_t is not a fixed-size type. Prefer uintXX_t.
                auto const num_members =
                    serialize::read<std::size_t> (std::forward<Archive> (archive));
                auto num_read = std::size_t{0};
                for (; num_read < num_members; ++num_read) {
                    inserter (serialize::read<typename Container::value_type> (
                        std::forward<Archive> (archive)));
                }
            }
        };


        template <typename T>
        struct serializer<std::atomic<T>> {
            using value_type = std::atomic<T>;

            template <typename Archive>
            static auto write (Archive && archive, value_type const & value)
                -> archive_result_type<Archive> {
                return serialize::write (std::forward<Archive> (archive), value.load ());
            }

            template <typename Archive>
            static void read (Archive && archive, value_type & value) {
                serialize::read_uninit<T> (std::forward<Archive> (archive), value);
            }
        };


        template <typename T, typename U>
        struct serializer<std::pair<T, U>> {
            using value_type = std::pair<T, U>;

            template <typename Archive>
            static auto write (Archive && archive, value_type const & value)
                -> archive_result_type<Archive> {

                auto const result = serialize::write (std::forward<Archive> (archive), value.first);
                serialize::write (std::forward<Archive> (archive), value.second);
                return result;
            }

            template <typename Archive>
            static void read (Archive && archive, value_type & value) {
                serialize::read_uninit (std::forward<Archive> (archive), value.first);
                serialize::read_uninit (std::forward<Archive> (archive), value.second);
            }
        };
    } // namespace serialize
} // namespace pstore
#endif // PSTORE_SERIALIZE_STANDARD_TYPES_HPP