Esempio n. 1
0
void register_InterGroupLJFF_class() {

    {   //::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >
        typedef bp::class_< SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >, bp::bases< SireFF::FF3D, SireFF::Inter2B2GFF<SireMM::LJPotentialInterface<SireMM::InterLJPotential> >, SireMM::LJPotentialInterface<SireMM::InterLJPotential>, SireFF::G2FF, SireFF::FF, SireMol::MolGroupsBase, SireBase::Property > > InterGroupLJFF_exposer_t;
        InterGroupLJFF_exposer_t InterGroupLJFF_exposer = InterGroupLJFF_exposer_t( "InterGroupLJFF", bp::init< >() );
        bp::scope InterGroupLJFF_scope( InterGroupLJFF_exposer );
        InterGroupLJFF_exposer.def( bp::init< QString const & >(( bp::arg("name") )) );
        InterGroupLJFF_exposer.def( bp::init< SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > > const & >(( bp::arg("other") )) );
        {   //::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::energy

            typedef SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > > exported_class_t;
            typedef void ( ::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::*energy_function_type )( ::SireFF::EnergyTable &,double ) ;
            energy_function_type energy_function_value( &::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::energy );

            InterGroupLJFF_exposer.def(
                "energy"
                , energy_function_value
                , ( bp::arg("energytable"), bp::arg("scale_energy")=1 ) );

        }
        {   //::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::energy

            typedef SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > > exported_class_t;
            typedef void ( ::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::*energy_function_type )( ::SireFF::EnergyTable &,::SireCAS::Symbol const &,double ) ;
            energy_function_type energy_function_value( &::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::energy );

            InterGroupLJFF_exposer.def(
                "energy"
                , energy_function_value
                , ( bp::arg("energytable"), bp::arg("symbol"), bp::arg("scale_energy")=1 ) );

        }
        {   //::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::field

            typedef SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > > exported_class_t;
            typedef void ( ::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::*field_function_type )( ::SireFF::FieldTable &,double ) ;
            field_function_type field_function_value( &::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::field );

            InterGroupLJFF_exposer.def(
                "field"
                , field_function_value
                , ( bp::arg("fieldtable"), bp::arg("scale_field")=1 ) );

        }
        {   //::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::field

            typedef SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > > exported_class_t;
            typedef void ( ::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::*field_function_type )( ::SireFF::FieldTable &,::SireCAS::Symbol const &,double ) ;
            field_function_type field_function_value( &::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::field );

            InterGroupLJFF_exposer.def(
                "field"
                , field_function_value
                , ( bp::arg("fieldtable"), bp::arg("component"), bp::arg("scale_field")=1 ) );

        }
        {   //::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::field

            typedef SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > > exported_class_t;
            typedef void ( ::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::*field_function_type )( ::SireFF::FieldTable &,::SireFF::Probe const &,double ) ;
            field_function_type field_function_value( &::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::field );

            InterGroupLJFF_exposer.def(
                "field"
                , field_function_value
                , ( bp::arg("fieldtable"), bp::arg("probe"), bp::arg("scale_field")=1 ) );

        }
        {   //::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::field

            typedef SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > > exported_class_t;
            typedef void ( ::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::*field_function_type )( ::SireFF::FieldTable &,::SireCAS::Symbol const &,::SireFF::Probe const &,double ) ;
            field_function_type field_function_value( &::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::field );

            InterGroupLJFF_exposer.def(
                "field"
                , field_function_value
                , ( bp::arg("fieldtable"), bp::arg("component"), bp::arg("probe"), bp::arg("scale_field")=1 ) );

        }
        {   //::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::force

            typedef SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > > exported_class_t;
            typedef void ( ::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::*force_function_type )( ::SireFF::ForceTable &,double ) ;
            force_function_type force_function_value( &::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::force );

            InterGroupLJFF_exposer.def(
                "force"
                , force_function_value
                , ( bp::arg("forcetable"), bp::arg("scale_force")=1 ) );

        }
        {   //::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::force

            typedef SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > > exported_class_t;
            typedef void ( ::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::*force_function_type )( ::SireFF::ForceTable &,::SireCAS::Symbol const &,double ) ;
            force_function_type force_function_value( &::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::force );

            InterGroupLJFF_exposer.def(
                "force"
                , force_function_value
                , ( bp::arg("forcetable"), bp::arg("symbol"), bp::arg("scale_force")=1 ) );

        }
        InterGroupLJFF_exposer.def( bp::self != bp::self );
        {   //::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::operator=

            typedef SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > > exported_class_t;
            typedef ::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > > & ( ::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::*assign_function_type )( ::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > > const & ) ;
            assign_function_type assign_function_value( &::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::operator= );

            InterGroupLJFF_exposer.def(
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >() );

        }
        InterGroupLJFF_exposer.def( bp::self == bp::self );
        {   //::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::potential

            typedef SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > > exported_class_t;
            typedef void ( ::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::*potential_function_type )( ::SireFF::PotentialTable &,double ) ;
            potential_function_type potential_function_value( &::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::potential );

            InterGroupLJFF_exposer.def(
                "potential"
                , potential_function_value
                , ( bp::arg("potentialtable"), bp::arg("scale_potential")=1 ) );

        }
        {   //::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::potential

            typedef SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > > exported_class_t;
            typedef void ( ::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::*potential_function_type )( ::SireFF::PotentialTable &,::SireCAS::Symbol const &,double ) ;
            potential_function_type potential_function_value( &::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::potential );

            InterGroupLJFF_exposer.def(
                "potential"
                , potential_function_value
                , ( bp::arg("potentialtable"), bp::arg("component"), bp::arg("scale_potential")=1 ) );

        }
        {   //::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::potential

            typedef SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > > exported_class_t;
            typedef void ( ::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::*potential_function_type )( ::SireFF::PotentialTable &,::SireFF::Probe const &,double ) ;
            potential_function_type potential_function_value( &::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::potential );

            InterGroupLJFF_exposer.def(
                "potential"
                , potential_function_value
                , ( bp::arg("potentialtable"), bp::arg("probe"), bp::arg("scale_potential")=1 ) );

        }
        {   //::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::potential

            typedef SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > > exported_class_t;
            typedef void ( ::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::*potential_function_type )( ::SireFF::PotentialTable &,::SireCAS::Symbol const &,::SireFF::Probe const &,double ) ;
            potential_function_type potential_function_value( &::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::potential );

            InterGroupLJFF_exposer.def(
                "potential"
                , potential_function_value
                , ( bp::arg("potentialtable"), bp::arg("component"), bp::arg("probe"), bp::arg("scale_potential")=1 ) );

        }
        {   //::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::typeName

            typedef SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > > exported_class_t;
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::typeName );

            InterGroupLJFF_exposer.def(
                "typeName"
                , typeName_function_value );

        }
        {   //::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::what

            typedef SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > > exported_class_t;
            typedef char const * ( ::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::*what_function_type )(  ) const;
            what_function_type what_function_value( &::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::what );

            InterGroupLJFF_exposer.def(
                "what"
                , what_function_value );

        }
        InterGroupLJFF_exposer.staticmethod( "typeName" );
        InterGroupLJFF_exposer.def( "__copy__", &__copy__);
        InterGroupLJFF_exposer.def( "__deepcopy__", &__copy__);
        InterGroupLJFF_exposer.def( "clone", &__copy__);
        InterGroupLJFF_exposer.def( "__str__", &__str__< ::SireFF::Inter2B2G3DFF<SireMM::LJPotentialInterface<SireMM::InterLJPotential> > > );
        InterGroupLJFF_exposer.def( "__repr__", &__str__< ::SireFF::Inter2B2G3DFF<SireMM::LJPotentialInterface<SireMM::InterLJPotential> > > );
        InterGroupLJFF_exposer.def( "__len__", &__len_count< ::SireFF::Inter2B2G3DFF<SireMM::LJPotentialInterface<SireMM::InterLJPotential> > > );
    }

}
Esempio n. 2
0
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 > );
    }

}
Esempio n. 3
0
void register_QMFF_class(){

    { //::Squire::QMFF
        typedef bp::class_< Squire::QMFF, bp::bases< SireFF::FF3D, SireFF::G1FF, SireFF::FF, SireMol::MolGroupsBase, SireBase::Property > > QMFF_exposer_t;
        QMFF_exposer_t QMFF_exposer = QMFF_exposer_t( "QMFF", bp::init< >() );
        bp::scope QMFF_scope( QMFF_exposer );
        QMFF_exposer.def( bp::init< QString const & >(( bp::arg("name") )) );
        QMFF_exposer.def( bp::init< Squire::QMFF const & >(( bp::arg("other") )) );
        { //::Squire::QMFF::components
        
            typedef ::Squire::QMComponent const & ( ::Squire::QMFF::*components_function_type )(  ) const;
            components_function_type components_function_value( &::Squire::QMFF::components );
            
            QMFF_exposer.def( 
                "components"
                , components_function_value
                , bp::return_value_policy<bp::clone_const_reference>() );
        
        }
        { //::Squire::QMFF::containsProperty
        
            typedef bool ( ::Squire::QMFF::*containsProperty_function_type )( ::QString const & ) const;
            containsProperty_function_type containsProperty_function_value( &::Squire::QMFF::containsProperty );
            
            QMFF_exposer.def( 
                "containsProperty"
                , containsProperty_function_value
                , ( bp::arg("name") ) );
        
        }
        { //::Squire::QMFF::energy
        
            typedef void ( ::Squire::QMFF::*energy_function_type )( ::SireFF::EnergyTable &,double ) ;
            energy_function_type energy_function_value( &::Squire::QMFF::energy );
            
            QMFF_exposer.def( 
                "energy"
                , energy_function_value
                , ( bp::arg("energytable"), bp::arg("scale_energy")=1 ) );
        
        }
        { //::Squire::QMFF::energy
        
            typedef void ( ::Squire::QMFF::*energy_function_type )( ::SireFF::EnergyTable &,::SireCAS::Symbol const &,double ) ;
            energy_function_type energy_function_value( &::Squire::QMFF::energy );
            
            QMFF_exposer.def( 
                "energy"
                , energy_function_value
                , ( bp::arg("energytable"), bp::arg("symbol"), bp::arg("scale_energy")=1 ) );
        
        }
        { //::Squire::QMFF::energyCommandFile
        
            typedef ::QString ( ::Squire::QMFF::*energyCommandFile_function_type )(  ) const;
            energyCommandFile_function_type energyCommandFile_function_value( &::Squire::QMFF::energyCommandFile );
            
            QMFF_exposer.def( 
                "energyCommandFile"
                , energyCommandFile_function_value );
        
        }
        { //::Squire::QMFF::field
        
            typedef void ( ::Squire::QMFF::*field_function_type )( ::SireFF::FieldTable &,double ) ;
            field_function_type field_function_value( &::Squire::QMFF::field );
            
            QMFF_exposer.def( 
                "field"
                , field_function_value
                , ( bp::arg("fieldtable"), bp::arg("scale_field")=1 ) );
        
        }
        { //::Squire::QMFF::field
        
            typedef void ( ::Squire::QMFF::*field_function_type )( ::SireFF::FieldTable &,::SireCAS::Symbol const &,double ) ;
            field_function_type field_function_value( &::Squire::QMFF::field );
            
            QMFF_exposer.def( 
                "field"
                , field_function_value
                , ( bp::arg("fieldtable"), bp::arg("component"), bp::arg("scale_field")=1 ) );
        
        }
        { //::Squire::QMFF::field
        
            typedef void ( ::Squire::QMFF::*field_function_type )( ::SireFF::FieldTable &,::SireFF::Probe const &,double ) ;
            field_function_type field_function_value( &::Squire::QMFF::field );
            
            QMFF_exposer.def( 
                "field"
                , field_function_value
                , ( bp::arg("fieldtable"), bp::arg("probe"), bp::arg("scale_field")=1 ) );
        
        }
        { //::Squire::QMFF::field
        
            typedef void ( ::Squire::QMFF::*field_function_type )( ::SireFF::FieldTable &,::SireCAS::Symbol const &,::SireFF::Probe const &,double ) ;
            field_function_type field_function_value( &::Squire::QMFF::field );
            
            QMFF_exposer.def( 
                "field"
                , field_function_value
                , ( bp::arg("fieldtable"), bp::arg("component"), bp::arg("probe"), bp::arg("scale_field")=1 ) );
        
        }
        { //::Squire::QMFF::fieldCommandFile
        
            typedef ::QString ( ::Squire::QMFF::*fieldCommandFile_function_type )( ::SireFF::FieldTable const & ) const;
            fieldCommandFile_function_type fieldCommandFile_function_value( &::Squire::QMFF::fieldCommandFile );
            
            QMFF_exposer.def( 
                "fieldCommandFile"
                , fieldCommandFile_function_value
                , ( bp::arg("fieldtable") ) );
        
        }
        { //::Squire::QMFF::fieldCommandFile
        
            typedef ::QString ( ::Squire::QMFF::*fieldCommandFile_function_type )( ::SireFF::FieldTable const &,::SireFF::Probe const & ) const;
            fieldCommandFile_function_type fieldCommandFile_function_value( &::Squire::QMFF::fieldCommandFile );
            
            QMFF_exposer.def( 
                "fieldCommandFile"
                , fieldCommandFile_function_value
                , ( bp::arg("fieldtable"), bp::arg("probe") ) );
        
        }
        { //::Squire::QMFF::force
        
            typedef void ( ::Squire::QMFF::*force_function_type )( ::SireFF::ForceTable &,double ) ;
            force_function_type force_function_value( &::Squire::QMFF::force );
            
            QMFF_exposer.def( 
                "force"
                , force_function_value
                , ( bp::arg("forcetable"), bp::arg("scale_force")=1 ) );
        
        }
        { //::Squire::QMFF::force
        
            typedef void ( ::Squire::QMFF::*force_function_type )( ::SireFF::ForceTable &,::SireCAS::Symbol const &,double ) ;
            force_function_type force_function_value( &::Squire::QMFF::force );
            
            QMFF_exposer.def( 
                "force"
                , force_function_value
                , ( bp::arg("forcetable"), bp::arg("symbol"), bp::arg("scale_force")=1 ) );
        
        }
        { //::Squire::QMFF::forceCommandFile
        
            typedef ::QString ( ::Squire::QMFF::*forceCommandFile_function_type )( ::SireFF::ForceTable const & ) const;
            forceCommandFile_function_type forceCommandFile_function_value( &::Squire::QMFF::forceCommandFile );
            
            QMFF_exposer.def( 
                "forceCommandFile"
                , forceCommandFile_function_value
                , ( bp::arg("forcetable") ) );
        
        }
        { //::Squire::QMFF::mustNowRecalculateFromScratch
        
            typedef void ( ::Squire::QMFF::*mustNowRecalculateFromScratch_function_type )(  ) ;
            mustNowRecalculateFromScratch_function_type mustNowRecalculateFromScratch_function_value( &::Squire::QMFF::mustNowRecalculateFromScratch );
            
            QMFF_exposer.def( 
                "mustNowRecalculateFromScratch"
                , mustNowRecalculateFromScratch_function_value );
        
        }
        QMFF_exposer.def( bp::self != bp::self );
        { //::Squire::QMFF::operator=
        
            typedef ::Squire::QMFF & ( ::Squire::QMFF::*assign_function_type )( ::Squire::QMFF const & ) ;
            assign_function_type assign_function_value( &::Squire::QMFF::operator= );
            
            QMFF_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >() );
        
        }
        QMFF_exposer.def( bp::self == bp::self );
        { //::Squire::QMFF::parameters
        
            typedef ::SireFF::detail::AtomicParameters3D< SireMol::Element > ( ::Squire::QMFF::*parameters_function_type )(  ) const;
            parameters_function_type parameters_function_value( &::Squire::QMFF::parameters );
            
            QMFF_exposer.def( 
                "parameters"
                , parameters_function_value );
        
        }
        { //::Squire::QMFF::potential
        
            typedef void ( ::Squire::QMFF::*potential_function_type )( ::SireFF::PotentialTable &,double ) ;
            potential_function_type potential_function_value( &::Squire::QMFF::potential );
            
            QMFF_exposer.def( 
                "potential"
                , potential_function_value
                , ( bp::arg("potentialtable"), bp::arg("scale_potential")=1 ) );
        
        }
        { //::Squire::QMFF::potential
        
            typedef void ( ::Squire::QMFF::*potential_function_type )( ::SireFF::PotentialTable &,::SireCAS::Symbol const &,double ) ;
            potential_function_type potential_function_value( &::Squire::QMFF::potential );
            
            QMFF_exposer.def( 
                "potential"
                , potential_function_value
                , ( bp::arg("potentialtable"), bp::arg("component"), bp::arg("scale_potential")=1 ) );
        
        }
        { //::Squire::QMFF::potential
        
            typedef void ( ::Squire::QMFF::*potential_function_type )( ::SireFF::PotentialTable &,::SireFF::Probe const &,double ) ;
            potential_function_type potential_function_value( &::Squire::QMFF::potential );
            
            QMFF_exposer.def( 
                "potential"
                , potential_function_value
                , ( bp::arg("potentialtable"), bp::arg("probe"), bp::arg("scale_potential")=1 ) );
        
        }
        { //::Squire::QMFF::potential
        
            typedef void ( ::Squire::QMFF::*potential_function_type )( ::SireFF::PotentialTable &,::SireCAS::Symbol const &,::SireFF::Probe const &,double ) ;
            potential_function_type potential_function_value( &::Squire::QMFF::potential );
            
            QMFF_exposer.def( 
                "potential"
                , potential_function_value
                , ( bp::arg("potentialtable"), bp::arg("component"), bp::arg("probe"), bp::arg("scale_potential")=1 ) );
        
        }
        { //::Squire::QMFF::potentialCommandFile
        
            typedef ::QString ( ::Squire::QMFF::*potentialCommandFile_function_type )( ::SireFF::PotentialTable const & ) const;
            potentialCommandFile_function_type potentialCommandFile_function_value( &::Squire::QMFF::potentialCommandFile );
            
            QMFF_exposer.def( 
                "potentialCommandFile"
                , potentialCommandFile_function_value
                , ( bp::arg("pottable") ) );
        
        }
        { //::Squire::QMFF::potentialCommandFile
        
            typedef ::QString ( ::Squire::QMFF::*potentialCommandFile_function_type )( ::SireFF::PotentialTable const &,::SireFF::Probe const & ) const;
            potentialCommandFile_function_type potentialCommandFile_function_value( &::Squire::QMFF::potentialCommandFile );
            
            QMFF_exposer.def( 
                "potentialCommandFile"
                , potentialCommandFile_function_value
                , ( bp::arg("pottable"), bp::arg("probe") ) );
        
        }
        { //::Squire::QMFF::properties
        
            typedef ::SireBase::Properties const & ( ::Squire::QMFF::*properties_function_type )(  ) const;
            properties_function_type properties_function_value( &::Squire::QMFF::properties );
            
            QMFF_exposer.def( 
                "properties"
                , properties_function_value
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        { //::Squire::QMFF::property
        
            typedef ::SireBase::Property const & ( ::Squire::QMFF::*property_function_type )( ::QString const & ) const;
            property_function_type property_function_value( &::Squire::QMFF::property );
            
            QMFF_exposer.def( 
                "property"
                , property_function_value
                , ( bp::arg("name") )
                , bp::return_value_policy<bp::clone_const_reference>() );
        
        }
        { //::Squire::QMFF::quantumProgram
        
            typedef ::Squire::QMProgram const & ( ::Squire::QMFF::*quantumProgram_function_type )(  ) const;
            quantumProgram_function_type quantumProgram_function_value( &::Squire::QMFF::quantumProgram );
            
            QMFF_exposer.def( 
                "quantumProgram"
                , quantumProgram_function_value
                , bp::return_value_policy<bp::clone_const_reference>() );
        
        }
        { //::Squire::QMFF::setProperty
        
            typedef bool ( ::Squire::QMFF::*setProperty_function_type )( ::QString const &,::SireBase::Property const & ) ;
            setProperty_function_type setProperty_function_value( &::Squire::QMFF::setProperty );
            
            QMFF_exposer.def( 
                "setProperty"
                , setProperty_function_value
                , ( bp::arg("name"), bp::arg("property") ) );
        
        }
        { //::Squire::QMFF::setQuantumProgram
        
            typedef bool ( ::Squire::QMFF::*setQuantumProgram_function_type )( ::Squire::QMProgram const & ) ;
            setQuantumProgram_function_type setQuantumProgram_function_value( &::Squire::QMFF::setQuantumProgram );
            
            QMFF_exposer.def( 
                "setQuantumProgram"
                , setQuantumProgram_function_value
                , ( bp::arg("qmprog") ) );
        
        }
        { //::Squire::QMFF::setSpace
        
            typedef bool ( ::Squire::QMFF::*setSpace_function_type )( ::SireVol::Space const & ) ;
            setSpace_function_type setSpace_function_value( &::Squire::QMFF::setSpace );
            
            QMFF_exposer.def( 
                "setSpace"
                , setSpace_function_value
                , ( bp::arg("space") ) );
        
        }
        { //::Squire::QMFF::setZeroEnergy
        
            typedef bool ( ::Squire::QMFF::*setZeroEnergy_function_type )( ::SireUnits::Dimension::MolarEnergy ) ;
            setZeroEnergy_function_type setZeroEnergy_function_value( &::Squire::QMFF::setZeroEnergy );
            
            QMFF_exposer.def( 
                "setZeroEnergy"
                , setZeroEnergy_function_value
                , ( bp::arg("zero_energy") ) );
        
        }
        { //::Squire::QMFF::space
        
            typedef ::SireVol::Space const & ( ::Squire::QMFF::*space_function_type )(  ) const;
            space_function_type space_function_value( &::Squire::QMFF::space );
            
            QMFF_exposer.def( 
                "space"
                , space_function_value
                , bp::return_value_policy<bp::clone_const_reference>() );
        
        }
        { //::Squire::QMFF::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::Squire::QMFF::typeName );
            
            QMFF_exposer.def( 
                "typeName"
                , typeName_function_value );
        
        }
        { //::Squire::QMFF::what
        
            typedef char const * ( ::Squire::QMFF::*what_function_type )(  ) const;
            what_function_type what_function_value( &::Squire::QMFF::what );
            
            QMFF_exposer.def( 
                "what"
                , what_function_value );
        
        }
        { //::Squire::QMFF::zeroEnergy
        
            typedef ::SireUnits::Dimension::MolarEnergy ( ::Squire::QMFF::*zeroEnergy_function_type )(  ) const;
            zeroEnergy_function_type zeroEnergy_function_value( &::Squire::QMFF::zeroEnergy );
            
            QMFF_exposer.def( 
                "zeroEnergy"
                , zeroEnergy_function_value );
        
        }
        QMFF_exposer.staticmethod( "typeName" );
        QMFF_exposer.def( "__copy__", &__copy__);
        QMFF_exposer.def( "__deepcopy__", &__copy__);
        QMFF_exposer.def( "clone", &__copy__);
        QMFF_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::Squire::QMFF >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        QMFF_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::Squire::QMFF >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        QMFF_exposer.def( "__str__", &__str__< ::Squire::QMFF > );
        QMFF_exposer.def( "__repr__", &__str__< ::Squire::QMFF > );
        QMFF_exposer.def( "__len__", &__len_count< ::Squire::QMFF > );
    }

}
Esempio n. 4
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 > );
    }

}