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