github.com/qiniu/go-sdk/v7@v7.27.0/sms/bytes/bytes.go (about)

     1  package bytes
     2  
     3  import (
     4  	"io"
     5  	"syscall"
     6  )
     7  
     8  // ---------------------------------------------------
     9  
    10  type Reader struct {
    11  	b   []byte
    12  	off int
    13  }
    14  
    15  func NewReader(val []byte) *Reader {
    16  	return &Reader{val, 0}
    17  }
    18  
    19  func (r *Reader) Len() int {
    20  	if r.off >= len(r.b) {
    21  		return 0
    22  	}
    23  	return len(r.b) - r.off
    24  }
    25  
    26  func (r *Reader) Bytes() []byte {
    27  	return r.b[r.off:]
    28  }
    29  
    30  func (r *Reader) SeekToBegin() (err error) {
    31  	r.off = 0
    32  	return
    33  }
    34  
    35  func (r *Reader) Seek(offset int64, whence int) (ret int64, err error) {
    36  	switch whence {
    37  	case 0:
    38  	case 1:
    39  		offset += int64(r.off)
    40  	case 2:
    41  		offset += int64(len(r.b))
    42  	default:
    43  		err = syscall.EINVAL
    44  		return
    45  	}
    46  	if offset < 0 {
    47  		err = syscall.EINVAL
    48  		return
    49  	}
    50  	if offset >= int64(len(r.b)) {
    51  		r.off = len(r.b)
    52  	} else {
    53  		r.off = int(offset)
    54  	}
    55  	ret = int64(r.off)
    56  	return
    57  }
    58  
    59  func (r *Reader) Read(val []byte) (n int, err error) {
    60  	n = copy(val, r.b[r.off:])
    61  	if n == 0 && len(val) != 0 {
    62  		err = io.EOF
    63  		return
    64  	}
    65  	r.off += n
    66  	return
    67  }
    68  
    69  func (r *Reader) Close() (err error) {
    70  	return
    71  }
    72  
    73  // ---------------------------------------------------
    74  
    75  type Writer struct {
    76  	b []byte
    77  	n int
    78  }
    79  
    80  func NewWriter(buff []byte) *Writer {
    81  	return &Writer{buff, 0}
    82  }
    83  
    84  func (p *Writer) Write(val []byte) (n int, err error) {
    85  	n = copy(p.b[p.n:], val)
    86  	if n == 0 && len(val) > 0 {
    87  		err = io.EOF
    88  		return
    89  	}
    90  	p.n += n
    91  	return
    92  }
    93  
    94  func (p *Writer) Len() int {
    95  	return p.n
    96  }
    97  
    98  func (p *Writer) Bytes() []byte {
    99  	return p.b[:p.n]
   100  }
   101  
   102  func (p *Writer) Reset() {
   103  	p.n = 0
   104  }
   105  
   106  // ---------------------------------------------------
   107  
   108  type Buffer struct {
   109  	b []byte
   110  }
   111  
   112  func NewBuffer() *Buffer {
   113  	return new(Buffer)
   114  }
   115  
   116  func (p *Buffer) ReadAt(buf []byte, off int64) (n int, err error) {
   117  	ioff := int(off)
   118  	if len(p.b) <= ioff {
   119  		return 0, io.EOF
   120  	}
   121  	n = copy(buf, p.b[ioff:])
   122  	if n != len(buf) {
   123  		err = io.EOF
   124  	}
   125  	return
   126  }
   127  
   128  func (p *Buffer) WriteAt(buf []byte, off int64) (n int, err error) {
   129  	ioff := int(off)
   130  	iend := ioff + len(buf)
   131  	if len(p.b) < iend {
   132  		if len(p.b) == ioff {
   133  			p.b = append(p.b, buf...)
   134  			return len(buf), nil
   135  		}
   136  		zero := make([]byte, iend-len(p.b))
   137  		p.b = append(p.b, zero...)
   138  	}
   139  	copy(p.b[ioff:], buf)
   140  	return len(buf), nil
   141  }
   142  
   143  func (p *Buffer) WriteStringAt(buf string, off int64) (n int, err error) {
   144  	ioff := int(off)
   145  	iend := ioff + len(buf)
   146  	if len(p.b) < iend {
   147  		if len(p.b) == ioff {
   148  			p.b = append(p.b, buf...)
   149  			return len(buf), nil
   150  		}
   151  		zero := make([]byte, iend-len(p.b))
   152  		p.b = append(p.b, zero...)
   153  	}
   154  	copy(p.b[ioff:], buf)
   155  	return len(buf), nil
   156  }
   157  
   158  func (p *Buffer) Truncate(fsize int64) (err error) {
   159  	size := int(fsize)
   160  	if len(p.b) < size {
   161  		zero := make([]byte, size-len(p.b))
   162  		p.b = append(p.b, zero...)
   163  	} else {
   164  		p.b = p.b[:size]
   165  	}
   166  	return nil
   167  }
   168  
   169  func (p *Buffer) Buffer() []byte {
   170  	return p.b
   171  }
   172  
   173  func (p *Buffer) Len() int {
   174  	return len(p.b)
   175  }
   176  
   177  // ---------------------------------------------------