codec

package
v1.0.3 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: May 16, 2024 License: Apache-2.0, BSD-2-Clause, BSD-3-Clause, + 2 more Imports: 20 Imported by: 74

README

English | 中文

The codec package can support any third-party business communication protocol by simply implementing the relevant interfaces. The following introduces the related interfaces of the codec package with the server-side protocol processing flow as an example. The client-side protocol processing flow is the reverse of the server-side protocol processing flow, and is not described here. For information on how to develop third-party business communication protocol plugins, please refer to here.

The following diagram shows the server-side protocol processing flow, which includes the related interfaces in the codec package.

                              package                     req body                                                       req struct
+-------+        +-------+    []byte     +--------------+  []byte    +-----------------------+    +----------------------+
|       +------->+ Framer +------------->| Codec-Decode +----------->| Compressor-Decompress +--->| Serializer-Unmarshal +------------+
|       |        +-------+               +--------------+            +-----------------------+    +----------------------+            |
|       |                                                                                                                        +----v----+
|network|                                                                                                                        | Handler |
|       |                                                 rsp body                                                               +----+----+
|       |                                                  []byte                                                         rsp struct  |
|       |                                +---------------+           +---------------------+       +--------------------+             |
|       <--------------------------------+  Codec-Encode +<--------- + Compressor-Compress + <-----+ Serializer-Marshal +-------------+
+-------+                                +---------------+           +---------------------+       +--------------------+
  • codec.Framer reads binary data from the network.
// Framer defines how to read a data frame.
type Framer interface {
    ReadFrame() ([]byte, error)
}
  • code.Codec: Provides the Decode and Encode interfaces, which parse the binary request body from the complete binary network data package and package the binary response body into a complete binary network data package, respectively.
// Codec defines the interface of business communication protocol,
// which contains head and body. It only parses the body in binary,
// and then the business body struct will be handled by serializer.
// In common, the body's protocol is pb, json, etc. Specially,
// we can register our own serializer to handle other body type.
type Codec interface {
    // Encode pack the body into binary buffer.
    // client: Encode(msg, reqBody)(request-buffer, err)
    // server: Encode(msg, rspBody)(response-buffer, err)
    Encode(message Msg, body []byte) (buffer []byte, err error)

    // Decode unpack the body from binary buffer
    // server: Decode(msg, request-buffer)(reqBody, err)
    // client: Decode(msg, response-buffer)(rspBody, err)
    Decode(message Msg, buffer []byte) (body []byte, err error)
}
  • codec.Compressor: Provides the Decompress and Compress interfaces. Currently, gzip and snappy type Compressor are supported. You can define your own Compressor and register it to the codec package.
// Compressor is body compress and decompress interface.
type Compressor interface {
	Compress(in []byte) (out []byte, err error)
	Decompress(in []byte) (out []byte, err error)
}
  • codec.Serializer: Provides the Unmarshal and Marshal interfaces. Currently, protobuf, json, fb, and xml types of Serializer are supported. You can define your own Serializer and register it to the codec package.
// Serializer defines body serialization interface.
type Serializer interface {
    // Unmarshal deserialize the in bytes into body
    Unmarshal(in []byte, body interface{}) error

    // Marshal returns the bytes serialized from body.
    Marshal(body interface{}) (out []byte, err error)
}

Documentation

Overview

Package codec defines the business communication protocol of packing and unpacking.

Index

Constants

View Source
const (
	// SendAndRecv means send one request and receive one response.
	SendAndRecv = RequestType(trpcpb.TrpcCallType_TRPC_UNARY_CALL)
	// SendOnly means only send request, no response.
	SendOnly = RequestType(trpcpb.TrpcCallType_TRPC_ONEWAY_CALL)
)
View Source
const (
	CompressTypeNoop = iota
	CompressTypeGzip
	CompressTypeSnappy
	CompressTypeZlib
	CompressTypeStreamSnappy
	CompressTypeBlockSnappy
)

CompressType is the mode of body compress or decompress.

View Source
const (
	ContextKeyMessage = ContextKey("TRPC_MESSAGE")
	// ServiceSectionLength is the length of service section,
	// service name example: trpc.app.server.service
	ServiceSectionLength = 4
)

trpc context key data

View Source
const (
	// SerializationTypePB is protobuf serialization code.
	SerializationTypePB = 0

	// SerializationTypeJSON is json serialization code.
	SerializationTypeJSON = 2
	// SerializationTypeFlatBuffer is flatbuffer serialization code.
	SerializationTypeFlatBuffer = 3
	// SerializationTypeNoop is bytes empty serialization code.
	SerializationTypeNoop = 4
	// SerializationTypeXML is xml serialization code (application/xml for http).
	SerializationTypeXML = 5
	// SerializationTypeTextXML is xml serialization code (text/xml for http).
	SerializationTypeTextXML = 6

	// SerializationTypeUnsupported is unsupported serialization code.
	SerializationTypeUnsupported = 128
	// SerializationTypeForm is used to handle form request.
	SerializationTypeForm = 129
	// SerializationTypeGet is used to handle http get request.
	SerializationTypeGet = 130
	// SerializationTypeFormData is used to handle form data.
	SerializationTypeFormData = 131
)

SerializationType defines the code of different serializers, such as protobuf, json, http-get-query and http-get-restful.

  • code 0-127 is used for common modes in all language versions of trpc.
  • code 128-999 is used for modes in any language specific version of trpc.
  • code 1000+ is used for customized occasions in which conflicts should be avoided.
View Source
const DefaultReaderSize = 4 * 1024

DefaultReaderSize is the default size of reader in bit.

Variables

JSONAPI is used by tRPC JSON serialization when the object does not conform to protobuf proto.Message interface.

Deprecated: This global variable is exportable due to backward comparability issue but should not be modified. If users want to change the default behavior of internal JSON serialization, please use register your customized serializer function like:

codec.RegisterSerializer(codec.SerializationTypeJSON, yourOwnJSONSerializer)
View Source
var Marshaler = protojson.MarshalOptions{EmitUnpopulated: true, UseProtoNames: true, UseEnumNumbers: true}

Marshaler is jsonpb marshal object, users can change its params.

View Source
var Unmarshaler = protojson.UnmarshalOptions{DiscardUnknown: false}

Unmarshaler is jsonpb unmarshal object, users can chang its params.

Functions

func Compress

func Compress(compressorType int, in []byte) ([]byte, error)

Compress returns the compressed data, the data is compressed by a specific compressor.

func CopyMsg

func CopyMsg(dst, src Msg)

CopyMsg copy src Msg to dst. All fields of src msg will be copied to dst msg.

func Decompress

func Decompress(compressorType int, in []byte) ([]byte, error)

Decompress returns the decompressed data, the data is decompressed by a specific compressor.

func GetReaderSize

func GetReaderSize() int

GetReaderSize returns size of read buffer in bit.

func IsSafeFramer

func IsSafeFramer(f interface{}) bool

IsSafeFramer returns if this framer is safe when concurrent read. The input parameter f should implement SafeFramer interface. If not , this method will return false.

func Marshal

func Marshal(serializationType int, body interface{}) ([]byte, error)

Marshal returns the serialized bytes from body. The specific serialization mode is defined by serializationType code, protobuf is default mode.

func NewReader

func NewReader(r io.Reader) io.Reader

NewReader returns reader with the default buffer size.

func NewReaderSize

func NewReaderSize(r io.Reader, size int) io.Reader

NewReaderSize returns a reader with read buffer. Size <= 0 means no buffer.

func PutBackMessage

func PutBackMessage(sourceMsg Msg)

PutBackMessage return struct Message to sync pool, and reset all the members of Message to default

func Register

func Register(name string, serverCodec Codec, clientCodec Codec)

Register defines the logic of register an codec by name. It will be called by init function defined by third package. If there is no server codec, the second param serverCodec can be nil.

func RegisterCompressor

func RegisterCompressor(compressType int, s Compressor)

RegisterCompressor register a specific compressor, which will be called by init function defined in third package.

func RegisterSerializer

func RegisterSerializer(serializationType int, s Serializer)

RegisterSerializer registers serializer, will be called by init function in third package.

func SetReaderSize

func SetReaderSize(size int)

SetReaderSize sets the size of read buffer in bit.

func Unmarshal

func Unmarshal(serializationType int, in []byte, body interface{}) error

Unmarshal deserializes the in bytes into body. The specific serialization mode is defined by serializationType code, protobuf is default mode.

Types

type Body

type Body struct {
	Data []byte
}

Body is bytes pack layer, it is not need serialized and used in gateway service generally.

func (*Body) Bytes

func (b *Body) Bytes() ([]byte, error)

Bytes returns body data and implements ByteBodyOut interface.

func (*Body) SetBytes

func (b *Body) SetBytes(p []byte) error

SetBytes sets body data and implements ByteBodyIn interface.

func (*Body) String

func (b *Body) String() string

String returns body data as string.

type BytesBodyIn

type BytesBodyIn interface {
	SetBytes([]byte) error
}

BytesBodyIn is used to receive custom type body.

type BytesBodyOut

type BytesBodyOut interface {
	Bytes() ([]byte, error)
}

BytesBodyOut is used to receive custom type body.

type Codec

type Codec interface {
	// Encode pack the body into binary buffer.
	// client: Encode(msg, reqBody)(request-buffer, err)
	// server: Encode(msg, rspBody)(response-buffer, err)
	Encode(message Msg, body []byte) (buffer []byte, err error)

	// Decode unpack the body from binary buffer
	// server: Decode(msg, request-buffer)(reqBody, err)
	// client: Decode(msg, response-buffer)(rspBody, err)
	Decode(message Msg, buffer []byte) (body []byte, err error)
}

Codec defines the interface of business communication protocol, which contains head and body. It only parses the body in binary, and then the business body struct will be handled by serializer. In common, the body's protocol is pb, json, etc. Specially, we can register our own serializer to handle other body type.

func GetClient

func GetClient(name string) Codec

GetClient returns the client codec by name.

func GetServer

func GetServer(name string) Codec

GetServer returns the server codec by name.

type CommonMeta

type CommonMeta map[interface{}]interface{}

CommonMeta is common meta message.

func (CommonMeta) Clone

func (c CommonMeta) Clone() CommonMeta

Clone returns a copied common meta message.

type Compressor

type Compressor interface {
	Compress(in []byte) (out []byte, err error)
	Decompress(in []byte) (out []byte, err error)
}

Compressor is body compress and decompress interface.

func GetCompressor

func GetCompressor(compressType int) Compressor

GetCompressor returns a specific compressor by type.

type ContextKey

type ContextKey string

ContextKey is trpc context key type, the specific value is judged by interface, the interface will both judge value and type. Defining a new type can avoid string value conflict.

type FBSerialization

type FBSerialization struct{}

FBSerialization provides the flatbuffers serialization mode. Flatbuffers official url: https://google.github.io/flatbuffers

func (*FBSerialization) Marshal

func (*FBSerialization) Marshal(body interface{}) ([]byte, error)

Marshal returns the serialized bytes, body should be a flatbuffers.Builder.

func (*FBSerialization) Unmarshal

func (*FBSerialization) Unmarshal(in []byte, body interface{}) error

Unmarshal deserializes the in bytes into body param, body should implement flatbuffersInit interface.

type Framer

type Framer interface {
	ReadFrame() ([]byte, error)
}

Framer defines how to read a data frame.

type FramerBuilder

type FramerBuilder interface {
	New(io.Reader) Framer
}

FramerBuilder defines how to build a framer. In general, each connection build a framer.

type GzipCompress

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

GzipCompress is gzip compressor.

func (*GzipCompress) Compress

func (c *GzipCompress) Compress(in []byte) ([]byte, error)

Compress returns binary data compressed by gzip.

func (*GzipCompress) Decompress

func (c *GzipCompress) Decompress(in []byte) ([]byte, error)

Decompress returns binary data decompressed by gzip.

type JSONPBSerialization

type JSONPBSerialization struct{}

JSONPBSerialization provides jsonpb serialization mode. It is based on protobuf/jsonpb. This serializer will firstly try jsonpb's serialization. If object does not conform to protobuf proto.Message interface, json-iterator will be used.

func (*JSONPBSerialization) Marshal

func (s *JSONPBSerialization) Marshal(body interface{}) ([]byte, error)

Marshal returns the serialized bytes in jsonpb protocol.

func (*JSONPBSerialization) Unmarshal

func (s *JSONPBSerialization) Unmarshal(in []byte, body interface{}) error

Unmarshal deserialize the in bytes into body.

type JSONSerialization

type JSONSerialization struct{}

JSONSerialization provides json serialization mode. golang official json package is implemented by reflection, and has very low performance. So trpc-go choose json-iterator package to implement json serialization.

func (*JSONSerialization) Marshal

func (s *JSONSerialization) Marshal(body interface{}) ([]byte, error)

Marshal returns the serialized bytes in json protocol.

func (*JSONSerialization) Unmarshal

func (s *JSONSerialization) Unmarshal(in []byte, body interface{}) error

Unmarshal deserializes the in bytes into body.

type MetaData

type MetaData map[string][]byte

MetaData is request penetrate message.

func (MetaData) Clone

func (m MetaData) Clone() MetaData

Clone returns a copied meta data.

type Msg

type Msg interface {
	// Context returns rpc context
	Context() context.Context

	// WithRemoteAddr sets upstream address for server,
	// or downstream address for client.
	WithRemoteAddr(addr net.Addr)

	// WithLocalAddr sets server local address.
	WithLocalAddr(addr net.Addr)

	// RemoteAddr returns upstream address for server,
	// or downstream address for client.
	RemoteAddr() net.Addr

	// LocalAddr returns server local address.
	LocalAddr() net.Addr

	// WithNamespace sets server namespace.
	WithNamespace(string)

	// Namespace returns server namespace.
	Namespace() string

	// WithEnvName sets server environment.
	WithEnvName(string)

	// EnvName returns server environment.
	EnvName() string

	// WithSetName sets server set name.
	WithSetName(string)

	// SetName returns server set name.
	SetName() string

	// WithEnvTransfer sets environment message for transfer.
	WithEnvTransfer(string)

	// EnvTransfer returns environment message for transfer.
	EnvTransfer() string

	// WithRequestTimeout sets the upstream timeout for server,
	// or downstream timeout for client.
	WithRequestTimeout(time.Duration)

	// RequestTimeout returns the upstream timeout for server,
	// or downstream timeout for client.
	RequestTimeout() time.Duration

	// WithSerializationType sets serialization type.
	WithSerializationType(int)

	// SerializationType returns serialization type.
	SerializationType() int

	// WithCompressType sets compress type.
	WithCompressType(int)

	// CompressType returns compress type.
	CompressType() int

	// WithServerRPCName sets server handler method name.
	WithServerRPCName(string)

	// WithClientRPCName sets client rpc name for downstream.
	WithClientRPCName(string)

	// ServerRPCName returns method name of current server handler name,
	// such as /trpc.app.server.service/method.
	ServerRPCName() string

	// ClientRPCName returns method name of downstream interface.
	ClientRPCName() string

	// WithCallerServiceName sets caller service name.
	WithCallerServiceName(string)

	// WithCalleeServiceName sets callee service name.
	WithCalleeServiceName(string)

	// WithCallerApp sets caller app. For server this app is upstream app,
	// but for client, is its own app.
	WithCallerApp(string)

	// WithCallerServer sets caller server. For server this server is upstream server,
	// but for client, is its own server.
	WithCallerServer(string)

	// WithCallerService sets caller service, For server this service is upstream service,
	// but for client, is its own service.
	WithCallerService(string)

	// WithCallerMethod sets caller method, For server this mothod is upstream mothod,
	// but for client, is its own method.
	WithCallerMethod(string)

	// WithCalleeApp sets callee app. For server, this app is its own app,
	// but for client, is downstream's app.
	WithCalleeApp(string)

	// WithCalleeServer sets callee server. For server, this server is its own server,
	// but for client, is downstream's server.
	WithCalleeServer(string)

	// WithCalleeService sets callee service. For server, this service is its own service,
	// but for client, is downstream's service.
	WithCalleeService(string)

	// WithCalleeMethod sets callee method. For server, this method is its own method,
	// but for client, is downstream's method.
	WithCalleeMethod(string)

	// CallerServiceName returns caller service name, such as trpc.app.server.service.
	// For server, this name is upstream's service name, but for client, is its own service name.
	CallerServiceName() string

	// CallerApp returns caller app. For server, this app is upstream's app,
	// but for client, is its own app.
	CallerApp() string

	// CallerServer returns caller server. For server, this is upstream's server,
	// but for client, is its own server.
	CallerServer() string

	// CallerService returns caller service. For server, this service is upstream's service,
	// but for client, is its own service.
	CallerService() string

	// CallerMethod returns caller method. For server, this method is upstream's method,
	// but for client, is its own method.
	CallerMethod() string

	// CalleeServiceName returns callee service name. For server, this name is its own service name,
	// but for client, is downstream's service name.
	CalleeServiceName() string

	// CalleeApp returns callee app. For server, this app is its own app,
	// but for client, is downstream's app.
	CalleeApp() string

	// CalleeServer returns callee server. For server, this server name is its own name,
	// but for client, is downstream's server name.
	CalleeServer() string

	// CalleeService returns callee service. For server, this service is its own service,
	// but for client, is downstream's service.
	CalleeService() string

	// CalleeMethod returns callee method. For server, this method is its own method,
	// but for client, is downstream's method.
	CalleeMethod() string

	// CalleeContainerName sets callee container name.
	CalleeContainerName() string

	// WithCalleeContainerName return callee container name.
	WithCalleeContainerName(string)

	// WithServerMetaData sets server meta data.
	WithServerMetaData(MetaData)

	// ServerMetaData returns server meta data.
	ServerMetaData() MetaData

	// WithFrameHead sets frame head.
	WithFrameHead(interface{})

	// FrameHead returns frame head.
	FrameHead() interface{}

	// WithServerReqHead sets server request head.
	WithServerReqHead(interface{})

	// ServerReqHead returns server request head.
	ServerReqHead() interface{}

	// WithServerRspHead sets server response head, this head will return to upstream.
	WithServerRspHead(interface{})

	// ServerRspHead returns server response head, this head will return to upstream.
	ServerRspHead() interface{}

	// WithDyeing sets dyeing mark.
	WithDyeing(bool)

	// Dyeing returns dyeing mark.
	Dyeing() bool

	// WithDyeingKey sets dyeing key.
	WithDyeingKey(string)

	// DyeingKey returns dyeing key.
	DyeingKey() string

	// WithServerRspErr sets response error for server.
	WithServerRspErr(error)

	// ServerRspErr returns response error for server.
	ServerRspErr() *errs.Error

	// WithClientMetaData sets client meta data.
	WithClientMetaData(MetaData)

	// ClientMetaData returns client meta data.
	ClientMetaData() MetaData

	// WithClientReqHead sets client request head.
	WithClientReqHead(interface{})

	// ClientReqHead returns client request head.
	ClientReqHead() interface{}

	// WithClientRspErr sets response error for client.
	WithClientRspErr(error)

	// ClientRspErr returns response error for client.
	ClientRspErr() error

	// WithClientRspHead sets response head for client.
	WithClientRspHead(interface{})

	// ClientRspHead returns response head for client.
	ClientRspHead() interface{}

	// WithLogger sets logger into context.
	WithLogger(interface{})

	// Logger returns logger from context.
	Logger() interface{}

	// WithRequestID sets request id.
	WithRequestID(uint32)

	// RequestID returns request id.
	RequestID() uint32

	// WithStreamID sets stream id.
	WithStreamID(uint32)

	// StreamID return stream id.
	StreamID() uint32

	// StreamFrame sets stream frame.
	StreamFrame() interface{}

	// WithStreamFrame returns stream frame.
	WithStreamFrame(interface{})

	// WithCalleeSetName sets callee set name.
	WithCalleeSetName(string)

	// CalleeSetName returns callee set name.
	CalleeSetName() string

	// WithCommonMeta sets common meta data.
	WithCommonMeta(CommonMeta)

	// CommonMeta returns common meta data.
	CommonMeta() CommonMeta

	// WithCallType sets call type.
	WithCallType(RequestType)

	// CallType returns call type.
	CallType() RequestType
}

Msg defines core message data for multi protocol, business protocol should set this message when packing and unpacking data.

func EnsureMessage

func EnsureMessage(ctx context.Context) (context.Context, Msg)

EnsureMessage returns context and message, if there is a message in context, returns the original one, if not, returns a new one.

func Message

func Message(ctx context.Context) Msg

Message returns the message of context.

func WithCloneContextAndMessage

func WithCloneContextAndMessage(ctx context.Context) (context.Context, Msg)

WithCloneContextAndMessage creates a new context, then copy the message of current context into new context, this method will return the new context and message for stream mod.

func WithCloneMessage

func WithCloneMessage(ctx context.Context) (context.Context, Msg)

WithCloneMessage copy a new message and put into context, each rpc call should create a new message, this method will be called by client stub.

func WithNewMessage

func WithNewMessage(ctx context.Context) (context.Context, Msg)

WithNewMessage create a new empty message, and put it into ctx,

type NoopCompress

type NoopCompress struct {
}

NoopCompress is an empty compressor

func (*NoopCompress) Compress

func (c *NoopCompress) Compress(in []byte) ([]byte, error)

Compress returns the origin data.

func (*NoopCompress) Decompress

func (c *NoopCompress) Decompress(in []byte) ([]byte, error)

Decompress returns the origin data.

type NoopSerialization

type NoopSerialization struct {
}

NoopSerialization provides empty serialization, it is used to serialize bytes.

func (*NoopSerialization) Marshal

func (s *NoopSerialization) Marshal(body interface{}) ([]byte, error)

Marshal returns the serialized bytes. body should be a Body or implements BytesBodyOut interface.

func (*NoopSerialization) Unmarshal

func (s *NoopSerialization) Unmarshal(in []byte, body interface{}) error

Unmarshal deserializes the in bytes into body, body should be a Body or implements BytesBodyIn interface.

type PBSerialization

type PBSerialization struct{}

PBSerialization provides protobuf serialization mode.

func (*PBSerialization) Marshal

func (s *PBSerialization) Marshal(body interface{}) ([]byte, error)

Marshal returns the serialized bytes in protobuf protocol.

func (*PBSerialization) Unmarshal

func (s *PBSerialization) Unmarshal(in []byte, body interface{}) error

Unmarshal deserializes the in bytes into body.

type RequestType

type RequestType int

RequestType is the type of client request, such as SendAndRecv,SendOnly.

type SafeFramer

type SafeFramer interface {
	Framer
	// IsSafe returns if this framer is safe when concurrent read.
	IsSafe() bool
}

SafeFramer is a special framer, provides an isSafe() method to describe if it is safe when concurrent read.

type Serializer

type Serializer interface {
	// Unmarshal deserialize the in bytes into body
	Unmarshal(in []byte, body interface{}) error

	// Marshal returns the bytes serialized from body.
	Marshal(body interface{}) (out []byte, err error)
}

Serializer defines body serialization interface.

func GetSerializer

func GetSerializer(serializationType int) Serializer

GetSerializer returns the serializer defined by serialization code.

type SnappyBlockCompressor

type SnappyBlockCompressor struct{}

SnappyBlockCompressor is snappy compressor using snappy block format.

func NewSnappyBlockCompressor

func NewSnappyBlockCompressor() *SnappyBlockCompressor

NewSnappyBlockCompressor returns a block format snappy compressor instance.

func (*SnappyBlockCompressor) Compress

func (c *SnappyBlockCompressor) Compress(in []byte) ([]byte, error)

Compress returns binary data compressed by snappy block formats.

func (*SnappyBlockCompressor) Decompress

func (c *SnappyBlockCompressor) Decompress(in []byte) ([]byte, error)

Decompress returns binary data decompressed by snappy block formats.

type SnappyCompress

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

SnappyCompress is snappy compressor using stream snappy format.

There are actually two Snappy formats: block and stream. They are related, but different: trying to decompress block-compressed data as a Snappy stream will fail, and vice versa.

func NewSnappyCompressor

func NewSnappyCompressor() *SnappyCompress

NewSnappyCompressor returns a stream format snappy compressor instance.

func (*SnappyCompress) Compress

func (c *SnappyCompress) Compress(in []byte) ([]byte, error)

Compress returns binary data compressed by snappy stream format.

func (*SnappyCompress) Decompress

func (c *SnappyCompress) Decompress(in []byte) ([]byte, error)

Decompress returns binary data decompressed by snappy stream format.

type XMLSerialization

type XMLSerialization struct{}

XMLSerialization provides xml serialization mode.

func (*XMLSerialization) Marshal

func (*XMLSerialization) Marshal(body interface{}) ([]byte, error)

Marshal returns the serialized bytes in xml protocol.

func (*XMLSerialization) Unmarshal

func (*XMLSerialization) Unmarshal(in []byte, body interface{}) error

Unmarshal deserializes the in bytes into body.

type ZlibCompress

type ZlibCompress struct {
}

ZlibCompress is zlib compressor.

func (*ZlibCompress) Compress

func (c *ZlibCompress) Compress(in []byte) ([]byte, error)

Compress returns binary data compressed by zlib.

func (*ZlibCompress) Decompress

func (c *ZlibCompress) Decompress(in []byte) ([]byte, error)

Decompress returns binary data decompressed by zlib.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL