// This file has been generated by Py++.

//Boost Software License( http://boost.org/more/license_info.html )

#include "boost/python.hpp"

#include "__convenience.pypp.hpp"

#include "__call_policies.pypp.hpp"


#include "cpsw_api_builder.h"
#include "cpsw_api_user.h"

namespace bp = boost::python;

template<typename T>
bp::list wrap_array( T arr, int nelm )
{
 bp::list l;
 for(int i = 0; i < nelm; i++){
  l.append( arr[i]) ; 
 }
 return l;
}

struct IVisitable_wrapper : IVisitable, bp::wrapper< IVisitable > {

    IVisitable_wrapper()
    : IVisitable()
      , bp::wrapper< IVisitable >(){
        // null constructor
        
    }

    virtual void accept( ::IVisitor * v, ::IVisitable::RecursionOrder order, int recursionDepth=IVisitable::DEPTH_INDEFINITE ){
        bp::override func_accept = this->get_override( "accept" );
        func_accept( boost::python::ptr(v), order, recursionDepth );
    }

};

struct IField_wrapper : IField, bp::wrapper< IField > {

    IField_wrapper()
    : IField()
      , bp::wrapper< IField >(){
        // null constructor
        
    }

    virtual ::IField::Cacheable getCacheable(  ) const {
        bp::override func_getCacheable = this->get_override( "getCacheable" );
        return func_getCacheable(  );
    }

    virtual ::EntryImpl getSelf(  ){
        bp::override func_getSelf = this->get_override( "getSelf" );
        return func_getSelf(  );
    }

    virtual void setCacheable( ::IField::Cacheable arg0 ){
        bp::override func_setCacheable = this->get_override( "setCacheable" );
        func_setCacheable( arg0 );
    }

    virtual void setDescription( char const * arg0 ){
        bp::override func_setDescription = this->get_override( "setDescription" );
        func_setDescription( arg0 );
    }

    virtual void setDescription( ::std::string const & arg0 ){
        bp::override func_setDescription = this->get_override( "setDescription" );
        func_setDescription( arg0 );
    }

    virtual void accept( ::IVisitor * v, ::IVisitable::RecursionOrder order, int recursionDepth=IVisitable::DEPTH_INDEFINITE ){
        bp::override func_accept = this->get_override( "accept" );
        func_accept( boost::python::ptr(v), order, recursionDepth );
    }

    virtual char const * getDescription(  ) const {
        bp::override func_getDescription = this->get_override( "getDescription" );
        return func_getDescription(  );
    }

    virtual char const * getName(  ) const {
        bp::override func_getName = this->get_override( "getName" );
        return func_getName(  );
    }

    virtual ::uint64_t getSize(  ) const {
        bp::override func_getSize = this->get_override( "getSize" );
        return func_getSize(  );
    }

    virtual ::Hub isHub(  ) const {
        bp::override func_isHub = this->get_override( "isHub" );
        return func_isHub(  );
    }

};

struct ICommandField_wrapper : ICommandField, bp::wrapper< ICommandField > {

    ICommandField_wrapper()
    : ICommandField()
      , bp::wrapper< ICommandField >(){
        // null constructor
        
    }

    virtual void accept( ::IVisitor * v, ::IVisitable::RecursionOrder order, int recursionDepth=IVisitable::DEPTH_INDEFINITE ){
        bp::override func_accept = this->get_override( "accept" );
        func_accept( boost::python::ptr(v), order, recursionDepth );
    }

    virtual ::IField::Cacheable getCacheable(  ) const {
        bp::override func_getCacheable = this->get_override( "getCacheable" );
        return func_getCacheable(  );
    }

    virtual char const * getDescription(  ) const {
        bp::override func_getDescription = this->get_override( "getDescription" );
        return func_getDescription(  );
    }

    virtual char const * getName(  ) const {
        bp::override func_getName = this->get_override( "getName" );
        return func_getName(  );
    }

    virtual ::EntryImpl getSelf(  ){
        bp::override func_getSelf = this->get_override( "getSelf" );
        return func_getSelf(  );
    }

    virtual ::uint64_t getSize(  ) const {
        bp::override func_getSize = this->get_override( "getSize" );
        return func_getSize(  );
    }

    virtual ::Hub isHub(  ) const {
        bp::override func_isHub = this->get_override( "isHub" );
        return func_isHub(  );
    }

    virtual void setCacheable( ::IField::Cacheable arg0 ){
        bp::override func_setCacheable = this->get_override( "setCacheable" );
        func_setCacheable( arg0 );
    }

    virtual void setDescription( char const * arg0 ){
        bp::override func_setDescription = this->get_override( "setDescription" );
        func_setDescription( arg0 );
    }

    virtual void setDescription( ::std::string const & arg0 ){
        bp::override func_setDescription = this->get_override( "setDescription" );
        func_setDescription( arg0 );
    }

};

struct IDev_wrapper : IDev, bp::wrapper< IDev > {

    IDev_wrapper()
    : IDev()
      , bp::wrapper< IDev >(){
        // null constructor
        
    }

    virtual void addAtAddress( ::Field f, unsigned int nelms=1 ){
        bp::override func_addAtAddress = this->get_override( "addAtAddress" );
        func_addAtAddress( f, nelms );
    }

    virtual void accept( ::IVisitor * v, ::IVisitable::RecursionOrder order, int recursionDepth=IVisitable::DEPTH_INDEFINITE ){
        bp::override func_accept = this->get_override( "accept" );
        func_accept( boost::python::ptr(v), order, recursionDepth );
    }

    virtual ::Path findByName( char const * path ){
        bp::override func_findByName = this->get_override( "findByName" );
        return func_findByName( path );
    }

    virtual ::IField::Cacheable getCacheable(  ) const {
        bp::override func_getCacheable = this->get_override( "getCacheable" );
        return func_getCacheable(  );
    }

    virtual ::Child getChild( char const * name ) const {
        bp::override func_getChild = this->get_override( "getChild" );
        return func_getChild( name );
    }

    virtual ::Children getChildren(  ) const {
        bp::override func_getChildren = this->get_override( "getChildren" );
        return func_getChildren(  );
    }

    virtual char const * getDescription(  ) const {
        bp::override func_getDescription = this->get_override( "getDescription" );
        return func_getDescription(  );
    }

    virtual char const * getName(  ) const {
        bp::override func_getName = this->get_override( "getName" );
        return func_getName(  );
    }

    virtual ::EntryImpl getSelf(  ){
        bp::override func_getSelf = this->get_override( "getSelf" );
        return func_getSelf(  );
    }

    virtual ::uint64_t getSize(  ) const {
        bp::override func_getSize = this->get_override( "getSize" );
        return func_getSize(  );
    }

    virtual ::Hub isHub(  ) const {
        bp::override func_isHub = this->get_override( "isHub" );
        return func_isHub(  );
    }

    virtual void setCacheable( ::IField::Cacheable arg0 ){
        bp::override func_setCacheable = this->get_override( "setCacheable" );
        func_setCacheable( arg0 );
    }

    virtual void setDescription( char const * arg0 ){
        bp::override func_setDescription = this->get_override( "setDescription" );
        func_setDescription( arg0 );
    }

    virtual void setDescription( ::std::string const & arg0 ){
        bp::override func_setDescription = this->get_override( "setDescription" );
        func_setDescription( arg0 );
    }

};

struct IIntField_wrapper : IIntField, bp::wrapper< IIntField > {

    IIntField_wrapper()
    : IIntField()
      , bp::wrapper< IIntField >(){
        // null constructor
        
    }

    struct IBuilder_wrapper : IIntField::IBuilder, bp::wrapper< IIntField::IBuilder > {
    
        IBuilder_wrapper()
        : IIntField::IBuilder()
          , bp::wrapper< IIntField::IBuilder >(){
            // null constructor
            
        }
    
        virtual ::IntField build(  ){
            bp::override func_build = this->get_override( "build" );
            return func_build(  );
        }
    
        virtual ::IntField build( char const * arg0 ){
            bp::override func_build = this->get_override( "build" );
            return func_build( arg0 );
        }
    
        virtual ::boost::shared_ptr< IIntField::IBuilder > clone(  ){
            bp::override func_clone = this->get_override( "clone" );
            return func_clone(  );
        }
    
        virtual ::boost::shared_ptr< IIntField::IBuilder > isSigned( bool arg0 ){
            bp::override func_isSigned = this->get_override( "isSigned" );
            return func_isSigned( arg0 );
        }
    
        virtual ::boost::shared_ptr< IIntField::IBuilder > lsBit( int arg0 ){
            bp::override func_lsBit = this->get_override( "lsBit" );
            return func_lsBit( arg0 );
        }
    
        virtual ::boost::shared_ptr< IIntField::IBuilder > mode( ::IIntField::Mode arg0 ){
            bp::override func_mode = this->get_override( "mode" );
            return func_mode( arg0 );
        }
    
        virtual ::boost::shared_ptr< IIntField::IBuilder > name( char const * arg0 ){
            bp::override func_name = this->get_override( "name" );
            return func_name( arg0 );
        }
    
        virtual ::boost::shared_ptr< IIntField::IBuilder > reset(  ){
            bp::override func_reset = this->get_override( "reset" );
            return func_reset(  );
        }
    
        virtual ::boost::shared_ptr< IIntField::IBuilder > setEnum( ::Enum arg0 ){
            bp::override func_setEnum = this->get_override( "setEnum" );
            return func_setEnum( arg0 );
        }
    
        virtual ::boost::shared_ptr< IIntField::IBuilder > sizeBits( ::uint64_t arg0 ){
            bp::override func_sizeBits = this->get_override( "sizeBits" );
            return func_sizeBits( arg0 );
        }
    
        virtual ::boost::shared_ptr< IIntField::IBuilder > wordSwap( unsigned int arg0 ){
            bp::override func_wordSwap = this->get_override( "wordSwap" );
            return func_wordSwap( arg0 );
        }
    
    };

    virtual int getLsBit(  ) const {
        bp::override func_getLsBit = this->get_override( "getLsBit" );
        return func_getLsBit(  );
    }

    virtual ::IIntField::Mode getMode(  ) const {
        bp::override func_getMode = this->get_override( "getMode" );
        return func_getMode(  );
    }

    virtual ::uint64_t getSizeBits(  ) const {
        bp::override func_getSizeBits = this->get_override( "getSizeBits" );
        return func_getSizeBits(  );
    }

    virtual bool isSigned(  ) const {
        bp::override func_isSigned = this->get_override( "isSigned" );
        return func_isSigned(  );
    }

    virtual void accept( ::IVisitor * v, ::IVisitable::RecursionOrder order, int recursionDepth=IVisitable::DEPTH_INDEFINITE ){
        bp::override func_accept = this->get_override( "accept" );
        func_accept( boost::python::ptr(v), order, recursionDepth );
    }

    virtual ::IField::Cacheable getCacheable(  ) const {
        bp::override func_getCacheable = this->get_override( "getCacheable" );
        return func_getCacheable(  );
    }

    virtual char const * getDescription(  ) const {
        bp::override func_getDescription = this->get_override( "getDescription" );
        return func_getDescription(  );
    }

    virtual char const * getName(  ) const {
        bp::override func_getName = this->get_override( "getName" );
        return func_getName(  );
    }

    virtual ::EntryImpl getSelf(  ){
        bp::override func_getSelf = this->get_override( "getSelf" );
        return func_getSelf(  );
    }

    virtual ::uint64_t getSize(  ) const {
        bp::override func_getSize = this->get_override( "getSize" );
        return func_getSize(  );
    }

    virtual ::Hub isHub(  ) const {
        bp::override func_isHub = this->get_override( "isHub" );
        return func_isHub(  );
    }

    virtual void setCacheable( ::IField::Cacheable arg0 ){
        bp::override func_setCacheable = this->get_override( "setCacheable" );
        func_setCacheable( arg0 );
    }

    virtual void setDescription( char const * arg0 ){
        bp::override func_setDescription = this->get_override( "setDescription" );
        func_setDescription( arg0 );
    }

    virtual void setDescription( ::std::string const & arg0 ){
        bp::override func_setDescription = this->get_override( "setDescription" );
        func_setDescription( arg0 );
    }

};

struct IMMIODev_wrapper : IMMIODev, bp::wrapper< IMMIODev > {

    IMMIODev_wrapper()
    : IMMIODev()
      , bp::wrapper< IMMIODev >(){
        // null constructor
        
    }

    virtual void addAtAddress( ::Field child, ::uint64_t offset, unsigned int nelms=1, ::uint64_t stride=IMMIODev::STRIDE_AUTO, ::ByteOrder byteOrder=::UNKNOWN ){
        bp::override func_addAtAddress = this->get_override( "addAtAddress" );
        func_addAtAddress( child, offset, nelms, stride, byteOrder );
    }

    virtual void accept( ::IVisitor * v, ::IVisitable::RecursionOrder order, int recursionDepth=IVisitable::DEPTH_INDEFINITE ){
        bp::override func_accept = this->get_override( "accept" );
        func_accept( boost::python::ptr(v), order, recursionDepth );
    }

    virtual void addAtAddress( ::Field f, unsigned int nelms=1 ){
        bp::override func_addAtAddress = this->get_override( "addAtAddress" );
        func_addAtAddress( f, nelms );
    }

    virtual ::Path findByName( char const * path ){
        bp::override func_findByName = this->get_override( "findByName" );
        return func_findByName( path );
    }

    virtual ::IField::Cacheable getCacheable(  ) const {
        bp::override func_getCacheable = this->get_override( "getCacheable" );
        return func_getCacheable(  );
    }

    virtual ::Child getChild( char const * name ) const {
        bp::override func_getChild = this->get_override( "getChild" );
        return func_getChild( name );
    }

    virtual ::Children getChildren(  ) const {
        bp::override func_getChildren = this->get_override( "getChildren" );
        return func_getChildren(  );
    }

    virtual char const * getDescription(  ) const {
        bp::override func_getDescription = this->get_override( "getDescription" );
        return func_getDescription(  );
    }

    virtual char const * getName(  ) const {
        bp::override func_getName = this->get_override( "getName" );
        return func_getName(  );
    }

    virtual ::EntryImpl getSelf(  ){
        bp::override func_getSelf = this->get_override( "getSelf" );
        return func_getSelf(  );
    }

    virtual ::uint64_t getSize(  ) const {
        bp::override func_getSize = this->get_override( "getSize" );
        return func_getSize(  );
    }

    virtual ::Hub isHub(  ) const {
        bp::override func_isHub = this->get_override( "isHub" );
        return func_isHub(  );
    }

    virtual void setCacheable( ::IField::Cacheable arg0 ){
        bp::override func_setCacheable = this->get_override( "setCacheable" );
        func_setCacheable( arg0 );
    }

    virtual void setDescription( char const * arg0 ){
        bp::override func_setDescription = this->get_override( "setDescription" );
        func_setDescription( arg0 );
    }

    virtual void setDescription( ::std::string const & arg0 ){
        bp::override func_setDescription = this->get_override( "setDescription" );
        func_setDescription( arg0 );
    }

};

struct IMemDev_wrapper : IMemDev, bp::wrapper< IMemDev > {

    IMemDev_wrapper()
    : IMemDev()
      , bp::wrapper< IMemDev >(){
        // null constructor
        
    }

    virtual void addAtAddress( ::Field child, unsigned int nelms=1 ){
        bp::override func_addAtAddress = this->get_override( "addAtAddress" );
        func_addAtAddress( child, nelms );
    }

    virtual ::uint8_t * const getBufp(  ) const {
        bp::override func_getBufp = this->get_override( "getBufp" );
        return func_getBufp(  );
    }

    virtual void accept( ::IVisitor * v, ::IVisitable::RecursionOrder order, int recursionDepth=IVisitable::DEPTH_INDEFINITE ){
        bp::override func_accept = this->get_override( "accept" );
        func_accept( boost::python::ptr(v), order, recursionDepth );
    }

    virtual ::Path findByName( char const * path ){
        bp::override func_findByName = this->get_override( "findByName" );
        return func_findByName( path );
    }

    virtual ::IField::Cacheable getCacheable(  ) const {
        bp::override func_getCacheable = this->get_override( "getCacheable" );
        return func_getCacheable(  );
    }

    virtual ::Child getChild( char const * name ) const {
        bp::override func_getChild = this->get_override( "getChild" );
        return func_getChild( name );
    }

    virtual ::Children getChildren(  ) const {
        bp::override func_getChildren = this->get_override( "getChildren" );
        return func_getChildren(  );
    }

    virtual char const * getDescription(  ) const {
        bp::override func_getDescription = this->get_override( "getDescription" );
        return func_getDescription(  );
    }

    virtual char const * getName(  ) const {
        bp::override func_getName = this->get_override( "getName" );
        return func_getName(  );
    }

    virtual ::EntryImpl getSelf(  ){
        bp::override func_getSelf = this->get_override( "getSelf" );
        return func_getSelf(  );
    }

    virtual ::uint64_t getSize(  ) const {
        bp::override func_getSize = this->get_override( "getSize" );
        return func_getSize(  );
    }

    virtual ::Hub isHub(  ) const {
        bp::override func_isHub = this->get_override( "isHub" );
        return func_isHub(  );
    }

    virtual void setCacheable( ::IField::Cacheable arg0 ){
        bp::override func_setCacheable = this->get_override( "setCacheable" );
        func_setCacheable( arg0 );
    }

    virtual void setDescription( char const * arg0 ){
        bp::override func_setDescription = this->get_override( "setDescription" );
        func_setDescription( arg0 );
    }

    virtual void setDescription( ::std::string const & arg0 ){
        bp::override func_setDescription = this->get_override( "setDescription" );
        func_setDescription( arg0 );
    }

};

struct IMutableEnum_wrapper : IMutableEnum, bp::wrapper< IMutableEnum > {

    IMutableEnum_wrapper()
    : IMutableEnum()
      , bp::wrapper< IMutableEnum >(){
        // null constructor
        
    }

    virtual void add( char const * enum_string, ::uint64_t enum_num ){
        bp::override func_add = this->get_override( "add" );
        func_add( enum_string, enum_num );
    }

    virtual ::IEnum::iterator begin(  ) const {
        bp::override func_begin = this->get_override( "begin" );
        return func_begin(  );
    }

    virtual ::IEnum::iterator end(  ) const {
        bp::override func_end = this->get_override( "end" );
        return func_end(  );
    }

    virtual unsigned int getNelms(  ) const {
        bp::override func_getNelms = this->get_override( "getNelms" );
        return func_getNelms(  );
    }

    virtual ::std::pair< boost::shared_ptr< std::string const >, unsigned long > map( ::uint64_t arg0 ){
        bp::override func_map = this->get_override( "map" );
        return func_map( arg0 );
    }

    virtual ::std::pair< boost::shared_ptr< std::string const >, unsigned long > map( char const * arg0 ){
        bp::override func_map = this->get_override( "map" );
        return func_map( arg0 );
    }

};

struct INoSsiDev_wrapper : INoSsiDev, bp::wrapper< INoSsiDev > {

    INoSsiDev_wrapper()
    : INoSsiDev()
      , bp::wrapper< INoSsiDev >(){
        // null constructor
        
    }

    virtual void addAtAddress( ::Field child, ::INoSsiDev::ProtocolVersion version=::INoSsiDev::SRP_UDP_V2, unsigned int dport=8192, unsigned int timeoutUs=1000, unsigned int retryCnt=10, ::uint8_t vc=0 ){
        bp::override func_addAtAddress = this->get_override( "addAtAddress" );
        func_addAtAddress( child, version, dport, timeoutUs, retryCnt, vc );
    }

    virtual void addAtStream( ::Field child, unsigned int dport, unsigned int timeoutUs, unsigned int inQDepth=32, unsigned int outQDepth=16, unsigned int ldFrameWinSize=4, unsigned int ldFragWinSize=4, unsigned int nUdpThreads=2 ){
        bp::override func_addAtStream = this->get_override( "addAtStream" );
        func_addAtStream( child, dport, timeoutUs, inQDepth, outQDepth, ldFrameWinSize, ldFragWinSize, nUdpThreads );
    }

    virtual char const * getIpAddressString(  ) const {
        bp::override func_getIpAddressString = this->get_override( "getIpAddressString" );
        return func_getIpAddressString(  );
    }

    virtual void accept( ::IVisitor * v, ::IVisitable::RecursionOrder order, int recursionDepth=IVisitable::DEPTH_INDEFINITE ){
        bp::override func_accept = this->get_override( "accept" );
        func_accept( boost::python::ptr(v), order, recursionDepth );
    }

    virtual void addAtAddress( ::Field f, unsigned int nelms=1 ){
        bp::override func_addAtAddress = this->get_override( "addAtAddress" );
        func_addAtAddress( f, nelms );
    }

    virtual ::Path findByName( char const * path ){
        bp::override func_findByName = this->get_override( "findByName" );
        return func_findByName( path );
    }

    virtual ::IField::Cacheable getCacheable(  ) const {
        bp::override func_getCacheable = this->get_override( "getCacheable" );
        return func_getCacheable(  );
    }

    virtual ::Child getChild( char const * name ) const {
        bp::override func_getChild = this->get_override( "getChild" );
        return func_getChild( name );
    }

    virtual ::Children getChildren(  ) const {
        bp::override func_getChildren = this->get_override( "getChildren" );
        return func_getChildren(  );
    }

    virtual char const * getDescription(  ) const {
        bp::override func_getDescription = this->get_override( "getDescription" );
        return func_getDescription(  );
    }

    virtual char const * getName(  ) const {
        bp::override func_getName = this->get_override( "getName" );
        return func_getName(  );
    }

    virtual ::EntryImpl getSelf(  ){
        bp::override func_getSelf = this->get_override( "getSelf" );
        return func_getSelf(  );
    }

    virtual ::uint64_t getSize(  ) const {
        bp::override func_getSize = this->get_override( "getSize" );
        return func_getSize(  );
    }

    virtual ::Hub isHub(  ) const {
        bp::override func_isHub = this->get_override( "isHub" );
        return func_isHub(  );
    }

    virtual void setCacheable( ::IField::Cacheable arg0 ){
        bp::override func_setCacheable = this->get_override( "setCacheable" );
        func_setCacheable( arg0 );
    }

    virtual void setDescription( char const * arg0 ){
        bp::override func_setDescription = this->get_override( "setDescription" );
        func_setDescription( arg0 );
    }

    virtual void setDescription( ::std::string const & arg0 ){
        bp::override func_setDescription = this->get_override( "setDescription" );
        func_setDescription( arg0 );
    }

};

struct IVisitor_wrapper : IVisitor, bp::wrapper< IVisitor > {

    IVisitor_wrapper()
    : IVisitor()
      , bp::wrapper< IVisitor >(){
        // null constructor
        
    }

    virtual void visit( ::Field arg0 ){
        bp::override func_visit = this->get_override( "visit" );
        func_visit( arg0 );
    }

    virtual void visit( ::Dev d ) {
        if( bp::override func_visit = this->get_override( "visit" ) )
            func_visit( d );
        else{
            this->IVisitor::visit( d );
        }
    }
    
    void default_visit( ::Dev d ) {
        IVisitor::visit( d );
    }

};


struct IEntry_wrapper : IEntry, bp::wrapper< IEntry > {

    IEntry_wrapper()
    : IEntry()
      , bp::wrapper< IEntry >(){
        // null constructor
        
    }

    virtual char const * getDescription(  ) const {
        bp::override func_getDescription = this->get_override( "getDescription" );
        return func_getDescription(  );
    }

    virtual char const * getName(  ) const {
        bp::override func_getName = this->get_override( "getName" );
        return func_getName(  );
    }

    virtual ::uint64_t getSize(  ) const {
        bp::override func_getSize = this->get_override( "getSize" );
        return func_getSize(  );
    }

    virtual ::Hub isHub(  ) const {
        bp::override func_isHub = this->get_override( "isHub" );
        return func_isHub(  );
    }

};

struct IChild_wrapper : IChild, bp::wrapper< IChild > {

    IChild_wrapper()
    : IChild()
      , bp::wrapper< IChild >(){
        // null constructor
        
    }

    virtual void dump( ::FILE * arg0 ) const {
        bp::override func_dump = this->get_override( "dump" );
        func_dump( boost::python::ptr(arg0) );
    }

    virtual void dump(  ) const {
        bp::override func_dump = this->get_override( "dump" );
        func_dump(  );
    }

    virtual unsigned int getNelms(  ) const {
        bp::override func_getNelms = this->get_override( "getNelms" );
        return func_getNelms(  );
    }

    virtual ::Hub getOwner(  ) const {
        bp::override func_getOwner = this->get_override( "getOwner" );
        return func_getOwner(  );
    }

    virtual char const * getDescription(  ) const {
        bp::override func_getDescription = this->get_override( "getDescription" );
        return func_getDescription(  );
    }

    virtual char const * getName(  ) const {
        bp::override func_getName = this->get_override( "getName" );
        return func_getName(  );
    }

    virtual ::uint64_t getSize(  ) const {
        bp::override func_getSize = this->get_override( "getSize" );
        return func_getSize(  );
    }

    virtual ::Hub isHub(  ) const {
        bp::override func_isHub = this->get_override( "isHub" );
        return func_isHub(  );
    }

};

struct IHub_wrapper : IHub, bp::wrapper< IHub > {

    IHub_wrapper()
    : IHub()
      , bp::wrapper< IHub >(){
        // null constructor
        
    }

    virtual ::Path findByName( char const * path ){
        bp::override func_findByName = this->get_override( "findByName" );
        return func_findByName( path );
    }

    virtual ::Child getChild( char const * name ) const {
        bp::override func_getChild = this->get_override( "getChild" );
        return func_getChild( name );
    }

    virtual ::Children getChildren(  ) const {
        bp::override func_getChildren = this->get_override( "getChildren" );
        return func_getChildren(  );
    }

    virtual char const * getDescription(  ) const {
        bp::override func_getDescription = this->get_override( "getDescription" );
        return func_getDescription(  );
    }

    virtual char const * getName(  ) const {
        bp::override func_getName = this->get_override( "getName" );
        return func_getName(  );
    }

    virtual ::uint64_t getSize(  ) const {
        bp::override func_getSize = this->get_override( "getSize" );
        return func_getSize(  );
    }

    virtual ::Hub isHub(  ) const {
        bp::override func_isHub = this->get_override( "isHub" );
        return func_isHub(  );
    }

};

struct IPath_wrapper : IPath, bp::wrapper< IPath > {

    IPath_wrapper()
    : IPath()
      , bp::wrapper< IPath >(){
        // null constructor
        
    }

    virtual void append( ::Path p ){
        bp::override func_append = this->get_override( "append" );
        func_append( p );
    }

    virtual void clear(  ){
        bp::override func_clear = this->get_override( "clear" );
        func_clear(  );
    }

    virtual void clear( ::Hub arg0 ){
        bp::override func_clear = this->get_override( "clear" );
        func_clear( arg0 );
    }

    virtual ::Path clone(  ) const {
        bp::override func_clone = this->get_override( "clone" );
        return func_clone(  );
    }

    virtual ::Path concat( ::Path p ) const {
        bp::override func_concat = this->get_override( "concat" );
        return func_concat( p );
    }

    virtual void dump( ::FILE * arg0 ) const {
        bp::override func_dump = this->get_override( "dump" );
        func_dump( boost::python::ptr(arg0) );
    }

    virtual bool empty(  ) const {
        bp::override func_empty = this->get_override( "empty" );
        return func_empty(  );
    }

    virtual ::Path findByName( char const * name ) const {
        bp::override func_findByName = this->get_override( "findByName" );
        return func_findByName( name );
    }

    virtual unsigned int getNelms(  ) const {
        bp::override func_getNelms = this->get_override( "getNelms" );
        return func_getNelms(  );
    }

    virtual ::Hub origin(  ) const {
        bp::override func_origin = this->get_override( "origin" );
        return func_origin(  );
    }

    virtual ::Hub parent(  ) const {
        bp::override func_parent = this->get_override( "parent" );
        return func_parent(  );
    }

    virtual ::Child tail(  ) const {
        bp::override func_tail = this->get_override( "tail" );
        return func_tail(  );
    }

    virtual ::std::string toString(  ) const {
        bp::override func_toString = this->get_override( "toString" );
        return func_toString(  );
    }

    virtual ::Child up(  ){
        bp::override func_up = this->get_override( "up" );
        return func_up(  );
    }

    virtual bool verifyAtTail( ::Path p ){
        bp::override func_verifyAtTail = this->get_override( "verifyAtTail" );
        return func_verifyAtTail( p );
    }

};



struct IScalVal_Base_wrapper : IScalVal_Base, bp::wrapper< IScalVal_Base > {

    IScalVal_Base_wrapper()
    : IScalVal_Base()
      , bp::wrapper< IScalVal_Base >(){
        // null constructor
        
    }

    virtual ::Enum getEnum(  ) const {
        bp::override func_getEnum = this->get_override( "getEnum" );
        return func_getEnum(  );
    }

    virtual unsigned int getNelms(  ){
        bp::override func_getNelms = this->get_override( "getNelms" );
        return func_getNelms(  );
    }

    virtual ::Path getPath(  ) const {
        bp::override func_getPath = this->get_override( "getPath" );
        return func_getPath(  );
    }

    virtual ::uint64_t getSizeBits(  ) const {
        bp::override func_getSizeBits = this->get_override( "getSizeBits" );
        return func_getSizeBits(  );
    }

    virtual bool isSigned(  ) const {
        bp::override func_isSigned = this->get_override( "isSigned" );
        return func_isSigned(  );
    }

    virtual char const * getDescription(  ) const {
        bp::override func_getDescription = this->get_override( "getDescription" );
        return func_getDescription(  );
    }

    virtual char const * getName(  ) const {
        bp::override func_getName = this->get_override( "getName" );
        return func_getName(  );
    }

    virtual ::uint64_t getSize(  ) const {
        bp::override func_getSize = this->get_override( "getSize" );
        return func_getSize(  );
    }

    virtual ::Hub isHub(  ) const {
        bp::override func_isHub = this->get_override( "isHub" );
        return func_isHub(  );
    }

};

struct IndexRange_wrapper : IndexRange, bp::wrapper< IndexRange > {

    IndexRange_wrapper(IndexRange const & arg )
    : IndexRange( arg )
      , bp::wrapper< IndexRange >(){
        // copy constructor
        
    }

    IndexRange_wrapper(int from, int to )
    : IndexRange( from, to )
      , bp::wrapper< IndexRange >(){
        // constructor
    
    }

    IndexRange_wrapper(int fromto )
    : IndexRange( fromto )
      , bp::wrapper< IndexRange >(){
        // constructor
    
    }

    virtual int getFrom(  ) {
        if( bp::override func_getFrom = this->get_override( "getFrom" ) )
            return func_getFrom(  );
        else{
            return this->IndexRange::getFrom(  );
        }
    }
    
    int default_getFrom(  ) {
        return IndexRange::getFrom( );
    }

    virtual int getTo(  ) {
        if( bp::override func_getTo = this->get_override( "getTo" ) )
            return func_getTo(  );
        else{
            return this->IndexRange::getTo(  );
        }
    }
    
    int default_getTo(  ) {
        return IndexRange::getTo( );
    }

    virtual void setFrom( int arg0 ) {
        if( bp::override func_setFrom = this->get_override( "setFrom" ) )
            func_setFrom( arg0 );
        else{
            this->IndexRange::setFrom( arg0 );
        }
    }
    
    void default_setFrom( int arg0 ) {
        IndexRange::setFrom( arg0 );
    }

    virtual void setFromTo( int arg0 ) {
        if( bp::override func_setFromTo = this->get_override( "setFromTo" ) )
            func_setFromTo( arg0 );
        else{
            this->IndexRange::setFromTo( arg0 );
        }
    }
    
    void default_setFromTo( int arg0 ) {
        IndexRange::setFromTo( arg0 );
    }

    virtual void setFromTo( int from, int to ) {
        if( bp::override func_setFromTo = this->get_override( "setFromTo" ) )
            func_setFromTo( from, to );
        else{
            this->IndexRange::setFromTo( from, to );
        }
    }
    
    void default_setFromTo( int from, int to ) {
        IndexRange::setFromTo( from, to );
    }

    virtual void setTo( int arg0 ) {
        if( bp::override func_setTo = this->get_override( "setTo" ) )
            func_setTo( arg0 );
        else{
            this->IndexRange::setTo( arg0 );
        }
    }
    
    void default_setTo( int arg0 ) {
        IndexRange::setTo( arg0 );
    }

};

struct IScalVal_RO_wrapper : IScalVal_RO, bp::wrapper< IScalVal_RO > {

    IScalVal_RO_wrapper()
    : IScalVal_RO()
      , bp::wrapper< IScalVal_RO >(){
        // null constructor
        
    }

    virtual unsigned int getVal( ::uint64_t * p, unsigned int nelms=1, ::IndexRange * range=0 ) {
        namespace bpl = boost::python;
        if( bpl::override func_getVal = this->get_override( "getVal" ) ){
            bpl::object py_result = bpl::call<bpl::object>( func_getVal.ptr(), nelms, range );
            *p = boost::python::extract< long unsigned int >( pyplus_conv::get_out_argument( py_result, "p" ) );
            return bpl::extract< unsigned int >( pyplus_conv::get_out_argument( py_result, 0 ) );
        }
        else{
              PyErr_SetString(PyExc_NotImplementedError, "Attempted calling Pure Virtual function that is not implemented :getVal");
              boost::python::throw_error_already_set();
        }
    }
    
    static boost::python::tuple default_getVal_b0638da20e7596e8f27dba3f0b00cb67( ::IScalVal_RO & inst, unsigned int nelms=1, ::IndexRange * range=0 ){
        uint64_t p2[1000];
        unsigned int result;
        if( dynamic_cast< IScalVal_RO_wrapper * >( boost::addressof( inst ) ) ){
              PyErr_SetString(PyExc_NotImplementedError, "Attempted calling Pure Virtual function that is not implemented :getVal");
              boost::python::throw_error_already_set();
        }
        else{
            result = inst.getVal( &p2[0], nelms, range);
        }
        return bp::make_tuple( result, wrap_array( p2, nelms) );
    }

    virtual unsigned int getVal( ::uint32_t * p, unsigned int nelms=1, ::IndexRange * range=0 ) {
        namespace bpl = boost::python;
        if( bpl::override func_getVal = this->get_override( "getVal" ) ){
            bpl::object py_result = bpl::call<bpl::object>( func_getVal.ptr(), nelms, range );
            *p = boost::python::extract< unsigned int >( pyplus_conv::get_out_argument( py_result, "p" ) );
            return bpl::extract< unsigned int >( pyplus_conv::get_out_argument( py_result, 0 ) );
        }
        else{
              PyErr_SetString(PyExc_NotImplementedError, "Attempted calling Pure Virtual function that is not implemented :getVal");
              boost::python::throw_error_already_set();
        }
    }
    
    static boost::python::tuple default_getVal_6193488e65b3131159f95715d15a1f6a( ::IScalVal_RO & inst, unsigned int nelms=1, ::IndexRange * range=0 ){
        uint32_t p2[1000];
        unsigned int result;
        if( dynamic_cast< IScalVal_RO_wrapper * >( boost::addressof( inst ) ) ){
              PyErr_SetString(PyExc_NotImplementedError, "Attempted calling Pure Virtual function that is not implemented :getVal");
              boost::python::throw_error_already_set();
        }
        else{
            result = inst.getVal(&p2[0], nelms, range);
        }
        return bp::make_tuple( result, wrap_array( p2, nelms) );
    }

    virtual unsigned int getVal( ::uint16_t * p, unsigned int nelms=1, ::IndexRange * range=0 ) {
        namespace bpl = boost::python;
        if( bpl::override func_getVal = this->get_override( "getVal" ) ){
            bpl::object py_result = bpl::call<bpl::object>( func_getVal.ptr(), nelms, range );
            *p = boost::python::extract< short unsigned int >( pyplus_conv::get_out_argument( py_result, "p" ) );
            return bpl::extract< unsigned int >( pyplus_conv::get_out_argument( py_result, 0 ) );
        }
        else{
              PyErr_SetString(PyExc_NotImplementedError, "Attempted calling Pure Virtual function that is not implemented :getVal");
              boost::python::throw_error_already_set();
        }
    }
    
    static boost::python::tuple default_getVal_542acbc8b2ae655af2f5bd1a45dcbefa( ::IScalVal_RO & inst, unsigned int nelms=1, ::IndexRange * range=0 ){
        uint16_t p2[1000];
        unsigned int result;
        if( dynamic_cast< IScalVal_RO_wrapper * >( boost::addressof( inst ) ) ){
              PyErr_SetString(PyExc_NotImplementedError, "Attempted calling Pure Virtual function that is not implemented :getVal");
              boost::python::throw_error_already_set();
        }
        else{
            result = inst.getVal(&p2[0], nelms, range);
        }
        return bp::make_tuple( result, wrap_array( p2, nelms) );
    }

    virtual unsigned int getVal( ::uint8_t * p, unsigned int nelms=1, ::IndexRange * range=0 ) {
        namespace bpl = boost::python;
        if( bpl::override func_getVal = this->get_override( "getVal" ) ){
            bpl::object py_result = bpl::call<bpl::object>( func_getVal.ptr(), nelms, range );
            *p = boost::python::extract< unsigned char >( pyplus_conv::get_out_argument( py_result, "p" ) );
            return bpl::extract< unsigned int >( pyplus_conv::get_out_argument( py_result, 0 ) );
        }
        else{
              PyErr_SetString(PyExc_NotImplementedError, "Attempted calling Pure Virtual function that is not implemented :getVal");
              boost::python::throw_error_already_set();
        }
    }
    
    static boost::python::tuple default_getVal_f8a4f576323e947d8f52210e3407bcac( ::IScalVal_RO & inst, unsigned int nelms=1, ::IndexRange * range=0 ){
        uint8_t p2[1000];
        unsigned int result;
        if( dynamic_cast< IScalVal_RO_wrapper * >( boost::addressof( inst ) ) ){
              PyErr_SetString(PyExc_NotImplementedError, "Attempted calling Pure Virtual function that is not implemented :getVal");
              boost::python::throw_error_already_set();
        }
        else{
            result = inst.getVal(&p2[0], nelms, range);
        }
       return bp::make_tuple( result, wrap_array( p2, nelms) );
    }

    virtual unsigned int getVal( ::CString * p, unsigned int nelms=1, ::IndexRange * range=0 ){
        bp::override func_getVal = this->get_override( "getVal" );
        return func_getVal( p, nelms, boost::python::ptr(range) );
    }

    virtual char const * getDescription(  ) const {
        bp::override func_getDescription = this->get_override( "getDescription" );
        return func_getDescription(  );
    }

    virtual ::Enum getEnum(  ) const {
        bp::override func_getEnum = this->get_override( "getEnum" );
        return func_getEnum(  );
    }

    virtual char const * getName(  ) const {
        bp::override func_getName = this->get_override( "getName" );
        return func_getName(  );
    }

    virtual unsigned int getNelms(  ){
        bp::override func_getNelms = this->get_override( "getNelms" );
        return func_getNelms(  );
    }

    virtual ::Path getPath(  ) const {
        bp::override func_getPath = this->get_override( "getPath" );
        return func_getPath(  );
    }

    virtual ::uint64_t getSize(  ) const {
        bp::override func_getSize = this->get_override( "getSize" );
        return func_getSize(  );
    }

    virtual ::uint64_t getSizeBits(  ) const {
        bp::override func_getSizeBits = this->get_override( "getSizeBits" );
        return func_getSizeBits(  );
    }

    virtual ::Hub isHub(  ) const {
        bp::override func_isHub = this->get_override( "isHub" );
        return func_isHub(  );
    }

    virtual bool isSigned(  ) const {
        bp::override func_isSigned = this->get_override( "isSigned" );
        return func_isSigned(  );
    }

};

struct IScalVal_WO_wrapper : IScalVal_WO, bp::wrapper< IScalVal_WO > {

    IScalVal_WO_wrapper()
    : IScalVal_WO()
      , bp::wrapper< IScalVal_WO >(){
        // null constructor
        
    }

    virtual unsigned int setVal( ::uint64_t * p, unsigned int nelms=1, ::IndexRange * range=0 ){
        bp::override func_setVal = this->get_override( "setVal" );
        return func_setVal( p, nelms, boost::python::ptr(range) );
    }

    virtual unsigned int setVal( ::uint32_t * p, unsigned int nelms=1, ::IndexRange * range=0 ){
        bp::override func_setVal = this->get_override( "setVal" );
        return func_setVal( p, nelms, boost::python::ptr(range) );
    }

    virtual unsigned int setVal( ::uint16_t * p, unsigned int nelms=1, ::IndexRange * range=0 ){
        bp::override func_setVal = this->get_override( "setVal" );
        return func_setVal( p, nelms, boost::python::ptr(range) );
    }

    virtual unsigned int setVal( ::uint8_t * p, unsigned int nelms=1, ::IndexRange * range=0 ){
        bp::override func_setVal = this->get_override( "setVal" );
        return func_setVal( p, nelms, boost::python::ptr(range) );
    }

    virtual unsigned int setVal( char const * * p, unsigned int nelms=1, ::IndexRange * range=0 ){
        bp::override func_setVal = this->get_override( "setVal" );
        return func_setVal( p, nelms, boost::python::ptr(range) );
    }

    virtual unsigned int setVal( ::uint64_t v, ::IndexRange * range=0 ){
        bp::override func_setVal = this->get_override( "setVal" );
        return func_setVal( v, boost::python::ptr(range) );
    }

    virtual unsigned int setVal( char const * v, ::IndexRange * range=0 ){
        bp::override func_setVal = this->get_override( "setVal" );
        return func_setVal( v, boost::python::ptr(range) );
    }

    virtual char const * getDescription(  ) const {
        bp::override func_getDescription = this->get_override( "getDescription" );
        return func_getDescription(  );
    }

    virtual ::Enum getEnum(  ) const {
        bp::override func_getEnum = this->get_override( "getEnum" );
        return func_getEnum(  );
    }

    virtual char const * getName(  ) const {
        bp::override func_getName = this->get_override( "getName" );
        return func_getName(  );
    }

    virtual unsigned int getNelms(  ){
        bp::override func_getNelms = this->get_override( "getNelms" );
        return func_getNelms(  );
    }

    virtual ::Path getPath(  ) const {
        bp::override func_getPath = this->get_override( "getPath" );
        return func_getPath(  );
    }

    virtual ::uint64_t getSize(  ) const {
        bp::override func_getSize = this->get_override( "getSize" );
        return func_getSize(  );
    }

    virtual ::uint64_t getSizeBits(  ) const {
        bp::override func_getSizeBits = this->get_override( "getSizeBits" );
        return func_getSizeBits(  );
    }

    virtual ::Hub isHub(  ) const {
        bp::override func_isHub = this->get_override( "isHub" );
        return func_isHub(  );
    }

    virtual bool isSigned(  ) const {
        bp::override func_isSigned = this->get_override( "isSigned" );
        return func_isSigned(  );
    }

};

struct IScalVal_wrapper : IScalVal, bp::wrapper< IScalVal > {

    IScalVal_wrapper()
    : IScalVal()
      , bp::wrapper< IScalVal >(){
        // null constructor
        
    }

    virtual char const * getDescription(  ) const {
        bp::override func_getDescription = this->get_override( "getDescription" );
        return func_getDescription(  );
    }

    virtual ::Enum getEnum(  ) const {
        bp::override func_getEnum = this->get_override( "getEnum" );
        return func_getEnum(  );
    }

    virtual char const * getName(  ) const {
        bp::override func_getName = this->get_override( "getName" );
        return func_getName(  );
    }

    virtual unsigned int getNelms(  ){
        bp::override func_getNelms = this->get_override( "getNelms" );
        return func_getNelms(  );
    }

    virtual ::Path getPath(  ) const {
        bp::override func_getPath = this->get_override( "getPath" );
        return func_getPath(  );
    }

    virtual ::uint64_t getSize(  ) const {
        bp::override func_getSize = this->get_override( "getSize" );
        return func_getSize(  );
    }

    virtual ::uint64_t getSizeBits(  ) const {
        bp::override func_getSizeBits = this->get_override( "getSizeBits" );
        return func_getSizeBits(  );
    }

    virtual unsigned int getVal( ::uint64_t * p, unsigned int nelms=1, ::IndexRange * range=0 ) {
        namespace bpl = boost::python;
        if( bpl::override func_getVal = this->get_override( "getVal" ) ){
            bpl::object py_result = bpl::call<bpl::object>( func_getVal.ptr(), nelms, range );
            *p = boost::python::extract< long unsigned int >( pyplus_conv::get_out_argument( py_result, "p" ) );
            return bpl::extract< unsigned int >( pyplus_conv::get_out_argument( py_result, 0 ) );
        }
        else{
              PyErr_SetString(PyExc_NotImplementedError, "Attempted calling Pure Virtual function that is not implemented :getVal");
              boost::python::throw_error_already_set();
        }
    }
    
    static boost::python::tuple default_getVal_b0638da20e7596e8f27dba3f0b00cb67( ::IScalVal_RO & inst, unsigned int nelms=1, ::IndexRange * range=0 ){
        uint64_t p2[1000];
        unsigned int result;
        if( dynamic_cast< IScalVal_RO_wrapper * >( boost::addressof( inst ) ) ){
              PyErr_SetString(PyExc_NotImplementedError, "Attempted calling Pure Virtual function that is not implemented :getVal");
              boost::python::throw_error_already_set();
        }
        else{
            result = inst.getVal( &p2[0], nelms, range);
        }
        return bp::make_tuple( result, wrap_array( p2, nelms) );
    }

    virtual unsigned int getVal( ::uint32_t * p, unsigned int nelms=1, ::IndexRange * range=0 ) {
        namespace bpl = boost::python;
        if( bpl::override func_getVal = this->get_override( "getVal" ) ){
            bpl::object py_result = bpl::call<bpl::object>( func_getVal.ptr(), nelms, range );
            *p = boost::python::extract< unsigned int >( pyplus_conv::get_out_argument( py_result, "p" ) );
            return bpl::extract< unsigned int >( pyplus_conv::get_out_argument( py_result, 0 ) );
        }
        else{
              PyErr_SetString(PyExc_NotImplementedError, "Attempted calling Pure Virtual function that is not implemented :getVal");
              boost::python::throw_error_already_set();
        }
    }
    
    static boost::python::tuple default_getVal_6193488e65b3131159f95715d15a1f6a( ::IScalVal_RO & inst, unsigned int nelms=1, ::IndexRange * range=0 ){
        uint32_t p2[1000];
        unsigned int result;
        if( dynamic_cast< IScalVal_wrapper * >( boost::addressof( inst ) ) ){
              PyErr_SetString(PyExc_NotImplementedError, "Attempted calling Pure Virtual function that is not implemented :getVal");
              boost::python::throw_error_already_set();
        }
        else{
            result = inst.getVal(&p2[0], nelms, range);
        }
        return bp::make_tuple( result, wrap_array( p2, nelms) );
    }

    virtual unsigned int getVal( ::uint16_t * p, unsigned int nelms=1, ::IndexRange * range=0 ) {
        namespace bpl = boost::python;
        if( bpl::override func_getVal = this->get_override( "getVal" ) ){
            bpl::object py_result = bpl::call<bpl::object>( func_getVal.ptr(), nelms, range );
            *p = boost::python::extract< short unsigned int >( pyplus_conv::get_out_argument( py_result, "p" ) );
            return bpl::extract< unsigned int >( pyplus_conv::get_out_argument( py_result, 0 ) );
        }
        else{
              PyErr_SetString(PyExc_NotImplementedError, "Attempted calling Pure Virtual function that is not implemented :getVal");
              boost::python::throw_error_already_set();
        }
    }
    
    static boost::python::tuple default_getVal_542acbc8b2ae655af2f5bd1a45dcbefa( ::IScalVal_RO & inst, unsigned int nelms=1, ::IndexRange * range=0 ){
        uint16_t p2[1000];
        unsigned int result;
        if( dynamic_cast< IScalVal_wrapper * >( boost::addressof( inst ) ) ){
              PyErr_SetString(PyExc_NotImplementedError, "Attempted calling Pure Virtual function that is not implemented :getVal");
              boost::python::throw_error_already_set();
        }
        else{
            result = inst.getVal(&p2[0], nelms, range);
        }
        return bp::make_tuple( result, wrap_array( p2, nelms) );
    }

    virtual unsigned int getVal( ::uint8_t * p, unsigned int nelms=1, ::IndexRange * range=0 ) {
        namespace bpl = boost::python;
        if( bpl::override func_getVal = this->get_override( "getVal" ) ){
            bpl::object py_result = bpl::call<bpl::object>( func_getVal.ptr(), nelms, range );
            *p = boost::python::extract< unsigned char >( pyplus_conv::get_out_argument( py_result, "p" ) );
            return bpl::extract< unsigned int >( pyplus_conv::get_out_argument( py_result, 0 ) );
        }
        else{
              PyErr_SetString(PyExc_NotImplementedError, "Attempted calling Pure Virtual function that is not implemented :getVal");
              boost::python::throw_error_already_set();
        }
    }
    
    static boost::python::tuple default_getVal_f8a4f576323e947d8f52210e3407bcac( ::IScalVal_RO & inst, unsigned int nelms=1, ::IndexRange * range=0 ){
        uint8_t p2[1000];
        unsigned int result;
        if( dynamic_cast< IScalVal_wrapper * >( boost::addressof( inst ) ) ){
              PyErr_SetString(PyExc_NotImplementedError, "Attempted calling Pure Virtual function that is not implemented :getVal");
              boost::python::throw_error_already_set();
        }
        else{
            result = inst.getVal(&p2[0], nelms, range);
        }
        return bp::make_tuple( result, wrap_array( p2, nelms) );
    }

    virtual unsigned int getVal( ::CString * p, unsigned int nelms=1, ::IndexRange * range=0 ){
        bp::override func_getVal = this->get_override( "getVal" );
        return func_getVal( p, nelms, boost::python::ptr(range) );
    }

    virtual ::Hub isHub(  ) const {
        bp::override func_isHub = this->get_override( "isHub" );
        return func_isHub(  );
    }

    virtual bool isSigned(  ) const {
        bp::override func_isSigned = this->get_override( "isSigned" );
        return func_isSigned(  );
    }

    virtual unsigned int setVal( ::uint64_t * p, unsigned int nelms=1, ::IndexRange * range=0 ){
        bp::override func_setVal = this->get_override( "setVal" );
        return func_setVal( p, nelms, boost::python::ptr(range) );
    }

    virtual unsigned int setVal( ::uint32_t * p, unsigned int nelms=1, ::IndexRange * range=0 ){
        bp::override func_setVal = this->get_override( "setVal" );
        return func_setVal( p, nelms, boost::python::ptr(range) );
    }
    
    static unsigned int set_value_as_uint16( ::IScalVal &inst, ::uint16_t p, unsigned int nelms=1, ::IndexRange * range=0){
       uint16_t u16 = p;
       int result;
        if( dynamic_cast< IScalVal_wrapper * >( boost::addressof( inst ) ) ){
              PyErr_SetString(PyExc_NotImplementedError, "Attempted calling Pure Virtual function that is not implemented :getVal");
              boost::python::throw_error_already_set();
        }
        else{
            result = inst.setVal(&u16, nelms, range);
        }
       return result;
    }
    
    static unsigned int set_value_as_uint32( ::IScalVal &inst, boost::python::object v, unsigned int nelms=1, ::IndexRange * range=0){
       uint32_t u32[1000];
       boost::python::list py_v;
       pyplus_conv::ensure_uniform_sequence< uint32_t >( v, nelms );
       pyplus_conv::copy_sequence( v, pyplus_conv::array_inserter( u32, nelms ) );
       int result;
        if( dynamic_cast< IScalVal_wrapper * >( boost::addressof( inst ) ) ){
              PyErr_SetString(PyExc_NotImplementedError, "Attempted calling Pure Virtual function that is not implemented :getVal");
              boost::python::throw_error_already_set();
        }
        else{
            result = inst.setVal(&u32[0], nelms, range);
        }
       return result;
    }
    
     static unsigned int set_value_as_uint32( ::IScalVal &inst, uint32_t p, unsigned int nelms=1, ::IndexRange * range=0){
       uint32_t u32 = p;
       int result;
        if( dynamic_cast< IScalVal_wrapper * >( boost::addressof( inst ) ) ){
              PyErr_SetString(PyExc_NotImplementedError, "Attempted calling Pure Virtual function that is not implemented :getVal");
              boost::python::throw_error_already_set();
        }
        else{
            result = inst.setVal(&u32, nelms, range);
        }
       return result;
    }

    virtual unsigned int setVal( ::uint16_t * p, unsigned int nelms=1, ::IndexRange * range=0 ){
        bp::override func_setVal = this->get_override( "setVal" );
        return func_setVal( p, nelms, boost::python::ptr(range) );
    }

    virtual unsigned int setVal( ::uint8_t * p, unsigned int nelms=1, ::IndexRange * range=0 ){
        bp::override func_setVal = this->get_override( "setVal" );
        return func_setVal( p, nelms, boost::python::ptr(range) );
    }

    virtual unsigned int setVal( char const * * p, unsigned int nelms=1, ::IndexRange * range=0 ){
        bp::override func_setVal = this->get_override( "setVal" );
        return func_setVal( p, nelms, boost::python::ptr(range) );
    }

    virtual unsigned int setVal( ::uint64_t v, ::IndexRange * range=0 ){
        bp::override func_setVal = this->get_override( "setVal" );
        return func_setVal( v, boost::python::ptr(range) );
    }

    virtual unsigned int setVal( char const * v, ::IndexRange * range=0 ){
        bp::override func_setVal = this->get_override( "setVal" );
        return func_setVal( v, boost::python::ptr(range) );
    }

};



BOOST_PYTHON_MODULE(cpsw_api_py){
    bp::enum_< ByteOrder>("ByteOrder")
        .value("UNKNOWN", UNKNOWN)
        .value("LE", LE)
        .value("BE", BE)
        .export_values()
        ;

    { //::IVisitable
        typedef bp::class_< IVisitable_wrapper, boost::noncopyable > IVisitable_exposer_t;
        IVisitable_exposer_t IVisitable_exposer = IVisitable_exposer_t( "IVisitable" );
        bp::scope IVisitable_scope( IVisitable_exposer );
        bp::enum_< IVisitable::RecursionOrder>("RecursionOrder")
            .value("RECURSE_DEPTH_FIRST", IVisitable::RECURSE_DEPTH_FIRST)
            .value("RECURSE_DEPTH_AFTER", IVisitable::RECURSE_DEPTH_AFTER)
            .export_values()
            ;
        { //::IVisitable::accept
        
            typedef void ( ::IVisitable::*accept_function_type)( ::IVisitor *,::IVisitable::RecursionOrder,int ) ;
            
            IVisitable_exposer.def( 
                "accept"
                , bp::pure_virtual( accept_function_type(&::IVisitable::accept) )
                , ( bp::arg("v"), bp::arg("order"), bp::arg("recursionDepth")=(int)(IVisitable::DEPTH_INDEFINITE) ) );
        
        }
        IVisitable_exposer.def_readonly( "DEPTH_INDEFINITE", IVisitable::DEPTH_INDEFINITE );
        IVisitable_exposer.def_readonly( "DEPTH_NONE", IVisitable::DEPTH_NONE );
    }

    { //::IField
        typedef bp::class_< IField_wrapper, bp::bases< IVisitable >, boost::noncopyable > IField_exposer_t;
        IField_exposer_t IField_exposer = IField_exposer_t( "IField" );
        bp::scope IField_scope( IField_exposer );
        bp::enum_< IField::Cacheable>("Cacheable")
            .value("UNKNOWN_CACHEABLE", IField::UNKNOWN_CACHEABLE)
            .value("NOT_CACHEABLE", IField::NOT_CACHEABLE)
            .value("WT_CACHEABLE", IField::WT_CACHEABLE)
            .value("WB_CACHEABLE", IField::WB_CACHEABLE)
            .export_values()
            ;
        { //::IField::create
        
            typedef ::Field ( *create_function_type )( char const *,::uint64_t );
            
            IField_exposer.def( 
                "create"
                , create_function_type( &::IField::create )
                , ( bp::arg("name"), bp::arg("size")=(::uint64_t)(0) ) );
        
        }
        { //::IField::getCacheable
        
            typedef ::IField::Cacheable ( ::IField::*getCacheable_function_type)(  ) const;
            
            IField_exposer.def( 
                "getCacheable"
                , bp::pure_virtual( getCacheable_function_type(&::IField::getCacheable) ) );
        
        }
//         { //::IField::getSelf
//         
//             typedef ::EntryImpl ( ::IField::*getSelf_function_type)(  ) ;
//             
//             IField_exposer.def( 
//                 "getSelf"
//                 , bp::pure_virtual( getSelf_function_type(&::IField::getSelf) ) );
//         
//         }
        { //::IField::setCacheable
        
            typedef void ( ::IField::*setCacheable_function_type)( ::IField::Cacheable ) ;
            
            IField_exposer.def( 
                "setCacheable"
                , bp::pure_virtual( setCacheable_function_type(&::IField::setCacheable) )
                , ( bp::arg("arg0") ) );
        
        }
        { //::IField::setDescription
        
            typedef void ( ::IField::*setDescription_function_type)( char const * ) ;
            
            IField_exposer.def( 
                "setDescription"
                , bp::pure_virtual( setDescription_function_type(&::IField::setDescription) )
                , ( bp::arg("arg0") ) );
        
        }
        { //::IField::setDescription
        
            typedef void ( ::IField::*setDescription_function_type)( ::std::string const & ) ;
            
            IField_exposer.def( 
                "setDescription"
                , bp::pure_virtual( setDescription_function_type(&::IField::setDescription) )
                , ( bp::arg("arg0") ) );
        
        }
        { //::IVisitable::accept
        
            typedef void ( ::IVisitable::*accept_function_type)( ::IVisitor *,::IVisitable::RecursionOrder,int ) ;
            
            IField_exposer.def( 
                "accept"
                , bp::pure_virtual( accept_function_type(&::IVisitable::accept) )
                , ( bp::arg("v"), bp::arg("order"), bp::arg("recursionDepth")=(int)(IVisitable::DEPTH_INDEFINITE) ) );
        
        }
        { //::IEntry::getDescription
        
            typedef char const * ( ::IEntry::*getDescription_function_type)(  ) const;
            
            IField_exposer.def( 
                "getDescription"
                , bp::pure_virtual( getDescription_function_type(&::IEntry::getDescription) ) );
        
        }
        { //::IEntry::getName
        
            typedef char const * ( ::IEntry::*getName_function_type)(  ) const;
            
            IField_exposer.def( 
                "getName"
                , bp::pure_virtual( getName_function_type(&::IEntry::getName) ) );
        
        }
        { //::IEntry::getSize
        
            typedef ::uint64_t ( ::IEntry::*getSize_function_type)(  ) const;
            
            IField_exposer.def( 
                "getSize"
                , bp::pure_virtual( getSize_function_type(&::IEntry::getSize) ) );
        
        }
        { //::IEntry::isHub
        
            typedef ::Hub ( ::IEntry::*isHub_function_type)(  ) const;
            
            IField_exposer.def( 
                "isHub"
                , bp::pure_virtual( isHub_function_type(&::IEntry::isHub) ) );
        
        }
        IField_exposer.staticmethod( "create" );
        bp::register_ptr_to_python< boost::shared_ptr< IField > >();
        bp::implicitly_convertible< boost::shared_ptr< IField >, boost::shared_ptr< IVisitable > >();
        bp::implicitly_convertible< boost::shared_ptr< IField >, boost::shared_ptr< IEntry > >();
        bp::implicitly_convertible< boost::shared_ptr< IIntField >, boost::shared_ptr< IField > >();
        bp::implicitly_convertible< boost::shared_ptr< ICommandField >, boost::shared_ptr< IField > >();
        bp::implicitly_convertible< boost::shared_ptr< IDev >, boost::shared_ptr< IField > >();
        bp::implicitly_convertible< boost::shared_ptr< INoSsiDev >, boost::shared_ptr< IField > >();
        bp::implicitly_convertible< boost::shared_ptr< IMMIODev >, boost::shared_ptr< IField > >();
        bp::implicitly_convertible< boost::shared_ptr< IMemDev >, boost::shared_ptr< IField > >();
    }

    { //::ICommandField
        typedef bp::class_< ICommandField_wrapper, bp::bases< IField >, boost::noncopyable > ICommandField_exposer_t;
        ICommandField_exposer_t ICommandField_exposer = ICommandField_exposer_t( "ICommandField" );
        bp::scope ICommandField_scope( ICommandField_exposer );
        { //::ICommandField::create
        
            typedef ::CommandField ( *create_function_type )( char const * );
            
            ICommandField_exposer.def( 
                "create"
                , create_function_type( &::ICommandField::create )
                , ( bp::arg("name") ) );
        
        }
        { //::IVisitable::accept
        
            typedef void ( ::IVisitable::*accept_function_type)( ::IVisitor *,::IVisitable::RecursionOrder,int ) ;
            
            ICommandField_exposer.def( 
                "accept"
                , bp::pure_virtual( accept_function_type(&::IVisitable::accept) )
                , ( bp::arg("v"), bp::arg("order"), bp::arg("recursionDepth")=(int)(IVisitable::DEPTH_INDEFINITE) ) );
        
        }
        { //::IField::getCacheable
        
            typedef ::IField::Cacheable ( ::IField::*getCacheable_function_type)(  ) const;
            
            ICommandField_exposer.def( 
                "getCacheable"
                , bp::pure_virtual( getCacheable_function_type(&::IField::getCacheable) ) );
        
        }
        { //::IEntry::getDescription
        
            typedef char const * ( ::IEntry::*getDescription_function_type)(  ) const;
            
            ICommandField_exposer.def( 
                "getDescription"
                , bp::pure_virtual( getDescription_function_type(&::IEntry::getDescription) ) );
        
        }
        { //::IEntry::getName
        
            typedef char const * ( ::IEntry::*getName_function_type)(  ) const;
            
            ICommandField_exposer.def( 
                "getName"
                , bp::pure_virtual( getName_function_type(&::IEntry::getName) ) );
        
        }
//         { //::IField::getSelf
//         
//             typedef ::EntryImpl ( ::IField::*getSelf_function_type)(  ) ;
//             
//             ICommandField_exposer.def( 
//                 "getSelf"
//                 , bp::pure_virtual( getSelf_function_type(&::IField::getSelf) ) );
//         
//         }
        { //::IEntry::getSize
        
            typedef ::uint64_t ( ::IEntry::*getSize_function_type)(  ) const;
            
            ICommandField_exposer.def( 
                "getSize"
                , bp::pure_virtual( getSize_function_type(&::IEntry::getSize) ) );
        
        }
        { //::IEntry::isHub
        
            typedef ::Hub ( ::IEntry::*isHub_function_type)(  ) const;
            
            ICommandField_exposer.def( 
                "isHub"
                , bp::pure_virtual( isHub_function_type(&::IEntry::isHub) ) );
        
        }
        { //::IField::setCacheable
        
            typedef void ( ::IField::*setCacheable_function_type)( ::IField::Cacheable ) ;
            
            ICommandField_exposer.def( 
                "setCacheable"
                , bp::pure_virtual( setCacheable_function_type(&::IField::setCacheable) )
                , ( bp::arg("arg0") ) );
        
        }
        { //::IField::setDescription
        
            typedef void ( ::IField::*setDescription_function_type)( char const * ) ;
            
            ICommandField_exposer.def( 
                "setDescription"
                , bp::pure_virtual( setDescription_function_type(&::IField::setDescription) )
                , ( bp::arg("arg0") ) );
        
        }
        { //::IField::setDescription
        
            typedef void ( ::IField::*setDescription_function_type)( ::std::string const & ) ;
            
            ICommandField_exposer.def( 
                "setDescription"
                , bp::pure_virtual( setDescription_function_type(&::IField::setDescription) )
                , ( bp::arg("arg0") ) );
        
        }
        ICommandField_exposer.staticmethod( "create" );
        bp::register_ptr_to_python< boost::shared_ptr< ICommandField > >();
        bp::implicitly_convertible< boost::shared_ptr< ICommandField >, boost::shared_ptr< IVisitable > >();
        bp::implicitly_convertible< boost::shared_ptr< ICommandField >, boost::shared_ptr< IEntry > >();
    }

    { //::IDev
        typedef bp::class_< IDev_wrapper, bp::bases< IField >, boost::noncopyable > IDev_exposer_t;
        IDev_exposer_t IDev_exposer = IDev_exposer_t( "IDev" );
        bp::scope IDev_scope( IDev_exposer );
        { //::IDev::addAtAddress
        
            typedef void ( ::IDev::*addAtAddress_function_type)( ::Field,unsigned int ) ;
            
            IDev_exposer.def( 
                "addAtAddress"
                , bp::pure_virtual( addAtAddress_function_type(&::IDev::addAtAddress) )
                , ( bp::arg("f"), bp::arg("nelms")=(unsigned int)(1) ) );
        
        }
        { //::IDev::create
        
            typedef ::Dev ( *create_function_type )( char const *,::uint64_t );
            
            IDev_exposer.def( 
                "create"
                , create_function_type( &::IDev::create )
                , ( bp::arg("name"), bp::arg("size")=(::uint64_t)(0) ) );
        
        }
        { //::IDev::getRootDev
        
            typedef ::Dev ( *getRootDev_function_type )(  );
            
            IDev_exposer.def( 
                "getRootDev"
                , getRootDev_function_type( &::IDev::getRootDev ) );
        
        }
        { //::IVisitable::accept
        
            typedef void ( ::IVisitable::*accept_function_type)( ::IVisitor *,::IVisitable::RecursionOrder,int ) ;
            
            IDev_exposer.def( 
                "accept"
                , bp::pure_virtual( accept_function_type(&::IVisitable::accept) )
                , ( bp::arg("v"), bp::arg("order"), bp::arg("recursionDepth")=(int)(IVisitable::DEPTH_INDEFINITE) ) );
        
        }
        { //::IHub::findByName
        
            typedef ::Path ( ::IHub::*findByName_function_type)( char const * ) ;
            
            IDev_exposer.def( 
                "findByName"
                , bp::pure_virtual( findByName_function_type(&::IHub::findByName) )
                , ( bp::arg("path") ) );
        
        }
        { //::IField::getCacheable
        
            typedef ::IField::Cacheable ( ::IField::*getCacheable_function_type)(  ) const;
            
            IDev_exposer.def( 
                "getCacheable"
                , bp::pure_virtual( getCacheable_function_type(&::IField::getCacheable) ) );
        
        }
        { //::IHub::getChild
        
            typedef ::Child ( ::IHub::*getChild_function_type)( char const * ) const;
            
            IDev_exposer.def( 
                "getChild"
                , bp::pure_virtual( getChild_function_type(&::IHub::getChild) )
                , ( bp::arg("name") ) );
        
        }
        { //::IHub::getChildren
        
            typedef ::Children ( ::IHub::*getChildren_function_type)(  ) const;
            
            IDev_exposer.def( 
                "getChildren"
                , bp::pure_virtual( getChildren_function_type(&::IHub::getChildren) ) );
        
        }
        { //::IEntry::getDescription
        
            typedef char const * ( ::IEntry::*getDescription_function_type)(  ) const;
            
            IDev_exposer.def( 
                "getDescription"
                , bp::pure_virtual( getDescription_function_type(&::IEntry::getDescription) ) );
        
        }
        { //::IEntry::getName
        
            typedef char const * ( ::IEntry::*getName_function_type)(  ) const;
            
            IDev_exposer.def( 
                "getName"
                , bp::pure_virtual( getName_function_type(&::IEntry::getName) ) );
        
        }
//         { //::IField::getSelf
//         
//             typedef ::EntryImpl ( ::IField::*getSelf_function_type)(  ) ;
//             
//             IDev_exposer.def( 
//                 "getSelf"
//                 , bp::pure_virtual( getSelf_function_type(&::IField::getSelf) ) );
//         
//         }
        { //::IEntry::getSize
        
            typedef ::uint64_t ( ::IEntry::*getSize_function_type)(  ) const;
            
            IDev_exposer.def( 
                "getSize"
                , bp::pure_virtual( getSize_function_type(&::IEntry::getSize) ) );
        
        }
        { //::IEntry::isHub
        
            typedef ::Hub ( ::IEntry::*isHub_function_type)(  ) const;
            
            IDev_exposer.def( 
                "isHub"
                , bp::pure_virtual( isHub_function_type(&::IEntry::isHub) ) );
        
        }
        { //::IField::setCacheable
        
            typedef void ( ::IField::*setCacheable_function_type)( ::IField::Cacheable ) ;
            
            IDev_exposer.def( 
                "setCacheable"
                , bp::pure_virtual( setCacheable_function_type(&::IField::setCacheable) )
                , ( bp::arg("arg0") ) );
        
        }
        { //::IField::setDescription
        
            typedef void ( ::IField::*setDescription_function_type)( char const * ) ;
            
            IDev_exposer.def( 
                "setDescription"
                , bp::pure_virtual( setDescription_function_type(&::IField::setDescription) )
                , ( bp::arg("arg0") ) );
        
        }
        { //::IField::setDescription
        
            typedef void ( ::IField::*setDescription_function_type)( ::std::string const & ) ;
            
            IDev_exposer.def( 
                "setDescription"
                , bp::pure_virtual( setDescription_function_type(&::IField::setDescription) )
                , ( bp::arg("arg0") ) );
        
        }
        IDev_exposer.staticmethod( "create" );
        IDev_exposer.staticmethod( "getRootDev" );
        bp::register_ptr_to_python< boost::shared_ptr< IDev > >();
        bp::implicitly_convertible< boost::shared_ptr< IDev >, boost::shared_ptr< IVisitable > >();
        bp::implicitly_convertible< boost::shared_ptr< IDev >, boost::shared_ptr< IEntry > >();
        bp::implicitly_convertible< boost::shared_ptr< IDev >, boost::shared_ptr< IHub > >();
        bp::implicitly_convertible< boost::shared_ptr< INoSsiDev >, boost::shared_ptr< IDev > >();
        bp::implicitly_convertible< boost::shared_ptr< IMMIODev >, boost::shared_ptr< IDev > >();
        bp::implicitly_convertible< boost::shared_ptr< IMemDev >, boost::shared_ptr< IDev > >();
    }

    { //::IIntField
        typedef bp::class_< IIntField_wrapper, bp::bases< IField >, boost::noncopyable > IIntField_exposer_t;
        IIntField_exposer_t IIntField_exposer = IIntField_exposer_t( "IIntField" );
        bp::scope IIntField_scope( IIntField_exposer );
        bp::enum_< IIntField::Mode>("Mode")
            .value("RO", IIntField::RO)
            .value("WO", IIntField::WO)
            .value("RW", IIntField::RW)
            .export_values()
            ;
        { //::IIntField::IBuilder
            typedef bp::class_< IIntField_wrapper::IBuilder_wrapper, boost::noncopyable > IBuilder_exposer_t;
            IBuilder_exposer_t IBuilder_exposer = IBuilder_exposer_t( "IBuilder" );
            bp::scope IBuilder_scope( IBuilder_exposer );
            { //::IIntField::IBuilder::build
            
                typedef ::IntField ( ::IIntField::IBuilder::*build_function_type)(  ) ;
                
                IBuilder_exposer.def( 
                    "build"
                    , bp::pure_virtual( build_function_type(&::IIntField::IBuilder::build) ) );
            
            }
            { //::IIntField::IBuilder::build
            
                typedef ::IntField ( ::IIntField::IBuilder::*build_function_type)( char const * ) ;
                
                IBuilder_exposer.def( 
                    "build"
                    , bp::pure_virtual( build_function_type(&::IIntField::IBuilder::build) )
                    , ( bp::arg("arg0") ) );
            
            }
            { //::IIntField::IBuilder::clone
            
                typedef ::boost::shared_ptr<IIntField::IBuilder> ( ::IIntField::IBuilder::*clone_function_type)(  ) ;
                
                IBuilder_exposer.def( 
                    "clone"
                    , bp::pure_virtual( clone_function_type(&::IIntField::IBuilder::clone) ) );
            
            }
            { //::IIntField::IBuilder::create
            
                typedef ::boost::shared_ptr< IIntField::IBuilder > ( *create_function_type )(  );
                
                IBuilder_exposer.def( 
                    "create"
                    , create_function_type( &::IIntField::IBuilder::create ) );
            
            }
            { //::IIntField::IBuilder::isSigned
            
                typedef ::boost::shared_ptr<IIntField::IBuilder> ( ::IIntField::IBuilder::*isSigned_function_type)( bool ) ;
                
                IBuilder_exposer.def( 
                    "isSigned"
                    , bp::pure_virtual( isSigned_function_type(&::IIntField::IBuilder::isSigned) )
                    , ( bp::arg("arg0") ) );
            
            }
            { //::IIntField::IBuilder::lsBit
            
                typedef ::boost::shared_ptr<IIntField::IBuilder> ( ::IIntField::IBuilder::*lsBit_function_type)( int ) ;
                
                IBuilder_exposer.def( 
                    "lsBit"
                    , bp::pure_virtual( lsBit_function_type(&::IIntField::IBuilder::lsBit) )
                    , ( bp::arg("arg0") ) );
            
            }
            { //::IIntField::IBuilder::mode
            
                typedef ::boost::shared_ptr<IIntField::IBuilder> ( ::IIntField::IBuilder::*mode_function_type)( ::IIntField::Mode ) ;
                
                IBuilder_exposer.def( 
                    "mode"
                    , bp::pure_virtual( mode_function_type(&::IIntField::IBuilder::mode) )
                    , ( bp::arg("arg0") ) );
            
            }
            { //::IIntField::IBuilder::name
            
                typedef ::boost::shared_ptr<IIntField::IBuilder> ( ::IIntField::IBuilder::*name_function_type)( char const * ) ;
                
                IBuilder_exposer.def( 
                    "name"
                    , bp::pure_virtual( name_function_type(&::IIntField::IBuilder::name) )
                    , ( bp::arg("arg0") ) );
            
            }
            { //::IIntField::IBuilder::reset
            
                typedef ::boost::shared_ptr<IIntField::IBuilder> ( ::IIntField::IBuilder::*reset_function_type)(  ) ;
                
                IBuilder_exposer.def( 
                    "reset"
                    , bp::pure_virtual( reset_function_type(&::IIntField::IBuilder::reset) ) );
            
            }
//             { //::IIntField::IBuilder::setEnum
//             
//                 typedef ::boost::shared_ptr<IIntField::IBuilder> ( ::IIntField::IBuilder::*setEnum_function_type)( ::Enum ) ;
//                 
//                 IBuilder_exposer.def( 
//                     "setEnum"
//                     , bp::pure_virtual( setEnum_function_type(&::IIntField::IBuilder::setEnum) )
//                     , ( bp::arg("arg0") ) );
//             
//             }
            { //::IIntField::IBuilder::sizeBits
            
                typedef ::boost::shared_ptr<IIntField::IBuilder> ( ::IIntField::IBuilder::*sizeBits_function_type)( ::uint64_t ) ;
                
                IBuilder_exposer.def( 
                    "sizeBits"
                    , bp::pure_virtual( sizeBits_function_type(&::IIntField::IBuilder::sizeBits) )
                    , ( bp::arg("arg0") ) );
            
            }
            { //::IIntField::IBuilder::wordSwap
            
                typedef ::boost::shared_ptr<IIntField::IBuilder> ( ::IIntField::IBuilder::*wordSwap_function_type)( unsigned int ) ;
                
                IBuilder_exposer.def( 
                    "wordSwap"
                    , bp::pure_virtual( wordSwap_function_type(&::IIntField::IBuilder::wordSwap) )
                    , ( bp::arg("arg0") ) );
            
            }
            IBuilder_exposer.staticmethod( "create" );
            bp::register_ptr_to_python< boost::shared_ptr< IIntField::IBuilder > >();
        }
        { //::IIntField::create
        
            typedef ::IntField ( *create_function_type )( char const *,::uint64_t,bool,int,::IIntField::Mode,unsigned int );
            
            IIntField_exposer.def( 
                "create"
                , create_function_type( &::IIntField::create )
                , ( bp::arg("name"), bp::arg("sizeBits")=(::uint64_t)(IIntField::DFLT_SIZE_BITS), bp::arg("is_Signed")=(bool)(IIntField::DFLT_IS_SIGNED), bp::arg("lsBit")=(int)(IIntField::DFLT_LS_BIT), bp::arg("mode")=IIntField::DFLT_MODE, bp::arg("wordSwap")=(unsigned int)(IIntField::DFLT_WORD_SWAP) ) );
        
        }
        { //::IIntField::getLsBit
        
            typedef int ( ::IIntField::*getLsBit_function_type)(  ) const;
            
            IIntField_exposer.def( 
                "getLsBit"
                , bp::pure_virtual( getLsBit_function_type(&::IIntField::getLsBit) ) );
        
        }
        { //::IIntField::getMode
        
            typedef ::IIntField::Mode ( ::IIntField::*getMode_function_type)(  ) const;
            
            IIntField_exposer.def( 
                "getMode"
                , bp::pure_virtual( getMode_function_type(&::IIntField::getMode) ) );
        
        }
        { //::IIntField::getSizeBits
        
            typedef ::uint64_t ( ::IIntField::*getSizeBits_function_type)(  ) const;
            
            IIntField_exposer.def( 
                "getSizeBits"
                , bp::pure_virtual( getSizeBits_function_type(&::IIntField::getSizeBits) ) );
        
        }
        { //::IIntField::isSigned
        
            typedef bool ( ::IIntField::*isSigned_function_type)(  ) const;
            
            IIntField_exposer.def( 
                "isSigned"
                , bp::pure_virtual( isSigned_function_type(&::IIntField::isSigned) ) );
        
        }
        IIntField_exposer.def_readonly( "DFLT_IS_SIGNED", IIntField::DFLT_IS_SIGNED );
        IIntField_exposer.def_readonly( "DFLT_LS_BIT", IIntField::DFLT_LS_BIT );
        IIntField_exposer.def_readonly( "DFLT_MODE", IIntField::DFLT_MODE );
        IIntField_exposer.def_readonly( "DFLT_SIZE_BITS", IIntField::DFLT_SIZE_BITS );
        IIntField_exposer.def_readonly( "DFLT_WORD_SWAP", IIntField::DFLT_WORD_SWAP );
        { //::IVisitable::accept
        
            typedef void ( ::IVisitable::*accept_function_type)( ::IVisitor *,::IVisitable::RecursionOrder,int ) ;
            
            IIntField_exposer.def( 
                "accept"
                , bp::pure_virtual( accept_function_type(&::IVisitable::accept) )
                , ( bp::arg("v"), bp::arg("order"), bp::arg("recursionDepth")=(int)(IVisitable::DEPTH_INDEFINITE) ) );
        
        }
        { //::IField::getCacheable
        
            typedef ::IField::Cacheable ( ::IField::*getCacheable_function_type)(  ) const;
            
            IIntField_exposer.def( 
                "getCacheable"
                , bp::pure_virtual( getCacheable_function_type(&::IField::getCacheable) ) );
        
        }
        { //::IEntry::getDescription
        
            typedef char const * ( ::IEntry::*getDescription_function_type)(  ) const;
            
            IIntField_exposer.def( 
                "getDescription"
                , bp::pure_virtual( getDescription_function_type(&::IEntry::getDescription) ) );
        
        }
        { //::IEntry::getName
        
            typedef char const * ( ::IEntry::*getName_function_type)(  ) const;
            
            IIntField_exposer.def( 
                "getName"
                , bp::pure_virtual( getName_function_type(&::IEntry::getName) ) );
        
        }
//         { //::IField::getSelf
//         
//             typedef ::EntryImpl ( ::IField::*getSelf_function_type)(  ) ;
//             
//             IIntField_exposer.def( 
//                 "getSelf"
//                 , bp::pure_virtual( getSelf_function_type(&::IField::getSelf) ) );
//         
//         }
        { //::IEntry::getSize
        
            typedef ::uint64_t ( ::IEntry::*getSize_function_type)(  ) const;
            
            IIntField_exposer.def( 
                "getSize"
                , bp::pure_virtual( getSize_function_type(&::IEntry::getSize) ) );
        
        }
        { //::IEntry::isHub
        
            typedef ::Hub ( ::IEntry::*isHub_function_type)(  ) const;
            
            IIntField_exposer.def( 
                "isHub"
                , bp::pure_virtual( isHub_function_type(&::IEntry::isHub) ) );
        
        }
        { //::IField::setCacheable
        
            typedef void ( ::IField::*setCacheable_function_type)( ::IField::Cacheable ) ;
            
            IIntField_exposer.def( 
                "setCacheable"
                , bp::pure_virtual( setCacheable_function_type(&::IField::setCacheable) )
                , ( bp::arg("arg0") ) );
        
        }
        { //::IField::setDescription
        
            typedef void ( ::IField::*setDescription_function_type)( char const * ) ;
            
            IIntField_exposer.def( 
                "setDescription"
                , bp::pure_virtual( setDescription_function_type(&::IField::setDescription) )
                , ( bp::arg("arg0") ) );
        
        }
        { //::IField::setDescription
        
            typedef void ( ::IField::*setDescription_function_type)( ::std::string const & ) ;
            
            IIntField_exposer.def( 
                "setDescription"
                , bp::pure_virtual( setDescription_function_type(&::IField::setDescription) )
                , ( bp::arg("arg0") ) );
        
        }
        IIntField_exposer.staticmethod( "create" );
        bp::register_ptr_to_python< boost::shared_ptr< IIntField > >();
        bp::implicitly_convertible< boost::shared_ptr< IIntField >, boost::shared_ptr< IVisitable > >();
        bp::implicitly_convertible< boost::shared_ptr< IIntField >, boost::shared_ptr< IEntry > >();
    }

    { //::IMMIODev
        typedef bp::class_< IMMIODev_wrapper, bp::bases< IDev >, boost::noncopyable > IMMIODev_exposer_t;
        IMMIODev_exposer_t IMMIODev_exposer = IMMIODev_exposer_t( "IMMIODev" );
        bp::scope IMMIODev_scope( IMMIODev_exposer );
        { //::IMMIODev::addAtAddress
        
            typedef void ( ::IMMIODev::*addAtAddress_function_type)( ::Field,::uint64_t,unsigned int,::uint64_t,::ByteOrder ) ;
            
            IMMIODev_exposer.def( 
                "addAtAddress"
                , bp::pure_virtual( addAtAddress_function_type(&::IMMIODev::addAtAddress) )
                , ( bp::arg("child"), bp::arg("offset"), bp::arg("nelms")=(unsigned int)(1), bp::arg("stride")=(::uint64_t)(IMMIODev::STRIDE_AUTO), bp::arg("byteOrder")=::UNKNOWN ) );
        
        }
        { //::IMMIODev::create
        
            typedef ::MMIODev ( *create_function_type )( char const *,::uint64_t,::ByteOrder );
            
            IMMIODev_exposer.def( 
                "create"
                , create_function_type( &::IMMIODev::create )
                , ( bp::arg("name"), bp::arg("size"), bp::arg("byteOrder")=::UNKNOWN ) );
        
        }
        IMMIODev_exposer.def_readonly( "STRIDE_AUTO", IMMIODev::STRIDE_AUTO );
        { //::IVisitable::accept
        
            typedef void ( ::IVisitable::*accept_function_type)( ::IVisitor *,::IVisitable::RecursionOrder,int ) ;
            
            IMMIODev_exposer.def( 
                "accept"
                , bp::pure_virtual( accept_function_type(&::IVisitable::accept) )
                , ( bp::arg("v"), bp::arg("order"), bp::arg("recursionDepth")=(int)(IVisitable::DEPTH_INDEFINITE) ) );
        
        }
//         { //::IDev::addAtAddress
//         
//             typedef void ( ::IDev::*addAtAddress_function_type)( ::Field,unsigned int ) ;
//             
//             IMMIODev_exposer.def( 
//                 "addAtAddress"
//                 , bp::pure_virtual( addAtAddress_function_type(&::IDev::addAtAddress) )
//                 , ( bp::arg("f"), bp::arg("nelms")=(unsigned int)(1) ) );
//         
//         }
        { //::IHub::findByName
        
            typedef ::Path ( ::IHub::*findByName_function_type)( char const * ) ;
            
            IMMIODev_exposer.def( 
                "findByName"
                , bp::pure_virtual( findByName_function_type(&::IHub::findByName) )
                , ( bp::arg("path") ) );
        
        }
        { //::IField::getCacheable
        
            typedef ::IField::Cacheable ( ::IField::*getCacheable_function_type)(  ) const;
            
            IMMIODev_exposer.def( 
                "getCacheable"
                , bp::pure_virtual( getCacheable_function_type(&::IField::getCacheable) ) );
        
        }
        { //::IHub::getChild
        
            typedef ::Child ( ::IHub::*getChild_function_type)( char const * ) const;
            
            IMMIODev_exposer.def( 
                "getChild"
                , bp::pure_virtual( getChild_function_type(&::IHub::getChild) )
                , ( bp::arg("name") ) );
        
        }
        { //::IHub::getChildren
        
            typedef ::Children ( ::IHub::*getChildren_function_type)(  ) const;
            
            IMMIODev_exposer.def( 
                "getChildren"
                , bp::pure_virtual( getChildren_function_type(&::IHub::getChildren) ) );
        
        }
        { //::IEntry::getDescription
        
            typedef char const * ( ::IEntry::*getDescription_function_type)(  ) const;
            
            IMMIODev_exposer.def( 
                "getDescription"
                , bp::pure_virtual( getDescription_function_type(&::IEntry::getDescription) ) );
        
        }
        { //::IEntry::getName
        
            typedef char const * ( ::IEntry::*getName_function_type)(  ) const;
            
            IMMIODev_exposer.def( 
                "getName"
                , bp::pure_virtual( getName_function_type(&::IEntry::getName) ) );
        
        }
//         { //::IField::getSelf
//         
//             typedef ::EntryImpl ( ::IField::*getSelf_function_type)(  ) ;
//             
//             IMMIODev_exposer.def( 
//                 "getSelf"
//                 , bp::pure_virtual( getSelf_function_type(&::IField::getSelf) ) );
//         
//         }
        { //::IEntry::getSize
        
            typedef ::uint64_t ( ::IEntry::*getSize_function_type)(  ) const;
            
            IMMIODev_exposer.def( 
                "getSize"
                , bp::pure_virtual( getSize_function_type(&::IEntry::getSize) ) );
        
        }
        { //::IEntry::isHub
        
            typedef ::Hub ( ::IEntry::*isHub_function_type)(  ) const;
            
            IMMIODev_exposer.def( 
                "isHub"
                , bp::pure_virtual( isHub_function_type(&::IEntry::isHub) ) );
        
        }
        { //::IField::setCacheable
        
            typedef void ( ::IField::*setCacheable_function_type)( ::IField::Cacheable ) ;
            
            IMMIODev_exposer.def( 
                "setCacheable"
                , bp::pure_virtual( setCacheable_function_type(&::IField::setCacheable) )
                , ( bp::arg("arg0") ) );
        
        }
        { //::IField::setDescription
        
            typedef void ( ::IField::*setDescription_function_type)( char const * ) ;
            
            IMMIODev_exposer.def( 
                "setDescription"
                , bp::pure_virtual( setDescription_function_type(&::IField::setDescription) )
                , ( bp::arg("arg0") ) );
        
        }
        { //::IField::setDescription
        
            typedef void ( ::IField::*setDescription_function_type)( ::std::string const & ) ;
            
            IMMIODev_exposer.def( 
                "setDescription"
                , bp::pure_virtual( setDescription_function_type(&::IField::setDescription) )
                , ( bp::arg("arg0") ) );
        
        }
        IMMIODev_exposer.staticmethod( "create" );
        bp::register_ptr_to_python< boost::shared_ptr< IMMIODev > >();
        bp::implicitly_convertible< boost::shared_ptr< IMMIODev >, boost::shared_ptr< IVisitable > >();
        bp::implicitly_convertible< boost::shared_ptr< IMMIODev >, boost::shared_ptr< IEntry > >();
        bp::implicitly_convertible< boost::shared_ptr< IMMIODev >, boost::shared_ptr< IHub > >();
    }

    { //::IMemDev
        typedef bp::class_< IMemDev_wrapper, bp::bases< IDev >, boost::noncopyable > IMemDev_exposer_t;
        IMemDev_exposer_t IMemDev_exposer = IMemDev_exposer_t( "IMemDev" );
        bp::scope IMemDev_scope( IMemDev_exposer );
        { //::IMemDev::addAtAddress
        
            typedef void ( ::IMemDev::*addAtAddress_function_type)( ::Field,unsigned int ) ;
            
            IMemDev_exposer.def( 
                "addAtAddress"
                , bp::pure_virtual( addAtAddress_function_type(&::IMemDev::addAtAddress) )
                , ( bp::arg("child"), bp::arg("nelms")=(unsigned int)(1) ) );
        
        }
        { //::IMemDev::create
        
            typedef ::MemDev ( *create_function_type )( char const *,::uint64_t );
            
            IMemDev_exposer.def( 
                "create"
                , create_function_type( &::IMemDev::create )
                , ( bp::arg("name"), bp::arg("size") ) );
        
        }
//         { //::IMemDev::getBufp
//         
//             typedef ::uint8_t * const ( ::IMemDev::*getBufp_function_type)(  ) const;
//             
//             IMemDev_exposer.def( 
//                 "getBufp"
//                 , bp::pure_virtual( getBufp_function_type(&::IMemDev::getBufp) )
//                     /* undefined call policies */ );
//         
//         }
        { //::IVisitable::accept
        
            typedef void ( ::IVisitable::*accept_function_type)( ::IVisitor *,::IVisitable::RecursionOrder,int ) ;
            
            IMemDev_exposer.def( 
                "accept"
                , bp::pure_virtual( accept_function_type(&::IVisitable::accept) )
                , ( bp::arg("v"), bp::arg("order"), bp::arg("recursionDepth")=(int)(IVisitable::DEPTH_INDEFINITE) ) );
        
        }
        { //::IHub::findByName
        
            typedef ::Path ( ::IHub::*findByName_function_type)( char const * ) ;
            
            IMemDev_exposer.def( 
                "findByName"
                , bp::pure_virtual( findByName_function_type(&::IHub::findByName) )
                , ( bp::arg("path") ) );
        
        }
        { //::IField::getCacheable
        
            typedef ::IField::Cacheable ( ::IField::*getCacheable_function_type)(  ) const;
            
            IMemDev_exposer.def( 
                "getCacheable"
                , bp::pure_virtual( getCacheable_function_type(&::IField::getCacheable) ) );
        
        }
        { //::IHub::getChild
        
            typedef ::Child ( ::IHub::*getChild_function_type)( char const * ) const;
            
            IMemDev_exposer.def( 
                "getChild"
                , bp::pure_virtual( getChild_function_type(&::IHub::getChild) )
                , ( bp::arg("name") ) );
        
        }
        { //::IHub::getChildren
        
            typedef ::Children ( ::IHub::*getChildren_function_type)(  ) const;
            
            IMemDev_exposer.def( 
                "getChildren"
                , bp::pure_virtual( getChildren_function_type(&::IHub::getChildren) ) );
        
        }
        { //::IEntry::getDescription
        
            typedef char const * ( ::IEntry::*getDescription_function_type)(  ) const;
            
            IMemDev_exposer.def( 
                "getDescription"
                , bp::pure_virtual( getDescription_function_type(&::IEntry::getDescription) ) );
        
        }
        { //::IEntry::getName
        
            typedef char const * ( ::IEntry::*getName_function_type)(  ) const;
            
            IMemDev_exposer.def( 
                "getName"
                , bp::pure_virtual( getName_function_type(&::IEntry::getName) ) );
        
        }
//         { //::IField::getSelf
//         
//             typedef ::EntryImpl ( ::IField::*getSelf_function_type)(  ) ;
//             
//             IMemDev_exposer.def( 
//                 "getSelf"
//                 , bp::pure_virtual( getSelf_function_type(&::IField::getSelf) ) );
//         
//         }
        { //::IEntry::getSize
        
            typedef ::uint64_t ( ::IEntry::*getSize_function_type)(  ) const;
            
            IMemDev_exposer.def( 
                "getSize"
                , bp::pure_virtual( getSize_function_type(&::IEntry::getSize) ) );
        
        }
        { //::IEntry::isHub
        
            typedef ::Hub ( ::IEntry::*isHub_function_type)(  ) const;
            
            IMemDev_exposer.def( 
                "isHub"
                , bp::pure_virtual( isHub_function_type(&::IEntry::isHub) ) );
        
        }
        { //::IField::setCacheable
        
            typedef void ( ::IField::*setCacheable_function_type)( ::IField::Cacheable ) ;
            
            IMemDev_exposer.def( 
                "setCacheable"
                , bp::pure_virtual( setCacheable_function_type(&::IField::setCacheable) )
                , ( bp::arg("arg0") ) );
        
        }
        { //::IField::setDescription
        
            typedef void ( ::IField::*setDescription_function_type)( char const * ) ;
            
            IMemDev_exposer.def( 
                "setDescription"
                , bp::pure_virtual( setDescription_function_type(&::IField::setDescription) )
                , ( bp::arg("arg0") ) );
        
        }
        { //::IField::setDescription
        
            typedef void ( ::IField::*setDescription_function_type)( ::std::string const & ) ;
            
            IMemDev_exposer.def( 
                "setDescription"
                , bp::pure_virtual( setDescription_function_type(&::IField::setDescription) )
                , ( bp::arg("arg0") ) );
        
        }
        IMemDev_exposer.staticmethod( "create" );
        bp::register_ptr_to_python< boost::shared_ptr< IMemDev > >();
        bp::implicitly_convertible< boost::shared_ptr< IMemDev >, boost::shared_ptr< IVisitable > >();
        bp::implicitly_convertible< boost::shared_ptr< IMemDev >, boost::shared_ptr< IEntry > >();
        bp::implicitly_convertible< boost::shared_ptr< IMemDev >, boost::shared_ptr< IHub > >();
    }

//     { //::IMutableEnum
//         typedef bp::class_< IMutableEnum_wrapper, boost::noncopyable > IMutableEnum_exposer_t;
//         IMutableEnum_exposer_t IMutableEnum_exposer = IMutableEnum_exposer_t( "IMutableEnum" );
//         bp::scope IMutableEnum_scope( IMutableEnum_exposer );
//         { //::IMutableEnum::add
//         
//             typedef void ( ::IMutableEnum::*add_function_type)( char const *,::uint64_t ) ;
//             
//             IMutableEnum_exposer.def( 
//                 "add"
//                 , bp::pure_virtual( add_function_type(&::IMutableEnum::add) )
//                 , ( bp::arg("enum_string"), bp::arg("enum_num") ) );
//         
//         }
//         { //::IMutableEnum::create
//         
//             typedef ::MutableEnum ( *create_function_type )(  );
//             
//             IMutableEnum_exposer.def( 
//                 "create"
//                 , create_function_type( &::IMutableEnum::create ) );
//         
//         }
//         { //::IEnum::begin
//         
//             typedef ::IEnum::iterator ( ::IEnum::*begin_function_type)(  ) const;
//             
//             IMutableEnum_exposer.def( 
//                 "begin"
//                 , bp::pure_virtual( begin_function_type(&::IEnum::begin) ) );
//         
//         }
//         { //::IEnum::end
//         
//             typedef ::IEnum::iterator ( ::IEnum::*end_function_type)(  ) const;
//             
//             IMutableEnum_exposer.def( 
//                 "end"
//                 , bp::pure_virtual( end_function_type(&::IEnum::end) ) );
//         
//         }
//         { //::IEnum::getNelms
//         
//             typedef unsigned int ( ::IEnum::*getNelms_function_type)(  ) const;
//             
//             IMutableEnum_exposer.def( 
//                 "getNelms"
//                 , bp::pure_virtual( getNelms_function_type(&::IEnum::getNelms) ) );
//         
//         }
//         { //::IEnum::map
//         
//             typedef ::std::pair<boost::shared_ptr<std::string const>, unsigned long> ( ::IEnum::*map_function_type)( ::uint64_t ) ;
//             
//             IMutableEnum_exposer.def( 
//                 "map"
//                 , bp::pure_virtual( map_function_type(&::IEnum::map) )
//                 , ( bp::arg("arg0") ) );
//         
//         }
//         { //::IEnum::map
//         
//             typedef ::std::pair<boost::shared_ptr<std::string const>, unsigned long> ( ::IEnum::*map_function_type)( char const * ) ;
//             
//             IMutableEnum_exposer.def( 
//                 "map"
//                 , bp::pure_virtual( map_function_type(&::IEnum::map) )
//                 , ( bp::arg("arg0") ) );
//         
//         }
//         IMutableEnum_exposer.staticmethod( "create" );
//         bp::register_ptr_to_python< boost::shared_ptr< IMutableEnum > >();
//         bp::implicitly_convertible< boost::shared_ptr< IMutableEnum >, boost::shared_ptr< IEnum > >();
//     }

    { //::INoSsiDev
        typedef bp::class_< INoSsiDev_wrapper, bp::bases< IDev >, boost::noncopyable > INoSsiDev_exposer_t;
        INoSsiDev_exposer_t INoSsiDev_exposer = INoSsiDev_exposer_t( "INoSsiDev" );
        bp::scope INoSsiDev_scope( INoSsiDev_exposer );
        bp::enum_< INoSsiDev::ProtocolVersion>("ProtocolVersion")
            .value("SRP_UDP_V1", INoSsiDev::SRP_UDP_V1)
            .value("SRP_UDP_V2", INoSsiDev::SRP_UDP_V2)
            .export_values()
            ;
        { //::INoSsiDev::addAtAddress
        
            typedef void ( ::INoSsiDev::*addAtAddress_function_type)( ::Field,::INoSsiDev::ProtocolVersion,unsigned int,unsigned int,unsigned int,::uint8_t ) ;
            
            INoSsiDev_exposer.def( 
                "addAtAddress"
                , bp::pure_virtual( addAtAddress_function_type(&::INoSsiDev::addAtAddress) )
                , ( bp::arg("child"), bp::arg("version")=::INoSsiDev::SRP_UDP_V2, bp::arg("dport")=(unsigned int)(8192), bp::arg("timeoutUs")=(unsigned int)(1000), bp::arg("retryCnt")=(unsigned int)(10), bp::arg("vc")=(::uint8_t)(0) ) );
        
        }
        { //::INoSsiDev::addAtStream
        
            typedef void ( ::INoSsiDev::*addAtStream_function_type)( ::Field,unsigned int,unsigned int,unsigned int,unsigned int,unsigned int,unsigned int,unsigned int ) ;
            
            INoSsiDev_exposer.def( 
                "addAtStream"
                , bp::pure_virtual( addAtStream_function_type(&::INoSsiDev::addAtStream) )
                , ( bp::arg("child"), bp::arg("dport"), bp::arg("timeoutUs"), bp::arg("inQDepth")=(unsigned int)(32), bp::arg("outQDepth")=(unsigned int)(16), bp::arg("ldFrameWinSize")=(unsigned int)(4), bp::arg("ldFragWinSize")=(unsigned int)(4), bp::arg("nUdpThreads")=(unsigned int)(2) ) );
        
        }
        { //::INoSsiDev::create
        
            typedef ::NoSsiDev ( *create_function_type )( char const *,char const * );
            
            INoSsiDev_exposer.def( 
                "create"
                , create_function_type( &::INoSsiDev::create )
                , ( bp::arg("name"), bp::arg("ipaddr") ) );
        
        }
        { //::INoSsiDev::getIpAddressString
        
            typedef char const * ( ::INoSsiDev::*getIpAddressString_function_type)(  ) const;
            
            INoSsiDev_exposer.def( 
                "getIpAddressString"
                , bp::pure_virtual( getIpAddressString_function_type(&::INoSsiDev::getIpAddressString) ) );
        
        }
        { //::IVisitable::accept
        
            typedef void ( ::IVisitable::*accept_function_type)( ::IVisitor *,::IVisitable::RecursionOrder,int ) ;
            
            INoSsiDev_exposer.def( 
                "accept"
                , bp::pure_virtual( accept_function_type(&::IVisitable::accept) )
                , ( bp::arg("v"), bp::arg("order"), bp::arg("recursionDepth")=(int)(IVisitable::DEPTH_INDEFINITE) ) );
        
        }
//         { //::IDev::addAtAddress
//         
//             typedef void ( ::IDev::*addAtAddress_function_type)( ::Field,unsigned int ) ;
//             
//             INoSsiDev_exposer.def( 
//                 "addAtAddress"
//                 , bp::pure_virtual( addAtAddress_function_type(&::IDev::addAtAddress) )
//                 , ( bp::arg("f"), bp::arg("nelms")=(unsigned int)(1) ) );
//         
//         }
        { //::IHub::findByName
        
            typedef ::Path ( ::IHub::*findByName_function_type)( char const * ) ;
            
            INoSsiDev_exposer.def( 
                "findByName"
                , bp::pure_virtual( findByName_function_type(&::IHub::findByName) )
                , ( bp::arg("path") ) );
        
        }
        { //::IField::getCacheable
        
            typedef ::IField::Cacheable ( ::IField::*getCacheable_function_type)(  ) const;
            
            INoSsiDev_exposer.def( 
                "getCacheable"
                , bp::pure_virtual( getCacheable_function_type(&::IField::getCacheable) ) );
        
        }
        { //::IHub::getChild
        
            typedef ::Child ( ::IHub::*getChild_function_type)( char const * ) const;
            
            INoSsiDev_exposer.def( 
                "getChild"
                , bp::pure_virtual( getChild_function_type(&::IHub::getChild) )
                , ( bp::arg("name") ) );
        
        }
        { //::IHub::getChildren
        
            typedef ::Children ( ::IHub::*getChildren_function_type)(  ) const;
            
            INoSsiDev_exposer.def( 
                "getChildren"
                , bp::pure_virtual( getChildren_function_type(&::IHub::getChildren) ) );
        
        }
        { //::IEntry::getDescription
        
            typedef char const * ( ::IEntry::*getDescription_function_type)(  ) const;
            
            INoSsiDev_exposer.def( 
                "getDescription"
                , bp::pure_virtual( getDescription_function_type(&::IEntry::getDescription) ) );
        
        }
        { //::IEntry::getName
        
            typedef char const * ( ::IEntry::*getName_function_type)(  ) const;
            
            INoSsiDev_exposer.def( 
                "getName"
                , bp::pure_virtual( getName_function_type(&::IEntry::getName) ) );
        
        }
//         { //::IField::getSelf
//         
//             typedef ::EntryImpl ( ::IField::*getSelf_function_type)(  ) ;
//             
//             INoSsiDev_exposer.def( 
//                 "getSelf"
//                 , bp::pure_virtual( getSelf_function_type(&::IField::getSelf) ) );
//         
//         }
        { //::IEntry::getSize
        
            typedef ::uint64_t ( ::IEntry::*getSize_function_type)(  ) const;
            
            INoSsiDev_exposer.def( 
                "getSize"
                , bp::pure_virtual( getSize_function_type(&::IEntry::getSize) ) );
        
        }
        { //::IEntry::isHub
        
            typedef ::Hub ( ::IEntry::*isHub_function_type)(  ) const;
            
            INoSsiDev_exposer.def( 
                "isHub"
                , bp::pure_virtual( isHub_function_type(&::IEntry::isHub) ) );
        
        }
        { //::IField::setCacheable
        
            typedef void ( ::IField::*setCacheable_function_type)( ::IField::Cacheable ) ;
            
            INoSsiDev_exposer.def( 
                "setCacheable"
                , bp::pure_virtual( setCacheable_function_type(&::IField::setCacheable) )
                , ( bp::arg("arg0") ) );
        
        }
        { //::IField::setDescription
        
            typedef void ( ::IField::*setDescription_function_type)( char const * ) ;
            
            INoSsiDev_exposer.def( 
                "setDescription"
                , bp::pure_virtual( setDescription_function_type(&::IField::setDescription) )
                , ( bp::arg("arg0") ) );
        
        }
        { //::IField::setDescription
        
            typedef void ( ::IField::*setDescription_function_type)( ::std::string const & ) ;
            
            INoSsiDev_exposer.def( 
                "setDescription"
                , bp::pure_virtual( setDescription_function_type(&::IField::setDescription) )
                , ( bp::arg("arg0") ) );
        
        }
        INoSsiDev_exposer.staticmethod( "create" );
        bp::register_ptr_to_python< boost::shared_ptr< INoSsiDev > >();
        bp::implicitly_convertible< boost::shared_ptr< INoSsiDev >, boost::shared_ptr< IVisitable > >();
        bp::implicitly_convertible< boost::shared_ptr< INoSsiDev >, boost::shared_ptr< IEntry > >();
        bp::implicitly_convertible< boost::shared_ptr< INoSsiDev >, boost::shared_ptr< IHub > >();
	bp::implicitly_convertible< boost::shared_ptr< INoSsiDev >, boost::shared_ptr< const IHub > >();
    }

    bp::class_< IVisitor_wrapper, boost::noncopyable >( "IVisitor" )    
        .def( 
            "visit"
            , bp::pure_virtual( (void ( ::IVisitor::* )( ::Field ))(&::IVisitor::visit) )
            , ( bp::arg("arg0") ) )    
        .def( 
            "visit"
            , (void ( ::IVisitor::* )( ::Dev ))(&::IVisitor::visit)
            , (void ( IVisitor_wrapper::* )( ::Dev ))(&IVisitor_wrapper::default_visit)
            , ( bp::arg("d") ) );

    { //::hostByteOrder
    
        typedef ::ByteOrder ( *hostByteOrder_function_type )(  );
        
        bp::def( 
            "hostByteOrder"
            , hostByteOrder_function_type( &::hostByteOrder ) );
    
    }

//    bp::scope().attr("enumBool") = enumBool;
//
//    bp::scope().attr("enumYesNo") = enumYesNo;
    
        bp::class_< IEntry_wrapper, boost::noncopyable >( "IEntry" )    
        .def( 
            "getDescription"
            , bp::pure_virtual( (char const * ( ::IEntry::* )(  )const)(&::IEntry::getDescription) ) )    
        .def( 
            "getName"
            , bp::pure_virtual( (char const * ( ::IEntry::* )(  )const)(&::IEntry::getName) ) )    
        .def( 
            "getSize"
            , bp::pure_virtual( (::uint64_t ( ::IEntry::* )(  )const)(&::IEntry::getSize) ) )    
        .def( 
            "isHub"
            , bp::pure_virtual( (::Hub ( ::IEntry::* )(  )const)(&::IEntry::isHub) ) );

    bp::class_< IChild_wrapper, bp::bases< IEntry >, boost::noncopyable >( "IChild" )    
        .def( 
            "dump"
            , bp::pure_virtual( (void ( ::IChild::* )( ::FILE * )const)(&::IChild::dump) )
            , ( bp::arg("arg0") ) )    
        .def( 
            "dump"
            , bp::pure_virtual( (void ( ::IChild::* )(  )const)(&::IChild::dump) ) )    
        .def( 
            "getNelms"
            , bp::pure_virtual( (unsigned int ( ::IChild::* )(  )const)(&::IChild::getNelms) ) )    
        .def( 
            "getOwner"
            , bp::pure_virtual( (::Hub ( ::IChild::* )(  )const)(&::IChild::getOwner) ) )    
        .def( 
            "getDescription"
            , bp::pure_virtual( (char const * ( ::IEntry::* )(  )const)(&::IEntry::getDescription) ) )    
        .def( 
            "getName"
            , bp::pure_virtual( (char const * ( ::IEntry::* )(  )const)(&::IEntry::getName) ) )    
        .def( 
            "getSize"
            , bp::pure_virtual( (::uint64_t ( ::IEntry::* )(  )const)(&::IEntry::getSize) ) )    
        .def( 
            "isHub"
            , bp::pure_virtual( (::Hub ( ::IEntry::* )(  )const)(&::IEntry::isHub) ) );

 
    bp::class_< IHub_wrapper, bp::bases< IEntry >, boost::noncopyable >( "IHub" )    
        .def( 
            "findByName"
            , bp::pure_virtual( (::Path ( ::IHub::* )( char const * ))(&::IHub::findByName) )
            , ( bp::arg("path") ) )    
        .def( 
            "getChild"
            , bp::pure_virtual( (::Child ( ::IHub::* )( char const * )const)(&::IHub::getChild) )
            , ( bp::arg("name") ) )    
        .def( 
            "getChildren"
            , bp::pure_virtual( (::Children ( ::IHub::* )(  )const)(&::IHub::getChildren) ) )    
        .def( 
            "getDescription"
            , bp::pure_virtual( (char const * ( ::IEntry::* )(  )const)(&::IEntry::getDescription) ) )    
        .def( 
            "getName"
            , bp::pure_virtual( (char const * ( ::IEntry::* )(  )const)(&::IEntry::getName) ) )    
        .def( 
            "getSize"
            , bp::pure_virtual( (::uint64_t ( ::IEntry::* )(  )const)(&::IEntry::getSize) ) )    
        .def( 
            "isHub"
            , bp::pure_virtual( (::Hub ( ::IEntry::* )(  )const)(&::IEntry::isHub) ) );

    { //::IPath
        typedef bp::class_< IPath_wrapper, boost::noncopyable > IPath_exposer_t;
        IPath_exposer_t IPath_exposer = IPath_exposer_t( "IPath" );
        bp::scope IPath_scope( IPath_exposer );
        { //::IPath::append
        
            typedef void ( ::IPath::*append_function_type)( ::Path ) ;
            
            IPath_exposer.def( 
                "append"
                , bp::pure_virtual( append_function_type(&::IPath::append) )
                , ( bp::arg("p") ) );
        
        }
        { //::IPath::clear
        
            typedef void ( ::IPath::*clear_function_type)(  ) ;
            
            IPath_exposer.def( 
                "clear"
                , bp::pure_virtual( clear_function_type(&::IPath::clear) ) );
        
        }
        { //::IPath::clear
        
            typedef void ( ::IPath::*clear_function_type)( ::Hub ) ;
            
            IPath_exposer.def( 
                "clear"
                , bp::pure_virtual( clear_function_type(&::IPath::clear) )
                , ( bp::arg("arg0") ) );
        
        }
        { //::IPath::clone
        
            typedef ::Path ( ::IPath::*clone_function_type)(  ) const;
            
            IPath_exposer.def( 
                "clone"
                , bp::pure_virtual( clone_function_type(&::IPath::clone) ) );
        
        }
        { //::IPath::concat
        
            typedef ::Path ( ::IPath::*concat_function_type)( ::Path ) const;
            
            IPath_exposer.def( 
                "concat"
                , bp::pure_virtual( concat_function_type(&::IPath::concat) )
                , ( bp::arg("p") ) );
        
        }
        { //::IPath::create
        
            typedef ::Path ( *create_function_type )(  );
            
            IPath_exposer.def( 
                "create"
                , create_function_type( &::IPath::create ) );
        
        }
        { //::IPath::create
        
            typedef ::Path ( *create_function_type )( char const * );
            
            IPath_exposer.def( 
                "create"
                , create_function_type( &::IPath::create )
                , ( bp::arg("arg0") ) );
        
        }
        { //::IPath::create
        
            typedef ::Path ( *create_function_type )( ::Hub );
            
            IPath_exposer.def( 
                "create"
                , create_function_type( &::IPath::create )
                , ( bp::arg("arg0") ) );
        
        }
        { //::IPath::dump
        
            typedef void ( ::IPath::*dump_function_type)( ::FILE * ) const;
            
            IPath_exposer.def( 
                "dump"
                , bp::pure_virtual( dump_function_type(&::IPath::dump) )
                , ( bp::arg("arg0") ) );
        
        }
        { //::IPath::empty
        
            typedef bool ( ::IPath::*empty_function_type)(  ) const;
            
            IPath_exposer.def( 
                "empty"
                , bp::pure_virtual( empty_function_type(&::IPath::empty) ) );
        
        }
        { //::IPath::findByName
        
            typedef ::Path ( ::IPath::*findByName_function_type)( char const * ) const;
            
            IPath_exposer.def( 
                "findByName"
                , bp::pure_virtual( findByName_function_type(&::IPath::findByName) )
                , ( bp::arg("name") ) );
        
        }
        { //::IPath::getNelms
        
            typedef unsigned int ( ::IPath::*getNelms_function_type)(  ) const;
            
            IPath_exposer.def( 
                "getNelms"
                , bp::pure_virtual( getNelms_function_type(&::IPath::getNelms) ) );
        
        }
        { //::IPath::origin
        
            typedef ::Hub ( ::IPath::*origin_function_type)(  ) const;
            
            IPath_exposer.def( 
                "origin"
                , bp::pure_virtual( origin_function_type(&::IPath::origin) ) );
        
        }
        { //::IPath::parent
        
            typedef ::Hub ( ::IPath::*parent_function_type)(  ) const;
            
            IPath_exposer.def( 
                "parent"
                , bp::pure_virtual( parent_function_type(&::IPath::parent) ) );
        
        }
        { //::IPath::tail
        
            typedef ::Child ( ::IPath::*tail_function_type)(  ) const;
            
            IPath_exposer.def( 
                "tail"
                , bp::pure_virtual( tail_function_type(&::IPath::tail) ) );
        
        }
        { //::IPath::toString
        
            typedef ::std::string ( ::IPath::*toString_function_type)(  ) const;
            
            IPath_exposer.def( 
                "toString"
                , bp::pure_virtual( toString_function_type(&::IPath::toString) ) );
        
        }
        { //::IPath::up
        
            typedef ::Child ( ::IPath::*up_function_type)(  ) ;
            
            IPath_exposer.def( 
                "up"
                , bp::pure_virtual( up_function_type(&::IPath::up) ) );
        
        }
        { //::IPath::verifyAtTail
        
            typedef bool ( ::IPath::*verifyAtTail_function_type)( ::Path ) ;
            
            IPath_exposer.def( 
                "verifyAtTail"
                , bp::pure_virtual( verifyAtTail_function_type(&::IPath::verifyAtTail) )
                , ( bp::arg("p") ) );
        
        }
        IPath_exposer.staticmethod( "create" );
        bp::register_ptr_to_python< boost::shared_ptr< IPath > >();
    }
    
    
    bp::class_< IScalVal_Base_wrapper, bp::bases< IEntry >, boost::noncopyable >( "IScalVal_Base" )    
        .def( 
            "getEnum"
            , bp::pure_virtual( (::Enum ( ::IScalVal_Base::* )(  )const)(&::IScalVal_Base::getEnum) ) )    
        .def( 
            "getNelms"
            , bp::pure_virtual( (unsigned int ( ::IScalVal_Base::* )(  ))(&::IScalVal_Base::getNelms) ) )    
        .def( 
            "getPath"
            , bp::pure_virtual( (::Path ( ::IScalVal_Base::* )(  )const)(&::IScalVal_Base::getPath) ) )    
        .def( 
            "getSizeBits"
            , bp::pure_virtual( (::uint64_t ( ::IScalVal_Base::* )(  )const)(&::IScalVal_Base::getSizeBits) ) )    
        .def( 
            "isSigned"
            , bp::pure_virtual( (bool ( ::IScalVal_Base::* )(  )const)(&::IScalVal_Base::isSigned) ) )    
        .def( 
            "getDescription"
            , bp::pure_virtual( (char const * ( ::IEntry::* )(  )const)(&::IEntry::getDescription) ) )    
        .def( 
            "getName"
            , bp::pure_virtual( (char const * ( ::IEntry::* )(  )const)(&::IEntry::getName) ) )    
        .def( 
            "getSize"
            , bp::pure_virtual( (::uint64_t ( ::IEntry::* )(  )const)(&::IEntry::getSize) ) )    
        .def( 
            "isHub"
            , bp::pure_virtual( (::Hub ( ::IEntry::* )(  )const)(&::IEntry::isHub) ) );
    { //::IScalVal_RO
        typedef bp::class_< IScalVal_RO_wrapper, bp::bases< IScalVal_Base >, boost::noncopyable > IScalVal_RO_exposer_t;
        IScalVal_RO_exposer_t IScalVal_RO_exposer = IScalVal_RO_exposer_t( "IScalVal_RO" );
        bp::scope IScalVal_RO_scope( IScalVal_RO_exposer );
        { //::IScalVal_RO::create
        
            typedef ::ScalVal_RO ( *create_function_type )( ::Path );
            
            IScalVal_RO_exposer.def( 
                "create"
                , create_function_type( &::IScalVal_RO::create )
                , ( bp::arg("p") ) );
        
        }
        { //::IScalVal_RO::getVal
        
            typedef boost::python::tuple ( *default_get_value_as_uint64_function_type )( ::IScalVal_RO &,unsigned int,::IndexRange * );
            
            IScalVal_RO_exposer.def( 
                "get_value_as_uint64"
                , default_get_value_as_uint64_function_type( &IScalVal_RO_wrapper::default_getVal_b0638da20e7596e8f27dba3f0b00cb67 )
                , ( bp::arg("inst"), bp::arg("nelms")=(unsigned int)(1), bp::arg("range")=bp::object() ) );
        
        }
        { //::IScalVal_RO::getVal
        
            typedef boost::python::tuple ( *default_get_value_as_uint32_function_type )( ::IScalVal_RO &,unsigned int,::IndexRange * );
            
            IScalVal_RO_exposer.def( 
                "get_value_as_uint32"
                , default_get_value_as_uint32_function_type( &IScalVal_RO_wrapper::default_getVal_6193488e65b3131159f95715d15a1f6a )
                , ( bp::arg("inst"), bp::arg("nelms")=(unsigned int)(1), bp::arg("range")=bp::object() ) );
        
        }
        { //::IScalVal_RO::getVal
        
            typedef boost::python::tuple ( *default_get_value_as_uint16_function_type )( ::IScalVal_RO &,unsigned int,::IndexRange * );
            
            IScalVal_RO_exposer.def( 
                "get_value_as_uint16"
                , default_get_value_as_uint16_function_type( &IScalVal_RO_wrapper::default_getVal_542acbc8b2ae655af2f5bd1a45dcbefa )
                , ( bp::arg("inst"), bp::arg("nelms")=(unsigned int)(1), bp::arg("range")=bp::object() ) );
        
        }
        { //::IScalVal_RO::getVal
        
            typedef boost::python::tuple ( *default_get_value_as_uint8_function_type )( ::IScalVal_RO &,unsigned int,::IndexRange * );
            
            IScalVal_RO_exposer.def( 
                "get_value_as_uint8"
                , default_get_value_as_uint8_function_type( &IScalVal_RO_wrapper::default_getVal_f8a4f576323e947d8f52210e3407bcac )
                , ( bp::arg("inst"), bp::arg("nelms")=(unsigned int)(1), bp::arg("range")=bp::object() ) );
        
        }
        { //::IScalVal_RO::getVal
        
            typedef unsigned int ( ::IScalVal_RO::*getVal_function_type)( ::CString *,unsigned int,::IndexRange * ) ;
            
            IScalVal_RO_exposer.def( 
                "getVal"
                , bp::pure_virtual( getVal_function_type(&::IScalVal_RO::getVal) )
                , ( bp::arg("p"), bp::arg("nelms")=(unsigned int)(1), bp::arg("range")=bp::object() ) );
        
        }
        { //::IEntry::getDescription
        
            typedef char const * ( ::IEntry::*getDescription_function_type)(  ) const;
            
            IScalVal_RO_exposer.def( 
                "getDescription"
                , bp::pure_virtual( getDescription_function_type(&::IEntry::getDescription) ) );
        
        }
        { //::IScalVal_Base::getEnum
        
            typedef ::Enum ( ::IScalVal_Base::*getEnum_function_type)(  ) const;
            
            IScalVal_RO_exposer.def( 
                "getEnum"
                , bp::pure_virtual( getEnum_function_type(&::IScalVal_Base::getEnum) ) );
        
        }
        { //::IEntry::getName
        
            typedef char const * ( ::IEntry::*getName_function_type)(  ) const;
            
            IScalVal_RO_exposer.def( 
                "getName"
                , bp::pure_virtual( getName_function_type(&::IEntry::getName) ) );
        
        }
        { //::IScalVal_Base::getNelms
        
            typedef unsigned int ( ::IScalVal_Base::*getNelms_function_type)(  ) ;
            
            IScalVal_RO_exposer.def( 
                "getNelms"
                , bp::pure_virtual( getNelms_function_type(&::IScalVal_Base::getNelms) ) );
        
        }
        { //::IScalVal_Base::getPath
        
            typedef ::Path ( ::IScalVal_Base::*getPath_function_type)(  ) const;
            
            IScalVal_RO_exposer.def( 
                "getPath"
                , bp::pure_virtual( getPath_function_type(&::IScalVal_Base::getPath) ) );
        
        }
        { //::IEntry::getSize
        
            typedef ::uint64_t ( ::IEntry::*getSize_function_type)(  ) const;
            
            IScalVal_RO_exposer.def( 
                "getSize"
                , bp::pure_virtual( getSize_function_type(&::IEntry::getSize) ) );
        
        }
        { //::IScalVal_Base::getSizeBits
        
            typedef ::uint64_t ( ::IScalVal_Base::*getSizeBits_function_type)(  ) const;
            
            IScalVal_RO_exposer.def( 
                "getSizeBits"
                , bp::pure_virtual( getSizeBits_function_type(&::IScalVal_Base::getSizeBits) ) );
        
        }
        { //::IEntry::isHub
        
            typedef ::Hub ( ::IEntry::*isHub_function_type)(  ) const;
            
            IScalVal_RO_exposer.def( 
                "isHub"
                , bp::pure_virtual( isHub_function_type(&::IEntry::isHub) ) );
        
        }
        { //::IScalVal_Base::isSigned
        
            typedef bool ( ::IScalVal_Base::*isSigned_function_type)(  ) const;
            
            IScalVal_RO_exposer.def( 
                "isSigned"
                , bp::pure_virtual( isSigned_function_type(&::IScalVal_Base::isSigned) ) );
        
        }
        IScalVal_RO_exposer.staticmethod( "create" );
        bp::register_ptr_to_python< boost::shared_ptr< IScalVal_RO > >();
        bp::implicitly_convertible< boost::shared_ptr< IScalVal_RO >, boost::shared_ptr< IScalVal_Base > >();
        bp::implicitly_convertible< boost::shared_ptr< IScalVal_RO >, boost::shared_ptr< IEntry > >();
        bp::implicitly_convertible< boost::shared_ptr< IScalVal >, boost::shared_ptr< IScalVal_RO > >();
    }

    { //::IScalVal_WO
        typedef bp::class_< IScalVal_WO_wrapper, bp::bases< IScalVal_Base >, boost::noncopyable > IScalVal_WO_exposer_t;
        IScalVal_WO_exposer_t IScalVal_WO_exposer = IScalVal_WO_exposer_t( "IScalVal_WO" );
        bp::scope IScalVal_WO_scope( IScalVal_WO_exposer );
//         { //::IScalVal_WO::create
//         
//             typedef ::ScalVal_WO ( *create_function_type )( ::Path );
//             
//             IScalVal_WO_exposer.def( 
//                 "create"
//                 , create_function_type( &::IScalVal_WO::create )
//                 , ( bp::arg("p") ) );
//         
//         }
        { //::IScalVal_WO::setVal
        
            typedef unsigned int ( ::IScalVal_WO::*setVal_function_type)( ::uint64_t *,unsigned int,::IndexRange * ) ;
            
            IScalVal_WO_exposer.def( 
                "setVal"
                , bp::pure_virtual( setVal_function_type(&::IScalVal_WO::setVal) )
                , ( bp::arg("p"), bp::arg("nelms")=(unsigned int)(1), bp::arg("range")=bp::object() ) );
        
        }
        { //::IScalVal_WO::setVal
        
            typedef unsigned int ( ::IScalVal_WO::*setVal_function_type)( ::uint32_t *,unsigned int,::IndexRange * ) ;
            
            IScalVal_WO_exposer.def( 
                "setVal"
                , bp::pure_virtual( setVal_function_type(&::IScalVal_WO::setVal) )
                , ( bp::arg("p"), bp::arg("nelms")=(unsigned int)(1), bp::arg("range")=bp::object() ) );
        
        }
        { //::IScalVal_WO::setVal
        
            typedef unsigned int ( ::IScalVal_WO::*setVal_function_type)( ::uint16_t *,unsigned int,::IndexRange * ) ;
            
            IScalVal_WO_exposer.def( 
                "setVal"
                , bp::pure_virtual( setVal_function_type(&::IScalVal_WO::setVal) )
                , ( bp::arg("p"), bp::arg("nelms")=(unsigned int)(1), bp::arg("range")=bp::object() ) );
        
        }
        { //::IScalVal_WO::setVal
        
            typedef unsigned int ( ::IScalVal_WO::*setVal_function_type)( ::uint8_t *,unsigned int,::IndexRange * ) ;
            
            IScalVal_WO_exposer.def( 
                "setVal"
                , bp::pure_virtual( setVal_function_type(&::IScalVal_WO::setVal) )
                , ( bp::arg("p"), bp::arg("nelms")=(unsigned int)(1), bp::arg("range")=bp::object() ) );
        
        }
        { //::IScalVal_WO::setVal
        
            typedef unsigned int ( ::IScalVal_WO::*setVal_function_type)( char const * *,unsigned int,::IndexRange * ) ;
            
            IScalVal_WO_exposer.def( 
                "setVal"
                , bp::pure_virtual( setVal_function_type(&::IScalVal_WO::setVal) )
                , ( bp::arg("p"), bp::arg("nelms")=(unsigned int)(1), bp::arg("range")=bp::object() ) );
        
        }
        { //::IScalVal_WO::setVal
        
            typedef unsigned int ( ::IScalVal_WO::*setVal_function_type)( ::uint64_t,::IndexRange * ) ;
            
            IScalVal_WO_exposer.def( 
                "setVal"
                , bp::pure_virtual( setVal_function_type(&::IScalVal_WO::setVal) )
                , ( bp::arg("v"), bp::arg("range")=bp::object() ) );
        
        }
        { //::IScalVal_WO::setVal
        
            typedef unsigned int ( ::IScalVal_WO::*setVal_function_type)( char const *,::IndexRange * ) ;
            
            IScalVal_WO_exposer.def( 
                "setVal"
                , bp::pure_virtual( setVal_function_type(&::IScalVal_WO::setVal) )
                , ( bp::arg("v"), bp::arg("range")=bp::object() ) );
        
        }
        { //::IEntry::getDescription
        
            typedef char const * ( ::IEntry::*getDescription_function_type)(  ) const;
            
            IScalVal_WO_exposer.def( 
                "getDescription"
                , bp::pure_virtual( getDescription_function_type(&::IEntry::getDescription) ) );
        
        }
        { //::IScalVal_Base::getEnum
        
            typedef ::Enum ( ::IScalVal_Base::*getEnum_function_type)(  ) const;
            
            IScalVal_WO_exposer.def( 
                "getEnum"
                , bp::pure_virtual( getEnum_function_type(&::IScalVal_Base::getEnum) ) );
        
        }
        { //::IEntry::getName
        
            typedef char const * ( ::IEntry::*getName_function_type)(  ) const;
            
            IScalVal_WO_exposer.def( 
                "getName"
                , bp::pure_virtual( getName_function_type(&::IEntry::getName) ) );
        
        }
        { //::IScalVal_Base::getNelms
        
            typedef unsigned int ( ::IScalVal_Base::*getNelms_function_type)(  ) ;
            
            IScalVal_WO_exposer.def( 
                "getNelms"
                , bp::pure_virtual( getNelms_function_type(&::IScalVal_Base::getNelms) ) );
        
        }
        { //::IScalVal_Base::getPath
        
            typedef ::Path ( ::IScalVal_Base::*getPath_function_type)(  ) const;
            
            IScalVal_WO_exposer.def( 
                "getPath"
                , bp::pure_virtual( getPath_function_type(&::IScalVal_Base::getPath) ) );
        
        }
        { //::IEntry::getSize
        
            typedef ::uint64_t ( ::IEntry::*getSize_function_type)(  ) const;
            
            IScalVal_WO_exposer.def( 
                "getSize"
                , bp::pure_virtual( getSize_function_type(&::IEntry::getSize) ) );
        
        }
        { //::IScalVal_Base::getSizeBits
        
            typedef ::uint64_t ( ::IScalVal_Base::*getSizeBits_function_type)(  ) const;
            
            IScalVal_WO_exposer.def( 
                "getSizeBits"
                , bp::pure_virtual( getSizeBits_function_type(&::IScalVal_Base::getSizeBits) ) );
        
        }
        { //::IEntry::isHub
        
            typedef ::Hub ( ::IEntry::*isHub_function_type)(  ) const;
            
            IScalVal_WO_exposer.def( 
                "isHub"
                , bp::pure_virtual( isHub_function_type(&::IEntry::isHub) ) );
        
        }
        { //::IScalVal_Base::isSigned
        
            typedef bool ( ::IScalVal_Base::*isSigned_function_type)(  ) const;
            
            IScalVal_WO_exposer.def( 
                "isSigned"
                , bp::pure_virtual( isSigned_function_type(&::IScalVal_Base::isSigned) ) );
        
        }
//         IScalVal_WO_exposer.staticmethod( "create" );
        bp::register_ptr_to_python< boost::shared_ptr< IScalVal_WO > >();
        bp::implicitly_convertible< boost::shared_ptr< IScalVal_WO >, boost::shared_ptr< IScalVal_Base > >();
        bp::implicitly_convertible< boost::shared_ptr< IScalVal_WO >, boost::shared_ptr< IEntry > >();
        bp::implicitly_convertible< boost::shared_ptr< IScalVal >, boost::shared_ptr< IScalVal_WO > >();
    }

    { //::IScalVal
        typedef bp::class_< IScalVal_wrapper, bp::bases< IScalVal_RO, IScalVal_WO >, boost::noncopyable > IScalVal_exposer_t;
        IScalVal_exposer_t IScalVal_exposer = IScalVal_exposer_t( "IScalVal" );
        bp::scope IScalVal_scope( IScalVal_exposer );
        { //::IScalVal::create
        
            typedef ::ScalVal ( *create_function_type )( ::Path );
            
            IScalVal_exposer.def( 
                "create"
                , create_function_type( &::IScalVal::create )
                , ( bp::arg("p") ) );
        
        }
        { //::IEntry::getDescription
        
            typedef char const * ( ::IEntry::*getDescription_function_type)(  ) const;
            
            IScalVal_exposer.def( 
                "getDescription"
                , bp::pure_virtual( getDescription_function_type(&::IEntry::getDescription) ) );
        
        }
        { //::IScalVal_Base::getEnum
        
            typedef ::Enum ( ::IScalVal_Base::*getEnum_function_type)(  ) const;
            
            IScalVal_exposer.def( 
                "getEnum"
                , bp::pure_virtual( getEnum_function_type(&::IScalVal_Base::getEnum) ) );
        
        }
        { //::IEntry::getName
        
            typedef char const * ( ::IEntry::*getName_function_type)(  ) const;
            
            IScalVal_exposer.def( 
                "getName"
                , bp::pure_virtual( getName_function_type(&::IEntry::getName) ) );
        
        }
        { //::IScalVal_Base::getNelms
        
            typedef unsigned int ( ::IScalVal_Base::*getNelms_function_type)(  ) ;
            
            IScalVal_exposer.def( 
                "getNelms"
                , bp::pure_virtual( getNelms_function_type(&::IScalVal_Base::getNelms) ) );
        
        }
        { //::IScalVal_Base::getPath
        
            typedef ::Path ( ::IScalVal_Base::*getPath_function_type)(  ) const;
            
            IScalVal_exposer.def( 
                "getPath"
                , bp::pure_virtual( getPath_function_type(&::IScalVal_Base::getPath) ) );
        
        }
        { //::IEntry::getSize
        
            typedef ::uint64_t ( ::IEntry::*getSize_function_type)(  ) const;
            
            IScalVal_exposer.def( 
                "getSize"
                , bp::pure_virtual( getSize_function_type(&::IEntry::getSize) ) );
        
        }
        { //::IScalVal_Base::getSizeBits
        
            typedef ::uint64_t ( ::IScalVal_Base::*getSizeBits_function_type)(  ) const;
            
            IScalVal_exposer.def( 
                "getSizeBits"
                , bp::pure_virtual( getSizeBits_function_type(&::IScalVal_Base::getSizeBits) ) );
        
        }
        { //::IScalVal_RO::getVal
        
            typedef boost::python::tuple ( *default_get_value_as_uint64_function_type )( ::IScalVal_RO &,unsigned int,::IndexRange * );
            
            IScalVal_exposer.def( 
                "get_value_as_uint64"
                , default_get_value_as_uint64_function_type( &IScalVal_wrapper::default_getVal_b0638da20e7596e8f27dba3f0b00cb67 )
                , ( bp::arg("inst"), bp::arg("nelms")=(unsigned int)(1), bp::arg("range")=bp::object() ) );
        
        }
        { //::IScalVal_RO::getVal
        
            typedef boost::python::tuple ( *default_get_value_as_uint32_function_type )( ::IScalVal_RO &,unsigned int,::IndexRange * );
            
            IScalVal_exposer.def( 
                "get_value_as_uint32"
                , default_get_value_as_uint32_function_type( &IScalVal_wrapper::default_getVal_6193488e65b3131159f95715d15a1f6a )
                , ( bp::arg("inst"), bp::arg("nelms")=(unsigned int)(1), bp::arg("range")=bp::object() ) );
        
        }
        { //::IScalVal_RO::getVal
        
            typedef boost::python::tuple ( *default_get_value_as_uint16_function_type )( ::IScalVal_RO &,unsigned int,::IndexRange * );
            
            IScalVal_exposer.def( 
                "get_value_as_uint16"
                , default_get_value_as_uint16_function_type( &IScalVal_wrapper::default_getVal_542acbc8b2ae655af2f5bd1a45dcbefa )
                , ( bp::arg("inst"), bp::arg("nelms")=(unsigned int)(1), bp::arg("range")=bp::object() ) );
        
        }
        { //::IScalVal_RO::getVal
        
            typedef boost::python::tuple ( *default_get_value_as_uint8_function_type )( ::IScalVal_RO &,unsigned int,::IndexRange * );
            
            IScalVal_exposer.def( 
                "get_value_as_uint8"
                , default_get_value_as_uint8_function_type( &IScalVal_wrapper::default_getVal_f8a4f576323e947d8f52210e3407bcac )
                , ( bp::arg("inst"), bp::arg("nelms")=(unsigned int)(1), bp::arg("range")=bp::object() ) );
        
        }
        { //::IScalVal_RO::getVal
        
            typedef unsigned int ( ::IScalVal_RO::*getVal_function_type)( ::CString *,unsigned int,::IndexRange * ) ;
            
            IScalVal_exposer.def( 
                "getVal"
                , bp::pure_virtual( getVal_function_type(&::IScalVal_RO::getVal) )
                , ( bp::arg("p"), bp::arg("nelms")=(unsigned int)(1), bp::arg("range")=bp::object() ) );
        
        }
        { //::IEntry::isHub
        
            typedef ::Hub ( ::IEntry::*isHub_function_type)(  ) const;
            
            IScalVal_exposer.def( 
                "isHub"
                , bp::pure_virtual( isHub_function_type(&::IEntry::isHub) ) );
        
        }
        { //::IScalVal_Base::isSigned
        
            typedef bool ( ::IScalVal_Base::*isSigned_function_type)(  ) const;
            
            IScalVal_exposer.def( 
                "isSigned"
                , bp::pure_virtual( isSigned_function_type(&::IScalVal_Base::isSigned) ) );
        
        }
        { //::IScalVal_WO::setVal
        
            typedef unsigned int ( ::IScalVal_WO::*setVal_function_type)( ::uint64_t *,unsigned int,::IndexRange * ) ;
            
            IScalVal_exposer.def( 
                "setVal"
                , bp::pure_virtual( setVal_function_type(&::IScalVal_WO::setVal) )
                , ( bp::arg("p"), bp::arg("nelms")=(unsigned int)(1), bp::arg("range")=bp::object() ) );
        
        }
        { //::IScalVal_WO::setVal
        
            typedef unsigned int ( ::IScalVal_WO::*setVal_function_type)( ::uint32_t *,unsigned int,::IndexRange * ) ;
            
            IScalVal_exposer.def( 
                "setVal"
                , bp::pure_virtual( setVal_function_type(&::IScalVal_WO::setVal) )
                , ( bp::arg("p"), bp::arg("nelms")=(unsigned int)(1), bp::arg("range")=bp::object() ) );
        
        }
        { //::IScalVal_WO::setVal
        
            typedef unsigned int ( ::IScalVal_WO::*setVal_function_type)( ::uint16_t *,unsigned int,::IndexRange * ) ;
            
            IScalVal_exposer.def( 
                "setVal"
                , bp::pure_virtual( setVal_function_type(&::IScalVal_WO::setVal) )
                , ( bp::arg("p"), bp::arg("nelms")=(unsigned int)(1), bp::arg("range")=bp::object() ) );
        
        }
        { //::IScalVal_WO::setVal
        
            typedef unsigned int ( ::IScalVal_WO::*setVal_function_type)( ::uint8_t *,unsigned int,::IndexRange * ) ;
            
            IScalVal_exposer.def( 
                "setVal"
                , bp::pure_virtual( setVal_function_type(&::IScalVal_WO::setVal) )
                , ( bp::arg("p"), bp::arg("nelms")=(unsigned int)(1), bp::arg("range")=bp::object() ) );
        
        }
        { //::IScalVal_WO::setVal
        
            typedef unsigned int ( ::IScalVal_WO::*setVal_function_type)( char const * *,unsigned int,::IndexRange * ) ;
            
            IScalVal_exposer.def( 
                "setVal"
                , bp::pure_virtual( setVal_function_type(&::IScalVal_WO::setVal) )
                , ( bp::arg("p"), bp::arg("nelms")=(unsigned int)(1), bp::arg("range")=bp::object() ) );
        
        }
        { //::IScalVal_WO::setVal
        
            typedef unsigned int ( ::IScalVal_WO::*setVal_function_type)( ::uint64_t,::IndexRange * ) ;
            
            IScalVal_exposer.def( 
                "setVal"
                , bp::pure_virtual( setVal_function_type(&::IScalVal_WO::setVal) )
                , ( bp::arg("v"), bp::arg("range")=bp::object() ) );
        
        }
        { //::IScalVal_WO::setVal
        
            typedef unsigned int ( ::IScalVal_WO::*setVal_function_type)( char const *,::IndexRange * ) ;
            
            IScalVal_exposer.def( 
                "setVal"
                , bp::pure_virtual( setVal_function_type(&::IScalVal_WO::setVal) )
                , ( bp::arg("v"), bp::arg("range")=bp::object() ) );
        
        }
        { //::IScalVal_WO::setVal
         
             typedef unsigned int ( *default_set_value_as_uint16_function_type )( ::IScalVal &, uint16_t, unsigned int,::IndexRange * );
             
             IScalVal_exposer.def( 
                 "set_value_as_uint16"
                 , default_set_value_as_uint16_function_type( &IScalVal_wrapper::set_value_as_uint16 )
                 , ( bp::arg("inst"), bp::arg("u16"), bp::arg("nelms")=(unsigned int)(1), bp::arg("range")=bp::object() ) );
         
         }
         { //::IScalVal_WO::setVal nelm > 1
         
             typedef unsigned int ( *default_set_value_as_uint32_function_type )( ::IScalVal &, boost::python::object, unsigned int,::IndexRange * );
             
             IScalVal_exposer.def( 
                 "set_value_as_uint32"
                 , default_set_value_as_uint32_function_type( &IScalVal_wrapper::set_value_as_uint32 )
                 , ( bp::arg("inst"), bp::arg("u32"), bp::arg("nelms")=(unsigned int)(1), bp::arg("range")=bp::object() ) );
         
         }
         { //::IScalVal_WO::setVal nelm == 1
         
             typedef unsigned int ( *default_set_value_as_uint32_function_type )( ::IScalVal &, uint32_t, unsigned int,::IndexRange * );
             
             IScalVal_exposer.def( 
                 "set_value_as_uint32"
                 , default_set_value_as_uint32_function_type( &IScalVal_wrapper::set_value_as_uint32 )
                 , ( bp::arg("inst"), bp::arg("u32"), bp::arg("nelms")=(unsigned int)(1), bp::arg("range")=bp::object() ) );
         
        }
        IScalVal_exposer.staticmethod( "create" );
        bp::register_ptr_to_python< boost::shared_ptr< IScalVal > >();
        bp::implicitly_convertible< boost::shared_ptr< IScalVal >, boost::shared_ptr< IScalVal_Base > >();
        bp::implicitly_convertible< boost::shared_ptr< IScalVal >, boost::shared_ptr< IEntry > >();
    }



//     bp::scope().attr("TIMEOUT_INDEFINITE") = TIMEOUT_INDEFINITE;
// 
//     bp::scope().attr("TIMEOUT_NONE") = TIMEOUT_NONE;
}