Ejemplo n.º 1
0
void register_Molecules_class(){

    { //::SireMol::Molecules
        typedef bp::class_< SireMol::Molecules, bp::bases< SireBase::Property > > Molecules_exposer_t;
        Molecules_exposer_t Molecules_exposer = Molecules_exposer_t( "Molecules", bp::init< >() );
        bp::scope Molecules_scope( Molecules_exposer );
        Molecules_exposer.def( bp::init< SireMol::MoleculeView const & >(( bp::arg("molecule") )) );
        Molecules_exposer.def( bp::init< SireMol::ViewsOfMol const & >(( bp::arg("molviews") )) );
        Molecules_exposer.def( bp::init< SireMol::Molecules const & >(( bp::arg("other") )) );
        { //::SireMol::Molecules::add
        
            typedef void ( ::SireMol::Molecules::*add_function_type )( ::SireMol::MoleculeView const & ) ;
            add_function_type add_function_value( &::SireMol::Molecules::add );
            
            Molecules_exposer.def( 
                "add"
                , add_function_value
                , ( bp::arg("molview") ) );
        
        }
        { //::SireMol::Molecules::add
        
            typedef void ( ::SireMol::Molecules::*add_function_type )( ::SireMol::ViewsOfMol const & ) ;
            add_function_type add_function_value( &::SireMol::Molecules::add );
            
            Molecules_exposer.def( 
                "add"
                , add_function_value
                , ( bp::arg("molviews") ) );
        
        }
        { //::SireMol::Molecules::add
        
            typedef void ( ::SireMol::Molecules::*add_function_type )( ::SireMol::Molecules const & ) ;
            add_function_type add_function_value( &::SireMol::Molecules::add );
            
            Molecules_exposer.def( 
                "add"
                , add_function_value
                , ( bp::arg("molecules") ) );
        
        }
        { //::SireMol::Molecules::addIfUnique
        
            typedef bool ( ::SireMol::Molecules::*addIfUnique_function_type )( ::SireMol::MoleculeView const & ) ;
            addIfUnique_function_type addIfUnique_function_value( &::SireMol::Molecules::addIfUnique );
            
            Molecules_exposer.def( 
                "addIfUnique"
                , addIfUnique_function_value
                , ( bp::arg("molview") ) );
        
        }
        { //::SireMol::Molecules::addIfUnique
        
            typedef ::SireMol::ViewsOfMol ( ::SireMol::Molecules::*addIfUnique_function_type )( ::SireMol::ViewsOfMol const & ) ;
            addIfUnique_function_type addIfUnique_function_value( &::SireMol::Molecules::addIfUnique );
            
            Molecules_exposer.def( 
                "addIfUnique"
                , addIfUnique_function_value
                , ( bp::arg("molviews") ) );
        
        }
        { //::SireMol::Molecules::addIfUnique
        
            typedef ::QList< SireMol::ViewsOfMol > ( ::SireMol::Molecules::*addIfUnique_function_type )( ::SireMol::Molecules const & ) ;
            addIfUnique_function_type addIfUnique_function_value( &::SireMol::Molecules::addIfUnique );
            
            Molecules_exposer.def( 
                "addIfUnique"
                , addIfUnique_function_value
                , ( bp::arg("molecules") ) );
        
        }
        { //::SireMol::Molecules::assertContains
        
            typedef void ( ::SireMol::Molecules::*assertContains_function_type )( ::SireMol::MolNum ) const;
            assertContains_function_type assertContains_function_value( &::SireMol::Molecules::assertContains );
            
            Molecules_exposer.def( 
                "assertContains"
                , assertContains_function_value
                , ( bp::arg("molnum") ) );
        
        }
        { //::SireMol::Molecules::at
        
            typedef ::SireMol::ViewsOfMol const & ( ::SireMol::Molecules::*at_function_type )( ::SireMol::MolNum ) const;
            at_function_type at_function_value( &::SireMol::Molecules::at );
            
            Molecules_exposer.def( 
                "at"
                , at_function_value
                , ( bp::arg("molnum") )
                , bp::return_value_policy<bp::clone_const_reference>() );
        
        }
        { //::SireMol::Molecules::at
        
            typedef ::SireMol::PartialMolecule ( ::SireMol::Molecules::*at_function_type )( ::boost::tuples::tuple< SireMol::MolNum, SireID::Index, 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 > const & ) const;
            at_function_type at_function_value( &::SireMol::Molecules::at );
            
            Molecules_exposer.def( 
                "at"
                , at_function_value
                , ( bp::arg("viewidx") ) );
        
        }
        { //::SireMol::Molecules::at
        
            typedef ::SireMol::PartialMolecule ( ::SireMol::Molecules::*at_function_type )( ::SireMol::MolNum,int ) const;
            at_function_type at_function_value( &::SireMol::Molecules::at );
            
            Molecules_exposer.def( 
                "at"
                , at_function_value
                , ( bp::arg("molnum"), bp::arg("idx") ) );
        
        }
        { //::SireMol::Molecules::back
        
            typedef ::SireMol::ViewsOfMol const & ( ::SireMol::Molecules::*back_function_type )(  ) const;
            back_function_type back_function_value( &::SireMol::Molecules::back );
            
            Molecules_exposer.def( 
                "back"
                , back_function_value
                , bp::return_value_policy<bp::clone_const_reference>() );
        
        }
        { //::SireMol::Molecules::begin
        
            typedef ::SireBase::ChunkedHash< SireMol::MolNum, SireMol::ViewsOfMol, 100 >::const_iterator ( ::SireMol::Molecules::*begin_function_type )(  ) const;
            begin_function_type begin_function_value( &::SireMol::Molecules::begin );
            
            Molecules_exposer.def( 
                "begin"
                , begin_function_value );
        
        }
        { //::SireMol::Molecules::clear
        
            typedef void ( ::SireMol::Molecules::*clear_function_type )(  ) ;
            clear_function_type clear_function_value( &::SireMol::Molecules::clear );
            
            Molecules_exposer.def( 
                "clear"
                , clear_function_value );
        
        }
        { //::SireMol::Molecules::constBegin
        
            typedef ::SireBase::ChunkedHash< SireMol::MolNum, SireMol::ViewsOfMol, 100 >::const_iterator ( ::SireMol::Molecules::*constBegin_function_type )(  ) const;
            constBegin_function_type constBegin_function_value( &::SireMol::Molecules::constBegin );
            
            Molecules_exposer.def( 
                "constBegin"
                , constBegin_function_value );
        
        }
        { //::SireMol::Molecules::constEnd
        
            typedef ::SireBase::ChunkedHash< SireMol::MolNum, SireMol::ViewsOfMol, 100 >::const_iterator ( ::SireMol::Molecules::*constEnd_function_type )(  ) const;
            constEnd_function_type constEnd_function_value( &::SireMol::Molecules::constEnd );
            
            Molecules_exposer.def( 
                "constEnd"
                , constEnd_function_value );
        
        }
        { //::SireMol::Molecules::constFind
        
            typedef ::SireBase::ChunkedHash< SireMol::MolNum, SireMol::ViewsOfMol, 100 >::const_iterator ( ::SireMol::Molecules::*constFind_function_type )( ::SireMol::MolNum ) const;
            constFind_function_type constFind_function_value( &::SireMol::Molecules::constFind );
            
            Molecules_exposer.def( 
                "constFind"
                , constFind_function_value
                , ( bp::arg("molnum") ) );
        
        }
        { //::SireMol::Molecules::contains
        
            typedef bool ( ::SireMol::Molecules::*contains_function_type )( ::SireMol::MolNum ) const;
            contains_function_type contains_function_value( &::SireMol::Molecules::contains );
            
            Molecules_exposer.def( 
                "contains"
                , contains_function_value
                , ( bp::arg("molnum") ) );
        
        }
        { //::SireMol::Molecules::contains
        
            typedef bool ( ::SireMol::Molecules::*contains_function_type )( ::SireMol::MoleculeView const & ) const;
            contains_function_type contains_function_value( &::SireMol::Molecules::contains );
            
            Molecules_exposer.def( 
                "contains"
                , contains_function_value
                , ( bp::arg("molview") ) );
        
        }
        { //::SireMol::Molecules::contains
        
            typedef bool ( ::SireMol::Molecules::*contains_function_type )( ::SireMol::ViewsOfMol const & ) const;
            contains_function_type contains_function_value( &::SireMol::Molecules::contains );
            
            Molecules_exposer.def( 
                "contains"
                , contains_function_value
                , ( bp::arg("molviews") ) );
        
        }
        { //::SireMol::Molecules::contains
        
            typedef bool ( ::SireMol::Molecules::*contains_function_type )( ::SireMol::Molecules const & ) const;
            contains_function_type contains_function_value( &::SireMol::Molecules::contains );
            
            Molecules_exposer.def( 
                "contains"
                , contains_function_value
                , ( bp::arg("molecules") ) );
        
        }
        { //::SireMol::Molecules::count
        
            typedef int ( ::SireMol::Molecules::*count_function_type )(  ) const;
            count_function_type count_function_value( &::SireMol::Molecules::count );
            
            Molecules_exposer.def( 
                "count"
                , count_function_value );
        
        }
        { //::SireMol::Molecules::end
        
            typedef ::SireBase::ChunkedHash< SireMol::MolNum, SireMol::ViewsOfMol, 100 >::const_iterator ( ::SireMol::Molecules::*end_function_type )(  ) const;
            end_function_type end_function_value( &::SireMol::Molecules::end );
            
            Molecules_exposer.def( 
                "end"
                , end_function_value );
        
        }
        { //::SireMol::Molecules::find
        
            typedef ::SireBase::ChunkedHash< SireMol::MolNum, SireMol::ViewsOfMol, 100 >::const_iterator ( ::SireMol::Molecules::*find_function_type )( ::SireMol::MolNum ) const;
            find_function_type find_function_value( &::SireMol::Molecules::find );
            
            Molecules_exposer.def( 
                "find"
                , find_function_value
                , ( bp::arg("molnum") ) );
        
        }
        { //::SireMol::Molecules::first
        
            typedef ::SireMol::ViewsOfMol const & ( ::SireMol::Molecules::*first_function_type )(  ) const;
            first_function_type first_function_value( &::SireMol::Molecules::first );
            
            Molecules_exposer.def( 
                "first"
                , first_function_value
                , bp::return_value_policy<bp::clone_const_reference>() );
        
        }
        { //::SireMol::Molecules::front
        
            typedef ::SireMol::ViewsOfMol const & ( ::SireMol::Molecules::*front_function_type )(  ) const;
            front_function_type front_function_value( &::SireMol::Molecules::front );
            
            Molecules_exposer.def( 
                "front"
                , front_function_value
                , bp::return_value_policy<bp::clone_const_reference>() );
        
        }
        { //::SireMol::Molecules::intersects
        
            typedef bool ( ::SireMol::Molecules::*intersects_function_type )( ::SireMol::MoleculeView const & ) const;
            intersects_function_type intersects_function_value( &::SireMol::Molecules::intersects );
            
            Molecules_exposer.def( 
                "intersects"
                , intersects_function_value
                , ( bp::arg("molview") ) );
        
        }
        { //::SireMol::Molecules::intersects
        
            typedef bool ( ::SireMol::Molecules::*intersects_function_type )( ::SireMol::Molecules const & ) const;
            intersects_function_type intersects_function_value( &::SireMol::Molecules::intersects );
            
            Molecules_exposer.def( 
                "intersects"
                , intersects_function_value
                , ( bp::arg("other") ) );
        
        }
        { //::SireMol::Molecules::isEmpty
        
            typedef bool ( ::SireMol::Molecules::*isEmpty_function_type )(  ) const;
            isEmpty_function_type isEmpty_function_value( &::SireMol::Molecules::isEmpty );
            
            Molecules_exposer.def( 
                "isEmpty"
                , isEmpty_function_value );
        
        }
        { //::SireMol::Molecules::last
        
            typedef ::SireMol::ViewsOfMol const & ( ::SireMol::Molecules::*last_function_type )(  ) const;
            last_function_type last_function_value( &::SireMol::Molecules::last );
            
            Molecules_exposer.def( 
                "last"
                , last_function_value
                , bp::return_value_policy<bp::clone_const_reference>() );
        
        }
        { //::SireMol::Molecules::molNums
        
            typedef ::QSet< SireMol::MolNum > ( ::SireMol::Molecules::*molNums_function_type )(  ) const;
            molNums_function_type molNums_function_value( &::SireMol::Molecules::molNums );
            
            Molecules_exposer.def( 
                "molNums"
                , molNums_function_value );
        
        }
        { //::SireMol::Molecules::molecule
        
            typedef ::SireMol::ViewsOfMol const & ( ::SireMol::Molecules::*molecule_function_type )( ::SireMol::MolNum ) const;
            molecule_function_type molecule_function_value( &::SireMol::Molecules::molecule );
            
            Molecules_exposer.def( 
                "molecule"
                , molecule_function_value
                , ( bp::arg("molnum") )
                , bp::return_value_policy<bp::clone_const_reference>() );
        
        }
        { //::SireMol::Molecules::nMolecules
        
            typedef int ( ::SireMol::Molecules::*nMolecules_function_type )(  ) const;
            nMolecules_function_type nMolecules_function_value( &::SireMol::Molecules::nMolecules );
            
            Molecules_exposer.def( 
                "nMolecules"
                , nMolecules_function_value );
        
        }
        { //::SireMol::Molecules::nViews
        
            typedef int ( ::SireMol::Molecules::*nViews_function_type )(  ) const;
            nViews_function_type nViews_function_value( &::SireMol::Molecules::nViews );
            
            Molecules_exposer.def( 
                "nViews"
                , nViews_function_value );
        
        }
        { //::SireMol::Molecules::nViews
        
            typedef int ( ::SireMol::Molecules::*nViews_function_type )( ::SireMol::MolNum ) const;
            nViews_function_type nViews_function_value( &::SireMol::Molecules::nViews );
            
            Molecules_exposer.def( 
                "nViews"
                , nViews_function_value
                , ( bp::arg("molnum") ) );
        
        }
        Molecules_exposer.def( bp::self != bp::self );
        Molecules_exposer.def( bp::self + bp::self );
        Molecules_exposer.def( bp::self - bp::self );
        { //::SireMol::Molecules::operator=
        
            typedef ::SireMol::Molecules & ( ::SireMol::Molecules::*assign_function_type )( ::SireMol::Molecules const & ) ;
            assign_function_type assign_function_value( &::SireMol::Molecules::operator= );
            
            Molecules_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >() );
        
        }
        Molecules_exposer.def( bp::self == bp::self );
        { //::SireMol::Molecules::operator[]
        
            typedef ::SireMol::ViewsOfMol const & ( ::SireMol::Molecules::*__getitem___function_type )( ::SireMol::MolNum ) const;
            __getitem___function_type __getitem___function_value( &::SireMol::Molecules::operator[] );
            
            Molecules_exposer.def( 
                "__getitem__"
                , __getitem___function_value
                , ( bp::arg("molnum") )
                , bp::return_value_policy<bp::clone_const_reference>() );
        
        }
        { //::SireMol::Molecules::operator[]
        
            typedef ::SireMol::PartialMolecule ( ::SireMol::Molecules::*__getitem___function_type )( ::boost::tuples::tuple< SireMol::MolNum, SireID::Index, 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 > const & ) const;
            __getitem___function_type __getitem___function_value( &::SireMol::Molecules::operator[] );
            
            Molecules_exposer.def( 
                "__getitem__"
                , __getitem___function_value
                , ( bp::arg("viewidx") ) );
        
        }
        { //::SireMol::Molecules::remove
        
            typedef bool ( ::SireMol::Molecules::*remove_function_type )( ::SireMol::MoleculeView const & ) ;
            remove_function_type remove_function_value( &::SireMol::Molecules::remove );
            
            Molecules_exposer.def( 
                "remove"
                , remove_function_value
                , ( bp::arg("molview") ) );
        
        }
        { //::SireMol::Molecules::remove
        
            typedef ::SireMol::ViewsOfMol ( ::SireMol::Molecules::*remove_function_type )( ::SireMol::ViewsOfMol const & ) ;
            remove_function_type remove_function_value( &::SireMol::Molecules::remove );
            
            Molecules_exposer.def( 
                "remove"
                , remove_function_value
                , ( bp::arg("molviews") ) );
        
        }
        { //::SireMol::Molecules::remove
        
            typedef ::QList< SireMol::ViewsOfMol > ( ::SireMol::Molecules::*remove_function_type )( ::SireMol::Molecules const & ) ;
            remove_function_type remove_function_value( &::SireMol::Molecules::remove );
            
            Molecules_exposer.def( 
                "remove"
                , remove_function_value
                , ( bp::arg("molecules") ) );
        
        }
        { //::SireMol::Molecules::remove
        
            typedef ::SireMol::ViewsOfMol ( ::SireMol::Molecules::*remove_function_type )( ::SireMol::MolNum ) ;
            remove_function_type remove_function_value( &::SireMol::Molecules::remove );
            
            Molecules_exposer.def( 
                "remove"
                , remove_function_value
                , ( bp::arg("molnum") ) );
        
        }
        { //::SireMol::Molecules::removeAll
        
            typedef bool ( ::SireMol::Molecules::*removeAll_function_type )( ::SireMol::MoleculeView const & ) ;
            removeAll_function_type removeAll_function_value( &::SireMol::Molecules::removeAll );
            
            Molecules_exposer.def( 
                "removeAll"
                , removeAll_function_value
                , ( bp::arg("molview") ) );
        
        }
        { //::SireMol::Molecules::removeAll
        
            typedef ::SireMol::ViewsOfMol ( ::SireMol::Molecules::*removeAll_function_type )( ::SireMol::ViewsOfMol const & ) ;
            removeAll_function_type removeAll_function_value( &::SireMol::Molecules::removeAll );
            
            Molecules_exposer.def( 
                "removeAll"
                , removeAll_function_value
                , ( bp::arg("molviews") ) );
        
        }
        { //::SireMol::Molecules::removeAll
        
            typedef ::QList< SireMol::ViewsOfMol > ( ::SireMol::Molecules::*removeAll_function_type )( ::SireMol::Molecules const & ) ;
            removeAll_function_type removeAll_function_value( &::SireMol::Molecules::removeAll );
            
            Molecules_exposer.def( 
                "removeAll"
                , removeAll_function_value
                , ( bp::arg("molecules") ) );
        
        }
        { //::SireMol::Molecules::removeAll
        
            typedef bool ( ::SireMol::Molecules::*removeAll_function_type )(  ) ;
            removeAll_function_type removeAll_function_value( &::SireMol::Molecules::removeAll );
            
            Molecules_exposer.def( 
                "removeAll"
                , removeAll_function_value );
        
        }
        { //::SireMol::Molecules::removeDuplicates
        
            typedef bool ( ::SireMol::Molecules::*removeDuplicates_function_type )(  ) ;
            removeDuplicates_function_type removeDuplicates_function_value( &::SireMol::Molecules::removeDuplicates );
            
            Molecules_exposer.def( 
                "removeDuplicates"
                , removeDuplicates_function_value );
        
        }
        { //::SireMol::Molecules::reserve
        
            typedef void ( ::SireMol::Molecules::*reserve_function_type )( int ) ;
            reserve_function_type reserve_function_value( &::SireMol::Molecules::reserve );
            
            Molecules_exposer.def( 
                "reserve"
                , reserve_function_value
                , ( bp::arg("nmolecules") ) );
        
        }
        { //::SireMol::Molecules::toString
        
            typedef ::QString ( ::SireMol::Molecules::*toString_function_type )(  ) const;
            toString_function_type toString_function_value( &::SireMol::Molecules::toString );
            
            Molecules_exposer.def( 
                "toString"
                , toString_function_value );
        
        }
        { //::SireMol::Molecules::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireMol::Molecules::typeName );
            
            Molecules_exposer.def( 
                "typeName"
                , typeName_function_value );
        
        }
        { //::SireMol::Molecules::unite
        
            typedef bool ( ::SireMol::Molecules::*unite_function_type )( ::SireMol::MoleculeView const & ) ;
            unite_function_type unite_function_value( &::SireMol::Molecules::unite );
            
            Molecules_exposer.def( 
                "unite"
                , unite_function_value
                , ( bp::arg("molview") ) );
        
        }
        { //::SireMol::Molecules::unite
        
            typedef ::SireMol::ViewsOfMol ( ::SireMol::Molecules::*unite_function_type )( ::SireMol::ViewsOfMol const & ) ;
            unite_function_type unite_function_value( &::SireMol::Molecules::unite );
            
            Molecules_exposer.def( 
                "unite"
                , unite_function_value
                , ( bp::arg("molviews") ) );
        
        }
        { //::SireMol::Molecules::unite
        
            typedef ::QList< SireMol::ViewsOfMol > ( ::SireMol::Molecules::*unite_function_type )( ::SireMol::Molecules const & ) ;
            unite_function_type unite_function_value( &::SireMol::Molecules::unite );
            
            Molecules_exposer.def( 
                "unite"
                , unite_function_value
                , ( bp::arg("other") ) );
        
        }
        { //::SireMol::Molecules::uniteViews
        
            typedef bool ( ::SireMol::Molecules::*uniteViews_function_type )(  ) ;
            uniteViews_function_type uniteViews_function_value( &::SireMol::Molecules::uniteViews );
            
            Molecules_exposer.def( 
                "uniteViews"
                , uniteViews_function_value );
        
        }
        { //::SireMol::Molecules::update
        
            typedef bool ( ::SireMol::Molecules::*update_function_type )( ::SireMol::MoleculeData const & ) ;
            update_function_type update_function_value( &::SireMol::Molecules::update );
            
            Molecules_exposer.def( 
                "update"
                , update_function_value
                , ( bp::arg("moldata") ) );
        
        }
        { //::SireMol::Molecules::update
        
            typedef bool ( ::SireMol::Molecules::*update_function_type )( ::SireMol::MoleculeView const & ) ;
            update_function_type update_function_value( &::SireMol::Molecules::update );
            
            Molecules_exposer.def( 
                "update"
                , update_function_value
                , ( bp::arg("molview") ) );
        
        }
        { //::SireMol::Molecules::update
        
            typedef ::QList< SireMol::Molecule > ( ::SireMol::Molecules::*update_function_type )( ::SireMol::Molecules const & ) ;
            update_function_type update_function_value( &::SireMol::Molecules::update );
            
            Molecules_exposer.def( 
                "update"
                , update_function_value
                , ( bp::arg("molecules") ) );
        
        }
        { //::SireMol::Molecules::what
        
            typedef char const * ( ::SireMol::Molecules::*what_function_type )(  ) const;
            what_function_type what_function_value( &::SireMol::Molecules::what );
            
            Molecules_exposer.def( 
                "what"
                , what_function_value );
        
        }
        Molecules_exposer.staticmethod( "typeName" );
        Molecules_exposer.def( "__copy__", &__copy__);
        Molecules_exposer.def( "__deepcopy__", &__copy__);
        Molecules_exposer.def( "clone", &__copy__);
        Molecules_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::Molecules >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        Molecules_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::Molecules >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        Molecules_exposer.def( "__str__", &__str__< ::SireMol::Molecules > );
        Molecules_exposer.def( "__repr__", &__str__< ::SireMol::Molecules > );
        Molecules_exposer.def( "__len__", &__len_count< ::SireMol::Molecules > );
    }

}
Ejemplo n.º 2
0
void register_Segment_class(){

    { //::SireMol::Segment
        typedef bp::class_< SireMol::Segment, bp::bases< SireMol::MoleculeView, SireBase::Property > > Segment_exposer_t;
        Segment_exposer_t Segment_exposer = Segment_exposer_t( "Segment", bp::init< >() );
        bp::scope Segment_scope( Segment_exposer );
        Segment_exposer.def( bp::init< SireMol::MoleculeData const &, SireMol::SegID const & >(( bp::arg("data"), bp::arg("segid") )) );
        Segment_exposer.def( bp::init< SireMol::Segment const & >(( bp::arg("other") )) );
        { //::SireMol::Segment::assertContainsMetadata
        
            typedef void ( ::SireMol::Segment::*assertContainsMetadata_function_type )( ::SireBase::PropertyName const & ) const;
            assertContainsMetadata_function_type assertContainsMetadata_function_value( &::SireMol::Segment::assertContainsMetadata );
            
            Segment_exposer.def( 
                "assertContainsMetadata"
                , assertContainsMetadata_function_value
                , ( bp::arg("metakey") ) );
        
        }
        { //::SireMol::Segment::assertContainsMetadata
        
            typedef void ( ::SireMol::Segment::*assertContainsMetadata_function_type )( ::SireBase::PropertyName const &,::SireBase::PropertyName const & ) const;
            assertContainsMetadata_function_type assertContainsMetadata_function_value( &::SireMol::Segment::assertContainsMetadata );
            
            Segment_exposer.def( 
                "assertContainsMetadata"
                , assertContainsMetadata_function_value
                , ( bp::arg("key"), bp::arg("metakey") ) );
        
        }
        { //::SireMol::Segment::assertContainsProperty
        
            typedef void ( ::SireMol::Segment::*assertContainsProperty_function_type )( ::SireBase::PropertyName const & ) const;
            assertContainsProperty_function_type assertContainsProperty_function_value( &::SireMol::Segment::assertContainsProperty );
            
            Segment_exposer.def( 
                "assertContainsProperty"
                , assertContainsProperty_function_value
                , ( bp::arg("key") ) );
        
        }
        { //::SireMol::Segment::atomIdxs
        
            typedef ::QList< SireMol::AtomIdx > const & ( ::SireMol::Segment::*atomIdxs_function_type )(  ) const;
            atomIdxs_function_type atomIdxs_function_value( &::SireMol::Segment::atomIdxs );
            
            Segment_exposer.def( 
                "atomIdxs"
                , atomIdxs_function_value
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        { //::SireMol::Segment::contains
        
            typedef bool ( ::SireMol::Segment::*contains_function_type )( ::SireMol::AtomIdx ) const;
            contains_function_type contains_function_value( &::SireMol::Segment::contains );
            
            Segment_exposer.def( 
                "contains"
                , contains_function_value
                , ( bp::arg("atomidx") ) );
        
        }
        { //::SireMol::Segment::contains
        
            typedef bool ( ::SireMol::Segment::*contains_function_type )( ::SireMol::AtomID const & ) const;
            contains_function_type contains_function_value( &::SireMol::Segment::contains );
            
            Segment_exposer.def( 
                "contains"
                , contains_function_value
                , ( bp::arg("atomid") ) );
        
        }
        { //::SireMol::Segment::edit
        
            typedef ::SireMol::SegEditor ( ::SireMol::Segment::*edit_function_type )(  ) const;
            edit_function_type edit_function_value( &::SireMol::Segment::edit );
            
            Segment_exposer.def( 
                "edit"
                , edit_function_value );
        
        }
        { //::SireMol::Segment::evaluate
        
            typedef ::SireMol::Evaluator ( ::SireMol::Segment::*evaluate_function_type )(  ) const;
            evaluate_function_type evaluate_function_value( &::SireMol::Segment::evaluate );
            
            Segment_exposer.def( 
                "evaluate"
                , evaluate_function_value );
        
        }
        { //::SireMol::Segment::hasMetadata
        
            typedef bool ( ::SireMol::Segment::*hasMetadata_function_type )( ::SireBase::PropertyName const & ) const;
            hasMetadata_function_type hasMetadata_function_value( &::SireMol::Segment::hasMetadata );
            
            Segment_exposer.def( 
                "hasMetadata"
                , hasMetadata_function_value
                , ( bp::arg("metakey") ) );
        
        }
        { //::SireMol::Segment::hasMetadata
        
            typedef bool ( ::SireMol::Segment::*hasMetadata_function_type )( ::SireBase::PropertyName const &,::SireBase::PropertyName const & ) const;
            hasMetadata_function_type hasMetadata_function_value( &::SireMol::Segment::hasMetadata );
            
            Segment_exposer.def( 
                "hasMetadata"
                , hasMetadata_function_value
                , ( bp::arg("key"), bp::arg("metakey") ) );
        
        }
        { //::SireMol::Segment::hasProperty
        
            typedef bool ( ::SireMol::Segment::*hasProperty_function_type )( ::SireBase::PropertyName const & ) const;
            hasProperty_function_type hasProperty_function_value( &::SireMol::Segment::hasProperty );
            
            Segment_exposer.def( 
                "hasProperty"
                , hasProperty_function_value
                , ( bp::arg("key") ) );
        
        }
        { //::SireMol::Segment::index
        
            typedef ::SireMol::SegIdx ( ::SireMol::Segment::*index_function_type )(  ) const;
            index_function_type index_function_value( &::SireMol::Segment::index );
            
            Segment_exposer.def( 
                "index"
                , index_function_value );
        
        }
        { //::SireMol::Segment::intersects
        
            typedef bool ( ::SireMol::Segment::*intersects_function_type )( ::SireMol::AtomID const & ) const;
            intersects_function_type intersects_function_value( &::SireMol::Segment::intersects );
            
            Segment_exposer.def( 
                "intersects"
                , intersects_function_value
                , ( bp::arg("atomid") ) );
        
        }
        { //::SireMol::Segment::isEmpty
        
            typedef bool ( ::SireMol::Segment::*isEmpty_function_type )(  ) const;
            isEmpty_function_type isEmpty_function_value( &::SireMol::Segment::isEmpty );
            
            Segment_exposer.def( 
                "isEmpty"
                , isEmpty_function_value );
        
        }
        { //::SireMol::Segment::metadataKeys
        
            typedef ::QStringList ( ::SireMol::Segment::*metadataKeys_function_type )(  ) const;
            metadataKeys_function_type metadataKeys_function_value( &::SireMol::Segment::metadataKeys );
            
            Segment_exposer.def( 
                "metadataKeys"
                , metadataKeys_function_value );
        
        }
        { //::SireMol::Segment::metadataKeys
        
            typedef ::QStringList ( ::SireMol::Segment::*metadataKeys_function_type )( ::SireBase::PropertyName const & ) const;
            metadataKeys_function_type metadataKeys_function_value( &::SireMol::Segment::metadataKeys );
            
            Segment_exposer.def( 
                "metadataKeys"
                , metadataKeys_function_value
                , ( bp::arg("key") ) );
        
        }
        { //::SireMol::Segment::move
        
            typedef ::SireMol::Mover< SireMol::Segment > ( ::SireMol::Segment::*move_function_type )(  ) const;
            move_function_type move_function_value( &::SireMol::Segment::move );
            
            Segment_exposer.def( 
                "move"
                , move_function_value );
        
        }
        { //::SireMol::Segment::nAtoms
        
            typedef int ( ::SireMol::Segment::*nAtoms_function_type )(  ) const;
            nAtoms_function_type nAtoms_function_value( &::SireMol::Segment::nAtoms );
            
            Segment_exposer.def( 
                "nAtoms"
                , nAtoms_function_value );
        
        }
        { //::SireMol::Segment::name
        
            typedef ::SireMol::SegName const & ( ::SireMol::Segment::*name_function_type )(  ) const;
            name_function_type name_function_value( &::SireMol::Segment::name );
            
            Segment_exposer.def( 
                "name"
                , name_function_value
                , bp::return_value_policy<bp::clone_const_reference>() );
        
        }
        Segment_exposer.def( bp::self != bp::self );
        { //::SireMol::Segment::operator=
        
            typedef ::SireMol::Segment & ( ::SireMol::Segment::*assign_function_type )( ::SireMol::Segment const & ) ;
            assign_function_type assign_function_value( &::SireMol::Segment::operator= );
            
            Segment_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >() );
        
        }
        Segment_exposer.def( bp::self == bp::self );
        { //::SireMol::Segment::propertyKeys
        
            typedef ::QStringList ( ::SireMol::Segment::*propertyKeys_function_type )(  ) const;
            propertyKeys_function_type propertyKeys_function_value( &::SireMol::Segment::propertyKeys );
            
            Segment_exposer.def( 
                "propertyKeys"
                , propertyKeys_function_value );
        
        }
        { //::SireMol::Segment::selectedAll
        
            typedef bool ( ::SireMol::Segment::*selectedAll_function_type )(  ) const;
            selectedAll_function_type selectedAll_function_value( &::SireMol::Segment::selectedAll );
            
            Segment_exposer.def( 
                "selectedAll"
                , selectedAll_function_value );
        
        }
        { //::SireMol::Segment::selection
        
            typedef ::SireMol::AtomSelection ( ::SireMol::Segment::*selection_function_type )(  ) const;
            selection_function_type selection_function_value( &::SireMol::Segment::selection );
            
            Segment_exposer.def( 
                "selection"
                , selection_function_value );
        
        }
        { //::SireMol::Segment::selector
        
            typedef ::SireMol::Selector< SireMol::Segment > ( ::SireMol::Segment::*selector_function_type )(  ) const;
            selector_function_type selector_function_value( &::SireMol::Segment::selector );
            
            Segment_exposer.def( 
                "selector"
                , selector_function_value );
        
        }
        { //::SireMol::Segment::toString
        
            typedef ::QString ( ::SireMol::Segment::*toString_function_type )(  ) const;
            toString_function_type toString_function_value( &::SireMol::Segment::toString );
            
            Segment_exposer.def( 
                "toString"
                , toString_function_value );
        
        }
        { //::SireMol::Segment::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireMol::Segment::typeName );
            
            Segment_exposer.def( 
                "typeName"
                , typeName_function_value );
        
        }
        { //::SireMol::Segment::update
        
            typedef void ( ::SireMol::Segment::*update_function_type )( ::SireMol::MoleculeData const & ) ;
            update_function_type update_function_value( &::SireMol::Segment::update );
            
            Segment_exposer.def( 
                "update"
                , update_function_value
                , ( bp::arg("moldata") ) );
        
        }
        Segment_exposer.staticmethod( "typeName" );
        Segment_exposer.def( "_get_property_SireMol_SegStringProperty", &SireMol::Segment::property< QString >, bp::return_value_policy<bp::copy_const_reference>());
        Segment_exposer.def( "_get_metadata_SireMol_SegStringProperty", get_Metadata_SireMol_SegStringProperty_function1, bp::return_value_policy<bp::copy_const_reference>());
        Segment_exposer.def( "_get_metadata_SireMol_SegStringProperty", &get_Metadata_SireMol_SegStringProperty_function2, bp::return_value_policy<bp::copy_const_reference>());
        Segment_exposer.def( "_get_property_SireMol_SegIntProperty", &SireMol::Segment::property< qint64 >, bp::return_value_policy<bp::copy_const_reference>());
        Segment_exposer.def( "_get_metadata_SireMol_SegIntProperty", get_Metadata_SireMol_SegIntProperty_function1, bp::return_value_policy<bp::copy_const_reference>());
        Segment_exposer.def( "_get_metadata_SireMol_SegIntProperty", &get_Metadata_SireMol_SegIntProperty_function2, bp::return_value_policy<bp::copy_const_reference>());
        Segment_exposer.def( "_get_property_SireMol_SegFloatProperty", &SireMol::Segment::property< double >, bp::return_value_policy<bp::copy_const_reference>());
        Segment_exposer.def( "_get_metadata_SireMol_SegFloatProperty", get_Metadata_SireMol_SegFloatProperty_function1, bp::return_value_policy<bp::copy_const_reference>());
        Segment_exposer.def( "_get_metadata_SireMol_SegFloatProperty", &get_Metadata_SireMol_SegFloatProperty_function2, bp::return_value_policy<bp::copy_const_reference>());
        Segment_exposer.def( "_get_property_SireMol_SegVariantProperty", &SireMol::Segment::property< QVariant >, bp::return_value_policy<bp::copy_const_reference>());
        Segment_exposer.def( "_get_metadata_SireMol_SegVariantProperty", get_Metadata_SireMol_SegVariantProperty_function1, bp::return_value_policy<bp::copy_const_reference>());
        Segment_exposer.def( "_get_metadata_SireMol_SegVariantProperty", &get_Metadata_SireMol_SegVariantProperty_function2, bp::return_value_policy<bp::copy_const_reference>());
        Segment_exposer.def( "__copy__", &__copy__);
        Segment_exposer.def( "__deepcopy__", &__copy__);
        Segment_exposer.def( "clone", &__copy__);
        Segment_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::Segment >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        Segment_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::Segment >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        Segment_exposer.def( "__str__", &__str__< ::SireMol::Segment > );
        Segment_exposer.def( "__repr__", &__str__< ::SireMol::Segment > );
    }

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

    { //::SireMaths::Sphere
        typedef bp::class_< SireMaths::Sphere > Sphere_exposer_t;
        Sphere_exposer_t Sphere_exposer = Sphere_exposer_t( "Sphere", bp::init< >() );
        bp::scope Sphere_scope( Sphere_exposer );
        Sphere_exposer.def( bp::init< double const & >(( bp::arg("radius") )) );
        Sphere_exposer.def( bp::init< SireMaths::Vector const &, double const & >(( bp::arg("position"), bp::arg("radius") )) );
        Sphere_exposer.def( bp::init< SireMaths::Sphere const & >(( bp::arg("other") )) );
        { //::SireMaths::Sphere::center
        
            typedef ::SireMaths::Vector const & ( ::SireMaths::Sphere::*center_function_type )(  ) const;
            center_function_type center_function_value( &::SireMaths::Sphere::center );
            
            Sphere_exposer.def( 
                "center"
                , center_function_value
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        { //::SireMaths::Sphere::combinedVolume
        
            typedef double ( *combinedVolume_function_type )( ::QVector< SireMaths::Sphere > const & );
            combinedVolume_function_type combinedVolume_function_value( &::SireMaths::Sphere::combinedVolume );
            
            Sphere_exposer.def( 
                "combinedVolume"
                , combinedVolume_function_value
                , ( bp::arg("spheres") ) );
        
        }
        { //::SireMaths::Sphere::combinedVolumeMC
        
            typedef double ( *combinedVolumeMC_function_type )( ::QVector< SireMaths::Sphere > const &,qint64 );
            combinedVolumeMC_function_type combinedVolumeMC_function_value( &::SireMaths::Sphere::combinedVolumeMC );
            
            Sphere_exposer.def( 
                "combinedVolumeMC"
                , combinedVolumeMC_function_value
                , ( bp::arg("spheres"), bp::arg("nsamples")=(qint64)(-0x00000000000000001) ) );
        
        }
        { //::SireMaths::Sphere::contains
        
            typedef bool ( ::SireMaths::Sphere::*contains_function_type )( ::SireMaths::Sphere const & ) const;
            contains_function_type contains_function_value( &::SireMaths::Sphere::contains );
            
            Sphere_exposer.def( 
                "contains"
                , contains_function_value
                , ( bp::arg("other") ) );
        
        }
        { //::SireMaths::Sphere::intersectionVolume
        
            typedef double ( ::SireMaths::Sphere::*intersectionVolume_function_type )( ::SireMaths::Sphere const & ) const;
            intersectionVolume_function_type intersectionVolume_function_value( &::SireMaths::Sphere::intersectionVolume );
            
            Sphere_exposer.def( 
                "intersectionVolume"
                , intersectionVolume_function_value
                , ( bp::arg("other") ) );
        
        }
        { //::SireMaths::Sphere::intersectionVolume
        
            typedef double ( ::SireMaths::Sphere::*intersectionVolume_function_type )( ::SireMaths::Sphere const &,::SireMaths::Sphere const & ) const;
            intersectionVolume_function_type intersectionVolume_function_value( &::SireMaths::Sphere::intersectionVolume );
            
            Sphere_exposer.def( 
                "intersectionVolume"
                , intersectionVolume_function_value
                , ( bp::arg("other0"), bp::arg("other1") ) );
        
        }
        { //::SireMaths::Sphere::intersects
        
            typedef bool ( ::SireMaths::Sphere::*intersects_function_type )( ::SireMaths::Sphere const & ) const;
            intersects_function_type intersects_function_value( &::SireMaths::Sphere::intersects );
            
            Sphere_exposer.def( 
                "intersects"
                , intersects_function_value
                , ( bp::arg("other") ) );
        
        }
        Sphere_exposer.def( bp::self != bp::self );
        Sphere_exposer.def( bp::self == bp::self );
        { //::SireMaths::Sphere::position
        
            typedef ::SireMaths::Vector const & ( ::SireMaths::Sphere::*position_function_type )(  ) const;
            position_function_type position_function_value( &::SireMaths::Sphere::position );
            
            Sphere_exposer.def( 
                "position"
                , position_function_value
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        { //::SireMaths::Sphere::radius
        
            typedef double ( ::SireMaths::Sphere::*radius_function_type )(  ) const;
            radius_function_type radius_function_value( &::SireMaths::Sphere::radius );
            
            Sphere_exposer.def( 
                "radius"
                , radius_function_value );
        
        }
        { //::SireMaths::Sphere::setCenter
        
            typedef void ( ::SireMaths::Sphere::*setCenter_function_type )( ::SireMaths::Vector const & ) ;
            setCenter_function_type setCenter_function_value( &::SireMaths::Sphere::setCenter );
            
            Sphere_exposer.def( 
                "setCenter"
                , setCenter_function_value
                , ( bp::arg("center") ) );
        
        }
        { //::SireMaths::Sphere::setPosition
        
            typedef void ( ::SireMaths::Sphere::*setPosition_function_type )( ::SireMaths::Vector const & ) ;
            setPosition_function_type setPosition_function_value( &::SireMaths::Sphere::setPosition );
            
            Sphere_exposer.def( 
                "setPosition"
                , setPosition_function_value
                , ( bp::arg("position") ) );
        
        }
        { //::SireMaths::Sphere::setRadius
        
            typedef void ( ::SireMaths::Sphere::*setRadius_function_type )( double ) ;
            setRadius_function_type setRadius_function_value( &::SireMaths::Sphere::setRadius );
            
            Sphere_exposer.def( 
                "setRadius"
                , setRadius_function_value
                , ( bp::arg("radius") ) );
        
        }
        { //::SireMaths::Sphere::surfaceArea
        
            typedef double ( ::SireMaths::Sphere::*surfaceArea_function_type )(  ) const;
            surfaceArea_function_type surfaceArea_function_value( &::SireMaths::Sphere::surfaceArea );
            
            Sphere_exposer.def( 
                "surfaceArea"
                , surfaceArea_function_value );
        
        }
        { //::SireMaths::Sphere::toString
        
            typedef ::QString ( ::SireMaths::Sphere::*toString_function_type )(  ) const;
            toString_function_type toString_function_value( &::SireMaths::Sphere::toString );
            
            Sphere_exposer.def( 
                "toString"
                , toString_function_value );
        
        }
        { //::SireMaths::Sphere::translate
        
            typedef ::SireMaths::Sphere ( ::SireMaths::Sphere::*translate_function_type )( ::SireMaths::Vector const & ) const;
            translate_function_type translate_function_value( &::SireMaths::Sphere::translate );
            
            Sphere_exposer.def( 
                "translate"
                , translate_function_value
                , ( bp::arg("delta") ) );
        
        }
        { //::SireMaths::Sphere::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireMaths::Sphere::typeName );
            
            Sphere_exposer.def( 
                "typeName"
                , typeName_function_value );
        
        }
        { //::SireMaths::Sphere::volume
        
            typedef double ( ::SireMaths::Sphere::*volume_function_type )(  ) const;
            volume_function_type volume_function_value( &::SireMaths::Sphere::volume );
            
            Sphere_exposer.def( 
                "volume"
                , volume_function_value );
        
        }
        { //::SireMaths::Sphere::what
        
            typedef char const * ( ::SireMaths::Sphere::*what_function_type )(  ) const;
            what_function_type what_function_value( &::SireMaths::Sphere::what );
            
            Sphere_exposer.def( 
                "what"
                , what_function_value );
        
        }
        Sphere_exposer.staticmethod( "combinedVolume" );
        Sphere_exposer.staticmethod( "combinedVolumeMC" );
        Sphere_exposer.staticmethod( "typeName" );
        Sphere_exposer.def( "__copy__", &__copy__);
        Sphere_exposer.def( "__deepcopy__", &__copy__);
        Sphere_exposer.def( "clone", &__copy__);
        Sphere_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMaths::Sphere >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        Sphere_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMaths::Sphere >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        Sphere_exposer.def( "__str__", &__str__< ::SireMaths::Sphere > );
        Sphere_exposer.def( "__repr__", &__str__< ::SireMaths::Sphere > );
    }

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

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

}