result.h

#pragma once
 
#include <ozo/impl/result.h>
#include <boost/iterator/iterator_facade.hpp>
#include <memory>
#include <vector>
 
 
namespace ozo {
 
#ifndef OZO_DOCUMENTATION
template <typename Result>
#endif
class value {
public:
    struct coordinates {
        const Result* res;
        int row;
        int col;
    };
 
    value(const coordinates& v) noexcept : v_(v) {}
 
    oid_t oid() const noexcept {
        return impl::field_type(res(), column());
    }
 
    bool is_text() const noexcept {
        return impl::field_format(res(), column()) == impl::result_format::text;
    }
 
    bool is_binary() const noexcept {
        return impl::field_format(res(), column()) == impl::result_format::binary;
    }
 
    const char* data() const noexcept {
        return impl::get_value(res(), row(), column());
    }
 
    std::size_t size() const noexcept {
        return impl::get_length(res(), row(), column());
    }
 
    bool is_null() const noexcept {
        return impl::get_isnull(res(), row(), column());
    }
 
private:
    int column() const noexcept { return v_.col;}
    int row() const noexcept { return v_.row;}
    const Result& res() const noexcept { return *(v_.res);}
 
    coordinates v_;
};
 
#ifndef OZO_DOCUMENTATION
template <typename Result>
#endif
class row {
public:
    using value = ozo::value<Result>;
    using coordinates = typename value::coordinates;
 
#ifdef OZO_DOCUMENTATION
 
    using const_iterator = <implementation defined>;
#else
    class const_iterator : public boost::iterator_facade<
        const_iterator,
        value,
        boost::random_access_traversal_tag,
        value,
        int
    > {
    public:
        const_iterator() = default;
        const_iterator(const coordinates& v) noexcept : v_{v} {}
 
    private:
        value dereference() const noexcept { return {v_}; }
 
        bool equal(const const_iterator& rhs) const noexcept {
            return v_.res == rhs.v_.res && v_.col == rhs.v_.col && v_.row == rhs.v_.row;
        }
 
        void increment() noexcept { advance(1); }
        void decrement() noexcept { advance(-1); }
        void advance(int n) noexcept { v_.col += n; }
 
        int distance_to(const const_iterator& z) noexcept { return z.col - v_.col; }
 
        coordinates v_ {nullptr, 0, 0};
 
        friend class boost::iterator_core_access;
    };
#endif
 
    using iterator = const_iterator;
 
    row(const coordinates& first) noexcept : first_(first) {}
 
    const_iterator begin() const noexcept { return {first_}; }
 
    const_iterator end() const noexcept { return begin() + size(); }
 
    const_iterator find(const char* name) const noexcept {
        int i = impl::field_number(*(first_.res), name);
        return i == -1 ? end() : begin() + i;
    }
 
    value operator[] (int index) const noexcept { return *(begin() + index); }
 
    std::size_t size() const noexcept { return impl::nfields(*(first_.res)); }
 
    [[nodiscard]] bool empty() const noexcept { return size() == 0; }
 
    value at(int index) const {
        if (index < 0 || static_cast<std::size_t>(index) >= size()) {
            throw std::out_of_range("ozo::row::at() field index "
                + std::to_string(index) + " out of range");
        }
        return (*this)[index];
    }
 
    value at(const char* name) const {
        auto i = find(name);
        if (i == end()) {
            throw std::out_of_range(std::string("ozo::row::at() no such field name ")
                + name);
        }
        return *i;
    }
 
private:
    coordinates first_;
};
 
template <typename T>
class basic_result {
public:
    using handle_type = T;
    using native_handle_type = decltype(std::addressof(*std::declval<handle_type>()));
    using row = ozo::row<std::decay_t<decltype(*std::declval<handle_type>())>>;
    using value = typename row::value;
    using coordinates = typename row::coordinates;
 
#ifdef OZO_DOCUMENTATION
 
    using const_iterator = <implementation defined>;
#else
    class const_iterator : public boost::iterator_facade<
        const_iterator,
        row,
        boost::random_access_traversal_tag,
        row,
        int
    > {
    public:
        const_iterator() = default;
        const_iterator(const coordinates& v) noexcept : v_{v} {}
 
    private:
        row dereference() const noexcept { return {v_}; }
 
        bool equal(const const_iterator& rhs) const noexcept {
            return v_.res == rhs.v_.res && v_.row == rhs.v_.row;
        }
 
        void increment() noexcept { advance(1); }
        void decrement() noexcept { advance(-1); }
        void advance(int n) noexcept { v_.row += n; }
 
        int distance_to(const const_iterator& z) noexcept { return z.row - v_.row; }
 
        coordinates v_ {nullptr, 0, 0};
 
        friend class boost::iterator_core_access;
    };
#endif
 
    using iterator = const_iterator;
 
    basic_result() = default;
    basic_result(handle_type res) noexcept(noexcept(handle_type(std::move(res))))
    : handle_(std::move(res)) {}
 
    template <typename Other, typename = hana::when<
        hana::is_convertible<Other, T>::value && !std::is_same_v<T, Other>
    >>
    basic_result(basic_result<Other>&& x) noexcept(
        noexcept(handle_type{hana::to<T>(std::move(x.release()))}))
    : handle_(hana::to<T>(std::move(x.release()))) {
    }
 
    const_iterator begin() const noexcept { return {{native_handle(), 0, 0}}; }
 
    const_iterator end() const noexcept { return begin() + size(); }
 
    std::size_t size() const noexcept { return impl::ntuples(*native_handle());}
 
    [[nodiscard]] bool empty() const noexcept { return size() == 0; }
 
    row operator[] (int i) const noexcept { return *(begin() + i); }
 
    row at(int i) const {
        if (i < 0 || static_cast<std::size_t>(i) >= size()) {
            throw std::out_of_range("ozo::result::at() index " + std::to_string(i) + " out of range");
        }
        return (*this)[i];
    }
 
    native_handle_type native_handle() const noexcept {
        return std::addressof(*handle_);
    }
 
    bool valid() const noexcept { return bool(handle_); }
 
    handle_type release() noexcept(std::is_nothrow_move_constructible_v<handle_type>) {
        return std::move(handle_);
    }
 
private:
 
    handle_type handle_;
};
 
using shared_result = basic_result<pg::shared_result>;
 
using result = basic_result<pg::result>;
 
template <typename T>
auto make_result(T&& handle) {
    return ozo::basic_result<std::decay_t<T>>(std::forward<T>(handle));
}
 
} // namespace ozo