Ejemplo n.º 1
0
void register_CoordGroupArray_class(){

    { //::SireVol::CoordGroupArray
        typedef bp::class_< SireVol::CoordGroupArray > CoordGroupArray_exposer_t;
        CoordGroupArray_exposer_t CoordGroupArray_exposer = CoordGroupArray_exposer_t( "CoordGroupArray", "This class holds an array of CoordGroups. While you could\nof course just use a QVector<CoordGroup>, this array\noptimises the memory layout of all of the CoordGroups\nso that they all lie contiguously along the same piece\nof memory (and indeed, all of the AABoxes are grouped\ntogether, while all of the coordinates are grouped together).\n\nThe memory packing means that this array is much more\nlimited than a QVector<CoordGroup>, i.e. you cant\nadd or remove CoordGroups from the array, and you cant\ndo anything to the contained CoordGroups except for\nchange their coordinates.\n\nThis class is really meant to be used as a fast container\nthat allow rapid iteration over all of the contained\nCoordGroups  coordinates\n\nAuthor: Christopher Woods\n", bp::init< >("Null constructor") );
        bp::scope CoordGroupArray_scope( CoordGroupArray_exposer );
        CoordGroupArray_exposer.def( bp::init< SireVol::CoordGroup const & >(( bp::arg("cgroup") ), "Construct an array that holds just the passed CoordGroup") );
        CoordGroupArray_exposer.def( bp::init< QVector< QVector< SireMaths::Vector > > const & >(( bp::arg("points") ), "Construct from a double-vector") );
        CoordGroupArray_exposer.def( bp::init< QVector< SireVol::CoordGroup > const & >(( bp::arg("cgroups") ), "Construct from an array of CoordGroups") );
        CoordGroupArray_exposer.def( bp::init< SireVol::CoordGroupArray const &, SireVol::CoordGroupArray const & >(( bp::arg("array0"), bp::arg("array1") ), "Construct from a pair of CoordGroupArrays") );
        CoordGroupArray_exposer.def( bp::init< SireVol::CoordGroupArray const & >(( bp::arg("other") ), "Copy constructor") );
        { //::SireVol::CoordGroupArray::aaBox
        
            typedef ::SireVol::AABox ( ::SireVol::CoordGroupArray::*aaBox_function_type)(  ) const;
            aaBox_function_type aaBox_function_value( &::SireVol::CoordGroupArray::aaBox );
            
            CoordGroupArray_exposer.def( 
                "aaBox"
                , aaBox_function_value
                , "Return an AABox that complete encompasses all of the CoordGroups\nin this array" );
        
        }
        { //::SireVol::CoordGroupArray::append
        
            typedef void ( ::SireVol::CoordGroupArray::*append_function_type)( ::SireVol::CoordGroup const & ) ;
            append_function_type append_function_value( &::SireVol::CoordGroupArray::append );
            
            CoordGroupArray_exposer.def( 
                "append"
                , append_function_value
                , ( bp::arg("cgroup") )
                , "Append the passed CoordGroup onto the end of this array" );
        
        }
        { //::SireVol::CoordGroupArray::append
        
            typedef void ( ::SireVol::CoordGroupArray::*append_function_type)( ::SireVol::CoordGroupArray const & ) ;
            append_function_type append_function_value( &::SireVol::CoordGroupArray::append );
            
            CoordGroupArray_exposer.def( 
                "append"
                , append_function_value
                , ( bp::arg("cgroups") )
                , "Append the passed CoordGroups onto the end of this array" );
        
        }
        { //::SireVol::CoordGroupArray::assertValidCoordGroup
        
            typedef void ( ::SireVol::CoordGroupArray::*assertValidCoordGroup_function_type)( ::quint32 ) const;
            assertValidCoordGroup_function_type assertValidCoordGroup_function_value( &::SireVol::CoordGroupArray::assertValidCoordGroup );
            
            CoordGroupArray_exposer.def( 
                "assertValidCoordGroup"
                , assertValidCoordGroup_function_value
                , ( bp::arg("i") )
                , "Assert that the index i points to a valid CoordGroup\nThrow: SireError::invalid_index\n" );
        
        }
        { //::SireVol::CoordGroupArray::assertValidCoordinate
        
            typedef void ( ::SireVol::CoordGroupArray::*assertValidCoordinate_function_type)( ::quint32 ) const;
            assertValidCoordinate_function_type assertValidCoordinate_function_value( &::SireVol::CoordGroupArray::assertValidCoordinate );
            
            CoordGroupArray_exposer.def( 
                "assertValidCoordinate"
                , assertValidCoordinate_function_value
                , ( bp::arg("i") )
                , "Assert that the index i points a valid coordinate\nThrow: SireError::invalid_index\n" );
        
        }
        { //::SireVol::CoordGroupArray::assertValidIndex
        
            typedef void ( ::SireVol::CoordGroupArray::*assertValidIndex_function_type)( ::quint32 ) const;
            assertValidIndex_function_type assertValidIndex_function_value( &::SireVol::CoordGroupArray::assertValidIndex );
            
            CoordGroupArray_exposer.def( 
                "assertValidIndex"
                , assertValidIndex_function_value
                , ( bp::arg("i") )
                , "Assert that the index i points to a valid CoordGroup\nThrow: SireError::invalid_index\n" );
        
        }
        { //::SireVol::CoordGroupArray::at
        
            typedef ::SireVol::CoordGroup const & ( ::SireVol::CoordGroupArray::*at_function_type)( ::quint32 ) const;
            at_function_type at_function_value( &::SireVol::CoordGroupArray::at );
            
            CoordGroupArray_exposer.def( 
                "at"
                , at_function_value
                , ( bp::arg("i") )
                , bp::return_value_policy< bp::copy_const_reference >()
                , "Return a reference to the ith CoordGroup\nThrow: SireError::invalid_index\n" );
        
        }
        { //::SireVol::CoordGroupArray::changeFrame
        
            typedef void ( ::SireVol::CoordGroupArray::*changeFrame_function_type)( ::SireMaths::AxisSet const &,::SireMaths::AxisSet const & ) ;
            changeFrame_function_type changeFrame_function_value( &::SireVol::CoordGroupArray::changeFrame );
            
            CoordGroupArray_exposer.def( 
                "changeFrame"
                , changeFrame_function_value
                , ( bp::arg("from_frame"), bp::arg("to_frame") )
                , "Change all of the coordinates in this array from the\ncoordinate frame from_frame to the coordinate frame to_frame" );
        
        }
        { //::SireVol::CoordGroupArray::changeFrame
        
            typedef void ( ::SireVol::CoordGroupArray::*changeFrame_function_type)( ::quint32,::SireMaths::AxisSet const &,::SireMaths::AxisSet const & ) ;
            changeFrame_function_type changeFrame_function_value( &::SireVol::CoordGroupArray::changeFrame );
            
            CoordGroupArray_exposer.def( 
                "changeFrame"
                , changeFrame_function_value
                , ( bp::arg("i"), bp::arg("from_frame"), bp::arg("to_frame") )
                , "Change all of the coordinates in the ith CoordGroup from\nthe coordinate frame from_frame to the coordinate frame\nto_frame\nThrow: SireError::invalid_index\n" );
        
        }
        { //::SireVol::CoordGroupArray::count
        
            typedef int ( ::SireVol::CoordGroupArray::*count_function_type)(  ) const;
            count_function_type count_function_value( &::SireVol::CoordGroupArray::count );
            
            CoordGroupArray_exposer.def( 
                "count"
                , count_function_value
                , "Return the number of CoordGroups in this array" );
        
        }
        { //::SireVol::CoordGroupArray::isEmpty
        
            typedef bool ( ::SireVol::CoordGroupArray::*isEmpty_function_type)(  ) const;
            isEmpty_function_type isEmpty_function_value( &::SireVol::CoordGroupArray::isEmpty );
            
            CoordGroupArray_exposer.def( 
                "isEmpty"
                , isEmpty_function_value
                , "Return whether or not this array is empty" );
        
        }
        { //::SireVol::CoordGroupArray::mapInto
        
            typedef void ( ::SireVol::CoordGroupArray::*mapInto_function_type)( ::SireMaths::AxisSet const & ) ;
            mapInto_function_type mapInto_function_value( &::SireVol::CoordGroupArray::mapInto );
            
            CoordGroupArray_exposer.def( 
                "mapInto"
                , mapInto_function_value
                , ( bp::arg("axes") )
                , "Map all of the coordinates in this array into the coordinate\nframe represented by axes" );
        
        }
        { //::SireVol::CoordGroupArray::mapInto
        
            typedef void ( ::SireVol::CoordGroupArray::*mapInto_function_type)( ::quint32,::SireMaths::AxisSet const & ) ;
            mapInto_function_type mapInto_function_value( &::SireVol::CoordGroupArray::mapInto );
            
            CoordGroupArray_exposer.def( 
                "mapInto"
                , mapInto_function_value
                , ( bp::arg("i"), bp::arg("axes") )
                , "Map all of the coordinates of the CoordGroup at index i\ninto the coordinate frame represented by axes\nThrow: SireError::invalid_index\n" );
        
        }
        { //::SireVol::CoordGroupArray::merge
        
            typedef ::SireVol::CoordGroup ( ::SireVol::CoordGroupArray::*merge_function_type)(  ) const;
            merge_function_type merge_function_value( &::SireVol::CoordGroupArray::merge );
            
            CoordGroupArray_exposer.def( 
                "merge"
                , merge_function_value
                , "Merge this array of CoordGroups back into a single CoordGroup" );
        
        }
        { //::SireVol::CoordGroupArray::nCoordGroups
        
            typedef int ( ::SireVol::CoordGroupArray::*nCoordGroups_function_type)(  ) const;
            nCoordGroups_function_type nCoordGroups_function_value( &::SireVol::CoordGroupArray::nCoordGroups );
            
            CoordGroupArray_exposer.def( 
                "nCoordGroups"
                , nCoordGroups_function_value
                , "Return the number of CoordGroups in this array" );
        
        }
        { //::SireVol::CoordGroupArray::nCoords
        
            typedef int ( ::SireVol::CoordGroupArray::*nCoords_function_type)(  ) const;
            nCoords_function_type nCoords_function_value( &::SireVol::CoordGroupArray::nCoords );
            
            CoordGroupArray_exposer.def( 
                "nCoords"
                , nCoords_function_value
                , "Return the number of coordinates in this array" );
        
        }
        CoordGroupArray_exposer.def( bp::self != bp::self );
        { //::SireVol::CoordGroupArray::operator=
        
            typedef ::SireVol::CoordGroupArray & ( ::SireVol::CoordGroupArray::*assign_function_type)( ::SireVol::CoordGroupArray const & ) ;
            assign_function_type assign_function_value( &::SireVol::CoordGroupArray::operator= );
            
            CoordGroupArray_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >()
                , "" );
        
        }
        CoordGroupArray_exposer.def( bp::self == bp::self );
        { //::SireVol::CoordGroupArray::operator[]
        
            typedef ::SireVol::CoordGroup const & ( ::SireVol::CoordGroupArray::*__getitem___function_type)( ::quint32 ) const;
            __getitem___function_type __getitem___function_value( &::SireVol::CoordGroupArray::operator[] );
            
            CoordGroupArray_exposer.def( 
                "__getitem__"
                , __getitem___function_value
                , ( bp::arg("i") )
                , bp::return_value_policy< bp::copy_const_reference >()
                , "" );
        
        }
        { //::SireVol::CoordGroupArray::remove
        
            typedef void ( ::SireVol::CoordGroupArray::*remove_function_type)( ::quint32 ) ;
            remove_function_type remove_function_value( &::SireVol::CoordGroupArray::remove );
            
            CoordGroupArray_exposer.def( 
                "remove"
                , remove_function_value
                , ( bp::arg("i") )
                , "Remove the ith CoordGroup from the array" );
        
        }
        { //::SireVol::CoordGroupArray::remove
        
            typedef void ( ::SireVol::CoordGroupArray::*remove_function_type)( ::quint32,int ) ;
            remove_function_type remove_function_value( &::SireVol::CoordGroupArray::remove );
            
            CoordGroupArray_exposer.def( 
                "remove"
                , remove_function_value
                , ( bp::arg("i"), bp::arg("count") )
                , "Remove count CoordGroups from the array, starting with the ith CoordGroup" );
        
        }
        { //::SireVol::CoordGroupArray::remove
        
            typedef void ( ::SireVol::CoordGroupArray::*remove_function_type)( ::QVarLengthArray< unsigned int, 256 > const & ) ;
            remove_function_type remove_function_value( &::SireVol::CoordGroupArray::remove );
            
            CoordGroupArray_exposer.def( 
                "remove"
                , remove_function_value
                , ( bp::arg("idxs") )
                , "Remove the specified CoordGroups from the array" );
        
        }
        { //::SireVol::CoordGroupArray::rotate
        
            typedef void ( ::SireVol::CoordGroupArray::*rotate_function_type)( ::SireMaths::Quaternion const &,::SireMaths::Vector const & ) ;
            rotate_function_type rotate_function_value( &::SireVol::CoordGroupArray::rotate );
            
            CoordGroupArray_exposer.def( 
                "rotate"
                , rotate_function_value
                , ( bp::arg("quat"), bp::arg("point") )
                , "Rotate all of the coordinates in this array using the quaternion\nquat around the point point" );
        
        }
        { //::SireVol::CoordGroupArray::rotate
        
            typedef void ( ::SireVol::CoordGroupArray::*rotate_function_type)( ::SireMaths::Matrix const &,::SireMaths::Vector const & ) ;
            rotate_function_type rotate_function_value( &::SireVol::CoordGroupArray::rotate );
            
            CoordGroupArray_exposer.def( 
                "rotate"
                , rotate_function_value
                , ( bp::arg("rotmat"), bp::arg("point") )
                , "Rotate all of coordinates in this array using the matrix rotmat\nabout the point point" );
        
        }
        { //::SireVol::CoordGroupArray::rotate
        
            typedef void ( ::SireVol::CoordGroupArray::*rotate_function_type)( ::quint32,::SireMaths::Quaternion const &,::SireMaths::Vector const & ) ;
            rotate_function_type rotate_function_value( &::SireVol::CoordGroupArray::rotate );
            
            CoordGroupArray_exposer.def( 
                "rotate"
                , rotate_function_value
                , ( bp::arg("i"), bp::arg("quat"), bp::arg("point") )
                , "Rotate all of the coordinates in the CoordGroup at index i using\nthe quaternion quat about the point point\nThrow: SireError::invalid_index\n" );
        
        }
        { //::SireVol::CoordGroupArray::rotate
        
            typedef void ( ::SireVol::CoordGroupArray::*rotate_function_type)( ::quint32,::SireMaths::Matrix const &,::SireMaths::Vector const & ) ;
            rotate_function_type rotate_function_value( &::SireVol::CoordGroupArray::rotate );
            
            CoordGroupArray_exposer.def( 
                "rotate"
                , rotate_function_value
                , ( bp::arg("i"), bp::arg("rotmat"), bp::arg("point") )
                , "Rotate all of the coordinates in the CoordGroup at index i using\nthe matrix rotmat about the point point\nThrow: SireError::invalid_index\n" );
        
        }
        { //::SireVol::CoordGroupArray::size
        
            typedef int ( ::SireVol::CoordGroupArray::*size_function_type)(  ) const;
            size_function_type size_function_value( &::SireVol::CoordGroupArray::size );
            
            CoordGroupArray_exposer.def( 
                "size"
                , size_function_value
                , "Return the number of CoordGroups in this array" );
        
        }
        { //::SireVol::CoordGroupArray::toString
        
            typedef ::QString ( ::SireVol::CoordGroupArray::*toString_function_type)(  ) const;
            toString_function_type toString_function_value( &::SireVol::CoordGroupArray::toString );
            
            CoordGroupArray_exposer.def( 
                "toString"
                , toString_function_value
                , "Return a string representation of this array" );
        
        }
        { //::SireVol::CoordGroupArray::transform
        
            typedef void ( ::SireVol::CoordGroupArray::*transform_function_type)( ::SireMaths::Transform const & ) ;
            transform_function_type transform_function_value( &::SireVol::CoordGroupArray::transform );
            
            CoordGroupArray_exposer.def( 
                "transform"
                , transform_function_value
                , ( bp::arg("t") )
                , "Transform all of coordinates in this array using the transformation t" );
        
        }
        { //::SireVol::CoordGroupArray::transform
        
            typedef void ( ::SireVol::CoordGroupArray::*transform_function_type)( ::quint32,::SireMaths::Transform const & ) ;
            transform_function_type transform_function_value( &::SireVol::CoordGroupArray::transform );
            
            CoordGroupArray_exposer.def( 
                "transform"
                , transform_function_value
                , ( bp::arg("i"), bp::arg("t") )
                , "Transform all of the coordinates in the CoordGroup at index i using\nthe transformation t\nThrow: SireError::invalid_index\n" );
        
        }
        { //::SireVol::CoordGroupArray::translate
        
            typedef void ( ::SireVol::CoordGroupArray::*translate_function_type)( ::SireMaths::Vector const & ) ;
            translate_function_type translate_function_value( &::SireVol::CoordGroupArray::translate );
            
            CoordGroupArray_exposer.def( 
                "translate"
                , translate_function_value
                , ( bp::arg("delta") )
                , "Translate all of the coordinates in this array by delta" );
        
        }
        { //::SireVol::CoordGroupArray::translate
        
            typedef void ( ::SireVol::CoordGroupArray::*translate_function_type)( ::quint32,::SireMaths::Vector const & ) ;
            translate_function_type translate_function_value( &::SireVol::CoordGroupArray::translate );
            
            CoordGroupArray_exposer.def( 
                "translate"
                , translate_function_value
                , ( bp::arg("i"), bp::arg("delta") )
                , "Translate all of the coordinates in the ith CoordGroup by delta" );
        
        }
        { //::SireVol::CoordGroupArray::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireVol::CoordGroupArray::typeName );
            
            CoordGroupArray_exposer.def( 
                "typeName"
                , typeName_function_value
                , "" );
        
        }
        { //::SireVol::CoordGroupArray::update
        
            typedef void ( ::SireVol::CoordGroupArray::*update_function_type)( ::quint32,::SireVol::CoordGroup const & ) ;
            update_function_type update_function_value( &::SireVol::CoordGroupArray::update );
            
            CoordGroupArray_exposer.def( 
                "update"
                , update_function_value
                , ( bp::arg("i"), bp::arg("cgroup") )
                , "Update the CoordGroup at index i so that it is equal to cgroup. Note\nthat cgroup must contain the same number of coordinates as the existing\nCoordGroup at this index\nThrow: SireError::invalid_index\nThrow: SireError::incompatible_error\n" );
        
        }
        { //::SireVol::CoordGroupArray::update
        
            typedef void ( ::SireVol::CoordGroupArray::*update_function_type)( ::quint32,::QVector< SireMaths::Vector > const & ) ;
            update_function_type update_function_value( &::SireVol::CoordGroupArray::update );
            
            CoordGroupArray_exposer.def( 
                "update"
                , update_function_value
                , ( bp::arg("i"), bp::arg("coords") )
                , "Update the CoordGroup at index i so that it has coordinates coords\nThere must contain the same number of coordinates as the existing\nCoordGroup at this index\nThrow: SireError::invalid_index\nThrow: SireError::incompatible_error\n" );
        
        }
        { //::SireVol::CoordGroupArray::update
        
            typedef void ( ::SireVol::CoordGroupArray::*update_function_type)( ::quint32,::SireMaths::Vector const *,int ) ;
            update_function_type update_function_value( &::SireVol::CoordGroupArray::update );
            
            CoordGroupArray_exposer.def( 
                "update"
                , update_function_value
                , ( bp::arg("i"), bp::arg("coords"), bp::arg("ncoords") )
                , "Update the CoordGroup at index i so that it has coordinates coords\n(there are ncoords coordinates in this array)\nThere must contain the same number of coordinates as the existing\nCoordGroup at this index\nThrow: SireError::invalid_index\nThrow: SireError::incompatible_error\n" );
        
        }
        { //::SireVol::CoordGroupArray::what
        
            typedef char const * ( ::SireVol::CoordGroupArray::*what_function_type)(  ) const;
            what_function_type what_function_value( &::SireVol::CoordGroupArray::what );
            
            CoordGroupArray_exposer.def( 
                "what"
                , what_function_value
                , "" );
        
        }
        CoordGroupArray_exposer.staticmethod( "typeName" );
        CoordGroupArray_exposer.def( "__copy__", &__copy__);
        CoordGroupArray_exposer.def( "__deepcopy__", &__copy__);
        CoordGroupArray_exposer.def( "clone", &__copy__);
        CoordGroupArray_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireVol::CoordGroupArray >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        CoordGroupArray_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireVol::CoordGroupArray >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        CoordGroupArray_exposer.def( "__str__", &__str__< ::SireVol::CoordGroupArray > );
        CoordGroupArray_exposer.def( "__repr__", &__str__< ::SireVol::CoordGroupArray > );
        CoordGroupArray_exposer.def( "__len__", &__len_size< ::SireVol::CoordGroupArray > );
    }

}
Ejemplo n.º 2
0
void register_PropertyList_class(){

    { //::SireBase::PropertyList
        typedef bp::class_< SireBase::PropertyList, bp::bases< SireBase::Property > > PropertyList_exposer_t;
        PropertyList_exposer_t PropertyList_exposer = PropertyList_exposer_t( "PropertyList", bp::init< >() );
        bp::scope PropertyList_scope( PropertyList_exposer );
        PropertyList_exposer.def( bp::init< QList< SireBase::PropPtr< SireBase::Property > > const & >(( bp::arg("props") )) );
        PropertyList_exposer.def( bp::init< SireBase::PropertyList const & >(( bp::arg("other") )) );
        { //::SireBase::PropertyList::append
        
            typedef void ( ::SireBase::PropertyList::*append_function_type )( ::SireBase::Property const & ) ;
            append_function_type append_function_value( &::SireBase::PropertyList::append );
            
            PropertyList_exposer.def( 
                "append"
                , append_function_value
                , ( bp::arg("property") ) );
        
        }
        { //::SireBase::PropertyList::append
        
            typedef void ( ::SireBase::PropertyList::*append_function_type )( ::QList< SireBase::PropPtr< SireBase::Property > > const & ) ;
            append_function_type append_function_value( &::SireBase::PropertyList::append );
            
            PropertyList_exposer.def( 
                "append"
                , append_function_value
                , ( bp::arg("props") ) );
        
        }
        { //::SireBase::PropertyList::array
        
            typedef ::QList< SireBase::PropPtr< SireBase::Property > > ( ::SireBase::PropertyList::*array_function_type )(  ) const;
            array_function_type array_function_value( &::SireBase::PropertyList::array );
            
            PropertyList_exposer.def( 
                "array"
                , array_function_value );
        
        }
        { //::SireBase::PropertyList::at
        
            typedef ::SireBase::Property const & ( ::SireBase::PropertyList::*at_function_type )( int ) const;
            at_function_type at_function_value( &::SireBase::PropertyList::at );
            
            PropertyList_exposer.def( 
                "at"
                , at_function_value
                , ( bp::arg("i") )
                , bp::return_value_policy<bp::clone_const_reference>() );
        
        }
        { //::SireBase::PropertyList::clear
        
            typedef void ( ::SireBase::PropertyList::*clear_function_type )(  ) ;
            clear_function_type clear_function_value( &::SireBase::PropertyList::clear );
            
            PropertyList_exposer.def( 
                "clear"
                , clear_function_value );
        
        }
        { //::SireBase::PropertyList::count
        
            typedef int ( ::SireBase::PropertyList::*count_function_type )(  ) const;
            count_function_type count_function_value( &::SireBase::PropertyList::count );
            
            PropertyList_exposer.def( 
                "count"
                , count_function_value );
        
        }
        { //::SireBase::PropertyList::empty
        
            typedef bool ( ::SireBase::PropertyList::*empty_function_type )(  ) const;
            empty_function_type empty_function_value( &::SireBase::PropertyList::empty );
            
            PropertyList_exposer.def( 
                "empty"
                , empty_function_value );
        
        }
        { //::SireBase::PropertyList::insert
        
            typedef void ( ::SireBase::PropertyList::*insert_function_type )( int,::SireBase::Property const & ) ;
            insert_function_type insert_function_value( &::SireBase::PropertyList::insert );
            
            PropertyList_exposer.def( 
                "insert"
                , insert_function_value
                , ( bp::arg("i"), bp::arg("value") ) );
        
        }
        { //::SireBase::PropertyList::isEmpty
        
            typedef bool ( ::SireBase::PropertyList::*isEmpty_function_type )(  ) const;
            isEmpty_function_type isEmpty_function_value( &::SireBase::PropertyList::isEmpty );
            
            PropertyList_exposer.def( 
                "isEmpty"
                , isEmpty_function_value );
        
        }
        { //::SireBase::PropertyList::mid
        
            typedef ::SireBase::PropertyList ( ::SireBase::PropertyList::*mid_function_type )( int,int ) const;
            mid_function_type mid_function_value( &::SireBase::PropertyList::mid );
            
            PropertyList_exposer.def( 
                "mid"
                , mid_function_value
                , ( bp::arg("pos"), bp::arg("length")=(int)(-0x00000000000000001) ) );
        
        }
        { //::SireBase::PropertyList::move
        
            typedef void ( ::SireBase::PropertyList::*move_function_type )( int,int ) ;
            move_function_type move_function_value( &::SireBase::PropertyList::move );
            
            PropertyList_exposer.def( 
                "move"
                , move_function_value
                , ( bp::arg("from"), bp::arg("to") ) );
        
        }
        PropertyList_exposer.def( bp::self != bp::self );
        PropertyList_exposer.def( bp::self + bp::self );
        { //::SireBase::PropertyList::operator=
        
            typedef ::SireBase::PropertyList & ( ::SireBase::PropertyList::*assign_function_type )( ::SireBase::PropertyList const & ) ;
            assign_function_type assign_function_value( &::SireBase::PropertyList::operator= );
            
            PropertyList_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >() );
        
        }
        PropertyList_exposer.def( bp::self == bp::self );
        { //::SireBase::PropertyList::operator[]
        
            typedef ::SireBase::Property const & ( ::SireBase::PropertyList::*__getitem___function_type )( int ) const;
            __getitem___function_type __getitem___function_value( &::SireBase::PropertyList::operator[] );
            
            PropertyList_exposer.def( 
                "__getitem__"
                , __getitem___function_value
                , ( bp::arg("i") )
                , bp::return_value_policy<bp::clone_const_reference>() );
        
        }
        { //::SireBase::PropertyList::pop_back
        
            typedef void ( ::SireBase::PropertyList::*pop_back_function_type )(  ) ;
            pop_back_function_type pop_back_function_value( &::SireBase::PropertyList::pop_back );
            
            PropertyList_exposer.def( 
                "pop_back"
                , pop_back_function_value );
        
        }
        { //::SireBase::PropertyList::pop_front
        
            typedef void ( ::SireBase::PropertyList::*pop_front_function_type )(  ) ;
            pop_front_function_type pop_front_function_value( &::SireBase::PropertyList::pop_front );
            
            PropertyList_exposer.def( 
                "pop_front"
                , pop_front_function_value );
        
        }
        { //::SireBase::PropertyList::prepend
        
            typedef void ( ::SireBase::PropertyList::*prepend_function_type )( ::SireBase::Property const & ) ;
            prepend_function_type prepend_function_value( &::SireBase::PropertyList::prepend );
            
            PropertyList_exposer.def( 
                "prepend"
                , prepend_function_value
                , ( bp::arg("value") ) );
        
        }
        { //::SireBase::PropertyList::push_back
        
            typedef void ( ::SireBase::PropertyList::*push_back_function_type )( ::SireBase::Property const & ) ;
            push_back_function_type push_back_function_value( &::SireBase::PropertyList::push_back );
            
            PropertyList_exposer.def( 
                "push_back"
                , push_back_function_value
                , ( bp::arg("value") ) );
        
        }
        { //::SireBase::PropertyList::push_front
        
            typedef void ( ::SireBase::PropertyList::*push_front_function_type )( ::SireBase::Property const & ) ;
            push_front_function_type push_front_function_value( &::SireBase::PropertyList::push_front );
            
            PropertyList_exposer.def( 
                "push_front"
                , push_front_function_value
                , ( bp::arg("value") ) );
        
        }
        { //::SireBase::PropertyList::removeAt
        
            typedef void ( ::SireBase::PropertyList::*removeAt_function_type )( int ) ;
            removeAt_function_type removeAt_function_value( &::SireBase::PropertyList::removeAt );
            
            PropertyList_exposer.def( 
                "removeAt"
                , removeAt_function_value
                , ( bp::arg("i") ) );
        
        }
        { //::SireBase::PropertyList::removeFirst
        
            typedef void ( ::SireBase::PropertyList::*removeFirst_function_type )(  ) ;
            removeFirst_function_type removeFirst_function_value( &::SireBase::PropertyList::removeFirst );
            
            PropertyList_exposer.def( 
                "removeFirst"
                , removeFirst_function_value );
        
        }
        { //::SireBase::PropertyList::removeLast
        
            typedef void ( ::SireBase::PropertyList::*removeLast_function_type )(  ) ;
            removeLast_function_type removeLast_function_value( &::SireBase::PropertyList::removeLast );
            
            PropertyList_exposer.def( 
                "removeLast"
                , removeLast_function_value );
        
        }
        { //::SireBase::PropertyList::replace
        
            typedef void ( ::SireBase::PropertyList::*replace_function_type )( int,::SireBase::Property const & ) ;
            replace_function_type replace_function_value( &::SireBase::PropertyList::replace );
            
            PropertyList_exposer.def( 
                "replace"
                , replace_function_value
                , ( bp::arg("i"), bp::arg("value") ) );
        
        }
        { //::SireBase::PropertyList::size
        
            typedef int ( ::SireBase::PropertyList::*size_function_type )(  ) const;
            size_function_type size_function_value( &::SireBase::PropertyList::size );
            
            PropertyList_exposer.def( 
                "size"
                , size_function_value );
        
        }
        { //::SireBase::PropertyList::swap
        
            typedef void ( ::SireBase::PropertyList::*swap_function_type )( ::SireBase::PropertyList & ) ;
            swap_function_type swap_function_value( &::SireBase::PropertyList::swap );
            
            PropertyList_exposer.def( 
                "swap"
                , swap_function_value
                , ( bp::arg("other") ) );
        
        }
        { //::SireBase::PropertyList::swap
        
            typedef void ( ::SireBase::PropertyList::*swap_function_type )( int,int ) ;
            swap_function_type swap_function_value( &::SireBase::PropertyList::swap );
            
            PropertyList_exposer.def( 
                "swap"
                , swap_function_value
                , ( bp::arg("i"), bp::arg("j") ) );
        
        }
        { //::SireBase::PropertyList::takeAt
        
            typedef ::SireBase::PropertyPtr ( ::SireBase::PropertyList::*takeAt_function_type )( int ) ;
            takeAt_function_type takeAt_function_value( &::SireBase::PropertyList::takeAt );
            
            PropertyList_exposer.def( 
                "takeAt"
                , takeAt_function_value
                , ( bp::arg("i") ) );
        
        }
        { //::SireBase::PropertyList::takeFirst
        
            typedef ::SireBase::PropertyPtr ( ::SireBase::PropertyList::*takeFirst_function_type )(  ) ;
            takeFirst_function_type takeFirst_function_value( &::SireBase::PropertyList::takeFirst );
            
            PropertyList_exposer.def( 
                "takeFirst"
                , takeFirst_function_value );
        
        }
        { //::SireBase::PropertyList::takeLast
        
            typedef ::SireBase::PropertyPtr ( ::SireBase::PropertyList::*takeLast_function_type )(  ) ;
            takeLast_function_type takeLast_function_value( &::SireBase::PropertyList::takeLast );
            
            PropertyList_exposer.def( 
                "takeLast"
                , takeLast_function_value );
        
        }
        { //::SireBase::PropertyList::toList
        
            typedef ::QList< SireBase::PropPtr< SireBase::Property > > ( ::SireBase::PropertyList::*toList_function_type )(  ) const;
            toList_function_type toList_function_value( &::SireBase::PropertyList::toList );
            
            PropertyList_exposer.def( 
                "toList"
                , toList_function_value );
        
        }
        { //::SireBase::PropertyList::toString
        
            typedef ::QString ( ::SireBase::PropertyList::*toString_function_type )(  ) const;
            toString_function_type toString_function_value( &::SireBase::PropertyList::toString );
            
            PropertyList_exposer.def( 
                "toString"
                , toString_function_value );
        
        }
        { //::SireBase::PropertyList::toVector
        
            typedef ::QVector< SireBase::PropPtr< SireBase::Property > > ( ::SireBase::PropertyList::*toVector_function_type )(  ) const;
            toVector_function_type toVector_function_value( &::SireBase::PropertyList::toVector );
            
            PropertyList_exposer.def( 
                "toVector"
                , toVector_function_value );
        
        }
        { //::SireBase::PropertyList::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireBase::PropertyList::typeName );
            
            PropertyList_exposer.def( 
                "typeName"
                , typeName_function_value );
        
        }
        { //::SireBase::PropertyList::value
        
            typedef ::SireBase::PropertyPtr ( ::SireBase::PropertyList::*value_function_type )( int ) const;
            value_function_type value_function_value( &::SireBase::PropertyList::value );
            
            PropertyList_exposer.def( 
                "value"
                , value_function_value
                , ( bp::arg("i") ) );
        
        }
        { //::SireBase::PropertyList::value
        
            typedef ::SireBase::PropertyPtr ( ::SireBase::PropertyList::*value_function_type )( int,::SireBase::Property const & ) const;
            value_function_type value_function_value( &::SireBase::PropertyList::value );
            
            PropertyList_exposer.def( 
                "value"
                , value_function_value
                , ( bp::arg("i"), bp::arg("default_value") ) );
        
        }
        PropertyList_exposer.staticmethod( "typeName" );
        PropertyList_exposer.def( "__copy__", &__copy__);
        PropertyList_exposer.def( "__deepcopy__", &__copy__);
        PropertyList_exposer.def( "clone", &__copy__);
        PropertyList_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireBase::PropertyList >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        PropertyList_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireBase::PropertyList >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        PropertyList_exposer.def( "__str__", &__str__< ::SireBase::PropertyList > );
        PropertyList_exposer.def( "__repr__", &__str__< ::SireBase::PropertyList > );
        PropertyList_exposer.def( "__len__", &__len_size< ::SireBase::PropertyList > );
    }

}
void register_ChunkedVector_double__class(){

    { //::SireBase::ChunkedVector< double, 100 >
        typedef bp::class_< SireBase::ChunkedVector< double, 100 > > ChunkedVector_double__exposer_t;
        ChunkedVector_double__exposer_t ChunkedVector_double__exposer = ChunkedVector_double__exposer_t( "ChunkedVector_double_", bp::init< >() );
        bp::scope ChunkedVector_double__scope( ChunkedVector_double__exposer );
        { //::SireBase::ChunkedVector< double, 100 >::const_iterator
            typedef bp::class_< SireBase::ChunkedVector< double, 100 >::const_iterator > const_iterator_exposer_t;
            const_iterator_exposer_t const_iterator_exposer = const_iterator_exposer_t( "const_iterator", bp::init< >() );
            bp::scope const_iterator_scope( const_iterator_exposer );
            const_iterator_exposer.def( bp::init< SireBase::ChunkedVector< double, 100 >::const_iterator const & >(( bp::arg("other") )) );
            const_iterator_exposer.def( bp::self != bp::self );
            { //::SireBase::ChunkedVector< double, 100 >::const_iterator::operator=
            
                typedef ::SireBase::ChunkedVector< double, 100 >::const_iterator & ( ::SireBase::ChunkedVector< double, 100 >::const_iterator::*assign_function_type )( ::SireBase::ChunkedVector< double, 100 >::const_iterator const & ) ;
                assign_function_type assign_function_value( &::SireBase::ChunkedVector< double, 100 >::const_iterator::operator= );
                
                const_iterator_exposer.def( 
                    "assign"
                    , assign_function_value
                    , ( bp::arg("other") )
                    , bp::return_self< >() );
            
            }
            const_iterator_exposer.def( bp::self == bp::self );
        }
        { //::SireBase::ChunkedVector< double, 100 >::iterator
            typedef bp::class_< SireBase::ChunkedVector< double, 100 >::iterator > iterator_exposer_t;
            iterator_exposer_t iterator_exposer = iterator_exposer_t( "iterator", bp::init< >() );
            bp::scope iterator_scope( iterator_exposer );
            iterator_exposer.def( bp::init< SireBase::ChunkedVector< double, 100 >::iterator const & >(( bp::arg("other") )) );
            iterator_exposer.def( bp::self != bp::self );
            { //::SireBase::ChunkedVector< double, 100 >::iterator::operator=
            
                typedef ::SireBase::ChunkedVector< double, 100 >::iterator & ( ::SireBase::ChunkedVector< double, 100 >::iterator::*assign_function_type )( ::SireBase::ChunkedVector< double, 100 >::iterator const & ) ;
                assign_function_type assign_function_value( &::SireBase::ChunkedVector< double, 100 >::iterator::operator= );
                
                iterator_exposer.def( 
                    "assign"
                    , assign_function_value
                    , ( bp::arg("other") )
                    , bp::return_self< >() );
            
            }
            iterator_exposer.def( bp::self == bp::self );
        }
        ChunkedVector_double__exposer.def( bp::init< int >(( bp::arg("size") )) );
        ChunkedVector_double__exposer.def( bp::init< int, double const & >(( bp::arg("size"), bp::arg("value") )) );
        ChunkedVector_double__exposer.def( bp::init< SireBase::ChunkedVector< double, 100 > const & >(( bp::arg("other") )) );
        { //::SireBase::ChunkedVector< double, 100 >::append
        
            typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
            typedef void ( ::SireBase::ChunkedVector< double, 100 >::*append_function_type )( double const & ) ;
            append_function_type append_function_value( &::SireBase::ChunkedVector< double, 100 >::append );
            
            ChunkedVector_double__exposer.def( 
                "append"
                , append_function_value
                , ( bp::arg("value") ) );
        
        }
        { //::SireBase::ChunkedVector< double, 100 >::at
        
            typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
            typedef double const & ( ::SireBase::ChunkedVector< double, 100 >::*at_function_type )( int ) const;
            at_function_type at_function_value( &::SireBase::ChunkedVector< double, 100 >::at );
            
            ChunkedVector_double__exposer.def( 
                "at"
                , at_function_value
                , ( bp::arg("i") )
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        { //::SireBase::ChunkedVector< double, 100 >::begin
        
            typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
            typedef ::SireBase::ChunkedVector< double, 100 >::iterator ( ::SireBase::ChunkedVector< double, 100 >::*begin_function_type )(  ) ;
            begin_function_type begin_function_value( &::SireBase::ChunkedVector< double, 100 >::begin );
            
            ChunkedVector_double__exposer.def( 
                "begin"
                , begin_function_value );
        
        }
        { //::SireBase::ChunkedVector< double, 100 >::begin
        
            typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
            typedef ::SireBase::ChunkedVector< double, 100 >::const_iterator ( ::SireBase::ChunkedVector< double, 100 >::*begin_function_type )(  ) const;
            begin_function_type begin_function_value( &::SireBase::ChunkedVector< double, 100 >::begin );
            
            ChunkedVector_double__exposer.def( 
                "begin"
                , begin_function_value );
        
        }
        { //::SireBase::ChunkedVector< double, 100 >::capacity
        
            typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
            typedef int ( ::SireBase::ChunkedVector< double, 100 >::*capacity_function_type )(  ) const;
            capacity_function_type capacity_function_value( &::SireBase::ChunkedVector< double, 100 >::capacity );
            
            ChunkedVector_double__exposer.def( 
                "capacity"
                , capacity_function_value );
        
        }
        { //::SireBase::ChunkedVector< double, 100 >::clear
        
            typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
            typedef void ( ::SireBase::ChunkedVector< double, 100 >::*clear_function_type )(  ) ;
            clear_function_type clear_function_value( &::SireBase::ChunkedVector< double, 100 >::clear );
            
            ChunkedVector_double__exposer.def( 
                "clear"
                , clear_function_value );
        
        }
        { //::SireBase::ChunkedVector< double, 100 >::constBegin
        
            typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
            typedef ::SireBase::ChunkedVector< double, 100 >::const_iterator ( ::SireBase::ChunkedVector< double, 100 >::*constBegin_function_type )(  ) const;
            constBegin_function_type constBegin_function_value( &::SireBase::ChunkedVector< double, 100 >::constBegin );
            
            ChunkedVector_double__exposer.def( 
                "constBegin"
                , constBegin_function_value );
        
        }
        { //::SireBase::ChunkedVector< double, 100 >::constEnd
        
            typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
            typedef ::SireBase::ChunkedVector< double, 100 >::const_iterator ( ::SireBase::ChunkedVector< double, 100 >::*constEnd_function_type )(  ) const;
            constEnd_function_type constEnd_function_value( &::SireBase::ChunkedVector< double, 100 >::constEnd );
            
            ChunkedVector_double__exposer.def( 
                "constEnd"
                , constEnd_function_value );
        
        }
        { //::SireBase::ChunkedVector< double, 100 >::count
        
            typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
            typedef int ( ::SireBase::ChunkedVector< double, 100 >::*count_function_type )(  ) const;
            count_function_type count_function_value( &::SireBase::ChunkedVector< double, 100 >::count );
            
            ChunkedVector_double__exposer.def( 
                "count"
                , count_function_value );
        
        }
        { //::SireBase::ChunkedVector< double, 100 >::count
        
            typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
            typedef int ( ::SireBase::ChunkedVector< double, 100 >::*count_function_type )( double const & ) const;
            count_function_type count_function_value( &::SireBase::ChunkedVector< double, 100 >::count );
            
            ChunkedVector_double__exposer.def( 
                "count"
                , count_function_value
                , ( bp::arg("value") ) );
        
        }
        { //::SireBase::ChunkedVector< double, 100 >::end
        
            typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
            typedef ::SireBase::ChunkedVector< double, 100 >::iterator ( ::SireBase::ChunkedVector< double, 100 >::*end_function_type )(  ) ;
            end_function_type end_function_value( &::SireBase::ChunkedVector< double, 100 >::end );
            
            ChunkedVector_double__exposer.def( 
                "end"
                , end_function_value );
        
        }
        { //::SireBase::ChunkedVector< double, 100 >::end
        
            typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
            typedef ::SireBase::ChunkedVector< double, 100 >::const_iterator ( ::SireBase::ChunkedVector< double, 100 >::*end_function_type )(  ) const;
            end_function_type end_function_value( &::SireBase::ChunkedVector< double, 100 >::end );
            
            ChunkedVector_double__exposer.def( 
                "end"
                , end_function_value );
        
        }
        { //::SireBase::ChunkedVector< double, 100 >::fromList
        
            typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
            typedef ::SireBase::ChunkedVector< double, 100 > ( *fromList_function_type )( ::QList< double > const & );
            fromList_function_type fromList_function_value( &::SireBase::ChunkedVector< double, 100 >::fromList );
            
            ChunkedVector_double__exposer.def( 
                "fromList"
                , fromList_function_value
                , ( bp::arg("list") ) );
        
        }
        { //::SireBase::ChunkedVector< double, 100 >::fromStdVector
        
            typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
            typedef ::SireBase::ChunkedVector< double, 100 > ( *fromStdVector_function_type )( ::std::vector< double > const & );
            fromStdVector_function_type fromStdVector_function_value( &::SireBase::ChunkedVector< double, 100 >::fromStdVector );
            
            ChunkedVector_double__exposer.def( 
                "fromStdVector"
                , fromStdVector_function_value
                , ( bp::arg("vector") ) );
        
        }
        { //::SireBase::ChunkedVector< double, 100 >::fromVector
        
            typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
            typedef ::SireBase::ChunkedVector< double, 100 > ( *fromVector_function_type )( ::QVector< double > const & );
            fromVector_function_type fromVector_function_value( &::SireBase::ChunkedVector< double, 100 >::fromVector );
            
            ChunkedVector_double__exposer.def( 
                "fromVector"
                , fromVector_function_value
                , ( bp::arg("vector") ) );
        
        }
        { //::SireBase::ChunkedVector< double, 100 >::isEmpty
        
            typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
            typedef bool ( ::SireBase::ChunkedVector< double, 100 >::*isEmpty_function_type )(  ) const;
            isEmpty_function_type isEmpty_function_value( &::SireBase::ChunkedVector< double, 100 >::isEmpty );
            
            ChunkedVector_double__exposer.def( 
                "isEmpty"
                , isEmpty_function_value );
        
        }
        ChunkedVector_double__exposer.def( bp::self != bp::self );
        { //::SireBase::ChunkedVector< double, 100 >::operator=
        
            typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
            typedef ::SireBase::ChunkedVector< double, 100 > & ( ::SireBase::ChunkedVector< double, 100 >::*assign_function_type )( ::SireBase::ChunkedVector< double, 100 > const & ) ;
            assign_function_type assign_function_value( &::SireBase::ChunkedVector< double, 100 >::operator= );
            
            ChunkedVector_double__exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >() );
        
        }
        ChunkedVector_double__exposer.def( bp::self == bp::self );
        { //::SireBase::ChunkedVector< double, 100 >::operator[]
        
            typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
            typedef double & ( ::SireBase::ChunkedVector< double, 100 >::*__getitem___function_type )( int ) ;
            __getitem___function_type __getitem___function_value( &::SireBase::ChunkedVector< double, 100 >::operator[] );
            
            ChunkedVector_double__exposer.def( 
                "__getitem__"
                , __getitem___function_value
                , ( bp::arg("i") )
                , bp::return_value_policy< bp::copy_non_const_reference >() );
        
        }
        { //::SireBase::ChunkedVector< double, 100 >::operator[]
        
            typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
            typedef double const & ( ::SireBase::ChunkedVector< double, 100 >::*__getitem___function_type )( int ) const;
            __getitem___function_type __getitem___function_value( &::SireBase::ChunkedVector< double, 100 >::operator[] );
            
            ChunkedVector_double__exposer.def( 
                "__getitem__"
                , __getitem___function_value
                , ( bp::arg("i") )
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        { //::SireBase::ChunkedVector< double, 100 >::remove
        
            typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
            typedef void ( ::SireBase::ChunkedVector< double, 100 >::*remove_function_type )( int ) ;
            remove_function_type remove_function_value( &::SireBase::ChunkedVector< double, 100 >::remove );
            
            ChunkedVector_double__exposer.def( 
                "remove"
                , remove_function_value
                , ( bp::arg("i") ) );
        
        }
        { //::SireBase::ChunkedVector< double, 100 >::remove
        
            typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
            typedef void ( ::SireBase::ChunkedVector< double, 100 >::*remove_function_type )( int,int ) ;
            remove_function_type remove_function_value( &::SireBase::ChunkedVector< double, 100 >::remove );
            
            ChunkedVector_double__exposer.def( 
                "remove"
                , remove_function_value
                , ( bp::arg("i"), bp::arg("count") ) );
        
        }
        { //::SireBase::ChunkedVector< double, 100 >::reserve
        
            typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
            typedef void ( ::SireBase::ChunkedVector< double, 100 >::*reserve_function_type )( int ) ;
            reserve_function_type reserve_function_value( &::SireBase::ChunkedVector< double, 100 >::reserve );
            
            ChunkedVector_double__exposer.def( 
                "reserve"
                , reserve_function_value
                , ( bp::arg("count") ) );
        
        }
        { //::SireBase::ChunkedVector< double, 100 >::resize
        
            typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
            typedef void ( ::SireBase::ChunkedVector< double, 100 >::*resize_function_type )( int ) ;
            resize_function_type resize_function_value( &::SireBase::ChunkedVector< double, 100 >::resize );
            
            ChunkedVector_double__exposer.def( 
                "resize"
                , resize_function_value
                , ( bp::arg("count") ) );
        
        }
        { //::SireBase::ChunkedVector< double, 100 >::size
        
            typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
            typedef int ( ::SireBase::ChunkedVector< double, 100 >::*size_function_type )(  ) const;
            size_function_type size_function_value( &::SireBase::ChunkedVector< double, 100 >::size );
            
            ChunkedVector_double__exposer.def( 
                "size"
                , size_function_value );
        
        }
        { //::SireBase::ChunkedVector< double, 100 >::squeeze
        
            typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
            typedef void ( ::SireBase::ChunkedVector< double, 100 >::*squeeze_function_type )(  ) ;
            squeeze_function_type squeeze_function_value( &::SireBase::ChunkedVector< double, 100 >::squeeze );
            
            ChunkedVector_double__exposer.def( 
                "squeeze"
                , squeeze_function_value );
        
        }
        { //::SireBase::ChunkedVector< double, 100 >::toList
        
            typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
            typedef ::QList< double > ( ::SireBase::ChunkedVector< double, 100 >::*toList_function_type )(  ) const;
            toList_function_type toList_function_value( &::SireBase::ChunkedVector< double, 100 >::toList );
            
            ChunkedVector_double__exposer.def( 
                "toList"
                , toList_function_value );
        
        }
        { //::SireBase::ChunkedVector< double, 100 >::toStdVector
        
            typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
            typedef ::std::vector< double > ( ::SireBase::ChunkedVector< double, 100 >::*toStdVector_function_type )(  ) const;
            toStdVector_function_type toStdVector_function_value( &::SireBase::ChunkedVector< double, 100 >::toStdVector );
            
            ChunkedVector_double__exposer.def( 
                "toStdVector"
                , toStdVector_function_value );
        
        }
        { //::SireBase::ChunkedVector< double, 100 >::toVector
        
            typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
            typedef ::QVector< double > ( ::SireBase::ChunkedVector< double, 100 >::*toVector_function_type )(  ) const;
            toVector_function_type toVector_function_value( &::SireBase::ChunkedVector< double, 100 >::toVector );
            
            ChunkedVector_double__exposer.def( 
                "toVector"
                , toVector_function_value );
        
        }
        { //::SireBase::ChunkedVector< double, 100 >::value
        
            typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
            typedef double ( ::SireBase::ChunkedVector< double, 100 >::*value_function_type )( int ) const;
            value_function_type value_function_value( &::SireBase::ChunkedVector< double, 100 >::value );
            
            ChunkedVector_double__exposer.def( 
                "value"
                , value_function_value
                , ( bp::arg("i") ) );
        
        }
        { //::SireBase::ChunkedVector< double, 100 >::value
        
            typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
            typedef double ( ::SireBase::ChunkedVector< double, 100 >::*value_function_type )( int,double const & ) const;
            value_function_type value_function_value( &::SireBase::ChunkedVector< double, 100 >::value );
            
            ChunkedVector_double__exposer.def( 
                "value"
                , value_function_value
                , ( bp::arg("i"), bp::arg("default_value") ) );
        
        }
        ChunkedVector_double__exposer.staticmethod( "fromList" );
        ChunkedVector_double__exposer.staticmethod( "fromStdVector" );
        ChunkedVector_double__exposer.staticmethod( "fromVector" );
        ChunkedVector_double__exposer.def( "__copy__", &__copy__);
        ChunkedVector_double__exposer.def( "__deepcopy__", &__copy__);
        ChunkedVector_double__exposer.def( "clone", &__copy__);
        ChunkedVector_double__exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireBase::ChunkedVector<double, 100> >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        ChunkedVector_double__exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireBase::ChunkedVector<double, 100> >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        ChunkedVector_double__exposer.def( "__str__", &pvt_get_name);
        ChunkedVector_double__exposer.def( "__repr__", &pvt_get_name);
        ChunkedVector_double__exposer.def( "__len__", &__len_size< ::SireBase::ChunkedVector<double, 100> > );
    }

}
void register_PackedArray2D_QString__class(){

    { //::SireBase::PackedArray2D< QString >
        typedef bp::class_< SireBase::PackedArray2D< QString > > PackedArray2D_QString__exposer_t;
        PackedArray2D_QString__exposer_t PackedArray2D_QString__exposer = PackedArray2D_QString__exposer_t( "PackedArray2D_QString_", bp::init< >() );
        bp::scope PackedArray2D_QString__scope( PackedArray2D_QString__exposer );
        PackedArray2D_QString__exposer.def( bp::init< SireBase::detail::PackedArray2D_Array< QString > const & >(( bp::arg("array") )) );
        PackedArray2D_QString__exposer.def( bp::init< QVector< SireBase::detail::PackedArray2D_Array< QString > > const & >(( bp::arg("arrays") )) );
        PackedArray2D_QString__exposer.def( bp::init< QVector< QString > const & >(( bp::arg("values") )) );
        PackedArray2D_QString__exposer.def( bp::init< QVector< QVector< QString > > const & >(( bp::arg("values") )) );
        PackedArray2D_QString__exposer.def( bp::init< SireBase::PackedArray2D< QString > const &, SireBase::PackedArray2D< QString > const & >(( bp::arg("array0"), bp::arg("array1") )) );
        PackedArray2D_QString__exposer.def( bp::init< SireBase::PackedArray2D< QString > const & >(( bp::arg("other") )) );
        { //::SireBase::PackedArray2D< QString >::append
        
            typedef SireBase::PackedArray2D< QString > exported_class_t;
            typedef void ( ::SireBase::PackedArray2D< QString >::*append_function_type )( ::SireBase::detail::PackedArray2D_Array< QString > const & ) ;
            append_function_type append_function_value( &::SireBase::PackedArray2D< QString >::append );
            
            PackedArray2D_QString__exposer.def( 
                "append"
                , append_function_value
                , ( bp::arg("array") ) );
        
        }
        { //::SireBase::PackedArray2D< QString >::append
        
            typedef SireBase::PackedArray2D< QString > exported_class_t;
            typedef void ( ::SireBase::PackedArray2D< QString >::*append_function_type )( ::SireBase::PackedArray2D< QString > const & ) ;
            append_function_type append_function_value( &::SireBase::PackedArray2D< QString >::append );
            
            PackedArray2D_QString__exposer.def( 
                "append"
                , append_function_value
                , ( bp::arg("arrays") ) );
        
        }
        { //::SireBase::PackedArray2D< QString >::append
        
            typedef SireBase::PackedArray2D< QString > exported_class_t;
            typedef void ( ::SireBase::PackedArray2D< QString >::*append_function_type )( ::QVector< QString > const & ) ;
            append_function_type append_function_value( &::SireBase::PackedArray2D< QString >::append );
            
            PackedArray2D_QString__exposer.def( 
                "append"
                , append_function_value
                , ( bp::arg("array") ) );
        
        }
        { //::SireBase::PackedArray2D< QString >::append
        
            typedef SireBase::PackedArray2D< QString > exported_class_t;
            typedef void ( ::SireBase::PackedArray2D< QString >::*append_function_type )( ::QVector< QVector< QString > > const & ) ;
            append_function_type append_function_value( &::SireBase::PackedArray2D< QString >::append );
            
            PackedArray2D_QString__exposer.def( 
                "append"
                , append_function_value
                , ( bp::arg("arrays") ) );
        
        }
        { //::SireBase::PackedArray2D< QString >::assertValidIndex
        
            typedef SireBase::PackedArray2D< QString > exported_class_t;
            typedef void ( ::SireBase::PackedArray2D< QString >::*assertValidIndex_function_type )( ::quint32 ) const;
            assertValidIndex_function_type assertValidIndex_function_value( &::SireBase::PackedArray2D< QString >::assertValidIndex );
            
            PackedArray2D_QString__exposer.def( 
                "assertValidIndex"
                , assertValidIndex_function_value
                , ( bp::arg("i") ) );
        
        }
        { //::SireBase::PackedArray2D< QString >::at
        
            typedef SireBase::PackedArray2D< QString > exported_class_t;
            typedef ::SireBase::detail::PackedArray2D_Array< QString > const & ( ::SireBase::PackedArray2D< QString >::*at_function_type )( ::quint32 ) const;
            at_function_type at_function_value( &::SireBase::PackedArray2D< QString >::at );
            
            PackedArray2D_QString__exposer.def( 
                "at"
                , at_function_value
                , ( bp::arg("i") )
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        { //::SireBase::PackedArray2D< QString >::at
        
            typedef SireBase::PackedArray2D< QString > exported_class_t;
            typedef ::QString const & ( ::SireBase::PackedArray2D< QString >::*at_function_type )( ::quint32,::quint32 ) const;
            at_function_type at_function_value( &::SireBase::PackedArray2D< QString >::at );
            
            PackedArray2D_QString__exposer.def( 
                "at"
                , at_function_value
                , ( bp::arg("i"), bp::arg("j") )
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        { //::SireBase::PackedArray2D< QString >::count
        
            typedef SireBase::PackedArray2D< QString > exported_class_t;
            typedef int ( ::SireBase::PackedArray2D< QString >::*count_function_type )(  ) const;
            count_function_type count_function_value( &::SireBase::PackedArray2D< QString >::count );
            
            PackedArray2D_QString__exposer.def( 
                "count"
                , count_function_value );
        
        }
        { //::SireBase::PackedArray2D< QString >::fromVariant
        
            typedef SireBase::PackedArray2D< QString > exported_class_t;
            typedef ::SireBase::PackedArray2D< QString > ( *fromVariant_function_type )( ::SireBase::PackedArray2D< QVariant > const & );
            fromVariant_function_type fromVariant_function_value( &::SireBase::PackedArray2D< QString >::fromVariant );
            
            PackedArray2D_QString__exposer.def( 
                "fromVariant"
                , fromVariant_function_value
                , ( bp::arg("variant") ) );
        
        }
        { //::SireBase::PackedArray2D< QString >::isEmpty
        
            typedef SireBase::PackedArray2D< QString > exported_class_t;
            typedef bool ( ::SireBase::PackedArray2D< QString >::*isEmpty_function_type )(  ) const;
            isEmpty_function_type isEmpty_function_value( &::SireBase::PackedArray2D< QString >::isEmpty );
            
            PackedArray2D_QString__exposer.def( 
                "isEmpty"
                , isEmpty_function_value );
        
        }
        { //::SireBase::PackedArray2D< QString >::nArrays
        
            typedef SireBase::PackedArray2D< QString > exported_class_t;
            typedef int ( ::SireBase::PackedArray2D< QString >::*nArrays_function_type )(  ) const;
            nArrays_function_type nArrays_function_value( &::SireBase::PackedArray2D< QString >::nArrays );
            
            PackedArray2D_QString__exposer.def( 
                "nArrays"
                , nArrays_function_value );
        
        }
        { //::SireBase::PackedArray2D< QString >::nValues
        
            typedef SireBase::PackedArray2D< QString > exported_class_t;
            typedef int ( ::SireBase::PackedArray2D< QString >::*nValues_function_type )(  ) const;
            nValues_function_type nValues_function_value( &::SireBase::PackedArray2D< QString >::nValues );
            
            PackedArray2D_QString__exposer.def( 
                "nValues"
                , nValues_function_value );
        
        }
        { //::SireBase::PackedArray2D< QString >::nValues
        
            typedef SireBase::PackedArray2D< QString > exported_class_t;
            typedef int ( ::SireBase::PackedArray2D< QString >::*nValues_function_type )( ::quint32 ) const;
            nValues_function_type nValues_function_value( &::SireBase::PackedArray2D< QString >::nValues );
            
            PackedArray2D_QString__exposer.def( 
                "nValues"
                , nValues_function_value
                , ( bp::arg("i") ) );
        
        }
        PackedArray2D_QString__exposer.def( bp::self != bp::self );
        { //::SireBase::PackedArray2D< QString >::operator()
        
            typedef SireBase::PackedArray2D< QString > exported_class_t;
            typedef ::QString const & ( ::SireBase::PackedArray2D< QString >::*__call___function_type )( ::quint32,::quint32 ) const;
            __call___function_type __call___function_value( &::SireBase::PackedArray2D< QString >::operator() );
            
            PackedArray2D_QString__exposer.def( 
                "__call__"
                , __call___function_value
                , ( bp::arg("i"), bp::arg("j") )
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        { //::SireBase::PackedArray2D< QString >::operator=
        
            typedef SireBase::PackedArray2D< QString > exported_class_t;
            typedef ::SireBase::PackedArray2D< QString > & ( ::SireBase::PackedArray2D< QString >::*assign_function_type )( ::SireBase::PackedArray2D< QString > const & ) ;
            assign_function_type assign_function_value( &::SireBase::PackedArray2D< QString >::operator= );
            
            PackedArray2D_QString__exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >() );
        
        }
        PackedArray2D_QString__exposer.def( bp::self == bp::self );
        { //::SireBase::PackedArray2D< QString >::operator[]
        
            typedef SireBase::PackedArray2D< QString > exported_class_t;
            typedef ::SireBase::detail::PackedArray2D_Array< QString > const & ( ::SireBase::PackedArray2D< QString >::*__getitem___function_type )( ::quint32 ) const;
            __getitem___function_type __getitem___function_value( &::SireBase::PackedArray2D< QString >::operator[] );
            
            PackedArray2D_QString__exposer.def( 
                "__getitem__"
                , __getitem___function_value
                , ( bp::arg("i") )
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        { //::SireBase::PackedArray2D< QString >::remove
        
            typedef SireBase::PackedArray2D< QString > exported_class_t;
            typedef void ( ::SireBase::PackedArray2D< QString >::*remove_function_type )( ::quint32 ) ;
            remove_function_type remove_function_value( &::SireBase::PackedArray2D< QString >::remove );
            
            PackedArray2D_QString__exposer.def( 
                "remove"
                , remove_function_value
                , ( bp::arg("i") ) );
        
        }
        { //::SireBase::PackedArray2D< QString >::removeAll
        
            typedef SireBase::PackedArray2D< QString > exported_class_t;
            typedef void ( ::SireBase::PackedArray2D< QString >::*removeAll_function_type )( ::QVarLengthArray< int, 256 > const & ) ;
            removeAll_function_type removeAll_function_value( &::SireBase::PackedArray2D< QString >::removeAll );
            
            PackedArray2D_QString__exposer.def( 
                "removeAll"
                , removeAll_function_value
                , ( bp::arg("idxs") ) );
        
        }
        { //::SireBase::PackedArray2D< QString >::size
        
            typedef SireBase::PackedArray2D< QString > exported_class_t;
            typedef int ( ::SireBase::PackedArray2D< QString >::*size_function_type )(  ) const;
            size_function_type size_function_value( &::SireBase::PackedArray2D< QString >::size );
            
            PackedArray2D_QString__exposer.def( 
                "size"
                , size_function_value );
        
        }
        { //::SireBase::PackedArray2D< QString >::toQVector
        
            typedef SireBase::PackedArray2D< QString > exported_class_t;
            typedef ::QVector< QString > ( ::SireBase::PackedArray2D< QString >::*toQVector_function_type )(  ) const;
            toQVector_function_type toQVector_function_value( &::SireBase::PackedArray2D< QString >::toQVector );
            
            PackedArray2D_QString__exposer.def( 
                "toQVector"
                , toQVector_function_value );
        
        }
        { //::SireBase::PackedArray2D< QString >::toQVectorVector
        
            typedef SireBase::PackedArray2D< QString > exported_class_t;
            typedef ::QVector< QVector< QString > > ( ::SireBase::PackedArray2D< QString >::*toQVectorVector_function_type )(  ) const;
            toQVectorVector_function_type toQVectorVector_function_value( &::SireBase::PackedArray2D< QString >::toQVectorVector );
            
            PackedArray2D_QString__exposer.def( 
                "toQVectorVector"
                , toQVectorVector_function_value );
        
        }
        { //::SireBase::PackedArray2D< QString >::toString
        
            typedef SireBase::PackedArray2D< QString > exported_class_t;
            typedef ::QString ( ::SireBase::PackedArray2D< QString >::*toString_function_type )(  ) const;
            toString_function_type toString_function_value( &::SireBase::PackedArray2D< QString >::toString );
            
            PackedArray2D_QString__exposer.def( 
                "toString"
                , toString_function_value );
        
        }
        { //::SireBase::PackedArray2D< QString >::toVariant
        
            typedef SireBase::PackedArray2D< QString > exported_class_t;
            typedef ::SireBase::PackedArray2D< QVariant > ( ::SireBase::PackedArray2D< QString >::*toVariant_function_type )(  ) const;
            toVariant_function_type toVariant_function_value( &::SireBase::PackedArray2D< QString >::toVariant );
            
            PackedArray2D_QString__exposer.def( 
                "toVariant"
                , toVariant_function_value );
        
        }
        { //::SireBase::PackedArray2D< QString >::update
        
            typedef SireBase::PackedArray2D< QString > exported_class_t;
            typedef void ( ::SireBase::PackedArray2D< QString >::*update_function_type )( ::quint32,::SireBase::detail::PackedArray2D_Array< QString > const & ) ;
            update_function_type update_function_value( &::SireBase::PackedArray2D< QString >::update );
            
            PackedArray2D_QString__exposer.def( 
                "update"
                , update_function_value
                , ( bp::arg("i"), bp::arg("array") ) );
        
        }
        { //::SireBase::PackedArray2D< QString >::update
        
            typedef SireBase::PackedArray2D< QString > exported_class_t;
            typedef void ( ::SireBase::PackedArray2D< QString >::*update_function_type )( ::quint32,::QVector< QString > const & ) ;
            update_function_type update_function_value( &::SireBase::PackedArray2D< QString >::update );
            
            PackedArray2D_QString__exposer.def( 
                "update"
                , update_function_value
                , ( bp::arg("i"), bp::arg("array") ) );
        
        }
        { //::SireBase::PackedArray2D< QString >::updateAll
        
            typedef SireBase::PackedArray2D< QString > exported_class_t;
            typedef void ( ::SireBase::PackedArray2D< QString >::*updateAll_function_type )( ::QVarLengthArray< int, 256 > const &,::SireBase::PackedArray2D< QString > const & ) ;
            updateAll_function_type updateAll_function_value( &::SireBase::PackedArray2D< QString >::updateAll );
            
            PackedArray2D_QString__exposer.def( 
                "updateAll"
                , updateAll_function_value
                , ( bp::arg("idxs"), bp::arg("arrays") ) );
        
        }
        PackedArray2D_QString__exposer.staticmethod( "fromVariant" );
        PackedArray2D_QString__exposer.def( "__copy__", &__copy__);
        PackedArray2D_QString__exposer.def( "__deepcopy__", &__copy__);
        PackedArray2D_QString__exposer.def( "clone", &__copy__);
        PackedArray2D_QString__exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireBase::PackedArray2D<QString> >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        PackedArray2D_QString__exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireBase::PackedArray2D<QString> >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        PackedArray2D_QString__exposer.def( "__str__", &__str__< ::SireBase::PackedArray2D<QString> > );
        PackedArray2D_QString__exposer.def( "__repr__", &__str__< ::SireBase::PackedArray2D<QString> > );
        PackedArray2D_QString__exposer.def( "__len__", &__len_size< ::SireBase::PackedArray2D<QString> > );
    }

}