rrudb 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 97365f391776500be966ed6f9549b86e56121cb688ea6875bd6cba2e7d39dbcb
+  data.tar.gz: 364d820a47146a01a2d969111b1e044ec80bc8e02f2887b5c1c49678b4a60551
+SHA512:
+  metadata.gz: 6fcef1c9c4e036e881ba4805ede5579e6eed788f7ed6d5fa3af93888ce55d284751f8ed555809e6ecedcf2f0e478e76d252bcefd4047014c12d7feaa19067327
+  data.tar.gz: 880d565f2aac8e0ac3821c495a9c52eb82baae3acf10fdf7601c578ed3f4d4ad1b12dd269ff490c47cfc8222d4395d507d7b78e5b288aead70373fa7b8bffc58

data/.yardopts

@@ -0,0 +1 @@
+--no-private

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2019 Dev Null Productions <devnullproductions@gmail.com>
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,26 @@
+### RuDB - Ruby NuDB wrapper
+
+RuDB provides a native wrapper around the [NuDB](https://github.com/CPPAlliance/NuDB) database. As NuDB is a *header only* library, this gem includes all the necessary logic builtin to manage a NuDB instance. As per the NuDB requirements, the following are necessary to install this gem:
+
+* Boost 1.61 or higher (development headers)
+* C++11 or greater
+
+#### Installation / Documentation
+
+rudb may be installed with the following command:
+
+```ruby
+$ gem install rrudb
+```
+
+(Yes, there are two '**r**'s in there!)
+
+#### Usage
+
+See **examples/example.rb** for a Ruby port of **NuDB/examples/example.cpp**
+
+#### License
+
+Copyright (C) 2019 Dev Null Productions
+
+Made available under the MIT License

data/examples/example.rb

@@ -0,0 +1,39 @@
+# Port of NuDB/examples/example.cpp to ruby
+
+require 'rudb'
+
+N = 1000
+KEY_SIZE = 32/8 # => sizeof(uint32_t) = 4 bytes
+
+dat_path = 'db.dat'
+key_path = 'db.key'
+log_path = 'db.log'
+
+ec = RuDB::create :dat_path    => dat_path,
+                  :key_path    => key_path,
+                  :log_path    => log_path,
+                  :app_num     => 1,
+                  :salt        => RuDB::make_salt,
+                  :key_size    => KEY_SIZE,
+                  :block_size  => RuDB::block_size('.'),
+                  :load_factor => 0.5
+
+db = RuDB::Store.new
+ec = db.open(dat_path, key_path, log_path)
+
+data = 0
+0.upto(N) { |i|
+  ec = db.insert([i].pack("L"),
+              [data].pack("L"))
+}
+
+0.upto(N) { |i|
+  dat, ec = db.fetch([i].pack("L"))
+  # do something with dat
+}
+
+ec = db.close
+
+RuDB::erase_file dat_path
+RuDB::erase_file key_path
+RuDB::erase_file log_path

data/ext/rudb/NuDB/include/nudb/CMakeLists.txt

@@ -0,0 +1,104 @@
+
+#[===================================================================[
+   define the primary target: nudb (header only lib)
+#]===================================================================]
+
+add_library (nudb_core INTERFACE)
+target_include_directories (nudb_core
+  INTERFACE
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/..>
+    $<INSTALL_INTERFACE:include>)
+target_link_libraries (nudb_core
+  INTERFACE
+    Boost::thread
+    Boost::system)
+# this is the min std required to use NuDB - should
+# it be 11 or 14?
+target_compile_features (nudb_core INTERFACE cxx_std_11)
+add_library (NuDB::nudb ALIAS nudb_core)
+install (
+  FILES
+    basic_store.hpp
+    concepts.hpp
+    create.hpp
+    error.hpp
+    file.hpp
+    native_file.hpp
+    nudb.hpp
+    posix_file.hpp
+    progress.hpp
+    recover.hpp
+    rekey.hpp
+    store.hpp
+    type_traits.hpp
+    verify.hpp
+    version.hpp
+    visit.hpp
+    win32_file.hpp
+    xxhasher.hpp
+  DESTINATION include/nudb)
+install (
+  FILES
+    _experimental/basic_seconds_clock.hpp
+    _experimental/chrono_util.hpp
+    _experimental/util.hpp
+  DESTINATION include/nudb/_experimental)
+# not sure if these should be part of the install set
+# are they needed by any public headers ?
+install (
+  FILES
+    _experimental/test/fail_file.hpp
+    _experimental/test/temp_dir.hpp
+    _experimental/test/test_store.hpp
+    _experimental/test/xor_shift_engine.hpp
+  DESTINATION include/nudb/_experimental/test)
+install (
+  FILES
+    impl/basic_store.ipp
+    impl/create.ipp
+    impl/error.ipp
+    impl/posix_file.ipp
+    impl/recover.ipp
+    impl/rekey.ipp
+    impl/verify.ipp
+    impl/visit.ipp
+    impl/win32_file.ipp
+  DESTINATION include/nudb/impl)
+install (
+  FILES
+    detail/arena.hpp
+    detail/bucket.hpp
+    detail/buffer.hpp
+    detail/bulkio.hpp
+    detail/cache.hpp
+    detail/endian.hpp
+    detail/field.hpp
+    detail/format.hpp
+    detail/gentex.hpp
+    detail/mutex.hpp
+    detail/pool.hpp
+    detail/stream.hpp
+    detail/xxhash.hpp
+  DESTINATION include/nudb/impl)
+install (
+  TARGETS nudb_core
+  EXPORT NuDBExports
+  INCLUDES DESTINATION include)
+install (EXPORT NuDBExports
+  FILE NuDBTargets.cmake
+  NAMESPACE NuDB::
+  DESTINATION lib/cmake/nudb)
+include (CMakePackageConfigHelpers)
+write_basic_package_version_file (
+  NuDBConfigVersion.cmake
+  VERSION ${CMAKE_PROJECT_VERSION}
+  COMPATIBILITY SameMajorVersion)
+
+if (is_root_project)
+  install (
+    FILES
+      ${CMAKE_SOURCE_DIR}/scripts/NuDBConfig.cmake
+      ${CMAKE_CURRENT_BINARY_DIR}/NuDBConfigVersion.cmake
+    DESTINATION lib/cmake/nudb)
+endif ()
+

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

@@ -0,0 +1,200 @@
+//
+// 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_EXPERIMENTAL_BASIC_SECONDS_CLOCK_HPP
+#define NUDB_EXPERIMENTAL_BASIC_SECONDS_CLOCK_HPP
+
+#include "chrono_util.hpp"
+
+#include <algorithm>
+#include <chrono>
+#include <condition_variable>
+#include <mutex>
+#include <thread>
+#include <vector>
+
+namespace detail {
+
+class seconds_clock_worker
+{
+public:
+    virtual void sample() = 0;
+};
+
+//------------------------------------------------------------------------------
+
+// Updates the clocks
+class seconds_clock_thread
+{
+public:
+    using mutex = std::mutex;
+    using cond_var = std::condition_variable;
+    using lock_guard = std::lock_guard <mutex>;
+    using unique_lock = std::unique_lock <mutex>;
+    using clock_type = std::chrono::steady_clock;
+    using seconds = std::chrono::seconds;
+    using thread = std::thread;
+    using workers = std::vector <seconds_clock_worker*>;
+
+    bool stop_;
+    mutex m_;
+    cond_var cond_;
+    workers workers_;
+    thread thread_;
+
+    seconds_clock_thread()
+        : stop_(false)
+    {
+        thread_ = thread{
+            &seconds_clock_thread::run, this};
+    }
+
+    ~seconds_clock_thread()
+    {
+        stop();
+    }
+
+    void add(seconds_clock_worker& w)
+    {
+        lock_guard lock{m_};
+        workers_.push_back(&w);
+    }
+
+    void remove(seconds_clock_worker& w)
+    {
+        lock_guard lock{m_};
+        workers_.erase(std::find(
+            workers_.begin(), workers_.end(), &w));
+    }
+
+    void stop()
+    {
+        if(thread_.joinable())
+        {
+            {
+                lock_guard lock{m_};
+                stop_ = true;
+            }
+            cond_.notify_all();
+            thread_.join();
+        }
+    }
+
+    void run()
+    {
+        unique_lock lock{m_};
+        for(;;)
+        {
+            for(auto iter : workers_)
+                iter->sample();
+
+            using namespace std::chrono;
+            clock_type::time_point const when(
+                floor <seconds>(
+                    clock_type::now().time_since_epoch()) +
+                        milliseconds(900));
+
+            if(cond_.wait_until(lock, when, [this]{ return stop_; }))
+                return;
+        }
+    }
+
+    static seconds_clock_thread& instance()
+    {
+        static seconds_clock_thread singleton;
+        return singleton;
+    }
+};
+
+} // detail
+
+//------------------------------------------------------------------------------
+
+/** Called before main exits to terminate the utility thread.
+    This is a workaround for Visual Studio 2013:
+    http://connect.microsoft.com/VisualStudio/feedback/details/786016/creating-a-global-c-object-that-used-thread-join-in-its-destructor-causes-a-lockup
+    http://stackoverflow.com/questions/10915233/stdthreadjoin-hangs-if-called-after-main-exits-when-using-vs2012-rc
+*/
+inline
+void
+basic_seconds_clock_main_hook()
+{
+#ifdef _MSC_VER
+    detail::seconds_clock_thread::instance().stop();
+#endif
+}
+
+/** A clock whose minimum resolution is one second.
+
+    The purpose of this class is to optimize the performance of the now()
+    member function call. It uses a dedicated thread that wakes up at least
+    once per second to sample the requested trivial clock.
+
+    @tparam Clock A type meeting these requirements:
+        http://en.cppreference.com/w/cpp/concept/Clock
+*/
+template<class Clock>
+class basic_seconds_clock
+{
+public:
+    using rep = typename Clock::rep;
+    using period = typename Clock::period;
+    using duration = typename Clock::duration;
+    using time_point = typename Clock::time_point;
+
+    static bool const is_steady = Clock::is_steady;
+
+    static time_point now()
+    {
+        // Make sure the thread is constructed before the
+        // worker otherwise we will crash during destruction
+        // of objects with static storage duration.
+        struct initializer
+        {
+            initializer()
+            {
+                detail::seconds_clock_thread::instance();
+            }
+        };
+        static initializer init;
+
+        struct worker : detail::seconds_clock_worker
+        {
+            time_point m_now;
+            std::mutex m_;
+
+            worker()
+                : m_now(Clock::now())
+            {
+                detail::seconds_clock_thread::instance().add(*this);
+            }
+
+            ~worker()
+            {
+                detail::seconds_clock_thread::instance().remove(*this);
+            }
+
+            time_point now()
+            {
+                std::lock_guard<std::mutex> lock{m_};
+                return m_now;
+            }
+
+            void sample()
+            {
+                std::lock_guard<std::mutex> lock{m_};
+                m_now = Clock::now();
+            }
+        };
+
+        static worker w;
+
+        return w.now();
+    }
+};
+
+#endif

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

@@ -0,0 +1,58 @@
+//
+// 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_EXPERIMENTAL_CHRONO_UTIL_HPP
+#define NUDB_EXPERIMENTAL_CHRONO_UTIL_HPP
+
+#include <chrono>
+
+// From Howard Hinnant
+// http://home.roadrunner.com/~hinnant/duration_io/chrono_util.html
+
+#if !defined(_MSC_FULL_VER) || (_MSC_FULL_VER <= 190023506)
+// round down
+template <class To, class Rep, class Period>
+To floor(std::chrono::duration <Rep, Period> const& d)
+{
+    To t = std::chrono::duration_cast<To>(d);
+    if (t > d)
+        --t;
+    return t;
+}
+
+// round to nearest, to even on tie
+template <class To, class Rep, class Period>
+To round (std::chrono::duration <Rep, Period> const& d)
+{
+    To t0 = std::chrono::duration_cast<To>(d);
+    To t1 = t0;
+    ++t1;
+    auto diff0 = d - t0;
+    auto diff1 = t1 - d;
+    if (diff0 == diff1)
+    {
+        if (t0.count() & 1)
+            return t1;
+        return t0;
+    }
+    else if (diff0 < diff1)
+        return t0;
+    return t1;
+}
+
+// round up
+template <class To, class Rep, class Period>
+To ceil (std::chrono::duration <Rep, Period> const& d)
+{
+    To t = std::chrono::duration_cast<To>(d);
+    if (t < d)
+        ++t;
+    return t;
+}
+#endif
+
+#endif