Ejemplo n.º 1
0
void register_TempBase_class(){

    { //::SireUnits::Dimension::TempBase
        typedef bp::class_< SireUnits::Dimension::TempBase, boost::noncopyable > TempBase_exposer_t;
        TempBase_exposer_t TempBase_exposer = TempBase_exposer_t( "TempBase", bp::no_init );
        bp::scope TempBase_scope( TempBase_exposer );
        { //::SireUnits::Dimension::TempBase::convertFromInternal
        
            typedef double ( ::SireUnits::Dimension::TempBase::*convertFromInternal_function_type )( double ) const;
            convertFromInternal_function_type convertFromInternal_function_value( &::SireUnits::Dimension::TempBase::convertFromInternal );
            
            TempBase_exposer.def( 
                "convertFromInternal"
                , convertFromInternal_function_value
                , ( bp::arg("value") ) );
        
        }
        { //::SireUnits::Dimension::TempBase::convertFromInternal
        
            typedef double ( ::SireUnits::Dimension::TempBase::*convertFromInternal_function_type )(  ) const;
            convertFromInternal_function_type convertFromInternal_function_value( &::SireUnits::Dimension::TempBase::convertFromInternal );
            
            TempBase_exposer.def( 
                "convertFromInternal"
                , convertFromInternal_function_value );
        
        }
        { //::SireUnits::Dimension::TempBase::convertToInternal
        
            typedef double ( ::SireUnits::Dimension::TempBase::*convertToInternal_function_type )( double ) const;
            convertToInternal_function_type convertToInternal_function_value( &::SireUnits::Dimension::TempBase::convertToInternal );
            
            TempBase_exposer.def( 
                "convertToInternal"
                , convertToInternal_function_value
                , ( bp::arg("value") ) );
        
        }
        { //::SireUnits::Dimension::TempBase::in
        
            typedef double ( ::SireUnits::Dimension::TempBase::*in_function_type )( ::SireUnits::Dimension::TempBase const & ) const;
            in_function_type in_function_value( &::SireUnits::Dimension::TempBase::in );
            
            TempBase_exposer.def( 
                "in"
                , in_function_value
                , ( bp::arg("other") ) );
        
        }
        { //::SireUnits::Dimension::TempBase::in
        
            typedef double ( ::SireUnits::Dimension::TempBase::*in_function_type )( ::SireUnits::Dimension::Temperature const & ) const;
            in_function_type in_function_value( &::SireUnits::Dimension::TempBase::in );
            
            TempBase_exposer.def( 
                "in"
                , in_function_value
                , ( bp::arg("temp") ) );
        
        }
        TempBase_exposer.def( bp::self != bp::self );
        TempBase_exposer.def( bp::self != bp::other< SireUnits::Dimension::PhysUnit< 0, 0, 0, 0, 1, 0, 0 > >() );
        { //::SireUnits::Dimension::TempBase::operator=
        
            typedef ::SireUnits::Dimension::TempBase & ( ::SireUnits::Dimension::TempBase::*assign_function_type )( ::SireUnits::Dimension::TempBase const & ) ;
            assign_function_type assign_function_value( &::SireUnits::Dimension::TempBase::operator= );
            
            TempBase_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >() );
        
        }
        { //::SireUnits::Dimension::TempBase::operator=
        
            typedef ::SireUnits::Dimension::TempBase & ( ::SireUnits::Dimension::TempBase::*assign_function_type )( ::SireUnits::Dimension::Temperature const & ) ;
            assign_function_type assign_function_value( &::SireUnits::Dimension::TempBase::operator= );
            
            TempBase_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("temp") )
                , bp::return_self< >() );
        
        }
        TempBase_exposer.def( bp::self == bp::self );
        TempBase_exposer.def( bp::self == bp::other< SireUnits::Dimension::PhysUnit< 0, 0, 0, 0, 1, 0, 0 > >() );
        { //::SireUnits::Dimension::TempBase::to
        
            typedef double ( ::SireUnits::Dimension::TempBase::*to_function_type )( ::SireUnits::Dimension::TempBase const & ) const;
            to_function_type to_function_value( &::SireUnits::Dimension::TempBase::to );
            
            TempBase_exposer.def( 
                "to"
                , to_function_value
                , ( bp::arg("other") ) );
        
        }
        TempBase_exposer.def( "__str__", &pvt_get_name);
        TempBase_exposer.def( "__repr__", &pvt_get_name);
    }

}
Ejemplo n.º 2
0
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);
    }

}
Ejemplo n.º 3
0
void register_Fahrenheit_class(){

    { //::SireUnits::Fahrenheit
        typedef bp::class_< SireUnits::Fahrenheit, bp::bases< SireUnits::Dimension::TempBase > > Fahrenheit_exposer_t;
        Fahrenheit_exposer_t Fahrenheit_exposer = Fahrenheit_exposer_t( "Fahrenheit", bp::init< >() );
        bp::scope Fahrenheit_scope( Fahrenheit_exposer );
        Fahrenheit_exposer.def( bp::init< double >(( bp::arg("value") )) );
        Fahrenheit_exposer.def( bp::init< SireUnits::Dimension::Temperature const & >(( bp::arg("temp") )) );
        Fahrenheit_exposer.def( bp::init< SireUnits::Dimension::TempBase const & >(( bp::arg("other") )) );
        Fahrenheit_exposer.def( bp::init< SireUnits::Fahrenheit const & >(( bp::arg("other") )) );
        { //::SireUnits::Fahrenheit::convertFromInternal
        
            typedef double ( ::SireUnits::Fahrenheit::*convertFromInternal_function_type )( double ) const;
            convertFromInternal_function_type convertFromInternal_function_value( &::SireUnits::Fahrenheit::convertFromInternal );
            
            Fahrenheit_exposer.def( 
                "convertFromInternal"
                , convertFromInternal_function_value
                , ( bp::arg("value") ) );
        
        }
        { //::SireUnits::Fahrenheit::convertFromInternal
        
            typedef double ( ::SireUnits::Fahrenheit::*convertFromInternal_function_type )(  ) const;
            convertFromInternal_function_type convertFromInternal_function_value( &::SireUnits::Fahrenheit::convertFromInternal );
            
            Fahrenheit_exposer.def( 
                "convertFromInternal"
                , convertFromInternal_function_value );
        
        }
        { //::SireUnits::Fahrenheit::convertToInternal
        
            typedef double ( ::SireUnits::Fahrenheit::*convertToInternal_function_type )( double ) const;
            convertToInternal_function_type convertToInternal_function_value( &::SireUnits::Fahrenheit::convertToInternal );
            
            Fahrenheit_exposer.def( 
                "convertToInternal"
                , convertToInternal_function_value
                , ( bp::arg("value") ) );
        
        }
        Fahrenheit_exposer.def( bp::self * bp::other< double >() );
        Fahrenheit_exposer.def( bp::self * bp::other< int >() );
        Fahrenheit_exposer.def( bp::self + bp::self );
        Fahrenheit_exposer.def( bp::self + bp::other< SireUnits::Dimension::PhysUnit< 0, 0, 0, 0, 1, 0, 0 > >() );
        Fahrenheit_exposer.def( -bp::self );
        Fahrenheit_exposer.def( bp::self - bp::self );
        Fahrenheit_exposer.def( bp::self - bp::other< SireUnits::Dimension::PhysUnit< 0, 0, 0, 0, 1, 0, 0 > >() );
        Fahrenheit_exposer.def( bp::self / bp::other< double >() );
        Fahrenheit_exposer.def( bp::self / bp::other< int >() );
        { //::SireUnits::Fahrenheit::operator=
        
            typedef ::SireUnits::Fahrenheit & ( ::SireUnits::Fahrenheit::*assign_function_type )( ::SireUnits::Fahrenheit const & ) ;
            assign_function_type assign_function_value( &::SireUnits::Fahrenheit::operator= );
            
            Fahrenheit_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >() );
        
        }
        { //::SireUnits::Fahrenheit::operator=
        
            typedef ::SireUnits::Fahrenheit & ( ::SireUnits::Fahrenheit::*assign_function_type )( ::SireUnits::Dimension::Temperature const & ) ;
            assign_function_type assign_function_value( &::SireUnits::Fahrenheit::operator= );
            
            Fahrenheit_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("temp") )
                , bp::return_self< >() );
        
        }
        Fahrenheit_exposer.def( bp::other<double>() * bp::self );
        Fahrenheit_exposer.def( bp::other<double>() / bp::self );
        Fahrenheit_exposer.def( "__copy__", &__copy__);
        Fahrenheit_exposer.def( "__deepcopy__", &__copy__);
        Fahrenheit_exposer.def( "clone", &__copy__);
        Fahrenheit_exposer.def( "__str__", &pvt_get_name);
        Fahrenheit_exposer.def( "__repr__", &pvt_get_name);
    }

}