rrudb 0.0.2

data/ext/rudb/NuDB/include/nudb/detail/bulkio.hpp

@@ -0,0 +1,196 @@
+//
+// Copyright (c) 2015-2016 Vinnie Falco (vinnie dot falco at gmail dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef NUDB_DETAIL_BULKIO_HPP
+#define NUDB_DETAIL_BULKIO_HPP
+
+#include <nudb/type_traits.hpp>
+#include <nudb/detail/buffer.hpp>
+#include <nudb/detail/stream.hpp>
+#include <nudb/error.hpp>
+#include <algorithm>
+#include <cstddef>
+
+namespace nudb {
+namespace detail {
+
+// Scans a file in sequential large reads
+template<class File>
+class bulk_reader
+{
+    File& f_;
+    buffer buf_;
+    noff_t last_;       // size of file
+    noff_t offset_;     // current position
+    std::size_t avail_; // bytes left to read in buf
+    std::size_t used_;  // bytes consumed in buf
+
+public:
+    bulk_reader(File& f, noff_t offset,
+        noff_t last, std::size_t buffer_size);
+
+    noff_t
+    offset() const
+    {
+        return offset_ - avail_;
+    }
+
+    bool
+    eof() const
+    {
+        return offset() >= last_;
+    }
+
+    istream
+    prepare(std::size_t needed, error_code& ec);
+};
+
+template<class File>
+bulk_reader<File>::
+bulk_reader(File& f, noff_t offset,
+        noff_t last, std::size_t buffer_size)
+    : f_(f)
+    , last_(last)
+    , offset_(offset)
+    , avail_(0)
+    , used_(0)
+{
+    buf_.reserve(buffer_size);
+}
+
+template<class File>
+istream
+bulk_reader<File>::
+prepare(std::size_t needed, error_code& ec)
+{
+    if(needed > avail_)
+    {
+        if(offset_ + needed - avail_ > last_)
+        {
+            ec = error::short_read;
+            return {};
+        }
+        if(needed > buf_.size())
+        {
+            buffer buf;
+            buf.reserve(needed);
+            std::memcpy(buf.get(),
+                buf_.get() + used_, avail_);
+            buf_ = std::move(buf);
+        }
+        else
+        {
+            std::memmove(buf_.get(),
+                buf_.get() + used_, avail_);
+        }
+
+        auto const n = std::min(buf_.size() - avail_,
+            static_cast<std::size_t>(last_ - offset_));
+        f_.read(offset_, buf_.get() + avail_, n, ec);
+        if(ec)
+            return {};
+        offset_ += n;
+        avail_ += n;
+        used_ = 0;
+    }
+    istream is{buf_.get() + used_, needed};
+    used_ += needed;
+    avail_ -= needed;
+    return is;
+}
+
+//------------------------------------------------------------------------------
+
+// Buffers file writes
+// Caller must call flush manually at the end
+template<class File>
+class bulk_writer
+{
+    File& f_;
+    buffer buf_;
+    noff_t offset_;      // current position
+    std::size_t used_;   // bytes written to buf
+
+public:
+    bulk_writer(File& f, noff_t offset,
+        std::size_t buffer_size);
+
+    ostream
+    prepare(std::size_t needed, error_code& ec);
+
+    // Returns the number of bytes buffered
+    std::size_t
+    size()
+    {
+        return used_;
+    }
+
+    // Return current offset in file. This
+    // is advanced with each call to prepare.
+    noff_t
+    offset() const
+    {
+        return offset_ + used_;
+    }
+
+    // Caller must invoke flush manually in
+    // order to handle any error conditions.
+    void
+    flush(error_code& ec);
+};
+
+template<class File>
+bulk_writer<File>::
+bulk_writer(File& f,
+        noff_t offset, std::size_t buffer_size)
+    : f_(f)
+    , offset_(offset)
+    , used_(0)
+
+{
+    buf_.reserve(buffer_size);
+}
+
+template<class File>
+ostream
+bulk_writer<File>::
+prepare(std::size_t needed, error_code& ec)
+{
+    if(used_ + needed > buf_.size())
+    {
+        flush(ec);
+        if(ec)
+            return{};
+    }
+    if(needed > buf_.size())
+        buf_.reserve(needed);
+    ostream os(buf_.get() + used_, needed);
+    used_ += needed;
+    return os;
+}
+
+template<class File>
+void
+bulk_writer<File>::
+flush(error_code& ec)
+{
+    if(used_)
+    {
+        auto const offset = offset_;
+        auto const used = used_;
+        offset_ += used_;
+        used_ = 0;
+        f_.write(offset, buf_.get(), used, ec);
+        if(ec)
+            return;
+    }
+}
+
+} // detail
+} // nudb
+
+#endif

data/ext/rudb/NuDB/include/nudb/detail/cache.hpp

@@ -0,0 +1,236 @@
+//
+// Copyright (c) 2015-2016 Vinnie Falco (vinnie dot falco at gmail dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef NUDB_DETAIL_CACHE_HPP
+#define NUDB_DETAIL_CACHE_HPP
+
+#include <nudb/detail/arena.hpp>
+#include <nudb/detail/bucket.hpp>
+#include <nudb/detail/format.hpp>
+#include <boost/iterator/transform_iterator.hpp>
+#include <algorithm>
+#include <cstdint>
+#include <utility>
+#include <vector>
+#include <unordered_map>
+
+namespace nudb {
+namespace detail {
+
+// Associative container storing
+// bucket blobs keyed by bucket index.
+//
+template<class = void>
+class cache_t
+{
+public:
+    using value_type = std::pair<nbuck_t, bucket>;
+
+private:
+    using map_type =
+        std::unordered_map<nbuck_t, void*>;
+
+    struct transform
+    {
+        using argument_type =
+            typename map_type::value_type;
+        using result_type = value_type;
+
+        cache_t* cache_;
+
+        transform()
+            : cache_(nullptr)
+        {
+        }
+
+        explicit
+        transform(cache_t& cache)
+            : cache_(&cache)
+        {
+        }
+
+        value_type
+        operator()(argument_type const& e) const
+        {
+            return std::make_pair(e.first,
+                bucket{cache_->block_size_, e.second});
+        }
+    };
+
+    nsize_t key_size_ = 0;
+    nsize_t block_size_ = 0;
+    arena arena_;
+    map_type map_;
+
+public:
+    using iterator = boost::transform_iterator<
+        transform, typename map_type::iterator,
+            value_type, value_type>;
+
+    cache_t(cache_t const&) = delete;
+    cache_t& operator=(cache_t&&) = delete;
+    cache_t& operator=(cache_t const&) = delete;
+
+    // Constructs a cache that will never have inserts
+    cache_t() = default;
+    
+    cache_t(cache_t&& other);
+
+    explicit
+    cache_t(nsize_t key_size,
+        nsize_t block_size, char const* label);
+
+    std::size_t
+    size() const
+    {
+        return map_.size();
+    }
+
+    iterator
+    begin()
+    {
+        return iterator{map_.begin(), transform{*this}};
+    }
+
+    iterator
+    end()
+    {
+        return iterator{map_.end(), transform{*this}};
+    }
+
+    bool
+    empty() const
+    {
+        return map_.empty();
+    }
+
+    void
+    clear();
+
+    void
+    reserve(std::size_t n);
+
+    void
+    periodic_activity();
+
+    iterator
+    find(nbuck_t n);
+
+    // Create an empty bucket
+    //
+    bucket
+    create(nbuck_t n);
+
+    // Insert a copy of a bucket.
+    //
+    iterator
+    insert(nbuck_t n, bucket const& b);
+
+    template<class U>
+    friend
+    void
+    swap(cache_t<U>& lhs, cache_t<U>& rhs);
+};
+
+template<class _>
+cache_t<_>::
+cache_t(cache_t&& other)
+    : key_size_{other.key_size_}
+    , block_size_(other.block_size_)
+    , arena_(std::move(other.arena_))
+    , map_(std::move(other.map_))
+{
+}
+
+template<class _>
+cache_t<_>::
+cache_t(nsize_t key_size,
+        nsize_t block_size, char const* label)
+    : key_size_(key_size)
+    , block_size_(block_size)
+    , arena_(label)
+{
+}
+
+template<class _>
+void
+cache_t<_>::
+reserve(std::size_t n)
+{
+    arena_.hint(n * block_size_);
+    map_.reserve(n);
+}
+
+template<class _>
+void
+cache_t<_>::
+clear()
+{
+    arena_.clear();
+    map_.clear();
+}
+
+template<class _>
+void
+cache_t<_>::
+periodic_activity()
+{
+    arena_.periodic_activity();
+}
+
+template<class _>
+auto
+cache_t<_>::
+find(nbuck_t n) ->
+    iterator
+{
+    auto const iter = map_.find(n);
+    if(iter == map_.end())
+        return iterator{map_.end(), transform(*this)};
+    return iterator{iter, transform(*this)};
+}
+
+template<class _>
+bucket
+cache_t<_>::
+create(nbuck_t n)
+{
+    auto const p = arena_.alloc(block_size_);
+    map_.emplace(n, p);
+    return bucket{block_size_, p, detail::empty};
+}
+
+template<class _>
+auto
+cache_t<_>::
+insert(nbuck_t n, bucket const& b) ->
+    iterator
+{
+    void* const p = arena_.alloc(b.block_size());
+    ostream os{p, b.block_size()};
+    b.write(os);
+    auto const result = map_.emplace(n, p);
+    return iterator{result.first, transform(*this)};
+}
+
+template<class U>
+void
+swap(cache_t<U>& lhs, cache_t<U>& rhs)
+{
+    using std::swap;
+    swap(lhs.key_size_, rhs.key_size_);
+    swap(lhs.block_size_, rhs.block_size_);
+    swap(lhs.arena_, rhs.arena_);
+    swap(lhs.map_, rhs.map_);
+}
+
+using cache = cache_t<>;
+
+} // detail
+} // nudb
+
+#endif

data/ext/rudb/NuDB/include/nudb/detail/endian.hpp

@@ -0,0 +1,93 @@
+//
+// Copyright (c) 2015-2016 Vinnie Falco (vinnie dot falco at gmail dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef NUDB_DETAIL_ENDIAN_HPP
+#define NUDB_DETAIL_ENDIAN_HPP
+
+#include <cstdint>
+#include <type_traits>
+
+namespace nudb {
+namespace detail {
+
+// This is a modified work, original implementation
+// by Howard Hinnant <howard.hinnant@gmail.com>
+//
+// "This should be standardized" - Howard
+
+// Endian provides answers to the following questions:
+// 1.  Is this system big or little endian?
+// 2.  Is the "desired endian" of some class or function the same as the
+//     native endian?
+enum class endian
+{
+#ifdef _MSC_VER
+    big    = 1,
+    little = 0,
+    native = little
+#else
+    native = __BYTE_ORDER__,
+    little = __ORDER_LITTLE_ENDIAN__,
+    big    = __ORDER_BIG_ENDIAN__
+#endif
+};
+
+using is_little_endian =
+    std::integral_constant<bool,
+        endian::native == endian::little>;
+
+static_assert(
+    endian::native == endian::little || endian::native == endian::big,
+    "endian::native shall be one of endian::little or endian::big");
+
+static_assert(
+    endian::big != endian::little,
+    "endian::big and endian::little shall have different values");
+
+// The pepper got baked into the file format as
+// the hash of the little endian salt so now we
+// need this function.
+//
+template<class = void>
+std::uint64_t
+to_little_endian(std::uint64_t v, std::false_type)
+{
+    union U
+    {
+        std::uint64_t vi;
+        std::uint8_t va[8];
+    };
+    U u;
+    u.va[0] =  v & 0xff;
+    u.va[1] = (v >>  8) & 0xff;
+    u.va[2] = (v >> 16) & 0xff;
+    u.va[3] = (v >> 24) & 0xff;
+    u.va[4] = (v >> 32) & 0xff;
+    u.va[5] = (v >> 40) & 0xff;
+    u.va[6] = (v >> 48) & 0xff;
+    u.va[7] = (v >> 56) & 0xff;
+    return u.vi;
+}
+
+inline
+std::uint64_t
+to_little_endian(std::uint64_t v, std::true_type)
+{
+    return v;
+}
+
+inline
+std::uint64_t
+to_little_endian(std::uint64_t v)
+{
+    return to_little_endian(v, is_little_endian{});
+}
+
+} // detail
+} // nudb
+
+#endif