void register_DoubleFunc_class(){ { //::SireCAS::DoubleFunc typedef bp::class_< SireCAS::DoubleFunc, bp::bases< SireCAS::ExBase >, boost::noncopyable > DoubleFunc_exposer_t; DoubleFunc_exposer_t DoubleFunc_exposer = DoubleFunc_exposer_t( "DoubleFunc", "Base class of all double-expression functions ( e.g. f(x(), y()) )\n\nAuthor: Christopher Woods\n", bp::no_init ); bp::scope DoubleFunc_scope( DoubleFunc_exposer ); { //::SireCAS::DoubleFunc::children typedef ::SireCAS::Expressions ( ::SireCAS::DoubleFunc::*children_function_type)( ) const; children_function_type children_function_value( &::SireCAS::DoubleFunc::children ); DoubleFunc_exposer.def( "children" , children_function_value , "Return the child expression of this function" ); } { //::SireCAS::DoubleFunc::conjugate typedef ::SireCAS::Expression ( ::SireCAS::DoubleFunc::*conjugate_function_type)( ) const; conjugate_function_type conjugate_function_value( &::SireCAS::DoubleFunc::conjugate ); DoubleFunc_exposer.def( "conjugate" , conjugate_function_value , "Return the conjugate of this function" ); } { //::SireCAS::DoubleFunc::differentiate typedef ::SireCAS::Expression ( ::SireCAS::DoubleFunc::*differentiate_function_type)( ::SireCAS::Symbol const & ) const; differentiate_function_type differentiate_function_value( &::SireCAS::DoubleFunc::differentiate ); DoubleFunc_exposer.def( "differentiate" , differentiate_function_value , ( bp::arg("symbol") ) , "Return the differential of this function with respect to symbol" ); } { //::SireCAS::DoubleFunc::expand typedef ::QList< SireCAS::Factor > ( ::SireCAS::DoubleFunc::*expand_function_type)( ::SireCAS::Symbol const & ) const; expand_function_type expand_function_value( &::SireCAS::DoubleFunc::expand ); DoubleFunc_exposer.def( "expand" , expand_function_value , ( bp::arg("symbol") ) , "" ); } { //::SireCAS::DoubleFunc::functions typedef ::SireCAS::Functions ( ::SireCAS::DoubleFunc::*functions_function_type)( ) const; functions_function_type functions_function_value( &::SireCAS::DoubleFunc::functions ); DoubleFunc_exposer.def( "functions" , functions_function_value , "Return the functions used in this function" ); } { //::SireCAS::DoubleFunc::hash typedef ::uint ( ::SireCAS::DoubleFunc::*hash_function_type)( ) const; hash_function_type hash_function_value( &::SireCAS::DoubleFunc::hash ); DoubleFunc_exposer.def( "hash" , hash_function_value , "Return a has for the function" ); } { //::SireCAS::DoubleFunc::integrate typedef ::SireCAS::Expression ( ::SireCAS::DoubleFunc::*integrate_function_type)( ::SireCAS::Symbol const & ) const; integrate_function_type integrate_function_value( &::SireCAS::DoubleFunc::integrate ); DoubleFunc_exposer.def( "integrate" , integrate_function_value , ( bp::arg("symbol") ) , "Return the integral of this function with respect to symbol" ); } { //::SireCAS::DoubleFunc::isComplex typedef bool ( ::SireCAS::DoubleFunc::*isComplex_function_type)( ) const; isComplex_function_type isComplex_function_value( &::SireCAS::DoubleFunc::isComplex ); DoubleFunc_exposer.def( "isComplex" , isComplex_function_value , "Return whether this is complex" ); } { //::SireCAS::DoubleFunc::isCompound typedef bool ( ::SireCAS::DoubleFunc::*isCompound_function_type)( ) const; isCompound_function_type isCompound_function_value( &::SireCAS::DoubleFunc::isCompound ); DoubleFunc_exposer.def( "isCompound" , isCompound_function_value , "A function is not compound" ); } { //::SireCAS::DoubleFunc::isConstant typedef bool ( ::SireCAS::DoubleFunc::*isConstant_function_type)( ) const; isConstant_function_type isConstant_function_value( &::SireCAS::DoubleFunc::isConstant ); DoubleFunc_exposer.def( "isConstant" , isConstant_function_value , "Return whether or not this is constant" ); } { //::SireCAS::DoubleFunc::isFunction typedef bool ( ::SireCAS::DoubleFunc::*isFunction_function_type)( ::SireCAS::Symbol const & ) const; isFunction_function_type isFunction_function_value( &::SireCAS::DoubleFunc::isFunction ); DoubleFunc_exposer.def( "isFunction" , isFunction_function_value , ( bp::arg("symbol") ) , "Return if this is a function of symbol" ); } { //::SireCAS::DoubleFunc::operator= typedef ::SireCAS::DoubleFunc & ( ::SireCAS::DoubleFunc::*assign_function_type)( ::SireCAS::DoubleFunc const & ) ; assign_function_type assign_function_value( &::SireCAS::DoubleFunc::operator= ); DoubleFunc_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() , "" ); } { //::SireCAS::DoubleFunc::substitute typedef ::SireCAS::Expression ( ::SireCAS::DoubleFunc::*substitute_function_type)( ::SireCAS::Identities const & ) const; substitute_function_type substitute_function_value( &::SireCAS::DoubleFunc::substitute ); DoubleFunc_exposer.def( "substitute" , substitute_function_value , ( bp::arg("identities") ) , "Substitute into this expression" ); } { //::SireCAS::DoubleFunc::symbols typedef ::SireCAS::Symbols ( ::SireCAS::DoubleFunc::*symbols_function_type)( ) const; symbols_function_type symbols_function_value( &::SireCAS::DoubleFunc::symbols ); DoubleFunc_exposer.def( "symbols" , symbols_function_value , "Return the symbols used in this function" ); } { //::SireCAS::DoubleFunc::toString typedef ::QString ( ::SireCAS::DoubleFunc::*toString_function_type)( ) const; toString_function_type toString_function_value( &::SireCAS::DoubleFunc::toString ); DoubleFunc_exposer.def( "toString" , toString_function_value , "Return a string representation of this function" ); } { //::SireCAS::DoubleFunc::x typedef ::SireCAS::Expression const & ( ::SireCAS::DoubleFunc::*x_function_type)( ) const; x_function_type x_function_value( &::SireCAS::DoubleFunc::x ); DoubleFunc_exposer.def( "x" , x_function_value , bp::return_value_policy< bp::copy_const_reference >() , "" ); } { //::SireCAS::DoubleFunc::y typedef ::SireCAS::Expression const & ( ::SireCAS::DoubleFunc::*y_function_type)( ) const; y_function_type y_function_value( &::SireCAS::DoubleFunc::y ); DoubleFunc_exposer.def( "y" , y_function_value , bp::return_value_policy< bp::copy_const_reference >() , "" ); } DoubleFunc_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireCAS::DoubleFunc >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); DoubleFunc_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireCAS::DoubleFunc >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); DoubleFunc_exposer.def( "__str__", &__str__< ::SireCAS::DoubleFunc > ); DoubleFunc_exposer.def( "__repr__", &__str__< ::SireCAS::DoubleFunc > ); DoubleFunc_exposer.def( "__hash__", &::SireCAS::DoubleFunc::hash ); } }
void register_Expression_class(){ { //::SireCAS::Expression typedef bp::class_< SireCAS::Expression > Expression_exposer_t; Expression_exposer_t Expression_exposer = Expression_exposer_t( "Expression", bp::init< >() ); bp::scope Expression_scope( Expression_exposer ); Expression_exposer.def( bp::init< int >(( bp::arg("constant") )) ); Expression_exposer.def( bp::init< SireMaths::Rational const & >(( bp::arg("constant") )) ); Expression_exposer.def( bp::init< double >(( bp::arg("constant") )) ); Expression_exposer.def( bp::init< SireMaths::Complex const & >(( bp::arg("constant") )) ); Expression_exposer.def( bp::init< SireCAS::ExpressionBase const & >(( bp::arg("base") )) ); Expression_exposer.def( bp::init< SireCAS::ExBase const & >(( bp::arg("base") )) ); Expression_exposer.def( bp::init< SireCAS::Expression const & >(( bp::arg("other") )) ); { //::SireCAS::Expression::add typedef ::SireCAS::Expression ( ::SireCAS::Expression::*add_function_type )( ::SireCAS::Expression const & ) const; add_function_type add_function_value( &::SireCAS::Expression::add ); Expression_exposer.def( "add" , add_function_value , ( bp::arg("ex") ) ); } { //::SireCAS::Expression::add typedef ::SireCAS::Expression ( ::SireCAS::Expression::*add_function_type )( double ) const; add_function_type add_function_value( &::SireCAS::Expression::add ); Expression_exposer.def( "add" , add_function_value , ( bp::arg("val") ) ); } { //::SireCAS::Expression::add typedef ::SireCAS::Expression ( ::SireCAS::Expression::*add_function_type )( ::SireMaths::Complex const & ) const; add_function_type add_function_value( &::SireCAS::Expression::add ); Expression_exposer.def( "add" , add_function_value , ( bp::arg("val") ) ); } { //::SireCAS::Expression::base typedef ::SireCAS::ExpressionBase const & ( ::SireCAS::Expression::*base_function_type )( ) const; base_function_type base_function_value( &::SireCAS::Expression::base ); Expression_exposer.def( "base" , base_function_value , bp::return_value_policy< bp::copy_const_reference >() ); } { //::SireCAS::Expression::children typedef ::SireCAS::Expressions ( ::SireCAS::Expression::*children_function_type )( ) const; children_function_type children_function_value( &::SireCAS::Expression::children ); Expression_exposer.def( "children" , children_function_value ); } { //::SireCAS::Expression::conjugate typedef ::SireCAS::Expression ( ::SireCAS::Expression::*conjugate_function_type )( ) const; conjugate_function_type conjugate_function_value( &::SireCAS::Expression::conjugate ); Expression_exposer.def( "conjugate" , conjugate_function_value ); } { //::SireCAS::Expression::cubed typedef ::SireCAS::Expression ( ::SireCAS::Expression::*cubed_function_type )( ) const; cubed_function_type cubed_function_value( &::SireCAS::Expression::cubed ); Expression_exposer.def( "cubed" , cubed_function_value ); } { //::SireCAS::Expression::diff typedef ::SireCAS::Expression ( ::SireCAS::Expression::*diff_function_type )( ::SireCAS::Symbol const &,int ) const; diff_function_type diff_function_value( &::SireCAS::Expression::diff ); Expression_exposer.def( "diff" , diff_function_value , ( bp::arg("symbol"), bp::arg("level")=(int)(1) ) ); } { //::SireCAS::Expression::differentiate typedef ::SireCAS::Expression ( ::SireCAS::Expression::*differentiate_function_type )( ::SireCAS::Symbol const &,int ) const; differentiate_function_type differentiate_function_value( &::SireCAS::Expression::differentiate ); Expression_exposer.def( "differentiate" , differentiate_function_value , ( bp::arg("symbol"), bp::arg("level")=(int)(1) ) ); } { //::SireCAS::Expression::divide typedef ::SireCAS::Expression ( ::SireCAS::Expression::*divide_function_type )( ::SireCAS::Expression const & ) const; divide_function_type divide_function_value( &::SireCAS::Expression::divide ); Expression_exposer.def( "divide" , divide_function_value , ( bp::arg("ex") ) ); } { //::SireCAS::Expression::divide typedef ::SireCAS::Expression ( ::SireCAS::Expression::*divide_function_type )( double ) const; divide_function_type divide_function_value( &::SireCAS::Expression::divide ); Expression_exposer.def( "divide" , divide_function_value , ( bp::arg("val") ) ); } { //::SireCAS::Expression::divide typedef ::SireCAS::Expression ( ::SireCAS::Expression::*divide_function_type )( ::SireMaths::Complex const & ) const; divide_function_type divide_function_value( &::SireCAS::Expression::divide ); Expression_exposer.def( "divide" , divide_function_value , ( bp::arg("val") ) ); } { //::SireCAS::Expression::evaluate typedef double ( ::SireCAS::Expression::*evaluate_function_type )( ::SireCAS::Values const & ) const; evaluate_function_type evaluate_function_value( &::SireCAS::Expression::evaluate ); Expression_exposer.def( "evaluate" , evaluate_function_value , ( bp::arg("values") ) ); } { //::SireCAS::Expression::evaluate typedef ::SireMaths::Complex ( ::SireCAS::Expression::*evaluate_function_type )( ::SireCAS::ComplexValues const & ) const; evaluate_function_type evaluate_function_value( &::SireCAS::Expression::evaluate ); Expression_exposer.def( "evaluate" , evaluate_function_value , ( bp::arg("values") ) ); } { //::SireCAS::Expression::expand typedef ::QList< SireCAS::Factor > ( ::SireCAS::Expression::*expand_function_type )( ::SireCAS::Symbol const & ) const; expand_function_type expand_function_value( &::SireCAS::Expression::expand ); Expression_exposer.def( "expand" , expand_function_value , ( bp::arg("symbol") ) ); } { //::SireCAS::Expression::factor typedef double ( ::SireCAS::Expression::*factor_function_type )( ) const; factor_function_type factor_function_value( &::SireCAS::Expression::factor ); Expression_exposer.def( "factor" , factor_function_value ); } { //::SireCAS::Expression::functions typedef ::SireCAS::Functions ( ::SireCAS::Expression::*functions_function_type )( ) const; functions_function_type functions_function_value( &::SireCAS::Expression::functions ); Expression_exposer.def( "functions" , functions_function_value ); } { //::SireCAS::Expression::hash typedef ::uint ( ::SireCAS::Expression::*hash_function_type )( ) const; hash_function_type hash_function_value( &::SireCAS::Expression::hash ); Expression_exposer.def( "hash" , hash_function_value ); } { //::SireCAS::Expression::integ typedef ::SireCAS::Expression ( ::SireCAS::Expression::*integ_function_type )( ::SireCAS::Symbol const & ) const; integ_function_type integ_function_value( &::SireCAS::Expression::integ ); Expression_exposer.def( "integ" , integ_function_value , ( bp::arg("symbol") ) ); } { //::SireCAS::Expression::integrate typedef ::SireCAS::Expression ( ::SireCAS::Expression::*integrate_function_type )( ::SireCAS::Symbol const & ) const; integrate_function_type integrate_function_value( &::SireCAS::Expression::integrate ); Expression_exposer.def( "integrate" , integrate_function_value , ( bp::arg("symbol") ) ); } { //::SireCAS::Expression::invert typedef ::SireCAS::Expression ( ::SireCAS::Expression::*invert_function_type )( ) const; invert_function_type invert_function_value( &::SireCAS::Expression::invert ); Expression_exposer.def( "invert" , invert_function_value ); } { //::SireCAS::Expression::isComplex typedef bool ( ::SireCAS::Expression::*isComplex_function_type )( ) const; isComplex_function_type isComplex_function_value( &::SireCAS::Expression::isComplex ); Expression_exposer.def( "isComplex" , isComplex_function_value ); } { //::SireCAS::Expression::isCompound typedef bool ( ::SireCAS::Expression::*isCompound_function_type )( ) const; isCompound_function_type isCompound_function_value( &::SireCAS::Expression::isCompound ); Expression_exposer.def( "isCompound" , isCompound_function_value ); } { //::SireCAS::Expression::isConstant typedef bool ( ::SireCAS::Expression::*isConstant_function_type )( ) const; isConstant_function_type isConstant_function_value( &::SireCAS::Expression::isConstant ); Expression_exposer.def( "isConstant" , isConstant_function_value ); } { //::SireCAS::Expression::isFunction typedef bool ( ::SireCAS::Expression::*isFunction_function_type )( ::SireCAS::Symbol const & ) const; isFunction_function_type isFunction_function_value( &::SireCAS::Expression::isFunction ); Expression_exposer.def( "isFunction" , isFunction_function_value , ( bp::arg("symbol") ) ); } { //::SireCAS::Expression::isZero typedef bool ( ::SireCAS::Expression::*isZero_function_type )( ) const; isZero_function_type isZero_function_value( &::SireCAS::Expression::isZero ); Expression_exposer.def( "isZero" , isZero_function_value ); } { //::SireCAS::Expression::multiply typedef ::SireCAS::Expression ( ::SireCAS::Expression::*multiply_function_type )( ::SireCAS::Expression const & ) const; multiply_function_type multiply_function_value( &::SireCAS::Expression::multiply ); Expression_exposer.def( "multiply" , multiply_function_value , ( bp::arg("ex") ) ); } { //::SireCAS::Expression::multiply typedef ::SireCAS::Expression ( ::SireCAS::Expression::*multiply_function_type )( double ) const; multiply_function_type multiply_function_value( &::SireCAS::Expression::multiply ); Expression_exposer.def( "multiply" , multiply_function_value , ( bp::arg("val") ) ); } { //::SireCAS::Expression::multiply typedef ::SireCAS::Expression ( ::SireCAS::Expression::*multiply_function_type )( ::SireMaths::Complex const & ) const; multiply_function_type multiply_function_value( &::SireCAS::Expression::multiply ); Expression_exposer.def( "multiply" , multiply_function_value , ( bp::arg("val") ) ); } { //::SireCAS::Expression::negate typedef ::SireCAS::Expression ( ::SireCAS::Expression::*negate_function_type )( ) const; negate_function_type negate_function_value( &::SireCAS::Expression::negate ); Expression_exposer.def( "negate" , negate_function_value ); } Expression_exposer.def( bp::self != bp::self ); { //::SireCAS::Expression::operator() typedef double ( ::SireCAS::Expression::*__call___function_type )( ::SireCAS::Values const & ) const; __call___function_type __call___function_value( &::SireCAS::Expression::operator() ); Expression_exposer.def( "__call__" , __call___function_value , ( bp::arg("values") ) ); } { //::SireCAS::Expression::operator() typedef ::SireMaths::Complex ( ::SireCAS::Expression::*__call___function_type )( ::SireCAS::ComplexValues const & ) const; __call___function_type __call___function_value( &::SireCAS::Expression::operator() ); Expression_exposer.def( "__call__" , __call___function_value , ( bp::arg("values") ) ); } Expression_exposer.def( -bp::self ); { //::SireCAS::Expression::operator= typedef ::SireCAS::Expression & ( ::SireCAS::Expression::*assign_function_type )( ::SireCAS::Expression const & ) ; assign_function_type assign_function_value( &::SireCAS::Expression::operator= ); Expression_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() ); } Expression_exposer.def( bp::self == bp::self ); { //::SireCAS::Expression::pow typedef ::SireCAS::Expression ( ::SireCAS::Expression::*pow_function_type )( int ) const; pow_function_type pow_function_value( &::SireCAS::Expression::pow ); Expression_exposer.def( "pow" , pow_function_value , ( bp::arg("n") ) ); } { //::SireCAS::Expression::pow typedef ::SireCAS::Expression ( ::SireCAS::Expression::*pow_function_type )( ::SireMaths::Rational const & ) const; pow_function_type pow_function_value( &::SireCAS::Expression::pow ); Expression_exposer.def( "pow" , pow_function_value , ( bp::arg("n") ) ); } { //::SireCAS::Expression::pow typedef ::SireCAS::Expression ( ::SireCAS::Expression::*pow_function_type )( double ) const; pow_function_type pow_function_value( &::SireCAS::Expression::pow ); Expression_exposer.def( "pow" , pow_function_value , ( bp::arg("n") ) ); } { //::SireCAS::Expression::pow typedef ::SireCAS::Expression ( ::SireCAS::Expression::*pow_function_type )( ::SireMaths::Complex const & ) const; pow_function_type pow_function_value( &::SireCAS::Expression::pow ); Expression_exposer.def( "pow" , pow_function_value , ( bp::arg("n") ) ); } { //::SireCAS::Expression::pow typedef ::SireCAS::Expression ( ::SireCAS::Expression::*pow_function_type )( ::SireCAS::Expression const & ) const; pow_function_type pow_function_value( &::SireCAS::Expression::pow ); Expression_exposer.def( "pow" , pow_function_value , ( bp::arg("n") ) ); } { //::SireCAS::Expression::root typedef ::SireCAS::Expression ( ::SireCAS::Expression::*root_function_type )( int ) const; root_function_type root_function_value( &::SireCAS::Expression::root ); Expression_exposer.def( "root" , root_function_value , ( bp::arg("n") ) ); } { //::SireCAS::Expression::series typedef ::SireCAS::Expression ( ::SireCAS::Expression::*series_function_type )( ::SireCAS::Symbol const &,int ) const; series_function_type series_function_value( &::SireCAS::Expression::series ); Expression_exposer.def( "series" , series_function_value , ( bp::arg("symbol"), bp::arg("order") ) ); } { //::SireCAS::Expression::simplify typedef ::SireCAS::Expression ( ::SireCAS::Expression::*simplify_function_type )( int ) const; simplify_function_type simplify_function_value( &::SireCAS::Expression::simplify ); Expression_exposer.def( "simplify" , simplify_function_value , ( bp::arg("options")=(int)(0) ) ); } { //::SireCAS::Expression::squared typedef ::SireCAS::Expression ( ::SireCAS::Expression::*squared_function_type )( ) const; squared_function_type squared_function_value( &::SireCAS::Expression::squared ); Expression_exposer.def( "squared" , squared_function_value ); } { //::SireCAS::Expression::substitute typedef ::SireCAS::Expression ( ::SireCAS::Expression::*substitute_function_type )( ::SireCAS::Identities const & ) const; substitute_function_type substitute_function_value( &::SireCAS::Expression::substitute ); Expression_exposer.def( "substitute" , substitute_function_value , ( bp::arg("identities") ) ); } { //::SireCAS::Expression::subtract typedef ::SireCAS::Expression ( ::SireCAS::Expression::*subtract_function_type )( ::SireCAS::Expression const & ) const; subtract_function_type subtract_function_value( &::SireCAS::Expression::subtract ); Expression_exposer.def( "subtract" , subtract_function_value , ( bp::arg("ex") ) ); } { //::SireCAS::Expression::subtract typedef ::SireCAS::Expression ( ::SireCAS::Expression::*subtract_function_type )( double ) const; subtract_function_type subtract_function_value( &::SireCAS::Expression::subtract ); Expression_exposer.def( "subtract" , subtract_function_value , ( bp::arg("val") ) ); } { //::SireCAS::Expression::subtract typedef ::SireCAS::Expression ( ::SireCAS::Expression::*subtract_function_type )( ::SireMaths::Complex const & ) const; subtract_function_type subtract_function_value( &::SireCAS::Expression::subtract ); Expression_exposer.def( "subtract" , subtract_function_value , ( bp::arg("val") ) ); } { //::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 ); Expression_exposer.def( self / self ); Expression_exposer.def( other<double>() + self ); Expression_exposer.def( other<double>() - self ); Expression_exposer.def( other<double>() * self ); Expression_exposer.def( other<double>() / self ); Expression_exposer.def( self + other<double>() ); Expression_exposer.def( self - other<double>() ); Expression_exposer.def( self * other<double>() ); Expression_exposer.def( self / other<double>() ); Expression_exposer.def( other<SireMaths::Complex>() + self ); Expression_exposer.def( other<SireMaths::Complex>() - self ); Expression_exposer.def( other<SireMaths::Complex>() * self ); Expression_exposer.def( other<SireMaths::Complex>() / self ); Expression_exposer.def( self + other<SireMaths::Complex>() ); Expression_exposer.def( self - other<SireMaths::Complex>() ); Expression_exposer.def( self * other<SireMaths::Complex>() ); Expression_exposer.def( self / other<SireMaths::Complex>() ); Expression_exposer.def( other<SireCAS::ExBase>() + self ); Expression_exposer.def( other<SireCAS::ExBase>() - self ); Expression_exposer.def( other<SireCAS::ExBase>() * self ); Expression_exposer.def( other<SireCAS::ExBase>() / self ); Expression_exposer.def( self + other<SireCAS::ExBase>() ); Expression_exposer.def( self - other<SireCAS::ExBase>() ); Expression_exposer.def( self * other<SireCAS::ExBase>() ); Expression_exposer.def( self / other<SireCAS::ExBase>() ); Expression_exposer.def( "__copy__", &__copy__); Expression_exposer.def( "__deepcopy__", &__copy__); Expression_exposer.def( "clone", &__copy__); Expression_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireCAS::Expression >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); Expression_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireCAS::Expression >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); Expression_exposer.def( "__str__", &__str__< ::SireCAS::Expression > ); Expression_exposer.def( "__repr__", &__str__< ::SireCAS::Expression > ); } }
void register_CLJWorkspace_class(){ { //::SireMM::CLJWorkspace typedef bp::class_< SireMM::CLJWorkspace > CLJWorkspace_exposer_t; CLJWorkspace_exposer_t CLJWorkspace_exposer = CLJWorkspace_exposer_t( "CLJWorkspace", "This class provides a workspace in which to hold the details of the changes\nthat occur in a CLJ forcefield during a Monte Carlo move. The class is optimised\nto avoid copying or duplicating data during Sires copy-on-write copying\n(e.g. the memory allocated in a workspace will always be available for the\nnew copy of a forcefield rather than the old, which, if things work correctly,\nwill mean that there should be no memory allocation during simple MC moves...)\n\nAuthor: Christopher Woods\n", bp::init< >("Constructor") ); bp::scope CLJWorkspace_scope( CLJWorkspace_exposer ); CLJWorkspace_exposer.def( bp::init< SireMM::CLJWorkspace const & >(( bp::arg("other") ), "Copy constructor") ); { //::SireMM::CLJWorkspace::accept typedef void ( ::SireMM::CLJWorkspace::*accept_function_type)( ::SireMM::CLJBoxes & ) ; accept_function_type accept_function_value( &::SireMM::CLJWorkspace::accept ); CLJWorkspace_exposer.def( "accept" , accept_function_value , ( bp::arg("boxes") ) , "Accept this workspace - this clears the recalc_from_scratch flag as it\nsignals that we have put the CLJBoxes into a sane state" ); } { //::SireMM::CLJWorkspace::at typedef ::SireMM::CLJDelta const & ( ::SireMM::CLJWorkspace::*at_function_type)( int ) const; at_function_type at_function_value( &::SireMM::CLJWorkspace::at ); CLJWorkspace_exposer.def( "at" , at_function_value , ( bp::arg("i") ) , bp::return_value_policy< bp::copy_const_reference >() , "Return the ith delta" ); } { //::SireMM::CLJWorkspace::changedAtoms typedef ::SireMM::CLJAtoms ( ::SireMM::CLJWorkspace::*changedAtoms_function_type)( ) const; changedAtoms_function_type changedAtoms_function_value( &::SireMM::CLJWorkspace::changedAtoms ); CLJWorkspace_exposer.def( "changedAtoms" , changedAtoms_function_value , "Merge all of the deltas together into a single set of changed CLJAtoms that\ncan be used for the change in energy calculation" ); } { //::SireMM::CLJWorkspace::clear typedef void ( ::SireMM::CLJWorkspace::*clear_function_type)( ) ; clear_function_type clear_function_value( &::SireMM::CLJWorkspace::clear ); CLJWorkspace_exposer.def( "clear" , clear_function_value , "Clear this workspace" ); } { //::SireMM::CLJWorkspace::commit typedef ::QVector< SireMM::CLJBoxIndex > ( ::SireMM::CLJWorkspace::*commit_function_type)( ::SireMM::CLJBoxes &,::SireMM::CLJDelta const & ) ; commit_function_type commit_function_value( &::SireMM::CLJWorkspace::commit ); CLJWorkspace_exposer.def( "commit" , commit_function_value , ( bp::arg("boxes"), bp::arg("delta") ) , "Commit the changes in the passed delta into the passed CLJBoxes" ); } { //::SireMM::CLJWorkspace::count typedef int ( ::SireMM::CLJWorkspace::*count_function_type)( ) const; count_function_type count_function_value( &::SireMM::CLJWorkspace::count ); CLJWorkspace_exposer.def( "count" , count_function_value , "Return the number of deltas" ); } { //::SireMM::CLJWorkspace::getitem typedef ::SireMM::CLJDelta ( ::SireMM::CLJWorkspace::*getitem_function_type)( int ) const; getitem_function_type getitem_function_value( &::SireMM::CLJWorkspace::getitem ); CLJWorkspace_exposer.def( "getitem" , getitem_function_value , ( bp::arg("i") ) , "Return the ith delta" ); } { //::SireMM::CLJWorkspace::isEmpty typedef bool ( ::SireMM::CLJWorkspace::*isEmpty_function_type)( ) const; isEmpty_function_type isEmpty_function_value( &::SireMM::CLJWorkspace::isEmpty ); CLJWorkspace_exposer.def( "isEmpty" , isEmpty_function_value , "Return whether or not this workspace is empty" ); } { //::SireMM::CLJWorkspace::isSingleID typedef bool ( ::SireMM::CLJWorkspace::*isSingleID_function_type)( ) const; isSingleID_function_type isSingleID_function_value( &::SireMM::CLJWorkspace::isSingleID ); CLJWorkspace_exposer.def( "isSingleID" , isSingleID_function_value , "Return whether or not this workspace contains deltas with a single\nID (a single CLJAtoms ID)" ); } { //::SireMM::CLJWorkspace::merge typedef ::boost::tuples::tuple< SireMM::CLJAtoms, SireMM::CLJAtoms, SireMM::CLJAtoms, 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::CLJWorkspace::*merge_function_type)( ) const; merge_function_type merge_function_value( &::SireMM::CLJWorkspace::merge ); CLJWorkspace_exposer.def( "merge" , merge_function_value , "Merge all of the deltas together to return the tuple of the\nchanged, old and new atoms. This is equivalent to calling\nchangedAtoms(), oldAtoms() and newAtoms() and placing them\ninto a tuple. This is more efficient than three separate calls" ); } { //::SireMM::CLJWorkspace::mustRecalculateFromScratch typedef void ( ::SireMM::CLJWorkspace::*mustRecalculateFromScratch_function_type)( ::SireMM::CLJBoxes & ) ; mustRecalculateFromScratch_function_type mustRecalculateFromScratch_function_value( &::SireMM::CLJWorkspace::mustRecalculateFromScratch ); CLJWorkspace_exposer.def( "mustRecalculateFromScratch" , mustRecalculateFromScratch_function_value , ( bp::arg("boxes") ) , "Tell the workspace that we are now recalculating everything from scratch" ); } { //::SireMM::CLJWorkspace::nDeltas typedef int ( ::SireMM::CLJWorkspace::*nDeltas_function_type)( ) const; nDeltas_function_type nDeltas_function_value( &::SireMM::CLJWorkspace::nDeltas ); CLJWorkspace_exposer.def( "nDeltas" , nDeltas_function_value , "Return the number of deltas in this workspace" ); } { //::SireMM::CLJWorkspace::needsAccepting typedef bool ( ::SireMM::CLJWorkspace::*needsAccepting_function_type)( ) const; needsAccepting_function_type needsAccepting_function_value( &::SireMM::CLJWorkspace::needsAccepting ); CLJWorkspace_exposer.def( "needsAccepting" , needsAccepting_function_value , "Return whether or not this workspace needs accepting" ); } { //::SireMM::CLJWorkspace::newAtoms typedef ::SireMM::CLJAtoms ( ::SireMM::CLJWorkspace::*newAtoms_function_type)( ) const; newAtoms_function_type newAtoms_function_value( &::SireMM::CLJWorkspace::newAtoms ); CLJWorkspace_exposer.def( "newAtoms" , newAtoms_function_value , "Merge all of the new atoms from the deltas together into a single\nset of new CLJAtoms that can be used for the change in energy calculation" ); } { //::SireMM::CLJWorkspace::oldAtoms typedef ::SireMM::CLJAtoms ( ::SireMM::CLJWorkspace::*oldAtoms_function_type)( ) const; oldAtoms_function_type oldAtoms_function_value( &::SireMM::CLJWorkspace::oldAtoms ); CLJWorkspace_exposer.def( "oldAtoms" , oldAtoms_function_value , "Merge all of the old atoms from the deltas together into a single\nset of old CLJAtoms that can be used for the change in energy calculation" ); } CLJWorkspace_exposer.def( bp::self != bp::self ); { //::SireMM::CLJWorkspace::operator= typedef ::SireMM::CLJWorkspace & ( ::SireMM::CLJWorkspace::*assign_function_type)( ::SireMM::CLJWorkspace const & ) ; assign_function_type assign_function_value( &::SireMM::CLJWorkspace::operator= ); CLJWorkspace_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() , "" ); } CLJWorkspace_exposer.def( bp::self == bp::self ); { //::SireMM::CLJWorkspace::operator[] typedef ::SireMM::CLJDelta const & ( ::SireMM::CLJWorkspace::*__getitem___function_type)( int ) const; __getitem___function_type __getitem___function_value( &::SireMM::CLJWorkspace::operator[] ); CLJWorkspace_exposer.def( "__getitem__" , __getitem___function_value , ( bp::arg("i") ) , bp::return_value_policy< bp::copy_const_reference >() , "" ); } { //::SireMM::CLJWorkspace::push typedef ::SireMM::CLJDelta ( ::SireMM::CLJWorkspace::*push_function_type)( ::SireMM::CLJBoxes &,::QVector< SireMM::CLJBoxIndex > const &,::SireMM::CLJAtoms const &,::SireMM::CLJDelta const & ) ; push_function_type push_function_value( &::SireMM::CLJWorkspace::push ); CLJWorkspace_exposer.def( "push" , push_function_value , ( bp::arg("boxes"), bp::arg("old_atoms"), bp::arg("new_atoms"), bp::arg("old_delta") ) , "Push the passed change onto the workspace. This changes the atoms in the\npassed CLJBoxes from their values in old_atoms to their values in the\npassed new_atoms. The last CLJDelta used for these atoms is supplied as\nold_delta, and this returns the new CLJDelta for these atoms." ); } { //::SireMM::CLJWorkspace::recalculatingFromScratch typedef bool ( ::SireMM::CLJWorkspace::*recalculatingFromScratch_function_type)( ) const; recalculatingFromScratch_function_type recalculatingFromScratch_function_value( &::SireMM::CLJWorkspace::recalculatingFromScratch ); CLJWorkspace_exposer.def( "recalculatingFromScratch" , recalculatingFromScratch_function_value , "Return whether or not we are recalculating everything from scratch" ); } { //::SireMM::CLJWorkspace::removeSameIDAtoms typedef void ( ::SireMM::CLJWorkspace::*removeSameIDAtoms_function_type)( ::SireMM::CLJBoxes & ) ; removeSameIDAtoms_function_type removeSameIDAtoms_function_value( &::SireMM::CLJWorkspace::removeSameIDAtoms ); CLJWorkspace_exposer.def( "removeSameIDAtoms" , removeSameIDAtoms_function_value , ( bp::arg("boxes") ) , "Internal function used to fully remove atoms that have not been\nremoved because they all have the same ID. This is used when the\noptimisation of not removing same ID atoms would break the energy\ncalculation, e.g. if we have multiple CLJGroups and have multiple\nchanged IDs across these groups" ); } { //::SireMM::CLJWorkspace::revert typedef ::QVector< SireMM::CLJBoxIndex > ( ::SireMM::CLJWorkspace::*revert_function_type)( ::SireMM::CLJBoxes &,::SireMM::CLJDelta const & ) ; revert_function_type revert_function_value( &::SireMM::CLJWorkspace::revert ); CLJWorkspace_exposer.def( "revert" , revert_function_value , ( bp::arg("boxes"), bp::arg("delta") ) , "Revert the changes supplied in the passed delta" ); } { //::SireMM::CLJWorkspace::size typedef int ( ::SireMM::CLJWorkspace::*size_function_type)( ) const; size_function_type size_function_value( &::SireMM::CLJWorkspace::size ); CLJWorkspace_exposer.def( "size" , size_function_value , "Return the number of deltas" ); } { //::SireMM::CLJWorkspace::toString typedef ::QString ( ::SireMM::CLJWorkspace::*toString_function_type)( ) const; toString_function_type toString_function_value( &::SireMM::CLJWorkspace::toString ); CLJWorkspace_exposer.def( "toString" , toString_function_value , "" ); } { //::SireMM::CLJWorkspace::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireMM::CLJWorkspace::typeName ); CLJWorkspace_exposer.def( "typeName" , typeName_function_value , "" ); } { //::SireMM::CLJWorkspace::what typedef char const * ( ::SireMM::CLJWorkspace::*what_function_type)( ) const; what_function_type what_function_value( &::SireMM::CLJWorkspace::what ); CLJWorkspace_exposer.def( "what" , what_function_value , "" ); } CLJWorkspace_exposer.staticmethod( "typeName" ); CLJWorkspace_exposer.def( "__copy__", &__copy__); CLJWorkspace_exposer.def( "__deepcopy__", &__copy__); CLJWorkspace_exposer.def( "clone", &__copy__); CLJWorkspace_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::CLJWorkspace >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); CLJWorkspace_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::CLJWorkspace >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); CLJWorkspace_exposer.def( "__str__", &__str__< ::SireMM::CLJWorkspace > ); CLJWorkspace_exposer.def( "__repr__", &__str__< ::SireMM::CLJWorkspace > ); CLJWorkspace_exposer.def( "__len__", &__len_size< ::SireMM::CLJWorkspace > ); CLJWorkspace_exposer.def( "__getitem__", &::SireMM::CLJWorkspace::getitem ); } }
void register_LJParameter_class(){ { //::SireMM::LJParameter typedef bp::class_< SireMM::LJParameter > LJParameter_exposer_t; LJParameter_exposer_t LJParameter_exposer = LJParameter_exposer_t( "LJParameter", bp::init< >() ); bp::scope LJParameter_scope( LJParameter_exposer ); LJParameter_exposer.def( bp::init< SireUnits::Dimension::Length, SireUnits::Dimension::MolarEnergy >(( bp::arg("sigma"), bp::arg("epsilon") )) ); LJParameter_exposer.def( bp::init< SireMM::LJPair const & >(( bp::arg("ljpair") )) ); LJParameter_exposer.def( bp::init< SireMM::LJParameter const & >(( bp::arg("param") )) ); { //::SireMM::LJParameter::A typedef double ( ::SireMM::LJParameter::*A_function_type )( ) const; A_function_type A_function_value( &::SireMM::LJParameter::A ); LJParameter_exposer.def( "A" , A_function_value ); } { //::SireMM::LJParameter::B typedef double ( ::SireMM::LJParameter::*B_function_type )( ) const; B_function_type B_function_value( &::SireMM::LJParameter::B ); LJParameter_exposer.def( "B" , B_function_value ); } { //::SireMM::LJParameter::dummy typedef ::SireMM::LJParameter ( *dummy_function_type )( ); dummy_function_type dummy_function_value( &::SireMM::LJParameter::dummy ); LJParameter_exposer.def( "dummy" , dummy_function_value ); } { //::SireMM::LJParameter::epsilon typedef ::SireUnits::Dimension::MolarEnergy ( ::SireMM::LJParameter::*epsilon_function_type )( ) const; epsilon_function_type epsilon_function_value( &::SireMM::LJParameter::epsilon ); LJParameter_exposer.def( "epsilon" , epsilon_function_value ); } { //::SireMM::LJParameter::fromAAndB typedef ::SireMM::LJParameter ( *fromAAndB_function_type )( double,double ); fromAAndB_function_type fromAAndB_function_value( &::SireMM::LJParameter::fromAAndB ); LJParameter_exposer.def( "fromAAndB" , fromAAndB_function_value , ( bp::arg("a"), bp::arg("b") ) ); } { //::SireMM::LJParameter::fromRMinAndEpsilon typedef ::SireMM::LJParameter ( *fromRMinAndEpsilon_function_type )( ::SireUnits::Dimension::Length,::SireUnits::Dimension::MolarEnergy ); fromRMinAndEpsilon_function_type fromRMinAndEpsilon_function_value( &::SireMM::LJParameter::fromRMinAndEpsilon ); LJParameter_exposer.def( "fromRMinAndEpsilon" , fromRMinAndEpsilon_function_value , ( bp::arg("rmin"), bp::arg("epsilon") ) ); } { //::SireMM::LJParameter::fromSigmaAndEpsilon typedef ::SireMM::LJParameter ( *fromSigmaAndEpsilon_function_type )( ::SireUnits::Dimension::Length,::SireUnits::Dimension::MolarEnergy ); fromSigmaAndEpsilon_function_type fromSigmaAndEpsilon_function_value( &::SireMM::LJParameter::fromSigmaAndEpsilon ); LJParameter_exposer.def( "fromSigmaAndEpsilon" , fromSigmaAndEpsilon_function_value , ( bp::arg("sigma"), bp::arg("epsilon") ) ); } { //::SireMM::LJParameter::isDummy typedef bool ( ::SireMM::LJParameter::*isDummy_function_type )( ) const; isDummy_function_type isDummy_function_value( &::SireMM::LJParameter::isDummy ); LJParameter_exposer.def( "isDummy" , isDummy_function_value ); } LJParameter_exposer.def( bp::self != bp::self ); LJParameter_exposer.def( bp::self == bp::self ); { //::SireMM::LJParameter::rmin typedef ::SireUnits::Dimension::Length ( ::SireMM::LJParameter::*rmin_function_type )( ) const; rmin_function_type rmin_function_value( &::SireMM::LJParameter::rmin ); LJParameter_exposer.def( "rmin" , rmin_function_value ); } { //::SireMM::LJParameter::sigma typedef ::SireUnits::Dimension::Length ( ::SireMM::LJParameter::*sigma_function_type )( ) const; sigma_function_type sigma_function_value( &::SireMM::LJParameter::sigma ); LJParameter_exposer.def( "sigma" , sigma_function_value ); } { //::SireMM::LJParameter::sqrtEpsilon typedef double ( ::SireMM::LJParameter::*sqrtEpsilon_function_type )( ) const; sqrtEpsilon_function_type sqrtEpsilon_function_value( &::SireMM::LJParameter::sqrtEpsilon ); LJParameter_exposer.def( "sqrtEpsilon" , sqrtEpsilon_function_value ); } { //::SireMM::LJParameter::sqrtSigma typedef double ( ::SireMM::LJParameter::*sqrtSigma_function_type )( ) const; sqrtSigma_function_type sqrtSigma_function_value( &::SireMM::LJParameter::sqrtSigma ); LJParameter_exposer.def( "sqrtSigma" , sqrtSigma_function_value ); } { //::SireMM::LJParameter::toString typedef ::QString ( ::SireMM::LJParameter::*toString_function_type )( ) const; toString_function_type toString_function_value( &::SireMM::LJParameter::toString ); LJParameter_exposer.def( "toString" , toString_function_value ); } { //::SireMM::LJParameter::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireMM::LJParameter::typeName ); LJParameter_exposer.def( "typeName" , typeName_function_value ); } { //::SireMM::LJParameter::what typedef char const * ( ::SireMM::LJParameter::*what_function_type )( ) const; what_function_type what_function_value( &::SireMM::LJParameter::what ); LJParameter_exposer.def( "what" , what_function_value ); } { //::SireMM::LJParameter::zeroLJ typedef bool ( ::SireMM::LJParameter::*zeroLJ_function_type )( ) const; zeroLJ_function_type zeroLJ_function_value( &::SireMM::LJParameter::zeroLJ ); LJParameter_exposer.def( "zeroLJ" , zeroLJ_function_value ); } LJParameter_exposer.staticmethod( "dummy" ); LJParameter_exposer.staticmethod( "fromAAndB" ); LJParameter_exposer.staticmethod( "fromRMinAndEpsilon" ); LJParameter_exposer.staticmethod( "fromSigmaAndEpsilon" ); LJParameter_exposer.staticmethod( "typeName" ); LJParameter_exposer.def( "__copy__", &__copy__); LJParameter_exposer.def( "__deepcopy__", &__copy__); LJParameter_exposer.def( "clone", &__copy__); LJParameter_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::LJParameter >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); LJParameter_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::LJParameter >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); LJParameter_exposer.def( "__str__", &__str__< ::SireMM::LJParameter > ); LJParameter_exposer.def( "__repr__", &__str__< ::SireMM::LJParameter > ); } }
void register_AtomMultiMatcher_class(){ { //::SireMol::AtomMultiMatcher typedef bp::class_< SireMol::AtomMultiMatcher, bp::bases< SireMol::AtomMatcher, SireBase::Property > > AtomMultiMatcher_exposer_t; AtomMultiMatcher_exposer_t AtomMultiMatcher_exposer = AtomMultiMatcher_exposer_t( "AtomMultiMatcher", "This is an atom matcher combines several sub-AtomMatchers together\n\nAuthor: Christopher Woods\n", bp::init< >("Constructor") ); bp::scope AtomMultiMatcher_scope( AtomMultiMatcher_exposer ); AtomMultiMatcher_exposer.def( bp::init< SireMol::AtomMatcher const & >(( bp::arg("matcher") ), "Construct from a single match") ); AtomMultiMatcher_exposer.def( bp::init< SireMol::AtomMatcher const &, SireMol::AtomMatcher const & >(( bp::arg("m0"), bp::arg("m1") ), "Construct from a pair of matches") ); AtomMultiMatcher_exposer.def( bp::init< SireMol::AtomMultiMatcher const & >(( bp::arg("other") ), "Copy constructor") ); { //::SireMol::AtomMultiMatcher::isNull typedef bool ( ::SireMol::AtomMultiMatcher::*isNull_function_type)( ) const; isNull_function_type isNull_function_value( &::SireMol::AtomMultiMatcher::isNull ); AtomMultiMatcher_exposer.def( "isNull" , isNull_function_value , "Return whether or not this matcher is null (cannot be used for matching)" ); } AtomMultiMatcher_exposer.def( bp::self != bp::self ); { //::SireMol::AtomMultiMatcher::operator= typedef ::SireMol::AtomMultiMatcher & ( ::SireMol::AtomMultiMatcher::*assign_function_type)( ::SireMol::AtomMultiMatcher const & ) ; assign_function_type assign_function_value( &::SireMol::AtomMultiMatcher::operator= ); AtomMultiMatcher_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() , "" ); } AtomMultiMatcher_exposer.def( bp::self == bp::self ); { //::SireMol::AtomMultiMatcher::toString typedef ::QString ( ::SireMol::AtomMultiMatcher::*toString_function_type)( ) const; toString_function_type toString_function_value( &::SireMol::AtomMultiMatcher::toString ); AtomMultiMatcher_exposer.def( "toString" , toString_function_value , "" ); } { //::SireMol::AtomMultiMatcher::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireMol::AtomMultiMatcher::typeName ); AtomMultiMatcher_exposer.def( "typeName" , typeName_function_value , "" ); } { //::SireMol::AtomMultiMatcher::what typedef char const * ( ::SireMol::AtomMultiMatcher::*what_function_type)( ) const; what_function_type what_function_value( &::SireMol::AtomMultiMatcher::what ); AtomMultiMatcher_exposer.def( "what" , what_function_value , "" ); } AtomMultiMatcher_exposer.staticmethod( "typeName" ); AtomMultiMatcher_exposer.def( "__copy__", &__copy__); AtomMultiMatcher_exposer.def( "__deepcopy__", &__copy__); AtomMultiMatcher_exposer.def( "clone", &__copy__); AtomMultiMatcher_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::AtomMultiMatcher >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); AtomMultiMatcher_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::AtomMultiMatcher >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); AtomMultiMatcher_exposer.def( "__str__", &__str__< ::SireMol::AtomMultiMatcher > ); AtomMultiMatcher_exposer.def( "__repr__", &__str__< ::SireMol::AtomMultiMatcher > ); } }
void register_Nodes_class(){ { //::SireCluster::Nodes typedef bp::class_< SireCluster::Nodes > Nodes_exposer_t; Nodes_exposer_t Nodes_exposer = Nodes_exposer_t( "Nodes", bp::init< >() ); bp::scope Nodes_scope( Nodes_exposer ); Nodes_exposer.def( bp::init< SireCluster::Nodes const & >(( bp::arg("other") )) ); { //::SireCluster::Nodes::add typedef void ( ::SireCluster::Nodes::*add_function_type )( ::SireCluster::Node ) ; add_function_type add_function_value( &::SireCluster::Nodes::add ); Nodes_exposer.def( "add" , add_function_value , ( bp::arg("node") ) ); } { //::SireCluster::Nodes::add typedef void ( ::SireCluster::Nodes::*add_function_type )( ::SireCluster::Nodes & ) ; add_function_type add_function_value( &::SireCluster::Nodes::add ); Nodes_exposer.def( "add" , add_function_value , ( bp::arg("nodes") ) ); } { //::SireCluster::Nodes::addNode typedef void ( ::SireCluster::Nodes::*addNode_function_type )( ) ; addNode_function_type addNode_function_value( &::SireCluster::Nodes::addNode ); Nodes_exposer.def( "addNode" , addNode_function_value ); } { //::SireCluster::Nodes::addNode typedef void ( ::SireCluster::Nodes::*addNode_function_type )( int ) ; addNode_function_type addNode_function_value( &::SireCluster::Nodes::addNode ); Nodes_exposer.def( "addNode" , addNode_function_value , ( bp::arg("timeout") ) ); } { //::SireCluster::Nodes::addNodes typedef void ( ::SireCluster::Nodes::*addNodes_function_type )( int ) ; addNodes_function_type addNodes_function_value( &::SireCluster::Nodes::addNodes ); Nodes_exposer.def( "addNodes" , addNodes_function_value , ( bp::arg("n") ) ); } { //::SireCluster::Nodes::addNodes typedef void ( ::SireCluster::Nodes::*addNodes_function_type )( int,int ) ; addNodes_function_type addNodes_function_value( &::SireCluster::Nodes::addNodes ); Nodes_exposer.def( "addNodes" , addNodes_function_value , ( bp::arg("n"), bp::arg("timeout") ) ); } { //::SireCluster::Nodes::borrowThisThread typedef ::SireCluster::ThisThread ( ::SireCluster::Nodes::*borrowThisThread_function_type )( ) ; borrowThisThread_function_type borrowThisThread_function_value( &::SireCluster::Nodes::borrowThisThread ); Nodes_exposer.def( "borrowThisThread" , borrowThisThread_function_value ); } { //::SireCluster::Nodes::count typedef int ( ::SireCluster::Nodes::*count_function_type )( ) ; count_function_type count_function_value( &::SireCluster::Nodes::count ); Nodes_exposer.def( "count" , count_function_value ); } { //::SireCluster::Nodes::getAllNodes typedef ::QList< SireCluster::Node > ( ::SireCluster::Nodes::*getAllNodes_function_type )( ) ; getAllNodes_function_type getAllNodes_function_value( &::SireCluster::Nodes::getAllNodes ); Nodes_exposer.def( "getAllNodes" , getAllNodes_function_value ); } { //::SireCluster::Nodes::getAllNodes typedef ::QList< SireCluster::Node > ( ::SireCluster::Nodes::*getAllNodes_function_type )( int ) ; getAllNodes_function_type getAllNodes_function_value( &::SireCluster::Nodes::getAllNodes ); Nodes_exposer.def( "getAllNodes" , getAllNodes_function_value , ( bp::arg("timeout") ) ); } { //::SireCluster::Nodes::getNode typedef ::SireCluster::Node ( ::SireCluster::Nodes::*getNode_function_type )( ) ; getNode_function_type getNode_function_value( &::SireCluster::Nodes::getNode ); Nodes_exposer.def( "getNode" , getNode_function_value ); } { //::SireCluster::Nodes::getNode typedef ::SireCluster::Node ( ::SireCluster::Nodes::*getNode_function_type )( int ) ; getNode_function_type getNode_function_value( &::SireCluster::Nodes::getNode ); Nodes_exposer.def( "getNode" , getNode_function_value , ( bp::arg("timeout") ) ); } { //::SireCluster::Nodes::getNodes typedef ::QList< SireCluster::Node > ( ::SireCluster::Nodes::*getNodes_function_type )( int ) ; getNodes_function_type getNodes_function_value( &::SireCluster::Nodes::getNodes ); Nodes_exposer.def( "getNodes" , getNodes_function_value , ( bp::arg("n") ) ); } { //::SireCluster::Nodes::getNodes typedef ::QList< SireCluster::Node > ( ::SireCluster::Nodes::*getNodes_function_type )( int,int ) ; getNodes_function_type getNodes_function_value( &::SireCluster::Nodes::getNodes ); Nodes_exposer.def( "getNodes" , getNodes_function_value , ( bp::arg("n"), bp::arg("timeout") ) ); } { //::SireCluster::Nodes::isEmpty typedef bool ( ::SireCluster::Nodes::*isEmpty_function_type )( ) ; isEmpty_function_type isEmpty_function_value( &::SireCluster::Nodes::isEmpty ); Nodes_exposer.def( "isEmpty" , isEmpty_function_value ); } { //::SireCluster::Nodes::nBusy typedef int ( ::SireCluster::Nodes::*nBusy_function_type )( ) ; nBusy_function_type nBusy_function_value( &::SireCluster::Nodes::nBusy ); Nodes_exposer.def( "nBusy" , nBusy_function_value ); } { //::SireCluster::Nodes::nFree typedef int ( ::SireCluster::Nodes::*nFree_function_type )( ) ; nFree_function_type nFree_function_value( &::SireCluster::Nodes::nFree ); Nodes_exposer.def( "nFree" , nFree_function_value ); } { //::SireCluster::Nodes::nNodes typedef int ( ::SireCluster::Nodes::*nNodes_function_type )( ) ; nNodes_function_type nNodes_function_value( &::SireCluster::Nodes::nNodes ); Nodes_exposer.def( "nNodes" , nNodes_function_value ); } Nodes_exposer.def( bp::self != bp::self ); { //::SireCluster::Nodes::operator= typedef ::SireCluster::Nodes & ( ::SireCluster::Nodes::*assign_function_type )( ::SireCluster::Nodes const & ) ; assign_function_type assign_function_value( &::SireCluster::Nodes::operator= ); Nodes_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() ); } Nodes_exposer.def( bp::self == bp::self ); { //::SireCluster::Nodes::remove typedef void ( ::SireCluster::Nodes::*remove_function_type )( ::SireCluster::Node ) ; remove_function_type remove_function_value( &::SireCluster::Nodes::remove ); Nodes_exposer.def( "remove" , remove_function_value , ( bp::arg("node") ) ); } { //::SireCluster::Nodes::removeAll typedef void ( ::SireCluster::Nodes::*removeAll_function_type )( ) ; removeAll_function_type removeAll_function_value( &::SireCluster::Nodes::removeAll ); Nodes_exposer.def( "removeAll" , removeAll_function_value ); } { //::SireCluster::Nodes::toString typedef ::QString ( ::SireCluster::Nodes::*toString_function_type )( ) const; toString_function_type toString_function_value( &::SireCluster::Nodes::toString ); Nodes_exposer.def( "toString" , toString_function_value ); } { //::SireCluster::Nodes::waitUntilAllFree typedef void ( ::SireCluster::Nodes::*waitUntilAllFree_function_type )( ) ; waitUntilAllFree_function_type waitUntilAllFree_function_value( &::SireCluster::Nodes::waitUntilAllFree ); Nodes_exposer.def( "waitUntilAllFree" , waitUntilAllFree_function_value ); } { //::SireCluster::Nodes::waitUntilAllFree typedef bool ( ::SireCluster::Nodes::*waitUntilAllFree_function_type )( int ) ; waitUntilAllFree_function_type waitUntilAllFree_function_value( &::SireCluster::Nodes::waitUntilAllFree ); Nodes_exposer.def( "waitUntilAllFree" , waitUntilAllFree_function_value , ( bp::arg("timeout") ) ); } Nodes_exposer.def( "__copy__", &__copy__); Nodes_exposer.def( "__deepcopy__", &__copy__); Nodes_exposer.def( "clone", &__copy__); Nodes_exposer.def( "__str__", &__str__< ::SireCluster::Nodes > ); Nodes_exposer.def( "__repr__", &__str__< ::SireCluster::Nodes > ); Nodes_exposer.def( "__len__", &__len_count< ::SireCluster::Nodes > ); } }
void register_GridInfo_class(){ { //::SireVol::GridInfo typedef bp::class_< SireVol::GridInfo > GridInfo_exposer_t; GridInfo_exposer_t GridInfo_exposer = GridInfo_exposer_t( "GridInfo", bp::init< >() ); bp::scope GridInfo_scope( GridInfo_exposer ); GridInfo_exposer.def( bp::init< SireVol::AABox const &, SireUnits::Dimension::Length >(( bp::arg("dimensions"), bp::arg("spacing") )) ); GridInfo_exposer.def( bp::init< SireVol::GridInfo const & >(( bp::arg("other") )) ); { //::SireVol::GridInfo::arrayToGridIndex typedef ::SireVol::GridIndex ( ::SireVol::GridInfo::*arrayToGridIndex_function_type )( int ) const; arrayToGridIndex_function_type arrayToGridIndex_function_value( &::SireVol::GridInfo::arrayToGridIndex ); GridInfo_exposer.def( "arrayToGridIndex" , arrayToGridIndex_function_value , ( bp::arg("i") ) ); } { //::SireVol::GridInfo::at typedef ::SireVol::GridIndex ( ::SireVol::GridInfo::*at_function_type )( int ) const; at_function_type at_function_value( &::SireVol::GridInfo::at ); GridInfo_exposer.def( "at" , at_function_value , ( bp::arg("i") ) ); } { //::SireVol::GridInfo::at typedef int ( ::SireVol::GridInfo::*at_function_type )( ::SireVol::GridIndex const & ) const; at_function_type at_function_value( &::SireVol::GridInfo::at ); GridInfo_exposer.def( "at" , at_function_value , ( bp::arg("idx") ) ); } { //::SireVol::GridInfo::at typedef int ( ::SireVol::GridInfo::*at_function_type )( int,int,int ) const; at_function_type at_function_value( &::SireVol::GridInfo::at ); GridInfo_exposer.def( "at" , at_function_value , ( bp::arg("i"), bp::arg("j"), bp::arg("k") ) ); } { //::SireVol::GridInfo::at typedef int ( ::SireVol::GridInfo::*at_function_type )( ::SireMaths::Vector const & ) const; at_function_type at_function_value( &::SireVol::GridInfo::at ); GridInfo_exposer.def( "at" , at_function_value , ( bp::arg("point") ) ); } { //::SireVol::GridInfo::box typedef ::SireVol::AABox ( ::SireVol::GridInfo::*box_function_type )( int ) const; box_function_type box_function_value( &::SireVol::GridInfo::box ); GridInfo_exposer.def( "box" , box_function_value , ( bp::arg("i") ) ); } { //::SireVol::GridInfo::box typedef ::SireVol::AABox ( ::SireVol::GridInfo::*box_function_type )( ::SireVol::GridIndex const & ) const; box_function_type box_function_value( &::SireVol::GridInfo::box ); GridInfo_exposer.def( "box" , box_function_value , ( bp::arg("idx") ) ); } { //::SireVol::GridInfo::box typedef ::SireVol::AABox ( ::SireVol::GridInfo::*box_function_type )( ::SireMaths::Vector const & ) const; box_function_type box_function_value( &::SireVol::GridInfo::box ); GridInfo_exposer.def( "box" , box_function_value , ( bp::arg("point") ) ); } { //::SireVol::GridInfo::closestIndexTo typedef ::SireVol::GridIndex ( ::SireVol::GridInfo::*closestIndexTo_function_type )( ::SireMaths::Vector const & ) const; closestIndexTo_function_type closestIndexTo_function_value( &::SireVol::GridInfo::closestIndexTo ); GridInfo_exposer.def( "closestIndexTo" , closestIndexTo_function_value , ( bp::arg("point") ) ); } { //::SireVol::GridInfo::contains typedef bool ( ::SireVol::GridInfo::*contains_function_type )( ::SireMaths::Vector const & ) const; contains_function_type contains_function_value( &::SireVol::GridInfo::contains ); GridInfo_exposer.def( "contains" , contains_function_value , ( bp::arg("point") ) ); } { //::SireVol::GridInfo::count typedef int ( ::SireVol::GridInfo::*count_function_type )( ) const; count_function_type count_function_value( &::SireVol::GridInfo::count ); GridInfo_exposer.def( "count" , count_function_value ); } { //::SireVol::GridInfo::dimX typedef ::qint32 ( ::SireVol::GridInfo::*dimX_function_type )( ) const; dimX_function_type dimX_function_value( &::SireVol::GridInfo::dimX ); GridInfo_exposer.def( "dimX" , dimX_function_value ); } { //::SireVol::GridInfo::dimY typedef ::qint32 ( ::SireVol::GridInfo::*dimY_function_type )( ) const; dimY_function_type dimY_function_value( &::SireVol::GridInfo::dimY ); GridInfo_exposer.def( "dimY" , dimY_function_value ); } { //::SireVol::GridInfo::dimZ typedef ::qint32 ( ::SireVol::GridInfo::*dimZ_function_type )( ) const; dimZ_function_type dimZ_function_value( &::SireVol::GridInfo::dimZ ); GridInfo_exposer.def( "dimZ" , dimZ_function_value ); } { //::SireVol::GridInfo::dimensions typedef ::SireVol::AABox ( ::SireVol::GridInfo::*dimensions_function_type )( ) const; dimensions_function_type dimensions_function_value( &::SireVol::GridInfo::dimensions ); GridInfo_exposer.def( "dimensions" , dimensions_function_value ); } { //::SireVol::GridInfo::getitem typedef ::SireVol::GridIndex ( ::SireVol::GridInfo::*getitem_function_type )( int ) const; getitem_function_type getitem_function_value( &::SireVol::GridInfo::getitem ); GridInfo_exposer.def( "getitem" , getitem_function_value , ( bp::arg("i") ) ); } { //::SireVol::GridInfo::gridToArrayIndex typedef int ( ::SireVol::GridInfo::*gridToArrayIndex_function_type )( int,int,int ) const; gridToArrayIndex_function_type gridToArrayIndex_function_value( &::SireVol::GridInfo::gridToArrayIndex ); GridInfo_exposer.def( "gridToArrayIndex" , gridToArrayIndex_function_value , ( bp::arg("i"), bp::arg("j"), bp::arg("k") ) ); } { //::SireVol::GridInfo::gridToArrayIndex typedef int ( ::SireVol::GridInfo::*gridToArrayIndex_function_type )( ::SireVol::GridIndex const & ) const; gridToArrayIndex_function_type gridToArrayIndex_function_value( &::SireVol::GridInfo::gridToArrayIndex ); GridInfo_exposer.def( "gridToArrayIndex" , gridToArrayIndex_function_value , ( bp::arg("idx") ) ); } { //::SireVol::GridInfo::indexOf typedef ::SireVol::GridIndex ( ::SireVol::GridInfo::*indexOf_function_type )( int,::SireVol::GridInfo const & ) const; indexOf_function_type indexOf_function_value( &::SireVol::GridInfo::indexOf ); GridInfo_exposer.def( "indexOf" , indexOf_function_value , ( bp::arg("i"), bp::arg("grid") ) ); } { //::SireVol::GridInfo::indexOf typedef ::SireVol::GridIndex ( ::SireVol::GridInfo::*indexOf_function_type )( ::SireVol::GridIndex const &,::SireVol::GridInfo const & ) const; indexOf_function_type indexOf_function_value( &::SireVol::GridInfo::indexOf ); GridInfo_exposer.def( "indexOf" , indexOf_function_value , ( bp::arg("idx"), bp::arg("grid") ) ); } { //::SireVol::GridInfo::isEmpty typedef bool ( ::SireVol::GridInfo::*isEmpty_function_type )( ) const; isEmpty_function_type isEmpty_function_value( &::SireVol::GridInfo::isEmpty ); GridInfo_exposer.def( "isEmpty" , isEmpty_function_value ); } { //::SireVol::GridInfo::nPoints typedef int ( ::SireVol::GridInfo::*nPoints_function_type )( ) const; nPoints_function_type nPoints_function_value( &::SireVol::GridInfo::nPoints ); GridInfo_exposer.def( "nPoints" , nPoints_function_value ); } GridInfo_exposer.def( bp::self != bp::self ); { //::SireVol::GridInfo::operator= typedef ::SireVol::GridInfo & ( ::SireVol::GridInfo::*assign_function_type )( ::SireVol::GridInfo const & ) ; assign_function_type assign_function_value( &::SireVol::GridInfo::operator= ); GridInfo_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() ); } GridInfo_exposer.def( bp::self == bp::self ); { //::SireVol::GridInfo::operator[] typedef ::SireVol::GridIndex ( ::SireVol::GridInfo::*__getitem___function_type )( int ) const; __getitem___function_type __getitem___function_value( &::SireVol::GridInfo::operator[] ); GridInfo_exposer.def( "__getitem__" , __getitem___function_value , ( bp::arg("i") ) ); } { //::SireVol::GridInfo::operator[] typedef int ( ::SireVol::GridInfo::*__getitem___function_type )( ::SireVol::GridIndex const & ) const; __getitem___function_type __getitem___function_value( &::SireVol::GridInfo::operator[] ); GridInfo_exposer.def( "__getitem__" , __getitem___function_value , ( bp::arg("idx") ) ); } { //::SireVol::GridInfo::operator[] typedef int ( ::SireVol::GridInfo::*__getitem___function_type )( ::SireMaths::Vector const & ) const; __getitem___function_type __getitem___function_value( &::SireVol::GridInfo::operator[] ); GridInfo_exposer.def( "__getitem__" , __getitem___function_value , ( bp::arg("point") ) ); } { //::SireVol::GridInfo::point typedef ::SireMaths::Vector ( ::SireVol::GridInfo::*point_function_type )( int ) const; point_function_type point_function_value( &::SireVol::GridInfo::point ); GridInfo_exposer.def( "point" , point_function_value , ( bp::arg("i") ) ); } { //::SireVol::GridInfo::point typedef ::SireMaths::Vector ( ::SireVol::GridInfo::*point_function_type )( ::SireVol::GridIndex const & ) const; point_function_type point_function_value( &::SireVol::GridInfo::point ); GridInfo_exposer.def( "point" , point_function_value , ( bp::arg("idx") ) ); } { //::SireVol::GridInfo::point typedef ::SireMaths::Vector ( ::SireVol::GridInfo::*point_function_type )( ::SireMaths::Vector const & ) const; point_function_type point_function_value( &::SireVol::GridInfo::point ); GridInfo_exposer.def( "point" , point_function_value , ( bp::arg("point") ) ); } { //::SireVol::GridInfo::pointToArrayIndex typedef int ( ::SireVol::GridInfo::*pointToArrayIndex_function_type )( ::SireMaths::Vector const & ) const; pointToArrayIndex_function_type pointToArrayIndex_function_value( &::SireVol::GridInfo::pointToArrayIndex ); GridInfo_exposer.def( "pointToArrayIndex" , pointToArrayIndex_function_value , ( bp::arg("point") ) ); } { //::SireVol::GridInfo::pointToGridCorners typedef void ( ::SireVol::GridInfo::*pointToGridCorners_function_type )( ::SireMaths::Vector const &,::QVector< int > & ) const; pointToGridCorners_function_type pointToGridCorners_function_value( &::SireVol::GridInfo::pointToGridCorners ); GridInfo_exposer.def( "pointToGridCorners" , pointToGridCorners_function_value , ( bp::arg("point"), bp::arg("indicies") ) ); } { //::SireVol::GridInfo::pointToGridCorners typedef void ( ::SireVol::GridInfo::*pointToGridCorners_function_type )( ::SireMaths::Vector const &,::QVector< int > &,::QVector< float > & ) const; pointToGridCorners_function_type pointToGridCorners_function_value( &::SireVol::GridInfo::pointToGridCorners ); GridInfo_exposer.def( "pointToGridCorners" , pointToGridCorners_function_value , ( bp::arg("point"), bp::arg("indicies"), bp::arg("weights") ) ); } { //::SireVol::GridInfo::pointToGridCorners typedef int ( ::SireVol::GridInfo::*pointToGridCorners_function_type )( ::SireMaths::MultiFloat const &,::SireMaths::MultiFloat const &,::SireMaths::MultiFloat const &,::QVector< SireMaths::MultiInt > & ) const; pointToGridCorners_function_type pointToGridCorners_function_value( &::SireVol::GridInfo::pointToGridCorners ); GridInfo_exposer.def( "pointToGridCorners" , pointToGridCorners_function_value , ( bp::arg("x"), bp::arg("y"), bp::arg("z"), bp::arg("indicies") ) ); } { //::SireVol::GridInfo::pointToGridCorners typedef int ( ::SireVol::GridInfo::*pointToGridCorners_function_type )( ::SireMaths::MultiFloat const &,::SireMaths::MultiFloat const &,::SireMaths::MultiFloat const &,::QVector< SireMaths::MultiInt > &,::QVector< SireMaths::MultiFloat > & ) const; pointToGridCorners_function_type pointToGridCorners_function_value( &::SireVol::GridInfo::pointToGridCorners ); GridInfo_exposer.def( "pointToGridCorners" , pointToGridCorners_function_value , ( bp::arg("x"), bp::arg("y"), bp::arg("z"), bp::arg("indicies"), bp::arg("weights") ) ); } { //::SireVol::GridInfo::pointToGridIndex typedef ::SireVol::GridIndex ( ::SireVol::GridInfo::*pointToGridIndex_function_type )( ::SireMaths::Vector const & ) const; pointToGridIndex_function_type pointToGridIndex_function_value( &::SireVol::GridInfo::pointToGridIndex ); GridInfo_exposer.def( "pointToGridIndex" , pointToGridIndex_function_value , ( bp::arg("point") ) ); } { //::SireVol::GridInfo::redimension typedef ::QVector< float > ( ::SireVol::GridInfo::*redimension_function_type )( ::QVector< float > const &,::SireVol::GridInfo const & ) const; redimension_function_type redimension_function_value( &::SireVol::GridInfo::redimension ); GridInfo_exposer.def( "redimension" , redimension_function_value , ( bp::arg("values"), bp::arg("new_grid") ) ); } { //::SireVol::GridInfo::size typedef int ( ::SireVol::GridInfo::*size_function_type )( ) const; size_function_type size_function_value( &::SireVol::GridInfo::size ); GridInfo_exposer.def( "size" , size_function_value ); } { //::SireVol::GridInfo::spacing typedef ::SireUnits::Dimension::Length ( ::SireVol::GridInfo::*spacing_function_type )( ) const; spacing_function_type spacing_function_value( &::SireVol::GridInfo::spacing ); GridInfo_exposer.def( "spacing" , spacing_function_value ); } { //::SireVol::GridInfo::toString typedef ::QString ( ::SireVol::GridInfo::*toString_function_type )( ) const; toString_function_type toString_function_value( &::SireVol::GridInfo::toString ); GridInfo_exposer.def( "toString" , toString_function_value ); } { //::SireVol::GridInfo::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireVol::GridInfo::typeName ); GridInfo_exposer.def( "typeName" , typeName_function_value ); } { //::SireVol::GridInfo::what typedef char const * ( ::SireVol::GridInfo::*what_function_type )( ) const; what_function_type what_function_value( &::SireVol::GridInfo::what ); GridInfo_exposer.def( "what" , what_function_value ); } GridInfo_exposer.staticmethod( "typeName" ); GridInfo_exposer.def( "__copy__", &__copy__); GridInfo_exposer.def( "__deepcopy__", &__copy__); GridInfo_exposer.def( "clone", &__copy__); GridInfo_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireVol::GridInfo >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); GridInfo_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireVol::GridInfo >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); GridInfo_exposer.def( "__str__", &__str__< ::SireVol::GridInfo > ); GridInfo_exposer.def( "__repr__", &__str__< ::SireVol::GridInfo > ); GridInfo_exposer.def( "__len__", &__len_size< ::SireVol::GridInfo > ); GridInfo_exposer.def( "__getitem__", &::SireVol::GridInfo::getitem ); } }
void register_PackedArray2D_int_Array_class(){ { //::SireBase::detail::PackedArray2D_Array< int > typedef bp::class_< SireBase::detail::PackedArray2D_Array< int > > PackedArray2D_int_Array_exposer_t; PackedArray2D_int_Array_exposer_t PackedArray2D_int_Array_exposer = PackedArray2D_int_Array_exposer_t( "PackedArray2D_int_Array", bp::init< >() ); bp::scope PackedArray2D_int_Array_scope( PackedArray2D_int_Array_exposer ); PackedArray2D_int_Array_exposer.def( bp::init< quint32 >(( bp::arg("sz") )) ); PackedArray2D_int_Array_exposer.def( bp::init< quint32, int const & >(( bp::arg("sz"), bp::arg("value") )) ); PackedArray2D_int_Array_exposer.def( bp::init< QVector< int > const & >(( bp::arg("values") )) ); PackedArray2D_int_Array_exposer.def( bp::init< SireBase::detail::PackedArray2D_Array< int > const & >(( bp::arg("other") )) ); { //::SireBase::detail::PackedArray2D_Array< int >::assertValidIndex typedef SireBase::detail::PackedArray2D_Array< int > exported_class_t; typedef void ( ::SireBase::detail::PackedArray2D_Array< int >::*assertValidIndex_function_type )( ::quint32 ) const; assertValidIndex_function_type assertValidIndex_function_value( &::SireBase::detail::PackedArray2D_Array< int >::assertValidIndex ); PackedArray2D_int_Array_exposer.def( "assertValidIndex" , assertValidIndex_function_value , ( bp::arg("i") ) ); } { //::SireBase::detail::PackedArray2D_Array< int >::at typedef SireBase::detail::PackedArray2D_Array< int > exported_class_t; typedef int const & ( ::SireBase::detail::PackedArray2D_Array< int >::*at_function_type )( ::quint32 ) const; at_function_type at_function_value( &::SireBase::detail::PackedArray2D_Array< int >::at ); PackedArray2D_int_Array_exposer.def( "at" , at_function_value , ( bp::arg("i") ) , bp::return_value_policy< bp::copy_const_reference >() ); } { //::SireBase::detail::PackedArray2D_Array< int >::count typedef SireBase::detail::PackedArray2D_Array< int > exported_class_t; typedef int ( ::SireBase::detail::PackedArray2D_Array< int >::*count_function_type )( ) const; count_function_type count_function_value( &::SireBase::detail::PackedArray2D_Array< int >::count ); PackedArray2D_int_Array_exposer.def( "count" , count_function_value ); } { //::SireBase::detail::PackedArray2D_Array< int >::isEmpty typedef SireBase::detail::PackedArray2D_Array< int > exported_class_t; typedef bool ( ::SireBase::detail::PackedArray2D_Array< int >::*isEmpty_function_type )( ) const; isEmpty_function_type isEmpty_function_value( &::SireBase::detail::PackedArray2D_Array< int >::isEmpty ); PackedArray2D_int_Array_exposer.def( "isEmpty" , isEmpty_function_value ); } { //::SireBase::detail::PackedArray2D_Array< int >::nValues typedef SireBase::detail::PackedArray2D_Array< int > exported_class_t; typedef int ( ::SireBase::detail::PackedArray2D_Array< int >::*nValues_function_type )( ) const; nValues_function_type nValues_function_value( &::SireBase::detail::PackedArray2D_Array< int >::nValues ); PackedArray2D_int_Array_exposer.def( "nValues" , nValues_function_value ); } PackedArray2D_int_Array_exposer.def( bp::self != bp::self ); { //::SireBase::detail::PackedArray2D_Array< int >::operator= typedef SireBase::detail::PackedArray2D_Array< int > exported_class_t; typedef ::SireBase::detail::PackedArray2D_Array< int > & ( ::SireBase::detail::PackedArray2D_Array< int >::*assign_function_type )( ::SireBase::detail::PackedArray2D_Array< int > const & ) ; assign_function_type assign_function_value( &::SireBase::detail::PackedArray2D_Array< int >::operator= ); PackedArray2D_int_Array_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() ); } PackedArray2D_int_Array_exposer.def( bp::self == bp::self ); { //::SireBase::detail::PackedArray2D_Array< int >::operator[] typedef SireBase::detail::PackedArray2D_Array< int > exported_class_t; typedef int const & ( ::SireBase::detail::PackedArray2D_Array< int >::*__getitem___function_type )( ::quint32 ) const; __getitem___function_type __getitem___function_value( &::SireBase::detail::PackedArray2D_Array< int >::operator[] ); PackedArray2D_int_Array_exposer.def( "__getitem__" , __getitem___function_value , ( bp::arg("i") ) , bp::return_value_policy< bp::copy_const_reference >() ); } { //::SireBase::detail::PackedArray2D_Array< int >::operator[] typedef SireBase::detail::PackedArray2D_Array< int > exported_class_t; typedef int & ( ::SireBase::detail::PackedArray2D_Array< int >::*__getitem___function_type )( ::quint32 ) ; __getitem___function_type __getitem___function_value( &::SireBase::detail::PackedArray2D_Array< int >::operator[] ); PackedArray2D_int_Array_exposer.def( "__getitem__" , __getitem___function_value , ( bp::arg("i") ) , bp::return_value_policy< bp::copy_non_const_reference >() ); } { //::SireBase::detail::PackedArray2D_Array< int >::size typedef SireBase::detail::PackedArray2D_Array< int > exported_class_t; typedef int ( ::SireBase::detail::PackedArray2D_Array< int >::*size_function_type )( ) const; size_function_type size_function_value( &::SireBase::detail::PackedArray2D_Array< int >::size ); PackedArray2D_int_Array_exposer.def( "size" , size_function_value ); } { //::SireBase::detail::PackedArray2D_Array< int >::toQVector typedef SireBase::detail::PackedArray2D_Array< int > exported_class_t; typedef ::QVector< int > ( ::SireBase::detail::PackedArray2D_Array< int >::*toQVector_function_type )( ) const; toQVector_function_type toQVector_function_value( &::SireBase::detail::PackedArray2D_Array< int >::toQVector ); PackedArray2D_int_Array_exposer.def( "toQVector" , toQVector_function_value ); } { //::SireBase::detail::PackedArray2D_Array< int >::toString typedef SireBase::detail::PackedArray2D_Array< int > exported_class_t; typedef ::QString ( ::SireBase::detail::PackedArray2D_Array< int >::*toString_function_type )( ) const; toString_function_type toString_function_value( &::SireBase::detail::PackedArray2D_Array< int >::toString ); PackedArray2D_int_Array_exposer.def( "toString" , toString_function_value ); } { //::SireBase::detail::PackedArray2D_Array< int >::update typedef SireBase::detail::PackedArray2D_Array< int > exported_class_t; typedef void ( ::SireBase::detail::PackedArray2D_Array< int >::*update_function_type )( ::SireBase::detail::PackedArray2D_Array< int > const & ) ; update_function_type update_function_value( &::SireBase::detail::PackedArray2D_Array< int >::update ); PackedArray2D_int_Array_exposer.def( "update" , update_function_value , ( bp::arg("other") ) ); } PackedArray2D_int_Array_exposer.def( "__copy__", &__copy__); PackedArray2D_int_Array_exposer.def( "__deepcopy__", &__copy__); PackedArray2D_int_Array_exposer.def( "clone", &__copy__); PackedArray2D_int_Array_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireBase::detail::PackedArray2D_Array<int> >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); PackedArray2D_int_Array_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireBase::detail::PackedArray2D_Array<int> >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); PackedArray2D_int_Array_exposer.def( "__str__", &__str__< ::SireBase::detail::PackedArray2D_Array<int> > ); PackedArray2D_int_Array_exposer.def( "__repr__", &__str__< ::SireBase::detail::PackedArray2D_Array<int> > ); PackedArray2D_int_Array_exposer.def( "__len__", &__len_size< ::SireBase::detail::PackedArray2D_Array<int> > ); } }
void register_SupraSubMove_class(){ { //::SireMove::SupraSubMove typedef bp::class_< SireMove::SupraSubMove, bp::bases< SireBase::Property >, boost::noncopyable > SupraSubMove_exposer_t; SupraSubMove_exposer_t SupraSubMove_exposer = SupraSubMove_exposer_t( "SupraSubMove", bp::no_init ); bp::scope SupraSubMove_scope( SupraSubMove_exposer ); { //::SireMove::SupraSubMove::clearStatistics typedef void ( ::SireMove::SupraSubMove::*clearStatistics_function_type )( ) ; clearStatistics_function_type clearStatistics_function_value( &::SireMove::SupraSubMove::clearStatistics ); SupraSubMove_exposer.def( "clearStatistics" , clearStatistics_function_value ); } { //::SireMove::SupraSubMove::move typedef void ( ::SireMove::SupraSubMove::*move_function_type )( ::SireMove::SupraSubSystem &,int,int,bool ) ; move_function_type move_function_value( &::SireMove::SupraSubMove::move ); SupraSubMove_exposer.def( "move" , move_function_value , ( bp::arg("system"), bp::arg("n_supra_moves"), bp::arg("n_supra_moves_per_block"), bp::arg("record_stats")=(bool)(true) ) ); } { //::SireMove::SupraSubMove::null typedef ::SireMove::NullSupraSubMove const & ( *null_function_type )( ); null_function_type null_function_value( &::SireMove::SupraSubMove::null ); SupraSubMove_exposer.def( "null" , null_function_value , bp::return_value_policy< bp::copy_const_reference >() ); } { //::SireMove::SupraSubMove::toString typedef ::QString ( ::SireMove::SupraSubMove::*toString_function_type )( ) const; toString_function_type toString_function_value( &::SireMove::SupraSubMove::toString ); SupraSubMove_exposer.def( "toString" , toString_function_value ); } { //::SireMove::SupraSubMove::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireMove::SupraSubMove::typeName ); SupraSubMove_exposer.def( "typeName" , typeName_function_value ); } SupraSubMove_exposer.staticmethod( "null" ); SupraSubMove_exposer.staticmethod( "typeName" ); SupraSubMove_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMove::SupraSubMove >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); SupraSubMove_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMove::SupraSubMove >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); SupraSubMove_exposer.def( "__str__", &__str__< ::SireMove::SupraSubMove > ); SupraSubMove_exposer.def( "__repr__", &__str__< ::SireMove::SupraSubMove > ); } }
void register_DataPoint_class(){ { //::SireAnalysis::DataPoint typedef bp::class_< SireAnalysis::DataPoint > DataPoint_exposer_t; DataPoint_exposer_t DataPoint_exposer = DataPoint_exposer_t( "DataPoint", "This class represents a single datapoint on an x,y graph. The point\nhas associated errors (small and large) on both the x and y axes\n\nAuthor: Christopher Woods\n", bp::init< >("Constructor. This constructs the point (0,0) with no error") ); bp::scope DataPoint_scope( DataPoint_exposer ); DataPoint_exposer.def( bp::init< double, double >(( bp::arg("x"), bp::arg("y") ), "Construct the point (x,y) with no error") ); DataPoint_exposer.def( bp::init< double, double, double, double >(( bp::arg("x"), bp::arg("y"), bp::arg("xerror"), bp::arg("yerror") ), "Construct the point (x,y) with error (xerror,yerror)") ); DataPoint_exposer.def( bp::init< double, double, double, double, double, double >(( bp::arg("x"), bp::arg("y"), bp::arg("xminerror"), bp::arg("yminerror"), bp::arg("xmaxerror"), bp::arg("ymaxerror") ), "Construct the point (x,y) with a minimum error of (xminerror,yminerror)\nand a maximum error of (xmaxerror,ymaxerror). This is for situations where\nthere may be multiple different error measures on a point and you want\nto store the range of errors (based on a range of error estimates)") ); DataPoint_exposer.def( bp::init< SireAnalysis::DataPoint const & >(( bp::arg("other") ), "Copy constructor") ); { //::SireAnalysis::DataPoint::equalWithinError typedef bool ( ::SireAnalysis::DataPoint::*equalWithinError_function_type)( ::SireAnalysis::DataPoint const & ) const; equalWithinError_function_type equalWithinError_function_value( &::SireAnalysis::DataPoint::equalWithinError ); DataPoint_exposer.def( "equalWithinError" , equalWithinError_function_value , ( bp::arg("other") ) , "Return whether or not this data point is equal to the other, within\nthe error range of the two points" ); } { //::SireAnalysis::DataPoint::equalWithinMaxError typedef bool ( ::SireAnalysis::DataPoint::*equalWithinMaxError_function_type)( ::SireAnalysis::DataPoint const & ) const; equalWithinMaxError_function_type equalWithinMaxError_function_value( &::SireAnalysis::DataPoint::equalWithinMaxError ); DataPoint_exposer.def( "equalWithinMaxError" , equalWithinMaxError_function_value , ( bp::arg("other") ) , "Return whether or not this data point in equal to the other, within\nthe maximum error range of the two points" ); } { //::SireAnalysis::DataPoint::equalWithinMinError typedef bool ( ::SireAnalysis::DataPoint::*equalWithinMinError_function_type)( ::SireAnalysis::DataPoint const & ) const; equalWithinMinError_function_type equalWithinMinError_function_value( &::SireAnalysis::DataPoint::equalWithinMinError ); DataPoint_exposer.def( "equalWithinMinError" , equalWithinMinError_function_value , ( bp::arg("other") ) , "Return whether or not this data point in equal to the other, within\nthe minimum error range of the two points" ); } { //::SireAnalysis::DataPoint::hasError typedef bool ( ::SireAnalysis::DataPoint::*hasError_function_type)( ) const; hasError_function_type hasError_function_value( &::SireAnalysis::DataPoint::hasError ); DataPoint_exposer.def( "hasError" , hasError_function_value , "Return whether or not this data point has any error" ); } { //::SireAnalysis::DataPoint::hasErrorRange typedef bool ( ::SireAnalysis::DataPoint::*hasErrorRange_function_type)( ) const; hasErrorRange_function_type hasErrorRange_function_value( &::SireAnalysis::DataPoint::hasErrorRange ); DataPoint_exposer.def( "hasErrorRange" , hasErrorRange_function_value , "Return whether or not this data point has an error range" ); } { //::SireAnalysis::DataPoint::hasXError typedef bool ( ::SireAnalysis::DataPoint::*hasXError_function_type)( ) const; hasXError_function_type hasXError_function_value( &::SireAnalysis::DataPoint::hasXError ); DataPoint_exposer.def( "hasXError" , hasXError_function_value , "Return whether or not there is any error in the x value" ); } { //::SireAnalysis::DataPoint::hasXErrorRange typedef bool ( ::SireAnalysis::DataPoint::*hasXErrorRange_function_type)( ) const; hasXErrorRange_function_type hasXErrorRange_function_value( &::SireAnalysis::DataPoint::hasXErrorRange ); DataPoint_exposer.def( "hasXErrorRange" , hasXErrorRange_function_value , "Return whether or not there is an error range on the x value" ); } { //::SireAnalysis::DataPoint::hasYError typedef bool ( ::SireAnalysis::DataPoint::*hasYError_function_type)( ) const; hasYError_function_type hasYError_function_value( &::SireAnalysis::DataPoint::hasYError ); DataPoint_exposer.def( "hasYError" , hasYError_function_value , "Return whether or not there is any error in the y value" ); } { //::SireAnalysis::DataPoint::hasYErrorRange typedef bool ( ::SireAnalysis::DataPoint::*hasYErrorRange_function_type)( ) const; hasYErrorRange_function_type hasYErrorRange_function_value( &::SireAnalysis::DataPoint::hasYErrorRange ); DataPoint_exposer.def( "hasYErrorRange" , hasYErrorRange_function_value , "Return whether or not there is an error range on the x value" ); } DataPoint_exposer.def( bp::self != bp::self ); { //::SireAnalysis::DataPoint::operator= typedef ::SireAnalysis::DataPoint & ( ::SireAnalysis::DataPoint::*assign_function_type)( ::SireAnalysis::DataPoint const & ) ; assign_function_type assign_function_value( &::SireAnalysis::DataPoint::operator= ); DataPoint_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() , "" ); } DataPoint_exposer.def( bp::self == bp::self ); { //::SireAnalysis::DataPoint::toString typedef ::QString ( ::SireAnalysis::DataPoint::*toString_function_type)( ) const; toString_function_type toString_function_value( &::SireAnalysis::DataPoint::toString ); DataPoint_exposer.def( "toString" , toString_function_value , "" ); } { //::SireAnalysis::DataPoint::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireAnalysis::DataPoint::typeName ); DataPoint_exposer.def( "typeName" , typeName_function_value , "" ); } { //::SireAnalysis::DataPoint::what typedef char const * ( ::SireAnalysis::DataPoint::*what_function_type)( ) const; what_function_type what_function_value( &::SireAnalysis::DataPoint::what ); DataPoint_exposer.def( "what" , what_function_value , "" ); } { //::SireAnalysis::DataPoint::x typedef double ( ::SireAnalysis::DataPoint::*x_function_type)( ) const; x_function_type x_function_value( &::SireAnalysis::DataPoint::x ); DataPoint_exposer.def( "x" , x_function_value , "Return the x value of the point" ); } { //::SireAnalysis::DataPoint::xError typedef double ( ::SireAnalysis::DataPoint::*xError_function_type)( ) const; xError_function_type xError_function_value( &::SireAnalysis::DataPoint::xError ); DataPoint_exposer.def( "xError" , xError_function_value , "Return the error on the x value. This is the average\nof the minimum and maximum error" ); } { //::SireAnalysis::DataPoint::xMaxError typedef double ( ::SireAnalysis::DataPoint::*xMaxError_function_type)( ) const; xMaxError_function_type xMaxError_function_value( &::SireAnalysis::DataPoint::xMaxError ); DataPoint_exposer.def( "xMaxError" , xMaxError_function_value , "Return the maximum size of the error on the x value" ); } { //::SireAnalysis::DataPoint::xMinError typedef double ( ::SireAnalysis::DataPoint::*xMinError_function_type)( ) const; xMinError_function_type xMinError_function_value( &::SireAnalysis::DataPoint::xMinError ); DataPoint_exposer.def( "xMinError" , xMinError_function_value , "Return the minimum size of the error on the x value" ); } { //::SireAnalysis::DataPoint::y typedef double ( ::SireAnalysis::DataPoint::*y_function_type)( ) const; y_function_type y_function_value( &::SireAnalysis::DataPoint::y ); DataPoint_exposer.def( "y" , y_function_value , "Return the y value of the point" ); } { //::SireAnalysis::DataPoint::yError typedef double ( ::SireAnalysis::DataPoint::*yError_function_type)( ) const; yError_function_type yError_function_value( &::SireAnalysis::DataPoint::yError ); DataPoint_exposer.def( "yError" , yError_function_value , "Return the error on the y value. This is the average\nof the minimum and maximum error" ); } { //::SireAnalysis::DataPoint::yMaxError typedef double ( ::SireAnalysis::DataPoint::*yMaxError_function_type)( ) const; yMaxError_function_type yMaxError_function_value( &::SireAnalysis::DataPoint::yMaxError ); DataPoint_exposer.def( "yMaxError" , yMaxError_function_value , "Return the maximum size of the error on the y value" ); } { //::SireAnalysis::DataPoint::yMinError typedef double ( ::SireAnalysis::DataPoint::*yMinError_function_type)( ) const; yMinError_function_type yMinError_function_value( &::SireAnalysis::DataPoint::yMinError ); DataPoint_exposer.def( "yMinError" , yMinError_function_value , "Return the minimum size of the error on the y value" ); } DataPoint_exposer.staticmethod( "typeName" ); DataPoint_exposer.def( "__copy__", &__copy__); DataPoint_exposer.def( "__deepcopy__", &__copy__); DataPoint_exposer.def( "clone", &__copy__); DataPoint_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireAnalysis::DataPoint >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); DataPoint_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireAnalysis::DataPoint >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); DataPoint_exposer.def( "__str__", &__str__< ::SireAnalysis::DataPoint > ); DataPoint_exposer.def( "__repr__", &__str__< ::SireAnalysis::DataPoint > ); } }
void register_CLJAtom_class(){ { //::SireMM::CLJAtom typedef bp::class_< SireMM::CLJAtom > CLJAtom_exposer_t; CLJAtom_exposer_t CLJAtom_exposer = CLJAtom_exposer_t( "CLJAtom", bp::init< >() ); bp::scope CLJAtom_scope( CLJAtom_exposer ); CLJAtom_exposer.def( bp::init< SireMaths::Vector, SireUnits::Dimension::Charge, SireMM::LJParameter, bp::optional< qint32 > >(( bp::arg("coords"), bp::arg("charge"), bp::arg("ljparam"), bp::arg("idnum")=(int)(1) )) ); CLJAtom_exposer.def( bp::init< SireMM::CLJAtom const & >(( bp::arg("other") )) ); { //::SireMM::CLJAtom::ID typedef ::qint32 ( ::SireMM::CLJAtom::*ID_function_type )( ) const; ID_function_type ID_function_value( &::SireMM::CLJAtom::ID ); CLJAtom_exposer.def( "ID" , ID_function_value ); } { //::SireMM::CLJAtom::buildFrom typedef ::QVector< SireMM::CLJAtom > ( *buildFrom_function_type )( ::SireMol::MoleculeView const &,::SireBase::PropertyMap const & ); buildFrom_function_type buildFrom_function_value( &::SireMM::CLJAtom::buildFrom ); CLJAtom_exposer.def( "buildFrom" , buildFrom_function_value , ( bp::arg("molecule"), bp::arg("map")=SireBase::PropertyMap() ) ); } { //::SireMM::CLJAtom::charge typedef ::SireUnits::Dimension::Charge ( ::SireMM::CLJAtom::*charge_function_type )( ) const; charge_function_type charge_function_value( &::SireMM::CLJAtom::charge ); CLJAtom_exposer.def( "charge" , charge_function_value ); } { //::SireMM::CLJAtom::coordinates typedef ::SireMaths::Vector ( ::SireMM::CLJAtom::*coordinates_function_type )( ) const; coordinates_function_type coordinates_function_value( &::SireMM::CLJAtom::coordinates ); CLJAtom_exposer.def( "coordinates" , coordinates_function_value ); } { //::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 > ); } }
void register_MolResNum_class(){ { //::SireMol::MolResNum typedef bp::class_< SireMol::MolResNum, bp::bases< SireMol::ResID, SireID::ID > > MolResNum_exposer_t; MolResNum_exposer_t MolResNum_exposer = MolResNum_exposer_t( "MolResNum", bp::init< >() ); bp::scope MolResNum_scope( MolResNum_exposer ); MolResNum_exposer.def( bp::init< SireMol::MolNum const &, SireMol::ResNum const & >(( bp::arg("molnum"), bp::arg("resnum") )) ); MolResNum_exposer.def( bp::init< SireMol::ResNum const &, SireMol::MolNum const & >(( bp::arg("resnum"), bp::arg("molnum") )) ); MolResNum_exposer.def( bp::init< SireMol::MolResNum const & >(( bp::arg("other") )) ); { //::SireMol::MolResNum::hash typedef ::uint ( ::SireMol::MolResNum::*hash_function_type )( ) const; hash_function_type hash_function_value( &::SireMol::MolResNum::hash ); MolResNum_exposer.def( "hash" , hash_function_value ); } { //::SireMol::MolResNum::isNull typedef bool ( ::SireMol::MolResNum::*isNull_function_type )( ) const; isNull_function_type isNull_function_value( &::SireMol::MolResNum::isNull ); MolResNum_exposer.def( "isNull" , isNull_function_value ); } { //::SireMol::MolResNum::map typedef ::QList< SireMol::ResIdx > ( ::SireMol::MolResNum::*map_function_type )( ::SireMol::MolInfo const & ) const; map_function_type map_function_value( &::SireMol::MolResNum::map ); MolResNum_exposer.def( "map" , map_function_value , ( bp::arg("molinfo") ) ); } { //::SireMol::MolResNum::molNum typedef ::SireMol::MolNum const & ( ::SireMol::MolResNum::*molNum_function_type )( ) const; molNum_function_type molNum_function_value( &::SireMol::MolResNum::molNum ); MolResNum_exposer.def( "molNum" , molNum_function_value , bp::return_value_policy<bp::clone_const_reference>() ); } MolResNum_exposer.def( bp::self != bp::self ); { //::SireMol::MolResNum::operator= typedef ::SireMol::MolResNum & ( ::SireMol::MolResNum::*assign_function_type )( ::SireMol::MolResNum const & ) ; assign_function_type assign_function_value( &::SireMol::MolResNum::operator= ); MolResNum_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() ); } MolResNum_exposer.def( bp::self == bp::other< SireID::ID >() ); MolResNum_exposer.def( bp::self == bp::self ); { //::SireMol::MolResNum::resNum typedef ::SireMol::ResNum const & ( ::SireMol::MolResNum::*resNum_function_type )( ) const; resNum_function_type resNum_function_value( &::SireMol::MolResNum::resNum ); MolResNum_exposer.def( "resNum" , resNum_function_value , bp::return_value_policy<bp::clone_const_reference>() ); } { //::SireMol::MolResNum::selectAllFrom typedef ::QHash< SireMol::MolNum, SireMol::Selector< SireMol::Residue > > ( ::SireMol::MolResNum::*selectAllFrom_function_type )( ::SireMol::Molecules const &,::SireBase::PropertyMap const & ) const; selectAllFrom_function_type selectAllFrom_function_value( &::SireMol::MolResNum::selectAllFrom ); MolResNum_exposer.def( "selectAllFrom" , selectAllFrom_function_value , ( bp::arg("molecules"), bp::arg("map")=SireBase::PropertyMap() ) ); } { //::SireMol::MolResNum::selectAllFrom typedef ::QHash< SireMol::MolNum, SireMol::Selector< SireMol::Residue > > ( ::SireMol::MolResNum::*selectAllFrom_function_type )( ::SireMol::MoleculeGroup const &,::SireBase::PropertyMap const & ) const; selectAllFrom_function_type selectAllFrom_function_value( &::SireMol::MolResNum::selectAllFrom ); MolResNum_exposer.def( "selectAllFrom" , selectAllFrom_function_value , ( bp::arg("molgroup"), bp::arg("map")=SireBase::PropertyMap() ) ); } { //::SireMol::MolResNum::selectAllFrom typedef ::QHash< SireMol::MolNum, SireMol::Selector< SireMol::Residue > > ( ::SireMol::MolResNum::*selectAllFrom_function_type )( ::SireMol::MolGroupsBase const &,::SireBase::PropertyMap const & ) const; selectAllFrom_function_type selectAllFrom_function_value( &::SireMol::MolResNum::selectAllFrom ); MolResNum_exposer.def( "selectAllFrom" , selectAllFrom_function_value , ( bp::arg("molgroups"), bp::arg("map")=SireBase::PropertyMap() ) ); } { //::SireMol::MolResNum::toString typedef ::QString ( ::SireMol::MolResNum::*toString_function_type )( ) const; toString_function_type toString_function_value( &::SireMol::MolResNum::toString ); MolResNum_exposer.def( "toString" , toString_function_value ); } { //::SireMol::MolResNum::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireMol::MolResNum::typeName ); MolResNum_exposer.def( "typeName" , typeName_function_value ); } { //::SireMol::MolResNum::what typedef char const * ( ::SireMol::MolResNum::*what_function_type )( ) const; what_function_type what_function_value( &::SireMol::MolResNum::what ); MolResNum_exposer.def( "what" , what_function_value ); } MolResNum_exposer.staticmethod( "typeName" ); MolResNum_exposer.def( "__copy__", &__copy__); MolResNum_exposer.def( "__deepcopy__", &__copy__); MolResNum_exposer.def( "clone", &__copy__); MolResNum_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::MolResNum >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); MolResNum_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::MolResNum >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); MolResNum_exposer.def( "__str__", &__str__< ::SireMol::MolResNum > ); MolResNum_exposer.def( "__repr__", &__str__< ::SireMol::MolResNum > ); } }
void register_AngleComponent_class(){ { //::SireSystem::AngleComponent typedef bp::class_< SireSystem::AngleComponent, bp::bases< SireSystem::GeometryComponent, SireSystem::Constraint, SireBase::Property > > AngleComponent_exposer_t; AngleComponent_exposer_t AngleComponent_exposer = AngleComponent_exposer_t( "AngleComponent", "This is a constraint that constrains a symbol to equal the\nvalue of an expression that involves an angle between three points\nor atoms\n\nAuthor: Christopher Woods\n", bp::init< >("Null constructor") ); bp::scope AngleComponent_scope( AngleComponent_exposer ); AngleComponent_exposer.def( bp::init< SireCAS::Symbol const &, SireFF::PointRef const &, SireFF::PointRef const &, SireFF::PointRef const &, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("constrained_symbol"), bp::arg("point0"), bp::arg("point1"), bp::arg("point2"), bp::arg("map")=SireBase::PropertyMap() ), "Construct to set the value of constrained_symbol equal to the\nangle between the three points point0, point1 and point2") ); AngleComponent_exposer.def( bp::init< SireCAS::Symbol const &, SireFF::PointRef const &, SireFF::PointRef const &, SireFF::PointRef const &, SireCAS::Expression const &, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("constrained_symbol"), bp::arg("point0"), bp::arg("point1"), bp::arg("point2"), bp::arg("geometry_expression"), bp::arg("map")=SireBase::PropertyMap() ), "Construct to set the value of constrained_symbol equal to the\nexpression based on the angles within the three points\npoint0, point1 and point2") ); AngleComponent_exposer.def( bp::init< SireSystem::AngleComponent const & >(( bp::arg("other") ), "Copy constructor") ); { //::SireSystem::AngleComponent::nPoints typedef int ( ::SireSystem::AngleComponent::*nPoints_function_type)( ) const; nPoints_function_type nPoints_function_value( &::SireSystem::AngleComponent::nPoints ); AngleComponent_exposer.def( "nPoints" , nPoints_function_value , "Return the number of points (3)" ); } AngleComponent_exposer.def( bp::self != bp::self ); { //::SireSystem::AngleComponent::operator= typedef ::SireSystem::AngleComponent & ( ::SireSystem::AngleComponent::*assign_function_type)( ::SireSystem::AngleComponent const & ) ; assign_function_type assign_function_value( &::SireSystem::AngleComponent::operator= ); AngleComponent_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() , "" ); } AngleComponent_exposer.def( bp::self == bp::self ); { //::SireSystem::AngleComponent::point typedef ::SireFF::Point const & ( ::SireSystem::AngleComponent::*point_function_type)( int ) const; point_function_type point_function_value( &::SireSystem::AngleComponent::point ); AngleComponent_exposer.def( "point" , point_function_value , ( bp::arg("i") ) , bp::return_value_policy<bp::clone_const_reference>() , "Return the ith point\nThrow: SireError::invalid_index\n" ); } { //::SireSystem::AngleComponent::point0 typedef ::SireFF::Point const & ( ::SireSystem::AngleComponent::*point0_function_type)( ) const; point0_function_type point0_function_value( &::SireSystem::AngleComponent::point0 ); AngleComponent_exposer.def( "point0" , point0_function_value , bp::return_value_policy<bp::clone_const_reference>() , "Return the first point between which the angle is calculated" ); } { //::SireSystem::AngleComponent::point1 typedef ::SireFF::Point const & ( ::SireSystem::AngleComponent::*point1_function_type)( ) const; point1_function_type point1_function_value( &::SireSystem::AngleComponent::point1 ); AngleComponent_exposer.def( "point1" , point1_function_value , bp::return_value_policy<bp::clone_const_reference>() , "Return the second point between which the angle is calculated" ); } { //::SireSystem::AngleComponent::point2 typedef ::SireFF::Point const & ( ::SireSystem::AngleComponent::*point2_function_type)( ) const; point2_function_type point2_function_value( &::SireSystem::AngleComponent::point2 ); AngleComponent_exposer.def( "point2" , point2_function_value , bp::return_value_policy<bp::clone_const_reference>() , "Return the third point between which the angle is calculated" ); } { //::SireSystem::AngleComponent::r01 typedef ::SireCAS::Symbol const & ( *r01_function_type )( ); r01_function_type r01_function_value( &::SireSystem::AngleComponent::r01 ); AngleComponent_exposer.def( "r01" , r01_function_value , bp::return_value_policy<bp::clone_const_reference>() , "Return the symbol that represents the 0-1 distance" ); } { //::SireSystem::AngleComponent::r02 typedef ::SireCAS::Symbol const & ( *r02_function_type )( ); r02_function_type r02_function_value( &::SireSystem::AngleComponent::r02 ); AngleComponent_exposer.def( "r02" , r02_function_value , bp::return_value_policy<bp::clone_const_reference>() , "Return the symbol that represents the 0-2 distance" ); } { //::SireSystem::AngleComponent::r12 typedef ::SireCAS::Symbol const & ( *r12_function_type )( ); r12_function_type r12_function_value( &::SireSystem::AngleComponent::r12 ); AngleComponent_exposer.def( "r12" , r12_function_value , bp::return_value_policy<bp::clone_const_reference>() , "Return the symbol that represents the 1-2 distance" ); } { //::SireSystem::AngleComponent::theta typedef ::SireCAS::Symbol const & ( *theta_function_type )( ); theta_function_type theta_function_value( &::SireSystem::AngleComponent::theta ); AngleComponent_exposer.def( "theta" , theta_function_value , bp::return_value_policy<bp::clone_const_reference>() , "Return the symbol that represents the central angle between\nthe three points" ); } { //::SireSystem::AngleComponent::theta012 typedef ::SireCAS::Symbol const & ( *theta012_function_type )( ); theta012_function_type theta012_function_value( &::SireSystem::AngleComponent::theta012 ); AngleComponent_exposer.def( "theta012" , theta012_function_value , bp::return_value_policy<bp::clone_const_reference>() , "Return the symbol that represents the angle 012 between\nthe three points" ); } { //::SireSystem::AngleComponent::theta021 typedef ::SireCAS::Symbol const & ( *theta021_function_type )( ); theta021_function_type theta021_function_value( &::SireSystem::AngleComponent::theta021 ); AngleComponent_exposer.def( "theta021" , theta021_function_value , bp::return_value_policy<bp::clone_const_reference>() , "Return the symbol that represents the angle 021 between\nthe three points" ); } { //::SireSystem::AngleComponent::theta102 typedef ::SireCAS::Symbol const & ( *theta102_function_type )( ); theta102_function_type theta102_function_value( &::SireSystem::AngleComponent::theta102 ); AngleComponent_exposer.def( "theta102" , theta102_function_value , bp::return_value_policy<bp::clone_const_reference>() , "Return the symbol that represents the angle 102 between\nthe three points" ); } { //::SireSystem::AngleComponent::toString typedef ::QString ( ::SireSystem::AngleComponent::*toString_function_type)( ) const; toString_function_type toString_function_value( &::SireSystem::AngleComponent::toString ); AngleComponent_exposer.def( "toString" , toString_function_value , "" ); } { //::SireSystem::AngleComponent::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireSystem::AngleComponent::typeName ); AngleComponent_exposer.def( "typeName" , typeName_function_value , "" ); } AngleComponent_exposer.staticmethod( "r01" ); AngleComponent_exposer.staticmethod( "r02" ); AngleComponent_exposer.staticmethod( "r12" ); AngleComponent_exposer.staticmethod( "theta" ); AngleComponent_exposer.staticmethod( "theta012" ); AngleComponent_exposer.staticmethod( "theta021" ); AngleComponent_exposer.staticmethod( "theta102" ); 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< ::SireSystem::AngleComponent >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); AngleComponent_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireSystem::AngleComponent >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); AngleComponent_exposer.def( "__str__", &__str__< ::SireSystem::AngleComponent > ); AngleComponent_exposer.def( "__repr__", &__str__< ::SireSystem::AngleComponent > ); } }
void register_IDAssigner_class(){ { //::SireSystem::IDAssigner typedef bp::class_< SireSystem::IDAssigner, bp::bases< SireBase::Property > > IDAssigner_exposer_t; IDAssigner_exposer_t IDAssigner_exposer = IDAssigner_exposer_t( "IDAssigner", "This class uses the machinery of the identity point to\npick out molecules that are associated with identity points.\nThis is useful if you want to monitor a property or energy,\nbut dont actually want to change the coordinates of atoms\n\nAuthor: Christopher Woods\n", bp::init< >("Constructor") ); bp::scope IDAssigner_scope( IDAssigner_exposer ); IDAssigner_exposer.def( bp::init< SireFF::PointRef const &, SireMol::MoleculeGroup const &, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("point"), bp::arg("molgroup"), bp::arg("map")=SireBase::PropertyMap() ), "Constructor") ); IDAssigner_exposer.def( bp::init< QVector< SireBase::PropPtr< SireFF::Point > > const &, SireMol::MoleculeGroup const &, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("points"), bp::arg("molgroup"), bp::arg("map")=SireBase::PropertyMap() ), "Construct to find the identity of the molecules from\nmolgroup that match the points in points -\nthis creates a list of n molecules, where the ith molecule\nis matched to the ith point") ); IDAssigner_exposer.def( bp::init< SireFF::PointRef const &, SireMol::MoleculeGroup const &, SireVol::Space const &, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("point"), bp::arg("molgroup"), bp::arg("space"), bp::arg("map")=SireBase::PropertyMap() ), "Constructor") ); IDAssigner_exposer.def( bp::init< QVector< SireBase::PropPtr< SireFF::Point > > const &, SireMol::MoleculeGroup const &, SireVol::Space const &, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("points"), bp::arg("molgroup"), bp::arg("space"), bp::arg("map")=SireBase::PropertyMap() ), "Construct to find the identity of the molecules from\nmolgroup that match the points in points -\nthis creates a list of n molecules, where the ith molecule\nis matched to the ith point") ); IDAssigner_exposer.def( bp::init< SireSystem::IDAssigner const & >(( bp::arg("other") ), "Copy constructor") ); { //::SireSystem::IDAssigner::identifiedMolecules typedef ::QVector< SireMol::PartialMolecule > ( ::SireSystem::IDAssigner::*identifiedMolecules_function_type)( ) const; identifiedMolecules_function_type identifiedMolecules_function_value( &::SireSystem::IDAssigner::identifiedMolecules ); IDAssigner_exposer.def( "identifiedMolecules" , identifiedMolecules_function_value , "Returns the list of identified molecules from the system,\nwhich are returned in the same order as the list of identity points\n" ); } { //::SireSystem::IDAssigner::moleculeGroup typedef ::SireMol::MoleculeGroup const & ( ::SireSystem::IDAssigner::*moleculeGroup_function_type)( ) const; moleculeGroup_function_type moleculeGroup_function_value( &::SireSystem::IDAssigner::moleculeGroup ); IDAssigner_exposer.def( "moleculeGroup" , moleculeGroup_function_value , bp::return_value_policy<bp::clone_const_reference>() , "Return the molecule group operated on by this constraint" ); } { //::SireSystem::IDAssigner::nPoints typedef int ( ::SireSystem::IDAssigner::*nPoints_function_type)( ) const; nPoints_function_type nPoints_function_value( &::SireSystem::IDAssigner::nPoints ); IDAssigner_exposer.def( "nPoints" , nPoints_function_value , "Return the number of identity points (and thus the number of\nidentified molecules)" ); } IDAssigner_exposer.def( bp::self != bp::self ); { //::SireSystem::IDAssigner::operator= typedef ::SireSystem::IDAssigner & ( ::SireSystem::IDAssigner::*assign_function_type)( ::SireSystem::IDAssigner const & ) ; assign_function_type assign_function_value( &::SireSystem::IDAssigner::operator= ); IDAssigner_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() , "" ); } IDAssigner_exposer.def( bp::self == bp::self ); { //::SireSystem::IDAssigner::points typedef ::QVector< SireBase::PropPtr< SireFF::Point > > ( ::SireSystem::IDAssigner::*points_function_type)( ) const; points_function_type points_function_value( &::SireSystem::IDAssigner::points ); IDAssigner_exposer.def( "points" , points_function_value , "Return the points used to identify the molecules" ); } { //::SireSystem::IDAssigner::propertyMap typedef ::SireBase::PropertyMap const & ( ::SireSystem::IDAssigner::*propertyMap_function_type)( ) const; propertyMap_function_type propertyMap_function_value( &::SireSystem::IDAssigner::propertyMap ); IDAssigner_exposer.def( "propertyMap" , propertyMap_function_value , bp::return_value_policy< bp::copy_const_reference >() , "Return the property map used to find the properties required\nby this constraint" ); } { //::SireSystem::IDAssigner::space typedef ::SireVol::Space const & ( ::SireSystem::IDAssigner::*space_function_type)( ) const; space_function_type space_function_value( &::SireSystem::IDAssigner::space ); IDAssigner_exposer.def( "space" , space_function_value , bp::return_value_policy<bp::clone_const_reference>() , "Return the space used to calculate distances between the molecules\nand the identity points" ); } { //::SireSystem::IDAssigner::toString typedef ::QString ( ::SireSystem::IDAssigner::*toString_function_type)( ) const; toString_function_type toString_function_value( &::SireSystem::IDAssigner::toString ); IDAssigner_exposer.def( "toString" , toString_function_value , "Return a string representation of this assigner" ); } { //::SireSystem::IDAssigner::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireSystem::IDAssigner::typeName ); IDAssigner_exposer.def( "typeName" , typeName_function_value , "" ); } { //::SireSystem::IDAssigner::update typedef void ( ::SireSystem::IDAssigner::*update_function_type)( ::SireSystem::System const & ) ; update_function_type update_function_value( &::SireSystem::IDAssigner::update ); IDAssigner_exposer.def( "update" , update_function_value , ( bp::arg("system") ) , "Update the assigner with the passed system." ); } { //::SireSystem::IDAssigner::what typedef char const * ( ::SireSystem::IDAssigner::*what_function_type)( ) const; what_function_type what_function_value( &::SireSystem::IDAssigner::what ); IDAssigner_exposer.def( "what" , what_function_value , "" ); } IDAssigner_exposer.staticmethod( "typeName" ); IDAssigner_exposer.def( "__copy__", &__copy__); IDAssigner_exposer.def( "__deepcopy__", &__copy__); IDAssigner_exposer.def( "clone", &__copy__); IDAssigner_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireSystem::IDAssigner >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); IDAssigner_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireSystem::IDAssigner >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); IDAssigner_exposer.def( "__str__", &__str__< ::SireSystem::IDAssigner > ); IDAssigner_exposer.def( "__repr__", &__str__< ::SireSystem::IDAssigner > ); } }
void register_QDate_class(){ { //::QDate typedef bp::class_< QDate > QDate_exposer_t; QDate_exposer_t QDate_exposer = QDate_exposer_t( "QDate", bp::init< >() ); bp::scope QDate_scope( QDate_exposer ); QDate_exposer.def( bp::init< int, int, int >(( bp::arg("y"), bp::arg("m"), bp::arg("d") )) ); { //::QDate::addDays typedef ::QDate ( ::QDate::*addDays_function_type )( qint64 ) const; addDays_function_type addDays_function_value( &::QDate::addDays ); QDate_exposer.def( "addDays" , addDays_function_value , ( bp::arg("days") ) ); } { //::QDate::addMonths typedef ::QDate ( ::QDate::*addMonths_function_type )( int ) const; addMonths_function_type addMonths_function_value( &::QDate::addMonths ); QDate_exposer.def( "addMonths" , addMonths_function_value , ( bp::arg("months") ) ); } { //::QDate::addYears typedef ::QDate ( ::QDate::*addYears_function_type )( int ) const; addYears_function_type addYears_function_value( &::QDate::addYears ); QDate_exposer.def( "addYears" , addYears_function_value , ( bp::arg("years") ) ); } { //::QDate::currentDate typedef ::QDate ( *currentDate_function_type )( ); currentDate_function_type currentDate_function_value( &::QDate::currentDate ); QDate_exposer.def( "currentDate" , currentDate_function_value ); } { //::QDate::day typedef int ( ::QDate::*day_function_type )( ) const; day_function_type day_function_value( &::QDate::day ); QDate_exposer.def( "day" , day_function_value ); } { //::QDate::dayOfWeek typedef int ( ::QDate::*dayOfWeek_function_type )( ) const; dayOfWeek_function_type dayOfWeek_function_value( &::QDate::dayOfWeek ); QDate_exposer.def( "dayOfWeek" , dayOfWeek_function_value ); } { //::QDate::dayOfYear typedef int ( ::QDate::*dayOfYear_function_type )( ) const; dayOfYear_function_type dayOfYear_function_value( &::QDate::dayOfYear ); QDate_exposer.def( "dayOfYear" , dayOfYear_function_value ); } { //::QDate::daysInMonth typedef int ( ::QDate::*daysInMonth_function_type )( ) const; daysInMonth_function_type daysInMonth_function_value( &::QDate::daysInMonth ); QDate_exposer.def( "daysInMonth" , daysInMonth_function_value ); } { //::QDate::daysInYear typedef int ( ::QDate::*daysInYear_function_type )( ) const; daysInYear_function_type daysInYear_function_value( &::QDate::daysInYear ); QDate_exposer.def( "daysInYear" , daysInYear_function_value ); } { //::QDate::daysTo typedef qint64 ( ::QDate::*daysTo_function_type )( ::QDate const & ) const; daysTo_function_type daysTo_function_value( &::QDate::daysTo ); QDate_exposer.def( "daysTo" , daysTo_function_value , ( bp::arg("arg0") ) ); } { //::QDate::fromJulianDay typedef ::QDate ( *fromJulianDay_function_type )( qint64 ); fromJulianDay_function_type fromJulianDay_function_value( &::QDate::fromJulianDay ); QDate_exposer.def( "fromJulianDay" , fromJulianDay_function_value , ( bp::arg("jd") ) ); } { //::QDate::fromString typedef ::QDate ( *fromString_function_type )( ::QString const &,::QString const & ); fromString_function_type fromString_function_value( &::QDate::fromString ); QDate_exposer.def( "fromString" , fromString_function_value , ( bp::arg("s"), bp::arg("format") ) ); } { //::QDate::isLeapYear typedef bool ( *isLeapYear_function_type )( int ); isLeapYear_function_type isLeapYear_function_value( &::QDate::isLeapYear ); QDate_exposer.def( "isLeapYear" , isLeapYear_function_value , ( bp::arg("year") ) ); } { //::QDate::isNull typedef bool ( ::QDate::*isNull_function_type )( ) const; isNull_function_type isNull_function_value( &::QDate::isNull ); QDate_exposer.def( "isNull" , isNull_function_value ); } { //::QDate::isValid typedef bool ( ::QDate::*isValid_function_type )( ) const; isValid_function_type isValid_function_value( &::QDate::isValid ); QDate_exposer.def( "isValid" , isValid_function_value ); } { //::QDate::isValid typedef bool ( *isValid_function_type )( int,int,int ); isValid_function_type isValid_function_value( &::QDate::isValid ); QDate_exposer.def( "isValid" , isValid_function_value , ( bp::arg("y"), bp::arg("m"), bp::arg("d") ) ); } { //::QDate::longDayName typedef ::QString ( *longDayName_function_type )( int, QDate::MonthNameType ); longDayName_function_type longDayName_function_value( &::QDate::longDayName ); QDate_exposer.def( "longDayName" , longDayName_function_value , ( bp::arg("weekday") ) ); } { //::QDate::longMonthName typedef ::QString ( *longMonthName_function_type )( int, QDate::MonthNameType ); longMonthName_function_type longMonthName_function_value( &::QDate::longMonthName ); QDate_exposer.def( "longMonthName" , longMonthName_function_value , ( bp::arg("month") ) ); } { //::QDate::month typedef int ( ::QDate::*month_function_type )( ) const; month_function_type month_function_value( &::QDate::month ); QDate_exposer.def( "month" , month_function_value ); } QDate_exposer.def( bp::self != bp::self ); QDate_exposer.def( bp::self < bp::self ); QDate_exposer.def( bp::self <= bp::self ); QDate_exposer.def( bp::self == bp::self ); QDate_exposer.def( bp::self > bp::self ); QDate_exposer.def( bp::self >= bp::self ); { //::QDate::setDate typedef bool ( ::QDate::*setDate_function_type )( int,int,int ) ; setDate_function_type setDate_function_value( &::QDate::setDate ); QDate_exposer.def( "setDate" , setDate_function_value , ( bp::arg("year"), bp::arg("month"), bp::arg("date") ) ); } { //::QDate::shortDayName typedef ::QString ( *shortDayName_function_type )( int, QDate::MonthNameType ); shortDayName_function_type shortDayName_function_value( &::QDate::shortDayName ); QDate_exposer.def( "shortDayName" , shortDayName_function_value , ( bp::arg("weekday") ) ); } { //::QDate::shortMonthName typedef ::QString ( *shortMonthName_function_type )( int, QDate::MonthNameType ); shortMonthName_function_type shortMonthName_function_value( &::QDate::shortMonthName ); QDate_exposer.def( "shortMonthName" , shortMonthName_function_value , ( bp::arg("month") ) ); } { //::QDate::toJulianDay typedef qint64 ( ::QDate::*toJulianDay_function_type )( ) const; toJulianDay_function_type toJulianDay_function_value( &::QDate::toJulianDay ); QDate_exposer.def( "toJulianDay" , toJulianDay_function_value ); } { //::QDate::toString typedef ::QString ( ::QDate::*toString_function_type )( ::QString const & ) const; toString_function_type toString_function_value( &::QDate::toString ); QDate_exposer.def( "toString" , toString_function_value , ( bp::arg("format") ) ); } { //::QDate::weekNumber typedef int ( ::QDate::*weekNumber_function_type )( int * ) const; weekNumber_function_type weekNumber_function_value( &::QDate::weekNumber ); QDate_exposer.def( "weekNumber" , weekNumber_function_value , ( bp::arg("yearNum")=bp::object() ) ); } { //::QDate::year typedef int ( ::QDate::*year_function_type )( ) const; year_function_type year_function_value( &::QDate::year ); QDate_exposer.def( "year" , year_function_value ); } QDate_exposer.staticmethod( "currentDate" ); QDate_exposer.staticmethod( "fromJulianDay" ); QDate_exposer.staticmethod( "fromString" ); QDate_exposer.staticmethod( "isLeapYear" ); QDate_exposer.staticmethod( "isValid" ); QDate_exposer.staticmethod( "longDayName" ); QDate_exposer.staticmethod( "longMonthName" ); QDate_exposer.staticmethod( "shortDayName" ); QDate_exposer.staticmethod( "shortMonthName" ); QDate_exposer.def( "__copy__", &__copy__); QDate_exposer.def( "__deepcopy__", &__copy__); QDate_exposer.def( "clone", &__copy__); QDate_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::QDate >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); QDate_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::QDate >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); } }
void register_Velocity3D_class(){ { //::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > typedef bp::class_< SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > > Velocity3D_exposer_t; Velocity3D_exposer_t Velocity3D_exposer = Velocity3D_exposer_t( "Velocity3D", bp::init< >() ); bp::scope Velocity3D_scope( Velocity3D_exposer ); Velocity3D_exposer.def( bp::init< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > const & >(( bp::arg("val") )) ); Velocity3D_exposer.def( bp::init< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > const &, SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > const &, SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > const & >(( bp::arg("x"), bp::arg("y"), bp::arg("z") )) ); Velocity3D_exposer.def( bp::init< SireMaths::Vector const & >(( bp::arg("v") )) ); Velocity3D_exposer.def( bp::init< SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > const & >(( bp::arg("other") )) ); { //::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::at typedef SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > exported_class_t; typedef ::SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > const & ( ::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::*at_function_type )( int ) const; at_function_type at_function_value( &::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::at ); Velocity3D_exposer.def( "at" , at_function_value , ( bp::arg("i") ) , bp::return_value_policy< bp::copy_const_reference >() ); } { //::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::count typedef SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > exported_class_t; typedef int ( ::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::*count_function_type )( ) const; count_function_type count_function_value( &::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::count ); Velocity3D_exposer.def( "count" , count_function_value ); } Velocity3D_exposer.def( bp::self != bp::self ); Velocity3D_exposer.def( bp::self * bp::other< double >() ); Velocity3D_exposer.def( bp::self + bp::self ); Velocity3D_exposer.def( -bp::self ); Velocity3D_exposer.def( bp::self - bp::self ); Velocity3D_exposer.def( bp::self / bp::other< double >() ); { //::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::operator= typedef SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > exported_class_t; typedef ::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > & ( ::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::*assign_function_type )( ::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > const & ) ; assign_function_type assign_function_value( &::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::operator= ); Velocity3D_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() ); } Velocity3D_exposer.def( bp::self == bp::self ); { //::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::operator[] typedef SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > exported_class_t; typedef ::SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > const & ( ::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::*__getitem___function_type )( int ) const; __getitem___function_type __getitem___function_value( &::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::operator[] ); Velocity3D_exposer.def( "__getitem__" , __getitem___function_value , ( bp::arg("i") ) , bp::return_value_policy< bp::copy_const_reference >() ); } { //::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::set typedef SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > exported_class_t; typedef void ( ::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::*set_function_type )( int,::SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > const & ) ; set_function_type set_function_value( &::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::set ); Velocity3D_exposer.def( "set" , set_function_value , ( bp::arg("i"), bp::arg("value") ) ); } { //::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::toString typedef SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > exported_class_t; typedef ::QString ( ::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::*toString_function_type )( ) const; toString_function_type toString_function_value( &::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::toString ); Velocity3D_exposer.def( "toString" , toString_function_value ); } { //::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::typeName typedef SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > exported_class_t; typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::typeName ); Velocity3D_exposer.def( "typeName" , typeName_function_value ); } { //::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::value typedef SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > exported_class_t; typedef ::SireMaths::Vector ( ::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::*value_function_type )( ) const; value_function_type value_function_value( &::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::value ); Velocity3D_exposer.def( "value" , value_function_value ); } { //::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::x typedef SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > exported_class_t; typedef ::SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > const & ( ::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::*x_function_type )( ) const; x_function_type x_function_value( &::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::x ); Velocity3D_exposer.def( "x" , x_function_value , bp::return_value_policy< bp::copy_const_reference >() ); } { //::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::y typedef SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > exported_class_t; typedef ::SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > const & ( ::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::*y_function_type )( ) const; y_function_type y_function_value( &::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::y ); Velocity3D_exposer.def( "y" , y_function_value , bp::return_value_policy< bp::copy_const_reference >() ); } { //::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::z typedef SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > exported_class_t; typedef ::SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > const & ( ::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::*z_function_type )( ) const; z_function_type z_function_value( &::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::z ); Velocity3D_exposer.def( "z" , z_function_value , bp::return_value_policy< bp::copy_const_reference >() ); } Velocity3D_exposer.staticmethod( "typeName" ); Velocity3D_exposer.def( "__copy__", &__copy__); Velocity3D_exposer.def( "__deepcopy__", &__copy__); Velocity3D_exposer.def( "clone", &__copy__); Velocity3D_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMaths::Vector3D<SireUnits::Dimension::PhysUnit<0, 1, -1, 0, 0, 0, 0> > >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); Velocity3D_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMaths::Vector3D<SireUnits::Dimension::PhysUnit<0, 1, -1, 0, 0, 0, 0> > >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); Velocity3D_exposer.def( "__str__", &__str__< ::SireMaths::Vector3D<SireUnits::Dimension::PhysUnit<0, 1, -1, 0, 0, 0, 0> > > ); Velocity3D_exposer.def( "__repr__", &__str__< ::SireMaths::Vector3D<SireUnits::Dimension::PhysUnit<0, 1, -1, 0, 0, 0, 0> > > ); Velocity3D_exposer.def( "__len__", &__len_count< ::SireMaths::Vector3D<SireUnits::Dimension::PhysUnit<0, 1, -1, 0, 0, 0, 0> > > ); } }
void register_TripleDistanceComponent_class() { { //::SireSystem::TripleDistanceComponent typedef bp::class_< SireSystem::TripleDistanceComponent, bp::bases< SireSystem::GeometryComponent, SireSystem::Constraint, SireBase::Property > > TripleDistanceComponent_exposer_t; TripleDistanceComponent_exposer_t TripleDistanceComponent_exposer = TripleDistanceComponent_exposer_t( "TripleDistanceComponent", bp::init< >() ); bp::scope TripleDistanceComponent_scope( TripleDistanceComponent_exposer ); TripleDistanceComponent_exposer.def( bp::init< SireCAS::Symbol const &, SireFF::PointRef const &, SireFF::PointRef const &, SireFF::PointRef const &, SireFF::PointRef const &, SireFF::PointRef const &, SireFF::PointRef const &, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("constrained_symbol"), bp::arg("point0"), bp::arg("point1"), bp::arg("point2"), bp::arg("point3"), bp::arg("point4"), bp::arg("point5"), bp::arg("map")=SireBase::PropertyMap() )) ); TripleDistanceComponent_exposer.def( bp::init< SireCAS::Symbol const &, SireFF::PointRef const &, SireFF::PointRef const &, SireFF::PointRef const &, SireFF::PointRef const &, SireFF::PointRef const &, SireFF::PointRef const &, SireCAS::Expression const &, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("constrained_symbol"), bp::arg("point0"), bp::arg("point1"), bp::arg("point2"), bp::arg("point3"), bp::arg("point4"), bp::arg("point5"), bp::arg("geometry_expression"), bp::arg("map")=SireBase::PropertyMap() )) ); TripleDistanceComponent_exposer.def( bp::init< SireSystem::TripleDistanceComponent const & >(( bp::arg("other") )) ); { //::SireSystem::TripleDistanceComponent::nPoints typedef int ( ::SireSystem::TripleDistanceComponent::*nPoints_function_type )( ) const; nPoints_function_type nPoints_function_value( &::SireSystem::TripleDistanceComponent::nPoints ); TripleDistanceComponent_exposer.def( "nPoints" , nPoints_function_value ); } TripleDistanceComponent_exposer.def( bp::self != bp::self ); { //::SireSystem::TripleDistanceComponent::operator= typedef ::SireSystem::TripleDistanceComponent & ( ::SireSystem::TripleDistanceComponent::*assign_function_type )( ::SireSystem::TripleDistanceComponent const & ) ; assign_function_type assign_function_value( &::SireSystem::TripleDistanceComponent::operator= ); TripleDistanceComponent_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() ); } TripleDistanceComponent_exposer.def( bp::self == bp::self ); { //::SireSystem::TripleDistanceComponent::point typedef ::SireFF::Point const & ( ::SireSystem::TripleDistanceComponent::*point_function_type )( int ) const; point_function_type point_function_value( &::SireSystem::TripleDistanceComponent::point ); TripleDistanceComponent_exposer.def( "point" , point_function_value , ( bp::arg("i") ) , bp::return_value_policy<bp::clone_const_reference>() ); } { //::SireSystem::TripleDistanceComponent::point0 typedef ::SireFF::Point const & ( ::SireSystem::TripleDistanceComponent::*point0_function_type )( ) const; point0_function_type point0_function_value( &::SireSystem::TripleDistanceComponent::point0 ); TripleDistanceComponent_exposer.def( "point0" , point0_function_value , bp::return_value_policy<bp::clone_const_reference>() ); } { //::SireSystem::TripleDistanceComponent::point1 typedef ::SireFF::Point const & ( ::SireSystem::TripleDistanceComponent::*point1_function_type )( ) const; point1_function_type point1_function_value( &::SireSystem::TripleDistanceComponent::point1 ); TripleDistanceComponent_exposer.def( "point1" , point1_function_value , bp::return_value_policy<bp::clone_const_reference>() ); } { //::SireSystem::TripleDistanceComponent::point2 typedef ::SireFF::Point const & ( ::SireSystem::TripleDistanceComponent::*point2_function_type )( ) const; point2_function_type point2_function_value( &::SireSystem::TripleDistanceComponent::point2 ); TripleDistanceComponent_exposer.def( "point2" , point2_function_value , bp::return_value_policy<bp::clone_const_reference>() ); } { //::SireSystem::TripleDistanceComponent::point3 typedef ::SireFF::Point const & ( ::SireSystem::TripleDistanceComponent::*point3_function_type )( ) const; point3_function_type point3_function_value( &::SireSystem::TripleDistanceComponent::point3 ); TripleDistanceComponent_exposer.def( "point3" , point3_function_value , bp::return_value_policy<bp::clone_const_reference>() ); } { //::SireSystem::TripleDistanceComponent::point4 typedef ::SireFF::Point const & ( ::SireSystem::TripleDistanceComponent::*point4_function_type )( ) const; point4_function_type point4_function_value( &::SireSystem::TripleDistanceComponent::point4 ); TripleDistanceComponent_exposer.def( "point4" , point4_function_value , bp::return_value_policy<bp::clone_const_reference>() ); } { //::SireSystem::TripleDistanceComponent::point5 typedef ::SireFF::Point const & ( ::SireSystem::TripleDistanceComponent::*point5_function_type )( ) const; point5_function_type point5_function_value( &::SireSystem::TripleDistanceComponent::point5 ); TripleDistanceComponent_exposer.def( "point5" , point5_function_value , bp::return_value_policy<bp::clone_const_reference>() ); } { //::SireSystem::TripleDistanceComponent::r01 typedef ::SireCAS::Symbol const & ( *r01_function_type )( ); r01_function_type r01_function_value( &::SireSystem::TripleDistanceComponent::r01 ); TripleDistanceComponent_exposer.def( "r01" , r01_function_value , bp::return_value_policy<bp::clone_const_reference>() ); } { //::SireSystem::TripleDistanceComponent::r23 typedef ::SireCAS::Symbol const & ( *r23_function_type )( ); r23_function_type r23_function_value( &::SireSystem::TripleDistanceComponent::r23 ); TripleDistanceComponent_exposer.def( "r23" , r23_function_value , bp::return_value_policy<bp::clone_const_reference>() ); } { //::SireSystem::TripleDistanceComponent::r45 typedef ::SireCAS::Symbol const & ( *r45_function_type )( ); r45_function_type r45_function_value( &::SireSystem::TripleDistanceComponent::r45 ); TripleDistanceComponent_exposer.def( "r45" , r45_function_value , bp::return_value_policy<bp::clone_const_reference>() ); } { //::SireSystem::TripleDistanceComponent::toString typedef ::QString ( ::SireSystem::TripleDistanceComponent::*toString_function_type )( ) const; toString_function_type toString_function_value( &::SireSystem::TripleDistanceComponent::toString ); TripleDistanceComponent_exposer.def( "toString" , toString_function_value ); } { //::SireSystem::TripleDistanceComponent::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireSystem::TripleDistanceComponent::typeName ); TripleDistanceComponent_exposer.def( "typeName" , typeName_function_value ); } TripleDistanceComponent_exposer.staticmethod( "r01" ); TripleDistanceComponent_exposer.staticmethod( "r23" ); TripleDistanceComponent_exposer.staticmethod( "r45" ); TripleDistanceComponent_exposer.staticmethod( "typeName" ); TripleDistanceComponent_exposer.def( "__copy__", &__copy__); TripleDistanceComponent_exposer.def( "__deepcopy__", &__copy__); TripleDistanceComponent_exposer.def( "clone", &__copy__); TripleDistanceComponent_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireSystem::TripleDistanceComponent >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); TripleDistanceComponent_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireSystem::TripleDistanceComponent >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); TripleDistanceComponent_exposer.def( "__str__", &__str__< ::SireSystem::TripleDistanceComponent > ); TripleDistanceComponent_exposer.def( "__repr__", &__str__< ::SireSystem::TripleDistanceComponent > ); } }
void register_IDOrSet_SegID__class(){ { //::SireID::IDOrSet< SireMol::SegID > typedef bp::class_< SireID::IDOrSet< SireMol::SegID >, bp::bases< SireMol::SegID, SireID::ID > > IDOrSet_SegID__exposer_t; IDOrSet_SegID__exposer_t IDOrSet_SegID__exposer = IDOrSet_SegID__exposer_t( "IDOrSet_SegID_", bp::init< >() ); bp::scope IDOrSet_SegID__scope( IDOrSet_SegID__exposer ); IDOrSet_SegID__exposer.def( bp::init< SireMol::SegID const & >(( bp::arg("id") )) ); IDOrSet_SegID__exposer.def( bp::init< SireMol::SegID const &, SireMol::SegID const & >(( bp::arg("id0"), bp::arg("id1") )) ); IDOrSet_SegID__exposer.def( bp::init< QList< SireMol::SegIdentifier > const & >(( bp::arg("ids") )) ); IDOrSet_SegID__exposer.def( bp::init< SireID::IDOrSet< SireMol::SegID > const & >(( bp::arg("other") )) ); { //::SireID::IDOrSet< SireMol::SegID >::IDs typedef SireID::IDOrSet< SireMol::SegID > exported_class_t; typedef ::QSet< SireMol::SegIdentifier > const & ( ::SireID::IDOrSet< SireMol::SegID >::*IDs_function_type )( ) const; IDs_function_type IDs_function_value( &::SireID::IDOrSet< SireMol::SegID >::IDs ); IDOrSet_SegID__exposer.def( "IDs" , IDs_function_value , bp::return_value_policy< bp::copy_const_reference >() ); } { //::SireID::IDOrSet< SireMol::SegID >::hash typedef SireID::IDOrSet< SireMol::SegID > exported_class_t; typedef ::uint ( ::SireID::IDOrSet< SireMol::SegID >::*hash_function_type )( ) const; hash_function_type hash_function_value( &::SireID::IDOrSet< SireMol::SegID >::hash ); IDOrSet_SegID__exposer.def( "hash" , hash_function_value ); } { //::SireID::IDOrSet< SireMol::SegID >::isNull 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> > ); } }
void register_Segment_class(){ { //::SireMol::Segment typedef bp::class_< SireMol::Segment, bp::bases< SireMol::MoleculeView, SireBase::Property > > Segment_exposer_t; Segment_exposer_t Segment_exposer = Segment_exposer_t( "Segment", bp::init< >() ); bp::scope Segment_scope( Segment_exposer ); Segment_exposer.def( bp::init< SireMol::MoleculeData const &, SireMol::SegID const & >(( bp::arg("data"), bp::arg("segid") )) ); Segment_exposer.def( bp::init< SireMol::Segment const & >(( bp::arg("other") )) ); { //::SireMol::Segment::assertContainsMetadata typedef void ( ::SireMol::Segment::*assertContainsMetadata_function_type )( ::SireBase::PropertyName const & ) const; assertContainsMetadata_function_type assertContainsMetadata_function_value( &::SireMol::Segment::assertContainsMetadata ); Segment_exposer.def( "assertContainsMetadata" , assertContainsMetadata_function_value , ( bp::arg("metakey") ) ); } { //::SireMol::Segment::assertContainsMetadata typedef void ( ::SireMol::Segment::*assertContainsMetadata_function_type )( ::SireBase::PropertyName const &,::SireBase::PropertyName const & ) const; assertContainsMetadata_function_type assertContainsMetadata_function_value( &::SireMol::Segment::assertContainsMetadata ); Segment_exposer.def( "assertContainsMetadata" , assertContainsMetadata_function_value , ( bp::arg("key"), bp::arg("metakey") ) ); } { //::SireMol::Segment::assertContainsProperty typedef void ( ::SireMol::Segment::*assertContainsProperty_function_type )( ::SireBase::PropertyName const & ) const; assertContainsProperty_function_type assertContainsProperty_function_value( &::SireMol::Segment::assertContainsProperty ); Segment_exposer.def( "assertContainsProperty" , assertContainsProperty_function_value , ( bp::arg("key") ) ); } { //::SireMol::Segment::atomIdxs typedef ::QList< SireMol::AtomIdx > const & ( ::SireMol::Segment::*atomIdxs_function_type )( ) const; atomIdxs_function_type atomIdxs_function_value( &::SireMol::Segment::atomIdxs ); Segment_exposer.def( "atomIdxs" , atomIdxs_function_value , bp::return_value_policy< bp::copy_const_reference >() ); } { //::SireMol::Segment::contains typedef bool ( ::SireMol::Segment::*contains_function_type )( ::SireMol::AtomIdx ) const; contains_function_type contains_function_value( &::SireMol::Segment::contains ); Segment_exposer.def( "contains" , contains_function_value , ( bp::arg("atomidx") ) ); } { //::SireMol::Segment::contains typedef bool ( ::SireMol::Segment::*contains_function_type )( ::SireMol::AtomID const & ) const; contains_function_type contains_function_value( &::SireMol::Segment::contains ); Segment_exposer.def( "contains" , contains_function_value , ( bp::arg("atomid") ) ); } { //::SireMol::Segment::edit typedef ::SireMol::SegEditor ( ::SireMol::Segment::*edit_function_type )( ) const; edit_function_type edit_function_value( &::SireMol::Segment::edit ); Segment_exposer.def( "edit" , edit_function_value ); } { //::SireMol::Segment::evaluate typedef ::SireMol::Evaluator ( ::SireMol::Segment::*evaluate_function_type )( ) const; evaluate_function_type evaluate_function_value( &::SireMol::Segment::evaluate ); Segment_exposer.def( "evaluate" , evaluate_function_value ); } { //::SireMol::Segment::hasMetadata typedef bool ( ::SireMol::Segment::*hasMetadata_function_type )( ::SireBase::PropertyName const & ) const; hasMetadata_function_type hasMetadata_function_value( &::SireMol::Segment::hasMetadata ); Segment_exposer.def( "hasMetadata" , hasMetadata_function_value , ( bp::arg("metakey") ) ); } { //::SireMol::Segment::hasMetadata typedef bool ( ::SireMol::Segment::*hasMetadata_function_type )( ::SireBase::PropertyName const &,::SireBase::PropertyName const & ) const; hasMetadata_function_type hasMetadata_function_value( &::SireMol::Segment::hasMetadata ); Segment_exposer.def( "hasMetadata" , hasMetadata_function_value , ( bp::arg("key"), bp::arg("metakey") ) ); } { //::SireMol::Segment::hasProperty typedef bool ( ::SireMol::Segment::*hasProperty_function_type )( ::SireBase::PropertyName const & ) const; hasProperty_function_type hasProperty_function_value( &::SireMol::Segment::hasProperty ); Segment_exposer.def( "hasProperty" , hasProperty_function_value , ( bp::arg("key") ) ); } { //::SireMol::Segment::index typedef ::SireMol::SegIdx ( ::SireMol::Segment::*index_function_type )( ) const; index_function_type index_function_value( &::SireMol::Segment::index ); Segment_exposer.def( "index" , index_function_value ); } { //::SireMol::Segment::intersects typedef bool ( ::SireMol::Segment::*intersects_function_type )( ::SireMol::AtomID const & ) const; intersects_function_type intersects_function_value( &::SireMol::Segment::intersects ); Segment_exposer.def( "intersects" , intersects_function_value , ( bp::arg("atomid") ) ); } { //::SireMol::Segment::isEmpty typedef bool ( ::SireMol::Segment::*isEmpty_function_type )( ) const; isEmpty_function_type isEmpty_function_value( &::SireMol::Segment::isEmpty ); Segment_exposer.def( "isEmpty" , isEmpty_function_value ); } { //::SireMol::Segment::metadataKeys typedef ::QStringList ( ::SireMol::Segment::*metadataKeys_function_type )( ) const; metadataKeys_function_type metadataKeys_function_value( &::SireMol::Segment::metadataKeys ); Segment_exposer.def( "metadataKeys" , metadataKeys_function_value ); } { //::SireMol::Segment::metadataKeys typedef ::QStringList ( ::SireMol::Segment::*metadataKeys_function_type )( ::SireBase::PropertyName const & ) const; metadataKeys_function_type metadataKeys_function_value( &::SireMol::Segment::metadataKeys ); Segment_exposer.def( "metadataKeys" , metadataKeys_function_value , ( bp::arg("key") ) ); } { //::SireMol::Segment::move typedef ::SireMol::Mover< SireMol::Segment > ( ::SireMol::Segment::*move_function_type )( ) const; move_function_type move_function_value( &::SireMol::Segment::move ); Segment_exposer.def( "move" , move_function_value ); } { //::SireMol::Segment::nAtoms typedef int ( ::SireMol::Segment::*nAtoms_function_type )( ) const; nAtoms_function_type nAtoms_function_value( &::SireMol::Segment::nAtoms ); Segment_exposer.def( "nAtoms" , nAtoms_function_value ); } { //::SireMol::Segment::name typedef ::SireMol::SegName const & ( ::SireMol::Segment::*name_function_type )( ) const; name_function_type name_function_value( &::SireMol::Segment::name ); Segment_exposer.def( "name" , name_function_value , bp::return_value_policy<bp::clone_const_reference>() ); } Segment_exposer.def( bp::self != bp::self ); { //::SireMol::Segment::operator= typedef ::SireMol::Segment & ( ::SireMol::Segment::*assign_function_type )( ::SireMol::Segment const & ) ; assign_function_type assign_function_value( &::SireMol::Segment::operator= ); Segment_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() ); } Segment_exposer.def( bp::self == bp::self ); { //::SireMol::Segment::propertyKeys typedef ::QStringList ( ::SireMol::Segment::*propertyKeys_function_type )( ) const; propertyKeys_function_type propertyKeys_function_value( &::SireMol::Segment::propertyKeys ); Segment_exposer.def( "propertyKeys" , propertyKeys_function_value ); } { //::SireMol::Segment::selectedAll typedef bool ( ::SireMol::Segment::*selectedAll_function_type )( ) const; selectedAll_function_type selectedAll_function_value( &::SireMol::Segment::selectedAll ); Segment_exposer.def( "selectedAll" , selectedAll_function_value ); } { //::SireMol::Segment::selection typedef ::SireMol::AtomSelection ( ::SireMol::Segment::*selection_function_type )( ) const; selection_function_type selection_function_value( &::SireMol::Segment::selection ); Segment_exposer.def( "selection" , selection_function_value ); } { //::SireMol::Segment::selector typedef ::SireMol::Selector< SireMol::Segment > ( ::SireMol::Segment::*selector_function_type )( ) const; selector_function_type selector_function_value( &::SireMol::Segment::selector ); Segment_exposer.def( "selector" , selector_function_value ); } { //::SireMol::Segment::toString typedef ::QString ( ::SireMol::Segment::*toString_function_type )( ) const; toString_function_type toString_function_value( &::SireMol::Segment::toString ); Segment_exposer.def( "toString" , toString_function_value ); } { //::SireMol::Segment::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireMol::Segment::typeName ); Segment_exposer.def( "typeName" , typeName_function_value ); } { //::SireMol::Segment::update typedef void ( ::SireMol::Segment::*update_function_type )( ::SireMol::MoleculeData const & ) ; update_function_type update_function_value( &::SireMol::Segment::update ); Segment_exposer.def( "update" , update_function_value , ( bp::arg("moldata") ) ); } Segment_exposer.staticmethod( "typeName" ); Segment_exposer.def( "_get_property_SireMol_SegStringProperty", &SireMol::Segment::property< QString >, bp::return_value_policy<bp::copy_const_reference>()); Segment_exposer.def( "_get_metadata_SireMol_SegStringProperty", get_Metadata_SireMol_SegStringProperty_function1, bp::return_value_policy<bp::copy_const_reference>()); Segment_exposer.def( "_get_metadata_SireMol_SegStringProperty", &get_Metadata_SireMol_SegStringProperty_function2, bp::return_value_policy<bp::copy_const_reference>()); Segment_exposer.def( "_get_property_SireMol_SegIntProperty", &SireMol::Segment::property< qint64 >, bp::return_value_policy<bp::copy_const_reference>()); Segment_exposer.def( "_get_metadata_SireMol_SegIntProperty", get_Metadata_SireMol_SegIntProperty_function1, bp::return_value_policy<bp::copy_const_reference>()); Segment_exposer.def( "_get_metadata_SireMol_SegIntProperty", &get_Metadata_SireMol_SegIntProperty_function2, bp::return_value_policy<bp::copy_const_reference>()); Segment_exposer.def( "_get_property_SireMol_SegFloatProperty", &SireMol::Segment::property< double >, bp::return_value_policy<bp::copy_const_reference>()); Segment_exposer.def( "_get_metadata_SireMol_SegFloatProperty", get_Metadata_SireMol_SegFloatProperty_function1, bp::return_value_policy<bp::copy_const_reference>()); Segment_exposer.def( "_get_metadata_SireMol_SegFloatProperty", &get_Metadata_SireMol_SegFloatProperty_function2, bp::return_value_policy<bp::copy_const_reference>()); Segment_exposer.def( "_get_property_SireMol_SegVariantProperty", &SireMol::Segment::property< QVariant >, bp::return_value_policy<bp::copy_const_reference>()); Segment_exposer.def( "_get_metadata_SireMol_SegVariantProperty", get_Metadata_SireMol_SegVariantProperty_function1, bp::return_value_policy<bp::copy_const_reference>()); Segment_exposer.def( "_get_metadata_SireMol_SegVariantProperty", &get_Metadata_SireMol_SegVariantProperty_function2, bp::return_value_policy<bp::copy_const_reference>()); Segment_exposer.def( "__copy__", &__copy__); Segment_exposer.def( "__deepcopy__", &__copy__); Segment_exposer.def( "clone", &__copy__); Segment_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::Segment >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); Segment_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::Segment >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); Segment_exposer.def( "__str__", &__str__< ::SireMol::Segment > ); Segment_exposer.def( "__repr__", &__str__< ::SireMol::Segment > ); } }
void register_MolWithResID_class(){ { //::SireMol::MolWithResID typedef bp::class_< SireMol::MolWithResID, bp::bases< SireMol::MolID, SireID::ID > > MolWithResID_exposer_t; MolWithResID_exposer_t MolWithResID_exposer = MolWithResID_exposer_t( "MolWithResID", bp::init< >() ); bp::scope MolWithResID_scope( MolWithResID_exposer ); MolWithResID_exposer.def( bp::init< QString const & >(( bp::arg("resname") )) ); MolWithResID_exposer.def( bp::init< int >(( bp::arg("resnum") )) ); MolWithResID_exposer.def( bp::init< SireMol::ResID const & >(( bp::arg("resid") )) ); MolWithResID_exposer.def( bp::init< QString const &, SireID::CaseSensitivity >(( bp::arg("resname"), bp::arg("case_sensitivity") )) ); MolWithResID_exposer.def( bp::init< SireMol::MolWithResID const & >(( bp::arg("other") )) ); { //::SireMol::MolWithResID::hash typedef ::uint ( ::SireMol::MolWithResID::*hash_function_type )( ) const; hash_function_type hash_function_value( &::SireMol::MolWithResID::hash ); MolWithResID_exposer.def( "hash" , hash_function_value ); } { //::SireMol::MolWithResID::isNull typedef bool ( ::SireMol::MolWithResID::*isNull_function_type )( ) const; isNull_function_type isNull_function_value( &::SireMol::MolWithResID::isNull ); MolWithResID_exposer.def( "isNull" , isNull_function_value ); } { //::SireMol::MolWithResID::map 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 > ); } }
void register_GeneralUnit_class(){ { //::SireUnits::Dimension::GeneralUnit typedef bp::class_< SireUnits::Dimension::GeneralUnit, bp::bases< SireUnits::Dimension::Unit > > GeneralUnit_exposer_t; GeneralUnit_exposer_t GeneralUnit_exposer = GeneralUnit_exposer_t( "GeneralUnit", bp::init< >() ); bp::scope GeneralUnit_scope( GeneralUnit_exposer ); GeneralUnit_exposer.def( bp::init< SireUnits::Dimension::GeneralUnit const & >(( bp::arg("other") )) ); { //::SireUnits::Dimension::GeneralUnit::ANGLE typedef int ( ::SireUnits::Dimension::GeneralUnit::*ANGLE_function_type )( ) const; ANGLE_function_type ANGLE_function_value( &::SireUnits::Dimension::GeneralUnit::ANGLE ); GeneralUnit_exposer.def( "ANGLE" , ANGLE_function_value ); } { //::SireUnits::Dimension::GeneralUnit::CHARGE typedef int ( ::SireUnits::Dimension::GeneralUnit::*CHARGE_function_type )( ) const; CHARGE_function_type CHARGE_function_value( &::SireUnits::Dimension::GeneralUnit::CHARGE ); GeneralUnit_exposer.def( "CHARGE" , CHARGE_function_value ); } { //::SireUnits::Dimension::GeneralUnit::LENGTH typedef int ( ::SireUnits::Dimension::GeneralUnit::*LENGTH_function_type )( ) const; LENGTH_function_type LENGTH_function_value( &::SireUnits::Dimension::GeneralUnit::LENGTH ); GeneralUnit_exposer.def( "LENGTH" , LENGTH_function_value ); } { //::SireUnits::Dimension::GeneralUnit::MASS typedef int ( ::SireUnits::Dimension::GeneralUnit::*MASS_function_type )( ) const; MASS_function_type MASS_function_value( &::SireUnits::Dimension::GeneralUnit::MASS ); GeneralUnit_exposer.def( "MASS" , MASS_function_value ); } { //::SireUnits::Dimension::GeneralUnit::QUANTITY typedef int ( ::SireUnits::Dimension::GeneralUnit::*QUANTITY_function_type )( ) const; QUANTITY_function_type QUANTITY_function_value( &::SireUnits::Dimension::GeneralUnit::QUANTITY ); GeneralUnit_exposer.def( "QUANTITY" , QUANTITY_function_value ); } { //::SireUnits::Dimension::GeneralUnit::TEMPERATURE typedef int ( ::SireUnits::Dimension::GeneralUnit::*TEMPERATURE_function_type )( ) const; TEMPERATURE_function_type TEMPERATURE_function_value( &::SireUnits::Dimension::GeneralUnit::TEMPERATURE ); GeneralUnit_exposer.def( "TEMPERATURE" , TEMPERATURE_function_value ); } { //::SireUnits::Dimension::GeneralUnit::TIME typedef int ( ::SireUnits::Dimension::GeneralUnit::*TIME_function_type )( ) const; TIME_function_type TIME_function_value( &::SireUnits::Dimension::GeneralUnit::TIME ); GeneralUnit_exposer.def( "TIME" , TIME_function_value ); } { //::SireUnits::Dimension::GeneralUnit::invert typedef ::SireUnits::Dimension::GeneralUnit ( ::SireUnits::Dimension::GeneralUnit::*invert_function_type )( ) const; invert_function_type invert_function_value( &::SireUnits::Dimension::GeneralUnit::invert ); GeneralUnit_exposer.def( "invert" , invert_function_value ); } GeneralUnit_exposer.def( bp::self != bp::self ); GeneralUnit_exposer.def( bp::self * bp::self ); GeneralUnit_exposer.def( bp::self * bp::other< double >() ); GeneralUnit_exposer.def( bp::self * bp::other< int >() ); GeneralUnit_exposer.def( bp::self *= bp::self ); GeneralUnit_exposer.def( bp::self + bp::self ); GeneralUnit_exposer.def( -bp::self ); GeneralUnit_exposer.def( bp::self - bp::self ); GeneralUnit_exposer.def( bp::self / bp::self ); GeneralUnit_exposer.def( bp::self / bp::other< double >() ); GeneralUnit_exposer.def( bp::self / bp::other< int >() ); GeneralUnit_exposer.def( bp::self /= bp::self ); { //::SireUnits::Dimension::GeneralUnit::operator= typedef ::SireUnits::Dimension::GeneralUnit & ( ::SireUnits::Dimension::GeneralUnit::*assign_function_type )( ::SireUnits::Dimension::GeneralUnit const & ) ; assign_function_type assign_function_value( &::SireUnits::Dimension::GeneralUnit::operator= ); GeneralUnit_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() ); } GeneralUnit_exposer.def( bp::self == bp::self ); { //::SireUnits::Dimension::GeneralUnit::to typedef double ( ::SireUnits::Dimension::GeneralUnit::*to_function_type )( ::SireUnits::Dimension::TempBase const & ) const; to_function_type to_function_value( &::SireUnits::Dimension::GeneralUnit::to ); GeneralUnit_exposer.def( "to" , to_function_value , ( bp::arg("other") ) ); } { //::SireUnits::Dimension::GeneralUnit::to typedef double ( ::SireUnits::Dimension::GeneralUnit::*to_function_type )( ::SireUnits::Dimension::GeneralUnit const & ) const; to_function_type to_function_value( &::SireUnits::Dimension::GeneralUnit::to ); GeneralUnit_exposer.def( "to" , to_function_value , ( bp::arg("other") ) ); } { //::SireUnits::Dimension::GeneralUnit::toString typedef ::QString ( ::SireUnits::Dimension::GeneralUnit::*toString_function_type )( ) const; toString_function_type toString_function_value( &::SireUnits::Dimension::GeneralUnit::toString ); GeneralUnit_exposer.def( "toString" , toString_function_value ); } { //::SireUnits::Dimension::GeneralUnit::typeName typedef ::QString ( ::SireUnits::Dimension::GeneralUnit::*typeName_function_type )( ) const; typeName_function_type typeName_function_value( &::SireUnits::Dimension::GeneralUnit::typeName ); GeneralUnit_exposer.def( "typeName" , typeName_function_value ); } { //::SireUnits::Dimension::GeneralUnit::what typedef ::QString ( ::SireUnits::Dimension::GeneralUnit::*what_function_type )( ) const; what_function_type what_function_value( &::SireUnits::Dimension::GeneralUnit::what ); GeneralUnit_exposer.def( "what" , what_function_value ); } GeneralUnit_exposer.def( bp::other<double>() * bp::self ); GeneralUnit_exposer.def( bp::other<double>() / bp::self ); GeneralUnit_exposer.def( "__copy__", &__copy__); GeneralUnit_exposer.def( "__deepcopy__", &__copy__); GeneralUnit_exposer.def( "clone", &__copy__); GeneralUnit_exposer.def( "__str__", &__str__< ::SireUnits::Dimension::GeneralUnit > ); GeneralUnit_exposer.def( "__repr__", &__str__< ::SireUnits::Dimension::GeneralUnit > ); } }
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 > ); } }
void register_Ensemble_class(){ { //::SireMove::Ensemble typedef bp::class_< SireMove::Ensemble, bp::bases< SireBase::Property > > Ensemble_exposer_t; Ensemble_exposer_t Ensemble_exposer = Ensemble_exposer_t( "Ensemble", "This class describes the ensemble that will be created by\na collection of moves (e.g. will the moves sample at constant\nvolume or temperature?)\n\nAuthor: Christopher Woods\n", bp::init< >("Construct an NVE ensemble") ); bp::scope Ensemble_scope( Ensemble_exposer ); Ensemble_exposer.def( bp::init< SireMove::Ensemble const & >(( bp::arg("other") ), "Copy constructor") ); { //::SireMove::Ensemble::MuVT typedef ::SireMove::Ensemble ( *MuVT_function_type )( ::SireUnits::Dimension::Temperature const &,::SireUnits::Dimension::Pressure const & ); MuVT_function_type MuVT_function_value( &::SireMove::Ensemble::MuVT ); Ensemble_exposer.def( "MuVT" , MuVT_function_value , ( bp::arg("temperature"), bp::arg("fugacity") ) , "Return the MuVT ensemble for the temperature temperature and\nthe fugacity fugacity" ); } { //::SireMove::Ensemble::MuVT typedef ::SireMove::Ensemble ( *MuVT_function_type )( ::SireUnits::Dimension::Temperature const &,::SireUnits::Dimension::MolarEnergy const & ); MuVT_function_type MuVT_function_value( &::SireMove::Ensemble::MuVT ); Ensemble_exposer.def( "MuVT" , MuVT_function_value , ( bp::arg("temperature"), bp::arg("chemical_potential") ) , "Return the MuVT ensemble for the temperature temperature and\nthe chemical potential chemical_potential" ); } { //::SireMove::Ensemble::NPT typedef ::SireMove::Ensemble ( *NPT_function_type )( ::SireUnits::Dimension::Temperature const &,::SireUnits::Dimension::Pressure const & ); NPT_function_type NPT_function_value( &::SireMove::Ensemble::NPT ); Ensemble_exposer.def( "NPT" , NPT_function_value , ( bp::arg("temperature"), bp::arg("pressure") ) , "Return the NPT ensemble for the temperature temperature and\nthe pressure pressure" ); } { //::SireMove::Ensemble::NVE typedef ::SireMove::Ensemble ( *NVE_function_type )( ); NVE_function_type NVE_function_value( &::SireMove::Ensemble::NVE ); Ensemble_exposer.def( "NVE" , NVE_function_value , "Return the NVE ensemble" ); } { //::SireMove::Ensemble::NVT typedef ::SireMove::Ensemble ( *NVT_function_type )( ::SireUnits::Dimension::Temperature const & ); NVT_function_type NVT_function_value( &::SireMove::Ensemble::NVT ); Ensemble_exposer.def( "NVT" , NVT_function_value , ( bp::arg("temperature") ) , "Return the NVT ensemble for the temperature temperature" ); } { //::SireMove::Ensemble::canonical typedef ::SireMove::Ensemble ( *canonical_function_type )( ::SireUnits::Dimension::Temperature const & ); canonical_function_type canonical_function_value( &::SireMove::Ensemble::canonical ); Ensemble_exposer.def( "canonical" , canonical_function_value , ( bp::arg("temperature") ) , "Syntactic sugar to return the NVT ensemble" ); } { //::SireMove::Ensemble::chemicalPotential typedef ::SireUnits::Dimension::MolarEnergy ( ::SireMove::Ensemble::*chemicalPotential_function_type)( ) const; chemicalPotential_function_type chemicalPotential_function_value( &::SireMove::Ensemble::chemicalPotential ); Ensemble_exposer.def( "chemicalPotential" , chemicalPotential_function_value , "Return the chemical potential of this ensemble\nThrow: SireError::incompatible_error\n" ); } { //::SireMove::Ensemble::fugacity typedef ::SireUnits::Dimension::Pressure ( ::SireMove::Ensemble::*fugacity_function_type)( ) const; fugacity_function_type fugacity_function_value( &::SireMove::Ensemble::fugacity ); Ensemble_exposer.def( "fugacity" , fugacity_function_value , "Return the fugacity of this ensemble\nThrow: SireError::incompatible_error\n" ); } { //::SireMove::Ensemble::grandCanonical typedef ::SireMove::Ensemble ( *grandCanonical_function_type )( ::SireUnits::Dimension::Temperature const &,::SireUnits::Dimension::Pressure const & ); grandCanonical_function_type grandCanonical_function_value( &::SireMove::Ensemble::grandCanonical ); Ensemble_exposer.def( "grandCanonical" , grandCanonical_function_value , ( bp::arg("temperature"), bp::arg("fugacity") ) , "Syntactic sugar to return the MuVT ensemble" ); } { //::SireMove::Ensemble::grandCanonical typedef ::SireMove::Ensemble ( *grandCanonical_function_type )( ::SireUnits::Dimension::Temperature const &,::SireUnits::Dimension::MolarEnergy const & ); grandCanonical_function_type grandCanonical_function_value( &::SireMove::Ensemble::grandCanonical ); Ensemble_exposer.def( "grandCanonical" , grandCanonical_function_value , ( bp::arg("temperature"), bp::arg("chemical_potential") ) , "Syntactic sugar to return the MuVT ensemble" ); } { //::SireMove::Ensemble::isCanonical typedef bool ( ::SireMove::Ensemble::*isCanonical_function_type)( ) const; isCanonical_function_type isCanonical_function_value( &::SireMove::Ensemble::isCanonical ); Ensemble_exposer.def( "isCanonical" , isCanonical_function_value , "Return whether or not this is the canonical (NVT) ensemble" ); } { //::SireMove::Ensemble::isConstantChemicalPotential typedef bool ( ::SireMove::Ensemble::*isConstantChemicalPotential_function_type)( ) const; isConstantChemicalPotential_function_type isConstantChemicalPotential_function_value( &::SireMove::Ensemble::isConstantChemicalPotential ); Ensemble_exposer.def( "isConstantChemicalPotential" , isConstantChemicalPotential_function_value , "Return whether the chemical potential is constant in this ensemble" ); } { //::SireMove::Ensemble::isConstantEnergy typedef bool ( ::SireMove::Ensemble::*isConstantEnergy_function_type)( ) const; isConstantEnergy_function_type isConstantEnergy_function_value( &::SireMove::Ensemble::isConstantEnergy ); Ensemble_exposer.def( "isConstantEnergy" , isConstantEnergy_function_value , "Return whether or not energy is a constant in this ensemble" ); } { //::SireMove::Ensemble::isConstantFugacity typedef bool ( ::SireMove::Ensemble::*isConstantFugacity_function_type)( ) const; isConstantFugacity_function_type isConstantFugacity_function_value( &::SireMove::Ensemble::isConstantFugacity ); Ensemble_exposer.def( "isConstantFugacity" , isConstantFugacity_function_value , "Return whether the chemical potential is constant in this ensemble" ); } { //::SireMove::Ensemble::isConstantNParticles typedef bool ( ::SireMove::Ensemble::*isConstantNParticles_function_type)( ) const; isConstantNParticles_function_type isConstantNParticles_function_value( &::SireMove::Ensemble::isConstantNParticles ); Ensemble_exposer.def( "isConstantNParticles" , isConstantNParticles_function_value , "Return whether or not the number of particles is constant in this ensemble" ); } { //::SireMove::Ensemble::isConstantPressure typedef bool ( ::SireMove::Ensemble::*isConstantPressure_function_type)( ) const; isConstantPressure_function_type isConstantPressure_function_value( &::SireMove::Ensemble::isConstantPressure ); Ensemble_exposer.def( "isConstantPressure" , isConstantPressure_function_value , "Return whether or not pressure is a constant in this ensemble" ); } { //::SireMove::Ensemble::isConstantTemperature typedef bool ( ::SireMove::Ensemble::*isConstantTemperature_function_type)( ) const; isConstantTemperature_function_type isConstantTemperature_function_value( &::SireMove::Ensemble::isConstantTemperature ); Ensemble_exposer.def( "isConstantTemperature" , isConstantTemperature_function_value , "Return whether or not temperature is a constant in this ensemble" ); } { //::SireMove::Ensemble::isConstantVolume typedef bool ( ::SireMove::Ensemble::*isConstantVolume_function_type)( ) const; isConstantVolume_function_type isConstantVolume_function_value( &::SireMove::Ensemble::isConstantVolume ); Ensemble_exposer.def( "isConstantVolume" , isConstantVolume_function_value , "Return whether or not volume is a constant in this ensemble" ); } { //::SireMove::Ensemble::isGrandCanonical typedef bool ( ::SireMove::Ensemble::*isGrandCanonical_function_type)( ) const; isGrandCanonical_function_type isGrandCanonical_function_value( &::SireMove::Ensemble::isGrandCanonical ); Ensemble_exposer.def( "isGrandCanonical" , isGrandCanonical_function_value , "Return whether or not this is the grand canonical (MuVT) ensemble" ); } { //::SireMove::Ensemble::isIsothermalIsobaric typedef bool ( ::SireMove::Ensemble::*isIsothermalIsobaric_function_type)( ) const; isIsothermalIsobaric_function_type isIsothermalIsobaric_function_value( &::SireMove::Ensemble::isIsothermalIsobaric ); Ensemble_exposer.def( "isIsothermalIsobaric" , isIsothermalIsobaric_function_value , "Return whether or not this is the isothermal-isobaric (NPT) ensemble" ); } { //::SireMove::Ensemble::isMicroCanonical typedef bool ( ::SireMove::Ensemble::*isMicroCanonical_function_type)( ) const; isMicroCanonical_function_type isMicroCanonical_function_value( &::SireMove::Ensemble::isMicroCanonical ); Ensemble_exposer.def( "isMicroCanonical" , isMicroCanonical_function_value , "Return whether or not this is the microcanonical (NVE) ensemble" ); } { //::SireMove::Ensemble::isMuVT typedef bool ( ::SireMove::Ensemble::*isMuVT_function_type)( ) const; isMuVT_function_type isMuVT_function_value( &::SireMove::Ensemble::isMuVT ); Ensemble_exposer.def( "isMuVT" , isMuVT_function_value , "Return whether or not this is the MuVT ensemble" ); } { //::SireMove::Ensemble::isNPT typedef bool ( ::SireMove::Ensemble::*isNPT_function_type)( ) const; isNPT_function_type isNPT_function_value( &::SireMove::Ensemble::isNPT ); Ensemble_exposer.def( "isNPT" , isNPT_function_value , "Return whether or not this is the NPT ensemble" ); } { //::SireMove::Ensemble::isNVE typedef bool ( ::SireMove::Ensemble::*isNVE_function_type)( ) const; isNVE_function_type isNVE_function_value( &::SireMove::Ensemble::isNVE ); Ensemble_exposer.def( "isNVE" , isNVE_function_value , "Return whether or not this is the NVE ensemble" ); } { //::SireMove::Ensemble::isNVT typedef bool ( ::SireMove::Ensemble::*isNVT_function_type)( ) const; isNVT_function_type isNVT_function_value( &::SireMove::Ensemble::isNVT ); Ensemble_exposer.def( "isNVT" , isNVT_function_value , "Return whether or not this is the NVT ensemble" ); } { //::SireMove::Ensemble::isothermalIsobaric typedef ::SireMove::Ensemble ( *isothermalIsobaric_function_type )( ::SireUnits::Dimension::Temperature const &,::SireUnits::Dimension::Pressure const & ); isothermalIsobaric_function_type isothermalIsobaric_function_value( &::SireMove::Ensemble::isothermalIsobaric ); Ensemble_exposer.def( "isothermalIsobaric" , isothermalIsobaric_function_value , ( bp::arg("temperature"), bp::arg("pressure") ) , "Syntactic sugar to return the NPT ensemble" ); } { //::SireMove::Ensemble::merge typedef ::SireMove::Ensemble ( ::SireMove::Ensemble::*merge_function_type)( ::SireMove::Ensemble const & ) const; merge_function_type merge_function_value( &::SireMove::Ensemble::merge ); Ensemble_exposer.def( "merge" , merge_function_value , ( bp::arg("other") ) , "Merge this ensemble with other. This tries to find an ensemble\nthat satisfies both, e.g. merging NVE with NVT will give NVT,\nwhile merging NVE with NPT would give NPT." ); } { //::SireMove::Ensemble::merge typedef ::SireMove::Ensemble ( *merge_function_type )( ::SireMove::Ensemble const &,::SireMove::Ensemble const & ); merge_function_type merge_function_value( &::SireMove::Ensemble::merge ); Ensemble_exposer.def( "merge" , merge_function_value , ( bp::arg("e0"), bp::arg("e1") ) , "Merge the two ensembles e0 and e1 together. This tries to find an ensemble\nthat satisfies both, e.g. merging NVE with NVT will give NVT,\nwhile merging NVE with NPT would give NPT." ); } { //::SireMove::Ensemble::microcanonical typedef ::SireMove::Ensemble ( *microcanonical_function_type )( ); microcanonical_function_type microcanonical_function_value( &::SireMove::Ensemble::microcanonical ); Ensemble_exposer.def( "microcanonical" , microcanonical_function_value , "Syntactic sugar to return the NVE ensemble" ); } { //::SireMove::Ensemble::name typedef ::QString ( ::SireMove::Ensemble::*name_function_type)( ) const; name_function_type name_function_value( &::SireMove::Ensemble::name ); Ensemble_exposer.def( "name" , name_function_value , "Return the name of this ensemble (if it has a name)" ); } Ensemble_exposer.def( bp::self != bp::self ); { //::SireMove::Ensemble::operator= typedef ::SireMove::Ensemble & ( ::SireMove::Ensemble::*assign_function_type)( ::SireMove::Ensemble const & ) ; assign_function_type assign_function_value( &::SireMove::Ensemble::operator= ); Ensemble_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() , "" ); } Ensemble_exposer.def( bp::self == bp::self ); { //::SireMove::Ensemble::pressure typedef ::SireUnits::Dimension::Pressure ( ::SireMove::Ensemble::*pressure_function_type)( ) const; pressure_function_type pressure_function_value( &::SireMove::Ensemble::pressure ); Ensemble_exposer.def( "pressure" , pressure_function_value , "Return the pressure of this ensemble\nThrow: SireError::incompatible_error\n" ); } { //::SireMove::Ensemble::shortHand typedef ::QString ( ::SireMove::Ensemble::*shortHand_function_type)( ) const; shortHand_function_type shortHand_function_value( &::SireMove::Ensemble::shortHand ); Ensemble_exposer.def( "shortHand" , shortHand_function_value , "Return the shorthand string for this ensemble (e.g. NVT)" ); } { //::SireMove::Ensemble::temperature typedef ::SireUnits::Dimension::Temperature ( ::SireMove::Ensemble::*temperature_function_type)( ) const; temperature_function_type temperature_function_value( &::SireMove::Ensemble::temperature ); Ensemble_exposer.def( "temperature" , temperature_function_value , "Return the temperature of this ensemble\nThrow: SireError::incompatible_error\n" ); } { //::SireMove::Ensemble::toString typedef ::QString ( ::SireMove::Ensemble::*toString_function_type)( ) const; toString_function_type toString_function_value( &::SireMove::Ensemble::toString ); Ensemble_exposer.def( "toString" , toString_function_value , "Return a string representation of this ensemble" ); } { //::SireMove::Ensemble::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireMove::Ensemble::typeName ); Ensemble_exposer.def( "typeName" , typeName_function_value , "" ); } Ensemble_exposer.staticmethod( "MuVT" ); Ensemble_exposer.staticmethod( "NPT" ); Ensemble_exposer.staticmethod( "NVE" ); Ensemble_exposer.staticmethod( "NVT" ); Ensemble_exposer.staticmethod( "canonical" ); Ensemble_exposer.staticmethod( "grandCanonical" ); Ensemble_exposer.staticmethod( "isothermalIsobaric" ); Ensemble_exposer.staticmethod( "merge" ); Ensemble_exposer.staticmethod( "microcanonical" ); Ensemble_exposer.staticmethod( "typeName" ); Ensemble_exposer.def( "__copy__", &__copy__); Ensemble_exposer.def( "__deepcopy__", &__copy__); Ensemble_exposer.def( "clone", &__copy__); Ensemble_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMove::Ensemble >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); Ensemble_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMove::Ensemble >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); Ensemble_exposer.def( "__str__", &__str__< ::SireMove::Ensemble > ); Ensemble_exposer.def( "__repr__", &__str__< ::SireMove::Ensemble > ); } }
void register_TrigArray2D_double__class(){ { //::SireBase::TrigArray2D< double > typedef bp::class_< SireBase::TrigArray2D< double >, bp::bases< SireBase::TrigArray2DBase > > TrigArray2D_double__exposer_t; TrigArray2D_double__exposer_t TrigArray2D_double__exposer = TrigArray2D_double__exposer_t( "TrigArray2D_double_", bp::init< >() ); bp::scope TrigArray2D_double__scope( TrigArray2D_double__exposer ); TrigArray2D_double__exposer.def( bp::init< int >(( bp::arg("dimension") )) ); TrigArray2D_double__exposer.def( bp::init< int, double const & >(( bp::arg("dimension"), bp::arg("default_value") )) ); TrigArray2D_double__exposer.def( bp::init< SireBase::TrigArray2D< double > const & >(( bp::arg("other") )) ); { //::SireBase::TrigArray2D< double >::at typedef SireBase::TrigArray2D< double > exported_class_t; typedef double const & ( ::SireBase::TrigArray2D< double >::*at_function_type )( int,int ) const; at_function_type at_function_value( &::SireBase::TrigArray2D< double >::at ); TrigArray2D_double__exposer.def( "at" , at_function_value , ( bp::arg("i"), bp::arg("j") ) , bp::return_value_policy< bp::copy_const_reference >() ); } { //::SireBase::TrigArray2D< double >::get typedef SireBase::TrigArray2D< double > exported_class_t; typedef double const & ( ::SireBase::TrigArray2D< double >::*get_function_type )( int,int ) const; get_function_type get_function_value( &::SireBase::TrigArray2D< double >::get ); TrigArray2D_double__exposer.def( "get" , get_function_value , ( bp::arg("i"), bp::arg("j") ) , bp::return_value_policy< bp::copy_const_reference >() ); } TrigArray2D_double__exposer.def( bp::self != bp::self ); { //::SireBase::TrigArray2D< double >::operator() typedef SireBase::TrigArray2D< double > exported_class_t; typedef double const & ( ::SireBase::TrigArray2D< double >::*__call___function_type )( int,int ) const; __call___function_type __call___function_value( &::SireBase::TrigArray2D< double >::operator() ); TrigArray2D_double__exposer.def( "__call__" , __call___function_value , ( bp::arg("i"), bp::arg("j") ) , bp::return_value_policy< bp::copy_const_reference >() ); } { //::SireBase::TrigArray2D< double >::operator= typedef SireBase::TrigArray2D< double > exported_class_t; typedef ::SireBase::TrigArray2D< double > & ( ::SireBase::TrigArray2D< double >::*assign_function_type )( ::SireBase::TrigArray2D< double > const & ) ; assign_function_type assign_function_value( &::SireBase::TrigArray2D< double >::operator= ); TrigArray2D_double__exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() ); } TrigArray2D_double__exposer.def( bp::self == bp::self ); { //::SireBase::TrigArray2D< double >::redimension typedef SireBase::TrigArray2D< double > exported_class_t; typedef void ( ::SireBase::TrigArray2D< double >::*redimension_function_type )( int ) ; redimension_function_type redimension_function_value( &::SireBase::TrigArray2D< double >::redimension ); TrigArray2D_double__exposer.def( "redimension" , redimension_function_value , ( bp::arg("dimension") ) ); } { //::SireBase::TrigArray2D< double >::set typedef SireBase::TrigArray2D< double > exported_class_t; typedef void ( ::SireBase::TrigArray2D< double >::*set_function_type )( int,int,double const & ) ; set_function_type set_function_value( &::SireBase::TrigArray2D< double >::set ); TrigArray2D_double__exposer.def( "set" , set_function_value , ( bp::arg("i"), bp::arg("j"), bp::arg("value") ) ); } { //::SireBase::TrigArray2D< double >::setAll typedef SireBase::TrigArray2D< double > exported_class_t; typedef void ( ::SireBase::TrigArray2D< double >::*setAll_function_type )( double const & ) ; setAll_function_type setAll_function_value( &::SireBase::TrigArray2D< double >::setAll ); TrigArray2D_double__exposer.def( "setAll" , setAll_function_value , ( bp::arg("value") ) ); } { //::SireBase::TrigArray2D< double >::toString typedef SireBase::TrigArray2D< double > exported_class_t; typedef ::QString ( ::SireBase::TrigArray2D< double >::*toString_function_type )( ) const; toString_function_type toString_function_value( &::SireBase::TrigArray2D< double >::toString ); TrigArray2D_double__exposer.def( "toString" , toString_function_value ); } { //::SireBase::TrigArray2D< double >::transpose typedef SireBase::TrigArray2D< double > exported_class_t; typedef ::SireBase::TrigArray2D< double > ( ::SireBase::TrigArray2D< double >::*transpose_function_type )( ) const; transpose_function_type transpose_function_value( &::SireBase::TrigArray2D< double >::transpose ); TrigArray2D_double__exposer.def( "transpose" , transpose_function_value ); } TrigArray2D_double__exposer.def( "__copy__", &__copy__); TrigArray2D_double__exposer.def( "__deepcopy__", &__copy__); TrigArray2D_double__exposer.def( "clone", &__copy__); TrigArray2D_double__exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireBase::TrigArray2D<double> >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); TrigArray2D_double__exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireBase::TrigArray2D<double> >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); TrigArray2D_double__exposer.def( "__str__", &__str__< ::SireBase::TrigArray2D<double> > ); TrigArray2D_double__exposer.def( "__repr__", &__str__< ::SireBase::TrigArray2D<double> > ); TrigArray2D_double__exposer.def( "__len__", &__len_size< ::SireBase::TrigArray2D<double> > ); } }
void register_Integrator_class(){ { //::SireMove::Integrator typedef bp::class_< SireMove::Integrator, bp::bases< SireBase::Property >, boost::noncopyable > Integrator_exposer_t; Integrator_exposer_t Integrator_exposer = Integrator_exposer_t( "Integrator", "This is the virtual base class of all dynamics integrators. An integrator\nis the kernel used to advance the coordinates of the system from one\ntimestep to the next\n\nAuthor: Christopher Woods\n", bp::no_init ); bp::scope Integrator_scope( Integrator_exposer ); { //::SireMove::Integrator::createWorkspace typedef ::SireMove::IntegratorWorkspacePtr ( ::SireMove::Integrator::*createWorkspace_function_type)( ::SireBase::PropertyMap const & ) const; createWorkspace_function_type createWorkspace_function_value( &::SireMove::Integrator::createWorkspace ); Integrator_exposer.def( "createWorkspace" , createWorkspace_function_value , ( bp::arg("map")=SireBase::PropertyMap() ) , "" ); } { //::SireMove::Integrator::createWorkspace typedef ::SireMove::IntegratorWorkspacePtr ( ::SireMove::Integrator::*createWorkspace_function_type)( ::SireMol::MoleculeGroup const &,::SireBase::PropertyMap const & ) const; createWorkspace_function_type createWorkspace_function_value( &::SireMove::Integrator::createWorkspace ); Integrator_exposer.def( "createWorkspace" , createWorkspace_function_value , ( bp::arg("molgroup"), bp::arg("map")=SireBase::PropertyMap() ) , "" ); } { //::SireMove::Integrator::ensemble typedef ::SireMove::Ensemble ( ::SireMove::Integrator::*ensemble_function_type)( ) const; ensemble_function_type ensemble_function_value( &::SireMove::Integrator::ensemble ); Integrator_exposer.def( "ensemble" , ensemble_function_value , "" ); } { //::SireMove::Integrator::integrate typedef void ( ::SireMove::Integrator::*integrate_function_type)( ::SireMove::IntegratorWorkspace &,::SireCAS::Symbol const &,::SireUnits::Dimension::Time,int,bool ) ; integrate_function_type integrate_function_value( &::SireMove::Integrator::integrate ); Integrator_exposer.def( "integrate" , integrate_function_value , ( bp::arg("workspace"), bp::arg("nrg_component"), bp::arg("timestep"), bp::arg("nmoves"), bp::arg("record_stats") ) , "" ); } { //::SireMove::Integrator::isTimeReversible typedef bool ( ::SireMove::Integrator::*isTimeReversible_function_type)( ) const; isTimeReversible_function_type isTimeReversible_function_value( &::SireMove::Integrator::isTimeReversible ); Integrator_exposer.def( "isTimeReversible" , isTimeReversible_function_value , "" ); } { //::SireMove::Integrator::null typedef ::SireMove::NullIntegrator const & ( *null_function_type )( ); null_function_type null_function_value( &::SireMove::Integrator::null ); Integrator_exposer.def( "null" , null_function_value , bp::return_value_policy< bp::copy_const_reference >() , "Return a NullIntegrator" ); } { //::SireMove::Integrator::toString typedef ::QString ( ::SireMove::Integrator::*toString_function_type)( ) const; toString_function_type toString_function_value( &::SireMove::Integrator::toString ); Integrator_exposer.def( "toString" , toString_function_value , "" ); } { //::SireMove::Integrator::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireMove::Integrator::typeName ); Integrator_exposer.def( "typeName" , typeName_function_value , "" ); } Integrator_exposer.staticmethod( "null" ); Integrator_exposer.staticmethod( "typeName" ); Integrator_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMove::Integrator >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); Integrator_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMove::Integrator >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); Integrator_exposer.def( "__str__", &__str__< ::SireMove::Integrator > ); Integrator_exposer.def( "__repr__", &__str__< ::SireMove::Integrator > ); } }
void register_BeadEditor_class(){ { //::SireMol::BeadEditor typedef bp::class_< SireMol::BeadEditor, bp::bases< SireMol::Editor<SireMol::BeadEditor, SireMol::Bead>, SireMol::Bead, SireMol::MoleculeView, SireBase::Property > > BeadEditor_exposer_t; BeadEditor_exposer_t BeadEditor_exposer = BeadEditor_exposer_t( "BeadEditor", "This is an editor for a single bead in a molecule\n\nAuthor: Christopher Woods\n", bp::init< >("Null constructor") ); bp::scope BeadEditor_scope( BeadEditor_exposer ); BeadEditor_exposer.def( bp::init< SireMol::Bead const & >(( bp::arg("bead") ), "Constructor an editor for the passed bead") ); BeadEditor_exposer.def( bp::init< SireMol::BeadEditor const & >(( bp::arg("other") ), "Copy constructor") ); { //::SireMol::BeadEditor::commit typedef ::SireMol::Bead ( ::SireMol::BeadEditor::*commit_function_type)( ) const; commit_function_type commit_function_value( &::SireMol::BeadEditor::commit ); BeadEditor_exposer.def( "commit" , commit_function_value , "Commit the changes" ); } { //::SireMol::BeadEditor::operator= typedef ::SireMol::BeadEditor & ( ::SireMol::BeadEditor::*assign_function_type)( ::SireMol::Bead const & ) ; assign_function_type assign_function_value( &::SireMol::BeadEditor::operator= ); BeadEditor_exposer.def( "assign" , assign_function_value , ( bp::arg("bead") ) , bp::return_self< >() , "" ); } { //::SireMol::BeadEditor::operator= typedef ::SireMol::BeadEditor & ( ::SireMol::BeadEditor::*assign_function_type)( ::SireMol::BeadEditor const & ) ; assign_function_type assign_function_value( &::SireMol::BeadEditor::operator= ); BeadEditor_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() , "" ); } { //::SireMol::BeadEditor::toString typedef ::QString ( ::SireMol::BeadEditor::*toString_function_type)( ) const; toString_function_type toString_function_value( &::SireMol::BeadEditor::toString ); BeadEditor_exposer.def( "toString" , toString_function_value , "Return a string representation of this editor" ); } { //::SireMol::BeadEditor::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireMol::BeadEditor::typeName ); BeadEditor_exposer.def( "typeName" , typeName_function_value , "" ); } BeadEditor_exposer.staticmethod( "typeName" ); BeadEditor_exposer.def( "__copy__", &__copy__); BeadEditor_exposer.def( "__deepcopy__", &__copy__); BeadEditor_exposer.def( "clone", &__copy__); BeadEditor_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::BeadEditor >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); BeadEditor_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::BeadEditor >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); BeadEditor_exposer.def( "__str__", &__str__< ::SireMol::BeadEditor > ); BeadEditor_exposer.def( "__repr__", &__str__< ::SireMol::BeadEditor > ); BeadEditor_exposer.def( "__len__", &__len_size< ::SireMol::BeadEditor > ); } }
void register_Specify_SegID__class(){ { //::SireID::Specify< SireMol::SegID > typedef bp::class_< SireID::Specify< SireMol::SegID >, bp::bases< SireMol::SegID, SireID::ID > > Specify_SegID__exposer_t; Specify_SegID__exposer_t Specify_SegID__exposer = Specify_SegID__exposer_t( "Specify_SegID_", bp::init< >() ); bp::scope Specify_SegID__scope( Specify_SegID__exposer ); Specify_SegID__exposer.def( bp::init< SireMol::SegID const &, qint32 >(( bp::arg("id"), bp::arg("i") )) ); Specify_SegID__exposer.def( bp::init< SireMol::SegID const &, qint32, qint32 >(( bp::arg("id"), bp::arg("i"), bp::arg("j") )) ); Specify_SegID__exposer.def( bp::init< SireID::Specify< SireMol::SegID > const & >(( bp::arg("other") )) ); { //::SireID::Specify< SireMol::SegID >::hash typedef SireID::Specify< SireMol::SegID > exported_class_t; typedef ::uint ( ::SireID::Specify< SireMol::SegID >::*hash_function_type )( ) const; hash_function_type hash_function_value( &::SireID::Specify< SireMol::SegID >::hash ); Specify_SegID__exposer.def( "hash" , hash_function_value ); } { //::SireID::Specify< SireMol::SegID >::isNull typedef SireID::Specify< SireMol::SegID > exported_class_t; typedef bool ( ::SireID::Specify< SireMol::SegID >::*isNull_function_type )( ) const; isNull_function_type isNull_function_value( &::SireID::Specify< SireMol::SegID >::isNull ); Specify_SegID__exposer.def( "isNull" , isNull_function_value ); } { //::SireID::Specify< SireMol::SegID >::map typedef SireID::Specify< SireMol::SegID > exported_class_t; typedef ::QList< SireMol::SegIdx > ( ::SireID::Specify< SireMol::SegID >::*map_function_type )( ::SireMol::MolInfo const & ) const; map_function_type map_function_value( &::SireID::Specify< SireMol::SegID >::map ); Specify_SegID__exposer.def( "map" , map_function_value , ( bp::arg("obj") ) ); } 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> > ); } }
void register_LJPerturbation_class(){ { //::SireMM::LJPerturbation typedef bp::class_< SireMM::LJPerturbation, bp::bases< SireMol::Perturbation, SireBase::Property > > LJPerturbation_exposer_t; LJPerturbation_exposer_t LJPerturbation_exposer = LJPerturbation_exposer_t( "LJPerturbation", "This is a perturbation that maps LJ parameters for a molecule\nfrom an initial to a final state\n\nAuthor: Christopher Woods\n", bp::init< bp::optional< SireBase::PropertyMap const & > >(( bp::arg("map")=SireBase::PropertyMap() ), "Constructor - this creates a LJ perturbation that\nperturbs from LJs in initial_LJ to LJs in\nfinal_LJ, placing the current LJs in LJ,\nand using Perturbation::defaultEquation() to map the\nsigma and epsilon values of the LJ.") ); bp::scope LJPerturbation_scope( LJPerturbation_exposer ); bp::enum_< SireMM::LJPerturbation::MapType>("MapType") .value("MAP_SIGMA_AND_EPSILON", SireMM::LJPerturbation::MAP_SIGMA_AND_EPSILON) .value("MAP_RMIN_AND_EPSILON", SireMM::LJPerturbation::MAP_RMIN_AND_EPSILON) .value("MAP_A_AND_B", SireMM::LJPerturbation::MAP_A_AND_B) .export_values() ; LJPerturbation_exposer.def( bp::init< SireMM::LJPerturbation::MapType, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("maptype"), bp::arg("map")=SireBase::PropertyMap() ), "Construct, using the passed map to find the properties used\nby this perturbation") ); LJPerturbation_exposer.def( bp::init< SireCAS::Expression const &, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("mapping_function"), bp::arg("map")=SireBase::PropertyMap() ), "Construct, using the passed map to find the properties used\nby this perturbation and the passed mapping function to map\nthe LJs between the states") ); LJPerturbation_exposer.def( bp::init< SireCAS::Expression const &, SireMM::LJPerturbation::MapType, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("mapping_function"), bp::arg("maptype"), bp::arg("map")=SireBase::PropertyMap() ), "Construct, using the passed map to find the properties used\nby this perturbation and the passed mapping function to map\nthe LJs between the states") ); LJPerturbation_exposer.def( bp::init< SireCAS::Expression const &, SireCAS::Expression const &, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("sigma_mapping_function"), bp::arg("epsilon_mapping_function"), bp::arg("map")=SireBase::PropertyMap() ), "Construct, using the passed map to find the properties used\nby this perturbation and the passed mapping function to map\nthe LJs between the states") ); LJPerturbation_exposer.def( bp::init< SireCAS::Expression const &, SireCAS::Expression const &, SireMM::LJPerturbation::MapType, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("sigma_mapping_function"), bp::arg("epsilon_mapping_function"), bp::arg("maptype"), bp::arg("map")=SireBase::PropertyMap() ), "Construct, using the passed map to find the properties used\nby this perturbation and the passed mapping function to map\nthe LJs between the states") ); LJPerturbation_exposer.def( bp::init< SireMM::LJPerturbation const & >(( bp::arg("other") ), "Copy constructor") ); { //::SireMM::LJPerturbation::A_MappingFunction typedef ::SireCAS::Expression const & ( ::SireMM::LJPerturbation::*A_MappingFunction_function_type)( ) const; A_MappingFunction_function_type A_MappingFunction_function_value( &::SireMM::LJPerturbation::A_MappingFunction ); LJPerturbation_exposer.def( "A_MappingFunction" , A_MappingFunction_function_value , bp::return_value_policy< bp::copy_const_reference >() , "Return the function used to map A\nThrow: SireError::invalid_state\n" ); } { //::SireMM::LJPerturbation::B_MappingFunction typedef ::SireCAS::Expression const & ( ::SireMM::LJPerturbation::*B_MappingFunction_function_type)( ) const; B_MappingFunction_function_type B_MappingFunction_function_value( &::SireMM::LJPerturbation::B_MappingFunction ); LJPerturbation_exposer.def( "B_MappingFunction" , B_MappingFunction_function_value , bp::return_value_policy< bp::copy_const_reference >() , "Return the function used to map B\nThrow: SireError::invalid_state\n" ); } { //::SireMM::LJPerturbation::epsilonMappingFunction typedef ::SireCAS::Expression const & ( ::SireMM::LJPerturbation::*epsilonMappingFunction_function_type)( ) const; epsilonMappingFunction_function_type epsilonMappingFunction_function_value( &::SireMM::LJPerturbation::epsilonMappingFunction ); LJPerturbation_exposer.def( "epsilonMappingFunction" , epsilonMappingFunction_function_value , bp::return_value_policy< bp::copy_const_reference >() , "Return the function used to map epsilon\nThrow: SireError::invalid_state\n" ); } { //::SireMM::LJPerturbation::mapAB typedef bool ( ::SireMM::LJPerturbation::*mapAB_function_type)( ) const; mapAB_function_type mapAB_function_value( &::SireMM::LJPerturbation::mapAB ); LJPerturbation_exposer.def( "mapAB" , mapAB_function_value , "Return whether or not this maps A and B" ); } { //::SireMM::LJPerturbation::mapRMinEpsilon typedef bool ( ::SireMM::LJPerturbation::*mapRMinEpsilon_function_type)( ) const; mapRMinEpsilon_function_type mapRMinEpsilon_function_value( &::SireMM::LJPerturbation::mapRMinEpsilon ); LJPerturbation_exposer.def( "mapRMinEpsilon" , mapRMinEpsilon_function_value , "Return whether or not this maps r_min and epsilon" ); } { //::SireMM::LJPerturbation::mapSigmaEpsilon typedef bool ( ::SireMM::LJPerturbation::*mapSigmaEpsilon_function_type)( ) const; mapSigmaEpsilon_function_type mapSigmaEpsilon_function_value( &::SireMM::LJPerturbation::mapSigmaEpsilon ); LJPerturbation_exposer.def( "mapSigmaEpsilon" , mapSigmaEpsilon_function_value , "Return whether or not this maps sigma and epsilon" ); } { //::SireMM::LJPerturbation::mappingFunction typedef ::SireCAS::Expression const & ( ::SireMM::LJPerturbation::*mappingFunction_function_type)( ) const; mappingFunction_function_type mappingFunction_function_value( &::SireMM::LJPerturbation::mappingFunction ); LJPerturbation_exposer.def( "mappingFunction" , mappingFunction_function_value , bp::return_value_policy< bp::copy_const_reference >() , "Return the mapping function\nThrow: SireError::invalid_state\n" ); } LJPerturbation_exposer.def( bp::self != bp::self ); { //::SireMM::LJPerturbation::operator= typedef ::SireMM::LJPerturbation & ( ::SireMM::LJPerturbation::*assign_function_type)( ::SireMM::LJPerturbation const & ) ; assign_function_type assign_function_value( &::SireMM::LJPerturbation::operator= ); LJPerturbation_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() , "" ); } LJPerturbation_exposer.def( bp::self == bp::self ); { //::SireMM::LJPerturbation::rMinMappingFunction typedef ::SireCAS::Expression const & ( ::SireMM::LJPerturbation::*rMinMappingFunction_function_type)( ) const; rMinMappingFunction_function_type rMinMappingFunction_function_value( &::SireMM::LJPerturbation::rMinMappingFunction ); LJPerturbation_exposer.def( "rMinMappingFunction" , rMinMappingFunction_function_value , bp::return_value_policy< bp::copy_const_reference >() , "Return the function used to map r_min\nThrow: SireError::invalid_state\n" ); } { //::SireMM::LJPerturbation::recreate typedef ::SireMol::PerturbationPtr ( ::SireMM::LJPerturbation::*recreate_function_type)( ::SireCAS::Expression const & ) const; recreate_function_type recreate_function_value( &::SireMM::LJPerturbation::recreate ); LJPerturbation_exposer.def( "recreate" , recreate_function_value , ( bp::arg("mapping_function") ) , "" ); } { //::SireMM::LJPerturbation::recreate typedef ::SireMol::PerturbationPtr ( ::SireMM::LJPerturbation::*recreate_function_type)( ::SireCAS::Expression const &,::SireBase::PropertyMap const & ) const; recreate_function_type recreate_function_value( &::SireMM::LJPerturbation::recreate ); LJPerturbation_exposer.def( "recreate" , recreate_function_value , ( bp::arg("mapping_function"), bp::arg("map") ) , "" ); } { //::SireMM::LJPerturbation::requiredProperties typedef ::QSet< QString > ( ::SireMM::LJPerturbation::*requiredProperties_function_type)( ) const; requiredProperties_function_type requiredProperties_function_value( &::SireMM::LJPerturbation::requiredProperties ); LJPerturbation_exposer.def( "requiredProperties" , requiredProperties_function_value , "Return the properties required or changed by this perturbation" ); } { //::SireMM::LJPerturbation::sigmaMappingFunction typedef ::SireCAS::Expression const & ( ::SireMM::LJPerturbation::*sigmaMappingFunction_function_type)( ) const; sigmaMappingFunction_function_type sigmaMappingFunction_function_value( &::SireMM::LJPerturbation::sigmaMappingFunction ); LJPerturbation_exposer.def( "sigmaMappingFunction" , sigmaMappingFunction_function_value , bp::return_value_policy< bp::copy_const_reference >() , "Return the function used to map sigma\nThrow: SireError::invalid_state\n" ); } { //::SireMM::LJPerturbation::substitute typedef ::SireMol::PerturbationPtr ( ::SireMM::LJPerturbation::*substitute_function_type)( ::SireCAS::Identities const & ) const; substitute_function_type substitute_function_value( &::SireMM::LJPerturbation::substitute ); LJPerturbation_exposer.def( "substitute" , substitute_function_value , ( bp::arg("identities") ) , "Substitute the identities in identities in all of the mapping functions\nused by this perturbation. This is useful if, for example, you want to\nswitch from using lambda to control the perturbation to using alpha, e.g.\n" ); } { //::SireMM::LJPerturbation::toString typedef ::QString ( ::SireMM::LJPerturbation::*toString_function_type)( ) const; toString_function_type toString_function_value( &::SireMM::LJPerturbation::toString ); LJPerturbation_exposer.def( "toString" , toString_function_value , "Return a string representation of this perturbation" ); } { //::SireMM::LJPerturbation::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireMM::LJPerturbation::typeName ); LJPerturbation_exposer.def( "typeName" , typeName_function_value , "" ); } { //::SireMM::LJPerturbation::wouldChange typedef bool ( ::SireMM::LJPerturbation::*wouldChange_function_type)( ::SireMol::Molecule const &,::SireCAS::Values const & ) const; wouldChange_function_type wouldChange_function_value( &::SireMM::LJPerturbation::wouldChange ); LJPerturbation_exposer.def( "wouldChange" , wouldChange_function_value , ( bp::arg("molecule"), bp::arg("values") ) , "Return whether or not this perturbation with the passed values would\nchange the molecule molecule" ); } LJPerturbation_exposer.staticmethod( "typeName" ); LJPerturbation_exposer.def( "__copy__", &__copy__); LJPerturbation_exposer.def( "__deepcopy__", &__copy__); LJPerturbation_exposer.def( "clone", &__copy__); LJPerturbation_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::LJPerturbation >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); LJPerturbation_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::LJPerturbation >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); LJPerturbation_exposer.def( "__str__", &__str__< ::SireMM::LJPerturbation > ); LJPerturbation_exposer.def( "__repr__", &__str__< ::SireMM::LJPerturbation > ); } }
void register_MultiVector_class(){ { //::SireMaths::MultiVector typedef bp::class_< SireMaths::MultiVector > MultiVector_exposer_t; MultiVector_exposer_t MultiVector_exposer = MultiVector_exposer_t( "MultiVector", "\nThis is a vectorised version of Vector, e.g. x, y, and z\nare held as MultiDouble objects, meaning that this is a\npacked vector of vectors\n\nAuthor: Christopher Woods\n", bp::init< >("") ); bp::scope MultiVector_scope( MultiVector_exposer ); MultiVector_exposer.def( bp::init< SireMaths::MultiDouble const & >(( bp::arg("value") ), "Copy constructor") ); MultiVector_exposer.def( bp::init< SireMaths::MultiDouble const &, SireMaths::MultiDouble const &, SireMaths::MultiDouble const & >(( bp::arg("x"), bp::arg("y"), bp::arg("z") ), "") ); MultiVector_exposer.def( bp::init< SireMaths::Vector const *, int >(( bp::arg("array"), bp::arg("size") ), "Construct from an array of Vectors. This array cannot be greater\nthan MultiDouble::size()") ); MultiVector_exposer.def( bp::init< QVector< SireMaths::Vector > const & >(( bp::arg("array") ), "Construct from an array of Vectors. This array cannot be greater\nthan MultiDouble::size()") ); MultiVector_exposer.def( bp::init< SireMaths::MultiVector const & >(( bp::arg("other") ), "Copy constructor") ); { //::SireMaths::MultiVector::angle typedef ::SireMaths::MultiDouble ( *angle_function_type )( ::SireMaths::MultiVector const &,::SireMaths::MultiVector const & ); angle_function_type angle_function_value( &::SireMaths::MultiVector::angle ); MultiVector_exposer.def( "angle" , angle_function_value , ( bp::arg("v0"), bp::arg("v1") ) , "Return the angle between vectors v0 and v1 - this is the smallest\nangle, and will always lie between 0 and 180 degrees" ); } { //::SireMaths::MultiVector::angle typedef ::SireMaths::MultiDouble ( *angle_function_type )( ::SireMaths::MultiVector const &,::SireMaths::MultiVector const &,::SireMaths::MultiVector const & ); angle_function_type angle_function_value( &::SireMaths::MultiVector::angle ); MultiVector_exposer.def( "angle" , angle_function_value , ( bp::arg("v0"), bp::arg("v1"), bp::arg("v2") ) , "Return the angle between v0-v1-v2 (treating the vectors as points in space)" ); } { //::SireMaths::MultiVector::at typedef ::SireMaths::Vector ( ::SireMaths::MultiVector::*at_function_type)( int ) const; at_function_type at_function_value( &::SireMaths::MultiVector::at ); MultiVector_exposer.def( "at" , at_function_value , ( bp::arg("i") ) , "Access the ith vector in the MultiVector" ); } { //::SireMaths::MultiVector::b typedef ::SireMaths::MultiDouble ( ::SireMaths::MultiVector::*b_function_type)( ) const; b_function_type b_function_value( &::SireMaths::MultiVector::b ); MultiVector_exposer.def( "b" , b_function_value , "Return the components via rgb (limited between 0 and 1)" ); } { //::SireMaths::MultiVector::bearing typedef ::SireMaths::MultiDouble ( ::SireMaths::MultiVector::*bearing_function_type)( ) const; bearing_function_type bearing_function_value( &::SireMaths::MultiVector::bearing ); MultiVector_exposer.def( "bearing" , bearing_function_value , "Return the bearing of this vector against (0,1,0) (north) on the xy plane" ); } { //::SireMaths::MultiVector::bearingXY typedef ::SireMaths::MultiDouble ( ::SireMaths::MultiVector::*bearingXY_function_type)( ::SireMaths::MultiVector const & ) const; bearingXY_function_type bearingXY_function_value( &::SireMaths::MultiVector::bearingXY ); MultiVector_exposer.def( "bearingXY" , bearingXY_function_value , ( bp::arg("v") ) , "Return the bearing of this vector against v on the xy plane" ); } { //::SireMaths::MultiVector::bearingXZ typedef ::SireMaths::MultiDouble ( ::SireMaths::MultiVector::*bearingXZ_function_type)( ::SireMaths::MultiVector const & ) const; bearingXZ_function_type bearingXZ_function_value( &::SireMaths::MultiVector::bearingXZ ); MultiVector_exposer.def( "bearingXZ" , bearingXZ_function_value , ( bp::arg("v") ) , "Return the bearing of this vector against v on the xz plane" ); } { //::SireMaths::MultiVector::bearingYZ typedef ::SireMaths::MultiDouble ( ::SireMaths::MultiVector::*bearingYZ_function_type)( ::SireMaths::MultiVector const & ) const; bearingYZ_function_type bearingYZ_function_value( &::SireMaths::MultiVector::bearingYZ ); MultiVector_exposer.def( "bearingYZ" , bearingYZ_function_value , ( bp::arg("v") ) , "Return the bearing of this vector against v on the yz plane" ); } { //::SireMaths::MultiVector::count typedef int ( *count_function_type )( ); count_function_type count_function_value( &::SireMaths::MultiVector::count ); MultiVector_exposer.def( "count" , count_function_value , "Return the number of vectors in this MultiVector" ); } { //::SireMaths::MultiVector::cross typedef ::SireMaths::MultiVector ( *cross_function_type )( ::SireMaths::MultiVector const &,::SireMaths::MultiVector const & ); cross_function_type cross_function_value( &::SireMaths::MultiVector::cross ); MultiVector_exposer.def( "cross" , cross_function_value , ( bp::arg("v0"), bp::arg("v1") ) , "Return the cross product of v0 and v1" ); } { //::SireMaths::MultiVector::dihedral typedef ::SireMaths::MultiDouble ( *dihedral_function_type )( ::SireMaths::MultiVector const &,::SireMaths::MultiVector const &,::SireMaths::MultiVector const &,::SireMaths::MultiVector const & ); dihedral_function_type dihedral_function_value( &::SireMaths::MultiVector::dihedral ); MultiVector_exposer.def( "dihedral" , dihedral_function_value , ( bp::arg("v0"), bp::arg("v1"), bp::arg("v2"), bp::arg("v3") ) , "Return the dihedral angle between v0-v1-v2-v3 (treating the vectors as points)" ); } { //::SireMaths::MultiVector::direction typedef ::SireMaths::MultiVector ( ::SireMaths::MultiVector::*direction_function_type)( ) const; direction_function_type direction_function_value( &::SireMaths::MultiVector::direction ); MultiVector_exposer.def( "direction" , direction_function_value , "Return the unit vector pointing in the direction of this vector" ); } { //::SireMaths::MultiVector::distance typedef ::SireMaths::MultiDouble ( *distance_function_type )( ::SireMaths::MultiVector const &,::SireMaths::MultiVector const & ); distance_function_type distance_function_value( &::SireMaths::MultiVector::distance ); MultiVector_exposer.def( "distance" , distance_function_value , ( bp::arg("v1"), bp::arg("v2") ) , "Return the distance between two vectors" ); } { //::SireMaths::MultiVector::distance2 typedef ::SireMaths::MultiDouble ( *distance2_function_type )( ::SireMaths::MultiVector const &,::SireMaths::MultiVector const & ); distance2_function_type distance2_function_value( &::SireMaths::MultiVector::distance2 ); MultiVector_exposer.def( "distance2" , distance2_function_value , ( bp::arg("v1"), bp::arg("v2") ) , "Return the distance squared between two vectors" ); } { //::SireMaths::MultiVector::dot typedef ::SireMaths::MultiDouble ( *dot_function_type )( ::SireMaths::MultiVector const &,::SireMaths::MultiVector const & ); dot_function_type dot_function_value( &::SireMaths::MultiVector::dot ); MultiVector_exposer.def( "dot" , dot_function_value , ( bp::arg("v0"), bp::arg("v1") ) , "Return the dot product of v0 and v1" ); } { //::SireMaths::MultiVector::fromArray typedef ::QVector< SireMaths::MultiVector > ( *fromArray_function_type )( ::SireMaths::Vector const *,int ); fromArray_function_type fromArray_function_value( &::SireMaths::MultiVector::fromArray ); MultiVector_exposer.def( "fromArray" , fromArray_function_value , ( bp::arg("array"), bp::arg("size") ) , "Convert the passed array of vectors into an array of MultiVectors" ); } { //::SireMaths::MultiVector::fromArray typedef ::QVector< SireMaths::MultiVector > ( *fromArray_function_type )( ::QVector< SireMaths::Vector > const & ); fromArray_function_type fromArray_function_value( &::SireMaths::MultiVector::fromArray ); MultiVector_exposer.def( "fromArray" , fromArray_function_value , ( bp::arg("array") ) , "Convert the passed array of vectors into an array of MultiVectors" ); } { //::SireMaths::MultiVector::g typedef ::SireMaths::MultiDouble ( ::SireMaths::MultiVector::*g_function_type)( ) const; g_function_type g_function_value( &::SireMaths::MultiVector::g ); MultiVector_exposer.def( "g" , g_function_value , "Return the components via rgb (limited between 0 and 1)" ); } { //::SireMaths::MultiVector::generate typedef ::SireMaths::MultiVector ( *generate_function_type )( ::SireMaths::MultiDouble const &,::SireMaths::MultiVector const &,::SireMaths::MultiDouble const &,::SireMaths::MultiVector const &,::SireMaths::MultiDouble const &,::SireMaths::MultiVector const & ); generate_function_type generate_function_value( &::SireMaths::MultiVector::generate ); MultiVector_exposer.def( "generate" , generate_function_value , ( bp::arg("dst"), bp::arg("v1"), bp::arg("ang"), bp::arg("v2"), bp::arg("dih"), bp::arg("v3") ) , "Generate a vector, v0, that has distance dst v0-v1, angle ang v0-v1-v2,\nand dihedral dih v0-v1-v2-v3" ); } { //::SireMaths::MultiVector::getitem typedef ::SireMaths::Vector ( ::SireMaths::MultiVector::*getitem_function_type)( int ) const; getitem_function_type getitem_function_value( &::SireMaths::MultiVector::getitem ); MultiVector_exposer.def( "getitem" , getitem_function_value , ( bp::arg("i") ) , "Access the ith vector in the MultiVector" ); } { //::SireMaths::MultiVector::invDistance typedef ::SireMaths::MultiDouble ( *invDistance_function_type )( ::SireMaths::MultiVector const &,::SireMaths::MultiVector const & ); invDistance_function_type invDistance_function_value( &::SireMaths::MultiVector::invDistance ); MultiVector_exposer.def( "invDistance" , invDistance_function_value , ( bp::arg("v1"), bp::arg("v2") ) , "Return the 1 distance between two vectors" ); } { //::SireMaths::MultiVector::invDistance2 typedef ::SireMaths::MultiDouble ( *invDistance2_function_type )( ::SireMaths::MultiVector const &,::SireMaths::MultiVector const & ); invDistance2_function_type invDistance2_function_value( &::SireMaths::MultiVector::invDistance2 ); MultiVector_exposer.def( "invDistance2" , invDistance2_function_value , ( bp::arg("v1"), bp::arg("v2") ) , "Return 1 distance2 between two vectors" ); } { //::SireMaths::MultiVector::invLength typedef ::SireMaths::MultiDouble ( ::SireMaths::MultiVector::*invLength_function_type)( ) const; invLength_function_type invLength_function_value( &::SireMaths::MultiVector::invLength ); MultiVector_exposer.def( "invLength" , invLength_function_value , "" ); } { //::SireMaths::MultiVector::invLength2 typedef ::SireMaths::MultiDouble ( ::SireMaths::MultiVector::*invLength2_function_type)( ) const; invLength2_function_type invLength2_function_value( &::SireMaths::MultiVector::invLength2 ); MultiVector_exposer.def( "invLength2" , invLength2_function_value , "Return the inverse length squared" ); } { //::SireMaths::MultiVector::length typedef ::SireMaths::MultiDouble ( ::SireMaths::MultiVector::*length_function_type)( ) const; length_function_type length_function_value( &::SireMaths::MultiVector::length ); MultiVector_exposer.def( "length" , length_function_value , "" ); } { //::SireMaths::MultiVector::length2 typedef ::SireMaths::MultiDouble ( ::SireMaths::MultiVector::*length2_function_type)( ) const; length2_function_type length2_function_value( &::SireMaths::MultiVector::length2 ); MultiVector_exposer.def( "length2" , length2_function_value , "" ); } { //::SireMaths::MultiVector::magnitude typedef ::SireMaths::MultiDouble ( ::SireMaths::MultiVector::*magnitude_function_type)( ) const; magnitude_function_type magnitude_function_value( &::SireMaths::MultiVector::magnitude ); MultiVector_exposer.def( "magnitude" , magnitude_function_value , "Return the length of this vector" ); } { //::SireMaths::MultiVector::manhattanLength typedef ::SireMaths::MultiDouble ( ::SireMaths::MultiVector::*manhattanLength_function_type)( ) const; manhattanLength_function_type manhattanLength_function_value( &::SireMaths::MultiVector::manhattanLength ); MultiVector_exposer.def( "manhattanLength" , manhattanLength_function_value , "Return the manhattan length of the vector" ); } { //::SireMaths::MultiVector::max typedef ::SireMaths::MultiVector ( ::SireMaths::MultiVector::*max_function_type)( ::SireMaths::MultiVector const & ) const; max_function_type max_function_value( &::SireMaths::MultiVector::max ); MultiVector_exposer.def( "max" , max_function_value , ( bp::arg("other") ) , "Return a vector that has the maximum xyz components out of this\nand other" ); } { //::SireMaths::MultiVector::min typedef ::SireMaths::MultiVector ( ::SireMaths::MultiVector::*min_function_type)( ::SireMaths::MultiVector const & ) const; min_function_type min_function_value( &::SireMaths::MultiVector::min ); MultiVector_exposer.def( "min" , min_function_value , ( bp::arg("other") ) , "Return a vector that has the minimum components" ); } { //::SireMaths::MultiVector::normalise typedef ::SireMaths::MultiVector ( ::SireMaths::MultiVector::*normalise_function_type)( ) const; normalise_function_type normalise_function_value( &::SireMaths::MultiVector::normalise ); MultiVector_exposer.def( "normalise" , normalise_function_value , "Return a normalised form of the vector" ); } MultiVector_exposer.def( bp::self != bp::self ); MultiVector_exposer.def( -bp::self ); { //::SireMaths::MultiVector::operator= typedef ::SireMaths::MultiVector & ( ::SireMaths::MultiVector::*assign_function_type)( ::SireMaths::MultiVector const & ) ; assign_function_type assign_function_value( &::SireMaths::MultiVector::operator= ); MultiVector_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() , "" ); } MultiVector_exposer.def( bp::self == bp::self ); { //::SireMaths::MultiVector::operator[] typedef ::SireMaths::Vector ( ::SireMaths::MultiVector::*__getitem___function_type)( int ) const; __getitem___function_type __getitem___function_value( &::SireMaths::MultiVector::operator[] ); MultiVector_exposer.def( "__getitem__" , __getitem___function_value , ( bp::arg("i") ) , "" ); } { //::SireMaths::MultiVector::quickSet typedef void ( ::SireMaths::MultiVector::*quickSet_function_type)( int,::SireMaths::Vector const & ) ; quickSet_function_type quickSet_function_value( &::SireMaths::MultiVector::quickSet ); MultiVector_exposer.def( "quickSet" , quickSet_function_value , ( bp::arg("i"), bp::arg("val") ) , "Quickly set the values of the vector, without checking the index is valid" ); } { //::SireMaths::MultiVector::r typedef ::SireMaths::MultiDouble ( ::SireMaths::MultiVector::*r_function_type)( ) const; r_function_type r_function_value( &::SireMaths::MultiVector::r ); MultiVector_exposer.def( "r" , r_function_value , "Return the components via rgb (limited between 0 and 1)" ); } { //::SireMaths::MultiVector::set typedef void ( ::SireMaths::MultiVector::*set_function_type)( ::SireMaths::MultiDouble const &,::SireMaths::MultiDouble const &,::SireMaths::MultiDouble const & ) ; set_function_type set_function_value( &::SireMaths::MultiVector::set ); MultiVector_exposer.def( "set" , set_function_value , ( bp::arg("x"), bp::arg("y"), bp::arg("z") ) , "Set individual values of the vector" ); } { //::SireMaths::MultiVector::set typedef void ( ::SireMaths::MultiVector::*set_function_type)( int,::SireMaths::Vector const & ) ; set_function_type set_function_value( &::SireMaths::MultiVector::set ); MultiVector_exposer.def( "set" , set_function_value , ( bp::arg("i"), bp::arg("val") ) , "Set individual values of the vector" ); } { //::SireMaths::MultiVector::setB typedef void ( ::SireMaths::MultiVector::*setB_function_type)( ::SireMaths::MultiDouble const & ) ; setB_function_type setB_function_value( &::SireMaths::MultiVector::setB ); MultiVector_exposer.def( "setB" , setB_function_value , ( bp::arg("val") ) , "Set individual values of the vector" ); } { //::SireMaths::MultiVector::setG typedef void ( ::SireMaths::MultiVector::*setG_function_type)( ::SireMaths::MultiDouble const & ) ; setG_function_type setG_function_value( &::SireMaths::MultiVector::setG ); MultiVector_exposer.def( "setG" , setG_function_value , ( bp::arg("val") ) , "Set individual values of the vector" ); } { //::SireMaths::MultiVector::setMax typedef void ( ::SireMaths::MultiVector::*setMax_function_type)( ::SireMaths::MultiVector const & ) ; setMax_function_type setMax_function_value( &::SireMaths::MultiVector::setMax ); MultiVector_exposer.def( "setMax" , setMax_function_value , ( bp::arg("other") ) , "Set this Vector so that it has the maximum xyz components out of\nthis and other (e.g. this->x = max(this->x(),other.x() etc.)" ); } { //::SireMaths::MultiVector::setMin typedef void ( ::SireMaths::MultiVector::*setMin_function_type)( ::SireMaths::MultiVector const & ) ; setMin_function_type setMin_function_value( &::SireMaths::MultiVector::setMin ); MultiVector_exposer.def( "setMin" , setMin_function_value , ( bp::arg("other") ) , "Set this Vector so that it has the minimum xyz components" ); } { //::SireMaths::MultiVector::setR typedef void ( ::SireMaths::MultiVector::*setR_function_type)( ::SireMaths::MultiDouble const & ) ; setR_function_type setR_function_value( &::SireMaths::MultiVector::setR ); MultiVector_exposer.def( "setR" , setR_function_value , ( bp::arg("val") ) , "Set individual values of the vector" ); } { //::SireMaths::MultiVector::setX typedef void ( ::SireMaths::MultiVector::*setX_function_type)( ::SireMaths::MultiDouble const & ) ; setX_function_type setX_function_value( &::SireMaths::MultiVector::setX ); MultiVector_exposer.def( "setX" , setX_function_value , ( bp::arg("val") ) , "Set individual values of the vector" ); } { //::SireMaths::MultiVector::setY typedef void ( ::SireMaths::MultiVector::*setY_function_type)( ::SireMaths::MultiDouble const & ) ; setY_function_type setY_function_value( &::SireMaths::MultiVector::setY ); MultiVector_exposer.def( "setY" , setY_function_value , ( bp::arg("val") ) , "Set individual values of the vector" ); } { //::SireMaths::MultiVector::setZ typedef void ( ::SireMaths::MultiVector::*setZ_function_type)( ::SireMaths::MultiDouble const & ) ; setZ_function_type setZ_function_value( &::SireMaths::MultiVector::setZ ); MultiVector_exposer.def( "setZ" , setZ_function_value , ( bp::arg("val") ) , "Set individual values of the vector" ); } { //::SireMaths::MultiVector::size typedef int ( *size_function_type )( ); size_function_type size_function_value( &::SireMaths::MultiVector::size ); MultiVector_exposer.def( "size" , size_function_value , "Return the number of vectors in this MultiVector" ); } { //::SireMaths::MultiVector::swap typedef void ( *swap_function_type )( ::SireMaths::MultiVector &,int,::SireMaths::MultiVector &,int ); swap_function_type swap_function_value( &::SireMaths::MultiVector::swap ); 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 typedef ::SireMaths::MultiDouble const & ( ::SireMaths::MultiVector::*z_function_type)( ) const; z_function_type z_function_value( &::SireMaths::MultiVector::z ); MultiVector_exposer.def( "z" , z_function_value , bp::return_value_policy< bp::copy_const_reference >() , "" ); } MultiVector_exposer.staticmethod( "angle" ); MultiVector_exposer.staticmethod( "count" ); MultiVector_exposer.staticmethod( "cross" ); MultiVector_exposer.staticmethod( "dihedral" ); MultiVector_exposer.staticmethod( "distance" ); MultiVector_exposer.staticmethod( "distance2" ); MultiVector_exposer.staticmethod( "dot" ); MultiVector_exposer.staticmethod( "fromArray" ); MultiVector_exposer.staticmethod( "generate" ); MultiVector_exposer.staticmethod( "invDistance" ); MultiVector_exposer.staticmethod( "invDistance2" ); MultiVector_exposer.staticmethod( "size" ); MultiVector_exposer.staticmethod( "swap" ); MultiVector_exposer.staticmethod( "typeName" ); MultiVector_exposer.def( bp::self * bp::other< SireMaths::MultiDouble >() ); MultiVector_exposer.def( bp::self * bp::other< SireMaths::MultiQuaternion >() ); MultiVector_exposer.def( bp::self + bp::self ); MultiVector_exposer.def( bp::self - bp::self ); MultiVector_exposer.def( bp::self / bp::other< SireMaths::MultiDouble >() ); MultiVector_exposer.def( "__copy__", &__copy__); MultiVector_exposer.def( "__deepcopy__", &__copy__); MultiVector_exposer.def( "clone", &__copy__); MultiVector_exposer.def( "__str__", &__str__< ::SireMaths::MultiVector > ); MultiVector_exposer.def( "__repr__", &__str__< ::SireMaths::MultiVector > ); MultiVector_exposer.def( "__len__", &__len_size< ::SireMaths::MultiVector > ); MultiVector_exposer.def( "__getitem__", &::SireMaths::MultiVector::getitem ); } }
void register_BoxPatching_class(){ { //::SireVol::BoxPatching typedef bp::class_< SireVol::BoxPatching, bp::bases< SireVol::Patching, SireBase::Property > > BoxPatching_exposer_t; BoxPatching_exposer_t BoxPatching_exposer = BoxPatching_exposer_t( "BoxPatching", bp::init< >() ); bp::scope BoxPatching_scope( BoxPatching_exposer ); BoxPatching_exposer.def( bp::init< SireVol::Space const & >(( bp::arg("space") )) ); BoxPatching_exposer.def( bp::init< SireVol::Space const &, SireMaths::Vector const & >(( bp::arg("space"), bp::arg("center") )) ); BoxPatching_exposer.def( bp::init< SireVol::Space const &, SireUnits::Dimension::Length >(( bp::arg("space"), bp::arg("patch_size") )) ); BoxPatching_exposer.def( bp::init< SireVol::Space const &, SireUnits::Dimension::Length, SireMaths::Vector const & >(( bp::arg("space"), bp::arg("patch_size"), bp::arg("center") )) ); BoxPatching_exposer.def( bp::init< SireVol::BoxPatching const & >(( bp::arg("other") )) ); { //::SireVol::BoxPatching::center typedef ::SireMaths::Vector ( ::SireVol::BoxPatching::*center_function_type )( ) const; center_function_type center_function_value( &::SireVol::BoxPatching::center ); BoxPatching_exposer.def( "center" , center_function_value ); } { //::SireVol::BoxPatching::nPatches typedef int ( ::SireVol::BoxPatching::*nPatches_function_type )( ) const; nPatches_function_type nPatches_function_value( &::SireVol::BoxPatching::nPatches ); BoxPatching_exposer.def( "nPatches" , nPatches_function_value ); } BoxPatching_exposer.def( bp::self != bp::self ); { //::SireVol::BoxPatching::operator= typedef ::SireVol::BoxPatching & ( ::SireVol::BoxPatching::*assign_function_type )( ::SireVol::BoxPatching const & ) ; assign_function_type assign_function_value( &::SireVol::BoxPatching::operator= ); BoxPatching_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() ); } BoxPatching_exposer.def( bp::self == bp::self ); { //::SireVol::BoxPatching::patchBox typedef ::SireVol::AABox ( ::SireVol::BoxPatching::*patchBox_function_type )( int ) const; patchBox_function_type patchBox_function_value( &::SireVol::BoxPatching::patchBox ); BoxPatching_exposer.def( "patchBox" , patchBox_function_value , ( bp::arg("i") ) ); } { //::SireVol::BoxPatching::patchBox typedef ::SireVol::AABox ( ::SireVol::BoxPatching::*patchBox_function_type )( ::SireMaths::Vector const & ) const; patchBox_function_type patchBox_function_value( &::SireVol::BoxPatching::patchBox ); BoxPatching_exposer.def( "patchBox" , patchBox_function_value , ( bp::arg("point") ) ); } { //::SireVol::BoxPatching::patchDimension typedef ::SireMaths::Vector ( ::SireVol::BoxPatching::*patchDimension_function_type )( ) const; patchDimension_function_type patchDimension_function_value( &::SireVol::BoxPatching::patchDimension ); BoxPatching_exposer.def( "patchDimension" , patchDimension_function_value ); } { //::SireVol::BoxPatching::patchIndex typedef int ( ::SireVol::BoxPatching::*patchIndex_function_type )( ::SireMaths::Vector const & ) const; patchIndex_function_type patchIndex_function_value( &::SireVol::BoxPatching::patchIndex ); BoxPatching_exposer.def( "patchIndex" , patchIndex_function_value , ( bp::arg("point") ) ); } { //::SireVol::BoxPatching::patchIndexAndCenter typedef ::QPair< int, SireMaths::Vector > ( ::SireVol::BoxPatching::*patchIndexAndCenter_function_type )( ::SireMaths::Vector const & ) const; patchIndexAndCenter_function_type patchIndexAndCenter_function_value( &::SireVol::BoxPatching::patchIndexAndCenter ); BoxPatching_exposer.def( "patchIndexAndCenter" , patchIndexAndCenter_function_value , ( bp::arg("point") ) ); } { //::SireVol::BoxPatching::patchSize typedef ::SireUnits::Dimension::Length ( ::SireVol::BoxPatching::*patchSize_function_type )( ) const; patchSize_function_type patchSize_function_value( &::SireVol::BoxPatching::patchSize ); BoxPatching_exposer.def( "patchSize" , patchSize_function_value ); } { //::SireVol::BoxPatching::repatch typedef ::SireVol::PatchingPtr ( ::SireVol::BoxPatching::*repatch_function_type )( ::SireVol::Space const & ) const; repatch_function_type repatch_function_value( &::SireVol::BoxPatching::repatch ); BoxPatching_exposer.def( "repatch" , repatch_function_value , ( bp::arg("new_space") ) ); } { //::SireVol::BoxPatching::toString typedef ::QString ( ::SireVol::BoxPatching::*toString_function_type )( ) const; toString_function_type toString_function_value( &::SireVol::BoxPatching::toString ); BoxPatching_exposer.def( "toString" , toString_function_value ); } { //::SireVol::BoxPatching::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireVol::BoxPatching::typeName ); BoxPatching_exposer.def( "typeName" , typeName_function_value ); } BoxPatching_exposer.staticmethod( "typeName" ); BoxPatching_exposer.def( "__copy__", &__copy__); BoxPatching_exposer.def( "__deepcopy__", &__copy__); BoxPatching_exposer.def( "clone", &__copy__); BoxPatching_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireVol::BoxPatching >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); BoxPatching_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireVol::BoxPatching >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); BoxPatching_exposer.def( "__str__", &__str__< ::SireVol::BoxPatching > ); BoxPatching_exposer.def( "__repr__", &__str__< ::SireVol::BoxPatching > ); } }