コード例 #1
0
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 > );
    }

}
コード例 #2
0
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 > );
    }

}
コード例 #3
0
ファイル: Center.pypp.cpp プロジェクト: Steboss/Sire
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 > );
    }

}
コード例 #4
0
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 > );
    }

}