gotmc/lxi

Go-based implementation of the LAN eXtensions for Instrumentation (LXI) standard

lxi's Issues

make bufio.Reader a member of lxi.Device

Hello,

I would suggest to make the bufio.Reader instantiated in the Query method a member of the Device struct.

There are multiple potential problems with the existing code.

1. The reader may read more data than the line, if possible. This data will be lost.
2. The reader allocates buffers for buffering data and the reader object. This creates pressure on the GC.

By making the Reader a member of the Device struct, it becomes persistant as well as its buffers and the data it contains. Is it still possible to use the Read methods and even read bytes per bytes, but efficiently.

Change the Device into this:

type Device struct {
	conn net.Conn
	rdr *bufio.Reader
}

The NewDevice function becomes:

func NewDevice(address string) (*Device, error) {
	v, err := NewVisaResource(address)
	if err != nil {
		return nil, err
	}
	tcpAddress := fmt.Sprintf("%s:%d", v.hostAddress, v.port)
	c, err := net.Dial("tcp", tcpAddress)
	if err != nil {
		return nil, err
	}
	return &Device{conn: c, rdr: bufio.NewReader(c)}, nil
}

Note that the convention is to return a nil Device in case of error.

The Read function becomes:

// Read reads from the network connection into the given byte slice.
func (d *Device) Read(p []byte) (n int, err error) {
	return d.rdr.Read(p)
}

The Close function becomes:

// Close closes the underlying network connection.
func (d *Device) Close() error {
	d.rdr = nil
	c := d.conn
	d.conn = nil
	return c.Close()
}

And Query becomes:

func (d *Device) Query(cmd string) (string, error) {
	err := d.Command(cmd)
	if err != nil {
		return "", err
	}
	return d.rdr.ReadString('\n')
}