quasardb 3.14.2.dev1__cp38-cp38-win32.whl → 3.14.2.dev4__cp38-cp38-win32.whl

quasardb/ts_iterator.hpp

@@ -1,193 +0,0 @@
-#pragma once
-
-#include "remove_cvref.hpp"
-#include <iterator>
-
-// we need a std::swap(std::tuple<T&...>, std::tuple<T&...>) in sort
-// because we create a zip_iterator for both time_offsets and values
-// we need to swap them both at the same time
-namespace std
-{
-
-template <typename T>
-void swap(tuple<qdb_timespec_t &, T &> lhs, tuple<qdb_timespec_t &, T &> rhs)
-{
-    std::swap(std::get<0>(lhs), std::get<0>(rhs));
-    std::swap(std::get<1>(lhs), std::get<1>(rhs));
-}
-
-} // namespace std
-
-namespace qdb
-{
-
-template <typename T>
-class ts_iterator
-{
-    using iterators =
-        typename std::tuple<std::vector<qdb_timespec_t>::iterator, typename std::vector<T>::iterator>;
-
-public:
-    using difference_type   = std::ptrdiff_t;
-    using value_type        = std::tuple<qdb_timespec_t, T>;
-    using reference         = std::tuple<qdb_timespec_t &, T &>;
-    using pointer           = std::tuple<qdb_timespec_t *, T *>;
-    using iterator_category = std::random_access_iterator_tag;
-
-    ts_iterator() = default;
-
-    explicit ts_iterator(
-        std::vector<qdb_timespec_t>::iterator it_ts, typename std::vector<T>::iterator it_vs)
-        : _its(std::make_tuple(it_ts, it_vs))
-    {}
-
-    ts_iterator(const ts_iterator & other)
-        : _its(other._its)
-    {}
-
-    reference operator*() const
-    {
-        return std::tie((*std::get<0>(_its)), (*std::get<1>(_its)));
-    }
-
-    template <size_t I>
-    decltype(auto) get()
-    {
-        static_assert(I < 2, "index must be less than 2");
-        return std::get<I>(_its);
-    }
-
-    template <size_t I>
-    decltype(auto) get() const
-    {
-        static_assert(I < 2, "index must be less than 2");
-        return std::get<I>(_its);
-    }
-
-    reference operator[](difference_type i) const
-    {
-        return *(*this + i);
-    }
-
-    difference_type operator-(const ts_iterator & it) const
-    {
-        return std::get<0>(_its) - std::get<0>(it._its);
-    }
-
-    ts_iterator & operator+=(difference_type forward)
-    {
-        auto advance = [forward](auto & it) {
-            auto forward_to =
-                static_cast<typename std::iterator_traits<std::decay_t<decltype(it)>>::difference_type>(
-                    forward);
-            it = std::next(it, forward_to);
-        };
-        advance(std::get<0>(_its));
-        advance(std::get<1>(_its));
-
-        return *this;
-    }
-
-    ts_iterator & operator-=(difference_type backward)
-    {
-        return *this += -backward;
-    }
-
-    ts_iterator & operator++()
-    {
-        return *this += 1;
-    }
-
-    ts_iterator & operator--()
-    {
-        return *this -= 1;
-    }
-
-    ts_iterator operator++(int)
-    {
-        ts_iterator it(*this);
-
-        ++(*this);
-
-        return it;
-    }
-
-    ts_iterator operator--(int)
-    {
-        ts_iterator it(*this);
-
-        --(*this);
-
-        return it;
-    }
-
-    ts_iterator operator-(difference_type backward) const
-    {
-
-        ts_iterator it(*this);
-
-        return it -= backward;
-    }
-
-    ts_iterator operator+(difference_type forward) const
-    {
-
-        ts_iterator it(*this);
-
-        return it += forward;
-    }
-
-    friend ts_iterator operator+(difference_type forward, const ts_iterator & it)
-    {
-        return it + forward;
-    }
-
-    bool operator==(const ts_iterator & it) const
-    {
-
-        return *this - it == 0;
-    }
-
-    bool operator!=(const ts_iterator & it) const
-    {
-        return !(*this == it);
-    }
-
-    bool operator<(const ts_iterator & it) const
-    {
-        return *this - it < 0;
-    }
-
-    bool operator>(const ts_iterator & it) const
-    {
-        return it < *this;
-    }
-
-    bool operator<=(const ts_iterator & it) const
-    {
-        return !(*this > it);
-    }
-
-    bool operator>=(const ts_iterator & it) const
-    {
-        return !(*this < it);
-    }
-
-private:
-    iterators _its;
-};
-
-template <size_t I, typename T>
-inline decltype(auto) get(const qdb::ts_iterator<T> & it)
-{
-    return it.template get<I>();
-}
-
-} // namespace qdb
-
-template <typename Iterator>
-auto make_ts_iterator(std::vector<qdb_timespec_t>::iterator ts_it, Iterator vs_it)
-{
-    using value_type = typename std::iterator_traits<Iterator>::value_type;
-    return qdb::ts_iterator<value_type>(ts_it, vs_it);
-}

quasardb/utils/blob_deque.hpp

@@ -1,96 +0,0 @@
-#pragma once
-
-#include <qdb/client.h>
-#include <cassert>
-#include <cstddef>
-#include <cstring>
-#include <forward_list>
-#include <vector>
-
-namespace utils
-{
-
-/// Stores chunks of bytes. They stay stable in memory until the deque is cleared.
-class blob_deque
-{
-    struct blob_block
-    {
-        std::unique_ptr<char[]> storage;
-        size_t size;
-        size_t capacity;
-
-        explicit blob_block(size_t capacity)
-            // TODO(C++20): Use std::make_unique_for_overwrite.
-            : storage{std::make_unique<char[]>(capacity)}
-            , size{}
-            , capacity{capacity}
-        {}
-
-        bool can_store(size_t bytes_cnt) const noexcept
-        {
-            return bytes_cnt <= capacity - size;
-        }
-
-        qdb_blob_t add(qdb_blob_t blob) noexcept
-        {
-            assert(can_store(blob.content_length));
-            auto dst = qdb_blob_t{static_cast<void *>(storage.get() + size), blob.content_length};
-            std::memcpy(const_cast<void *>(dst.content), blob.content, blob.content_length);
-            size += blob.content_length;
-            return dst;
-        }
-
-        void clear() noexcept
-        {
-            size = 0;
-        }
-    };
-
-    std::forward_list<blob_block> _blocks;
-    decltype(_blocks)::iterator _cur_block;
-    size_t _filled_blocks_size = 0;
-
-public:
-    explicit blob_deque(size_t initial_capacity = 64)
-    {
-        _blocks.emplace_front(initial_capacity);
-        _cur_block = _blocks.begin();
-    }
-
-    qdb_blob_t add(qdb_blob_t blob)
-    {
-
-        while (!_cur_block->can_store(blob.content_length))
-        {
-            _filled_blocks_size += _cur_block->size;
-            auto next_it = _cur_block;
-            ++next_it;
-            if (next_it == _blocks.end())
-            {
-                const auto cap = std::max(blob.content_length, _cur_block->capacity * 2);
-                _cur_block     = _blocks.emplace_after(_cur_block, cap);
-                break;
-            }
-            _cur_block = next_it;
-        }
-        return _cur_block->add(blob);
-    }
-
-    // Keep allocated memory to reuse it in subsequent 'add' calls.
-    void clear()
-    {
-        for (auto & block : _blocks)
-        {
-            block.clear();
-        }
-        _cur_block          = _blocks.begin();
-        _filled_blocks_size = 0;
-    }
-
-    size_t bytes_count() const noexcept
-    {
-        return _filled_blocks_size + _cur_block->size;
-    }
-};
-
-} // namespace utils

quasardb/utils/ostream.hpp

@@ -1,17 +0,0 @@
-#pragma once
-
-#include <qdb/ts.h>
-
-template <typename Ostream>
-Ostream & operator<<(Ostream & os, qdb_timespec_t timestamp)
-{
-    os << "(" << timestamp.tv_sec << "," << timestamp.tv_nsec << ")";
-    return os;
-}
-
-template <typename Ostream>
-Ostream & operator<<(Ostream & os, qdb_ts_range_t range)
-{
-    os << "[" << range.begin << "," << range.end << "]";
-    return os;
-}

quasardb/utils/permutation.hpp

@@ -1,50 +0,0 @@
-#pragma once
-
-#include "stable_sort.hpp"
-#include <vector>
-
-namespace utils
-{
-
-template <typename RandomAccessIterator1, typename RandomAccessIterator2>
-void apply_permutation(RandomAccessIterator1 item_begin,
-    RandomAccessIterator1 item_end,
-    RandomAccessIterator2 ind_begin,
-    RandomAccessIterator2 ind_end)
-{
-    using Diff = typename std::iterator_traits<RandomAccessIterator1>::difference_type;
-    using std::swap;
-    Diff size = std::distance(item_begin, item_end);
-    for (Diff i = 0; i < size; i++)
-    {
-        auto current = i;
-        while (i != ind_begin[current])
-        {
-            auto next = ind_begin[current];
-            swap(item_begin[current], item_begin[next]);
-            ind_begin[current] = current;
-            current            = next;
-        }
-        ind_begin[current] = current;
-    }
-}
-
-template <typename Range1, typename Range2>
-void apply_permutation(Range1 & item_range, Range2 & ind_range)
-{
-    apply_permutation(
-        std::begin(item_range), std::end(item_range), std::begin(ind_range), std::end(ind_range));
-}
-
-template <typename T, typename Compare>
-std::vector<std::int64_t> sort_permutation(const std::vector<T> & vec, Compare && compare)
-{
-    std::vector<std::int64_t> order;
-    order.resize(vec.size());
-    std::iota(std::begin(order), std::end(order), 0);
-    stable_sort(std::begin(order), std::end(order),
-        [&](std::size_t i, std::size_t j) { return compare(vec[i], vec[j]); });
-    return order;
-}
-
-} // namespace utils

quasardb/utils/stable_sort.hpp

@@ -1,25 +0,0 @@
-#pragma once
-
-#include <algorithm>
-#include <functional>
-
-namespace utils
-{
-
-using std::stable_sort;
-
-template <class BidirContainer, class BinaryOp>
-void stable_sort(BidirContainer & c, BinaryOp && comparer)
-{
-    using std::begin;
-    using std::end;
-    stable_sort(begin(c), end(c), comparer);
-}
-
-template <class BidirContainer>
-void stable_sort(BidirContainer & c)
-{
-    stable_sort(c, std::less<typename BidirContainer::value_type>{});
-}
-
-} // namespace utils

quasardb/utils/unzip_view.hpp

@@ -1,89 +0,0 @@
-#pragma once
-
-#include <range/v3/range/concepts.hpp>
-#include <range/v3/view/transform.hpp>
-#include <iterator>
-#include <tuple>
-#include <type_traits>
-#include <utility>
-
-namespace qdb
-{
-
-template <std::size_t I, ranges::input_range R>
-inline decltype(auto) make_unzip_view(R const & input) noexcept
-{
-    using tuple_type = ranges::range_value_t<R>;
-
-    auto xform = [](tuple_type const & x) { return std::get<I>(x); };
-
-    return ranges::views::transform(input, xform);
-}
-
-template <std::size_t I>
-struct view_unzipper
-{
-    template <ranges::input_range R>
-    inline decltype(auto) operator()(R const &) = delete;
-};
-
-template <>
-struct view_unzipper<1>
-{
-    template <ranges::input_range R>
-    inline decltype(auto) operator()(R const & input)
-    {
-        return std::make_tuple(make_unzip_view<0>(input));
-    }
-};
-
-template <>
-struct view_unzipper<2>
-{
-    template <ranges::input_range R>
-    inline decltype(auto) operator()(R const & input)
-    {
-        return std::make_tuple(make_unzip_view<0>(input), make_unzip_view<1>(input));
-    }
-};
-
-template <>
-struct view_unzipper<3>
-{
-    template <ranges::input_range R>
-    inline decltype(auto) operator()(R const & input)
-    {
-        return std::make_tuple(
-            make_unzip_view<0>(input), make_unzip_view<1>(input), make_unzip_view<2>(input));
-    }
-};
-
-template <>
-struct view_unzipper<4>
-{
-    template <ranges::input_range R>
-    inline decltype(auto) operator()(R const & input)
-    {
-        return std::make_tuple(make_unzip_view<0>(input), make_unzip_view<1>(input),
-            make_unzip_view<2>(input), make_unzip_view<3>(input));
-    }
-};
-
-/**
- * Transforms a single range of tuples to a tuple of ranges, such that
- * std::get<I>(std::next(in, N)) becomes std::next(std::get<I>(out), N)
- *
- * TODO(leon): It isn't perfect, as we iterate over the input array multiple
- *             times, once for each type. A better approach would be to iterate
- *             once and build all sub-ranges out of it, but that approach
- *             doesn't map well to the existing ranges views / abstractions.
- */
-template <ranges::input_range R>
-inline constexpr decltype(auto) make_unzip_views(R const & input) noexcept
-{
-    using tuple_type = typename ranges::range_value_t<R>;
-    using tuple_size = std::tuple_size<tuple_type>;
-    return view_unzipper<tuple_size::value>{}(input);
-}
-
-}; // namespace qdb

quasardb/utils.cpp

@@ -1,28 +0,0 @@
-#include "utils.hpp"
-#include "traits.hpp"
-#include "convert/value.hpp"
-
-namespace qdb
-{
-
-std::vector<qdb_ts_range_t> convert_ranges(py::object xs)
-{
-    if (xs.is_none() == true)
-    {
-        return {traits::qdb_value<qdb_ts_range_t>::forever()};
-    };
-
-    std::vector<qdb_ts_range_t> ret;
-
-    // Must be a list
-    auto xs_ = xs.cast<py::list>();
-
-    ret.resize(xs_.size());
-    std::transform(xs_.begin(), xs_.end(), ret.begin(), [](py::handle x) -> qdb_ts_range_t {
-        return convert::value<py::tuple, qdb_ts_range_t>(py::cast<py::tuple>(x));
-    });
-
-    return ret;
-};
-
-}; // namespace qdb

quasardb/utils.hpp

@@ -1,174 +0,0 @@
-/*
- *
- * Official Python API
- *
- * Copyright (c) 2009-2024, quasardb SAS. All rights reserved.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *
- *    * Redistributions of source code must retain the above copyright
- *      notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above copyright
- *      notice, this list of conditions and the following disclaimer in the
- *      documentation and/or other materials provided with the distribution.
- *    * Neither the name of quasardb nor the names of its contributors may
- *      be used to endorse or promote products derived from this software
- *      without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY QUASARDB AND CONTRIBUTORS ``AS IS'' AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-#pragma once
-
-#include "handle.hpp"
-#include <qdb/client.h>
-#include <qdb/ts.h>
-#include <pybind11/numpy.h>
-#include <algorithm>
-#include <chrono>
-#include <string>
-#include <vector>
-
-namespace qdb
-{
-struct scoped_timer
-{
-    typedef std::chrono::time_point<std::chrono::high_resolution_clock> time_point_t;
-    using clock = std::chrono::high_resolution_clock;
-
-    std::string id_;
-    time_point_t start_;
-    scoped_timer(std::string id) noexcept
-        : id_{id}
-        , start_{clock::now()}
-    {}
-
-    ~scoped_timer() noexcept
-    {
-        done();
-    };
-
-    void done() noexcept
-    {
-        if (id_.empty() == false)
-        {
-            time_point_t end = clock::now();
-            auto delta       = end - start_;
-            std::cout << "[" << id_ << "] elapsed: "
-                      << std::chrono::duration_cast<std::chrono::milliseconds>(delta).count() << "ms"
-                      << std::endl;
-        };
-
-        id_.clear();
-    };
-};
-}; // namespace qdb
-
-static inline bool operator<(qdb_timespec_t const & lhs, qdb_timespec_t const & rhs)
-{
-    if (lhs.tv_sec < rhs.tv_sec)
-    {
-        return true;
-    }
-    else if (lhs.tv_sec == rhs.tv_sec)
-    {
-        return lhs.tv_nsec < rhs.tv_nsec;
-    }
-    else
-    {
-        return false;
-    }
-}
-
-static inline bool operator==(qdb_timespec_t const & lhs, qdb_timespec_t const & rhs)
-{
-    return lhs.tv_sec == rhs.tv_sec && lhs.tv_nsec == rhs.tv_nsec;
-}
-
-namespace qdb
-{
-
-/**
- * Simple guard class which always releases tracked objects back to qdb api.
- */
-template <typename T>
-class release_guard
-{
-public:
-    release_guard(handle_ptr handle) noexcept
-        : _handle(handle)
-        , _obj(nullptr)
-    {}
-
-    release_guard(handle_ptr handle, T obj) noexcept
-        : _handle(handle)
-        , _obj(obj)
-    {}
-
-    ~release_guard()
-    {
-        qdb_release(*_handle, _obj);
-    }
-
-    T get() const noexcept
-    {
-        return _obj;
-    }
-
-    T * ptr() noexcept
-    {
-        return &_obj;
-    }
-
-    T const * ptr() const noexcept
-    {
-        return &_obj;
-    }
-
-private:
-    handle_ptr _handle;
-    T _obj;
-};
-
-static inline std::vector<std::string> convert_strings_and_release(
-    qdb::handle_ptr h, const char ** ss, size_t c)
-{
-    std::vector<std::string> res(c);
-
-    std::transform(ss, ss + c, res.begin(), [](const char * s) { return std::string{s}; });
-
-    qdb_release(*h, ss);
-
-    return res;
-}
-
-std::vector<qdb_ts_range_t> convert_ranges(py::object xs);
-
-template <typename PointType>
-static inline size_t max_length(const PointType * points, size_t count)
-{
-    if (!count) return 0;
-
-    return std::max_element(points, points + count,
-        [](const PointType & left, const PointType & right) {
-            return left.content_length < right.content_length;
-        })
-        ->content_length;
-}
-
-static inline std::string to_string(qdb_string_t s)
-{
-    return std::string(s.data, s.length);
-}
-
-} // namespace qdb