mrpc.go

// Code generated by mprotc.
// Do not edit.

package mrpc

import (
	"fmt"
	"time"

	msgpack "github.com/mprot/msgpack-go"
)

var _ = fmt.Errorf
var _ time.Time
var _ *msgpack.Writer

// ErrCode is an enumeration of supported error codes.
type ErrCode int

// Enumerators for ErrCode.
const (
	OK              ErrCode = 0
	Unknown         ErrCode = 1
	Timeout         ErrCode = 2
	NotFound        ErrCode = 3
	AlreadyExists   ErrCode = 4
	InvalidArgument ErrCode = 5
	Unauthorized    ErrCode = 6
	Forbidden       ErrCode = 7
	Internal        ErrCode = 8
	Unavailable     ErrCode = 9
)

// EncodeMsgpack implements the Encoder interface for ErrCode.
func (o ErrCode) EncodeMsgpack(w *msgpack.Writer) error {
	return w.WriteInt(int(o))
}

// DecodeMsgpack implements the Decoder interface for ErrCode.
func (o *ErrCode) DecodeMsgpack(r *msgpack.Reader) error {
	val, err := r.ReadInt()
	if err != nil {
		return err
	}
	*o = ErrCode(val)
	return nil
}

// RequestHeaders holds all supported header data for a mrpc request.
type RequestHeaders struct {
	Timeout uint64
}

// EncodeMsgpack implements the Encoder interface for RequestHeaders.
func (o *RequestHeaders) EncodeMsgpack(w *msgpack.Writer) (err error) {
	if err = w.WriteMapHeader(1); err != nil {
		return err
	}
	// Timeout
	if err = w.WriteInt64(1); err != nil {
		return err
	}
	if err = w.WriteUint64(o.Timeout); err != nil {
		return err
	}
	return nil
}

// DecodeMsgpack implements the Decoder interface for RequestHeaders.
func (o *RequestHeaders) DecodeMsgpack(r *msgpack.Reader) error {
	n, err := r.ReadMapHeader()
	if err != nil {
		return err
	}
	for i := 0; i < n; i++ {
		ord, err := r.ReadInt64()
		if err != nil {
			return err
		}
		switch ord {
		case 1: // Timeout
			if o.Timeout, err = r.ReadUint64(); err != nil {
				return err
			}
		default:
			if err := r.Skip(); err != nil {
				return err
			}
		}
	}
	return nil
}

// Request holds the data for a single mrpc request. The target service is
// specified by its name and must be registered at the corresponding mrpc
// server. A service contains methods, each identified by an ordinal. With
// this ordinal the method of the targeted service is specified.
type Request struct {
	Service string
	Method  int
	Headers RequestHeaders
	Body    []byte
}

// EncodeMsgpack implements the Encoder interface for Request.
func (o *Request) EncodeMsgpack(w *msgpack.Writer) (err error) {
	if err = w.WriteMapHeader(4); err != nil {
		return err
	}
	// Service
	if err = w.WriteInt64(1); err != nil {
		return err
	}
	if err = w.WriteString(o.Service); err != nil {
		return err
	}
	// Method
	if err = w.WriteInt64(2); err != nil {
		return err
	}
	if err = w.WriteInt(o.Method); err != nil {
		return err
	}
	// Headers
	if err = w.WriteInt64(3); err != nil {
		return err
	}
	if err = o.Headers.EncodeMsgpack(w); err != nil {
		return err
	}
	// Body
	if err = w.WriteInt64(4); err != nil {
		return err
	}
	if err = w.WriteBytes(o.Body); err != nil {
		return err
	}
	return nil
}

// DecodeMsgpack implements the Decoder interface for Request.
func (o *Request) DecodeMsgpack(r *msgpack.Reader) error {
	n, err := r.ReadMapHeader()
	if err != nil {
		return err
	}
	for i := 0; i < n; i++ {
		ord, err := r.ReadInt64()
		if err != nil {
			return err
		}
		switch ord {
		case 1: // Service
			if o.Service, err = r.ReadString(); err != nil {
				return err
			}
		case 2: // Method
			if o.Method, err = r.ReadInt(); err != nil {
				return err
			}
		case 3: // Headers
			if err = o.Headers.DecodeMsgpack(r); err != nil {
				return err
			}
		case 4: // Body
			if o.Body, err = r.ReadBytes(nil); err != nil {
				return err
			}
		default:
			if err := r.Skip(); err != nil {
				return err
			}
		}
	}
	return nil
}

// Response holds the data for an mrpc response. If ErrCode is not OK, an
// error with the specified error text will be reported to the client. In
// this case the return value will be ignored. In case of a successful call,
// the return value will be reported to the client.
type Response struct {
	ErrorCode ErrCode
	ErrorText string
	Body      []byte
}

// EncodeMsgpack implements the Encoder interface for Response.
func (o *Response) EncodeMsgpack(w *msgpack.Writer) (err error) {
	if err = w.WriteMapHeader(3); err != nil {
		return err
	}
	// ErrorCode
	if err = w.WriteInt64(1); err != nil {
		return err
	}
	if err = o.ErrorCode.EncodeMsgpack(w); err != nil {
		return err
	}
	// ErrorText
	if err = w.WriteInt64(2); err != nil {
		return err
	}
	if err = w.WriteString(o.ErrorText); err != nil {
		return err
	}
	// Body
	if err = w.WriteInt64(3); err != nil {
		return err
	}
	if err = w.WriteBytes(o.Body); err != nil {
		return err
	}
	return nil
}

// DecodeMsgpack implements the Decoder interface for Response.
func (o *Response) DecodeMsgpack(r *msgpack.Reader) error {
	n, err := r.ReadMapHeader()
	if err != nil {
		return err
	}
	for i := 0; i < n; i++ {
		ord, err := r.ReadInt64()
		if err != nil {
			return err
		}
		switch ord {
		case 1: // ErrorCode
			if err = o.ErrorCode.DecodeMsgpack(r); err != nil {
				return err
			}
		case 2: // ErrorText
			if o.ErrorText, err = r.ReadString(); err != nil {
				return err
			}
		case 3: // Body
			if o.Body, err = r.ReadBytes(nil); err != nil {
				return err
			}
		default:
			if err := r.Skip(); err != nil {
				return err
			}
		}
	}
	return nil
}