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              :         "context"
       9              : 
      10              :         "github.com/cockroachdb/pebble/internal/base"
      11              :         "github.com/cockroachdb/pebble/internal/keyspan"
      12              :         "github.com/cockroachdb/pebble/internal/treeprinter"
      13              : )
      14              : 
      15              : type errorIter struct {
      16              :         err error
      17              : }
      18              : 
      19              : // errorIter implements the base.InternalIterator interface.
      20              : var _ internalIterator = (*errorIter)(nil)
      21              : 
      22            1 : func (c *errorIter) SeekGE(key []byte, flags base.SeekGEFlags) *base.InternalKV {
      23            1 :         return nil
      24            1 : }
      25              : 
      26            1 : func (c *errorIter) SeekPrefixGE(prefix, key []byte, flags base.SeekGEFlags) *base.InternalKV {
      27            1 :         return c.SeekPrefixGEStrict(prefix, key, flags)
      28            1 : }
      29              : 
      30              : func (c *errorIter) SeekPrefixGEStrict(
      31              :         prefix, key []byte, flags base.SeekGEFlags,
      32            1 : ) *base.InternalKV {
      33            1 :         return nil
      34            1 : }
      35              : 
      36            1 : func (c *errorIter) SeekLT(key []byte, flags base.SeekLTFlags) *base.InternalKV {
      37            1 :         return nil
      38            1 : }
      39              : 
      40            1 : func (c *errorIter) First() *base.InternalKV {
      41            1 :         return nil
      42            1 : }
      43              : 
      44            1 : func (c *errorIter) Last() *base.InternalKV {
      45            1 :         return nil
      46            1 : }
      47              : 
      48            1 : func (c *errorIter) Next() *base.InternalKV {
      49            1 :         return nil
      50            1 : }
      51              : 
      52            1 : func (c *errorIter) Prev() *base.InternalKV {
      53            1 :         return nil
      54            1 : }
      55              : 
      56            0 : func (c *errorIter) NextPrefix([]byte) *base.InternalKV {
      57            0 :         return nil
      58            0 : }
      59              : 
      60            1 : func (c *errorIter) Error() error {
      61            1 :         return c.err
      62            1 : }
      63              : 
      64            1 : func (c *errorIter) Close() error {
      65            1 :         return c.err
      66            1 : }
      67              : 
      68            0 : func (c *errorIter) String() string {
      69            0 :         return "error"
      70            0 : }
      71              : 
      72            1 : func (c *errorIter) SetBounds(lower, upper []byte) {}
      73              : 
      74            0 : func (c *errorIter) SetContext(_ context.Context) {}
      75              : 
      76            0 : func (c *errorIter) DebugTree(tp treeprinter.Node) {
      77            0 :         tp.Childf("%T(%p)", c, c)
      78            0 : }
      79              : 
      80              : type errorKeyspanIter struct {
      81              :         err error
      82              : }
      83              : 
      84              : // errorKeyspanIter implements the keyspan.FragmentIterator interface.
      85              : var _ keyspan.FragmentIterator = (*errorKeyspanIter)(nil)
      86              : 
      87            1 : func (i *errorKeyspanIter) SeekGE(key []byte) (*keyspan.Span, error) { return nil, i.err }
      88            1 : func (i *errorKeyspanIter) SeekLT(key []byte) (*keyspan.Span, error) { return nil, i.err }
      89            1 : func (i *errorKeyspanIter) First() (*keyspan.Span, error)            { return nil, i.err }
      90            1 : func (i *errorKeyspanIter) Last() (*keyspan.Span, error)             { return nil, i.err }
      91            0 : func (i *errorKeyspanIter) Next() (*keyspan.Span, error)             { return nil, i.err }
      92            0 : func (i *errorKeyspanIter) Prev() (*keyspan.Span, error)             { return nil, i.err }
      93            0 : func (i *errorKeyspanIter) SetContext(ctx context.Context)           {}
      94            1 : func (i *errorKeyspanIter) Close()                                   {}
      95            0 : func (*errorKeyspanIter) String() string                             { return "error" }
      96            0 : func (*errorKeyspanIter) WrapChildren(wrap keyspan.WrapFn)           {}
      97            0 : func (i *errorKeyspanIter) DebugTree(tp treeprinter.Node)            { tp.Childf("%T(%p)", i, i) }