cursor.h

Go to the documentation of this file.

/*-------------------------------------------------------------------------
 *
 *   FILE
 *      pqxx/cursor.h
 *
 *   DESCRIPTION
 *      definition of the pqxx::Cursor class.
 *   pqxx::Cursor represents a database cursor.
 *
 * Copyright (c) 2001-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.
 *
 *-------------------------------------------------------------------------
 */
#ifndef PQXX_OLD_CURSOR_H
#define PQXX_OLD_CURSOR_H

#include "pqxx/result.h"
#include "pqxx/transaction_base.h"
#include "pqxx/util.h"

/* Methods tested in eg. self-test program test001 are marked with "//[t1]"
 */

namespace pqxx
{
class result;


// Work around bug in CodeWarrior 8.3
#ifdef __MWERKS__
#pragma defer_defarg_parsing on
#endif



class PQXX_LIBEXPORT Cursor
{
  enum { dist_next=1 };

public:
  typedef result::size_type size_type;
  typedef result::difference_type difference_type;

  enum pos { pos_unknown = -1, pos_start = 0 };

  struct PQXX_LIBEXPORT unknown_position : PGSTD::runtime_error
  {
    unknown_position(const PGSTD::string &cursorname) :
      PGSTD::runtime_error("Position for cursor '" + cursorname + "' "
                           "is unknown") 
    {
    }
  };


  template<typename TRANSACTION> 
    Cursor(TRANSACTION &T,
           const char Query[], 
           const PGSTD::string &BaseName="cur",
           difference_type Count=dist_next) :                           //[t3]
      m_Trans(T),
      m_Name(),
      m_Count(Count),
      m_Done(false),
      m_Pos(pos_start),
      m_Size(pos_unknown)
  {
    // Trigger build error if T has insufficient isolation level
    error_permitted_isolation_level(PQXX_TYPENAME TRANSACTION::isolation_tag());
    init(BaseName, Query);
  }


  template<typename TRANSACTION>
    Cursor(TRANSACTION &T,
           const result::field &Name,
           difference_type Count=dist_next) :                           //[t45]
      m_Trans(T),
      m_Name(Name.c_str()),
      m_Count(Count),
      m_Done(false),
      m_Pos(size_type(pos_unknown)),
      m_Size(size_type(pos_unknown))
  {
    // Trigger build error if T has insufficient isolation level
    error_permitted_isolation_level(PQXX_TYPENAME TRANSACTION::isolation_tag());
  }

  difference_type SetCount(difference_type);                            //[t19]


  result Fetch(difference_type Count);                                  //[t19]


  difference_type Move(difference_type Count);                          //[t42]

  void MoveTo(size_type);                                               //[t44]


  static difference_type ALL() throw ();                                //[t3]

  static difference_type NEXT() throw () { return dist_next; }          //[t19]

  static difference_type PRIOR() throw () { return -1; }                //[t19]


  static difference_type BACKWARD_ALL() throw ();                       //[t19]


  Cursor &operator>>(result &);                                         //[t3]

  operator bool() const throw () { return !m_Done; }                    //[t3]
  bool operator!() const throw () { return m_Done; }                    //[t3]

  Cursor &operator+=(difference_type N) { Move(N); return *this;}       //[t19]
  Cursor &operator-=(difference_type N) { Move(-N); return *this;}      //[t19]


  size_type size() const throw () { return m_Size; }                    //[t44]


  size_type Pos() const throw (unknown_position)                        //[t43]
  {
    if (m_Pos==size_type(pos_unknown)) throw unknown_position(m_Name);
    return m_Pos;
  }


private:
  static PGSTD::string OffsetString(difference_type);
  void init(const PGSTD::string &BaseName, const char Query[]);
  PGSTD::string MakeFetchCmd(difference_type) const;
  difference_type NormalizedMove(difference_type Intended,
      difference_type Actual);

#ifndef PQXX_WORKAROUND_VC7


  template<typename ISOLATIONTAG> 
    static inline void error_permitted_isolation_level(ISOLATIONTAG) throw();

#if defined(__SUNPRO_CC)
  // Incorrect, but needed to compile with Sun CC
  template<> static void 
    error_permitted_level(isolation_traits<serializable>) throw() {}
#endif  // __SUNPRO_CC
#else
  // Incorrect, but needed to compile with Visual C++ 7
  template<> static inline void 
    error_permitted_isolation_level(isolation_traits<serializable>) throw ();
#endif

  transaction_base &m_Trans;
  PGSTD::string m_Name;
  difference_type m_Count;
  bool m_Done;
  size_type m_Pos;
  difference_type m_Size;

  // Not allowed:
  Cursor(const Cursor &);
  Cursor &operator=(const Cursor &);
};

template<> inline void 
Cursor::error_permitted_isolation_level(isolation_traits<serializable>) throw ()
        {}

} // namespace pqxx

#endif

---