cursor.hxx

#ifndef PQXX_H_CURSOR
#define PQXX_H_CURSOR

#include "pqxx/compiler-public.hxx"
#include "pqxx/compiler-internal-pre.hxx"

#include <limits>
#include <stdexcept>

#include "pqxx/result.hxx"
#include "pqxx/transaction_base.hxx"


namespace pqxx
{

class PQXX_LIBEXPORT cursor_base
{
public:
  using size_type = result_size_type;
  using difference_type = result_difference_type;


  enum accesspolicy
  {
    forward_only,
    random_access
  };


  enum updatepolicy
  {
    read_only,
    update
  };


  enum ownershippolicy
  {
    owned,
    loose
  };

  cursor_base() =delete;
  cursor_base(const cursor_base &) =delete;
  cursor_base &operator=(const cursor_base &) =delete;



  static difference_type all() noexcept;                                //[t81]


  static difference_type next() noexcept { return 1; }                  //[t81]


  static difference_type prior() noexcept { return -1; }                //[t00]


  static difference_type backward_all() noexcept;                       //[t00]



  const std::string &name() const noexcept { return m_name; }           //[t81]

protected:
  cursor_base(
        connection_base &,
        const std::string &Name,
        bool embellish_name=true);

  const std::string m_name;
};
} // namespace pqxx


#include <pqxx/internal/sql_cursor.hxx>


namespace pqxx
{

template<cursor_base::updatepolicy up, cursor_base::ownershippolicy op>
class stateless_cursor
{
public:
  using size_type = result_size_type;
  using difference_type = result_difference_type;

  stateless_cursor(
        transaction_base &trans,
        const std::string &query,
        const std::string &cname,
        bool hold) :
    m_cur{trans, query, cname, cursor_base::random_access, up, op, hold}
  {
  }

  stateless_cursor(
        transaction_base &trans,
        const std::string adopted_cursor) :
    m_cur{trans, adopted_cursor, op}
  {
    // Put cursor in known position
    m_cur.move(cursor_base::backward_all());
  }

  void close() noexcept { m_cur.close(); }


  size_type size() { return internal::obtain_stateless_cursor_size(m_cur); }


  result retrieve(difference_type begin_pos, difference_type end_pos)
  {
    return internal::stateless_cursor_retrieve(
        m_cur,
        result::difference_type(size()),
        begin_pos,
        end_pos);
  }

  const std::string &name() const noexcept { return m_cur.name(); }

private:
  internal::sql_cursor m_cur;
};


class icursor_iterator;


namespace internal
{
namespace gate
{
class icursor_iterator_icursorstream;
class icursorstream_icursor_iterator;
} // namespace internal::gate
} // namespace internal



class PQXX_LIBEXPORT icursorstream
{
public:
  using size_type = cursor_base::size_type;
  using difference_type = cursor_base::difference_type;


  icursorstream(
        transaction_base &context,
        const std::string &query,
        const std::string &basename,
        difference_type sstride=1);                                     //[t81]


  icursorstream(
        transaction_base &context,
        const field &cname,
        difference_type sstride=1,
        cursor_base::ownershippolicy op=cursor_base::owned);            //[t84]

  operator bool() const noexcept { return not m_done; }


  icursorstream &get(result &res) { res = fetchblock(); return *this; } //[t81]

  icursorstream &operator>>(result &res) { return get(res); }           //[t81]


  icursorstream &ignore(std::streamsize n=1);                           //[t81]


  void set_stride(difference_type stride);                              //[t81]
  difference_type stride() const noexcept { return m_stride; }          //[t81]

private:
  result fetchblock();

  friend class internal::gate::icursorstream_icursor_iterator;
  size_type forward(size_type n=1);
  void insert_iterator(icursor_iterator *) noexcept;
  void remove_iterator(icursor_iterator *) const noexcept;

  void service_iterators(difference_type);

  internal::sql_cursor m_cur;

  difference_type m_stride;
  difference_type m_realpos, m_reqpos;

  mutable icursor_iterator *m_iterators;

  bool m_done;
};



class PQXX_LIBEXPORT icursor_iterator
{
public:
  using iterator_category = std::input_iterator_tag;
  using value_type = result;
  using pointer = const result *;
  using reference = const result &;
  using istream_type = icursorstream;
  using size_type = istream_type::size_type;
  using difference_type = istream_type::difference_type;

  icursor_iterator() noexcept;                                          //[t84]
  explicit icursor_iterator(istream_type &) noexcept;                   //[t84]
  icursor_iterator(const icursor_iterator &) noexcept;                  //[t84]
  ~icursor_iterator() noexcept;

  const result &operator*() const { refresh(); return m_here; }         //[t84]
  const result *operator->() const { refresh(); return &m_here; }       //[t84]
  icursor_iterator &operator++();                                       //[t84]
  icursor_iterator operator++(int);                                     //[t84]
  icursor_iterator &operator+=(difference_type);                        //[t84]
  icursor_iterator &operator=(const icursor_iterator &) noexcept;       //[t84]

  bool operator==(const icursor_iterator &rhs) const;                   //[t84]
  bool operator!=(const icursor_iterator &rhs) const noexcept           //[t84]
        { return not operator==(rhs); }
  bool operator<(const icursor_iterator &rhs) const;                    //[t84]
  bool operator>(const icursor_iterator &rhs) const                     //[t84]
        { return rhs < *this; }
  bool operator<=(const icursor_iterator &rhs) const                    //[t84]
        { return not (*this > rhs); }
  bool operator>=(const icursor_iterator &rhs) const                    //[t84]
        { return not (*this < rhs); }

private:
  void refresh() const;

  friend class internal::gate::icursor_iterator_icursorstream;
  difference_type pos() const noexcept { return m_pos; }
  void fill(const result &);

  icursorstream *m_stream = nullptr;
  result m_here;
  difference_type m_pos;
  icursor_iterator *m_prev = nullptr, *m_next = nullptr;
};
} // namespace pqxx

#include "pqxx/compiler-internal-post.hxx"
#endif