void register_LJPerturbation_class(){ { //::SireMM::LJPerturbation typedef bp::class_< SireMM::LJPerturbation, bp::bases< SireMol::Perturbation, SireBase::Property > > LJPerturbation_exposer_t; LJPerturbation_exposer_t LJPerturbation_exposer = LJPerturbation_exposer_t( "LJPerturbation", "This is a perturbation that maps LJ parameters for a molecule\nfrom an initial to a final state\n\nAuthor: Christopher Woods\n", bp::init< bp::optional< SireBase::PropertyMap const & > >(( bp::arg("map")=SireBase::PropertyMap() ), "Constructor - this creates a LJ perturbation that\nperturbs from LJs in initial_LJ to LJs in\nfinal_LJ, placing the current LJs in LJ,\nand using Perturbation::defaultEquation() to map the\nsigma and epsilon values of the LJ.") ); bp::scope LJPerturbation_scope( LJPerturbation_exposer ); bp::enum_< SireMM::LJPerturbation::MapType>("MapType") .value("MAP_SIGMA_AND_EPSILON", SireMM::LJPerturbation::MAP_SIGMA_AND_EPSILON) .value("MAP_RMIN_AND_EPSILON", SireMM::LJPerturbation::MAP_RMIN_AND_EPSILON) .value("MAP_A_AND_B", SireMM::LJPerturbation::MAP_A_AND_B) .export_values() ; LJPerturbation_exposer.def( bp::init< SireMM::LJPerturbation::MapType, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("maptype"), bp::arg("map")=SireBase::PropertyMap() ), "Construct, using the passed map to find the properties used\nby this perturbation") ); LJPerturbation_exposer.def( bp::init< SireCAS::Expression const &, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("mapping_function"), bp::arg("map")=SireBase::PropertyMap() ), "Construct, using the passed map to find the properties used\nby this perturbation and the passed mapping function to map\nthe LJs between the states") ); LJPerturbation_exposer.def( bp::init< SireCAS::Expression const &, SireMM::LJPerturbation::MapType, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("mapping_function"), bp::arg("maptype"), bp::arg("map")=SireBase::PropertyMap() ), "Construct, using the passed map to find the properties used\nby this perturbation and the passed mapping function to map\nthe LJs between the states") ); LJPerturbation_exposer.def( bp::init< SireCAS::Expression const &, SireCAS::Expression const &, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("sigma_mapping_function"), bp::arg("epsilon_mapping_function"), bp::arg("map")=SireBase::PropertyMap() ), "Construct, using the passed map to find the properties used\nby this perturbation and the passed mapping function to map\nthe LJs between the states") ); LJPerturbation_exposer.def( bp::init< SireCAS::Expression const &, SireCAS::Expression const &, SireMM::LJPerturbation::MapType, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("sigma_mapping_function"), bp::arg("epsilon_mapping_function"), bp::arg("maptype"), bp::arg("map")=SireBase::PropertyMap() ), "Construct, using the passed map to find the properties used\nby this perturbation and the passed mapping function to map\nthe LJs between the states") ); LJPerturbation_exposer.def( bp::init< SireMM::LJPerturbation const & >(( bp::arg("other") ), "Copy constructor") ); { //::SireMM::LJPerturbation::A_MappingFunction typedef ::SireCAS::Expression const & ( ::SireMM::LJPerturbation::*A_MappingFunction_function_type)( ) const; A_MappingFunction_function_type A_MappingFunction_function_value( &::SireMM::LJPerturbation::A_MappingFunction ); LJPerturbation_exposer.def( "A_MappingFunction" , A_MappingFunction_function_value , bp::return_value_policy< bp::copy_const_reference >() , "Return the function used to map A\nThrow: SireError::invalid_state\n" ); } { //::SireMM::LJPerturbation::B_MappingFunction typedef ::SireCAS::Expression const & ( ::SireMM::LJPerturbation::*B_MappingFunction_function_type)( ) const; B_MappingFunction_function_type B_MappingFunction_function_value( &::SireMM::LJPerturbation::B_MappingFunction ); LJPerturbation_exposer.def( "B_MappingFunction" , B_MappingFunction_function_value , bp::return_value_policy< bp::copy_const_reference >() , "Return the function used to map B\nThrow: SireError::invalid_state\n" ); } { //::SireMM::LJPerturbation::epsilonMappingFunction typedef ::SireCAS::Expression const & ( ::SireMM::LJPerturbation::*epsilonMappingFunction_function_type)( ) const; epsilonMappingFunction_function_type epsilonMappingFunction_function_value( &::SireMM::LJPerturbation::epsilonMappingFunction ); LJPerturbation_exposer.def( "epsilonMappingFunction" , epsilonMappingFunction_function_value , bp::return_value_policy< bp::copy_const_reference >() , "Return the function used to map epsilon\nThrow: SireError::invalid_state\n" ); } { //::SireMM::LJPerturbation::mapAB typedef bool ( ::SireMM::LJPerturbation::*mapAB_function_type)( ) const; mapAB_function_type mapAB_function_value( &::SireMM::LJPerturbation::mapAB ); LJPerturbation_exposer.def( "mapAB" , mapAB_function_value , "Return whether or not this maps A and B" ); } { //::SireMM::LJPerturbation::mapRMinEpsilon typedef bool ( ::SireMM::LJPerturbation::*mapRMinEpsilon_function_type)( ) const; mapRMinEpsilon_function_type mapRMinEpsilon_function_value( &::SireMM::LJPerturbation::mapRMinEpsilon ); LJPerturbation_exposer.def( "mapRMinEpsilon" , mapRMinEpsilon_function_value , "Return whether or not this maps r_min and epsilon" ); } { //::SireMM::LJPerturbation::mapSigmaEpsilon typedef bool ( ::SireMM::LJPerturbation::*mapSigmaEpsilon_function_type)( ) const; mapSigmaEpsilon_function_type mapSigmaEpsilon_function_value( &::SireMM::LJPerturbation::mapSigmaEpsilon ); LJPerturbation_exposer.def( "mapSigmaEpsilon" , mapSigmaEpsilon_function_value , "Return whether or not this maps sigma and epsilon" ); } { //::SireMM::LJPerturbation::mappingFunction typedef ::SireCAS::Expression const & ( ::SireMM::LJPerturbation::*mappingFunction_function_type)( ) const; mappingFunction_function_type mappingFunction_function_value( &::SireMM::LJPerturbation::mappingFunction ); LJPerturbation_exposer.def( "mappingFunction" , mappingFunction_function_value , bp::return_value_policy< bp::copy_const_reference >() , "Return the mapping function\nThrow: SireError::invalid_state\n" ); } LJPerturbation_exposer.def( bp::self != bp::self ); { //::SireMM::LJPerturbation::operator= typedef ::SireMM::LJPerturbation & ( ::SireMM::LJPerturbation::*assign_function_type)( ::SireMM::LJPerturbation const & ) ; assign_function_type assign_function_value( &::SireMM::LJPerturbation::operator= ); LJPerturbation_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() , "" ); } LJPerturbation_exposer.def( bp::self == bp::self ); { //::SireMM::LJPerturbation::rMinMappingFunction typedef ::SireCAS::Expression const & ( ::SireMM::LJPerturbation::*rMinMappingFunction_function_type)( ) const; rMinMappingFunction_function_type rMinMappingFunction_function_value( &::SireMM::LJPerturbation::rMinMappingFunction ); LJPerturbation_exposer.def( "rMinMappingFunction" , rMinMappingFunction_function_value , bp::return_value_policy< bp::copy_const_reference >() , "Return the function used to map r_min\nThrow: SireError::invalid_state\n" ); } { //::SireMM::LJPerturbation::recreate typedef ::SireMol::PerturbationPtr ( ::SireMM::LJPerturbation::*recreate_function_type)( ::SireCAS::Expression const & ) const; recreate_function_type recreate_function_value( &::SireMM::LJPerturbation::recreate ); LJPerturbation_exposer.def( "recreate" , recreate_function_value , ( bp::arg("mapping_function") ) , "" ); } { //::SireMM::LJPerturbation::recreate typedef ::SireMol::PerturbationPtr ( ::SireMM::LJPerturbation::*recreate_function_type)( ::SireCAS::Expression const &,::SireBase::PropertyMap const & ) const; recreate_function_type recreate_function_value( &::SireMM::LJPerturbation::recreate ); LJPerturbation_exposer.def( "recreate" , recreate_function_value , ( bp::arg("mapping_function"), bp::arg("map") ) , "" ); } { //::SireMM::LJPerturbation::requiredProperties typedef ::QSet< QString > ( ::SireMM::LJPerturbation::*requiredProperties_function_type)( ) const; requiredProperties_function_type requiredProperties_function_value( &::SireMM::LJPerturbation::requiredProperties ); LJPerturbation_exposer.def( "requiredProperties" , requiredProperties_function_value , "Return the properties required or changed by this perturbation" ); } { //::SireMM::LJPerturbation::sigmaMappingFunction typedef ::SireCAS::Expression const & ( ::SireMM::LJPerturbation::*sigmaMappingFunction_function_type)( ) const; sigmaMappingFunction_function_type sigmaMappingFunction_function_value( &::SireMM::LJPerturbation::sigmaMappingFunction ); LJPerturbation_exposer.def( "sigmaMappingFunction" , sigmaMappingFunction_function_value , bp::return_value_policy< bp::copy_const_reference >() , "Return the function used to map sigma\nThrow: SireError::invalid_state\n" ); } { //::SireMM::LJPerturbation::substitute typedef ::SireMol::PerturbationPtr ( ::SireMM::LJPerturbation::*substitute_function_type)( ::SireCAS::Identities const & ) const; substitute_function_type substitute_function_value( &::SireMM::LJPerturbation::substitute ); LJPerturbation_exposer.def( "substitute" , substitute_function_value , ( bp::arg("identities") ) , "Substitute the identities in identities in all of the mapping functions\nused by this perturbation. This is useful if, for example, you want to\nswitch from using lambda to control the perturbation to using alpha, e.g.\n" ); } { //::SireMM::LJPerturbation::toString typedef ::QString ( ::SireMM::LJPerturbation::*toString_function_type)( ) const; toString_function_type toString_function_value( &::SireMM::LJPerturbation::toString ); LJPerturbation_exposer.def( "toString" , toString_function_value , "Return a string representation of this perturbation" ); } { //::SireMM::LJPerturbation::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireMM::LJPerturbation::typeName ); LJPerturbation_exposer.def( "typeName" , typeName_function_value , "" ); } { //::SireMM::LJPerturbation::wouldChange typedef bool ( ::SireMM::LJPerturbation::*wouldChange_function_type)( ::SireMol::Molecule const &,::SireCAS::Values const & ) const; wouldChange_function_type wouldChange_function_value( &::SireMM::LJPerturbation::wouldChange ); LJPerturbation_exposer.def( "wouldChange" , wouldChange_function_value , ( bp::arg("molecule"), bp::arg("values") ) , "Return whether or not this perturbation with the passed values would\nchange the molecule molecule" ); } LJPerturbation_exposer.staticmethod( "typeName" ); LJPerturbation_exposer.def( "__copy__", &__copy__); LJPerturbation_exposer.def( "__deepcopy__", &__copy__); LJPerturbation_exposer.def( "clone", &__copy__); LJPerturbation_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::LJPerturbation >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); LJPerturbation_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::LJPerturbation >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); LJPerturbation_exposer.def( "__str__", &__str__< ::SireMM::LJPerturbation > ); LJPerturbation_exposer.def( "__repr__", &__str__< ::SireMM::LJPerturbation > ); } }
void register_Perturbation_class(){ { //::SireMol::Perturbation typedef bp::class_< SireMol::Perturbation, bp::bases< SireBase::Property >, boost::noncopyable > Perturbation_exposer_t; Perturbation_exposer_t Perturbation_exposer = Perturbation_exposer_t( "Perturbation", "This is the base class of all perturbation objects. A Perturbation\nis a rule for changing a property of a molecule with respect\nto a driving (reaction) coordinate. Perturbations can be used\nto implement single topology free energy calculations\n\nAuthor: Christopher Woods\n", bp::no_init ); bp::scope Perturbation_scope( Perturbation_exposer ); { //::SireMol::Perturbation::children typedef ::QList< SireBase::PropPtr< SireMol::Perturbation > > ( ::SireMol::Perturbation::*children_function_type)( ) const; children_function_type children_function_value( &::SireMol::Perturbation::children ); Perturbation_exposer.def( "children" , children_function_value , "Return all of the child perturbations that make up\nthis perturbation" ); } { //::SireMol::Perturbation::defaultFunction typedef ::SireCAS::Expression const & ( *defaultFunction_function_type )( ); defaultFunction_function_type defaultFunction_function_value( &::SireMol::Perturbation::defaultFunction ); Perturbation_exposer.def( "defaultFunction" , defaultFunction_function_value , bp::return_value_policy< bp::copy_const_reference >() , "Return the default mapping equation for the perturbations - this\nlinearly maps from the initial values at lambda=0 to the\nfinal value at lambda=1" ); } { //::SireMol::Perturbation::mappingFunction typedef ::SireCAS::Expression const & ( ::SireMol::Perturbation::*mappingFunction_function_type)( ) const; mappingFunction_function_type mappingFunction_function_value( &::SireMol::Perturbation::mappingFunction ); Perturbation_exposer.def( "mappingFunction" , mappingFunction_function_value , bp::return_value_policy< bp::copy_const_reference >() , "Return the equation used to control the mapping from the\nthe initial value (represented using symbols().initial()) to\nthe final value (represented using symbols().final()) as a\nfunction of the reaction coordinate (which is normally\nrepresented using symbols().lambda())" ); } { //::SireMol::Perturbation::null typedef ::SireMol::NullPerturbation const & ( *null_function_type )( ); null_function_type null_function_value( &::SireMol::Perturbation::null ); Perturbation_exposer.def( "null" , null_function_value , bp::return_value_policy< bp::copy_const_reference >() , "" ); } { //::SireMol::Perturbation::perturb typedef ::SireMol::Molecule ( ::SireMol::Perturbation::*perturb_function_type)( ::SireMol::Molecule const &,::SireCAS::Values const & ) const; perturb_function_type perturb_function_value( &::SireMol::Perturbation::perturb ); Perturbation_exposer.def( "perturb" , perturb_function_value , ( bp::arg("molecule"), bp::arg("values") ) , "Perturb the passed molecule, returning the result\nThrow: SireBase::missing_property\nThrow: SireError::invalid_cast\nThrow: SireError:incompatible_error\n" ); } { //::SireMol::Perturbation::propertyMap typedef ::SireBase::PropertyMap const & ( ::SireMol::Perturbation::*propertyMap_function_type)( ) const; propertyMap_function_type propertyMap_function_value( &::SireMol::Perturbation::propertyMap ); Perturbation_exposer.def( "propertyMap" , propertyMap_function_value , bp::return_value_policy< bp::copy_const_reference >() , "Return the property map used to find the properties used,\nand affected by this perturbation" ); } { //::SireMol::Perturbation::recreate typedef ::SireMol::PerturbationPtr ( ::SireMol::Perturbation::*recreate_function_type)( ) const; recreate_function_type recreate_function_value( &::SireMol::Perturbation::recreate ); Perturbation_exposer.def( "recreate" , recreate_function_value , "Recreate this perturbation - this has the same effect as .clone()" ); } { //::SireMol::Perturbation::recreate typedef ::SireMol::PerturbationPtr ( ::SireMol::Perturbation::*recreate_function_type)( ::SireCAS::Expression const & ) const; recreate_function_type recreate_function_value( &::SireMol::Perturbation::recreate ); Perturbation_exposer.def( "recreate" , recreate_function_value , ( bp::arg("mapping_function") ) , "Recreate this perturbation, replacing its current mapping function\nwith mapping_function" ); } { //::SireMol::Perturbation::recreate typedef ::SireMol::PerturbationPtr ( ::SireMol::Perturbation::*recreate_function_type)( ::SireBase::PropertyMap const & ) const; recreate_function_type recreate_function_value( &::SireMol::Perturbation::recreate ); Perturbation_exposer.def( "recreate" , recreate_function_value , ( bp::arg("map") ) , "Recreate this perturbation, replacing the current property map with map" ); } { //::SireMol::Perturbation::recreate typedef ::SireMol::PerturbationPtr ( ::SireMol::Perturbation::*recreate_function_type)( ::SireCAS::Expression const &,::SireBase::PropertyMap const & ) const; recreate_function_type recreate_function_value( &::SireMol::Perturbation::recreate ); Perturbation_exposer.def( "recreate" , recreate_function_value , ( bp::arg("mapping_function"), bp::arg("map") ) , "Recreate this perturbation, replacing both the mapping function and\nthe property map" ); } { //::SireMol::Perturbation::requiredProperties typedef ::QSet< QString > ( ::SireMol::Perturbation::*requiredProperties_function_type)( ) const; requiredProperties_function_type requiredProperties_function_value( &::SireMol::Perturbation::requiredProperties ); Perturbation_exposer.def( "requiredProperties" , requiredProperties_function_value , "" ); } { //::SireMol::Perturbation::requiredSymbols typedef ::QSet< SireCAS::Symbol > ( ::SireMol::Perturbation::*requiredSymbols_function_type)( ) const; requiredSymbols_function_type requiredSymbols_function_value( &::SireMol::Perturbation::requiredSymbols ); Perturbation_exposer.def( "requiredSymbols" , requiredSymbols_function_value , "Return all of the symbols that need to be supplied\nto the mapping function (i.e. ignoring symbols().initial()\nand symbols().final() )" ); } { //::SireMol::Perturbation::substitute typedef ::SireMol::PerturbationPtr ( ::SireMol::Perturbation::*substitute_function_type)( ::SireCAS::Symbol const &,::SireCAS::Symbol const & ) const; substitute_function_type substitute_function_value( &::SireMol::Perturbation::substitute ); Perturbation_exposer.def( "substitute" , substitute_function_value , ( bp::arg("old_symbol"), bp::arg("new_symbol") ) , "Substitute the symbol old_symbol with the symbol new_symbol\nin all of the mapping functions used by this perturbation. This is\nuseful if, for example, you want to switch from using\nlambda to control the perturbation to using alpha, e.g.\n" ); } { //::SireMol::Perturbation::substitute typedef ::SireMol::PerturbationPtr ( ::SireMol::Perturbation::*substitute_function_type)( ::SireCAS::Identities const & ) const; substitute_function_type substitute_function_value( &::SireMol::Perturbation::substitute ); Perturbation_exposer.def( "substitute" , substitute_function_value , ( bp::arg("identities") ) , "Substitute the identities in identities in all of the mapping functions\nused by this perturbation. This is useful if, for example, you want to\nswitch from using lambda to control the perturbation to using alpha, e.g.\n" ); } { //::SireMol::Perturbation::symbols typedef ::SireMol::PerturbationSymbols const & ( *symbols_function_type )( ); symbols_function_type symbols_function_value( &::SireMol::Perturbation::symbols ); Perturbation_exposer.def( "symbols" , symbols_function_value , bp::return_value_policy< bp::copy_const_reference >() , "Return the symbols object that contains the symbols used\nby the mapping equation" ); } { //::SireMol::Perturbation::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireMol::Perturbation::typeName ); Perturbation_exposer.def( "typeName" , typeName_function_value , "" ); } { //::SireMol::Perturbation::wouldChange typedef bool ( ::SireMol::Perturbation::*wouldChange_function_type)( ::SireMol::Molecule const &,::SireCAS::Values const & ) const; wouldChange_function_type wouldChange_function_value( &::SireMol::Perturbation::wouldChange ); Perturbation_exposer.def( "wouldChange" , wouldChange_function_value , ( bp::arg("molecule"), bp::arg("values") ) , "" ); } Perturbation_exposer.staticmethod( "defaultFunction" ); Perturbation_exposer.staticmethod( "null" ); Perturbation_exposer.staticmethod( "symbols" ); Perturbation_exposer.staticmethod( "typeName" ); Perturbation_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::Perturbation >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); Perturbation_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::Perturbation >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); Perturbation_exposer.def( "__str__", &__str__< ::SireMol::Perturbation > ); Perturbation_exposer.def( "__repr__", &__str__< ::SireMol::Perturbation > ); } }
void register_TwoAtomPerturbation_class(){ { //::SireMM::TwoAtomPerturbation typedef bp::class_< SireMM::TwoAtomPerturbation, bp::bases< SireMM::InternalPerturbation, SireMol::Perturbation, SireBase::Property > > TwoAtomPerturbation_exposer_t; TwoAtomPerturbation_exposer_t TwoAtomPerturbation_exposer = TwoAtomPerturbation_exposer_t( "TwoAtomPerturbation", bp::init< >() ); bp::scope TwoAtomPerturbation_scope( TwoAtomPerturbation_exposer ); TwoAtomPerturbation_exposer.def( bp::init< SireMol::AtomID const &, SireMol::AtomID const &, SireCAS::Expression const &, SireCAS::Expression const &, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("atom0"), bp::arg("atom1"), bp::arg("initial_form"), bp::arg("final_form"), bp::arg("map")=SireBase::PropertyMap() )) ); TwoAtomPerturbation_exposer.def( bp::init< SireMol::AtomID const &, SireMol::AtomID const &, SireCAS::Expression const &, SireCAS::Expression const &, SireCAS::Expression const &, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("atom0"), bp::arg("atom1"), bp::arg("initial_form"), bp::arg("final_form"), bp::arg("mapping_function"), bp::arg("map")=SireBase::PropertyMap() )) ); TwoAtomPerturbation_exposer.def( bp::init< SireMol::AtomID const &, SireMol::AtomID const &, SireCAS::Expression const &, SireCAS::Identities const &, SireCAS::Identities const &, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("atom0"), bp::arg("atom1"), bp::arg("base_expression"), bp::arg("initial_forms"), bp::arg("final_forms"), bp::arg("map")=SireBase::PropertyMap() )) ); TwoAtomPerturbation_exposer.def( bp::init< SireMol::AtomID const &, SireMol::AtomID const &, SireCAS::Expression const &, SireCAS::Identities const &, SireCAS::Identities const &, SireCAS::Expression const &, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("atom0"), bp::arg("atom1"), bp::arg("base_expression"), bp::arg("initial_forms"), bp::arg("final_forms"), bp::arg("mapping_function"), bp::arg("map")=SireBase::PropertyMap() )) ); TwoAtomPerturbation_exposer.def( bp::init< SireMM::TwoAtomPerturbation const & >(( bp::arg("other") )) ); { //::SireMM::TwoAtomPerturbation::atom0 typedef ::SireMol::AtomID const & ( ::SireMM::TwoAtomPerturbation::*atom0_function_type )( ) const; atom0_function_type atom0_function_value( &::SireMM::TwoAtomPerturbation::atom0 ); TwoAtomPerturbation_exposer.def( "atom0" , atom0_function_value , bp::return_value_policy<bp::clone_const_reference>() ); } { //::SireMM::TwoAtomPerturbation::atom1 typedef ::SireMol::AtomID const & ( ::SireMM::TwoAtomPerturbation::*atom1_function_type )( ) const; atom1_function_type atom1_function_value( &::SireMM::TwoAtomPerturbation::atom1 ); TwoAtomPerturbation_exposer.def( "atom1" , atom1_function_value , bp::return_value_policy<bp::clone_const_reference>() ); } TwoAtomPerturbation_exposer.def( bp::self != bp::self ); { //::SireMM::TwoAtomPerturbation::operator= typedef ::SireMM::TwoAtomPerturbation & ( ::SireMM::TwoAtomPerturbation::*assign_function_type )( ::SireMM::TwoAtomPerturbation const & ) ; assign_function_type assign_function_value( &::SireMM::TwoAtomPerturbation::operator= ); TwoAtomPerturbation_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() ); } TwoAtomPerturbation_exposer.def( bp::self == bp::self ); { //::SireMM::TwoAtomPerturbation::requiredProperties typedef ::QSet< QString > ( ::SireMM::TwoAtomPerturbation::*requiredProperties_function_type )( ) const; requiredProperties_function_type requiredProperties_function_value( &::SireMM::TwoAtomPerturbation::requiredProperties ); TwoAtomPerturbation_exposer.def( "requiredProperties" , requiredProperties_function_value ); } { //::SireMM::TwoAtomPerturbation::toString typedef ::QString ( ::SireMM::TwoAtomPerturbation::*toString_function_type )( ) const; toString_function_type toString_function_value( &::SireMM::TwoAtomPerturbation::toString ); TwoAtomPerturbation_exposer.def( "toString" , toString_function_value ); } { //::SireMM::TwoAtomPerturbation::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireMM::TwoAtomPerturbation::typeName ); TwoAtomPerturbation_exposer.def( "typeName" , typeName_function_value ); } { //::SireMM::TwoAtomPerturbation::wouldChange typedef bool ( ::SireMM::TwoAtomPerturbation::*wouldChange_function_type )( ::SireMol::Molecule const &,::SireCAS::Values const & ) const; wouldChange_function_type wouldChange_function_value( &::SireMM::TwoAtomPerturbation::wouldChange ); TwoAtomPerturbation_exposer.def( "wouldChange" , wouldChange_function_value , ( bp::arg("molecule"), bp::arg("values") ) ); } TwoAtomPerturbation_exposer.staticmethod( "typeName" ); TwoAtomPerturbation_exposer.def( "__copy__", &__copy__); TwoAtomPerturbation_exposer.def( "__deepcopy__", &__copy__); TwoAtomPerturbation_exposer.def( "clone", &__copy__); TwoAtomPerturbation_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::TwoAtomPerturbation >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); TwoAtomPerturbation_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::TwoAtomPerturbation >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); TwoAtomPerturbation_exposer.def( "__str__", &__str__< ::SireMM::TwoAtomPerturbation > ); TwoAtomPerturbation_exposer.def( "__repr__", &__str__< ::SireMM::TwoAtomPerturbation > ); } }