go的一个用于读写byte的NetStream

网络通信中通常需要用到byte的通用操作方式

功能大概

• 写入int16,int32,int64,byte
• 读取int16,int32,int64,byte

• package mynet
  
  import (
      "bytes"
      "encoding/binary"
      "errors"
  )
  
  type NetStream struct {
      Data     []byte
      Rpos     int
      Wpos     int
      Capacity int
  }
  
  func NewNetStream(capacity int) *NetStream {
      a := &NetStream{
          Rpos:     0,
          Wpos:     0,
          Capacity: capacity,
      }
  
      a.Data = make([]byte, capacity)
      return a
  }
  
  // read
  func (self *NetStream) ReadInt16() (int16, error) {
      var p int16
      if self.Rpos+2 > self.Wpos {
          return p, errors.New("not enough read")
      }
      binary.Read(bytes.NewBuffer(self.Data[self.Rpos:]), binary.BigEndian, &p)
      self.Rpos += 2
      return p, nil
  }
  
  func (self *NetStream) ReadInt32() (int32, error) {
      var p int32
      if self.Rpos+4 > self.Wpos {
          return p, errors.New("not enough read")
      }
  
      binary.Read(bytes.NewBuffer(self.Data[self.Rpos:]), binary.BigEndian, &p)
      self.Rpos += 4
      return p, nil
  }
  
  func (self *NetStream) GetInt16() (int16, error) {
      var p int16
      if self.Rpos+2 > self.Wpos {
          return p, errors.New("not enough read")
      }
  
      binary.Read(bytes.NewBuffer(self.Data[self.Rpos:]), binary.BigEndian, &p)
      return p, nil
  }
  
  func (self *NetStream) GetInt32() (int32, error) {
      var p int32
      if self.Rpos+4 > self.Wpos {
          return p, errors.New("not enough read")
      }
  
      binary.Read(bytes.NewBuffer(self.Data[self.Rpos:]), binary.BigEndian, &p)
      return p, nil
  }
  
  func (self *NetStream) ReadInt64() (int64, error) {
      var p int64
      if self.Rpos+8 > self.Wpos {
          return p, errors.New("not enough read")
      }
  
      binary.Read(bytes.NewBuffer(self.Data[self.Rpos:]), binary.BigEndian, &p)
      self.Rpos += 8
      return p, nil
  }
  
  func (self *NetStream) ReadBytes(p []byte, offset int, len int) error {
      if self.Rpos+len > self.Wpos {
          return errors.New("not enough read")
      }
      copy(p[offset:offset+len], self.Data[self.Rpos:self.Rpos+len])
      self.Rpos += len
      return nil
  }
  
  // write
  func (self *NetStream) WriteInt16(p int16) error {
      if self.Wpos+2 > self.Capacity {
          return errors.New("not cap to write")
      }
  
      buff := bytes.NewBuffer([]byte{})
      binary.Write(buff, binary.BigEndian, p)
      self.WriteByte(buff.Bytes())
      return nil
  }
  
  func (self *NetStream) WriteInt32(p int32) error {
      if self.Wpos+4 > self.Capacity {
          return errors.New("not cap to write")
      }
      buff := bytes.NewBuffer([]byte{})
      binary.Write(buff, binary.BigEndian, p)
      self.WriteByte(buff.Bytes())
      return nil
  }
  
  func (self *NetStream) WriteInt64(p int64) error {
      if self.Wpos+8 > self.Capacity {
          return errors.New("not cap to write")
      }
      buff := bytes.NewBuffer([]byte{})
      binary.Write(buff, binary.BigEndian, p)
      self.WriteByte(buff.Bytes())
      return nil
  }
  
  func (self *NetStream) WriteBytes(p []byte, offset int, len int) error {
      if self.Wpos+len > self.Capacity {
          return errors.New("not cap to write")
      }
      copy(self.Data[self.Wpos:], p[offset:offset+len])
      self.Wpos += len
      return nil
  }
  
  func (self *NetStream) WriteByte(p []byte) error {
      if self.Wpos+len(p) > self.Capacity {
          return errors.New("not cap to write")
      }
      copy(self.Data[self.Wpos:], p)
      self.Wpos += len(p)
      return nil
  }
  
  func (self *NetStream) ClearRead() {
      if self.Rpos > 0 {
          copy(self.Data[0:], self.Data[self.Rpos:self.Wpos])
          self.Rpos = 0
          self.Wpos = self.Wpos - self.Rpos
      }
  }
  
  func (self *NetStream) AvailableNum() int {
      return self.Wpos - self.Rpos
  }
  
  func (self *NetStream) PrefixedDataAvailable(len int) bool {
      if self.AvailableNum() < len {
          return false
      }
      var b1 int16
      var b2 int32
      var err error
      if len == 2 {
          b1, err = self.GetInt16()
      } else if len == 4 {
          b2, err = self.GetInt32()
      }
  
      if err == nil {
          if self.AvailableNum() >= int(b1)+len || self.AvailableNum() >= int(b2)+len {
              return true
          }
      }
      return false
  }
  
  func (self *NetStream) PrefixedDataAvailableShort() bool {
      return self.PrefixedDataAvailable(2)
  }
  
  func (self *NetStream) PrefixedDataAvailableInt() bool {
      return self.PrefixedDataAvailable(4)
  }