void register_StretchBendTorsionComponent_class() {

    {   //::SireMM::StretchBendTorsionComponent
        typedef bp::class_< SireMM::StretchBendTorsionComponent, bp::bases< SireFF::FFComponent, SireCAS::Symbol, SireCAS::ExBase > > StretchBendTorsionComponent_exposer_t;
        StretchBendTorsionComponent_exposer_t StretchBendTorsionComponent_exposer = StretchBendTorsionComponent_exposer_t( "StretchBendTorsionComponent", bp::init< bp::optional< SireFF::FFName const & > >(( bp::arg("ffname")=SireFF::FFName() )) );
        bp::scope StretchBendTorsionComponent_scope( StretchBendTorsionComponent_exposer );
        StretchBendTorsionComponent_exposer.def( bp::init< SireCAS::Symbol const & >(( bp::arg("symbol") )) );
        StretchBendTorsionComponent_exposer.def( bp::init< SireMM::StretchBendTorsionComponent const & >(( bp::arg("other") )) );
        {   //::SireMM::StretchBendTorsionComponent::changeEnergy

            typedef void ( ::SireMM::StretchBendTorsionComponent::*changeEnergy_function_type )( ::SireFF::FF &,::SireMM::StretchBendTorsionEnergy const & ) const;
            changeEnergy_function_type changeEnergy_function_value( &::SireMM::StretchBendTorsionComponent::changeEnergy );

            StretchBendTorsionComponent_exposer.def(
                "changeEnergy"
                , changeEnergy_function_value
                , ( bp::arg("ff"), bp::arg("sbtnrg") ) );

        }
        {   //::SireMM::StretchBendTorsionComponent::setEnergy

            typedef void ( ::SireMM::StretchBendTorsionComponent::*setEnergy_function_type )( ::SireFF::FF &,::SireMM::StretchBendTorsionEnergy const & ) const;
            setEnergy_function_type setEnergy_function_value( &::SireMM::StretchBendTorsionComponent::setEnergy );

            StretchBendTorsionComponent_exposer.def(
                "setEnergy"
                , setEnergy_function_value
                , ( bp::arg("ff"), bp::arg("sbtnrg") ) );

        }
        {   //::SireMM::StretchBendTorsionComponent::symbols

            typedef ::SireCAS::Symbols ( ::SireMM::StretchBendTorsionComponent::*symbols_function_type )(  ) const;
            symbols_function_type symbols_function_value( &::SireMM::StretchBendTorsionComponent::symbols );

            StretchBendTorsionComponent_exposer.def(
                "symbols"
                , symbols_function_value );

        }
        {   //::SireMM::StretchBendTorsionComponent::total

            typedef ::SireMM::StretchBendTorsionComponent const & ( ::SireMM::StretchBendTorsionComponent::*total_function_type )(  ) const;
            total_function_type total_function_value( &::SireMM::StretchBendTorsionComponent::total );

            StretchBendTorsionComponent_exposer.def(
                "total"
                , total_function_value
                , bp::return_value_policy<bp::clone_const_reference>() );

        }
        {   //::SireMM::StretchBendTorsionComponent::typeName

            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireMM::StretchBendTorsionComponent::typeName );

            StretchBendTorsionComponent_exposer.def(
                "typeName"
                , typeName_function_value );

        }
        {   //::SireMM::StretchBendTorsionComponent::what

            typedef char const * ( ::SireMM::StretchBendTorsionComponent::*what_function_type )(  ) const;
            what_function_type what_function_value( &::SireMM::StretchBendTorsionComponent::what );

            StretchBendTorsionComponent_exposer.def(
                "what"
                , what_function_value );

        }
        StretchBendTorsionComponent_exposer.staticmethod( "typeName" );
        StretchBendTorsionComponent_exposer.def( "__copy__", &__copy__);
        StretchBendTorsionComponent_exposer.def( "__deepcopy__", &__copy__);
        StretchBendTorsionComponent_exposer.def( "clone", &__copy__);
        StretchBendTorsionComponent_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::StretchBendTorsionComponent >,
                bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        StretchBendTorsionComponent_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::StretchBendTorsionComponent >,
                bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        StretchBendTorsionComponent_exposer.def( "__str__", &__str__< ::SireMM::StretchBendTorsionComponent > );
        StretchBendTorsionComponent_exposer.def( "__repr__", &__str__< ::SireMM::StretchBendTorsionComponent > );
    }

}
Beispiel #2
0
void register_AngleComponent_class(){

    { //::SireMM::AngleComponent
        typedef bp::class_< SireMM::AngleComponent, bp::bases< SireFF::FFComponent, SireCAS::Symbol, SireCAS::ExBase > > AngleComponent_exposer_t;
        AngleComponent_exposer_t AngleComponent_exposer = AngleComponent_exposer_t( "AngleComponent", "This class represents a Angle component of a forcefield", bp::init< bp::optional< SireFF::FFName const & > >(( bp::arg("ffname")=SireFF::FFName() ), "Constructor") );
        bp::scope AngleComponent_scope( AngleComponent_exposer );
        AngleComponent_exposer.def( bp::init< SireCAS::Symbol const & >(( bp::arg("symbol") ), "Construct from a symbol\nThrow: SireError::incompatible_error\n") );
        AngleComponent_exposer.def( bp::init< SireMM::AngleComponent const & >(( bp::arg("other") ), "Copy constructor") );
        { //::SireMM::AngleComponent::changeEnergy
        
            typedef void ( ::SireMM::AngleComponent::*changeEnergy_function_type)( ::SireFF::FF &,::SireMM::AngleEnergy const & ) const;
            changeEnergy_function_type changeEnergy_function_value( &::SireMM::AngleComponent::changeEnergy );
            
            AngleComponent_exposer.def( 
                "changeEnergy"
                , changeEnergy_function_value
                , ( bp::arg("ff"), bp::arg("angnrg") )
                , "Change the component of the energy in the forcefield ff\nby delta" );
        
        }
        { //::SireMM::AngleComponent::setEnergy
        
            typedef void ( ::SireMM::AngleComponent::*setEnergy_function_type)( ::SireFF::FF &,::SireMM::AngleEnergy const & ) const;
            setEnergy_function_type setEnergy_function_value( &::SireMM::AngleComponent::setEnergy );
            
            AngleComponent_exposer.def( 
                "setEnergy"
                , setEnergy_function_value
                , ( bp::arg("ff"), bp::arg("angnrg") )
                , "Set the component of the energy in the forcefield ff\nto be equal to the passed energy" );
        
        }
        { //::SireMM::AngleComponent::symbols
        
            typedef ::SireCAS::Symbols ( ::SireMM::AngleComponent::*symbols_function_type)(  ) const;
            symbols_function_type symbols_function_value( &::SireMM::AngleComponent::symbols );
            
            AngleComponent_exposer.def( 
                "symbols"
                , symbols_function_value
                , "" );
        
        }
        { //::SireMM::AngleComponent::total
        
            typedef ::SireMM::AngleComponent const & ( ::SireMM::AngleComponent::*total_function_type)(  ) const;
            total_function_type total_function_value( &::SireMM::AngleComponent::total );
            
            AngleComponent_exposer.def( 
                "total"
                , total_function_value
                , bp::return_value_policy<bp::clone_const_reference>()
                , "" );
        
        }
        { //::SireMM::AngleComponent::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireMM::AngleComponent::typeName );
            
            AngleComponent_exposer.def( 
                "typeName"
                , typeName_function_value
                , "" );
        
        }
        { //::SireMM::AngleComponent::what
        
            typedef char const * ( ::SireMM::AngleComponent::*what_function_type)(  ) const;
            what_function_type what_function_value( &::SireMM::AngleComponent::what );
            
            AngleComponent_exposer.def( 
                "what"
                , what_function_value
                , "" );
        
        }
        AngleComponent_exposer.staticmethod( "typeName" );
        AngleComponent_exposer.def( "__copy__", &__copy__);
        AngleComponent_exposer.def( "__deepcopy__", &__copy__);
        AngleComponent_exposer.def( "clone", &__copy__);
        AngleComponent_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::AngleComponent >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        AngleComponent_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::AngleComponent >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        AngleComponent_exposer.def( "__str__", &__str__< ::SireMM::AngleComponent > );
        AngleComponent_exposer.def( "__repr__", &__str__< ::SireMM::AngleComponent > );
        AngleComponent_exposer.def( "__hash__", &::SireMM::AngleComponent::hash );
    }

}