restruct: github.com/go-restruct/restruct Index | Files

package restruct

import "github.com/go-restruct/restruct"

Package restruct implements packing and unpacking of raw binary formats.

Structures can be created with struct tags annotating the on-disk or in-memory layout of the structure, using the "struct" struct tag, like so:

struct {
	Length int `struct:"int32,sizeof=Packets"`
	Packets []struct{
		Source    string    `struct:"[16]byte"`
		Timestamp int       `struct:"int32,big"`
		Data      [256]byte `struct:"skip=8"`
	}
}

To unpack data in memory to this structure, simply use Unpack with a byte slice:

msg := Message{}
restruct.Unpack(data, binary.LittleEndian, &msg)

Index

Package Files

arrayof_15.go decoder.go encoder.go field.go packing.go tag.go typestr.go

func Pack Uses

func Pack(order binary.ByteOrder, v interface{}) (data []byte, err error)

Pack writes data from a datastructure into a byteslice.

Two types of values are directly supported here: Packers and structs. You can pass them by value or by pointer.

Each structure is serialized in the same way it would be deserialized with Unpack. See Unpack documentation for the struct tag format.

func RegisterArrayType Uses

func RegisterArrayType(array interface{})

RegisterArrayType registers an array type for use with struct tags. This function is only necessary on Go 1.4 and below, which do not provide reflect.ArrayOf. This function is goroutine safe and idempotent (i.e., calling it multiple times with the same value is perfectly safe.) If you require Go 1.5 or above, you can safely use any array type in your struct tags without using this function.

func SizeOf Uses

func SizeOf(v interface{}) (size int, err error)

SizeOf returns the serialized size of the structure passed, in memory.

func Unpack Uses

func Unpack(data []byte, order binary.ByteOrder, v interface{}) (err error)

Unpack reads data from a byteslice into a value.

Two types of values are directly supported here: Unpackers and structs. You can pass them by value or by pointer, although it is an error if Restruct is unable to set a value because it is unaddressable.

For structs, each field will be read sequentially based on a straightforward interpretation of the type. For example, an int32 will be read as a 32-bit signed integer, taking 4 bytes of memory. Structures and arrays are laid out flat with no padding or metadata.

Unexported fields are ignored, except for fields named _ - those fields will be treated purely as padding. Padding will not be preserved through packing and unpacking.

The behavior of deserialization can be customized using struct tags. The following struct tag syntax is supported:

`struct:"[flags...]"`

Flags are comma-separated keys. The following are available:

type            A bare type name, e.g. int32 or []string.

sizeof=[Field]  Specifies that the field should be treated as a count of
                the number of elements in Field.

skip=[Count]    Skips Count bytes before the field. You can use this to
                e.g. emulate C structure alignment.

big,msb         Specifies big endian byte order. When applied to structs,
                this will apply to all fields under the struct.

little,lsb      Specifies little endian byte order. When applied to structs,
                this will apply to all fields under the struct.

type Packer Uses

type Packer interface {
    Sizer
    Pack(buf []byte, order binary.ByteOrder) ([]byte, error)
}

Packer is a type capable of packing a native value into a binary representation. The Pack function is expected to overwrite a number of bytes in buf then return a slice of the remaining buffer. Note that you must also implement SizeOf, and returning an incorrect SizeOf will cause the encoder to crash. The SizeOf should be equal to the number of bytes consumed from the buffer slice in Pack. You may use a pointer receiver even if the type is used by value.

type Sizer Uses

type Sizer interface {
    SizeOf() int
}

Sizer is a type which has a defined size in binary. The SizeOf function returns how many bytes the type will consume in memory. This is used during encoding for allocation and therefore must equal the exact number of bytes the encoded form needs. You may use a pointer receiver even if the type is used by value.

type Unpacker Uses

type Unpacker interface {
    Unpack(buf []byte, order binary.ByteOrder) ([]byte, error)
}

Unpacker is a type capable of unpacking a binary representation of itself into a native representation. The Unpack function is expected to consume a number of bytes from the buffer, then return a slice of the remaining bytes in the buffer. You may use a pointer receiver even if the type is used by value.

Package restruct imports 12 packages (graph). Updated 2017-06-18. Refresh now. Tools for package owners.