void register_Molecules_class(){ { //::SireMol::Molecules typedef bp::class_< SireMol::Molecules, bp::bases< SireBase::Property > > Molecules_exposer_t; Molecules_exposer_t Molecules_exposer = Molecules_exposer_t( "Molecules", bp::init< >() ); bp::scope Molecules_scope( Molecules_exposer ); Molecules_exposer.def( bp::init< SireMol::MoleculeView const & >(( bp::arg("molecule") )) ); Molecules_exposer.def( bp::init< SireMol::ViewsOfMol const & >(( bp::arg("molviews") )) ); Molecules_exposer.def( bp::init< SireMol::Molecules const & >(( bp::arg("other") )) ); { //::SireMol::Molecules::add typedef void ( ::SireMol::Molecules::*add_function_type )( ::SireMol::MoleculeView const & ) ; add_function_type add_function_value( &::SireMol::Molecules::add ); Molecules_exposer.def( "add" , add_function_value , ( bp::arg("molview") ) ); } { //::SireMol::Molecules::add typedef void ( ::SireMol::Molecules::*add_function_type )( ::SireMol::ViewsOfMol const & ) ; add_function_type add_function_value( &::SireMol::Molecules::add ); Molecules_exposer.def( "add" , add_function_value , ( bp::arg("molviews") ) ); } { //::SireMol::Molecules::add typedef void ( ::SireMol::Molecules::*add_function_type )( ::SireMol::Molecules const & ) ; add_function_type add_function_value( &::SireMol::Molecules::add ); Molecules_exposer.def( "add" , add_function_value , ( bp::arg("molecules") ) ); } { //::SireMol::Molecules::addIfUnique typedef bool ( ::SireMol::Molecules::*addIfUnique_function_type )( ::SireMol::MoleculeView const & ) ; addIfUnique_function_type addIfUnique_function_value( &::SireMol::Molecules::addIfUnique ); Molecules_exposer.def( "addIfUnique" , addIfUnique_function_value , ( bp::arg("molview") ) ); } { //::SireMol::Molecules::addIfUnique typedef ::SireMol::ViewsOfMol ( ::SireMol::Molecules::*addIfUnique_function_type )( ::SireMol::ViewsOfMol const & ) ; addIfUnique_function_type addIfUnique_function_value( &::SireMol::Molecules::addIfUnique ); Molecules_exposer.def( "addIfUnique" , addIfUnique_function_value , ( bp::arg("molviews") ) ); } { //::SireMol::Molecules::addIfUnique typedef ::QList< SireMol::ViewsOfMol > ( ::SireMol::Molecules::*addIfUnique_function_type )( ::SireMol::Molecules const & ) ; addIfUnique_function_type addIfUnique_function_value( &::SireMol::Molecules::addIfUnique ); Molecules_exposer.def( "addIfUnique" , addIfUnique_function_value , ( bp::arg("molecules") ) ); } { //::SireMol::Molecules::assertContains typedef void ( ::SireMol::Molecules::*assertContains_function_type )( ::SireMol::MolNum ) const; assertContains_function_type assertContains_function_value( &::SireMol::Molecules::assertContains ); Molecules_exposer.def( "assertContains" , assertContains_function_value , ( bp::arg("molnum") ) ); } { //::SireMol::Molecules::at typedef ::SireMol::ViewsOfMol const & ( ::SireMol::Molecules::*at_function_type )( ::SireMol::MolNum ) const; at_function_type at_function_value( &::SireMol::Molecules::at ); Molecules_exposer.def( "at" , at_function_value , ( bp::arg("molnum") ) , bp::return_value_policy<bp::clone_const_reference>() ); } { //::SireMol::Molecules::at typedef ::SireMol::PartialMolecule ( ::SireMol::Molecules::*at_function_type )( ::boost::tuples::tuple< SireMol::MolNum, SireID::Index, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type > const & ) const; at_function_type at_function_value( &::SireMol::Molecules::at ); Molecules_exposer.def( "at" , at_function_value , ( bp::arg("viewidx") ) ); } { //::SireMol::Molecules::at typedef ::SireMol::PartialMolecule ( ::SireMol::Molecules::*at_function_type )( ::SireMol::MolNum,int ) const; at_function_type at_function_value( &::SireMol::Molecules::at ); Molecules_exposer.def( "at" , at_function_value , ( bp::arg("molnum"), bp::arg("idx") ) ); } { //::SireMol::Molecules::back typedef ::SireMol::ViewsOfMol const & ( ::SireMol::Molecules::*back_function_type )( ) const; back_function_type back_function_value( &::SireMol::Molecules::back ); Molecules_exposer.def( "back" , back_function_value , bp::return_value_policy<bp::clone_const_reference>() ); } { //::SireMol::Molecules::begin typedef ::SireBase::ChunkedHash< SireMol::MolNum, SireMol::ViewsOfMol, 100 >::const_iterator ( ::SireMol::Molecules::*begin_function_type )( ) const; begin_function_type begin_function_value( &::SireMol::Molecules::begin ); Molecules_exposer.def( "begin" , begin_function_value ); } { //::SireMol::Molecules::clear typedef void ( ::SireMol::Molecules::*clear_function_type )( ) ; clear_function_type clear_function_value( &::SireMol::Molecules::clear ); Molecules_exposer.def( "clear" , clear_function_value ); } { //::SireMol::Molecules::constBegin typedef ::SireBase::ChunkedHash< SireMol::MolNum, SireMol::ViewsOfMol, 100 >::const_iterator ( ::SireMol::Molecules::*constBegin_function_type )( ) const; constBegin_function_type constBegin_function_value( &::SireMol::Molecules::constBegin ); Molecules_exposer.def( "constBegin" , constBegin_function_value ); } { //::SireMol::Molecules::constEnd typedef ::SireBase::ChunkedHash< SireMol::MolNum, SireMol::ViewsOfMol, 100 >::const_iterator ( ::SireMol::Molecules::*constEnd_function_type )( ) const; constEnd_function_type constEnd_function_value( &::SireMol::Molecules::constEnd ); Molecules_exposer.def( "constEnd" , constEnd_function_value ); } { //::SireMol::Molecules::constFind typedef ::SireBase::ChunkedHash< SireMol::MolNum, SireMol::ViewsOfMol, 100 >::const_iterator ( ::SireMol::Molecules::*constFind_function_type )( ::SireMol::MolNum ) const; constFind_function_type constFind_function_value( &::SireMol::Molecules::constFind ); Molecules_exposer.def( "constFind" , constFind_function_value , ( bp::arg("molnum") ) ); } { //::SireMol::Molecules::contains typedef bool ( ::SireMol::Molecules::*contains_function_type )( ::SireMol::MolNum ) const; contains_function_type contains_function_value( &::SireMol::Molecules::contains ); Molecules_exposer.def( "contains" , contains_function_value , ( bp::arg("molnum") ) ); } { //::SireMol::Molecules::contains typedef bool ( ::SireMol::Molecules::*contains_function_type )( ::SireMol::MoleculeView const & ) const; contains_function_type contains_function_value( &::SireMol::Molecules::contains ); Molecules_exposer.def( "contains" , contains_function_value , ( bp::arg("molview") ) ); } { //::SireMol::Molecules::contains typedef bool ( ::SireMol::Molecules::*contains_function_type )( ::SireMol::ViewsOfMol const & ) const; contains_function_type contains_function_value( &::SireMol::Molecules::contains ); Molecules_exposer.def( "contains" , contains_function_value , ( bp::arg("molviews") ) ); } { //::SireMol::Molecules::contains typedef bool ( ::SireMol::Molecules::*contains_function_type )( ::SireMol::Molecules const & ) const; contains_function_type contains_function_value( &::SireMol::Molecules::contains ); Molecules_exposer.def( "contains" , contains_function_value , ( bp::arg("molecules") ) ); } { //::SireMol::Molecules::count typedef int ( ::SireMol::Molecules::*count_function_type )( ) const; count_function_type count_function_value( &::SireMol::Molecules::count ); Molecules_exposer.def( "count" , count_function_value ); } { //::SireMol::Molecules::end typedef ::SireBase::ChunkedHash< SireMol::MolNum, SireMol::ViewsOfMol, 100 >::const_iterator ( ::SireMol::Molecules::*end_function_type )( ) const; end_function_type end_function_value( &::SireMol::Molecules::end ); Molecules_exposer.def( "end" , end_function_value ); } { //::SireMol::Molecules::find typedef ::SireBase::ChunkedHash< SireMol::MolNum, SireMol::ViewsOfMol, 100 >::const_iterator ( ::SireMol::Molecules::*find_function_type )( ::SireMol::MolNum ) const; find_function_type find_function_value( &::SireMol::Molecules::find ); Molecules_exposer.def( "find" , find_function_value , ( bp::arg("molnum") ) ); } { //::SireMol::Molecules::first typedef ::SireMol::ViewsOfMol const & ( ::SireMol::Molecules::*first_function_type )( ) const; first_function_type first_function_value( &::SireMol::Molecules::first ); Molecules_exposer.def( "first" , first_function_value , bp::return_value_policy<bp::clone_const_reference>() ); } { //::SireMol::Molecules::front typedef ::SireMol::ViewsOfMol const & ( ::SireMol::Molecules::*front_function_type )( ) const; front_function_type front_function_value( &::SireMol::Molecules::front ); Molecules_exposer.def( "front" , front_function_value , bp::return_value_policy<bp::clone_const_reference>() ); } { //::SireMol::Molecules::intersects typedef bool ( ::SireMol::Molecules::*intersects_function_type )( ::SireMol::MoleculeView const & ) const; intersects_function_type intersects_function_value( &::SireMol::Molecules::intersects ); Molecules_exposer.def( "intersects" , intersects_function_value , ( bp::arg("molview") ) ); } { //::SireMol::Molecules::intersects typedef bool ( ::SireMol::Molecules::*intersects_function_type )( ::SireMol::Molecules const & ) const; intersects_function_type intersects_function_value( &::SireMol::Molecules::intersects ); Molecules_exposer.def( "intersects" , intersects_function_value , ( bp::arg("other") ) ); } { //::SireMol::Molecules::isEmpty typedef bool ( ::SireMol::Molecules::*isEmpty_function_type )( ) const; isEmpty_function_type isEmpty_function_value( &::SireMol::Molecules::isEmpty ); Molecules_exposer.def( "isEmpty" , isEmpty_function_value ); } { //::SireMol::Molecules::last typedef ::SireMol::ViewsOfMol const & ( ::SireMol::Molecules::*last_function_type )( ) const; last_function_type last_function_value( &::SireMol::Molecules::last ); Molecules_exposer.def( "last" , last_function_value , bp::return_value_policy<bp::clone_const_reference>() ); } { //::SireMol::Molecules::molNums typedef ::QSet< SireMol::MolNum > ( ::SireMol::Molecules::*molNums_function_type )( ) const; molNums_function_type molNums_function_value( &::SireMol::Molecules::molNums ); Molecules_exposer.def( "molNums" , molNums_function_value ); } { //::SireMol::Molecules::molecule typedef ::SireMol::ViewsOfMol const & ( ::SireMol::Molecules::*molecule_function_type )( ::SireMol::MolNum ) const; molecule_function_type molecule_function_value( &::SireMol::Molecules::molecule ); Molecules_exposer.def( "molecule" , molecule_function_value , ( bp::arg("molnum") ) , bp::return_value_policy<bp::clone_const_reference>() ); } { //::SireMol::Molecules::nMolecules typedef int ( ::SireMol::Molecules::*nMolecules_function_type )( ) const; nMolecules_function_type nMolecules_function_value( &::SireMol::Molecules::nMolecules ); Molecules_exposer.def( "nMolecules" , nMolecules_function_value ); } { //::SireMol::Molecules::nViews typedef int ( ::SireMol::Molecules::*nViews_function_type )( ) const; nViews_function_type nViews_function_value( &::SireMol::Molecules::nViews ); Molecules_exposer.def( "nViews" , nViews_function_value ); } { //::SireMol::Molecules::nViews typedef int ( ::SireMol::Molecules::*nViews_function_type )( ::SireMol::MolNum ) const; nViews_function_type nViews_function_value( &::SireMol::Molecules::nViews ); Molecules_exposer.def( "nViews" , nViews_function_value , ( bp::arg("molnum") ) ); } Molecules_exposer.def( bp::self != bp::self ); Molecules_exposer.def( bp::self + bp::self ); Molecules_exposer.def( bp::self - bp::self ); { //::SireMol::Molecules::operator= typedef ::SireMol::Molecules & ( ::SireMol::Molecules::*assign_function_type )( ::SireMol::Molecules const & ) ; assign_function_type assign_function_value( &::SireMol::Molecules::operator= ); Molecules_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() ); } Molecules_exposer.def( bp::self == bp::self ); { //::SireMol::Molecules::operator[] typedef ::SireMol::ViewsOfMol const & ( ::SireMol::Molecules::*__getitem___function_type )( ::SireMol::MolNum ) const; __getitem___function_type __getitem___function_value( &::SireMol::Molecules::operator[] ); Molecules_exposer.def( "__getitem__" , __getitem___function_value , ( bp::arg("molnum") ) , bp::return_value_policy<bp::clone_const_reference>() ); } { //::SireMol::Molecules::operator[] typedef ::SireMol::PartialMolecule ( ::SireMol::Molecules::*__getitem___function_type )( ::boost::tuples::tuple< SireMol::MolNum, SireID::Index, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type > const & ) const; __getitem___function_type __getitem___function_value( &::SireMol::Molecules::operator[] ); Molecules_exposer.def( "__getitem__" , __getitem___function_value , ( bp::arg("viewidx") ) ); } { //::SireMol::Molecules::remove typedef bool ( ::SireMol::Molecules::*remove_function_type )( ::SireMol::MoleculeView const & ) ; remove_function_type remove_function_value( &::SireMol::Molecules::remove ); Molecules_exposer.def( "remove" , remove_function_value , ( bp::arg("molview") ) ); } { //::SireMol::Molecules::remove typedef ::SireMol::ViewsOfMol ( ::SireMol::Molecules::*remove_function_type )( ::SireMol::ViewsOfMol const & ) ; remove_function_type remove_function_value( &::SireMol::Molecules::remove ); Molecules_exposer.def( "remove" , remove_function_value , ( bp::arg("molviews") ) ); } { //::SireMol::Molecules::remove typedef ::QList< SireMol::ViewsOfMol > ( ::SireMol::Molecules::*remove_function_type )( ::SireMol::Molecules const & ) ; remove_function_type remove_function_value( &::SireMol::Molecules::remove ); Molecules_exposer.def( "remove" , remove_function_value , ( bp::arg("molecules") ) ); } { //::SireMol::Molecules::remove typedef ::SireMol::ViewsOfMol ( ::SireMol::Molecules::*remove_function_type )( ::SireMol::MolNum ) ; remove_function_type remove_function_value( &::SireMol::Molecules::remove ); Molecules_exposer.def( "remove" , remove_function_value , ( bp::arg("molnum") ) ); } { //::SireMol::Molecules::removeAll typedef bool ( ::SireMol::Molecules::*removeAll_function_type )( ::SireMol::MoleculeView const & ) ; removeAll_function_type removeAll_function_value( &::SireMol::Molecules::removeAll ); Molecules_exposer.def( "removeAll" , removeAll_function_value , ( bp::arg("molview") ) ); } { //::SireMol::Molecules::removeAll typedef ::SireMol::ViewsOfMol ( ::SireMol::Molecules::*removeAll_function_type )( ::SireMol::ViewsOfMol const & ) ; removeAll_function_type removeAll_function_value( &::SireMol::Molecules::removeAll ); Molecules_exposer.def( "removeAll" , removeAll_function_value , ( bp::arg("molviews") ) ); } { //::SireMol::Molecules::removeAll typedef ::QList< SireMol::ViewsOfMol > ( ::SireMol::Molecules::*removeAll_function_type )( ::SireMol::Molecules const & ) ; removeAll_function_type removeAll_function_value( &::SireMol::Molecules::removeAll ); Molecules_exposer.def( "removeAll" , removeAll_function_value , ( bp::arg("molecules") ) ); } { //::SireMol::Molecules::removeAll typedef bool ( ::SireMol::Molecules::*removeAll_function_type )( ) ; removeAll_function_type removeAll_function_value( &::SireMol::Molecules::removeAll ); Molecules_exposer.def( "removeAll" , removeAll_function_value ); } { //::SireMol::Molecules::removeDuplicates typedef bool ( ::SireMol::Molecules::*removeDuplicates_function_type )( ) ; removeDuplicates_function_type removeDuplicates_function_value( &::SireMol::Molecules::removeDuplicates ); Molecules_exposer.def( "removeDuplicates" , removeDuplicates_function_value ); } { //::SireMol::Molecules::reserve typedef void ( ::SireMol::Molecules::*reserve_function_type )( int ) ; reserve_function_type reserve_function_value( &::SireMol::Molecules::reserve ); Molecules_exposer.def( "reserve" , reserve_function_value , ( bp::arg("nmolecules") ) ); } { //::SireMol::Molecules::toString typedef ::QString ( ::SireMol::Molecules::*toString_function_type )( ) const; toString_function_type toString_function_value( &::SireMol::Molecules::toString ); Molecules_exposer.def( "toString" , toString_function_value ); } { //::SireMol::Molecules::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireMol::Molecules::typeName ); Molecules_exposer.def( "typeName" , typeName_function_value ); } { //::SireMol::Molecules::unite typedef bool ( ::SireMol::Molecules::*unite_function_type )( ::SireMol::MoleculeView const & ) ; unite_function_type unite_function_value( &::SireMol::Molecules::unite ); Molecules_exposer.def( "unite" , unite_function_value , ( bp::arg("molview") ) ); } { //::SireMol::Molecules::unite typedef ::SireMol::ViewsOfMol ( ::SireMol::Molecules::*unite_function_type )( ::SireMol::ViewsOfMol const & ) ; unite_function_type unite_function_value( &::SireMol::Molecules::unite ); Molecules_exposer.def( "unite" , unite_function_value , ( bp::arg("molviews") ) ); } { //::SireMol::Molecules::unite typedef ::QList< SireMol::ViewsOfMol > ( ::SireMol::Molecules::*unite_function_type )( ::SireMol::Molecules const & ) ; unite_function_type unite_function_value( &::SireMol::Molecules::unite ); Molecules_exposer.def( "unite" , unite_function_value , ( bp::arg("other") ) ); } { //::SireMol::Molecules::uniteViews typedef bool ( ::SireMol::Molecules::*uniteViews_function_type )( ) ; uniteViews_function_type uniteViews_function_value( &::SireMol::Molecules::uniteViews ); Molecules_exposer.def( "uniteViews" , uniteViews_function_value ); } { //::SireMol::Molecules::update typedef bool ( ::SireMol::Molecules::*update_function_type )( ::SireMol::MoleculeData const & ) ; update_function_type update_function_value( &::SireMol::Molecules::update ); Molecules_exposer.def( "update" , update_function_value , ( bp::arg("moldata") ) ); } { //::SireMol::Molecules::update typedef bool ( ::SireMol::Molecules::*update_function_type )( ::SireMol::MoleculeView const & ) ; update_function_type update_function_value( &::SireMol::Molecules::update ); Molecules_exposer.def( "update" , update_function_value , ( bp::arg("molview") ) ); } { //::SireMol::Molecules::update typedef ::QList< SireMol::Molecule > ( ::SireMol::Molecules::*update_function_type )( ::SireMol::Molecules const & ) ; update_function_type update_function_value( &::SireMol::Molecules::update ); Molecules_exposer.def( "update" , update_function_value , ( bp::arg("molecules") ) ); } { //::SireMol::Molecules::what typedef char const * ( ::SireMol::Molecules::*what_function_type )( ) const; what_function_type what_function_value( &::SireMol::Molecules::what ); Molecules_exposer.def( "what" , what_function_value ); } Molecules_exposer.staticmethod( "typeName" ); Molecules_exposer.def( "__copy__", &__copy__); Molecules_exposer.def( "__deepcopy__", &__copy__); Molecules_exposer.def( "clone", &__copy__); Molecules_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::Molecules >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); Molecules_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::Molecules >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); Molecules_exposer.def( "__str__", &__str__< ::SireMol::Molecules > ); Molecules_exposer.def( "__repr__", &__str__< ::SireMol::Molecules > ); Molecules_exposer.def( "__len__", &__len_count< ::SireMol::Molecules > ); } }
void register_DihedralRestraint_class(){ { //::SireMM::DihedralRestraint typedef bp::class_< SireMM::DihedralRestraint, bp::bases< SireMM::Restraint3D, SireMM::Restraint, SireBase::Property > > DihedralRestraint_exposer_t; DihedralRestraint_exposer_t DihedralRestraint_exposer = DihedralRestraint_exposer_t( "DihedralRestraint", "This is a restraint that operates on the dihedral angle between\nfour SireMM::Point objects (e.g. four atoms in a molecule)\n\nAuthor: Christopher Woods\n", bp::init< >("Constructor") ); bp::scope DihedralRestraint_scope( DihedralRestraint_exposer ); DihedralRestraint_exposer.def( bp::init< SireFF::PointRef const &, SireFF::PointRef const &, SireFF::PointRef const &, SireFF::PointRef const &, SireCAS::Expression const & >(( bp::arg("point0"), bp::arg("point1"), bp::arg("point2"), bp::arg("point3"), bp::arg("restraint") ), "Construct a restraint that acts on the angle within the\nthree points point0, point1 and point2 (theta == a(012)),\nrestraining the angle within these points using the expression\nrestraint") ); DihedralRestraint_exposer.def( bp::init< SireFF::PointRef const &, SireFF::PointRef const &, SireFF::PointRef const &, SireFF::PointRef const &, SireCAS::Expression const &, SireCAS::Values const & >(( bp::arg("point0"), bp::arg("point1"), bp::arg("point2"), bp::arg("point3"), bp::arg("restraint"), bp::arg("values") ), "Construct a restraint that acts on the angle within the\nthree points point0, point1 and point2 (theta == a(012)),\nrestraining the angle within these points using the expression\nrestraint") ); DihedralRestraint_exposer.def( bp::init< SireMM::DihedralRestraint const & >(( bp::arg("other") ), "Copy constructor") ); { //::SireMM::DihedralRestraint::builtinSymbols typedef ::SireCAS::Symbols ( ::SireMM::DihedralRestraint::*builtinSymbols_function_type)( ) const; builtinSymbols_function_type builtinSymbols_function_value( &::SireMM::DihedralRestraint::builtinSymbols ); DihedralRestraint_exposer.def( "builtinSymbols" , builtinSymbols_function_value , "Return the built-in symbols for this restraint" ); } { //::SireMM::DihedralRestraint::builtinValues typedef ::SireCAS::Values ( ::SireMM::DihedralRestraint::*builtinValues_function_type)( ) const; builtinValues_function_type builtinValues_function_value( &::SireMM::DihedralRestraint::builtinValues ); DihedralRestraint_exposer.def( "builtinValues" , builtinValues_function_value , "Return the values of the built-in symbols of this restraint" ); } { //::SireMM::DihedralRestraint::contains typedef bool ( ::SireMM::DihedralRestraint::*contains_function_type)( ::SireMol::MolNum ) const; contains_function_type contains_function_value( &::SireMM::DihedralRestraint::contains ); DihedralRestraint_exposer.def( "contains" , contains_function_value , ( bp::arg("molnum") ) , "Return whether or not this restraint affects the molecule\nwith number molnum" ); } { //::SireMM::DihedralRestraint::contains typedef bool ( ::SireMM::DihedralRestraint::*contains_function_type)( ::SireMol::MolID const & ) const; contains_function_type contains_function_value( &::SireMM::DihedralRestraint::contains ); DihedralRestraint_exposer.def( "contains" , contains_function_value , ( bp::arg("molid") ) , "Return whether or not this restraint affects the molecule\nwith ID molid" ); } { //::SireMM::DihedralRestraint::differentialRestraintFunction typedef ::SireCAS::Expression const & ( ::SireMM::DihedralRestraint::*differentialRestraintFunction_function_type)( ) const; differentialRestraintFunction_function_type differentialRestraintFunction_function_value( &::SireMM::DihedralRestraint::differentialRestraintFunction ); DihedralRestraint_exposer.def( "differentialRestraintFunction" , differentialRestraintFunction_function_value , bp::return_value_policy< bp::copy_const_reference >() , "Return the function used to calculate the restraint force" ); } { //::SireMM::DihedralRestraint::differentiate typedef ::SireMM::RestraintPtr ( ::SireMM::DihedralRestraint::*differentiate_function_type)( ::SireCAS::Symbol const & ) const; differentiate_function_type differentiate_function_value( &::SireMM::DihedralRestraint::differentiate ); DihedralRestraint_exposer.def( "differentiate" , differentiate_function_value , ( bp::arg("symbol") ) , "Return the differential of this restraint with respect to\nthe symbol symbol\nThrow: SireCAS::unavailable_differential\n" ); } { //::SireMM::DihedralRestraint::force typedef void ( ::SireMM::DihedralRestraint::*force_function_type)( ::SireFF::MolForceTable &,double ) const; force_function_type force_function_value( &::SireMM::DihedralRestraint::force ); DihedralRestraint_exposer.def( "force" , force_function_value , ( bp::arg("forcetable"), bp::arg("scale_force")=1 ) , "Calculate the force acting on the molecule in the forcetable forcetable\ncaused by this restraint, and add it on to the forcetable scaled by\nscale_force" ); } { //::SireMM::DihedralRestraint::force typedef void ( ::SireMM::DihedralRestraint::*force_function_type)( ::SireFF::ForceTable &,double ) const; force_function_type force_function_value( &::SireMM::DihedralRestraint::force ); DihedralRestraint_exposer.def( "force" , force_function_value , ( bp::arg("forcetable"), bp::arg("scale_force")=1 ) , "Calculate the force acting on the molecules in the forcetable forcetable\ncaused by this restraint, and add it on to the forcetable scaled by\nscale_force" ); } { //::SireMM::DihedralRestraint::halfHarmonic typedef ::SireMM::DihedralRestraint ( *halfHarmonic_function_type )( ::SireFF::PointRef const &,::SireFF::PointRef const &,::SireFF::PointRef const &,::SireFF::PointRef const &,::SireUnits::Dimension::Angle const &,::SireMM::HarmonicAngleForceConstant const & ); halfHarmonic_function_type halfHarmonic_function_value( &::SireMM::DihedralRestraint::halfHarmonic ); DihedralRestraint_exposer.def( "halfHarmonic" , halfHarmonic_function_value , ( bp::arg("point0"), bp::arg("point1"), bp::arg("point2"), bp::arg("point3"), bp::arg("angle"), bp::arg("force_constant") ) , "Return a distance restraint that applied a half-harmonic potential\nbetween the points point0 and point1 above a distance distance\nusing a force constant force_constant" ); } { //::SireMM::DihedralRestraint::harmonic typedef ::SireMM::DihedralRestraint ( *harmonic_function_type )( ::SireFF::PointRef const &,::SireFF::PointRef const &,::SireFF::PointRef const &,::SireFF::PointRef const &,::SireMM::HarmonicAngleForceConstant const & ); harmonic_function_type harmonic_function_value( &::SireMM::DihedralRestraint::harmonic ); DihedralRestraint_exposer.def( "harmonic" , harmonic_function_value , ( bp::arg("point0"), bp::arg("point1"), bp::arg("point2"), bp::arg("point3"), bp::arg("force_constant") ) , "Return a distance restraint that applies a harmonic potential between\nthe points point0 and point1 using a force constant force_constant" ); } { //::SireMM::DihedralRestraint::molecules typedef ::SireMol::Molecules ( ::SireMM::DihedralRestraint::*molecules_function_type)( ) const; molecules_function_type molecules_function_value( &::SireMM::DihedralRestraint::molecules ); DihedralRestraint_exposer.def( "molecules" , molecules_function_value , "Return the molecules used in this restraint" ); } { //::SireMM::DihedralRestraint::nPoints typedef int ( ::SireMM::DihedralRestraint::*nPoints_function_type)( ) const; nPoints_function_type nPoints_function_value( &::SireMM::DihedralRestraint::nPoints ); DihedralRestraint_exposer.def( "nPoints" , nPoints_function_value , "This restraint involves four points" ); } DihedralRestraint_exposer.def( bp::self != bp::self ); { //::SireMM::DihedralRestraint::operator= typedef ::SireMM::DihedralRestraint & ( ::SireMM::DihedralRestraint::*assign_function_type)( ::SireMM::DihedralRestraint const & ) ; assign_function_type assign_function_value( &::SireMM::DihedralRestraint::operator= ); DihedralRestraint_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() , "" ); } DihedralRestraint_exposer.def( bp::self == bp::self ); { //::SireMM::DihedralRestraint::phi typedef ::SireCAS::Symbol const & ( *phi_function_type )( ); phi_function_type phi_function_value( &::SireMM::DihedralRestraint::phi ); DihedralRestraint_exposer.def( "phi" , phi_function_value , bp::return_value_policy<bp::clone_const_reference>() , "Return the symbol that represents the dihedral angle between the points (phi)" ); } { //::SireMM::DihedralRestraint::point typedef ::SireFF::Point const & ( ::SireMM::DihedralRestraint::*point_function_type)( int ) const; point_function_type point_function_value( &::SireMM::DihedralRestraint::point ); DihedralRestraint_exposer.def( "point" , point_function_value , ( bp::arg("i") ) , bp::return_value_policy<bp::clone_const_reference>() , "Return the ith point" ); } { //::SireMM::DihedralRestraint::point0 typedef ::SireFF::Point const & ( ::SireMM::DihedralRestraint::*point0_function_type)( ) const; point0_function_type point0_function_value( &::SireMM::DihedralRestraint::point0 ); DihedralRestraint_exposer.def( "point0" , point0_function_value , bp::return_value_policy<bp::clone_const_reference>() , "Return the first point" ); } { //::SireMM::DihedralRestraint::point1 typedef ::SireFF::Point const & ( ::SireMM::DihedralRestraint::*point1_function_type)( ) const; point1_function_type point1_function_value( &::SireMM::DihedralRestraint::point1 ); DihedralRestraint_exposer.def( "point1" , point1_function_value , bp::return_value_policy<bp::clone_const_reference>() , "Return the second point" ); } { //::SireMM::DihedralRestraint::point2 typedef ::SireFF::Point const & ( ::SireMM::DihedralRestraint::*point2_function_type)( ) const; point2_function_type point2_function_value( &::SireMM::DihedralRestraint::point2 ); DihedralRestraint_exposer.def( "point2" , point2_function_value , bp::return_value_policy<bp::clone_const_reference>() , "Return the third point" ); } { //::SireMM::DihedralRestraint::point3 typedef ::SireFF::Point const & ( ::SireMM::DihedralRestraint::*point3_function_type)( ) const; point3_function_type point3_function_value( &::SireMM::DihedralRestraint::point3 ); DihedralRestraint_exposer.def( "point3" , point3_function_value , bp::return_value_policy<bp::clone_const_reference>() , "Return the fourth point" ); } { //::SireMM::DihedralRestraint::setSpace typedef void ( ::SireMM::DihedralRestraint::*setSpace_function_type)( ::SireVol::Space const & ) ; setSpace_function_type setSpace_function_value( &::SireMM::DihedralRestraint::setSpace ); DihedralRestraint_exposer.def( "setSpace" , setSpace_function_value , ( bp::arg("space") ) , "Set the space used to evaluate the energy of this restraint\nThrow: SireVol::incompatible_space\n" ); } { //::SireMM::DihedralRestraint::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireMM::DihedralRestraint::typeName ); DihedralRestraint_exposer.def( "typeName" , typeName_function_value , "" ); } { //::SireMM::DihedralRestraint::update typedef void ( ::SireMM::DihedralRestraint::*update_function_type)( ::SireMol::MoleculeData const & ) ; update_function_type update_function_value( &::SireMM::DihedralRestraint::update ); DihedralRestraint_exposer.def( "update" , update_function_value , ( bp::arg("moldata") ) , "Update the points of this restraint using new molecule data from moldata\nThrow: SireBase::missing_property\nThrow: SireError::invalid_cast\nThrow: SireError::incompatible_error\n" ); } { //::SireMM::DihedralRestraint::update typedef void ( ::SireMM::DihedralRestraint::*update_function_type)( ::SireMol::Molecules const & ) ; update_function_type update_function_value( &::SireMM::DihedralRestraint::update ); DihedralRestraint_exposer.def( "update" , update_function_value , ( bp::arg("molecules") ) , "Update the points of this restraint using new molecule data from molecules\nThrow: SireBase::missing_property\nThrow: SireError::invalid_cast\nThrow: SireError::incompatible_error\n" ); } { //::SireMM::DihedralRestraint::usesMoleculesIn typedef bool ( ::SireMM::DihedralRestraint::*usesMoleculesIn_function_type)( ::SireFF::ForceTable const & ) const; usesMoleculesIn_function_type usesMoleculesIn_function_value( &::SireMM::DihedralRestraint::usesMoleculesIn ); DihedralRestraint_exposer.def( "usesMoleculesIn" , usesMoleculesIn_function_value , ( bp::arg("forcetable") ) , "Return whether or not this restraint involves any of the molecules\nthat are in the forcetable forcetable" ); } { //::SireMM::DihedralRestraint::usesMoleculesIn typedef bool ( ::SireMM::DihedralRestraint::*usesMoleculesIn_function_type)( ::SireMol::Molecules const & ) const; usesMoleculesIn_function_type usesMoleculesIn_function_value( &::SireMM::DihedralRestraint::usesMoleculesIn ); DihedralRestraint_exposer.def( "usesMoleculesIn" , usesMoleculesIn_function_value , ( bp::arg("molecules") ) , "Return whether or not this restraint involves any of the molecules\nin molecules" ); } DihedralRestraint_exposer.staticmethod( "halfHarmonic" ); DihedralRestraint_exposer.staticmethod( "harmonic" ); DihedralRestraint_exposer.staticmethod( "phi" ); DihedralRestraint_exposer.staticmethod( "typeName" ); DihedralRestraint_exposer.def( "__copy__", &__copy__); DihedralRestraint_exposer.def( "__deepcopy__", &__copy__); DihedralRestraint_exposer.def( "clone", &__copy__); DihedralRestraint_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::DihedralRestraint >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); DihedralRestraint_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::DihedralRestraint >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); DihedralRestraint_exposer.def( "__str__", &__str__< ::SireMM::DihedralRestraint > ); DihedralRestraint_exposer.def( "__repr__", &__str__< ::SireMM::DihedralRestraint > ); } }
void register_CoordGroupArray_class(){ { //::SireVol::CoordGroupArray typedef bp::class_< SireVol::CoordGroupArray > CoordGroupArray_exposer_t; CoordGroupArray_exposer_t CoordGroupArray_exposer = CoordGroupArray_exposer_t( "CoordGroupArray", "This class holds an array of CoordGroups. While you could\nof course just use a QVector<CoordGroup>, this array\noptimises the memory layout of all of the CoordGroups\nso that they all lie contiguously along the same piece\nof memory (and indeed, all of the AABoxes are grouped\ntogether, while all of the coordinates are grouped together).\n\nThe memory packing means that this array is much more\nlimited than a QVector<CoordGroup>, i.e. you cant\nadd or remove CoordGroups from the array, and you cant\ndo anything to the contained CoordGroups except for\nchange their coordinates.\n\nThis class is really meant to be used as a fast container\nthat allow rapid iteration over all of the contained\nCoordGroups coordinates\n\nAuthor: Christopher Woods\n", bp::init< >("Null constructor") ); bp::scope CoordGroupArray_scope( CoordGroupArray_exposer ); CoordGroupArray_exposer.def( bp::init< SireVol::CoordGroup const & >(( bp::arg("cgroup") ), "Construct an array that holds just the passed CoordGroup") ); CoordGroupArray_exposer.def( bp::init< QVector< QVector< SireMaths::Vector > > const & >(( bp::arg("points") ), "Construct from a double-vector") ); CoordGroupArray_exposer.def( bp::init< QVector< SireVol::CoordGroup > const & >(( bp::arg("cgroups") ), "Construct from an array of CoordGroups") ); CoordGroupArray_exposer.def( bp::init< SireVol::CoordGroupArray const &, SireVol::CoordGroupArray const & >(( bp::arg("array0"), bp::arg("array1") ), "Construct from a pair of CoordGroupArrays") ); CoordGroupArray_exposer.def( bp::init< SireVol::CoordGroupArray const & >(( bp::arg("other") ), "Copy constructor") ); { //::SireVol::CoordGroupArray::aaBox typedef ::SireVol::AABox ( ::SireVol::CoordGroupArray::*aaBox_function_type)( ) const; aaBox_function_type aaBox_function_value( &::SireVol::CoordGroupArray::aaBox ); CoordGroupArray_exposer.def( "aaBox" , aaBox_function_value , "Return an AABox that complete encompasses all of the CoordGroups\nin this array" ); } { //::SireVol::CoordGroupArray::append typedef void ( ::SireVol::CoordGroupArray::*append_function_type)( ::SireVol::CoordGroup const & ) ; append_function_type append_function_value( &::SireVol::CoordGroupArray::append ); CoordGroupArray_exposer.def( "append" , append_function_value , ( bp::arg("cgroup") ) , "Append the passed CoordGroup onto the end of this array" ); } { //::SireVol::CoordGroupArray::append typedef void ( ::SireVol::CoordGroupArray::*append_function_type)( ::SireVol::CoordGroupArray const & ) ; append_function_type append_function_value( &::SireVol::CoordGroupArray::append ); CoordGroupArray_exposer.def( "append" , append_function_value , ( bp::arg("cgroups") ) , "Append the passed CoordGroups onto the end of this array" ); } { //::SireVol::CoordGroupArray::assertValidCoordGroup typedef void ( ::SireVol::CoordGroupArray::*assertValidCoordGroup_function_type)( ::quint32 ) const; assertValidCoordGroup_function_type assertValidCoordGroup_function_value( &::SireVol::CoordGroupArray::assertValidCoordGroup ); CoordGroupArray_exposer.def( "assertValidCoordGroup" , assertValidCoordGroup_function_value , ( bp::arg("i") ) , "Assert that the index i points to a valid CoordGroup\nThrow: SireError::invalid_index\n" ); } { //::SireVol::CoordGroupArray::assertValidCoordinate typedef void ( ::SireVol::CoordGroupArray::*assertValidCoordinate_function_type)( ::quint32 ) const; assertValidCoordinate_function_type assertValidCoordinate_function_value( &::SireVol::CoordGroupArray::assertValidCoordinate ); CoordGroupArray_exposer.def( "assertValidCoordinate" , assertValidCoordinate_function_value , ( bp::arg("i") ) , "Assert that the index i points a valid coordinate\nThrow: SireError::invalid_index\n" ); } { //::SireVol::CoordGroupArray::assertValidIndex typedef void ( ::SireVol::CoordGroupArray::*assertValidIndex_function_type)( ::quint32 ) const; assertValidIndex_function_type assertValidIndex_function_value( &::SireVol::CoordGroupArray::assertValidIndex ); CoordGroupArray_exposer.def( "assertValidIndex" , assertValidIndex_function_value , ( bp::arg("i") ) , "Assert that the index i points to a valid CoordGroup\nThrow: SireError::invalid_index\n" ); } { //::SireVol::CoordGroupArray::at typedef ::SireVol::CoordGroup const & ( ::SireVol::CoordGroupArray::*at_function_type)( ::quint32 ) const; at_function_type at_function_value( &::SireVol::CoordGroupArray::at ); CoordGroupArray_exposer.def( "at" , at_function_value , ( bp::arg("i") ) , bp::return_value_policy< bp::copy_const_reference >() , "Return a reference to the ith CoordGroup\nThrow: SireError::invalid_index\n" ); } { //::SireVol::CoordGroupArray::changeFrame typedef void ( ::SireVol::CoordGroupArray::*changeFrame_function_type)( ::SireMaths::AxisSet const &,::SireMaths::AxisSet const & ) ; changeFrame_function_type changeFrame_function_value( &::SireVol::CoordGroupArray::changeFrame ); CoordGroupArray_exposer.def( "changeFrame" , changeFrame_function_value , ( bp::arg("from_frame"), bp::arg("to_frame") ) , "Change all of the coordinates in this array from the\ncoordinate frame from_frame to the coordinate frame to_frame" ); } { //::SireVol::CoordGroupArray::changeFrame typedef void ( ::SireVol::CoordGroupArray::*changeFrame_function_type)( ::quint32,::SireMaths::AxisSet const &,::SireMaths::AxisSet const & ) ; changeFrame_function_type changeFrame_function_value( &::SireVol::CoordGroupArray::changeFrame ); CoordGroupArray_exposer.def( "changeFrame" , changeFrame_function_value , ( bp::arg("i"), bp::arg("from_frame"), bp::arg("to_frame") ) , "Change all of the coordinates in the ith CoordGroup from\nthe coordinate frame from_frame to the coordinate frame\nto_frame\nThrow: SireError::invalid_index\n" ); } { //::SireVol::CoordGroupArray::count typedef int ( ::SireVol::CoordGroupArray::*count_function_type)( ) const; count_function_type count_function_value( &::SireVol::CoordGroupArray::count ); CoordGroupArray_exposer.def( "count" , count_function_value , "Return the number of CoordGroups in this array" ); } { //::SireVol::CoordGroupArray::isEmpty typedef bool ( ::SireVol::CoordGroupArray::*isEmpty_function_type)( ) const; isEmpty_function_type isEmpty_function_value( &::SireVol::CoordGroupArray::isEmpty ); CoordGroupArray_exposer.def( "isEmpty" , isEmpty_function_value , "Return whether or not this array is empty" ); } { //::SireVol::CoordGroupArray::mapInto typedef void ( ::SireVol::CoordGroupArray::*mapInto_function_type)( ::SireMaths::AxisSet const & ) ; mapInto_function_type mapInto_function_value( &::SireVol::CoordGroupArray::mapInto ); CoordGroupArray_exposer.def( "mapInto" , mapInto_function_value , ( bp::arg("axes") ) , "Map all of the coordinates in this array into the coordinate\nframe represented by axes" ); } { //::SireVol::CoordGroupArray::mapInto typedef void ( ::SireVol::CoordGroupArray::*mapInto_function_type)( ::quint32,::SireMaths::AxisSet const & ) ; mapInto_function_type mapInto_function_value( &::SireVol::CoordGroupArray::mapInto ); CoordGroupArray_exposer.def( "mapInto" , mapInto_function_value , ( bp::arg("i"), bp::arg("axes") ) , "Map all of the coordinates of the CoordGroup at index i\ninto the coordinate frame represented by axes\nThrow: SireError::invalid_index\n" ); } { //::SireVol::CoordGroupArray::merge typedef ::SireVol::CoordGroup ( ::SireVol::CoordGroupArray::*merge_function_type)( ) const; merge_function_type merge_function_value( &::SireVol::CoordGroupArray::merge ); CoordGroupArray_exposer.def( "merge" , merge_function_value , "Merge this array of CoordGroups back into a single CoordGroup" ); } { //::SireVol::CoordGroupArray::nCoordGroups typedef int ( ::SireVol::CoordGroupArray::*nCoordGroups_function_type)( ) const; nCoordGroups_function_type nCoordGroups_function_value( &::SireVol::CoordGroupArray::nCoordGroups ); CoordGroupArray_exposer.def( "nCoordGroups" , nCoordGroups_function_value , "Return the number of CoordGroups in this array" ); } { //::SireVol::CoordGroupArray::nCoords typedef int ( ::SireVol::CoordGroupArray::*nCoords_function_type)( ) const; nCoords_function_type nCoords_function_value( &::SireVol::CoordGroupArray::nCoords ); CoordGroupArray_exposer.def( "nCoords" , nCoords_function_value , "Return the number of coordinates in this array" ); } CoordGroupArray_exposer.def( bp::self != bp::self ); { //::SireVol::CoordGroupArray::operator= typedef ::SireVol::CoordGroupArray & ( ::SireVol::CoordGroupArray::*assign_function_type)( ::SireVol::CoordGroupArray const & ) ; assign_function_type assign_function_value( &::SireVol::CoordGroupArray::operator= ); CoordGroupArray_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() , "" ); } CoordGroupArray_exposer.def( bp::self == bp::self ); { //::SireVol::CoordGroupArray::operator[] typedef ::SireVol::CoordGroup const & ( ::SireVol::CoordGroupArray::*__getitem___function_type)( ::quint32 ) const; __getitem___function_type __getitem___function_value( &::SireVol::CoordGroupArray::operator[] ); CoordGroupArray_exposer.def( "__getitem__" , __getitem___function_value , ( bp::arg("i") ) , bp::return_value_policy< bp::copy_const_reference >() , "" ); } { //::SireVol::CoordGroupArray::remove typedef void ( ::SireVol::CoordGroupArray::*remove_function_type)( ::quint32 ) ; remove_function_type remove_function_value( &::SireVol::CoordGroupArray::remove ); CoordGroupArray_exposer.def( "remove" , remove_function_value , ( bp::arg("i") ) , "Remove the ith CoordGroup from the array" ); } { //::SireVol::CoordGroupArray::remove typedef void ( ::SireVol::CoordGroupArray::*remove_function_type)( ::quint32,int ) ; remove_function_type remove_function_value( &::SireVol::CoordGroupArray::remove ); CoordGroupArray_exposer.def( "remove" , remove_function_value , ( bp::arg("i"), bp::arg("count") ) , "Remove count CoordGroups from the array, starting with the ith CoordGroup" ); } { //::SireVol::CoordGroupArray::remove typedef void ( ::SireVol::CoordGroupArray::*remove_function_type)( ::QVarLengthArray< unsigned int, 256 > const & ) ; remove_function_type remove_function_value( &::SireVol::CoordGroupArray::remove ); CoordGroupArray_exposer.def( "remove" , remove_function_value , ( bp::arg("idxs") ) , "Remove the specified CoordGroups from the array" ); } { //::SireVol::CoordGroupArray::rotate typedef void ( ::SireVol::CoordGroupArray::*rotate_function_type)( ::SireMaths::Quaternion const &,::SireMaths::Vector const & ) ; rotate_function_type rotate_function_value( &::SireVol::CoordGroupArray::rotate ); CoordGroupArray_exposer.def( "rotate" , rotate_function_value , ( bp::arg("quat"), bp::arg("point") ) , "Rotate all of the coordinates in this array using the quaternion\nquat around the point point" ); } { //::SireVol::CoordGroupArray::rotate typedef void ( ::SireVol::CoordGroupArray::*rotate_function_type)( ::SireMaths::Matrix const &,::SireMaths::Vector const & ) ; rotate_function_type rotate_function_value( &::SireVol::CoordGroupArray::rotate ); CoordGroupArray_exposer.def( "rotate" , rotate_function_value , ( bp::arg("rotmat"), bp::arg("point") ) , "Rotate all of coordinates in this array using the matrix rotmat\nabout the point point" ); } { //::SireVol::CoordGroupArray::rotate typedef void ( ::SireVol::CoordGroupArray::*rotate_function_type)( ::quint32,::SireMaths::Quaternion const &,::SireMaths::Vector const & ) ; rotate_function_type rotate_function_value( &::SireVol::CoordGroupArray::rotate ); CoordGroupArray_exposer.def( "rotate" , rotate_function_value , ( bp::arg("i"), bp::arg("quat"), bp::arg("point") ) , "Rotate all of the coordinates in the CoordGroup at index i using\nthe quaternion quat about the point point\nThrow: SireError::invalid_index\n" ); } { //::SireVol::CoordGroupArray::rotate typedef void ( ::SireVol::CoordGroupArray::*rotate_function_type)( ::quint32,::SireMaths::Matrix const &,::SireMaths::Vector const & ) ; rotate_function_type rotate_function_value( &::SireVol::CoordGroupArray::rotate ); CoordGroupArray_exposer.def( "rotate" , rotate_function_value , ( bp::arg("i"), bp::arg("rotmat"), bp::arg("point") ) , "Rotate all of the coordinates in the CoordGroup at index i using\nthe matrix rotmat about the point point\nThrow: SireError::invalid_index\n" ); } { //::SireVol::CoordGroupArray::size typedef int ( ::SireVol::CoordGroupArray::*size_function_type)( ) const; size_function_type size_function_value( &::SireVol::CoordGroupArray::size ); CoordGroupArray_exposer.def( "size" , size_function_value , "Return the number of CoordGroups in this array" ); } { //::SireVol::CoordGroupArray::toString typedef ::QString ( ::SireVol::CoordGroupArray::*toString_function_type)( ) const; toString_function_type toString_function_value( &::SireVol::CoordGroupArray::toString ); CoordGroupArray_exposer.def( "toString" , toString_function_value , "Return a string representation of this array" ); } { //::SireVol::CoordGroupArray::transform typedef void ( ::SireVol::CoordGroupArray::*transform_function_type)( ::SireMaths::Transform const & ) ; transform_function_type transform_function_value( &::SireVol::CoordGroupArray::transform ); CoordGroupArray_exposer.def( "transform" , transform_function_value , ( bp::arg("t") ) , "Transform all of coordinates in this array using the transformation t" ); } { //::SireVol::CoordGroupArray::transform typedef void ( ::SireVol::CoordGroupArray::*transform_function_type)( ::quint32,::SireMaths::Transform const & ) ; transform_function_type transform_function_value( &::SireVol::CoordGroupArray::transform ); CoordGroupArray_exposer.def( "transform" , transform_function_value , ( bp::arg("i"), bp::arg("t") ) , "Transform all of the coordinates in the CoordGroup at index i using\nthe transformation t\nThrow: SireError::invalid_index\n" ); } { //::SireVol::CoordGroupArray::translate typedef void ( ::SireVol::CoordGroupArray::*translate_function_type)( ::SireMaths::Vector const & ) ; translate_function_type translate_function_value( &::SireVol::CoordGroupArray::translate ); CoordGroupArray_exposer.def( "translate" , translate_function_value , ( bp::arg("delta") ) , "Translate all of the coordinates in this array by delta" ); } { //::SireVol::CoordGroupArray::translate typedef void ( ::SireVol::CoordGroupArray::*translate_function_type)( ::quint32,::SireMaths::Vector const & ) ; translate_function_type translate_function_value( &::SireVol::CoordGroupArray::translate ); CoordGroupArray_exposer.def( "translate" , translate_function_value , ( bp::arg("i"), bp::arg("delta") ) , "Translate all of the coordinates in the ith CoordGroup by delta" ); } { //::SireVol::CoordGroupArray::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireVol::CoordGroupArray::typeName ); CoordGroupArray_exposer.def( "typeName" , typeName_function_value , "" ); } { //::SireVol::CoordGroupArray::update typedef void ( ::SireVol::CoordGroupArray::*update_function_type)( ::quint32,::SireVol::CoordGroup const & ) ; update_function_type update_function_value( &::SireVol::CoordGroupArray::update ); CoordGroupArray_exposer.def( "update" , update_function_value , ( bp::arg("i"), bp::arg("cgroup") ) , "Update the CoordGroup at index i so that it is equal to cgroup. Note\nthat cgroup must contain the same number of coordinates as the existing\nCoordGroup at this index\nThrow: SireError::invalid_index\nThrow: SireError::incompatible_error\n" ); } { //::SireVol::CoordGroupArray::update typedef void ( ::SireVol::CoordGroupArray::*update_function_type)( ::quint32,::QVector< SireMaths::Vector > const & ) ; update_function_type update_function_value( &::SireVol::CoordGroupArray::update ); CoordGroupArray_exposer.def( "update" , update_function_value , ( bp::arg("i"), bp::arg("coords") ) , "Update the CoordGroup at index i so that it has coordinates coords\nThere must contain the same number of coordinates as the existing\nCoordGroup at this index\nThrow: SireError::invalid_index\nThrow: SireError::incompatible_error\n" ); } { //::SireVol::CoordGroupArray::update typedef void ( ::SireVol::CoordGroupArray::*update_function_type)( ::quint32,::SireMaths::Vector const *,int ) ; update_function_type update_function_value( &::SireVol::CoordGroupArray::update ); CoordGroupArray_exposer.def( "update" , update_function_value , ( bp::arg("i"), bp::arg("coords"), bp::arg("ncoords") ) , "Update the CoordGroup at index i so that it has coordinates coords\n(there are ncoords coordinates in this array)\nThere must contain the same number of coordinates as the existing\nCoordGroup at this index\nThrow: SireError::invalid_index\nThrow: SireError::incompatible_error\n" ); } { //::SireVol::CoordGroupArray::what typedef char const * ( ::SireVol::CoordGroupArray::*what_function_type)( ) const; what_function_type what_function_value( &::SireVol::CoordGroupArray::what ); CoordGroupArray_exposer.def( "what" , what_function_value , "" ); } CoordGroupArray_exposer.staticmethod( "typeName" ); CoordGroupArray_exposer.def( "__copy__", &__copy__); CoordGroupArray_exposer.def( "__deepcopy__", &__copy__); CoordGroupArray_exposer.def( "clone", &__copy__); CoordGroupArray_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireVol::CoordGroupArray >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); CoordGroupArray_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireVol::CoordGroupArray >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); CoordGroupArray_exposer.def( "__str__", &__str__< ::SireVol::CoordGroupArray > ); CoordGroupArray_exposer.def( "__repr__", &__str__< ::SireVol::CoordGroupArray > ); CoordGroupArray_exposer.def( "__len__", &__len_size< ::SireVol::CoordGroupArray > ); } }
void register_CLJ14Group_class(){ { //::SireMM::CLJ14Group typedef bp::class_< SireMM::CLJ14Group > CLJ14Group_exposer_t; CLJ14Group_exposer_t CLJ14Group_exposer = CLJ14Group_exposer_t( "CLJ14Group", bp::init< >() ); bp::scope CLJ14Group_scope( CLJ14Group_exposer ); CLJ14Group_exposer.def( bp::init< SireMol::MoleculeView const &, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("molecule"), bp::arg("map")=SireBase::PropertyMap() )) ); CLJ14Group_exposer.def( bp::init< SireMol::MoleculeView const &, SireMM::CLJFunction::COMBINING_RULES, bool, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("molecule"), bp::arg("combining_rules"), bp::arg("is_strict"), bp::arg("map")=SireBase::PropertyMap() )) ); CLJ14Group_exposer.def( bp::init< SireMM::CLJ14Group const & >(( bp::arg("other") )) ); { //::SireMM::CLJ14Group::add typedef void ( ::SireMM::CLJ14Group::*add_function_type )( ::SireMol::MoleculeView const & ) ; add_function_type add_function_value( &::SireMM::CLJ14Group::add ); CLJ14Group_exposer.def( "add" , add_function_value , ( bp::arg("new_molecule") ) ); } { //::SireMM::CLJ14Group::add typedef void ( ::SireMM::CLJ14Group::*add_function_type )( ::SireMol::AtomSelection const & ) ; add_function_type add_function_value( &::SireMM::CLJ14Group::add ); CLJ14Group_exposer.def( "add" , add_function_value , ( bp::arg("new_selection") ) ); } { //::SireMM::CLJ14Group::combiningRules typedef ::SireMM::CLJFunction::COMBINING_RULES ( ::SireMM::CLJ14Group::*combiningRules_function_type )( ) const; combiningRules_function_type combiningRules_function_value( &::SireMM::CLJ14Group::combiningRules ); CLJ14Group_exposer.def( "combiningRules" , combiningRules_function_value ); } { //::SireMM::CLJ14Group::energy typedef ::boost::tuples::tuple< double, double, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type > ( ::SireMM::CLJ14Group::*energy_function_type )( ) ; energy_function_type energy_function_value( &::SireMM::CLJ14Group::energy ); CLJ14Group_exposer.def( "energy" , energy_function_value ); } { //::SireMM::CLJ14Group::isNull typedef bool ( ::SireMM::CLJ14Group::*isNull_function_type )( ) const; isNull_function_type isNull_function_value( &::SireMM::CLJ14Group::isNull ); CLJ14Group_exposer.def( "isNull" , isNull_function_value ); } { //::SireMM::CLJ14Group::isStrict typedef bool ( ::SireMM::CLJ14Group::*isStrict_function_type )( ) const; isStrict_function_type isStrict_function_value( &::SireMM::CLJ14Group::isStrict ); CLJ14Group_exposer.def( "isStrict" , isStrict_function_value ); } { //::SireMM::CLJ14Group::molecule typedef ::SireMol::MoleculeView const & ( ::SireMM::CLJ14Group::*molecule_function_type )( ) const; molecule_function_type molecule_function_value( &::SireMM::CLJ14Group::molecule ); CLJ14Group_exposer.def( "molecule" , molecule_function_value , bp::return_value_policy<bp::clone_const_reference>() ); } { //::SireMM::CLJ14Group::mustNowRecalculateFromScratch typedef void ( ::SireMM::CLJ14Group::*mustNowRecalculateFromScratch_function_type )( ) ; mustNowRecalculateFromScratch_function_type mustNowRecalculateFromScratch_function_value( &::SireMM::CLJ14Group::mustNowRecalculateFromScratch ); CLJ14Group_exposer.def( "mustNowRecalculateFromScratch" , mustNowRecalculateFromScratch_function_value ); } { //::SireMM::CLJ14Group::mustReallyRecalculateFromScratch typedef void ( ::SireMM::CLJ14Group::*mustReallyRecalculateFromScratch_function_type )( ) ; mustReallyRecalculateFromScratch_function_type mustReallyRecalculateFromScratch_function_value( &::SireMM::CLJ14Group::mustReallyRecalculateFromScratch ); CLJ14Group_exposer.def( "mustReallyRecalculateFromScratch" , mustReallyRecalculateFromScratch_function_value ); } CLJ14Group_exposer.def( bp::self != bp::self ); { //::SireMM::CLJ14Group::operator= typedef ::SireMM::CLJ14Group & ( ::SireMM::CLJ14Group::*assign_function_type )( ::SireMM::CLJ14Group const & ) ; assign_function_type assign_function_value( &::SireMM::CLJ14Group::operator= ); CLJ14Group_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() ); } CLJ14Group_exposer.def( bp::self == bp::self ); { //::SireMM::CLJ14Group::propertyMap typedef ::SireBase::PropertyMap ( ::SireMM::CLJ14Group::*propertyMap_function_type )( ) const; propertyMap_function_type propertyMap_function_value( &::SireMM::CLJ14Group::propertyMap ); CLJ14Group_exposer.def( "propertyMap" , propertyMap_function_value ); } { //::SireMM::CLJ14Group::recalculatingFromScratch typedef bool ( ::SireMM::CLJ14Group::*recalculatingFromScratch_function_type )( ) const; recalculatingFromScratch_function_type recalculatingFromScratch_function_value( &::SireMM::CLJ14Group::recalculatingFromScratch ); CLJ14Group_exposer.def( "recalculatingFromScratch" , recalculatingFromScratch_function_value ); } { //::SireMM::CLJ14Group::remove typedef void ( ::SireMM::CLJ14Group::*remove_function_type )( ::SireMol::AtomSelection const & ) ; remove_function_type remove_function_value( &::SireMM::CLJ14Group::remove ); CLJ14Group_exposer.def( "remove" , remove_function_value , ( bp::arg("new_selection") ) ); } { //::SireMM::CLJ14Group::remove typedef void ( ::SireMM::CLJ14Group::*remove_function_type )( ::SireMol::MoleculeView const & ) ; remove_function_type remove_function_value( &::SireMM::CLJ14Group::remove ); CLJ14Group_exposer.def( "remove" , remove_function_value , ( bp::arg("new_molecule") ) ); } { //::SireMM::CLJ14Group::setArithmeticCombiningRules typedef void ( ::SireMM::CLJ14Group::*setArithmeticCombiningRules_function_type )( bool ) ; setArithmeticCombiningRules_function_type setArithmeticCombiningRules_function_value( &::SireMM::CLJ14Group::setArithmeticCombiningRules ); CLJ14Group_exposer.def( "setArithmeticCombiningRules" , setArithmeticCombiningRules_function_value , ( bp::arg("on") ) ); } { //::SireMM::CLJ14Group::setCombiningRules typedef void ( ::SireMM::CLJ14Group::*setCombiningRules_function_type )( ::SireMM::CLJFunction::COMBINING_RULES ) ; setCombiningRules_function_type setCombiningRules_function_value( &::SireMM::CLJ14Group::setCombiningRules ); CLJ14Group_exposer.def( "setCombiningRules" , setCombiningRules_function_value , ( bp::arg("rules") ) ); } { //::SireMM::CLJ14Group::setGeometricCombiningRules typedef void ( ::SireMM::CLJ14Group::*setGeometricCombiningRules_function_type )( bool ) ; setGeometricCombiningRules_function_type setGeometricCombiningRules_function_value( &::SireMM::CLJ14Group::setGeometricCombiningRules ); CLJ14Group_exposer.def( "setGeometricCombiningRules" , setGeometricCombiningRules_function_value , ( bp::arg("on") ) ); } { //::SireMM::CLJ14Group::setStrict typedef bool ( ::SireMM::CLJ14Group::*setStrict_function_type )( bool ) ; setStrict_function_type setStrict_function_value( &::SireMM::CLJ14Group::setStrict ); CLJ14Group_exposer.def( "setStrict" , setStrict_function_value , ( bp::arg("isstrict") ) ); } { //::SireMM::CLJ14Group::toString typedef ::QString ( ::SireMM::CLJ14Group::*toString_function_type )( ) const; toString_function_type toString_function_value( &::SireMM::CLJ14Group::toString ); CLJ14Group_exposer.def( "toString" , toString_function_value ); } { //::SireMM::CLJ14Group::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireMM::CLJ14Group::typeName ); CLJ14Group_exposer.def( "typeName" , typeName_function_value ); } { //::SireMM::CLJ14Group::update typedef void ( ::SireMM::CLJ14Group::*update_function_type )( ::SireMol::MoleculeView const & ) ; update_function_type update_function_value( &::SireMM::CLJ14Group::update ); CLJ14Group_exposer.def( "update" , update_function_value , ( bp::arg("new_molecule") ) ); } { //::SireMM::CLJ14Group::updateSelection typedef void ( ::SireMM::CLJ14Group::*updateSelection_function_type )( ::SireMol::AtomSelection const & ) ; updateSelection_function_type updateSelection_function_value( &::SireMM::CLJ14Group::updateSelection ); CLJ14Group_exposer.def( "updateSelection" , updateSelection_function_value , ( bp::arg("selection") ) ); } { //::SireMM::CLJ14Group::usingArithmeticCombiningRules typedef bool ( ::SireMM::CLJ14Group::*usingArithmeticCombiningRules_function_type )( ) const; usingArithmeticCombiningRules_function_type usingArithmeticCombiningRules_function_value( &::SireMM::CLJ14Group::usingArithmeticCombiningRules ); CLJ14Group_exposer.def( "usingArithmeticCombiningRules" , usingArithmeticCombiningRules_function_value ); } { //::SireMM::CLJ14Group::usingGeometricCombiningRules typedef bool ( ::SireMM::CLJ14Group::*usingGeometricCombiningRules_function_type )( ) const; usingGeometricCombiningRules_function_type usingGeometricCombiningRules_function_value( &::SireMM::CLJ14Group::usingGeometricCombiningRules ); CLJ14Group_exposer.def( "usingGeometricCombiningRules" , usingGeometricCombiningRules_function_value ); } { //::SireMM::CLJ14Group::what typedef char const * ( ::SireMM::CLJ14Group::*what_function_type )( ) const; what_function_type what_function_value( &::SireMM::CLJ14Group::what ); CLJ14Group_exposer.def( "what" , what_function_value ); } { //::SireMM::CLJ14Group::wouldChangeProperties typedef bool ( ::SireMM::CLJ14Group::*wouldChangeProperties_function_type )( ::SireBase::PropertyMap const & ) const; wouldChangeProperties_function_type wouldChangeProperties_function_value( &::SireMM::CLJ14Group::wouldChangeProperties ); CLJ14Group_exposer.def( "wouldChangeProperties" , wouldChangeProperties_function_value , ( bp::arg("map") ) ); } CLJ14Group_exposer.staticmethod( "typeName" ); CLJ14Group_exposer.def( "__copy__", &__copy__); CLJ14Group_exposer.def( "__deepcopy__", &__copy__); CLJ14Group_exposer.def( "clone", &__copy__); CLJ14Group_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::CLJ14Group >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); CLJ14Group_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::CLJ14Group >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); CLJ14Group_exposer.def( "__str__", &__str__< ::SireMM::CLJ14Group > ); CLJ14Group_exposer.def( "__repr__", &__str__< ::SireMM::CLJ14Group > ); } }
void register_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_IDAssigner_class(){ { //::SireSystem::IDAssigner typedef bp::class_< SireSystem::IDAssigner, bp::bases< SireBase::Property > > IDAssigner_exposer_t; IDAssigner_exposer_t IDAssigner_exposer = IDAssigner_exposer_t( "IDAssigner", "This class uses the machinery of the identity point to\npick out molecules that are associated with identity points.\nThis is useful if you want to monitor a property or energy,\nbut dont actually want to change the coordinates of atoms\n\nAuthor: Christopher Woods\n", bp::init< >("Constructor") ); bp::scope IDAssigner_scope( IDAssigner_exposer ); IDAssigner_exposer.def( bp::init< SireFF::PointRef const &, SireMol::MoleculeGroup const &, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("point"), bp::arg("molgroup"), bp::arg("map")=SireBase::PropertyMap() ), "Constructor") ); IDAssigner_exposer.def( bp::init< QVector< SireBase::PropPtr< SireFF::Point > > const &, SireMol::MoleculeGroup const &, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("points"), bp::arg("molgroup"), bp::arg("map")=SireBase::PropertyMap() ), "Construct to find the identity of the molecules from\nmolgroup that match the points in points -\nthis creates a list of n molecules, where the ith molecule\nis matched to the ith point") ); IDAssigner_exposer.def( bp::init< SireFF::PointRef const &, SireMol::MoleculeGroup const &, SireVol::Space const &, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("point"), bp::arg("molgroup"), bp::arg("space"), bp::arg("map")=SireBase::PropertyMap() ), "Constructor") ); IDAssigner_exposer.def( bp::init< QVector< SireBase::PropPtr< SireFF::Point > > const &, SireMol::MoleculeGroup const &, SireVol::Space const &, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("points"), bp::arg("molgroup"), bp::arg("space"), bp::arg("map")=SireBase::PropertyMap() ), "Construct to find the identity of the molecules from\nmolgroup that match the points in points -\nthis creates a list of n molecules, where the ith molecule\nis matched to the ith point") ); IDAssigner_exposer.def( bp::init< SireSystem::IDAssigner const & >(( bp::arg("other") ), "Copy constructor") ); { //::SireSystem::IDAssigner::identifiedMolecules typedef ::QVector< SireMol::PartialMolecule > ( ::SireSystem::IDAssigner::*identifiedMolecules_function_type)( ) const; identifiedMolecules_function_type identifiedMolecules_function_value( &::SireSystem::IDAssigner::identifiedMolecules ); IDAssigner_exposer.def( "identifiedMolecules" , identifiedMolecules_function_value , "Returns the list of identified molecules from the system,\nwhich are returned in the same order as the list of identity points\n" ); } { //::SireSystem::IDAssigner::moleculeGroup typedef ::SireMol::MoleculeGroup const & ( ::SireSystem::IDAssigner::*moleculeGroup_function_type)( ) const; moleculeGroup_function_type moleculeGroup_function_value( &::SireSystem::IDAssigner::moleculeGroup ); IDAssigner_exposer.def( "moleculeGroup" , moleculeGroup_function_value , bp::return_value_policy<bp::clone_const_reference>() , "Return the molecule group operated on by this constraint" ); } { //::SireSystem::IDAssigner::nPoints typedef int ( ::SireSystem::IDAssigner::*nPoints_function_type)( ) const; nPoints_function_type nPoints_function_value( &::SireSystem::IDAssigner::nPoints ); IDAssigner_exposer.def( "nPoints" , nPoints_function_value , "Return the number of identity points (and thus the number of\nidentified molecules)" ); } IDAssigner_exposer.def( bp::self != bp::self ); { //::SireSystem::IDAssigner::operator= typedef ::SireSystem::IDAssigner & ( ::SireSystem::IDAssigner::*assign_function_type)( ::SireSystem::IDAssigner const & ) ; assign_function_type assign_function_value( &::SireSystem::IDAssigner::operator= ); IDAssigner_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() , "" ); } IDAssigner_exposer.def( bp::self == bp::self ); { //::SireSystem::IDAssigner::points typedef ::QVector< SireBase::PropPtr< SireFF::Point > > ( ::SireSystem::IDAssigner::*points_function_type)( ) const; points_function_type points_function_value( &::SireSystem::IDAssigner::points ); IDAssigner_exposer.def( "points" , points_function_value , "Return the points used to identify the molecules" ); } { //::SireSystem::IDAssigner::propertyMap typedef ::SireBase::PropertyMap const & ( ::SireSystem::IDAssigner::*propertyMap_function_type)( ) const; propertyMap_function_type propertyMap_function_value( &::SireSystem::IDAssigner::propertyMap ); IDAssigner_exposer.def( "propertyMap" , propertyMap_function_value , bp::return_value_policy< bp::copy_const_reference >() , "Return the property map used to find the properties required\nby this constraint" ); } { //::SireSystem::IDAssigner::space typedef ::SireVol::Space const & ( ::SireSystem::IDAssigner::*space_function_type)( ) const; space_function_type space_function_value( &::SireSystem::IDAssigner::space ); IDAssigner_exposer.def( "space" , space_function_value , bp::return_value_policy<bp::clone_const_reference>() , "Return the space used to calculate distances between the molecules\nand the identity points" ); } { //::SireSystem::IDAssigner::toString typedef ::QString ( ::SireSystem::IDAssigner::*toString_function_type)( ) const; toString_function_type toString_function_value( &::SireSystem::IDAssigner::toString ); IDAssigner_exposer.def( "toString" , toString_function_value , "Return a string representation of this assigner" ); } { //::SireSystem::IDAssigner::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireSystem::IDAssigner::typeName ); IDAssigner_exposer.def( "typeName" , typeName_function_value , "" ); } { //::SireSystem::IDAssigner::update typedef void ( ::SireSystem::IDAssigner::*update_function_type)( ::SireSystem::System const & ) ; update_function_type update_function_value( &::SireSystem::IDAssigner::update ); IDAssigner_exposer.def( "update" , update_function_value , ( bp::arg("system") ) , "Update the assigner with the passed system." ); } { //::SireSystem::IDAssigner::what typedef char const * ( ::SireSystem::IDAssigner::*what_function_type)( ) const; what_function_type what_function_value( &::SireSystem::IDAssigner::what ); IDAssigner_exposer.def( "what" , what_function_value , "" ); } IDAssigner_exposer.staticmethod( "typeName" ); IDAssigner_exposer.def( "__copy__", &__copy__); IDAssigner_exposer.def( "__deepcopy__", &__copy__); IDAssigner_exposer.def( "clone", &__copy__); IDAssigner_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireSystem::IDAssigner >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); IDAssigner_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireSystem::IDAssigner >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); IDAssigner_exposer.def( "__str__", &__str__< ::SireSystem::IDAssigner > ); IDAssigner_exposer.def( "__repr__", &__str__< ::SireSystem::IDAssigner > ); } }
void register_PackedArray2D_int_Array_class(){ { //::SireBase::detail::PackedArray2D_Array< int > typedef bp::class_< SireBase::detail::PackedArray2D_Array< int > > PackedArray2D_int_Array_exposer_t; PackedArray2D_int_Array_exposer_t PackedArray2D_int_Array_exposer = PackedArray2D_int_Array_exposer_t( "PackedArray2D_int_Array", bp::init< >() ); bp::scope PackedArray2D_int_Array_scope( PackedArray2D_int_Array_exposer ); PackedArray2D_int_Array_exposer.def( bp::init< quint32 >(( bp::arg("sz") )) ); PackedArray2D_int_Array_exposer.def( bp::init< quint32, int const & >(( bp::arg("sz"), bp::arg("value") )) ); PackedArray2D_int_Array_exposer.def( bp::init< QVector< int > const & >(( bp::arg("values") )) ); PackedArray2D_int_Array_exposer.def( bp::init< SireBase::detail::PackedArray2D_Array< int > const & >(( bp::arg("other") )) ); { //::SireBase::detail::PackedArray2D_Array< int >::assertValidIndex typedef SireBase::detail::PackedArray2D_Array< int > exported_class_t; typedef void ( ::SireBase::detail::PackedArray2D_Array< int >::*assertValidIndex_function_type )( ::quint32 ) const; assertValidIndex_function_type assertValidIndex_function_value( &::SireBase::detail::PackedArray2D_Array< int >::assertValidIndex ); PackedArray2D_int_Array_exposer.def( "assertValidIndex" , assertValidIndex_function_value , ( bp::arg("i") ) ); } { //::SireBase::detail::PackedArray2D_Array< int >::at typedef SireBase::detail::PackedArray2D_Array< int > exported_class_t; typedef int const & ( ::SireBase::detail::PackedArray2D_Array< int >::*at_function_type )( ::quint32 ) const; at_function_type at_function_value( &::SireBase::detail::PackedArray2D_Array< int >::at ); PackedArray2D_int_Array_exposer.def( "at" , at_function_value , ( bp::arg("i") ) , bp::return_value_policy< bp::copy_const_reference >() ); } { //::SireBase::detail::PackedArray2D_Array< int >::count typedef SireBase::detail::PackedArray2D_Array< int > exported_class_t; typedef int ( ::SireBase::detail::PackedArray2D_Array< int >::*count_function_type )( ) const; count_function_type count_function_value( &::SireBase::detail::PackedArray2D_Array< int >::count ); PackedArray2D_int_Array_exposer.def( "count" , count_function_value ); } { //::SireBase::detail::PackedArray2D_Array< int >::isEmpty typedef SireBase::detail::PackedArray2D_Array< int > exported_class_t; typedef bool ( ::SireBase::detail::PackedArray2D_Array< int >::*isEmpty_function_type )( ) const; isEmpty_function_type isEmpty_function_value( &::SireBase::detail::PackedArray2D_Array< int >::isEmpty ); PackedArray2D_int_Array_exposer.def( "isEmpty" , isEmpty_function_value ); } { //::SireBase::detail::PackedArray2D_Array< int >::nValues typedef SireBase::detail::PackedArray2D_Array< int > exported_class_t; typedef int ( ::SireBase::detail::PackedArray2D_Array< int >::*nValues_function_type )( ) const; nValues_function_type nValues_function_value( &::SireBase::detail::PackedArray2D_Array< int >::nValues ); PackedArray2D_int_Array_exposer.def( "nValues" , nValues_function_value ); } PackedArray2D_int_Array_exposer.def( bp::self != bp::self ); { //::SireBase::detail::PackedArray2D_Array< int >::operator= typedef SireBase::detail::PackedArray2D_Array< int > exported_class_t; typedef ::SireBase::detail::PackedArray2D_Array< int > & ( ::SireBase::detail::PackedArray2D_Array< int >::*assign_function_type )( ::SireBase::detail::PackedArray2D_Array< int > const & ) ; assign_function_type assign_function_value( &::SireBase::detail::PackedArray2D_Array< int >::operator= ); PackedArray2D_int_Array_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() ); } PackedArray2D_int_Array_exposer.def( bp::self == bp::self ); { //::SireBase::detail::PackedArray2D_Array< int >::operator[] typedef SireBase::detail::PackedArray2D_Array< int > exported_class_t; typedef int const & ( ::SireBase::detail::PackedArray2D_Array< int >::*__getitem___function_type )( ::quint32 ) const; __getitem___function_type __getitem___function_value( &::SireBase::detail::PackedArray2D_Array< int >::operator[] ); PackedArray2D_int_Array_exposer.def( "__getitem__" , __getitem___function_value , ( bp::arg("i") ) , bp::return_value_policy< bp::copy_const_reference >() ); } { //::SireBase::detail::PackedArray2D_Array< int >::operator[] typedef SireBase::detail::PackedArray2D_Array< int > exported_class_t; typedef int & ( ::SireBase::detail::PackedArray2D_Array< int >::*__getitem___function_type )( ::quint32 ) ; __getitem___function_type __getitem___function_value( &::SireBase::detail::PackedArray2D_Array< int >::operator[] ); PackedArray2D_int_Array_exposer.def( "__getitem__" , __getitem___function_value , ( bp::arg("i") ) , bp::return_value_policy< bp::copy_non_const_reference >() ); } { //::SireBase::detail::PackedArray2D_Array< int >::size typedef SireBase::detail::PackedArray2D_Array< int > exported_class_t; typedef int ( ::SireBase::detail::PackedArray2D_Array< int >::*size_function_type )( ) const; size_function_type size_function_value( &::SireBase::detail::PackedArray2D_Array< int >::size ); PackedArray2D_int_Array_exposer.def( "size" , size_function_value ); } { //::SireBase::detail::PackedArray2D_Array< int >::toQVector typedef SireBase::detail::PackedArray2D_Array< int > exported_class_t; typedef ::QVector< int > ( ::SireBase::detail::PackedArray2D_Array< int >::*toQVector_function_type )( ) const; toQVector_function_type toQVector_function_value( &::SireBase::detail::PackedArray2D_Array< int >::toQVector ); PackedArray2D_int_Array_exposer.def( "toQVector" , toQVector_function_value ); } { //::SireBase::detail::PackedArray2D_Array< int >::toString typedef SireBase::detail::PackedArray2D_Array< int > exported_class_t; typedef ::QString ( ::SireBase::detail::PackedArray2D_Array< int >::*toString_function_type )( ) const; toString_function_type toString_function_value( &::SireBase::detail::PackedArray2D_Array< int >::toString ); PackedArray2D_int_Array_exposer.def( "toString" , toString_function_value ); } { //::SireBase::detail::PackedArray2D_Array< int >::update typedef SireBase::detail::PackedArray2D_Array< int > exported_class_t; typedef void ( ::SireBase::detail::PackedArray2D_Array< int >::*update_function_type )( ::SireBase::detail::PackedArray2D_Array< int > const & ) ; update_function_type update_function_value( &::SireBase::detail::PackedArray2D_Array< int >::update ); PackedArray2D_int_Array_exposer.def( "update" , update_function_value , ( bp::arg("other") ) ); } PackedArray2D_int_Array_exposer.def( "__copy__", &__copy__); PackedArray2D_int_Array_exposer.def( "__deepcopy__", &__copy__); PackedArray2D_int_Array_exposer.def( "clone", &__copy__); PackedArray2D_int_Array_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireBase::detail::PackedArray2D_Array<int> >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); PackedArray2D_int_Array_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireBase::detail::PackedArray2D_Array<int> >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); PackedArray2D_int_Array_exposer.def( "__str__", &__str__< ::SireBase::detail::PackedArray2D_Array<int> > ); PackedArray2D_int_Array_exposer.def( "__repr__", &__str__< ::SireBase::detail::PackedArray2D_Array<int> > ); PackedArray2D_int_Array_exposer.def( "__len__", &__len_size< ::SireBase::detail::PackedArray2D_Array<int> > ); } }
void register_CloseMols_class() { { //::SireSystem::CloseMols typedef bp::class_< SireSystem::CloseMols > CloseMols_exposer_t; CloseMols_exposer_t CloseMols_exposer = CloseMols_exposer_t( "CloseMols", bp::init< >() ); bp::scope CloseMols_scope( CloseMols_exposer ); CloseMols_exposer.def( bp::init< SireFF::PointRef const &, SireMol::MoleculeGroup const &, bp::optional< int, SireBase::PropertyMap const & > >(( bp::arg("point"), bp::arg("molgroup"), bp::arg("nclosest")=(int)(1), bp::arg("map")=SireBase::PropertyMap() )) ); CloseMols_exposer.def( bp::init< SireFF::PointRef const &, SireMol::MoleculeGroup const &, SireVol::Space const &, bp::optional< int, SireBase::PropertyMap const & > >(( bp::arg("point"), bp::arg("molgroup"), bp::arg("space"), bp::arg("nclosest")=(int)(1), bp::arg("map")=SireBase::PropertyMap() )) ); CloseMols_exposer.def( bp::init< SireSystem::CloseMols const & >(( bp::arg("other") )) ); { //::SireSystem::CloseMols::closeMolecules typedef ::QHash< SireMol::MolNum, double > const & ( ::SireSystem::CloseMols::*closeMolecules_function_type )( ) const; closeMolecules_function_type closeMolecules_function_value( &::SireSystem::CloseMols::closeMolecules ); CloseMols_exposer.def( "closeMolecules" , closeMolecules_function_value , bp::return_value_policy< bp::copy_const_reference >() ); } { //::SireSystem::CloseMols::isClose typedef bool ( ::SireSystem::CloseMols::*isClose_function_type )( ::SireMol::MolNum ) const; isClose_function_type isClose_function_value( &::SireSystem::CloseMols::isClose ); CloseMols_exposer.def( "isClose" , isClose_function_value , ( bp::arg("molnum") ) ); } { //::SireSystem::CloseMols::moleculeGroup typedef ::SireMol::MoleculeGroup const & ( ::SireSystem::CloseMols::*moleculeGroup_function_type )( ) const; moleculeGroup_function_type moleculeGroup_function_value( &::SireSystem::CloseMols::moleculeGroup ); CloseMols_exposer.def( "moleculeGroup" , moleculeGroup_function_value , bp::return_value_policy<bp::clone_const_reference>() ); } { //::SireSystem::CloseMols::nClosest typedef int ( ::SireSystem::CloseMols::*nClosest_function_type )( ) const; nClosest_function_type nClosest_function_value( &::SireSystem::CloseMols::nClosest ); CloseMols_exposer.def( "nClosest" , nClosest_function_value ); } CloseMols_exposer.def( bp::self != bp::self ); { //::SireSystem::CloseMols::operator= typedef ::SireSystem::CloseMols & ( ::SireSystem::CloseMols::*assign_function_type )( ::SireSystem::CloseMols const & ) ; assign_function_type assign_function_value( &::SireSystem::CloseMols::operator= ); CloseMols_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() ); } CloseMols_exposer.def( bp::self == bp::self ); { //::SireSystem::CloseMols::point typedef ::SireFF::Point const & ( ::SireSystem::CloseMols::*point_function_type )( ) const; point_function_type point_function_value( &::SireSystem::CloseMols::point ); CloseMols_exposer.def( "point" , point_function_value , bp::return_value_policy<bp::clone_const_reference>() ); } { //::SireSystem::CloseMols::propertyMap typedef ::SireBase::PropertyMap const & ( ::SireSystem::CloseMols::*propertyMap_function_type )( ) const; propertyMap_function_type propertyMap_function_value( &::SireSystem::CloseMols::propertyMap ); CloseMols_exposer.def( "propertyMap" , propertyMap_function_value , bp::return_value_policy< bp::copy_const_reference >() ); } { //::SireSystem::CloseMols::space typedef ::SireVol::Space const & ( ::SireSystem::CloseMols::*space_function_type )( ) const; space_function_type space_function_value( &::SireSystem::CloseMols::space ); CloseMols_exposer.def( "space" , space_function_value , bp::return_value_policy<bp::clone_const_reference>() ); } { //::SireSystem::CloseMols::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireSystem::CloseMols::typeName ); CloseMols_exposer.def( "typeName" , typeName_function_value ); } { //::SireSystem::CloseMols::update typedef bool ( ::SireSystem::CloseMols::*update_function_type )( ::SireSystem::System const & ) ; update_function_type update_function_value( &::SireSystem::CloseMols::update ); CloseMols_exposer.def( "update" , update_function_value , ( bp::arg("system") ) ); } { //::SireSystem::CloseMols::update typedef bool ( ::SireSystem::CloseMols::*update_function_type )( ::SireSystem::System const &,::SireMol::MolNum ) ; update_function_type update_function_value( &::SireSystem::CloseMols::update ); CloseMols_exposer.def( "update" , update_function_value , ( bp::arg("system"), bp::arg("changed_mol") ) ); } { //::SireSystem::CloseMols::update typedef bool ( ::SireSystem::CloseMols::*update_function_type )( ::SireSystem::System const &,::SireMol::Molecules const & ) ; update_function_type update_function_value( &::SireSystem::CloseMols::update ); CloseMols_exposer.def( "update" , update_function_value , ( bp::arg("system"), bp::arg("molecules") ) ); } { //::SireSystem::CloseMols::what typedef char const * ( ::SireSystem::CloseMols::*what_function_type )( ) const; what_function_type what_function_value( &::SireSystem::CloseMols::what ); CloseMols_exposer.def( "what" , what_function_value ); } CloseMols_exposer.staticmethod( "typeName" ); CloseMols_exposer.def( "__copy__", &__copy__); CloseMols_exposer.def( "__deepcopy__", &__copy__); CloseMols_exposer.def( "clone", &__copy__); CloseMols_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireSystem::CloseMols >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); CloseMols_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireSystem::CloseMols >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); CloseMols_exposer.def( "__str__", &pvt_get_name); CloseMols_exposer.def( "__repr__", &pvt_get_name); } }
void register_Center_class(){ { //::SireFF::Center typedef bp::class_< SireFF::Center, bp::bases< SireFF::Point, SireBase::Property > > Center_exposer_t; Center_exposer_t Center_exposer = Center_exposer_t( "Center", "This point returns the center of a view of a molecule, or group\nof molecules", bp::init< >("Constructor") ); bp::scope Center_scope( Center_exposer ); Center_exposer.def( bp::init< SireMol::MoleculeView const &, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("molview"), bp::arg("map")=SireBase::PropertyMap() ), "Construct to get the center of the molecule view molview using the\npassed property map to find the required properties\nThrow: SireBase::missing_property\nThrow: SireError::invalid_cast\n") ); Center_exposer.def( bp::init< SireMol::Molecules const &, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("molecules"), bp::arg("map")=SireBase::PropertyMap() ), "Construct to get the center of the molecules in molecules, using the\npassed property map to find the required properties\nThrow: SireBase::missing_property\nThrow: SireError::invalid_cast\n") ); Center_exposer.def( bp::init< SireFF::Center const & >(( bp::arg("other") ), "Copy constructor") ); { //::SireFF::Center::addForce typedef bool ( ::SireFF::Center::*addForce_function_type)( ::SireFF::MolForceTable &,::SireMaths::Vector const & ) const; addForce_function_type addForce_function_value( &::SireFF::Center::addForce ); Center_exposer.def( "addForce" , addForce_function_value , ( bp::arg("molforces"), bp::arg("force") ) , "Decompose the force force acting on this point from the\nmolecule whose forces are in molforces and add the\nforce onto the table" ); } { //::SireFF::Center::addForce typedef bool ( ::SireFF::Center::*addForce_function_type)( ::SireFF::ForceTable &,::SireMaths::Vector const & ) const; addForce_function_type addForce_function_value( &::SireFF::Center::addForce ); Center_exposer.def( "addForce" , addForce_function_value , ( bp::arg("forces"), bp::arg("force") ) , "Decompose the force force into the forces acting on\nthe molecules that contribute to this point and add those\nforces onto the table forces" ); } { //::SireFF::Center::contains typedef bool ( ::SireFF::Center::*contains_function_type)( ::SireMol::MolNum ) const; contains_function_type contains_function_value( &::SireFF::Center::contains ); Center_exposer.def( "contains" , contains_function_value , ( bp::arg("molnum") ) , "Return whether or not the molecule with number molnum is\nneeded to generate this point" ); } { //::SireFF::Center::contains typedef bool ( ::SireFF::Center::*contains_function_type)( ::SireMol::MolID const & ) const; contains_function_type contains_function_value( &::SireFF::Center::contains ); Center_exposer.def( "contains" , contains_function_value , ( bp::arg("molid") ) , "Return whether or not this molecule with ID molid is\nneeded to generate this point" ); } { //::SireFF::Center::isExtraMoleculePoint typedef bool ( ::SireFF::Center::*isExtraMoleculePoint_function_type)( ) const; isExtraMoleculePoint_function_type isExtraMoleculePoint_function_value( &::SireFF::Center::isExtraMoleculePoint ); Center_exposer.def( "isExtraMoleculePoint" , isExtraMoleculePoint_function_value , "Return whether or not this is an extramolecular point (it is independent\nof the coordinates of atoms in any molecule, i.e. it is just a point in space)" ); } { //::SireFF::Center::isInterMoleculePoint typedef bool ( ::SireFF::Center::*isInterMoleculePoint_function_type)( ) const; isInterMoleculePoint_function_type isInterMoleculePoint_function_value( &::SireFF::Center::isInterMoleculePoint ); Center_exposer.def( "isInterMoleculePoint" , isInterMoleculePoint_function_value , "Return whether or not this is an intermolecular point (it depends on\ncoordinates of atoms from than one molecule)" ); } { //::SireFF::Center::isIntraMoleculePoint typedef bool ( ::SireFF::Center::*isIntraMoleculePoint_function_type)( ) const; isIntraMoleculePoint_function_type isIntraMoleculePoint_function_value( &::SireFF::Center::isIntraMoleculePoint ); Center_exposer.def( "isIntraMoleculePoint" , isIntraMoleculePoint_function_value , "Return whether this is an intramolecular point (it depends on coordinates\nof atoms in just one molecule)" ); } { //::SireFF::Center::molecules typedef ::SireMol::Molecules ( ::SireFF::Center::*molecules_function_type)( ) const; molecules_function_type molecules_function_value( &::SireFF::Center::molecules ); Center_exposer.def( "molecules" , molecules_function_value , "Return all of the molecules used to generate this point" ); } { //::SireFF::Center::nMolecules typedef int ( ::SireFF::Center::*nMolecules_function_type)( ) const; nMolecules_function_type nMolecules_function_value( &::SireFF::Center::nMolecules ); Center_exposer.def( "nMolecules" , nMolecules_function_value , "Return the number of molecules needed to generate this point" ); } Center_exposer.def( bp::self != bp::self ); { //::SireFF::Center::operator= typedef ::SireFF::Center & ( ::SireFF::Center::*assign_function_type)( ::SireFF::Center const & ) ; assign_function_type assign_function_value( &::SireFF::Center::operator= ); Center_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() , "" ); } Center_exposer.def( bp::self == bp::self ); { //::SireFF::Center::setSpace typedef void ( ::SireFF::Center::*setSpace_function_type)( ::SireVol::Space const & ) ; setSpace_function_type setSpace_function_value( &::SireFF::Center::setSpace ); Center_exposer.def( "setSpace" , setSpace_function_value , ( bp::arg("space") ) , "Set the space - if there is more than one molecule, then this\npoint can only be used with a cartesian, non-periodic space" ); } { //::SireFF::Center::toString typedef ::QString ( ::SireFF::Center::*toString_function_type)( ) const; toString_function_type toString_function_value( &::SireFF::Center::toString ); Center_exposer.def( "toString" , toString_function_value , "Return a string representation" ); } { //::SireFF::Center::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireFF::Center::typeName ); Center_exposer.def( "typeName" , typeName_function_value , "" ); } { //::SireFF::Center::update typedef bool ( ::SireFF::Center::*update_function_type)( ::SireMol::MoleculeData const & ) ; update_function_type update_function_value( &::SireFF::Center::update ); Center_exposer.def( "update" , update_function_value , ( bp::arg("moldata") ) , "Update the molecules used to create this point" ); } { //::SireFF::Center::update typedef bool ( ::SireFF::Center::*update_function_type)( ::SireMol::Molecules const & ) ; update_function_type update_function_value( &::SireFF::Center::update ); Center_exposer.def( "update" , update_function_value , ( bp::arg("molecules") ) , "Update the molecules used to create this point" ); } { //::SireFF::Center::update typedef bool ( ::SireFF::Center::*update_function_type)( ::SireMol::MoleculeGroup const & ) ; update_function_type update_function_value( &::SireFF::Center::update ); Center_exposer.def( "update" , update_function_value , ( bp::arg("molgroup") ) , "Update the molecules used to create this point" ); } { //::SireFF::Center::update typedef bool ( ::SireFF::Center::*update_function_type)( ::SireMol::MolGroupsBase const & ) ; update_function_type update_function_value( &::SireFF::Center::update ); Center_exposer.def( "update" , update_function_value , ( bp::arg("molgroups") ) , "Update the molecules used to create this point" ); } { //::SireFF::Center::usesMoleculesIn typedef bool ( ::SireFF::Center::*usesMoleculesIn_function_type)( ::SireFF::ForceTable const & ) const; usesMoleculesIn_function_type usesMoleculesIn_function_value( &::SireFF::Center::usesMoleculesIn ); Center_exposer.def( "usesMoleculesIn" , usesMoleculesIn_function_value , ( bp::arg("forcetable") ) , "Return whether or not this point uses data from any of the\nmolecules in the passed forcetable" ); } { //::SireFF::Center::usesMoleculesIn typedef bool ( ::SireFF::Center::*usesMoleculesIn_function_type)( ::SireMol::Molecules const & ) const; usesMoleculesIn_function_type usesMoleculesIn_function_value( &::SireFF::Center::usesMoleculesIn ); Center_exposer.def( "usesMoleculesIn" , usesMoleculesIn_function_value , ( bp::arg("molecules") ) , "Return whether or not this point uses data from any of the\nmolecules in molecules" ); } { //::SireFF::Center::usesMoleculesIn typedef bool ( ::SireFF::Center::*usesMoleculesIn_function_type)( ::SireMol::MoleculeGroup const & ) const; usesMoleculesIn_function_type usesMoleculesIn_function_value( &::SireFF::Center::usesMoleculesIn ); Center_exposer.def( "usesMoleculesIn" , usesMoleculesIn_function_value , ( bp::arg("molgroup") ) , "Return whether or not this point uses data from any of the\nmolecules in the group molgroup" ); } { //::SireFF::Center::usesMoleculesIn typedef bool ( ::SireFF::Center::*usesMoleculesIn_function_type)( ::SireMol::MolGroupsBase const & ) const; usesMoleculesIn_function_type usesMoleculesIn_function_value( &::SireFF::Center::usesMoleculesIn ); Center_exposer.def( "usesMoleculesIn" , usesMoleculesIn_function_value , ( bp::arg("molgroups") ) , "Return whether or not this point uses data from any of the\nmolecules in the groups in molgroups" ); } { //::SireFF::Center::wouldUpdate typedef bool ( ::SireFF::Center::*wouldUpdate_function_type)( ::SireMol::MoleculeData const & ) const; wouldUpdate_function_type wouldUpdate_function_value( &::SireFF::Center::wouldUpdate ); Center_exposer.def( "wouldUpdate" , wouldUpdate_function_value , ( bp::arg("moldata") ) , "Return whether or not the passed molecule would change this point" ); } { //::SireFF::Center::wouldUpdate typedef bool ( ::SireFF::Center::*wouldUpdate_function_type)( ::SireMol::Molecules const & ) const; wouldUpdate_function_type wouldUpdate_function_value( &::SireFF::Center::wouldUpdate ); Center_exposer.def( "wouldUpdate" , wouldUpdate_function_value , ( bp::arg("molecules") ) , "Return whether or not the passed molecules would change this point" ); } { //::SireFF::Center::wouldUpdate typedef bool ( ::SireFF::Center::*wouldUpdate_function_type)( ::SireMol::MoleculeGroup const & ) const; wouldUpdate_function_type wouldUpdate_function_value( &::SireFF::Center::wouldUpdate ); Center_exposer.def( "wouldUpdate" , wouldUpdate_function_value , ( bp::arg("molgroup") ) , "Return whether or not the passed molecules would change this point" ); } { //::SireFF::Center::wouldUpdate typedef bool ( ::SireFF::Center::*wouldUpdate_function_type)( ::SireMol::MolGroupsBase const & ) const; wouldUpdate_function_type wouldUpdate_function_value( &::SireFF::Center::wouldUpdate ); Center_exposer.def( "wouldUpdate" , wouldUpdate_function_value , ( bp::arg("molgroups") ) , "Return whether or not the passed molecules would change this point" ); } Center_exposer.staticmethod( "typeName" ); Center_exposer.def( "__copy__", &__copy__); Center_exposer.def( "__deepcopy__", &__copy__); Center_exposer.def( "clone", &__copy__); Center_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireFF::Center >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); Center_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireFF::Center >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); Center_exposer.def( "__str__", &__str__< ::SireFF::Center > ); Center_exposer.def( "__repr__", &__str__< ::SireFF::Center > ); } }
void register_PackedArray2D_QString__class(){ { //::SireBase::PackedArray2D< QString > typedef bp::class_< SireBase::PackedArray2D< QString > > PackedArray2D_QString__exposer_t; PackedArray2D_QString__exposer_t PackedArray2D_QString__exposer = PackedArray2D_QString__exposer_t( "PackedArray2D_QString_", bp::init< >() ); bp::scope PackedArray2D_QString__scope( PackedArray2D_QString__exposer ); PackedArray2D_QString__exposer.def( bp::init< SireBase::detail::PackedArray2D_Array< QString > const & >(( bp::arg("array") )) ); PackedArray2D_QString__exposer.def( bp::init< QVector< SireBase::detail::PackedArray2D_Array< QString > > const & >(( bp::arg("arrays") )) ); PackedArray2D_QString__exposer.def( bp::init< QVector< QString > const & >(( bp::arg("values") )) ); PackedArray2D_QString__exposer.def( bp::init< QVector< QVector< QString > > const & >(( bp::arg("values") )) ); PackedArray2D_QString__exposer.def( bp::init< SireBase::PackedArray2D< QString > const &, SireBase::PackedArray2D< QString > const & >(( bp::arg("array0"), bp::arg("array1") )) ); PackedArray2D_QString__exposer.def( bp::init< SireBase::PackedArray2D< QString > const & >(( bp::arg("other") )) ); { //::SireBase::PackedArray2D< QString >::append typedef SireBase::PackedArray2D< QString > exported_class_t; typedef void ( ::SireBase::PackedArray2D< QString >::*append_function_type )( ::SireBase::detail::PackedArray2D_Array< QString > const & ) ; append_function_type append_function_value( &::SireBase::PackedArray2D< QString >::append ); PackedArray2D_QString__exposer.def( "append" , append_function_value , ( bp::arg("array") ) ); } { //::SireBase::PackedArray2D< QString >::append typedef SireBase::PackedArray2D< QString > exported_class_t; typedef void ( ::SireBase::PackedArray2D< QString >::*append_function_type )( ::SireBase::PackedArray2D< QString > const & ) ; append_function_type append_function_value( &::SireBase::PackedArray2D< QString >::append ); PackedArray2D_QString__exposer.def( "append" , append_function_value , ( bp::arg("arrays") ) ); } { //::SireBase::PackedArray2D< QString >::append typedef SireBase::PackedArray2D< QString > exported_class_t; typedef void ( ::SireBase::PackedArray2D< QString >::*append_function_type )( ::QVector< QString > const & ) ; append_function_type append_function_value( &::SireBase::PackedArray2D< QString >::append ); PackedArray2D_QString__exposer.def( "append" , append_function_value , ( bp::arg("array") ) ); } { //::SireBase::PackedArray2D< QString >::append typedef SireBase::PackedArray2D< QString > exported_class_t; typedef void ( ::SireBase::PackedArray2D< QString >::*append_function_type )( ::QVector< QVector< QString > > const & ) ; append_function_type append_function_value( &::SireBase::PackedArray2D< QString >::append ); PackedArray2D_QString__exposer.def( "append" , append_function_value , ( bp::arg("arrays") ) ); } { //::SireBase::PackedArray2D< QString >::assertValidIndex typedef SireBase::PackedArray2D< QString > exported_class_t; typedef void ( ::SireBase::PackedArray2D< QString >::*assertValidIndex_function_type )( ::quint32 ) const; assertValidIndex_function_type assertValidIndex_function_value( &::SireBase::PackedArray2D< QString >::assertValidIndex ); PackedArray2D_QString__exposer.def( "assertValidIndex" , assertValidIndex_function_value , ( bp::arg("i") ) ); } { //::SireBase::PackedArray2D< QString >::at typedef SireBase::PackedArray2D< QString > exported_class_t; typedef ::SireBase::detail::PackedArray2D_Array< QString > const & ( ::SireBase::PackedArray2D< QString >::*at_function_type )( ::quint32 ) const; at_function_type at_function_value( &::SireBase::PackedArray2D< QString >::at ); PackedArray2D_QString__exposer.def( "at" , at_function_value , ( bp::arg("i") ) , bp::return_value_policy< bp::copy_const_reference >() ); } { //::SireBase::PackedArray2D< QString >::at typedef SireBase::PackedArray2D< QString > exported_class_t; typedef ::QString const & ( ::SireBase::PackedArray2D< QString >::*at_function_type )( ::quint32,::quint32 ) const; at_function_type at_function_value( &::SireBase::PackedArray2D< QString >::at ); PackedArray2D_QString__exposer.def( "at" , at_function_value , ( bp::arg("i"), bp::arg("j") ) , bp::return_value_policy< bp::copy_const_reference >() ); } { //::SireBase::PackedArray2D< QString >::count typedef SireBase::PackedArray2D< QString > exported_class_t; typedef int ( ::SireBase::PackedArray2D< QString >::*count_function_type )( ) const; count_function_type count_function_value( &::SireBase::PackedArray2D< QString >::count ); PackedArray2D_QString__exposer.def( "count" , count_function_value ); } { //::SireBase::PackedArray2D< QString >::fromVariant typedef SireBase::PackedArray2D< QString > exported_class_t; typedef ::SireBase::PackedArray2D< QString > ( *fromVariant_function_type )( ::SireBase::PackedArray2D< QVariant > const & ); fromVariant_function_type fromVariant_function_value( &::SireBase::PackedArray2D< QString >::fromVariant ); PackedArray2D_QString__exposer.def( "fromVariant" , fromVariant_function_value , ( bp::arg("variant") ) ); } { //::SireBase::PackedArray2D< QString >::isEmpty typedef SireBase::PackedArray2D< QString > exported_class_t; typedef bool ( ::SireBase::PackedArray2D< QString >::*isEmpty_function_type )( ) const; isEmpty_function_type isEmpty_function_value( &::SireBase::PackedArray2D< QString >::isEmpty ); PackedArray2D_QString__exposer.def( "isEmpty" , isEmpty_function_value ); } { //::SireBase::PackedArray2D< QString >::nArrays typedef SireBase::PackedArray2D< QString > exported_class_t; typedef int ( ::SireBase::PackedArray2D< QString >::*nArrays_function_type )( ) const; nArrays_function_type nArrays_function_value( &::SireBase::PackedArray2D< QString >::nArrays ); PackedArray2D_QString__exposer.def( "nArrays" , nArrays_function_value ); } { //::SireBase::PackedArray2D< QString >::nValues typedef SireBase::PackedArray2D< QString > exported_class_t; typedef int ( ::SireBase::PackedArray2D< QString >::*nValues_function_type )( ) const; nValues_function_type nValues_function_value( &::SireBase::PackedArray2D< QString >::nValues ); PackedArray2D_QString__exposer.def( "nValues" , nValues_function_value ); } { //::SireBase::PackedArray2D< QString >::nValues typedef SireBase::PackedArray2D< QString > exported_class_t; typedef int ( ::SireBase::PackedArray2D< QString >::*nValues_function_type )( ::quint32 ) const; nValues_function_type nValues_function_value( &::SireBase::PackedArray2D< QString >::nValues ); PackedArray2D_QString__exposer.def( "nValues" , nValues_function_value , ( bp::arg("i") ) ); } PackedArray2D_QString__exposer.def( bp::self != bp::self ); { //::SireBase::PackedArray2D< QString >::operator() typedef SireBase::PackedArray2D< QString > exported_class_t; typedef ::QString const & ( ::SireBase::PackedArray2D< QString >::*__call___function_type )( ::quint32,::quint32 ) const; __call___function_type __call___function_value( &::SireBase::PackedArray2D< QString >::operator() ); PackedArray2D_QString__exposer.def( "__call__" , __call___function_value , ( bp::arg("i"), bp::arg("j") ) , bp::return_value_policy< bp::copy_const_reference >() ); } { //::SireBase::PackedArray2D< QString >::operator= typedef SireBase::PackedArray2D< QString > exported_class_t; typedef ::SireBase::PackedArray2D< QString > & ( ::SireBase::PackedArray2D< QString >::*assign_function_type )( ::SireBase::PackedArray2D< QString > const & ) ; assign_function_type assign_function_value( &::SireBase::PackedArray2D< QString >::operator= ); PackedArray2D_QString__exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() ); } PackedArray2D_QString__exposer.def( bp::self == bp::self ); { //::SireBase::PackedArray2D< QString >::operator[] typedef SireBase::PackedArray2D< QString > exported_class_t; typedef ::SireBase::detail::PackedArray2D_Array< QString > const & ( ::SireBase::PackedArray2D< QString >::*__getitem___function_type )( ::quint32 ) const; __getitem___function_type __getitem___function_value( &::SireBase::PackedArray2D< QString >::operator[] ); PackedArray2D_QString__exposer.def( "__getitem__" , __getitem___function_value , ( bp::arg("i") ) , bp::return_value_policy< bp::copy_const_reference >() ); } { //::SireBase::PackedArray2D< QString >::remove typedef SireBase::PackedArray2D< QString > exported_class_t; typedef void ( ::SireBase::PackedArray2D< QString >::*remove_function_type )( ::quint32 ) ; remove_function_type remove_function_value( &::SireBase::PackedArray2D< QString >::remove ); PackedArray2D_QString__exposer.def( "remove" , remove_function_value , ( bp::arg("i") ) ); } { //::SireBase::PackedArray2D< QString >::removeAll typedef SireBase::PackedArray2D< QString > exported_class_t; typedef void ( ::SireBase::PackedArray2D< QString >::*removeAll_function_type )( ::QVarLengthArray< int, 256 > const & ) ; removeAll_function_type removeAll_function_value( &::SireBase::PackedArray2D< QString >::removeAll ); PackedArray2D_QString__exposer.def( "removeAll" , removeAll_function_value , ( bp::arg("idxs") ) ); } { //::SireBase::PackedArray2D< QString >::size typedef SireBase::PackedArray2D< QString > exported_class_t; typedef int ( ::SireBase::PackedArray2D< QString >::*size_function_type )( ) const; size_function_type size_function_value( &::SireBase::PackedArray2D< QString >::size ); PackedArray2D_QString__exposer.def( "size" , size_function_value ); } { //::SireBase::PackedArray2D< QString >::toQVector typedef SireBase::PackedArray2D< QString > exported_class_t; typedef ::QVector< QString > ( ::SireBase::PackedArray2D< QString >::*toQVector_function_type )( ) const; toQVector_function_type toQVector_function_value( &::SireBase::PackedArray2D< QString >::toQVector ); PackedArray2D_QString__exposer.def( "toQVector" , toQVector_function_value ); } { //::SireBase::PackedArray2D< QString >::toQVectorVector typedef SireBase::PackedArray2D< QString > exported_class_t; typedef ::QVector< QVector< QString > > ( ::SireBase::PackedArray2D< QString >::*toQVectorVector_function_type )( ) const; toQVectorVector_function_type toQVectorVector_function_value( &::SireBase::PackedArray2D< QString >::toQVectorVector ); PackedArray2D_QString__exposer.def( "toQVectorVector" , toQVectorVector_function_value ); } { //::SireBase::PackedArray2D< QString >::toString typedef SireBase::PackedArray2D< QString > exported_class_t; typedef ::QString ( ::SireBase::PackedArray2D< QString >::*toString_function_type )( ) const; toString_function_type toString_function_value( &::SireBase::PackedArray2D< QString >::toString ); PackedArray2D_QString__exposer.def( "toString" , toString_function_value ); } { //::SireBase::PackedArray2D< QString >::toVariant typedef SireBase::PackedArray2D< QString > exported_class_t; typedef ::SireBase::PackedArray2D< QVariant > ( ::SireBase::PackedArray2D< QString >::*toVariant_function_type )( ) const; toVariant_function_type toVariant_function_value( &::SireBase::PackedArray2D< QString >::toVariant ); PackedArray2D_QString__exposer.def( "toVariant" , toVariant_function_value ); } { //::SireBase::PackedArray2D< QString >::update typedef SireBase::PackedArray2D< QString > exported_class_t; typedef void ( ::SireBase::PackedArray2D< QString >::*update_function_type )( ::quint32,::SireBase::detail::PackedArray2D_Array< QString > const & ) ; update_function_type update_function_value( &::SireBase::PackedArray2D< QString >::update ); PackedArray2D_QString__exposer.def( "update" , update_function_value , ( bp::arg("i"), bp::arg("array") ) ); } { //::SireBase::PackedArray2D< QString >::update typedef SireBase::PackedArray2D< QString > exported_class_t; typedef void ( ::SireBase::PackedArray2D< QString >::*update_function_type )( ::quint32,::QVector< QString > const & ) ; update_function_type update_function_value( &::SireBase::PackedArray2D< QString >::update ); PackedArray2D_QString__exposer.def( "update" , update_function_value , ( bp::arg("i"), bp::arg("array") ) ); } { //::SireBase::PackedArray2D< QString >::updateAll typedef SireBase::PackedArray2D< QString > exported_class_t; typedef void ( ::SireBase::PackedArray2D< QString >::*updateAll_function_type )( ::QVarLengthArray< int, 256 > const &,::SireBase::PackedArray2D< QString > const & ) ; updateAll_function_type updateAll_function_value( &::SireBase::PackedArray2D< QString >::updateAll ); PackedArray2D_QString__exposer.def( "updateAll" , updateAll_function_value , ( bp::arg("idxs"), bp::arg("arrays") ) ); } PackedArray2D_QString__exposer.staticmethod( "fromVariant" ); PackedArray2D_QString__exposer.def( "__copy__", &__copy__); PackedArray2D_QString__exposer.def( "__deepcopy__", &__copy__); PackedArray2D_QString__exposer.def( "clone", &__copy__); PackedArray2D_QString__exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireBase::PackedArray2D<QString> >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); PackedArray2D_QString__exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireBase::PackedArray2D<QString> >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); PackedArray2D_QString__exposer.def( "__str__", &__str__< ::SireBase::PackedArray2D<QString> > ); PackedArray2D_QString__exposer.def( "__repr__", &__str__< ::SireBase::PackedArray2D<QString> > ); PackedArray2D_QString__exposer.def( "__len__", &__len_size< ::SireBase::PackedArray2D<QString> > ); } }
void register_NullRestraint_class() { { //::SireMM::NullRestraint typedef bp::class_< SireMM::NullRestraint, bp::bases< SireMM::Restraint3D, SireMM::Restraint, SireBase::Property > > NullRestraint_exposer_t; NullRestraint_exposer_t NullRestraint_exposer = NullRestraint_exposer_t( "NullRestraint", bp::init< >() ); bp::scope NullRestraint_scope( NullRestraint_exposer ); NullRestraint_exposer.def( bp::init< SireMM::NullRestraint const & >(( bp::arg("other") )) ); { //::SireMM::NullRestraint::builtinSymbols typedef ::SireCAS::Symbols ( ::SireMM::NullRestraint::*builtinSymbols_function_type )( ) const; builtinSymbols_function_type builtinSymbols_function_value( &::SireMM::NullRestraint::builtinSymbols ); NullRestraint_exposer.def( "builtinSymbols" , builtinSymbols_function_value ); } { //::SireMM::NullRestraint::builtinValues typedef ::SireCAS::Values ( ::SireMM::NullRestraint::*builtinValues_function_type )( ) const; builtinValues_function_type builtinValues_function_value( &::SireMM::NullRestraint::builtinValues ); NullRestraint_exposer.def( "builtinValues" , builtinValues_function_value ); } { //::SireMM::NullRestraint::contains typedef bool ( ::SireMM::NullRestraint::*contains_function_type )( ::SireMol::MolNum ) const; contains_function_type contains_function_value( &::SireMM::NullRestraint::contains ); NullRestraint_exposer.def( "contains" , contains_function_value , ( bp::arg("molnum") ) ); } { //::SireMM::NullRestraint::contains typedef bool ( ::SireMM::NullRestraint::*contains_function_type )( ::SireMol::MolID const & ) const; contains_function_type contains_function_value( &::SireMM::NullRestraint::contains ); NullRestraint_exposer.def( "contains" , contains_function_value , ( bp::arg("molid") ) ); } { //::SireMM::NullRestraint::differentiate typedef ::SireMM::RestraintPtr ( ::SireMM::NullRestraint::*differentiate_function_type )( ::SireCAS::Symbol const & ) const; differentiate_function_type differentiate_function_value( &::SireMM::NullRestraint::differentiate ); NullRestraint_exposer.def( "differentiate" , differentiate_function_value , ( bp::arg("symbol") ) ); } { //::SireMM::NullRestraint::energy typedef ::SireUnits::Dimension::MolarEnergy ( ::SireMM::NullRestraint::*energy_function_type )( ) const; energy_function_type energy_function_value( &::SireMM::NullRestraint::energy ); NullRestraint_exposer.def( "energy" , energy_function_value ); } { //::SireMM::NullRestraint::force typedef void ( ::SireMM::NullRestraint::*force_function_type )( ::SireFF::MolForceTable &,double ) const; force_function_type force_function_value( &::SireMM::NullRestraint::force ); NullRestraint_exposer.def( "force" , force_function_value , ( bp::arg("forcetable"), bp::arg("scale_force")=1 ) ); } { //::SireMM::NullRestraint::force typedef void ( ::SireMM::NullRestraint::*force_function_type )( ::SireFF::ForceTable &,double ) const; force_function_type force_function_value( &::SireMM::NullRestraint::force ); NullRestraint_exposer.def( "force" , force_function_value , ( bp::arg("forcetable"), bp::arg("scale_force")=1 ) ); } { //::SireMM::NullRestraint::getValue typedef double ( ::SireMM::NullRestraint::*getValue_function_type )( ::SireCAS::Symbol const & ) const; getValue_function_type getValue_function_value( &::SireMM::NullRestraint::getValue ); NullRestraint_exposer.def( "getValue" , getValue_function_value , ( bp::arg("symbol") ) ); } { //::SireMM::NullRestraint::hasValue typedef bool ( ::SireMM::NullRestraint::*hasValue_function_type )( ::SireCAS::Symbol const & ) const; hasValue_function_type hasValue_function_value( &::SireMM::NullRestraint::hasValue ); NullRestraint_exposer.def( "hasValue" , hasValue_function_value , ( bp::arg("symbol") ) ); } { //::SireMM::NullRestraint::molecules typedef ::SireMol::Molecules ( ::SireMM::NullRestraint::*molecules_function_type )( ) const; molecules_function_type molecules_function_value( &::SireMM::NullRestraint::molecules ); NullRestraint_exposer.def( "molecules" , molecules_function_value ); } NullRestraint_exposer.def( bp::self != bp::self ); { //::SireMM::NullRestraint::operator= typedef ::SireMM::NullRestraint & ( ::SireMM::NullRestraint::*assign_function_type )( ::SireMM::NullRestraint const & ) ; assign_function_type assign_function_value( &::SireMM::NullRestraint::operator= ); NullRestraint_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() ); } NullRestraint_exposer.def( bp::self == bp::self ); { //::SireMM::NullRestraint::setValue typedef void ( ::SireMM::NullRestraint::*setValue_function_type )( ::SireCAS::Symbol const &,double ) ; setValue_function_type setValue_function_value( &::SireMM::NullRestraint::setValue ); NullRestraint_exposer.def( "setValue" , setValue_function_value , ( bp::arg("symbol"), bp::arg("value") ) ); } { //::SireMM::NullRestraint::symbols typedef ::SireCAS::Symbols ( ::SireMM::NullRestraint::*symbols_function_type )( ) const; symbols_function_type symbols_function_value( &::SireMM::NullRestraint::symbols ); NullRestraint_exposer.def( "symbols" , symbols_function_value ); } { //::SireMM::NullRestraint::toString typedef ::QString ( ::SireMM::NullRestraint::*toString_function_type )( ) const; toString_function_type toString_function_value( &::SireMM::NullRestraint::toString ); NullRestraint_exposer.def( "toString" , toString_function_value ); } { //::SireMM::NullRestraint::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireMM::NullRestraint::typeName ); NullRestraint_exposer.def( "typeName" , typeName_function_value ); } { //::SireMM::NullRestraint::update typedef void ( ::SireMM::NullRestraint::*update_function_type )( ::SireMol::MoleculeData const & ) ; update_function_type update_function_value( &::SireMM::NullRestraint::update ); NullRestraint_exposer.def( "update" , update_function_value , ( bp::arg("moldata") ) ); } { //::SireMM::NullRestraint::update typedef void ( ::SireMM::NullRestraint::*update_function_type )( ::SireMol::Molecules const & ) ; update_function_type update_function_value( &::SireMM::NullRestraint::update ); NullRestraint_exposer.def( "update" , update_function_value , ( bp::arg("molecules") ) ); } { //::SireMM::NullRestraint::userSymbols typedef ::SireCAS::Symbols ( ::SireMM::NullRestraint::*userSymbols_function_type )( ) const; userSymbols_function_type userSymbols_function_value( &::SireMM::NullRestraint::userSymbols ); NullRestraint_exposer.def( "userSymbols" , userSymbols_function_value ); } { //::SireMM::NullRestraint::userValues typedef ::SireCAS::Values ( ::SireMM::NullRestraint::*userValues_function_type )( ) const; userValues_function_type userValues_function_value( &::SireMM::NullRestraint::userValues ); NullRestraint_exposer.def( "userValues" , userValues_function_value ); } { //::SireMM::NullRestraint::usesMoleculesIn typedef bool ( ::SireMM::NullRestraint::*usesMoleculesIn_function_type )( ::SireFF::ForceTable const & ) const; usesMoleculesIn_function_type usesMoleculesIn_function_value( &::SireMM::NullRestraint::usesMoleculesIn ); NullRestraint_exposer.def( "usesMoleculesIn" , usesMoleculesIn_function_value , ( bp::arg("forcetable") ) ); } { //::SireMM::NullRestraint::usesMoleculesIn typedef bool ( ::SireMM::NullRestraint::*usesMoleculesIn_function_type )( ::SireMol::Molecules const & ) const; usesMoleculesIn_function_type usesMoleculesIn_function_value( &::SireMM::NullRestraint::usesMoleculesIn ); NullRestraint_exposer.def( "usesMoleculesIn" , usesMoleculesIn_function_value , ( bp::arg("molecules") ) ); } { //::SireMM::NullRestraint::values typedef ::SireCAS::Values ( ::SireMM::NullRestraint::*values_function_type )( ) const; values_function_type values_function_value( &::SireMM::NullRestraint::values ); NullRestraint_exposer.def( "values" , values_function_value ); } NullRestraint_exposer.staticmethod( "typeName" ); NullRestraint_exposer.def( "__copy__", &__copy__); NullRestraint_exposer.def( "__deepcopy__", &__copy__); NullRestraint_exposer.def( "clone", &__copy__); NullRestraint_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::NullRestraint >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); NullRestraint_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::NullRestraint >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); NullRestraint_exposer.def( "__str__", &__str__< ::SireMM::NullRestraint > ); NullRestraint_exposer.def( "__repr__", &__str__< ::SireMM::NullRestraint > ); } }
void register_DoubleDistanceRestraint_class(){ { //::SireMM::DoubleDistanceRestraint typedef bp::class_< SireMM::DoubleDistanceRestraint, bp::bases< SireMM::Restraint3D, SireMM::Restraint, SireBase::Property > > DoubleDistanceRestraint_exposer_t; DoubleDistanceRestraint_exposer_t DoubleDistanceRestraint_exposer = DoubleDistanceRestraint_exposer_t( "DoubleDistanceRestraint", bp::init< >() ); bp::scope DoubleDistanceRestraint_scope( DoubleDistanceRestraint_exposer ); DoubleDistanceRestraint_exposer.def( bp::init< SireFF::PointRef const &, SireFF::PointRef const &, SireFF::PointRef const &, SireFF::PointRef const &, SireCAS::Expression const & >(( bp::arg("point0"), bp::arg("point1"), bp::arg("point2"), bp::arg("point3"), bp::arg("restraint") )) ); DoubleDistanceRestraint_exposer.def( bp::init< SireFF::PointRef const &, SireFF::PointRef const &, SireFF::PointRef const &, SireFF::PointRef const &, SireCAS::Expression const &, SireCAS::Values const & >(( bp::arg("point0"), bp::arg("point1"), bp::arg("point2"), bp::arg("point3"), bp::arg("restraint"), bp::arg("values") )) ); DoubleDistanceRestraint_exposer.def( bp::init< SireMM::DoubleDistanceRestraint const & >(( bp::arg("other") )) ); { //::SireMM::DoubleDistanceRestraint::builtinSymbols typedef ::SireCAS::Symbols ( ::SireMM::DoubleDistanceRestraint::*builtinSymbols_function_type )( ) const; builtinSymbols_function_type builtinSymbols_function_value( &::SireMM::DoubleDistanceRestraint::builtinSymbols ); DoubleDistanceRestraint_exposer.def( "builtinSymbols" , builtinSymbols_function_value ); } { //::SireMM::DoubleDistanceRestraint::builtinValues typedef ::SireCAS::Values ( ::SireMM::DoubleDistanceRestraint::*builtinValues_function_type )( ) const; builtinValues_function_type builtinValues_function_value( &::SireMM::DoubleDistanceRestraint::builtinValues ); DoubleDistanceRestraint_exposer.def( "builtinValues" , builtinValues_function_value ); } { //::SireMM::DoubleDistanceRestraint::contains typedef bool ( ::SireMM::DoubleDistanceRestraint::*contains_function_type )( ::SireMol::MolNum ) const; contains_function_type contains_function_value( &::SireMM::DoubleDistanceRestraint::contains ); DoubleDistanceRestraint_exposer.def( "contains" , contains_function_value , ( bp::arg("molnum") ) ); } { //::SireMM::DoubleDistanceRestraint::contains typedef bool ( ::SireMM::DoubleDistanceRestraint::*contains_function_type )( ::SireMol::MolID const & ) const; contains_function_type contains_function_value( &::SireMM::DoubleDistanceRestraint::contains ); DoubleDistanceRestraint_exposer.def( "contains" , contains_function_value , ( bp::arg("molid") ) ); } { //::SireMM::DoubleDistanceRestraint::differentialRestraintFunction01 typedef ::SireCAS::Expression const & ( ::SireMM::DoubleDistanceRestraint::*differentialRestraintFunction01_function_type )( ) const; differentialRestraintFunction01_function_type differentialRestraintFunction01_function_value( &::SireMM::DoubleDistanceRestraint::differentialRestraintFunction01 ); DoubleDistanceRestraint_exposer.def( "differentialRestraintFunction01" , differentialRestraintFunction01_function_value , bp::return_value_policy< bp::copy_const_reference >() ); } { //::SireMM::DoubleDistanceRestraint::differentialRestraintFunction23 typedef ::SireCAS::Expression const & ( ::SireMM::DoubleDistanceRestraint::*differentialRestraintFunction23_function_type )( ) const; differentialRestraintFunction23_function_type differentialRestraintFunction23_function_value( &::SireMM::DoubleDistanceRestraint::differentialRestraintFunction23 ); DoubleDistanceRestraint_exposer.def( "differentialRestraintFunction23" , differentialRestraintFunction23_function_value , bp::return_value_policy< bp::copy_const_reference >() ); } { //::SireMM::DoubleDistanceRestraint::differentiate typedef ::SireMM::RestraintPtr ( ::SireMM::DoubleDistanceRestraint::*differentiate_function_type )( ::SireCAS::Symbol const & ) const; differentiate_function_type differentiate_function_value( &::SireMM::DoubleDistanceRestraint::differentiate ); DoubleDistanceRestraint_exposer.def( "differentiate" , differentiate_function_value , ( bp::arg("symbol") ) ); } { //::SireMM::DoubleDistanceRestraint::force typedef void ( ::SireMM::DoubleDistanceRestraint::*force_function_type )( ::SireFF::MolForceTable &,double ) const; force_function_type force_function_value( &::SireMM::DoubleDistanceRestraint::force ); DoubleDistanceRestraint_exposer.def( "force" , force_function_value , ( bp::arg("forcetable"), bp::arg("scale_force")=1 ) ); } { //::SireMM::DoubleDistanceRestraint::force typedef void ( ::SireMM::DoubleDistanceRestraint::*force_function_type )( ::SireFF::ForceTable &,double ) const; force_function_type force_function_value( &::SireMM::DoubleDistanceRestraint::force ); DoubleDistanceRestraint_exposer.def( "force" , force_function_value , ( bp::arg("forcetable"), bp::arg("scale_force")=1 ) ); } { //::SireMM::DoubleDistanceRestraint::molecules typedef ::SireMol::Molecules ( ::SireMM::DoubleDistanceRestraint::*molecules_function_type )( ) const; molecules_function_type molecules_function_value( &::SireMM::DoubleDistanceRestraint::molecules ); DoubleDistanceRestraint_exposer.def( "molecules" , molecules_function_value ); } { //::SireMM::DoubleDistanceRestraint::nPoints typedef int ( ::SireMM::DoubleDistanceRestraint::*nPoints_function_type )( ) const; nPoints_function_type nPoints_function_value( &::SireMM::DoubleDistanceRestraint::nPoints ); DoubleDistanceRestraint_exposer.def( "nPoints" , nPoints_function_value ); } DoubleDistanceRestraint_exposer.def( bp::self != bp::self ); { //::SireMM::DoubleDistanceRestraint::operator= typedef ::SireMM::DoubleDistanceRestraint & ( ::SireMM::DoubleDistanceRestraint::*assign_function_type )( ::SireMM::DoubleDistanceRestraint const & ) ; assign_function_type assign_function_value( &::SireMM::DoubleDistanceRestraint::operator= ); DoubleDistanceRestraint_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() ); } DoubleDistanceRestraint_exposer.def( bp::self == bp::self ); { //::SireMM::DoubleDistanceRestraint::point typedef ::SireFF::Point const & ( ::SireMM::DoubleDistanceRestraint::*point_function_type )( int ) const; point_function_type point_function_value( &::SireMM::DoubleDistanceRestraint::point ); DoubleDistanceRestraint_exposer.def( "point" , point_function_value , ( bp::arg("i") ) , bp::return_value_policy<bp::clone_const_reference>() ); } { //::SireMM::DoubleDistanceRestraint::point0 typedef ::SireFF::Point const & ( ::SireMM::DoubleDistanceRestraint::*point0_function_type )( ) const; point0_function_type point0_function_value( &::SireMM::DoubleDistanceRestraint::point0 ); DoubleDistanceRestraint_exposer.def( "point0" , point0_function_value , bp::return_value_policy<bp::clone_const_reference>() ); } { //::SireMM::DoubleDistanceRestraint::point1 typedef ::SireFF::Point const & ( ::SireMM::DoubleDistanceRestraint::*point1_function_type )( ) const; point1_function_type point1_function_value( &::SireMM::DoubleDistanceRestraint::point1 ); DoubleDistanceRestraint_exposer.def( "point1" , point1_function_value , bp::return_value_policy<bp::clone_const_reference>() ); } { //::SireMM::DoubleDistanceRestraint::point2 typedef ::SireFF::Point const & ( ::SireMM::DoubleDistanceRestraint::*point2_function_type )( ) const; point2_function_type point2_function_value( &::SireMM::DoubleDistanceRestraint::point2 ); DoubleDistanceRestraint_exposer.def( "point2" , point2_function_value , bp::return_value_policy<bp::clone_const_reference>() ); } { //::SireMM::DoubleDistanceRestraint::point3 typedef ::SireFF::Point const & ( ::SireMM::DoubleDistanceRestraint::*point3_function_type )( ) const; point3_function_type point3_function_value( &::SireMM::DoubleDistanceRestraint::point3 ); DoubleDistanceRestraint_exposer.def( "point3" , point3_function_value , bp::return_value_policy<bp::clone_const_reference>() ); } { //::SireMM::DoubleDistanceRestraint::r01 typedef ::SireCAS::Symbol const & ( *r01_function_type )( ); r01_function_type r01_function_value( &::SireMM::DoubleDistanceRestraint::r01 ); DoubleDistanceRestraint_exposer.def( "r01" , r01_function_value , bp::return_value_policy<bp::clone_const_reference>() ); } { //::SireMM::DoubleDistanceRestraint::r23 typedef ::SireCAS::Symbol const & ( *r23_function_type )( ); r23_function_type r23_function_value( &::SireMM::DoubleDistanceRestraint::r23 ); DoubleDistanceRestraint_exposer.def( "r23" , r23_function_value , bp::return_value_policy<bp::clone_const_reference>() ); } { //::SireMM::DoubleDistanceRestraint::setSpace typedef void ( ::SireMM::DoubleDistanceRestraint::*setSpace_function_type )( ::SireVol::Space const & ) ; setSpace_function_type setSpace_function_value( &::SireMM::DoubleDistanceRestraint::setSpace ); DoubleDistanceRestraint_exposer.def( "setSpace" , setSpace_function_value , ( bp::arg("space") ) ); } { //::SireMM::DoubleDistanceRestraint::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireMM::DoubleDistanceRestraint::typeName ); DoubleDistanceRestraint_exposer.def( "typeName" , typeName_function_value ); } { //::SireMM::DoubleDistanceRestraint::update typedef void ( ::SireMM::DoubleDistanceRestraint::*update_function_type )( ::SireMol::MoleculeData const & ) ; update_function_type update_function_value( &::SireMM::DoubleDistanceRestraint::update ); DoubleDistanceRestraint_exposer.def( "update" , update_function_value , ( bp::arg("moldata") ) ); } { //::SireMM::DoubleDistanceRestraint::update typedef void ( ::SireMM::DoubleDistanceRestraint::*update_function_type )( ::SireMol::Molecules const & ) ; update_function_type update_function_value( &::SireMM::DoubleDistanceRestraint::update ); DoubleDistanceRestraint_exposer.def( "update" , update_function_value , ( bp::arg("molecules") ) ); } { //::SireMM::DoubleDistanceRestraint::usesMoleculesIn typedef bool ( ::SireMM::DoubleDistanceRestraint::*usesMoleculesIn_function_type )( ::SireFF::ForceTable const & ) const; usesMoleculesIn_function_type usesMoleculesIn_function_value( &::SireMM::DoubleDistanceRestraint::usesMoleculesIn ); DoubleDistanceRestraint_exposer.def( "usesMoleculesIn" , usesMoleculesIn_function_value , ( bp::arg("forcetable") ) ); } { //::SireMM::DoubleDistanceRestraint::usesMoleculesIn typedef bool ( ::SireMM::DoubleDistanceRestraint::*usesMoleculesIn_function_type )( ::SireMol::Molecules const & ) const; usesMoleculesIn_function_type usesMoleculesIn_function_value( &::SireMM::DoubleDistanceRestraint::usesMoleculesIn ); DoubleDistanceRestraint_exposer.def( "usesMoleculesIn" , usesMoleculesIn_function_value , ( bp::arg("molecules") ) ); } DoubleDistanceRestraint_exposer.staticmethod( "r01" ); DoubleDistanceRestraint_exposer.staticmethod( "r23" ); DoubleDistanceRestraint_exposer.staticmethod( "typeName" ); DoubleDistanceRestraint_exposer.def( "__copy__", &__copy__); DoubleDistanceRestraint_exposer.def( "__deepcopy__", &__copy__); DoubleDistanceRestraint_exposer.def( "clone", &__copy__); DoubleDistanceRestraint_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::DoubleDistanceRestraint >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); DoubleDistanceRestraint_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::DoubleDistanceRestraint >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); DoubleDistanceRestraint_exposer.def( "__str__", &__str__< ::SireMM::DoubleDistanceRestraint > ); DoubleDistanceRestraint_exposer.def( "__repr__", &__str__< ::SireMM::DoubleDistanceRestraint > ); } }