Below is a structure Config, that holds an anonymous function, ReturnNewAddress that returns a net.Conn interface. ReturnNewAddress is then utilized to return an 'addr'.
type struct Config {
ReturnNewAddress func(net.Conn, error)
}
Where later the anonymous function, ReturnnewAddress is called below, note that cfg is a instance of Config.
addr, err := cfg.ReturnNewAddress()
So my question comes to - how does the interface net.Conn know what function to utilize considering the interface holds many different functions? What brings me to confusion is that LocalAddr() or RemoteAddr() are not implicitly called. How is it known to explicitly use one of these methods. What if I need to explicitly use LocalAddr over RemoteAddr?
Below is the go doc of net.Conn:
type Conn interface {
// Read reads data from the connection.
// Read can be made to time out and return an Error with Timeout() == true
// after a fixed time limit; see SetDeadline and SetReadDeadline.
Read(b []byte) (n int, err error)
// Write writes data to the connection.
// Write can be made to time out and return an Error with Timeout() == true
// after a fixed time limit; see SetDeadline and SetWriteDeadline.
Write(b []byte) (n int, err error)
// Close closes the connection.
// Any blocked Read or Write operations will be unblocked and return errors.
Close() error
// LocalAddr returns the local network address.
LocalAddr() Addr
// RemoteAddr returns the remote network address.
RemoteAddr() Addr
// SetDeadline sets the read and write deadlines associated
// with the connection. It is equivalent to calling both
// SetReadDeadline and SetWriteDeadline.
//
// A deadline is an absolute time after which I/O operations
// fail with a timeout (see type Error) instead of
// blocking. The deadline applies to all future and pending
// I/O, not just the immediately following call to Read or
// Write. After a deadline has been exceeded, the connection
// can be refreshed by setting a deadline in the future.
//
// An idle timeout can be implemented by repeatedly extending
// the deadline after successful Read or Write calls.
//
// A zero value for t means I/O operations will not time out.
SetDeadline(t time.Time) error
// SetReadDeadline sets the deadline for future Read calls
// and any currently-blocked Read call.
// A zero value for t means Read will not time out.
SetReadDeadline(t time.Time) error
// SetWriteDeadline sets the deadline for future Write calls
// and any currently-blocked Write call.
// Even if write times out, it may return n > 0, indicating that
// some of the data was successfully written.
// A zero value for t means Write will not time out.
SetWriteDeadline(t time.Time) error
}
Conn is a generic stream-oriented network connection.
The question is not fully clear, but ..
It looks like the code for the Config type has a typo as
ReturnNewAddress func(net.Conn, error)
does not have a function type compatible with the later code
addr, err := cfg.ReturnNewAddress()
I believe the config struct type shoud be defined as
type struct Config {
ReturnNewAddress func()(net.Conn, error)
}
Based on this, the variable addr returned from the call to cfg.ReturnNewAddress() has the type net.Conn - so it is a value which implements the interface net.Conn. Hence you can explicitly call the required functions as follows:
localAddr :=addr.LocalAddr();
remoteAddr := addr.RemoteAddr();