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) }