1from ctypes import *
2from enum import Enum
3import datetime, string, random, sys, os, platform
4
5PY3 = sys.version_info[ 0 ] == 3
6
7if PY3 :
8    def xrange( *args, **kwargs ) :
9        return iter( range( *args, **kwargs ) )
10
11def to_bytes( s ) :
12    if PY3 and ( type( s ) == str ) :
13        return str.encode( s )
14    return s
15
16def to_char_p( s ) :
17    if PY3  and ( type( s ) == str ) :
18        return c_char_p( str.encode( s ) )
19    return c_char_p( s )
20
21
22class CreateMode( Enum ) :
23    Open = 0
24    Init = 1
25    Create = 2
26    MD5 = ( 1 << 6 )
27
28class TypeDomain( Enum ) :
29    Bool = 1
30    UInt = 2
31    Int = 3
32    Float = 4
33    Ascii = 5
34    Unicode = 6
35
36class CursorMode( Enum ) :
37    Update = 0
38    Replace = 1
39    Insert = 2
40
41class OpenMode( Enum ) :
42    Read = 0
43    Write = 1
44
45class RepoCat( Enum ) :
46    Bad = 0
47    User = 1
48    Site = 2
49    Remote = 3
50
51class RepoSubCat( Enum ) :
52    Bad = 0
53    Main = 1
54    Aux = 2
55    Protected = 3
56
57class RemoteProto( Enum ) :
58    Http = 0
59    Fasp = 1
60    FaspHttp = 2
61    HttpFasp = 3
62
63class ResolvEnable( Enum ) :
64    UseConfig = 0
65    AlwaysEnable = 1
66    AlwaysDisable = 2
67
68class PathType( Enum ) :
69    NotFound = 0
70    BadPath = 1
71    File = 2
72    Dir = 3
73    CharDev = 4
74    BlockDev = 5
75    Fifo = 6
76    ZombieFile = 7
77    FakeRoot = 8
78    Dataset = 9
79    Datatype = 10
80    Database = 11
81    Table = 12
82    Index = 13
83    Column = 14,
84    Metadata = 15
85    PrereleaseTbl = 16
86    Alias = 128
87
88class IndexType( Enum ) :
89    Text = 0
90    UInt64 = 1
91    Text_reverse = 128
92    UInt64_reverse = 129
93
94RepoCatDict = { RepoCat.Bad : "Bad", RepoCat.User : "User", RepoCat.Site : "Site", RepoCat.Remote : "Remote" }
95def RepoCat2String( cat ) :
96    x = RepoCatDict[ cat ]
97    if x == None :
98        x = "Bad"
99    return x
100
101RepoSubCatDict = { RepoSubCat.Bad : "Bad", RepoSubCat.Main : "Main", RepoSubCat.Aux : "Aux", RepoSubCat.Protected : "Protected" }
102def RepoSubCat2String( cat ) :
103    x = RepoSubCatDict[ cat ]
104    if x == None :
105        x = "Bad"
106    return x
107
108class vdb_string( Structure ) :
109    _fields_ = [ ( "addr", c_char_p ), ( "size", c_int ), ( "len", c_int ) ]
110
111    def __str__( self ) :
112        return self.addr.value
113
114class vdb_vector( Structure ) :
115    _fields_ = [ ( "v", c_void_p ), ( "start", c_int ), ( "len", c_int ), ( "mask", c_int ) ]
116
117
118#------------------------------------------------------------------------------------------------------------
119class version :
120    major = 0
121    minor = 0
122    release = 0
123
124    def __init__( self, s ) :
125        if PY3 :
126            string_types = str
127        else :
128            string_types = basestring
129        if isinstance( s, string_types ) :
130            a = s.split( '.' )
131            l = len( a )
132            if l > 0 :
133                self.major = int( a[ 0 ] )
134            if l > 1 :
135                self.minor = int( a[ 1 ] )
136            if l > 2 :
137                self.release = int( a[ 2 ] )
138        elif isinstance( s, int ) :
139            self.major = ( s & 0xFF000000 ) >> 24
140            self.minor = ( s & 0xFF0000 ) >> 16
141            self.release = s & 0xFFFF
142
143    def __str__( self ) :
144        return "%d.%d.%d"%( self.major, self.minor, self.release )
145
146    def __cmp__( self, other ) :
147        if not isinstance( other, version ) :
148            return NotImplemented
149        d = cmp( self.major, other.major )
150        if d != 0 :
151            return d
152        d = cmp( self.minor, other.minor )
153        if d != 0 :
154            return d
155        return cmp( self.release, other.release )
156
157
158#------------------------------------------------------------------------------------------------------------
159class vdb_error( Exception ) :
160    """Exception thrown by vdb-objects like mananger, schema, database, table, cursor, column
161
162    Args:
163        rc  (int)      :    rc-code from vdb-library call
164        msg ( string ) :    explanation of error
165        obj            :    object that caused the error ( manager, schema, database, table, cursor, column )
166    """
167    def __init__( self, rc, msg, obj ) :
168        super( vdb_error, self ).__init__( "%s.%s"%( obj.__class__.__name__, msg ) )
169        self.obj_name = obj.__class__.__name__
170        self.rc = rc
171
172
173#------------------------------------------------------------------------------------------------------------
174class KNamelist :
175    def __init__( self, mgr, ptr ) :
176        self.__mgr = mgr
177        self.__ptr = ptr
178
179    def __del__( self ) :
180        rc = self.__mgr.KNamelistRelease( self.__ptr )
181        if rc != 0 :
182            self.__mgr.raise_rc( rc, "KNamelistRelease()", self )
183
184    def count( self ) :
185        n = c_int()
186        rc = self.__mgr.KNamelistCount( self.__ptr, byref( n ) )
187        if rc != 0 :
188            self.__mgr.raise_rc( rc, "KNamelistCount()", self )
189        return n.value
190
191    def to_list( self ) :
192        res = list()
193        for idx in xrange( 0, self.count() ) :
194            name = c_char_p()
195            rc = self.__mgr.KNamelistGet( self.__ptr, idx, byref( name ) )
196            if rc != 0 :
197                self.__mgr.raise_rc( rc, "KNamelistGet( %d )"%( idx ), self )
198            if PY3 :
199                res.append( name.value.decode( "utf-8" ) )
200            else :
201                res.append( name.value )
202        return res
203
204
205#------------------------------------------------------------------------------------------------------------
206def random_string( size = 12, chars = string.ascii_uppercase + string.ascii_lowercase + string.digits ) :
207    return ''.join( random.choice( chars ) for _ in xrange( size ) )
208
209def random_data( count, min_value, max_value ) :
210    res = list()
211    for _ in xrange( count ) :
212        res.append( random.randint( min_value, max_value ) )
213    return res
214
215#------------------------------------------------------------------------------------------------------------
216class typedecl( Structure ) :
217    _fields_ = [ ( "type_id", c_int ), ( "dim", c_int ) ]
218
219    def __str__( self ) :
220        return "( type_id=%d, dim=%d )"%( self.type_id, self.dim )
221
222class typedesc( Structure ) :
223    _fields_ = [ ( "bits", c_int ), ( "dim", c_int ), ( "domain", c_int ) ]
224
225    def __str__( self ) :
226        return "( bits=%d, dim=%d, domain=%d )"%( self.bits, self.dim, self.domain )
227
228
229#------------------------------------------------------------------------------------------------------------
230uint_xf  = { 1 : c_ubyte, 8  : c_ubyte, 16 : c_ushort, 32 : c_uint, 64 : c_ulonglong }
231int_xf   = { 1 : c_byte,  8  : c_byte,  16 : c_short,  32 : c_int,  64 : c_longlong }
232float_xf = { 32 : c_float, 64 : c_double }
233txt_xf   = { 8  : c_char }
234
235if platform.system() == "Windows" :
236    type_xf = { TypeDomain.Bool     : ( uint_xf,  c_ubyte ),
237                TypeDomain.UInt     : ( uint_xf,  c_ubyte ),
238                TypeDomain.Int      : ( int_xf,   c_byte ),
239                TypeDomain.Float    : ( float_xf, c_double ),
240                TypeDomain.Ascii    : ( txt_xf,   c_char ),
241                TypeDomain.Unicode  : ( txt_xf,   c_char ) }
242
243else :
244    type_xf = { TypeDomain.Bool.value     : ( uint_xf,  c_ubyte ),
245                TypeDomain.UInt.value     : ( uint_xf,  c_ubyte ),
246                TypeDomain.Int.value      : ( int_xf,   c_byte ),
247                TypeDomain.Float.value    : ( float_xf, c_double ),
248                TypeDomain.Ascii.value    : ( txt_xf,   c_char ),
249                TypeDomain.Unicode.value  : ( txt_xf,   c_char ) }
250
251
252#------------------------------------------------------------------------------------------------------------
253class VColumn :
254    """representing a column of a vdb-cursor
255    """
256    def __init__( self, mgr, cur, id, name, tabname ) :
257        self.__mgr = mgr
258        self.__cur = cur
259        self.__id = id
260        p1 = name.find( '(' )
261        p2 = name.find( ')' )
262        if p1 > -1 and p2 > -1 :
263            self.cast = name[ p1 + 1 : p2 ]
264            self.name = name[ p2 + 1 : ]
265        else :
266            self.cast = ""
267            self.name = name
268        self.tabname = tabname
269        self.__tdec = typedecl( 0, 0 )
270        self.__tdes = typedesc( 0, 0, 0 )
271        self.column_type = None
272        self.min_value = None
273        self.max_value = None
274
275    def __str__( self ) :
276        return "%s.%s: (%d) %s %s"%( self.tabname, self.name, self.__id, self.tdec, self.tdes )
277
278    def __enter__( self ) :
279        return self
280
281    def __exit__( self, type, value, traceback ) :
282        pass
283
284    def _update( self ) :
285        rc = self.__mgr.VCursorDatatype( self.__cur._VCursor__ptr, self.__id, byref( self.__tdec ), byref( self.__tdes ) )
286        if rc != 0 :
287            self.__mgr.raise_rc( rc, "VCursorDatatype( '%s.%s' )"%( self.tabname, self.name ), self )
288        ( dict, dflt ) = type_xf[ self.__tdes.domain ]
289        self.column_type = dict[ self.__tdes.bits ]
290        if self.column_type == None :
291            self.column_type == dflt
292
293    def domain( self ) :
294        return TypeDomain( self.__tdes.domain )
295
296    def bits( self ) :
297        return self.__tdes.bits
298
299    def dim( self ) :
300        return self.__tdes.dim
301
302    def Read( self, row ) :
303        """read values from a column
304        returns either a string or a list of integer, float, boolean values
305
306        Args:
307            row (longlong)  :  row to read from
308        """
309        if self.column_type == None :
310            raise vdb_error( 0, "read: undefined column-type", self )
311        row_id = c_longlong( row )
312        elem_bits = c_int()
313        data = c_void_p()
314        row_len = c_int()
315        rc = self.__mgr.VCursorCellDataDirect( self.__cur._VCursor__ptr, row_id, self.__id, byref( elem_bits ), byref( data ), None, byref( row_len ) )
316        if rc != 0 :
317            self.__mgr.raise_rc( rc, "VCursorCellDataDirect( '%s.%s', #%d )"%( self.tabname, self.name, row ), self )
318        if self.column_type == c_char :
319            tmp = string_at( data, row_len.value )
320            if PY3 and isinstance( tmp, bytes ) :
321                return tmp.decode( "utf-8" )
322            return tmp
323        else :
324            typed_ptr = cast( data, POINTER( self.column_type ) )
325            e_count = row_len.value
326            if elem_bits.value < 8 :
327                e_count *= elem_bits.value
328                if PY3 :
329                    e_count //= 8
330                else :
331                    e_count /= 8
332            l = list()
333            for idx in xrange( 0, e_count ) :
334                l.append( typed_ptr[ idx ] )
335            return l
336
337    def __write_values( self, data ) :
338        if isinstance( data, list ) :
339            l = len( data )
340            t = self.column_type * l
341            arr = t()
342            idx = 0
343            for x in data :
344                arr[ idx ] = x
345                idx += 1
346        else :
347            l = 1
348            t = self.column_type * l
349            arr = t()
350            arr[ 0 ] = data
351
352        bits = c_int( self.__tdes.bits )
353        rc = self.__mgr.VCursorWrite( self.__cur._VCursor__ptr, self.__id, bits, arr, c_int( 0 ), c_int( l ) )
354        if rc != 0 :
355            self.__mgr.raise_rc( rc, "VCursorWrite( %s.%s )"%( self.tabname, self.name ), self )
356
357    def __write_string( self, data ) :
358        p = create_string_buffer( to_bytes( data ) )
359        rc = self.__mgr.VCursorWrite( self.__cur._VCursor__ptr, self.__id, c_int( 8 ), p, c_int( 0 ), c_int( len( data ) ) )
360        if rc != 0 :
361            self.__mgr.raise_rc( rc, "VCursorWrite( %s.%s, %s )"%( self.tabname, self.name, data ), self )
362
363    def write( self, data ) :
364        """write values to a column
365        raises vdb_error if error occurs
366
367        Args:
368            data ( list of values or string ) :  data to be written
369        """
370        if self.column_type == None :
371            raise vdb_error( 0, "write: undefined column-type", self )
372        elif self.column_type == c_char :
373            self.__write_string( data )
374        else :
375            self.__write_values( data )
376
377    def write_rand( self, count = 1, max_value = 255, min_value = 0 ) :
378        if self.column_type == None :
379            raise vdb_error( 0, "write_rand: undefined column-type", self )
380        else :
381            dom = self.domain()
382            if dom == TypeDomain.Ascii or dom == TypeDomain.Unicode :
383                self.__write_string( random_string( count ) )
384            elif dom == TypeDomain.Bool :
385                self.__write_values( random_data( count, 0, 1 ) )
386            else :
387                self.__write_values( random_data( count, min_value, max_value ) )
388
389    def set_default( self, data ) :
390        if isinstance( data, list ) :
391            l = len( data )
392            t = self.column_type * l
393            arr = t()
394            idx = 0
395            for x in data :
396                arr[ idx ] = x
397                idx += 1
398        else :
399            l = 1
400            t = self.column_type * l
401            arr = t()
402            arr[ 0 ] = data
403
404        bits = c_int( self.__tdes.bits )
405        rc = self.__mgr.VCursorDefault( self.__cur._VCursor__ptr, self.__id, bits, arr, c_int( 0 ), c_int( l ) )
406        if rc != 0 :
407            self.__mgr.raise_rc( rc, "VCursorDefault( %s.%s )"%( self.tabname, self.name ), self )
408
409    def default_string( self, data ) :
410        p = create_string_buffer( data )
411        rc = self.__mgr.VCursorDefault( self.__cur._VCursor__ptr, self.__id, c_int( 8 ), p, c_int( 0 ), c_int( len( data ) ) )
412        if rc != 0 :
413            self.__mgr.raise_rc( rc, "VCursorDefault( %s.%s, %s )"%( self.tabname, self.name, data ), self )
414
415    def default( self, data ) :
416        if self.column_type == None :
417            raise vdb_error( 0, "default: undefined column-type", self )
418        if self.column_type == c_char :
419            return self.default_string( data )
420        else :
421            return self.default_values( data )
422
423    def row_range( self ) :
424        first = c_longlong()
425        count = c_longlong()
426        rc = self.__mgr.VCursorIdRange( self.__cur._VCursor__ptr, self.__id, byref( first ), byref( count ) )
427        if rc != 0 :
428            self.__mgr.raise_rc( rc, "VCursorIdRange( '%s.%s' )"%( self.tabname, self.name ), self )
429        return ( first.value, count.value )
430
431    def range( self ) :
432        ( first, count ) = self.row_range()
433        return xrange( first, first + count )
434
435    def next_row( self, current_row ) :
436        res = c_longlong( 0 )
437        rc = self.__mgr.VCursorFindNextRowIdDirect( self.__cur._VCursor__ptr, self.__id, c_longlong( current_row ), byref( res ) )
438        if rc != 0 :
439            return None
440        else :
441            return res.value
442
443
444#------------------------------------------------------------------------------------------------------------
445class ReferenceObj :
446    def __init__( self, mgr, ptr ) :
447        self.__mgr = mgr
448        self.__ptr = ptr
449
450    def __del__( self ) :
451        self.__mgr.ReferenceObj_Release( self.__ptr )
452
453    def __str__( self ) :
454        idx = self.Idx()
455        start, stop = self.IdRange()
456        seq_id = self.SeqId()
457        name = self.Name()
458        return "Idx\t%d\nIdRange\t%d..%d\nSeqId\t%s\nName\t%s"%( idx, start, stop, seq_id, name )
459
460    def Idx( self ) :
461        res = c_int()
462        rc = self.__mgr.ReferenceObj_Idx( self.__ptr, byref( res ) )
463        if rc != 0 :
464            self.__mgr.raise_rc( rc, "ReferenceObj_Idx()", self )
465        return res.value
466
467    def IdRange( self ) :
468        start = c_longlong()
469        stop = c_longlong()
470        rc = self.__mgr.ReferenceObj_IdRange( self.__ptr, byref( start ), byref( stop ) )
471        if rc != 0 :
472            self.__mgr.raise_rc( rc, "ReferenceObj_IdRange()", self )
473        return ( start.value, stop.value )
474
475    def Bin( self ) :
476        res = c_int()
477        rc = self.__mgr.ReferenceObj_Bin( self.__ptr, byref( res ) )
478        if rc != 0 :
479            self.__mgr.raise_rc( rc, "ReferenceObj_Bin()", self )
480        return res.value
481
482    def SeqId( self ) :
483        res = c_char_p()
484        rc = self.__mgr.ReferenceObj_SeqId( self.__ptr, byref( res ) )
485        if rc != 0 :
486            self.__mgr.raise_rc( rc, "ReferenceObj_SeqId()", self )
487        return res.value
488
489    def Name( self ) :
490        res = c_char_p()
491        rc = self.__mgr.ReferenceObj_Name( self.__ptr, byref( res ) )
492        if rc != 0 :
493            self.__mgr.raise_rc( rc, "ReferenceObj_Name()", self )
494        return res.value
495
496    def SeqLength( self ) :
497        res = c_int()
498        rc = self.__mgr.ReferenceObj_SeqLength( self.__ptr, byref( res ) )
499        if rc != 0 :
500            self.__mgr.raise_rc( rc, "ReferenceObj_SeqLength()", self )
501        return res.value
502
503    def Circular( self ) :
504        res = c_bool()
505        rc = self.__mgr.ReferenceObj_Circular( self.__ptr, byref( res ) )
506        if rc != 0 :
507            self.__mgr.raise_rc( rc, "ReferenceObj_Circular()", self )
508        return res.value
509
510    def External( self ) :
511        res = c_bool()
512        rc = self.__mgr.ReferenceObj_External( self.__ptr, byref( res ), c_void_p( 0 ) )
513        if rc != 0 :
514            self.__mgr.raise_rc( rc, "ReferenceObj_External()", self )
515        return res.value
516
517    def Read( self, offs, len ) :
518        buffer = create_string_buffer( len )
519        written = c_int()
520        rc = self.__mgr.ReferenceObj_Read( self.__ptr, c_int( offs ), c_int( len ), buffer, byref( written ) )
521        if rc != 0 :
522            self.__mgr.raise_rc( rc, "ReferenceObj_Read( %d.%d )" % ( offs, len ), self )
523        if PY3 :
524            return buffer.value.decode( "utf-8" )
525        return buffer.value
526
527    def GetIdCount( self, row_id ) :
528        res = c_int()
529        rc = self.__mgr.ReferenceObj_GetIdCount( self.__ptr, c_longlong( row_id ), byref( res ) )
530        if rc != 0 :
531            self.__mgr.raise_rc( rc, "ReferenceObj_GetIdCount( %d )" % row_id, self )
532        return res.value
533
534
535#------------------------------------------------------------------------------------------------------------
536class ReferenceList :
537    def __init__( self, mgr, ptr ) :
538        self.__mgr = mgr
539        self.__ptr = ptr
540
541    def __del__( self ) :
542        rc = self.__mgr.ReferenceList_Release( self.__ptr )
543        if rc != 0 :
544            self.__mgr.raise_rc( rc, "ReferenceList_Release()", self )
545
546    def count( self ) :
547        res = c_int()
548        rc = self.__mgr.ReferenceList_Count( self.__ptr, byref( res ) )
549        if rc != 0 :
550            self.__mgr.raise_rc( rc, "ReferenceList_Count()", self )
551        return res.value
552
553    def find( self, name ) :
554        ptr = c_void_p()
555        rc = self.__mgr.ReferenceList_Find( self.__ptr, byref( ptr ), to_char_p( name ), c_int( len( name ) ) )
556        if rc != 0 :
557            self.__mgr.raise_rc( rc, "ReferenceList_Find( '%s' )" % name, self )
558        return ReferenceObj( self.__mgr, ptr )
559
560    def get( self, idx ) :
561        ptr = c_void_p()
562        rc = self.mgr.ReferenceList_Get( self.__ptr, byref( ptr ), c_int( idx ) )
563        if rc != 0 :
564            self.__mgr.raise_rc( rc, "ReferenceList_Get( %d )" % idx, self )
565        return ReferenceObj( self.__mgr, ptr )
566
567
568#------------------------------------------------------------------------------------------------------------
569def read_row( cols, row_id ) :
570    res = {}
571    try :
572        for ( name, column ) in cols.iteritems() :
573            res[ name ] = column.Read( row_id )
574    except AttributeError :
575        for ( name, column ) in cols.items() :
576            res[ name ] = column.Read( row_id )
577    return res
578
579
580#------------------------------------------------------------------------------------------------------------
581def first_none_static_col( cols ) :
582    res = None
583    try :
584        v = cols.itervalues()
585    except AttributeError :
586        v = cols.values()
587    for c in v :
588        rr = c.row_range()
589        if res == None and rr[ 1 ] > 0 :
590            res = c
591    return res
592
593
594#------------------------------------------------------------------------------------------------------------
595def row_gen( cols, row_range = None ) :
596    if isinstance( cols, dict ) :
597        first_col = first_none_static_col( cols )
598        if first_col != None :
599            if row_range == None :
600                row_id = 1
601                while row_id != None :
602                    yield read_row( cols, row_id )
603                    row_id = first_col.next_row( row_id + 1 )
604            else :
605                range_idx = 0
606                try :
607                    row_id = row_range[ range_idx ]
608                except :
609                    row_id = None
610                while row_id != None :
611                    yield read_row( cols, row_id )
612                    range_idx += 1
613                    try :
614                        row_id = first_col.next_row( row_range[ range_idx ] )
615                    except :
616                        row_id = None
617    else :
618        if row_range == None :
619            row_id = 1
620            while row_id != None :
621                yield cols.Read( row_id )
622                row_id = cols.next_row( row_id + 1 )
623        else :
624            range_idx = 0
625            try :
626                row_id = row_range[ range_idx ]
627            except :
628                row_id = None
629            while row_id != None :
630                yield cols.Read( row_id )
631                range_idx += 1
632                try :
633                    row_id = cols.next_row( row_range[ range_idx ] )
634                except :
635                    row_id = None
636
637
638#------------------------------------------------------------------------------------------------------------
639class VCursor :
640    def __init__( self, tab, ptr ) :
641        self.__mgr = tab._VTable__mgr
642        self.__tab = tab
643        self.__ptr = ptr
644
645    def __del__( self ) :
646        rc = self.__mgr.VCursorRelease( self.__ptr )
647        if rc != 0 :
648            self.__mgr.raise_rc( rc, "VCursorRelease( '%s' )"%( self.__tab._VTable__name ), self )
649
650    def __enter__( self ) :
651        return self
652
653    def __exit__( self, type, value, traceback ) :
654        pass
655
656    def OpenColumns( self, col_names ) :
657        if isinstance( col_names, list ) :
658            res = {}
659            for name in col_names :
660                res[ name ] = self.AddColumn( name )
661            self.Open()
662            try :
663                v = res.itervalues()
664            except AttributeError :
665                v = res.values()
666            for c in v :
667                c._update()
668            return res
669        elif isinstance( col_names, str ) :
670            c = self.AddColumn( col_names )
671            self.Open()
672            c._update()
673            return c
674        else :
675            raise vdb_error( 0, "cursor.open( x ) x is not list or string", self )
676
677    def AddColumn( self, name ) :
678        idx = c_int()
679        rc = self.__mgr.VCursorAddColumn( self.__ptr, byref( idx ), to_char_p( name ) )
680        if rc != 0 :
681            self.__mgr.raise_rc( rc, "VCursorAddColumn( %s.%s )"%( self.__tab.name, name ), self )
682        return VColumn( self.__mgr, self, idx.value, name, self.__tab._VTable__name )
683
684    def Open( self ) :
685        rc = self.__mgr.VCursorOpen( self.__ptr )
686        if rc != 0 :
687            self.__mgr.raise_rc( rc, "VCursorOpen( '%s' )"%( self.__tab._VTable__name ), self )
688
689    def Commit( self ) :
690        rc = self.__mgr.VCursorCommit( self.__ptr )
691        if rc != 0 :
692            self.__mgr.raise_rc( rc, "VCursorCommit( %s )"%( self.__tab._VTable__name ), self )
693
694    def OpenRow( self ) :
695        rc = self.__mgr.VCursorOpenRow( self.__ptr )
696        if rc != 0 :
697            self.__mgr.raise_rc( rc, "VCursorOpenRow( '%s' )"%( self.__tab._VTable__name ), self )
698
699    def CommitRow( self ) :
700        rc = self.__mgr.VCursorCommitRow( self.__ptr )
701        if rc != 0 :
702            self.__mgr.raise_rc( rc, "VCursorCommitRow( '%s' )"%( self.__tab._VTable__name ), self )
703
704    def RepeatRow( self, count ) :
705        rc = self.__mgr.VCursorRepeatRow( self.__ptr, count )
706        if rc != 0 :
707            self.__mgr.raise_rc( rc, "VCursorRepeatRow( '%s', %d )"%( self.__tab._VTable__name, count ), self )
708
709    def CloseRow( self ) :
710        rc = self.__mgr.VCursorCloseRow( self.__ptr )
711        if rc != 0 :
712            self.__mgr.raise_rc( rc, "VCursorCloseRow( '%s' )"%( self.__tab._VTable__name ), self )
713
714    def FlushPage( self ) :
715        rc = self.__mgr.VCursorFlushPage( self.__ptr )
716        if rc != 0 :
717            self.__mgr.raise_rc( rc, "VCursorFlushPage( '%s' )"%( self.__tab._VTable__name ), self )
718
719    def RowId( self ) :
720        row_id = c_longlong()
721        rc = self.__mgr.VCursorRowId( self.__ptr, byref( row_id ) )
722        if rc != 0 :
723            self.__mgr.raise_rc( rc, "VCursorRowId( '%s' )"%( self.__tab._VTable__name ), self )
724        return row_id.value
725
726    def SetRowId( self, value ) :
727        rc = self.__mgr.VCursorSetRowId( self.__ptr, value )
728        if rc != 0 :
729            self.__mgr.raise_rc( rc, "VCursorSetRowId( '%s', %d )"%( self.__tab._VTable__name, value ), self )
730
731    def ReferenceList( self ) :
732        reflist_ptr = c_void_p()
733        rc = self.__mgr.ReferenceList_MakeCursor( byref( reflist_ptr ), self.__ptr, c_int( 0 ), c_char_p( 0 ), c_int( 0 ) )
734        if rc != 0 :
735            self.__mgr.raise_rc( rc, "ReferenceList_MakeCursor()", self )
736        return ReferenceList( self.__mgr, reflist_ptr )
737
738
739def max_colname_len( cols, colnames ) :
740    res = 0
741    if colnames == None :
742        try :
743            for ( name, column ) in cols.iteritems() :
744                l = len( name )
745                if l > res :
746                    res = l
747        except AttributeError :
748            for ( name, column ) in cols.items() :
749                l = len( name )
750                if l > res :
751                    res = l
752    else :
753        for name in colnames :
754            l = len( name )
755            if l > res :
756                res = l
757    return res
758
759
760#------------------------------------------------------------------------------------------------------------
761# cols ....... dictionay : key = colname, value = column-object
762# rowrange ... a xrange - iterator ( None: all rows )
763# colnames ... a list of string ( None: all columns )
764# prefix ..... a string printed at the beginning of each line
765def print_cols( cols, rowrange, colnames = None, prefix = "" ) :
766    if cols != None :
767        if rowrange == None :
768            try :
769                column = cols.itervalues().next()
770            except AttributeError :
771                column = list( cols.values() )[ 0 ]
772            rr = column.range()
773        else :
774            rr = rowrange
775        w = max_colname_len( cols, colnames )
776        for row_id in rr :
777            if colnames == None :
778                try :
779                    for ( name, column ) in sorted( cols.iteritems() ) :
780                        print( '{0}{1:<{width}}.{2} : {3}'.format( prefix, name, row_id, column.Read( row_id ), width = w ) )
781                except AttributeError :
782                    for ( name, column ) in sorted( cols.items() ) :
783                        print( '{0}{1:<{width}}.{2} : {3}'.format( prefix, name, row_id, column.Read( row_id ), width = w ) )
784            else :
785                for name in colnames :
786                    column = cols[ name ]
787                    if column != None :
788                        print( '{0}{1:<{width}}.{2} : {3}'.format( prefix, name, row_id, column.Read( row_id ), width = w ) )
789            print( "%s."%( prefix ) )
790
791
792#------------------------------------------------------------------------------------------------------------
793class KIndex :
794    def __init__( self, mgr, ptr, name ) :
795        self.__mgr = mgr
796        self.__ptr = ptr
797        self.__name = name
798
799    def __del__( self ) :
800        rc = self.__mgr.KIndexRelease( self.__ptr )
801        if rc != 0 :
802            self.__mgr.raise_rc( rc, "KIndexRelease( '%s' )"%( self.__name ), self )
803
804    def Version( self ) :
805        vers = c_int()
806        rc = self.__mgr.KIndexVersion( self.__ptr, byref( vers ) )
807        if rc != 0 :
808            self.__mgr.raise_rc( rc, "KIndexVersion( '%s' )"%( self.__name ), self )
809        return version( vers.value )
810
811    def Type( self ) :
812        type = c_int()
813        rc = self.__mgr.KIndexType( self.__ptr, byref( type ) )
814        if rc != 0 :
815            self.__mgr.raise_rc( rc, "KIndexType( '%s' )"%( self.__name ), self )
816        return IndexType( type.value )
817
818    def Locked( self ) :
819        return self.__mgr.KIndexLocked( self.__ptr )
820
821    def FindText( self, key ) :
822        start_id = c_longlong()
823        id_count = c_longlong()
824        rc = self.__mgr.KIndexFindText( self.__ptr, to_char_p( key ), byref( start_id ), by_ref( id_count ), c_void_p( 0 ), c_void_p( 0 ) )
825        if rc != 0 :
826            self.__mgr.raise_rc( rc, "KIndexFindText( %s, %s )"%( self.__name, key ), self )
827        return ( start_id.value, id_count.value )
828
829    def ProjectText( self, row_id, bufsize = 1024 ) :
830        buffer = create_string_buffer( bufsize )
831        start_id = c_longlong()
832        id_count = c_longlong()
833        num_writ = c_int( 0 )
834        rc = self.__mgr.KIndexProjectText( self.__ptr, c_longlong( row_id ), byref( start_id ), byref( id_count ), buffer, c_int( bufsize ), byref( num_writ ) )
835        if rc != 0 :
836            self.__mgr.raise_rc( rc, "KIndexProjectText( %s, %d )"%( self.__name, row_id ), self )
837        if PY3 :
838            return ( buffer.value.decode( "utf-8" ), start_id.value, id_count.value )
839        return ( buffer.value, start_id.value, id_count.value )
840
841    def Commit( self ) :
842        rc = self.__mgr.KIndexCommit( self.__ptr )
843        if rc != 0 :
844            self.__mgr.raise_rc( rc, "KIndexCommit( %s )"%( self.__name ), self )
845
846    def InsertText( self, unique, key, value ) :
847        rc = self.__mgr.KIndexInsertText( self.__ptr, c_bool( unique ), to_char_p( key ), c_longlong( value ) )
848        if rc != 0 :
849            self.__mgr.raise_rc( rc, "KIndexInsertText( %s, k=%s, v=%d )"%( self.__name, key, value ), self )
850
851    def DeleteText( self, key ) :
852        rc = self.__mgr.KIndexDeleteText( self.__ptr, to_char_p( key ) )
853        if rc != 0 :
854            self.__mgr.raise_rc( rc, "KIndexDeleteText( %s, k=%s )"%( self.__name, key ), self )
855
856    def InsertU64( self, unique, key_start, keylen, value_start, value_len ) :
857        rc = self.__mgr.KIndexInsertU64( self.__ptr, c_bool( unique ), c_longlong( key_start ), c_longlong( key_len ), c_longlong( value_start ), c_longlong( value_len ) )
858        if rc != 0 :
859            self.__mgr.raise_rc( rc, "KIndexInsertU64( %s, k=%d.%d, v=%d.%d )"%( self.__name, key_start, key_len, value_start, value_len ), self )
860
861    def DeleteU64( self, key ) :
862        rc = self.__mgr.KIndexDeleteU64( self.__ptr, c_longlong( key ) )
863        if rc != 0 :
864            self.__mgr.raise_rc( rc, "KIndexDeleteU64( %s, k=%d )"%( self.__name, key ), self )
865
866
867#------------------------------------------------------------------------------------------------------------
868class KMDataNode :
869    def __init__( self, mgr, ptr ) :
870        self.__mgr = mgr
871        self.__ptr = ptr
872
873    def __del__( self ) :
874        rc = self.__mgr.KMDataNodeRelease( self.__ptr )
875        if rc != 0 :
876            self.__mgr.raise_rc( rc, "KMDataNodeRelease()", self )
877
878    def __enter__( self ) :
879        return self
880
881    def __exit__( self, type, value, traceback ) :
882        pass
883
884    def OpenNode( self, path, open_mode = OpenMode.Read ) :
885        node = c_void_p()
886        if open_mode == OpenMode.Write :
887            rc = self.__mgr.KMDataNodeOpenNodeUpdate( self.__ptr, byref( node ), to_char_p( path ) )
888            if rc != 0 :
889                self.__mgr.raise_rc( rc, "KMDataNodeOpenNodeUpdate( %s )"%( path ), self )
890        else :
891            rc = self.__mgr.KMDataNodeOpenNodeRead( self.__ptr, byref( node ), to_char_p( path ) )
892            if rc != 0 :
893                self.__mgr.raise_rc( rc, "KMDataNodeOpenNodeRead( %s )"%( path ), self )
894        return KMDataNode( self.__mgr, node )
895
896    def ByteOrder( self ) :
897        order = c_bool()
898        rc = self.__mgr.KMDataNodeByteOrder( self.__ptr, byref( order ) )
899        if rc != 0 :
900            self.__mgr.raise_rc( rc, "KMDataNodeByteOrder()", self )
901        return order.value
902
903    def ListChildren( self ) :
904        l = c_void_p()
905        rc = self.__mgr.KMDataNodeListChildren( self.__ptr, byref( l ) )
906        if rc == 0 :
907            return KNamelist( self.__mgr, l ).to_list()
908        return []
909
910    def ListAttr( self ) :
911        l = c_void_p()
912        rc = self.__mgr.KMDataNodeListAttr( self.__ptr, byref( l ) )
913        if rc == 0 :
914            return KNamelist( self.__mgr, l ).to_list()
915        return []
916
917    def size( self ) :
918        buffer = create_string_buffer( 16 )
919        num_read = c_size_t()
920        remaining = c_size_t()
921        rc = self.__mgr.KMDataNodeRead( self.__ptr, c_size_t( 0 ), buffer, c_size_t( 16 ), byref( num_read ), byref( remaining ) )
922        if rc != 0 :
923            self.__mgr.raise_rc( rc, "KMDataNodeRead()", self )
924        return num_read.value + remaining.value
925
926    def to_read( self, req_len ) :
927        ns = self.size()
928        if req_len > 0 :
929            return min( req_len, ns )
930        return ns
931
932    def Read( self, buffer_size, to_read, offset ) :
933        buffer = create_string_buffer( int( buffer_size ) )
934        num_read = c_size_t()
935        remaining = c_size_t()
936        rc = self.__mgr.KMDataNodeRead( self.__ptr, c_size_t( offset ), buffer, c_size_t( to_read ), byref( num_read ), byref( remaining ) )
937        if rc != 0 :
938            self.__mgr.raise_rc( rc, "KMDataNodeRead( offset = %d )"%( offset ), self )
939        if PY3 :
940            return buffer.value.decode( "utf-8" )
941        return buffer.value
942
943    def as_string( self, req_len = 0, offset = 0 ) :
944        n_bytes = self.to_read( req_len )
945        if n_bytes < 1 :
946            return ""
947        return self.Read( n_bytes, n_bytes, offset )
948
949    def read_buffer_as( self, t = c_ubyte, align = 1, req_len = 0, offset = 0 ) :
950        n_bytes = self.to_read( req_len )
951        if n_bytes < 1 :
952            return []
953        n_values = n_bytes
954        if align > 1 :
955            if PY3 :
956                n_values = n_bytes / align
957            else :
958                n_values = n_bytes // align
959            if n_bytes > ( n_values * align ) :
960                n_values += 1
961        buffer = self.Read( n_values * align, n_bytes, offset )
962        ptr = cast( buffer, POINTER( t ) )
963        l = list()
964        for idx in xrange( 0, int( n_values ) ) :
965            l.append( ptr[ idx ] )
966        return l
967
968    def as_uint8( self, req_len = 0, offset = 0 ) :
969        return self.read_buffer_as( c_ubyte, 1, req_len, offset )
970
971    def as_int8( self, req_len = 0, offset = 0 ) :
972        return self.read_buffer_as( c_byte, 1, req_len, offset )
973
974    def as_uint16( self, req_len = 0, offset = 0 ) :
975        return self.read_buffer_as( c_ushort, 2, req_len, offset )
976
977    def as_int16( self, req_len = 0, offset = 0 ) :
978        return self.read_buffer_as( c_short, 2, req_len, offset )
979
980    def as_uint32( self, req_len = 0, offset = 0 ) :
981        return self.read_buffer_as( c_uint, 4, req_len, offset )
982
983    def as_int32( self, req_len = 0, offset = 0 ) :
984        return self.read_buffer_as( c_int, 4, req_len, offset )
985
986    def as_uint64( self, req_len = 0, offset = 0 ) :
987        return self.read_buffer_as( c_ulonglong, 8, req_len, offset )
988
989    def as_int64( self, req_len = 0, offset = 0 ) :
990        return self.read_buffer_as( c_longlong, 8, req_len, offset )
991
992    def write_string( self, data, append = False ) :
993        p = create_string_buffer( data )
994        if append :
995            rc = self.__mgr.KMDataNodeAppend( self.__ptr, p, c_size_t( len( data ) ) )
996            if rc != 0 :
997                self.__mgr.raise_rc( rc, "KMDataNodeAppend()", self )
998        else :
999            rc = self.__mgr.KMDataNodeWrite( self.__ptr, p, c_size_t( len( data ) ) )
1000            if rc != 0 :
1001                self.__mgr.raise_rc( rc, "KMDataNodeWrite()", self )
1002
1003    def write_values( self, data, ct, ct_size, append ) :
1004        if isinstance( data, list ) :
1005            l = len( data )
1006            t = ct * l
1007            arr = t()
1008            idx = 0
1009            for x in data :
1010                arr[ idx ] = x
1011                idx += 1
1012        else :
1013            l = 1
1014            t = ct * l
1015            arr = t()
1016            arr[ 0 ] = data
1017        if append :
1018            rc = self.__mgr.KMDataNodeAppend( self.__ptr, arr, c_size_t( l * ct_size ) )
1019            if rc != 0 :
1020                self.__mgr.raise_rc( rc, "KMDataNodeAppend()", self )
1021        else :
1022            rc = self.__mgr.KMDataNodeWrite( self.__ptr, arr, c_size_t( l * ct_size ) )
1023            if rc != 0 :
1024                self.__mgr.raise_rc( rc, "KMDataNodeWrite()", self )
1025
1026    def write_uint8( self, data, append = False ) :
1027        self.write_values( data, c_ubyte, 1, append )
1028
1029    def write_int8( self, data, append = False ) :
1030        self.write_values( data, c_byte, 1, append )
1031
1032    def write_uint16( self, data, append = False ) :
1033        self.write_values( data, c_ushort, 2, append )
1034
1035    def write_int16( self, data, append = False ) :
1036        self.write_values( data, c_short, 2, append )
1037
1038    def write_uint32( self, data, append = False ) :
1039        self.write_values( data, c_uint, 4, append )
1040
1041    def write_int32( self, data, append = False ) :
1042        self.write_values( data, c_int, 4, append )
1043
1044    def write_uint64( self, data, append = False ) :
1045        self.write_values( data, c_ulonglong, 8, append )
1046
1047    def write_int64( self, data, append = False ) :
1048        self.write_values( data, c_longlong, 8, append )
1049
1050
1051#------------------------------------------------------------------------------------------------------------
1052class KMetadata :
1053    def __init__( self, mgr, ptr ) :
1054        self.__mgr = mgr
1055        self.__ptr = ptr
1056
1057    def __del__( self ) :
1058        rc = self.__mgr.KMetadataRelease( self.__ptr )
1059        if rc != 0 :
1060            self.__mgr.raise_rc( rc, "KMetadataRelease()", self )
1061
1062    def __enter__( self ) :
1063        return self
1064
1065    def __exit__( self, type, value, traceback ) :
1066        pass
1067
1068    def Version( self ) :
1069        vers = c_int()
1070        rc = self.__mgr.KMetadataVersion( self.__ptr, byref( vers ) )
1071        if rc != 0 :
1072            self.__mgr.raise_rc( rc, "KMetadataVersion()", self )
1073        return version( vers.value )
1074
1075    def ByteOrder( self ) :
1076        order = c_bool()
1077        rc = self.__mgr.KMetadataByteOrder( self.__ptr, byref( order ) )
1078        if rc != 0 :
1079            self.__mgr.raise_rc( rc, "KMetadataByteOrder()", self )
1080        return order.value
1081
1082    def Revision( self ) :
1083        rev = c_int()
1084        rc = self.__mgr.KMetadataRevision( self.__ptr, byref( rev ) )
1085        if rc != 0 :
1086            self.__mgr.raise_rc( rc, "KMetadataRevision()", self )
1087        return rev.value
1088
1089    def MaxRevision( self ) :
1090        rev = c_int()
1091        rc = self.__mgr.KMetadataMaxRevision( self.__ptr, byref( rev ) )
1092        if rc != 0 :
1093            self.__mgr.raise_rc( rc, "KMetadataMaxRevision()", self )
1094        return rev.value
1095
1096    def Commit( self ) :
1097        rc = self.__mgr.KMetadataCommit( self.__ptr )
1098        if rc != 0 :
1099            self.__mgr.raise_rc( rc, "KMetadataCommit()", self )
1100
1101    def Freeze( self ) :
1102        rc = self.__mgr.KMetadataFreeze( self.__ptr )
1103        if rc != 0 :
1104            self.__mgr.raise_rc( rc, "KMetadataFreeze()", self )
1105
1106    def OpenRevision( self, rev_nr ) :
1107        k_meta = c_void_p()
1108        rc = self.__mgr.KMetadataOpenRevision( self.__ptr, byref( k_meta ), c_int( rev_nr ) )
1109        if rc != 0 :
1110            self.__mgr.raise_rc( rc, "KMetadataOpenRevision( %d )"%rev_nr, self )
1111        return KMetadata( self.__mgr, k_meta )
1112
1113    def GetSequence( self, name ) :
1114        value = c_longlong()
1115        rc = self.__mgr.KMetadataGetSequence( self.__ptr, to_char_p( name ), byref( value ) )
1116        if rc != 0 :
1117            self.__mgr.raise_rc( rc, "KMetadataGetSequence( %s )"%name, self )
1118        return value.value
1119
1120    def SetSequence( self, name, value ) :
1121        rc = self.__mgr.KMetadataSetSequence( self.__ptr, to_char_p( name ), c_longlong( value ) )
1122        if rc != 0 :
1123            self.__mgr.raise_rc( rc, "KMetadataSetSequence( %s, %d )"%( name, value ), self )
1124
1125    def NextSequence( self, name ) :
1126        value = c_longlong()
1127        rc = self.__mgr.KMetadataNextSequence( self.__ptr, to_char_p( name ), byref( value ) )
1128        if rc != 0 :
1129            self.__mgr.raise_rc( rc, "KMetadataNextSequence( %s )"%( name ), self )
1130        return value.value
1131
1132    def OpenNode( self, path, open_mode = OpenMode.Read ) :
1133        ptr = c_void_p()
1134        if open_mode == OpenMode.Write :
1135            rc = self.__mgr.KMetadataOpenNodeUpdate( self.__ptr, byref( ptr ), to_char_p( path ) )
1136            if rc != 0 :
1137                self.__mgr.raise_rc( rc, "KMetadataOpenNodeUpdate( %s )"%( path ), self )
1138        else :
1139            rc = self.__mgr.KMetadataOpenNodeRead( self.__ptr, byref( ptr ), to_char_p( path ) )
1140            if rc != 0 :
1141                self.__mgr.raise_rc( rc, "KMetadataOpenNodeRead( %s )"%( path ), self )
1142        return KMDataNode( self.__mgr, ptr )
1143
1144
1145#------------------------------------------------------------------------------------------------------------
1146class VTable :
1147    def __init__( self, mgr, ptr, name ) :
1148        self.__mgr = mgr
1149        self.__ptr = ptr
1150        self.__kdb_ptr = None
1151        self.__name = name
1152        self.p_cur = None
1153        self.p_cols = None
1154
1155    def __del__( self ) :
1156        rc = self.__mgr.VTableRelease( self.__ptr )
1157        if rc != 0 :
1158            self.__mgr.raise_rc( rc, "VTableRelease( %s )"%( self.__name ), self )
1159        if self.__kdb_ptr != None :
1160            rc = self.__mgr.KTableRelease( self.__kdb_ptr )
1161            if rc != 0 :
1162                self.__mgr.raise_rc( rc, "KTableRelease( %s )"%( self.__name ), self )
1163
1164    def __enter__( self ) :
1165        return self
1166
1167    def __exit__( self, type, value, traceback ) :
1168        pass
1169
1170    def Name( self ) :
1171        return self.__name
1172
1173    def ListCol( self ) :
1174        l = c_void_p()
1175        rc = self.__mgr.VTableListCol( self.__ptr, byref( l ) )
1176        if rc != 0 :
1177            self.__mgr.raise_rc( rc, "VTableListCol( %s )"%( self.__name ), self )
1178        return KNamelist( self.__mgr, l ).to_list()
1179
1180    def __OpenKTableRead__( self ) :
1181        k_table = c_void_p()
1182        rc = self.__mgr.VTableOpenKTableRead( self.__ptr, byref( k_table ) )
1183        if rc != 0 :
1184            self.__mgr.raise_rc( rc, "VTableOpenKTableRead( '%s' )"%( self.__name ), self )
1185        self.__kdb_ptr = k_table
1186
1187    def __OpenKTableUpdate__( self ) :
1188        k_table = c_void_p()
1189        rc = self.__mgr.VTableOpenKTableUpdate( self.__ptr, byref( k_table ) )
1190        if rc != 0 :
1191            self.__mgr.raise_rc( rc, "VTableOpenKTableUpdate( '%s' )"%( self.__name ), self )
1192        self.__kdb_ptr = k_table
1193
1194    def ListIdx( self ) :
1195        if self.__kdb_ptr == None :
1196            self.__OpenKTableRead__()
1197        l = c_void_p()
1198        rc = self.__mgr.KTableListIdx( self.__kdb_ptr, byref( l ) )
1199        if rc == 0 :
1200            return KNamelist( self.__mgr, l ).to_list()
1201        return []
1202
1203    def OpenIndexRead( self, name ) :
1204        if self.__kdb_ptr == None :
1205            self.__OpenKTableUpdate__()
1206        k_idx = c_void_p()
1207        rc = self.__mgr.KTableOpenIndexRead( self.__kdb_ptr, byref( k_idx ), to_char_p( name ) )
1208        if rc != 0 :
1209            self.__mgr.raise_rc( rc, "KTableOpenIndexRead( '%s' )"%( self.__name ), self )
1210        return KIndex( self.__mgr, k_idx, name )
1211
1212    def CreateIndex( self, name, idx_type = IndexType.Text, create_mode = CreateMode.Init ) :
1213        if self.__kdb_ptr == None :
1214            self.__OpenKTableUpdate__()
1215        k_idx = c_void_p()
1216        rc = self.__mgr.KTableCreateIndex( self.__kdb_ptr, byref( k_idx ), c_int( idx_type.value ), c_int( create_mode.value ), to_char_p( name ) )
1217        if rc != 0 :
1218            self.__mgr.raise_rc( rc, "KTableCreateIndex( '%s' )"%( self.__name ), self )
1219        return KIndex( self.__mgr, k_idx, name )
1220
1221    def OpenMetadata( self, open_mode = OpenMode.Read ) :
1222        k_meta = c_void_p()
1223        if open_mode == OpenMode.Write :
1224            rc = self.__mgr.VTableOpenMetadataUpdate(self.__ptr, byref(k_meta))
1225            if rc != 0 :
1226                self.__mgr.raise_rc( rc, "VTableOpenMetadataUpdate( '%s' )"%( self.__name ), self )
1227        else :
1228            if self.__kdb_ptr == None :
1229                self.__OpenKTableRead__()
1230            rc = self.__mgr.KTableOpenMetadataRead( self.__kdb_ptr, byref( k_meta ) )
1231            if rc != 0 :
1232                self.__mgr.raise_rc( rc, "KTableOpenMetadataRead( '%s' )"%( self.__name ), self )
1233        return KMetadata( self.__mgr, k_meta )
1234
1235    def CreateCursor( self, open_mode = OpenMode.Read, ins_mode = CursorMode.Insert ) :
1236        c = c_void_p()
1237        if open_mode == OpenMode.Write :
1238            rc = self.__mgr.VTableCreateCursorWrite( self.__ptr, byref( c ), c_int( ins_mode.value ) )
1239            if rc != 0 :
1240                self.__mgr.raise_rc( rc, "VTableCreateCursorWrite( %s )"%( self.__name ), self )
1241        else :
1242            rc = self.__mgr.VTableCreateCursorRead( self.__ptr, byref( c ) )
1243            if rc != 0 :
1244                self.__mgr.raise_rc( rc, "VTableCreateCursorRead( %s )"%( self.__name ), self )
1245        return VCursor( self, c )
1246
1247    def CreateCachedCursorRead( self, cache_size ) :
1248        c = c_void_p()
1249        rc = self.__mgr.VTableCreateCachedCursorRead( self.__ptr, byref( c ), c_longlong( cache_size ) )
1250        if rc != 0 :
1251            self.__mgr.raise_rc( rc, "VTableCreateCachedCursorRead( %s, %d )"%( self.__name, cache_size ), self )
1252        return VCursor( self, c )
1253
1254    def Locked( self ) :
1255        return self.__mgr.VTableLocked( self.__ptr )
1256
1257    def ReferenceList( self, options = 2 ) :
1258        ptr = c_void_p()
1259        rc = self.__mgr.ReferenceList_MakeTable( byref( ptr ), self.__ptr, c_int( options ), c_int( 0 ), c_char_p( 0 ), c_int( 0 ) )
1260        if rc != 0 :
1261            self.__mgr.raise_rc( rc, "ReferenceList_MakeTable( '%s' )"%( self.__name ), self )
1262        return ReferenceList( self.__mgr, ptr )
1263
1264    def print_rows( self, colrange = None, colnames = None, prefix = "" ) :
1265        if self.p_cur == None :
1266            self.p_cur = self.CreateCursor()
1267        if self.p_cur != None :
1268            if self.p_cols == None :
1269                if colnames == None :
1270                    self.p_cols = self.p_cur.OpenColumns( self.ListCol() )
1271                else :
1272                    self.p_cols = self.p_cur.OpenColumns( colnames )
1273            elif colnames != None :
1274                more_to_open = 0
1275                for name in colnames :
1276                    if self.p_cols[ name ] == None :
1277                        more_to_open += 1
1278                if more_to_open > 0 :
1279                    self.p_cur = None
1280                    self.p_cols = None
1281                    self.p_cur = self.CreateCursor()
1282                    if self.p_cur != None :
1283                        self.p_cols = self.p_cur.OpenColumns( colnames )
1284            if self.p_cols != None :
1285                print_cols( self.p_cols, colrange, colnames, prefix )
1286
1287
1288#------------------------------------------------------------------------------------------------------------
1289class VDatabase :
1290    def __init__( self, mgr, ptr, name ) :
1291        self.__mgr = mgr
1292        self.__ptr = ptr
1293        self.__name = name
1294
1295    def __del__( self ) :
1296        rc = self.__mgr.VDatabaseRelease( self.__ptr )
1297        if rc != 0 :
1298            self.__mgr.raise_rc( rc, "VDatabaseRelease( %s )"%( self.__name ), self )
1299
1300    def __enter__( self ) :
1301        return self
1302
1303    def __exit__( self, type, value, traceback ) :
1304        pass
1305
1306    def Name( self ) :
1307        return self.__name
1308
1309    def ListTbl( self ) :
1310        l = c_void_p()
1311        rc = self.__mgr.VDatabaseListTbl( self.__ptr, byref( l ) )
1312        if rc != 0 :
1313            self.__mgr.raise_rc( rc, "VDatabaseListTbl( %s )"%( self.__name ), self )
1314        return KNamelist( self.__mgr, l ).to_list()
1315
1316    def ListDB( self ) :
1317        l = c_void_p()
1318        rc = self.__mgr.VDatabaseListDB( self.__ptr, byref( l ) )
1319        if rc != 0 :
1320            self.__mgr.raise_rc( rc, "VDatabaseListDB( %s )"%( self.__name ), self )
1321        return KNamelist( self.__mgr, l ).to_list()
1322
1323    def OpenTable( self, name, mode = OpenMode.Read ) :
1324        f = self.__mgr.VDatabaseOpenTableUpdate if mode == OpenMode.Write else self.__mgr.VDatabaseOpenTableRead
1325        tab = c_void_p()
1326        rc = f( self.__ptr, byref( tab ), to_char_p( name ) )
1327        if rc != 0 :
1328            self.__mgr.raise_rc( rc, "VDatabaseOpenTable( %s.%s )"%( self.__name, name ), self )
1329        return VTable( self.__mgr, tab, name )
1330
1331    def OpenDB( self, name, mode = OpenMode.Read ) :
1332        f = self.__mgr.VDatabaseOpenDBUpdate if mode == OpenMode.Write else self.__mgr.VDatabaseOpenDBRead
1333        db = c_void_p()
1334        rc = f( self.__ptr, byref( db ), to_char_p( name ) )
1335        if rc != 0 :
1336            self.__mgr.raise_rc( rc, "VDatabaseOpenDB( %s.%s )"%( self.__name, name ), self )
1337        return VDatabase( self.__mgr, db, name )
1338
1339    def CreateTable( self, spec, name = None, mode = CreateMode.Init ) :
1340        tab = c_void_p()
1341        p = to_char_p( name if name != None else spec )
1342        rc = self.__mgr.VDatabaseCreateTable( self.__ptr, byref( tab ), to_char_p( spec ), c_int( mode.value ), p )
1343        if rc != 0 :
1344            self.__mgr.raise_rc( rc, "VDatabaseCreateTable( %s.%s )"%( self.__name, spec ), self )
1345        return VTable( self.__mgr, tab, p.value )
1346
1347    def CreateDB( self, spec, name = None, mode = CreateMode.Init ) :
1348        new_db = c_void_p()
1349        p = to_char_p( name if name != None else spec )
1350        rc = self.__mgr.VDatabaseCreateDB( self.__ptr, byref( new_db ), to_char_p( spec ), c_int( mode.value ), p )
1351        if rc != 0 :
1352            self.__mgr.raise_rc( rc, "VDatabaseCreateDB( %s.%s )"%( self.__name, spec ), self )
1353        return VDatabase( self.__mgr, new_db, p.value )
1354
1355    def DropTable( self, name ) :
1356        rc = self.__mgr.VDatabaseDropTable( self.__ptr, to_char_p( name ) )
1357        if rc != 0 :
1358            self.__mgr.raise_rc( rc, "VDatabaseDropTable( %s.%s )"%( self.__name, name ), self )
1359
1360    def DropDB( self, name ) :
1361        rc = self.__mgr.VDatabaseDropDB( self.__ptr, to_char_p( name ) )
1362        if rc != 0 :
1363            self.__mgr.raise_rc( rc, "VDatabaseDropDB( %s.%s )"%( self.__name, name ), self )
1364
1365    def Lock( self, name, what ) :
1366        rc = self.__mgr.VDatabaseLock( self.__ptr, c_int( what ), to_char_p( name ) )
1367        if rc != 0 :
1368            self.__mgr.raise_rc( rc, "VDatabaseLock( %s.%s )"%( self.__name, name ), self )
1369
1370    def UnLock( self, name, what ) :
1371        rc = self.__mgr.VDatabaseUnlock( self.__ptr, c_int( what ), to_char_p( name ) )
1372        if rc != 0 :
1373            self.__mgr.raise_rc( rc, "VDatabaseUnlock( %s.%s )"%( self.__name, name ), self )
1374
1375    def Locked( self ) :
1376        return self.__mgr.VDatabaseLocked( self.__ptr )
1377
1378    def ReferenceList( self, options = 2 ) :
1379        ptr = c_void_p()
1380        rc = self.__mgr.ReferenceList_MakeDatabase( byref( ptr ), self.__ptr, c_int( options ), c_int( 0 ), c_char_p( 0 ), c_int( 0 ) )
1381        if rc != 0 :
1382            self.__mgr.raise_rc( rc, "ReferenceList_MakeDatabase( %s )"%( self.__name ), self )
1383        return ReferenceList( self.__mgr, ptr )
1384
1385
1386#------------------------------------------------------------------------------------------------------------
1387class VSchema :
1388    def __init__( self, mgr, ptr ) :
1389        self.__mgr = mgr
1390        self.__ptr = ptr
1391
1392    def __del__( self ) :
1393        rc = self.__mgr.VSchemaRelease( self.__ptr )
1394        if rc != 0 :
1395            self.__mgr.raise_rc( rc, "VSchemaRelease()", self )
1396
1397    def __enter__( self ) :
1398        return self
1399
1400    def __exit__( self, type, value, traceback ) :
1401        pass
1402
1403    def ParseText( self, schema_txt ) :
1404        txt = to_char_p( schema_txt )
1405        l = len( schema_txt )
1406        rc = self.__mgr.VSchemaParseText( self.__ptr, c_char_p( 0 ), txt, c_int( l ) )
1407        if rc != 0 :
1408            self.__mgr.raise_rc( rc, "VSchemaParseText()", self )
1409
1410    def ParseFile( self, schema_file ) :
1411        rc = self.__mgr.VSchemaParseFile( self.__ptr, to_char_p( schema_file ) )
1412        if rc != 0 :
1413            self.mgr.raise_rc( rc, "VSchemaParseFile( '%s' )"%schema_file, self )
1414
1415    def AddIncludePath( self, path ) :
1416        rc = self.__mgr.VSchemaAddIncludePath( self.__ptr, to_char_p( path ) )
1417        if rc != 0 :
1418            self.__mgr.raise_rc( rc, "VSchemaAddIncludePath( '%s' )"%path, self )
1419
1420
1421#------------------------------------------------------------------------------------------------------------
1422class KRepository :
1423    def __init__( self, mgr, ptr ) :
1424        self.__mgr = mgr
1425        self.__ptr = ptr
1426
1427    def __del__( self ) :
1428        rc = self.__mgr.KRepositoryRelease( self.__ptr )
1429        if rc != 0 :
1430            self.__mgr.raise_rc( rc, "KRepositoryRelease()", self )
1431
1432    def __enter__( self ) :
1433        return self
1434
1435    def __exit__( self, type, value, traceback ) :
1436        pass
1437
1438    def __str__( self ) :
1439        lst = [ "'%s'"%( self.Name() ) ]
1440        lst.append( "%s"%( RepoCat( self.Category() ) ) )
1441        lst.append( "%s"%( RepoSubCat( self.SubCategory() ) ) )
1442        lst.append( "display: %s"%( self.DisplayName() ) )
1443        lst.append( "root: %s"%( self.Root() ) )
1444        lst.append( "resolver: %s"%( self.Resolver() ) )
1445        lst.append( "disabled: %r"%( self.Disabled() ) )
1446        lst.append( "cached: %r"%( self.CacheEnabled() ) )
1447        return ", ".join( lst )
1448
1449    def AddRef ( self ) :
1450        rc = self.__mgr.KRepositoryAddRef( self.__ptr )
1451        if rc != 0 :
1452            self.__mgr.raise_rc( rc, "KRepositoryAddRef()", self )
1453
1454    def Category( self ) :
1455        res = self.__mgr.KRepositoryCategory( self.__ptr )
1456        return res;
1457
1458    def SubCategory( self ) :
1459        return self.__mgr.KRepositorySubCategory( self.__ptr )
1460
1461    def Name( self ) :
1462        p = create_string_buffer( 1024 )
1463        n = c_int( 0 )
1464        rc = self.__mgr.KRepositoryName( self.__ptr, p, sizeof( p ), byref( n ) )
1465        if rc != 0 :
1466            self.__mgr.raise_rc( rc, "KRepositoryName()", self )
1467        if PY3 :
1468            return p.value.decode( "utf-8" )
1469        return p.value
1470
1471    def DisplayName( self ) :
1472        p = create_string_buffer( 1024 )
1473        n = c_int( 0 )
1474        rc = self.__mgr.KRepositoryDisplayName( self.__ptr, p, sizeof( p ), byref( n ) )
1475        if rc != 0 :
1476            self.__mgr.raise_rc( rc, "KRepositoryDisplayName()", self )
1477        if PY3 :
1478            return p.value.decode( "utf-8" )
1479        return p.value
1480
1481    def Root( self ) :
1482        p = create_string_buffer( 1024 )
1483        n = c_int( 0 )
1484        rc = self.__mgr.KRepositoryRoot( self.__ptr, p, sizeof( p ), byref( n ) )
1485        if rc != 0 :
1486            return ""
1487        if PY3 :
1488            return p.value.decode( "utf-8" )
1489        return p.value
1490
1491    def SetRoot( self, root ) :
1492        rc = self.__mgr.KRepositorySetRoot( self.__ptr, to_char_p( root ), c_int( len( root ) ) )
1493        if rc != 0 :
1494            self.__mgr.raise_rc( rc, "KRepositorySetRoot( '%s' )"%( root ), self )
1495
1496    def Resolver( self ) :
1497        p = create_string_buffer( 1024 )
1498        n = c_int( 0 )
1499        rc = self.__mgr.KRepositoryResolver( self.__ptr, p, sizeof( p ), byref( n ) )
1500        if rc != 0 :
1501            return ""
1502        if PY3 :
1503            return p.value.decode( "utf-8" )
1504        return p.value
1505
1506    def Disabled( self ) :
1507        return self.__mgr.KRepositoryDisabled( self.__ptr )
1508
1509    def SetDisabled( self, value ) :
1510        rc = self.__mgr.KRepositorySetDisabled( self.__ptr, c_bool( value ) )
1511        if rc != 0 :
1512            self.__mgr.raise_rc( rc, "KRepositorySetDisabled()", self )
1513
1514    def CacheEnabled( self ) :
1515        return self.__mgr.KRepositoryCacheEnabled( self.__ptr )
1516
1517
1518#------------------------------------------------------------------------------------------------------------
1519class KRepositoryMgr :
1520    def __init__( self, mgr, ptr ) :
1521        self.__mgr = mgr
1522        self.__ptr = ptr
1523
1524    def __del__( self ) :
1525        rc = self.__mgr.KRepositoryMgrRelease( self.__ptr )
1526        if rc != 0 :
1527            self.__mgr.raise_rc( rc, "KRepositoryMgrRelease()", self )
1528
1529    def __enter__( self ) :
1530        return self
1531
1532    def __exit__( self, type, value, traceback ) :
1533        pass
1534
1535    def HasRemoteAccess( self ) :
1536        return self.__mgr.KRepositoryMgrHasRemoteAccess( self.__ptr );
1537
1538    def __vector_2_list__( self, v ) :
1539        res = list()
1540        for i in xrange( v.start, v.start + v.len ) :
1541            r = KRepository( self.__mgr, self.__mgr.VectorGet( byref( v ), c_int( i ) ) )
1542            r.AddRef()
1543            res.append( r )
1544        self.__mgr.KRepositoryVectorWhack( byref( v ) )
1545        return res
1546
1547    def UserRepositories( self ) :
1548        v = vdb_vector()
1549        rc = self.__mgr.KRepositoryMgrUserRepositories( self.__ptr, byref( v ) )
1550        if rc != 0 :
1551            self.__mgr.raise_rc( rc, "KRepositoryMgrUserRepositories()", self )
1552        return self.__vector_2_list__( v )
1553
1554    def SiteRepositories( self ) :
1555        v = vdb_vector()
1556        rc = self.__mgr.KRepositoryMgrSiteRepositories( self.__ptr, byref( v ) )
1557        if rc != 0 :
1558            self.__mgr.raise_rc( rc, "KRepositoryMgrSiteRepositories()", self )
1559        return self.__vector_2_list__( v )
1560
1561    def RemoteRepositories( self ) :
1562        v = vdb_vector()
1563        rc = self.__mgr.KRepositoryMgrRemoteRepositories( self.__ptr, byref( v ) )
1564        if rc != 0 :
1565            self.__mgr.raise_rc( rc, "KRepositoryMgrRemoteRepositories()", self )
1566        return self.__vector_2_list__( v )
1567
1568    def CategoryDisabled( self, cat ) :
1569        return self.__mgr.KRepositoryMgrCategoryDisabled( self.__ptr, c_int( cat ) )
1570
1571    def CategorySetDisabled( self, cat, value ) :
1572        return self.__mgr.KRepositoryMgrCategorySetDisabled( self.__ptr, c_int( cat ), c_bool( value ) )
1573
1574    def AllRepos( self ) :
1575        return [ self.UserRepositories(), self.SiteRepositories(), self.RemoteRepositories() ]
1576
1577#------------------------------------------------------------------------------------------------------------
1578class KConfig :
1579    def __init__( self, mgr, ptr ) :
1580        self.__mgr = mgr
1581        self.__ptr = ptr
1582
1583    def __del__( self ) :
1584        rc = self.__mgr.KConfigRelease( self.__ptr )
1585        if rc != 0 :
1586            self.__mgr.raise_rc( rc, "KConfigRelease()", self )
1587
1588    def __enter__( self ) :
1589        return self
1590
1591    def __exit__( self, type, value, traceback ) :
1592        pass
1593
1594    def Commit( self ) :
1595        rc = self.__mgr.KConfigCommit( self.__ptr )
1596        if rc != 0 :
1597            self.__mgr.raise_rc( rc, "KConfigCommit()", self )
1598        return rc
1599
1600    def ReadBool( self, path ) :
1601        value = c_bool()
1602        rc = self.__mgr.KConfigReadBool( self.__ptr, to_char_p( path ), byref( value ) )
1603        if rc != 0 :
1604            self.__mgr.raise_rc( rc, "KConfigReadBool( '%s' )"%( path ), self )
1605        return value.value
1606
1607    def WriteBool( self, path, value ) :
1608        rc = self.__mgr.KConfigWriteBool( self.__ptr, to_char_p( path ), c_bool( value ) )
1609        if rc != 0 :
1610            self.__mgr.raise_rc( rc, "KConfigWriteBool( '%s', %s )"%( path, value ), self )
1611        return rc
1612
1613    def ReadString( self, path ) :
1614        s = vdb_string( None, 0, 0 )
1615        sp = pointer( s )
1616        rc = self.__mgr.KConfigReadString( self.__ptr, to_char_p( path ), byref( sp ) )
1617        if rc != 0 :
1618            self.__mgr.raise_rc( rc, "KConfigReadString( '%s' )"%( path ), self )
1619        res = sp.contents.addr
1620        self.__mgr.string_whack( sp.contents )
1621        return res
1622
1623    def WriteString( self, path, value ) :
1624        rc = self.__mgr.KConfigWriteString( self.__ptr, to_char_p( path ), to_char_p( value ) )
1625        if rc != 0 :
1626            self.__mgr.raise_rc( rc, "KConfigWriteString( '%s', '%s' )"%( path, value ), self )
1627        return rc
1628
1629    def ReadI64( self, path ) :
1630        value = c_longlong()
1631        rc = self.__mgr.KConfigReadI64( self.__ptr, to_char_p( path ), byref( value ) )
1632        if rc != 0 :
1633            self.__mgr.raise_rc( rc, "KConfigReadI64( '%s' )"%( path ), self )
1634        return value.value
1635
1636    def ReadU64( self, path ) :
1637        value = c_ulonglong()
1638        rc = self.__mgr.KConfigReadU64( self.__ptr, to_char_p( path ), byref( value ) )
1639        if rc != 0 :
1640            self.__mgr.raise_rc( rc, "KConfigReadU64( '%s' )"%( path ), self )
1641        return value.value
1642
1643    def ReadF64( self, path ) :
1644        value = c_double()
1645        rc = self.__mgr.KConfigReadF64( self.__ptr, to_char_p( path ), byref( value ) )
1646        if rc != 0 :
1647            self.__mgr.raise_rc( rc, "KConfigReadF64( '%s' )"%( path ), self )
1648        return value.value
1649
1650    def DisableUserSettings( self ) :
1651        rc = self.__mgr.KConfigDisableUserSettings( self.__ptr )
1652        if rc != 0 :
1653            self.__mgr.raise_rc( rc, "KConfigDisableUserSettings()", self )
1654        return value.value
1655
1656    def MakeRepositoryMgr( self, mode = OpenMode.Read ) :
1657        ptr = c_void_p()
1658        rc = 0
1659        if mode == OpenMode.Read :
1660            rc = self.__mgr.KConfigMakeRepositoryMgrRead( self.__ptr, byref( ptr ) )
1661            if rc != 0 :
1662                self.__mgr.raise_rc( rc, "KConfigMakeRepositoryMgrRead()", self )
1663        else :
1664            rc = self.__mgr.KConfigMakeRepositoryMgrUpdate( self.__ptr, byref( ptr ) )
1665            if rc != 0 :
1666                self.__mgr.raise_rc( rc, "KConfigMakeRepositoryMgrUpdate()", self )
1667        return KRepositoryMgr( self.__mgr, ptr )
1668
1669
1670#------------------------------------------------------------------------------------------------------------
1671class VPath :
1672    def __init__( self, mgr, ptr ) :
1673        self.mgr = __mgr
1674        self.ptr = __ptr
1675
1676    def __str__( self ) :
1677        if self.__ptr :
1678            s = vdb_string( None, 0, 0 )
1679            sp = pointer( s )
1680            rc = VPathMakeString( self.__ptr, byref( sp ) )
1681            if rc != 0 :
1682                self.__mgr.raise_rc( rc, "VPathMakeString()", self )
1683            res = sp.contents.addr
1684            self.__mgr.string_whack( sp.contents )
1685        else :
1686            res = ""
1687        return res
1688
1689
1690#------------------------------------------------------------------------------------------------------------
1691class VResolver :
1692    def __init__( self, mgr, ptr ) :
1693        self.__mgr = mgr
1694        self.__ptr = ptr
1695
1696    def __del__( self ) :
1697        rc = self.__mgr.VResolverRelease( self.__ptr )
1698        if rc != 0 :
1699            self.__mgr.raise_rc( rc, "VResolverRelease()", self )
1700
1701    def __enter__( self ) :
1702        return self
1703
1704    def __exit__( self, type, value, traceback ) :
1705        pass
1706
1707    def QueryLocal( self, path ) :
1708        loc = c_void_p()
1709        rc = self.__mgr.VResolverQuery( self.__ptr, c_int( 0 ), path.__ptr, byref( loc ), 0, 0 )
1710        if rc != 0 :
1711            return vpath( self.__mgr, 0 )
1712        return vpath( self.__mgr, loc )
1713
1714    def QueryRemote( self, path, remote_prot = RemoteProto.Http ) :
1715        rem = c_void_p()
1716        rc = self.__mgr.fVResolverQuery( self.__ptr, c_int( remote_prot ), path.__ptr, 0, byref( rem ), 0 )
1717        if rc != 0 :
1718            return vpath( self.__mgr, 0 )
1719        return vpath( self.__mgr, rem )
1720
1721    def QueryCache( self, path ) :
1722        cache = c_void_p()
1723        rc = self.__mgr.VResolverQuery( self.__ptr, c_int( 0 ), path.__ptr, 0, 0, byref( cache ) )
1724        if rc != 0 :
1725            return vpath( self.__mgr, 0 )
1726        return vpath( self.__mgr, cache )
1727
1728    def RemoteEnable( self, state = ResolvEnable.UseConfig ) :
1729        rc = self.__mgr.VResolverRemoteEnable( self.__ptr, c_int( state ) )
1730        if rc != 0 :
1731            self.__mgr.raise_rc( rc, "VResolverRemoteEnable()", self )
1732
1733
1734#------------------------------------------------------------------------------------------------------------
1735class VFSManager :
1736    def __init__( self, mgr, ptr ) :
1737        self.__mgr = mgr
1738        self.__ptr = ptr
1739
1740    def __del__( self ) :
1741        rc = self.__mgr.VFSManagerRelease( self.__ptr )
1742        if rc != 0 :
1743            self.__mgr.raise_rc( rc, "VFSManagerRelease()", self )
1744
1745    def __enter__( self ) :
1746        return self
1747
1748    def __exit__( self, type, value, traceback ) :
1749        pass
1750
1751    def GetResolver( self ) :
1752        ptr = c_void_p()
1753        rc = self.__mgr.VFSManagerGetResolver( self.__ptr, byref( ptr ) )
1754        if rc != 0 :
1755            self.__mgr.raise_rc( rc, "VFSManagerGetResolver()", self )
1756        return VResolver( self.__mgr, ptr )
1757
1758    def MakeResolver( self, cfg ) :
1759        ptr = c_void_p()
1760        rc = self.__mgr.VFSManagerMakeResolver( self.__ptr, byref( ptr ), cfg.__ptr )
1761        if rc != 0 :
1762            self.__mgr.raise_rc( rc, "VFSManagerMakeResolver()", self )
1763        return VResolver( self.__mgr, ptr )
1764
1765    def MakePath( self, s_path ) :
1766        path = c_void_p()
1767        rc = self.__mgr.VFSManagerMakePath( self.__ptr, byref( path ), to_char_p( s_path ) )
1768        if rc != 0 :
1769            self.__mgr.raise_rc( rc, "VFSManagerMakePath( '%s' )"%( s_paht ), self )
1770        return VPath( self.__mgr, path )
1771
1772
1773#------------------------------------------------------------------------------------------------------------
1774class RefVariation :
1775    def __init__( self, mgr, ptr ) :
1776        self.__mgr = mgr
1777        self.__ptr = ptr
1778
1779    def __del__( self ) :
1780        rc = self.__mgr.RefVariationRelease( self.__ptr )
1781        if rc != 0 :
1782            self.__mgr.raise_rc( rc, "RefVariationRelease()", self )
1783
1784    def __enter__( self ) :
1785        return self
1786
1787    def __exit__( self, type, value, traceback ) :
1788        pass
1789
1790    def GetIUPACSearchQuery( self ) :
1791        txt = c_char_p()
1792        len = c_int()
1793        start = c_int()
1794        rc = self.__mgr.RefVariationGetIUPACSearchQuery( self.__ptr, byref( txt ), byref( len ), byref( start ) )
1795        if rc != 0 :
1796            self.__mgr.raise_rc( rc, "RefVariationGetIUPACSearchQuery()", self )
1797        return ( txt.value, len.value, start.value )
1798
1799    def GetSearchQueryLenOnRef( self ) :
1800        len = c_int()
1801        rc = self.__mgr.RefVariationGetSearchQueryLenOnRef( self.__ptr, byref( len ) )
1802        if rc != 0 :
1803            self.__mgr.raise_rc( rc, "RefVariationGetSearchQueryLenOnRef()", self )
1804        return len.value
1805
1806    def GetAllele( self ) :
1807        txt = c_char_p()
1808        len = c_int()
1809        start = c_int()
1810        rc = self.__mgr.RefVariationGetAllele( self.__ptr, byref( txt ), byref( len ), byref( start ) )
1811        if rc != 0 :
1812            self.__mgr.raise_rc( rc, "RefVariationGetAllele()", self )
1813        return ( txt.value, len.value, start.value )
1814
1815    def GetAlleleLenOnRef( self ) :
1816        len = c_int()
1817        rc = self.__mgr.RefVariationGetAlleleLenOnRef( self.__ptr, byref( len ) )
1818        if rc != 0 :
1819            self.__mgr.raise_rc( rc, "RefVariationGetAlleleLenOnRef()", self )
1820        return len.value
1821
1822
1823#------------------------------------------------------------------------------------------------------------
1824def make_lib_name( mode, prefix = None ) :
1825    libname = None
1826    if platform.system() == "Windows":
1827        libname = "ncbi-wvdb.dll" if mode == OpenMode.Write else "ncbi-vdb.dll"
1828    elif platform.system() == "Darwin":
1829        libname = "libncbi-wvdb.dylib" if mode == OpenMode.Write else "libncbi-vdb.dylib"
1830    elif platform.system() == "Linux" :
1831        libname = "libncbi-wvdb.so" if mode == OpenMode.Write else "libncbi-vdb.so"
1832    if libname == None :
1833        return None
1834    if prefix != None :
1835        return os.path.join( os.path.sep, prefix, libname )
1836    return libname
1837
1838def check_lib_path( mode, path ) :
1839    res = None
1840    if path != None :
1841        if not os.path.isfile( path ) :
1842            raise vdb_error( 0, "lib '%s' does not exist"% path, None )
1843        else :
1844            res = path
1845    else :
1846        res = make_lib_name( mode )
1847        if res == None :
1848            raise vdb_error( 0, "cannot load lib: unknow platform", None )
1849        else :
1850            if not os.path.isfile( res ) :
1851                home_ncbi_lib64 = os.path.join( os.path.sep, os.path.expanduser( "~" ), ".ncbi", "lib64" )
1852                res = make_lib_name( mode, home_ncbi_lib64 )
1853        if not os.path.isfile( res ) :
1854            raise vdb_error( 0, "cannot find lib: '%s'"%path, None )
1855    return res
1856
1857
1858class manager :
1859    def __init__( self, mode = OpenMode.Read, path = None ) :
1860        self.__mode = mode
1861        self.__dir = None
1862        self.__ptr = None
1863
1864        p = check_lib_path( mode, path )
1865        try :
1866            self.__lib = cdll.LoadLibrary( p )
1867        except :
1868            raise vdb_error( 0, "cannot load library '%s'"%p, None )
1869
1870        #we need this one first, because we need it to throw a vdb-error ( used in manager.explain() )
1871        self.string_printf = self.__func__( "string_printf", [ c_void_p, c_int, c_void_p, c_char_p, c_int ] )
1872
1873        self.KDirectoryNativeDir = self.__func__( "KDirectoryNativeDir_v1", [ c_void_p ] )
1874        self.KDirectoryRelease = self.__func__( "KDirectoryRelease_v1", [ c_void_p ] )
1875
1876        self.VDBManagerRelease = self.__func__( "VDBManagerRelease", [ c_void_p ] )
1877        self.VDBManagerVersion = self.__func__( "VDBManagerVersion", [ c_void_p, c_void_p ] )
1878        self.VDBManagerPathType = self.__func__( "VDBManagerPathType", [ c_void_p, c_char_p ] )
1879        self.VDBManagerGetObjVersion = self.__func__( "VDBManagerGetObjVersion", [ c_void_p, c_void_p, c_char_p ] )
1880        self.VDBManagerGetObjModDate = self.__func__( "VDBManagerGetObjModDate", [ c_void_p, c_void_p, c_char_p ] )
1881        self.VDBManagerOpenDBRead = self.__func__( "VDBManagerOpenDBRead", [ c_void_p, c_void_p, c_void_p, c_char_p ] )
1882        self.VDBManagerOpenTableRead = self.__func__( "VDBManagerOpenTableRead", [ c_void_p, c_void_p, c_void_p, c_char_p ] )
1883        self.VDBManagerMakeSchema = self.__func__( "VDBManagerMakeSchema", [ c_void_p, c_void_p ] )
1884
1885        self.VDatabaseOpenDBRead = self.__func__( "VDatabaseOpenDBRead", [ c_void_p, c_void_p, c_char_p ] )
1886        self.VDatabaseRelease = self.__func__( "VDatabaseRelease", [ c_void_p ] )
1887        self.VDatabaseOpenTableRead = self.__func__( "VDatabaseOpenTableRead", [ c_void_p, c_void_p, c_char_p ] )
1888        self.VDatabaseListTbl = self.__func__( "VDatabaseListTbl", [ c_void_p, c_void_p ] )
1889        self.VDatabaseListDB = self.__func__( "VDatabaseListDB", [ c_void_p, c_void_p ] )
1890        self.VDatabaseLocked = self.__func__( "VDatabaseLocked", [ c_void_p ], c_bool )
1891
1892        self.VTableRelease = self.__func__( "VTableRelease", [ c_void_p ] )
1893        self.VTableListCol = self.__func__( "VTableListCol", [ c_void_p, c_void_p ] )
1894        self.VTableCreateCursorRead = self.__func__( "VTableCreateCursorRead", [ c_void_p, c_void_p ] )
1895        self.VTableCreateCachedCursorRead = self.__func__( "VTableCreateCachedCursorRead", [ c_void_p, c_void_p, c_longlong ] )
1896        self.VTableLocked = self.__func__( "VTableLocked", [ c_void_p ], c_bool )
1897        self.VTableOpenKTableRead = self.__func__( "VTableOpenKTableRead", [ c_void_p, c_void_p ] )
1898        self.VTableOpenMetadataRead = self.__func__("VTableOpenMetadataRead", [ c_void_p, c_void_p ] )
1899        self.VTableOpenMetadataUpdate = self.__func__("VTableOpenMetadataUpdate", [ c_void_p, c_void_p ] )
1900
1901        self.KNamelistCount = self.__func__( "KNamelistCount", [ c_void_p, c_void_p ] )
1902        self.KNamelistGet = self.__func__( "KNamelistGet", [ c_void_p, c_int, c_void_p ] )
1903        self.KNamelistRelease = self.__func__( "KNamelistRelease", [ c_void_p ] )
1904
1905        self.VSchemaRelease = self.__func__( "VSchemaRelease", [ c_void_p ] )
1906        self.VSchemaParseText = self.__func__( "VSchemaParseText", [ c_void_p, c_char_p, c_char_p, c_int ] )
1907        self.VSchemaParseFile = self.__func__( "VSchemaParseFile", [ c_void_p, c_char_p ] )
1908        self.VSchemaAddIncludePath = self.__func__( "VSchemaAddIncludePath", [ c_void_p, c_char_p ] )
1909
1910        self.VCursorRelease = self.__func__( "VCursorRelease", [ c_void_p ] )
1911        self.VCursorAddColumn = self.__func__( "VCursorAddColumn", [ c_void_p, c_void_p, c_char_p ] )
1912        self.VCursorOpen = self.__func__( "VCursorOpen", [ c_void_p ] )
1913        self.VCursorDatatype = self.__func__( "VCursorDatatype", [ c_void_p, c_int, c_void_p, c_void_p ] )
1914        self.VCursorCellDataDirect = self.__func__( "VCursorCellDataDirect", [ c_void_p, c_longlong, c_int, c_void_p, c_void_p, c_void_p, c_void_p ] )
1915        self.VCursorCloseRow = self.__func__( "VCursorCloseRow", [ c_void_p ] )
1916        self.VCursorIdRange = self.__func__( "VCursorIdRange", [ c_void_p, c_int, c_void_p, c_void_p ] )
1917        self.VCursorRowId = self.__func__( "VCursorRowId", [ c_void_p, c_void_p ] )
1918        self.VCursorSetRowId = self.__func__( "VCursorSetRowId", [ c_void_p, c_longlong ] )
1919        self.VCursorOpenRow = self.__func__( "VCursorOpenRow", [ c_void_p ] )
1920        self.VCursorFindNextRowIdDirect = self.__func__( "VCursorFindNextRowIdDirect", [ c_void_p, c_int, c_longlong, c_void_p ] )
1921
1922        self.KTableRelease = self.__func__( "KTableRelease", [ c_void_p ] )
1923        self.KTableListIdx = self.__func__( "KTableListIdx", [ c_void_p, c_void_p ] )
1924        self.KTableOpenIndexRead = self.__func__( "KTableOpenIndexRead", [ c_void_p, c_void_p, c_char_p ] )
1925        self.KTableOpenMetadataRead = self.__func__( "KTableOpenMetadataRead", [ c_void_p, c_void_p ] )
1926
1927        self.KIndexRelease = self.__func__( "KIndexRelease", [ c_void_p ] )
1928        self.KIndexVersion = self.__func__( "KIndexVersion", [ c_void_p, c_void_p ] )
1929        self.KIndexType = self.__func__( "KIndexType", [ c_void_p, c_void_p ] )
1930        self.KIndexLocked = self.__func__( "KIndexLocked", [ c_void_p ], c_bool )
1931        self.KIndexFindText = self.__func__( "KIndexFindText", [ c_void_p, c_char_p, c_void_p, c_void_p, c_void_p, c_void_p ] )
1932        self.KIndexProjectText = self.__func__( "KIndexProjectText", [ c_void_p, c_longlong, c_void_p, c_void_p, c_char_p, c_int, c_void_p ] )
1933
1934        self.KMetadataRelease = self.__func__( "KMetadataRelease", [ c_void_p ] )
1935        self.KMetadataVersion = self.__func__( "KMetadataVersion", [ c_void_p, c_void_p ] )
1936        self.KMetadataByteOrder = self.__func__( "KMetadataByteOrder", [ c_void_p, c_void_p ] )
1937        self.KMetadataRevision = self.__func__( "KMetadataRevision", [ c_void_p, c_void_p ] )
1938        self.KMetadataMaxRevision = self.__func__( "KMetadataMaxRevision", [ c_void_p, c_void_p ] )
1939        self.KMetadataOpenRevision = self.__func__( "KMetadataOpenRevision", [ c_void_p, c_void_p, c_int ] )
1940        self.KMetadataGetSequence = self.__func__( "KMetadataGetSequence", [ c_void_p, c_char_p, c_void_p ] )
1941        self.KMetadataOpenNodeRead = self.__func__( "KMetadataOpenNodeRead", [ c_void_p, c_void_p, c_char_p ] )
1942
1943        self.KMDataNodeOpenNodeRead = self.__func__( "KMDataNodeOpenNodeRead", [ c_void_p, c_void_p, c_char_p ] )
1944        self.KMDataNodeRelease = self.__func__( "KMDataNodeRelease", [ c_void_p ] )
1945        self.KMDataNodeListAttr = self.__func__( "KMDataNodeListAttr", [ c_void_p ] )
1946        self.KMDataNodeListChildren = self.__func__( "KMDataNodeListChildren", [ c_void_p ] )
1947        self.KMDataNodeByteOrder = self.__func__( "KMDataNodeByteOrder", [ c_void_p, c_void_p ] )
1948        self.KMDataNodeRead = self.__func__( "KMDataNodeRead", [ c_void_p, c_size_t, c_void_p, c_size_t, c_void_p, c_void_p ] )
1949
1950        if mode == OpenMode.Write :
1951            self.VDBManagerMakeUpdate = self.__func__( "VDBManagerMakeUpdate", [ c_void_p, c_void_p ] )
1952            self.VDBManagerCreateTable = self.__func__( "VDBManagerCreateTable", [ c_void_p, c_void_p, c_void_p, c_char_p, c_int, c_char_p ] )
1953            self.VDBManagerCreateDB = self.__func__( "VDBManagerCreateDB", [ c_void_p, c_void_p, c_void_p, c_char_p, c_int, c_char_p ] )
1954            self.VDBManagerOpenTableUpdate = self.__func__( "VDBManagerOpenTableUpdate", [ c_void_p, c_void_p, c_void_p, c_char_p ] )
1955            self.VDBManagerOpenDBUpdate = self.__func__( "VDBManagerOpenDBUpdate", [ c_void_p, c_void_p, c_void_p, c_char_p ] )
1956
1957            self.VTableCreateCursorWrite = self.__func__( "VTableCreateCursorWrite", [ c_void_p, c_void_p, c_int ] )
1958            self.VTableOpenKTableUpdate = self.__func__( "VTableOpenKTableUpdate", [ c_void_p, c_void_p ] )
1959
1960            self.VCursorCommitRow = self.__func__( "VCursorCommitRow", [ c_void_p ] )
1961            self.VCursorRepeatRow = self.__func__( "VCursorRepeatRow", [ c_void_p, c_longlong ] )
1962            self.VCursorFlushPage = self.__func__( "VCursorFlushPage", [ c_void_p ] )
1963            self.VCursorCommit = self.__func__( "VCursorCommit", [ c_void_p ] )
1964            self.VCursorWrite = self.__func__( "VCursorWrite", [ c_void_p, c_int, c_int, c_void_p, c_int, c_int ] )
1965            self.VCursorDefault = self.__func__( "VCursorDefault", [ c_void_p, c_int, c_int, c_void_p, c_int, c_int ] )
1966
1967            self.VDatabaseCreateDB = self.__func__( "VDatabaseCreateDB", [ c_void_p, c_void_p, c_char_p, c_int, c_char_p ] )
1968            self.VDatabaseOpenTableUpdate = self.__func__( "VDatabaseOpenTableUpdate", [ c_void_p, c_void_p, c_char_p ] )
1969            self.VDatabaseOpenDBUpdate = self.__func__( "VDatabaseOpenDBUpdate", [ c_void_p, c_void_p, c_char_p ] )
1970            self.VDatabaseCreateTable = self.__func__( "VDatabaseCreateTable", [ c_void_p, c_void_p, c_char_p, c_int, c_char_p ] )
1971            self.VDatabaseDropDB = self.__func__( "VDatabaseDropDB", [ c_void_p, c_char_p ] )
1972            self.VDatabaseDropTable = self.__func__( "VDatabaseDropTable", [ c_void_p, c_char_p ] )
1973            self.VDatabaseLock = self.__func__( "VDatabaseLock", [ c_void_p, c_int, c_char_p ] )
1974            self.VDatabaseUnlock = self.__func__( "VDatabaseUnlock", [ c_void_p, c_int, c_char_p ] )
1975
1976            self.KTableCreateIndex = self.__func__( "KTableCreateIndex", [ c_void_p, c_void_p, c_int, c_int, c_char_p ] )
1977            self.KIndexCommit = self.__func__( "KIndexCommit", [ c_void_p ] )
1978            self.KIndexInsertText = self.__func__( "KIndexInsertText", [ c_void_p, c_bool, c_char_p, c_longlong ] )
1979            self.KIndexDeleteText = self.__func__( "KIndexDeleteText", [ c_void_p, c_char_p ] )
1980            self.KIndexInsertU64 = self.__func__( "KIndexInsertU64", [ c_void_p, c_bool, c_longlong, c_longlong, c_longlong, c_longlong ] )
1981            self.KIndexDeleteU64 = self.__func__( "KIndexDeleteU64", [ c_void_p, c_longlong ] )
1982
1983            self.KTableOpenMetadataUpdate = self.__func__( "KTableOpenMetadataUpdate", [ c_void_p, c_void_p ] )
1984
1985            self.KMetadataCommit = self.__func__( "KMetadataCommit", [ c_void_p ] )
1986            self.KMetadataFreeze = self.__func__( "KMetadataFreeze", [ c_void_p ] )
1987            self.KMetadataSetSequence = self.__func__( "KMetadataSetSequence", [ c_void_p, c_char_p, c_longlong ] )
1988            self.KMetadataNextSequence = self.__func__( "KMetadataNextSequence", [ c_void_p, c_char_p, c_void_p ] )
1989            self.KMetadataOpenNodeUpdate = self.__func__( "KMetadataOpenNodeUpdate", [ c_void_p, c_void_p, c_char_p ] )
1990
1991            self.KMDataNodeOpenNodeUpdate = self.__func__( "KMDataNodeOpenNodeUpdate", [ c_void_p, c_void_p, c_char_p ] )
1992            self.KMDataNodeWrite = self.__func__( "KMDataNodeWrite", [ c_void_p, c_void_p, c_size_t ] )
1993            self.KMDataNodeAppend = self.__func__( "KMDataNodeAppend", [ c_void_p, c_void_p, c_size_t ] )
1994
1995        else :
1996            self.VDBManagerMakeRead = self.__func__( "VDBManagerMakeRead", [ c_void_p, c_void_p ] )
1997
1998        self.KConfigMake = self.__func__( "KConfigMake", [ c_void_p, c_void_p ] )
1999        self.KConfigRelease = self.__func__( "KConfigRelease", [ c_void_p ] )
2000        self.KConfigCommit = self.__func__( "KConfigCommit", [ c_void_p ] )
2001        self.KConfigReadBool = self.__func__( "KConfigReadBool", [ c_void_p, c_char_p, c_void_p ] )
2002        self.KConfigWriteBool = self.__func__( "KConfigWriteBool", [ c_void_p, c_char_p, c_bool ] )
2003        self.KConfigReadString = self.__func__( "KConfigReadString", [ c_void_p, c_char_p, c_void_p ] )
2004        self.KConfigWriteString = self.__func__( "KConfigWriteString", [ c_void_p, c_char_p, c_char_p ] )
2005        self.KConfigReadI64 = self.__func__( "KConfigReadI64", [ c_void_p, c_char_p, c_void_p ] )
2006        self.KConfigReadU64 = self.__func__( "KConfigReadU64", [ c_void_p, c_char_p, c_void_p ] )
2007        self.KConfigReadF64 = self.__func__( "KConfigReadF64", [ c_void_p, c_char_p, c_void_p ] )
2008        self.KConfigDisableUserSettings = self.__func__( "KConfigDisableUserSettings", [] )
2009        self.KConfigMakeRepositoryMgrRead = self.__func__( "KConfigMakeRepositoryMgrRead", [ c_void_p, c_void_p ] )
2010        self.KConfigMakeRepositoryMgrUpdate = self.__func__( "KConfigMakeRepositoryMgrUpdate", [ c_void_p, c_void_p ] )
2011
2012        self.KRepositoryMgrRelease = self.__func__( "KRepositoryMgrRelease", [ c_void_p ] )
2013        self.KRepositoryMgrHasRemoteAccess = self.__func__( "KRepositoryMgrHasRemoteAccess", [ c_void_p ], c_bool )
2014        self.KRepositoryMgrUserRepositories = self.__func__( "KRepositoryMgrUserRepositories", [ c_void_p, c_void_p ] )
2015        self.KRepositoryMgrSiteRepositories = self.__func__( "KRepositoryMgrSiteRepositories", [ c_void_p, c_void_p ] )
2016        self.KRepositoryMgrRemoteRepositories = self.__func__( "KRepositoryMgrRemoteRepositories", [ c_void_p, c_void_p ] )
2017        self.KRepositoryMgrCategoryDisabled = self.__func__( "KRepositoryMgrCategoryDisabled", [ c_void_p, c_int ], c_bool )
2018        self.KRepositoryMgrCategorySetDisabled = self.__func__( "KRepositoryMgrCategorySetDisabled", [ c_void_p, c_int, c_bool ] )
2019        self.KRepositoryVectorWhack = self.__func__( "KRepositoryVectorWhack", [ c_void_p ] )
2020        self.KRepositoryAddRef = self.__func__( "KRepositoryAddRef", [ c_void_p ] )
2021        self.KRepositoryRelease = self.__func__( "KRepositoryRelease", [ c_void_p ] )
2022        self.KRepositoryCategory = self.__func__( "KRepositoryCategory", [ c_void_p ] )
2023        self.KRepositorySubCategory = self.__func__( "KRepositorySubCategory", [ c_void_p ] )
2024        self.KRepositoryName = self.__func__( "KRepositoryName", [ c_void_p, c_char_p, c_int, c_void_p ] )
2025        self.KRepositoryDisplayName = self.__func__( "KRepositoryDisplayName", [ c_void_p, c_char_p, c_int, c_void_p ] )
2026        self.KRepositoryRoot = self.__func__( "KRepositoryRoot", [ c_void_p, c_char_p, c_int, c_void_p ] )
2027        self.KRepositorySetRoot = self.__func__( "KRepositorySetRoot", [ c_void_p, c_char_p, c_int ] )
2028        self.KRepositoryResolver = self.__func__( "KRepositoryResolver", [ c_void_p, c_char_p, c_int, c_void_p ] )
2029        self.KRepositoryDisabled = self.__func__( "KRepositoryDisabled", [ c_void_p ], c_bool )
2030        self.KRepositorySetDisabled = self.__func__( "KRepositorySetDisabled", [ c_void_p, c_bool ] )
2031        self.KRepositoryCacheEnabled = self.__func__( "KRepositoryCacheEnabled", [ c_void_p ], c_bool )
2032
2033        self.VFSManagerMake = self.__func__( "VFSManagerMake", [ c_void_p ] )
2034        self.VFSManagerRelease = self.__func__( "VFSManagerRelease", [ c_void_p ] )
2035        self.VFSManagerGetResolver = self.__func__( "VFSManagerGetResolver", [ c_void_p, c_void_p ] )
2036        self.VFSManagerMakeResolver = self.__func__( "VFSManagerMakeResolver", [ c_void_p, c_void_p, c_void_p ] )
2037        self.VFSManagerMakePath = self.__func__( "VFSManagerMakePath", [ c_void_p, c_void_p, c_void_p ] )
2038
2039        self.VResolverRelease = self.__func__( "VResolverRelease", [ c_void_p ] )
2040        self.VResolverQuery = self.__func__( "VResolverQuery", [ c_void_p, c_int, c_void_p, c_void_p, c_void_p, c_void_p ] )
2041        self.VResolverRemoteEnable = self.__func__( "VResolverRemoteEnable", [ c_void_p, c_int ] )
2042
2043        self.RefVariationIUPACMake = self.__func__( "RefVariationIUPACMake", [ c_void_p, c_char_p, c_longlong, c_longlong, c_longlong, c_char_p, c_longlong, c_int ] )
2044        self.RefVariationRelease = self.__func__( "RefVariationRelease", [ c_void_p ] )
2045        self.RefVariationGetIUPACSearchQuery = self.__func__( "RefVariationGetIUPACSearchQuery", [ c_void_p, c_void_p, c_void_p, c_void_p ] )
2046        self.RefVariationGetSearchQueryLenOnRef = self.__func__( "RefVariationGetSearchQueryLenOnRef", [ c_void_p, c_void_p ] )
2047        self.RefVariationGetAllele = self.__func__( "RefVariationGetAllele", [ c_void_p, c_void_p, c_void_p, c_void_p ] )
2048        self.RefVariationGetAlleleLenOnRef = self.__func__( "RefVariationGetAlleleLenOnRef", [ c_void_p, c_void_p ] )
2049
2050        self.ReferenceList_MakeCursor = self.__func__( "ReferenceList_MakeCursor", [ c_void_p, c_void_p, c_int, c_char_p, c_int ] )
2051        self.ReferenceList_MakeTable = self.__func__( "ReferenceList_MakeTable", [ c_void_p, c_void_p, c_int, c_int, c_char_p, c_int ] )
2052        self.ReferenceList_MakeDatabase = self.__func__( "ReferenceList_MakeDatabase", [ c_void_p, c_void_p, c_int, c_int, c_char_p, c_int ] )
2053        self.ReferenceList_MakePath = self.__func__( "ReferenceList_MakePath", [ c_void_p, c_void_p, c_char_p, c_int, c_int, c_char_p, c_int ] )
2054        self.ReferenceList_Release = self.__func__( "ReferenceList_Release", [ c_void_p ] )
2055        self.ReferenceList_Count = self.__func__( "ReferenceList_Count", [ c_void_p, c_void_p ] )
2056        self.ReferenceList_Find = self.__func__( "ReferenceList_Find", [ c_void_p, c_void_p, c_char_p, c_int ] )
2057        self.ReferenceList_Get = self.__func__( "ReferenceList_Get", [ c_void_p, c_void_p, c_int ] )
2058
2059        self.ReferenceObj_Release = self.__func__( "ReferenceObj_Release", [ c_void_p ] )
2060        self.ReferenceObj_Idx = self.__func__( "ReferenceObj_Idx", [ c_void_p, c_void_p ] )
2061        self.ReferenceObj_IdRange = self.__func__( "ReferenceObj_IdRange", [ c_void_p, c_void_p, c_void_p ] )
2062        self.ReferenceObj_Bin = self.__func__( "ReferenceObj_Bin", [ c_void_p, c_void_p ] )
2063        self.ReferenceObj_SeqId = self.__func__( "ReferenceObj_SeqId", [ c_void_p, c_void_p ] )
2064        self.ReferenceObj_Name = self.__func__( "ReferenceObj_Name", [ c_void_p, c_void_p ] )
2065        self.ReferenceObj_SeqLength = self.__func__( "ReferenceObj_SeqLength", [ c_void_p, c_void_p ] )
2066        self.ReferenceObj_Circular = self.__func__( "ReferenceObj_Circular", [ c_void_p, c_void_p ] )
2067        self.ReferenceObj_External = self.__func__( "ReferenceObj_External", [ c_void_p, c_void_p, c_void_p ] )
2068        self.ReferenceObj_Read = self.__func__( "ReferenceObj_Read", [ c_void_p, c_int, c_int, c_void_p, c_void_p ] )
2069        self.ReferenceObj_GetIdCount = self.__func__( "ReferenceObj_GetIdCount", [ c_void_p, c_longlong, c_void_p ] )
2070
2071        self.VPathMakeString = self.__func__( "VPathMakeString", [ c_void_p, c_void_p ] )
2072        self.VectorGet = self.__func__( "VectorGet", [ c_void_p, c_int ], c_void_p )
2073        self.StringWhack = self.__func__( "StringWhack", [ c_void_p ] )
2074
2075        self.__dir = self.__make_native_dir__()
2076        self.__ptr = self.__make_mgr__( mode )
2077
2078
2079    def __del__( self ) :
2080        if self.__ptr != None :
2081            if self.VDBManagerRelease != None :
2082                self.VDBManagerRelease( self.__ptr )
2083        if self.__dir != None :
2084            if self.KDirectoryRelease != None :
2085                self.KDirectoryRelease( self.__dir )
2086
2087    def __enter__( self ) :
2088        return self
2089
2090    def __exit__( self, type, value, traceback ) :
2091        pass
2092
2093    def string_whack( self, str ) :
2094        self.StringWhack( byref( str ) )
2095
2096    def __make_native_dir__( self ) :
2097        res = c_void_p()
2098        if self.KDirectoryNativeDir == None :
2099            raise "'KDirectoryNativeDir' not found in lib"
2100        else :
2101            rc = self.KDirectoryNativeDir( byref( res ) )
2102            if rc != 0 :
2103                self.raise_rc( rc, "KDirectoryNativeDir()", self )
2104        return res;
2105
2106    def __make_mgr__( self, mode ) :
2107        res = c_void_p()
2108        if mode == OpenMode.Write :
2109            rc = self.VDBManagerMakeUpdate( byref( res ), self.__dir )
2110        else :
2111            rc = self.VDBManagerMakeRead( byref( res ), self.__dir )
2112        if rc != 0 :
2113            self.raise_rc( rc, "make_mgr()", self )
2114        return res
2115
2116    def __func__( self, name, argt, rest = c_int ) :
2117        res = None
2118        try :
2119            res = getattr( self.__lib, name )
2120            res.argtypes = argt
2121            res.restype = rest
2122        except :
2123            pass
2124        return res
2125
2126    def explain( self, rc ) :
2127        buffer = create_string_buffer( 1024 )
2128        num_writ = c_int( 0 )
2129        fmt = create_string_buffer( to_bytes( "%R" ) )
2130        if self.string_printf( buffer, c_int( 1024 ), byref( num_writ ), fmt, c_int( rc ) ) == 0 :
2131            if PY3 :
2132                return buffer.value.decode( "utf-8" )
2133            return buffer.value
2134        return "cannot explain %d"%( rc )
2135
2136    def raise_rc( self, rc, funcname, obj ) :
2137        msg = "%s -> %s"%( funcname, self.explain( rc ) )
2138        raise vdb_error( rc, msg, obj )
2139
2140    def Version( self ) :
2141        vers = c_int( 0 )
2142        rc = self.VDBManagerVersion( self.__ptr, byref( vers ) )
2143        if rc != 0 :
2144            self.raise_rc( rc, "version()", self )
2145        return version( vers.value )
2146
2147    def writable( self ) :
2148        return self.__mode == OpenMode.Write
2149
2150    def PathType( self, path ) :
2151        return PathType( self.VDBManagerPathType( self.__ptr, to_char_p( path ) ) )
2152
2153    def GetObjVersion( self, path ) :
2154        vers = c_int()
2155        rc = self.VDBManagerGetObjVersion( self.__ptr, byref( vers ), to_char_p( path ) )
2156        if rc != 0 :
2157            self.raise_rc( rc, "obj_vers( '%s' )"%( path ), self )
2158        return version( vers.value )
2159
2160    def GetObjModDate( self, path ) :
2161        t = c_int()
2162        rc = self.VDBManagerGetObjModDate( self.__ptr, byref( t ), to_char_p( path ) )
2163        if rc != 0 :
2164            self.raise_rc( rc, "obj_time( '%s' )"%( path ), self )
2165        return datetime.datetime.fromtimestamp( t.value )
2166
2167    def OpenDB( self, path, writable = False, schema = None ) :
2168        f = self.VDBManagerOpenDBUpdate if writable else self.VDBManagerOpenDBRead
2169        db = c_void_p()
2170        vdb_schema_ptr = schema.__ptr if schema != None else c_void_p( 0 )
2171        rc = f( self.__ptr, byref( db ), vdb_schema_ptr, to_char_p( path ) )
2172        if rc != 0 :
2173            self.raise_rc( rc, "open_db( %s )"%( path ), self )
2174        return VDatabase( self, db, path )
2175
2176    def OpenTable( self, path, writable = False, schema = None ) :
2177        f = self.VDBManagerOpenTableUpdate if writable else self.VDBManagerOpenTableRead
2178        tab = c_void_p()
2179        vdb_schema_ptr = schema.__ptr if schema != None else c_void_p( 0 )
2180        rc = f( self.__ptr, byref( tab ), vdb_schema_ptr, to_char_p( path ) )
2181        if rc != 0 :
2182            self.raise_rc( rc, "VDBManagerOpenTable( %s )"%( path ), self )
2183        return VTable( self, tab, path )
2184
2185    def CreateDB( self, schema, spec, path = None, mode = CreateMode.Init ) :
2186        if schema == None :
2187            raise vdb_error( "CreateDB(): schema missing", self, 0 )
2188        if spec == None :
2189            raise vdb_error( "CreateDB(): spec missing", self, 0 )
2190        db = c_void_p()
2191        px = path if path != None else spec
2192        p = to_char_p( px )
2193        rc = self.VDBManagerCreateDB( self.__ptr, byref( db ), schema._VSchema__ptr, to_char_p( spec ), c_int( mode.value ), p )
2194        if rc != 0 :
2195            self.raise_rc( rc, "vdb_manger.VDBManagerCreateDB( %s )"%( px ), self )
2196        return VDatabase( self, db, px )
2197
2198    def CreateTable( self, schema, spec, path = None, mode = CreateMode.Init ) :
2199        if schema == None :
2200            raise vdb_error( "CreateTable(): schema missing", self, 0 )
2201        if spec == None :
2202            raise vdb_error( "CreateTable(): spec missing", self, 0 )
2203        tab = c_void_p()
2204        px = path if path != None else spec
2205        p = to_char_p( px )
2206        rc = self.VDBManagerCreateTable( self.__ptr, byref( tab ), schema._VSchema__ptr, to_char_p( spec ), c_int( mode.value ), p )
2207        if rc != 0 :
2208            self.raise_rc( rc, "VDBManagerCreateTable( %s )"%( px ), self )
2209        return VTable( self, tab, px )
2210
2211    def MakeSchema( self, schema_text = None ) :
2212        vdb_schema_ptr = c_void_p()
2213        rc = self.VDBManagerMakeSchema( self.__ptr, byref( vdb_schema_ptr ) )
2214        if rc != 0 :
2215            self.raise_rc( rc, "VDBManagerMakeSchema()", self )
2216        res = VSchema( self, vdb_schema_ptr )
2217        if schema_text != None :
2218            res.ParseText( schema_text )
2219        return res
2220
2221    def MakeKConfig( self ) :
2222        ptr = c_void_p()
2223        rc = self.KConfigMake( byref( ptr ), c_void_p( 0 ) )
2224        if rc != 0 :
2225            self.raise_rc( rc, "KConfigMake()", self )
2226        return KConfig( self, ptr )
2227
2228    def MakeVFSManager( self ) :
2229        ptr = c_void_p()
2230        rc = self.VFSManagerMake( byref( ptr ) )
2231        if rc != 0 :
2232            self.raise_rc( rc, "VFSManagerMake()", self )
2233        return VFSManager( self, ptr )
2234
2235    def ReferenceList( self, path, options = 2 ) :
2236        ptr = c_void_p()
2237        rc = self.ReferenceList_MakePath( byref( ptr ), self.__ptr, to_char_p( path ), c_int( options ), c_int( 0 ), c_char_p( 0 ), c_int( 0 ) )
2238        if rc != 0 :
2239            self.raise_rc( rc, "ReferenceList_MakePath( '%s' )" % path, self )
2240        return ReferenceList( self, ptr )
2241
2242    def RefVariation( self, ref_bases, del_pos, del_len, insertion, algo = 2 ) :
2243        ptr = c_void_p()
2244        ref = to_char_p( ref_bases )
2245        ref_len = c_longlong( len( ref_bases ) )
2246        ins = to_char_p( insertion )
2247        ins_len = c_longlong( len( insertion ) )
2248        rc = self.RefVariationIUPACMake( byref( ptr ), ref, ref_len, c_longlong( del_pos ), c_longlong( del_len ), ins, ins_len, c_int( algo ) )
2249        if rc != 0 :
2250            self.raise_rc( rc, "RefVariationIUPACMake( %s )"%( ref_bases ), self )
2251        return RefVariation( self, ptr )
2252