db_archive.hpp

Go to the documentation of this file.

//===- include/pstore/core/db_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_CORE_DB_ARCHIVE_HPP
#define PSTORE_CORE_DB_ARCHIVE_HPP

#include "pstore/core/transaction.hpp"
#include "pstore/serialize/archive.hpp"
#include "pstore/support/error.hpp"

namespace pstore {
    namespace serialize {
        namespace archive {

            // *************************************
            // *   d a t a b a s e _ w r i t e r   *
            // *************************************
            namespace details {

                class database_writer_policy {
                public:
                    using result_type = pstore::address;

                    explicit constexpr database_writer_policy (transaction_base & trans) noexcept
                            : transaction_ (trans) {}

                    template <typename Ty>
                    auto put (Ty const & value) -> result_type {
                        std::shared_ptr<Ty> ptr;
                        auto addr = typed_address<Ty>::null ();
                        std::tie (ptr, addr) = transaction_.template alloc_rw<Ty> ();
                        *ptr = value;
                        return addr.to_address ();
                    }

                    template <typename Span>
                    auto putn (Span sp) -> result_type {
                        using element_type =
                            typename std::remove_const<typename Span::element_type>::type;

                        std::shared_ptr<element_type> ptr;
                        auto addr = typed_address<element_type>::null ();
                        std::tie (ptr, addr) = transaction_.template alloc_rw<element_type> (
                            unsigned_cast (sp.size ()));
                        std::copy (std::begin (sp), std::end (sp), ptr.get ());
                        return addr.to_address ();
                    }

                    void flush () noexcept {}

                private:
                    transaction_base & transaction_;
                };

            } // namespace details

            class database_writer final : public writer_base<details::database_writer_policy> {
                using policy = details::database_writer_policy;

            public:
                explicit database_writer (transaction_base & transaction)
                        : writer_base<policy> (policy{transaction}) {}
            };

            inline auto make_writer (transaction_base & transaction) noexcept -> database_writer {
                return database_writer{transaction};
            }


            // *************************************
            // *   d a t a b a s e _ r e a d e r   *
            // *************************************

            class database_reader {
            public:
                database_reader (pstore::database const & db, pstore::address const addr) noexcept
                        : db_ (db)
                        , addr_ (addr) {}

                pstore::database const & get_db () const noexcept { return db_; }
                pstore::address get_address () const noexcept { return addr_; }
                void skip (std::size_t const distance) noexcept { addr_ += distance; }

                template <typename Ty, typename = typename std::enable_if<
                                           std::is_standard_layout<Ty>::value>::type>
                void get (Ty & v);

                template <typename SpanType,
                          typename = typename std::enable_if<std::is_standard_layout<
                              typename SpanType::element_type>::value>::type>
                void getn (SpanType span);

            private:
                database const & db_; 
                address addr_;        
            };

            // get
            // ~~~
            template <typename Ty, typename>
            void database_reader::get (Ty & v) {

                auto const extra_for_alignment = calc_alignment (addr_.absolute (), alignof (Ty));
                PSTORE_ASSERT (extra_for_alignment < sizeof (Ty));
                addr_ += extra_for_alignment;
                // Load the data.
                auto result = db_.getro (typed_address<Ty> (addr_));
                addr_ += sizeof (Ty);
                // Copy to the destination.
                new (&v) Ty (*result);
            }

            // getn
            // ~~~~
            template <typename SpanType, typename>
            void database_reader::getn (SpanType span) {
                using element_type = typename SpanType::element_type;

                // Adjust addr_ so that it is correctly aligned for element_type.
                auto const extra_for_alignment =
                    calc_alignment (addr_.absolute (), alignof (element_type));
                PSTORE_ASSERT (extra_for_alignment < sizeof (element_type));
                addr_ += extra_for_alignment;

                // Load the data.
                auto const size = unsigned_cast (span.size_bytes ());
                auto src = db_.getro (typed_address<std::uint8_t> (addr_), size);
                addr_ += size;

                // Copy to the destination span.
                auto first = src.get ();
                std::copy (first, first + size, reinterpret_cast<std::uint8_t *> (span.data ()));
            }

            inline database_reader make_reader (pstore::database const & db,
                                                pstore::address const addr) noexcept {
                return {db, addr};
            }
        } // namespace archive
    }     // namespace serialize
} // namespace pstore
#endif // PSTORE_CORE_DB_ARCHIVE_HPP