Line data    Source code

       1             : // Copyright 2018 The LevelDB-Go and Pebble Authors. All rights reserved. Use
       2             : // of this source code is governed by a BSD-style license that can be found in
       3             : // the LICENSE file.
       4             : 
       5             : package pebble
       6             : 
       7             : import (
       8             :         "github.com/cockroachdb/pebble/internal/base"
       9             :         "github.com/cockroachdb/pebble/internal/keyspan"
      10             : )
      11             : 
      12             : type errorIter struct {
      13             :         err error
      14             : }
      15             : 
      16             : // errorIter implements the base.InternalIterator interface.
      17             : var _ internalIterator = (*errorIter)(nil)
      18             : 
      19           0 : func newErrorIter(err error) *errorIter {
      20           0 :         return &errorIter{err: err}
      21           0 : }
      22             : 
      23           2 : func (c *errorIter) SeekGE(key []byte, flags base.SeekGEFlags) (*InternalKey, base.LazyValue) {
      24           2 :         return nil, base.LazyValue{}
      25           2 : }
      26             : 
      27             : func (c *errorIter) SeekPrefixGE(
      28             :         prefix, key []byte, flags base.SeekGEFlags,
      29           2 : ) (*base.InternalKey, base.LazyValue) {
      30           2 :         return nil, base.LazyValue{}
      31           2 : }
      32             : 
      33           2 : func (c *errorIter) SeekLT(key []byte, flags base.SeekLTFlags) (*InternalKey, base.LazyValue) {
      34           2 :         return nil, base.LazyValue{}
      35           2 : }
      36             : 
      37           2 : func (c *errorIter) First() (*InternalKey, base.LazyValue) {
      38           2 :         return nil, base.LazyValue{}
      39           2 : }
      40             : 
      41           2 : func (c *errorIter) Last() (*InternalKey, base.LazyValue) {
      42           2 :         return nil, base.LazyValue{}
      43           2 : }
      44             : 
      45           2 : func (c *errorIter) Next() (*InternalKey, base.LazyValue) {
      46           2 :         return nil, base.LazyValue{}
      47           2 : }
      48             : 
      49           2 : func (c *errorIter) Prev() (*InternalKey, base.LazyValue) {
      50           2 :         return nil, base.LazyValue{}
      51           2 : }
      52             : 
      53           0 : func (c *errorIter) NextPrefix([]byte) (*InternalKey, base.LazyValue) {
      54           0 :         return nil, base.LazyValue{}
      55           0 : }
      56             : 
      57           2 : func (c *errorIter) Error() error {
      58           2 :         return c.err
      59           2 : }
      60             : 
      61           2 : func (c *errorIter) Close() error {
      62           2 :         return c.err
      63           2 : }
      64             : 
      65           0 : func (c *errorIter) String() string {
      66           0 :         return "error"
      67           0 : }
      68             : 
      69           2 : func (c *errorIter) SetBounds(lower, upper []byte) {}
      70             : 
      71             : type errorKeyspanIter struct {
      72             :         err error
      73             : }
      74             : 
      75             : // errorKeyspanIter implements the keyspan.FragmentIterator interface.
      76             : var _ keyspan.FragmentIterator = (*errorKeyspanIter)(nil)
      77             : 
      78           0 : func newErrorKeyspanIter(err error) *errorKeyspanIter {
      79           0 :         return &errorKeyspanIter{err: err}
      80           0 : }
      81             : 
      82           2 : func (*errorKeyspanIter) SeekGE(key []byte) *keyspan.Span { return nil }
      83           2 : func (*errorKeyspanIter) SeekLT(key []byte) *keyspan.Span { return nil }
      84           2 : func (*errorKeyspanIter) First() *keyspan.Span            { return nil }
      85           2 : func (*errorKeyspanIter) Last() *keyspan.Span             { return nil }
      86           0 : func (*errorKeyspanIter) Next() *keyspan.Span             { return nil }
      87           0 : func (*errorKeyspanIter) Prev() *keyspan.Span             { return nil }
      88           1 : func (i *errorKeyspanIter) Error() error                  { return i.err }
      89           2 : func (i *errorKeyspanIter) Close() error                  { return i.err }
      90           0 : func (*errorKeyspanIter) String() string                  { return "error" }