static void write_type(const type_t *type) { switch(type->kind) { case TYPE_ATOMIC: write_atomic_type(&type->atomic); return; case TYPE_POINTER: write_pointer_type(&type->pointer); return; case TYPE_COMPOUND_UNION: case TYPE_COMPOUND_STRUCT: write_compound_type(&type->compound); return; case TYPE_ENUM: write_enum_type(&type->enumt); return; case TYPE_FUNCTION: write_function_type(&type->function); return; case TYPE_INVALID: panic("invalid type found"); case TYPE_COMPLEX: case TYPE_IMAGINARY: default: fprintf(out, "/* TODO type */"); break; } }
void register_ExternalFileWriter_class(){ { //::osgDB::ExternalFileWriter typedef bp::class_< osgDB::ExternalFileWriter, boost::noncopyable > ExternalFileWriter_exposer_t; ExternalFileWriter_exposer_t ExternalFileWriter_exposer = ExternalFileWriter_exposer_t( "ExternalFileWriter", "\n Helper allowing intelligent writing of external files (images, shaders, etc.), regarding to a main file (a scene), especially in plugins.\n Goals are:\n - Enable writing out objects only once (even if referenced multiple times)\n - Handle duplicates (avoid writing two different objects at the same place, renaming files as needed)\n - Handle directory creation when paths dont just exist\n - Generate writing paths which may keep original directory structure (depending on user wishes). Ex:\n Reading: model.osg and images/img1.jpg\n Writing with keepRelativePaths: /somePath/newmodel.osg and /somePath/images/img1.jpg\n Writing without keepRelativePaths: /somePath/newmodel.osg and /somePath/img1.jpg\nAuthor: Sukender\nTODO Handling of naming constraints (such as 8.3 names in 3DS)\n", bp::init< std::string const &, std::string const &, bool, bp::optional< unsigned int > >(( bp::arg("srcDirectory"), bp::arg("destDirectory"), bp::arg("keepRelativePaths"), bp::arg("allowUpDirs")=(unsigned int)(0) ), "\n Builds the helper class with all options.\n@param srcDirectory: Directory of the initial main file (if any), used as a base when relativising objects names. Not used if keepRelativePaths==false.\n@param destDirectory: Directory where to write the main file.\n@param keepRelativePaths: If true, then relative paths of source objects are kept if possible (ex: If an image is initially imageDir/image.jpg relatively to the source dir, then wed like to get destDir/imageDir/image.jpg). If false, then only the simple file name is used to write the object file.\n@param allowUpDirs: When relativising objects paths, sets the maximum number of directories the objects can be written up the destination directory. Not used if keepRelativePaths==false. Examples: If an image is initially ../image.jpg relatively to the source dir *AND* if we allow one dir level up, then wed like to get destDirParent/destDir/../image.jpg (= destDirParent/image.jpg). If we *DO NOT* allow one dir level up, then wed like to get destDir/image.jpg.\n") ); bp::scope ExternalFileWriter_scope( ExternalFileWriter_exposer ); bp::class_< osgDB::ExternalFileWriter::ObjectData >( "ObjectData", bp::init< >() ) .def( bp::init< std::string const &, std::string const &, bool >(( bp::arg("absolutePath"), bp::arg("relativePath"), bp::arg("written") )) ) .def_readwrite( "absolutePath", &osgDB::ExternalFileWriter::ObjectData::absolutePath ) .def_readwrite( "relativePath", &osgDB::ExternalFileWriter::ObjectData::relativePath ) .def_readwrite( "written", &osgDB::ExternalFileWriter::ObjectData::written, "\n Says if write succeded or not.\n" ); ExternalFileWriter_exposer.def( bp::init< std::string const & >(( bp::arg("destDirectory") ), "\n Short constructor used when not relativising objects paths, or when having no initial model file (which is pretty the same here).\n") ); bp::implicitly_convertible< std::string const &, osgDB::ExternalFileWriter >(); { //::osgDB::ExternalFileWriter::getObjects typedef ::std::map< osg::Object const*, osgDB::ExternalFileWriter::ObjectData > const & ( ::osgDB::ExternalFileWriter::*getObjects_function_type )( ) const; ExternalFileWriter_exposer.def( "getObjects" , getObjects_function_type( &::osgDB::ExternalFileWriter::getObjects ) , bp::return_internal_reference< >() , "\n Returns the written objects.\n" ); } { //::osgDB::ExternalFileWriter::write typedef boost::python::object ( *write_function_type )( ::osgDB::ExternalFileWriter &,::osg::Object &,::osgDB::Options const *,::std::string *,::std::string * ); ExternalFileWriter_exposer.def( "write" , write_function_type( &write_450b6356464d3b168ed8fbce635bbd4a ) , ( bp::arg("inst"), bp::arg("obj"), bp::arg("options"), bp::arg("out_absolutePath")=0l, bp::arg("out_relativePath")=0l ) , " Writes the current object if not already done.\n@param obj: Object to write, using corresponding osgDB::write method.\n@param options: Writing options to pass to corresponding osgDB::write method.\n@param [out]: out_absolutePath Pointer to a string to be filled with absolute writing path, or NULL.\n@param [out]: out_relativePath Pointer to a string to be filled with write path relative to the destination directory if possible (absolute path if not), or NULL.\nReturn: true on success, false otherwise." ); } } }
void register_File_class(){ { //::osiris::File typedef ::boost::python::class_< File_wrapper, ::boost::python::bases< ::osiris::IStream >, ::boost::noncopyable > File_exposer_t; File_exposer_t File_exposer = File_exposer_t( "File", ::boost::python::init< >() ); ::boost::python::scope File_scope( File_exposer ); ::boost::python::enum_< ::osiris::File::OpenFlags>("OpenFlags") .value("ofRead", ::osiris::File::ofRead) .value("ofWrite", ::osiris::File::ofWrite) .value("ofReadWrite", ::osiris::File::ofReadWrite) .value("ofNoTruncate", ::osiris::File::ofNoTruncate) .value("ofBinary", ::osiris::File::ofBinary) .value("ofText", ::osiris::File::ofText) .export_values() ; File_exposer.def( ::boost::python::init< ::osiris::String const &, ::osiris::uint32 >(( ::boost::python::arg("filename"), ::boost::python::arg("flags") )) ); { //::osiris::File::getHandle typedef boost::python::object ( *getHandle_function_type )( ::osiris::File const & ); File_exposer.def( "getHandle" , getHandle_function_type( &File_wrapper::getHandle ) ); } { //::osiris::File::open typedef bool ( ::osiris::File::*open_function_type )( ::osiris::String const &,::osiris::uint32 ) ; typedef bool ( File_wrapper::*default_open_function_type )( ::osiris::String const &,::osiris::uint32 ) ; File_exposer.def( "open" , open_function_type(&::osiris::File::open) , default_open_function_type(&File_wrapper::default_open) , ( ::boost::python::arg("filename"), ::boost::python::arg("flags") ) ); } { //::osiris::File::is_open typedef bool ( ::osiris::File::*is_open_function_type )( ) const; typedef bool ( File_wrapper::*default_is_open_function_type )( ) const; File_exposer.def( "is_open" , is_open_function_type(&::osiris::File::is_open) , default_is_open_function_type(&File_wrapper::default_is_open) ); } { //::osiris::File::close typedef bool ( ::osiris::File::*close_function_type )( ) ; typedef bool ( File_wrapper::*default_close_function_type )( ) ; File_exposer.def( "close" , close_function_type(&::osiris::File::close) , default_close_function_type(&File_wrapper::default_close) ); } { //::osiris::File::read typedef ::osiris::uint32 ( ::osiris::File::*read_function_type )( void *,::osiris::uint32 ) const; typedef ::osiris::uint32 ( File_wrapper::*default_read_function_type )( void *,::osiris::uint32 ) const; File_exposer.def( "read" , read_function_type(&::osiris::File::read) , default_read_function_type(&File_wrapper::default_read) , ( ::boost::python::arg("v"), ::boost::python::arg("size") ) ); } { //::osiris::File::write typedef ::osiris::uint32 ( ::osiris::File::*write_function_type )( void const *,::osiris::uint32 ) ; typedef ::osiris::uint32 ( File_wrapper::*default_write_function_type )( void const *,::osiris::uint32 ) ; File_exposer.def( "write" , write_function_type(&::osiris::File::write) , default_write_function_type(&File_wrapper::default_write) , ( ::boost::python::arg("v"), ::boost::python::arg("size") ) ); } { //::osiris::File::seek typedef bool ( ::osiris::File::*seek_function_type )( ::osiris::uint64,::osiris::SeekPosition ) const; typedef bool ( File_wrapper::*default_seek_function_type )( ::osiris::uint64,::osiris::SeekPosition ) const; File_exposer.def( "seek" , seek_function_type(&::osiris::File::seek) , default_seek_function_type(&File_wrapper::default_seek) , ( ::boost::python::arg("offset"), ::boost::python::arg("from") ) ); } { //::osiris::File::position typedef ::osiris::uint64 ( ::osiris::File::*position_function_type )( ) const; typedef ::osiris::uint64 ( File_wrapper::*default_position_function_type )( ) const; File_exposer.def( "position" , position_function_type(&::osiris::File::position) , default_position_function_type(&File_wrapper::default_position) ); } { //::osiris::File::size typedef ::osiris::uint64 ( ::osiris::File::*size_function_type )( ) const; typedef ::osiris::uint64 ( File_wrapper::*default_size_function_type )( ) const; File_exposer.def( "size" , size_function_type(&::osiris::File::size) , default_size_function_type(&File_wrapper::default_size) ); } { //::osiris::File::flush typedef bool ( ::osiris::File::*flush_function_type )( ) ; typedef bool ( File_wrapper::*default_flush_function_type )( ) ; File_exposer.def( "flush" , flush_function_type(&::osiris::File::flush) , default_flush_function_type(&File_wrapper::default_flush) ); } { //::osiris::File::eof typedef bool ( ::osiris::File::*eof_function_type )( ) const; typedef bool ( File_wrapper::*default_eof_function_type )( ) const; File_exposer.def( "eof" , eof_function_type(&::osiris::File::eof) , default_eof_function_type(&File_wrapper::default_eof) ); } { //::osiris::File::getStats typedef boost::python::object ( *getStats_function_type )( ::osiris::File const &,::boost::posix_time::ptime *,::boost::posix_time::ptime *,::boost::posix_time::ptime * ); File_exposer.def( "getStats" , getStats_function_type( &File_wrapper::getStats ) , ( ::boost::python::arg("inst"), ::boost::python::arg("timeCreation"), ::boost::python::arg("timeLastModify")=(nullptr), ::boost::python::arg("timeLastAccess")=(nullptr) ) ); } { //::osiris::IStream::peek typedef ::osiris::uint32 ( ::osiris::IStream::*peek_function_type )( void *,::osiris::uint32 ) const; typedef ::osiris::uint32 ( File_wrapper::*default_peek_function_type )( void *,::osiris::uint32 ) const; File_exposer.def( "peek" , peek_function_type(&::osiris::IStream::peek) , default_peek_function_type(&File_wrapper::default_peek) , ( ::boost::python::arg("v"), ::boost::python::arg("size") ) ); } { //property "handle"[fget=::osiris::File::getHandle] typedef ::FILE * ( ::osiris::File::*fget )( ) const; File_exposer.add_property( "handle" , ::boost::python::make_function( fget( &::osiris::File::getHandle ) , bp::return_value_policy< bp::reference_existing_object >() ) , "get property, built on top of \"FILE * osiris::File::getHandle() const [member function]\"" ); } ::boost::python::register_ptr_to_python< boost::shared_ptr< ::osiris::File > >(); ::boost::python::implicitly_convertible< boost::shared_ptr< ::osiris::File >, boost::shared_ptr< ::boost::noncopyable_::noncopyable > >(); ::boost::python::implicitly_convertible< boost::shared_ptr< ::osiris::File >, boost::shared_ptr< ::osiris::Object > >(); ::boost::python::implicitly_convertible< boost::shared_ptr< ::osiris::TextFile >, boost::shared_ptr< ::osiris::File > >(); } }
explicit output_stream(write_function_type write_f_ = write_function_type()) : write_f(write_f_) {}
void register_Alignatum_class(){ { //::alignlib::Alignatum typedef bp::class_< alignlib::Alignatum, bp::bases< alignlib::AlignlibBase >, boost::noncopyable > Alignatum_exposer_t; Alignatum_exposer_t Alignatum_exposer = Alignatum_exposer_t( "Alignatum", bp::no_init ); bp::scope Alignatum_scope( Alignatum_exposer ); { //::alignlib::Alignatum::addGaps typedef void ( ::alignlib::Alignatum::*addGaps_function_type )( int,int ) ; Alignatum_exposer.def( "addGaps" , addGaps_function_type( &::alignlib::Alignatum::addGaps ) , ( bp::arg("front"), bp::arg("back") ) ); } { //::alignlib::Alignatum::fillAlignment typedef void ( ::alignlib::Alignatum::*fillAlignment_function_type )( ::alignlib::HAlignment &,bool const ) const; Alignatum_exposer.def( "fillAlignment" , fillAlignment_function_type( &::alignlib::Alignatum::fillAlignment ) , ( bp::arg("dest"), bp::arg("invert")=(bool const)(false) ) ); } { //::alignlib::Alignatum::getAlignedLength typedef ::alignlib::Position ( ::alignlib::Alignatum::*getAlignedLength_function_type )( ) const; Alignatum_exposer.def( "getAlignedLength" , getAlignedLength_function_type( &::alignlib::Alignatum::getAlignedLength ) ); } { //::alignlib::Alignatum::getClone typedef ::alignlib::HAlignatum ( ::alignlib::Alignatum::*getClone_function_type )( ) const; Alignatum_exposer.def( "getClone" , getClone_function_type( &::alignlib::Alignatum::getClone ) ); } { //::alignlib::Alignatum::getFrom typedef ::alignlib::Position ( ::alignlib::Alignatum::*getFrom_function_type )( ) const; Alignatum_exposer.def( "getFrom" , getFrom_function_type( &::alignlib::Alignatum::getFrom ) ); } { //::alignlib::Alignatum::getFullLength typedef ::alignlib::Position ( ::alignlib::Alignatum::*getFullLength_function_type )( ) const; Alignatum_exposer.def( "getFullLength" , getFullLength_function_type( &::alignlib::Alignatum::getFullLength ) ); } { //::alignlib::Alignatum::getNew typedef ::alignlib::HAlignatum ( ::alignlib::Alignatum::*getNew_function_type )( ) const; Alignatum_exposer.def( "getNew" , getNew_function_type( &::alignlib::Alignatum::getNew ) ); } { //::alignlib::Alignatum::getResidueNumber typedef ::alignlib::Position ( ::alignlib::Alignatum::*getResidueNumber_function_type )( ::alignlib::Position const,::alignlib::SearchType const ) const; Alignatum_exposer.def( "getResidueNumber" , getResidueNumber_function_type( &::alignlib::Alignatum::getResidueNumber ) , ( bp::arg("pos"), bp::arg("search")=::alignlib::NO_SEARCH ) ); } { //::alignlib::Alignatum::getString typedef ::std::string const & ( ::alignlib::Alignatum::*getString_function_type )( ) const; Alignatum_exposer.def( "getString" , getString_function_type( &::alignlib::Alignatum::getString ) , bp::return_value_policy< bp::copy_const_reference >() ); } { //::alignlib::Alignatum::getTo typedef ::alignlib::Position ( ::alignlib::Alignatum::*getTo_function_type )( ) const; Alignatum_exposer.def( "getTo" , getTo_function_type( &::alignlib::Alignatum::getTo ) ); } { //::alignlib::Alignatum::insertGaps typedef void ( ::alignlib::Alignatum::*insertGaps_function_type )( int,::alignlib::Position ) ; Alignatum_exposer.def( "insertGaps" , insertGaps_function_type( &::alignlib::Alignatum::insertGaps ) , ( bp::arg("position"), bp::arg("count")=(int)(1) ) ); } { //::alignlib::Alignatum::isConsistent typedef bool ( ::alignlib::Alignatum::*isConsistent_function_type )( ) const; Alignatum_exposer.def( "isConsistent" , isConsistent_function_type( &::alignlib::Alignatum::isConsistent ) ); } { //::alignlib::Alignatum::mapOnAlignment typedef void ( ::alignlib::Alignatum::*mapOnAlignment_function_type )( ::alignlib::HAlignment const &,::alignlib::Position const,bool const ) ; Alignatum_exposer.def( "mapOnAlignment" , mapOnAlignment_function_type( &::alignlib::Alignatum::mapOnAlignment ) , ( bp::arg("map_old2new"), bp::arg("new_length")=(int const)(0), bp::arg("unaligned_chars")=(bool const)(false) ) ); } { //::alignlib::Alignatum::read typedef void ( ::alignlib::Alignatum::*read_function_type )( ::std::istream & ) ; Alignatum_exposer.def( "read" , read_function_type( &::alignlib::Alignatum::read ) , ( bp::arg("input") ) ); } { //::alignlib::Alignatum::removeColumns typedef void ( ::alignlib::Alignatum::*removeColumns_function_type )( int,::alignlib::Position ) ; Alignatum_exposer.def( "removeColumns" , removeColumns_function_type( &::alignlib::Alignatum::removeColumns ) , ( bp::arg("position"), bp::arg("count")=(int)(1) ) ); } { //::alignlib::Alignatum::removeEndGaps typedef void ( ::alignlib::Alignatum::*removeEndGaps_function_type )( ) ; Alignatum_exposer.def( "removeEndGaps" , removeEndGaps_function_type( &::alignlib::Alignatum::removeEndGaps ) ); } { //::alignlib::Alignatum::write typedef void ( ::alignlib::Alignatum::*write_function_type )( ::std::ostream & ) const; Alignatum_exposer.def( "write" , write_function_type( &::alignlib::Alignatum::write ) , ( bp::arg("output") ) ); } Alignatum_exposer.def( bp::self_ns::str( bp::self ) ); bp::register_ptr_to_python< boost::shared_ptr< alignlib::Alignatum > >(); bp::implicitly_convertible< boost::shared_ptr< alignlib::Alignatum >, boost::shared_ptr< alignlib::AlignlibBase > >(); } }