void register_Number_class(){
{ //::SireID::Number
typedef bp::class_< SireID::Number, boost::noncopyable > Number_exposer_t;
Number_exposer_t Number_exposer = Number_exposer_t( "Number", bp::no_init );
bp::scope Number_scope( Number_exposer );
{ //::SireID::Number::hash
typedef ::uint ( ::SireID::Number::*hash_function_type )( ) const;
hash_function_type hash_function_value( &::SireID::Number::hash );
Number_exposer.def(
"hash"
, hash_function_value );
}
{ //::SireID::Number::isNull
typedef bool ( ::SireID::Number::*isNull_function_type )( ) const;
isNull_function_type isNull_function_value( &::SireID::Number::isNull );
Number_exposer.def(
"isNull"
, isNull_function_value );
}
{ //::SireID::Number::null
typedef ::qint32 ( *null_function_type )( );
null_function_type null_function_value( &::SireID::Number::null );
Number_exposer.def(
"null"
, null_function_value );
}
{ //::SireID::Number::value
typedef ::qint32 ( ::SireID::Number::*value_function_type )( ) const;
value_function_type value_function_value( &::SireID::Number::value );
Number_exposer.def(
"value"
, value_function_value );
}
Number_exposer.staticmethod( "null" );
Number_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireID::Number >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Number_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireID::Number >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Number_exposer.def( "__str__", &pvt_get_name);
Number_exposer.def( "__repr__", &pvt_get_name);
}
}
void register_FFIdx_class(){
{ //::SireFF::FFIdx
typedef bp::class_< SireFF::FFIdx, bp::bases< SireFF::FFID, SireID::ID, SireID::IndexBase > > FFIdx_exposer_t;
FFIdx_exposer_t FFIdx_exposer = FFIdx_exposer_t( "FFIdx", "This is an ID object that is used to index forcefields (e.g. index\nin a list or array).\n\nAuthor: Christopher Woods\n", bp::init< >("") );
bp::scope FFIdx_scope( FFIdx_exposer );
FFIdx_exposer.def( bp::init< qint32 >(( bp::arg("idx") ), "") );
FFIdx_exposer.def( bp::init< SireFF::FFIdx const & >(( bp::arg("other") ), "") );
{ //::SireFF::FFIdx::hash
typedef ::uint ( ::SireFF::FFIdx::*hash_function_type)( ) const;
hash_function_type hash_function_value( &::SireFF::FFIdx::hash );
FFIdx_exposer.def(
"hash"
, hash_function_value
, "" );
}
{ //::SireFF::FFIdx::isNull
typedef bool ( ::SireFF::FFIdx::*isNull_function_type)( ) const;
isNull_function_type isNull_function_value( &::SireFF::FFIdx::isNull );
FFIdx_exposer.def(
"isNull"
, isNull_function_value
, "" );
}
{ //::SireFF::FFIdx::map
typedef ::QList< SireFF::FFIdx > ( ::SireFF::FFIdx::*map_function_type)( ::SireFF::ForceFields const & ) const;
map_function_type map_function_value( &::SireFF::FFIdx::map );
FFIdx_exposer.def(
"map"
, map_function_value
, ( bp::arg("ffields") )
, "Short cut function to map this index to the index of the\nmatching forcefield in the passed ForceFields object\nThrow: SireError::invalid_index\n" );
}
{ //::SireFF::FFIdx::null
typedef ::SireFF::FFIdx ( *null_function_type )( );
null_function_type null_function_value( &::SireFF::FFIdx::null );
FFIdx_exposer.def(
"null"
, null_function_value
, "" );
}
{ //::SireFF::FFIdx::operator=
typedef ::SireFF::FFIdx & ( ::SireFF::FFIdx::*assign_function_type)( ::SireFF::FFIdx const & ) ;
assign_function_type assign_function_value( &::SireFF::FFIdx::operator= );
FFIdx_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >()
, "" );
}
{ //::SireFF::FFIdx::toString
typedef ::QString ( ::SireFF::FFIdx::*toString_function_type)( ) const;
toString_function_type toString_function_value( &::SireFF::FFIdx::toString );
FFIdx_exposer.def(
"toString"
, toString_function_value
, "" );
}
{ //::SireFF::FFIdx::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireFF::FFIdx::typeName );
FFIdx_exposer.def(
"typeName"
, typeName_function_value
, "" );
}
{ //::SireFF::FFIdx::what
typedef char const * ( ::SireFF::FFIdx::*what_function_type)( ) const;
what_function_type what_function_value( &::SireFF::FFIdx::what );
FFIdx_exposer.def(
"what"
, what_function_value
, "" );
}
FFIdx_exposer.staticmethod( "null" );
FFIdx_exposer.staticmethod( "typeName" );
FFIdx_exposer.def( "__copy__", &__copy__);
FFIdx_exposer.def( "__deepcopy__", &__copy__);
FFIdx_exposer.def( "clone", &__copy__);
FFIdx_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireFF::FFIdx >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
FFIdx_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireFF::FFIdx >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
FFIdx_exposer.def( "__str__", &__str__< ::SireFF::FFIdx > );
FFIdx_exposer.def( "__repr__", &__str__< ::SireFF::FFIdx > );
FFIdx_exposer.def( "__hash__", &::SireFF::FFIdx::hash );
}
}
void register_Conditional_class(){
{ //::SireCAS::Conditional
typedef bp::class_< SireCAS::Conditional, bp::bases< SireCAS::ExBase > > Conditional_exposer_t;
Conditional_exposer_t Conditional_exposer = Conditional_exposer_t( "Conditional", "This is a conditional expression. If the condition is true,\nthen true_expression is evaluated, else if the condition\nis false then false_expression is evaluate\n\nAuthor: Christopher Woods\n", bp::init< >("Null constructor") );
bp::scope Conditional_scope( Conditional_exposer );
Conditional_exposer.def( bp::init< SireCAS::Condition const &, SireCAS::Expression const &, SireCAS::Expression const & >(( bp::arg("condition"), bp::arg("true_expression"), bp::arg("false_expression") ), "Construct a conditional where if condition is true, then\ntrue_expression is evaluated, while if condition is false,\nthen false_expression is evaluated") );
Conditional_exposer.def( bp::init< SireCAS::Conditional const & >(( bp::arg("other") ), "Copy constructor") );
{ //::SireCAS::Conditional::children
typedef ::SireCAS::Expressions ( ::SireCAS::Conditional::*children_function_type)( ) const;
children_function_type children_function_value( &::SireCAS::Conditional::children );
Conditional_exposer.def(
"children"
, children_function_value
, "Return the children of this expression" );
}
{ //::SireCAS::Conditional::condition
typedef ::SireCAS::Condition const & ( ::SireCAS::Conditional::*condition_function_type)( ) const;
condition_function_type condition_function_value( &::SireCAS::Conditional::condition );
Conditional_exposer.def(
"condition"
, condition_function_value
, bp::return_value_policy<bp::clone_const_reference>()
, "Return the condition" );
}
{ //::SireCAS::Conditional::conjugate
typedef ::SireCAS::Expression ( ::SireCAS::Conditional::*conjugate_function_type)( ) const;
conjugate_function_type conjugate_function_value( &::SireCAS::Conditional::conjugate );
Conditional_exposer.def(
"conjugate"
, conjugate_function_value
, "Return the complex conjugate of this expression" );
}
{ //::SireCAS::Conditional::differentiate
typedef ::SireCAS::Expression ( ::SireCAS::Conditional::*differentiate_function_type)( ::SireCAS::Symbol const & ) const;
differentiate_function_type differentiate_function_value( &::SireCAS::Conditional::differentiate );
Conditional_exposer.def(
"differentiate"
, differentiate_function_value
, ( bp::arg("symbol") )
, "Return the differential of this expression" );
}
{ //::SireCAS::Conditional::evaluate
typedef double ( ::SireCAS::Conditional::*evaluate_function_type)( ::SireCAS::Values const & ) const;
evaluate_function_type evaluate_function_value( &::SireCAS::Conditional::evaluate );
Conditional_exposer.def(
"evaluate"
, evaluate_function_value
, ( bp::arg("values") )
, "Evaluate this expression for the passed values" );
}
{ //::SireCAS::Conditional::evaluate
typedef ::SireMaths::Complex ( ::SireCAS::Conditional::*evaluate_function_type)( ::SireCAS::ComplexValues const & ) const;
evaluate_function_type evaluate_function_value( &::SireCAS::Conditional::evaluate );
Conditional_exposer.def(
"evaluate"
, evaluate_function_value
, ( bp::arg("values") )
, "Evaluate this expresion for the passed values" );
}
{ //::SireCAS::Conditional::expand
typedef ::QList< SireCAS::Factor > ( ::SireCAS::Conditional::*expand_function_type)( ::SireCAS::Symbol const & ) const;
expand_function_type expand_function_value( &::SireCAS::Conditional::expand );
Conditional_exposer.def(
"expand"
, expand_function_value
, ( bp::arg("symbol") )
, "Expand this expression in terms of symbol" );
}
{ //::SireCAS::Conditional::falseExpression
typedef ::SireCAS::Expression const & ( ::SireCAS::Conditional::*falseExpression_function_type)( ) const;
falseExpression_function_type falseExpression_function_value( &::SireCAS::Conditional::falseExpression );
Conditional_exposer.def(
"falseExpression"
, falseExpression_function_value
, bp::return_value_policy< bp::copy_const_reference >()
, "Return the expression to be evaluated if the condition is false" );
}
{ //::SireCAS::Conditional::functions
typedef ::SireCAS::Functions ( ::SireCAS::Conditional::*functions_function_type)( ) const;
functions_function_type functions_function_value( &::SireCAS::Conditional::functions );
Conditional_exposer.def(
"functions"
, functions_function_value
, "Return the functions used in this expression" );
}
{ //::SireCAS::Conditional::hash
typedef ::uint ( ::SireCAS::Conditional::*hash_function_type)( ) const;
hash_function_type hash_function_value( &::SireCAS::Conditional::hash );
Conditional_exposer.def(
"hash"
, hash_function_value
, "Hash this conditional" );
}
{ //::SireCAS::Conditional::integrate
typedef ::SireCAS::Expression ( ::SireCAS::Conditional::*integrate_function_type)( ::SireCAS::Symbol const & ) const;
integrate_function_type integrate_function_value( &::SireCAS::Conditional::integrate );
Conditional_exposer.def(
"integrate"
, integrate_function_value
, ( bp::arg("symbol") )
, "Return the integral of this expression" );
}
{ //::SireCAS::Conditional::isComplex
typedef bool ( ::SireCAS::Conditional::*isComplex_function_type)( ) const;
isComplex_function_type isComplex_function_value( &::SireCAS::Conditional::isComplex );
Conditional_exposer.def(
"isComplex"
, isComplex_function_value
, "Is this a complex expression?" );
}
{ //::SireCAS::Conditional::isCompound
typedef bool ( ::SireCAS::Conditional::*isCompound_function_type)( ) const;
isCompound_function_type isCompound_function_value( &::SireCAS::Conditional::isCompound );
Conditional_exposer.def(
"isCompound"
, isCompound_function_value
, "Is this a compound expression?" );
}
{ //::SireCAS::Conditional::isConstant
typedef bool ( ::SireCAS::Conditional::*isConstant_function_type)( ) const;
isConstant_function_type isConstant_function_value( &::SireCAS::Conditional::isConstant );
Conditional_exposer.def(
"isConstant"
, isConstant_function_value
, "Return whether or not this is constant" );
}
{ //::SireCAS::Conditional::isFunction
typedef bool ( ::SireCAS::Conditional::*isFunction_function_type)( ::SireCAS::Symbol const & ) const;
isFunction_function_type isFunction_function_value( &::SireCAS::Conditional::isFunction );
Conditional_exposer.def(
"isFunction"
, isFunction_function_value
, ( bp::arg("arg0") )
, "Return whether or not this is a function of symbol" );
}
{ //::SireCAS::Conditional::isNull
typedef bool ( ::SireCAS::Conditional::*isNull_function_type)( ) const;
isNull_function_type isNull_function_value( &::SireCAS::Conditional::isNull );
Conditional_exposer.def(
"isNull"
, isNull_function_value
, "Return whether or not this is null" );
}
{ //::SireCAS::Conditional::operator=
typedef ::SireCAS::Conditional & ( ::SireCAS::Conditional::*assign_function_type)( ::SireCAS::Conditional const & ) ;
assign_function_type assign_function_value( &::SireCAS::Conditional::operator= );
Conditional_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >()
, "" );
}
Conditional_exposer.def( bp::self == bp::self );
Conditional_exposer.def( bp::self == bp::other< SireCAS::ExBase >() );
{ //::SireCAS::Conditional::series
typedef ::SireCAS::Expression ( ::SireCAS::Conditional::*series_function_type)( ::SireCAS::Symbol const &,int ) const;
series_function_type series_function_value( &::SireCAS::Conditional::series );
Conditional_exposer.def(
"series"
, series_function_value
, ( bp::arg("symbol"), bp::arg("n") )
, "Return the series expansion of this product with respect to symbol, to order n" );
}
{ //::SireCAS::Conditional::simplify
typedef ::SireCAS::Expression ( ::SireCAS::Conditional::*simplify_function_type)( int ) const;
simplify_function_type simplify_function_value( &::SireCAS::Conditional::simplify );
Conditional_exposer.def(
"simplify"
, simplify_function_value
, ( bp::arg("options")=(int)(0) )
, "Try to simplify this condition" );
}
{ //::SireCAS::Conditional::substitute
typedef ::SireCAS::Expression ( ::SireCAS::Conditional::*substitute_function_type)( ::SireCAS::Identities const & ) const;
substitute_function_type substitute_function_value( &::SireCAS::Conditional::substitute );
Conditional_exposer.def(
"substitute"
, substitute_function_value
, ( bp::arg("identities") )
, "Substitute identities into this expression" );
}
{ //::SireCAS::Conditional::symbols
typedef ::SireCAS::Symbols ( ::SireCAS::Conditional::*symbols_function_type)( ) const;
symbols_function_type symbols_function_value( &::SireCAS::Conditional::symbols );
Conditional_exposer.def(
"symbols"
, symbols_function_value
, "Return the symbols used in this expression" );
}
{ //::SireCAS::Conditional::toString
typedef ::QString ( ::SireCAS::Conditional::*toString_function_type)( ) const;
toString_function_type toString_function_value( &::SireCAS::Conditional::toString );
Conditional_exposer.def(
"toString"
, toString_function_value
, "Return a string representation of this conditional" );
}
{ //::SireCAS::Conditional::trueExpression
typedef ::SireCAS::Expression const & ( ::SireCAS::Conditional::*trueExpression_function_type)( ) const;
trueExpression_function_type trueExpression_function_value( &::SireCAS::Conditional::trueExpression );
Conditional_exposer.def(
"trueExpression"
, trueExpression_function_value
, bp::return_value_policy< bp::copy_const_reference >()
, "Return the expression to be evaluated if the condition is true" );
}
{ //::SireCAS::Conditional::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireCAS::Conditional::typeName );
Conditional_exposer.def(
"typeName"
, typeName_function_value
, "" );
}
{ //::SireCAS::Conditional::what
typedef char const * ( ::SireCAS::Conditional::*what_function_type)( ) const;
what_function_type what_function_value( &::SireCAS::Conditional::what );
Conditional_exposer.def(
"what"
, what_function_value
, "" );
}
Conditional_exposer.staticmethod( "typeName" );
Conditional_exposer.def( "__copy__", &__copy__);
Conditional_exposer.def( "__deepcopy__", &__copy__);
Conditional_exposer.def( "clone", &__copy__);
Conditional_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireCAS::Conditional >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Conditional_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireCAS::Conditional >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Conditional_exposer.def( "__str__", &__str__< ::SireCAS::Conditional > );
Conditional_exposer.def( "__repr__", &__str__< ::SireCAS::Conditional > );
Conditional_exposer.def( "__hash__", &::SireCAS::Conditional::hash );
}
}
void register_ChainAtomID_class(){
{ //::SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >
typedef bp::class_< SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >, bp::bases< SireMol::GroupAtomIDBase, SireMol::AtomID, SireID::ID > > ChainAtomID_exposer_t;
ChainAtomID_exposer_t ChainAtomID_exposer = ChainAtomID_exposer_t( "ChainAtomID", "", bp::init< >("") );
bp::scope ChainAtomID_scope( ChainAtomID_exposer );
ChainAtomID_exposer.def( bp::init< SireMol::ChainID const &, SireMol::AtomID const & >(( bp::arg("group"), bp::arg("atom") ), "") );
ChainAtomID_exposer.def( bp::init< SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID > const & >(( bp::arg("other") ), "") );
{ //::SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >::hash
typedef SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID > exported_class_t;
typedef ::uint ( ::SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >::*hash_function_type)( ) const;
hash_function_type hash_function_value( &::SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >::hash );
ChainAtomID_exposer.def(
"hash"
, hash_function_value
, "" );
}
{ //::SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >::isNull
typedef SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID > exported_class_t;
typedef bool ( ::SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >::*isNull_function_type)( ) const;
isNull_function_type isNull_function_value( &::SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >::isNull );
ChainAtomID_exposer.def(
"isNull"
, isNull_function_value
, "" );
}
{ //::SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >::map
typedef SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID > exported_class_t;
typedef ::QList< SireMol::AtomIdx > ( ::SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >::*map_function_type)( ::SireMol::MolInfo const & ) const;
map_function_type map_function_value( &::SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >::map );
ChainAtomID_exposer.def(
"map"
, map_function_value
, ( bp::arg("molinfo") )
, "" );
}
ChainAtomID_exposer.def( bp::self != bp::self );
ChainAtomID_exposer.def( bp::self == bp::self );
ChainAtomID_exposer.def( bp::self == bp::other< SireID::ID >() );
{ //::SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >::toString
typedef SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID > exported_class_t;
typedef ::QString ( ::SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >::*toString_function_type)( ) const;
toString_function_type toString_function_value( &::SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >::toString );
ChainAtomID_exposer.def(
"toString"
, toString_function_value
, "" );
}
{ //::SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >::typeName
typedef SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID > exported_class_t;
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >::typeName );
ChainAtomID_exposer.def(
"typeName"
, typeName_function_value
, "" );
}
{ //::SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >::what
typedef SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID > exported_class_t;
typedef char const * ( ::SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >::*what_function_type)( ) const;
what_function_type what_function_value( &::SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >::what );
ChainAtomID_exposer.def(
"what"
, what_function_value
, "" );
}
ChainAtomID_exposer.staticmethod( "typeName" );
ChainAtomID_exposer.def( "__copy__", &__copy__);
ChainAtomID_exposer.def( "__deepcopy__", &__copy__);
ChainAtomID_exposer.def( "clone", &__copy__);
ChainAtomID_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::GroupAtomID<SireMol::ChainID, SireMol::AtomID> >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
ChainAtomID_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::GroupAtomID<SireMol::ChainID, SireMol::AtomID> >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
ChainAtomID_exposer.def( "__str__", &__str__< ::SireMol::GroupAtomID<SireMol::ChainID, SireMol::AtomID> > );
ChainAtomID_exposer.def( "__repr__", &__str__< ::SireMol::GroupAtomID<SireMol::ChainID, SireMol::AtomID> > );
ChainAtomID_exposer.def( "__hash__", &::SireMol::GroupAtomID<SireMol::ChainID, SireMol::AtomID>::hash );
}
}
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_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_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_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_Within_class(){
{ //::SireMol::Within
typedef bp::class_< SireMol::Within, bp::bases< SireMol::AtomID, SireID::ID > > Within_exposer_t;
Within_exposer_t Within_exposer = Within_exposer_t( "Within", bp::init< >() );
bp::scope Within_scope( Within_exposer );
Within_exposer.def( bp::init< SireUnits::Dimension::Length, SireMaths::Vector const & >(( bp::arg("distance"), bp::arg("point") )) );
Within_exposer.def( bp::init< SireUnits::Dimension::Length, SireMol::AtomID const & >(( bp::arg("distance"), bp::arg("atomid") )) );
Within_exposer.def( bp::init< SireMol::Within const & >(( bp::arg("other") )) );
{ //::SireMol::Within::hash
typedef ::uint ( ::SireMol::Within::*hash_function_type )( ) const;
hash_function_type hash_function_value( &::SireMol::Within::hash );
Within_exposer.def(
"hash"
, hash_function_value );
}
{ //::SireMol::Within::isNull
typedef bool ( ::SireMol::Within::*isNull_function_type )( ) const;
isNull_function_type isNull_function_value( &::SireMol::Within::isNull );
Within_exposer.def(
"isNull"
, isNull_function_value );
}
{ //::SireMol::Within::map
typedef ::QList< SireMol::AtomIdx > ( ::SireMol::Within::*map_function_type )( ::SireMol::MolInfo const & ) const;
map_function_type map_function_value( &::SireMol::Within::map );
Within_exposer.def(
"map"
, map_function_value
, ( bp::arg("molinfo") ) );
}
{ //::SireMol::Within::map
typedef ::QList< SireMol::AtomIdx > ( ::SireMol::Within::*map_function_type )( ::SireMol::MoleculeView const &,::SireBase::PropertyMap const & ) const;
map_function_type map_function_value( &::SireMol::Within::map );
Within_exposer.def(
"map"
, map_function_value
, ( bp::arg("molview"), bp::arg("map") ) );
}
Within_exposer.def( bp::self != bp::self );
{ //::SireMol::Within::operator=
typedef ::SireMol::Within & ( ::SireMol::Within::*assign_function_type )( ::SireMol::Within const & ) ;
assign_function_type assign_function_value( &::SireMol::Within::operator= );
Within_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
Within_exposer.def( bp::self == bp::other< SireID::ID >() );
Within_exposer.def( bp::self == bp::self );
{ //::SireMol::Within::toString
typedef ::QString ( ::SireMol::Within::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireMol::Within::toString );
Within_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireMol::Within::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMol::Within::typeName );
Within_exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireMol::Within::what
typedef char const * ( ::SireMol::Within::*what_function_type )( ) const;
what_function_type what_function_value( &::SireMol::Within::what );
Within_exposer.def(
"what"
, what_function_value );
}
Within_exposer.staticmethod( "typeName" );
Within_exposer.def( "__copy__", &__copy__);
Within_exposer.def( "__deepcopy__", &__copy__);
Within_exposer.def( "clone", &__copy__);
Within_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::Within >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Within_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::Within >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Within_exposer.def( "__str__", &__str__< ::SireMol::Within > );
Within_exposer.def( "__repr__", &__str__< ::SireMol::Within > );
}
}
void register_CGsWithAtoms_class(){
{ //::SireMol::CGsWithAtoms
typedef bp::class_< SireMol::CGsWithAtoms, bp::bases< SireMol::CGID, SireID::ID > > CGsWithAtoms_exposer_t;
CGsWithAtoms_exposer_t CGsWithAtoms_exposer = CGsWithAtoms_exposer_t( "CGsWithAtoms", bp::init< >() );
bp::scope CGsWithAtoms_scope( CGsWithAtoms_exposer );
CGsWithAtoms_exposer.def( bp::init< SireMol::AtomID const & >(( bp::arg("atomid") )) );
CGsWithAtoms_exposer.def( bp::init< SireMol::CGsWithAtoms const & >(( bp::arg("other") )) );
{ //::SireMol::CGsWithAtoms::atomID
typedef ::SireMol::AtomID const & ( ::SireMol::CGsWithAtoms::*atomID_function_type )( ) const;
atomID_function_type atomID_function_value( &::SireMol::CGsWithAtoms::atomID );
CGsWithAtoms_exposer.def(
"atomID"
, atomID_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireMol::CGsWithAtoms::hash
typedef ::uint ( ::SireMol::CGsWithAtoms::*hash_function_type )( ) const;
hash_function_type hash_function_value( &::SireMol::CGsWithAtoms::hash );
CGsWithAtoms_exposer.def(
"hash"
, hash_function_value );
}
{ //::SireMol::CGsWithAtoms::isNull
typedef bool ( ::SireMol::CGsWithAtoms::*isNull_function_type )( ) const;
isNull_function_type isNull_function_value( &::SireMol::CGsWithAtoms::isNull );
CGsWithAtoms_exposer.def(
"isNull"
, isNull_function_value );
}
{ //::SireMol::CGsWithAtoms::map
typedef ::QList< SireMol::CGIdx > ( ::SireMol::CGsWithAtoms::*map_function_type )( ::SireMol::MolInfo const & ) const;
map_function_type map_function_value( &::SireMol::CGsWithAtoms::map );
CGsWithAtoms_exposer.def(
"map"
, map_function_value
, ( bp::arg("molinfo") ) );
}
CGsWithAtoms_exposer.def( bp::self != bp::self );
{ //::SireMol::CGsWithAtoms::operator=
typedef ::SireMol::CGsWithAtoms & ( ::SireMol::CGsWithAtoms::*assign_function_type )( ::SireMol::CGsWithAtoms const & ) ;
assign_function_type assign_function_value( &::SireMol::CGsWithAtoms::operator= );
CGsWithAtoms_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
CGsWithAtoms_exposer.def( bp::self == bp::other< SireID::ID >() );
CGsWithAtoms_exposer.def( bp::self == bp::self );
{ //::SireMol::CGsWithAtoms::toString
typedef ::QString ( ::SireMol::CGsWithAtoms::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireMol::CGsWithAtoms::toString );
CGsWithAtoms_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireMol::CGsWithAtoms::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMol::CGsWithAtoms::typeName );
CGsWithAtoms_exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireMol::CGsWithAtoms::what
typedef char const * ( ::SireMol::CGsWithAtoms::*what_function_type )( ) const;
what_function_type what_function_value( &::SireMol::CGsWithAtoms::what );
CGsWithAtoms_exposer.def(
"what"
, what_function_value );
}
CGsWithAtoms_exposer.staticmethod( "typeName" );
CGsWithAtoms_exposer.def( "__copy__", &__copy__);
CGsWithAtoms_exposer.def( "__deepcopy__", &__copy__);
CGsWithAtoms_exposer.def( "clone", &__copy__);
CGsWithAtoms_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::CGsWithAtoms >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
CGsWithAtoms_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::CGsWithAtoms >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
CGsWithAtoms_exposer.def( "__str__", &__str__< ::SireMol::CGsWithAtoms > );
CGsWithAtoms_exposer.def( "__repr__", &__str__< ::SireMol::CGsWithAtoms > );
}
}
void register_Number_class(){
{ //::SireID::Number
typedef bp::class_< SireID::Number, boost::noncopyable > Number_exposer_t;
Number_exposer_t Number_exposer = Number_exposer_t( "Number", "This is the base class of all Number ID objects. A Number\nis used to provide an object with an identifying number.\nThis could be the number of a residue in a molecule, a\nuser-supplied number of a CutGroup in a molecule, or\nperhaps the automatic unique ID numbers of molecules,\nforcefields or molecule groups that are assigned by the\nprogram. The key point of a Number is to provide an ID\nthat can be queried and compared rapidly, and that\ndoes not change as the object is moved between different\ncontainers. Generally an object should keep its number\nthroughout its lifetime.\n\nAuthor: Christopher Woods\n", bp::no_init );
bp::scope Number_scope( Number_exposer );
{ //::SireID::Number::hash
typedef ::uint ( ::SireID::Number::*hash_function_type)( ) const;
hash_function_type hash_function_value( &::SireID::Number::hash );
Number_exposer.def(
"hash"
, hash_function_value
, "" );
}
{ //::SireID::Number::isNull
typedef bool ( ::SireID::Number::*isNull_function_type)( ) const;
isNull_function_type isNull_function_value( &::SireID::Number::isNull );
Number_exposer.def(
"isNull"
, isNull_function_value
, "" );
}
{ //::SireID::Number::null
typedef ::qint32 ( *null_function_type )( );
null_function_type null_function_value( &::SireID::Number::null );
Number_exposer.def(
"null"
, null_function_value
, "" );
}
{ //::SireID::Number::value
typedef ::qint32 ( ::SireID::Number::*value_function_type)( ) const;
value_function_type value_function_value( &::SireID::Number::value );
Number_exposer.def(
"value"
, value_function_value
, "" );
}
Number_exposer.staticmethod( "null" );
Number_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireID::Number >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Number_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireID::Number >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Number_exposer.def( "__str__", &pvt_get_name);
Number_exposer.def( "__repr__", &pvt_get_name);
Number_exposer.def( "__hash__", &::SireID::Number::hash );
}
}
void register_ChainIdx_class(){
{ //::SireMol::ChainIdx
typedef bp::class_< SireMol::ChainIdx, bp::bases< SireMol::ChainID, SireID::ID, SireID::IndexBase > > ChainIdx_exposer_t;
ChainIdx_exposer_t ChainIdx_exposer = ChainIdx_exposer_t( "ChainIdx", bp::init< >() );
bp::scope ChainIdx_scope( ChainIdx_exposer );
ChainIdx_exposer.def( bp::init< qint32 >(( bp::arg("idx") )) );
ChainIdx_exposer.def( bp::init< SireMol::ChainIdx const & >(( bp::arg("other") )) );
{ //::SireMol::ChainIdx::hash
typedef ::uint ( ::SireMol::ChainIdx::*hash_function_type )( ) const;
hash_function_type hash_function_value( &::SireMol::ChainIdx::hash );
ChainIdx_exposer.def(
"hash"
, hash_function_value );
}
{ //::SireMol::ChainIdx::isNull
typedef bool ( ::SireMol::ChainIdx::*isNull_function_type )( ) const;
isNull_function_type isNull_function_value( &::SireMol::ChainIdx::isNull );
ChainIdx_exposer.def(
"isNull"
, isNull_function_value );
}
{ //::SireMol::ChainIdx::map
typedef ::QList< SireMol::ChainIdx > ( ::SireMol::ChainIdx::*map_function_type )( ::SireMol::MolInfo const & ) const;
map_function_type map_function_value( &::SireMol::ChainIdx::map );
ChainIdx_exposer.def(
"map"
, map_function_value
, ( bp::arg("molinfo") ) );
}
{ //::SireMol::ChainIdx::null
typedef ::SireMol::ChainIdx ( *null_function_type )( );
null_function_type null_function_value( &::SireMol::ChainIdx::null );
ChainIdx_exposer.def(
"null"
, null_function_value );
}
{ //::SireMol::ChainIdx::operator=
typedef ::SireMol::ChainIdx & ( ::SireMol::ChainIdx::*assign_function_type )( ::SireMol::ChainIdx const & ) ;
assign_function_type assign_function_value( &::SireMol::ChainIdx::operator= );
ChainIdx_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
{ //::SireMol::ChainIdx::toString
typedef ::QString ( ::SireMol::ChainIdx::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireMol::ChainIdx::toString );
ChainIdx_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireMol::ChainIdx::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMol::ChainIdx::typeName );
ChainIdx_exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireMol::ChainIdx::what
typedef char const * ( ::SireMol::ChainIdx::*what_function_type )( ) const;
what_function_type what_function_value( &::SireMol::ChainIdx::what );
ChainIdx_exposer.def(
"what"
, what_function_value );
}
ChainIdx_exposer.staticmethod( "null" );
ChainIdx_exposer.staticmethod( "typeName" );
ChainIdx_exposer.def( "__copy__", &__copy__);
ChainIdx_exposer.def( "__deepcopy__", &__copy__);
ChainIdx_exposer.def( "clone", &__copy__);
ChainIdx_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::ChainIdx >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
ChainIdx_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::ChainIdx >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
ChainIdx_exposer.def( "__str__", &__str__< ::SireMol::ChainIdx > );
ChainIdx_exposer.def( "__repr__", &__str__< ::SireMol::ChainIdx > );
}
}
void register_MonitorName_class(){
{ //::SireSystem::MonitorName
typedef bp::class_< SireSystem::MonitorName, bp::bases< SireSystem::MonitorID, SireID::ID, SireID::Name > > MonitorName_exposer_t;
MonitorName_exposer_t MonitorName_exposer = MonitorName_exposer_t( "MonitorName", "This class holds the name of a simulation system\n\nAuthor: Christopher Woods\n", bp::init< >("") );
bp::scope MonitorName_scope( MonitorName_exposer );
MonitorName_exposer.def( bp::init< QString const & >(( bp::arg("name") ), "") );
MonitorName_exposer.def( bp::init< SireSystem::MonitorName const & >(( bp::arg("other") ), "") );
{ //::SireSystem::MonitorName::hash
typedef ::uint ( ::SireSystem::MonitorName::*hash_function_type)( ) const;
hash_function_type hash_function_value( &::SireSystem::MonitorName::hash );
MonitorName_exposer.def(
"hash"
, hash_function_value
, "" );
}
{ //::SireSystem::MonitorName::isNull
typedef bool ( ::SireSystem::MonitorName::*isNull_function_type)( ) const;
isNull_function_type isNull_function_value( &::SireSystem::MonitorName::isNull );
MonitorName_exposer.def(
"isNull"
, isNull_function_value
, "" );
}
{ //::SireSystem::MonitorName::map
typedef ::QList< SireSystem::MonitorName > ( ::SireSystem::MonitorName::*map_function_type)( ::SireSystem::SystemMonitors const & ) const;
map_function_type map_function_value( &::SireSystem::MonitorName::map );
MonitorName_exposer.def(
"map"
, map_function_value
, ( bp::arg("monitors") )
, "" );
}
MonitorName_exposer.def( bp::self != bp::self );
{ //::SireSystem::MonitorName::operator=
typedef ::SireSystem::MonitorName & ( ::SireSystem::MonitorName::*assign_function_type)( ::SireSystem::MonitorName const & ) ;
assign_function_type assign_function_value( &::SireSystem::MonitorName::operator= );
MonitorName_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >()
, "" );
}
MonitorName_exposer.def( bp::self == bp::other< SireID::ID >() );
MonitorName_exposer.def( bp::self == bp::self );
{ //::SireSystem::MonitorName::toString
typedef ::QString ( ::SireSystem::MonitorName::*toString_function_type)( ) const;
toString_function_type toString_function_value( &::SireSystem::MonitorName::toString );
MonitorName_exposer.def(
"toString"
, toString_function_value
, "" );
}
{ //::SireSystem::MonitorName::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireSystem::MonitorName::typeName );
MonitorName_exposer.def(
"typeName"
, typeName_function_value
, "" );
}
{ //::SireSystem::MonitorName::what
typedef char const * ( ::SireSystem::MonitorName::*what_function_type)( ) const;
what_function_type what_function_value( &::SireSystem::MonitorName::what );
MonitorName_exposer.def(
"what"
, what_function_value
, "" );
}
MonitorName_exposer.staticmethod( "typeName" );
MonitorName_exposer.def( "__copy__", &__copy__);
MonitorName_exposer.def( "__deepcopy__", &__copy__);
MonitorName_exposer.def( "clone", &__copy__);
MonitorName_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireSystem::MonitorName >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
MonitorName_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireSystem::MonitorName >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
MonitorName_exposer.def( "__str__", &__str__< ::SireSystem::MonitorName > );
MonitorName_exposer.def( "__repr__", &__str__< ::SireSystem::MonitorName > );
MonitorName_exposer.def( "__hash__", &::SireSystem::MonitorName::hash );
}
}
void register_Transform_class(){
{ //::SireMaths::Transform
typedef bp::class_< SireMaths::Transform > Transform_exposer_t;
Transform_exposer_t Transform_exposer = Transform_exposer_t( "Transform", bp::init< >() );
bp::scope Transform_scope( Transform_exposer );
Transform_exposer.def( bp::init< SireMaths::Vector const & >(( bp::arg("delta") )) );
Transform_exposer.def( bp::init< SireMaths::Quaternion const &, SireMaths::Vector const & >(( bp::arg("rotmat"), bp::arg("center") )) );
Transform_exposer.def( bp::init< SireMaths::Matrix const &, SireMaths::Vector const & >(( bp::arg("rotmat"), bp::arg("center") )) );
Transform_exposer.def( bp::init< SireMaths::Vector const &, SireMaths::Quaternion const &, SireMaths::Vector const & >(( bp::arg("delta"), bp::arg("rotmat"), bp::arg("center") )) );
Transform_exposer.def( bp::init< SireMaths::Vector const &, SireMaths::Matrix const &, SireMaths::Vector const & >(( bp::arg("delta"), bp::arg("rotmat"), bp::arg("center") )) );
Transform_exposer.def( bp::init< SireMaths::Transform const & >(( bp::arg("other") )) );
{ //::SireMaths::Transform::apply
typedef ::SireMaths::Vector ( ::SireMaths::Transform::*apply_function_type )( ::SireMaths::Vector const & ) const;
apply_function_type apply_function_value( &::SireMaths::Transform::apply );
Transform_exposer.def(
"apply"
, apply_function_value
, ( bp::arg("point") ) );
}
{ //::SireMaths::Transform::apply
typedef ::QVector< SireMaths::Vector > ( ::SireMaths::Transform::*apply_function_type )( ::QVector< SireMaths::Vector > const & ) const;
apply_function_type apply_function_value( &::SireMaths::Transform::apply );
Transform_exposer.def(
"apply"
, apply_function_value
, ( bp::arg("points") ) );
}
{ //::SireMaths::Transform::isNull
typedef bool ( ::SireMaths::Transform::*isNull_function_type )( ) const;
isNull_function_type isNull_function_value( &::SireMaths::Transform::isNull );
Transform_exposer.def(
"isNull"
, isNull_function_value );
}
{ //::SireMaths::Transform::isZero
typedef bool ( ::SireMaths::Transform::*isZero_function_type )( ) const;
isZero_function_type isZero_function_value( &::SireMaths::Transform::isZero );
Transform_exposer.def(
"isZero"
, isZero_function_value );
}
Transform_exposer.def( bp::self != bp::self );
{ //::SireMaths::Transform::operator()
typedef ::SireMaths::Vector ( ::SireMaths::Transform::*__call___function_type )( ::SireMaths::Vector const & ) const;
__call___function_type __call___function_value( &::SireMaths::Transform::operator() );
Transform_exposer.def(
"__call__"
, __call___function_value
, ( bp::arg("point") ) );
}
{ //::SireMaths::Transform::operator()
typedef ::QVector< SireMaths::Vector > ( ::SireMaths::Transform::*__call___function_type )( ::QVector< SireMaths::Vector > const & ) const;
__call___function_type __call___function_value( &::SireMaths::Transform::operator() );
Transform_exposer.def(
"__call__"
, __call___function_value
, ( bp::arg("point") ) );
}
{ //::SireMaths::Transform::operator=
typedef ::SireMaths::Transform & ( ::SireMaths::Transform::*assign_function_type )( ::SireMaths::Transform const & ) ;
assign_function_type assign_function_value( &::SireMaths::Transform::operator= );
Transform_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
Transform_exposer.def( bp::self == bp::self );
{ //::SireMaths::Transform::rotationCenter
typedef ::SireMaths::Vector ( ::SireMaths::Transform::*rotationCenter_function_type )( ) const;
rotationCenter_function_type rotationCenter_function_value( &::SireMaths::Transform::rotationCenter );
Transform_exposer.def(
"rotationCenter"
, rotationCenter_function_value );
}
{ //::SireMaths::Transform::rotationMatrix
typedef ::SireMaths::Matrix ( ::SireMaths::Transform::*rotationMatrix_function_type )( ) const;
rotationMatrix_function_type rotationMatrix_function_value( &::SireMaths::Transform::rotationMatrix );
Transform_exposer.def(
"rotationMatrix"
, rotationMatrix_function_value );
}
{ //::SireMaths::Transform::rotationQuaternion
typedef ::SireMaths::Quaternion ( ::SireMaths::Transform::*rotationQuaternion_function_type )( ) const;
rotationQuaternion_function_type rotationQuaternion_function_value( &::SireMaths::Transform::rotationQuaternion );
Transform_exposer.def(
"rotationQuaternion"
, rotationQuaternion_function_value );
}
{ //::SireMaths::Transform::toString
typedef ::QString ( ::SireMaths::Transform::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireMaths::Transform::toString );
Transform_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireMaths::Transform::translationDelta
typedef ::SireMaths::Vector ( ::SireMaths::Transform::*translationDelta_function_type )( ) const;
translationDelta_function_type translationDelta_function_value( &::SireMaths::Transform::translationDelta );
Transform_exposer.def(
"translationDelta"
, translationDelta_function_value );
}
{ //::SireMaths::Transform::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMaths::Transform::typeName );
Transform_exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireMaths::Transform::what
typedef char const * ( ::SireMaths::Transform::*what_function_type )( ) const;
what_function_type what_function_value( &::SireMaths::Transform::what );
Transform_exposer.def(
"what"
, what_function_value );
}
Transform_exposer.staticmethod( "typeName" );
Transform_exposer.def( "__copy__", &__copy__);
Transform_exposer.def( "__deepcopy__", &__copy__);
Transform_exposer.def( "clone", &__copy__);
Transform_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMaths::Transform >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Transform_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMaths::Transform >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Transform_exposer.def( "__str__", &__str__< ::SireMaths::Transform > );
Transform_exposer.def( "__repr__", &__str__< ::SireMaths::Transform > );
}
}
void register_AABox_class(){
{ //::SireVol::AABox
typedef bp::class_< SireVol::AABox > AABox_exposer_t;
AABox_exposer_t AABox_exposer = AABox_exposer_t( "AABox", "\nAn AABox is an axis-aligned bounding box that is the smallest box that is aligned with the three cartesian axes that completely encases a CoordGroup. It is trivial to obtain the bounding sphere from the AABox. The AABox is used by the distance calculators to quickly determine whether two CoordGroups are within the cutoff radius, and to obtain all CoordGroups that are within particular regions of space.\n\nAuthor: Christopher Woods\n", bp::init< >("Construct an empty AABox") );
bp::scope AABox_scope( AABox_exposer );
AABox_exposer.def( bp::init< SireMaths::Vector const & >(( bp::arg("point") ), "Construct an AABox that completely encloses the point point") );
AABox_exposer.def( bp::init< SireMaths::Vector const &, SireMaths::Vector const & >(( bp::arg("cent"), bp::arg("extents") ), "Construct an AABox with center at cent, and half-extents extents") );
AABox_exposer.def( bp::init< QVector< SireMaths::Vector > const & >(( bp::arg("coordinates") ), "Construct an AABox that completely encases the points in coordinates") );
AABox_exposer.def( bp::init< SireMaths::Vector const *, int >(( bp::arg("coords"), bp::arg("ncoords") ), "Construct an AABox that completely encases the points in coords") );
AABox_exposer.def( bp::init< SireVol::CoordGroupBase const & >(( bp::arg("coordgroup") ), "Construct an AABox that completely encases the CoordGroup coordgroup") );
AABox_exposer.def( bp::init< SireVol::CoordGroupArray const & >(( bp::arg("cgarray") ), "Construct an AABox that completely encases all of the points in all of the\nCoordGroups in cgarray") );
AABox_exposer.def( bp::init< SireVol::CoordGroupArrayArray const & >(( bp::arg("cgarrays") ), "Construct an AABox that completely encases all of the points in all of the\nCoordGroups in all of the arrays in cgarrays") );
{ //::SireVol::AABox::add
typedef void ( ::SireVol::AABox::*add_function_type)( ::SireVol::AABox const & ) ;
add_function_type add_function_value( &::SireVol::AABox::add );
AABox_exposer.def(
"add"
, add_function_value
, ( bp::arg("other") )
, "Add another AABox to this one - this forms the union of both of the\nboxes." );
}
{ //::SireVol::AABox::add
typedef void ( ::SireVol::AABox::*add_function_type)( ::SireMaths::Vector const & ) ;
add_function_type add_function_value( &::SireVol::AABox::add );
AABox_exposer.def(
"add"
, add_function_value
, ( bp::arg("point") )
, "Add a point to this box" );
}
{ //::SireVol::AABox::add
typedef void ( ::SireVol::AABox::*add_function_type)( ::QVector< SireMaths::Vector > const & ) ;
add_function_type add_function_value( &::SireVol::AABox::add );
AABox_exposer.def(
"add"
, add_function_value
, ( bp::arg("points") )
, "Add lots of points to this box" );
}
{ //::SireVol::AABox::boundingSphere
typedef ::SireMaths::Sphere ( ::SireVol::AABox::*boundingSphere_function_type)( ) const;
boundingSphere_function_type boundingSphere_function_value( &::SireVol::AABox::boundingSphere );
AABox_exposer.def(
"boundingSphere"
, boundingSphere_function_value
, "Return the sphere that just contains this AABox" );
}
{ //::SireVol::AABox::center
typedef ::SireMaths::Vector const & ( ::SireVol::AABox::*center_function_type)( ) const;
center_function_type center_function_value( &::SireVol::AABox::center );
AABox_exposer.def(
"center"
, center_function_value
, bp::return_value_policy< bp::copy_const_reference >()
, "" );
}
{ //::SireVol::AABox::contains
typedef bool ( ::SireVol::AABox::*contains_function_type)( ::SireVol::AABox const & ) const;
contains_function_type contains_function_value( &::SireVol::AABox::contains );
AABox_exposer.def(
"contains"
, contains_function_value
, ( bp::arg("other") )
, "Return whether or not this box contains other" );
}
{ //::SireVol::AABox::contains
typedef bool ( ::SireVol::AABox::*contains_function_type)( ::SireMaths::Vector const & ) const;
contains_function_type contains_function_value( &::SireVol::AABox::contains );
AABox_exposer.def(
"contains"
, contains_function_value
, ( bp::arg("point") )
, "Return whether or not this box contains the point point" );
}
{ //::SireVol::AABox::from
typedef ::SireVol::AABox ( *from_function_type )( ::SireMaths::Vector const & );
from_function_type from_function_value( &::SireVol::AABox::from );
AABox_exposer.def(
"from"
, from_function_value
, ( bp::arg("point") )
, "Return an AABox constructed to contain the coordinates of point" );
}
{ //::SireVol::AABox::from
typedef ::SireVol::AABox ( *from_function_type )( ::SireVol::CoordGroupBase const & );
from_function_type from_function_value( &::SireVol::AABox::from );
AABox_exposer.def(
"from"
, from_function_value
, ( bp::arg("coordgroup") )
, "Return an AABox constructed to contain the coordinates in coordinates" );
}
{ //::SireVol::AABox::from
typedef ::SireVol::AABox ( *from_function_type )( ::SireVol::CoordGroupArray const & );
from_function_type from_function_value( &::SireVol::AABox::from );
AABox_exposer.def(
"from"
, from_function_value
, ( bp::arg("cgarray") )
, "Return an AABox constructed to contain all of the CoordGroups in cgarray" );
}
{ //::SireVol::AABox::from
typedef ::SireVol::AABox ( *from_function_type )( ::SireVol::CoordGroupArrayArray const & );
from_function_type from_function_value( &::SireVol::AABox::from );
AABox_exposer.def(
"from"
, from_function_value
, ( bp::arg("cgarrays") )
, "Return an AABox constructed to contain all of the CoordGroups in the\narrays in cgarrays" );
}
{ //::SireVol::AABox::from
typedef ::SireVol::AABox ( *from_function_type )( ::QVector< SireMaths::Vector > const & );
from_function_type from_function_value( &::SireVol::AABox::from );
AABox_exposer.def(
"from"
, from_function_value
, ( bp::arg("coords") )
, "Return an AABox constructed to contain the coordinates in coordinates" );
}
{ //::SireVol::AABox::from
typedef ::SireVol::AABox ( *from_function_type )( ::SireMaths::Vector const &,::SireMaths::Vector const & );
from_function_type from_function_value( &::SireVol::AABox::from );
AABox_exposer.def(
"from"
, from_function_value
, ( bp::arg("mincoords"), bp::arg("maxcoords") )
, "Construct a new AABox from the passed minimum and maximum coordinates" );
}
{ //::SireVol::AABox::halfExtents
typedef ::SireMaths::Vector const & ( ::SireVol::AABox::*halfExtents_function_type)( ) const;
halfExtents_function_type halfExtents_function_value( &::SireVol::AABox::halfExtents );
AABox_exposer.def(
"halfExtents"
, halfExtents_function_value
, bp::return_value_policy< bp::copy_const_reference >()
, "" );
}
{ //::SireVol::AABox::intersects
typedef bool ( ::SireVol::AABox::*intersects_function_type)( ::SireVol::AABox const & ) const;
intersects_function_type intersects_function_value( &::SireVol::AABox::intersects );
AABox_exposer.def(
"intersects"
, intersects_function_value
, ( bp::arg("other") )
, "Return whether this box intersects with box" );
}
{ //::SireVol::AABox::isEmpty
typedef bool ( ::SireVol::AABox::*isEmpty_function_type)( ) const;
isEmpty_function_type isEmpty_function_value( &::SireVol::AABox::isEmpty );
AABox_exposer.def(
"isEmpty"
, isEmpty_function_value
, "Return if the AABox is empty" );
}
{ //::SireVol::AABox::isNull
typedef bool ( ::SireVol::AABox::*isNull_function_type)( ) const;
isNull_function_type isNull_function_value( &::SireVol::AABox::isNull );
AABox_exposer.def(
"isNull"
, isNull_function_value
, "Return if the AABox is null" );
}
{ //::SireVol::AABox::maxCoords
typedef ::SireMaths::Vector ( ::SireVol::AABox::*maxCoords_function_type)( ) const;
maxCoords_function_type maxCoords_function_value( &::SireVol::AABox::maxCoords );
AABox_exposer.def(
"maxCoords"
, maxCoords_function_value
, "" );
}
{ //::SireVol::AABox::minCoords
typedef ::SireMaths::Vector ( ::SireVol::AABox::*minCoords_function_type)( ) const;
minCoords_function_type minCoords_function_value( &::SireVol::AABox::minCoords );
AABox_exposer.def(
"minCoords"
, minCoords_function_value
, "" );
}
AABox_exposer.def( bp::self != bp::self );
AABox_exposer.def( bp::self + bp::self );
AABox_exposer.def( bp::self + bp::other< SireMaths::Vector >() );
AABox_exposer.def( bp::self + bp::other< QVector< SireMaths::Vector > >() );
{ //::SireVol::AABox::operator=
typedef ::SireVol::AABox const & ( ::SireVol::AABox::*assign_function_type)( ::SireVol::AABox const & ) ;
assign_function_type assign_function_value( &::SireVol::AABox::operator= );
AABox_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_value_policy< bp::copy_const_reference >()
, "" );
}
AABox_exposer.def( bp::self == bp::self );
{ //::SireVol::AABox::radius
typedef double ( ::SireVol::AABox::*radius_function_type)( ) const;
radius_function_type radius_function_value( &::SireVol::AABox::radius );
AABox_exposer.def(
"radius"
, radius_function_value
, "" );
}
{ //::SireVol::AABox::recalculate
typedef void ( ::SireVol::AABox::*recalculate_function_type)( ::SireVol::CoordGroupBase const & ) ;
recalculate_function_type recalculate_function_value( &::SireVol::AABox::recalculate );
AABox_exposer.def(
"recalculate"
, recalculate_function_value
, ( bp::arg("coordgroup") )
, "Recalculate the AABox so that it completely encloses the CoordGroup coordgroup" );
}
{ //::SireVol::AABox::recalculate
typedef void ( ::SireVol::AABox::*recalculate_function_type)( ::SireVol::CoordGroupArray const & ) ;
recalculate_function_type recalculate_function_value( &::SireVol::AABox::recalculate );
AABox_exposer.def(
"recalculate"
, recalculate_function_value
, ( bp::arg("cgarray") )
, "Recalculate the AABox so that it completely encloses the CoordGroups\nin the array cgarray" );
}
{ //::SireVol::AABox::recalculate
typedef void ( ::SireVol::AABox::*recalculate_function_type)( ::SireVol::CoordGroupArrayArray const & ) ;
recalculate_function_type recalculate_function_value( &::SireVol::AABox::recalculate );
AABox_exposer.def(
"recalculate"
, recalculate_function_value
, ( bp::arg("cgarrays") )
, "Recalculate the AABox so that it completely encloses the CoordGroups\nin the arrays cgarrays" );
}
{ //::SireVol::AABox::recalculate
typedef void ( ::SireVol::AABox::*recalculate_function_type)( ::QVector< SireMaths::Vector > const & ) ;
recalculate_function_type recalculate_function_value( &::SireVol::AABox::recalculate );
AABox_exposer.def(
"recalculate"
, recalculate_function_value
, ( bp::arg("coordinates") )
, "Recalculate the AABox so that it completely encloses the coordinates" );
}
{ //::SireVol::AABox::toString
typedef ::QString ( ::SireVol::AABox::*toString_function_type)( ) const;
toString_function_type toString_function_value( &::SireVol::AABox::toString );
AABox_exposer.def(
"toString"
, toString_function_value
, "Return a string representation of this AABox" );
}
{ //::SireVol::AABox::translate
typedef void ( ::SireVol::AABox::*translate_function_type)( ::SireMaths::Vector const & ) ;
translate_function_type translate_function_value( &::SireVol::AABox::translate );
AABox_exposer.def(
"translate"
, translate_function_value
, ( bp::arg("delta") )
, "Translate this AABox by delta" );
}
{ //::SireVol::AABox::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireVol::AABox::typeName );
AABox_exposer.def(
"typeName"
, typeName_function_value
, "" );
}
{ //::SireVol::AABox::what
typedef char const * ( ::SireVol::AABox::*what_function_type)( ) const;
what_function_type what_function_value( &::SireVol::AABox::what );
AABox_exposer.def(
"what"
, what_function_value
, "" );
}
{ //::SireVol::AABox::withinDistance
typedef bool ( ::SireVol::AABox::*withinDistance_function_type)( double,::SireVol::AABox const & ) const;
withinDistance_function_type withinDistance_function_value( &::SireVol::AABox::withinDistance );
AABox_exposer.def(
"withinDistance"
, withinDistance_function_value
, ( bp::arg("dist"), bp::arg("box") )
, "Return whether or not this box is within dist of box box.\n(using infinite cartesian axes)" );
}
AABox_exposer.staticmethod( "from" );
AABox_exposer.staticmethod( "typeName" );
AABox_exposer.def( "__copy__", &__copy__);
AABox_exposer.def( "__deepcopy__", &__copy__);
AABox_exposer.def( "clone", &__copy__);
AABox_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireVol::AABox >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
AABox_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireVol::AABox >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
AABox_exposer.def( "__str__", &__str__< ::SireVol::AABox > );
AABox_exposer.def( "__repr__", &__str__< ::SireVol::AABox > );
}
}
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_SpecifyMol_class(){
{ //::SireMol::SpecifyMol
typedef bp::class_< SireMol::SpecifyMol, bp::bases< SireMol::MolID, SireID::ID > > SpecifyMol_exposer_t;
SpecifyMol_exposer_t SpecifyMol_exposer = SpecifyMol_exposer_t( "SpecifyMol", "This class allow for the specification of specific\nmatching molecules\n\nAuthor: Christopher Woods\n", bp::init< >("Constructor") );
bp::scope SpecifyMol_scope( SpecifyMol_exposer );
SpecifyMol_exposer.def( bp::init< SireMol::MolID const & >(( bp::arg("molid") ), "Construct to match all of the molecules that match the\nID molid") );
SpecifyMol_exposer.def( bp::init< SireMol::MolID const &, int >(( bp::arg("molid"), bp::arg("i") ), "Construct to match the ith molecule that matches the ID molid") );
SpecifyMol_exposer.def( bp::init< SireMol::MolID const &, int, int >(( bp::arg("molid"), bp::arg("i"), bp::arg("j") ), "Construct to math the range of molecules from i to j that\nmatch the ID molid") );
SpecifyMol_exposer.def( bp::init< SireMol::SpecifyMol const & >(( bp::arg("other") ), "Copy constructor") );
{ //::SireMol::SpecifyMol::hash
typedef ::uint ( ::SireMol::SpecifyMol::*hash_function_type)( ) const;
hash_function_type hash_function_value( &::SireMol::SpecifyMol::hash );
SpecifyMol_exposer.def(
"hash"
, hash_function_value
, "Hash this ID" );
}
{ //::SireMol::SpecifyMol::isNull
typedef bool ( ::SireMol::SpecifyMol::*isNull_function_type)( ) const;
isNull_function_type isNull_function_value( &::SireMol::SpecifyMol::isNull );
SpecifyMol_exposer.def(
"isNull"
, isNull_function_value
, "Return whether or not this ID is null" );
}
{ //::SireMol::SpecifyMol::map
typedef ::QList< SireMol::MolNum > ( ::SireMol::SpecifyMol::*map_function_type)( ::SireMol::Molecules const & ) const;
map_function_type map_function_value( &::SireMol::SpecifyMol::map );
SpecifyMol_exposer.def(
"map"
, map_function_value
, ( bp::arg("molecules") )
, "Map this ID to the list of molecule numbers that match" );
}
{ //::SireMol::SpecifyMol::map
typedef ::QList< SireMol::MolNum > ( ::SireMol::SpecifyMol::*map_function_type)( ::SireMol::MoleculeGroup const & ) const;
map_function_type map_function_value( &::SireMol::SpecifyMol::map );
SpecifyMol_exposer.def(
"map"
, map_function_value
, ( bp::arg("molgroup") )
, "Map this ID to the list of molecule numbers that match" );
}
{ //::SireMol::SpecifyMol::map
typedef ::QList< SireMol::MolNum > ( ::SireMol::SpecifyMol::*map_function_type)( ::SireMol::MolGroupsBase const & ) const;
map_function_type map_function_value( &::SireMol::SpecifyMol::map );
SpecifyMol_exposer.def(
"map"
, map_function_value
, ( bp::arg("molgroups") )
, "Map this ID to the list of molecule numbers that match" );
}
SpecifyMol_exposer.def( bp::self != bp::self );
SpecifyMol_exposer.def( bp::self != bp::other< SireID::ID >() );
{ //::SireMol::SpecifyMol::operator=
typedef ::SireMol::SpecifyMol & ( ::SireMol::SpecifyMol::*assign_function_type)( ::SireMol::SpecifyMol const & ) ;
assign_function_type assign_function_value( &::SireMol::SpecifyMol::operator= );
SpecifyMol_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >()
, "" );
}
SpecifyMol_exposer.def( bp::self == bp::self );
SpecifyMol_exposer.def( bp::self == bp::other< SireID::ID >() );
{ //::SireMol::SpecifyMol::toString
typedef ::QString ( ::SireMol::SpecifyMol::*toString_function_type)( ) const;
toString_function_type toString_function_value( &::SireMol::SpecifyMol::toString );
SpecifyMol_exposer.def(
"toString"
, toString_function_value
, "Return a string representation of this ID" );
}
{ //::SireMol::SpecifyMol::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMol::SpecifyMol::typeName );
SpecifyMol_exposer.def(
"typeName"
, typeName_function_value
, "" );
}
{ //::SireMol::SpecifyMol::what
typedef char const * ( ::SireMol::SpecifyMol::*what_function_type)( ) const;
what_function_type what_function_value( &::SireMol::SpecifyMol::what );
SpecifyMol_exposer.def(
"what"
, what_function_value
, "" );
}
SpecifyMol_exposer.staticmethod( "typeName" );
SpecifyMol_exposer.def( "__copy__", &__copy__);
SpecifyMol_exposer.def( "__deepcopy__", &__copy__);
SpecifyMol_exposer.def( "clone", &__copy__);
SpecifyMol_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::SpecifyMol >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
SpecifyMol_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::SpecifyMol >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
SpecifyMol_exposer.def( "__str__", &__str__< ::SireMol::SpecifyMol > );
SpecifyMol_exposer.def( "__repr__", &__str__< ::SireMol::SpecifyMol > );
SpecifyMol_exposer.def( "__hash__", &::SireMol::SpecifyMol::hash );
}
}
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_Name_class(){
{ //::SireID::Name
typedef bp::class_< SireID::Name, boost::noncopyable > Name_exposer_t;
Name_exposer_t Name_exposer = Name_exposer_t( "Name", bp::no_init );
bp::scope Name_scope( Name_exposer );
{ //::SireID::Name::hash
typedef ::uint ( ::SireID::Name::*hash_function_type )( ) const;
hash_function_type hash_function_value( &::SireID::Name::hash );
Name_exposer.def(
"hash"
, hash_function_value );
}
{ //::SireID::Name::isCaseSensitive
typedef bool ( ::SireID::Name::*isCaseSensitive_function_type )( ) const;
isCaseSensitive_function_type isCaseSensitive_function_value( &::SireID::Name::isCaseSensitive );
Name_exposer.def(
"isCaseSensitive"
, isCaseSensitive_function_value );
}
{ //::SireID::Name::isEmpty
typedef bool ( ::SireID::Name::*isEmpty_function_type )( ) const;
isEmpty_function_type isEmpty_function_value( &::SireID::Name::isEmpty );
Name_exposer.def(
"isEmpty"
, isEmpty_function_value );
}
{ //::SireID::Name::isNull
typedef bool ( ::SireID::Name::*isNull_function_type )( ) const;
isNull_function_type isNull_function_value( &::SireID::Name::isNull );
Name_exposer.def(
"isNull"
, isNull_function_value );
}
{ //::SireID::Name::value
typedef ::QString const & ( ::SireID::Name::*value_function_type )( ) const;
value_function_type value_function_value( &::SireID::Name::value );
Name_exposer.def(
"value"
, value_function_value
, bp::return_value_policy< bp::copy_const_reference >() );
}
Name_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireID::Name >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Name_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireID::Name >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Name_exposer.def( "__str__", &pvt_get_name);
Name_exposer.def( "__repr__", &pvt_get_name);
}
}
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_AABox_class(){
{ //::SireVol::AABox
typedef bp::class_< SireVol::AABox > AABox_exposer_t;
AABox_exposer_t AABox_exposer = AABox_exposer_t( "AABox", bp::init< >() );
bp::scope AABox_scope( AABox_exposer );
AABox_exposer.def( bp::init< SireMaths::Vector const & >(( bp::arg("point") )) );
AABox_exposer.def( bp::init< SireMaths::Vector const &, SireMaths::Vector const & >(( bp::arg("cent"), bp::arg("extents") )) );
AABox_exposer.def( bp::init< QVector< SireMaths::Vector > const & >(( bp::arg("coordinates") )) );
AABox_exposer.def( bp::init< SireMaths::Vector const *, int >(( bp::arg("coords"), bp::arg("ncoords") )) );
AABox_exposer.def( bp::init< SireVol::CoordGroupBase const & >(( bp::arg("coordgroup") )) );
AABox_exposer.def( bp::init< SireVol::CoordGroupArray const & >(( bp::arg("cgarray") )) );
AABox_exposer.def( bp::init< SireVol::CoordGroupArrayArray const & >(( bp::arg("cgarrays") )) );
{ //::SireVol::AABox::add
typedef void ( ::SireVol::AABox::*add_function_type )( ::SireVol::AABox const & ) ;
add_function_type add_function_value( &::SireVol::AABox::add );
AABox_exposer.def(
"add"
, add_function_value
, ( bp::arg("other") ) );
}
{ //::SireVol::AABox::add
typedef void ( ::SireVol::AABox::*add_function_type )( ::SireMaths::Vector const & ) ;
add_function_type add_function_value( &::SireVol::AABox::add );
AABox_exposer.def(
"add"
, add_function_value
, ( bp::arg("point") ) );
}
{ //::SireVol::AABox::add
typedef void ( ::SireVol::AABox::*add_function_type )( ::QVector< SireMaths::Vector > const & ) ;
add_function_type add_function_value( &::SireVol::AABox::add );
AABox_exposer.def(
"add"
, add_function_value
, ( bp::arg("points") ) );
}
{ //::SireVol::AABox::boundingSphere
typedef ::SireMaths::Sphere ( ::SireVol::AABox::*boundingSphere_function_type )( ) const;
boundingSphere_function_type boundingSphere_function_value( &::SireVol::AABox::boundingSphere );
AABox_exposer.def(
"boundingSphere"
, boundingSphere_function_value );
}
{ //::SireVol::AABox::center
typedef ::SireMaths::Vector const & ( ::SireVol::AABox::*center_function_type )( ) const;
center_function_type center_function_value( &::SireVol::AABox::center );
AABox_exposer.def(
"center"
, center_function_value
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireVol::AABox::contains
typedef bool ( ::SireVol::AABox::*contains_function_type )( ::SireVol::AABox const & ) const;
contains_function_type contains_function_value( &::SireVol::AABox::contains );
AABox_exposer.def(
"contains"
, contains_function_value
, ( bp::arg("other") ) );
}
{ //::SireVol::AABox::contains
typedef bool ( ::SireVol::AABox::*contains_function_type )( ::SireMaths::Vector const & ) const;
contains_function_type contains_function_value( &::SireVol::AABox::contains );
AABox_exposer.def(
"contains"
, contains_function_value
, ( bp::arg("point") ) );
}
{ //::SireVol::AABox::from
typedef ::SireVol::AABox ( *from_function_type )( ::SireMaths::Vector const & );
from_function_type from_function_value( &::SireVol::AABox::from );
AABox_exposer.def(
"from"
, from_function_value
, ( bp::arg("point") ) );
}
{ //::SireVol::AABox::from
typedef ::SireVol::AABox ( *from_function_type )( ::SireVol::CoordGroupBase const & );
from_function_type from_function_value( &::SireVol::AABox::from );
AABox_exposer.def(
"from"
, from_function_value
, ( bp::arg("coordgroup") ) );
}
{ //::SireVol::AABox::from
typedef ::SireVol::AABox ( *from_function_type )( ::SireVol::CoordGroupArray const & );
from_function_type from_function_value( &::SireVol::AABox::from );
AABox_exposer.def(
"from"
, from_function_value
, ( bp::arg("cgarray") ) );
}
{ //::SireVol::AABox::from
typedef ::SireVol::AABox ( *from_function_type )( ::SireVol::CoordGroupArrayArray const & );
from_function_type from_function_value( &::SireVol::AABox::from );
AABox_exposer.def(
"from"
, from_function_value
, ( bp::arg("cgarrays") ) );
}
{ //::SireVol::AABox::from
typedef ::SireVol::AABox ( *from_function_type )( ::QVector< SireMaths::Vector > const & );
from_function_type from_function_value( &::SireVol::AABox::from );
AABox_exposer.def(
"from"
, from_function_value
, ( bp::arg("coords") ) );
}
{ //::SireVol::AABox::from
typedef ::SireVol::AABox ( *from_function_type )( ::SireMaths::Vector const &,::SireMaths::Vector const & );
from_function_type from_function_value( &::SireVol::AABox::from );
AABox_exposer.def(
"from"
, from_function_value
, ( bp::arg("mincoords"), bp::arg("maxcoords") ) );
}
{ //::SireVol::AABox::halfExtents
typedef ::SireMaths::Vector const & ( ::SireVol::AABox::*halfExtents_function_type )( ) const;
halfExtents_function_type halfExtents_function_value( &::SireVol::AABox::halfExtents );
AABox_exposer.def(
"halfExtents"
, halfExtents_function_value
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireVol::AABox::intersects
typedef bool ( ::SireVol::AABox::*intersects_function_type )( ::SireVol::AABox const & ) const;
intersects_function_type intersects_function_value( &::SireVol::AABox::intersects );
AABox_exposer.def(
"intersects"
, intersects_function_value
, ( bp::arg("other") ) );
}
{ //::SireVol::AABox::isEmpty
typedef bool ( ::SireVol::AABox::*isEmpty_function_type )( ) const;
isEmpty_function_type isEmpty_function_value( &::SireVol::AABox::isEmpty );
AABox_exposer.def(
"isEmpty"
, isEmpty_function_value );
}
{ //::SireVol::AABox::isNull
typedef bool ( ::SireVol::AABox::*isNull_function_type )( ) const;
isNull_function_type isNull_function_value( &::SireVol::AABox::isNull );
AABox_exposer.def(
"isNull"
, isNull_function_value );
}
{ //::SireVol::AABox::maxCoords
typedef ::SireMaths::Vector ( ::SireVol::AABox::*maxCoords_function_type )( ) const;
maxCoords_function_type maxCoords_function_value( &::SireVol::AABox::maxCoords );
AABox_exposer.def(
"maxCoords"
, maxCoords_function_value );
}
{ //::SireVol::AABox::minCoords
typedef ::SireMaths::Vector ( ::SireVol::AABox::*minCoords_function_type )( ) const;
minCoords_function_type minCoords_function_value( &::SireVol::AABox::minCoords );
AABox_exposer.def(
"minCoords"
, minCoords_function_value );
}
AABox_exposer.def( bp::self != bp::self );
AABox_exposer.def( bp::self + bp::self );
AABox_exposer.def( bp::self + bp::other< SireMaths::Vector >() );
AABox_exposer.def( bp::self + bp::other< QVector< SireMaths::Vector > >() );
{ //::SireVol::AABox::operator=
typedef ::SireVol::AABox const & ( ::SireVol::AABox::*assign_function_type )( ::SireVol::AABox const & ) ;
assign_function_type assign_function_value( &::SireVol::AABox::operator= );
AABox_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_value_policy< bp::copy_const_reference >() );
}
AABox_exposer.def( bp::self == bp::self );
{ //::SireVol::AABox::radius
typedef double ( ::SireVol::AABox::*radius_function_type )( ) const;
radius_function_type radius_function_value( &::SireVol::AABox::radius );
AABox_exposer.def(
"radius"
, radius_function_value );
}
{ //::SireVol::AABox::recalculate
typedef void ( ::SireVol::AABox::*recalculate_function_type )( ::SireVol::CoordGroupBase const & ) ;
recalculate_function_type recalculate_function_value( &::SireVol::AABox::recalculate );
AABox_exposer.def(
"recalculate"
, recalculate_function_value
, ( bp::arg("coordgroup") ) );
}
{ //::SireVol::AABox::recalculate
typedef void ( ::SireVol::AABox::*recalculate_function_type )( ::SireVol::CoordGroupArray const & ) ;
recalculate_function_type recalculate_function_value( &::SireVol::AABox::recalculate );
AABox_exposer.def(
"recalculate"
, recalculate_function_value
, ( bp::arg("cgarray") ) );
}
{ //::SireVol::AABox::recalculate
typedef void ( ::SireVol::AABox::*recalculate_function_type )( ::SireVol::CoordGroupArrayArray const & ) ;
recalculate_function_type recalculate_function_value( &::SireVol::AABox::recalculate );
AABox_exposer.def(
"recalculate"
, recalculate_function_value
, ( bp::arg("cgarrays") ) );
}
{ //::SireVol::AABox::recalculate
typedef void ( ::SireVol::AABox::*recalculate_function_type )( ::QVector< SireMaths::Vector > const & ) ;
recalculate_function_type recalculate_function_value( &::SireVol::AABox::recalculate );
AABox_exposer.def(
"recalculate"
, recalculate_function_value
, ( bp::arg("coordinates") ) );
}
{ //::SireVol::AABox::toString
typedef ::QString ( ::SireVol::AABox::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireVol::AABox::toString );
AABox_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireVol::AABox::translate
typedef void ( ::SireVol::AABox::*translate_function_type )( ::SireMaths::Vector const & ) ;
translate_function_type translate_function_value( &::SireVol::AABox::translate );
AABox_exposer.def(
"translate"
, translate_function_value
, ( bp::arg("delta") ) );
}
{ //::SireVol::AABox::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireVol::AABox::typeName );
AABox_exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireVol::AABox::what
typedef char const * ( ::SireVol::AABox::*what_function_type )( ) const;
what_function_type what_function_value( &::SireVol::AABox::what );
AABox_exposer.def(
"what"
, what_function_value );
}
{ //::SireVol::AABox::withinDistance
typedef bool ( ::SireVol::AABox::*withinDistance_function_type )( double,::SireVol::AABox const & ) const;
withinDistance_function_type withinDistance_function_value( &::SireVol::AABox::withinDistance );
AABox_exposer.def(
"withinDistance"
, withinDistance_function_value
, ( bp::arg("dist"), bp::arg("box") ) );
}
AABox_exposer.staticmethod( "from" );
AABox_exposer.staticmethod( "typeName" );
AABox_exposer.def( "__copy__", &__copy__);
AABox_exposer.def( "__deepcopy__", &__copy__);
AABox_exposer.def( "clone", &__copy__);
AABox_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireVol::AABox >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
AABox_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireVol::AABox >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
AABox_exposer.def( "__str__", &__str__< ::SireVol::AABox > );
AABox_exposer.def( "__repr__", &__str__< ::SireVol::AABox > );
}
}
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_Condition_class(){
{ //::SireCAS::Condition
typedef bp::class_< SireCAS::Condition, bp::bases< SireCAS::ExBase >, boost::noncopyable > Condition_exposer_t;
Condition_exposer_t Condition_exposer = Condition_exposer_t( "Condition", bp::no_init );
bp::scope Condition_scope( Condition_exposer );
{ //::SireCAS::Condition::alwaysFalse
typedef bool ( ::SireCAS::Condition::*alwaysFalse_function_type )( ) const;
alwaysFalse_function_type alwaysFalse_function_value( &::SireCAS::Condition::alwaysFalse );
Condition_exposer.def(
"alwaysFalse"
, alwaysFalse_function_value );
}
{ //::SireCAS::Condition::alwaysTrue
typedef bool ( ::SireCAS::Condition::*alwaysTrue_function_type )( ) const;
alwaysTrue_function_type alwaysTrue_function_value( &::SireCAS::Condition::alwaysTrue );
Condition_exposer.def(
"alwaysTrue"
, alwaysTrue_function_value );
}
{ //::SireCAS::Condition::children
typedef ::SireCAS::Expressions ( ::SireCAS::Condition::*children_function_type )( ) const;
children_function_type children_function_value( &::SireCAS::Condition::children );
Condition_exposer.def(
"children"
, children_function_value );
}
{ //::SireCAS::Condition::conjugate
typedef ::SireCAS::Expression ( ::SireCAS::Condition::*conjugate_function_type )( ) const;
conjugate_function_type conjugate_function_value( &::SireCAS::Condition::conjugate );
Condition_exposer.def(
"conjugate"
, conjugate_function_value );
}
{ //::SireCAS::Condition::differentiate
typedef ::SireCAS::Expression ( ::SireCAS::Condition::*differentiate_function_type )( ::SireCAS::Symbol const & ) const;
differentiate_function_type differentiate_function_value( &::SireCAS::Condition::differentiate );
Condition_exposer.def(
"differentiate"
, differentiate_function_value
, ( bp::arg("symbol") ) );
}
{ //::SireCAS::Condition::evaluate
typedef double ( ::SireCAS::Condition::*evaluate_function_type )( ::SireCAS::Values const & ) const;
evaluate_function_type evaluate_function_value( &::SireCAS::Condition::evaluate );
Condition_exposer.def(
"evaluate"
, evaluate_function_value
, ( bp::arg("values") ) );
}
{ //::SireCAS::Condition::evaluate
typedef ::SireMaths::Complex ( ::SireCAS::Condition::*evaluate_function_type )( ::SireCAS::ComplexValues const & ) const;
evaluate_function_type evaluate_function_value( &::SireCAS::Condition::evaluate );
Condition_exposer.def(
"evaluate"
, evaluate_function_value
, ( bp::arg("values") ) );
}
{ //::SireCAS::Condition::evaluateCondition
typedef bool ( ::SireCAS::Condition::*evaluateCondition_function_type )( ::SireCAS::Values const & ) const;
evaluateCondition_function_type evaluateCondition_function_value( &::SireCAS::Condition::evaluateCondition );
Condition_exposer.def(
"evaluateCondition"
, evaluateCondition_function_value
, ( bp::arg("values") ) );
}
{ //::SireCAS::Condition::evaluateCondition
typedef bool ( ::SireCAS::Condition::*evaluateCondition_function_type )( ::SireCAS::ComplexValues const & ) const;
evaluateCondition_function_type evaluateCondition_function_value( &::SireCAS::Condition::evaluateCondition );
Condition_exposer.def(
"evaluateCondition"
, evaluateCondition_function_value
, ( bp::arg("values") ) );
}
{ //::SireCAS::Condition::expand
typedef ::QList< SireCAS::Factor > ( ::SireCAS::Condition::*expand_function_type )( ::SireCAS::Symbol const & ) const;
expand_function_type expand_function_value( &::SireCAS::Condition::expand );
Condition_exposer.def(
"expand"
, expand_function_value
, ( bp::arg("symbol") ) );
}
{ //::SireCAS::Condition::functions
typedef ::SireCAS::Functions ( ::SireCAS::Condition::*functions_function_type )( ) const;
functions_function_type functions_function_value( &::SireCAS::Condition::functions );
Condition_exposer.def(
"functions"
, functions_function_value );
}
{ //::SireCAS::Condition::hash
typedef ::uint ( ::SireCAS::Condition::*hash_function_type )( ) const;
hash_function_type hash_function_value( &::SireCAS::Condition::hash );
Condition_exposer.def(
"hash"
, hash_function_value );
}
{ //::SireCAS::Condition::integrate
typedef ::SireCAS::Expression ( ::SireCAS::Condition::*integrate_function_type )( ::SireCAS::Symbol const & ) const;
integrate_function_type integrate_function_value( &::SireCAS::Condition::integrate );
Condition_exposer.def(
"integrate"
, integrate_function_value
, ( bp::arg("symbol") ) );
}
{ //::SireCAS::Condition::isComplex
typedef bool ( ::SireCAS::Condition::*isComplex_function_type )( ) const;
isComplex_function_type isComplex_function_value( &::SireCAS::Condition::isComplex );
Condition_exposer.def(
"isComplex"
, isComplex_function_value );
}
{ //::SireCAS::Condition::isCompound
typedef bool ( ::SireCAS::Condition::*isCompound_function_type )( ) const;
isCompound_function_type isCompound_function_value( &::SireCAS::Condition::isCompound );
Condition_exposer.def(
"isCompound"
, isCompound_function_value );
}
{ //::SireCAS::Condition::isConstant
typedef bool ( ::SireCAS::Condition::*isConstant_function_type )( ) const;
isConstant_function_type isConstant_function_value( &::SireCAS::Condition::isConstant );
Condition_exposer.def(
"isConstant"
, isConstant_function_value );
}
{ //::SireCAS::Condition::isFunction
typedef bool ( ::SireCAS::Condition::*isFunction_function_type )( ::SireCAS::Symbol const & ) const;
isFunction_function_type isFunction_function_value( &::SireCAS::Condition::isFunction );
Condition_exposer.def(
"isFunction"
, isFunction_function_value
, ( bp::arg("arg0") ) );
}
{ //::SireCAS::Condition::isNull
typedef bool ( ::SireCAS::Condition::*isNull_function_type )( ) const;
isNull_function_type isNull_function_value( &::SireCAS::Condition::isNull );
Condition_exposer.def(
"isNull"
, isNull_function_value );
}
{ //::SireCAS::Condition::leftHandSide
typedef ::SireCAS::Expression const & ( ::SireCAS::Condition::*leftHandSide_function_type )( ) const;
leftHandSide_function_type leftHandSide_function_value( &::SireCAS::Condition::leftHandSide );
Condition_exposer.def(
"leftHandSide"
, leftHandSide_function_value
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireCAS::Condition::rightHandSide
typedef ::SireCAS::Expression const & ( ::SireCAS::Condition::*rightHandSide_function_type )( ) const;
rightHandSide_function_type rightHandSide_function_value( &::SireCAS::Condition::rightHandSide );
Condition_exposer.def(
"rightHandSide"
, rightHandSide_function_value
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireCAS::Condition::simplify
typedef ::SireCAS::Expression ( ::SireCAS::Condition::*simplify_function_type )( int ) const;
simplify_function_type simplify_function_value( &::SireCAS::Condition::simplify );
Condition_exposer.def(
"simplify"
, simplify_function_value
, ( bp::arg("options")=(int)(0) ) );
}
{ //::SireCAS::Condition::substitute
typedef ::SireCAS::Expression ( ::SireCAS::Condition::*substitute_function_type )( ::SireCAS::Identities const & ) const;
substitute_function_type substitute_function_value( &::SireCAS::Condition::substitute );
Condition_exposer.def(
"substitute"
, substitute_function_value
, ( bp::arg("identities") ) );
}
{ //::SireCAS::Condition::symbols
typedef ::SireCAS::Symbols ( ::SireCAS::Condition::*symbols_function_type )( ) const;
symbols_function_type symbols_function_value( &::SireCAS::Condition::symbols );
Condition_exposer.def(
"symbols"
, symbols_function_value );
}
{ //::SireCAS::Condition::toString
typedef ::QString ( ::SireCAS::Condition::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireCAS::Condition::toString );
Condition_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireCAS::Condition::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireCAS::Condition::typeName );
Condition_exposer.def(
"typeName"
, typeName_function_value );
}
Condition_exposer.staticmethod( "typeName" );
Condition_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireCAS::Condition >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Condition_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireCAS::Condition >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Condition_exposer.def( "__str__", &__str__< ::SireCAS::Condition > );
Condition_exposer.def( "__repr__", &__str__< ::SireCAS::Condition > );
}
}
void register_ChainsWithRes_class(){
{ //::SireMol::ChainsWithRes
typedef bp::class_< SireMol::ChainsWithRes, bp::bases< SireMol::ChainID, SireID::ID > > ChainsWithRes_exposer_t;
ChainsWithRes_exposer_t ChainsWithRes_exposer = ChainsWithRes_exposer_t( "ChainsWithRes", "This ID class identifies chains that contain residues that\nmatch the passed ResID\n\nAuthor: Christopher Woods\n", bp::init< >("Null constructor") );
bp::scope ChainsWithRes_scope( ChainsWithRes_exposer );
ChainsWithRes_exposer.def( bp::init< SireMol::ResID const & >(( bp::arg("resid") ), "Construct from the passed residue ID") );
ChainsWithRes_exposer.def( bp::init< SireMol::ChainsWithRes const & >(( bp::arg("other") ), "Copy constructor") );
{ //::SireMol::ChainsWithRes::hash
typedef ::uint ( ::SireMol::ChainsWithRes::*hash_function_type)( ) const;
hash_function_type hash_function_value( &::SireMol::ChainsWithRes::hash );
ChainsWithRes_exposer.def(
"hash"
, hash_function_value
, "Return a hash of this identifier" );
}
{ //::SireMol::ChainsWithRes::isNull
typedef bool ( ::SireMol::ChainsWithRes::*isNull_function_type)( ) const;
isNull_function_type isNull_function_value( &::SireMol::ChainsWithRes::isNull );
ChainsWithRes_exposer.def(
"isNull"
, isNull_function_value
, "Is this selection null?" );
}
{ //::SireMol::ChainsWithRes::map
typedef ::QList< SireMol::ChainIdx > ( ::SireMol::ChainsWithRes::*map_function_type)( ::SireMol::MolInfo const & ) const;
map_function_type map_function_value( &::SireMol::ChainsWithRes::map );
ChainsWithRes_exposer.def(
"map"
, map_function_value
, ( bp::arg("molinfo") )
, "Map this ID to the list of indicies of chains that match this ID\nThrow: SireMol::missing_chain\nThrow: SireError::invalid_index\n" );
}
ChainsWithRes_exposer.def( bp::self != bp::self );
{ //::SireMol::ChainsWithRes::operator=
typedef ::SireMol::ChainsWithRes & ( ::SireMol::ChainsWithRes::*assign_function_type)( ::SireMol::ChainsWithRes const & ) ;
assign_function_type assign_function_value( &::SireMol::ChainsWithRes::operator= );
ChainsWithRes_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >()
, "" );
}
ChainsWithRes_exposer.def( bp::self == bp::other< SireID::ID >() );
ChainsWithRes_exposer.def( bp::self == bp::self );
{ //::SireMol::ChainsWithRes::resID
typedef ::SireMol::ResID const & ( ::SireMol::ChainsWithRes::*resID_function_type)( ) const;
resID_function_type resID_function_value( &::SireMol::ChainsWithRes::resID );
ChainsWithRes_exposer.def(
"resID"
, resID_function_value
, bp::return_value_policy<bp::clone_const_reference>()
, "Return the residue ID" );
}
{ //::SireMol::ChainsWithRes::toString
typedef ::QString ( ::SireMol::ChainsWithRes::*toString_function_type)( ) const;
toString_function_type toString_function_value( &::SireMol::ChainsWithRes::toString );
ChainsWithRes_exposer.def(
"toString"
, toString_function_value
, "Return a string representatio of this ID" );
}
{ //::SireMol::ChainsWithRes::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMol::ChainsWithRes::typeName );
ChainsWithRes_exposer.def(
"typeName"
, typeName_function_value
, "" );
}
{ //::SireMol::ChainsWithRes::what
typedef char const * ( ::SireMol::ChainsWithRes::*what_function_type)( ) const;
what_function_type what_function_value( &::SireMol::ChainsWithRes::what );
ChainsWithRes_exposer.def(
"what"
, what_function_value
, "" );
}
ChainsWithRes_exposer.staticmethod( "typeName" );
ChainsWithRes_exposer.def( "__copy__", &__copy__);
ChainsWithRes_exposer.def( "__deepcopy__", &__copy__);
ChainsWithRes_exposer.def( "clone", &__copy__);
ChainsWithRes_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::ChainsWithRes >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
ChainsWithRes_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::ChainsWithRes >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
ChainsWithRes_exposer.def( "__str__", &__str__< ::SireMol::ChainsWithRes > );
ChainsWithRes_exposer.def( "__repr__", &__str__< ::SireMol::ChainsWithRes > );
ChainsWithRes_exposer.def( "__hash__", &::SireMol::ChainsWithRes::hash );
}
}
void register_Symbol_class(){
{ //::SireCAS::Symbol
typedef bp::class_< SireCAS::Symbol, bp::bases< SireCAS::ExBase > > Symbol_exposer_t;
Symbol_exposer_t Symbol_exposer = Symbol_exposer_t( "Symbol", bp::init< >() );
bp::scope Symbol_scope( Symbol_exposer );
Symbol_exposer.def( bp::init< SireCAS::SymbolID >(( bp::arg("symid") )) );
Symbol_exposer.def( bp::init< QString const & >(( bp::arg("rep") )) );
Symbol_exposer.def( bp::init< SireCAS::Symbol const & >(( bp::arg("other") )) );
{ //::SireCAS::Symbol::ID
typedef ::SireCAS::SymbolID ( ::SireCAS::Symbol::*ID_function_type )( ) const;
ID_function_type ID_function_value( &::SireCAS::Symbol::ID );
Symbol_exposer.def(
"ID"
, ID_function_value );
}
{ //::SireCAS::Symbol::children
typedef ::SireCAS::Expressions ( ::SireCAS::Symbol::*children_function_type )( ) const;
children_function_type children_function_value( &::SireCAS::Symbol::children );
Symbol_exposer.def(
"children"
, children_function_value );
}
{ //::SireCAS::Symbol::differentiate
typedef ::SireCAS::Expression ( ::SireCAS::Symbol::*differentiate_function_type )( ::SireCAS::Symbol const & ) const;
differentiate_function_type differentiate_function_value( &::SireCAS::Symbol::differentiate );
Symbol_exposer.def(
"differentiate"
, differentiate_function_value
, ( bp::arg("symbol") ) );
}
{ //::SireCAS::Symbol::evaluate
typedef double ( ::SireCAS::Symbol::*evaluate_function_type )( ::SireCAS::Values const & ) const;
evaluate_function_type evaluate_function_value( &::SireCAS::Symbol::evaluate );
Symbol_exposer.def(
"evaluate"
, evaluate_function_value
, ( bp::arg("values") ) );
}
{ //::SireCAS::Symbol::evaluate
typedef ::SireMaths::Complex ( ::SireCAS::Symbol::*evaluate_function_type )( ::SireCAS::ComplexValues const & ) const;
evaluate_function_type evaluate_function_value( &::SireCAS::Symbol::evaluate );
Symbol_exposer.def(
"evaluate"
, evaluate_function_value
, ( bp::arg("values") ) );
}
{ //::SireCAS::Symbol::expand
typedef ::QList< SireCAS::Factor > ( ::SireCAS::Symbol::*expand_function_type )( ::SireCAS::Symbol const & ) const;
expand_function_type expand_function_value( &::SireCAS::Symbol::expand );
Symbol_exposer.def(
"expand"
, expand_function_value
, ( bp::arg("symbol") ) );
}
{ //::SireCAS::Symbol::functions
typedef ::SireCAS::Functions ( ::SireCAS::Symbol::*functions_function_type )( ) const;
functions_function_type functions_function_value( &::SireCAS::Symbol::functions );
Symbol_exposer.def(
"functions"
, functions_function_value );
}
{ //::SireCAS::Symbol::hash
typedef ::uint ( ::SireCAS::Symbol::*hash_function_type )( ) const;
hash_function_type hash_function_value( &::SireCAS::Symbol::hash );
Symbol_exposer.def(
"hash"
, hash_function_value );
}
{ //::SireCAS::Symbol::integrate
typedef ::SireCAS::Expression ( ::SireCAS::Symbol::*integrate_function_type )( ::SireCAS::Symbol const & ) const;
integrate_function_type integrate_function_value( &::SireCAS::Symbol::integrate );
Symbol_exposer.def(
"integrate"
, integrate_function_value
, ( bp::arg("symbol") ) );
}
{ //::SireCAS::Symbol::isConstant
typedef bool ( ::SireCAS::Symbol::*isConstant_function_type )( ) const;
isConstant_function_type isConstant_function_value( &::SireCAS::Symbol::isConstant );
Symbol_exposer.def(
"isConstant"
, isConstant_function_value );
}
{ //::SireCAS::Symbol::isFunction
typedef bool ( ::SireCAS::Symbol::*isFunction_function_type )( ::SireCAS::Symbol const & ) const;
isFunction_function_type isFunction_function_value( &::SireCAS::Symbol::isFunction );
Symbol_exposer.def(
"isFunction"
, isFunction_function_value
, ( bp::arg("arg0") ) );
}
{ //::SireCAS::Symbol::isNull
typedef bool ( ::SireCAS::Symbol::*isNull_function_type )( ) const;
isNull_function_type isNull_function_value( &::SireCAS::Symbol::isNull );
Symbol_exposer.def(
"isNull"
, isNull_function_value );
}
Symbol_exposer.def( bp::self < bp::self );
Symbol_exposer.def( bp::self <= bp::self );
{ //::SireCAS::Symbol::operator=
typedef ::SireCAS::Symbol & ( ::SireCAS::Symbol::*assign_function_type )( ::SireCAS::Symbol const & ) ;
assign_function_type assign_function_value( &::SireCAS::Symbol::operator= );
Symbol_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
{ //::SireCAS::Symbol::operator=
typedef ::SireCAS::Symbol & ( ::SireCAS::Symbol::*assign_function_type )( ::SireCAS::SymbolID ) ;
assign_function_type assign_function_value( &::SireCAS::Symbol::operator= );
Symbol_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("symid") )
, bp::return_self< >() );
}
Symbol_exposer.def( bp::self == bp::other< double >() );
Symbol_exposer.def( bp::self == bp::other< int >() );
Symbol_exposer.def( bp::self == bp::other< SireMaths::Complex >() );
Symbol_exposer.def( bp::self == bp::other< SireCAS::Expression >() );
Symbol_exposer.def( bp::self == bp::other< SireCAS::ExBase >() );
Symbol_exposer.def( bp::self > bp::self );
Symbol_exposer.def( bp::self >= bp::self );
{ //::SireCAS::Symbol::substitute
typedef ::SireCAS::Expression ( ::SireCAS::Symbol::*substitute_function_type )( ::SireCAS::Identities const & ) const;
substitute_function_type substitute_function_value( &::SireCAS::Symbol::substitute );
Symbol_exposer.def(
"substitute"
, substitute_function_value
, ( bp::arg("identities") ) );
}
{ //::SireCAS::Symbol::symbols
typedef ::SireCAS::Symbols ( ::SireCAS::Symbol::*symbols_function_type )( ) const;
symbols_function_type symbols_function_value( &::SireCAS::Symbol::symbols );
Symbol_exposer.def(
"symbols"
, symbols_function_value );
}
{ //::SireCAS::Symbol::toString
typedef ::QString ( ::SireCAS::Symbol::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireCAS::Symbol::toString );
Symbol_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireCAS::Symbol::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireCAS::Symbol::typeName );
Symbol_exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireCAS::Symbol::what
typedef char const * ( ::SireCAS::Symbol::*what_function_type )( ) const;
what_function_type what_function_value( &::SireCAS::Symbol::what );
Symbol_exposer.def(
"what"
, what_function_value );
}
Symbol_exposer.staticmethod( "typeName" );
Symbol_exposer.def( "__copy__", &__copy__);
Symbol_exposer.def( "__deepcopy__", &__copy__);
Symbol_exposer.def( "clone", &__copy__);
Symbol_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireCAS::Symbol >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Symbol_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireCAS::Symbol >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Symbol_exposer.def( "__str__", &__str__< ::SireCAS::Symbol > );
Symbol_exposer.def( "__repr__", &__str__< ::SireCAS::Symbol > );
}
}
