LCOV - code coverage report
Current view: top level - pebble - error_iter.go (source / functions) Hit Total Coverage
Test: 2023-11-20 08:16Z b9be64b8 - tests + meta.lcov Lines: 34 50 68.0 %
Date: 2023-11-20 08:17:03 Functions: 0 0 -

          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           0 : func newErrorIter(err error) *errorIter {
      22           0 :         return &errorIter{err: err}
      23           0 : }
      24             : 
      25           2 : func (c *errorIter) SeekGE(key []byte, flags base.SeekGEFlags) (*InternalKey, base.LazyValue) {
      26           2 :         return nil, base.LazyValue{}
      27           2 : }
      28             : 
      29             : func (c *errorIter) SeekPrefixGE(
      30             :         prefix, key []byte, flags base.SeekGEFlags,
      31           2 : ) (*base.InternalKey, base.LazyValue) {
      32           2 :         return nil, base.LazyValue{}
      33           2 : }
      34             : 
      35           2 : func (c *errorIter) SeekLT(key []byte, flags base.SeekLTFlags) (*InternalKey, base.LazyValue) {
      36           2 :         return nil, base.LazyValue{}
      37           2 : }
      38             : 
      39           2 : func (c *errorIter) First() (*InternalKey, base.LazyValue) {
      40           2 :         return nil, base.LazyValue{}
      41           2 : }
      42             : 
      43           2 : func (c *errorIter) Last() (*InternalKey, base.LazyValue) {
      44           2 :         return nil, base.LazyValue{}
      45           2 : }
      46             : 
      47           2 : func (c *errorIter) Next() (*InternalKey, base.LazyValue) {
      48           2 :         return nil, base.LazyValue{}
      49           2 : }
      50             : 
      51           2 : func (c *errorIter) Prev() (*InternalKey, base.LazyValue) {
      52           2 :         return nil, base.LazyValue{}
      53           2 : }
      54             : 
      55           0 : func (c *errorIter) NextPrefix([]byte) (*InternalKey, base.LazyValue) {
      56           0 :         return nil, base.LazyValue{}
      57           0 : }
      58             : 
      59           2 : func (c *errorIter) Error() error {
      60           2 :         return c.err
      61           2 : }
      62             : 
      63           2 : func (c *errorIter) Close() error {
      64           2 :         return c.err
      65           2 : }
      66             : 
      67           0 : func (c *errorIter) String() string {
      68           0 :         return "error"
      69           0 : }
      70             : 
      71           2 : func (c *errorIter) SetBounds(lower, upper []byte) {}
      72             : 
      73           0 : func (c *errorIter) SetContext(_ context.Context) {}
      74             : 
      75             : type errorKeyspanIter struct {
      76             :         err error
      77             : }
      78             : 
      79             : // errorKeyspanIter implements the keyspan.FragmentIterator interface.
      80             : var _ keyspan.FragmentIterator = (*errorKeyspanIter)(nil)
      81             : 
      82           0 : func newErrorKeyspanIter(err error) *errorKeyspanIter {
      83           0 :         return &errorKeyspanIter{err: err}
      84           0 : }
      85             : 
      86           2 : func (*errorKeyspanIter) SeekGE(key []byte) *keyspan.Span { return nil }
      87           2 : func (*errorKeyspanIter) SeekLT(key []byte) *keyspan.Span { return nil }
      88           2 : func (*errorKeyspanIter) First() *keyspan.Span            { return nil }
      89           2 : func (*errorKeyspanIter) Last() *keyspan.Span             { return nil }
      90           0 : func (*errorKeyspanIter) Next() *keyspan.Span             { return nil }
      91           0 : func (*errorKeyspanIter) Prev() *keyspan.Span             { return nil }
      92           1 : func (i *errorKeyspanIter) Error() error                  { return i.err }
      93           2 : func (i *errorKeyspanIter) Close() error                  { return i.err }
      94           0 : func (*errorKeyspanIter) String() string                  { return "error" }

Generated by: LCOV version 1.14