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