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 > ); } }
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> > ); } }