netchan

type Binder interface {
	// Bind binds a local channel to a URI that is addressing a remote
	// channel. After the binding is established, the bound channel may
	// be used to send messages to the remote channel.
	//
	// Remotely exposed channels are addressed by URI's. The URI
	// syntax depends on the underlying transport. For the default TCP
	// transport an address has the syntax: tcp://HOST[:PORT]/ID
	//
	// The uri parameter contains the URI and can be of type string or
	// *url.URL. An error channel (of type chan error) may also be
	// specified. This error channel will receive transport errors, etc.
	// related to the bound channel.
	//
	// It is also possible to associate a new error channel with an
	// already bound channel. For this purpose use a nil uri and
	// the new error channel to associate with the bound channel.
	//
	// To unbind a bound channel simply close it.
	Bind(uri interface{}, ichan interface{}, echan chan error) error
}

type ChanDecoder interface {
	ChanDecode(link Link, vchan reflect.Value, buf []byte, accum map[string]reflect.Value) error
	ChanDecodeAccum(link Link, accum map[string]reflect.Value) error
}

type ChanEncoder interface {
	ChanEncode(link Link, vchan reflect.Value, accum map[string]reflect.Value) ([]byte, error)
	ChanEncodeAccum(link Link, accum map[string]reflect.Value) error
}

type Config struct {
	// MaxLinks contains the maximum number of links that may be opened
	// to a particular address/URI.
	MaxLinks int

	// RedialTimeout contains a timeout for "redial" attempts. If it is
	// non-zero a Transport will retry dialing if a dialing error occurs
	// for at least the duration specified in RedialTimeout. If this
	// field is zero no redial attempts will be made.
	RedialTimeout time.Duration

	// IdleTimeout will close connections that have been idle for the
	// specified duration. If this field is zero idle connections will
	// not be closed.
	IdleTimeout time.Duration
}

type Err interface {
	error

	// Nested returns the original error that is the cause of this error.
	// May be nil.
	Nested() error

	// Chan returns a channel that is associated with this error.
	// May be nil.
	Chan() interface{}
}

type ErrArgument struct {
	// contains filtered or unexported fields
}

type ErrBinder struct {
	// contains filtered or unexported fields
}

type ErrExposer struct {
	// contains filtered or unexported fields
}

type ErrMarshaler struct {
	// contains filtered or unexported fields
}

type ErrTransport struct {
	// contains filtered or unexported fields
}

type Exposer interface {
	// Expose exposes a channel under an ID. Exposing a channel
	// associates it with the ID and makes it available to receive
	// messages.
	//
	// If multiple channels are exposed under the same ID which
	// channel(s) receive a message depends on the ID. ID's that start
	// with a '+' character are considered "broadcast" ID's and messages
	// sent to them are delivered to all channels exposed under that
	// ID. All other ID's are considered "unicast" and messages sent to
	// them are delivered to a single channel exposed under that ID
	// (determined using a pseudo-random algorithm).
	//
	// To receive exposer errors one can expose error channels (of type
	// chan error) under the special broadcast ID "+err/". All such error
	// channels will receive transport errors, etc. This special broadcast
	// ID is local to the running process and cannot be accessed remotely.
	//
	// It is also possible to receive "invalid" messages on channels (of
	// type chan Message) exposed under the special broadcast ID
	// "+inv/". Invalid messages are messages that cannot be delivered
	// for any of a number of reasons: because they contain the wrong
	// message ID, because their payload is the wrong type, because the
	// destination channels have been closed, etc. As with "+err/" this
	// special broadcast ID is local to the running process and cannot
	// be accessed remotely.
	Expose(id string, ichan interface{}) error

	// Unexpose unexposes a channel. It disassociates it from the ID
	// and makes it unavailable to receive messages under that ID.
	Unexpose(id string, ichan interface{})
}

type Link interface {
	Sigchan() chan struct{}
	Reference()
	Dereference()
	Activate()
	Recv() (id string, vmsg reflect.Value, err error)
	Send(id string, vmsg reflect.Value) (err error)
}

type Marshaler interface {
	RegisterType(val interface{})
	SetChanEncoder(chanEnc ChanEncoder)
	SetChanDecoder(chanDec ChanDecoder)
	Marshal(link Link, id string, vmsg reflect.Value, hdrlen int) (buf []byte, err error)
	Unmarshal(link Link, buf []byte, hdrlen int) (id string, vmsg reflect.Value, err error)
}

type Message struct {
	// Id contains the ID of the intended recipient.
	Id string

	// Value contains the message payload (as decoded by the marshaling
	// layer).
	Value reflect.Value
}

type Recver interface {
	Recver(link Link) error
}

type Sender interface {
	Sender(link Link) error
}

type Stats interface {
	// StatNames returns a list of value names.
	StatNames() []string

	// Stat returns the value associated with a particular name.
	Stat(name string) float64
}

type Transport interface {
	SetRecver(recver Recver)
	SetSender(sender Sender)
	Listen() error
	Dial(uri *url.URL) (id string, link Link, err error)
	Close()
}