rrudb 0.0.2

data/ext/rudb/NuDB/include/nudb/impl/visit.ipp

@@ -0,0 +1,96 @@
+//
+// 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_IMPL_VISIT_IPP
+#define NUDB_IMPL_VISIT_IPP
+
+#include <nudb/concepts.hpp>
+#include <nudb/error.hpp>
+#include <nudb/type_traits.hpp>
+#include <nudb/native_file.hpp>
+#include <nudb/detail/bulkio.hpp>
+#include <nudb/detail/format.hpp>
+#include <algorithm>
+#include <cstddef>
+#include <string>
+
+namespace nudb {
+
+template<
+    class Callback,
+    class Progress>
+void
+visit(
+    path_type const& path,
+    Callback&& callback,
+    Progress&& progress,
+    error_code& ec)
+{
+    // VFALCO Need concept check for Callback
+    static_assert(is_Progress<Progress>::value,
+        "Progress requirements not met");
+    using namespace detail;
+    using File = native_file;
+    auto const readSize = 1024 * block_size(path);
+    File df;
+    df.open(file_mode::scan, path, ec);
+    if(ec)
+        return;
+    dat_file_header dh;
+    read(df, dh, ec);
+    if(ec)
+        return;
+    verify(dh, ec);
+    if(ec)
+        return;
+    auto const fileSize = df.size(ec);
+    if(ec)
+        return;
+    bulk_reader<File> r(df,
+        dat_file_header::size, fileSize, readSize);
+    progress(0, fileSize);
+    while(! r.eof())
+    {
+        // Data Record or Spill Record
+        nsize_t size;
+        auto is = r.prepare(
+            field<uint48_t>::size, ec); // Size
+        if(ec)
+            return;
+        detail::read_size48(is, size);
+        if(size > 0)
+        {
+            // Data Record
+            is = r.prepare(
+                dh.key_size +           // Key
+                size, ec);              // Data
+            std::uint8_t const* const key =
+                is.data(dh.key_size);
+            callback(key, dh.key_size,
+                is.data(size), size, ec);
+            if(ec)
+                return;
+        }
+        else
+        {
+            // Spill Record
+            is = r.prepare(
+                field<std::uint16_t>::size, ec);
+            if(ec)
+                return;
+            read<std::uint16_t>(is, size);  // Size
+            r.prepare(size, ec); // skip bucket
+            if(ec)
+                return;
+        }
+        progress(r.offset(), fileSize);
+    }
+}
+
+} // nudb
+
+#endif

data/ext/rudb/NuDB/include/nudb/impl/win32_file.ipp

@@ -0,0 +1,264 @@
+//
+// 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_IMPL_WIN32_FILE_IPP
+#define NUDB_IMPL_WIN32_FILE_IPP
+
+#include <boost/assert.hpp>
+
+namespace nudb {
+
+inline
+win32_file::
+~win32_file()
+{
+    close();
+}
+
+inline
+win32_file::
+win32_file(win32_file&& other)
+    : hf_(other.hf_)
+{
+    other.hf_ = INVALID_HANDLE_VALUE;
+}
+
+inline
+win32_file&
+win32_file::
+operator=(win32_file&& other)
+{
+    if(&other == this)
+        return *this;
+    close();
+    hf_ = other.hf_;
+    other.hf_ = INVALID_HANDLE_VALUE;
+    return *this;
+}
+
+inline
+void
+win32_file::
+close()
+{
+    if(hf_ != INVALID_HANDLE_VALUE)
+    {
+        ::CloseHandle(hf_);
+        hf_ = INVALID_HANDLE_VALUE;
+    }
+}
+
+inline
+void
+win32_file::
+create(file_mode mode, path_type const& path, error_code& ec)
+{
+    BOOST_ASSERT(! is_open());
+    auto const f = flags(mode);
+    hf_ = ::CreateFileA(path.c_str(),
+        f.first,
+        0,
+        NULL,
+        CREATE_NEW,
+        f.second,
+        NULL);
+    if(hf_ == INVALID_HANDLE_VALUE)
+        return last_err(ec);
+}
+
+inline
+void
+win32_file::
+open(file_mode mode, path_type const& path, error_code& ec)
+{
+    BOOST_ASSERT(! is_open());
+    auto const f = flags(mode);
+    hf_ = ::CreateFileA(path.c_str(),
+        f.first,
+        0,
+        NULL,
+        OPEN_EXISTING,
+        f.second,
+        NULL);
+    if(hf_ == INVALID_HANDLE_VALUE)
+        return last_err(ec);
+}
+
+inline
+void
+win32_file::
+erase(path_type const& path, error_code& ec)
+{
+    BOOL const bSuccess =
+        ::DeleteFileA(path.c_str());
+    if(! bSuccess)
+        return last_err(ec);
+}
+
+inline
+std::uint64_t
+win32_file::
+size(error_code& ec) const
+{
+    BOOST_ASSERT(is_open());
+    LARGE_INTEGER fileSize;
+    if(! ::GetFileSizeEx(hf_, &fileSize))
+    {
+        last_err(ec);
+        return 0;
+    }
+    return fileSize.QuadPart;
+}
+
+inline
+void
+win32_file::
+read(std::uint64_t offset, void* buffer, std::size_t bytes, error_code& ec)
+{
+    while(bytes > 0)
+    {
+        DWORD bytesRead;
+        LARGE_INTEGER li;
+        li.QuadPart = static_cast<LONGLONG>(offset);
+        OVERLAPPED ov;
+        ov.Offset = li.LowPart;
+        ov.OffsetHigh = li.HighPart;
+        ov.hEvent = NULL;
+        DWORD amount;
+        if(bytes > std::numeric_limits<DWORD>::max())
+            amount = std::numeric_limits<DWORD>::max();
+        else
+            amount = static_cast<DWORD>(bytes);
+        BOOL const bSuccess = ::ReadFile(
+            hf_, buffer, amount, &bytesRead, &ov);
+        if(! bSuccess)
+        {
+            DWORD const dwError = ::GetLastError();
+            if(dwError != ERROR_HANDLE_EOF)
+                return err(dwError, ec);
+            ec = make_error_code(error::short_read);
+            return;
+        }
+        if(bytesRead == 0)
+        {
+            ec = make_error_code(error::short_read);
+            return;
+        }
+        offset += bytesRead;
+        bytes -= bytesRead;
+        buffer = reinterpret_cast<char*>(
+            buffer) + bytesRead;
+    }
+}
+
+inline
+void
+win32_file::
+write(std::uint64_t offset,
+    void const* buffer, std::size_t bytes, error_code& ec)
+{
+    while(bytes > 0)
+    {
+        LARGE_INTEGER li;
+        li.QuadPart = static_cast<LONGLONG>(offset);
+        OVERLAPPED ov;
+        ov.Offset = li.LowPart;
+        ov.OffsetHigh = li.HighPart;
+        ov.hEvent = NULL;
+        DWORD amount;
+        if(bytes > std::numeric_limits<DWORD>::max())
+            amount = std::numeric_limits<DWORD>::max();
+        else
+            amount = static_cast<DWORD>(bytes);
+        DWORD bytesWritten;
+        BOOL const bSuccess = ::WriteFile(
+            hf_, buffer, amount, &bytesWritten, &ov);
+        if(! bSuccess)
+            return last_err(ec);
+        if(bytesWritten == 0)
+        {
+            ec = error_code{errc::no_space_on_device,
+                generic_category()};;
+            return;
+        }
+        offset += bytesWritten;
+        bytes -= bytesWritten;
+        buffer = reinterpret_cast<char const*>(
+            buffer) + bytesWritten;
+    }
+}
+
+inline
+void
+win32_file::
+sync(error_code& ec)
+{
+    if(! ::FlushFileBuffers(hf_))
+        return last_err(ec);
+}
+
+inline
+void
+win32_file::
+trunc(std::uint64_t length, error_code& ec)
+{
+    LARGE_INTEGER li;
+    li.QuadPart = length;
+    BOOL bSuccess;
+    bSuccess = ::SetFilePointerEx(
+        hf_, li, NULL, FILE_BEGIN);
+    if(bSuccess)
+        bSuccess = ::SetEndOfFile(hf_);
+    if(! bSuccess)
+        return last_err(ec);
+}
+
+inline
+std::pair<DWORD, DWORD>
+win32_file::
+flags(file_mode mode)
+{
+    std::pair<DWORD, DWORD> result{0, 0};
+    switch(mode)
+    {
+    case file_mode::scan:
+        result.first =
+            GENERIC_READ;
+        result.second =
+            FILE_FLAG_SEQUENTIAL_SCAN;
+        break;
+
+    case file_mode::read:
+        result.first =
+            GENERIC_READ;
+        result.second =
+            FILE_FLAG_RANDOM_ACCESS;
+        break;
+
+    case file_mode::append:
+        result.first =
+            GENERIC_READ | GENERIC_WRITE;
+        result.second =
+            FILE_FLAG_RANDOM_ACCESS
+            //| FILE_FLAG_NO_BUFFERING
+            //| FILE_FLAG_WRITE_THROUGH
+            ;
+        break;
+
+    case file_mode::write:
+        result.first =
+            GENERIC_READ | GENERIC_WRITE;
+        result.second =
+            FILE_FLAG_RANDOM_ACCESS;
+        break;
+    }
+    return result;
+}
+
+} // nudb
+
+#endif

data/ext/rudb/NuDB/include/nudb/native_file.hpp

@@ -0,0 +1,76 @@
+//
+// 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_NATIVE_FILE_HPP
+#define NUDB_NATIVE_FILE_HPP
+
+#include <nudb/error.hpp>
+#include <nudb/file.hpp>
+#include <nudb/posix_file.hpp>
+#include <nudb/win32_file.hpp>
+#include <string>
+
+namespace nudb {
+
+/** A native file handle.
+
+    This type is set to the appropriate platform-specific
+    implementation to meet the file wrapper requirements.
+*/
+using native_file =
+#ifdef _MSC_VER
+    win32_file;
+#else
+    posix_file;
+#endif
+
+/** Erase a file if it exists.
+
+    This function attempts to erase the specified file.
+    No error is generated if the file does not already
+    exist.
+
+    @param path The path to the file to erase.
+
+    @param ec Set to the error, if any occurred.
+
+    @tparam File A type meeting the requirements of @b File.
+    If this type is unspecified, @ref native_file is used.
+*/
+template<class File = native_file>
+inline
+void
+erase_file(path_type const& path, error_code& ec)
+{
+    native_file::erase(path, ec);
+    if(ec == errc::no_such_file_or_directory)
+        ec = {};
+}
+
+/** Erase a file without returnign an error.
+
+    This function attempts to erase the specified file.
+    Any errors are ignored, including if the file does
+    not exist.
+
+    @param path The path to the file to erase.
+
+    @tparam File A type meeting the requirements of @b File.
+    If this type is unspecified, @ref native_file is used.
+*/
+template<class File = native_file>
+inline
+void
+erase_file(path_type const& path)
+{
+    error_code ec;
+    File::erase(path, ec);
+}
+
+} // nudb
+
+#endif

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

@@ -0,0 +1,27 @@
+//
+// 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_HPP
+#define NUDB_HPP
+
+#include <nudb/concepts.hpp>
+#include <nudb/create.hpp>
+#include <nudb/error.hpp>
+#include <nudb/file.hpp>
+#include <nudb/posix_file.hpp>
+#include <nudb/progress.hpp>
+#include <nudb/recover.hpp>
+#include <nudb/rekey.hpp>
+#include <nudb/store.hpp>
+#include <nudb/type_traits.hpp>
+#include <nudb/verify.hpp>
+#include <nudb/version.hpp>
+#include <nudb/visit.hpp>
+#include <nudb/win32_file.hpp>
+#include <nudb/xxhasher.hpp>
+
+#endif

data/ext/rudb/NuDB/include/nudb/posix_file.hpp

@@ -0,0 +1,228 @@
+//
+// 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_POSIX_FILE_HPP
+#define NUDB_DETAIL_POSIX_FILE_HPP
+
+#include <nudb/file.hpp>
+#include <nudb/error.hpp>
+#include <cerrno>
+#include <cstring>
+#include <string>
+#include <utility>
+
+#ifndef NUDB_POSIX_FILE
+# ifdef _MSC_VER
+#  define NUDB_POSIX_FILE 0
+# else
+#  define NUDB_POSIX_FILE 1
+# endif
+#endif
+
+#if NUDB_POSIX_FILE
+# include <fcntl.h>
+# include <sys/types.h>
+# include <sys/uio.h>
+# include <sys/stat.h>
+# include <unistd.h>
+#endif
+
+#if NUDB_POSIX_FILE
+
+namespace nudb {
+
+class posix_file
+{
+    int fd_ = -1;
+
+public:
+    /// Constructor
+    posix_file() = default;
+
+    /// Copy constructor (disallowed)
+    posix_file(posix_file const&) = delete;
+
+    // Copy assignment (disallowed)
+    posix_file& operator=(posix_file const&) = delete;
+
+    /** Destructor.
+
+        If open, the file is closed.
+    */
+    ~posix_file();
+
+    /** Move constructor.
+
+        @note The state of the moved-from object is as if default constructed.
+    */
+    posix_file(posix_file&&);
+
+    /** Move assignment.
+
+        @note The state of the moved-from object is as if default constructed.
+    */
+    posix_file&
+    operator=(posix_file&& other);
+
+    /// Returns `true` if the file is open.
+    bool
+    is_open() const
+    {
+        return fd_ != -1;
+    }
+
+    /// Close the file if it is open.
+    void
+    close();
+
+    /** Create a new file.
+
+        After the file is created, it is opened as if by `open(mode, path, ec)`.
+
+        @par Requirements
+
+        The file must not already exist, or else `errc::file_exists`
+        is returned.
+
+        @param mode The open mode, which must be a valid @ref file_mode.
+
+        @param path The path of the file to create.
+
+        @param ec Set to the error, if any occurred.
+    */
+    void
+    create(file_mode mode, path_type const& path, error_code& ec);
+
+    /** Open a file.
+
+        @par Requirements
+
+        The file must not already be open.
+
+        @param mode The open mode, which must be a valid @ref file_mode.
+
+        @param path The path of the file to open.
+
+        @param ec Set to the error, if any occurred.
+    */
+    void
+    open(file_mode mode, path_type const& path, error_code& ec);
+
+    /** Remove a file from the file system.
+
+        It is not an error to attempt to erase a file that does not exist.
+
+        @param path The path of the file to remove.
+
+        @param ec Set to the error, if any occurred.
+    */
+    static
+    void
+    erase(path_type const& path, error_code& ec);
+
+    /** Return the size of the file.
+
+        @par Requirements
+
+        The file must be open.
+
+        @param ec Set to the error, if any occurred.
+
+        @return The size of the file, in bytes.
+    */
+    std::uint64_t
+    size(error_code& ec) const;
+
+    /** Read data from a location in the file.
+
+        @par Requirements
+
+        The file must be open.
+
+        @param offset The position in the file to read from,
+        expressed as a byte offset from the beginning.
+
+        @param buffer The location to store the data.
+
+        @param bytes The number of bytes to read.
+
+        @param ec Set to the error, if any occurred.
+    */
+    void
+    read(std::uint64_t offset,
+        void* buffer, std::size_t bytes, error_code& ec);
+
+    /** Write data to a location in the file.
+
+        @par Requirements
+
+        The file must be open with a mode allowing writes.
+
+        @param offset The position in the file to write from,
+        expressed as a byte offset from the beginning.
+
+        @param buffer The data the write.
+
+        @param bytes The number of bytes to write.
+
+        @param ec Set to the error, if any occurred.
+    */
+    void
+    write(std::uint64_t offset,
+        void const* buffer, std::size_t bytes, error_code& ec);
+
+    /** Perform a low level file synchronization.
+
+        @par Requirements
+
+        The file must be open with a mode allowing writes.
+
+        @param ec Set to the error, if any occurred.
+    */
+    void
+    sync(error_code& ec);
+
+    /** Truncate the file at a specific size.
+
+        @par Requirements
+
+        The file must be open with a mode allowing writes.
+
+        @param length The new file size.
+
+        @param ec Set to the error, if any occurred.
+    */
+    void
+    trunc(std::uint64_t length, error_code& ec);
+
+private:
+    static
+    void
+    err(int ev, error_code& ec)
+    {
+        ec = error_code{ev, system_category()};
+    }
+
+    static
+    void
+    last_err(error_code& ec)
+    {
+        err(errno, ec);
+    }
+
+    static
+    std::pair<int, int>
+    flags(file_mode mode);
+};
+
+} // nudb
+
+#include <nudb/impl/posix_file.ipp>
+
+#endif
+
+#endif

data/ext/rudb/NuDB/include/nudb/progress.hpp

@@ -0,0 +1,32 @@
+//
+// 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_PROGRESS_HPP
+#define NUDB_PROGRESS_HPP
+
+namespace nudb {
+
+/** Progress function that does nothing.
+
+    This type meets the requirements of @b Progress,
+    and does nothing when invoked.
+*/
+struct
+no_progress
+{
+    no_progress() = default;
+
+    /// Called to indicate progress
+    void
+    operator()(std::uint64_t, std::uint64_t) const noexcept
+    {
+    };
+};
+
+} // nudb
+
+#endif