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