void register_HistogramValue_class(){
{ //::SireMaths::HistogramValue
typedef bp::class_< SireMaths::HistogramValue, bp::bases< SireMaths::HistogramBin > > HistogramValue_exposer_t;
HistogramValue_exposer_t HistogramValue_exposer = HistogramValue_exposer_t( "HistogramValue", "This class represents a single histogram bin with its associated value", bp::init< >("Null constructor") );
bp::scope HistogramValue_scope( HistogramValue_exposer );
HistogramValue_exposer.def( bp::init< SireMaths::HistogramBin const &, double >(( bp::arg("bin"), bp::arg("value") ), "Construct the value for the bin bin equal to value") );
HistogramValue_exposer.def( bp::init< SireMaths::HistogramValue const & >(( bp::arg("other") ), "Copy constructor") );
HistogramValue_exposer.def( bp::self != bp::self );
{ //::SireMaths::HistogramValue::operator=
typedef ::SireMaths::HistogramValue & ( ::SireMaths::HistogramValue::*assign_function_type)( ::SireMaths::HistogramValue const & ) ;
assign_function_type assign_function_value( &::SireMaths::HistogramValue::operator= );
HistogramValue_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >()
, "" );
}
HistogramValue_exposer.def( bp::self == bp::self );
{ //::SireMaths::HistogramValue::toString
typedef ::QString ( ::SireMaths::HistogramValue::*toString_function_type)( ) const;
toString_function_type toString_function_value( &::SireMaths::HistogramValue::toString );
HistogramValue_exposer.def(
"toString"
, toString_function_value
, "Return a string representation" );
}
{ //::SireMaths::HistogramValue::value
typedef double ( ::SireMaths::HistogramValue::*value_function_type)( ) const;
value_function_type value_function_value( &::SireMaths::HistogramValue::value );
HistogramValue_exposer.def(
"value"
, value_function_value
, "Return the value of the bin" );
}
HistogramValue_exposer.def( "__copy__", &__copy__);
HistogramValue_exposer.def( "__deepcopy__", &__copy__);
HistogramValue_exposer.def( "clone", &__copy__);
HistogramValue_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMaths::HistogramValue >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
HistogramValue_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMaths::HistogramValue >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
HistogramValue_exposer.def( "__str__", &__str__< ::SireMaths::HistogramValue > );
HistogramValue_exposer.def( "__repr__", &__str__< ::SireMaths::HistogramValue > );
}
}
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_SymbolComplex_class(){
{ //::SireCAS::SymbolComplex
typedef bp::class_< SireCAS::SymbolComplex > SymbolComplex_exposer_t;
SymbolComplex_exposer_t SymbolComplex_exposer = SymbolComplex_exposer_t( "SymbolComplex", bp::init< SireCAS::SymbolID, SireMaths::Complex const & >(( bp::arg("id"), bp::arg("val") )) );
bp::scope SymbolComplex_scope( SymbolComplex_exposer );
SymbolComplex_exposer.def( bp::init< SireCAS::SymbolID, double >(( bp::arg("id"), bp::arg("val") )) );
SymbolComplex_exposer.def( bp::init< SireCAS::SymbolValue const & >(( bp::arg("val") )) );
{ //::SireCAS::SymbolComplex::ID
typedef ::SireCAS::SymbolID ( ::SireCAS::SymbolComplex::*ID_function_type )( ) const;
ID_function_type ID_function_value( &::SireCAS::SymbolComplex::ID );
SymbolComplex_exposer.def(
"ID"
, ID_function_value );
}
{ //::SireCAS::SymbolComplex::value
typedef ::SireMaths::Complex const & ( ::SireCAS::SymbolComplex::*value_function_type )( ) const;
value_function_type value_function_value( &::SireCAS::SymbolComplex::value );
SymbolComplex_exposer.def(
"value"
, value_function_value
, bp::return_value_policy< bp::copy_const_reference >() );
}
SymbolComplex_exposer.def( "__copy__", &__copy__);
SymbolComplex_exposer.def( "__deepcopy__", &__copy__);
SymbolComplex_exposer.def( "clone", &__copy__);
SymbolComplex_exposer.def( "__str__", &pvt_get_name);
SymbolComplex_exposer.def( "__repr__", &pvt_get_name);
}
}
void register_Unit_class(){
{ //::SireUnits::Dimension::Unit
typedef bp::class_< SireUnits::Dimension::Unit, boost::noncopyable > Unit_exposer_t;
Unit_exposer_t Unit_exposer = Unit_exposer_t( "Unit", "This is the base class of all units - at its heart, this is\njust a scale factor - how many times the base unit is the\ncurrent value.\n\nAuthor: Christopher Woods\n", bp::no_init );
bp::scope Unit_scope( Unit_exposer );
{ //::SireUnits::Dimension::Unit::convertFromInternal
typedef double ( ::SireUnits::Dimension::Unit::*convertFromInternal_function_type)( double ) const;
convertFromInternal_function_type convertFromInternal_function_value( &::SireUnits::Dimension::Unit::convertFromInternal );
Unit_exposer.def(
"convertFromInternal"
, convertFromInternal_function_value
, ( bp::arg("value") )
, "" );
}
{ //::SireUnits::Dimension::Unit::convertToInternal
typedef double ( ::SireUnits::Dimension::Unit::*convertToInternal_function_type)( double ) const;
convertToInternal_function_type convertToInternal_function_value( &::SireUnits::Dimension::Unit::convertToInternal );
Unit_exposer.def(
"convertToInternal"
, convertToInternal_function_value
, ( bp::arg("value") )
, "" );
}
{ //::SireUnits::Dimension::Unit::scaleFactor
typedef double ( ::SireUnits::Dimension::Unit::*scaleFactor_function_type)( ) const;
scaleFactor_function_type scaleFactor_function_value( &::SireUnits::Dimension::Unit::scaleFactor );
Unit_exposer.def(
"scaleFactor"
, scaleFactor_function_value
, "" );
}
{ //::SireUnits::Dimension::Unit::value
typedef double ( ::SireUnits::Dimension::Unit::*value_function_type)( ) const;
value_function_type value_function_value( &::SireUnits::Dimension::Unit::value );
Unit_exposer.def(
"value"
, value_function_value
, "" );
}
Unit_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireUnits::Dimension::Unit >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Unit_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireUnits::Dimension::Unit >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Unit_exposer.def( "__str__", &pvt_get_name);
Unit_exposer.def( "__repr__", &pvt_get_name);
}
}
void register_Velocity3D_class(){
{ //::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >
typedef bp::class_< SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > > Velocity3D_exposer_t;
Velocity3D_exposer_t Velocity3D_exposer = Velocity3D_exposer_t( "Velocity3D", bp::init< >() );
bp::scope Velocity3D_scope( Velocity3D_exposer );
Velocity3D_exposer.def( bp::init< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > const & >(( bp::arg("val") )) );
Velocity3D_exposer.def( bp::init< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > const &, SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > const &, SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > const & >(( bp::arg("x"), bp::arg("y"), bp::arg("z") )) );
Velocity3D_exposer.def( bp::init< SireMaths::Vector const & >(( bp::arg("v") )) );
Velocity3D_exposer.def( bp::init< SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > const & >(( bp::arg("other") )) );
{ //::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::at
typedef SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > exported_class_t;
typedef ::SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > const & ( ::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::*at_function_type )( int ) const;
at_function_type at_function_value( &::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::at );
Velocity3D_exposer.def(
"at"
, at_function_value
, ( bp::arg("i") )
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::count
typedef SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > exported_class_t;
typedef int ( ::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::*count_function_type )( ) const;
count_function_type count_function_value( &::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::count );
Velocity3D_exposer.def(
"count"
, count_function_value );
}
Velocity3D_exposer.def( bp::self != bp::self );
Velocity3D_exposer.def( bp::self * bp::other< double >() );
Velocity3D_exposer.def( bp::self + bp::self );
Velocity3D_exposer.def( -bp::self );
Velocity3D_exposer.def( bp::self - bp::self );
Velocity3D_exposer.def( bp::self / bp::other< double >() );
{ //::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::operator=
typedef SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > exported_class_t;
typedef ::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > & ( ::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::*assign_function_type )( ::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > const & ) ;
assign_function_type assign_function_value( &::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::operator= );
Velocity3D_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
Velocity3D_exposer.def( bp::self == bp::self );
{ //::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::operator[]
typedef SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > exported_class_t;
typedef ::SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > const & ( ::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::*__getitem___function_type )( int ) const;
__getitem___function_type __getitem___function_value( &::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::operator[] );
Velocity3D_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("i") )
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::set
typedef SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > exported_class_t;
typedef void ( ::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::*set_function_type )( int,::SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > const & ) ;
set_function_type set_function_value( &::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::set );
Velocity3D_exposer.def(
"set"
, set_function_value
, ( bp::arg("i"), bp::arg("value") ) );
}
{ //::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::toString
typedef SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > exported_class_t;
typedef ::QString ( ::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::toString );
Velocity3D_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::typeName
typedef SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > exported_class_t;
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::typeName );
Velocity3D_exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::value
typedef SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > exported_class_t;
typedef ::SireMaths::Vector ( ::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::*value_function_type )( ) const;
value_function_type value_function_value( &::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::value );
Velocity3D_exposer.def(
"value"
, value_function_value );
}
{ //::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::x
typedef SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > exported_class_t;
typedef ::SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > const & ( ::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::*x_function_type )( ) const;
x_function_type x_function_value( &::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::x );
Velocity3D_exposer.def(
"x"
, x_function_value
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::y
typedef SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > exported_class_t;
typedef ::SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > const & ( ::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::*y_function_type )( ) const;
y_function_type y_function_value( &::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::y );
Velocity3D_exposer.def(
"y"
, y_function_value
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::z
typedef SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > exported_class_t;
typedef ::SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > const & ( ::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::*z_function_type )( ) const;
z_function_type z_function_value( &::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::z );
Velocity3D_exposer.def(
"z"
, z_function_value
, bp::return_value_policy< bp::copy_const_reference >() );
}
Velocity3D_exposer.staticmethod( "typeName" );
Velocity3D_exposer.def( "__copy__", &__copy__);
Velocity3D_exposer.def( "__deepcopy__", &__copy__);
Velocity3D_exposer.def( "clone", &__copy__);
Velocity3D_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMaths::Vector3D<SireUnits::Dimension::PhysUnit<0, 1, -1, 0, 0, 0, 0> > >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Velocity3D_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMaths::Vector3D<SireUnits::Dimension::PhysUnit<0, 1, -1, 0, 0, 0, 0> > >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Velocity3D_exposer.def( "__str__", &__str__< ::SireMaths::Vector3D<SireUnits::Dimension::PhysUnit<0, 1, -1, 0, 0, 0, 0> > > );
Velocity3D_exposer.def( "__repr__", &__str__< ::SireMaths::Vector3D<SireUnits::Dimension::PhysUnit<0, 1, -1, 0, 0, 0, 0> > > );
Velocity3D_exposer.def( "__len__", &__len_count< ::SireMaths::Vector3D<SireUnits::Dimension::PhysUnit<0, 1, -1, 0, 0, 0, 0> > > );
}
}
void register_ChunkedVector_double__class(){
{ //::SireBase::ChunkedVector< double, 100 >
typedef bp::class_< SireBase::ChunkedVector< double, 100 > > ChunkedVector_double__exposer_t;
ChunkedVector_double__exposer_t ChunkedVector_double__exposer = ChunkedVector_double__exposer_t( "ChunkedVector_double_", bp::init< >() );
bp::scope ChunkedVector_double__scope( ChunkedVector_double__exposer );
{ //::SireBase::ChunkedVector< double, 100 >::const_iterator
typedef bp::class_< SireBase::ChunkedVector< double, 100 >::const_iterator > const_iterator_exposer_t;
const_iterator_exposer_t const_iterator_exposer = const_iterator_exposer_t( "const_iterator", bp::init< >() );
bp::scope const_iterator_scope( const_iterator_exposer );
const_iterator_exposer.def( bp::init< SireBase::ChunkedVector< double, 100 >::const_iterator const & >(( bp::arg("other") )) );
const_iterator_exposer.def( bp::self != bp::self );
{ //::SireBase::ChunkedVector< double, 100 >::const_iterator::operator=
typedef ::SireBase::ChunkedVector< double, 100 >::const_iterator & ( ::SireBase::ChunkedVector< double, 100 >::const_iterator::*assign_function_type )( ::SireBase::ChunkedVector< double, 100 >::const_iterator const & ) ;
assign_function_type assign_function_value( &::SireBase::ChunkedVector< double, 100 >::const_iterator::operator= );
const_iterator_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
const_iterator_exposer.def( bp::self == bp::self );
}
{ //::SireBase::ChunkedVector< double, 100 >::iterator
typedef bp::class_< SireBase::ChunkedVector< double, 100 >::iterator > iterator_exposer_t;
iterator_exposer_t iterator_exposer = iterator_exposer_t( "iterator", bp::init< >() );
bp::scope iterator_scope( iterator_exposer );
iterator_exposer.def( bp::init< SireBase::ChunkedVector< double, 100 >::iterator const & >(( bp::arg("other") )) );
iterator_exposer.def( bp::self != bp::self );
{ //::SireBase::ChunkedVector< double, 100 >::iterator::operator=
typedef ::SireBase::ChunkedVector< double, 100 >::iterator & ( ::SireBase::ChunkedVector< double, 100 >::iterator::*assign_function_type )( ::SireBase::ChunkedVector< double, 100 >::iterator const & ) ;
assign_function_type assign_function_value( &::SireBase::ChunkedVector< double, 100 >::iterator::operator= );
iterator_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
iterator_exposer.def( bp::self == bp::self );
}
ChunkedVector_double__exposer.def( bp::init< int >(( bp::arg("size") )) );
ChunkedVector_double__exposer.def( bp::init< int, double const & >(( bp::arg("size"), bp::arg("value") )) );
ChunkedVector_double__exposer.def( bp::init< SireBase::ChunkedVector< double, 100 > const & >(( bp::arg("other") )) );
{ //::SireBase::ChunkedVector< double, 100 >::append
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef void ( ::SireBase::ChunkedVector< double, 100 >::*append_function_type )( double const & ) ;
append_function_type append_function_value( &::SireBase::ChunkedVector< double, 100 >::append );
ChunkedVector_double__exposer.def(
"append"
, append_function_value
, ( bp::arg("value") ) );
}
{ //::SireBase::ChunkedVector< double, 100 >::at
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef double const & ( ::SireBase::ChunkedVector< double, 100 >::*at_function_type )( int ) const;
at_function_type at_function_value( &::SireBase::ChunkedVector< double, 100 >::at );
ChunkedVector_double__exposer.def(
"at"
, at_function_value
, ( bp::arg("i") )
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireBase::ChunkedVector< double, 100 >::begin
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef ::SireBase::ChunkedVector< double, 100 >::iterator ( ::SireBase::ChunkedVector< double, 100 >::*begin_function_type )( ) ;
begin_function_type begin_function_value( &::SireBase::ChunkedVector< double, 100 >::begin );
ChunkedVector_double__exposer.def(
"begin"
, begin_function_value );
}
{ //::SireBase::ChunkedVector< double, 100 >::begin
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef ::SireBase::ChunkedVector< double, 100 >::const_iterator ( ::SireBase::ChunkedVector< double, 100 >::*begin_function_type )( ) const;
begin_function_type begin_function_value( &::SireBase::ChunkedVector< double, 100 >::begin );
ChunkedVector_double__exposer.def(
"begin"
, begin_function_value );
}
{ //::SireBase::ChunkedVector< double, 100 >::capacity
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef int ( ::SireBase::ChunkedVector< double, 100 >::*capacity_function_type )( ) const;
capacity_function_type capacity_function_value( &::SireBase::ChunkedVector< double, 100 >::capacity );
ChunkedVector_double__exposer.def(
"capacity"
, capacity_function_value );
}
{ //::SireBase::ChunkedVector< double, 100 >::clear
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef void ( ::SireBase::ChunkedVector< double, 100 >::*clear_function_type )( ) ;
clear_function_type clear_function_value( &::SireBase::ChunkedVector< double, 100 >::clear );
ChunkedVector_double__exposer.def(
"clear"
, clear_function_value );
}
{ //::SireBase::ChunkedVector< double, 100 >::constBegin
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef ::SireBase::ChunkedVector< double, 100 >::const_iterator ( ::SireBase::ChunkedVector< double, 100 >::*constBegin_function_type )( ) const;
constBegin_function_type constBegin_function_value( &::SireBase::ChunkedVector< double, 100 >::constBegin );
ChunkedVector_double__exposer.def(
"constBegin"
, constBegin_function_value );
}
{ //::SireBase::ChunkedVector< double, 100 >::constEnd
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef ::SireBase::ChunkedVector< double, 100 >::const_iterator ( ::SireBase::ChunkedVector< double, 100 >::*constEnd_function_type )( ) const;
constEnd_function_type constEnd_function_value( &::SireBase::ChunkedVector< double, 100 >::constEnd );
ChunkedVector_double__exposer.def(
"constEnd"
, constEnd_function_value );
}
{ //::SireBase::ChunkedVector< double, 100 >::count
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef int ( ::SireBase::ChunkedVector< double, 100 >::*count_function_type )( ) const;
count_function_type count_function_value( &::SireBase::ChunkedVector< double, 100 >::count );
ChunkedVector_double__exposer.def(
"count"
, count_function_value );
}
{ //::SireBase::ChunkedVector< double, 100 >::count
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef int ( ::SireBase::ChunkedVector< double, 100 >::*count_function_type )( double const & ) const;
count_function_type count_function_value( &::SireBase::ChunkedVector< double, 100 >::count );
ChunkedVector_double__exposer.def(
"count"
, count_function_value
, ( bp::arg("value") ) );
}
{ //::SireBase::ChunkedVector< double, 100 >::end
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef ::SireBase::ChunkedVector< double, 100 >::iterator ( ::SireBase::ChunkedVector< double, 100 >::*end_function_type )( ) ;
end_function_type end_function_value( &::SireBase::ChunkedVector< double, 100 >::end );
ChunkedVector_double__exposer.def(
"end"
, end_function_value );
}
{ //::SireBase::ChunkedVector< double, 100 >::end
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef ::SireBase::ChunkedVector< double, 100 >::const_iterator ( ::SireBase::ChunkedVector< double, 100 >::*end_function_type )( ) const;
end_function_type end_function_value( &::SireBase::ChunkedVector< double, 100 >::end );
ChunkedVector_double__exposer.def(
"end"
, end_function_value );
}
{ //::SireBase::ChunkedVector< double, 100 >::fromList
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef ::SireBase::ChunkedVector< double, 100 > ( *fromList_function_type )( ::QList< double > const & );
fromList_function_type fromList_function_value( &::SireBase::ChunkedVector< double, 100 >::fromList );
ChunkedVector_double__exposer.def(
"fromList"
, fromList_function_value
, ( bp::arg("list") ) );
}
{ //::SireBase::ChunkedVector< double, 100 >::fromStdVector
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef ::SireBase::ChunkedVector< double, 100 > ( *fromStdVector_function_type )( ::std::vector< double > const & );
fromStdVector_function_type fromStdVector_function_value( &::SireBase::ChunkedVector< double, 100 >::fromStdVector );
ChunkedVector_double__exposer.def(
"fromStdVector"
, fromStdVector_function_value
, ( bp::arg("vector") ) );
}
{ //::SireBase::ChunkedVector< double, 100 >::fromVector
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef ::SireBase::ChunkedVector< double, 100 > ( *fromVector_function_type )( ::QVector< double > const & );
fromVector_function_type fromVector_function_value( &::SireBase::ChunkedVector< double, 100 >::fromVector );
ChunkedVector_double__exposer.def(
"fromVector"
, fromVector_function_value
, ( bp::arg("vector") ) );
}
{ //::SireBase::ChunkedVector< double, 100 >::isEmpty
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef bool ( ::SireBase::ChunkedVector< double, 100 >::*isEmpty_function_type )( ) const;
isEmpty_function_type isEmpty_function_value( &::SireBase::ChunkedVector< double, 100 >::isEmpty );
ChunkedVector_double__exposer.def(
"isEmpty"
, isEmpty_function_value );
}
ChunkedVector_double__exposer.def( bp::self != bp::self );
{ //::SireBase::ChunkedVector< double, 100 >::operator=
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef ::SireBase::ChunkedVector< double, 100 > & ( ::SireBase::ChunkedVector< double, 100 >::*assign_function_type )( ::SireBase::ChunkedVector< double, 100 > const & ) ;
assign_function_type assign_function_value( &::SireBase::ChunkedVector< double, 100 >::operator= );
ChunkedVector_double__exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
ChunkedVector_double__exposer.def( bp::self == bp::self );
{ //::SireBase::ChunkedVector< double, 100 >::operator[]
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef double & ( ::SireBase::ChunkedVector< double, 100 >::*__getitem___function_type )( int ) ;
__getitem___function_type __getitem___function_value( &::SireBase::ChunkedVector< double, 100 >::operator[] );
ChunkedVector_double__exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("i") )
, bp::return_value_policy< bp::copy_non_const_reference >() );
}
{ //::SireBase::ChunkedVector< double, 100 >::operator[]
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef double const & ( ::SireBase::ChunkedVector< double, 100 >::*__getitem___function_type )( int ) const;
__getitem___function_type __getitem___function_value( &::SireBase::ChunkedVector< double, 100 >::operator[] );
ChunkedVector_double__exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("i") )
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireBase::ChunkedVector< double, 100 >::remove
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef void ( ::SireBase::ChunkedVector< double, 100 >::*remove_function_type )( int ) ;
remove_function_type remove_function_value( &::SireBase::ChunkedVector< double, 100 >::remove );
ChunkedVector_double__exposer.def(
"remove"
, remove_function_value
, ( bp::arg("i") ) );
}
{ //::SireBase::ChunkedVector< double, 100 >::remove
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef void ( ::SireBase::ChunkedVector< double, 100 >::*remove_function_type )( int,int ) ;
remove_function_type remove_function_value( &::SireBase::ChunkedVector< double, 100 >::remove );
ChunkedVector_double__exposer.def(
"remove"
, remove_function_value
, ( bp::arg("i"), bp::arg("count") ) );
}
{ //::SireBase::ChunkedVector< double, 100 >::reserve
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef void ( ::SireBase::ChunkedVector< double, 100 >::*reserve_function_type )( int ) ;
reserve_function_type reserve_function_value( &::SireBase::ChunkedVector< double, 100 >::reserve );
ChunkedVector_double__exposer.def(
"reserve"
, reserve_function_value
, ( bp::arg("count") ) );
}
{ //::SireBase::ChunkedVector< double, 100 >::resize
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef void ( ::SireBase::ChunkedVector< double, 100 >::*resize_function_type )( int ) ;
resize_function_type resize_function_value( &::SireBase::ChunkedVector< double, 100 >::resize );
ChunkedVector_double__exposer.def(
"resize"
, resize_function_value
, ( bp::arg("count") ) );
}
{ //::SireBase::ChunkedVector< double, 100 >::size
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef int ( ::SireBase::ChunkedVector< double, 100 >::*size_function_type )( ) const;
size_function_type size_function_value( &::SireBase::ChunkedVector< double, 100 >::size );
ChunkedVector_double__exposer.def(
"size"
, size_function_value );
}
{ //::SireBase::ChunkedVector< double, 100 >::squeeze
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef void ( ::SireBase::ChunkedVector< double, 100 >::*squeeze_function_type )( ) ;
squeeze_function_type squeeze_function_value( &::SireBase::ChunkedVector< double, 100 >::squeeze );
ChunkedVector_double__exposer.def(
"squeeze"
, squeeze_function_value );
}
{ //::SireBase::ChunkedVector< double, 100 >::toList
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef ::QList< double > ( ::SireBase::ChunkedVector< double, 100 >::*toList_function_type )( ) const;
toList_function_type toList_function_value( &::SireBase::ChunkedVector< double, 100 >::toList );
ChunkedVector_double__exposer.def(
"toList"
, toList_function_value );
}
{ //::SireBase::ChunkedVector< double, 100 >::toStdVector
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef ::std::vector< double > ( ::SireBase::ChunkedVector< double, 100 >::*toStdVector_function_type )( ) const;
toStdVector_function_type toStdVector_function_value( &::SireBase::ChunkedVector< double, 100 >::toStdVector );
ChunkedVector_double__exposer.def(
"toStdVector"
, toStdVector_function_value );
}
{ //::SireBase::ChunkedVector< double, 100 >::toVector
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef ::QVector< double > ( ::SireBase::ChunkedVector< double, 100 >::*toVector_function_type )( ) const;
toVector_function_type toVector_function_value( &::SireBase::ChunkedVector< double, 100 >::toVector );
ChunkedVector_double__exposer.def(
"toVector"
, toVector_function_value );
}
{ //::SireBase::ChunkedVector< double, 100 >::value
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef double ( ::SireBase::ChunkedVector< double, 100 >::*value_function_type )( int ) const;
value_function_type value_function_value( &::SireBase::ChunkedVector< double, 100 >::value );
ChunkedVector_double__exposer.def(
"value"
, value_function_value
, ( bp::arg("i") ) );
}
{ //::SireBase::ChunkedVector< double, 100 >::value
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef double ( ::SireBase::ChunkedVector< double, 100 >::*value_function_type )( int,double const & ) const;
value_function_type value_function_value( &::SireBase::ChunkedVector< double, 100 >::value );
ChunkedVector_double__exposer.def(
"value"
, value_function_value
, ( bp::arg("i"), bp::arg("default_value") ) );
}
ChunkedVector_double__exposer.staticmethod( "fromList" );
ChunkedVector_double__exposer.staticmethod( "fromStdVector" );
ChunkedVector_double__exposer.staticmethod( "fromVector" );
ChunkedVector_double__exposer.def( "__copy__", &__copy__);
ChunkedVector_double__exposer.def( "__deepcopy__", &__copy__);
ChunkedVector_double__exposer.def( "clone", &__copy__);
ChunkedVector_double__exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireBase::ChunkedVector<double, 100> >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
ChunkedVector_double__exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireBase::ChunkedVector<double, 100> >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
ChunkedVector_double__exposer.def( "__str__", &pvt_get_name);
ChunkedVector_double__exposer.def( "__repr__", &pvt_get_name);
ChunkedVector_double__exposer.def( "__len__", &__len_size< ::SireBase::ChunkedVector<double, 100> > );
}
}
void register_PropertyList_class(){
{ //::SireBase::PropertyList
typedef bp::class_< SireBase::PropertyList, bp::bases< SireBase::Property > > PropertyList_exposer_t;
PropertyList_exposer_t PropertyList_exposer = PropertyList_exposer_t( "PropertyList", bp::init< >() );
bp::scope PropertyList_scope( PropertyList_exposer );
PropertyList_exposer.def( bp::init< QList< SireBase::PropPtr< SireBase::Property > > const & >(( bp::arg("props") )) );
PropertyList_exposer.def( bp::init< SireBase::PropertyList const & >(( bp::arg("other") )) );
{ //::SireBase::PropertyList::append
typedef void ( ::SireBase::PropertyList::*append_function_type )( ::SireBase::Property const & ) ;
append_function_type append_function_value( &::SireBase::PropertyList::append );
PropertyList_exposer.def(
"append"
, append_function_value
, ( bp::arg("property") ) );
}
{ //::SireBase::PropertyList::append
typedef void ( ::SireBase::PropertyList::*append_function_type )( ::QList< SireBase::PropPtr< SireBase::Property > > const & ) ;
append_function_type append_function_value( &::SireBase::PropertyList::append );
PropertyList_exposer.def(
"append"
, append_function_value
, ( bp::arg("props") ) );
}
{ //::SireBase::PropertyList::array
typedef ::QList< SireBase::PropPtr< SireBase::Property > > ( ::SireBase::PropertyList::*array_function_type )( ) const;
array_function_type array_function_value( &::SireBase::PropertyList::array );
PropertyList_exposer.def(
"array"
, array_function_value );
}
{ //::SireBase::PropertyList::at
typedef ::SireBase::Property const & ( ::SireBase::PropertyList::*at_function_type )( int ) const;
at_function_type at_function_value( &::SireBase::PropertyList::at );
PropertyList_exposer.def(
"at"
, at_function_value
, ( bp::arg("i") )
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireBase::PropertyList::clear
typedef void ( ::SireBase::PropertyList::*clear_function_type )( ) ;
clear_function_type clear_function_value( &::SireBase::PropertyList::clear );
PropertyList_exposer.def(
"clear"
, clear_function_value );
}
{ //::SireBase::PropertyList::count
typedef int ( ::SireBase::PropertyList::*count_function_type )( ) const;
count_function_type count_function_value( &::SireBase::PropertyList::count );
PropertyList_exposer.def(
"count"
, count_function_value );
}
{ //::SireBase::PropertyList::empty
typedef bool ( ::SireBase::PropertyList::*empty_function_type )( ) const;
empty_function_type empty_function_value( &::SireBase::PropertyList::empty );
PropertyList_exposer.def(
"empty"
, empty_function_value );
}
{ //::SireBase::PropertyList::insert
typedef void ( ::SireBase::PropertyList::*insert_function_type )( int,::SireBase::Property const & ) ;
insert_function_type insert_function_value( &::SireBase::PropertyList::insert );
PropertyList_exposer.def(
"insert"
, insert_function_value
, ( bp::arg("i"), bp::arg("value") ) );
}
{ //::SireBase::PropertyList::isEmpty
typedef bool ( ::SireBase::PropertyList::*isEmpty_function_type )( ) const;
isEmpty_function_type isEmpty_function_value( &::SireBase::PropertyList::isEmpty );
PropertyList_exposer.def(
"isEmpty"
, isEmpty_function_value );
}
{ //::SireBase::PropertyList::mid
typedef ::SireBase::PropertyList ( ::SireBase::PropertyList::*mid_function_type )( int,int ) const;
mid_function_type mid_function_value( &::SireBase::PropertyList::mid );
PropertyList_exposer.def(
"mid"
, mid_function_value
, ( bp::arg("pos"), bp::arg("length")=(int)(-0x00000000000000001) ) );
}
{ //::SireBase::PropertyList::move
typedef void ( ::SireBase::PropertyList::*move_function_type )( int,int ) ;
move_function_type move_function_value( &::SireBase::PropertyList::move );
PropertyList_exposer.def(
"move"
, move_function_value
, ( bp::arg("from"), bp::arg("to") ) );
}
PropertyList_exposer.def( bp::self != bp::self );
PropertyList_exposer.def( bp::self + bp::self );
{ //::SireBase::PropertyList::operator=
typedef ::SireBase::PropertyList & ( ::SireBase::PropertyList::*assign_function_type )( ::SireBase::PropertyList const & ) ;
assign_function_type assign_function_value( &::SireBase::PropertyList::operator= );
PropertyList_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
PropertyList_exposer.def( bp::self == bp::self );
{ //::SireBase::PropertyList::operator[]
typedef ::SireBase::Property const & ( ::SireBase::PropertyList::*__getitem___function_type )( int ) const;
__getitem___function_type __getitem___function_value( &::SireBase::PropertyList::operator[] );
PropertyList_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("i") )
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireBase::PropertyList::pop_back
typedef void ( ::SireBase::PropertyList::*pop_back_function_type )( ) ;
pop_back_function_type pop_back_function_value( &::SireBase::PropertyList::pop_back );
PropertyList_exposer.def(
"pop_back"
, pop_back_function_value );
}
{ //::SireBase::PropertyList::pop_front
typedef void ( ::SireBase::PropertyList::*pop_front_function_type )( ) ;
pop_front_function_type pop_front_function_value( &::SireBase::PropertyList::pop_front );
PropertyList_exposer.def(
"pop_front"
, pop_front_function_value );
}
{ //::SireBase::PropertyList::prepend
typedef void ( ::SireBase::PropertyList::*prepend_function_type )( ::SireBase::Property const & ) ;
prepend_function_type prepend_function_value( &::SireBase::PropertyList::prepend );
PropertyList_exposer.def(
"prepend"
, prepend_function_value
, ( bp::arg("value") ) );
}
{ //::SireBase::PropertyList::push_back
typedef void ( ::SireBase::PropertyList::*push_back_function_type )( ::SireBase::Property const & ) ;
push_back_function_type push_back_function_value( &::SireBase::PropertyList::push_back );
PropertyList_exposer.def(
"push_back"
, push_back_function_value
, ( bp::arg("value") ) );
}
{ //::SireBase::PropertyList::push_front
typedef void ( ::SireBase::PropertyList::*push_front_function_type )( ::SireBase::Property const & ) ;
push_front_function_type push_front_function_value( &::SireBase::PropertyList::push_front );
PropertyList_exposer.def(
"push_front"
, push_front_function_value
, ( bp::arg("value") ) );
}
{ //::SireBase::PropertyList::removeAt
typedef void ( ::SireBase::PropertyList::*removeAt_function_type )( int ) ;
removeAt_function_type removeAt_function_value( &::SireBase::PropertyList::removeAt );
PropertyList_exposer.def(
"removeAt"
, removeAt_function_value
, ( bp::arg("i") ) );
}
{ //::SireBase::PropertyList::removeFirst
typedef void ( ::SireBase::PropertyList::*removeFirst_function_type )( ) ;
removeFirst_function_type removeFirst_function_value( &::SireBase::PropertyList::removeFirst );
PropertyList_exposer.def(
"removeFirst"
, removeFirst_function_value );
}
{ //::SireBase::PropertyList::removeLast
typedef void ( ::SireBase::PropertyList::*removeLast_function_type )( ) ;
removeLast_function_type removeLast_function_value( &::SireBase::PropertyList::removeLast );
PropertyList_exposer.def(
"removeLast"
, removeLast_function_value );
}
{ //::SireBase::PropertyList::replace
typedef void ( ::SireBase::PropertyList::*replace_function_type )( int,::SireBase::Property const & ) ;
replace_function_type replace_function_value( &::SireBase::PropertyList::replace );
PropertyList_exposer.def(
"replace"
, replace_function_value
, ( bp::arg("i"), bp::arg("value") ) );
}
{ //::SireBase::PropertyList::size
typedef int ( ::SireBase::PropertyList::*size_function_type )( ) const;
size_function_type size_function_value( &::SireBase::PropertyList::size );
PropertyList_exposer.def(
"size"
, size_function_value );
}
{ //::SireBase::PropertyList::swap
typedef void ( ::SireBase::PropertyList::*swap_function_type )( ::SireBase::PropertyList & ) ;
swap_function_type swap_function_value( &::SireBase::PropertyList::swap );
PropertyList_exposer.def(
"swap"
, swap_function_value
, ( bp::arg("other") ) );
}
{ //::SireBase::PropertyList::swap
typedef void ( ::SireBase::PropertyList::*swap_function_type )( int,int ) ;
swap_function_type swap_function_value( &::SireBase::PropertyList::swap );
PropertyList_exposer.def(
"swap"
, swap_function_value
, ( bp::arg("i"), bp::arg("j") ) );
}
{ //::SireBase::PropertyList::takeAt
typedef ::SireBase::PropertyPtr ( ::SireBase::PropertyList::*takeAt_function_type )( int ) ;
takeAt_function_type takeAt_function_value( &::SireBase::PropertyList::takeAt );
PropertyList_exposer.def(
"takeAt"
, takeAt_function_value
, ( bp::arg("i") ) );
}
{ //::SireBase::PropertyList::takeFirst
typedef ::SireBase::PropertyPtr ( ::SireBase::PropertyList::*takeFirst_function_type )( ) ;
takeFirst_function_type takeFirst_function_value( &::SireBase::PropertyList::takeFirst );
PropertyList_exposer.def(
"takeFirst"
, takeFirst_function_value );
}
{ //::SireBase::PropertyList::takeLast
typedef ::SireBase::PropertyPtr ( ::SireBase::PropertyList::*takeLast_function_type )( ) ;
takeLast_function_type takeLast_function_value( &::SireBase::PropertyList::takeLast );
PropertyList_exposer.def(
"takeLast"
, takeLast_function_value );
}
{ //::SireBase::PropertyList::toList
typedef ::QList< SireBase::PropPtr< SireBase::Property > > ( ::SireBase::PropertyList::*toList_function_type )( ) const;
toList_function_type toList_function_value( &::SireBase::PropertyList::toList );
PropertyList_exposer.def(
"toList"
, toList_function_value );
}
{ //::SireBase::PropertyList::toString
typedef ::QString ( ::SireBase::PropertyList::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireBase::PropertyList::toString );
PropertyList_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireBase::PropertyList::toVector
typedef ::QVector< SireBase::PropPtr< SireBase::Property > > ( ::SireBase::PropertyList::*toVector_function_type )( ) const;
toVector_function_type toVector_function_value( &::SireBase::PropertyList::toVector );
PropertyList_exposer.def(
"toVector"
, toVector_function_value );
}
{ //::SireBase::PropertyList::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireBase::PropertyList::typeName );
PropertyList_exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireBase::PropertyList::value
typedef ::SireBase::PropertyPtr ( ::SireBase::PropertyList::*value_function_type )( int ) const;
value_function_type value_function_value( &::SireBase::PropertyList::value );
PropertyList_exposer.def(
"value"
, value_function_value
, ( bp::arg("i") ) );
}
{ //::SireBase::PropertyList::value
typedef ::SireBase::PropertyPtr ( ::SireBase::PropertyList::*value_function_type )( int,::SireBase::Property const & ) const;
value_function_type value_function_value( &::SireBase::PropertyList::value );
PropertyList_exposer.def(
"value"
, value_function_value
, ( bp::arg("i"), bp::arg("default_value") ) );
}
PropertyList_exposer.staticmethod( "typeName" );
PropertyList_exposer.def( "__copy__", &__copy__);
PropertyList_exposer.def( "__deepcopy__", &__copy__);
PropertyList_exposer.def( "clone", &__copy__);
PropertyList_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireBase::PropertyList >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
PropertyList_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireBase::PropertyList >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
PropertyList_exposer.def( "__str__", &__str__< ::SireBase::PropertyList > );
PropertyList_exposer.def( "__repr__", &__str__< ::SireBase::PropertyList > );
PropertyList_exposer.def( "__len__", &__len_size< ::SireBase::PropertyList > );
}
}
void register_ComplexValues_class(){
{ //::SireCAS::ComplexValues
typedef bp::class_< SireCAS::ComplexValues > ComplexValues_exposer_t;
ComplexValues_exposer_t ComplexValues_exposer = ComplexValues_exposer_t( "ComplexValues", "\nThis class holds a set of Symbols and their associated complex values.\nThis is used when numerically evaluating an equation using complex maths.\n\nAuthor: Christopher Woods\n", bp::init< >("Construct an empty set of values") );
bp::scope ComplexValues_scope( ComplexValues_exposer );
ComplexValues_exposer.def( bp::init< QList< SireCAS::SymbolComplex > const & >(( bp::arg("values") ), "Construct from a list of values") );
ComplexValues_exposer.def( bp::init< QHash< SireCAS::Symbol, SireMaths::Complex > const & >(( bp::arg("values") ), "Construct from a hash of values indexed by symbol") );
ComplexValues_exposer.def( bp::init< SireCAS::SymbolComplex const & >(( bp::arg("symval0") ), "Construct from the passed values") );
ComplexValues_exposer.def( bp::init< SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const & >(( bp::arg("symval0"), bp::arg("symval1") ), "Construct from the passed values") );
ComplexValues_exposer.def( bp::init< SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const & >(( bp::arg("symval0"), bp::arg("symval1"), bp::arg("symval2") ), "Construct from the passed values") );
ComplexValues_exposer.def( bp::init< SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const & >(( bp::arg("symval0"), bp::arg("symval1"), bp::arg("symval2"), bp::arg("symval3") ), "Construct from the passed values") );
ComplexValues_exposer.def( bp::init< SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const & >(( bp::arg("symval0"), bp::arg("symval1"), bp::arg("symval2"), bp::arg("symval3"), bp::arg("symval4") ), "Construct from the passed values") );
ComplexValues_exposer.def( bp::init< SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const & >(( bp::arg("symval0"), bp::arg("symval1"), bp::arg("symval2"), bp::arg("symval3"), bp::arg("symval4"), bp::arg("symval5") ), "Construct from the passed values") );
ComplexValues_exposer.def( bp::init< SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const & >(( bp::arg("symval0"), bp::arg("symval1"), bp::arg("symval2"), bp::arg("symval3"), bp::arg("symval4"), bp::arg("symval5"), bp::arg("symval6") ), "Construct from the passed values") );
ComplexValues_exposer.def( bp::init< SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const & >(( bp::arg("symval0"), bp::arg("symval1"), bp::arg("symval2"), bp::arg("symval3"), bp::arg("symval4"), bp::arg("symval5"), bp::arg("symval6"), bp::arg("symval7") ), "Construct from the passed values") );
ComplexValues_exposer.def( bp::init< SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const & >(( bp::arg("symval0"), bp::arg("symval1"), bp::arg("symval2"), bp::arg("symval3"), bp::arg("symval4"), bp::arg("symval5"), bp::arg("symval6"), bp::arg("symval7"), bp::arg("symval8") ), "Construct from the passed values") );
ComplexValues_exposer.def( bp::init< SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const & >(( bp::arg("symval0"), bp::arg("symval1"), bp::arg("symval2"), bp::arg("symval3"), bp::arg("symval4"), bp::arg("symval5"), bp::arg("symval6"), bp::arg("symval7"), bp::arg("symval8"), bp::arg("symval9") ), "Construct from the passed values") );
ComplexValues_exposer.def( bp::init< SireCAS::Values const & >(( bp::arg("other") ), "Construct from Values") );
ComplexValues_exposer.def( bp::init< SireCAS::ComplexValues const & >(( bp::arg("other") ), "Copy constructor") );
{ //::SireCAS::ComplexValues::add
typedef void ( ::SireCAS::ComplexValues::*add_function_type)( ::SireCAS::SymbolComplex const & ) ;
add_function_type add_function_value( &::SireCAS::ComplexValues::add );
ComplexValues_exposer.def(
"add"
, add_function_value
, ( bp::arg("symval0") )
, "" );
}
{ //::SireCAS::ComplexValues::add
typedef void ( ::SireCAS::ComplexValues::*add_function_type)( ::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const & ) ;
add_function_type add_function_value( &::SireCAS::ComplexValues::add );
ComplexValues_exposer.def(
"add"
, add_function_value
, ( bp::arg("symval0"), bp::arg("symval1") )
, "Add the passed values" );
}
{ //::SireCAS::ComplexValues::add
typedef void ( ::SireCAS::ComplexValues::*add_function_type)( ::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const & ) ;
add_function_type add_function_value( &::SireCAS::ComplexValues::add );
ComplexValues_exposer.def(
"add"
, add_function_value
, ( bp::arg("symval0"), bp::arg("symval1"), bp::arg("symval2") )
, "Add the passed values" );
}
{ //::SireCAS::ComplexValues::add
typedef void ( ::SireCAS::ComplexValues::*add_function_type)( ::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const & ) ;
add_function_type add_function_value( &::SireCAS::ComplexValues::add );
ComplexValues_exposer.def(
"add"
, add_function_value
, ( bp::arg("symval0"), bp::arg("symval1"), bp::arg("symval2"), bp::arg("symval3") )
, "Add the passed values" );
}
{ //::SireCAS::ComplexValues::add
typedef void ( ::SireCAS::ComplexValues::*add_function_type)( ::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const & ) ;
add_function_type add_function_value( &::SireCAS::ComplexValues::add );
ComplexValues_exposer.def(
"add"
, add_function_value
, ( bp::arg("symval0"), bp::arg("symval1"), bp::arg("symval2"), bp::arg("symval3"), bp::arg("symval4") )
, "Add the passed values" );
}
{ //::SireCAS::ComplexValues::add
typedef void ( ::SireCAS::ComplexValues::*add_function_type)( ::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const & ) ;
add_function_type add_function_value( &::SireCAS::ComplexValues::add );
ComplexValues_exposer.def(
"add"
, add_function_value
, ( bp::arg("symval0"), bp::arg("symval1"), bp::arg("symval2"), bp::arg("symval3"), bp::arg("symval4"), bp::arg("symval5") )
, "Add the passed values" );
}
{ //::SireCAS::ComplexValues::add
typedef void ( ::SireCAS::ComplexValues::*add_function_type)( ::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const & ) ;
add_function_type add_function_value( &::SireCAS::ComplexValues::add );
ComplexValues_exposer.def(
"add"
, add_function_value
, ( bp::arg("symval0"), bp::arg("symval1"), bp::arg("symval2"), bp::arg("symval3"), bp::arg("symval4"), bp::arg("symval5"), bp::arg("symval6") )
, "Add the passed values" );
}
{ //::SireCAS::ComplexValues::add
typedef void ( ::SireCAS::ComplexValues::*add_function_type)( ::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const & ) ;
add_function_type add_function_value( &::SireCAS::ComplexValues::add );
ComplexValues_exposer.def(
"add"
, add_function_value
, ( bp::arg("symval0"), bp::arg("symval1"), bp::arg("symval2"), bp::arg("symval3"), bp::arg("symval4"), bp::arg("symval5"), bp::arg("symval6"), bp::arg("symval7") )
, "Add the passed values" );
}
{ //::SireCAS::ComplexValues::add
typedef void ( ::SireCAS::ComplexValues::*add_function_type)( ::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const & ) ;
add_function_type add_function_value( &::SireCAS::ComplexValues::add );
ComplexValues_exposer.def(
"add"
, add_function_value
, ( bp::arg("symval0"), bp::arg("symval1"), bp::arg("symval2"), bp::arg("symval3"), bp::arg("symval4"), bp::arg("symval5"), bp::arg("symval6"), bp::arg("symval7"), bp::arg("symval8") )
, "Add the passed values" );
}
{ //::SireCAS::ComplexValues::add
typedef void ( ::SireCAS::ComplexValues::*add_function_type)( ::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const & ) ;
add_function_type add_function_value( &::SireCAS::ComplexValues::add );
ComplexValues_exposer.def(
"add"
, add_function_value
, ( bp::arg("symval0"), bp::arg("symval1"), bp::arg("symval2"), bp::arg("symval3"), bp::arg("symval4"), bp::arg("symval5"), bp::arg("symval6"), bp::arg("symval7"), bp::arg("symval8"), bp::arg("symval9") )
, "Add the passed values" );
}
{ //::SireCAS::ComplexValues::set
typedef void ( ::SireCAS::ComplexValues::*set_function_type)( ::SireCAS::Symbol const &,::SireMaths::Complex const & ) ;
set_function_type set_function_value( &::SireCAS::ComplexValues::set );
ComplexValues_exposer.def(
"set"
, set_function_value
, ( bp::arg("symbol"), bp::arg("value") )
, "" );
}
{ //::SireCAS::ComplexValues::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireCAS::ComplexValues::typeName );
ComplexValues_exposer.def(
"typeName"
, typeName_function_value
, "" );
}
{ //::SireCAS::ComplexValues::value
typedef ::SireMaths::Complex ( ::SireCAS::ComplexValues::*value_function_type)( ::SireCAS::Symbol const & ) const;
value_function_type value_function_value( &::SireCAS::ComplexValues::value );
ComplexValues_exposer.def(
"value"
, value_function_value
, ( bp::arg("sym") )
, "Return the value of the Symbol with ID id, or 0.0 if there is no such symbol" );
}
{ //::SireCAS::ComplexValues::values
typedef ::QHash< unsigned int, SireMaths::Complex > const & ( ::SireCAS::ComplexValues::*values_function_type)( ) const;
values_function_type values_function_value( &::SireCAS::ComplexValues::values );
ComplexValues_exposer.def(
"values"
, values_function_value
, bp::return_value_policy< bp::copy_const_reference >()
, "" );
}
{ //::SireCAS::ComplexValues::what
typedef char const * ( ::SireCAS::ComplexValues::*what_function_type)( ) const;
what_function_type what_function_value( &::SireCAS::ComplexValues::what );
ComplexValues_exposer.def(
"what"
, what_function_value
, "" );
}
ComplexValues_exposer.staticmethod( "typeName" );
ComplexValues_exposer.def( "__copy__", &__copy__);
ComplexValues_exposer.def( "__deepcopy__", &__copy__);
ComplexValues_exposer.def( "clone", &__copy__);
ComplexValues_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireCAS::ComplexValues >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
ComplexValues_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireCAS::ComplexValues >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
ComplexValues_exposer.def( "__str__", &pvt_get_name);
ComplexValues_exposer.def( "__repr__", &pvt_get_name);
}
}
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_LengthProperty_class(){
{ //::SireBase::LengthProperty
typedef bp::class_< SireBase::LengthProperty, bp::bases< SireBase::Property > > LengthProperty_exposer_t;
LengthProperty_exposer_t LengthProperty_exposer = LengthProperty_exposer_t( "LengthProperty", bp::init< >() );
bp::scope LengthProperty_scope( LengthProperty_exposer );
LengthProperty_exposer.def( bp::init< SireUnits::Dimension::Length >(( bp::arg("value") )) );
LengthProperty_exposer.def( bp::init< SireBase::LengthProperty const & >(( bp::arg("other") )) );
LengthProperty_exposer.def( bp::self != bp::self );
{ //::SireBase::LengthProperty::operator=
typedef ::SireBase::LengthProperty & ( ::SireBase::LengthProperty::*assign_function_type )( ::SireBase::LengthProperty const & ) ;
assign_function_type assign_function_value( &::SireBase::LengthProperty::operator= );
LengthProperty_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
LengthProperty_exposer.def( bp::self == bp::self );
{ //::SireBase::LengthProperty::toString
typedef ::QString ( ::SireBase::LengthProperty::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireBase::LengthProperty::toString );
LengthProperty_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireBase::LengthProperty::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireBase::LengthProperty::typeName );
LengthProperty_exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireBase::LengthProperty::value
typedef ::SireUnits::Dimension::Length ( ::SireBase::LengthProperty::*value_function_type )( ) const;
value_function_type value_function_value( &::SireBase::LengthProperty::value );
LengthProperty_exposer.def(
"value"
, value_function_value );
}
LengthProperty_exposer.staticmethod( "typeName" );
LengthProperty_exposer.def( "__copy__", &__copy__);
LengthProperty_exposer.def( "__deepcopy__", &__copy__);
LengthProperty_exposer.def( "clone", &__copy__);
LengthProperty_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireBase::LengthProperty >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
LengthProperty_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireBase::LengthProperty >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
LengthProperty_exposer.def( "__str__", &__str__< ::SireBase::LengthProperty > );
LengthProperty_exposer.def( "__repr__", &__str__< ::SireBase::LengthProperty > );
}
}
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_NumberProperty_class(){
{ //::SireBase::NumberProperty
typedef bp::class_< SireBase::NumberProperty, bp::bases< SireBase::Property > > NumberProperty_exposer_t;
NumberProperty_exposer_t NumberProperty_exposer = NumberProperty_exposer_t( "NumberProperty", "This class provides a thin Property wrapper around numbers (doubles and ints)\n\nAuthor: Christopher Woods\n", bp::init< >("Constructor - this constructs the integer 0") );
bp::scope NumberProperty_scope( NumberProperty_exposer );
NumberProperty_exposer.def( bp::init< double >(( bp::arg("value") ), "Construct from the passed double") );
NumberProperty_exposer.def( bp::init< int >(( bp::arg("value") ), "Construct from the passed integer") );
NumberProperty_exposer.def( bp::init< qint64 >(( bp::arg("value") ), "Construct from the passed integer") );
NumberProperty_exposer.def( bp::init< SireBase::VariantProperty const & >(( bp::arg("other") ), "Construct from the passed VariantProperty") );
NumberProperty_exposer.def( bp::init< SireBase::NumberProperty const & >(( bp::arg("other") ), "Copy constructor") );
NumberProperty_exposer.def( bp::self != bp::self );
{ //::SireBase::NumberProperty::operator=
typedef ::SireBase::NumberProperty & ( ::SireBase::NumberProperty::*assign_function_type)( ::SireBase::NumberProperty const & ) ;
assign_function_type assign_function_value( &::SireBase::NumberProperty::operator= );
NumberProperty_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >()
, "" );
}
NumberProperty_exposer.def( bp::self == bp::self );
{ //::SireBase::NumberProperty::toDouble
typedef double ( ::SireBase::NumberProperty::*toDouble_function_type)( ) const;
toDouble_function_type toDouble_function_value( &::SireBase::NumberProperty::toDouble );
NumberProperty_exposer.def(
"toDouble"
, toDouble_function_value
, "Return this number cast as a double" );
}
{ //::SireBase::NumberProperty::toInt
typedef ::qint64 ( ::SireBase::NumberProperty::*toInt_function_type)( ) const;
toInt_function_type toInt_function_value( &::SireBase::NumberProperty::toInt );
NumberProperty_exposer.def(
"toInt"
, toInt_function_value
, "Return this number cast as an integer" );
}
{ //::SireBase::NumberProperty::toString
typedef ::QString ( ::SireBase::NumberProperty::*toString_function_type)( ) const;
toString_function_type toString_function_value( &::SireBase::NumberProperty::toString );
NumberProperty_exposer.def(
"toString"
, toString_function_value
, "" );
}
{ //::SireBase::NumberProperty::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireBase::NumberProperty::typeName );
NumberProperty_exposer.def(
"typeName"
, typeName_function_value
, "" );
}
{ //::SireBase::NumberProperty::value
typedef double ( ::SireBase::NumberProperty::*value_function_type)( ) const;
value_function_type value_function_value( &::SireBase::NumberProperty::value );
NumberProperty_exposer.def(
"value"
, value_function_value
, "Return this number cast as a double" );
}
NumberProperty_exposer.staticmethod( "typeName" );
NumberProperty_exposer.def( "__copy__", &__copy__);
NumberProperty_exposer.def( "__deepcopy__", &__copy__);
NumberProperty_exposer.def( "clone", &__copy__);
NumberProperty_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireBase::NumberProperty >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
NumberProperty_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireBase::NumberProperty >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
NumberProperty_exposer.def( "__str__", &__str__< ::SireBase::NumberProperty > );
NumberProperty_exposer.def( "__repr__", &__str__< ::SireBase::NumberProperty > );
}
}
