github.com/cellofellow/gopkg@v0.0.0-20140722061823-eec0544a62ad/database/leveldb/capi_helper.go (about)

     1  // Copyright 2013 <chaishushan{AT}gmail.com>. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package leveldb
     6  
     7  import "C"
     8  import (
     9  	"errors"
    10  	"strings"
    11  	"sync"
    12  	"unsafe"
    13  )
    14  
    15  func minInt(a, b int) int {
    16  	if a <= b {
    17  		return a
    18  	}
    19  	return b
    20  }
    21  
    22  /* Error types */
    23  var (
    24  	ErrNotFound        = errors.New("leveldb: not found")
    25  	ErrCorruption      = errors.New("leveldb: corruption")
    26  	ErrNotImplemented  = errors.New("leveldb: not implemented")
    27  	ErrInvalidArgument = errors.New("leveldb: invalid argument")
    28  	ErrIO              = errors.New("leveldb: IO error")
    29  	ErrUnknown         = errors.New("leveldb: unknown")
    30  )
    31  
    32  func leveldb_error(e string) error {
    33  	if e == "" || e == "OK" {
    34  		return nil
    35  	}
    36  	if strings.HasPrefix(e, "NotFound:") {
    37  		return ErrNotFound
    38  	}
    39  	if strings.HasPrefix(e, "Corruption:") {
    40  		return ErrCorruption
    41  	}
    42  	if strings.HasPrefix(e, "Not implemented:") {
    43  		return ErrNotImplemented
    44  	}
    45  	if strings.HasPrefix(e, "Invalid argument:") {
    46  		return ErrInvalidArgument
    47  	}
    48  	if strings.HasPrefix(e, "IO error:") {
    49  		return ErrIO
    50  	}
    51  	return ErrUnknown
    52  }
    53  
    54  /* Write batch */
    55  
    56  type leveldb_writebatch_iterate_state_t struct {
    57  	put func(key, val []byte)
    58  	del func(key []byte)
    59  }
    60  
    61  // Avoid GC
    62  var leveldb_writebatch_iterate_state_list []*leveldb_writebatch_iterate_state_t
    63  var leveldb_writebatch_iterate_state_mutex sync.Mutex
    64  
    65  func leveldb_writebatch_iterate_state_create(
    66  	put func(key, val []byte),
    67  	del func(key []byte),
    68  ) unsafe.Pointer {
    69  	leveldb_writebatch_iterate_state_mutex.Lock()
    70  	defer leveldb_writebatch_iterate_state_mutex.Unlock()
    71  	p := &leveldb_writebatch_iterate_state_t{put: put, del: del}
    72  	leveldb_writebatch_iterate_state_list = append(leveldb_writebatch_iterate_state_list, p)
    73  	return unsafe.Pointer(p)
    74  }
    75  
    76  /* Comparator */
    77  
    78  type leveldb_comparator_create_state_t struct {
    79  	destructor func()
    80  	compare    func(a, b []byte) int
    81  	name       func() string
    82  	cname      *C.char
    83  }
    84  
    85  // Avoid GC
    86  var leveldb_comparator_create_state_list []*leveldb_comparator_create_state_t
    87  var leveldb_comparator_create_state_mutex sync.Mutex
    88  
    89  func leveldb_comparator_create_state_create(
    90  	destructor func(),
    91  	compare func(a, b []byte) int,
    92  	name func() string,
    93  ) unsafe.Pointer {
    94  	leveldb_comparator_create_state_mutex.Lock()
    95  	defer leveldb_comparator_create_state_mutex.Unlock()
    96  	cname := C.CString(name())
    97  	p := &leveldb_comparator_create_state_t{
    98  		destructor: destructor,
    99  		compare:    compare,
   100  		name:       name,
   101  		cname:      cname,
   102  	}
   103  	leveldb_comparator_create_state_list = append(leveldb_comparator_create_state_list, p)
   104  	return unsafe.Pointer(p)
   105  }
   106  
   107  /* Filter policy */
   108  
   109  type leveldb_filterpolicy_create_state_t struct {
   110  	destructor    func()
   111  	free_filter   func()
   112  	create_filter func(keys [][]byte) []byte
   113  	key_may_match func(key, filter []byte) bool
   114  	name          func() string
   115  	cname         *C.char
   116  	cfilter       *C.char
   117  	cfilter_len   C.int
   118  }
   119  
   120  // Avoid GC
   121  var leveldb_filterpolicy_create_state_list []*leveldb_filterpolicy_create_state_t
   122  var leveldb_filterpolicy_create_state_mutex sync.Mutex
   123  
   124  func leveldb_filterpolicy_create_state_create(
   125  	destructor func(),
   126  	create_filter func(keys [][]byte) []byte,
   127  	key_may_match func(key, filter []byte) bool,
   128  	name func() string,
   129  ) unsafe.Pointer {
   130  	leveldb_filterpolicy_create_state_mutex.Lock()
   131  	defer leveldb_filterpolicy_create_state_mutex.Unlock()
   132  	cname := C.CString(name())
   133  	p := &leveldb_filterpolicy_create_state_t{
   134  		destructor:    destructor,
   135  		create_filter: create_filter,
   136  		key_may_match: key_may_match,
   137  		name:          name,
   138  		cname:         cname,
   139  	}
   140  	leveldb_filterpolicy_create_state_list = append(leveldb_filterpolicy_create_state_list, p)
   141  	return unsafe.Pointer(p)
   142  }