cursor.hxx

Go to the documentation of this file.

/*-------------------------------------------------------------------------
 *
 *   FILE
 *      pqxx/cursor.hxx
 *
 *   DESCRIPTION
 *      definition of the iterator/container-style cursor classes
 *   C++-style wrappers for SQL cursors
 *   DO NOT INCLUDE THIS FILE DIRECTLY; include pqxx/pipeline instead.
 *
 * Copyright (c) 2004, Jeroen T. Vermeulen <jtv@xs4all.nl>
 *
 * See COPYING for copyright license.  If you did not receive a file called
 * COPYING with this source code, please notify the distributor of this mistake,
 * or contact the author.
 *
 *-------------------------------------------------------------------------
 */
#include "pqxx/libcompiler.h"

#ifdef PQXX_HAVE_LIMITS
#include <limits>
#endif

#include "pqxx/result"


namespace pqxx
{
class transaction_base;

class PQXX_LIBEXPORT cursor_base
{
public:
  typedef result::size_type size_type;
  typedef result::difference_type difference_type;


  operator void *() const { return m_done ? 0 : &s_dummy; }             //[t81]

  bool operator!() const { return m_done; }                             //[t81]


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

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

  static difference_type prior() throw () { return -1; }                //[t0]

  static difference_type backward_all() throw ();                       //[t0]


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

protected:
  cursor_base(transaction_base *,
      const PGSTD::string &cname,
      bool embellish_name = true);

  transaction_base *m_context;
  bool m_done;

private:
  int get_unique_cursor_num();

  PGSTD::string m_name;

  static unsigned char s_dummy;

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


inline cursor_base::difference_type cursor_base::all() throw ()
{
  // Microsoft Visual C++ sabotages numeric limits by defining min() and max()
  // as preprocessor macros; some other compilers just don't have numeric_limits
#if defined(PQXX_HAVE_LIMITS) && !defined(_MSC_VER)
  return PGSTD::numeric_limits<difference_type>::max();
#else
  return INT_MAX;
#endif
}

inline cursor_base::difference_type cursor_base::backward_all() throw ()
{
#if defined(PQXX_HAVE_LIMITS) && !defined(_MSC_VER)
  return PGSTD::numeric_limits<difference_type>::min() + 1;
#else
  return INT_MIN + 1;
#endif
}

class icursor_iterator;


class PQXX_LIBEXPORT icursorstream : public cursor_base
{
public:

  icursorstream(transaction_base &Context,
      const PGSTD::string &Query,
      const PGSTD::string &Basename,
      difference_type Stride=1);                                        //[t81]


  icursorstream(transaction_base &Context,
      const result::field &Name,
      difference_type Stride=1);                                        //[t84]


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

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

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


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

private:
  void declare(const PGSTD::string &query);
  result fetch();

  friend class icursor_iterator;
  size_type forward(size_type n=1);
  void insert_iterator(icursor_iterator *) throw ();
  void remove_iterator(icursor_iterator *) const throw ();

  void service_iterators(size_type);

  difference_type m_stride;
  size_type m_realpos, m_reqpos;

  mutable icursor_iterator *m_iterators;
};



class PQXX_LIBEXPORT icursor_iterator : 
  public PGSTD::iterator<PGSTD::input_iterator_tag, 
        result,
        cursor_base::size_type,
        const result *,
        const result &>
{
public:
  typedef icursorstream istream_type;
  typedef istream_type::size_type size_type;
  typedef istream_type::difference_type difference_type;

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

  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 &) throw ();       //[t84]

  bool operator==(const icursor_iterator &rhs) const;                   //[t84]
  bool operator!=(const icursor_iterator &rhs) const throw ()           //[t84]
        { return !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 !(*this > rhs); }
  bool operator>=(const icursor_iterator &rhs) const                    //[t84]
        { return !(*this < rhs); }

private:
  void refresh() const;

  friend class icursorstream;
  size_type pos() const throw () { return m_pos; }
  void fill(const result &) const;

  icursorstream *m_stream;
  mutable result m_here;
  size_type m_pos;
  icursor_iterator *m_prev, *m_next;
};


} // namespace pqxx

---