//-----------------------------------------------------------------------------
//
// Copyright (c) 1998 - 2007, The Regents of the University of California
// Produced at the Lawrence Livermore National Laboratory
// All rights reserved.
//
// This file is part of PyCXX. For details,see http://cxx.sourceforge.net/. The
// full copyright notice is contained in the file COPYRIGHT located at the root
// of the PyCXX distribution.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// - Redistributions of source code must retain the above copyright notice,
// this list of conditions and the disclaimer below.
// - Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the disclaimer (as noted below) in the
// documentation and/or materials provided with the distribution.
// - Neither the name of the UC/LLNL nor the names of its contributors may be
// used to endorse or promote products derived from this software without
// specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OF THE UNIVERSITY OF
// CALIFORNIA, THE U.S. DEPARTMENT OF ENERGY OR CONTRIBUTORS BE LIABLE FOR
// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
// DAMAGE.
//
//-----------------------------------------------------------------------------
#ifndef __CXX_Objects__h
#define __CXX_Objects__h
#include "CXX/WrapPython.h"
#include "CXX/Version.hxx"
#include "CXX/Python3/Config.hxx"
#include "CXX/Python3/CxxDebug.hxx"
#include "CXX/Python3/Exception.hxx"
#include <iostream>
#include STR_STREAM
#include <string>
#include <iterator>
#include <utility>
#include <typeinfo>
namespace Py
{
typedef int sequence_index_type; // type of an index into a sequence
// Forward declarations
class Object;
class Type;
template<TEMPLATE_TYPENAME T> class SeqBase;
class Bytes;
class String;
class List;
template<TEMPLATE_TYPENAME T> class MapBase;
class Tuple;
class Dict;
//===========================================================================//
// class Object
// The purpose of this class is to serve as the most general kind of
// Python object, for the purpose of writing C++ extensions in Python
// Objects hold a PyObject* which they own. This pointer is always a
// valid pointer to a Python object. In children we must maintain this behavior.
//
// Instructions on how to make your own class MyType descended from Object:
// (0) Pick a base class, either Object or perhaps SeqBase<T> or MapBase<T>.
// This example assumes Object.
// (1) Write a routine int MyType_Check( PyObject * ) modeled after PyInt_Check,
// PyFloat_Check, etc.
// (2) Add method accepts:
// virtual bool accepts( PyObject *pyob ) const {
// return pyob && MyType_Check( pyob );
// }
// (3) Include the following constructor and copy constructor
//
/*
explicit MyType( PyObject *pyob ): Object( pyob )
{
validate();
}
MyType( const Object &other ): Object( other.ptr() )
{
validate();
}
*/
// Alernate version for the constructor to allow for construction from owned pointers:
/*
explicit MyType( PyObject *pyob ): Object( pyob )
{
validate();
}
*/
// You may wish to add other constructors; see the classes below for examples.
// Each constructor must use "set" to set the pointer
// and end by validating the pointer you have created.
//( 4 ) Each class needs at least these two assignment operators:
/*
MyType &operator=( const Object &rhs )
{
return *this = *rhs;
}
Mytype &operator=( PyObject *rhsp )
{
if( ptr() != rhsp )
set( rhsp );
return *this;
}
*/
// Note on accepts: constructors call the base class
// version of a virtual when calling the base class constructor,
// so the test has to be done explicitly in a descendent.
// If you are inheriting from PythonExtension<T> to define an object
// note that it contains PythonExtension<T>::check
// which you can use in accepts when writing a wrapper class.
// See Demo/range.h and Demo/range.cxx for an example.
class Object
{
private:
// the pointer to the Python object
// Only Object sets this directly.
// The default constructor for Object sets it to Py_None and
// child classes must use "set" to set it
//
PyObject *p;
protected:
void set( PyObject *pyob, bool owned = false )
{
release();
p = pyob;
if( !owned )
{
Py::_XINCREF( p );
}
validate();
}
void release()
{
Py::_XDECREF( p );
p = NULL;
}
void validate();
public:
// Constructor acquires new ownership of pointer unless explicitly told not to.
explicit Object( PyObject *pyob=Py::_None(), bool owned = false )
: p( pyob )
{
if( !owned )
{
Py::_XINCREF( p );
}
validate();
}
// Copy constructor acquires new ownership of pointer
Object( const Object &ob )
: p( ob.p )
{
Py::_XINCREF( p );
validate();
}
// Assignment acquires new ownership of pointer
Object &operator=( const Object &rhs )
{
set( rhs.p );
return *this;
}
Object &operator=( PyObject *rhsp )
{
if( ptr() != rhsp )
set( rhsp );
return *this;
}
// Destructor
virtual ~Object()
{
release();
}
// Loaning the pointer to others, retain ownership
PyObject *operator*() const
{
return p;
}
// Explicit reference_counting changes
void increment_reference_count()
{
Py::_XINCREF( p );
}
void decrement_reference_count()
{
// not allowed to commit suicide, however
if( reference_count() == 1 )
throw RuntimeError( "Object::decrement_reference_count error." );
Py::_XDECREF( p );
}
// Would like to call this pointer() but messes up STL in SeqBase<T>
PyObject *ptr() const
{
return p;
}
//
// Queries
//
// Can pyob be used in this object's constructor?
virtual bool accepts( PyObject *pyob ) const
{
// allow any object or NULL
return true;
}
Py_ssize_t reference_count() const
{ // the reference count
return p ? p->ob_refcnt : 0;
}
Type type() const; // the type object associated with this one
String str() const; // the str() representation
std::string as_string() const;
String repr() const; // the repr() representation
List dir() const; // the dir() list
bool hasAttr( const std::string &s ) const
{
return PyObject_HasAttrString( p, const_cast<char*>( s.c_str() ) ) ? true: false;
}
Object getAttr( const std::string &s ) const
{
return Object( PyObject_GetAttrString( p, const_cast<char*>( s.c_str() ) ), true );
}
Object callMemberFunction( const std::string &function_name ) const;
Object callMemberFunction( const std::string &function_name, const Tuple &args ) const;
Object callMemberFunction( const std::string &function_name, const Tuple &args, const Dict &kw ) const;
Object getItem( const Object &key ) const
{
return Object( PyObject_GetItem( p, *key ), true );
}
Py_hash_t hashValue() const
{
return PyObject_Hash( p );
}
// convert to bool
bool as_bool() const
{
return PyObject_IsTrue( ptr() ) != 0;
}
//operator bool() const
//{
// return as_bool();
//}
// int print( FILE *fp, int flags=Py_Print_RAW )
//{
// return PyObject_Print( p, fp, flags );
//}
bool is( PyObject *pother ) const
{ // identity test
return p == pother;
}
bool is( const Object &other ) const
{ // identity test
return p == other.p;
}
bool isNull() const
{
return p == NULL;
}
bool isNone() const
{
return p == _None();
}
bool isCallable() const
{
return PyCallable_Check( p ) != 0;
}
bool isDict() const
{
return Py::_Dict_Check( p );
}
bool isList() const
{
return Py::_List_Check( p );
}
bool isMapping() const
{
return PyMapping_Check( p ) != 0;
}
bool isNumeric() const
{
return PyNumber_Check( p ) != 0;
}
bool isSequence() const
{
return PySequence_Check( p ) != 0;
}
bool isTrue() const
{
return PyObject_IsTrue( p ) != 0;
}
bool isType( const Type &t ) const;
bool isTuple() const
{
return Py::_Tuple_Check( p );
}
bool isString() const
{
return Py::_Unicode_Check( p );
}
bool isBytes() const
{
return Py::_Bytes_Check( p );
}
bool isBoolean() const
{
return Py::_Boolean_Check( p );
}
// Commands
void setAttr( const std::string &s, const Object &value )
{
if( PyObject_SetAttrString( p, const_cast<char*>( s.c_str() ), *value ) == -1 )
throw AttributeError( "getAttr failed." );
}
void delAttr( const std::string &s )
{
if( PyObject_DelAttrString( p, const_cast<char*>( s.c_str() ) ) == -1 )
throw AttributeError( "delAttr failed." );
}
// PyObject_SetItem is too weird to be using from C++
// so it is intentionally omitted.
void delItem( const Object &key )
{
//if( PyObject_DelItem( p, *key ) == -1 )
// failed to link on Windows?
throw KeyError( "delItem failed." );
}
// Equality and comparison use PyObject_Compare
};
// End of class Object
// Null can be return from when it is require to return NULL to Python from a method
class Null: public Object
{
public:
Null()
: Object( NULL )
{
}
virtual ~Null()
{
}
virtual bool accepts( PyObject *pyob ) const
{
return pyob == NULL;
}
};
//------------------------------------------------------------
bool operator==( const Object &o1, const Object &o2 );
bool operator!=( const Object &o1, const Object &o2 );
bool operator>=( const Object &o1, const Object &o2 );
bool operator<=( const Object &o1, const Object &o2 );
bool operator<( const Object &o1, const Object &o2 );
bool operator>( const Object &o1, const Object &o2 );
//------------------------------------------------------------
//
// Convert an owned Python pointer into a PyCXX Object
//
inline Object asObject( PyObject *p )
{
return Object( p, true );
}
// new_reference_to also overloaded below on Object
inline PyObject *new_reference_to( PyObject *p )
{
Py::_XINCREF( p );
return p;
}
inline PyObject *new_reference_to( const Object &g )
{
PyObject *p = g.ptr();
Py::_XINCREF( p );
return p;
}
// Python special None value
inline Object None()
{
return Object( Py::_None() );
}
// Python special Boolean values
inline Object False()
{
return Object( Py::_False() );
}
inline Object True()
{
return Object( Py::_True() );
}
// TMM: 31May'01 - Added the #ifndef so I can exlude iostreams.
#ifndef CXX_NO_IOSTREAMS
std::ostream &operator<<( std::ostream &os, const Object &ob );
#endif
// Class Type
class Type: public Object
{
public:
explicit Type( PyObject *pyob, bool owned = false )
: Object( pyob, owned )
{
validate();
}
Type( const Object &ob )
: Object( *ob )
{
validate();
}
Type( const Type &t )
: Object( t )
{
validate();
}
Type &operator=( const Object &rhs )
{
return *this = *rhs;
}
Type &operator=( PyObject *rhsp )
{
if( ptr() != rhsp )
set( rhsp );
return *this;
}
virtual bool accepts( PyObject *pyob ) const
{
return pyob && Py::_Type_Check( pyob );
}
};
// ===============================================
// class boolean
class Boolean: public Object
{
public:
// Constructor
Boolean( PyObject *pyob, bool owned = false )
: Object( pyob, owned )
{
validate();
}
Boolean( const Boolean &ob )
: Object( *ob )
{
validate();
}
// create from bool
Boolean( bool v=false )
{
set( PyBool_FromLong( v ? 1 : 0 ), true );
validate();
}
explicit Boolean( const Object &ob )
: Object( *ob )
{
validate();
}
// Assignment acquires new ownership of pointer
Boolean &operator=( const Object &rhs )
{
return *this = *rhs;
}
Boolean &operator=( PyObject *rhsp )
{
if( ptr() != rhsp )
set( rhsp );
return *this;
}
// Membership
virtual bool accepts( PyObject *pyob ) const
{
// accepts any object that can be converted to a boolean
return pyob && PyObject_IsTrue( pyob ) != -1;
}
Boolean &operator=( bool v )
{
set( PyBool_FromLong( v ? 1 : 0 ), true );
return *this;
}
operator bool() const
{
return as_bool();
}
};
// ===============================================
// class Long
class Long: public Object
{
public:
// Constructor
explicit Long( PyObject *pyob, bool owned = false )
: Object( pyob, owned )
{
validate();
}
Long( const Long &ob )
: Object( ob.ptr() )
{
validate();
}
// try to create from any object
explicit Long( const Object &ob )
: Object( PyNumber_Long( *ob ), true )
{
validate();
}
// create from long
explicit Long( long v = 0L )
: Object( PyLong_FromLong( v ), true )
{
validate();
}
// create from unsigned long
explicit Long( unsigned long v )
: Object( PyLong_FromUnsignedLong( v ), true )
{
validate();
}
// create from int
explicit Long( int v )
: Object( PyLong_FromLong( static_cast<long>( v ) ), true )
{
validate();
}
#ifdef HAVE_LONG_LONG
// create from long long
explicit Long( PY_LONG_LONG v )
: Object( PyLong_FromLongLong( v ), true )
{
validate();
}
// create from unsigned long long
explicit Long( unsigned PY_LONG_LONG v )
: Object( PyLong_FromUnsignedLongLong( v ), true )
{
validate();
}
#endif
// Membership
virtual bool accepts( PyObject *pyob ) const
{
return pyob && Py::_Long_Check( pyob );
}
// Assignment acquires new ownership of pointer
Long &operator=( const Object &rhs )
{
return *this = *rhs;
}
Long &operator=( PyObject *rhsp )
{
if( ptr() != rhsp )
set( PyNumber_Long( rhsp ), true );
return *this;
}
// assign from an int
Long &operator=( int v )
{
set( PyLong_FromLong( long( v ) ), true );
return *this;
}
// assign from long
Long &operator=( long v )
{
set( PyLong_FromLong( v ), true );
return *this;
}
// assign from unsigned long
Long &operator=( unsigned long v )
{
set( PyLong_FromUnsignedLong( v ), true );
return *this;
}
#ifdef HAVE_LONG_LONG
Long &operator=( PY_LONG_LONG v )
{
set( PyLong_FromLongLong( v ), true );
return *this;
}
Long &operator=( unsigned PY_LONG_LONG v )
{
set( PyLong_FromUnsignedLongLong( v ), true );
return *this;
}
#endif
//operator bool() const
//{
// return as_bool();
//}
// convert to long
long as_long() const
{
return PyLong_AsLong( ptr() );
}
operator long() const
{
return as_long();
}
operator int() const
{
return static_cast<int>( as_long() );
}
// convert to unsigned
long as_unsigned_long() const
{
return PyLong_AsUnsignedLong( ptr() );
}
operator unsigned long() const
{
return as_unsigned_long();
}
double as_double() const
{
return PyLong_AsDouble( ptr() );
}
operator double() const
{
return as_double();
}
#ifdef HAVE_LONG_LONG
PY_LONG_LONG as_long_long() const
{
return PyLong_AsLongLong( ptr() );
}
operator PY_LONG_LONG() const
{
return as_long_long();
}
unsigned PY_LONG_LONG as_unsigned_long_long() const
{
return PyLong_AsUnsignedLongLong( ptr() );
}
operator unsigned PY_LONG_LONG() const
{
return as_unsigned_long_long();
}
#endif
// prefix ++
Long operator++()
{
set( PyNumber_Add( ptr(), *Long( 1 ) ) );
return *this;
}
// postfix ++
Long operator++( int )
{
Long a = *this;
set( PyNumber_Add( ptr(), *Long( 1 ) ) );
return a;
}
// prefix --
Long operator--()
{
set( PyNumber_Subtract( ptr(), *Long( 1 ) ) );
return *this;
}
// postfix --
Long operator--( int )
{
Long a = *this;
set( PyNumber_Subtract( ptr(), *Long( 1 ) ) );
return a;
}
};
#ifdef PYCXX_PYTHON_2TO3
// PyCXX for Python2 had an Int and LongLong classes
typedef Long Int;
#ifdef HAVE_LONG_LONG
typedef Long LongLong;
#endif
#endif
#if 1
//------------------------------------------------------------
// compare operators
bool operator!=( const Long &a, const Long &b );
bool operator!=( const Long &a, int b );
bool operator!=( const Long &a, long b );
bool operator!=( int a, const Long &b );
bool operator!=( long a, const Long &b );
//------------------------------
bool operator==( const Long &a, const Long &b );
bool operator==( const Long &a, int b );
bool operator==( const Long &a, long b );
bool operator==( int a, const Long &b );
bool operator==( long a, const Long &b );
//------------------------------
bool operator>( const Long &a, const Long &b );
bool operator>( const Long &a, int b );
bool operator>( const Long &a, long b );
bool operator>( int a, const Long &b );
bool operator>( long a, const Long &b );
//------------------------------
bool operator>=( const Long &a, const Long &b );
bool operator>=( const Long &a, int b );
bool operator>=( const Long &a, long b );
bool operator>=( int a, const Long &b );
bool operator>=( long a, const Long &b );
//------------------------------
bool operator<( const Long &a, const Long &b );
bool operator<( const Long &a, int b );
bool operator<( const Long &a, long b );
bool operator<( int a, const Long &b );
bool operator<( long a, const Long &b );
//------------------------------
bool operator<=( const Long &a, const Long &b );
bool operator<=( int a, const Long &b );
bool operator<=( long a, const Long &b );
bool operator<=( const Long &a, int b );
bool operator<=( const Long &a, long b );
#ifdef HAVE_LONG_LONG
//------------------------------
bool operator!=( const Long &a, PY_LONG_LONG b );
bool operator!=( PY_LONG_LONG a, const Long &b );
//------------------------------
bool operator==( const Long &a, PY_LONG_LONG b );
bool operator==( PY_LONG_LONG a, const Long &b );
//------------------------------
bool operator>( const Long &a, PY_LONG_LONG b );
bool operator>( PY_LONG_LONG a, const Long &b );
//------------------------------
bool operator>=( const Long &a, PY_LONG_LONG b );
bool operator>=( PY_LONG_LONG a, const Long &b );
//------------------------------
bool operator<( const Long &a, PY_LONG_LONG b );
bool operator<( PY_LONG_LONG a, const Long &b );
//------------------------------
bool operator<=( const Long &a, PY_LONG_LONG b );
bool operator<=( PY_LONG_LONG a, const Long &b );
#endif
#endif
// ===============================================
// class Float
//
class Float: public Object
{
public:
// Constructor
explicit Float( PyObject *pyob, bool owned = false )
: Object( pyob, owned )
{
validate();
}
Float( const Float &f )
: Object( f )
{
validate();
}
// make from double
explicit Float( double v=0.0 )
: Object( PyFloat_FromDouble( v ), true )
{
validate();
}
// try to make from any object
Float( const Object &ob )
: Object( PyNumber_Float( *ob ), true )
{
validate();
}
Float &operator=( const Object &rhs )
{
return *this = *rhs;
}
Float &operator=( PyObject *rhsp )
{
if( ptr() != rhsp )
set( PyNumber_Float( rhsp ), true );
return *this;
}
// Membership
virtual bool accepts( PyObject *pyob ) const
{
return pyob && Py::_Float_Check( pyob );
}
double as_double() const
{
return PyFloat_AsDouble( ptr() );
}
// convert to double
operator double() const
{
return as_double();
}
// assign from a double
Float &operator=( double v )
{
set( PyFloat_FromDouble( v ), true );
return *this;
}
// assign from an int
Float &operator=( int v )
{
set( PyFloat_FromDouble( double( v ) ), true );
return *this;
}
// assign from long
Float &operator=( long v )
{
set( PyFloat_FromDouble( double( v ) ), true );
return *this;
}
// assign from an Long
Float &operator=( const Long &iob )
{
set( PyFloat_FromDouble( double( iob.as_long() ) ), true );
return *this;
}
};
//------------------------------------------------------------
// compare operators
bool operator!=( const Float &a, const Float &b );
bool operator!=( const Float &a, double b );
bool operator!=( double a, const Float &b );
//------------------------------
bool operator==( const Float &a, const Float &b );
bool operator==( const Float &a, double b );
bool operator==( double a, const Float &b );
//------------------------------
bool operator>( const Float &a, const Float &b );
bool operator>( const Float &a, double b );
bool operator>( double a, const Float &b );
//------------------------------
bool operator>=( const Float &a, const Float &b );
bool operator>=( const Float &a, double b );
bool operator>=( double a, const Float &b );
//------------------------------
bool operator<( const Float &a, const Float &b );
bool operator<( const Float &a, double b );
bool operator<( double a, const Float &b );
//------------------------------
bool operator<=( const Float &a, const Float &b );
bool operator<=( double a, const Float &b );
bool operator<=( const Float &a, double b );
// ===============================================
// class Complex
class Complex: public Object
{
public:
// Constructor
explicit Complex( PyObject *pyob, bool owned = false )
: Object( pyob, owned )
{
validate();
}
Complex( const Complex &f )
: Object( f )
{
validate();
}
// make from double
explicit Complex( double v=0.0, double w=0.0 )
:Object( PyComplex_FromDoubles( v, w ), true )
{
validate();
}
Complex &operator=( const Object &rhs )
{
return *this = *rhs;
}
Complex &operator=( PyObject *rhsp )
{
if( ptr() != rhsp )
set( rhsp );
return *this;
}
// Membership
virtual bool accepts( PyObject *pyob ) const
{
return pyob && Py::_Complex_Check( pyob );
}
// convert to Py_complex
operator Py_complex() const
{
return PyComplex_AsCComplex( ptr() );
}
// assign from a Py_complex
Complex &operator=( const Py_complex &v )
{
set( PyComplex_FromCComplex( v ), true );
return *this;
}
// assign from a double
Complex &operator=( double v )
{
set( PyComplex_FromDoubles( v, 0.0 ), true );
return *this;
}
// assign from an int
Complex &operator=( int v )
{
set( PyComplex_FromDoubles( double( v ), 0.0 ), true );
return *this;
}
// assign from long
Complex &operator=( long v )
{
set( PyComplex_FromDoubles( double( v ), 0.0 ), true );
return *this;
}
// assign from an Long
Complex &operator=( const Long &iob )
{
set( PyComplex_FromDoubles( double( iob.as_long() ), 0.0 ), true );
return *this;
}
double real() const
{
return PyComplex_RealAsDouble( ptr() );
}
double imag() const
{
return PyComplex_ImagAsDouble( ptr() );
}
};
// Sequences
// Sequences are here represented as sequences of items of type T.
// The base class SeqBase<T> represents that.
// In basic Python T is always "Object".
// seqref<T> is what you get if you get elements from a non-const SeqBase<T>.
// Note: seqref<T> could probably be a nested class in SeqBase<T> but that might stress
// some compilers needlessly. Simlarly for mapref later.
// While this class is not intended for enduser use, it needs some public
// constructors for the benefit of the STL.
// See Scott Meyer's More Essential C++ for a description of proxies.
// This application is even more complicated. We are doing an unusual thing
// in having a double proxy. If we want the STL to work
// properly we have to compromise by storing the rvalue inside. The
// entire Object API is repeated so that things like s[i].isList() will
// work properly.
// Still, once in a while a weird compiler message may occur using expressions like x[i]
// Changing them to Object( x[i] ) helps the compiler to understand that the
// conversion of a seqref to an Object is wanted.
template<TEMPLATE_TYPENAME T>
class seqref
{
protected:
SeqBase<T> &s; // the sequence
int offset; // item number
T the_item; // lvalue
public:
seqref( SeqBase<T> &seq, sequence_index_type j )
: s( seq )
, offset( j )
, the_item( s.getItem( j ) )
{}
seqref( const seqref<T> &range )
: s( range.s )
, offset( range.offset )
, the_item( range.the_item )
{}
// TMM: added this seqref ctor for use with STL algorithms
seqref( Object &obj )
: s( dynamic_cast< SeqBase<T>&>( obj ) )
, offset( NULL )
, the_item( s.getItem( offset ) )
{}
~seqref()
{}
operator T() const
{ // rvalue
return the_item;
}
seqref<T> &operator=( const seqref<T> &rhs )
{ //used as lvalue
the_item = rhs.the_item;
s.setItem( offset, the_item );
return *this;
}
seqref<T> &operator=( const T &ob )
{ // used as lvalue
the_item = ob;
s.setItem( offset, ob );
return *this;
}
// forward everything else to the item
PyObject *ptr() const
{
return the_item.ptr();
}
int reference_count() const
{ // the reference count
return the_item.reference_count();
}
Type type() const
{
return the_item.type();
}
String str() const;
String repr() const;
bool hasAttr( const std::string &attr_name ) const
{
return the_item.hasAttr( attr_name );
}
Object getAttr( const std::string &attr_name ) const
{
return the_item.getAttr( attr_name );
}
Object getItem( const Object &key ) const
{
return the_item.getItem( key );
}
Py_hash_t hashValue() const
{
return the_item.hashValue();
}
bool isCallable() const
{
return the_item.isCallable();
}
bool isInstance() const
{
return the_item.isInstance();
}
bool isDict() const
{
return the_item.isDict();
}
bool isList() const
{
return the_item.isList();
}
bool isMapping() const
{
return the_item.isMapping();
}
bool isNumeric() const
{
return the_item.isNumeric();
}
bool isSequence() const
{
return the_item.isSequence();
}
bool isTrue() const
{
return the_item.isTrue();
}
bool isType( const Type &t ) const
{
return the_item.isType( t );
}
bool isTuple() const
{
return the_item.isTuple();
}
bool isString() const
{
return the_item.isString();
}
// Commands
void setAttr( const std::string &attr_name, const Object &value )
{
the_item.setAttr( attr_name, value );
}
void delAttr( const std::string &attr_name )
{
the_item.delAttr( attr_name );
}
void delItem( const Object &key )
{
the_item.delItem( key );
}
bool operator==( const Object &o2 ) const
{
return the_item == o2;
}
bool operator!=( const Object &o2 ) const
{
return the_item != o2;
}
bool operator>=( const Object &o2 ) const
{
return the_item >= o2;
}
bool operator<=( const Object &o2 ) const
{
return the_item <= o2;
}
bool operator<( const Object &o2 ) const
{
return the_item < o2;
}
bool operator>( const Object &o2 ) const
{
return the_item > o2;
}
}; // end of seqref
// class SeqBase<T>
// ...the base class for all sequence types
template<TEMPLATE_TYPENAME T>
class SeqBase: public Object
{
public:
// STL definitions
typedef size_t size_type;
typedef seqref<T> reference;
typedef T const_reference;
typedef seqref<T> *pointer;
typedef int difference_type;
typedef T value_type; // TMM: 26Jun'01
virtual size_type max_size() const
{
return std::string::npos; // ?
}
virtual size_type capacity() const
{
return size();
}
virtual void swap( SeqBase<T> &c )
{
SeqBase<T> temp = c;
c = ptr();
set( temp.ptr() );
}
virtual size_type size() const
{
return PySequence_Length( ptr() );
}
explicit SeqBase<T>()
:Object( PyTuple_New( 0 ), true )
{
validate();
}
explicit SeqBase<T>( PyObject *pyob, bool owned=false )
: Object( pyob, owned )
{
validate();
}
SeqBase<T>( const Object &ob )
: Object( ob )
{
validate();
}
// Assignment acquires new ownership of pointer
SeqBase<T> &operator=( const Object &rhs )
{
return *this = *rhs;
}
SeqBase<T> &operator=( PyObject *rhsp )
{
if( ptr() != rhsp )
set( rhsp );
return *this;
}
virtual bool accepts( PyObject *pyob ) const
{
return pyob && PySequence_Check( pyob );
}
size_type length() const
{
return PySequence_Length( ptr() );
}
// Element access
const T operator[]( sequence_index_type index ) const
{
return getItem( index );
}
seqref<T> operator[]( sequence_index_type index )
{
return seqref<T>( *this, index );
}
virtual T getItem( sequence_index_type i ) const
{
return T( asObject( PySequence_GetItem( ptr(), i ) ) );
}
virtual void setItem( sequence_index_type i, const T &ob )
{
if( PySequence_SetItem( ptr(), i, *ob ) == -1 )
{
throw Exception();
}
}
SeqBase<T> repeat( int count ) const
{
return SeqBase<T>( PySequence_Repeat( ptr(), count ), true );
}
SeqBase<T> concat( const SeqBase<T> &other ) const
{
return SeqBase<T>( PySequence_Concat( ptr(), *other ), true );
}
// more STL compatability
const T front() const
{
return getItem( 0 );
}
seqref<T> front()
{
return seqref<T>( *this, 0 );
}
const T back() const
{
return getItem( size()-1 );
}
seqref<T> back()
{
return seqref<T>( *this, size()-1 );
}
void verify_length( size_type required_size ) const
{
if( size() != required_size )
throw IndexError( "Unexpected SeqBase<T> length." );
}
void verify_length( size_type min_size, size_type max_size ) const
{
size_type n = size();
if( n < min_size || n > max_size )
throw IndexError( "Unexpected SeqBase<T> length." );
}
class iterator
: public random_access_iterator_parent( seqref<T> )
{
protected:
friend class SeqBase<T>;
SeqBase<T> *seq;
int count;
public:
~iterator()
{}
iterator()
: seq( 0 )
, count( 0 )
{}
iterator( SeqBase<T> *s, int where )
: seq( s )
, count( where )
{}
iterator( const iterator &other )
: seq( other.seq )
, count( other.count )
{}
bool eql( const iterator &other ) const
{
return seq->ptr() == other.seq->ptr() && count == other.count;
}
bool neq( const iterator &other ) const
{
return seq->ptr() != other.seq->ptr() || count != other.count;
}
bool lss( const iterator &other ) const
{
return count < other.count;
}
bool gtr( const iterator &other ) const
{
return count > other.count;
}
bool leq( const iterator &other ) const
{
return count <= other.count;
}
bool geq( const iterator &other ) const
{
return count >= other.count;
}
seqref<T> operator*()
{
return seqref<T>( *seq, count );
}
seqref<T> operator[]( sequence_index_type i )
{
return seqref<T>( *seq, count + i );
}
iterator &operator=( const iterator &other )
{
if( this != &other )
{
seq = other.seq;
count = other.count;
}
return *this;
}
iterator operator+( int n ) const
{
return iterator( seq, count + n );
}
iterator operator-( int n ) const
{
return iterator( seq, count - n );
}
iterator &operator+=( int n )
{
count = count + n;
return *this;
}
iterator &operator-=( int n )
{
count = count - n;
return *this;
}
int operator-( const iterator &other ) const
{
if( seq->ptr() != other.seq->ptr() )
throw RuntimeError( "SeqBase<T>::iterator comparison error" );
return count - other.count;
}
// prefix ++
iterator &operator++()
{
count++;
return *this;
}
// postfix ++
iterator operator++( int )
{
return iterator( seq, count++ );
}
// prefix --
iterator &operator--()
{
count--;
return *this;
}
// postfix --
iterator operator--( int )
{
return iterator( seq, count-- );
}
std::string diagnose() const
{
std::OSTRSTREAM oss;
oss << "iterator diagnosis " << seq << ", " << count << std::ends;
return std::string( oss.str() );
}
}; // end of class SeqBase<T>::iterator
iterator begin()
{
return iterator( this, 0 );
}
iterator end()
{
return iterator( this, length() );
}
class const_iterator
: public random_access_iterator_parent( const Object )
{
protected:
friend class SeqBase<T>;
const SeqBase<T> *seq;
sequence_index_type count;
public:
~const_iterator()
{}
const_iterator()
: seq( 0 )
, count( 0 )
{}
const_iterator( const SeqBase<T> *s, int where )
: seq( s )
, count( where )
{}
const_iterator( const const_iterator &other )
: seq( other.seq )
, count( other.count )
{}
const T operator*() const
{
return seq->getItem( count );
}
const T operator[]( sequence_index_type i ) const
{
return seq->getItem( count + i );
}
const_iterator &operator=( const const_iterator &other )
{
if( this != &other )
{
seq = other.seq;
count = other.count;
}
return *this;
}
const_iterator operator+( int n ) const
{
return const_iterator( seq, count + n );
}
bool eql( const const_iterator &other ) const
{
return seq->ptr() == other.seq->ptr() && count == other.count;
}
bool neq( const const_iterator &other ) const
{
return seq->ptr() != other.seq->ptr() || count != other.count;
}
bool lss( const const_iterator &other ) const
{
return count < other.count;
}
bool gtr( const const_iterator &other ) const
{
return count > other.count;
}
bool leq( const const_iterator &other ) const
{
return count <= other.count;
}
bool geq( const const_iterator &other ) const
{
return count >= other.count;
}
const_iterator operator-( int n )
{
return const_iterator( seq, count - n );
}
const_iterator &operator+=( int n )
{
count = count + n;
return *this;
}
const_iterator &operator-=( int n )
{
count = count - n;
return *this;
}
int operator-( const const_iterator &other ) const
{
if( *seq != *other.seq )
throw RuntimeError( "SeqBase<T>::const_iterator::- error" );
return count - other.count;
}
// prefix ++
const_iterator &operator++()
{
count++;
return *this;
}
// postfix ++
const_iterator operator++( int )
{
return const_iterator( seq, count++ );
}
// prefix --
const_iterator &operator--()
{
count--;
return *this;
}
// postfix --
const_iterator operator--( int )
{
return const_iterator( seq, count-- );
}
}; // end of class SeqBase<T>::const_iterator
const_iterator begin() const
{
return const_iterator( this, 0 );
}
const_iterator end() const
{
return const_iterator( this, length() );
}
};
// Here's an important typedef you might miss if reading too fast...
typedef SeqBase<Object> Sequence;
template <TEMPLATE_TYPENAME T> bool operator==( const EXPLICIT_TYPENAME SeqBase<T>::iterator &left, const EXPLICIT_TYPENAME SeqBase<T>::iterator &right );
template <TEMPLATE_TYPENAME T> bool operator!=( const EXPLICIT_TYPENAME SeqBase<T>::iterator &left, const EXPLICIT_TYPENAME SeqBase<T>::iterator &right );
template <TEMPLATE_TYPENAME T> bool operator< ( const EXPLICIT_TYPENAME SeqBase<T>::iterator &left, const EXPLICIT_TYPENAME SeqBase<T>::iterator &right );
template <TEMPLATE_TYPENAME T> bool operator> ( const EXPLICIT_TYPENAME SeqBase<T>::iterator &left, const EXPLICIT_TYPENAME SeqBase<T>::iterator &right );
template <TEMPLATE_TYPENAME T> bool operator<=( const EXPLICIT_TYPENAME SeqBase<T>::iterator &left, const EXPLICIT_TYPENAME SeqBase<T>::iterator &right );
template <TEMPLATE_TYPENAME T> bool operator>=( const EXPLICIT_TYPENAME SeqBase<T>::iterator &left, const EXPLICIT_TYPENAME SeqBase<T>::iterator &right );
template <TEMPLATE_TYPENAME T> bool operator==( const EXPLICIT_TYPENAME SeqBase<T>::const_iterator &left, const EXPLICIT_TYPENAME SeqBase<T>::const_iterator &right );
template <TEMPLATE_TYPENAME T> bool operator!=( const EXPLICIT_TYPENAME SeqBase<T>::const_iterator &left, const EXPLICIT_TYPENAME SeqBase<T>::const_iterator &right );
template <TEMPLATE_TYPENAME T> bool operator< ( const EXPLICIT_TYPENAME SeqBase<T>::const_iterator &left, const EXPLICIT_TYPENAME SeqBase<T>::const_iterator &right );
template <TEMPLATE_TYPENAME T> bool operator> ( const EXPLICIT_TYPENAME SeqBase<T>::const_iterator &left, const EXPLICIT_TYPENAME SeqBase<T>::const_iterator &right );
template <TEMPLATE_TYPENAME T> bool operator<=( const EXPLICIT_TYPENAME SeqBase<T>::const_iterator &left, const EXPLICIT_TYPENAME SeqBase<T>::const_iterator &right );
template <TEMPLATE_TYPENAME T> bool operator>=( const EXPLICIT_TYPENAME SeqBase<T>::const_iterator &left, const EXPLICIT_TYPENAME SeqBase<T>::const_iterator &right );
extern bool operator==( const Sequence::iterator &left, const Sequence::iterator &right );
extern bool operator!=( const Sequence::iterator &left, const Sequence::iterator &right );
extern bool operator< ( const Sequence::iterator &left, const Sequence::iterator &right );
extern bool operator> ( const Sequence::iterator &left, const Sequence::iterator &right );
extern bool operator<=( const Sequence::iterator &left, const Sequence::iterator &right );
extern bool operator>=( const Sequence::iterator &left, const Sequence::iterator &right );
extern bool operator==( const Sequence::const_iterator &left, const Sequence::const_iterator &right );
extern bool operator!=( const Sequence::const_iterator &left, const Sequence::const_iterator &right );
extern bool operator< ( const Sequence::const_iterator &left, const Sequence::const_iterator &right );
extern bool operator> ( const Sequence::const_iterator &left, const Sequence::const_iterator &right );
extern bool operator<=( const Sequence::const_iterator &left, const Sequence::const_iterator &right );
extern bool operator>=( const Sequence::const_iterator &left, const Sequence::const_iterator &right );
// ==================================================
// class Char
// Python strings return strings as individual elements.
// I'll try having a class Char which is a String of length 1
//
typedef std::basic_string<Py_UNICODE> unicodestring;
extern Py_UNICODE unicode_null_string[1];
class Byte: public Object
{
public:
// Membership
virtual bool accepts( PyObject *pyob ) const
{
return pyob != NULL
&& Py::_Unicode_Check( pyob )
&& PySequence_Length( pyob ) == 1;
}
explicit Byte( PyObject *pyob, bool owned = false )
: Object( pyob, owned )
{
validate();
}
Byte( const Object &ob )
: Object( ob )
{
validate();
}
Byte( const std::string &v = "" )
: Object( PyBytes_FromStringAndSize( const_cast<char*>( v.c_str() ), 1 ), true )
{
validate();
}
Byte( char v )
: Object( PyBytes_FromStringAndSize( &v, 1 ), true )
{
validate();
}
// Assignment acquires new ownership of pointer
Byte &operator=( const Object &rhs )
{
return *this = *rhs;
}
Byte &operator=( PyObject *rhsp )
{
if( ptr() != rhsp )
set( rhsp );
return *this;
}
// Assignment from C string
Byte &operator=( const std::string &v )
{
set( PyBytes_FromStringAndSize( const_cast<char*>( v.c_str() ),1 ), true );
return *this;
}
Byte &operator=( char v )
{
set( PyUnicode_FromStringAndSize( &v, 1 ), true );
return *this;
}
// Conversion
operator Bytes() const;
};
class Bytes: public SeqBase<Byte>
{
public:
// Membership
virtual bool accepts( PyObject *pyob ) const
{
return pyob != NULL && Py::_Bytes_Check( pyob );
}
virtual size_type capacity() const
{
return max_size();
}
explicit Bytes( PyObject *pyob, bool owned = false )
: SeqBase<Byte>( pyob, owned )
{
validate();
}
Bytes( const Object &ob )
: SeqBase<Byte>( ob )
{
validate();
}
Bytes()
: SeqBase<Byte>( PyBytes_FromStringAndSize( "", 0 ), true )
{
validate();
}
Bytes( const std::string &v )
: SeqBase<Byte>( PyBytes_FromStringAndSize( const_cast<char*>( v.data() ), static_cast<int>( v.length() ) ), true )
{
validate();
}
Bytes( const std::string &v, Py_ssize_t vsize )
: SeqBase<Byte>( PyBytes_FromStringAndSize( const_cast<char*>( v.data() ), static_cast<int>( vsize ) ), true )
{
validate();
}
Bytes( const char *v )
: SeqBase<Byte>( PyBytes_FromString( v ), true )
{
validate();
}
Bytes( const char *v, Py_ssize_t vsize )
: SeqBase<Byte>( PyBytes_FromStringAndSize( const_cast<char*>( v ), vsize ), true )
{
validate();
}
// Assignment acquires new ownership of pointer
Bytes &operator=( const Object &rhs )
{
return *this = *rhs;
}
Bytes &operator=( PyObject *rhsp )
{
if( ptr() != rhsp )
set( rhsp );
return *this;
}
// Assignment from C string
Bytes &operator=( const std::string &v )
{
set( PyBytes_FromStringAndSize( const_cast<char*>( v.data() ), static_cast<int>( v.length() ) ), true );
return *this;
}
String decode( const char *encoding, const char *error="strict" );
// Queries
virtual size_type size() const
{
return static_cast<size_type>( PyBytes_Size( ptr() ) );
}
operator std::string() const
{
return as_std_string();
}
std::string as_std_string() const
{
return std::string( PyBytes_AsString( ptr() ), static_cast<size_type>( PyBytes_Size( ptr() ) ) );
}
};
class Char: public Object
{
public:
// Membership
virtual bool accepts( PyObject *pyob ) const
{
return pyob != 0 &&( Py::_Unicode_Check( pyob ) ) && PySequence_Length( pyob ) == 1;
}
explicit Char( PyObject *pyob, bool owned = false )
: Object( pyob, owned )
{
validate();
}
Char( const Object &ob )
: Object( ob )
{
validate();
}
Char( int v )
: Object( PyUnicode_FromOrdinal( v ), true )
{
validate();
}
Char( Py_UNICODE v )
: Object( PyUnicode_FromOrdinal( v ), true )
{
validate();
}
Char( const unicodestring &v )
: Object( PyUnicode_FromUnicode( const_cast<Py_UNICODE*>( v.data() ),1 ), true )
{
validate();
}
// Assignment acquires new ownership of pointer
Char &operator=( const Object &rhs )
{
return *this = *rhs;
}
Char &operator=( PyObject *rhsp )
{
if( ptr() != rhsp )
set( rhsp );
return *this;
}
Char &operator=( const unicodestring &v )
{
set( PyUnicode_FromUnicode( const_cast<Py_UNICODE*>( v.data() ), 1 ), true );
return *this;
}
Char &operator=( int v_ )
{
Py_UNICODE v( v_ );
set( PyUnicode_FromUnicode( &v, 1 ), true );
return *this;
}
Char &operator=( Py_UNICODE v )
{
set( PyUnicode_FromUnicode( &v, 1 ), true );
return *this;
}
// Conversion
operator String() const;
};
class String: public SeqBase<Char>
{
public:
virtual size_type capacity() const
{
return max_size();
}
// Membership
virtual bool accepts( PyObject *pyob ) const
{
return pyob != NULL && Py::_Unicode_Check( pyob );
}
explicit String( PyObject *pyob, bool owned = false )
: SeqBase<Char>( pyob, owned )
{
validate();
}
String( const Object &ob )
: SeqBase<Char>( ob )
{
validate();
}
String()
: SeqBase<Char>( PyUnicode_FromString( "" ) )
{
validate();
}
String( const char *latin1 )
: SeqBase<Char>( PyUnicode_FromString( latin1 ) )
{
validate();
}
String( const std::string &latin1 )
: SeqBase<Char>( PyUnicode_FromStringAndSize( latin1.c_str(), latin1.size() ) )
{
validate();
}
String( const char *latin1, Py_ssize_t size )
: SeqBase<Char>( PyUnicode_FromStringAndSize( latin1, size ) )
{
validate();
}
/* [Taken from Pythons's unicode.h]
Many of these APIs take two arguments encoding and errors. These
parameters encoding and errors have the same semantics as the ones
of the builtin unicode() API.
Setting encoding to NULL causes the default encoding to be used.
Error handling is set by errors which may also be set to NULL
meaning to use the default handling defined for the codec. Default
error handling for all builtin codecs is "strict" (ValueErrors are
raised).
The codecs all use a similar interface. Only deviation from the
generic ones are documented.
*/
String( const std::string &s, const char *encoding, const char *errors=NULL )
: SeqBase<Char>( PyUnicode_Decode( s.c_str(), s.size(), encoding, errors ), true )
{
validate();
}
String( const char *s, const char *encoding, const char *errors=NULL )
: SeqBase<Char>( PyUnicode_Decode( s, strlen(s), encoding, errors ), true )
{
validate();
}
String( const char *s, Py_ssize_t size, const char *encoding, const char *errors=NULL )
: SeqBase<Char>( PyUnicode_Decode( s, size, encoding, errors ), true )
{
validate();
}
String( const Py_UNICODE *s, int length )
: SeqBase<Char>( PyUnicode_FromUnicode( s, length ), true )
{
validate();
}
// Assignment acquires new ownership of pointer
String &operator=( const Object &rhs )
{
return *this = *rhs;
}
String &operator=( PyObject *rhsp )
{
if( ptr() != rhsp )
set( rhsp );
return *this;
}
String &operator=( const unicodestring &v )
{
set( PyUnicode_FromUnicode( const_cast<Py_UNICODE *>( v.data() ), static_cast<int>( v.length() ) ), true );
return *this;
}
// Encode
Bytes encode( const char *encoding, const char *error="strict" ) const
{
return Bytes( PyUnicode_AsEncodedString( ptr(), encoding, error ), true );
}
// Queries
virtual size_type size() const
{
return static_cast<size_type>( PyUnicode_GET_SIZE( ptr() ) );
}
unicodestring as_unicodestring() const
{
return unicodestring( PyUnicode_AS_UNICODE( ptr() ), static_cast<size_type>( PyUnicode_GET_SIZE( ptr() ) ) );
}
operator std::string() const
{
// use the default encoding
return as_std_string( NULL );
}
std::string as_std_string( const char *encoding=NULL, const char *error="strict" ) const
{
Bytes b( encode( encoding, error ) );
return b.as_std_string();
}
const Py_UNICODE *unicode_data() const
{
return PyUnicode_AS_UNICODE( ptr() );
}
};
// ==================================================
// class Tuple
class Tuple: public Sequence
{
public:
virtual void setItem( sequence_index_type offset, const Object&ob )
{
// note PyTuple_SetItem is a thief...
if( PyTuple_SetItem( ptr(), offset, new_reference_to( ob ) ) == -1 )
{
throw Exception();
}
}
// Constructor
explicit Tuple( PyObject *pyob, bool owned = false )
: Sequence( pyob, owned )
{
validate();
}
Tuple( const Object &ob )
: Sequence( ob )
{
validate();
}
// New tuple of a given size
explicit Tuple( int size = 0 )
{
set( PyTuple_New( size ), true );
validate();
for( sequence_index_type i=0; i < size; i++ )
{
if( PyTuple_SetItem( ptr(), i, new_reference_to( Py::_None() ) ) == -1 )
{
throw Exception();
}
}
}
// Tuple from any sequence
explicit Tuple( const Sequence &s )
{
sequence_index_type limit( sequence_index_type( s.length() ) );
set( PyTuple_New( limit ), true );
validate();
for( sequence_index_type i=0; i < limit; i++ )
{
if( PyTuple_SetItem( ptr(), i, new_reference_to( s[i] ) ) == -1 )
{
throw Exception();
}
}
}
// Assignment acquires new ownership of pointer
Tuple &operator=( const Object &rhs )
{
return *this = *rhs;
}
Tuple &operator=( PyObject *rhsp )
{
if( ptr() != rhsp )
set( rhsp );
return *this;
}
// Membership
virtual bool accepts( PyObject *pyob ) const
{
return pyob && Py::_Tuple_Check( pyob );
}
Tuple getSlice( int i, int j ) const
{
return Tuple( PySequence_GetSlice( ptr(), i, j ), true );
}
};
class TupleN: public Tuple
{
public:
TupleN()
: Tuple( 0 )
{
}
TupleN( const Object &obj1 )
: Tuple( 1 )
{
setItem( 0, obj1 );
}
TupleN( const Object &obj1, const Object &obj2 )
: Tuple( 2 )
{
setItem( 0, obj1 );
setItem( 1, obj2 );
}
TupleN( const Object &obj1, const Object &obj2, const Object &obj3 )
: Tuple( 3 )
{
setItem( 0, obj1 );
setItem( 1, obj2 );
setItem( 2, obj3 );
}
TupleN( const Object &obj1, const Object &obj2, const Object &obj3,
const Object &obj4 )
: Tuple( 4 )
{
setItem( 0, obj1 );
setItem( 1, obj2 );
setItem( 2, obj3 );
setItem( 3, obj4 );
}
TupleN( const Object &obj1, const Object &obj2, const Object &obj3,
const Object &obj4, const Object &obj5 )
: Tuple( 5 )
{
setItem( 0, obj1 );
setItem( 1, obj2 );
setItem( 2, obj3 );
setItem( 3, obj4 );
setItem( 4, obj5 );
}
TupleN( const Object &obj1, const Object &obj2, const Object &obj3,
const Object &obj4, const Object &obj5, const Object &obj6 )
: Tuple( 6 )
{
setItem( 0, obj1 );
setItem( 1, obj2 );
setItem( 2, obj3 );
setItem( 3, obj4 );
setItem( 4, obj5 );
setItem( 5, obj6 );
}
TupleN( const Object &obj1, const Object &obj2, const Object &obj3,
const Object &obj4, const Object &obj5, const Object &obj6,
const Object &obj7 )
: Tuple( 7 )
{
setItem( 0, obj1 );
setItem( 1, obj2 );
setItem( 2, obj3 );
setItem( 3, obj4 );
setItem( 4, obj5 );
setItem( 5, obj6 );
setItem( 6, obj7 );
}
TupleN( const Object &obj1, const Object &obj2, const Object &obj3,
const Object &obj4, const Object &obj5, const Object &obj6,
const Object &obj7, const Object &obj8 )
: Tuple( 8 )
{
setItem( 0, obj1 );
setItem( 1, obj2 );
setItem( 2, obj3 );
setItem( 3, obj4 );
setItem( 4, obj5 );
setItem( 5, obj6 );
setItem( 6, obj7 );
setItem( 7, obj8 );
}
TupleN( const Object &obj1, const Object &obj2, const Object &obj3,
const Object &obj4, const Object &obj5, const Object &obj6,
const Object &obj7, const Object &obj8, const Object &obj9 )
: Tuple( 9 )
{
setItem( 0, obj1 );
setItem( 1, obj2 );
setItem( 2, obj3 );
setItem( 3, obj4 );
setItem( 4, obj5 );
setItem( 5, obj6 );
setItem( 6, obj7 );
setItem( 7, obj8 );
setItem( 8, obj9 );
}
virtual ~TupleN()
{ }
};
// ==================================================
// class List
class List: public Sequence
{
public:
// Constructor
explicit List( PyObject *pyob, bool owned = false )
: Sequence( pyob, owned )
{
validate();
}
List( const Object &ob )
: Sequence( ob )
{
validate();
}
// Creation at a fixed size
List( int size = 0 )
{
set( PyList_New( size ), true );
validate();
for( sequence_index_type i=0; i < size; i++ )
{
if( PyList_SetItem( ptr(), i, new_reference_to( Py::_None() ) ) == -1 )
{
throw Exception();
}
}
}
// List from a sequence
List( const Sequence &s )
: Sequence()
{
int n =( int )s.length();
set( PyList_New( n ), true );
validate();
for( sequence_index_type i=0; i < n; i++ )
{
if( PyList_SetItem( ptr(), i, new_reference_to( s[i] ) ) == -1 )
{
throw Exception();
}
}
}
virtual size_type capacity() const
{
return max_size();
}
// Assignment acquires new ownership of pointer
List &operator=( const Object &rhs )
{
return *this = *rhs;
}
List &operator=( PyObject *rhsp )
{
if( ptr() != rhsp )
set( rhsp );
return *this;
}
// Membership
virtual bool accepts( PyObject *pyob ) const
{
return pyob && Py::_List_Check( pyob );
}
List getSlice( int i, int j ) const
{
return List( PyList_GetSlice( ptr(), i, j ), true );
}
void setSlice( int i, int j, const Object &v )
{
if( PyList_SetSlice( ptr(), i, j, *v ) == -1 )
{
throw Exception();
}
}
void append( const Object &ob )
{
if( PyList_Append( ptr(), *ob ) == -1 )
{
throw Exception();
}
}
void extend( const Object &ob )
{
setSlice( size(), size(), ob );
}
void insert( int i, const Object &ob )
{
if( PyList_Insert( ptr(), i, *ob ) == -1 )
{
throw Exception();
}
}
void sort()
{
if( PyList_Sort( ptr() ) == -1 )
{
throw Exception();
}
}
void reverse()
{
if( PyList_Reverse( ptr() ) == -1 )
{
throw Exception();
}
}
};
// Mappings
// ==================================================
template<TEMPLATE_TYPENAME T>
class mapref
{
protected:
MapBase<T> &s; // the map
Object key; // item key
T the_item;
public:
mapref<T>( MapBase<T> &map, const std::string &k )
: s( map ), the_item()
{
key = String( k );
if( map.hasKey( key ) ) the_item = map.getItem( key );
}
mapref<T>( MapBase<T> &map, const Object &k )
: s( map ), key( k ), the_item()
{
if( map.hasKey( key ) ) the_item = map.getItem( key );
}
virtual ~mapref<T>()
{}
// MapBase<T> stuff
// lvalue
mapref<T> &operator=( const mapref<T> &other )
{
if( this != &other )
{
the_item = other.the_item;
s.setItem( key, other.the_item );
}
return *this;
}
mapref<T> &operator=( const T &ob )
{
the_item = ob;
s.setItem( key, ob );
return *this;
}
// rvalue
operator T() const
{
return the_item;
}
// forward everything else to the_item
PyObject *ptr() const
{
return the_item.ptr();
}
int reference_count() const
{ // the mapref count
return the_item.reference_count();
}
Type type() const
{
return the_item.type();
}
String str() const
{
return the_item.str();
}
String repr() const
{
return the_item.repr();
}
bool hasAttr( const std::string &attr_name ) const
{
return the_item.hasAttr( attr_name );
}
Object getAttr( const std::string &attr_name ) const
{
return the_item.getAttr( attr_name );
}
Object getItem( const Object &k ) const
{
return the_item.getItem( k );
}
Py_hash_t hashValue() const
{
return the_item.hashValue();
}
bool isCallable() const
{
return the_item.isCallable();
}
bool isInstance() const
{
return the_item.isInstance();
}
bool isList() const
{
return the_item.isList();
}
bool isMapping() const
{
return the_item.isMapping();
}
bool isNumeric() const
{
return the_item.isNumeric();
}
bool isSequence() const
{
return the_item.isSequence();
}
bool isTrue() const
{
return the_item.isTrue();
}
bool isType( const Type &t ) const
{
return the_item.isType( t );
}
bool isTuple() const
{
return the_item.isTuple();
}
bool isString() const
{
return the_item.isString();
}
// Commands
void setAttr( const std::string &attr_name, const Object &value )
{
the_item.setAttr( attr_name, value );
}
void delAttr( const std::string &attr_name )
{
the_item.delAttr( attr_name );
}
void delItem( const Object &k )
{
the_item.delItem( k );
}
}; // end of mapref
#if 0
// TMM: now for mapref<T>
template< class T >
bool operator==( const mapref<T> &left, const mapref<T> &right )
{
return true; // NOT completed.
}
template< class T >
bool operator!=( const mapref<T> &left, const mapref<T> &right )
{
return true; // not completed.
}
#endif
template<TEMPLATE_TYPENAME T>
class MapBase: public Object
{
protected:
explicit MapBase<T>()
{}
public:
// reference: proxy class for implementing []
// TMM: 26Jun'01 - the types
// If you assume that Python mapping is a hash_map...
// hash_map::value_type is not assignable, but
//( *it ).second = data must be a valid expression
typedef size_t size_type;
typedef Object key_type;
typedef mapref<T> data_type;
typedef std::pair< const T, T > value_type;
typedef std::pair< const T, mapref<T> > reference;
typedef const std::pair< const T, const T > const_reference;
typedef std::pair< const T, mapref<T> > pointer;
// Constructor
explicit MapBase<T>( PyObject *pyob, bool owned = false )
: Object( pyob, owned )
{
validate();
}
// TMM: 02Jul'01 - changed MapBase<T> to Object in next line
MapBase<T>( const Object &ob )
: Object( ob )
{
validate();
}
// Assignment acquires new ownership of pointer
MapBase<T> &operator=( const Object &rhs )
{
return *this = *rhs;
}
MapBase<T> &operator=( PyObject *rhsp )
{
if( ptr() != rhsp )
set( rhsp );
return *this;
}
// Membership
virtual bool accepts( PyObject *pyob ) const
{
return pyob && PyMapping_Check( pyob );
}
// Clear -- PyMapping Clear is missing
//
void clear()
{
List k = keys();
for( List::iterator i = k.begin(); i != k.end(); i++ )
{
delItem( *i );
}
}
virtual size_type size() const
{
return PyMapping_Length( ptr() );
}
// Element Access
T operator[]( const std::string &key ) const
{
return getItem( key );
}
T operator[]( const Object &key ) const
{
return getItem( key );
}
mapref<T> operator[]( const char *key )
{
return mapref<T>( *this, key );
}
mapref<T> operator[]( const std::string &key )
{
return mapref<T>( *this, key );
}
mapref<T> operator[]( const Object &key )
{
return mapref<T>( *this, key );
}
int length() const
{
return PyMapping_Length( ptr() );
}
bool hasKey( const std::string &s ) const
{
return PyMapping_HasKeyString( ptr(),const_cast<char*>( s.c_str() ) ) != 0;
}
bool hasKey( const Object &s ) const
{
return PyMapping_HasKey( ptr(), s.ptr() ) != 0;
}
T getItem( const std::string &s ) const
{
return T( asObject( PyMapping_GetItemString( ptr(),const_cast<char*>( s.c_str() ) ) ) );
}
T getItem( const Object &s ) const
{
return T( asObject( PyObject_GetItem( ptr(), s.ptr() ) ) );
}
virtual void setItem( const char *s, const Object &ob )
{
if( PyMapping_SetItemString( ptr(), const_cast<char*>( s ), *ob ) == -1 )
{
throw Exception();
}
}
virtual void setItem( const std::string &s, const Object &ob )
{
if( PyMapping_SetItemString( ptr(), const_cast<char*>( s.c_str() ), *ob ) == -1 )
{
throw Exception();
}
}
virtual void setItem( const Object &s, const Object &ob )
{
if( PyObject_SetItem( ptr(), s.ptr(), ob.ptr() ) == -1 )
{
throw Exception();
}
}
void delItem( const std::string &s )
{
if( PyMapping_DelItemString( ptr(), const_cast<char*>( s.c_str() ) ) == -1 )
{
throw Exception();
}
}
void delItem( const Object &s )
{
if( PyMapping_DelItem( ptr(), *s ) == -1 )
{
throw Exception();
}
}
// Queries
List keys() const
{
return List( PyMapping_Keys( ptr() ), true );
}
List values() const
{
// each returned item is a (key, value) pair
return List( PyMapping_Values( ptr() ), true );
}
List items() const
{
return List( PyMapping_Items( ptr() ), true );
}
class iterator
{
// : public forward_iterator_parent( std::pair<const T,T> ) {
protected:
typedef std::forward_iterator_tag iterator_category;
typedef std::pair< const T, T > value_type;
typedef int difference_type;
typedef std::pair< const T, mapref<T> > pointer;
typedef std::pair< const T, mapref<T> > reference;
friend class MapBase<T>;
//
MapBase<T> *map;
List keys; // for iterating over the map
int pos; // index into the keys
public:
~iterator()
{}
iterator()
: map( 0 )
, keys()
, pos( 0 )
{}
iterator( MapBase<T> *m, bool end = false )
: map( m )
, keys( m->keys() )
, pos( end ? keys.length() : 0 )
{}
iterator( const iterator &other )
: map( other.map )
, keys( other.keys )
, pos( other.pos )
{}
iterator( MapBase<T> *map_, List keys_, int pos_ )
: map( map_ )
, keys( keys_ )
, pos( pos_ )
{}
reference operator*()
{
Object key = keys[ pos ];
return std::make_pair( key, mapref<T>( *map, key ) );
}
iterator &operator=( const iterator &other )
{
if( this != &other )
{
map = other.map;
keys = other.keys;
pos = other.pos;
}
return *this;
}
bool eql( const iterator &other ) const
{
return map->ptr() == other.map->ptr() && pos == other.pos;
}
bool neq( const iterator &other ) const
{
return map->ptr() != other.map->ptr() || pos != other.pos;
}
// pointer operator->() {
// return ;
// }
// prefix ++
iterator &operator++()
{
pos++;
return *this;
}
// postfix ++
iterator operator++( int )
{
return iterator( map, keys, pos++ );
}
// prefix --
iterator &operator--()
{
pos--;
return *this;
}
// postfix --
iterator operator--( int )
{
return iterator( map, keys, pos-- );
}
std::string diagnose() const
{
std::OSTRSTREAM oss;
oss << "iterator diagnosis " << map << ", " << pos << std::ends;
return std::string( oss.str() );
}
}; // end of class MapBase<T>::iterator
iterator begin()
{
return iterator( this, false );
}
iterator end()
{
return iterator( this, true );
}
class const_iterator
{
protected:
typedef std::forward_iterator_tag iterator_category;
typedef const std::pair< const T, T > value_type;
typedef int difference_type;
typedef const std::pair< const T, T > pointer;
typedef const std::pair< const T, T > reference;
friend class MapBase<T>;
const MapBase<T> *map;
List keys; // for iterating over the map
int pos; // index into the keys
public:
~const_iterator()
{}
const_iterator()
: map( 0 )
, keys()
, pos()
{}
const_iterator( const MapBase<T> *m, List k, int p )
: map( m )
, keys( k )
, pos( p )
{}
const_iterator( const const_iterator &other )
: map( other.map )
, keys( other.keys )
, pos( other.pos )
{}
bool eql( const const_iterator &other ) const
{
return map->ptr() == other.map->ptr() && pos == other.pos;
}
bool neq( const const_iterator &other ) const
{
return map->ptr() != other.map->ptr() || pos != other.pos;
}
// const_reference operator*() {
// Object key = *pos;
// return std::make_pair( key, map->[key] );
// GCC < 3 barfes on this line at the '['.
// }
const_reference operator*()
{
Object key = keys[ pos ];
return std::make_pair( key, mapref<T>( *map, key ) );
}
const_iterator &operator=( const const_iterator &other )
{
if( this != &other )
{
map = other.map;
keys = other.keys;
pos = other.pos;
}
return *this;
}
// prefix ++
const_iterator &operator++()
{
pos++;
return *this;
}
// postfix ++
const_iterator operator++( int )
{
return const_iterator( map, keys, pos++ );
}
// prefix --
const_iterator &operator--()
{
pos--;
return *this;
}
// postfix --
const_iterator operator--( int )
{
return const_iterator( map, keys, pos-- );
}
}; // end of class MapBase<T>::const_iterator
const_iterator begin() const
{
return const_iterator( this, keys(), 0 );
}
const_iterator end() const
{
return const_iterator( this, keys(), length() );
}
}; // end of MapBase<T>
typedef MapBase<Object> Mapping;
template <TEMPLATE_TYPENAME T> bool operator==( const EXPLICIT_TYPENAME MapBase<T>::iterator &left, const EXPLICIT_TYPENAME MapBase<T>::iterator &right );
template <TEMPLATE_TYPENAME T> bool operator!=( const EXPLICIT_TYPENAME MapBase<T>::iterator &left, const EXPLICIT_TYPENAME MapBase<T>::iterator &right );
template <TEMPLATE_TYPENAME T> bool operator==( const EXPLICIT_TYPENAME MapBase<T>::const_iterator &left, const EXPLICIT_TYPENAME MapBase<T>::const_iterator &right );
template <TEMPLATE_TYPENAME T> bool operator!=( const EXPLICIT_TYPENAME MapBase<T>::const_iterator &left, const EXPLICIT_TYPENAME MapBase<T>::const_iterator &right );
extern bool operator==( const Mapping::iterator &left, const Mapping::iterator &right );
extern bool operator!=( const Mapping::iterator &left, const Mapping::iterator &right );
extern bool operator==( const Mapping::const_iterator &left, const Mapping::const_iterator &right );
extern bool operator!=( const Mapping::const_iterator &left, const Mapping::const_iterator &right );
// ==================================================
// class Dict
class Dict: public Mapping
{
public:
// Constructor
explicit Dict( PyObject *pyob, bool owned=false )
: Mapping( pyob, owned )
{
validate();
}
Dict( const Object &ob )
: Mapping( ob )
{
validate();
}
// Creation
Dict()
{
set( PyDict_New(), true );
validate();
}
// Assignment acquires new ownership of pointer
Dict &operator=( const Object &rhs )
{
return *this = *rhs;
}
Dict &operator=( PyObject *rhsp )
{
if( ptr() != rhsp )
set( rhsp );
return *this;
}
// Membership
virtual bool accepts( PyObject *pyob ) const
{
return pyob && Py::_Dict_Check( pyob );
}
};
class Callable: public Object
{
public:
// Constructor
explicit Callable()
: Object()
{}
explicit Callable( PyObject *pyob, bool owned = false )
: Object( pyob, owned )
{
validate();
}
Callable( const Object &ob )
: Object( ob )
{
validate();
}
// Assignment acquires new ownership of pointer
Callable &operator=( const Object &rhs )
{
return *this = *rhs;
}
Callable &operator=( PyObject *rhsp )
{
if( ptr() != rhsp )
set( rhsp );
return *this;
}
// Membership
virtual bool accepts( PyObject *pyob ) const
{
return pyob && PyCallable_Check( pyob );
}
// Call
Object apply( const Tuple &args ) const
{
return asObject( PyObject_CallObject( ptr(), args.ptr() ) );
}
// Call with keywords
Object apply( const Tuple &args, const Dict &kw ) const
{
return asObject( PyEval_CallObjectWithKeywords( ptr(), args.ptr(), kw.ptr() ) );
}
Object apply( PyObject *pargs = 0 ) const
{
return apply( Tuple( pargs ) );
}
};
class Module: public Object
{
public:
explicit Module( PyObject *pyob, bool owned = false )
: Object( pyob, owned )
{
validate();
}
// Construct from module name
explicit Module( const std::string &s )
: Object()
{
PyObject *m = PyImport_AddModule( const_cast<char *>( s.c_str() ) );
set( m, false );
validate();
}
// Copy constructor acquires new ownership of pointer
Module( const Module &ob )
: Object( *ob )
{
validate();
}
Module &operator=( const Object &rhs )
{
return *this = *rhs;
}
Module &operator=( PyObject *rhsp )
{
if( ptr() != rhsp )
set( rhsp );
return *this;
}
Dict getDict() const
{
return Dict( PyModule_GetDict( ptr() ) );
// Caution -- PyModule_GetDict returns borrowed reference!
}
};
// Call function helper
inline Object Object::callMemberFunction( const std::string &function_name ) const
{
Callable target( getAttr( function_name ) );
Tuple args( 0 );
return target.apply( args );
}
inline Object Object::callMemberFunction( const std::string &function_name, const Tuple &args ) const
{
Callable target( getAttr( function_name ) );
return target.apply( args );
}
inline Object Object::callMemberFunction( const std::string &function_name, const Tuple &args, const Dict &kw ) const
{
Callable target( getAttr( function_name ) );
return target.apply( args, kw );
}
// Numeric interface
inline Object operator+( const Object &a )
{
return asObject( PyNumber_Positive( *a ) );
}
inline Object operator-( const Object &a )
{
return asObject( PyNumber_Negative( *a ) );
}
inline Object abs( const Object &a )
{
return asObject( PyNumber_Absolute( *a ) );
}
//------------------------------------------------------------
// operator +
inline Object operator+( const Object &a, const Object &b )
{
return asObject( PyNumber_Add( *a, *b ) );
}
inline Object operator+( const Object &a, int j )
{
return asObject( PyNumber_Add( *a, *Long( j ) ) );
}
inline Object operator+( const Object &a, long j )
{
return asObject( PyNumber_Add( *a, *Long( j ) ) );
}
inline Object operator+( const Object &a, double v )
{
return asObject( PyNumber_Add( *a, *Float( v ) ) );
}
inline Object operator+( int j, const Object &b )
{
return asObject( PyNumber_Add( *Long( j ), *b ) );
}
inline Object operator+( long j, const Object &b )
{
return asObject( PyNumber_Add( *Long( j ), *b ) );
}
inline Object operator+( double v, const Object &b )
{
return asObject( PyNumber_Add( *Float( v ), *b ) );
}
//------------------------------------------------------------
// operator -
inline Object operator-( const Object &a, const Object &b )
{
return asObject( PyNumber_Subtract( *a, *b ) );
}
inline Object operator-( const Object &a, int j )
{
return asObject( PyNumber_Subtract( *a, *Long( j ) ) );
}
inline Object operator-( const Object &a, double v )
{
return asObject( PyNumber_Subtract( *a, *Float( v ) ) );
}
inline Object operator-( int j, const Object &b )
{
return asObject( PyNumber_Subtract( *Long( j ), *b ) );
}
inline Object operator-( double v, const Object &b )
{
return asObject( PyNumber_Subtract( *Float( v ), *b ) );
}
//------------------------------------------------------------
// operator *
inline Object operator*( const Object &a, const Object &b )
{
return asObject( PyNumber_Multiply( *a, *b ) );
}
inline Object operator*( const Object &a, int j )
{
return asObject( PyNumber_Multiply( *a, *Long( j ) ) );
}
inline Object operator*( const Object &a, double v )
{
return asObject( PyNumber_Multiply( *a, *Float( v ) ) );
}
inline Object operator*( int j, const Object &b )
{
return asObject( PyNumber_Multiply( *Long( j ), *b ) );
}
inline Object operator*( double v, const Object &b )
{
return asObject( PyNumber_Multiply( *Float( v ), *b ) );
}
//------------------------------------------------------------
// operator /
inline Object operator/( const Object &a, const Object &b )
{
return asObject( PyNumber_TrueDivide( *a, *b ) );
}
inline Object operator/( const Object &a, int j )
{
return asObject( PyNumber_TrueDivide( *a, *Long( j ) ) );
}
inline Object operator/( const Object &a, double v )
{
return asObject( PyNumber_TrueDivide( *a, *Float( v ) ) );
}
inline Object operator/( int j, const Object &b )
{
return asObject( PyNumber_TrueDivide( *Long( j ), *b ) );
}
inline Object operator/( double v, const Object &b )
{
return asObject( PyNumber_TrueDivide( *Float( v ), *b ) );
}
//------------------------------------------------------------
// operator %
inline Object operator%( const Object &a, const Object &b )
{
return asObject( PyNumber_Remainder( *a, *b ) );
}
inline Object operator%( const Object &a, int j )
{
return asObject( PyNumber_Remainder( *a, *Long( j ) ) );
}
inline Object operator%( const Object &a, double v )
{
return asObject( PyNumber_Remainder( *a, *Float( v ) ) );
}
inline Object operator%( int j, const Object &b )
{
return asObject( PyNumber_Remainder( *Long( j ), *b ) );
}
inline Object operator%( double v, const Object &b )
{
return asObject( PyNumber_Remainder( *Float( v ), *b ) );
}
//------------------------------------------------------------
// type
inline Object type( const Exception &) // return the type of the error
{
PyObject *ptype, *pvalue, *ptrace;
PyErr_Fetch( &ptype, &pvalue, &ptrace );
Object result;
if( ptype )
result = ptype;
PyErr_Restore( ptype, pvalue, ptrace );
return result;
}
inline Object value( const Exception &) // return the value of the error
{
PyObject *ptype, *pvalue, *ptrace;
PyErr_Fetch( &ptype, &pvalue, &ptrace );
Object result;
if( pvalue )
result = pvalue;
PyErr_Restore( ptype, pvalue, ptrace );
return result;
}
inline Object trace( const Exception &) // return the traceback of the error
{
PyObject *ptype, *pvalue, *ptrace;
PyErr_Fetch( &ptype, &pvalue, &ptrace );
Object result;
if( ptrace )
result = ptrace;
PyErr_Restore( ptype, pvalue, ptrace );
return result;
}
template<TEMPLATE_TYPENAME T>
String seqref<T>::str() const
{
return the_item.str();
}
template<TEMPLATE_TYPENAME T>
String seqref<T>::repr() const
{
return the_item.repr();
}
} // namespace Py
#endif // __CXX_Objects__h
