void register_Segment_class(){
{ //::SireMol::Segment
typedef bp::class_< SireMol::Segment, bp::bases< SireMol::MoleculeView, SireBase::Property > > Segment_exposer_t;
Segment_exposer_t Segment_exposer = Segment_exposer_t( "Segment", bp::init< >() );
bp::scope Segment_scope( Segment_exposer );
Segment_exposer.def( bp::init< SireMol::MoleculeData const &, SireMol::SegID const & >(( bp::arg("data"), bp::arg("segid") )) );
Segment_exposer.def( bp::init< SireMol::Segment const & >(( bp::arg("other") )) );
{ //::SireMol::Segment::assertContainsMetadata
typedef void ( ::SireMol::Segment::*assertContainsMetadata_function_type )( ::SireBase::PropertyName const & ) const;
assertContainsMetadata_function_type assertContainsMetadata_function_value( &::SireMol::Segment::assertContainsMetadata );
Segment_exposer.def(
"assertContainsMetadata"
, assertContainsMetadata_function_value
, ( bp::arg("metakey") ) );
}
{ //::SireMol::Segment::assertContainsMetadata
typedef void ( ::SireMol::Segment::*assertContainsMetadata_function_type )( ::SireBase::PropertyName const &,::SireBase::PropertyName const & ) const;
assertContainsMetadata_function_type assertContainsMetadata_function_value( &::SireMol::Segment::assertContainsMetadata );
Segment_exposer.def(
"assertContainsMetadata"
, assertContainsMetadata_function_value
, ( bp::arg("key"), bp::arg("metakey") ) );
}
{ //::SireMol::Segment::assertContainsProperty
typedef void ( ::SireMol::Segment::*assertContainsProperty_function_type )( ::SireBase::PropertyName const & ) const;
assertContainsProperty_function_type assertContainsProperty_function_value( &::SireMol::Segment::assertContainsProperty );
Segment_exposer.def(
"assertContainsProperty"
, assertContainsProperty_function_value
, ( bp::arg("key") ) );
}
{ //::SireMol::Segment::atomIdxs
typedef ::QList< SireMol::AtomIdx > const & ( ::SireMol::Segment::*atomIdxs_function_type )( ) const;
atomIdxs_function_type atomIdxs_function_value( &::SireMol::Segment::atomIdxs );
Segment_exposer.def(
"atomIdxs"
, atomIdxs_function_value
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireMol::Segment::contains
typedef bool ( ::SireMol::Segment::*contains_function_type )( ::SireMol::AtomIdx ) const;
contains_function_type contains_function_value( &::SireMol::Segment::contains );
Segment_exposer.def(
"contains"
, contains_function_value
, ( bp::arg("atomidx") ) );
}
{ //::SireMol::Segment::contains
typedef bool ( ::SireMol::Segment::*contains_function_type )( ::SireMol::AtomID const & ) const;
contains_function_type contains_function_value( &::SireMol::Segment::contains );
Segment_exposer.def(
"contains"
, contains_function_value
, ( bp::arg("atomid") ) );
}
{ //::SireMol::Segment::edit
typedef ::SireMol::SegEditor ( ::SireMol::Segment::*edit_function_type )( ) const;
edit_function_type edit_function_value( &::SireMol::Segment::edit );
Segment_exposer.def(
"edit"
, edit_function_value );
}
{ //::SireMol::Segment::evaluate
typedef ::SireMol::Evaluator ( ::SireMol::Segment::*evaluate_function_type )( ) const;
evaluate_function_type evaluate_function_value( &::SireMol::Segment::evaluate );
Segment_exposer.def(
"evaluate"
, evaluate_function_value );
}
{ //::SireMol::Segment::hasMetadata
typedef bool ( ::SireMol::Segment::*hasMetadata_function_type )( ::SireBase::PropertyName const & ) const;
hasMetadata_function_type hasMetadata_function_value( &::SireMol::Segment::hasMetadata );
Segment_exposer.def(
"hasMetadata"
, hasMetadata_function_value
, ( bp::arg("metakey") ) );
}
{ //::SireMol::Segment::hasMetadata
typedef bool ( ::SireMol::Segment::*hasMetadata_function_type )( ::SireBase::PropertyName const &,::SireBase::PropertyName const & ) const;
hasMetadata_function_type hasMetadata_function_value( &::SireMol::Segment::hasMetadata );
Segment_exposer.def(
"hasMetadata"
, hasMetadata_function_value
, ( bp::arg("key"), bp::arg("metakey") ) );
}
{ //::SireMol::Segment::hasProperty
typedef bool ( ::SireMol::Segment::*hasProperty_function_type )( ::SireBase::PropertyName const & ) const;
hasProperty_function_type hasProperty_function_value( &::SireMol::Segment::hasProperty );
Segment_exposer.def(
"hasProperty"
, hasProperty_function_value
, ( bp::arg("key") ) );
}
{ //::SireMol::Segment::index
typedef ::SireMol::SegIdx ( ::SireMol::Segment::*index_function_type )( ) const;
index_function_type index_function_value( &::SireMol::Segment::index );
Segment_exposer.def(
"index"
, index_function_value );
}
{ //::SireMol::Segment::intersects
typedef bool ( ::SireMol::Segment::*intersects_function_type )( ::SireMol::AtomID const & ) const;
intersects_function_type intersects_function_value( &::SireMol::Segment::intersects );
Segment_exposer.def(
"intersects"
, intersects_function_value
, ( bp::arg("atomid") ) );
}
{ //::SireMol::Segment::isEmpty
typedef bool ( ::SireMol::Segment::*isEmpty_function_type )( ) const;
isEmpty_function_type isEmpty_function_value( &::SireMol::Segment::isEmpty );
Segment_exposer.def(
"isEmpty"
, isEmpty_function_value );
}
{ //::SireMol::Segment::metadataKeys
typedef ::QStringList ( ::SireMol::Segment::*metadataKeys_function_type )( ) const;
metadataKeys_function_type metadataKeys_function_value( &::SireMol::Segment::metadataKeys );
Segment_exposer.def(
"metadataKeys"
, metadataKeys_function_value );
}
{ //::SireMol::Segment::metadataKeys
typedef ::QStringList ( ::SireMol::Segment::*metadataKeys_function_type )( ::SireBase::PropertyName const & ) const;
metadataKeys_function_type metadataKeys_function_value( &::SireMol::Segment::metadataKeys );
Segment_exposer.def(
"metadataKeys"
, metadataKeys_function_value
, ( bp::arg("key") ) );
}
{ //::SireMol::Segment::move
typedef ::SireMol::Mover< SireMol::Segment > ( ::SireMol::Segment::*move_function_type )( ) const;
move_function_type move_function_value( &::SireMol::Segment::move );
Segment_exposer.def(
"move"
, move_function_value );
}
{ //::SireMol::Segment::nAtoms
typedef int ( ::SireMol::Segment::*nAtoms_function_type )( ) const;
nAtoms_function_type nAtoms_function_value( &::SireMol::Segment::nAtoms );
Segment_exposer.def(
"nAtoms"
, nAtoms_function_value );
}
{ //::SireMol::Segment::name
typedef ::SireMol::SegName const & ( ::SireMol::Segment::*name_function_type )( ) const;
name_function_type name_function_value( &::SireMol::Segment::name );
Segment_exposer.def(
"name"
, name_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
Segment_exposer.def( bp::self != bp::self );
{ //::SireMol::Segment::operator=
typedef ::SireMol::Segment & ( ::SireMol::Segment::*assign_function_type )( ::SireMol::Segment const & ) ;
assign_function_type assign_function_value( &::SireMol::Segment::operator= );
Segment_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
Segment_exposer.def( bp::self == bp::self );
{ //::SireMol::Segment::propertyKeys
typedef ::QStringList ( ::SireMol::Segment::*propertyKeys_function_type )( ) const;
propertyKeys_function_type propertyKeys_function_value( &::SireMol::Segment::propertyKeys );
Segment_exposer.def(
"propertyKeys"
, propertyKeys_function_value );
}
{ //::SireMol::Segment::selectedAll
typedef bool ( ::SireMol::Segment::*selectedAll_function_type )( ) const;
selectedAll_function_type selectedAll_function_value( &::SireMol::Segment::selectedAll );
Segment_exposer.def(
"selectedAll"
, selectedAll_function_value );
}
{ //::SireMol::Segment::selection
typedef ::SireMol::AtomSelection ( ::SireMol::Segment::*selection_function_type )( ) const;
selection_function_type selection_function_value( &::SireMol::Segment::selection );
Segment_exposer.def(
"selection"
, selection_function_value );
}
{ //::SireMol::Segment::selector
typedef ::SireMol::Selector< SireMol::Segment > ( ::SireMol::Segment::*selector_function_type )( ) const;
selector_function_type selector_function_value( &::SireMol::Segment::selector );
Segment_exposer.def(
"selector"
, selector_function_value );
}
{ //::SireMol::Segment::toString
typedef ::QString ( ::SireMol::Segment::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireMol::Segment::toString );
Segment_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireMol::Segment::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMol::Segment::typeName );
Segment_exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireMol::Segment::update
typedef void ( ::SireMol::Segment::*update_function_type )( ::SireMol::MoleculeData const & ) ;
update_function_type update_function_value( &::SireMol::Segment::update );
Segment_exposer.def(
"update"
, update_function_value
, ( bp::arg("moldata") ) );
}
Segment_exposer.staticmethod( "typeName" );
Segment_exposer.def( "_get_property_SireMol_SegStringProperty", &SireMol::Segment::property< QString >, bp::return_value_policy<bp::copy_const_reference>());
Segment_exposer.def( "_get_metadata_SireMol_SegStringProperty", get_Metadata_SireMol_SegStringProperty_function1, bp::return_value_policy<bp::copy_const_reference>());
Segment_exposer.def( "_get_metadata_SireMol_SegStringProperty", &get_Metadata_SireMol_SegStringProperty_function2, bp::return_value_policy<bp::copy_const_reference>());
Segment_exposer.def( "_get_property_SireMol_SegIntProperty", &SireMol::Segment::property< qint64 >, bp::return_value_policy<bp::copy_const_reference>());
Segment_exposer.def( "_get_metadata_SireMol_SegIntProperty", get_Metadata_SireMol_SegIntProperty_function1, bp::return_value_policy<bp::copy_const_reference>());
Segment_exposer.def( "_get_metadata_SireMol_SegIntProperty", &get_Metadata_SireMol_SegIntProperty_function2, bp::return_value_policy<bp::copy_const_reference>());
Segment_exposer.def( "_get_property_SireMol_SegFloatProperty", &SireMol::Segment::property< double >, bp::return_value_policy<bp::copy_const_reference>());
Segment_exposer.def( "_get_metadata_SireMol_SegFloatProperty", get_Metadata_SireMol_SegFloatProperty_function1, bp::return_value_policy<bp::copy_const_reference>());
Segment_exposer.def( "_get_metadata_SireMol_SegFloatProperty", &get_Metadata_SireMol_SegFloatProperty_function2, bp::return_value_policy<bp::copy_const_reference>());
Segment_exposer.def( "_get_property_SireMol_SegVariantProperty", &SireMol::Segment::property< QVariant >, bp::return_value_policy<bp::copy_const_reference>());
Segment_exposer.def( "_get_metadata_SireMol_SegVariantProperty", get_Metadata_SireMol_SegVariantProperty_function1, bp::return_value_policy<bp::copy_const_reference>());
Segment_exposer.def( "_get_metadata_SireMol_SegVariantProperty", &get_Metadata_SireMol_SegVariantProperty_function2, bp::return_value_policy<bp::copy_const_reference>());
Segment_exposer.def( "__copy__", &__copy__);
Segment_exposer.def( "__deepcopy__", &__copy__);
Segment_exposer.def( "clone", &__copy__);
Segment_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::Segment >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Segment_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::Segment >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Segment_exposer.def( "__str__", &__str__< ::SireMol::Segment > );
Segment_exposer.def( "__repr__", &__str__< ::SireMol::Segment > );
}
}
void register_ForceTable_class(){
{ //::SireFF::ForceTable
typedef bp::class_< SireFF::ForceTable > ForceTable_exposer_t;
ForceTable_exposer_t ForceTable_exposer = ForceTable_exposer_t( "ForceTable", bp::init< >() );
bp::scope ForceTable_scope( ForceTable_exposer );
ForceTable_exposer.def( bp::init< SireMol::MoleculeGroup const & >(( bp::arg("molgroup") )) );
ForceTable_exposer.def( bp::init< SireFF::ForceTable const & >(( bp::arg("other") )) );
{ //::SireFF::ForceTable::add
typedef void ( ::SireFF::ForceTable::*add_function_type )( ::SireFF::ForceTable const & ) ;
add_function_type add_function_value( &::SireFF::ForceTable::add );
ForceTable_exposer.def(
"add"
, add_function_value
, ( bp::arg("other") ) );
}
{ //::SireFF::ForceTable::add
typedef void ( ::SireFF::ForceTable::*add_function_type )( ::SireMaths::Vector const & ) ;
add_function_type add_function_value( &::SireFF::ForceTable::add );
ForceTable_exposer.def(
"add"
, add_function_value
, ( bp::arg("force") ) );
}
{ //::SireFF::ForceTable::assertContainsTableFor
typedef void ( ::SireFF::ForceTable::*assertContainsTableFor_function_type )( ::SireMol::MolNum ) const;
assertContainsTableFor_function_type assertContainsTableFor_function_value( &::SireFF::ForceTable::assertContainsTableFor );
ForceTable_exposer.def(
"assertContainsTableFor"
, assertContainsTableFor_function_value
, ( bp::arg("molnum") ) );
}
{ //::SireFF::ForceTable::constGetTable
typedef ::SireFF::MolForceTable const & ( ::SireFF::ForceTable::*constGetTable_function_type )( ::SireMol::MolNum ) const;
constGetTable_function_type constGetTable_function_value( &::SireFF::ForceTable::constGetTable );
ForceTable_exposer.def(
"constGetTable"
, constGetTable_function_value
, ( bp::arg("molnum") )
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireFF::ForceTable::containsTable
typedef bool ( ::SireFF::ForceTable::*containsTable_function_type )( ::SireMol::MolNum ) const;
containsTable_function_type containsTable_function_value( &::SireFF::ForceTable::containsTable );
ForceTable_exposer.def(
"containsTable"
, containsTable_function_value
, ( bp::arg("molnum") ) );
}
{ //::SireFF::ForceTable::count
typedef int ( ::SireFF::ForceTable::*count_function_type )( ) const;
count_function_type count_function_value( &::SireFF::ForceTable::count );
ForceTable_exposer.def(
"count"
, count_function_value );
}
{ //::SireFF::ForceTable::divide
typedef void ( ::SireFF::ForceTable::*divide_function_type )( double ) ;
divide_function_type divide_function_value( &::SireFF::ForceTable::divide );
ForceTable_exposer.def(
"divide"
, divide_function_value
, ( bp::arg("value") ) );
}
{ //::SireFF::ForceTable::getTable
typedef ::SireFF::MolForceTable const & ( ::SireFF::ForceTable::*getTable_function_type )( ::SireMol::MolNum ) const;
getTable_function_type getTable_function_value( &::SireFF::ForceTable::getTable );
ForceTable_exposer.def(
"getTable"
, getTable_function_value
, ( bp::arg("molnum") )
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireFF::ForceTable::index
typedef ::QHash< SireMol::MolNum, int > const & ( ::SireFF::ForceTable::*index_function_type )( ) const;
index_function_type index_function_value( &::SireFF::ForceTable::index );
ForceTable_exposer.def(
"index"
, index_function_value
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireFF::ForceTable::indexOf
typedef int ( ::SireFF::ForceTable::*indexOf_function_type )( ::SireMol::MolNum ) const;
indexOf_function_type indexOf_function_value( &::SireFF::ForceTable::indexOf );
ForceTable_exposer.def(
"indexOf"
, indexOf_function_value
, ( bp::arg("molnum") ) );
}
{ //::SireFF::ForceTable::initialiseTable
typedef void ( ::SireFF::ForceTable::*initialiseTable_function_type )( ::SireMol::MolNum ) ;
initialiseTable_function_type initialiseTable_function_value( &::SireFF::ForceTable::initialiseTable );
ForceTable_exposer.def(
"initialiseTable"
, initialiseTable_function_value
, ( bp::arg("molnum") ) );
}
{ //::SireFF::ForceTable::initialiseTables
typedef void ( ::SireFF::ForceTable::*initialiseTables_function_type )( ) ;
initialiseTables_function_type initialiseTables_function_value( &::SireFF::ForceTable::initialiseTables );
ForceTable_exposer.def(
"initialiseTables"
, initialiseTables_function_value );
}
{ //::SireFF::ForceTable::molNums
typedef ::QList< SireMol::MolNum > ( ::SireFF::ForceTable::*molNums_function_type )( ) const;
molNums_function_type molNums_function_value( &::SireFF::ForceTable::molNums );
ForceTable_exposer.def(
"molNums"
, molNums_function_value );
}
{ //::SireFF::ForceTable::multiply
typedef void ( ::SireFF::ForceTable::*multiply_function_type )( double ) ;
multiply_function_type multiply_function_value( &::SireFF::ForceTable::multiply );
ForceTable_exposer.def(
"multiply"
, multiply_function_value
, ( bp::arg("value") ) );
}
ForceTable_exposer.def( bp::self != bp::self );
ForceTable_exposer.def( bp::self * bp::other< double >() );
ForceTable_exposer.def( bp::self + bp::self );
ForceTable_exposer.def( bp::self + bp::other< SireMaths::Vector >() );
ForceTable_exposer.def( bp::self - bp::self );
ForceTable_exposer.def( bp::self - bp::other< SireMaths::Vector >() );
ForceTable_exposer.def( -bp::self );
ForceTable_exposer.def( bp::self / bp::other< double >() );
{ //::SireFF::ForceTable::operator=
typedef ::SireFF::ForceTable & ( ::SireFF::ForceTable::*assign_function_type )( ::SireFF::ForceTable const & ) ;
assign_function_type assign_function_value( &::SireFF::ForceTable::operator= );
ForceTable_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
{ //::SireFF::ForceTable::operator=
typedef ::SireFF::ForceTable & ( ::SireFF::ForceTable::*assign_function_type )( ::SireMaths::Vector const & ) ;
assign_function_type assign_function_value( &::SireFF::ForceTable::operator= );
ForceTable_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("force") )
, bp::return_self< >() );
}
ForceTable_exposer.def( bp::self == bp::self );
{ //::SireFF::ForceTable::setAll
typedef void ( ::SireFF::ForceTable::*setAll_function_type )( ::SireMaths::Vector const & ) ;
setAll_function_type setAll_function_value( &::SireFF::ForceTable::setAll );
ForceTable_exposer.def(
"setAll"
, setAll_function_value
, ( bp::arg("force") ) );
}
{ //::SireFF::ForceTable::subtract
typedef void ( ::SireFF::ForceTable::*subtract_function_type )( ::SireFF::ForceTable const & ) ;
subtract_function_type subtract_function_value( &::SireFF::ForceTable::subtract );
ForceTable_exposer.def(
"subtract"
, subtract_function_value
, ( bp::arg("other") ) );
}
{ //::SireFF::ForceTable::subtract
typedef void ( ::SireFF::ForceTable::*subtract_function_type )( ::SireMaths::Vector const & ) ;
subtract_function_type subtract_function_value( &::SireFF::ForceTable::subtract );
ForceTable_exposer.def(
"subtract"
, subtract_function_value
, ( bp::arg("force") ) );
}
{ //::SireFF::ForceTable::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireFF::ForceTable::typeName );
ForceTable_exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireFF::ForceTable::what
typedef char const * ( ::SireFF::ForceTable::*what_function_type )( ) const;
what_function_type what_function_value( &::SireFF::ForceTable::what );
ForceTable_exposer.def(
"what"
, what_function_value );
}
ForceTable_exposer.staticmethod( "typeName" );
ForceTable_exposer.def( "__copy__", &__copy__);
ForceTable_exposer.def( "__deepcopy__", &__copy__);
ForceTable_exposer.def( "clone", &__copy__);
ForceTable_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireFF::ForceTable >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
ForceTable_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireFF::ForceTable >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
ForceTable_exposer.def( "__str__", &pvt_get_name);
ForceTable_exposer.def( "__repr__", &pvt_get_name);
ForceTable_exposer.def( "__len__", &__len_count< ::SireFF::ForceTable > );
}
}
void register_PotentialTable_class(){
{ //::SireFF::PotentialTable
typedef bp::class_< SireFF::PotentialTable > PotentialTable_exposer_t;
PotentialTable_exposer_t PotentialTable_exposer = PotentialTable_exposer_t( "PotentialTable", "A PotentialTable is a workspace within which all of the potentials\nat the points of atoms in molecules, or the points on a grid\nmay be stored. A PotentialTable is used as storing the potentials\nmay require lots of memory, and continually\ncreating a deleting such large amouts of memory would be inefficient.\nAlso, using a PotentialTable allows for potentials to be accumalated directly,\nrather than requiring intermediate storage space for the\nindividual components.\n\nYou create a potential table to hold all of the potentials at all of\nthe atoms of all of the molecules in a specified MoleculeGroup,\nor at all of the points of a passed Grid.\n\nThe potentials are held in an array that holds the potentials for\nthe molecules in the same order as the molecules appear\nin the molecule group, or in an array that holds the potentials\nin the same order as they appear in the grid.\nThe potential table also comes with an index so you can quickly\nlook up the potential for a specific molecule.\n\nAuthor: Christopher Woods\n", bp::init< >("Null constructor") );
bp::scope PotentialTable_scope( PotentialTable_exposer );
PotentialTable_exposer.def( bp::init< SireMol::MoleculeGroup const & >(( bp::arg("molgroup") ), "Construct the table to hold the potentials at the points of all\nof the atoms in the CutGroups that are viewed in the molecules\nin molgroup") );
PotentialTable_exposer.def( bp::init< SireVol::Grid const & >(( bp::arg("grid") ), "Construct the table to hold the potentials at all of the points\nin the passed grid") );
PotentialTable_exposer.def( bp::init< QVector< SireBase::PropPtr< SireVol::Grid > > const & >(( bp::arg("grids") ), "Construct the table to hold the potentials at all of the points\nof all of the passed grids") );
PotentialTable_exposer.def( bp::init< SireMol::MoleculeGroup const &, SireVol::Grid const & >(( bp::arg("molgroup"), bp::arg("grid") ), "Construct the table to hold the potentials at the points of all\nof the atoms in the CutGroups that are viewed in the molecules\nin molgroup, and all of the grid points in the passed grid") );
PotentialTable_exposer.def( bp::init< SireMol::MoleculeGroup const &, QVector< SireBase::PropPtr< SireVol::Grid > > const & >(( bp::arg("molgroup"), bp::arg("grids") ), "Construct the table to hold the potentials at the points of all\nof the atoms in the CutGroups that are viewed in the molecules\nin molgroup, and all of the grid points in the passed grids") );
PotentialTable_exposer.def( bp::init< SireFF::PotentialTable const & >(( bp::arg("other") ), "Copy constructor") );
{ //::SireFF::PotentialTable::add
typedef void ( ::SireFF::PotentialTable::*add_function_type)( ::SireFF::PotentialTable const & ) ;
add_function_type add_function_value( &::SireFF::PotentialTable::add );
PotentialTable_exposer.def(
"add"
, add_function_value
, ( bp::arg("other") )
, "Add the contents of the table other onto this table. This will only\nadd the potentials for the molecules grids that are in both tables" );
}
{ //::SireFF::PotentialTable::add
typedef void ( ::SireFF::PotentialTable::*add_function_type)( ::SireUnits::Dimension::MolarEnergy const & ) ;
add_function_type add_function_value( &::SireFF::PotentialTable::add );
PotentialTable_exposer.def(
"add"
, add_function_value
, ( bp::arg("potential") )
, "Add the potential potential onto all of the atom grid points in this table" );
}
{ //::SireFF::PotentialTable::assertContainsTableFor
typedef void ( ::SireFF::PotentialTable::*assertContainsTableFor_function_type)( ::SireMol::MolNum ) const;
assertContainsTableFor_function_type assertContainsTableFor_function_value( &::SireFF::PotentialTable::assertContainsTableFor );
PotentialTable_exposer.def(
"assertContainsTableFor"
, assertContainsTableFor_function_value
, ( bp::arg("molnum") )
, "Assert that this contains a table for the molecule with number molnum\nThrow: SireError::unavailable_resource\n" );
}
{ //::SireFF::PotentialTable::assertContainsTableFor
typedef void ( ::SireFF::PotentialTable::*assertContainsTableFor_function_type)( ::SireVol::Grid const & ) const;
assertContainsTableFor_function_type assertContainsTableFor_function_value( &::SireFF::PotentialTable::assertContainsTableFor );
PotentialTable_exposer.def(
"assertContainsTableFor"
, assertContainsTableFor_function_value
, ( bp::arg("grid") )
, "Assert that this contains a table for the passed grid\nThrow: SireError::unavailable_resource\n" );
}
{ //::SireFF::PotentialTable::constGetTable
typedef ::SireFF::MolPotentialTable const & ( ::SireFF::PotentialTable::*constGetTable_function_type)( ::SireMol::MolNum ) const;
constGetTable_function_type constGetTable_function_value( &::SireFF::PotentialTable::constGetTable );
PotentialTable_exposer.def(
"constGetTable"
, constGetTable_function_value
, ( bp::arg("molnum") )
, bp::return_value_policy< bp::copy_const_reference >()
, "Return the potential table for the passed grid\nThrow: SireError::unavailable_resource\n" );
}
{ //::SireFF::PotentialTable::constGetTable
typedef ::SireFF::GridPotentialTable const & ( ::SireFF::PotentialTable::*constGetTable_function_type)( ::SireVol::Grid const & ) const;
constGetTable_function_type constGetTable_function_value( &::SireFF::PotentialTable::constGetTable );
PotentialTable_exposer.def(
"constGetTable"
, constGetTable_function_value
, ( bp::arg("grid") )
, bp::return_value_policy< bp::copy_const_reference >()
, "Return the potential table for the passed grid\nThrow: SireError::unavailable_resource\n" );
}
{ //::SireFF::PotentialTable::contains
typedef bool ( ::SireFF::PotentialTable::*contains_function_type)( ::SireMol::MolNum ) const;
contains_function_type contains_function_value( &::SireFF::PotentialTable::contains );
PotentialTable_exposer.def(
"contains"
, contains_function_value
, ( bp::arg("molnum") )
, "Return whether or not this contains a table for the passed grid" );
}
{ //::SireFF::PotentialTable::contains
typedef bool ( ::SireFF::PotentialTable::*contains_function_type)( ::SireVol::Grid const & ) const;
contains_function_type contains_function_value( &::SireFF::PotentialTable::contains );
PotentialTable_exposer.def(
"contains"
, contains_function_value
, ( bp::arg("grid") )
, "Return whether or not this contains a table for the passed grid" );
}
{ //::SireFF::PotentialTable::divide
typedef void ( ::SireFF::PotentialTable::*divide_function_type)( double ) ;
divide_function_type divide_function_value( &::SireFF::PotentialTable::divide );
PotentialTable_exposer.def(
"divide"
, divide_function_value
, ( bp::arg("value") )
, "Divide the potential at all atom and grid points by value" );
}
{ //::SireFF::PotentialTable::getTable
typedef ::SireFF::MolPotentialTable const & ( ::SireFF::PotentialTable::*getTable_function_type)( ::SireMol::MolNum ) const;
getTable_function_type getTable_function_value( &::SireFF::PotentialTable::getTable );
PotentialTable_exposer.def(
"getTable"
, getTable_function_value
, ( bp::arg("molnum") )
, bp::return_value_policy< bp::copy_const_reference >()
, "Return the potential table for the passed grid\nThrow: SireError::unavailable_resource\n" );
}
{ //::SireFF::PotentialTable::getTable
typedef ::SireFF::GridPotentialTable const & ( ::SireFF::PotentialTable::*getTable_function_type)( ::SireVol::Grid const & ) const;
getTable_function_type getTable_function_value( &::SireFF::PotentialTable::getTable );
PotentialTable_exposer.def(
"getTable"
, getTable_function_value
, ( bp::arg("grid") )
, bp::return_value_policy< bp::copy_const_reference >()
, "Return the potential table for the passed grid\nThrow: SireError::unavailable_resource\n" );
}
{ //::SireFF::PotentialTable::index
typedef ::QHash< SireMol::MolNum, int > const & ( ::SireFF::PotentialTable::*index_function_type)( ) const;
index_function_type index_function_value( &::SireFF::PotentialTable::index );
PotentialTable_exposer.def(
"index"
, index_function_value
, bp::return_value_policy< bp::copy_const_reference >()
, "" );
}
{ //::SireFF::PotentialTable::indexOf
typedef int ( ::SireFF::PotentialTable::*indexOf_function_type)( ::SireMol::MolNum ) const;
indexOf_function_type indexOf_function_value( &::SireFF::PotentialTable::indexOf );
PotentialTable_exposer.def(
"indexOf"
, indexOf_function_value
, ( bp::arg("molnum") )
, "Return the index of the molecule with number molnum in this table\nThrow: SireMol::missing_molecule\n" );
}
{ //::SireFF::PotentialTable::initialiseTable
typedef void ( ::SireFF::PotentialTable::*initialiseTable_function_type)( ::SireMol::MolNum ) ;
initialiseTable_function_type initialiseTable_function_value( &::SireFF::PotentialTable::initialiseTable );
PotentialTable_exposer.def(
"initialiseTable"
, initialiseTable_function_value
, ( bp::arg("molnum") )
, "Initialise the table for the molecule with number molnum" );
}
{ //::SireFF::PotentialTable::initialiseTable
typedef void ( ::SireFF::PotentialTable::*initialiseTable_function_type)( ::SireVol::Grid const & ) ;
initialiseTable_function_type initialiseTable_function_value( &::SireFF::PotentialTable::initialiseTable );
PotentialTable_exposer.def(
"initialiseTable"
, initialiseTable_function_value
, ( bp::arg("grid") )
, "Initialise the table for the grid grid" );
}
{ //::SireFF::PotentialTable::initialiseTables
typedef void ( ::SireFF::PotentialTable::*initialiseTables_function_type)( ) ;
initialiseTables_function_type initialiseTables_function_value( &::SireFF::PotentialTable::initialiseTables );
PotentialTable_exposer.def(
"initialiseTables"
, initialiseTables_function_value
, "Initialise all of the tables to have a zero potential" );
}
{ //::SireFF::PotentialTable::isEmpty
typedef bool ( ::SireFF::PotentialTable::*isEmpty_function_type)( ) const;
isEmpty_function_type isEmpty_function_value( &::SireFF::PotentialTable::isEmpty );
PotentialTable_exposer.def(
"isEmpty"
, isEmpty_function_value
, "Return whether or not this table is empty" );
}
{ //::SireFF::PotentialTable::molNums
typedef ::QList< SireMol::MolNum > ( ::SireFF::PotentialTable::*molNums_function_type)( ) const;
molNums_function_type molNums_function_value( &::SireFF::PotentialTable::molNums );
PotentialTable_exposer.def(
"molNums"
, molNums_function_value
, "" );
}
{ //::SireFF::PotentialTable::multiply
typedef void ( ::SireFF::PotentialTable::*multiply_function_type)( double ) ;
multiply_function_type multiply_function_value( &::SireFF::PotentialTable::multiply );
PotentialTable_exposer.def(
"multiply"
, multiply_function_value
, ( bp::arg("value") )
, "Multiply the potential at all atom and grid points by value" );
}
{ //::SireFF::PotentialTable::nGrids
typedef int ( ::SireFF::PotentialTable::*nGrids_function_type)( ) const;
nGrids_function_type nGrids_function_value( &::SireFF::PotentialTable::nGrids );
PotentialTable_exposer.def(
"nGrids"
, nGrids_function_value
, "" );
}
{ //::SireFF::PotentialTable::nMolecules
typedef int ( ::SireFF::PotentialTable::*nMolecules_function_type)( ) const;
nMolecules_function_type nMolecules_function_value( &::SireFF::PotentialTable::nMolecules );
PotentialTable_exposer.def(
"nMolecules"
, nMolecules_function_value
, "" );
}
PotentialTable_exposer.def( bp::self != bp::self );
PotentialTable_exposer.def( bp::self * bp::other< double >() );
PotentialTable_exposer.def( bp::self + bp::self );
PotentialTable_exposer.def( bp::self + bp::other< SireUnits::Dimension::PhysUnit< 1, 2, -2, 0, 0, -1, 0 > >() );
PotentialTable_exposer.def( bp::self - bp::self );
PotentialTable_exposer.def( bp::self - bp::other< SireUnits::Dimension::PhysUnit< 1, 2, -2, 0, 0, -1, 0 > >() );
PotentialTable_exposer.def( -bp::self );
PotentialTable_exposer.def( bp::self / bp::other< double >() );
{ //::SireFF::PotentialTable::operator=
typedef ::SireFF::PotentialTable & ( ::SireFF::PotentialTable::*assign_function_type)( ::SireFF::PotentialTable const & ) ;
assign_function_type assign_function_value( &::SireFF::PotentialTable::operator= );
PotentialTable_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >()
, "" );
}
{ //::SireFF::PotentialTable::operator=
typedef ::SireFF::PotentialTable & ( ::SireFF::PotentialTable::*assign_function_type)( ::SireUnits::Dimension::MolarEnergy const & ) ;
assign_function_type assign_function_value( &::SireFF::PotentialTable::operator= );
PotentialTable_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("potential") )
, bp::return_self< >()
, "" );
}
PotentialTable_exposer.def( bp::self == bp::self );
{ //::SireFF::PotentialTable::setAll
typedef void ( ::SireFF::PotentialTable::*setAll_function_type)( ::SireUnits::Dimension::MolarEnergy const & ) ;
setAll_function_type setAll_function_value( &::SireFF::PotentialTable::setAll );
PotentialTable_exposer.def(
"setAll"
, setAll_function_value
, ( bp::arg("potential") )
, "Set the potential at all atom and grid points equal to potential" );
}
{ //::SireFF::PotentialTable::subtract
typedef void ( ::SireFF::PotentialTable::*subtract_function_type)( ::SireFF::PotentialTable const & ) ;
subtract_function_type subtract_function_value( &::SireFF::PotentialTable::subtract );
PotentialTable_exposer.def(
"subtract"
, subtract_function_value
, ( bp::arg("other") )
, "Subtract the contents of the table other from this table. This will only\nsubtract the potentials for the molecules grids that are in both tables" );
}
{ //::SireFF::PotentialTable::subtract
typedef void ( ::SireFF::PotentialTable::*subtract_function_type)( ::SireUnits::Dimension::MolarEnergy const & ) ;
subtract_function_type subtract_function_value( &::SireFF::PotentialTable::subtract );
PotentialTable_exposer.def(
"subtract"
, subtract_function_value
, ( bp::arg("potential") )
, "Subtract the potential potential from all of the atom grid points in this table" );
}
{ //::SireFF::PotentialTable::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireFF::PotentialTable::typeName );
PotentialTable_exposer.def(
"typeName"
, typeName_function_value
, "" );
}
{ //::SireFF::PotentialTable::what
typedef char const * ( ::SireFF::PotentialTable::*what_function_type)( ) const;
what_function_type what_function_value( &::SireFF::PotentialTable::what );
PotentialTable_exposer.def(
"what"
, what_function_value
, "" );
}
PotentialTable_exposer.staticmethod( "typeName" );
PotentialTable_exposer.def( "__copy__", &__copy__);
PotentialTable_exposer.def( "__deepcopy__", &__copy__);
PotentialTable_exposer.def( "clone", &__copy__);
PotentialTable_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireFF::PotentialTable >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
PotentialTable_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireFF::PotentialTable >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
PotentialTable_exposer.def( "__str__", &pvt_get_name);
PotentialTable_exposer.def( "__repr__", &pvt_get_name);
}
}
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 > );
}
}
