array_iter.go

Documentation: github.com/syndtr/goleveldb/leveldb/iterator

     1  // Copyright (c) 2014, Suryandaru Triandana <syndtr@gmail.com>
     2  // All rights reserved.
     3  //
     4  // Use of this source code is governed by a BSD-style license that can be
     5  // found in the LICENSE file.
     6  
     7  package iterator
     8  
     9  import (
    10  	"github.com/syndtr/goleveldb/leveldb/util"
    11  )
    12  
    13  // BasicArray is the interface that wraps basic Len and Search method.
    14  type BasicArray interface {
    15  	// Len returns length of the array.
    16  	Len() int
    17  
    18  	// Search finds smallest index that point to a key that is greater
    19  	// than or equal to the given key.
    20  	Search(key []byte) int
    21  }
    22  
    23  // Array is the interface that wraps BasicArray and basic Index method.
    24  type Array interface {
    25  	BasicArray
    26  
    27  	// Index returns key/value pair with index of i.
    28  	Index(i int) (key, value []byte)
    29  }
    30  
    31  // Array is the interface that wraps BasicArray and basic Get method.
    32  type ArrayIndexer interface {
    33  	BasicArray
    34  
    35  	// Get returns a new data iterator with index of i.
    36  	Get(i int) Iterator
    37  }
    38  
    39  type basicArrayIterator struct {
    40  	util.BasicReleaser
    41  	array BasicArray
    42  	pos   int
    43  	err   error
    44  }
    45  
    46  func (i *basicArrayIterator) Valid() bool {
    47  	return i.pos >= 0 && i.pos < i.array.Len() && !i.Released()
    48  }
    49  
    50  func (i *basicArrayIterator) First() bool {
    51  	if i.Released() {
    52  		i.err = ErrIterReleased
    53  		return false
    54  	}
    55  
    56  	if i.array.Len() == 0 {
    57  		i.pos = -1
    58  		return false
    59  	}
    60  	i.pos = 0
    61  	return true
    62  }
    63  
    64  func (i *basicArrayIterator) Last() bool {
    65  	if i.Released() {
    66  		i.err = ErrIterReleased
    67  		return false
    68  	}
    69  
    70  	n := i.array.Len()
    71  	if n == 0 {
    72  		i.pos = 0
    73  		return false
    74  	}
    75  	i.pos = n - 1
    76  	return true
    77  }
    78  
    79  func (i *basicArrayIterator) Seek(key []byte) bool {
    80  	if i.Released() {
    81  		i.err = ErrIterReleased
    82  		return false
    83  	}
    84  
    85  	n := i.array.Len()
    86  	if n == 0 {
    87  		i.pos = 0
    88  		return false
    89  	}
    90  	i.pos = i.array.Search(key)
    91  	return i.pos < n
    92  }
    93  
    94  func (i *basicArrayIterator) Next() bool {
    95  	if i.Released() {
    96  		i.err = ErrIterReleased
    97  		return false
    98  	}
    99  
   100  	i.pos++
   101  	if n := i.array.Len(); i.pos >= n {
   102  		i.pos = n
   103  		return false
   104  	}
   105  	return true
   106  }
   107  
   108  func (i *basicArrayIterator) Prev() bool {
   109  	if i.Released() {
   110  		i.err = ErrIterReleased
   111  		return false
   112  	}
   113  
   114  	i.pos--
   115  	if i.pos < 0 {
   116  		i.pos = -1
   117  		return false
   118  	}
   119  	return true
   120  }
   121  
   122  func (i *basicArrayIterator) Error() error { return i.err }
   123  
   124  type arrayIterator struct {
   125  	basicArrayIterator
   126  	array      Array
   127  	pos        int
   128  	key, value []byte
   129  }
   130  
   131  func (i *arrayIterator) updateKV() {
   132  	if i.pos == i.basicArrayIterator.pos {
   133  		return
   134  	}
   135  	i.pos = i.basicArrayIterator.pos
   136  	if i.Valid() {
   137  		i.key, i.value = i.array.Index(i.pos)
   138  	} else {
   139  		i.key = nil
   140  		i.value = nil
   141  	}
   142  }
   143  
   144  func (i *arrayIterator) Key() []byte {
   145  	i.updateKV()
   146  	return i.key
   147  }
   148  
   149  func (i *arrayIterator) Value() []byte {
   150  	i.updateKV()
   151  	return i.value
   152  }
   153  
   154  type arrayIteratorIndexer struct {
   155  	basicArrayIterator
   156  	array ArrayIndexer
   157  }
   158  
   159  func (i *arrayIteratorIndexer) Get() Iterator {
   160  	if i.Valid() {
   161  		return i.array.Get(i.basicArrayIterator.pos)
   162  	}
   163  	return nil
   164  }
   165  
   166  // NewArrayIterator returns an iterator from the given array.
   167  func NewArrayIterator(array Array) Iterator {
   168  	return &arrayIterator{
   169  		basicArrayIterator: basicArrayIterator{array: array, pos: -1},
   170  		array:              array,
   171  		pos:                -1,
   172  	}
   173  }
   174  
   175  // NewArrayIndexer returns an index iterator from the given array.
   176  func NewArrayIndexer(array ArrayIndexer) IteratorIndexer {
   177  	return &arrayIteratorIndexer{
   178  		basicArrayIterator: basicArrayIterator{array: array, pos: -1},
   179  		array:              array,
   180  	}
   181  }
   182
View as plain text