void register_ResID_class(){
{ //::SireMol::ResID
typedef bp::class_< SireMol::ResID, bp::bases< SireID::ID >, boost::noncopyable > ResID_exposer_t;
ResID_exposer_t ResID_exposer = ResID_exposer_t( "ResID", bp::no_init );
bp::scope ResID_scope( ResID_exposer );
{ //::SireMol::ResID::atom
typedef ::SireMol::AtomsIn< SireMol::ResID > ( ::SireMol::ResID::*atom_function_type )( int ) const;
atom_function_type atom_function_value( &::SireMol::ResID::atom );
ResID_exposer.def(
"atom"
, atom_function_value
, ( bp::arg("i") ) );
}
{ //::SireMol::ResID::atoms
typedef ::SireMol::AtomsIn< SireMol::ResID > ( ::SireMol::ResID::*atoms_function_type )( ) const;
atoms_function_type atoms_function_value( &::SireMol::ResID::atoms );
ResID_exposer.def(
"atoms"
, atoms_function_value );
}
{ //::SireMol::ResID::atoms
typedef ::SireMol::AtomsIn< SireMol::ResID > ( ::SireMol::ResID::*atoms_function_type )( int,int ) const;
atoms_function_type atoms_function_value( &::SireMol::ResID::atoms );
ResID_exposer.def(
"atoms"
, atoms_function_value
, ( bp::arg("i"), bp::arg("j") ) );
}
{ //::SireMol::ResID::chains
typedef ::SireMol::ChainsWithRes ( ::SireMol::ResID::*chains_function_type )( ) const;
chains_function_type chains_function_value( &::SireMol::ResID::chains );
ResID_exposer.def(
"chains"
, chains_function_value );
}
{ //::SireMol::ResID::map
typedef ::QList< SireMol::ResIdx > ( ::SireMol::ResID::*map_function_type )( ::SireMol::MolInfo const & ) const;
map_function_type map_function_value( &::SireMol::ResID::map );
ResID_exposer.def(
"map"
, map_function_value
, ( bp::arg("molinfo") ) );
}
{ //::SireMol::ResID::map
typedef ::QList< SireMol::ResIdx > ( ::SireMol::ResID::*map_function_type )( ::SireMol::MoleculeView const &,::SireBase::PropertyMap const & ) const;
map_function_type map_function_value( &::SireMol::ResID::map );
ResID_exposer.def(
"map"
, map_function_value
, ( bp::arg("molview"), bp::arg("map")=SireBase::PropertyMap() ) );
}
ResID_exposer.def( bp::self & bp::self );
ResID_exposer.def( bp::self & bp::other< SireMol::ChainID >() );
ResID_exposer.def( bp::self & bp::other< SireMol::AtomID >() );
ResID_exposer.def( bp::self & bp::other< SireMol::SegID >() );
ResID_exposer.def( bp::self & bp::other< SireMol::CGID >() );
{ //::SireMol::ResID::operator()
typedef ::SireID::Specify< SireMol::ResID > ( ::SireMol::ResID::*__call___function_type )( int ) const;
__call___function_type __call___function_value( &::SireMol::ResID::operator() );
ResID_exposer.def(
"__call__"
, __call___function_value
, ( bp::arg("i") ) );
}
{ //::SireMol::ResID::operator()
typedef ::SireID::Specify< SireMol::ResID > ( ::SireMol::ResID::*__call___function_type )( int,int ) const;
__call___function_type __call___function_value( &::SireMol::ResID::operator() );
ResID_exposer.def(
"__call__"
, __call___function_value
, ( bp::arg("i"), bp::arg("j") ) );
}
ResID_exposer.def( bp::self * bp::self );
ResID_exposer.def( bp::self + bp::self );
ResID_exposer.def( bp::self + bp::other< SireMol::ChainID >() );
ResID_exposer.def( bp::self + bp::other< SireMol::AtomID >() );
ResID_exposer.def( bp::self + bp::other< SireMol::SegID >() );
ResID_exposer.def( bp::self + bp::other< SireMol::CGID >() );
{ //::SireMol::ResID::operator[]
typedef ::SireID::Specify< SireMol::ResID > ( ::SireMol::ResID::*__getitem___function_type )( int ) const;
__getitem___function_type __getitem___function_value( &::SireMol::ResID::operator[] );
ResID_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("i") ) );
}
ResID_exposer.def( bp::self | bp::self );
{ //::SireMol::ResID::selectAllFrom
typedef ::SireMol::Selector< SireMol::Residue > ( ::SireMol::ResID::*selectAllFrom_function_type )( ::SireMol::MoleculeView const &,::SireBase::PropertyMap const & ) const;
selectAllFrom_function_type selectAllFrom_function_value( &::SireMol::ResID::selectAllFrom );
ResID_exposer.def(
"selectAllFrom"
, selectAllFrom_function_value
, ( bp::arg("molview"), bp::arg("map")=SireBase::PropertyMap() ) );
}
{ //::SireMol::ResID::selectAllFrom
typedef ::QHash< SireMol::MolNum, SireMol::Selector< SireMol::Residue > > ( ::SireMol::ResID::*selectAllFrom_function_type )( ::SireMol::Molecules const &,::SireBase::PropertyMap const & ) const;
selectAllFrom_function_type selectAllFrom_function_value( &::SireMol::ResID::selectAllFrom );
ResID_exposer.def(
"selectAllFrom"
, selectAllFrom_function_value
, ( bp::arg("molecules"), bp::arg("map")=SireBase::PropertyMap() ) );
}
{ //::SireMol::ResID::selectAllFrom
typedef ::QHash< SireMol::MolNum, SireMol::Selector< SireMol::Residue > > ( ::SireMol::ResID::*selectAllFrom_function_type )( ::SireMol::MoleculeGroup const &,::SireBase::PropertyMap const & ) const;
selectAllFrom_function_type selectAllFrom_function_value( &::SireMol::ResID::selectAllFrom );
ResID_exposer.def(
"selectAllFrom"
, selectAllFrom_function_value
, ( bp::arg("molgroup"), bp::arg("map")=SireBase::PropertyMap() ) );
}
{ //::SireMol::ResID::selectAllFrom
typedef ::QHash< SireMol::MolNum, SireMol::Selector< SireMol::Residue > > ( ::SireMol::ResID::*selectAllFrom_function_type )( ::SireMol::MolGroupsBase const &,::SireBase::PropertyMap const & ) const;
selectAllFrom_function_type selectAllFrom_function_value( &::SireMol::ResID::selectAllFrom );
ResID_exposer.def(
"selectAllFrom"
, selectAllFrom_function_value
, ( bp::arg("molgroups"), bp::arg("map")=SireBase::PropertyMap() ) );
}
{ //::SireMol::ResID::selectFrom
typedef ::SireMol::Residue ( ::SireMol::ResID::*selectFrom_function_type )( ::SireMol::MoleculeView const &,::SireBase::PropertyMap const & ) const;
selectFrom_function_type selectFrom_function_value( &::SireMol::ResID::selectFrom );
ResID_exposer.def(
"selectFrom"
, selectFrom_function_value
, ( bp::arg("molview"), bp::arg("map")=SireBase::PropertyMap() ) );
}
{ //::SireMol::ResID::selectFrom
typedef ::SireMol::Residue ( ::SireMol::ResID::*selectFrom_function_type )( ::SireMol::Molecules const &,::SireBase::PropertyMap const & ) const;
selectFrom_function_type selectFrom_function_value( &::SireMol::ResID::selectFrom );
ResID_exposer.def(
"selectFrom"
, selectFrom_function_value
, ( bp::arg("molecules"), bp::arg("map")=SireBase::PropertyMap() ) );
}
{ //::SireMol::ResID::selectFrom
typedef ::SireMol::Residue ( ::SireMol::ResID::*selectFrom_function_type )( ::SireMol::MoleculeGroup const &,::SireBase::PropertyMap const & ) const;
selectFrom_function_type selectFrom_function_value( &::SireMol::ResID::selectFrom );
ResID_exposer.def(
"selectFrom"
, selectFrom_function_value
, ( bp::arg("molgroup"), bp::arg("map")=SireBase::PropertyMap() ) );
}
{ //::SireMol::ResID::selectFrom
typedef ::SireMol::Residue ( ::SireMol::ResID::*selectFrom_function_type )( ::SireMol::MolGroupsBase const &,::SireBase::PropertyMap const & ) const;
selectFrom_function_type selectFrom_function_value( &::SireMol::ResID::selectFrom );
ResID_exposer.def(
"selectFrom"
, selectFrom_function_value
, ( bp::arg("molgroups"), bp::arg("map")=SireBase::PropertyMap() ) );
}
{ //::SireMol::ResID::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMol::ResID::typeName );
ResID_exposer.def(
"typeName"
, typeName_function_value );
}
ResID_exposer.staticmethod( "typeName" );
ResID_exposer.def( "__str__", &__str__< ::SireMol::ResID > );
ResID_exposer.def( "__repr__", &__str__< ::SireMol::ResID > );
}
}
void register_ChainID_class(){
{ //::SireMol::ChainID
typedef bp::class_< SireMol::ChainID, bp::bases< SireID::ID >, boost::noncopyable > ChainID_exposer_t;
ChainID_exposer_t ChainID_exposer = ChainID_exposer_t( "ChainID", "This is the base class of all identifiers that are used\nto identify a chain within a molecule\n\nAuthor: Christopher Woods\n", bp::no_init );
bp::scope ChainID_scope( ChainID_exposer );
{ //::SireMol::ChainID::atom
typedef ::SireMol::AtomsIn< SireMol::ChainID > ( ::SireMol::ChainID::*atom_function_type)( int ) const;
atom_function_type atom_function_value( &::SireMol::ChainID::atom );
ChainID_exposer.def(
"atom"
, atom_function_value
, ( bp::arg("i") )
, "Return a specific atom in the matching residues" );
}
{ //::SireMol::ChainID::atoms
typedef ::SireMol::AtomsIn< SireMol::ChainID > ( ::SireMol::ChainID::*atoms_function_type)( ) const;
atoms_function_type atoms_function_value( &::SireMol::ChainID::atoms );
ChainID_exposer.def(
"atoms"
, atoms_function_value
, "Return the atoms in the matching residues" );
}
{ //::SireMol::ChainID::atoms
typedef ::SireMol::AtomsIn< SireMol::ChainID > ( ::SireMol::ChainID::*atoms_function_type)( int,int ) const;
atoms_function_type atoms_function_value( &::SireMol::ChainID::atoms );
ChainID_exposer.def(
"atoms"
, atoms_function_value
, ( bp::arg("i"), bp::arg("j") )
, "Return a range of atoms in the matching residues" );
}
{ //::SireMol::ChainID::map
typedef ::QList< SireMol::ChainIdx > ( ::SireMol::ChainID::*map_function_type)( ::SireMol::MolInfo const & ) const;
map_function_type map_function_value( &::SireMol::ChainID::map );
ChainID_exposer.def(
"map"
, map_function_value
, ( bp::arg("molinfo") )
, "Map this ID back to the indicies of the chains in the molecule,\nusing the passed MoleculeInfo to do the mapping" );
}
{ //::SireMol::ChainID::map
typedef ::QList< SireMol::ChainIdx > ( ::SireMol::ChainID::*map_function_type)( ::SireMol::MoleculeView const &,::SireBase::PropertyMap const & ) const;
map_function_type map_function_value( &::SireMol::ChainID::map );
ChainID_exposer.def(
"map"
, map_function_value
, ( bp::arg("molview"), bp::arg("map")=SireBase::PropertyMap() )
, "Map this ChainID to the chains in the passed molecule view\nThrow: SireMol::missing_chain\nThrow: SireError::invalid_index\n" );
}
ChainID_exposer.def( bp::self & bp::self );
ChainID_exposer.def( bp::self & bp::other< SireMol::ResID >() );
ChainID_exposer.def( bp::self & bp::other< SireMol::AtomID >() );
ChainID_exposer.def( bp::self & bp::other< SireMol::SegID >() );
ChainID_exposer.def( bp::self & bp::other< SireMol::CGID >() );
{ //::SireMol::ChainID::operator()
typedef ::SireID::Specify< SireMol::ChainID > ( ::SireMol::ChainID::*__call___function_type)( int ) const;
__call___function_type __call___function_value( &::SireMol::ChainID::operator() );
ChainID_exposer.def(
"__call__"
, __call___function_value
, ( bp::arg("i") )
, "" );
}
{ //::SireMol::ChainID::operator()
typedef ::SireID::Specify< SireMol::ChainID > ( ::SireMol::ChainID::*__call___function_type)( int,int ) const;
__call___function_type __call___function_value( &::SireMol::ChainID::operator() );
ChainID_exposer.def(
"__call__"
, __call___function_value
, ( bp::arg("i"), bp::arg("j") )
, "" );
}
ChainID_exposer.def( bp::self * bp::self );
ChainID_exposer.def( bp::self + bp::self );
ChainID_exposer.def( bp::self + bp::other< SireMol::ResID >() );
ChainID_exposer.def( bp::self + bp::other< SireMol::AtomID >() );
ChainID_exposer.def( bp::self + bp::other< SireMol::SegID >() );
ChainID_exposer.def( bp::self + bp::other< SireMol::CGID >() );
{ //::SireMol::ChainID::operator[]
typedef ::SireID::Specify< SireMol::ChainID > ( ::SireMol::ChainID::*__getitem___function_type)( int ) const;
__getitem___function_type __getitem___function_value( &::SireMol::ChainID::operator[] );
ChainID_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("i") )
, "" );
}
ChainID_exposer.def( bp::self | bp::self );
{ //::SireMol::ChainID::residue
typedef ::SireMol::ResIn< SireMol::ChainID > ( ::SireMol::ChainID::*residue_function_type)( int ) const;
residue_function_type residue_function_value( &::SireMol::ChainID::residue );
ChainID_exposer.def(
"residue"
, residue_function_value
, ( bp::arg("i") )
, "Return a specific atom in the matching residues" );
}
{ //::SireMol::ChainID::residues
typedef ::SireMol::ResIn< SireMol::ChainID > ( ::SireMol::ChainID::*residues_function_type)( ) const;
residues_function_type residues_function_value( &::SireMol::ChainID::residues );
ChainID_exposer.def(
"residues"
, residues_function_value
, "Return the atoms in the matching residues" );
}
{ //::SireMol::ChainID::residues
typedef ::SireMol::ResIn< SireMol::ChainID > ( ::SireMol::ChainID::*residues_function_type)( int,int ) const;
residues_function_type residues_function_value( &::SireMol::ChainID::residues );
ChainID_exposer.def(
"residues"
, residues_function_value
, ( bp::arg("i"), bp::arg("j") )
, "Return a range of atoms in the matching residues" );
}
{ //::SireMol::ChainID::selectAllFrom
typedef ::SireMol::Selector< SireMol::Chain > ( ::SireMol::ChainID::*selectAllFrom_function_type)( ::SireMol::MoleculeView const &,::SireBase::PropertyMap const & ) const;
selectAllFrom_function_type selectAllFrom_function_value( &::SireMol::ChainID::selectAllFrom );
ChainID_exposer.def(
"selectAllFrom"
, selectAllFrom_function_value
, ( bp::arg("molview"), bp::arg("map")=SireBase::PropertyMap() )
, "Select all the chains from the passed view that match this ID\nThrow: SireMol::missing_chain\nThrow: SireError::invalid_index\nThrow: SireMol::duplicate_chain\n" );
}
{ //::SireMol::ChainID::selectAllFrom
typedef ::QHash< SireMol::MolNum, SireMol::Selector< SireMol::Chain > > ( ::SireMol::ChainID::*selectAllFrom_function_type)( ::SireMol::Molecules const &,::SireBase::PropertyMap const & ) const;
selectAllFrom_function_type selectAllFrom_function_value( &::SireMol::ChainID::selectAllFrom );
ChainID_exposer.def(
"selectAllFrom"
, selectAllFrom_function_value
, ( bp::arg("molecules"), bp::arg("map")=SireBase::PropertyMap() )
, "Return all of the chains from the molecules that match\nthis ID\nThrow: SireMol::missing_chain\n" );
}
{ //::SireMol::ChainID::selectAllFrom
typedef ::QHash< SireMol::MolNum, SireMol::Selector< SireMol::Chain > > ( ::SireMol::ChainID::*selectAllFrom_function_type)( ::SireMol::MoleculeGroup const &,::SireBase::PropertyMap const & ) const;
selectAllFrom_function_type selectAllFrom_function_value( &::SireMol::ChainID::selectAllFrom );
ChainID_exposer.def(
"selectAllFrom"
, selectAllFrom_function_value
, ( bp::arg("molgroup"), bp::arg("map")=SireBase::PropertyMap() )
, "Return the chains from the molecule group molgroup that match\nthis ID\nThrow: SireMol::missing_chain\n" );
}
{ //::SireMol::ChainID::selectAllFrom
typedef ::QHash< SireMol::MolNum, SireMol::Selector< SireMol::Chain > > ( ::SireMol::ChainID::*selectAllFrom_function_type)( ::SireMol::MolGroupsBase const &,::SireBase::PropertyMap const & ) const;
selectAllFrom_function_type selectAllFrom_function_value( &::SireMol::ChainID::selectAllFrom );
ChainID_exposer.def(
"selectAllFrom"
, selectAllFrom_function_value
, ( bp::arg("molgroups"), bp::arg("map")=SireBase::PropertyMap() )
, "Return the set of chains that match this ID in the molecule groups\nset molgroups\nThrow: SireMol::missing_chain\n" );
}
{ //::SireMol::ChainID::selectFrom
typedef ::SireMol::Chain ( ::SireMol::ChainID::*selectFrom_function_type)( ::SireMol::MoleculeView const &,::SireBase::PropertyMap const & ) const;
selectFrom_function_type selectFrom_function_value( &::SireMol::ChainID::selectFrom );
ChainID_exposer.def(
"selectFrom"
, selectFrom_function_value
, ( bp::arg("molview"), bp::arg("map")=SireBase::PropertyMap() )
, "Select the chain from the passed view that matches this ID\nThrow: SireMol::missing_chain\nThrow: SireError::invalid_index\nThrow: SireMol::duplicate_chain\n" );
}
{ //::SireMol::ChainID::selectFrom
typedef ::SireMol::Chain ( ::SireMol::ChainID::*selectFrom_function_type)( ::SireMol::Molecules const &,::SireBase::PropertyMap const & ) const;
selectFrom_function_type selectFrom_function_value( &::SireMol::ChainID::selectFrom );
ChainID_exposer.def(
"selectFrom"
, selectFrom_function_value
, ( bp::arg("molecules"), bp::arg("map")=SireBase::PropertyMap() )
, "Return the chain from the molecules molecules that matches\nthis ID\nThrow: SireMol::missing_chain\nThrow: SireMol::duplicate_chain\n" );
}
{ //::SireMol::ChainID::selectFrom
typedef ::SireMol::Chain ( ::SireMol::ChainID::*selectFrom_function_type)( ::SireMol::MoleculeGroup const &,::SireBase::PropertyMap const & ) const;
selectFrom_function_type selectFrom_function_value( &::SireMol::ChainID::selectFrom );
ChainID_exposer.def(
"selectFrom"
, selectFrom_function_value
, ( bp::arg("molgroup"), bp::arg("map")=SireBase::PropertyMap() )
, "Return the chain from the molecule group molgroup that matches\nthis ID\nThrow: SireMol::missing_chain\nThrow: SireMol::duplicate_chain\n" );
}
{ //::SireMol::ChainID::selectFrom
typedef ::SireMol::Chain ( ::SireMol::ChainID::*selectFrom_function_type)( ::SireMol::MolGroupsBase const &,::SireBase::PropertyMap const & ) const;
selectFrom_function_type selectFrom_function_value( &::SireMol::ChainID::selectFrom );
ChainID_exposer.def(
"selectFrom"
, selectFrom_function_value
, ( bp::arg("molgroups"), bp::arg("map")=SireBase::PropertyMap() )
, "Return the chain from the molecule groups molgroups that matches\nthis ID\nThrow: SireMol::missing_chain\nThrow: SireMol::duplicate_chain\n" );
}
{ //::SireMol::ChainID::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMol::ChainID::typeName );
ChainID_exposer.def(
"typeName"
, typeName_function_value
, "" );
}
ChainID_exposer.staticmethod( "typeName" );
ChainID_exposer.def( "__str__", &__str__< ::SireMol::ChainID > );
ChainID_exposer.def( "__repr__", &__str__< ::SireMol::ChainID > );
ChainID_exposer.def( "__hash__", &::SireMol::ChainID::hash );
}
}
void register_MolWithResID_class(){
{ //::SireMol::MolWithResID
typedef bp::class_< SireMol::MolWithResID, bp::bases< SireMol::MolID, SireID::ID > > MolWithResID_exposer_t;
MolWithResID_exposer_t MolWithResID_exposer = MolWithResID_exposer_t( "MolWithResID", bp::init< >() );
bp::scope MolWithResID_scope( MolWithResID_exposer );
MolWithResID_exposer.def( bp::init< QString const & >(( bp::arg("resname") )) );
MolWithResID_exposer.def( bp::init< int >(( bp::arg("resnum") )) );
MolWithResID_exposer.def( bp::init< SireMol::ResID const & >(( bp::arg("resid") )) );
MolWithResID_exposer.def( bp::init< QString const &, SireID::CaseSensitivity >(( bp::arg("resname"), bp::arg("case_sensitivity") )) );
MolWithResID_exposer.def( bp::init< SireMol::MolWithResID const & >(( bp::arg("other") )) );
{ //::SireMol::MolWithResID::hash
typedef ::uint ( ::SireMol::MolWithResID::*hash_function_type )( ) const;
hash_function_type hash_function_value( &::SireMol::MolWithResID::hash );
MolWithResID_exposer.def(
"hash"
, hash_function_value );
}
{ //::SireMol::MolWithResID::isNull
typedef bool ( ::SireMol::MolWithResID::*isNull_function_type )( ) const;
isNull_function_type isNull_function_value( &::SireMol::MolWithResID::isNull );
MolWithResID_exposer.def(
"isNull"
, isNull_function_value );
}
{ //::SireMol::MolWithResID::map
typedef ::QList< SireMol::MolNum > ( ::SireMol::MolWithResID::*map_function_type )( ::SireMol::Molecules const & ) const;
map_function_type map_function_value( &::SireMol::MolWithResID::map );
MolWithResID_exposer.def(
"map"
, map_function_value
, ( bp::arg("molecules") ) );
}
{ //::SireMol::MolWithResID::map
typedef ::QList< SireMol::MolNum > ( ::SireMol::MolWithResID::*map_function_type )( ::SireMol::MoleculeGroup const & ) const;
map_function_type map_function_value( &::SireMol::MolWithResID::map );
MolWithResID_exposer.def(
"map"
, map_function_value
, ( bp::arg("molgroup") ) );
}
{ //::SireMol::MolWithResID::map
typedef ::QList< SireMol::MolNum > ( ::SireMol::MolWithResID::*map_function_type )( ::SireMol::MolGroupsBase const & ) const;
map_function_type map_function_value( &::SireMol::MolWithResID::map );
MolWithResID_exposer.def(
"map"
, map_function_value
, ( bp::arg("molgroups") ) );
}
MolWithResID_exposer.def( bp::self != bp::self );
{ //::SireMol::MolWithResID::operator=
typedef ::SireMol::MolWithResID & ( ::SireMol::MolWithResID::*assign_function_type )( ::SireMol::MolWithResID const & ) ;
assign_function_type assign_function_value( &::SireMol::MolWithResID::operator= );
MolWithResID_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
MolWithResID_exposer.def( bp::self == bp::other< SireID::ID >() );
MolWithResID_exposer.def( bp::self == bp::self );
{ //::SireMol::MolWithResID::resID
typedef ::SireMol::ResID const & ( ::SireMol::MolWithResID::*resID_function_type )( ) const;
resID_function_type resID_function_value( &::SireMol::MolWithResID::resID );
MolWithResID_exposer.def(
"resID"
, resID_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireMol::MolWithResID::toString
typedef ::QString ( ::SireMol::MolWithResID::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireMol::MolWithResID::toString );
MolWithResID_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireMol::MolWithResID::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMol::MolWithResID::typeName );
MolWithResID_exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireMol::MolWithResID::what
typedef char const * ( ::SireMol::MolWithResID::*what_function_type )( ) const;
what_function_type what_function_value( &::SireMol::MolWithResID::what );
MolWithResID_exposer.def(
"what"
, what_function_value );
}
MolWithResID_exposer.staticmethod( "typeName" );
MolWithResID_exposer.def( "__copy__", &__copy__);
MolWithResID_exposer.def( "__deepcopy__", &__copy__);
MolWithResID_exposer.def( "clone", &__copy__);
MolWithResID_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::MolWithResID >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
MolWithResID_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::MolWithResID >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
MolWithResID_exposer.def( "__str__", &__str__< ::SireMol::MolWithResID > );
MolWithResID_exposer.def( "__repr__", &__str__< ::SireMol::MolWithResID > );
}
}
void register_Specify_SegID__class(){
{ //::SireID::Specify< SireMol::SegID >
typedef bp::class_< SireID::Specify< SireMol::SegID >, bp::bases< SireMol::SegID, SireID::ID > > Specify_SegID__exposer_t;
Specify_SegID__exposer_t Specify_SegID__exposer = Specify_SegID__exposer_t( "Specify_SegID_", bp::init< >() );
bp::scope Specify_SegID__scope( Specify_SegID__exposer );
Specify_SegID__exposer.def( bp::init< SireMol::SegID const &, qint32 >(( bp::arg("id"), bp::arg("i") )) );
Specify_SegID__exposer.def( bp::init< SireMol::SegID const &, qint32, qint32 >(( bp::arg("id"), bp::arg("i"), bp::arg("j") )) );
Specify_SegID__exposer.def( bp::init< SireID::Specify< SireMol::SegID > const & >(( bp::arg("other") )) );
{ //::SireID::Specify< SireMol::SegID >::hash
typedef SireID::Specify< SireMol::SegID > exported_class_t;
typedef ::uint ( ::SireID::Specify< SireMol::SegID >::*hash_function_type )( ) const;
hash_function_type hash_function_value( &::SireID::Specify< SireMol::SegID >::hash );
Specify_SegID__exposer.def(
"hash"
, hash_function_value );
}
{ //::SireID::Specify< SireMol::SegID >::isNull
typedef SireID::Specify< SireMol::SegID > exported_class_t;
typedef bool ( ::SireID::Specify< SireMol::SegID >::*isNull_function_type )( ) const;
isNull_function_type isNull_function_value( &::SireID::Specify< SireMol::SegID >::isNull );
Specify_SegID__exposer.def(
"isNull"
, isNull_function_value );
}
{ //::SireID::Specify< SireMol::SegID >::map
typedef SireID::Specify< SireMol::SegID > exported_class_t;
typedef ::QList< SireMol::SegIdx > ( ::SireID::Specify< SireMol::SegID >::*map_function_type )( ::SireMol::MolInfo const & ) const;
map_function_type map_function_value( &::SireID::Specify< SireMol::SegID >::map );
Specify_SegID__exposer.def(
"map"
, map_function_value
, ( bp::arg("obj") ) );
}
Specify_SegID__exposer.def( bp::self != bp::self );
Specify_SegID__exposer.def( bp::self != bp::other< SireID::ID >() );
{ //::SireID::Specify< SireMol::SegID >::operator()
typedef SireID::Specify< SireMol::SegID > exported_class_t;
typedef ::SireID::Specify< SireMol::SegID > ( ::SireID::Specify< SireMol::SegID >::*__call___function_type )( int ) const;
__call___function_type __call___function_value( &::SireID::Specify< SireMol::SegID >::operator() );
Specify_SegID__exposer.def(
"__call__"
, __call___function_value
, ( bp::arg("i") ) );
}
{ //::SireID::Specify< SireMol::SegID >::operator()
typedef SireID::Specify< SireMol::SegID > exported_class_t;
typedef ::SireID::Specify< SireMol::SegID > ( ::SireID::Specify< SireMol::SegID >::*__call___function_type )( int,int ) const;
__call___function_type __call___function_value( &::SireID::Specify< SireMol::SegID >::operator() );
Specify_SegID__exposer.def(
"__call__"
, __call___function_value
, ( bp::arg("i"), bp::arg("j") ) );
}
{ //::SireID::Specify< SireMol::SegID >::operator=
typedef SireID::Specify< SireMol::SegID > exported_class_t;
typedef ::SireID::Specify< SireMol::SegID > & ( ::SireID::Specify< SireMol::SegID >::*assign_function_type )( ::SireID::Specify< SireMol::SegID > const & ) ;
assign_function_type assign_function_value( &::SireID::Specify< SireMol::SegID >::operator= );
Specify_SegID__exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
Specify_SegID__exposer.def( bp::self == bp::self );
Specify_SegID__exposer.def( bp::self == bp::other< SireID::ID >() );
{ //::SireID::Specify< SireMol::SegID >::operator[]
typedef SireID::Specify< SireMol::SegID > exported_class_t;
typedef ::SireID::Specify< SireMol::SegID > ( ::SireID::Specify< SireMol::SegID >::*__getitem___function_type )( int ) const;
__getitem___function_type __getitem___function_value( &::SireID::Specify< SireMol::SegID >::operator[] );
Specify_SegID__exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("i") ) );
}
{ //::SireID::Specify< SireMol::SegID >::toString
typedef SireID::Specify< SireMol::SegID > exported_class_t;
typedef ::QString ( ::SireID::Specify< SireMol::SegID >::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireID::Specify< SireMol::SegID >::toString );
Specify_SegID__exposer.def(
"toString"
, toString_function_value );
}
{ //::SireID::Specify< SireMol::SegID >::typeName
typedef SireID::Specify< SireMol::SegID > exported_class_t;
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireID::Specify< SireMol::SegID >::typeName );
Specify_SegID__exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireID::Specify< SireMol::SegID >::what
typedef SireID::Specify< SireMol::SegID > exported_class_t;
typedef char const * ( ::SireID::Specify< SireMol::SegID >::*what_function_type )( ) const;
what_function_type what_function_value( &::SireID::Specify< SireMol::SegID >::what );
Specify_SegID__exposer.def(
"what"
, what_function_value );
}
Specify_SegID__exposer.staticmethod( "typeName" );
Specify_SegID__exposer.def( "__copy__", &__copy__);
Specify_SegID__exposer.def( "__deepcopy__", &__copy__);
Specify_SegID__exposer.def( "clone", &__copy__);
Specify_SegID__exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireID::Specify<SireMol::SegID> >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Specify_SegID__exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireID::Specify<SireMol::SegID> >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Specify_SegID__exposer.def( "__str__", &__str__< ::SireID::Specify<SireMol::SegID> > );
Specify_SegID__exposer.def( "__repr__", &__str__< ::SireID::Specify<SireMol::SegID> > );
}
}
void register_MolResNum_class(){
{ //::SireMol::MolResNum
typedef bp::class_< SireMol::MolResNum, bp::bases< SireMol::ResID, SireID::ID > > MolResNum_exposer_t;
MolResNum_exposer_t MolResNum_exposer = MolResNum_exposer_t( "MolResNum", bp::init< >() );
bp::scope MolResNum_scope( MolResNum_exposer );
MolResNum_exposer.def( bp::init< SireMol::MolNum const &, SireMol::ResNum const & >(( bp::arg("molnum"), bp::arg("resnum") )) );
MolResNum_exposer.def( bp::init< SireMol::ResNum const &, SireMol::MolNum const & >(( bp::arg("resnum"), bp::arg("molnum") )) );
MolResNum_exposer.def( bp::init< SireMol::MolResNum const & >(( bp::arg("other") )) );
{ //::SireMol::MolResNum::hash
typedef ::uint ( ::SireMol::MolResNum::*hash_function_type )( ) const;
hash_function_type hash_function_value( &::SireMol::MolResNum::hash );
MolResNum_exposer.def(
"hash"
, hash_function_value );
}
{ //::SireMol::MolResNum::isNull
typedef bool ( ::SireMol::MolResNum::*isNull_function_type )( ) const;
isNull_function_type isNull_function_value( &::SireMol::MolResNum::isNull );
MolResNum_exposer.def(
"isNull"
, isNull_function_value );
}
{ //::SireMol::MolResNum::map
typedef ::QList< SireMol::ResIdx > ( ::SireMol::MolResNum::*map_function_type )( ::SireMol::MolInfo const & ) const;
map_function_type map_function_value( &::SireMol::MolResNum::map );
MolResNum_exposer.def(
"map"
, map_function_value
, ( bp::arg("molinfo") ) );
}
{ //::SireMol::MolResNum::molNum
typedef ::SireMol::MolNum const & ( ::SireMol::MolResNum::*molNum_function_type )( ) const;
molNum_function_type molNum_function_value( &::SireMol::MolResNum::molNum );
MolResNum_exposer.def(
"molNum"
, molNum_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
MolResNum_exposer.def( bp::self != bp::self );
{ //::SireMol::MolResNum::operator=
typedef ::SireMol::MolResNum & ( ::SireMol::MolResNum::*assign_function_type )( ::SireMol::MolResNum const & ) ;
assign_function_type assign_function_value( &::SireMol::MolResNum::operator= );
MolResNum_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
MolResNum_exposer.def( bp::self == bp::other< SireID::ID >() );
MolResNum_exposer.def( bp::self == bp::self );
{ //::SireMol::MolResNum::resNum
typedef ::SireMol::ResNum const & ( ::SireMol::MolResNum::*resNum_function_type )( ) const;
resNum_function_type resNum_function_value( &::SireMol::MolResNum::resNum );
MolResNum_exposer.def(
"resNum"
, resNum_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireMol::MolResNum::selectAllFrom
typedef ::QHash< SireMol::MolNum, SireMol::Selector< SireMol::Residue > > ( ::SireMol::MolResNum::*selectAllFrom_function_type )( ::SireMol::Molecules const &,::SireBase::PropertyMap const & ) const;
selectAllFrom_function_type selectAllFrom_function_value( &::SireMol::MolResNum::selectAllFrom );
MolResNum_exposer.def(
"selectAllFrom"
, selectAllFrom_function_value
, ( bp::arg("molecules"), bp::arg("map")=SireBase::PropertyMap() ) );
}
{ //::SireMol::MolResNum::selectAllFrom
typedef ::QHash< SireMol::MolNum, SireMol::Selector< SireMol::Residue > > ( ::SireMol::MolResNum::*selectAllFrom_function_type )( ::SireMol::MoleculeGroup const &,::SireBase::PropertyMap const & ) const;
selectAllFrom_function_type selectAllFrom_function_value( &::SireMol::MolResNum::selectAllFrom );
MolResNum_exposer.def(
"selectAllFrom"
, selectAllFrom_function_value
, ( bp::arg("molgroup"), bp::arg("map")=SireBase::PropertyMap() ) );
}
{ //::SireMol::MolResNum::selectAllFrom
typedef ::QHash< SireMol::MolNum, SireMol::Selector< SireMol::Residue > > ( ::SireMol::MolResNum::*selectAllFrom_function_type )( ::SireMol::MolGroupsBase const &,::SireBase::PropertyMap const & ) const;
selectAllFrom_function_type selectAllFrom_function_value( &::SireMol::MolResNum::selectAllFrom );
MolResNum_exposer.def(
"selectAllFrom"
, selectAllFrom_function_value
, ( bp::arg("molgroups"), bp::arg("map")=SireBase::PropertyMap() ) );
}
{ //::SireMol::MolResNum::toString
typedef ::QString ( ::SireMol::MolResNum::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireMol::MolResNum::toString );
MolResNum_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireMol::MolResNum::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMol::MolResNum::typeName );
MolResNum_exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireMol::MolResNum::what
typedef char const * ( ::SireMol::MolResNum::*what_function_type )( ) const;
what_function_type what_function_value( &::SireMol::MolResNum::what );
MolResNum_exposer.def(
"what"
, what_function_value );
}
MolResNum_exposer.staticmethod( "typeName" );
MolResNum_exposer.def( "__copy__", &__copy__);
MolResNum_exposer.def( "__deepcopy__", &__copy__);
MolResNum_exposer.def( "clone", &__copy__);
MolResNum_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::MolResNum >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
MolResNum_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::MolResNum >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
MolResNum_exposer.def( "__str__", &__str__< ::SireMol::MolResNum > );
MolResNum_exposer.def( "__repr__", &__str__< ::SireMol::MolResNum > );
}
}
void register_IDOrSet_SegID__class(){
{ //::SireID::IDOrSet< SireMol::SegID >
typedef bp::class_< SireID::IDOrSet< SireMol::SegID >, bp::bases< SireMol::SegID, SireID::ID > > IDOrSet_SegID__exposer_t;
IDOrSet_SegID__exposer_t IDOrSet_SegID__exposer = IDOrSet_SegID__exposer_t( "IDOrSet_SegID_", bp::init< >() );
bp::scope IDOrSet_SegID__scope( IDOrSet_SegID__exposer );
IDOrSet_SegID__exposer.def( bp::init< SireMol::SegID const & >(( bp::arg("id") )) );
IDOrSet_SegID__exposer.def( bp::init< SireMol::SegID const &, SireMol::SegID const & >(( bp::arg("id0"), bp::arg("id1") )) );
IDOrSet_SegID__exposer.def( bp::init< QList< SireMol::SegIdentifier > const & >(( bp::arg("ids") )) );
IDOrSet_SegID__exposer.def( bp::init< SireID::IDOrSet< SireMol::SegID > const & >(( bp::arg("other") )) );
{ //::SireID::IDOrSet< SireMol::SegID >::IDs
typedef SireID::IDOrSet< SireMol::SegID > exported_class_t;
typedef ::QSet< SireMol::SegIdentifier > const & ( ::SireID::IDOrSet< SireMol::SegID >::*IDs_function_type )( ) const;
IDs_function_type IDs_function_value( &::SireID::IDOrSet< SireMol::SegID >::IDs );
IDOrSet_SegID__exposer.def(
"IDs"
, IDs_function_value
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireID::IDOrSet< SireMol::SegID >::hash
typedef SireID::IDOrSet< SireMol::SegID > exported_class_t;
typedef ::uint ( ::SireID::IDOrSet< SireMol::SegID >::*hash_function_type )( ) const;
hash_function_type hash_function_value( &::SireID::IDOrSet< SireMol::SegID >::hash );
IDOrSet_SegID__exposer.def(
"hash"
, hash_function_value );
}
{ //::SireID::IDOrSet< SireMol::SegID >::isNull
typedef SireID::IDOrSet< SireMol::SegID > exported_class_t;
typedef bool ( ::SireID::IDOrSet< SireMol::SegID >::*isNull_function_type )( ) const;
isNull_function_type isNull_function_value( &::SireID::IDOrSet< SireMol::SegID >::isNull );
IDOrSet_SegID__exposer.def(
"isNull"
, isNull_function_value );
}
{ //::SireID::IDOrSet< SireMol::SegID >::map
typedef SireID::IDOrSet< SireMol::SegID > exported_class_t;
typedef ::QList< SireMol::SegIdx > ( ::SireID::IDOrSet< SireMol::SegID >::*map_function_type )( ::SireMol::MolInfo const & ) const;
map_function_type map_function_value( &::SireID::IDOrSet< SireMol::SegID >::map );
IDOrSet_SegID__exposer.def(
"map"
, map_function_value
, ( bp::arg("obj") ) );
}
IDOrSet_SegID__exposer.def( bp::self != bp::other< SireID::ID >() );
IDOrSet_SegID__exposer.def( bp::self != bp::self );
IDOrSet_SegID__exposer.def( bp::self != bp::other< SireMol::SegID >() );
{ //::SireID::IDOrSet< SireMol::SegID >::operator=
typedef SireID::IDOrSet< SireMol::SegID > exported_class_t;
typedef ::SireID::IDOrSet< SireMol::SegID > & ( ::SireID::IDOrSet< SireMol::SegID >::*assign_function_type )( ::SireID::IDOrSet< SireMol::SegID > const & ) ;
assign_function_type assign_function_value( &::SireID::IDOrSet< SireMol::SegID >::operator= );
IDOrSet_SegID__exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
{ //::SireID::IDOrSet< SireMol::SegID >::operator=
typedef SireID::IDOrSet< SireMol::SegID > exported_class_t;
typedef ::SireID::IDOrSet< SireMol::SegID > & ( ::SireID::IDOrSet< SireMol::SegID >::*assign_function_type )( ::SireMol::SegID const & ) ;
assign_function_type assign_function_value( &::SireID::IDOrSet< SireMol::SegID >::operator= );
IDOrSet_SegID__exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
IDOrSet_SegID__exposer.def( bp::self == bp::other< SireID::ID >() );
IDOrSet_SegID__exposer.def( bp::self == bp::self );
IDOrSet_SegID__exposer.def( bp::self == bp::other< SireMol::SegID >() );
{ //::SireID::IDOrSet< SireMol::SegID >::toString
typedef SireID::IDOrSet< SireMol::SegID > exported_class_t;
typedef ::QString ( ::SireID::IDOrSet< SireMol::SegID >::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireID::IDOrSet< SireMol::SegID >::toString );
IDOrSet_SegID__exposer.def(
"toString"
, toString_function_value );
}
{ //::SireID::IDOrSet< SireMol::SegID >::typeName
typedef SireID::IDOrSet< SireMol::SegID > exported_class_t;
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireID::IDOrSet< SireMol::SegID >::typeName );
IDOrSet_SegID__exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireID::IDOrSet< SireMol::SegID >::what
typedef SireID::IDOrSet< SireMol::SegID > exported_class_t;
typedef char const * ( ::SireID::IDOrSet< SireMol::SegID >::*what_function_type )( ) const;
what_function_type what_function_value( &::SireID::IDOrSet< SireMol::SegID >::what );
IDOrSet_SegID__exposer.def(
"what"
, what_function_value );
}
IDOrSet_SegID__exposer.staticmethod( "typeName" );
IDOrSet_SegID__exposer.def( "__copy__", &__copy__);
IDOrSet_SegID__exposer.def( "__deepcopy__", &__copy__);
IDOrSet_SegID__exposer.def( "clone", &__copy__);
IDOrSet_SegID__exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireID::IDOrSet<SireMol::SegID> >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
IDOrSet_SegID__exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireID::IDOrSet<SireMol::SegID> >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
IDOrSet_SegID__exposer.def( "__str__", &__str__< ::SireID::IDOrSet<SireMol::SegID> > );
IDOrSet_SegID__exposer.def( "__repr__", &__str__< ::SireID::IDOrSet<SireMol::SegID> > );
}
}
void register_FFIdx_class(){
{ //::SireFF::FFIdx
typedef bp::class_< SireFF::FFIdx, bp::bases< SireFF::FFID, SireID::ID, SireID::IndexBase > > FFIdx_exposer_t;
FFIdx_exposer_t FFIdx_exposer = FFIdx_exposer_t( "FFIdx", "This is an ID object that is used to index forcefields (e.g. index\nin a list or array).\n\nAuthor: Christopher Woods\n", bp::init< >("") );
bp::scope FFIdx_scope( FFIdx_exposer );
FFIdx_exposer.def( bp::init< qint32 >(( bp::arg("idx") ), "") );
FFIdx_exposer.def( bp::init< SireFF::FFIdx const & >(( bp::arg("other") ), "") );
{ //::SireFF::FFIdx::hash
typedef ::uint ( ::SireFF::FFIdx::*hash_function_type)( ) const;
hash_function_type hash_function_value( &::SireFF::FFIdx::hash );
FFIdx_exposer.def(
"hash"
, hash_function_value
, "" );
}
{ //::SireFF::FFIdx::isNull
typedef bool ( ::SireFF::FFIdx::*isNull_function_type)( ) const;
isNull_function_type isNull_function_value( &::SireFF::FFIdx::isNull );
FFIdx_exposer.def(
"isNull"
, isNull_function_value
, "" );
}
{ //::SireFF::FFIdx::map
typedef ::QList< SireFF::FFIdx > ( ::SireFF::FFIdx::*map_function_type)( ::SireFF::ForceFields const & ) const;
map_function_type map_function_value( &::SireFF::FFIdx::map );
FFIdx_exposer.def(
"map"
, map_function_value
, ( bp::arg("ffields") )
, "Short cut function to map this index to the index of the\nmatching forcefield in the passed ForceFields object\nThrow: SireError::invalid_index\n" );
}
{ //::SireFF::FFIdx::null
typedef ::SireFF::FFIdx ( *null_function_type )( );
null_function_type null_function_value( &::SireFF::FFIdx::null );
FFIdx_exposer.def(
"null"
, null_function_value
, "" );
}
{ //::SireFF::FFIdx::operator=
typedef ::SireFF::FFIdx & ( ::SireFF::FFIdx::*assign_function_type)( ::SireFF::FFIdx const & ) ;
assign_function_type assign_function_value( &::SireFF::FFIdx::operator= );
FFIdx_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >()
, "" );
}
{ //::SireFF::FFIdx::toString
typedef ::QString ( ::SireFF::FFIdx::*toString_function_type)( ) const;
toString_function_type toString_function_value( &::SireFF::FFIdx::toString );
FFIdx_exposer.def(
"toString"
, toString_function_value
, "" );
}
{ //::SireFF::FFIdx::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireFF::FFIdx::typeName );
FFIdx_exposer.def(
"typeName"
, typeName_function_value
, "" );
}
{ //::SireFF::FFIdx::what
typedef char const * ( ::SireFF::FFIdx::*what_function_type)( ) const;
what_function_type what_function_value( &::SireFF::FFIdx::what );
FFIdx_exposer.def(
"what"
, what_function_value
, "" );
}
FFIdx_exposer.staticmethod( "null" );
FFIdx_exposer.staticmethod( "typeName" );
FFIdx_exposer.def( "__copy__", &__copy__);
FFIdx_exposer.def( "__deepcopy__", &__copy__);
FFIdx_exposer.def( "clone", &__copy__);
FFIdx_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireFF::FFIdx >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
FFIdx_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireFF::FFIdx >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
FFIdx_exposer.def( "__str__", &__str__< ::SireFF::FFIdx > );
FFIdx_exposer.def( "__repr__", &__str__< ::SireFF::FFIdx > );
FFIdx_exposer.def( "__hash__", &::SireFF::FFIdx::hash );
}
}
void register_ChainAtomID_class(){
{ //::SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >
typedef bp::class_< SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >, bp::bases< SireMol::GroupAtomIDBase, SireMol::AtomID, SireID::ID > > ChainAtomID_exposer_t;
ChainAtomID_exposer_t ChainAtomID_exposer = ChainAtomID_exposer_t( "ChainAtomID", "", bp::init< >("") );
bp::scope ChainAtomID_scope( ChainAtomID_exposer );
ChainAtomID_exposer.def( bp::init< SireMol::ChainID const &, SireMol::AtomID const & >(( bp::arg("group"), bp::arg("atom") ), "") );
ChainAtomID_exposer.def( bp::init< SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID > const & >(( bp::arg("other") ), "") );
{ //::SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >::hash
typedef SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID > exported_class_t;
typedef ::uint ( ::SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >::*hash_function_type)( ) const;
hash_function_type hash_function_value( &::SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >::hash );
ChainAtomID_exposer.def(
"hash"
, hash_function_value
, "" );
}
{ //::SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >::isNull
typedef SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID > exported_class_t;
typedef bool ( ::SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >::*isNull_function_type)( ) const;
isNull_function_type isNull_function_value( &::SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >::isNull );
ChainAtomID_exposer.def(
"isNull"
, isNull_function_value
, "" );
}
{ //::SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >::map
typedef SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID > exported_class_t;
typedef ::QList< SireMol::AtomIdx > ( ::SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >::*map_function_type)( ::SireMol::MolInfo const & ) const;
map_function_type map_function_value( &::SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >::map );
ChainAtomID_exposer.def(
"map"
, map_function_value
, ( bp::arg("molinfo") )
, "" );
}
ChainAtomID_exposer.def( bp::self != bp::self );
ChainAtomID_exposer.def( bp::self == bp::self );
ChainAtomID_exposer.def( bp::self == bp::other< SireID::ID >() );
{ //::SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >::toString
typedef SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID > exported_class_t;
typedef ::QString ( ::SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >::*toString_function_type)( ) const;
toString_function_type toString_function_value( &::SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >::toString );
ChainAtomID_exposer.def(
"toString"
, toString_function_value
, "" );
}
{ //::SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >::typeName
typedef SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID > exported_class_t;
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >::typeName );
ChainAtomID_exposer.def(
"typeName"
, typeName_function_value
, "" );
}
{ //::SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >::what
typedef SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID > exported_class_t;
typedef char const * ( ::SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >::*what_function_type)( ) const;
what_function_type what_function_value( &::SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >::what );
ChainAtomID_exposer.def(
"what"
, what_function_value
, "" );
}
ChainAtomID_exposer.staticmethod( "typeName" );
ChainAtomID_exposer.def( "__copy__", &__copy__);
ChainAtomID_exposer.def( "__deepcopy__", &__copy__);
ChainAtomID_exposer.def( "clone", &__copy__);
ChainAtomID_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::GroupAtomID<SireMol::ChainID, SireMol::AtomID> >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
ChainAtomID_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::GroupAtomID<SireMol::ChainID, SireMol::AtomID> >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
ChainAtomID_exposer.def( "__str__", &__str__< ::SireMol::GroupAtomID<SireMol::ChainID, SireMol::AtomID> > );
ChainAtomID_exposer.def( "__repr__", &__str__< ::SireMol::GroupAtomID<SireMol::ChainID, SireMol::AtomID> > );
ChainAtomID_exposer.def( "__hash__", &::SireMol::GroupAtomID<SireMol::ChainID, SireMol::AtomID>::hash );
}
}
void register_Within_class(){
{ //::SireMol::Within
typedef bp::class_< SireMol::Within, bp::bases< SireMol::AtomID, SireID::ID > > Within_exposer_t;
Within_exposer_t Within_exposer = Within_exposer_t( "Within", bp::init< >() );
bp::scope Within_scope( Within_exposer );
Within_exposer.def( bp::init< SireUnits::Dimension::Length, SireMaths::Vector const & >(( bp::arg("distance"), bp::arg("point") )) );
Within_exposer.def( bp::init< SireUnits::Dimension::Length, SireMol::AtomID const & >(( bp::arg("distance"), bp::arg("atomid") )) );
Within_exposer.def( bp::init< SireMol::Within const & >(( bp::arg("other") )) );
{ //::SireMol::Within::hash
typedef ::uint ( ::SireMol::Within::*hash_function_type )( ) const;
hash_function_type hash_function_value( &::SireMol::Within::hash );
Within_exposer.def(
"hash"
, hash_function_value );
}
{ //::SireMol::Within::isNull
typedef bool ( ::SireMol::Within::*isNull_function_type )( ) const;
isNull_function_type isNull_function_value( &::SireMol::Within::isNull );
Within_exposer.def(
"isNull"
, isNull_function_value );
}
{ //::SireMol::Within::map
typedef ::QList< SireMol::AtomIdx > ( ::SireMol::Within::*map_function_type )( ::SireMol::MolInfo const & ) const;
map_function_type map_function_value( &::SireMol::Within::map );
Within_exposer.def(
"map"
, map_function_value
, ( bp::arg("molinfo") ) );
}
{ //::SireMol::Within::map
typedef ::QList< SireMol::AtomIdx > ( ::SireMol::Within::*map_function_type )( ::SireMol::MoleculeView const &,::SireBase::PropertyMap const & ) const;
map_function_type map_function_value( &::SireMol::Within::map );
Within_exposer.def(
"map"
, map_function_value
, ( bp::arg("molview"), bp::arg("map") ) );
}
Within_exposer.def( bp::self != bp::self );
{ //::SireMol::Within::operator=
typedef ::SireMol::Within & ( ::SireMol::Within::*assign_function_type )( ::SireMol::Within const & ) ;
assign_function_type assign_function_value( &::SireMol::Within::operator= );
Within_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
Within_exposer.def( bp::self == bp::other< SireID::ID >() );
Within_exposer.def( bp::self == bp::self );
{ //::SireMol::Within::toString
typedef ::QString ( ::SireMol::Within::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireMol::Within::toString );
Within_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireMol::Within::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMol::Within::typeName );
Within_exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireMol::Within::what
typedef char const * ( ::SireMol::Within::*what_function_type )( ) const;
what_function_type what_function_value( &::SireMol::Within::what );
Within_exposer.def(
"what"
, what_function_value );
}
Within_exposer.staticmethod( "typeName" );
Within_exposer.def( "__copy__", &__copy__);
Within_exposer.def( "__deepcopy__", &__copy__);
Within_exposer.def( "clone", &__copy__);
Within_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::Within >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Within_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::Within >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Within_exposer.def( "__str__", &__str__< ::SireMol::Within > );
Within_exposer.def( "__repr__", &__str__< ::SireMol::Within > );
}
}
void register_SpecifyMol_class(){
{ //::SireMol::SpecifyMol
typedef bp::class_< SireMol::SpecifyMol, bp::bases< SireMol::MolID, SireID::ID > > SpecifyMol_exposer_t;
SpecifyMol_exposer_t SpecifyMol_exposer = SpecifyMol_exposer_t( "SpecifyMol", "This class allow for the specification of specific\nmatching molecules\n\nAuthor: Christopher Woods\n", bp::init< >("Constructor") );
bp::scope SpecifyMol_scope( SpecifyMol_exposer );
SpecifyMol_exposer.def( bp::init< SireMol::MolID const & >(( bp::arg("molid") ), "Construct to match all of the molecules that match the\nID molid") );
SpecifyMol_exposer.def( bp::init< SireMol::MolID const &, int >(( bp::arg("molid"), bp::arg("i") ), "Construct to match the ith molecule that matches the ID molid") );
SpecifyMol_exposer.def( bp::init< SireMol::MolID const &, int, int >(( bp::arg("molid"), bp::arg("i"), bp::arg("j") ), "Construct to math the range of molecules from i to j that\nmatch the ID molid") );
SpecifyMol_exposer.def( bp::init< SireMol::SpecifyMol const & >(( bp::arg("other") ), "Copy constructor") );
{ //::SireMol::SpecifyMol::hash
typedef ::uint ( ::SireMol::SpecifyMol::*hash_function_type)( ) const;
hash_function_type hash_function_value( &::SireMol::SpecifyMol::hash );
SpecifyMol_exposer.def(
"hash"
, hash_function_value
, "Hash this ID" );
}
{ //::SireMol::SpecifyMol::isNull
typedef bool ( ::SireMol::SpecifyMol::*isNull_function_type)( ) const;
isNull_function_type isNull_function_value( &::SireMol::SpecifyMol::isNull );
SpecifyMol_exposer.def(
"isNull"
, isNull_function_value
, "Return whether or not this ID is null" );
}
{ //::SireMol::SpecifyMol::map
typedef ::QList< SireMol::MolNum > ( ::SireMol::SpecifyMol::*map_function_type)( ::SireMol::Molecules const & ) const;
map_function_type map_function_value( &::SireMol::SpecifyMol::map );
SpecifyMol_exposer.def(
"map"
, map_function_value
, ( bp::arg("molecules") )
, "Map this ID to the list of molecule numbers that match" );
}
{ //::SireMol::SpecifyMol::map
typedef ::QList< SireMol::MolNum > ( ::SireMol::SpecifyMol::*map_function_type)( ::SireMol::MoleculeGroup const & ) const;
map_function_type map_function_value( &::SireMol::SpecifyMol::map );
SpecifyMol_exposer.def(
"map"
, map_function_value
, ( bp::arg("molgroup") )
, "Map this ID to the list of molecule numbers that match" );
}
{ //::SireMol::SpecifyMol::map
typedef ::QList< SireMol::MolNum > ( ::SireMol::SpecifyMol::*map_function_type)( ::SireMol::MolGroupsBase const & ) const;
map_function_type map_function_value( &::SireMol::SpecifyMol::map );
SpecifyMol_exposer.def(
"map"
, map_function_value
, ( bp::arg("molgroups") )
, "Map this ID to the list of molecule numbers that match" );
}
SpecifyMol_exposer.def( bp::self != bp::self );
SpecifyMol_exposer.def( bp::self != bp::other< SireID::ID >() );
{ //::SireMol::SpecifyMol::operator=
typedef ::SireMol::SpecifyMol & ( ::SireMol::SpecifyMol::*assign_function_type)( ::SireMol::SpecifyMol const & ) ;
assign_function_type assign_function_value( &::SireMol::SpecifyMol::operator= );
SpecifyMol_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >()
, "" );
}
SpecifyMol_exposer.def( bp::self == bp::self );
SpecifyMol_exposer.def( bp::self == bp::other< SireID::ID >() );
{ //::SireMol::SpecifyMol::toString
typedef ::QString ( ::SireMol::SpecifyMol::*toString_function_type)( ) const;
toString_function_type toString_function_value( &::SireMol::SpecifyMol::toString );
SpecifyMol_exposer.def(
"toString"
, toString_function_value
, "Return a string representation of this ID" );
}
{ //::SireMol::SpecifyMol::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMol::SpecifyMol::typeName );
SpecifyMol_exposer.def(
"typeName"
, typeName_function_value
, "" );
}
{ //::SireMol::SpecifyMol::what
typedef char const * ( ::SireMol::SpecifyMol::*what_function_type)( ) const;
what_function_type what_function_value( &::SireMol::SpecifyMol::what );
SpecifyMol_exposer.def(
"what"
, what_function_value
, "" );
}
SpecifyMol_exposer.staticmethod( "typeName" );
SpecifyMol_exposer.def( "__copy__", &__copy__);
SpecifyMol_exposer.def( "__deepcopy__", &__copy__);
SpecifyMol_exposer.def( "clone", &__copy__);
SpecifyMol_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::SpecifyMol >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
SpecifyMol_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::SpecifyMol >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
SpecifyMol_exposer.def( "__str__", &__str__< ::SireMol::SpecifyMol > );
SpecifyMol_exposer.def( "__repr__", &__str__< ::SireMol::SpecifyMol > );
SpecifyMol_exposer.def( "__hash__", &::SireMol::SpecifyMol::hash );
}
}
void register_CGsWithAtoms_class(){
{ //::SireMol::CGsWithAtoms
typedef bp::class_< SireMol::CGsWithAtoms, bp::bases< SireMol::CGID, SireID::ID > > CGsWithAtoms_exposer_t;
CGsWithAtoms_exposer_t CGsWithAtoms_exposer = CGsWithAtoms_exposer_t( "CGsWithAtoms", bp::init< >() );
bp::scope CGsWithAtoms_scope( CGsWithAtoms_exposer );
CGsWithAtoms_exposer.def( bp::init< SireMol::AtomID const & >(( bp::arg("atomid") )) );
CGsWithAtoms_exposer.def( bp::init< SireMol::CGsWithAtoms const & >(( bp::arg("other") )) );
{ //::SireMol::CGsWithAtoms::atomID
typedef ::SireMol::AtomID const & ( ::SireMol::CGsWithAtoms::*atomID_function_type )( ) const;
atomID_function_type atomID_function_value( &::SireMol::CGsWithAtoms::atomID );
CGsWithAtoms_exposer.def(
"atomID"
, atomID_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireMol::CGsWithAtoms::hash
typedef ::uint ( ::SireMol::CGsWithAtoms::*hash_function_type )( ) const;
hash_function_type hash_function_value( &::SireMol::CGsWithAtoms::hash );
CGsWithAtoms_exposer.def(
"hash"
, hash_function_value );
}
{ //::SireMol::CGsWithAtoms::isNull
typedef bool ( ::SireMol::CGsWithAtoms::*isNull_function_type )( ) const;
isNull_function_type isNull_function_value( &::SireMol::CGsWithAtoms::isNull );
CGsWithAtoms_exposer.def(
"isNull"
, isNull_function_value );
}
{ //::SireMol::CGsWithAtoms::map
typedef ::QList< SireMol::CGIdx > ( ::SireMol::CGsWithAtoms::*map_function_type )( ::SireMol::MolInfo const & ) const;
map_function_type map_function_value( &::SireMol::CGsWithAtoms::map );
CGsWithAtoms_exposer.def(
"map"
, map_function_value
, ( bp::arg("molinfo") ) );
}
CGsWithAtoms_exposer.def( bp::self != bp::self );
{ //::SireMol::CGsWithAtoms::operator=
typedef ::SireMol::CGsWithAtoms & ( ::SireMol::CGsWithAtoms::*assign_function_type )( ::SireMol::CGsWithAtoms const & ) ;
assign_function_type assign_function_value( &::SireMol::CGsWithAtoms::operator= );
CGsWithAtoms_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
CGsWithAtoms_exposer.def( bp::self == bp::other< SireID::ID >() );
CGsWithAtoms_exposer.def( bp::self == bp::self );
{ //::SireMol::CGsWithAtoms::toString
typedef ::QString ( ::SireMol::CGsWithAtoms::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireMol::CGsWithAtoms::toString );
CGsWithAtoms_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireMol::CGsWithAtoms::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMol::CGsWithAtoms::typeName );
CGsWithAtoms_exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireMol::CGsWithAtoms::what
typedef char const * ( ::SireMol::CGsWithAtoms::*what_function_type )( ) const;
what_function_type what_function_value( &::SireMol::CGsWithAtoms::what );
CGsWithAtoms_exposer.def(
"what"
, what_function_value );
}
CGsWithAtoms_exposer.staticmethod( "typeName" );
CGsWithAtoms_exposer.def( "__copy__", &__copy__);
CGsWithAtoms_exposer.def( "__deepcopy__", &__copy__);
CGsWithAtoms_exposer.def( "clone", &__copy__);
CGsWithAtoms_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::CGsWithAtoms >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
CGsWithAtoms_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::CGsWithAtoms >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
CGsWithAtoms_exposer.def( "__str__", &__str__< ::SireMol::CGsWithAtoms > );
CGsWithAtoms_exposer.def( "__repr__", &__str__< ::SireMol::CGsWithAtoms > );
}
}
void register_ChainIdx_class(){
{ //::SireMol::ChainIdx
typedef bp::class_< SireMol::ChainIdx, bp::bases< SireMol::ChainID, SireID::ID, SireID::IndexBase > > ChainIdx_exposer_t;
ChainIdx_exposer_t ChainIdx_exposer = ChainIdx_exposer_t( "ChainIdx", bp::init< >() );
bp::scope ChainIdx_scope( ChainIdx_exposer );
ChainIdx_exposer.def( bp::init< qint32 >(( bp::arg("idx") )) );
ChainIdx_exposer.def( bp::init< SireMol::ChainIdx const & >(( bp::arg("other") )) );
{ //::SireMol::ChainIdx::hash
typedef ::uint ( ::SireMol::ChainIdx::*hash_function_type )( ) const;
hash_function_type hash_function_value( &::SireMol::ChainIdx::hash );
ChainIdx_exposer.def(
"hash"
, hash_function_value );
}
{ //::SireMol::ChainIdx::isNull
typedef bool ( ::SireMol::ChainIdx::*isNull_function_type )( ) const;
isNull_function_type isNull_function_value( &::SireMol::ChainIdx::isNull );
ChainIdx_exposer.def(
"isNull"
, isNull_function_value );
}
{ //::SireMol::ChainIdx::map
typedef ::QList< SireMol::ChainIdx > ( ::SireMol::ChainIdx::*map_function_type )( ::SireMol::MolInfo const & ) const;
map_function_type map_function_value( &::SireMol::ChainIdx::map );
ChainIdx_exposer.def(
"map"
, map_function_value
, ( bp::arg("molinfo") ) );
}
{ //::SireMol::ChainIdx::null
typedef ::SireMol::ChainIdx ( *null_function_type )( );
null_function_type null_function_value( &::SireMol::ChainIdx::null );
ChainIdx_exposer.def(
"null"
, null_function_value );
}
{ //::SireMol::ChainIdx::operator=
typedef ::SireMol::ChainIdx & ( ::SireMol::ChainIdx::*assign_function_type )( ::SireMol::ChainIdx const & ) ;
assign_function_type assign_function_value( &::SireMol::ChainIdx::operator= );
ChainIdx_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
{ //::SireMol::ChainIdx::toString
typedef ::QString ( ::SireMol::ChainIdx::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireMol::ChainIdx::toString );
ChainIdx_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireMol::ChainIdx::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMol::ChainIdx::typeName );
ChainIdx_exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireMol::ChainIdx::what
typedef char const * ( ::SireMol::ChainIdx::*what_function_type )( ) const;
what_function_type what_function_value( &::SireMol::ChainIdx::what );
ChainIdx_exposer.def(
"what"
, what_function_value );
}
ChainIdx_exposer.staticmethod( "null" );
ChainIdx_exposer.staticmethod( "typeName" );
ChainIdx_exposer.def( "__copy__", &__copy__);
ChainIdx_exposer.def( "__deepcopy__", &__copy__);
ChainIdx_exposer.def( "clone", &__copy__);
ChainIdx_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::ChainIdx >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
ChainIdx_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::ChainIdx >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
ChainIdx_exposer.def( "__str__", &__str__< ::SireMol::ChainIdx > );
ChainIdx_exposer.def( "__repr__", &__str__< ::SireMol::ChainIdx > );
}
}
void register_MonitorName_class(){
{ //::SireSystem::MonitorName
typedef bp::class_< SireSystem::MonitorName, bp::bases< SireSystem::MonitorID, SireID::ID, SireID::Name > > MonitorName_exposer_t;
MonitorName_exposer_t MonitorName_exposer = MonitorName_exposer_t( "MonitorName", "This class holds the name of a simulation system\n\nAuthor: Christopher Woods\n", bp::init< >("") );
bp::scope MonitorName_scope( MonitorName_exposer );
MonitorName_exposer.def( bp::init< QString const & >(( bp::arg("name") ), "") );
MonitorName_exposer.def( bp::init< SireSystem::MonitorName const & >(( bp::arg("other") ), "") );
{ //::SireSystem::MonitorName::hash
typedef ::uint ( ::SireSystem::MonitorName::*hash_function_type)( ) const;
hash_function_type hash_function_value( &::SireSystem::MonitorName::hash );
MonitorName_exposer.def(
"hash"
, hash_function_value
, "" );
}
{ //::SireSystem::MonitorName::isNull
typedef bool ( ::SireSystem::MonitorName::*isNull_function_type)( ) const;
isNull_function_type isNull_function_value( &::SireSystem::MonitorName::isNull );
MonitorName_exposer.def(
"isNull"
, isNull_function_value
, "" );
}
{ //::SireSystem::MonitorName::map
typedef ::QList< SireSystem::MonitorName > ( ::SireSystem::MonitorName::*map_function_type)( ::SireSystem::SystemMonitors const & ) const;
map_function_type map_function_value( &::SireSystem::MonitorName::map );
MonitorName_exposer.def(
"map"
, map_function_value
, ( bp::arg("monitors") )
, "" );
}
MonitorName_exposer.def( bp::self != bp::self );
{ //::SireSystem::MonitorName::operator=
typedef ::SireSystem::MonitorName & ( ::SireSystem::MonitorName::*assign_function_type)( ::SireSystem::MonitorName const & ) ;
assign_function_type assign_function_value( &::SireSystem::MonitorName::operator= );
MonitorName_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >()
, "" );
}
MonitorName_exposer.def( bp::self == bp::other< SireID::ID >() );
MonitorName_exposer.def( bp::self == bp::self );
{ //::SireSystem::MonitorName::toString
typedef ::QString ( ::SireSystem::MonitorName::*toString_function_type)( ) const;
toString_function_type toString_function_value( &::SireSystem::MonitorName::toString );
MonitorName_exposer.def(
"toString"
, toString_function_value
, "" );
}
{ //::SireSystem::MonitorName::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireSystem::MonitorName::typeName );
MonitorName_exposer.def(
"typeName"
, typeName_function_value
, "" );
}
{ //::SireSystem::MonitorName::what
typedef char const * ( ::SireSystem::MonitorName::*what_function_type)( ) const;
what_function_type what_function_value( &::SireSystem::MonitorName::what );
MonitorName_exposer.def(
"what"
, what_function_value
, "" );
}
MonitorName_exposer.staticmethod( "typeName" );
MonitorName_exposer.def( "__copy__", &__copy__);
MonitorName_exposer.def( "__deepcopy__", &__copy__);
MonitorName_exposer.def( "clone", &__copy__);
MonitorName_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireSystem::MonitorName >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
MonitorName_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireSystem::MonitorName >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
MonitorName_exposer.def( "__str__", &__str__< ::SireSystem::MonitorName > );
MonitorName_exposer.def( "__repr__", &__str__< ::SireSystem::MonitorName > );
MonitorName_exposer.def( "__hash__", &::SireSystem::MonitorName::hash );
}
}
void register_ChainsWithRes_class(){
{ //::SireMol::ChainsWithRes
typedef bp::class_< SireMol::ChainsWithRes, bp::bases< SireMol::ChainID, SireID::ID > > ChainsWithRes_exposer_t;
ChainsWithRes_exposer_t ChainsWithRes_exposer = ChainsWithRes_exposer_t( "ChainsWithRes", "This ID class identifies chains that contain residues that\nmatch the passed ResID\n\nAuthor: Christopher Woods\n", bp::init< >("Null constructor") );
bp::scope ChainsWithRes_scope( ChainsWithRes_exposer );
ChainsWithRes_exposer.def( bp::init< SireMol::ResID const & >(( bp::arg("resid") ), "Construct from the passed residue ID") );
ChainsWithRes_exposer.def( bp::init< SireMol::ChainsWithRes const & >(( bp::arg("other") ), "Copy constructor") );
{ //::SireMol::ChainsWithRes::hash
typedef ::uint ( ::SireMol::ChainsWithRes::*hash_function_type)( ) const;
hash_function_type hash_function_value( &::SireMol::ChainsWithRes::hash );
ChainsWithRes_exposer.def(
"hash"
, hash_function_value
, "Return a hash of this identifier" );
}
{ //::SireMol::ChainsWithRes::isNull
typedef bool ( ::SireMol::ChainsWithRes::*isNull_function_type)( ) const;
isNull_function_type isNull_function_value( &::SireMol::ChainsWithRes::isNull );
ChainsWithRes_exposer.def(
"isNull"
, isNull_function_value
, "Is this selection null?" );
}
{ //::SireMol::ChainsWithRes::map
typedef ::QList< SireMol::ChainIdx > ( ::SireMol::ChainsWithRes::*map_function_type)( ::SireMol::MolInfo const & ) const;
map_function_type map_function_value( &::SireMol::ChainsWithRes::map );
ChainsWithRes_exposer.def(
"map"
, map_function_value
, ( bp::arg("molinfo") )
, "Map this ID to the list of indicies of chains that match this ID\nThrow: SireMol::missing_chain\nThrow: SireError::invalid_index\n" );
}
ChainsWithRes_exposer.def( bp::self != bp::self );
{ //::SireMol::ChainsWithRes::operator=
typedef ::SireMol::ChainsWithRes & ( ::SireMol::ChainsWithRes::*assign_function_type)( ::SireMol::ChainsWithRes const & ) ;
assign_function_type assign_function_value( &::SireMol::ChainsWithRes::operator= );
ChainsWithRes_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >()
, "" );
}
ChainsWithRes_exposer.def( bp::self == bp::other< SireID::ID >() );
ChainsWithRes_exposer.def( bp::self == bp::self );
{ //::SireMol::ChainsWithRes::resID
typedef ::SireMol::ResID const & ( ::SireMol::ChainsWithRes::*resID_function_type)( ) const;
resID_function_type resID_function_value( &::SireMol::ChainsWithRes::resID );
ChainsWithRes_exposer.def(
"resID"
, resID_function_value
, bp::return_value_policy<bp::clone_const_reference>()
, "Return the residue ID" );
}
{ //::SireMol::ChainsWithRes::toString
typedef ::QString ( ::SireMol::ChainsWithRes::*toString_function_type)( ) const;
toString_function_type toString_function_value( &::SireMol::ChainsWithRes::toString );
ChainsWithRes_exposer.def(
"toString"
, toString_function_value
, "Return a string representatio of this ID" );
}
{ //::SireMol::ChainsWithRes::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMol::ChainsWithRes::typeName );
ChainsWithRes_exposer.def(
"typeName"
, typeName_function_value
, "" );
}
{ //::SireMol::ChainsWithRes::what
typedef char const * ( ::SireMol::ChainsWithRes::*what_function_type)( ) const;
what_function_type what_function_value( &::SireMol::ChainsWithRes::what );
ChainsWithRes_exposer.def(
"what"
, what_function_value
, "" );
}
ChainsWithRes_exposer.staticmethod( "typeName" );
ChainsWithRes_exposer.def( "__copy__", &__copy__);
ChainsWithRes_exposer.def( "__deepcopy__", &__copy__);
ChainsWithRes_exposer.def( "clone", &__copy__);
ChainsWithRes_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::ChainsWithRes >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
ChainsWithRes_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::ChainsWithRes >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
ChainsWithRes_exposer.def( "__str__", &__str__< ::SireMol::ChainsWithRes > );
ChainsWithRes_exposer.def( "__repr__", &__str__< ::SireMol::ChainsWithRes > );
ChainsWithRes_exposer.def( "__hash__", &::SireMol::ChainsWithRes::hash );
}
}
void register_MolPotentialTable_class(){
{ //::SireFF::MolPotentialTable
typedef bp::class_< SireFF::MolPotentialTable > MolPotentialTable_exposer_t;
MolPotentialTable_exposer_t MolPotentialTable_exposer = MolPotentialTable_exposer_t( "MolPotentialTable", bp::init< >() );
bp::scope MolPotentialTable_scope( MolPotentialTable_exposer );
MolPotentialTable_exposer.def( bp::init< SireMol::MoleculeView const & >(( bp::arg("molview") )) );
MolPotentialTable_exposer.def( bp::init< SireFF::MolPotentialTable const & >(( bp::arg("other") )) );
{ //::SireFF::MolPotentialTable::add
typedef bool ( ::SireFF::MolPotentialTable::*add_function_type )( ::SireMol::CGAtomIdx const &,::SireUnits::Dimension::MolarEnergy const & ) ;
add_function_type add_function_value( &::SireFF::MolPotentialTable::add );
MolPotentialTable_exposer.def(
"add"
, add_function_value
, ( bp::arg("cgatomidx"), bp::arg("potential") ) );
}
{ //::SireFF::MolPotentialTable::add
typedef bool ( ::SireFF::MolPotentialTable::*add_function_type )( ::SireMol::AtomSelection const &,::SireUnits::Dimension::MolarEnergy const & ) ;
add_function_type add_function_value( &::SireFF::MolPotentialTable::add );
MolPotentialTable_exposer.def(
"add"
, add_function_value
, ( bp::arg("selected_atoms"), bp::arg("potential") ) );
}
{ //::SireFF::MolPotentialTable::add
typedef void ( ::SireFF::MolPotentialTable::*add_function_type )( ::SireFF::MolPotentialTable const & ) ;
add_function_type add_function_value( &::SireFF::MolPotentialTable::add );
MolPotentialTable_exposer.def(
"add"
, add_function_value
, ( bp::arg("other") ) );
}
{ //::SireFF::MolPotentialTable::add
typedef void ( ::SireFF::MolPotentialTable::*add_function_type )( ::SireUnits::Dimension::MolarEnergy const & ) ;
add_function_type add_function_value( &::SireFF::MolPotentialTable::add );
MolPotentialTable_exposer.def(
"add"
, add_function_value
, ( bp::arg("potential") ) );
}
{ //::SireFF::MolPotentialTable::divide
typedef void ( ::SireFF::MolPotentialTable::*divide_function_type )( double ) ;
divide_function_type divide_function_value( &::SireFF::MolPotentialTable::divide );
MolPotentialTable_exposer.def(
"divide"
, divide_function_value
, ( bp::arg("value") ) );
}
{ //::SireFF::MolPotentialTable::initialise
typedef void ( ::SireFF::MolPotentialTable::*initialise_function_type )( ) ;
initialise_function_type initialise_function_value( &::SireFF::MolPotentialTable::initialise );
MolPotentialTable_exposer.def(
"initialise"
, initialise_function_value );
}
{ //::SireFF::MolPotentialTable::map
typedef int ( ::SireFF::MolPotentialTable::*map_function_type )( ::SireMol::CGIdx ) const;
map_function_type map_function_value( &::SireFF::MolPotentialTable::map );
MolPotentialTable_exposer.def(
"map"
, map_function_value
, ( bp::arg("cgidx") ) );
}
{ //::SireFF::MolPotentialTable::molNum
typedef ::SireMol::MolNum ( ::SireFF::MolPotentialTable::*molNum_function_type )( ) const;
molNum_function_type molNum_function_value( &::SireFF::MolPotentialTable::molNum );
MolPotentialTable_exposer.def(
"molNum"
, molNum_function_value );
}
{ //::SireFF::MolPotentialTable::molUID
typedef ::QUuid const & ( ::SireFF::MolPotentialTable::*molUID_function_type )( ) const;
molUID_function_type molUID_function_value( &::SireFF::MolPotentialTable::molUID );
MolPotentialTable_exposer.def(
"molUID"
, molUID_function_value
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireFF::MolPotentialTable::multiply
typedef void ( ::SireFF::MolPotentialTable::*multiply_function_type )( double ) ;
multiply_function_type multiply_function_value( &::SireFF::MolPotentialTable::multiply );
MolPotentialTable_exposer.def(
"multiply"
, multiply_function_value
, ( bp::arg("value") ) );
}
{ //::SireFF::MolPotentialTable::nCutGroups
typedef int ( ::SireFF::MolPotentialTable::*nCutGroups_function_type )( ) const;
nCutGroups_function_type nCutGroups_function_value( &::SireFF::MolPotentialTable::nCutGroups );
MolPotentialTable_exposer.def(
"nCutGroups"
, nCutGroups_function_value );
}
{ //::SireFF::MolPotentialTable::nSelectedCutGroups
typedef int ( ::SireFF::MolPotentialTable::*nSelectedCutGroups_function_type )( ) const;
nSelectedCutGroups_function_type nSelectedCutGroups_function_value( &::SireFF::MolPotentialTable::nSelectedCutGroups );
MolPotentialTable_exposer.def(
"nSelectedCutGroups"
, nSelectedCutGroups_function_value );
}
MolPotentialTable_exposer.def( bp::self != bp::self );
MolPotentialTable_exposer.def( bp::self * bp::other< double >() );
MolPotentialTable_exposer.def( bp::self + bp::self );
MolPotentialTable_exposer.def( bp::self + bp::other< SireUnits::Dimension::PhysUnit< 1, 2, -2, 0, 0, -1, 0 > >() );
MolPotentialTable_exposer.def( bp::self - bp::self );
MolPotentialTable_exposer.def( bp::self - bp::other< SireUnits::Dimension::PhysUnit< 1, 2, -2, 0, 0, -1, 0 > >() );
MolPotentialTable_exposer.def( -bp::self );
MolPotentialTable_exposer.def( bp::self / bp::other< double >() );
{ //::SireFF::MolPotentialTable::operator=
typedef ::SireFF::MolPotentialTable & ( ::SireFF::MolPotentialTable::*assign_function_type )( ::SireFF::MolPotentialTable const & ) ;
assign_function_type assign_function_value( &::SireFF::MolPotentialTable::operator= );
MolPotentialTable_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
{ //::SireFF::MolPotentialTable::operator=
typedef ::SireFF::MolPotentialTable & ( ::SireFF::MolPotentialTable::*assign_function_type )( ::SireUnits::Dimension::MolarEnergy const & ) ;
assign_function_type assign_function_value( &::SireFF::MolPotentialTable::operator= );
MolPotentialTable_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("potential") )
, bp::return_self< >() );
}
MolPotentialTable_exposer.def( bp::self == bp::self );
{ //::SireFF::MolPotentialTable::selected
typedef bool ( ::SireFF::MolPotentialTable::*selected_function_type )( ::SireMol::CGIdx ) const;
selected_function_type selected_function_value( &::SireFF::MolPotentialTable::selected );
MolPotentialTable_exposer.def(
"selected"
, selected_function_value
, ( bp::arg("cgidx") ) );
}
{ //::SireFF::MolPotentialTable::selectedAll
typedef bool ( ::SireFF::MolPotentialTable::*selectedAll_function_type )( ) const;
selectedAll_function_type selectedAll_function_value( &::SireFF::MolPotentialTable::selectedAll );
MolPotentialTable_exposer.def(
"selectedAll"
, selectedAll_function_value );
}
{ //::SireFF::MolPotentialTable::setAll
typedef void ( ::SireFF::MolPotentialTable::*setAll_function_type )( ::SireUnits::Dimension::MolarEnergy const & ) ;
setAll_function_type setAll_function_value( &::SireFF::MolPotentialTable::setAll );
MolPotentialTable_exposer.def(
"setAll"
, setAll_function_value
, ( bp::arg("potential") ) );
}
{ //::SireFF::MolPotentialTable::subtract
typedef bool ( ::SireFF::MolPotentialTable::*subtract_function_type )( ::SireMol::CGAtomIdx const &,::SireUnits::Dimension::MolarEnergy const & ) ;
subtract_function_type subtract_function_value( &::SireFF::MolPotentialTable::subtract );
MolPotentialTable_exposer.def(
"subtract"
, subtract_function_value
, ( bp::arg("cgatomidx"), bp::arg("potential") ) );
}
{ //::SireFF::MolPotentialTable::subtract
typedef bool ( ::SireFF::MolPotentialTable::*subtract_function_type )( ::SireMol::AtomSelection const &,::SireUnits::Dimension::MolarEnergy const & ) ;
subtract_function_type subtract_function_value( &::SireFF::MolPotentialTable::subtract );
MolPotentialTable_exposer.def(
"subtract"
, subtract_function_value
, ( bp::arg("selected_atoms"), bp::arg("potential") ) );
}
{ //::SireFF::MolPotentialTable::subtract
typedef void ( ::SireFF::MolPotentialTable::*subtract_function_type )( ::SireFF::MolPotentialTable const & ) ;
subtract_function_type subtract_function_value( &::SireFF::MolPotentialTable::subtract );
MolPotentialTable_exposer.def(
"subtract"
, subtract_function_value
, ( bp::arg("other") ) );
}
{ //::SireFF::MolPotentialTable::subtract
typedef void ( ::SireFF::MolPotentialTable::*subtract_function_type )( ::SireUnits::Dimension::MolarEnergy const & ) ;
subtract_function_type subtract_function_value( &::SireFF::MolPotentialTable::subtract );
MolPotentialTable_exposer.def(
"subtract"
, subtract_function_value
, ( bp::arg("potential") ) );
}
{ //::SireFF::MolPotentialTable::toVector
typedef ::QVector< SireUnits::Dimension::PhysUnit< 1, 2, -2, 0, 0, -1, 0 > > ( ::SireFF::MolPotentialTable::*toVector_function_type )( ) const;
toVector_function_type toVector_function_value( &::SireFF::MolPotentialTable::toVector );
MolPotentialTable_exposer.def(
"toVector"
, toVector_function_value );
}
{ //::SireFF::MolPotentialTable::toVector
typedef ::QVector< SireUnits::Dimension::PhysUnit< 1, 2, -2, 0, 0, -1, 0 > > ( ::SireFF::MolPotentialTable::*toVector_function_type )( ::SireMol::AtomSelection const & ) const;
toVector_function_type toVector_function_value( &::SireFF::MolPotentialTable::toVector );
MolPotentialTable_exposer.def(
"toVector"
, toVector_function_value
, ( bp::arg("selection") ) );
}
{ //::SireFF::MolPotentialTable::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireFF::MolPotentialTable::typeName );
MolPotentialTable_exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireFF::MolPotentialTable::what
typedef char const * ( ::SireFF::MolPotentialTable::*what_function_type )( ) const;
what_function_type what_function_value( &::SireFF::MolPotentialTable::what );
MolPotentialTable_exposer.def(
"what"
, what_function_value );
}
MolPotentialTable_exposer.staticmethod( "typeName" );
MolPotentialTable_exposer.def( "__copy__", &__copy__);
MolPotentialTable_exposer.def( "__deepcopy__", &__copy__);
MolPotentialTable_exposer.def( "clone", &__copy__);
MolPotentialTable_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireFF::MolPotentialTable >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
MolPotentialTable_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireFF::MolPotentialTable >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
MolPotentialTable_exposer.def( "__str__", &__str__< ::SireFF::MolPotentialTable > );
MolPotentialTable_exposer.def( "__repr__", &__str__< ::SireFF::MolPotentialTable > );
MolPotentialTable_exposer.def( "__len__", &__len_size< ::SireFF::MolPotentialTable > );
}
}
void register_MonitorID_class(){
{ //::SireSystem::MonitorID
typedef bp::class_< SireSystem::MonitorID, bp::bases< SireID::ID >, boost::noncopyable > MonitorID_exposer_t;
MonitorID_exposer_t MonitorID_exposer = MonitorID_exposer_t( "MonitorID", bp::no_init );
bp::scope MonitorID_scope( MonitorID_exposer );
{ //::SireSystem::MonitorID::map
typedef ::QList< SireSystem::MonitorName > ( ::SireSystem::MonitorID::*map_function_type )( ::SireSystem::SystemMonitors const & ) const;
map_function_type map_function_value( &::SireSystem::MonitorID::map );
MonitorID_exposer.def(
"map"
, map_function_value
, ( bp::arg("monitors") ) );
}
MonitorID_exposer.def( bp::self & bp::self );
{ //::SireSystem::MonitorID::operator()
typedef ::SireID::Specify< SireSystem::MonitorID > ( ::SireSystem::MonitorID::*__call___function_type )( int ) const;
__call___function_type __call___function_value( &::SireSystem::MonitorID::operator() );
MonitorID_exposer.def(
"__call__"
, __call___function_value
, ( bp::arg("i") ) );
}
{ //::SireSystem::MonitorID::operator()
typedef ::SireID::Specify< SireSystem::MonitorID > ( ::SireSystem::MonitorID::*__call___function_type )( int,int ) const;
__call___function_type __call___function_value( &::SireSystem::MonitorID::operator() );
MonitorID_exposer.def(
"__call__"
, __call___function_value
, ( bp::arg("i"), bp::arg("j") ) );
}
MonitorID_exposer.def( bp::self * bp::self );
MonitorID_exposer.def( bp::self + bp::self );
{ //::SireSystem::MonitorID::operator[]
typedef ::SireID::Specify< SireSystem::MonitorID > ( ::SireSystem::MonitorID::*__getitem___function_type )( int ) const;
__getitem___function_type __getitem___function_value( &::SireSystem::MonitorID::operator[] );
MonitorID_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("i") ) );
}
MonitorID_exposer.def( bp::self | bp::self );
{ //::SireSystem::MonitorID::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireSystem::MonitorID::typeName );
MonitorID_exposer.def(
"typeName"
, typeName_function_value );
}
MonitorID_exposer.staticmethod( "typeName" );
MonitorID_exposer.def( "__str__", &__str__< ::SireSystem::MonitorID > );
MonitorID_exposer.def( "__repr__", &__str__< ::SireSystem::MonitorID > );
}
}
void register_SysID_class(){
{ //::SireSystem::SysID
typedef bp::class_< SireSystem::SysID, bp::bases< SireID::ID >, boost::noncopyable > SysID_exposer_t;
SysID_exposer_t SysID_exposer = SysID_exposer_t( "SysID", "The base class of all system identifiers\n\nAuthor: Christopher Woods\n", bp::no_init );
bp::scope SysID_scope( SysID_exposer );
{ //::SireSystem::SysID::map
typedef ::QList< SireSystem::SysIdx > ( ::SireSystem::SysID::*map_function_type)( ::SireSystem::Systems const & ) const;
map_function_type map_function_value( &::SireSystem::SysID::map );
SysID_exposer.def(
"map"
, map_function_value
, ( bp::arg("systems") )
, "" );
}
SysID_exposer.def( bp::self & bp::self );
{ //::SireSystem::SysID::operator()
typedef ::SireID::Specify< SireSystem::SysID > ( ::SireSystem::SysID::*__call___function_type)( int ) const;
__call___function_type __call___function_value( &::SireSystem::SysID::operator() );
SysID_exposer.def(
"__call__"
, __call___function_value
, ( bp::arg("i") )
, "" );
}
{ //::SireSystem::SysID::operator()
typedef ::SireID::Specify< SireSystem::SysID > ( ::SireSystem::SysID::*__call___function_type)( int,int ) const;
__call___function_type __call___function_value( &::SireSystem::SysID::operator() );
SysID_exposer.def(
"__call__"
, __call___function_value
, ( bp::arg("i"), bp::arg("j") )
, "" );
}
SysID_exposer.def( bp::self * bp::self );
SysID_exposer.def( bp::self + bp::self );
{ //::SireSystem::SysID::operator[]
typedef ::SireID::Specify< SireSystem::SysID > ( ::SireSystem::SysID::*__getitem___function_type)( int ) const;
__getitem___function_type __getitem___function_value( &::SireSystem::SysID::operator[] );
SysID_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("i") )
, "" );
}
SysID_exposer.def( bp::self | bp::self );
{ //::SireSystem::SysID::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireSystem::SysID::typeName );
SysID_exposer.def(
"typeName"
, typeName_function_value
, "" );
}
SysID_exposer.staticmethod( "typeName" );
SysID_exposer.def( "__str__", &__str__< ::SireSystem::SysID > );
SysID_exposer.def( "__repr__", &__str__< ::SireSystem::SysID > );
SysID_exposer.def( "__hash__", &::SireSystem::SysID::hash );
}
}