matplotlib · Feb 20, 2011 · Jun 8, 2009 · Jun 8, 2009 · Jun 8, 2009 · Jun 8, 2009
diff --git a/CHANGELOG b/CHANGELOG
diff --git a/CXX/Config.hxx b/CXX/Config.hxx
@@ -115,4 +115,20 @@
 typedef int Py_ssize_t;
 #endif
 
+// hash_map container usage selection
+// 1) if PYCXX_USING_STD_MAP is defined PyCXX will be using std::map<> container
+//    implementation only.
+// 2) if compilers are used other than MS Visual Studio (7.1+) or GCC 3.x
+//    STANDARD_LIBRARY_HAS_HASH_MAP must be defined before compilation to
+//    make PyCXX using hash_map container.
+#if !defined( PYCXX_USING_STD_MAP )
+  #if defined( _MSC_VER ) || defined( __INTEL_COMPILER ) || defined ( __ICC ) || (defined( __GNUC__ ) && ( __GNUC__ > 3 ))
+  #  define PYCXX_USING_HASH_MAP
+  #else
+  #  if defined( STANDARD_LIBRARY_HAS_HASH_MAP ) && !defined( PYCXX_USING_HASH_MAP )
+  #     define PYCXX_USING_HASH_MAP
+  #  endif
+  #endif
+#endif
+
 #endif //  __PyCXX_config_hh__
diff --git a/CXX/Extensions.hxx b/CXX/Extensions.hxx
@@ -56,8 +56,108 @@ extern "C"
 }
 
 #include <vector>
+
+// std::map / hash_map selection and declarations ----------------------------
+#if !defined( PYCXX_USING_HASH_MAP )
+
 #include <map>
 
+#else
+
+#if defined( __GNUC__) && !defined( _STLPORT_VERSION )
+    #include <ext/hash_map>
+#else
+    #include <hash_map>
+#endif
+#if defined( _STLPORT_VERSION )
+    #define __PYCXX_HASHMAP_NAMESPACE std
+    using namespace std;
+#elif defined ( _MSC_VER ) && !defined( __INTEL_COMPILER ) && !defined( __ICC ) && !defined( __ICL ) && !defined( __ECC )
+    #define __PYCXX_HASHMAP_NAMESPACE stdext
+    using namespace stdext;
+#elif defined( __INTEL_COMPILER ) || defined( __ICC ) || defined( __ICL ) || defined( __ECC )
+    #define __PYCXX_HASHMAP_NAMESPACE stdext
+    using namespace stdext;
+#elif defined( __GNUC__ )
+    #define __PYCXX_HASHMAP_NAMESPACE __gnu_cxx
+    using namespace __gnu_cxx;
+#else
+    #define __PYCXX_HASHMAP_NAMESPACE std
+    using namespace std;
+#endif
+
+class __pycxx_str_hash_func
+{
+public:
+    enum
+    {
+        // parameters for hash table
+        bucket_size = 4, // 0 < bucket_size
+        min_buckets = 8  // min_buckets = 2 ^^ N, 0 < N
+    };
+
+    // http://www.azillionmonkeys.com/qed/hash.html
+    size_t operator()( const std::string &str ) const
+    {
+        const unsigned char * data = reinterpret_cast<const unsigned char *>( str.c_str() );
+        int len = (int)str.length();
+        unsigned int hash = len;
+        unsigned int tmp;
+        int rem;
+
+        if (len <= 0 || data == NULL)
+            return 0;
+
+        rem = len & 3;
+        len >>= 2;
+
+        /* Main loop */
+        for (;len > 0; len--)
+        {
+            hash  += (data[1] << 8) | data[0];
+            tmp    = (((data[3] << 8) | data[2]) << 11) ^ hash;
+            hash   = (hash << 16) ^ tmp;
+            data  += 2*sizeof (unsigned short);
+            hash  += hash >> 11;
+        }
+
+        /* Handle end cases */
+        switch (rem)
+        {
+            case 3: hash += (data[1] << 8) | data[0];
+                    hash ^= hash << 16;
+                    hash ^= data[sizeof (unsigned short)] << 18;
+                    hash += hash >> 11;
+                    break;
+            case 2: hash += (data[1] << 8) | data[0];
+                    hash ^= hash << 11;
+                    hash += hash >> 17;
+                    break;
+            case 1: hash += *data;
+                    hash ^= hash << 10;
+                    hash += hash >> 1;
+        }
+
+        /* Force "avalanching" of final 127 bits */
+        hash ^= hash << 3;
+        hash += hash >> 5;
+        hash ^= hash << 4;
+        hash += hash >> 17;
+        hash ^= hash << 25;
+        hash += hash >> 6;
+
+        return hash;
+    }
+
+    bool operator()(const std::string &str_1, const std::string &str_2) const
+    {
+        // test if str_1 ordered before str_2
+        return str_1 < str_2;
+    }
+};
+#endif // PYCXX_USING_HASH_MAP
+// ----------------------------------------------------------------------
+
 namespace Py
 {
     class ExtensionModuleBase;
@@ -205,7 +305,12 @@ namespace Py
     protected:
         typedef Object (T::*method_varargs_function_t)( const Tuple &args );
         typedef Object (T::*method_keyword_function_t)( const Tuple &args, const Dict &kws );
+
+#if defined( PYCXX_USING_HASH_MAP )
+        typedef __PYCXX_HASHMAP_NAMESPACE::hash_map<std::string, MethodDefExt<T> *, __pycxx_str_hash_func> method_map_t;
+#else
         typedef std::map<std::string,MethodDefExt<T> *> method_map_t;
+#endif
 
         static void add_varargs_method( const char *name, method_varargs_function_t function, const char *doc="" )
         {
@@ -247,7 +352,7 @@ namespace Py
             // so that we get called back at the function in T.
             //
             method_map_t &mm = methods();
-            EXPLICIT_TYPENAME method_map_t::iterator i;
+            EXPLICIT_TYPENAME method_map_t::const_iterator i;
 
             for( i=mm.begin(); i != mm.end(); ++i )
             {
@@ -349,6 +454,9 @@ namespace Py
         PythonType & supportGetattro(void);
         PythonType & supportSetattro(void);
         PythonType & supportCompare(void);
+#if PY_MAJOR_VERSION > 2 || (PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION >= 1)
+        PythonType & supportRichCompare(void);
+#endif
         PythonType & supportRepr(void);
         PythonType & supportStr(void);
         PythonType & supportHash(void);
@@ -416,6 +524,7 @@ namespace Py
         virtual Object getattro( const Object & );
         virtual int setattro( const Object &, const Object & );
         virtual int compare( const Object & );
+        virtual Object rich_compare( const Object &, int op );
         virtual Object repr();
         virtual Object str();
         virtual long hash();
@@ -539,7 +648,12 @@ namespace Py
 
         typedef Object (T::*method_varargs_function_t)( const Tuple &args );
         typedef Object (T::*method_keyword_function_t)( const Tuple &args, const Dict &kws );
+
+#if defined( PYCXX_USING_HASH_MAP )
+        typedef __PYCXX_HASHMAP_NAMESPACE::hash_map<std::string, MethodDefExt<T> *, __pycxx_str_hash_func> method_map_t;
+#else
         typedef std::map<std::string,MethodDefExt<T> *> method_map_t;
+#endif
 
         // support the default attributes, __name__, __doc__ and methods
         virtual Object getattr_default( const char *_name )
@@ -579,26 +693,29 @@ namespace Py
 
             method_map_t &mm = methods();
 
+            EXPLICIT_TYPENAME method_map_t::const_iterator i;
+
             if( name == "__methods__" )
             {
                 List methods;
 
-                for( EXPLICIT_TYPENAME method_map_t::iterator i = mm.begin(); i != mm.end(); ++i )
+                for( i = mm.begin(); i != mm.end(); ++i )
                     methods.append( String( (*i).first ) );
 
                 return methods;
             }
 
-            // see if name exists
-            if( mm.find( name ) == mm.end() )
+            // see if name exists and get entry with method
+            i = mm.find( name );
+            if( i == mm.end() )
                 throw AttributeError( name );
 
             Tuple self( 2 );
 
             self[0] = Object( this );
             self[1] = String( name );
 
-            MethodDefExt<T> *method_definition = mm[ name ];
+            MethodDefExt<T> *method_definition = i->second;
 
             PyObject *func = PyCFunction_New( &method_definition->ext_meth_def, self.ptr() );
 
@@ -609,6 +726,12 @@ namespace Py
         {
             method_map_t &mm = methods();
 
+            // check that all methods added are unique
+            EXPLICIT_TYPENAME method_map_t::const_iterator i;
+            i = mm.find( name );
+            if( i != mm.end() )
+                throw AttributeError( name );
+
             MethodDefExt<T> *method_definition = new MethodDefExt<T>
             (
             name,
@@ -624,6 +747,12 @@ namespace Py
         {
             method_map_t &mm = methods();
 
+            // check that all methods added are unique
+            EXPLICIT_TYPENAME method_map_t::const_iterator i;
+            i = mm.find( name );
+            if( i != mm.end() )
+                throw AttributeError( name );
+
             MethodDefExt<T> *method_definition = new MethodDefExt<T>
             (
             name,
@@ -657,10 +786,14 @@ namespace Py
                 String name( self_and_name_tuple[1] );
 
                 method_map_t &mm = methods();
-                MethodDefExt<T> *meth_def = mm[ name ];
-                if( meth_def == NULL )
+
+                EXPLICIT_TYPENAME method_map_t::const_iterator i;
+                i = mm.find( name );
+                if( i == mm.end() )
                     return 0;
 
+                MethodDefExt<T> *meth_def = i->second;
+
                 Tuple args( _args );
 
                 // _keywords may be NULL so be careful about the way the dict is created
@@ -690,10 +823,14 @@ namespace Py
                 String name( self_and_name_tuple[1] );
 
                 method_map_t &mm = methods();
-                MethodDefExt<T> *meth_def = mm[ name ];
-                if( meth_def == NULL )
+
+                EXPLICIT_TYPENAME method_map_t::const_iterator i;
+                i = mm.find( name );
+                if( i == mm.end() )
                     return 0;
 
+                MethodDefExt<T> *meth_def = i->second;
+
                 Tuple args( _args );
 
                 Object result;

diff --git a/CXX/IndirectPythonInterface.cxx b/CXX/IndirectPythonInterface.cxx
@@ -49,6 +49,7 @@ bool _File_Check( PyObject *op ) { return (op)->ob_type == _File_Type(); }
 bool _Float_Check( PyObject *op ) { return (op)->ob_type == _Float_Type(); }
 bool _Function_Check( PyObject *op ) { return (op)->ob_type == _Function_Type(); }
 bool _Instance_Check( PyObject *op ) { return (op)->ob_type == _Instance_Type(); }
+bool _Boolean_Check( PyObject *op ) { return (op)->ob_type == _Bool_Type(); }
 bool _Int_Check( PyObject *op ) { return (op)->ob_type == _Int_Type(); }
 bool _List_Check( PyObject *o ) { return o->ob_type == _List_Type(); }
 bool _Long_Check( PyObject *op ) { return (op)->ob_type == _Long_Type(); }
@@ -116,6 +117,9 @@ static PyObject *ptr__Exc_UnicodeError = NULL;
 
 static PyObject *ptr__PyNone = NULL;
 
+static PyObject *ptr__PyFalse = NULL;
+static PyObject *ptr__PyTrue = NULL;
+
 static PyTypeObject *ptr__Buffer_Type = NULL;
 static PyTypeObject *ptr__CFunction_Type = NULL;
 static PyTypeObject *ptr__Class_Type = NULL;
@@ -300,6 +304,9 @@ bool InitialisePythonIndirectInterface()
 #endif
     ptr__PyNone            = GetPyObject_As_PyObjectPointer( "_Py_NoneStruct" );
 
+    ptr__PyFalse            = GetPyObject_As_PyObjectPointer( "_Py_ZeroStruct" );
+    ptr__PyTrue            = GetPyObject_As_PyObjectPointer( "_Py_TrueStruct" );
+
     ptr__Buffer_Type        = GetPyTypeObject_As_PyTypeObjectPointer( "PyBuffer_Type" );
     ptr__CFunction_Type        = GetPyTypeObject_As_PyTypeObjectPointer( "PyCFunction_Type" );
     ptr__Class_Type            = GetPyTypeObject_As_PyTypeObjectPointer( "PyClass_Type" );
@@ -385,6 +392,8 @@ PyObject * _Exc_UnicodeError()    { return ptr__Exc_UnicodeError; }
 //
 PyObject * _None() { return ptr__PyNone; }
 
+PyObject * _False() { return ptr__PyFalse; }
+PyObject * _True() { return ptr__PyTrue; }
 
 PyTypeObject * _Buffer_Type()    { return ptr__Buffer_Type; }
 PyTypeObject * _CFunction_Type(){ return ptr__CFunction_Type; }
@@ -396,6 +405,7 @@ PyTypeObject * _File_Type()    { return ptr__File_Type; }
 PyTypeObject * _Float_Type()    { return ptr__Float_Type; }
 PyTypeObject * _Function_Type()    { return ptr__Function_Type; }
 PyTypeObject * _Instance_Type()    { return ptr__Instance_Type; }
+PyTypeObject * _Bool_Type()    { return ptr__Bool_Type; }
 PyTypeObject * _Int_Type()    { return ptr__Int_Type; }
 PyTypeObject * _List_Type()    { return ptr__List_Type; }
 PyTypeObject * _Long_Type()    { return ptr__Long_Type; }
@@ -526,6 +536,9 @@ PyObject * _Exc_UnicodeError() { return ::PyExc_UnicodeError; }
 //
 PyObject * _None() { return &::_Py_NoneStruct; }
 
+PyObject * _False() { return Py_False; }
+PyObject * _True() { return Py_True; }
+
 PyTypeObject * _Buffer_Type() { return &PyBuffer_Type; }
 PyTypeObject * _CFunction_Type() { return &PyCFunction_Type; }
 PyTypeObject * _Class_Type() { return &PyClass_Type; }
@@ -536,6 +549,7 @@ PyTypeObject * _File_Type() { return &PyFile_Type; }
 PyTypeObject * _Float_Type() { return &PyFloat_Type; }
 PyTypeObject * _Function_Type() { return &PyFunction_Type; }
 PyTypeObject * _Instance_Type() { return &PyInstance_Type; }
+PyTypeObject * _Bool_Type()    { return &PyBool_Type; }
 PyTypeObject * _Int_Type() { return &PyInt_Type; }
 PyTypeObject * _List_Type() { return &PyList_Type; }
 PyTypeObject * _Long_Type() { return &PyLong_Type; }

diff --git a/CXX/IndirectPythonInterface.hxx b/CXX/IndirectPythonInterface.hxx
@@ -92,6 +92,8 @@ PyObject * _Exc_UnicodeError();
 //
 PyObject * _None();
 
+PyObject * _False();
+PyObject * _True();
 
 //
 //    Wrap Type variables as function calls
@@ -132,6 +134,9 @@ bool _Frame_Check( PyObject *op );
 PyTypeObject * _Function_Type();
 bool _Function_Check( PyObject *op );
 
+PyTypeObject * _Bool_Type();
+bool _Boolean_Check( PyObject *op );
+
 PyTypeObject * _Int_Type();
 bool _Int_Check( PyObject *op );
 
@@ -188,6 +193,6 @@ void _XINCREF( PyObject *op );
 void _XDECREF( PyObject *op );
 
 char *__Py_PackageContext();
-};
+}
 
 #endif    // __CXX_INDIRECT_PYTHON_INTERFACE__HXX__