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 > );
}
}
void register_Segment_class(){
{ //::SireMol::Segment
typedef bp::class_< SireMol::Segment, bp::bases< SireMol::MoleculeView, SireBase::Property > > Segment_exposer_t;
Segment_exposer_t Segment_exposer = Segment_exposer_t( "Segment", bp::init< >() );
bp::scope Segment_scope( Segment_exposer );
Segment_exposer.def( bp::init< SireMol::MoleculeData const &, SireMol::SegID const & >(( bp::arg("data"), bp::arg("segid") )) );
Segment_exposer.def( bp::init< SireMol::Segment const & >(( bp::arg("other") )) );
{ //::SireMol::Segment::assertContainsMetadata
typedef void ( ::SireMol::Segment::*assertContainsMetadata_function_type )( ::SireBase::PropertyName const & ) const;
assertContainsMetadata_function_type assertContainsMetadata_function_value( &::SireMol::Segment::assertContainsMetadata );
Segment_exposer.def(
"assertContainsMetadata"
, assertContainsMetadata_function_value
, ( bp::arg("metakey") ) );
}
{ //::SireMol::Segment::assertContainsMetadata
typedef void ( ::SireMol::Segment::*assertContainsMetadata_function_type )( ::SireBase::PropertyName const &,::SireBase::PropertyName const & ) const;
assertContainsMetadata_function_type assertContainsMetadata_function_value( &::SireMol::Segment::assertContainsMetadata );
Segment_exposer.def(
"assertContainsMetadata"
, assertContainsMetadata_function_value
, ( bp::arg("key"), bp::arg("metakey") ) );
}
{ //::SireMol::Segment::assertContainsProperty
typedef void ( ::SireMol::Segment::*assertContainsProperty_function_type )( ::SireBase::PropertyName const & ) const;
assertContainsProperty_function_type assertContainsProperty_function_value( &::SireMol::Segment::assertContainsProperty );
Segment_exposer.def(
"assertContainsProperty"
, assertContainsProperty_function_value
, ( bp::arg("key") ) );
}
{ //::SireMol::Segment::atomIdxs
typedef ::QList< SireMol::AtomIdx > const & ( ::SireMol::Segment::*atomIdxs_function_type )( ) const;
atomIdxs_function_type atomIdxs_function_value( &::SireMol::Segment::atomIdxs );
Segment_exposer.def(
"atomIdxs"
, atomIdxs_function_value
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireMol::Segment::contains
typedef bool ( ::SireMol::Segment::*contains_function_type )( ::SireMol::AtomIdx ) const;
contains_function_type contains_function_value( &::SireMol::Segment::contains );
Segment_exposer.def(
"contains"
, contains_function_value
, ( bp::arg("atomidx") ) );
}
{ //::SireMol::Segment::contains
typedef bool ( ::SireMol::Segment::*contains_function_type )( ::SireMol::AtomID const & ) const;
contains_function_type contains_function_value( &::SireMol::Segment::contains );
Segment_exposer.def(
"contains"
, contains_function_value
, ( bp::arg("atomid") ) );
}
{ //::SireMol::Segment::edit
typedef ::SireMol::SegEditor ( ::SireMol::Segment::*edit_function_type )( ) const;
edit_function_type edit_function_value( &::SireMol::Segment::edit );
Segment_exposer.def(
"edit"
, edit_function_value );
}
{ //::SireMol::Segment::evaluate
typedef ::SireMol::Evaluator ( ::SireMol::Segment::*evaluate_function_type )( ) const;
evaluate_function_type evaluate_function_value( &::SireMol::Segment::evaluate );
Segment_exposer.def(
"evaluate"
, evaluate_function_value );
}
{ //::SireMol::Segment::hasMetadata
typedef bool ( ::SireMol::Segment::*hasMetadata_function_type )( ::SireBase::PropertyName const & ) const;
hasMetadata_function_type hasMetadata_function_value( &::SireMol::Segment::hasMetadata );
Segment_exposer.def(
"hasMetadata"
, hasMetadata_function_value
, ( bp::arg("metakey") ) );
}
{ //::SireMol::Segment::hasMetadata
typedef bool ( ::SireMol::Segment::*hasMetadata_function_type )( ::SireBase::PropertyName const &,::SireBase::PropertyName const & ) const;
hasMetadata_function_type hasMetadata_function_value( &::SireMol::Segment::hasMetadata );
Segment_exposer.def(
"hasMetadata"
, hasMetadata_function_value
, ( bp::arg("key"), bp::arg("metakey") ) );
}
{ //::SireMol::Segment::hasProperty
typedef bool ( ::SireMol::Segment::*hasProperty_function_type )( ::SireBase::PropertyName const & ) const;
hasProperty_function_type hasProperty_function_value( &::SireMol::Segment::hasProperty );
Segment_exposer.def(
"hasProperty"
, hasProperty_function_value
, ( bp::arg("key") ) );
}
{ //::SireMol::Segment::index
typedef ::SireMol::SegIdx ( ::SireMol::Segment::*index_function_type )( ) const;
index_function_type index_function_value( &::SireMol::Segment::index );
Segment_exposer.def(
"index"
, index_function_value );
}
{ //::SireMol::Segment::intersects
typedef bool ( ::SireMol::Segment::*intersects_function_type )( ::SireMol::AtomID const & ) const;
intersects_function_type intersects_function_value( &::SireMol::Segment::intersects );
Segment_exposer.def(
"intersects"
, intersects_function_value
, ( bp::arg("atomid") ) );
}
{ //::SireMol::Segment::isEmpty
typedef bool ( ::SireMol::Segment::*isEmpty_function_type )( ) const;
isEmpty_function_type isEmpty_function_value( &::SireMol::Segment::isEmpty );
Segment_exposer.def(
"isEmpty"
, isEmpty_function_value );
}
{ //::SireMol::Segment::metadataKeys
typedef ::QStringList ( ::SireMol::Segment::*metadataKeys_function_type )( ) const;
metadataKeys_function_type metadataKeys_function_value( &::SireMol::Segment::metadataKeys );
Segment_exposer.def(
"metadataKeys"
, metadataKeys_function_value );
}
{ //::SireMol::Segment::metadataKeys
typedef ::QStringList ( ::SireMol::Segment::*metadataKeys_function_type )( ::SireBase::PropertyName const & ) const;
metadataKeys_function_type metadataKeys_function_value( &::SireMol::Segment::metadataKeys );
Segment_exposer.def(
"metadataKeys"
, metadataKeys_function_value
, ( bp::arg("key") ) );
}
{ //::SireMol::Segment::move
typedef ::SireMol::Mover< SireMol::Segment > ( ::SireMol::Segment::*move_function_type )( ) const;
move_function_type move_function_value( &::SireMol::Segment::move );
Segment_exposer.def(
"move"
, move_function_value );
}
{ //::SireMol::Segment::nAtoms
typedef int ( ::SireMol::Segment::*nAtoms_function_type )( ) const;
nAtoms_function_type nAtoms_function_value( &::SireMol::Segment::nAtoms );
Segment_exposer.def(
"nAtoms"
, nAtoms_function_value );
}
{ //::SireMol::Segment::name
typedef ::SireMol::SegName const & ( ::SireMol::Segment::*name_function_type )( ) const;
name_function_type name_function_value( &::SireMol::Segment::name );
Segment_exposer.def(
"name"
, name_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
Segment_exposer.def( bp::self != bp::self );
{ //::SireMol::Segment::operator=
typedef ::SireMol::Segment & ( ::SireMol::Segment::*assign_function_type )( ::SireMol::Segment const & ) ;
assign_function_type assign_function_value( &::SireMol::Segment::operator= );
Segment_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
Segment_exposer.def( bp::self == bp::self );
{ //::SireMol::Segment::propertyKeys
typedef ::QStringList ( ::SireMol::Segment::*propertyKeys_function_type )( ) const;
propertyKeys_function_type propertyKeys_function_value( &::SireMol::Segment::propertyKeys );
Segment_exposer.def(
"propertyKeys"
, propertyKeys_function_value );
}
{ //::SireMol::Segment::selectedAll
typedef bool ( ::SireMol::Segment::*selectedAll_function_type )( ) const;
selectedAll_function_type selectedAll_function_value( &::SireMol::Segment::selectedAll );
Segment_exposer.def(
"selectedAll"
, selectedAll_function_value );
}
{ //::SireMol::Segment::selection
typedef ::SireMol::AtomSelection ( ::SireMol::Segment::*selection_function_type )( ) const;
selection_function_type selection_function_value( &::SireMol::Segment::selection );
Segment_exposer.def(
"selection"
, selection_function_value );
}
{ //::SireMol::Segment::selector
typedef ::SireMol::Selector< SireMol::Segment > ( ::SireMol::Segment::*selector_function_type )( ) const;
selector_function_type selector_function_value( &::SireMol::Segment::selector );
Segment_exposer.def(
"selector"
, selector_function_value );
}
{ //::SireMol::Segment::toString
typedef ::QString ( ::SireMol::Segment::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireMol::Segment::toString );
Segment_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireMol::Segment::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMol::Segment::typeName );
Segment_exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireMol::Segment::update
typedef void ( ::SireMol::Segment::*update_function_type )( ::SireMol::MoleculeData const & ) ;
update_function_type update_function_value( &::SireMol::Segment::update );
Segment_exposer.def(
"update"
, update_function_value
, ( bp::arg("moldata") ) );
}
Segment_exposer.staticmethod( "typeName" );
Segment_exposer.def( "_get_property_SireMol_SegStringProperty", &SireMol::Segment::property< QString >, bp::return_value_policy<bp::copy_const_reference>());
Segment_exposer.def( "_get_metadata_SireMol_SegStringProperty", get_Metadata_SireMol_SegStringProperty_function1, bp::return_value_policy<bp::copy_const_reference>());
Segment_exposer.def( "_get_metadata_SireMol_SegStringProperty", &get_Metadata_SireMol_SegStringProperty_function2, bp::return_value_policy<bp::copy_const_reference>());
Segment_exposer.def( "_get_property_SireMol_SegIntProperty", &SireMol::Segment::property< qint64 >, bp::return_value_policy<bp::copy_const_reference>());
Segment_exposer.def( "_get_metadata_SireMol_SegIntProperty", get_Metadata_SireMol_SegIntProperty_function1, bp::return_value_policy<bp::copy_const_reference>());
Segment_exposer.def( "_get_metadata_SireMol_SegIntProperty", &get_Metadata_SireMol_SegIntProperty_function2, bp::return_value_policy<bp::copy_const_reference>());
Segment_exposer.def( "_get_property_SireMol_SegFloatProperty", &SireMol::Segment::property< double >, bp::return_value_policy<bp::copy_const_reference>());
Segment_exposer.def( "_get_metadata_SireMol_SegFloatProperty", get_Metadata_SireMol_SegFloatProperty_function1, bp::return_value_policy<bp::copy_const_reference>());
Segment_exposer.def( "_get_metadata_SireMol_SegFloatProperty", &get_Metadata_SireMol_SegFloatProperty_function2, bp::return_value_policy<bp::copy_const_reference>());
Segment_exposer.def( "_get_property_SireMol_SegVariantProperty", &SireMol::Segment::property< QVariant >, bp::return_value_policy<bp::copy_const_reference>());
Segment_exposer.def( "_get_metadata_SireMol_SegVariantProperty", get_Metadata_SireMol_SegVariantProperty_function1, bp::return_value_policy<bp::copy_const_reference>());
Segment_exposer.def( "_get_metadata_SireMol_SegVariantProperty", &get_Metadata_SireMol_SegVariantProperty_function2, bp::return_value_policy<bp::copy_const_reference>());
Segment_exposer.def( "__copy__", &__copy__);
Segment_exposer.def( "__deepcopy__", &__copy__);
Segment_exposer.def( "clone", &__copy__);
Segment_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::Segment >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Segment_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::Segment >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Segment_exposer.def( "__str__", &__str__< ::SireMol::Segment > );
Segment_exposer.def( "__repr__", &__str__< ::SireMol::Segment > );
}
}
void register_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 > );
}
}
void register_AABox_class(){
{ //::SireVol::AABox
typedef bp::class_< SireVol::AABox > AABox_exposer_t;
AABox_exposer_t AABox_exposer = AABox_exposer_t( "AABox", "\nAn AABox is an axis-aligned bounding box that is the smallest box that is aligned with the three cartesian axes that completely encases a CoordGroup. It is trivial to obtain the bounding sphere from the AABox. The AABox is used by the distance calculators to quickly determine whether two CoordGroups are within the cutoff radius, and to obtain all CoordGroups that are within particular regions of space.\n\nAuthor: Christopher Woods\n", bp::init< >("Construct an empty AABox") );
bp::scope AABox_scope( AABox_exposer );
AABox_exposer.def( bp::init< SireMaths::Vector const & >(( bp::arg("point") ), "Construct an AABox that completely encloses the point point") );
AABox_exposer.def( bp::init< SireMaths::Vector const &, SireMaths::Vector const & >(( bp::arg("cent"), bp::arg("extents") ), "Construct an AABox with center at cent, and half-extents extents") );
AABox_exposer.def( bp::init< QVector< SireMaths::Vector > const & >(( bp::arg("coordinates") ), "Construct an AABox that completely encases the points in coordinates") );
AABox_exposer.def( bp::init< SireMaths::Vector const *, int >(( bp::arg("coords"), bp::arg("ncoords") ), "Construct an AABox that completely encases the points in coords") );
AABox_exposer.def( bp::init< SireVol::CoordGroupBase const & >(( bp::arg("coordgroup") ), "Construct an AABox that completely encases the CoordGroup coordgroup") );
AABox_exposer.def( bp::init< SireVol::CoordGroupArray const & >(( bp::arg("cgarray") ), "Construct an AABox that completely encases all of the points in all of the\nCoordGroups in cgarray") );
AABox_exposer.def( bp::init< SireVol::CoordGroupArrayArray const & >(( bp::arg("cgarrays") ), "Construct an AABox that completely encases all of the points in all of the\nCoordGroups in all of the arrays in cgarrays") );
{ //::SireVol::AABox::add
typedef void ( ::SireVol::AABox::*add_function_type)( ::SireVol::AABox const & ) ;
add_function_type add_function_value( &::SireVol::AABox::add );
AABox_exposer.def(
"add"
, add_function_value
, ( bp::arg("other") )
, "Add another AABox to this one - this forms the union of both of the\nboxes." );
}
{ //::SireVol::AABox::add
typedef void ( ::SireVol::AABox::*add_function_type)( ::SireMaths::Vector const & ) ;
add_function_type add_function_value( &::SireVol::AABox::add );
AABox_exposer.def(
"add"
, add_function_value
, ( bp::arg("point") )
, "Add a point to this box" );
}
{ //::SireVol::AABox::add
typedef void ( ::SireVol::AABox::*add_function_type)( ::QVector< SireMaths::Vector > const & ) ;
add_function_type add_function_value( &::SireVol::AABox::add );
AABox_exposer.def(
"add"
, add_function_value
, ( bp::arg("points") )
, "Add lots of points to this box" );
}
{ //::SireVol::AABox::boundingSphere
typedef ::SireMaths::Sphere ( ::SireVol::AABox::*boundingSphere_function_type)( ) const;
boundingSphere_function_type boundingSphere_function_value( &::SireVol::AABox::boundingSphere );
AABox_exposer.def(
"boundingSphere"
, boundingSphere_function_value
, "Return the sphere that just contains this AABox" );
}
{ //::SireVol::AABox::center
typedef ::SireMaths::Vector const & ( ::SireVol::AABox::*center_function_type)( ) const;
center_function_type center_function_value( &::SireVol::AABox::center );
AABox_exposer.def(
"center"
, center_function_value
, bp::return_value_policy< bp::copy_const_reference >()
, "" );
}
{ //::SireVol::AABox::contains
typedef bool ( ::SireVol::AABox::*contains_function_type)( ::SireVol::AABox const & ) const;
contains_function_type contains_function_value( &::SireVol::AABox::contains );
AABox_exposer.def(
"contains"
, contains_function_value
, ( bp::arg("other") )
, "Return whether or not this box contains other" );
}
{ //::SireVol::AABox::contains
typedef bool ( ::SireVol::AABox::*contains_function_type)( ::SireMaths::Vector const & ) const;
contains_function_type contains_function_value( &::SireVol::AABox::contains );
AABox_exposer.def(
"contains"
, contains_function_value
, ( bp::arg("point") )
, "Return whether or not this box contains the point point" );
}
{ //::SireVol::AABox::from
typedef ::SireVol::AABox ( *from_function_type )( ::SireMaths::Vector const & );
from_function_type from_function_value( &::SireVol::AABox::from );
AABox_exposer.def(
"from"
, from_function_value
, ( bp::arg("point") )
, "Return an AABox constructed to contain the coordinates of point" );
}
{ //::SireVol::AABox::from
typedef ::SireVol::AABox ( *from_function_type )( ::SireVol::CoordGroupBase const & );
from_function_type from_function_value( &::SireVol::AABox::from );
AABox_exposer.def(
"from"
, from_function_value
, ( bp::arg("coordgroup") )
, "Return an AABox constructed to contain the coordinates in coordinates" );
}
{ //::SireVol::AABox::from
typedef ::SireVol::AABox ( *from_function_type )( ::SireVol::CoordGroupArray const & );
from_function_type from_function_value( &::SireVol::AABox::from );
AABox_exposer.def(
"from"
, from_function_value
, ( bp::arg("cgarray") )
, "Return an AABox constructed to contain all of the CoordGroups in cgarray" );
}
{ //::SireVol::AABox::from
typedef ::SireVol::AABox ( *from_function_type )( ::SireVol::CoordGroupArrayArray const & );
from_function_type from_function_value( &::SireVol::AABox::from );
AABox_exposer.def(
"from"
, from_function_value
, ( bp::arg("cgarrays") )
, "Return an AABox constructed to contain all of the CoordGroups in the\narrays in cgarrays" );
}
{ //::SireVol::AABox::from
typedef ::SireVol::AABox ( *from_function_type )( ::QVector< SireMaths::Vector > const & );
from_function_type from_function_value( &::SireVol::AABox::from );
AABox_exposer.def(
"from"
, from_function_value
, ( bp::arg("coords") )
, "Return an AABox constructed to contain the coordinates in coordinates" );
}
{ //::SireVol::AABox::from
typedef ::SireVol::AABox ( *from_function_type )( ::SireMaths::Vector const &,::SireMaths::Vector const & );
from_function_type from_function_value( &::SireVol::AABox::from );
AABox_exposer.def(
"from"
, from_function_value
, ( bp::arg("mincoords"), bp::arg("maxcoords") )
, "Construct a new AABox from the passed minimum and maximum coordinates" );
}
{ //::SireVol::AABox::halfExtents
typedef ::SireMaths::Vector const & ( ::SireVol::AABox::*halfExtents_function_type)( ) const;
halfExtents_function_type halfExtents_function_value( &::SireVol::AABox::halfExtents );
AABox_exposer.def(
"halfExtents"
, halfExtents_function_value
, bp::return_value_policy< bp::copy_const_reference >()
, "" );
}
{ //::SireVol::AABox::intersects
typedef bool ( ::SireVol::AABox::*intersects_function_type)( ::SireVol::AABox const & ) const;
intersects_function_type intersects_function_value( &::SireVol::AABox::intersects );
AABox_exposer.def(
"intersects"
, intersects_function_value
, ( bp::arg("other") )
, "Return whether this box intersects with box" );
}
{ //::SireVol::AABox::isEmpty
typedef bool ( ::SireVol::AABox::*isEmpty_function_type)( ) const;
isEmpty_function_type isEmpty_function_value( &::SireVol::AABox::isEmpty );
AABox_exposer.def(
"isEmpty"
, isEmpty_function_value
, "Return if the AABox is empty" );
}
{ //::SireVol::AABox::isNull
typedef bool ( ::SireVol::AABox::*isNull_function_type)( ) const;
isNull_function_type isNull_function_value( &::SireVol::AABox::isNull );
AABox_exposer.def(
"isNull"
, isNull_function_value
, "Return if the AABox is null" );
}
{ //::SireVol::AABox::maxCoords
typedef ::SireMaths::Vector ( ::SireVol::AABox::*maxCoords_function_type)( ) const;
maxCoords_function_type maxCoords_function_value( &::SireVol::AABox::maxCoords );
AABox_exposer.def(
"maxCoords"
, maxCoords_function_value
, "" );
}
{ //::SireVol::AABox::minCoords
typedef ::SireMaths::Vector ( ::SireVol::AABox::*minCoords_function_type)( ) const;
minCoords_function_type minCoords_function_value( &::SireVol::AABox::minCoords );
AABox_exposer.def(
"minCoords"
, minCoords_function_value
, "" );
}
AABox_exposer.def( bp::self != bp::self );
AABox_exposer.def( bp::self + bp::self );
AABox_exposer.def( bp::self + bp::other< SireMaths::Vector >() );
AABox_exposer.def( bp::self + bp::other< QVector< SireMaths::Vector > >() );
{ //::SireVol::AABox::operator=
typedef ::SireVol::AABox const & ( ::SireVol::AABox::*assign_function_type)( ::SireVol::AABox const & ) ;
assign_function_type assign_function_value( &::SireVol::AABox::operator= );
AABox_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_value_policy< bp::copy_const_reference >()
, "" );
}
AABox_exposer.def( bp::self == bp::self );
{ //::SireVol::AABox::radius
typedef double ( ::SireVol::AABox::*radius_function_type)( ) const;
radius_function_type radius_function_value( &::SireVol::AABox::radius );
AABox_exposer.def(
"radius"
, radius_function_value
, "" );
}
{ //::SireVol::AABox::recalculate
typedef void ( ::SireVol::AABox::*recalculate_function_type)( ::SireVol::CoordGroupBase const & ) ;
recalculate_function_type recalculate_function_value( &::SireVol::AABox::recalculate );
AABox_exposer.def(
"recalculate"
, recalculate_function_value
, ( bp::arg("coordgroup") )
, "Recalculate the AABox so that it completely encloses the CoordGroup coordgroup" );
}
{ //::SireVol::AABox::recalculate
typedef void ( ::SireVol::AABox::*recalculate_function_type)( ::SireVol::CoordGroupArray const & ) ;
recalculate_function_type recalculate_function_value( &::SireVol::AABox::recalculate );
AABox_exposer.def(
"recalculate"
, recalculate_function_value
, ( bp::arg("cgarray") )
, "Recalculate the AABox so that it completely encloses the CoordGroups\nin the array cgarray" );
}
{ //::SireVol::AABox::recalculate
typedef void ( ::SireVol::AABox::*recalculate_function_type)( ::SireVol::CoordGroupArrayArray const & ) ;
recalculate_function_type recalculate_function_value( &::SireVol::AABox::recalculate );
AABox_exposer.def(
"recalculate"
, recalculate_function_value
, ( bp::arg("cgarrays") )
, "Recalculate the AABox so that it completely encloses the CoordGroups\nin the arrays cgarrays" );
}
{ //::SireVol::AABox::recalculate
typedef void ( ::SireVol::AABox::*recalculate_function_type)( ::QVector< SireMaths::Vector > const & ) ;
recalculate_function_type recalculate_function_value( &::SireVol::AABox::recalculate );
AABox_exposer.def(
"recalculate"
, recalculate_function_value
, ( bp::arg("coordinates") )
, "Recalculate the AABox so that it completely encloses the coordinates" );
}
{ //::SireVol::AABox::toString
typedef ::QString ( ::SireVol::AABox::*toString_function_type)( ) const;
toString_function_type toString_function_value( &::SireVol::AABox::toString );
AABox_exposer.def(
"toString"
, toString_function_value
, "Return a string representation of this AABox" );
}
{ //::SireVol::AABox::translate
typedef void ( ::SireVol::AABox::*translate_function_type)( ::SireMaths::Vector const & ) ;
translate_function_type translate_function_value( &::SireVol::AABox::translate );
AABox_exposer.def(
"translate"
, translate_function_value
, ( bp::arg("delta") )
, "Translate this AABox by delta" );
}
{ //::SireVol::AABox::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireVol::AABox::typeName );
AABox_exposer.def(
"typeName"
, typeName_function_value
, "" );
}
{ //::SireVol::AABox::what
typedef char const * ( ::SireVol::AABox::*what_function_type)( ) const;
what_function_type what_function_value( &::SireVol::AABox::what );
AABox_exposer.def(
"what"
, what_function_value
, "" );
}
{ //::SireVol::AABox::withinDistance
typedef bool ( ::SireVol::AABox::*withinDistance_function_type)( double,::SireVol::AABox const & ) const;
withinDistance_function_type withinDistance_function_value( &::SireVol::AABox::withinDistance );
AABox_exposer.def(
"withinDistance"
, withinDistance_function_value
, ( bp::arg("dist"), bp::arg("box") )
, "Return whether or not this box is within dist of box box.\n(using infinite cartesian axes)" );
}
AABox_exposer.staticmethod( "from" );
AABox_exposer.staticmethod( "typeName" );
AABox_exposer.def( "__copy__", &__copy__);
AABox_exposer.def( "__deepcopy__", &__copy__);
AABox_exposer.def( "clone", &__copy__);
AABox_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireVol::AABox >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
AABox_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireVol::AABox >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
AABox_exposer.def( "__str__", &__str__< ::SireVol::AABox > );
AABox_exposer.def( "__repr__", &__str__< ::SireVol::AABox > );
}
}
void register_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 > );
}
}
