• 设为首页
  • 点击收藏
  • 手机版
    手机扫一扫访问
    迪恩网络手机版
  • 关注官方公众号
    微信扫一扫关注
    迪恩网络公众号

C++ what_function_value函数代码示例

原作者: [db:作者] 来自: [db:来源] 收藏 邀请

本文整理汇总了C++中what_function_value函数的典型用法代码示例。如果您正苦于以下问题:C++ what_function_value函数的具体用法?C++ what_function_value怎么用?C++ what_function_value使用的例子?那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。



在下文中一共展示了what_function_value函数的20个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于我们的系统推荐出更棒的C++代码示例。

示例1: register_CLJAtom_class


//.........这里部分代码省略.........
        
        }
        { //::SireMM::CLJAtom::isDummy
        
            typedef bool ( ::SireMM::CLJAtom::*isDummy_function_type )(  ) const;
            isDummy_function_type isDummy_function_value( &::SireMM::CLJAtom::isDummy );
            
            CLJAtom_exposer.def( 
                "isDummy"
                , isDummy_function_value );
        
        }
        { //::SireMM::CLJAtom::isNull
        
            typedef bool ( ::SireMM::CLJAtom::*isNull_function_type )(  ) const;
            isNull_function_type isNull_function_value( &::SireMM::CLJAtom::isNull );
            
            CLJAtom_exposer.def( 
                "isNull"
                , isNull_function_value );
        
        }
        { //::SireMM::CLJAtom::ljParameter
        
            typedef ::SireMM::LJParameter ( ::SireMM::CLJAtom::*ljParameter_function_type )(  ) const;
            ljParameter_function_type ljParameter_function_value( &::SireMM::CLJAtom::ljParameter );
            
            CLJAtom_exposer.def( 
                "ljParameter"
                , ljParameter_function_value );
        
        }
        { //::SireMM::CLJAtom::negate
        
            typedef ::SireMM::CLJAtom ( ::SireMM::CLJAtom::*negate_function_type )(  ) const;
            negate_function_type negate_function_value( &::SireMM::CLJAtom::negate );
            
            CLJAtom_exposer.def( 
                "negate"
                , negate_function_value );
        
        }
        CLJAtom_exposer.def( bp::self != bp::self );
        { //::SireMM::CLJAtom::operator=
        
            typedef ::SireMM::CLJAtom & ( ::SireMM::CLJAtom::*assign_function_type )( ::SireMM::CLJAtom const & ) ;
            assign_function_type assign_function_value( &::SireMM::CLJAtom::operator= );
            
            CLJAtom_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >() );
        
        }
        CLJAtom_exposer.def( bp::self == bp::self );
        { //::SireMM::CLJAtom::toString
        
            typedef ::QString ( ::SireMM::CLJAtom::*toString_function_type )(  ) const;
            toString_function_type toString_function_value( &::SireMM::CLJAtom::toString );
            
            CLJAtom_exposer.def( 
                "toString"
                , toString_function_value );
        
        }
        { //::SireMM::CLJAtom::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireMM::CLJAtom::typeName );
            
            CLJAtom_exposer.def( 
                "typeName"
                , typeName_function_value );
        
        }
        { //::SireMM::CLJAtom::what
        
            typedef char const * ( ::SireMM::CLJAtom::*what_function_type )(  ) const;
            what_function_type what_function_value( &::SireMM::CLJAtom::what );
            
            CLJAtom_exposer.def( 
                "what"
                , what_function_value );
        
        }
        CLJAtom_exposer.staticmethod( "buildFrom" );
        CLJAtom_exposer.staticmethod( "typeName" );
        CLJAtom_exposer.def( "__copy__", &__copy__);
        CLJAtom_exposer.def( "__deepcopy__", &__copy__);
        CLJAtom_exposer.def( "clone", &__copy__);
        CLJAtom_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::CLJAtom >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        CLJAtom_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::CLJAtom >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        CLJAtom_exposer.def( "__str__", &__str__< ::SireMM::CLJAtom > );
        CLJAtom_exposer.def( "__repr__", &__str__< ::SireMM::CLJAtom > );
    }

}
开发者ID:Alwnikrotikz,项目名称:sire,代码行数:101,代码来源:CLJAtom.pypp.cpp


示例2: register_CoordGroupArray_class


//.........这里部分代码省略.........
                , ( bp::arg("i"), bp::arg("t") )
                , "Transform all of the coordinates in the CoordGroup at index i using\nthe transformation t\nThrow: SireError::invalid_index\n" );
        
        }
        { //::SireVol::CoordGroupArray::translate
        
            typedef void ( ::SireVol::CoordGroupArray::*translate_function_type)( ::SireMaths::Vector const & ) ;
            translate_function_type translate_function_value( &::SireVol::CoordGroupArray::translate );
            
            CoordGroupArray_exposer.def( 
                "translate"
                , translate_function_value
                , ( bp::arg("delta") )
                , "Translate all of the coordinates in this array by delta" );
        
        }
        { //::SireVol::CoordGroupArray::translate
        
            typedef void ( ::SireVol::CoordGroupArray::*translate_function_type)( ::quint32,::SireMaths::Vector const & ) ;
            translate_function_type translate_function_value( &::SireVol::CoordGroupArray::translate );
            
            CoordGroupArray_exposer.def( 
                "translate"
                , translate_function_value
                , ( bp::arg("i"), bp::arg("delta") )
                , "Translate all of the coordinates in the ith CoordGroup by delta" );
        
        }
        { //::SireVol::CoordGroupArray::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireVol::CoordGroupArray::typeName );
            
            CoordGroupArray_exposer.def( 
                "typeName"
                , typeName_function_value
                , "" );
        
        }
        { //::SireVol::CoordGroupArray::update
        
            typedef void ( ::SireVol::CoordGroupArray::*update_function_type)( ::quint32,::SireVol::CoordGroup const & ) ;
            update_function_type update_function_value( &::SireVol::CoordGroupArray::update );
            
            CoordGroupArray_exposer.def( 
                "update"
                , update_function_value
                , ( bp::arg("i"), bp::arg("cgroup") )
                , "Update the CoordGroup at index i so that it is equal to cgroup. Note\nthat cgroup must contain the same number of coordinates as the existing\nCoordGroup at this index\nThrow: SireError::invalid_index\nThrow: SireError::incompatible_error\n" );
        
        }
        { //::SireVol::CoordGroupArray::update
        
            typedef void ( ::SireVol::CoordGroupArray::*update_function_type)( ::quint32,::QVector< SireMaths::Vector > const & ) ;
            update_function_type update_function_value( &::SireVol::CoordGroupArray::update );
            
            CoordGroupArray_exposer.def( 
                "update"
                , update_function_value
                , ( bp::arg("i"), bp::arg("coords") )
                , "Update the CoordGroup at index i so that it has coordinates coords\nThere must contain the same number of coordinates as the existing\nCoordGroup at this index\nThrow: SireError::invalid_index\nThrow: SireError::incompatible_error\n" );
        
        }
        { //::SireVol::CoordGroupArray::update
        
            typedef void ( ::SireVol::CoordGroupArray::*update_function_type)( ::quint32,::SireMaths::Vector const *,int ) ;
            update_function_type update_function_value( &::SireVol::CoordGroupArray::update );
            
            CoordGroupArray_exposer.def( 
                "update"
                , update_function_value
                , ( bp::arg("i"), bp::arg("coords"), bp::arg("ncoords") )
                , "Update the CoordGroup at index i so that it has coordinates coords\n(there are ncoords coordinates in this array)\nThere must contain the same number of coordinates as the existing\nCoordGroup at this index\nThrow: SireError::invalid_index\nThrow: SireError::incompatible_error\n" );
        
        }
        { //::SireVol::CoordGroupArray::what
        
            typedef char const * ( ::SireVol::CoordGroupArray::*what_function_type)(  ) const;
            what_function_type what_function_value( &::SireVol::CoordGroupArray::what );
            
            CoordGroupArray_exposer.def( 
                "what"
                , what_function_value
                , "" );
        
        }
        CoordGroupArray_exposer.staticmethod( "typeName" );
        CoordGroupArray_exposer.def( "__copy__", &__copy__);
        CoordGroupArray_exposer.def( "__deepcopy__", &__copy__);
        CoordGroupArray_exposer.def( "clone", &__copy__);
        CoordGroupArray_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireVol::CoordGroupArray >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        CoordGroupArray_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireVol::CoordGroupArray >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        CoordGroupArray_exposer.def( "__str__", &__str__< ::SireVol::CoordGroupArray > );
        CoordGroupArray_exposer.def( "__repr__", &__str__< ::SireVol::CoordGroupArray > );
        CoordGroupArray_exposer.def( "__len__", &__len_size< ::SireVol::CoordGroupArray > );
    }

}
开发者ID:Steboss,项目名称:Sire,代码行数:101,代码来源:CoordGroupArray.pypp.cpp


示例3: register_ExBase_class


//.........这里部分代码省略.........
                "symbols"
                , symbols_function_value
                , "Return the set of Symbols that appear in this ExBase" );
        
        }
        { //::SireCAS::ExBase::toOpenMMString
        
            typedef ::QString ( ::SireCAS::ExBase::*toOpenMMString_function_type)(  ) const;
            toOpenMMString_function_type toOpenMMString_function_value( &::SireCAS::ExBase::toOpenMMString );
            
            ExBase_exposer.def( 
                "toOpenMMString"
                , toOpenMMString_function_value
                , "Return a string representation of this object in the OpenMM syntax" );
        
        }
        { //::SireCAS::ExBase::toString
        
            typedef ::QString ( ::SireCAS::ExBase::*toString_function_type)(  ) const;
            toString_function_type toString_function_value( &::SireCAS::ExBase::toString );
            
            ExBase_exposer.def( 
                "toString"
                , toString_function_value
                , "Return a string representation of this object" );
        
        }
        { //::SireCAS::ExBase::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireCAS::ExBase::typeName );
            
            ExBase_exposer.def( 
                "typeName"
                , typeName_function_value
                , "Return the name of this class type" );
        
        }
        { //::SireCAS::ExBase::what
        
            typedef char const * ( ::SireCAS::ExBase::*what_function_type)(  ) const;
            what_function_type what_function_value( &::SireCAS::ExBase::what );
            
            ExBase_exposer.def( 
                "what"
                , what_function_value
                , "Return the name of the type of this ExBase object" );
        
        }
        ExBase_exposer.staticmethod( "typeName" );
        ExBase_exposer.def( bp::self * bp::self );
        ExBase_exposer.def( bp::self * bp::other< SireCAS::Expression >() );
        ExBase_exposer.def( bp::self * bp::other< double >() );
        ExBase_exposer.def( bp::other< double >() * bp::self );
        ExBase_exposer.def( bp::self * bp::other< SireMaths::Complex >() );
        ExBase_exposer.def( bp::self + bp::self );
        ExBase_exposer.def( bp::self + bp::other< SireCAS::Expression >() );
        ExBase_exposer.def( bp::self + bp::other< double >() );
        ExBase_exposer.def( bp::other< double >() + bp::self );
        ExBase_exposer.def( bp::self + bp::other< SireMaths::Complex >() );
        ExBase_exposer.def( bp::self - bp::self );
        ExBase_exposer.def( bp::self - bp::other< SireCAS::Expression >() );
        ExBase_exposer.def( bp::self - bp::other< double >() );
        ExBase_exposer.def( bp::other< double >() - bp::self );
        ExBase_exposer.def( bp::self - bp::other< SireMaths::Complex >() );
        ExBase_exposer.def( bp::self / bp::self );
        ExBase_exposer.def( bp::self / bp::other< SireCAS::Expression >() );
        ExBase_exposer.def( bp::self / bp::other< double >() );
        ExBase_exposer.def( bp::other< double >() / bp::self );
        ExBase_exposer.def( bp::self / bp::other< SireMaths::Complex >() );
        ExBase_exposer.def( self + self );
        ExBase_exposer.def( self - self );
        ExBase_exposer.def( self * self );
        ExBase_exposer.def( self / self );
        ExBase_exposer.def( other<double>() + self );
        ExBase_exposer.def( other<double>() - self );
        ExBase_exposer.def( other<double>() * self );
        ExBase_exposer.def( other<double>() / self );
        ExBase_exposer.def( self + other<double>() );
        ExBase_exposer.def( self - other<double>() );
        ExBase_exposer.def( self * other<double>() );
        ExBase_exposer.def( self / other<double>() );
        ExBase_exposer.def( other<SireMaths::Complex>() + self );
        ExBase_exposer.def( other<SireMaths::Complex>() - self );
        ExBase_exposer.def( other<SireMaths::Complex>() * self );
        ExBase_exposer.def( other<SireMaths::Complex>() / self );
        ExBase_exposer.def( self + other<SireMaths::Complex>() );
        ExBase_exposer.def( self - other<SireMaths::Complex>() );
        ExBase_exposer.def( self * other<SireMaths::Complex>() );
        ExBase_exposer.def( self / other<SireMaths::Complex>() );
        ExBase_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireCAS::ExBase >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        ExBase_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireCAS::ExBase >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        ExBase_exposer.def( "__str__", &__str__< ::SireCAS::ExBase > );
        ExBase_exposer.def( "__repr__", &__str__< ::SireCAS::ExBase > );
        ExBase_exposer.def( "__hash__", &::SireCAS::ExBase::hash );
    }

}
开发者ID:Steboss,项目名称:Sire,代码行数:101,代码来源:ExBase.pypp.cpp


示例4: register_Specify_SegID__class


//.........这里部分代码省略.........
        }
        Specify_SegID__exposer.def( bp::self != bp::self );
        Specify_SegID__exposer.def( bp::self != bp::other< SireID::ID >() );
        { //::SireID::Specify< SireMol::SegID >::operator()
        
            typedef SireID::Specify< SireMol::SegID > exported_class_t;
            typedef ::SireID::Specify< SireMol::SegID > ( ::SireID::Specify< SireMol::SegID >::*__call___function_type )( int ) const;
            __call___function_type __call___function_value( &::SireID::Specify< SireMol::SegID >::operator() );
            
            Specify_SegID__exposer.def( 
                "__call__"
                , __call___function_value
                , ( bp::arg("i") ) );
        
        }
        { //::SireID::Specify< SireMol::SegID >::operator()
        
            typedef SireID::Specify< SireMol::SegID > exported_class_t;
            typedef ::SireID::Specify< SireMol::SegID > ( ::SireID::Specify< SireMol::SegID >::*__call___function_type )( int,int ) const;
            __call___function_type __call___function_value( &::SireID::Specify< SireMol::SegID >::operator() );
            
            Specify_SegID__exposer.def( 
                "__call__"
                , __call___function_value
                , ( bp::arg("i"), bp::arg("j") ) );
        
        }
        { //::SireID::Specify< SireMol::SegID >::operator=
        
            typedef SireID::Specify< SireMol::SegID > exported_class_t;
            typedef ::SireID::Specify< SireMol::SegID > & ( ::SireID::Specify< SireMol::SegID >::*assign_function_type )( ::SireID::Specify< SireMol::SegID > const & ) ;
            assign_function_type assign_function_value( &::SireID::Specify< SireMol::SegID >::operator= );
            
            Specify_SegID__exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >() );
        
        }
        Specify_SegID__exposer.def( bp::self == bp::self );
        Specify_SegID__exposer.def( bp::self == bp::other< SireID::ID >() );
        { //::SireID::Specify< SireMol::SegID >::operator[]
        
            typedef SireID::Specify< SireMol::SegID > exported_class_t;
            typedef ::SireID::Specify< SireMol::SegID > ( ::SireID::Specify< SireMol::SegID >::*__getitem___function_type )( int ) const;
            __getitem___function_type __getitem___function_value( &::SireID::Specify< SireMol::SegID >::operator[] );
            
            Specify_SegID__exposer.def( 
                "__getitem__"
                , __getitem___function_value
                , ( bp::arg("i") ) );
        
        }
        { //::SireID::Specify< SireMol::SegID >::toString
        
            typedef SireID::Specify< SireMol::SegID > exported_class_t;
            typedef ::QString ( ::SireID::Specify< SireMol::SegID >::*toString_function_type )(  ) const;
            toString_function_type toString_function_value( &::SireID::Specify< SireMol::SegID >::toString );
            
            Specify_SegID__exposer.def( 
                "toString"
                , toString_function_value );
        
        }
        { //::SireID::Specify< SireMol::SegID >::typeName
        
            typedef SireID::Specify< SireMol::SegID > exported_class_t;
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireID::Specify< SireMol::SegID >::typeName );
            
            Specify_SegID__exposer.def( 
                "typeName"
                , typeName_function_value );
        
        }
        { //::SireID::Specify< SireMol::SegID >::what
        
            typedef SireID::Specify< SireMol::SegID > exported_class_t;
            typedef char const * ( ::SireID::Specify< SireMol::SegID >::*what_function_type )(  ) const;
            what_function_type what_function_value( &::SireID::Specify< SireMol::SegID >::what );
            
            Specify_SegID__exposer.def( 
                "what"
                , what_function_value );
        
        }
        Specify_SegID__exposer.staticmethod( "typeName" );
        Specify_SegID__exposer.def( "__copy__", &__copy__);
        Specify_SegID__exposer.def( "__deepcopy__", &__copy__);
        Specify_SegID__exposer.def( "clone", &__copy__);
        Specify_SegID__exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireID::Specify<SireMol::SegID> >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        Specify_SegID__exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireID::Specify<SireMol::SegID> >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        Specify_SegID__exposer.def( "__str__", &__str__< ::SireID::Specify<SireMol::SegID> > );
        Specify_SegID__exposer.def( "__repr__", &__str__< ::SireID::Specify<SireMol::SegID> > );
    }

}
开发者ID:Alwnikrotikz,项目名称:sire,代码行数:101,代码来源:Specify_SegID_.pypp.cpp


示例5: register_MultiVector_class


//.........这里部分代码省略.........
            
            MultiVector_exposer.def( 
                "swap"
                , swap_function_value
                , ( bp::arg("v0"), bp::arg("idx0"), bp::arg("v1"), bp::arg("idx1") )
                , "Swap the values of the value at index idx0 in f0 with the value at index idx in f1" );
        
        }
        { //::SireMaths::MultiVector::toString
        
            typedef ::QString ( ::SireMaths::MultiVector::*toString_function_type)(  ) const;
            toString_function_type toString_function_value( &::SireMaths::MultiVector::toString );
            
            MultiVector_exposer.def( 
                "toString"
                , toString_function_value
                , "Return a QString representation of the vector" );
        
        }
        { //::SireMaths::MultiVector::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireMaths::MultiVector::typeName );
            
            MultiVector_exposer.def( 
                "typeName"
                , typeName_function_value
                , "" );
        
        }
        { //::SireMaths::MultiVector::what
        
            typedef char const * ( ::SireMaths::MultiVector::*what_function_type)(  ) const;
            what_function_type what_function_value( &::SireMaths::MultiVector::what );
            
            MultiVector_exposer.def( 
                "what"
                , what_function_value
                , "" );
        
        }
        { //::SireMaths::MultiVector::x
        
            typedef ::SireMaths::MultiDouble const & ( ::SireMaths::MultiVector::*x_function_type)(  ) const;
            x_function_type x_function_value( &::SireMaths::MultiVector::x );
            
            MultiVector_exposer.def( 
                "x"
                , x_function_value
                , bp::return_value_policy< bp::copy_const_reference >()
                , "" );
        
        }
        { //::SireMaths::MultiVector::y
        
            typedef ::SireMaths::MultiDouble const & ( ::SireMaths::MultiVector::*y_function_type)(  ) const;
            y_function_type y_function_value( &::SireMaths::MultiVector::y );
            
            MultiVector_exposer.def( 
                "y"
                , y_function_value
                , bp::return_value_policy< bp::copy_const_reference >()
                , "" );
        
        }
        { //::SireMaths::MultiVector::z
开发者ID:Steboss,项目名称:Sire,代码行数:67,代码来源:MultiVector.pypp.cpp


示例6: register_AngleComponent_class

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 );
    }

}
开发者ID:Steboss,项目名称:Sire,代码行数:91,代码来源:AngleComponent.pypp.cpp


示例7: register_Expression_class


//.........这里部分代码省略.........
        { //::SireCAS::Expression::symbols
        
            typedef ::SireCAS::Symbols ( ::SireCAS::Expression::*symbols_function_type )(  ) const;
            symbols_function_type symbols_function_value( &::SireCAS::Expression::symbols );
            
            Expression_exposer.def( 
                "symbols"
                , symbols_function_value );
        
        }
        { //::SireCAS::Expression::toString
        
            typedef ::QString ( ::SireCAS::Expression::*toString_function_type )(  ) const;
            toString_function_type toString_function_value( &::SireCAS::Expression::toString );
            
            Expression_exposer.def( 
                "toString"
                , toString_function_value );
        
        }
        { //::SireCAS::Expression::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireCAS::Expression::typeName );
            
            Expression_exposer.def( 
                "typeName"
                , typeName_function_value );
        
        }
        { //::SireCAS::Expression::what
        
            typedef char const * ( ::SireCAS::Expression::*what_function_type )(  ) const;
            what_function_type what_function_value( &::SireCAS::Expression::what );
            
            Expression_exposer.def( 
                "what"
                , what_function_value );
        
        }
        Expression_exposer.staticmethod( "typeName" );
        Expression_exposer.def( bp::self * bp::other< SireMaths::Complex >() );
        Expression_exposer.def( bp::other< SireMaths::Complex >() * bp::self );
        Expression_exposer.def( bp::self * bp::other< double >() );
        Expression_exposer.def( bp::other< double >() * bp::self );
        Expression_exposer.def( bp::self * bp::self );
        Expression_exposer.def( bp::self * bp::other< SireCAS::ExBase >() );
        Expression_exposer.def( bp::other< SireMaths::Complex >() + bp::self );
        Expression_exposer.def( bp::self + bp::other< SireMaths::Complex >() );
        Expression_exposer.def( bp::other< double >() + bp::self );
        Expression_exposer.def( bp::self + bp::other< double >() );
        Expression_exposer.def( bp::self + bp::self );
        Expression_exposer.def( bp::self + bp::other< SireCAS::ExBase >() );
        Expression_exposer.def( bp::other< double >() - bp::self );
        Expression_exposer.def( bp::self - bp::other< double >() );
        Expression_exposer.def( bp::self - bp::self );
        Expression_exposer.def( bp::self - bp::other< SireCAS::ExBase >() );
        Expression_exposer.def( bp::other< SireMaths::Complex >() / bp::self );
        Expression_exposer.def( bp::self / bp::other< SireMaths::Complex >() );
        Expression_exposer.def( bp::other< double >() / bp::self );
        Expression_exposer.def( bp::self / bp::other< double >() );
        Expression_exposer.def( bp::self / bp::self );
        Expression_exposer.def( bp::self / bp::other< SireCAS::ExBase >() );
        Expression_exposer.def( self + self );
        Expression_exposer.def( self - self );
        Expression_exposer.def( self * self );
开发者ID:Alwnikrotikz,项目名称:sire,代码行数:67,代码来源:Expression.pypp.cpp


示例8: register_Process_class


//.........这里部分代码省略.........
            run_function_type run_function_value( &::SireBase::Process::run );
            
            Process_exposer.def( 
                "run"
                , run_function_value
                , ( bp::arg("command") )
                , "Run the command command and return a Process object that can be\nused to monitor the command" );
        
        }
        { //::SireBase::Process::run
        
            typedef ::SireBase::Process ( *run_function_type )( ::QString const &,::QString const & );
            run_function_type run_function_value( &::SireBase::Process::run );
            
            Process_exposer.def( 
                "run"
                , run_function_value
                , ( bp::arg("command"), bp::arg("arg") )
                , "Run the command command with the solitary argument arg" );
        
        }
        { //::SireBase::Process::run
        
            typedef ::SireBase::Process ( *run_function_type )( ::QString const &,::QStringList const & );
            run_function_type run_function_value( &::SireBase::Process::run );
            
            Process_exposer.def( 
                "run"
                , run_function_value
                , ( bp::arg("command"), bp::arg("arguments") )
                , "Run the command command with the arguments arguments, and\nreturn a Process object that can be used to query and control the\njob" );
        
        }
        { //::SireBase::Process::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireBase::Process::typeName );
            
            Process_exposer.def( 
                "typeName"
                , typeName_function_value
                , "" );
        
        }
        { //::SireBase::Process::wait
        
            typedef void ( ::SireBase::Process::*wait_function_type)(  ) ;
            wait_function_type wait_function_value( &::SireBase::Process::wait );
            
            Process_exposer.def( 
                "wait"
                , wait_function_value
                , "Wait until the process has finished" );
        
        }
        { //::SireBase::Process::wait
        
            typedef bool ( ::SireBase::Process::*wait_function_type)( int ) ;
            wait_function_type wait_function_value( &::SireBase::Process::wait );
            
            Process_exposer.def( 
                "wait"
                , wait_function_value
                , ( bp::arg("ms") )
                , "Wait until the process has finished, or until ms milliseconds have passed.\nThis returns whether or not the process has finished" );
        
        }
        { //::SireBase::Process::wasKilled
        
            typedef bool ( ::SireBase::Process::*wasKilled_function_type)(  ) ;
            wasKilled_function_type wasKilled_function_value( &::SireBase::Process::wasKilled );
            
            Process_exposer.def( 
                "wasKilled"
                , wasKilled_function_value
                , "Return whether or not the process was killed" );
        
        }
        { //::SireBase::Process::what
        
            typedef char const * ( ::SireBase::Process::*what_function_type)(  ) const;
            what_function_type what_function_value( &::SireBase::Process::what );
            
            Process_exposer.def( 
                "what"
                , what_function_value
                , "" );
        
        }
        Process_exposer.staticmethod( "killAll" );
        Process_exposer.staticmethod( "run" );
        Process_exposer.staticmethod( "typeName" );
        Process_exposer.def( "__copy__", &__copy__);
        Process_exposer.def( "__deepcopy__", &__copy__);
        Process_exposer.def( "clone", &__copy__);
        Process_exposer.def( "__str__", &pvt_get_name);
        Process_exposer.def( "__repr__", &pvt_get_name);
    }

}
开发者ID:Steboss,项目名称:Sire,代码行数:101,代码来源:Process.pypp.cpp


示例9: register_MolWithResID_class


//.........这里部分代码省略.........
            typedef ::QList< SireMol::MolNum > ( ::SireMol::MolWithResID::*map_function_type )( ::SireMol::Molecules const & ) const;
            map_function_type map_function_value( &::SireMol::MolWithResID::map );
            
            MolWithResID_exposer.def( 
                "map"
                , map_function_value
                , ( bp::arg("molecules") ) );
        
        }
        { //::SireMol::MolWithResID::map
        
            typedef ::QList< SireMol::MolNum > ( ::SireMol::MolWithResID::*map_function_type )( ::SireMol::MoleculeGroup const & ) const;
            map_function_type map_function_value( &::SireMol::MolWithResID::map );
            
            MolWithResID_exposer.def( 
                "map"
                , map_function_value
                , ( bp::arg("molgroup") ) );
        
        }
        { //::SireMol::MolWithResID::map
        
            typedef ::QList< SireMol::MolNum > ( ::SireMol::MolWithResID::*map_function_type )( ::SireMol::MolGroupsBase const & ) const;
            map_function_type map_function_value( &::SireMol::MolWithResID::map );
            
            MolWithResID_exposer.def( 
                "map"
                , map_function_value
                , ( bp::arg("molgroups") ) );
        
        }
        MolWithResID_exposer.def( bp::self != bp::self );
        { //::SireMol::MolWithResID::operator=
        
            typedef ::SireMol::MolWithResID & ( ::SireMol::MolWithResID::*assign_function_type )( ::SireMol::MolWithResID const & ) ;
            assign_function_type assign_function_value( &::SireMol::MolWithResID::operator= );
            
            MolWithResID_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >() );
        
        }
        MolWithResID_exposer.def( bp::self == bp::other< SireID::ID >() );
        MolWithResID_exposer.def( bp::self == bp::self );
        { //::SireMol::MolWithResID::resID
        
            typedef ::SireMol::ResID const & ( ::SireMol::MolWithResID::*resID_function_type )(  ) const;
            resID_function_type resID_function_value( &::SireMol::MolWithResID::resID );
            
            MolWithResID_exposer.def( 
                "resID"
                , resID_function_value
                , bp::return_value_policy<bp::clone_const_reference>() );
        
        }
        { //::SireMol::MolWithResID::toString
        
            typedef ::QString ( ::SireMol::MolWithResID::*toString_function_type )(  ) const;
            toString_function_type toString_function_value( &::SireMol::MolWithResID::toString );
            
            MolWithResID_exposer.def( 
                "toString"
                , toString_function_value );
        
        }
        { //::SireMol::MolWithResID::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireMol::MolWithResID::typeName );
            
            MolWithResID_exposer.def( 
                "typeName"
                , typeName_function_value );
        
        }
        { //::SireMol::MolWithResID::what
        
            typedef char const * ( ::SireMol::MolWithResID::*what_function_type )(  ) const;
            what_function_type what_function_value( &::SireMol::MolWithResID::what );
            
            MolWithResID_exposer.def( 
                "what"
                , what_function_value );
        
        }
        MolWithResID_exposer.staticmethod( "typeName" );
        MolWithResID_exposer.def( "__copy__", &__copy__);
        MolWithResID_exposer.def( "__deepcopy__", &__copy__);
        MolWithResID_exposer.def( "clone", &__copy__);
        MolWithResID_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::MolWithResID >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        MolWithResID_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::MolWithResID >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        MolWithResID_exposer.def( "__str__", &__str__< ::SireMol::MolWithResID > );
        MolWithResID_exposer.def( "__repr__", &__str__< ::SireMol::MolWithResID > );
    }

}
开发者ID:Alwnikrotikz,项目名称:sire,代码行数:101,代码来源:MolWithResID.pypp.cpp


示例10: register_IDOrSet_SegID__class


//.........这里部分代码省略.........
        
            typedef SireID::IDOrSet< SireMol::SegID > exported_class_t;
            typedef bool ( ::SireID::IDOrSet< SireMol::SegID >::*isNull_function_type )(  ) const;
            isNull_function_type isNull_function_value( &::SireID::IDOrSet< SireMol::SegID >::isNull );
            
            IDOrSet_SegID__exposer.def( 
                "isNull"
                , isNull_function_value );
        
        }
        { //::SireID::IDOrSet< SireMol::SegID >::map
        
            typedef SireID::IDOrSet< SireMol::SegID > exported_class_t;
            typedef ::QList< SireMol::SegIdx > ( ::SireID::IDOrSet< SireMol::SegID >::*map_function_type )( ::SireMol::MolInfo const & ) const;
            map_function_type map_function_value( &::SireID::IDOrSet< SireMol::SegID >::map );
            
            IDOrSet_SegID__exposer.def( 
                "map"
                , map_function_value
                , ( bp::arg("obj") ) );
        
        }
        IDOrSet_SegID__exposer.def( bp::self != bp::other< SireID::ID >() );
        IDOrSet_SegID__exposer.def( bp::self != bp::self );
        IDOrSet_SegID__exposer.def( bp::self != bp::other< SireMol::SegID >() );
        { //::SireID::IDOrSet< SireMol::SegID >::operator=
        
            typedef SireID::IDOrSet< SireMol::SegID > exported_class_t;
            typedef ::SireID::IDOrSet< SireMol::SegID > & ( ::SireID::IDOrSet< SireMol::SegID >::*assign_function_type )( ::SireID::IDOrSet< SireMol::SegID > const & ) ;
            assign_function_type assign_function_value( &::SireID::IDOrSet< SireMol::SegID >::operator= );
            
            IDOrSet_SegID__exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >() );
        
        }
        { //::SireID::IDOrSet< SireMol::SegID >::operator=
        
            typedef SireID::IDOrSet< SireMol::SegID > exported_class_t;
            typedef ::SireID::IDOrSet< SireMol::SegID > & ( ::SireID::IDOrSet< SireMol::SegID >::*assign_function_type )( ::SireMol::SegID const & ) ;
            assign_function_type assign_function_value( &::SireID::IDOrSet< SireMol::SegID >::operator= );
            
            IDOrSet_SegID__exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >() );
        
        }
        IDOrSet_SegID__exposer.def( bp::self == bp::other< SireID::ID >() );
        IDOrSet_SegID__exposer.def( bp::self == bp::self );
        IDOrSet_SegID__exposer.def( bp::self == bp::other< SireMol::SegID >() );
        { //::SireID::IDOrSet< SireMol::SegID >::toString
        
            typedef SireID::IDOrSet< SireMol::SegID > exported_class_t;
            typedef ::QString ( ::SireID::IDOrSet< SireMol::SegID >::*toString_function_type )(  ) const;
            toString_function_type toString_function_value( &::SireID::IDOrSet< SireMol::SegID >::toString );
            
            IDOrSet_SegID__exposer.def( 
                "toString"
                , toString_function_value );
        
        }
        { //::SireID::IDOrSet< SireMol::SegID >::typeName
        
            typedef SireID::IDOrSet< SireMol::SegID > exported_class_t;
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireID::IDOrSet< SireMol::SegID >::typeName );
            
            IDOrSet_SegID__exposer.def( 
                "typeName"
                , typeName_function_value );
        
        }
        { //::SireID::IDOrSet< SireMol::SegID >::what
        
            typedef SireID::IDOrSet< SireMol::SegID > exported_class_t;
            typedef char const * ( ::SireID::IDOrSet< SireMol::SegID >::*what_function_type )(  ) const;
            what_function_type what_function_value( &::SireID::IDOrSet< SireMol::SegID >::what );
            
            IDOrSet_SegID__exposer.def( 
                "what"
                , what_function_value );
        
        }
        IDOrSet_SegID__exposer.staticmethod( "typeName" );
        IDOrSet_SegID__exposer.def( "__copy__", &__copy__);
        IDOrSet_SegID__exposer.def( "__deepcopy__", &__copy__);
        IDOrSet_SegID__exposer.def( "clone", &__copy__);
        IDOrSet_SegID__exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireID::IDOrSet<SireMol::SegID> >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        IDOrSet_SegID__exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireID::IDOrSet<SireMol::SegID> >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        IDOrSet_SegID__exposer.def( "__str__", &__str__< ::SireID::IDOrSet<SireMol::SegID> > );
        IDOrSet_SegID__exposer.def( "__repr__", &__str__< ::SireID::IDOrSet<SireMol::SegID> > );
    }

}
开发者ID:Alwnikrotikz,项目名称:sire,代码行数:101,代码来源:IDOrSet_SegID_.pypp.cpp


示例11: register_Process_class


//.........这里部分代码省略.........
                , ( bp::arg("other") )
                , bp::return_self< >() );
        
        }
        Process_exposer.def( bp::self == bp::self );
        { //::SireBase::Process::run
        
            typedef ::SireBase::Process ( *run_function_type )( ::QString const & );
            run_function_type run_function_value( &::SireBase::Process::run );
            
            Process_exposer.def( 
                "run"
                , run_function_value
                , ( bp::arg("command") ) );
        
        }
        { //::SireBase::Process::run
        
            typedef ::SireBase::Process ( *run_function_type )( ::QString const &,::QString const & );
            run_function_type run_function_value( &::SireBase::Process::run );
            
            Process_exposer.def( 
                "run"
                , run_function_value
                , ( bp::arg("command"), bp::arg("arg") ) );
        
        }
        { //::SireBase::Process::run
        
            typedef ::SireBase::Process ( *run_function_type )( ::QString const &,::QStringList const & );
            run_function_type run_function_value( &::SireBase::Process::run );
            
            Proce 

鲜花

握手

雷人

路过

鸡蛋
该文章已有0人参与评论

请发表评论

全部评论

专题导读
上一篇:
C++ xil_printf函数代码示例发布时间:2022-05-31
下一篇:
C++ virDomainDefFree函数代码示例发布时间:2022-05-31
热门推荐
阅读排行榜

扫描微信二维码

查看手机版网站

随时了解更新最新资讯

139-2527-9053

在线客服(服务时间 9:00~18:00)

在线QQ客服
地址:深圳市南山区西丽大学城创智工业园
电邮:jeky_zhao#qq.com
移动电话:139-2527-9053

Powered by 互联科技 X3.4© 2001-2213 极客世界.|Sitemap