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_Molecules_class(){
{ //::SireMol::Molecules
typedef bp::class_< SireMol::Molecules, bp::bases< SireBase::Property > > Molecules_exposer_t;
Molecules_exposer_t Molecules_exposer = Molecules_exposer_t( "Molecules", bp::init< >() );
bp::scope Molecules_scope( Molecules_exposer );
Molecules_exposer.def( bp::init< SireMol::MoleculeView const & >(( bp::arg("molecule") )) );
Molecules_exposer.def( bp::init< SireMol::ViewsOfMol const & >(( bp::arg("molviews") )) );
Molecules_exposer.def( bp::init< SireMol::Molecules const & >(( bp::arg("other") )) );
{ //::SireMol::Molecules::add
typedef void ( ::SireMol::Molecules::*add_function_type )( ::SireMol::MoleculeView const & ) ;
add_function_type add_function_value( &::SireMol::Molecules::add );
Molecules_exposer.def(
"add"
, add_function_value
, ( bp::arg("molview") ) );
}
{ //::SireMol::Molecules::add
typedef void ( ::SireMol::Molecules::*add_function_type )( ::SireMol::ViewsOfMol const & ) ;
add_function_type add_function_value( &::SireMol::Molecules::add );
Molecules_exposer.def(
"add"
, add_function_value
, ( bp::arg("molviews") ) );
}
{ //::SireMol::Molecules::add
typedef void ( ::SireMol::Molecules::*add_function_type )( ::SireMol::Molecules const & ) ;
add_function_type add_function_value( &::SireMol::Molecules::add );
Molecules_exposer.def(
"add"
, add_function_value
, ( bp::arg("molecules") ) );
}
{ //::SireMol::Molecules::addIfUnique
typedef bool ( ::SireMol::Molecules::*addIfUnique_function_type )( ::SireMol::MoleculeView const & ) ;
addIfUnique_function_type addIfUnique_function_value( &::SireMol::Molecules::addIfUnique );
Molecules_exposer.def(
"addIfUnique"
, addIfUnique_function_value
, ( bp::arg("molview") ) );
}
{ //::SireMol::Molecules::addIfUnique
typedef ::SireMol::ViewsOfMol ( ::SireMol::Molecules::*addIfUnique_function_type )( ::SireMol::ViewsOfMol const & ) ;
addIfUnique_function_type addIfUnique_function_value( &::SireMol::Molecules::addIfUnique );
Molecules_exposer.def(
"addIfUnique"
, addIfUnique_function_value
, ( bp::arg("molviews") ) );
}
{ //::SireMol::Molecules::addIfUnique
typedef ::QList< SireMol::ViewsOfMol > ( ::SireMol::Molecules::*addIfUnique_function_type )( ::SireMol::Molecules const & ) ;
addIfUnique_function_type addIfUnique_function_value( &::SireMol::Molecules::addIfUnique );
Molecules_exposer.def(
"addIfUnique"
, addIfUnique_function_value
, ( bp::arg("molecules") ) );
}
{ //::SireMol::Molecules::assertContains
typedef void ( ::SireMol::Molecules::*assertContains_function_type )( ::SireMol::MolNum ) const;
assertContains_function_type assertContains_function_value( &::SireMol::Molecules::assertContains );
Molecules_exposer.def(
"assertContains"
, assertContains_function_value
, ( bp::arg("molnum") ) );
}
{ //::SireMol::Molecules::at
typedef ::SireMol::ViewsOfMol const & ( ::SireMol::Molecules::*at_function_type )( ::SireMol::MolNum ) const;
at_function_type at_function_value( &::SireMol::Molecules::at );
Molecules_exposer.def(
"at"
, at_function_value
, ( bp::arg("molnum") )
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireMol::Molecules::at
typedef ::SireMol::PartialMolecule ( ::SireMol::Molecules::*at_function_type )( ::boost::tuples::tuple< SireMol::MolNum, SireID::Index, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type > const & ) const;
at_function_type at_function_value( &::SireMol::Molecules::at );
Molecules_exposer.def(
"at"
, at_function_value
, ( bp::arg("viewidx") ) );
}
{ //::SireMol::Molecules::at
typedef ::SireMol::PartialMolecule ( ::SireMol::Molecules::*at_function_type )( ::SireMol::MolNum,int ) const;
at_function_type at_function_value( &::SireMol::Molecules::at );
Molecules_exposer.def(
"at"
, at_function_value
, ( bp::arg("molnum"), bp::arg("idx") ) );
}
{ //::SireMol::Molecules::back
typedef ::SireMol::ViewsOfMol const & ( ::SireMol::Molecules::*back_function_type )( ) const;
back_function_type back_function_value( &::SireMol::Molecules::back );
Molecules_exposer.def(
"back"
, back_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireMol::Molecules::begin
typedef ::SireBase::ChunkedHash< SireMol::MolNum, SireMol::ViewsOfMol, 100 >::const_iterator ( ::SireMol::Molecules::*begin_function_type )( ) const;
begin_function_type begin_function_value( &::SireMol::Molecules::begin );
Molecules_exposer.def(
"begin"
, begin_function_value );
}
{ //::SireMol::Molecules::clear
typedef void ( ::SireMol::Molecules::*clear_function_type )( ) ;
clear_function_type clear_function_value( &::SireMol::Molecules::clear );
Molecules_exposer.def(
"clear"
, clear_function_value );
}
{ //::SireMol::Molecules::constBegin
typedef ::SireBase::ChunkedHash< SireMol::MolNum, SireMol::ViewsOfMol, 100 >::const_iterator ( ::SireMol::Molecules::*constBegin_function_type )( ) const;
constBegin_function_type constBegin_function_value( &::SireMol::Molecules::constBegin );
Molecules_exposer.def(
"constBegin"
, constBegin_function_value );
}
{ //::SireMol::Molecules::constEnd
typedef ::SireBase::ChunkedHash< SireMol::MolNum, SireMol::ViewsOfMol, 100 >::const_iterator ( ::SireMol::Molecules::*constEnd_function_type )( ) const;
constEnd_function_type constEnd_function_value( &::SireMol::Molecules::constEnd );
Molecules_exposer.def(
"constEnd"
, constEnd_function_value );
}
{ //::SireMol::Molecules::constFind
typedef ::SireBase::ChunkedHash< SireMol::MolNum, SireMol::ViewsOfMol, 100 >::const_iterator ( ::SireMol::Molecules::*constFind_function_type )( ::SireMol::MolNum ) const;
constFind_function_type constFind_function_value( &::SireMol::Molecules::constFind );
Molecules_exposer.def(
"constFind"
, constFind_function_value
, ( bp::arg("molnum") ) );
}
{ //::SireMol::Molecules::contains
typedef bool ( ::SireMol::Molecules::*contains_function_type )( ::SireMol::MolNum ) const;
contains_function_type contains_function_value( &::SireMol::Molecules::contains );
Molecules_exposer.def(
"contains"
, contains_function_value
, ( bp::arg("molnum") ) );
}
{ //::SireMol::Molecules::contains
typedef bool ( ::SireMol::Molecules::*contains_function_type )( ::SireMol::MoleculeView const & ) const;
contains_function_type contains_function_value( &::SireMol::Molecules::contains );
Molecules_exposer.def(
"contains"
, contains_function_value
, ( bp::arg("molview") ) );
}
{ //::SireMol::Molecules::contains
typedef bool ( ::SireMol::Molecules::*contains_function_type )( ::SireMol::ViewsOfMol const & ) const;
contains_function_type contains_function_value( &::SireMol::Molecules::contains );
Molecules_exposer.def(
"contains"
, contains_function_value
, ( bp::arg("molviews") ) );
}
{ //::SireMol::Molecules::contains
typedef bool ( ::SireMol::Molecules::*contains_function_type )( ::SireMol::Molecules const & ) const;
contains_function_type contains_function_value( &::SireMol::Molecules::contains );
Molecules_exposer.def(
"contains"
, contains_function_value
, ( bp::arg("molecules") ) );
}
{ //::SireMol::Molecules::count
typedef int ( ::SireMol::Molecules::*count_function_type )( ) const;
count_function_type count_function_value( &::SireMol::Molecules::count );
Molecules_exposer.def(
"count"
, count_function_value );
}
{ //::SireMol::Molecules::end
typedef ::SireBase::ChunkedHash< SireMol::MolNum, SireMol::ViewsOfMol, 100 >::const_iterator ( ::SireMol::Molecules::*end_function_type )( ) const;
end_function_type end_function_value( &::SireMol::Molecules::end );
Molecules_exposer.def(
"end"
, end_function_value );
}
{ //::SireMol::Molecules::find
typedef ::SireBase::ChunkedHash< SireMol::MolNum, SireMol::ViewsOfMol, 100 >::const_iterator ( ::SireMol::Molecules::*find_function_type )( ::SireMol::MolNum ) const;
find_function_type find_function_value( &::SireMol::Molecules::find );
Molecules_exposer.def(
"find"
, find_function_value
, ( bp::arg("molnum") ) );
}
{ //::SireMol::Molecules::first
typedef ::SireMol::ViewsOfMol const & ( ::SireMol::Molecules::*first_function_type )( ) const;
first_function_type first_function_value( &::SireMol::Molecules::first );
Molecules_exposer.def(
"first"
, first_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireMol::Molecules::front
typedef ::SireMol::ViewsOfMol const & ( ::SireMol::Molecules::*front_function_type )( ) const;
front_function_type front_function_value( &::SireMol::Molecules::front );
Molecules_exposer.def(
"front"
, front_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireMol::Molecules::intersects
typedef bool ( ::SireMol::Molecules::*intersects_function_type )( ::SireMol::MoleculeView const & ) const;
intersects_function_type intersects_function_value( &::SireMol::Molecules::intersects );
Molecules_exposer.def(
"intersects"
, intersects_function_value
, ( bp::arg("molview") ) );
}
{ //::SireMol::Molecules::intersects
typedef bool ( ::SireMol::Molecules::*intersects_function_type )( ::SireMol::Molecules const & ) const;
intersects_function_type intersects_function_value( &::SireMol::Molecules::intersects );
Molecules_exposer.def(
"intersects"
, intersects_function_value
, ( bp::arg("other") ) );
}
{ //::SireMol::Molecules::isEmpty
typedef bool ( ::SireMol::Molecules::*isEmpty_function_type )( ) const;
isEmpty_function_type isEmpty_function_value( &::SireMol::Molecules::isEmpty );
Molecules_exposer.def(
"isEmpty"
, isEmpty_function_value );
}
{ //::SireMol::Molecules::last
typedef ::SireMol::ViewsOfMol const & ( ::SireMol::Molecules::*last_function_type )( ) const;
last_function_type last_function_value( &::SireMol::Molecules::last );
Molecules_exposer.def(
"last"
, last_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireMol::Molecules::molNums
typedef ::QSet< SireMol::MolNum > ( ::SireMol::Molecules::*molNums_function_type )( ) const;
molNums_function_type molNums_function_value( &::SireMol::Molecules::molNums );
Molecules_exposer.def(
"molNums"
, molNums_function_value );
}
{ //::SireMol::Molecules::molecule
typedef ::SireMol::ViewsOfMol const & ( ::SireMol::Molecules::*molecule_function_type )( ::SireMol::MolNum ) const;
molecule_function_type molecule_function_value( &::SireMol::Molecules::molecule );
Molecules_exposer.def(
"molecule"
, molecule_function_value
, ( bp::arg("molnum") )
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireMol::Molecules::nMolecules
typedef int ( ::SireMol::Molecules::*nMolecules_function_type )( ) const;
nMolecules_function_type nMolecules_function_value( &::SireMol::Molecules::nMolecules );
Molecules_exposer.def(
"nMolecules"
, nMolecules_function_value );
}
{ //::SireMol::Molecules::nViews
typedef int ( ::SireMol::Molecules::*nViews_function_type )( ) const;
nViews_function_type nViews_function_value( &::SireMol::Molecules::nViews );
Molecules_exposer.def(
"nViews"
, nViews_function_value );
}
{ //::SireMol::Molecules::nViews
typedef int ( ::SireMol::Molecules::*nViews_function_type )( ::SireMol::MolNum ) const;
nViews_function_type nViews_function_value( &::SireMol::Molecules::nViews );
Molecules_exposer.def(
"nViews"
, nViews_function_value
, ( bp::arg("molnum") ) );
}
Molecules_exposer.def( bp::self != bp::self );
Molecules_exposer.def( bp::self + bp::self );
Molecules_exposer.def( bp::self - bp::self );
{ //::SireMol::Molecules::operator=
typedef ::SireMol::Molecules & ( ::SireMol::Molecules::*assign_function_type )( ::SireMol::Molecules const & ) ;
assign_function_type assign_function_value( &::SireMol::Molecules::operator= );
Molecules_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
Molecules_exposer.def( bp::self == bp::self );
{ //::SireMol::Molecules::operator[]
typedef ::SireMol::ViewsOfMol const & ( ::SireMol::Molecules::*__getitem___function_type )( ::SireMol::MolNum ) const;
__getitem___function_type __getitem___function_value( &::SireMol::Molecules::operator[] );
Molecules_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("molnum") )
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireMol::Molecules::operator[]
typedef ::SireMol::PartialMolecule ( ::SireMol::Molecules::*__getitem___function_type )( ::boost::tuples::tuple< SireMol::MolNum, SireID::Index, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type > const & ) const;
__getitem___function_type __getitem___function_value( &::SireMol::Molecules::operator[] );
Molecules_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("viewidx") ) );
}
{ //::SireMol::Molecules::remove
typedef bool ( ::SireMol::Molecules::*remove_function_type )( ::SireMol::MoleculeView const & ) ;
remove_function_type remove_function_value( &::SireMol::Molecules::remove );
Molecules_exposer.def(
"remove"
, remove_function_value
, ( bp::arg("molview") ) );
}
{ //::SireMol::Molecules::remove
typedef ::SireMol::ViewsOfMol ( ::SireMol::Molecules::*remove_function_type )( ::SireMol::ViewsOfMol const & ) ;
remove_function_type remove_function_value( &::SireMol::Molecules::remove );
Molecules_exposer.def(
"remove"
, remove_function_value
, ( bp::arg("molviews") ) );
}
{ //::SireMol::Molecules::remove
typedef ::QList< SireMol::ViewsOfMol > ( ::SireMol::Molecules::*remove_function_type )( ::SireMol::Molecules const & ) ;
remove_function_type remove_function_value( &::SireMol::Molecules::remove );
Molecules_exposer.def(
"remove"
, remove_function_value
, ( bp::arg("molecules") ) );
}
{ //::SireMol::Molecules::remove
typedef ::SireMol::ViewsOfMol ( ::SireMol::Molecules::*remove_function_type )( ::SireMol::MolNum ) ;
remove_function_type remove_function_value( &::SireMol::Molecules::remove );
Molecules_exposer.def(
"remove"
, remove_function_value
, ( bp::arg("molnum") ) );
}
{ //::SireMol::Molecules::removeAll
typedef bool ( ::SireMol::Molecules::*removeAll_function_type )( ::SireMol::MoleculeView const & ) ;
removeAll_function_type removeAll_function_value( &::SireMol::Molecules::removeAll );
Molecules_exposer.def(
"removeAll"
, removeAll_function_value
, ( bp::arg("molview") ) );
}
{ //::SireMol::Molecules::removeAll
typedef ::SireMol::ViewsOfMol ( ::SireMol::Molecules::*removeAll_function_type )( ::SireMol::ViewsOfMol const & ) ;
removeAll_function_type removeAll_function_value( &::SireMol::Molecules::removeAll );
Molecules_exposer.def(
"removeAll"
, removeAll_function_value
, ( bp::arg("molviews") ) );
}
{ //::SireMol::Molecules::removeAll
typedef ::QList< SireMol::ViewsOfMol > ( ::SireMol::Molecules::*removeAll_function_type )( ::SireMol::Molecules const & ) ;
removeAll_function_type removeAll_function_value( &::SireMol::Molecules::removeAll );
Molecules_exposer.def(
"removeAll"
, removeAll_function_value
, ( bp::arg("molecules") ) );
}
{ //::SireMol::Molecules::removeAll
typedef bool ( ::SireMol::Molecules::*removeAll_function_type )( ) ;
removeAll_function_type removeAll_function_value( &::SireMol::Molecules::removeAll );
Molecules_exposer.def(
"removeAll"
, removeAll_function_value );
}
{ //::SireMol::Molecules::removeDuplicates
typedef bool ( ::SireMol::Molecules::*removeDuplicates_function_type )( ) ;
removeDuplicates_function_type removeDuplicates_function_value( &::SireMol::Molecules::removeDuplicates );
Molecules_exposer.def(
"removeDuplicates"
, removeDuplicates_function_value );
}
{ //::SireMol::Molecules::reserve
typedef void ( ::SireMol::Molecules::*reserve_function_type )( int ) ;
reserve_function_type reserve_function_value( &::SireMol::Molecules::reserve );
Molecules_exposer.def(
"reserve"
, reserve_function_value
, ( bp::arg("nmolecules") ) );
}
{ //::SireMol::Molecules::toString
typedef ::QString ( ::SireMol::Molecules::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireMol::Molecules::toString );
Molecules_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireMol::Molecules::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMol::Molecules::typeName );
Molecules_exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireMol::Molecules::unite
typedef bool ( ::SireMol::Molecules::*unite_function_type )( ::SireMol::MoleculeView const & ) ;
unite_function_type unite_function_value( &::SireMol::Molecules::unite );
Molecules_exposer.def(
"unite"
, unite_function_value
, ( bp::arg("molview") ) );
}
{ //::SireMol::Molecules::unite
typedef ::SireMol::ViewsOfMol ( ::SireMol::Molecules::*unite_function_type )( ::SireMol::ViewsOfMol const & ) ;
unite_function_type unite_function_value( &::SireMol::Molecules::unite );
Molecules_exposer.def(
"unite"
, unite_function_value
, ( bp::arg("molviews") ) );
}
{ //::SireMol::Molecules::unite
typedef ::QList< SireMol::ViewsOfMol > ( ::SireMol::Molecules::*unite_function_type )( ::SireMol::Molecules const & ) ;
unite_function_type unite_function_value( &::SireMol::Molecules::unite );
Molecules_exposer.def(
"unite"
, unite_function_value
, ( bp::arg("other") ) );
}
{ //::SireMol::Molecules::uniteViews
typedef bool ( ::SireMol::Molecules::*uniteViews_function_type )( ) ;
uniteViews_function_type uniteViews_function_value( &::SireMol::Molecules::uniteViews );
Molecules_exposer.def(
"uniteViews"
, uniteViews_function_value );
}
{ //::SireMol::Molecules::update
typedef bool ( ::SireMol::Molecules::*update_function_type )( ::SireMol::MoleculeData const & ) ;
update_function_type update_function_value( &::SireMol::Molecules::update );
Molecules_exposer.def(
"update"
, update_function_value
, ( bp::arg("moldata") ) );
}
{ //::SireMol::Molecules::update
typedef bool ( ::SireMol::Molecules::*update_function_type )( ::SireMol::MoleculeView const & ) ;
update_function_type update_function_value( &::SireMol::Molecules::update );
Molecules_exposer.def(
"update"
, update_function_value
, ( bp::arg("molview") ) );
}
{ //::SireMol::Molecules::update
typedef ::QList< SireMol::Molecule > ( ::SireMol::Molecules::*update_function_type )( ::SireMol::Molecules const & ) ;
update_function_type update_function_value( &::SireMol::Molecules::update );
Molecules_exposer.def(
"update"
, update_function_value
, ( bp::arg("molecules") ) );
}
{ //::SireMol::Molecules::what
typedef char const * ( ::SireMol::Molecules::*what_function_type )( ) const;
what_function_type what_function_value( &::SireMol::Molecules::what );
Molecules_exposer.def(
"what"
, what_function_value );
}
Molecules_exposer.staticmethod( "typeName" );
Molecules_exposer.def( "__copy__", &__copy__);
Molecules_exposer.def( "__deepcopy__", &__copy__);
Molecules_exposer.def( "clone", &__copy__);
Molecules_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::Molecules >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Molecules_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::Molecules >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Molecules_exposer.def( "__str__", &__str__< ::SireMol::Molecules > );
Molecules_exposer.def( "__repr__", &__str__< ::SireMol::Molecules > );
Molecules_exposer.def( "__len__", &__len_count< ::SireMol::Molecules > );
}
}
void register_Nodes_class(){
{ //::SireCluster::Nodes
typedef bp::class_< SireCluster::Nodes > Nodes_exposer_t;
Nodes_exposer_t Nodes_exposer = Nodes_exposer_t( "Nodes", bp::init< >() );
bp::scope Nodes_scope( Nodes_exposer );
Nodes_exposer.def( bp::init< SireCluster::Nodes const & >(( bp::arg("other") )) );
{ //::SireCluster::Nodes::add
typedef void ( ::SireCluster::Nodes::*add_function_type )( ::SireCluster::Node ) ;
add_function_type add_function_value( &::SireCluster::Nodes::add );
Nodes_exposer.def(
"add"
, add_function_value
, ( bp::arg("node") ) );
}
{ //::SireCluster::Nodes::add
typedef void ( ::SireCluster::Nodes::*add_function_type )( ::SireCluster::Nodes & ) ;
add_function_type add_function_value( &::SireCluster::Nodes::add );
Nodes_exposer.def(
"add"
, add_function_value
, ( bp::arg("nodes") ) );
}
{ //::SireCluster::Nodes::addNode
typedef void ( ::SireCluster::Nodes::*addNode_function_type )( ) ;
addNode_function_type addNode_function_value( &::SireCluster::Nodes::addNode );
Nodes_exposer.def(
"addNode"
, addNode_function_value );
}
{ //::SireCluster::Nodes::addNode
typedef void ( ::SireCluster::Nodes::*addNode_function_type )( int ) ;
addNode_function_type addNode_function_value( &::SireCluster::Nodes::addNode );
Nodes_exposer.def(
"addNode"
, addNode_function_value
, ( bp::arg("timeout") ) );
}
{ //::SireCluster::Nodes::addNodes
typedef void ( ::SireCluster::Nodes::*addNodes_function_type )( int ) ;
addNodes_function_type addNodes_function_value( &::SireCluster::Nodes::addNodes );
Nodes_exposer.def(
"addNodes"
, addNodes_function_value
, ( bp::arg("n") ) );
}
{ //::SireCluster::Nodes::addNodes
typedef void ( ::SireCluster::Nodes::*addNodes_function_type )( int,int ) ;
addNodes_function_type addNodes_function_value( &::SireCluster::Nodes::addNodes );
Nodes_exposer.def(
"addNodes"
, addNodes_function_value
, ( bp::arg("n"), bp::arg("timeout") ) );
}
{ //::SireCluster::Nodes::borrowThisThread
typedef ::SireCluster::ThisThread ( ::SireCluster::Nodes::*borrowThisThread_function_type )( ) ;
borrowThisThread_function_type borrowThisThread_function_value( &::SireCluster::Nodes::borrowThisThread );
Nodes_exposer.def(
"borrowThisThread"
, borrowThisThread_function_value );
}
{ //::SireCluster::Nodes::count
typedef int ( ::SireCluster::Nodes::*count_function_type )( ) ;
count_function_type count_function_value( &::SireCluster::Nodes::count );
Nodes_exposer.def(
"count"
, count_function_value );
}
{ //::SireCluster::Nodes::getAllNodes
typedef ::QList< SireCluster::Node > ( ::SireCluster::Nodes::*getAllNodes_function_type )( ) ;
getAllNodes_function_type getAllNodes_function_value( &::SireCluster::Nodes::getAllNodes );
Nodes_exposer.def(
"getAllNodes"
, getAllNodes_function_value );
}
{ //::SireCluster::Nodes::getAllNodes
typedef ::QList< SireCluster::Node > ( ::SireCluster::Nodes::*getAllNodes_function_type )( int ) ;
getAllNodes_function_type getAllNodes_function_value( &::SireCluster::Nodes::getAllNodes );
Nodes_exposer.def(
"getAllNodes"
, getAllNodes_function_value
, ( bp::arg("timeout") ) );
}
{ //::SireCluster::Nodes::getNode
typedef ::SireCluster::Node ( ::SireCluster::Nodes::*getNode_function_type )( ) ;
getNode_function_type getNode_function_value( &::SireCluster::Nodes::getNode );
Nodes_exposer.def(
"getNode"
, getNode_function_value );
}
{ //::SireCluster::Nodes::getNode
typedef ::SireCluster::Node ( ::SireCluster::Nodes::*getNode_function_type )( int ) ;
getNode_function_type getNode_function_value( &::SireCluster::Nodes::getNode );
Nodes_exposer.def(
"getNode"
, getNode_function_value
, ( bp::arg("timeout") ) );
}
{ //::SireCluster::Nodes::getNodes
typedef ::QList< SireCluster::Node > ( ::SireCluster::Nodes::*getNodes_function_type )( int ) ;
getNodes_function_type getNodes_function_value( &::SireCluster::Nodes::getNodes );
Nodes_exposer.def(
"getNodes"
, getNodes_function_value
, ( bp::arg("n") ) );
}
{ //::SireCluster::Nodes::getNodes
typedef ::QList< SireCluster::Node > ( ::SireCluster::Nodes::*getNodes_function_type )( int,int ) ;
getNodes_function_type getNodes_function_value( &::SireCluster::Nodes::getNodes );
Nodes_exposer.def(
"getNodes"
, getNodes_function_value
, ( bp::arg("n"), bp::arg("timeout") ) );
}
{ //::SireCluster::Nodes::isEmpty
typedef bool ( ::SireCluster::Nodes::*isEmpty_function_type )( ) ;
isEmpty_function_type isEmpty_function_value( &::SireCluster::Nodes::isEmpty );
Nodes_exposer.def(
"isEmpty"
, isEmpty_function_value );
}
{ //::SireCluster::Nodes::nBusy
typedef int ( ::SireCluster::Nodes::*nBusy_function_type )( ) ;
nBusy_function_type nBusy_function_value( &::SireCluster::Nodes::nBusy );
Nodes_exposer.def(
"nBusy"
, nBusy_function_value );
}
{ //::SireCluster::Nodes::nFree
typedef int ( ::SireCluster::Nodes::*nFree_function_type )( ) ;
nFree_function_type nFree_function_value( &::SireCluster::Nodes::nFree );
Nodes_exposer.def(
"nFree"
, nFree_function_value );
}
{ //::SireCluster::Nodes::nNodes
typedef int ( ::SireCluster::Nodes::*nNodes_function_type )( ) ;
nNodes_function_type nNodes_function_value( &::SireCluster::Nodes::nNodes );
Nodes_exposer.def(
"nNodes"
, nNodes_function_value );
}
Nodes_exposer.def( bp::self != bp::self );
{ //::SireCluster::Nodes::operator=
typedef ::SireCluster::Nodes & ( ::SireCluster::Nodes::*assign_function_type )( ::SireCluster::Nodes const & ) ;
assign_function_type assign_function_value( &::SireCluster::Nodes::operator= );
Nodes_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
Nodes_exposer.def( bp::self == bp::self );
{ //::SireCluster::Nodes::remove
typedef void ( ::SireCluster::Nodes::*remove_function_type )( ::SireCluster::Node ) ;
remove_function_type remove_function_value( &::SireCluster::Nodes::remove );
Nodes_exposer.def(
"remove"
, remove_function_value
, ( bp::arg("node") ) );
}
{ //::SireCluster::Nodes::removeAll
typedef void ( ::SireCluster::Nodes::*removeAll_function_type )( ) ;
removeAll_function_type removeAll_function_value( &::SireCluster::Nodes::removeAll );
Nodes_exposer.def(
"removeAll"
, removeAll_function_value );
}
{ //::SireCluster::Nodes::toString
typedef ::QString ( ::SireCluster::Nodes::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireCluster::Nodes::toString );
Nodes_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireCluster::Nodes::waitUntilAllFree
typedef void ( ::SireCluster::Nodes::*waitUntilAllFree_function_type )( ) ;
waitUntilAllFree_function_type waitUntilAllFree_function_value( &::SireCluster::Nodes::waitUntilAllFree );
Nodes_exposer.def(
"waitUntilAllFree"
, waitUntilAllFree_function_value );
}
{ //::SireCluster::Nodes::waitUntilAllFree
typedef bool ( ::SireCluster::Nodes::*waitUntilAllFree_function_type )( int ) ;
waitUntilAllFree_function_type waitUntilAllFree_function_value( &::SireCluster::Nodes::waitUntilAllFree );
Nodes_exposer.def(
"waitUntilAllFree"
, waitUntilAllFree_function_value
, ( bp::arg("timeout") ) );
}
Nodes_exposer.def( "__copy__", &__copy__);
Nodes_exposer.def( "__deepcopy__", &__copy__);
Nodes_exposer.def( "clone", &__copy__);
Nodes_exposer.def( "__str__", &__str__< ::SireCluster::Nodes > );
Nodes_exposer.def( "__repr__", &__str__< ::SireCluster::Nodes > );
Nodes_exposer.def( "__len__", &__len_count< ::SireCluster::Nodes > );
}
}
void register_RestraintFF_class(){
{ //::SireMM::RestraintFF
typedef bp::class_< SireMM::RestraintFF, bp::bases< SireFF::FF3D, SireFF::G1FF, SireFF::FF, SireMol::MolGroupsBase, SireBase::Property > > RestraintFF_exposer_t;
RestraintFF_exposer_t RestraintFF_exposer = RestraintFF_exposer_t( "RestraintFF", bp::init< >() );
bp::scope RestraintFF_scope( RestraintFF_exposer );
RestraintFF_exposer.def( bp::init< QString const & >(( bp::arg("name") )) );
RestraintFF_exposer.def( bp::init< SireMM::RestraintFF const & >(( bp::arg("other") )) );
{ //::SireMM::RestraintFF::add
typedef bool ( ::SireMM::RestraintFF::*add_function_type )( ::SireMM::Restraint3D const & ) ;
add_function_type add_function_value( &::SireMM::RestraintFF::add );
RestraintFF_exposer.def(
"add"
, add_function_value
, ( bp::arg("restraint") ) );
}
{ //::SireMM::RestraintFF::builtinSymbols
typedef ::SireCAS::Symbols ( ::SireMM::RestraintFF::*builtinSymbols_function_type )( ) const;
builtinSymbols_function_type builtinSymbols_function_value( &::SireMM::RestraintFF::builtinSymbols );
RestraintFF_exposer.def(
"builtinSymbols"
, builtinSymbols_function_value );
}
{ //::SireMM::RestraintFF::components
typedef ::SireMM::RestraintComponent const & ( ::SireMM::RestraintFF::*components_function_type )( ) const;
components_function_type components_function_value( &::SireMM::RestraintFF::components );
RestraintFF_exposer.def(
"components"
, components_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireMM::RestraintFF::contains
typedef bool ( ::SireMM::RestraintFF::*contains_function_type )( ::SireMM::Restraint3D const & ) const;
contains_function_type contains_function_value( &::SireMM::RestraintFF::contains );
RestraintFF_exposer.def(
"contains"
, contains_function_value
, ( bp::arg("restraint") ) );
}
{ //::SireMM::RestraintFF::containsProperty
typedef bool ( ::SireMM::RestraintFF::*containsProperty_function_type )( ::QString const & ) const;
containsProperty_function_type containsProperty_function_value( &::SireMM::RestraintFF::containsProperty );
RestraintFF_exposer.def(
"containsProperty"
, containsProperty_function_value
, ( bp::arg("name") ) );
}
{ //::SireMM::RestraintFF::differentiate
typedef ::SireMM::RestraintFF ( ::SireMM::RestraintFF::*differentiate_function_type )( ::SireCAS::Symbol const & ) const;
differentiate_function_type differentiate_function_value( &::SireMM::RestraintFF::differentiate );
RestraintFF_exposer.def(
"differentiate"
, differentiate_function_value
, ( bp::arg("symbol") ) );
}
{ //::SireMM::RestraintFF::field
typedef void ( ::SireMM::RestraintFF::*field_function_type )( ::SireFF::FieldTable &,double ) ;
field_function_type field_function_value( &::SireMM::RestraintFF::field );
RestraintFF_exposer.def(
"field"
, field_function_value
, ( bp::arg("fieldtable"), bp::arg("scale_field")=1 ) );
}
{ //::SireMM::RestraintFF::field
typedef void ( ::SireMM::RestraintFF::*field_function_type )( ::SireFF::FieldTable &,::SireCAS::Symbol const &,double ) ;
field_function_type field_function_value( &::SireMM::RestraintFF::field );
RestraintFF_exposer.def(
"field"
, field_function_value
, ( bp::arg("fieldtable"), bp::arg("component"), bp::arg("scale_field")=1 ) );
}
{ //::SireMM::RestraintFF::field
typedef void ( ::SireMM::RestraintFF::*field_function_type )( ::SireFF::FieldTable &,::SireFF::Probe const &,double ) ;
field_function_type field_function_value( &::SireMM::RestraintFF::field );
RestraintFF_exposer.def(
"field"
, field_function_value
, ( bp::arg("fieldtable"), bp::arg("probe"), bp::arg("scale_field")=1 ) );
}
{ //::SireMM::RestraintFF::field
typedef void ( ::SireMM::RestraintFF::*field_function_type )( ::SireFF::FieldTable &,::SireCAS::Symbol const &,::SireFF::Probe const &,double ) ;
field_function_type field_function_value( &::SireMM::RestraintFF::field );
RestraintFF_exposer.def(
"field"
, field_function_value
, ( bp::arg("fieldtable"), bp::arg("component"), bp::arg("probe"), bp::arg("scale_field")=1 ) );
}
{ //::SireMM::RestraintFF::force
typedef void ( ::SireMM::RestraintFF::*force_function_type )( ::SireFF::ForceTable &,double ) ;
force_function_type force_function_value( &::SireMM::RestraintFF::force );
RestraintFF_exposer.def(
"force"
, force_function_value
, ( bp::arg("forcetable"), bp::arg("scale_force")=1 ) );
}
{ //::SireMM::RestraintFF::force
typedef void ( ::SireMM::RestraintFF::*force_function_type )( ::SireFF::ForceTable &,::SireCAS::Symbol const &,double ) ;
force_function_type force_function_value( &::SireMM::RestraintFF::force );
RestraintFF_exposer.def(
"force"
, force_function_value
, ( bp::arg("forcetable"), bp::arg("symbol"), bp::arg("scale_force")=1 ) );
}
{ //::SireMM::RestraintFF::getValue
typedef double ( ::SireMM::RestraintFF::*getValue_function_type )( ::SireCAS::Symbol const & ) const;
getValue_function_type getValue_function_value( &::SireMM::RestraintFF::getValue );
RestraintFF_exposer.def(
"getValue"
, getValue_function_value
, ( bp::arg("symbol") ) );
}
{ //::SireMM::RestraintFF::hasValue
typedef bool ( ::SireMM::RestraintFF::*hasValue_function_type )( ::SireCAS::Symbol const & ) const;
hasValue_function_type hasValue_function_value( &::SireMM::RestraintFF::hasValue );
RestraintFF_exposer.def(
"hasValue"
, hasValue_function_value
, ( bp::arg("symbol") ) );
}
{ //::SireMM::RestraintFF::mustNowRecalculateFromScratch
typedef void ( ::SireMM::RestraintFF::*mustNowRecalculateFromScratch_function_type )( ) ;
mustNowRecalculateFromScratch_function_type mustNowRecalculateFromScratch_function_value( &::SireMM::RestraintFF::mustNowRecalculateFromScratch );
RestraintFF_exposer.def(
"mustNowRecalculateFromScratch"
, mustNowRecalculateFromScratch_function_value );
}
{ //::SireMM::RestraintFF::nRestraints
typedef int ( ::SireMM::RestraintFF::*nRestraints_function_type )( ) const;
nRestraints_function_type nRestraints_function_value( &::SireMM::RestraintFF::nRestraints );
RestraintFF_exposer.def(
"nRestraints"
, nRestraints_function_value );
}
RestraintFF_exposer.def( bp::self != bp::self );
{ //::SireMM::RestraintFF::operator=
typedef ::SireMM::RestraintFF & ( ::SireMM::RestraintFF::*assign_function_type )( ::SireMM::RestraintFF const & ) ;
assign_function_type assign_function_value( &::SireMM::RestraintFF::operator= );
RestraintFF_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
RestraintFF_exposer.def( bp::self == bp::self );
{ //::SireMM::RestraintFF::potential
typedef void ( ::SireMM::RestraintFF::*potential_function_type )( ::SireFF::PotentialTable &,double ) ;
potential_function_type potential_function_value( &::SireMM::RestraintFF::potential );
RestraintFF_exposer.def(
"potential"
, potential_function_value
, ( bp::arg("potentialtable"), bp::arg("scale_potential")=1 ) );
}
{ //::SireMM::RestraintFF::potential
typedef void ( ::SireMM::RestraintFF::*potential_function_type )( ::SireFF::PotentialTable &,::SireCAS::Symbol const &,double ) ;
potential_function_type potential_function_value( &::SireMM::RestraintFF::potential );
RestraintFF_exposer.def(
"potential"
, potential_function_value
, ( bp::arg("potentialtable"), bp::arg("component"), bp::arg("scale_potential")=1 ) );
}
{ //::SireMM::RestraintFF::potential
typedef void ( ::SireMM::RestraintFF::*potential_function_type )( ::SireFF::PotentialTable &,::SireFF::Probe const &,double ) ;
potential_function_type potential_function_value( &::SireMM::RestraintFF::potential );
RestraintFF_exposer.def(
"potential"
, potential_function_value
, ( bp::arg("potentialtable"), bp::arg("probe"), bp::arg("scale_potential")=1 ) );
}
{ //::SireMM::RestraintFF::potential
typedef void ( ::SireMM::RestraintFF::*potential_function_type )( ::SireFF::PotentialTable &,::SireCAS::Symbol const &,::SireFF::Probe const &,double ) ;
potential_function_type potential_function_value( &::SireMM::RestraintFF::potential );
RestraintFF_exposer.def(
"potential"
, potential_function_value
, ( bp::arg("potentialtable"), bp::arg("component"), bp::arg("probe"), bp::arg("scale_potential")=1 ) );
}
{ //::SireMM::RestraintFF::properties
typedef ::SireBase::Properties const & ( ::SireMM::RestraintFF::*properties_function_type )( ) const;
properties_function_type properties_function_value( &::SireMM::RestraintFF::properties );
RestraintFF_exposer.def(
"properties"
, properties_function_value
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireMM::RestraintFF::property
typedef ::SireBase::Property const & ( ::SireMM::RestraintFF::*property_function_type )( ::QString const & ) const;
property_function_type property_function_value( &::SireMM::RestraintFF::property );
RestraintFF_exposer.def(
"property"
, property_function_value
, ( bp::arg("name") )
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireMM::RestraintFF::remove
typedef bool ( ::SireMM::RestraintFF::*remove_function_type )( ::SireMM::Restraint3D const & ) ;
remove_function_type remove_function_value( &::SireMM::RestraintFF::remove );
RestraintFF_exposer.def(
"remove"
, remove_function_value
, ( bp::arg("restraint") ) );
}
{ //::SireMM::RestraintFF::removeRestraintAt
typedef void ( ::SireMM::RestraintFF::*removeRestraintAt_function_type )( int ) ;
removeRestraintAt_function_type removeRestraintAt_function_value( &::SireMM::RestraintFF::removeRestraintAt );
RestraintFF_exposer.def(
"removeRestraintAt"
, removeRestraintAt_function_value
, ( bp::arg("i") ) );
}
{ //::SireMM::RestraintFF::restraintAt
typedef ::SireMM::Restraint3D const & ( ::SireMM::RestraintFF::*restraintAt_function_type )( int ) const;
restraintAt_function_type restraintAt_function_value( &::SireMM::RestraintFF::restraintAt );
RestraintFF_exposer.def(
"restraintAt"
, restraintAt_function_value
, ( bp::arg("i") )
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireMM::RestraintFF::restraints
typedef ::QVector< SireBase::PropPtr< SireMM::Restraint3D > > ( ::SireMM::RestraintFF::*restraints_function_type )( ) const;
restraints_function_type restraints_function_value( &::SireMM::RestraintFF::restraints );
RestraintFF_exposer.def(
"restraints"
, restraints_function_value );
}
{ //::SireMM::RestraintFF::setProperty
typedef bool ( ::SireMM::RestraintFF::*setProperty_function_type )( ::QString const &,::SireBase::Property const & ) ;
setProperty_function_type setProperty_function_value( &::SireMM::RestraintFF::setProperty );
RestraintFF_exposer.def(
"setProperty"
, setProperty_function_value
, ( bp::arg("name"), bp::arg("property") ) );
}
{ //::SireMM::RestraintFF::setSpace
typedef bool ( ::SireMM::RestraintFF::*setSpace_function_type )( ::SireVol::Space const & ) ;
setSpace_function_type setSpace_function_value( &::SireMM::RestraintFF::setSpace );
RestraintFF_exposer.def(
"setSpace"
, setSpace_function_value
, ( bp::arg("space") ) );
}
{ //::SireMM::RestraintFF::setValue
typedef bool ( ::SireMM::RestraintFF::*setValue_function_type )( ::SireCAS::Symbol const &,double ) ;
setValue_function_type setValue_function_value( &::SireMM::RestraintFF::setValue );
RestraintFF_exposer.def(
"setValue"
, setValue_function_value
, ( bp::arg("symbol"), bp::arg("value") ) );
}
{ //::SireMM::RestraintFF::space
typedef ::SireVol::Space const & ( ::SireMM::RestraintFF::*space_function_type )( ) const;
space_function_type space_function_value( &::SireMM::RestraintFF::space );
RestraintFF_exposer.def(
"space"
, space_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireMM::RestraintFF::symbols
typedef ::SireCAS::Symbols ( ::SireMM::RestraintFF::*symbols_function_type )( ) const;
symbols_function_type symbols_function_value( &::SireMM::RestraintFF::symbols );
RestraintFF_exposer.def(
"symbols"
, symbols_function_value );
}
{ //::SireMM::RestraintFF::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMM::RestraintFF::typeName );
RestraintFF_exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireMM::RestraintFF::userSymbols
typedef ::SireCAS::Symbols ( ::SireMM::RestraintFF::*userSymbols_function_type )( ) const;
userSymbols_function_type userSymbols_function_value( &::SireMM::RestraintFF::userSymbols );
RestraintFF_exposer.def(
"userSymbols"
, userSymbols_function_value );
}
{ //::SireMM::RestraintFF::userValues
typedef ::SireCAS::Values ( ::SireMM::RestraintFF::*userValues_function_type )( ) const;
userValues_function_type userValues_function_value( &::SireMM::RestraintFF::userValues );
RestraintFF_exposer.def(
"userValues"
, userValues_function_value );
}
RestraintFF_exposer.staticmethod( "typeName" );
RestraintFF_exposer.def( "__copy__", &__copy__);
RestraintFF_exposer.def( "__deepcopy__", &__copy__);
RestraintFF_exposer.def( "clone", &__copy__);
RestraintFF_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::RestraintFF >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
RestraintFF_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::RestraintFF >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
RestraintFF_exposer.def( "__str__", &__str__< ::SireMM::RestraintFF > );
RestraintFF_exposer.def( "__repr__", &__str__< ::SireMM::RestraintFF > );
RestraintFF_exposer.def( "__len__", &__len_count< ::SireMM::RestraintFF > );
}
}
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_CLJ14Group_class(){
{ //::SireMM::CLJ14Group
typedef bp::class_< SireMM::CLJ14Group > CLJ14Group_exposer_t;
CLJ14Group_exposer_t CLJ14Group_exposer = CLJ14Group_exposer_t( "CLJ14Group", bp::init< >() );
bp::scope CLJ14Group_scope( CLJ14Group_exposer );
CLJ14Group_exposer.def( bp::init< SireMol::MoleculeView const &, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("molecule"), bp::arg("map")=SireBase::PropertyMap() )) );
CLJ14Group_exposer.def( bp::init< SireMol::MoleculeView const &, SireMM::CLJFunction::COMBINING_RULES, bool, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("molecule"), bp::arg("combining_rules"), bp::arg("is_strict"), bp::arg("map")=SireBase::PropertyMap() )) );
CLJ14Group_exposer.def( bp::init< SireMM::CLJ14Group const & >(( bp::arg("other") )) );
{ //::SireMM::CLJ14Group::add
typedef void ( ::SireMM::CLJ14Group::*add_function_type )( ::SireMol::MoleculeView const & ) ;
add_function_type add_function_value( &::SireMM::CLJ14Group::add );
CLJ14Group_exposer.def(
"add"
, add_function_value
, ( bp::arg("new_molecule") ) );
}
{ //::SireMM::CLJ14Group::add
typedef void ( ::SireMM::CLJ14Group::*add_function_type )( ::SireMol::AtomSelection const & ) ;
add_function_type add_function_value( &::SireMM::CLJ14Group::add );
CLJ14Group_exposer.def(
"add"
, add_function_value
, ( bp::arg("new_selection") ) );
}
{ //::SireMM::CLJ14Group::combiningRules
typedef ::SireMM::CLJFunction::COMBINING_RULES ( ::SireMM::CLJ14Group::*combiningRules_function_type )( ) const;
combiningRules_function_type combiningRules_function_value( &::SireMM::CLJ14Group::combiningRules );
CLJ14Group_exposer.def(
"combiningRules"
, combiningRules_function_value );
}
{ //::SireMM::CLJ14Group::energy
typedef ::boost::tuples::tuple< double, double, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type > ( ::SireMM::CLJ14Group::*energy_function_type )( ) ;
energy_function_type energy_function_value( &::SireMM::CLJ14Group::energy );
CLJ14Group_exposer.def(
"energy"
, energy_function_value );
}
{ //::SireMM::CLJ14Group::isNull
typedef bool ( ::SireMM::CLJ14Group::*isNull_function_type )( ) const;
isNull_function_type isNull_function_value( &::SireMM::CLJ14Group::isNull );
CLJ14Group_exposer.def(
"isNull"
, isNull_function_value );
}
{ //::SireMM::CLJ14Group::isStrict
typedef bool ( ::SireMM::CLJ14Group::*isStrict_function_type )( ) const;
isStrict_function_type isStrict_function_value( &::SireMM::CLJ14Group::isStrict );
CLJ14Group_exposer.def(
"isStrict"
, isStrict_function_value );
}
{ //::SireMM::CLJ14Group::molecule
typedef ::SireMol::MoleculeView const & ( ::SireMM::CLJ14Group::*molecule_function_type )( ) const;
molecule_function_type molecule_function_value( &::SireMM::CLJ14Group::molecule );
CLJ14Group_exposer.def(
"molecule"
, molecule_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireMM::CLJ14Group::mustNowRecalculateFromScratch
typedef void ( ::SireMM::CLJ14Group::*mustNowRecalculateFromScratch_function_type )( ) ;
mustNowRecalculateFromScratch_function_type mustNowRecalculateFromScratch_function_value( &::SireMM::CLJ14Group::mustNowRecalculateFromScratch );
CLJ14Group_exposer.def(
"mustNowRecalculateFromScratch"
, mustNowRecalculateFromScratch_function_value );
}
{ //::SireMM::CLJ14Group::mustReallyRecalculateFromScratch
typedef void ( ::SireMM::CLJ14Group::*mustReallyRecalculateFromScratch_function_type )( ) ;
mustReallyRecalculateFromScratch_function_type mustReallyRecalculateFromScratch_function_value( &::SireMM::CLJ14Group::mustReallyRecalculateFromScratch );
CLJ14Group_exposer.def(
"mustReallyRecalculateFromScratch"
, mustReallyRecalculateFromScratch_function_value );
}
CLJ14Group_exposer.def( bp::self != bp::self );
{ //::SireMM::CLJ14Group::operator=
typedef ::SireMM::CLJ14Group & ( ::SireMM::CLJ14Group::*assign_function_type )( ::SireMM::CLJ14Group const & ) ;
assign_function_type assign_function_value( &::SireMM::CLJ14Group::operator= );
CLJ14Group_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
CLJ14Group_exposer.def( bp::self == bp::self );
{ //::SireMM::CLJ14Group::propertyMap
typedef ::SireBase::PropertyMap ( ::SireMM::CLJ14Group::*propertyMap_function_type )( ) const;
propertyMap_function_type propertyMap_function_value( &::SireMM::CLJ14Group::propertyMap );
CLJ14Group_exposer.def(
"propertyMap"
, propertyMap_function_value );
}
{ //::SireMM::CLJ14Group::recalculatingFromScratch
typedef bool ( ::SireMM::CLJ14Group::*recalculatingFromScratch_function_type )( ) const;
recalculatingFromScratch_function_type recalculatingFromScratch_function_value( &::SireMM::CLJ14Group::recalculatingFromScratch );
CLJ14Group_exposer.def(
"recalculatingFromScratch"
, recalculatingFromScratch_function_value );
}
{ //::SireMM::CLJ14Group::remove
typedef void ( ::SireMM::CLJ14Group::*remove_function_type )( ::SireMol::AtomSelection const & ) ;
remove_function_type remove_function_value( &::SireMM::CLJ14Group::remove );
CLJ14Group_exposer.def(
"remove"
, remove_function_value
, ( bp::arg("new_selection") ) );
}
{ //::SireMM::CLJ14Group::remove
typedef void ( ::SireMM::CLJ14Group::*remove_function_type )( ::SireMol::MoleculeView const & ) ;
remove_function_type remove_function_value( &::SireMM::CLJ14Group::remove );
CLJ14Group_exposer.def(
"remove"
, remove_function_value
, ( bp::arg("new_molecule") ) );
}
{ //::SireMM::CLJ14Group::setArithmeticCombiningRules
typedef void ( ::SireMM::CLJ14Group::*setArithmeticCombiningRules_function_type )( bool ) ;
setArithmeticCombiningRules_function_type setArithmeticCombiningRules_function_value( &::SireMM::CLJ14Group::setArithmeticCombiningRules );
CLJ14Group_exposer.def(
"setArithmeticCombiningRules"
, setArithmeticCombiningRules_function_value
, ( bp::arg("on") ) );
}
{ //::SireMM::CLJ14Group::setCombiningRules
typedef void ( ::SireMM::CLJ14Group::*setCombiningRules_function_type )( ::SireMM::CLJFunction::COMBINING_RULES ) ;
setCombiningRules_function_type setCombiningRules_function_value( &::SireMM::CLJ14Group::setCombiningRules );
CLJ14Group_exposer.def(
"setCombiningRules"
, setCombiningRules_function_value
, ( bp::arg("rules") ) );
}
{ //::SireMM::CLJ14Group::setGeometricCombiningRules
typedef void ( ::SireMM::CLJ14Group::*setGeometricCombiningRules_function_type )( bool ) ;
setGeometricCombiningRules_function_type setGeometricCombiningRules_function_value( &::SireMM::CLJ14Group::setGeometricCombiningRules );
CLJ14Group_exposer.def(
"setGeometricCombiningRules"
, setGeometricCombiningRules_function_value
, ( bp::arg("on") ) );
}
{ //::SireMM::CLJ14Group::setStrict
typedef bool ( ::SireMM::CLJ14Group::*setStrict_function_type )( bool ) ;
setStrict_function_type setStrict_function_value( &::SireMM::CLJ14Group::setStrict );
CLJ14Group_exposer.def(
"setStrict"
, setStrict_function_value
, ( bp::arg("isstrict") ) );
}
{ //::SireMM::CLJ14Group::toString
typedef ::QString ( ::SireMM::CLJ14Group::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireMM::CLJ14Group::toString );
CLJ14Group_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireMM::CLJ14Group::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMM::CLJ14Group::typeName );
CLJ14Group_exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireMM::CLJ14Group::update
typedef void ( ::SireMM::CLJ14Group::*update_function_type )( ::SireMol::MoleculeView const & ) ;
update_function_type update_function_value( &::SireMM::CLJ14Group::update );
CLJ14Group_exposer.def(
"update"
, update_function_value
, ( bp::arg("new_molecule") ) );
}
{ //::SireMM::CLJ14Group::updateSelection
typedef void ( ::SireMM::CLJ14Group::*updateSelection_function_type )( ::SireMol::AtomSelection const & ) ;
updateSelection_function_type updateSelection_function_value( &::SireMM::CLJ14Group::updateSelection );
CLJ14Group_exposer.def(
"updateSelection"
, updateSelection_function_value
, ( bp::arg("selection") ) );
}
{ //::SireMM::CLJ14Group::usingArithmeticCombiningRules
typedef bool ( ::SireMM::CLJ14Group::*usingArithmeticCombiningRules_function_type )( ) const;
usingArithmeticCombiningRules_function_type usingArithmeticCombiningRules_function_value( &::SireMM::CLJ14Group::usingArithmeticCombiningRules );
CLJ14Group_exposer.def(
"usingArithmeticCombiningRules"
, usingArithmeticCombiningRules_function_value );
}
{ //::SireMM::CLJ14Group::usingGeometricCombiningRules
typedef bool ( ::SireMM::CLJ14Group::*usingGeometricCombiningRules_function_type )( ) const;
usingGeometricCombiningRules_function_type usingGeometricCombiningRules_function_value( &::SireMM::CLJ14Group::usingGeometricCombiningRules );
CLJ14Group_exposer.def(
"usingGeometricCombiningRules"
, usingGeometricCombiningRules_function_value );
}
{ //::SireMM::CLJ14Group::what
typedef char const * ( ::SireMM::CLJ14Group::*what_function_type )( ) const;
what_function_type what_function_value( &::SireMM::CLJ14Group::what );
CLJ14Group_exposer.def(
"what"
, what_function_value );
}
{ //::SireMM::CLJ14Group::wouldChangeProperties
typedef bool ( ::SireMM::CLJ14Group::*wouldChangeProperties_function_type )( ::SireBase::PropertyMap const & ) const;
wouldChangeProperties_function_type wouldChangeProperties_function_value( &::SireMM::CLJ14Group::wouldChangeProperties );
CLJ14Group_exposer.def(
"wouldChangeProperties"
, wouldChangeProperties_function_value
, ( bp::arg("map") ) );
}
CLJ14Group_exposer.staticmethod( "typeName" );
CLJ14Group_exposer.def( "__copy__", &__copy__);
CLJ14Group_exposer.def( "__deepcopy__", &__copy__);
CLJ14Group_exposer.def( "clone", &__copy__);
CLJ14Group_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::CLJ14Group >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
CLJ14Group_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::CLJ14Group >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
CLJ14Group_exposer.def( "__str__", &__str__< ::SireMM::CLJ14Group > );
CLJ14Group_exposer.def( "__repr__", &__str__< ::SireMM::CLJ14Group > );
}
}
void register_MolEditor_class(){
{ //::SireMol::MolEditor
typedef bp::class_< SireMol::MolEditor, bp::bases< SireMol::Editor<SireMol::MolEditor, SireMol::Molecule>, SireMol::Molecule, SireMol::MoleculeView, SireBase::Property > > MolEditor_exposer_t;
MolEditor_exposer_t MolEditor_exposer = MolEditor_exposer_t( "MolEditor", "This class is used to edit non-structural parts of a molecule\n(e.g. its name, number, properties etc.). To add, move or remove\natoms, residues, CutGroups, chains or segments, you need to\nuse a MolStructureEditor (which is created for you automatically\nby member functions that perform such editing)\n\nAuthor: Christopher Woods\n", bp::init< >("Null constructor") );
bp::scope MolEditor_scope( MolEditor_exposer );
MolEditor_exposer.def( bp::init< SireMol::Molecule const & >(( bp::arg("molecule") ), "Construct an editor to edit a copy of molecule") );
MolEditor_exposer.def( bp::init< SireMol::MolEditor const & >(( bp::arg("other") ), "Copy constructor") );
{ //::SireMol::MolEditor::add
typedef ::SireMol::AtomStructureEditor ( ::SireMol::MolEditor::*add_function_type)( ::SireMol::AtomName const & ) const;
add_function_type add_function_value( &::SireMol::MolEditor::add );
MolEditor_exposer.def(
"add"
, add_function_value
, ( bp::arg("atom") )
, "Add an atom called name and return an editor that can\nbe used to edit it" );
}
{ //::SireMol::MolEditor::add
typedef ::SireMol::AtomStructureEditor ( ::SireMol::MolEditor::*add_function_type)( ::SireMol::AtomNum const & ) const;
add_function_type add_function_value( &::SireMol::MolEditor::add );
MolEditor_exposer.def(
"add"
, add_function_value
, ( bp::arg("atom") )
, "Add an atom with number number and return an editor that\ncan be used to edit it" );
}
{ //::SireMol::MolEditor::add
typedef ::SireMol::ResStructureEditor ( ::SireMol::MolEditor::*add_function_type)( ::SireMol::ResName const & ) const;
add_function_type add_function_value( &::SireMol::MolEditor::add );
MolEditor_exposer.def(
"add"
, add_function_value
, ( bp::arg("residue") )
, "Add a residue called name and return an editor that can\nbe used to edit it" );
}
{ //::SireMol::MolEditor::add
typedef ::SireMol::ResStructureEditor ( ::SireMol::MolEditor::*add_function_type)( ::SireMol::ResNum const & ) const;
add_function_type add_function_value( &::SireMol::MolEditor::add );
MolEditor_exposer.def(
"add"
, add_function_value
, ( bp::arg("residue") )
, "Add a residue with number number and return an editor that\ncan be used to edit it" );
}
{ //::SireMol::MolEditor::add
typedef ::SireMol::CGStructureEditor ( ::SireMol::MolEditor::*add_function_type)( ::SireMol::CGName const & ) const;
add_function_type add_function_value( &::SireMol::MolEditor::add );
MolEditor_exposer.def(
"add"
, add_function_value
, ( bp::arg("cutgroup") )
, "Add a CutGroup called name and return an editor that can\nbe used to edit it" );
}
{ //::SireMol::MolEditor::add
typedef ::SireMol::ChainStructureEditor ( ::SireMol::MolEditor::*add_function_type)( ::SireMol::ChainName const & ) const;
add_function_type add_function_value( &::SireMol::MolEditor::add );
MolEditor_exposer.def(
"add"
, add_function_value
, ( bp::arg("chain") )
, "Add a chain called name and return an editor that can\nbe used to edit it" );
}
{ //::SireMol::MolEditor::add
typedef ::SireMol::SegStructureEditor ( ::SireMol::MolEditor::*add_function_type)( ::SireMol::SegName const & ) const;
add_function_type add_function_value( &::SireMol::MolEditor::add );
MolEditor_exposer.def(
"add"
, add_function_value
, ( bp::arg("segment") )
, "Add a segment called name and return an editor that can\nbe used to edit it" );
}
{ //::SireMol::MolEditor::commit
typedef ::SireMol::Molecule ( ::SireMol::MolEditor::*commit_function_type)( ) const;
commit_function_type commit_function_value( &::SireMol::MolEditor::commit );
MolEditor_exposer.def(
"commit"
, commit_function_value
, "Commit these changes and return a copy of the\nedited molecule" );
}
{ //::SireMol::MolEditor::operator=
typedef ::SireMol::MolEditor & ( ::SireMol::MolEditor::*assign_function_type)( ::SireMol::Molecule const & ) ;
assign_function_type assign_function_value( &::SireMol::MolEditor::operator= );
MolEditor_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("molecule") )
, bp::return_self< >()
, "" );
}
{ //::SireMol::MolEditor::operator=
typedef ::SireMol::MolEditor & ( ::SireMol::MolEditor::*assign_function_type)( ::SireMol::MolEditor const & ) ;
assign_function_type assign_function_value( &::SireMol::MolEditor::operator= );
MolEditor_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >()
, "" );
}
{ //::SireMol::MolEditor::remove
typedef ::SireMol::MolStructureEditor ( ::SireMol::MolEditor::*remove_function_type)( ::SireMol::AtomID const & ) const;
remove_function_type remove_function_value( &::SireMol::MolEditor::remove );
MolEditor_exposer.def(
"remove"
, remove_function_value
, ( bp::arg("atomid") )
, "Remove all atoms from this molecule that have the ID atomid.\nThis does nothing if there are no atoms with this ID.\nThis returns an editor that can be used to further edit\nthe molecule" );
}
{ //::SireMol::MolEditor::remove
typedef ::SireMol::MolStructureEditor ( ::SireMol::MolEditor::*remove_function_type)( ::SireMol::CGID const & ) const;
remove_function_type remove_function_value( &::SireMol::MolEditor::remove );
MolEditor_exposer.def(
"remove"
, remove_function_value
, ( bp::arg("cgid") )
, "Remove all CutGroups from this molecule that have the ID atomid.\nThis does nothing if there are no CutGroups with this ID.\nThis returns an editor that can be used to further edit\nthe molecule" );
}
{ //::SireMol::MolEditor::remove
typedef ::SireMol::MolStructureEditor ( ::SireMol::MolEditor::*remove_function_type)( ::SireMol::ResID const & ) const;
remove_function_type remove_function_value( &::SireMol::MolEditor::remove );
MolEditor_exposer.def(
"remove"
, remove_function_value
, ( bp::arg("resid") )
, "Remove all residues from this molecule that have the ID atomid.\nThis does nothing if there are no residues with this ID.\nThis returns an editor that can be used to further edit\nthe molecule" );
}
{ //::SireMol::MolEditor::remove
typedef ::SireMol::MolStructureEditor ( ::SireMol::MolEditor::*remove_function_type)( ::SireMol::ChainID const & ) const;
remove_function_type remove_function_value( &::SireMol::MolEditor::remove );
MolEditor_exposer.def(
"remove"
, remove_function_value
, ( bp::arg("chainid") )
, "Remove all chains from this molecule that have the ID atomid.\nThis does nothing if there are no chains with this ID.\nThis returns an editor that can be used to further edit\nthe molecule" );
}
{ //::SireMol::MolEditor::remove
typedef ::SireMol::MolStructureEditor ( ::SireMol::MolEditor::*remove_function_type)( ::SireMol::SegID const & ) const;
remove_function_type remove_function_value( &::SireMol::MolEditor::remove );
MolEditor_exposer.def(
"remove"
, remove_function_value
, ( bp::arg("segid") )
, "Remove all segments from this molecule that have the ID atomid.\nThis does nothing if there are no segments with this ID.\nThis returns an editor that can be used to further edit\nthe molecule" );
}
{ //::SireMol::MolEditor::removeAllAtoms
typedef ::SireMol::MolStructureEditor ( ::SireMol::MolEditor::*removeAllAtoms_function_type)( ) const;
removeAllAtoms_function_type removeAllAtoms_function_value( &::SireMol::MolEditor::removeAllAtoms );
MolEditor_exposer.def(
"removeAllAtoms"
, removeAllAtoms_function_value
, "Remove all atoms from this molecule. This returns an editor that\ncan be used to further edit the structure of this molecule" );
}
{ //::SireMol::MolEditor::removeAllChains
typedef ::SireMol::MolStructureEditor ( ::SireMol::MolEditor::*removeAllChains_function_type)( ) const;
removeAllChains_function_type removeAllChains_function_value( &::SireMol::MolEditor::removeAllChains );
MolEditor_exposer.def(
"removeAllChains"
, removeAllChains_function_value
, "Remove all chains from this molecule. This returns an editor that\ncan be used to further edit the structure of this molecule" );
}
{ //::SireMol::MolEditor::removeAllCutGroups
typedef ::SireMol::MolStructureEditor ( ::SireMol::MolEditor::*removeAllCutGroups_function_type)( ) const;
removeAllCutGroups_function_type removeAllCutGroups_function_value( &::SireMol::MolEditor::removeAllCutGroups );
MolEditor_exposer.def(
"removeAllCutGroups"
, removeAllCutGroups_function_value
, "Remove all CutGroups from this molecule. This returns an editor that\ncan be used to further edit the structure of this molecule" );
}
{ //::SireMol::MolEditor::removeAllResidues
typedef ::SireMol::MolStructureEditor ( ::SireMol::MolEditor::*removeAllResidues_function_type)( ) const;
removeAllResidues_function_type removeAllResidues_function_value( &::SireMol::MolEditor::removeAllResidues );
MolEditor_exposer.def(
"removeAllResidues"
, removeAllResidues_function_value
, "Remove all residues from this molecule. This returns an editor that\ncan be used to further edit the structure of this molecule" );
}
{ //::SireMol::MolEditor::removeAllSegments
typedef ::SireMol::MolStructureEditor ( ::SireMol::MolEditor::*removeAllSegments_function_type)( ) const;
removeAllSegments_function_type removeAllSegments_function_value( &::SireMol::MolEditor::removeAllSegments );
MolEditor_exposer.def(
"removeAllSegments"
, removeAllSegments_function_value
, "Remove all segments from this molecule. This returns an editor that\ncan be used to further edit the structure of this molecule" );
}
{ //::SireMol::MolEditor::rename
typedef ::SireMol::MolEditor & ( ::SireMol::MolEditor::*rename_function_type)( ::QString const & ) ;
rename_function_type rename_function_value( &::SireMol::MolEditor::rename );
MolEditor_exposer.def(
"rename"
, rename_function_value
, ( bp::arg("name") )
, bp::return_self< >()
, "Rename this molecule to newname" );
}
{ //::SireMol::MolEditor::renumber
typedef ::SireMol::MolEditor & ( ::SireMol::MolEditor::*renumber_function_type)( ) ;
renumber_function_type renumber_function_value( &::SireMol::MolEditor::renumber );
MolEditor_exposer.def(
"renumber"
, renumber_function_value
, bp::return_self< >()
, "Give this molecule a new, unique ID number" );
}
{ //::SireMol::MolEditor::renumber
typedef ::SireMol::MolEditor & ( ::SireMol::MolEditor::*renumber_function_type)( ::SireMol::MolNum ) ;
renumber_function_type renumber_function_value( &::SireMol::MolEditor::renumber );
MolEditor_exposer.def(
"renumber"
, renumber_function_value
, ( bp::arg("newnum") )
, bp::return_self< >()
, "Give this molecule the ID number newnum" );
}
{ //::SireMol::MolEditor::toString
typedef ::QString ( ::SireMol::MolEditor::*toString_function_type)( ) const;
toString_function_type toString_function_value( &::SireMol::MolEditor::toString );
MolEditor_exposer.def(
"toString"
, toString_function_value
, "Return a string representation of this editor" );
}
{ //::SireMol::MolEditor::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMol::MolEditor::typeName );
MolEditor_exposer.def(
"typeName"
, typeName_function_value
, "" );
}
MolEditor_exposer.staticmethod( "typeName" );
MolEditor_exposer.def( "__copy__", &__copy__);
MolEditor_exposer.def( "__deepcopy__", &__copy__);
MolEditor_exposer.def( "clone", &__copy__);
MolEditor_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::MolEditor >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
MolEditor_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::MolEditor >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
MolEditor_exposer.def( "__str__", &__str__< ::SireMol::MolEditor > );
MolEditor_exposer.def( "__repr__", &__str__< ::SireMol::MolEditor > );
}
}
void register_G1FF_class(){
{ //::SireFF::G1FF
typedef bp::class_< SireFF::G1FF, bp::bases< SireFF::FF, SireMol::MolGroupsBase, SireBase::Property >, boost::noncopyable > G1FF_exposer_t;
G1FF_exposer_t G1FF_exposer = G1FF_exposer_t( "G1FF", bp::no_init );
bp::scope G1FF_scope( G1FF_exposer );
{ //::SireFF::G1FF::accept
typedef void ( ::SireFF::G1FF::*accept_function_type )( ) ;
accept_function_type accept_function_value( &::SireFF::G1FF::accept );
G1FF_exposer.def(
"accept"
, accept_function_value );
}
{ //::SireFF::G1FF::add
typedef void ( ::SireFF::G1FF::*add_function_type )( ::SireMol::MoleculeView const &,::SireBase::PropertyMap const & ) ;
add_function_type add_function_value( &::SireFF::G1FF::add );
G1FF_exposer.def(
"add"
, add_function_value
, ( bp::arg("molview"), bp::arg("map") ) );
}
{ //::SireFF::G1FF::add
typedef void ( ::SireFF::G1FF::*add_function_type )( ::SireMol::ViewsOfMol const &,::SireBase::PropertyMap const & ) ;
add_function_type add_function_value( &::SireFF::G1FF::add );
G1FF_exposer.def(
"add"
, add_function_value
, ( bp::arg("molviews"), bp::arg("map") ) );
}
{ //::SireFF::G1FF::add
typedef void ( ::SireFF::G1FF::*add_function_type )( ::SireMol::Molecules const &,::SireBase::PropertyMap const & ) ;
add_function_type add_function_value( &::SireFF::G1FF::add );
G1FF_exposer.def(
"add"
, add_function_value
, ( bp::arg("molecules"), bp::arg("map") ) );
}
{ //::SireFF::G1FF::add
typedef void ( ::SireFF::G1FF::*add_function_type )( ::SireMol::MoleculeGroup const &,::SireBase::PropertyMap const & ) ;
add_function_type add_function_value( &::SireFF::G1FF::add );
G1FF_exposer.def(
"add"
, add_function_value
, ( bp::arg("molgroup"), bp::arg("map") ) );
}
{ //::SireFF::G1FF::add
typedef void ( ::SireFF::G1FF::*add_function_type )( ::SireMol::MoleculeView const & ) ;
add_function_type add_function_value( &::SireFF::G1FF::add );
G1FF_exposer.def(
"add"
, add_function_value
, ( bp::arg("molview") ) );
}
{ //::SireFF::G1FF::add
typedef void ( ::SireFF::G1FF::*add_function_type )( ::SireMol::ViewsOfMol const & ) ;
add_function_type add_function_value( &::SireFF::G1FF::add );
G1FF_exposer.def(
"add"
, add_function_value
, ( bp::arg("molviews") ) );
}
{ //::SireFF::G1FF::add
typedef void ( ::SireFF::G1FF::*add_function_type )( ::SireMol::Molecules const & ) ;
add_function_type add_function_value( &::SireFF::G1FF::add );
G1FF_exposer.def(
"add"
, add_function_value
, ( bp::arg("molecules") ) );
}
{ //::SireFF::G1FF::add
typedef void ( ::SireFF::G1FF::*add_function_type )( ::SireMol::MoleculeGroup const & ) ;
add_function_type add_function_value( &::SireFF::G1FF::add );
G1FF_exposer.def(
"add"
, add_function_value
, ( bp::arg("molgroup") ) );
}
{ //::SireFF::G1FF::addIfUnique
typedef void ( ::SireFF::G1FF::*addIfUnique_function_type )( ::SireMol::MoleculeView const &,::SireBase::PropertyMap const & ) ;
addIfUnique_function_type addIfUnique_function_value( &::SireFF::G1FF::addIfUnique );
G1FF_exposer.def(
"addIfUnique"
, addIfUnique_function_value
, ( bp::arg("molview"), bp::arg("map") ) );
}
{ //::SireFF::G1FF::addIfUnique
typedef void ( ::SireFF::G1FF::*addIfUnique_function_type )( ::SireMol::ViewsOfMol const &,::SireBase::PropertyMap const & ) ;
addIfUnique_function_type addIfUnique_function_value( &::SireFF::G1FF::addIfUnique );
G1FF_exposer.def(
"addIfUnique"
, addIfUnique_function_value
, ( bp::arg("molviews"), bp::arg("map") ) );
}
{ //::SireFF::G1FF::addIfUnique
typedef void ( ::SireFF::G1FF::*addIfUnique_function_type )( ::SireMol::Molecules const &,::SireBase::PropertyMap const & ) ;
addIfUnique_function_type addIfUnique_function_value( &::SireFF::G1FF::addIfUnique );
G1FF_exposer.def(
"addIfUnique"
, addIfUnique_function_value
, ( bp::arg("molecules"), bp::arg("map") ) );
}
{ //::SireFF::G1FF::addIfUnique
typedef void ( ::SireFF::G1FF::*addIfUnique_function_type )( ::SireMol::MoleculeGroup const &,::SireBase::PropertyMap const & ) ;
addIfUnique_function_type addIfUnique_function_value( &::SireFF::G1FF::addIfUnique );
G1FF_exposer.def(
"addIfUnique"
, addIfUnique_function_value
, ( bp::arg("molgroup"), bp::arg("map") ) );
}
{ //::SireFF::G1FF::addIfUnique
typedef void ( ::SireFF::G1FF::*addIfUnique_function_type )( ::SireMol::MoleculeView const & ) ;
addIfUnique_function_type addIfUnique_function_value( &::SireFF::G1FF::addIfUnique );
G1FF_exposer.def(
"addIfUnique"
, addIfUnique_function_value
, ( bp::arg("molview") ) );
}
{ //::SireFF::G1FF::addIfUnique
typedef void ( ::SireFF::G1FF::*addIfUnique_function_type )( ::SireMol::ViewsOfMol const & ) ;
addIfUnique_function_type addIfUnique_function_value( &::SireFF::G1FF::addIfUnique );
G1FF_exposer.def(
"addIfUnique"
, addIfUnique_function_value
, ( bp::arg("molviews") ) );
}
{ //::SireFF::G1FF::addIfUnique
typedef void ( ::SireFF::G1FF::*addIfUnique_function_type )( ::SireMol::Molecules const & ) ;
addIfUnique_function_type addIfUnique_function_value( &::SireFF::G1FF::addIfUnique );
G1FF_exposer.def(
"addIfUnique"
, addIfUnique_function_value
, ( bp::arg("molecules") ) );
}
{ //::SireFF::G1FF::addIfUnique
typedef void ( ::SireFF::G1FF::*addIfUnique_function_type )( ::SireMol::MoleculeGroup const & ) ;
addIfUnique_function_type addIfUnique_function_value( &::SireFF::G1FF::addIfUnique );
G1FF_exposer.def(
"addIfUnique"
, addIfUnique_function_value
, ( bp::arg("molgroup") ) );
}
{ //::SireFF::G1FF::assertContains
typedef void ( ::SireFF::G1FF::*assertContains_function_type )( ::SireMol::MGNum ) const;
assertContains_function_type assertContains_function_value( &::SireFF::G1FF::assertContains );
G1FF_exposer.def(
"assertContains"
, assertContains_function_value
, ( bp::arg("mgnum") ) );
}
{ //::SireFF::G1FF::at
typedef ::SireMol::MoleculeGroup const & ( ::SireFF::G1FF::*at_function_type )( ::SireMol::MGNum ) const;
at_function_type at_function_value( &::SireFF::G1FF::at );
G1FF_exposer.def(
"at"
, at_function_value
, ( bp::arg("mgnum") )
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireFF::G1FF::needsAccepting
typedef bool ( ::SireFF::G1FF::*needsAccepting_function_type )( ) const;
needsAccepting_function_type needsAccepting_function_value( &::SireFF::G1FF::needsAccepting );
G1FF_exposer.def(
"needsAccepting"
, needsAccepting_function_value );
}
{ //::SireFF::G1FF::remove
typedef bool ( ::SireFF::G1FF::*remove_function_type )( ::SireMol::MoleculeView const & ) ;
remove_function_type remove_function_value( &::SireFF::G1FF::remove );
G1FF_exposer.def(
"remove"
, remove_function_value
, ( bp::arg("molview") ) );
}
{ //::SireFF::G1FF::remove
typedef bool ( ::SireFF::G1FF::*remove_function_type )( ::SireMol::ViewsOfMol const & ) ;
remove_function_type remove_function_value( &::SireFF::G1FF::remove );
G1FF_exposer.def(
"remove"
, remove_function_value
, ( bp::arg("molviews") ) );
}
{ //::SireFF::G1FF::remove
typedef bool ( ::SireFF::G1FF::*remove_function_type )( ::SireMol::Molecules const & ) ;
remove_function_type remove_function_value( &::SireFF::G1FF::remove );
G1FF_exposer.def(
"remove"
, remove_function_value
, ( bp::arg("molecules") ) );
}
{ //::SireFF::G1FF::remove
typedef bool ( ::SireFF::G1FF::*remove_function_type )( ::SireMol::MoleculeGroup const & ) ;
remove_function_type remove_function_value( &::SireFF::G1FF::remove );
G1FF_exposer.def(
"remove"
, remove_function_value
, ( bp::arg("molgroup") ) );
}
{ //::SireFF::G1FF::remove
typedef bool ( ::SireFF::G1FF::*remove_function_type )( ::SireMol::MolNum ) ;
remove_function_type remove_function_value( &::SireFF::G1FF::remove );
G1FF_exposer.def(
"remove"
, remove_function_value
, ( bp::arg("molnum") ) );
}
{ //::SireFF::G1FF::remove
typedef bool ( ::SireFF::G1FF::*remove_function_type )( ::QSet< SireMol::MolNum > const & ) ;
remove_function_type remove_function_value( &::SireFF::G1FF::remove );
G1FF_exposer.def(
"remove"
, remove_function_value
, ( bp::arg("molnums") ) );
}
{ //::SireFF::G1FF::removeAll
typedef bool ( ::SireFF::G1FF::*removeAll_function_type )( ) ;
removeAll_function_type removeAll_function_value( &::SireFF::G1FF::removeAll );
G1FF_exposer.def(
"removeAll"
, removeAll_function_value );
}
{ //::SireFF::G1FF::removeAll
typedef bool ( ::SireFF::G1FF::*removeAll_function_type )( ::SireMol::MoleculeView const & ) ;
removeAll_function_type removeAll_function_value( &::SireFF::G1FF::removeAll );
G1FF_exposer.def(
"removeAll"
, removeAll_function_value
, ( bp::arg("molview") ) );
}
{ //::SireFF::G1FF::removeAll
typedef bool ( ::SireFF::G1FF::*removeAll_function_type )( ::SireMol::ViewsOfMol const & ) ;
removeAll_function_type removeAll_function_value( &::SireFF::G1FF::removeAll );
G1FF_exposer.def(
"removeAll"
, removeAll_function_value
, ( bp::arg("molviews") ) );
}
{ //::SireFF::G1FF::removeAll
typedef bool ( ::SireFF::G1FF::*removeAll_function_type )( ::SireMol::Molecules const & ) ;
removeAll_function_type removeAll_function_value( &::SireFF::G1FF::removeAll );
G1FF_exposer.def(
"removeAll"
, removeAll_function_value
, ( bp::arg("molecules") ) );
}
{ //::SireFF::G1FF::removeAll
typedef bool ( ::SireFF::G1FF::*removeAll_function_type )( ::SireMol::MoleculeGroup const & ) ;
removeAll_function_type removeAll_function_value( &::SireFF::G1FF::removeAll );
G1FF_exposer.def(
"removeAll"
, removeAll_function_value
, ( bp::arg("molgroup") ) );
}
{ //::SireFF::G1FF::setContents
typedef void ( ::SireFF::G1FF::*setContents_function_type )( ::SireMol::MoleculeView const & ) ;
setContents_function_type setContents_function_value( &::SireFF::G1FF::setContents );
G1FF_exposer.def(
"setContents"
, setContents_function_value
, ( bp::arg("molview") ) );
}
{ //::SireFF::G1FF::setContents
typedef void ( ::SireFF::G1FF::*setContents_function_type )( ::SireMol::ViewsOfMol const & ) ;
setContents_function_type setContents_function_value( &::SireFF::G1FF::setContents );
G1FF_exposer.def(
"setContents"
, setContents_function_value
, ( bp::arg("molview") ) );
}
{ //::SireFF::G1FF::setContents
typedef void ( ::SireFF::G1FF::*setContents_function_type )( ::SireMol::Molecules const & ) ;
setContents_function_type setContents_function_value( &::SireFF::G1FF::setContents );
G1FF_exposer.def(
"setContents"
, setContents_function_value
, ( bp::arg("molecules") ) );
}
{ //::SireFF::G1FF::setContents
typedef void ( ::SireFF::G1FF::*setContents_function_type )( ::SireMol::MoleculeGroup const & ) ;
setContents_function_type setContents_function_value( &::SireFF::G1FF::setContents );
G1FF_exposer.def(
"setContents"
, setContents_function_value
, ( bp::arg("molgroup") ) );
}
{ //::SireFF::G1FF::setContents
typedef void ( ::SireFF::G1FF::*setContents_function_type )( ::SireMol::MoleculeView const &,::SireBase::PropertyMap const & ) ;
setContents_function_type setContents_function_value( &::SireFF::G1FF::setContents );
G1FF_exposer.def(
"setContents"
, setContents_function_value
, ( bp::arg("molview"), bp::arg("map") ) );
}
{ //::SireFF::G1FF::setContents
typedef void ( ::SireFF::G1FF::*setContents_function_type )( ::SireMol::ViewsOfMol const &,::SireBase::PropertyMap const & ) ;
setContents_function_type setContents_function_value( &::SireFF::G1FF::setContents );
G1FF_exposer.def(
"setContents"
, setContents_function_value
, ( bp::arg("molviews"), bp::arg("map") ) );
}
{ //::SireFF::G1FF::setContents
typedef void ( ::SireFF::G1FF::*setContents_function_type )( ::SireMol::Molecules const &,::SireBase::PropertyMap const & ) ;
setContents_function_type setContents_function_value( &::SireFF::G1FF::setContents );
G1FF_exposer.def(
"setContents"
, setContents_function_value
, ( bp::arg("molecules"), bp::arg("map") ) );
}
{ //::SireFF::G1FF::setContents
typedef void ( ::SireFF::G1FF::*setContents_function_type )( ::SireMol::MoleculeGroup const &,::SireBase::PropertyMap const & ) ;
setContents_function_type setContents_function_value( &::SireFF::G1FF::setContents );
G1FF_exposer.def(
"setContents"
, setContents_function_value
, ( bp::arg("molgroup"), bp::arg("map") ) );
}
G1FF_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireFF::G1FF >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
G1FF_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireFF::G1FF >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
G1FF_exposer.def( "__str__", &__str__< ::SireFF::G1FF > );
G1FF_exposer.def( "__repr__", &__str__< ::SireFF::G1FF > );
G1FF_exposer.def( "__len__", &__len_count< ::SireFF::G1FF > );
}
}
void register_CLJBoxes_class(){
{ //::SireMM::CLJBoxes
typedef bp::class_< SireMM::CLJBoxes > CLJBoxes_exposer_t;
CLJBoxes_exposer_t CLJBoxes_exposer = CLJBoxes_exposer_t( "CLJBoxes", bp::init< >() );
bp::scope CLJBoxes_scope( CLJBoxes_exposer );
CLJBoxes_exposer.def( bp::init< SireUnits::Dimension::Length >(( bp::arg("box_size") )) );
CLJBoxes_exposer.def( bp::init< SireMM::CLJAtoms const & >(( bp::arg("atoms") )) );
CLJBoxes_exposer.def( bp::init< SireMM::CLJAtoms const &, SireMM::CLJAtoms const & >(( bp::arg("atoms0"), bp::arg("atoms1") )) );
CLJBoxes_exposer.def( bp::init< SireMM::CLJAtoms const &, SireUnits::Dimension::Length >(( bp::arg("atoms"), bp::arg("box_size") )) );
CLJBoxes_exposer.def( bp::init< SireMM::CLJAtoms const &, SireMM::CLJAtoms const &, SireUnits::Dimension::Length >(( bp::arg("atoms0"), bp::arg("atoms1"), bp::arg("box_size") )) );
CLJBoxes_exposer.def( bp::init< SireMM::CLJBoxes const & >(( bp::arg("other") )) );
{ //::SireMM::CLJBoxes::add
typedef ::QVector< SireMM::CLJBoxIndex > ( ::SireMM::CLJBoxes::*add_function_type )( ::SireMM::CLJAtoms const & ) ;
add_function_type add_function_value( &::SireMM::CLJBoxes::add );
CLJBoxes_exposer.def(
"add"
, add_function_value
, ( bp::arg("atoms") ) );
}
{ //::SireMM::CLJBoxes::at
typedef ::SireMM::CLJAtom ( ::SireMM::CLJBoxes::*at_function_type )( ::SireMM::CLJBoxIndex const & ) const;
at_function_type at_function_value( &::SireMM::CLJBoxes::at );
CLJBoxes_exposer.def(
"at"
, at_function_value
, ( bp::arg("idx") ) );
}
{ //::SireMM::CLJBoxes::atoms
typedef ::SireMM::CLJAtoms ( ::SireMM::CLJBoxes::*atoms_function_type )( ) const;
atoms_function_type atoms_function_value( &::SireMM::CLJBoxes::atoms );
CLJBoxes_exposer.def(
"atoms"
, atoms_function_value );
}
{ //::SireMM::CLJBoxes::atoms
typedef ::SireMM::CLJAtoms ( ::SireMM::CLJBoxes::*atoms_function_type )( ::QVector< SireMM::CLJBoxIndex > const & ) const;
atoms_function_type atoms_function_value( &::SireMM::CLJBoxes::atoms );
CLJBoxes_exposer.def(
"atoms"
, atoms_function_value
, ( bp::arg("atoms") ) );
}
{ //::SireMM::CLJBoxes::boxAt
typedef ::SireMM::CLJBox ( ::SireMM::CLJBoxes::*boxAt_function_type )( int ) const;
boxAt_function_type boxAt_function_value( &::SireMM::CLJBoxes::boxAt );
CLJBoxes_exposer.def(
"boxAt"
, boxAt_function_value
, ( bp::arg("i") ) );
}
{ //::SireMM::CLJBoxes::boxAt
typedef ::SireMM::CLJBox ( ::SireMM::CLJBoxes::*boxAt_function_type )( ::SireMM::CLJBoxIndex const & ) const;
boxAt_function_type boxAt_function_value( &::SireMM::CLJBoxes::boxAt );
CLJBoxes_exposer.def(
"boxAt"
, boxAt_function_value
, ( bp::arg("index") ) );
}
{ //::SireMM::CLJBoxes::boxAt
typedef ::SireMM::CLJBox ( ::SireMM::CLJBoxes::*boxAt_function_type )( ::SireMaths::Vector const & ) const;
boxAt_function_type boxAt_function_value( &::SireMM::CLJBoxes::boxAt );
CLJBoxes_exposer.def(
"boxAt"
, boxAt_function_value
, ( bp::arg("coords") ) );
}
{ //::SireMM::CLJBoxes::boxDimensions
typedef ::QVector< SireVol::AABox > ( ::SireMM::CLJBoxes::*boxDimensions_function_type )( ) const;
boxDimensions_function_type boxDimensions_function_value( &::SireMM::CLJBoxes::boxDimensions );
CLJBoxes_exposer.def(
"boxDimensions"
, boxDimensions_function_value );
}
{ //::SireMM::CLJBoxes::boxDimensionsAt
typedef ::SireVol::AABox ( ::SireMM::CLJBoxes::*boxDimensionsAt_function_type )( int ) const;
boxDimensionsAt_function_type boxDimensionsAt_function_value( &::SireMM::CLJBoxes::boxDimensionsAt );
CLJBoxes_exposer.def(
"boxDimensionsAt"
, boxDimensionsAt_function_value
, ( bp::arg("i") ) );
}
{ //::SireMM::CLJBoxes::boxDimensionsAt
typedef ::SireVol::AABox ( ::SireMM::CLJBoxes::*boxDimensionsAt_function_type )( ::SireMM::CLJBoxIndex const & ) const;
boxDimensionsAt_function_type boxDimensionsAt_function_value( &::SireMM::CLJBoxes::boxDimensionsAt );
CLJBoxes_exposer.def(
"boxDimensionsAt"
, boxDimensionsAt_function_value
, ( bp::arg("index") ) );
}
{ //::SireMM::CLJBoxes::boxDimensionsAt
typedef ::SireVol::AABox ( ::SireMM::CLJBoxes::*boxDimensionsAt_function_type )( ::SireMaths::Vector const & ) const;
boxDimensionsAt_function_type boxDimensionsAt_function_value( &::SireMM::CLJBoxes::boxDimensionsAt );
CLJBoxes_exposer.def(
"boxDimensionsAt"
, boxDimensionsAt_function_value
, ( bp::arg("coords") ) );
}
{ //::SireMM::CLJBoxes::boxes
typedef ::QVector< SireMM::CLJBox > ( ::SireMM::CLJBoxes::*boxes_function_type )( ) const;
boxes_function_type boxes_function_value( &::SireMM::CLJBoxes::boxes );
CLJBoxes_exposer.def(
"boxes"
, boxes_function_value );
}
{ //::SireMM::CLJBoxes::get
typedef ::SireMM::CLJAtoms ( ::SireMM::CLJBoxes::*get_function_type )( ::QVector< SireMM::CLJBoxIndex > const & ) const;
get_function_type get_function_value( &::SireMM::CLJBoxes::get );
CLJBoxes_exposer.def(
"get"
, get_function_value
, ( bp::arg("atoms") ) );
}
{ //::SireMM::CLJBoxes::getDistance
typedef float ( ::SireMM::CLJBoxes::*getDistance_function_type )( ::SireMM::CLJBoxIndex const &,::SireMM::CLJBoxIndex const & ) const;
getDistance_function_type getDistance_function_value( &::SireMM::CLJBoxes::getDistance );
CLJBoxes_exposer.def(
"getDistance"
, getDistance_function_value
, ( bp::arg("box0"), bp::arg("box1") ) );
}
{ //::SireMM::CLJBoxes::getDistance
typedef float ( ::SireMM::CLJBoxes::*getDistance_function_type )( ::SireVol::Space const &,::SireMM::CLJBoxIndex const &,::SireMM::CLJBoxIndex const & ) const;
getDistance_function_type getDistance_function_value( &::SireMM::CLJBoxes::getDistance );
CLJBoxes_exposer.def(
"getDistance"
, getDistance_function_value
, ( bp::arg("space"), bp::arg("box0"), bp::arg("box1") ) );
}
{ //::SireMM::CLJBoxes::getDistance
typedef float ( ::SireMM::CLJBoxes::*getDistance_function_type )( ::SireVol::Space const &,::SireMM::CLJBoxIndex const &,::SireMM::CLJBoxIndex const &,::quint32,::quint32,::quint32 ) const;
getDistance_function_type getDistance_function_value( &::SireMM::CLJBoxes::getDistance );
CLJBoxes_exposer.def(
"getDistance"
, getDistance_function_value
, ( bp::arg("space"), bp::arg("box0"), bp::arg("box1"), bp::arg("nx"), bp::arg("ny"), bp::arg("nz") ) );
}
{ //::SireMM::CLJBoxes::getDistances
typedef ::QVector< SireMM::CLJBoxDistance > ( *getDistances_function_type )( ::SireVol::Space const &,::SireMM::CLJBoxes const & );
getDistances_function_type getDistances_function_value( &::SireMM::CLJBoxes::getDistances );
CLJBoxes_exposer.def(
"getDistances"
, getDistances_function_value
, ( bp::arg("space"), bp::arg("boxes") ) );
}
{ //::SireMM::CLJBoxes::getDistances
typedef ::QVector< SireMM::CLJBoxDistance > ( *getDistances_function_type )( ::SireVol::Space const &,::SireMM::CLJBoxes const &,::SireUnits::Dimension::Length );
getDistances_function_type getDistances_function_value( &::SireMM::CLJBoxes::getDistances );
CLJBoxes_exposer.def(
"getDistances"
, getDistances_function_value
, ( bp::arg("space"), bp::arg("boxes"), bp::arg("cutoff") ) );
}
{ //::SireMM::CLJBoxes::getDistances
typedef ::QVector< SireMM::CLJBoxDistance > ( *getDistances_function_type )( ::SireVol::Space const &,::SireMM::CLJBoxes const &,::SireMM::CLJBoxes const & );
getDistances_function_type getDistances_function_value( &::SireMM::CLJBoxes::getDistances );
CLJBoxes_exposer.def(
"getDistances"
, getDistances_function_value
, ( bp::arg("space"), bp::arg("boxes0"), bp::arg("boxes1") ) );
}
{ //::SireMM::CLJBoxes::getDistances
typedef ::QVector< SireMM::CLJBoxDistance > ( *getDistances_function_type )( ::SireVol::Space const &,::SireMM::CLJBoxes const &,::SireMM::CLJBoxes const &,::SireUnits::Dimension::Length );
getDistances_function_type getDistances_function_value( &::SireMM::CLJBoxes::getDistances );
CLJBoxes_exposer.def(
"getDistances"
, getDistances_function_value
, ( bp::arg("space"), bp::arg("boxes0"), bp::arg("boxes1"), bp::arg("cutoff") ) );
}
{ //::SireMM::CLJBoxes::getDistances
typedef ::QVector< SireMM::CLJBoxDistance > ( *getDistances_function_type )( ::SireVol::Space const &,::SireMM::CLJAtoms const &,::SireMM::CLJBoxes const & );
getDistances_function_type getDistances_function_value( &::SireMM::CLJBoxes::getDistances );
CLJBoxes_exposer.def(
"getDistances"
, getDistances_function_value
, ( bp::arg("space"), bp::arg("atoms0"), bp::arg("boxes1") ) );
}
{ //::SireMM::CLJBoxes::getDistances
typedef ::QVector< SireMM::CLJBoxDistance > ( *getDistances_function_type )( ::SireVol::Space const &,::SireMM::CLJAtoms const &,::SireMM::CLJBoxes const &,::SireUnits::Dimension::Length );
getDistances_function_type getDistances_function_value( &::SireMM::CLJBoxes::getDistances );
CLJBoxes_exposer.def(
"getDistances"
, getDistances_function_value
, ( bp::arg("space"), bp::arg("atoms0"), bp::arg("boxes1"), bp::arg("cutoff") ) );
}
{ //::SireMM::CLJBoxes::getitem
typedef ::SireMM::CLJAtom ( ::SireMM::CLJBoxes::*getitem_function_type )( ::SireMM::CLJBoxIndex const & ) const;
getitem_function_type getitem_function_value( &::SireMM::CLJBoxes::getitem );
CLJBoxes_exposer.def(
"getitem"
, getitem_function_value
, ( bp::arg("idx") ) );
}
{ //::SireMM::CLJBoxes::isEmpty
typedef bool ( ::SireMM::CLJBoxes::*isEmpty_function_type )( ) const;
isEmpty_function_type isEmpty_function_value( &::SireMM::CLJBoxes::isEmpty );
CLJBoxes_exposer.def(
"isEmpty"
, isEmpty_function_value );
}
{ //::SireMM::CLJBoxes::length
typedef ::SireUnits::Dimension::Length ( ::SireMM::CLJBoxes::*length_function_type )( ) const;
length_function_type length_function_value( &::SireMM::CLJBoxes::length );
CLJBoxes_exposer.def(
"length"
, length_function_value );
}
{ //::SireMM::CLJBoxes::nAtoms
typedef int ( ::SireMM::CLJBoxes::*nAtoms_function_type )( ) const;
nAtoms_function_type nAtoms_function_value( &::SireMM::CLJBoxes::nAtoms );
CLJBoxes_exposer.def(
"nAtoms"
, nAtoms_function_value );
}
{ //::SireMM::CLJBoxes::nOccupiedBoxes
typedef int ( ::SireMM::CLJBoxes::*nOccupiedBoxes_function_type )( ) const;
nOccupiedBoxes_function_type nOccupiedBoxes_function_value( &::SireMM::CLJBoxes::nOccupiedBoxes );
CLJBoxes_exposer.def(
"nOccupiedBoxes"
, nOccupiedBoxes_function_value );
}
{ //::SireMM::CLJBoxes::occupiedBoxIndicies
typedef ::QVector< SireMM::CLJBoxIndex > ( ::SireMM::CLJBoxes::*occupiedBoxIndicies_function_type )( ) const;
occupiedBoxIndicies_function_type occupiedBoxIndicies_function_value( &::SireMM::CLJBoxes::occupiedBoxIndicies );
CLJBoxes_exposer.def(
"occupiedBoxIndicies"
, occupiedBoxIndicies_function_value );
}
{ //::SireMM::CLJBoxes::occupiedBoxes
typedef ::QVector< SireMM::CLJBoxPtr > const & ( ::SireMM::CLJBoxes::*occupiedBoxes_function_type )( ) const;
occupiedBoxes_function_type occupiedBoxes_function_value( &::SireMM::CLJBoxes::occupiedBoxes );
CLJBoxes_exposer.def(
"occupiedBoxes"
, occupiedBoxes_function_value
, bp::return_value_policy< bp::copy_const_reference >() );
}
CLJBoxes_exposer.def( bp::self != bp::self );
CLJBoxes_exposer.def( bp::self + bp::self );
{ //::SireMM::CLJBoxes::operator=
typedef ::SireMM::CLJBoxes & ( ::SireMM::CLJBoxes::*assign_function_type )( ::SireMM::CLJBoxes const & ) ;
assign_function_type assign_function_value( &::SireMM::CLJBoxes::operator= );
CLJBoxes_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
CLJBoxes_exposer.def( bp::self == bp::self );
{ //::SireMM::CLJBoxes::operator[]
typedef ::SireMM::CLJAtom ( ::SireMM::CLJBoxes::*__getitem___function_type )( ::SireMM::CLJBoxIndex const & ) const;
__getitem___function_type __getitem___function_value( &::SireMM::CLJBoxes::operator[] );
CLJBoxes_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("idx") ) );
}
{ //::SireMM::CLJBoxes::remove
typedef void ( ::SireMM::CLJBoxes::*remove_function_type )( ::QVector< SireMM::CLJBoxIndex > const & ) ;
remove_function_type remove_function_value( &::SireMM::CLJBoxes::remove );
CLJBoxes_exposer.def(
"remove"
, remove_function_value
, ( bp::arg("atoms") ) );
}
{ //::SireMM::CLJBoxes::squeeze
typedef ::SireMM::CLJBoxes ( ::SireMM::CLJBoxes::*squeeze_function_type )( ) const;
squeeze_function_type squeeze_function_value( &::SireMM::CLJBoxes::squeeze );
CLJBoxes_exposer.def(
"squeeze"
, squeeze_function_value );
}
{ //::SireMM::CLJBoxes::take
typedef ::SireMM::CLJAtoms ( ::SireMM::CLJBoxes::*take_function_type )( ::QVector< SireMM::CLJBoxIndex > const & ) ;
take_function_type take_function_value( &::SireMM::CLJBoxes::take );
CLJBoxes_exposer.def(
"take"
, take_function_value
, ( bp::arg("atoms") ) );
}
{ //::SireMM::CLJBoxes::toString
typedef ::QString ( ::SireMM::CLJBoxes::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireMM::CLJBoxes::toString );
CLJBoxes_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireMM::CLJBoxes::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMM::CLJBoxes::typeName );
CLJBoxes_exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireMM::CLJBoxes::what
typedef char const * ( ::SireMM::CLJBoxes::*what_function_type )( ) const;
what_function_type what_function_value( &::SireMM::CLJBoxes::what );
CLJBoxes_exposer.def(
"what"
, what_function_value );
}
CLJBoxes_exposer.staticmethod( "getDistances" );
CLJBoxes_exposer.staticmethod( "typeName" );
CLJBoxes_exposer.def( "__copy__", &__copy__);
CLJBoxes_exposer.def( "__deepcopy__", &__copy__);
CLJBoxes_exposer.def( "clone", &__copy__);
CLJBoxes_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::CLJBoxes >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
CLJBoxes_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::CLJBoxes >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
CLJBoxes_exposer.def( "__str__", &__str__< ::SireMM::CLJBoxes > );
CLJBoxes_exposer.def( "__repr__", &__str__< ::SireMM::CLJBoxes > );
CLJBoxes_exposer.def( "__getitem__", &::SireMM::CLJBoxes::getitem );
}
}
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> > );
}
}
void register_ResStructureEditor_class(){
{ //::SireMol::ResStructureEditor
typedef bp::class_< SireMol::ResStructureEditor > ResStructureEditor_exposer_t;
ResStructureEditor_exposer_t ResStructureEditor_exposer = ResStructureEditor_exposer_t( "ResStructureEditor", "This is the class used to edit a residues structure\n\nAuthor: Christopher Woods\n", bp::init< >("Null constructor") );
bp::scope ResStructureEditor_scope( ResStructureEditor_exposer );
ResStructureEditor_exposer.def( bp::init< SireMol::Residue const & >(( bp::arg("residue") ), "Construct an editor to edit the structure of a copy of the\nresidue residue") );
ResStructureEditor_exposer.def( bp::init< SireMol::StructureEditor const &, SireMol::ResIdx >(( bp::arg("data"), bp::arg("residx") ), "Construct an editor to edit the residue at index residx in the\neditor whose data is in data\nThrow: SireError::invalid_index\n") );
ResStructureEditor_exposer.def( bp::init< SireMol::ResStructureEditor const & >(( bp::arg("other") ), "Copy constructor") );
{ //::SireMol::ResStructureEditor::add
typedef ::SireMol::AtomStructureEditor ( ::SireMol::ResStructureEditor::*add_function_type)( ::SireMol::AtomName const & ) ;
add_function_type add_function_value( &::SireMol::ResStructureEditor::add );
ResStructureEditor_exposer.def(
"add"
, add_function_value
, ( bp::arg("atomname") )
, "Add a new atom called name to this residue - this returns\nan editor that can be used to further edit this atom" );
}
{ //::SireMol::ResStructureEditor::add
typedef ::SireMol::AtomStructureEditor ( ::SireMol::ResStructureEditor::*add_function_type)( ::SireMol::AtomNum ) ;
add_function_type add_function_value( &::SireMol::ResStructureEditor::add );
ResStructureEditor_exposer.def(
"add"
, add_function_value
, ( bp::arg("atomnum") )
, "Add a new atom with the number number to this residue - this\nreturns an editor that can be used to further edit this atom" );
}
{ //::SireMol::ResStructureEditor::atom
typedef ::SireMol::AtomStructureEditor ( ::SireMol::ResStructureEditor::*atom_function_type)( int ) ;
atom_function_type atom_function_value( &::SireMol::ResStructureEditor::atom );
ResStructureEditor_exposer.def(
"atom"
, atom_function_value
, ( bp::arg("i") )
, "Return an editor for the ith atom in this residue\nThrow: SireError::invalid_index\n" );
}
{ //::SireMol::ResStructureEditor::atom
typedef ::SireMol::AtomStructureEditor ( ::SireMol::ResStructureEditor::*atom_function_type)( ::SireMol::AtomID const & ) ;
atom_function_type atom_function_value( &::SireMol::ResStructureEditor::atom );
ResStructureEditor_exposer.def(
"atom"
, atom_function_value
, ( bp::arg("atomid") )
, "Return an editor for the atom with ID == atomid in\nthis residue\nThrow: SireMol::missing_atom\nThrow: SireMol::duplicate_atom\nThrow: SireError::invalid_index\n" );
}
{ //::SireMol::ResStructureEditor::chain
typedef ::SireMol::ChainStructureEditor ( ::SireMol::ResStructureEditor::*chain_function_type)( ) ;
chain_function_type chain_function_value( &::SireMol::ResStructureEditor::chain );
ResStructureEditor_exposer.def(
"chain"
, chain_function_value
, "Return an editor for the chain that contains this residue" );
}
{ //::SireMol::ResStructureEditor::commit
typedef ::SireMol::Residue ( ::SireMol::ResStructureEditor::*commit_function_type)( ) const;
commit_function_type commit_function_value( &::SireMol::ResStructureEditor::commit );
ResStructureEditor_exposer.def(
"commit"
, commit_function_value
, "Commit the changes made by this editor and return the updated residue" );
}
{ //::SireMol::ResStructureEditor::index
typedef ::SireMol::ResIdx ( ::SireMol::ResStructureEditor::*index_function_type)( ) const;
index_function_type index_function_value( &::SireMol::ResStructureEditor::index );
ResStructureEditor_exposer.def(
"index"
, index_function_value
, "Return the index of this residue in the molecule" );
}
{ //::SireMol::ResStructureEditor::molecule
typedef ::SireMol::MolStructureEditor ( ::SireMol::ResStructureEditor::*molecule_function_type)( ) ;
molecule_function_type molecule_function_value( &::SireMol::ResStructureEditor::molecule );
ResStructureEditor_exposer.def(
"molecule"
, molecule_function_value
, "Return an editor for the molecule that contains this residue" );
}
{ //::SireMol::ResStructureEditor::nAtoms
typedef int ( ::SireMol::ResStructureEditor::*nAtoms_function_type)( ) const;
nAtoms_function_type nAtoms_function_value( &::SireMol::ResStructureEditor::nAtoms );
ResStructureEditor_exposer.def(
"nAtoms"
, nAtoms_function_value
, "Return the number of atoms in this residue - this may be zero" );
}
{ //::SireMol::ResStructureEditor::name
typedef ::SireMol::ResName const & ( ::SireMol::ResStructureEditor::*name_function_type)( ) const;
name_function_type name_function_value( &::SireMol::ResStructureEditor::name );
ResStructureEditor_exposer.def(
"name"
, name_function_value
, bp::return_value_policy<bp::clone_const_reference>()
, "Return the name of this residue" );
}
{ //::SireMol::ResStructureEditor::number
typedef ::SireMol::ResNum ( ::SireMol::ResStructureEditor::*number_function_type)( ) const;
number_function_type number_function_value( &::SireMol::ResStructureEditor::number );
ResStructureEditor_exposer.def(
"number"
, number_function_value
, "Return the number of this residue" );
}
{ //::SireMol::ResStructureEditor::operator=
typedef ::SireMol::ResStructureEditor & ( ::SireMol::ResStructureEditor::*assign_function_type)( ::SireMol::Residue const & ) ;
assign_function_type assign_function_value( &::SireMol::ResStructureEditor::operator= );
ResStructureEditor_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("residue") )
, bp::return_self< >()
, "" );
}
{ //::SireMol::ResStructureEditor::operator=
typedef ::SireMol::ResStructureEditor & ( ::SireMol::ResStructureEditor::*assign_function_type)( ::SireMol::ResStructureEditor const & ) ;
assign_function_type assign_function_value( &::SireMol::ResStructureEditor::operator= );
ResStructureEditor_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >()
, "" );
}
{ //::SireMol::ResStructureEditor::reindex
typedef ::SireMol::ResStructureEditor & ( ::SireMol::ResStructureEditor::*reindex_function_type)( ::SireMol::ResIdx ) ;
reindex_function_type reindex_function_value( &::SireMol::ResStructureEditor::reindex );
ResStructureEditor_exposer.def(
"reindex"
, reindex_function_value
, ( bp::arg("index") )
, bp::return_self< >()
, "Change the index of this residue to newidx. If this\nis larger than the number of residues in the molecule\nthen this residue is moved to the end" );
}
{ //::SireMol::ResStructureEditor::remove
typedef ::SireMol::MolStructureEditor ( ::SireMol::ResStructureEditor::*remove_function_type)( ) ;
remove_function_type remove_function_value( &::SireMol::ResStructureEditor::remove );
ResStructureEditor_exposer.def(
"remove"
, remove_function_value
, bp::return_self< >()
, "Completely remove this residue from the molecule - this returns\na MolStructureEditor that can be used to further edit the molecule" );
}
{ //::SireMol::ResStructureEditor::remove
typedef ::SireMol::ResStructureEditor & ( ::SireMol::ResStructureEditor::*remove_function_type)( ::SireMol::AtomID const & ) ;
remove_function_type remove_function_value( &::SireMol::ResStructureEditor::remove );
ResStructureEditor_exposer.def(
"remove"
, remove_function_value
, ( bp::arg("atomid") )
, bp::return_self< >()
, "Remove all atoms with ID atomid from this residue\nThrow: SireMol::missing_atom\nThrow: SireError::invalid_index\n" );
}
{ //::SireMol::ResStructureEditor::remove
typedef ::SireMol::ResStructureEditor & ( ::SireMol::ResStructureEditor::*remove_function_type)( int ) ;
remove_function_type remove_function_value( &::SireMol::ResStructureEditor::remove );
ResStructureEditor_exposer.def(
"remove"
, remove_function_value
, ( bp::arg("i") )
, bp::return_self< >()
, "Remove the ith atom from this residue\nThrow: SireError::invalid_index\n" );
}
{ //::SireMol::ResStructureEditor::rename
typedef ::SireMol::ResStructureEditor & ( ::SireMol::ResStructureEditor::*rename_function_type)( ::SireMol::ResName const & ) ;
rename_function_type rename_function_value( &::SireMol::ResStructureEditor::rename );
ResStructureEditor_exposer.def(
"rename"
, rename_function_value
, ( bp::arg("name") )
, bp::return_self< >()
, "Rename this residue to newname" );
}
{ //::SireMol::ResStructureEditor::renumber
typedef ::SireMol::ResStructureEditor & ( ::SireMol::ResStructureEditor::*renumber_function_type)( ::SireMol::ResNum ) ;
renumber_function_type renumber_function_value( &::SireMol::ResStructureEditor::renumber );
ResStructureEditor_exposer.def(
"renumber"
, renumber_function_value
, ( bp::arg("number") )
, bp::return_self< >()
, "Renumber this residue to newnum" );
}
{ //::SireMol::ResStructureEditor::reparent
typedef ::SireMol::ResStructureEditor & ( ::SireMol::ResStructureEditor::*reparent_function_type)( ::SireMol::ChainID const & ) ;
reparent_function_type reparent_function_value( &::SireMol::ResStructureEditor::reparent );
ResStructureEditor_exposer.def(
"reparent"
, reparent_function_value
, ( bp::arg("chainid") )
, bp::return_self< >()
, "Move this residue into the chain with ID chainid\nThrow: SireMol::missing_chain\nThrow: SireMol::duplicate_chain\nThrow: SireError::invalid_index\n" );
}
{ //::SireMol::ResStructureEditor::select
typedef ::SireMol::AtomStructureEditor ( ::SireMol::ResStructureEditor::*select_function_type)( int ) ;
select_function_type select_function_value( &::SireMol::ResStructureEditor::select );
ResStructureEditor_exposer.def(
"select"
, select_function_value
, ( bp::arg("i") )
, "Return an editor for the ith atom in this residue\nThrow: SireError::invalid_index\n" );
}
{ //::SireMol::ResStructureEditor::select
typedef ::SireMol::AtomStructureEditor ( ::SireMol::ResStructureEditor::*select_function_type)( ::SireMol::AtomID const & ) ;
select_function_type select_function_value( &::SireMol::ResStructureEditor::select );
ResStructureEditor_exposer.def(
"select"
, select_function_value
, ( bp::arg("atomid") )
, "Return an editor for the atom with ID == atomid in\nthis residue\nThrow: SireMol::missing_atom\nThrow: SireMol::duplicate_atom\nThrow: SireError::invalid_index\n" );
}
{ //::SireMol::ResStructureEditor::selectedAll
typedef bool ( ::SireMol::ResStructureEditor::*selectedAll_function_type)( ) const;
selectedAll_function_type selectedAll_function_value( &::SireMol::ResStructureEditor::selectedAll );
ResStructureEditor_exposer.def(
"selectedAll"
, selectedAll_function_value
, "Is this editor editing the entire molecule?" );
}
{ //::SireMol::ResStructureEditor::toString
typedef ::QString ( ::SireMol::ResStructureEditor::*toString_function_type)( ) const;
toString_function_type toString_function_value( &::SireMol::ResStructureEditor::toString );
ResStructureEditor_exposer.def(
"toString"
, toString_function_value
, "Return a string representation of this editor" );
}
{ //::SireMol::ResStructureEditor::transfer
typedef ::SireMol::ResStructureEditor & ( ::SireMol::ResStructureEditor::*transfer_function_type)( ::SireMol::AtomID const &,::SireMol::ResID const & ) ;
transfer_function_type transfer_function_value( &::SireMol::ResStructureEditor::transfer );
ResStructureEditor_exposer.def(
"transfer"
, transfer_function_value
, ( bp::arg("atomid"), bp::arg("resid") )
, bp::return_self< >()
, "Transfer all atoms that match the ID atomid into the residue that\nmatches the ID resid\nThrow: SireMol::missing_atom\nThrow: SireMol::missing_residue\nThrow: SireMol::duplicate_residue\nThrow: SireError::invalid_index\n" );
}
{ //::SireMol::ResStructureEditor::transfer
typedef ::SireMol::ResStructureEditor & ( ::SireMol::ResStructureEditor::*transfer_function_type)( int,::SireMol::ResID const & ) ;
transfer_function_type transfer_function_value( &::SireMol::ResStructureEditor::transfer );
ResStructureEditor_exposer.def(
"transfer"
, transfer_function_value
, ( bp::arg("i"), bp::arg("resid") )
, bp::return_self< >()
, "Transfer the ith atom from this residue into the residue that\nmatches the ID resid\nThrow: SireMol::missing_residue\nThrow: SireMol::duplicate_residue\nThrow: SireError::invalid_index\n" );
}
{ //::SireMol::ResStructureEditor::transferAll
typedef ::SireMol::ResStructureEditor & ( ::SireMol::ResStructureEditor::*transferAll_function_type)( ::SireMol::ResID const & ) ;
transferAll_function_type transferAll_function_value( &::SireMol::ResStructureEditor::transferAll );
ResStructureEditor_exposer.def(
"transferAll"
, transferAll_function_value
, ( bp::arg("resid") )
, bp::return_self< >()
, "Transfer all atoms from this residue into the residue with ID resid\nThrow: SireMol::missing_residue\nThrow: SireMol::duplicate_residue\nThrow: SireError::invalid_index\n" );
}
{ //::SireMol::ResStructureEditor::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMol::ResStructureEditor::typeName );
ResStructureEditor_exposer.def(
"typeName"
, typeName_function_value
, "" );
}
{ //::SireMol::ResStructureEditor::what
typedef char const * ( ::SireMol::ResStructureEditor::*what_function_type)( ) const;
what_function_type what_function_value( &::SireMol::ResStructureEditor::what );
ResStructureEditor_exposer.def(
"what"
, what_function_value
, "" );
}
ResStructureEditor_exposer.staticmethod( "typeName" );
ResStructureEditor_exposer.def( "__copy__", &__copy__);
ResStructureEditor_exposer.def( "__deepcopy__", &__copy__);
ResStructureEditor_exposer.def( "clone", &__copy__);
ResStructureEditor_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::ResStructureEditor >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
ResStructureEditor_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::ResStructureEditor >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
ResStructureEditor_exposer.def( "__str__", &__str__< ::SireMol::ResStructureEditor > );
ResStructureEditor_exposer.def( "__repr__", &__str__< ::SireMol::ResStructureEditor > );
}
}
