resultset.hpp

Go to the documentation of this file.

#ifndef TIP_DB_PG_RESULT_HPP_
#define TIP_DB_PG_RESULT_HPP_

#include <tip/db/pg/common.hpp>
#include <tip/db/pg/error.hpp>
#include <tip/db/pg/protocol_io_traits.hpp>

#include <iterator>
#include <istream>
#include <memory>
#include <tuple>

namespace tip {
namespace db {
namespace pg {

namespace detail {
struct result_impl;
}

class resultset {
public:

    typedef uinteger    size_type;
    typedef integer     difference_type;

    class row;
    class field;
    class const_row_iterator;

    typedef std::shared_ptr<detail::result_impl> result_impl_ptr;


    typedef const_row_iterator const_iterator;
    typedef std::reverse_iterator< const_iterator > const_reverse_iterator;

    typedef row value_type;
    typedef const value_type reference;
    typedef const_iterator pointer;


    class const_field_iterator;
    typedef std::reverse_iterator<const_field_iterator> const_reverse_field_iterator;
private:
    typedef resultset const* result_pointer;
public:
    static const size_type npos;
public:
    resultset();
    resultset(result_impl_ptr);

    size_type
    size() const; 
    bool
    empty() const; 
    const_iterator
    begin() const; 
    const_iterator
    end() const; 
    const_reverse_iterator
    rbegin() const; 
    const_reverse_iterator
    rend() const; 
    reference
    front() const;
    reference
    back() const;

    reference
    operator[](size_type index) const;
    reference
    at(size_type index) const;


    operator bool() const
    {
        return !empty();
    }
    bool
    operator!() const
    {
        return *this;
    }
public:

    size_type
    columns_size() const; 
    row_description_type const&
    row_description() const;
    size_type
    index_of_name(std::string const& name) const;

    field_description const&
    field(size_type col_index) const;

    field_description const&
    field(std::string const& name) const;

    std::string const&
    field_name(size_type col_index) const;
public:

    class row {
    public:
        typedef smallint                    size_type;
        typedef resultset::difference_type  difference_type;


        typedef const_field_iterator const_iterator;
        typedef const_reverse_field_iterator const_reverse_iterator;

        typedef class field value_type;
        typedef class field reference;
        typedef const_iterator pointer;
        static const size_type npos;
    public:
        size_type
        row_index() const 
        { return row_index_; }


        size_type
        size() const; 
        bool
        empty() const;

        const_iterator
        begin() const; 
        const_iterator
        end() const; 
        const_reverse_iterator
        rbegin() const;
        const_reverse_iterator
        rend() const;


        reference
        operator[](size_type index) const;
        reference
        operator[](std::string const& name) const;

        template < typename ... T >
        void
        to( std::tuple< T ... >& ) const;

        template < typename ... T >
        void
        to( std::tuple< T& ... > ) const;

        template < typename ... T >
        void
        to(T& ... ) const;
    protected:
        friend class resultset;
        row(result_pointer res, resultset::size_type idx)
            : result_(res), row_index_(idx) {}

        result_pointer          result_;
        resultset::size_type    row_index_;
    }; // row
    class field {
    public:
        size_type
        row_index() const 
        { return row_index_; }
        row::size_type
        field_index() const 
        { return field_index_; }

        std::string const&
        name() const; 
        field_description const&
        description() const; 
        bool
        is_null() const; 
        bool
        empty() const; 
        template < typename T >
        bool
        to( T& val ) const
        {
            if (is_null())
                throw error::value_is_null(name());
            return to_impl(val,
                    io::traits::has_parser<T, BINARY_DATA_FORMAT>() );
        }

        template < typename T >
        bool
        to( boost::optional< T >& val ) const
        {
            if (is_null()) {
                val = boost::optional< T >();
                return true;
            } else {
                typename std::decay<T>::type tmp;
                to_impl(tmp, io::traits::has_parser<T, BINARY_DATA_FORMAT>() );
                val = boost::optional< T > (tmp);
                return true;
            }
            return false;
        }

        template < typename T >
        typename std::decay<T>::type
        as() const
        {
            typename std::decay<T>::type val;
            to(val);
            return val;
        }
        template < typename T >
        typename std::decay<T>::type
        coalesce(T const& default_val)
        {
            if (is_null())
                return default_val;
            return as< T >();
        }
    private:
        template < typename T >
        bool
        to_impl( T& val, std::true_type const& ) const
        {
            field_description const& fd = description();
            field_buffer b = input_buffer();
            if (fd.format_code == TEXT_DATA_FORMAT) {
                io::protocol_read< TEXT_DATA_FORMAT >(b.begin(), b.end(), val);
            } else {
                io::protocol_read< BINARY_DATA_FORMAT >(b.begin(), b.end(), val);
            }
            return true;
        }

        template < typename T >
        bool
        to_impl( T& val, std::false_type const& ) const
        {
            field_buffer b = input_buffer();
            io::protocol_read< TEXT_DATA_FORMAT >(b.begin(), b.end(), val);
            return true;
        }

        field_buffer
        input_buffer() const;
    protected:
        friend class resultset;
        friend class row;
        field(result_pointer res, size_type row, row::size_type col) :
            result_(res), row_index_(row), field_index_(col) {}

        result_pointer  result_;
        size_type       row_index_;
        row::size_type  field_index_;
    }; // field


    class const_row_iterator : public row {
    public:

        typedef row value_type;
        typedef resultset::difference_type difference_type;
        typedef value_type reference;
        typedef value_type const* pointer;
        typedef std::random_access_iterator_tag iterator_category;
    public:
        const_row_iterator() : row(nullptr, npos) {}


        reference
        operator*() const
        {
            return reference(*this);
        }
        pointer
        operator->() const
        {
            return this;
        }


        operator bool() const
        { return result_ && row_index_ <= result_->size(); }
        bool
        operator !() const
        { return !(this->operator bool()); }


        const_row_iterator&
        operator++() 
        { return advance(1); }

        const_row_iterator
        operator++(int) 
        {
            const_row_iterator i(*this);
            advance(1);
            return i;
        }
        const_row_iterator&
        operator--() 
        { return advance(-1); }

        const_row_iterator
        operator--(int) 
        {
            const_row_iterator i(*this);
            advance(-1);
            return i;
        }

        const_row_iterator&
        operator += (difference_type distance)
        { return advance(distance); }
        const_row_iterator&
        operator -= (difference_type distance)
        { return advance(-distance); }


        bool
        operator == (const_row_iterator const& rhs) const
        { return compare(rhs) == 0; }

        bool
        operator != (const_row_iterator const& rhs) const
        { return !(*this == rhs); }

        bool
        operator < (const_row_iterator const& rhs) const
        { return compare(rhs) < 0; }
        bool
        operator <= (const_row_iterator const& rhs) const
        { return compare(rhs) <= 0; }
        bool
        operator > (const_row_iterator const& rhs) const
        { return compare(rhs) > 0; }
        bool
        operator >= (const_row_iterator const& rhs) const
        { return compare(rhs) >= 0; }

    private:
        friend class resultset;
        const_row_iterator(result_pointer res, resultset::size_type index)
            : row(res, index) {}
        int
        compare(const_row_iterator const& rhs) const;
        const_row_iterator&
        advance(difference_type);
    }; // const_row_iterator

    class const_field_iterator : public field {
    public:

        typedef field value_type;
        typedef resultset::difference_type difference_type;
        typedef value_type reference;
        typedef value_type const* pointer;
        typedef std::random_access_iterator_tag iterator_category;
    public:
        const_field_iterator() : field(nullptr, npos, npos) {}


        reference
        operator*() const
        {
            return reference(*this);
        }
        pointer
        operator->() const
        {
            return this;
        }


        operator bool() const
        { return result_
                && row_index_ < result_->size()
                && field_index_ <= result_->columns_size(); }
        bool
        operator !() const
        { return !(this->operator bool()); }


        const_field_iterator&
        operator++() 
        { return advance(1); }

        const_field_iterator
        operator++(int) 
        {
            const_field_iterator i(*this);
            advance(1);
            return i;
        }
        const_field_iterator&
        operator--() 
        { return advance(-1); }

        const_field_iterator
        operator--(int) 
        {
            const_field_iterator i(*this);
            advance(-1);
            return i;
        }

        const_field_iterator&
        operator += (difference_type distance)
        { return advance(distance); }
        const_field_iterator&
        operator -= (difference_type distance)
        { return advance(-distance); }


        bool
        operator == (const_field_iterator const& rhs) const
        { return compare(rhs) == 0; }

        bool
        operator != (const_field_iterator const& rhs) const
        { return !(*this == rhs); }

        bool
        operator < (const_field_iterator const& rhs) const
        { return compare(rhs) < 0; }
        bool
        operator <= (const_field_iterator const& rhs) const
        { return compare(rhs) <= 0; }
        bool
        operator > (const_field_iterator const& rhs) const
        { return compare(rhs) > 0; }
        bool
        operator >= (const_field_iterator const& rhs) const
        { return compare(rhs) >= 0; }
    private:
        friend class row;
        const_field_iterator(result_pointer res, size_type row, size_type col)
            : field(res, row, col) {}
        int
        compare(const_field_iterator const& rhs) const;
        const_field_iterator&
        advance(difference_type distance);
    }; // const_field_iterator
private:
    friend class row;
    friend class field;
    typedef std::shared_ptr<const detail::result_impl> const_result_impl_ptr;
    const_result_impl_ptr pimpl_;

    field_buffer
    at(size_type r, row::size_type c) const;

    bool
    is_null(size_type r, row::size_type c) const;
}; // resultset

inline resultset::row::difference_type
operator - (resultset::row const& a, resultset::row const& b)
{
    return a.row_index() - b.row_index();
}

}  // namespace pg
}  // namespace db
}  // namespace tip

#include <tip/db/pg/resultset.inl>

#endif /* TIP_DB_PG_RESULT_HPP_ */