proto

Documentation

Index

• Constants
• Variables
• func Encode(m Message, reservedHeadLen int) ([]byte, error)
• func EncodeAppend(buf []byte, m Message) ([]byte, error)
• func EncodeSize(buf []byte, size int) int
• func EncodeType(buf []byte, typ Type) int
• func ErrUnrecognizedType(typ Type) error
• func FreeBuffer(b *Buffer)
• func IsTextproto(contentType ContentType) bool
• func Marshal(m Message) ([]byte, error)
• func Moduleof(typ Type) string
• func PeekSize(peeker Peeker) (n int, size int, err error)
• func ReadSize(r io.ByteReader) (size int, err error)
• func Register(mod string, typ Type, creator func() Message)
• func Unmarshal(buf []byte, m Message) error
• type Arena
• type ArenaFunc
  • func (fn ArenaFunc) Get(typ Type) Message
  • func (fn ArenaFunc) Put(_ Message)
• type Body
  • func Text(b []byte) Body
• type Buffer
  • func AllocBuffer() *Buffer
  • func (b *Buffer) Bytes() []byte
  • func (b *Buffer) Cap() int
  • func (b *Buffer) Encode(m Message, contentType ContentType) error
  • func (b *Buffer) Len() int
  • func (b *Buffer) Marshal(m Message) error
  • func (b *Buffer) Reserve(n int)
  • func (b *Buffer) Reset()
  • func (b *Buffer) Unmarshal(m Message) error
  • func (b *Buffer) Write(p []byte) (n int, err error)
• type ContentType
• type Dispatcher
• type Listener
  • func Listen[H ~func(M), M Message](h H) Listener
• type Message
  • func Decode(buf []byte, arena Arena) (int, Message, error)
  • func New(typ Type) Message
• type MessageInfo
  • func Messages() []MessageInfo
• type Peeker
• type Pool
  • func (pp *Pool) Get(typ Type) Message
  • func (pp *Pool) Put(m Message)
• type Type
  • func Lookup(module string) []Type
  • func ParseType(s string) (Type, error)
  • func PeekType(peeker Peeker) (n int, typ Type, err error)
  • func ReadType(r io.ByteReader) (typ Type, err error)
• type UnrecognizedTypeError
  • func (err *UnrecognizedTypeError) Error() string

Constants

const (
	// max size of content: 1G
	MaxSize = 1 << 30
	// max message type
	MaxType = 1 << 31
)

Variables

var (
	ErrVarintOverflow         = errors.New("proto: varint overflow")
	ErrSizeOverflow           = errors.New("proto: size overflow")
	ErrTypeOverflow           = errors.New("proto: type overflow")
	ErrOutOfRange             = errors.New("proto: out of range")
	ErrUnsupportedContentType = errors.New("proto: unsupported content type")
)

Functions

func Encode

func Encode(m Message, reservedHeadLen int) ([]byte, error)

Encode returns the wire-format encoding of m with type and size.

|type|body.size|body|

func EncodeAppend

func EncodeAppend(buf []byte, m Message) ([]byte, error)

EncodeAppend encodes m to buf

func EncodeSize

func EncodeSize(buf []byte, size int) int

EncodeSize encodes type as varint to buf and returns number of bytes written.

func EncodeType

func EncodeType(buf []byte, typ Type) int

EncodeType encodes type as varint to buf and returns number of bytes written.

func ErrUnrecognizedType

func ErrUnrecognizedType(typ Type) error

func FreeBuffer

func FreeBuffer(b *Buffer)

FreeBuffer puts buffer to pool if cap of buffer less than 64k

func IsTextproto

func IsTextproto(contentType ContentType) bool

IsTextproto reports whether the contentType is a textproto type

func Marshal

func Marshal(m Message) ([]byte, error)

Marshal returns the wire-format encoding of m without type or size.

func Moduleof

func Moduleof(typ Type) string

Moduleof returns the module name of message by type

func PeekSize

func PeekSize(peeker Peeker) (n int, size int, err error)

PeekSize reads message size without advancing underlying reader offset

func ReadSize

func ReadSize(r io.ByteReader) (size int, err error)

ReadSize reads message size from reader

func Register

func Register(mod string, typ Type, creator func() Message)

Register registers a message creator by type. Register is not concurrent-safe, it is recommended to call in `init` function.

e.g.

package foo

import "github.com/gopherd/doge/proto"

func init() {
	proto.Register("foo", BarType, func() proto.Message { return new(Bar) })
}

func Unmarshal

func Unmarshal(buf []byte, m Message) error

Unmarshal parses the wire-format message in b and places the result in m. The provided message must be mutable (e.g., a non-nil pointer to a message).

Types

type Arena

type Arena interface {
	Get(typ Type) Message
	Put(m Message)
}

Arena represents a message factory

type ArenaFunc

type ArenaFunc func(Type) Message

ArenaFunc wraps function as an Arena

func (ArenaFunc) Get

func (fn ArenaFunc) Get(typ Type) Message

Get implements Arena Get method

func (ArenaFunc) Put

func (fn ArenaFunc) Put(_ Message)

Put implements Arena Put method

type Body

type Body interface {
	io.Reader
	io.ByteReader

	// Len returns remain length of body
	Len() int

	// Peek returns the next n bytes without advancing the reader. The bytes stop
	// being valid at the next read call. If Peek returns fewer than n bytes, it
	// also returns an error explaining why the read is short.
	Peek(n int) ([]byte, error)

	// Discard skips the next n bytes, returning the number of bytes discarded.
	// If Discard skips fewer than n bytes, it also returns an error.
	Discard(n int) (discarded int, err error)
}

Body represents message body

func Text

func Text(b []byte) Body

Text creates a textproto body

type Buffer

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

func AllocBuffer

func AllocBuffer() *Buffer

AllocBuffer gets buffer from pool

func (*Buffer) Bytes

func (b *Buffer) Bytes() []byte

func (*Buffer) Cap

func (b *Buffer) Cap() int

func (*Buffer) Encode

func (b *Buffer) Encode(m Message, contentType ContentType) error

func (*Buffer) Len

func (b *Buffer) Len() int

func (*Buffer) Marshal

func (b *Buffer) Marshal(m Message) error

func (*Buffer) Reserve

func (b *Buffer) Reserve(n int)

func (*Buffer) Reset

func (b *Buffer) Reset()

func (*Buffer) Unmarshal

func (b *Buffer) Unmarshal(m Message) error

func (*Buffer) Write

func (b *Buffer) Write(p []byte) (n int, err error)

type ContentType

type ContentType int

ContentType represents encoding type of content

const (
	ContentTypeProtobuf ContentType = iota
	ContentTypeText
)

type Dispatcher

type Dispatcher = event.Dispatcher[Type]

Dispatcher aliases event.Dispatcher for Type

type Listener

type Listener = event.Listener[Type]

Listener aliases event.Listener for Type

func Listen

func Listen[H ~func(M), M Message](h H) Listener

Listen listens message handler

type Message

type Message interface {
	// Type of message
	Typeof() Type
	// Size of message
	Sizeof() int
	// Name of message
	Nameof() string

	// MarshalAppend marshals message to buf
	MarshalAppend(buf []byte, useCachedSize bool) ([]byte, error)
	// Unmarshal unmarshals message from buf
	Unmarshal(buf []byte) error
}

Message represents a message interface

func Decode

func Decode(buf []byte, arena Arena) (int, Message, error)

Decode decodes one message with type and size from buf and returns number of bytes read and unmarshaled message.

func New

func New(typ Type) Message

New creates a message by type, nil returned if type not found

type MessageInfo

type MessageInfo struct {
	Type   Type
	Name   string
	Module string
}

func Messages

func Messages() []MessageInfo

Messages returns all registered message informations

type Peeker

type Peeker interface {
	Peek(n int) ([]byte, error)
}

Peeker peeks n bytes

type Pool

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

Pool implements Arena interface to reuse message objects

func (*Pool) Get

func (pp *Pool) Get(typ Type) Message

Get selects an message object from the Pool by type, removes it from the Pool, and returns it to the caller.

func (*Pool) Put

func (pp *Pool) Put(m Message)

Put adds x to the pool.

type Type

type Type = uint32

Type represents message type

func Lookup

func Lookup(module string) []Type

Lookup lookups all registered types by module

func ParseType

func ParseType(s string) (Type, error)

ParseType parses type from string

func PeekType

func PeekType(peeker Peeker) (n int, typ Type, err error)

PeekType reads message type without advancing underlying reader offset

func ReadType

func ReadType(r io.ByteReader) (typ Type, err error)

ReadType reads message type from reader

type UnrecognizedTypeError

type UnrecognizedTypeError struct {
	Type Type
}

func (*UnrecognizedTypeError) Error

func (err *UnrecognizedTypeError) Error() string