archive.hpp

Go to the documentation of this file.

//===- include/pstore/serialize/archive.hpp ---------------*- mode: C++ -*-===//
//*                 _     _            *
//*   __ _ _ __ ___| |__ (_)_   _____  *
//*  / _` | '__/ __| '_ \| \ \ / / _ \ *
//* | (_| | | | (__| | | | |\ V /  __/ *
//*  \__,_|_|  \___|_| |_|_| \_/ \___| *
//*                                    *
//===----------------------------------------------------------------------===//
//
// 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_ARCHIVE_HPP
#define PSTORE_SERIALIZE_ARCHIVE_HPP

#include <cstring>

#include "pstore/serialize/common.hpp"
#include "pstore/support/error.hpp"

namespace pstore {
    namespace serialize {
        namespace archive {

            template <typename T>
            auto unsigned_cast (T const & t) -> typename std::make_unsigned<T>::type {
                using unsigned_type = typename std::make_unsigned<T>::type;
                PSTORE_ASSERT (t >= 0);
                return static_cast<unsigned_type> (t);
            }

            struct void_type {};


            // *****************************
            // *   w r i t e r _ b a s e   *
            // *****************************

            template <typename WriterPolicy>
            class writer_base {
            public:
                using policy_type = WriterPolicy;
                using result_type = typename policy_type::result_type;

                writer_base (writer_base const &) = delete;
                writer_base (writer_base &&) noexcept = default;

                virtual ~writer_base () noexcept {
                    no_ex_escape ([this] () { this->flush (); });
                }

                writer_base & operator= (writer_base &&) noexcept = default;
                writer_base & operator= (writer_base const &) = delete;


                template <typename Ty>
                auto put (Ty const & t) -> result_type {
                    static_assert (std::is_standard_layout<Ty>::value,
                                   "writer_base can only write standard-layout types!");
                    PSTORE_ASSERT (!flushed_);
                    result_type r = policy_.put (t);
                    bytes_consumed_ += sizeof (t);
                    return r;
                }

                template <typename Span>
                auto putn (Span sp) -> result_type {
                    using element_type = typename Span::element_type;
                    static_assert (std::is_standard_layout<element_type>::value,
                                   "writer_base can only write standard-layout types!");
                    PSTORE_ASSERT (!flushed_);
                    auto r = putn_helper::template putn<Span> (policy_, sp);
                    bytes_consumed_ += unsigned_cast (sp.size_bytes ());
                    return r;
                }

                void flush () {
                    if (!flushed_) {
                        policy_.flush ();
                        flushed_ = true;
                    }
                }

                std::size_t bytes_consumed () const { return bytes_consumed_; }

                std::size_t bytes_produced () const {
                    return bytes_produced_helper (*this).get (policy_, nullptr);
                }

                WriterPolicy & writer_policy () noexcept { return policy_; }
                WriterPolicy const & writer_policy () const noexcept { return policy_; }

            protected:
                explicit writer_base (WriterPolicy policy = WriterPolicy ())
                        : policy_{std::move (policy)} {}

            private:
                class bytes_produced_helper {
                public:
                    explicit bytes_produced_helper (writer_base const & writer)
                            : writer_{writer} {}
                    // (This is a varargs function so that it is considered last in template
                    // resolution.)
                    template <typename Policy>
                    std::size_t get (Policy const & /*policy*/, ...) { // NOLINT(cert-dcl50-cpp)
                        return writer_.bytes_consumed ();
                    }
                    template <typename Policy>
                    std::size_t get (Policy const & policy, decltype (&Policy::bytes_produced)) {
                        return policy.bytes_produced ();
                    }

                private:
                    writer_base const & writer_;
                };

                struct putn_helper {
                public:
                    using result_type = typename policy_type::result_type;

                    template <typename Span>
                    static auto putn (WriterPolicy & policy, Span span) -> result_type {
                        return invoke (policy, span, nullptr);
                    }

                private:
                    // This overload is always in the set of overloads but a function with
                    // ellipsis parameter has the lowest ranking for overload resolution.
                    template <typename P, typename Span>
                    static auto invoke (P & policy, Span span, ...) // NOLINT(cert-dcl50-cpp)
                        -> result_type {
                        sticky_assign<result_type> r;
                        for (auto & v : span) {
                            r = policy.put (v);
                        }
                        return r.get ();
                    }

                    // This overload is called if P has a putn<>() method. SFINAE means that we fall
                    // back to the ellipsis overload if it does not.
                    template <typename P, typename Span>
                    static auto invoke (P & policy, Span span, decltype (&P::template putn<Span>))
                        -> result_type {
                        return policy.putn (span);
                    }
                };

                WriterPolicy policy_;
                std::size_t bytes_consumed_ = 0U;
                bool flushed_{false}; 
            };


            namespace details {
                class vector_writer_policy {
                public:
                    using result_type = std::size_t;
                    using container = std::vector<std::uint8_t>;
                    using const_iterator = container::const_iterator;

                    explicit vector_writer_policy (container & bytes) noexcept
                            : bytes_ (bytes) {}

                    template <typename Ty>
                    auto put (Ty const & t) -> result_type {
                        auto const old_size = bytes_.size ();
                        auto const * const first = reinterpret_cast<std::uint8_t const *> (&t);
                        std::copy (first, first + sizeof (Ty), std::back_inserter (bytes_));
                        return old_size;
                    }

                    template <typename SpanType>
                    auto putn (SpanType sp) -> result_type {
                        auto const old_size = bytes_.size ();
                        auto const * const first = reinterpret_cast<std::uint8_t const *> (sp.data ());
                        std::copy (first, first + sp.size_bytes (), std::back_inserter (bytes_));
                        return old_size;
                    }

                    std::size_t size () const noexcept { return bytes_.size (); }

                    void flush () noexcept {}

                    container::const_iterator begin () const { return std::begin (bytes_); }
                    container::const_iterator end () const { return std::end (bytes_); }

                private:
                    container & bytes_; 
                };
            } // namespace details

            // *******************************
            // *  v e c t o r _ w r i t e r  *
            // *******************************


            class vector_writer final : public writer_base<details::vector_writer_policy> {
            public:
                explicit vector_writer (std::vector<std::uint8_t> & container)
                        : writer_base<details::vector_writer_policy> (
                              details::vector_writer_policy{container}) {}
                vector_writer (vector_writer const &) = delete;
                vector_writer (vector_writer &&) = delete;

                ~vector_writer () noexcept override;

                vector_writer & operator= (vector_writer const &) = delete;
                vector_writer & operator= (vector_writer &&) = delete;

                using container = policy_type::container;
                using const_iterator = policy_type::const_iterator;

                const_iterator begin () const { return writer_policy ().begin (); }
                const_iterator end () const { return writer_policy ().end (); }
            };



            std::ostream & operator<< (std::ostream & os, vector_writer const & writer);


            // *********************************
            // *   b u f f e r _ w r i t e r   *
            // *********************************

            namespace details {
                class buffer_writer_policy {
                public:
                    using result_type = void *;

                    buffer_writer_policy (void * const first, void * const last) noexcept
                            : begin_ (static_cast<std::uint8_t *> (first))
#ifndef NDEBUG
                            , end_ (static_cast<std::uint8_t *> (last))
#endif
                            , it_ (static_cast<std::uint8_t *> (first)) {

                        (void) last;
                        PSTORE_ASSERT (end_ >= it_);
                    }

                    template <typename Ty>
                    auto put (Ty const & v) -> result_type {
                        auto const size = sizeof (v);
                        PSTORE_ASSERT (it_ + size <= end_);
                        auto const result = it_;
                        std::memcpy (it_, &v, size);
                        it_ += size;
                        PSTORE_ASSERT (it_ <= end_);
                        return result;
                    }

                    std::size_t size () const noexcept {
                        PSTORE_ASSERT (it_ >= begin_);
                        static_assert (sizeof (std::size_t) >= sizeof (std::ptrdiff_t),
                                       "sizeof size_t should be at least sizeof ptrdiff_t");
                        return static_cast<std::size_t> (it_ - begin_);
                    }

                    void flush () noexcept {}

                    using const_iterator = std::uint8_t const *;

                    const_iterator begin () const noexcept { return begin_; }
                    const_iterator end () const noexcept { return it_; }

                private:
                    std::uint8_t * begin_;
#ifndef NDEBUG
                    std::uint8_t * end_;
#endif
                    std::uint8_t * it_;
                };
            } // namespace details

            class buffer_writer final : public writer_base<details::buffer_writer_policy> {
            public:
                buffer_writer (void * const first, void * const last)
                        : writer_base<policy_type> (policy_type{first, last}) {}
                buffer_writer (buffer_writer const &) = delete;
                buffer_writer (buffer_writer &&) = delete;

                buffer_writer (void * const first, std::size_t const size)
                        : buffer_writer (static_cast<std::uint8_t *> (first),
                                         static_cast<std::uint8_t *> (first) + size) {}

                template <typename T>
                explicit buffer_writer (T * t)
                        : buffer_writer (t, sizeof (T)) {}

                ~buffer_writer () noexcept override;

                buffer_writer & operator= (buffer_writer const &) = delete;
                buffer_writer & operator= (buffer_writer &&) = delete;

                using const_iterator = policy_type::const_iterator;

                const_iterator begin () const { return writer_policy ().begin (); }
                const_iterator end () const { return writer_policy ().end (); }
            };


            std::ostream & operator<< (std::ostream & os, buffer_writer const & writer);


            // ***************
            // *   n u l l   *
            // ***************

            namespace details {

                class null_policy {
                public:
                    using result_type = void_type;
                    template <typename Ty>
                    auto put (Ty const &) -> result_type {
                        return {};
                    }
                    template <typename SpanType>
                    auto putn (SpanType) -> result_type {
                        return {};
                    }

                    void flush () noexcept {}
                };

            } // end namespace details

            class null final : public writer_base<details::null_policy> {
            public:
                null () = default;
                null (null const &) = delete;
                null (null &&) = delete;

                ~null () noexcept override;

                null & operator= (null const &) = delete;
                null & operator= (null &&) = delete;
            };


            // *******************************
            // *   r a n g e _ r e a d e r   *
            // *******************************

            template <typename InputIterator>
            class range_reader {
                static_assert (sizeof (typename std::iterator_traits<InputIterator>::value_type) ==
                                   1,
                               "archive_reader reads from a byte-wide sequence");

            public:
                explicit range_reader (InputIterator first)
                        : first_ (first) {}

                InputIterator iterator () { return first_; }

                template <typename Ty>
                void get (Ty & v) {
                    static_assert (std::is_standard_layout<Ty>::value,
                                   "range_reader can only read standard-layout types");
                    auto ptr = reinterpret_cast<std::uint8_t *> (&v);
                    auto const last = ptr + sizeof (Ty);
                    while (ptr != last) {
                        *(ptr++) = *(first_++);
                    }
                }

                template <typename SpanType>
                void getn (SpanType span) {
                    using element_type = typename SpanType::element_type;
                    static_assert (std::is_standard_layout<element_type>::value,
                                   "range_reader can only read standard-layout types");
                    auto out = reinterpret_cast<std::uint8_t *> (span.data ());
                    auto last = out + span.size_bytes ();
                    while (out != last) {
                        *(out++) = *(first_++);
                    }
                }

            private:
                InputIterator first_; 
            };


            template <typename InputIterator>
            range_reader<InputIterator> make_reader (InputIterator first) {
                return range_reader<InputIterator>{first};
            }


            // *********************************
            // *   b u f f e r _ r e a d e r   *
            // *********************************

            class buffer_reader {
            public:
                constexpr buffer_reader (void const * const first, void const * const last) noexcept
                        : first_ (static_cast<std::uint8_t const *> (first))
                        , last_ (static_cast<std::uint8_t const *> (last)) {}

                constexpr buffer_reader (void const * const first, std::size_t const size) noexcept
                        : first_ (static_cast<std::uint8_t const *> (first))
                        , last_ (static_cast<std::uint8_t const *> (first) + size) {}

                template <typename SpanType>
                explicit buffer_reader (SpanType const span) noexcept
                        : first_ (reinterpret_cast<std::uint8_t const *> (span.data ()))
                        , last_ (first_ + span.size_bytes ()) {}

                template <typename T>
                T get () {
                    typename std::remove_const<T>::type result;
                    static_assert (std::is_standard_layout<T>::value,
                                   "buffer_reader(T&) can only read standard-layout types");
                    if (first_ + sizeof (T) > last_) {
                        raise (std::errc::no_buffer_space,
                               "Attempted to read past the end of a buffer.");
                    }
                    std::memcpy (&result, first_, sizeof (T));
                    first_ += sizeof (T);
                    return result;
                }

            private:
                std::uint8_t const * first_; 
                std::uint8_t const * last_;  
            };

        } // end namespace archive
    }     // end namespace serialize
} // end namespace pstore

#endif // PSTORE_SERIALIZE_ARCHIVE_HPP