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             : )
      13             : 
      14             : type errorIter struct {
      15             :         err error
      16             : }
      17             : 
      18             : // errorIter implements the base.InternalIterator interface.
      19             : var _ internalIterator = (*errorIter)(nil)
      20             : 
      21           1 : func (c *errorIter) SeekGE(key []byte, flags base.SeekGEFlags) (*InternalKey, base.LazyValue) {
      22           1 :         return nil, base.LazyValue{}
      23           1 : }
      24             : 
      25             : func (c *errorIter) SeekPrefixGE(
      26             :         prefix, key []byte, flags base.SeekGEFlags,
      27           1 : ) (*base.InternalKey, base.LazyValue) {
      28           1 :         return nil, base.LazyValue{}
      29           1 : }
      30             : 
      31           1 : func (c *errorIter) SeekLT(key []byte, flags base.SeekLTFlags) (*InternalKey, base.LazyValue) {
      32           1 :         return nil, base.LazyValue{}
      33           1 : }
      34             : 
      35           1 : func (c *errorIter) First() (*InternalKey, base.LazyValue) {
      36           1 :         return nil, base.LazyValue{}
      37           1 : }
      38             : 
      39           1 : func (c *errorIter) Last() (*InternalKey, base.LazyValue) {
      40           1 :         return nil, base.LazyValue{}
      41           1 : }
      42             : 
      43           1 : func (c *errorIter) Next() (*InternalKey, base.LazyValue) {
      44           1 :         return nil, base.LazyValue{}
      45           1 : }
      46             : 
      47           1 : func (c *errorIter) Prev() (*InternalKey, base.LazyValue) {
      48           1 :         return nil, base.LazyValue{}
      49           1 : }
      50             : 
      51           0 : func (c *errorIter) NextPrefix([]byte) (*InternalKey, base.LazyValue) {
      52           0 :         return nil, base.LazyValue{}
      53           0 : }
      54             : 
      55           1 : func (c *errorIter) Error() error {
      56           1 :         return c.err
      57           1 : }
      58             : 
      59           1 : func (c *errorIter) Close() error {
      60           1 :         return c.err
      61           1 : }
      62             : 
      63           0 : func (c *errorIter) String() string {
      64           0 :         return "error"
      65           0 : }
      66             : 
      67           1 : func (c *errorIter) SetBounds(lower, upper []byte) {}
      68             : 
      69           0 : func (c *errorIter) SetContext(_ context.Context) {}
      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           1 : func (i *errorKeyspanIter) SeekGE(key []byte) (*keyspan.Span, error) { return nil, i.err }
      79           1 : func (i *errorKeyspanIter) SeekLT(key []byte) (*keyspan.Span, error) { return nil, i.err }
      80           1 : func (i *errorKeyspanIter) First() (*keyspan.Span, error)            { return nil, i.err }
      81           1 : func (i *errorKeyspanIter) Last() (*keyspan.Span, error)             { return nil, i.err }
      82           0 : func (i *errorKeyspanIter) Next() (*keyspan.Span, error)             { return nil, i.err }
      83           0 : func (i *errorKeyspanIter) Prev() (*keyspan.Span, error)             { return nil, i.err }
      84           1 : func (i *errorKeyspanIter) Close() error                             { return i.err }
      85           0 : func (*errorKeyspanIter) String() string                             { return "error" }
      86           0 : func (*errorKeyspanIter) WrapChildren(wrap keyspan.WrapFn)           {}