indirect_string.hpp

//===- include/pstore/core/indirect_string.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_CORE_INDIRECT_STRING_HPP
#define PSTORE_CORE_INDIRECT_STRING_HPP

#include <memory>

#include "pstore/core/sstring_view_archive.hpp"

namespace pstore {

    //*  _         _ _            _        _       _            *
    //* (_)_ _  __| (_)_ _ ___ __| |_   __| |_ _ _(_)_ _  __ _  *
    //* | | ' \/ _` | | '_/ -_) _|  _| (_-<  _| '_| | ' \/ _` | *
    //* |_|_||_\__,_|_|_| \___\__|\__| /__/\__|_| |_|_||_\__, | *
    //*                                                  |___/  *

    class indirect_string {
        friend struct serialize::serializer<indirect_string>;

    public:
        constexpr indirect_string (database const & db, address const addr) noexcept
                : db_{db}
                , is_pointer_{false}
                , address_{addr.absolute ()} {}
        constexpr indirect_string (database const & db,
                                   gsl::not_null<raw_sstring_view const *> const str) noexcept
                : db_{db}
                , is_pointer_{true}
                , str_{str} {
            PSTORE_ASSERT ((reinterpret_cast<std::uintptr_t> (str.get ()) & in_heap_mask) == 0);
        }

        bool operator== (indirect_string const & rhs) const;
        bool operator!= (indirect_string const & rhs) const { return !operator== (rhs); }
        bool operator< (indirect_string const & rhs) const;

        raw_sstring_view as_string_view (gsl::not_null<shared_sstring_view *> owner) const;

        std::size_t length () const;

        raw_sstring_view
        as_db_string_view (gsl::not_null<shared_sstring_view *> const owner) const {
            if (!is_in_store ()) {
                raise (error_code::bad_address);
            }
            return this->as_string_view (owner);
        }

        std::string to_string () const {
            shared_sstring_view owner;
            return this->as_string_view (&owner).to_string ();
        }

        constexpr bool is_in_store () const noexcept {
            return !is_pointer_ && !(address_ & in_heap_mask);
        }

        constexpr address in_store_address () const noexcept {
            PSTORE_ASSERT (this->is_in_store ());
            return address{address_};
        }

        static address write_body_and_patch_address (transaction_base & transaction,
                                                     raw_sstring_view const & str,
                                                     typed_address<address> address_to_patch);

        static indirect_string read (database const & db, typed_address<indirect_string> addr);

    private:
        static constexpr std::uint64_t in_heap_mask = 0x01;
        bool equal_contents (indirect_string const & rhs) const;

        database const & db_;
        // TODO: replace with std::variant<>...?
        bool is_pointer_;
        union {
            address::value_type address_;  
            raw_sstring_view const * str_; 
        };
    };

    template <typename OStream>
    OStream & operator<< (OStream & os, indirect_string const & ind_str) {
        shared_sstring_view owner;
        return os << ind_str.as_string_view (&owner);
    }


    namespace serialize {

        template <>
        struct serializer<indirect_string> {
            using value_type = indirect_string;

            static auto write (archive::database_writer && archive, value_type const & value)
                -> archive_result_type<archive::database_writer> {
                return write_string_address (archive, value);
            }

            static auto write (archive::database_writer & archive, value_type const & value)
                -> archive_result_type<archive::database_writer> {
                return write_string_address (archive, value);
            }


            static void read (archive::database_reader & archive, value_type & value);

            static void read (archive::database_reader && archive, value_type & value);

        private:
            template <typename DBArchive>
            static auto write_string_address (DBArchive && archive, value_type const & value)
                -> archive_result_type<DBArchive>;

            template <typename DBArchive>
            static void read_string_address (DBArchive && archive, value_type & value);
        };

        // write_string_address
        // ~~~~~~~~~~~~~~~~~~~~
        template <typename DBArchive>
        auto serializer<indirect_string>::write_string_address (DBArchive && archive,
                                                                value_type const & value)
            -> archive_result_type<DBArchive> {

            // The body of an indirect string must be written separately by the caller.
            PSTORE_ASSERT (value.is_pointer_);
            constexpr auto mask = indirect_string::in_heap_mask;
            PSTORE_ASSERT (!(reinterpret_cast<std::uintptr_t> (value.str_) & mask));

            return archive.put (address{reinterpret_cast<std::uintptr_t> (value.str_) | mask});
        }

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

namespace std {

    template <>
    struct hash<::pstore::indirect_string> {
        size_t operator() (::pstore::indirect_string const & str) const {
            ::pstore::shared_sstring_view owner;
            return std::hash<pstore::raw_sstring_view>{}(str.as_string_view (&owner));
        }
    };

} // namespace std

namespace pstore {

    //*  _         _ _            _        _       _                     _    _          *
    //* (_)_ _  __| (_)_ _ ___ __| |_   __| |_ _ _(_)_ _  __ _   __ _ __| |__| |___ _ _  *
    //* | | ' \/ _` | | '_/ -_) _|  _| (_-<  _| '_| | ' \/ _` | / _` / _` / _` / -_) '_| *
    //* |_|_||_\__,_|_|_| \___\__|\__| /__/\__|_| |_|_||_\__, | \__,_\__,_\__,_\___|_|   *
    //*                                                  |___/                           *

    class indirect_string_adder {
    public:
        indirect_string_adder () = default;
        explicit indirect_string_adder (std::size_t expected_size);

        template <typename Index>
        std::pair<typename Index::iterator, bool> add (transaction_base & transaction,
                                                       std::shared_ptr<Index> const & index,
                                                       gsl::not_null<raw_sstring_view const *> str);

        void flush (transaction_base & transaction);

    private:
        std::vector<std::pair<raw_sstring_view const *, typed_address<address>>> views_;
    };

    // add
    // ~~~
    template <typename Index>
    std::pair<typename Index::iterator, bool>
    indirect_string_adder::add (transaction_base & transaction,
                                std::shared_ptr<Index> const & index,
                                gsl::not_null<raw_sstring_view const *> str) {

        // Inserting into the index immediately writes the indirect_string instance to the store if
        // the string isn't already in the set.
        auto res = index->insert (transaction, pstore::indirect_string{transaction.db (), str});
        if (res.second) {
            // Now the in-store addresses are pointing at the sstring_view instances on the heap.
            // If the string was written, we remember where it went.
            typename Index::iterator const & pos = res.first;
            views_.emplace_back (str, typed_address<address>::make (pos.get_address ()));
        }
        return res;
    }

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

    raw_sstring_view get_sstring_view (database const & db,
                                       typed_address<indirect_string> const addr,
                                       gsl::not_null<shared_sstring_view *> const owner);

    raw_sstring_view get_sstring_view (database const & db, address addr,
                                       gsl::not_null<shared_sstring_view *> const owner);

    raw_sstring_view get_sstring_view (database const & db, address addr, std::size_t length,
                                       gsl::not_null<shared_sstring_view *> owner);

} // end namespace pstore

#endif // PSTORE_CORE_INDIRECT_STRING_HPP