github.com/jmigpin/editor@v1.6.0/util/iout/iorw/seeker.go (about)

     1  package iorw
     2  
     3  //type Seeker interface {
     4  //	Seek(i int, from SeekFrom) (int, error)
     5  //}
     6  
     7  //type SeekFrom int
     8  
     9  //const (
    10  //	SeekStart SeekFrom = iota
    11  //	SeekCurrent
    12  //	SeekEnd
    13  //)
    14  
    15  //type Lengther interface {
    16  //	Len() int
    17  //}
    18  
    19  ////----------
    20  
    21  //type ReadWriter2 interface {
    22  //	Reader2
    23  //	Writer2
    24  //}
    25  
    26  //type Reader2 interface {
    27  //	ReadFast(n int) ([]byte, error) // might read less then n
    28  //}
    29  
    30  //type Writer2 interface {
    31  //	Overwrite(del int, p []byte) error // writes len(p)
    32  //}
    33  
    34  ////----------
    35  
    36  //// TODO
    37  ////ReadAt(p []byte, i int) (int, error)
    38  ////WriteAt(p []byte, i int) (n int, err error)
    39  
    40  ////----------
    41  
    42  //type ReadSeeker interface {
    43  //	Reader2
    44  //	Seeker
    45  //}
    46  
    47  //type WriteSeeker interface {
    48  //	Writer2
    49  //	Seeker
    50  //}
    51  
    52  //type RuneReadSeeker interface {
    53  //	ReadRune() (r rune, size int, err error) // io.RuneReader
    54  //	//ReadLastRune() (r rune, size int, err error)
    55  //	Seeker
    56  //}
    57  
    58  ////----------
    59  
    60  //type Seek struct {
    61  //	i int
    62  //	l Lengther
    63  //}
    64  
    65  //func NewSeek(l Lengther) *Seek {
    66  //	return &Seek{l: l}
    67  //}
    68  
    69  //func (s *Seek) Seek(i int, from SeekFrom) (int, error) {
    70  //	var abs int
    71  //	switch from {
    72  //	case SeekStart:
    73  //		abs = i
    74  //	case SeekCurrent:
    75  //		abs = s.i + i
    76  //	case SeekEnd:
    77  //		abs = s.l.Len() + i
    78  //	}
    79  //	if abs < 0 {
    80  //		return 0, fmt.Errorf("iorws.seek: %v<0", abs)
    81  //	}
    82  //	if abs > s.l.Len() {
    83  //		return 0, fmt.Errorf("iorws.seek: %v>%v", abs, s.l.Len())
    84  //	}
    85  //	s.i = abs
    86  //	return abs, nil
    87  //}
    88  
    89  //func (s *Seek) SeekCurrent() int {
    90  //	return s.i
    91  //}
    92  
    93  ////----------
    94  
    95  //type LimitedSeek struct {
    96  //	Seeker
    97  //	start, n int
    98  //}
    99  
   100  //func NewLimitedSeek(s Seeker, start, n int) *LimitedSeek {
   101  //	return &LimitedSeek{s, start, n}
   102  //}
   103  
   104  //func (s *LimitedSeek) Seek(i int, from SeekFrom) (int, error) {
   105  //	var abs int
   106  //	switch from {
   107  //	case SeekStart:
   108  //		abs = s.start + i
   109  //	case SeekCurrent:
   110  //		k, err := s.Seeker.Seek(0, SeekCurrent)
   111  //		if err != nil {
   112  //			return 0, err
   113  //		}
   114  //		abs = k + i
   115  //	case SeekEnd:
   116  //		abs = s.start + s.n + i
   117  //	}
   118  //	if abs < s.start {
   119  //		return 0, fmt.Errorf("iorws.limitedseek: %v<%v", abs, s.start)
   120  //	}
   121  //	if abs > s.start+s.n {
   122  //		return 0, fmt.Errorf("iorws.limitedseek: %v>%v", abs, s.start+s.n)
   123  //	}
   124  //	return s.Seek(abs, SeekStart)
   125  //}
   126  
   127  ////----------
   128  
   129  //type rs struct {
   130  //	r ReaderAt
   131  //	Seeker
   132  //}
   133  
   134  //func NewReadSeeker(r ReaderAt) ReadSeeker {
   135  //	return &rs{r, NewSeek(r)}
   136  //}
   137  
   138  //// Implements Reader
   139  //func (rs *rs) ReadFast(n int) ([]byte, error) {
   140  //	i, err := rs.Seek(0, SeekCurrent)
   141  //	if err != nil {
   142  //		return nil, err
   143  //	}
   144  //	b, err := rs.r.ReadFastAt(i, n)
   145  //	if err != nil {
   146  //		return nil, err
   147  //	}
   148  //	_, err = rs.Seek(len(b), SeekCurrent)
   149  //	return b, err
   150  //}
   151  
   152  ////----------
   153  
   154  //type ws struct {
   155  //	w WriterAt
   156  //	Seeker
   157  //}
   158  
   159  //func NewWriteSeeker(w WriterAt, l Lengther) WriteSeeker {
   160  //	return &ws{w, NewSeek(l)}
   161  //}
   162  
   163  //// Implements Writer
   164  //func (ws *ws) Overwrite(del int, p []byte) error {
   165  //	i, err := ws.Seek(0, SeekCurrent)
   166  //	if err != nil {
   167  //		return err
   168  //	}
   169  //	if err := ws.w.OverwriteAt(i, del, p); err != nil {
   170  //		return err
   171  //	}
   172  //	_, err = ws.Seek(len(p), SeekCurrent)
   173  //	return err
   174  //}
   175  
   176  ////----------
   177  
   178  //type rr struct {
   179  //	r ReaderAt
   180  //	Seeker
   181  //}
   182  
   183  //func NewRuneReadSeeker(r ReaderAt) RuneReadSeeker {
   184  //	s := NewSeek(r)
   185  //	return &rr{r, s}
   186  //}
   187  
   188  //// Implements io.RuneReader
   189  //func (r *rr) ReadRune() (rune, int, error) {
   190  //	i, err := r.Seek(0, SeekCurrent)
   191  //	if err != nil {
   192  //		return 0, 0, err
   193  //	}
   194  //	defer func() { _, _ = r.Seek(i, SeekStart) }() // restore/advance index
   195  
   196  //	rra := NewRuneReaderAt(r.r)
   197  //	ru, size, err := rra.ReadRuneAt(i)
   198  //	i += size // advance
   199  //	return ru, size, err
   200  //}
   201  
   202  ////----------
   203  
   204  //type rrr struct {
   205  //	r ReaderAt
   206  //	Seeker
   207  //}
   208  
   209  //func NewReverseRuneReadSeeker(r ReaderAt) RuneReadSeeker {
   210  //	s := NewSeek(r)
   211  //	return &rrr{r, s}
   212  //}
   213  
   214  //// Implements io.RuneReader
   215  //func (r *rrr) ReadRune() (rune, int, error) {
   216  //	i, err := r.Seek(0, SeekCurrent)
   217  //	if err != nil {
   218  //		return 0, 0, err
   219  //	}
   220  //	defer func() { _, _ = r.Seek(i, SeekStart) }() // restore/advance index
   221  
   222  //	rra := NewRuneReaderAt(r.r)
   223  //	ru, size, err := rra.ReadLastRuneAt(i)
   224  //	i -= size // advance
   225  //	return ru, size, err
   226  //}
   227  
   228  ////----------
   229  
   230  //type ior struct {
   231  //	r Reader2
   232  //}
   233  
   234  //func NewIOReader(r Reader2) io.Reader {
   235  //	return &ior{r}
   236  //}
   237  
   238  //// Implements io.Reader
   239  //func (r *ior) Read(p []byte) (int, error) {
   240  //	b, err := r.r.ReadFast(len(p))
   241  //	if err != nil {
   242  //		return 0, err
   243  //	}
   244  //	return copy(p, b), nil
   245  //}
   246  
   247  ////----------
   248  
   249  //type iow struct {
   250  //	w Writer2
   251  //}
   252  
   253  //func NewIOWriter(w Writer2) io.Writer {
   254  //	return &iow{w}
   255  //}
   256  
   257  //// Implements io.Writer
   258  //func (w *iow) Write(p []byte) (int, error) {
   259  //	if err := w.w.Overwrite(0, p); err != nil {
   260  //		return 0, err
   261  //	}
   262  //	return len(p), nil
   263  //}