README

Version 1.0 vs 2.0

Update 2015 Sept 20:

Big news! Version 2.0 of the go-bindings, authored by Ross Light, is now released and newly available! It features capnproto RPC and capabilities support. See https://github.com/zombiezen/go-capnproto2 for the v2 code and docs.

This repository (https://github.com/glycerine/go-capnproto) is now being called version 1.0 of the go bindings for capnproto. It does not have RPC (it was created before the RPC protocol was defined). Version 1 has schema generating tools such as https://github.com/glycerine/bambam. Personally I have many projects that use v1 with mangos for network transport; https://github.com/gdamore/mangos. Here is an example of using them together: https://github.com/glycerine/goq. Nonetheless, for new projects, especially once v2 has been hardened and tested, v2 should be preferred.

Version 1 will be maintained for applications that currently use it. However new users, new features and new code contributions should be directed to the version 2 code base to take advantage of the RPC and capabilities.

License

MIT - see LICENSE file

Documentation

In godoc see http://godoc.org/github.com/glycerine/go-capnproto

News

5 April 2014: James McKaskill, the author of go-capnproto (https://github.com/jmckaskill/go-capnproto), has been super busy of late, so I agreed to take over as maintainer. This branch (https://github.com/glycerine/go-capnproto) includes my recent work to fix bugs in the creation (originating) of structs for Go, and an implementation of the packing/unpacking capnp specification. Thanks to Albert Strasheim (https://github.com/alberts/go-capnproto) of CloudFlare for a great set of packing tests. - Jason

Getting started

New! Visit the sibling project to this one, bambam, to automagically generate a capnproto schema from the struct definitions in your go source files. Bambam makes it easy to get starting with go-capnproto.

pre-requisite: Due to the use of the customtype annotation feature, you will need a relatively recent capnproto installation. At or after 1 July 2014 (at or after b2d752beac5436bada2712f1a23185b78063e6fa) is known to work.

# first: be sure you have your GOPATH env variable setup.
$ go get -u -t github.com/glycerine/go-capnproto
$ cd $GOPATH/src/github.com/glycerine/go-capnproto
$ make # will install capnpc-go and compile the test schema aircraftlib/aircraft.capnp, which is used in the tests.
$ diff ./capnpc-go/capnpc-go `which capnpc-go` # you should verify that you are using the capnpc-go binary you just built. There should be no diff. Adjust your PATH if necessary to include the binary capnpc-go that you just built/installed from ./capnpc-go/capnpc-go.
$ go test -v  # confirm all tests are green

What is Cap'n Proto?

The best cerealization...

http://kentonv.github.io/capnproto/

Documentation

Overview

Package capn is a capnproto library for go

see http://kentonv.github.io/capnproto/

capnpc-go provides the compiler backend for capnp after installing to $PATH capnp files can be compiled with

capnp compile -ogo *.capnp

capnpc-go requires two annotations for all types. This is the package and import found in go.capnp. Package is needed to know what package to place at the head of the generated file and what go name to use when referring to the type from another package. Import should be the fully qualified import path and is used to generate import statement from other packages and to detect when two types are in the same package. Typically these are added as file annotations. For example:

using Go = import "github.com/glycerine/go-capnproto/go.capnp";
$Go.package("main");
$Go.import("github.com/glycerine/go-capnproto/example");

In capnproto, the unit of communication is a message. A message consists of one or more of segments to allow easier allocation, but ideally and typically you just make one segment per message.

Logically, a message organized in a tree of objects, with the root always being a struct (as opposed to a list or primitive).

Here is an example of writing a new message. We use the demo schema aircraft.capnp from the aircraftlib directory. You may wish to read the schema before reading this example.

<< Example moved to its own file: See the file, write_test.go >>

In summary, when you make a new message, you should first make new segment, and then create the root struct in that segment. Then add your non-child (contained) objects. This is because, as the spec says:

The first word of the first segment of the message
is always a pointer pointing to the message's root
struct.

All objects are values with pointer semantics that point into the data in a message or segment. Messages can be read/written from a stream uncompressed or using the capnproto compression.

In this library a *Segment is taken to refer to both a specific segment as well as the containing message. This is to reduce the number of types generic code needs to deal with and allows objects to be created in the same segment as their outer object (thus reducing the number of far pointers).

Most getters/setters in the library don't return an error. Instead a get that fails due to an invalid pointer, out of bounds, etc will return the default value. A invalid set will be noop'ed. If you really need to know whether a set succeeds then errors are provided by the lower level Object methods.

Since go doesn't have any templating, lists are created for the basic types and one level of named types. The list of basic types (e.g. List(UInt8), List(Text), etc) are all provided in this library. Lists of user named types are created with the user types (e.g. user struct Foo will create a Foo_List type). capnp schemas that use deeper lists (e.g. List(List(UInt8))) will use PointerList and the user will have to use the Object.ToList* functions to cast to the correct type.

For adding documentation comments to the generated code, there's the doc annotation. This annotation adds the comment to a struct, enum or field so that godoc will pick it up. For Example:

struct Zdate $Go.doc("Zdate represents an instance in time") {
  year  @0   :Int16;
  month @1   :UInt8;
  day   @2   :UInt8 ;
}

Structs

capnpc-go will generate the following for structs:

// Foo is a value with pointer semantics referencing the data in a
// segment. Member functions are provided to get/set members in the
// struct. Getters/setters of an outer struct will use values of type
// Foo to set/get pointers.
type Foo capn.Struct

// NewFoo creates a new orphaned Foo struct. This can then be added to
// a message by using a Set function which takes a Foo argument.
func NewFoo(s *capn.Segment) Foo

// NewRootFoo creates a new root of type Foo in the next unused space in the
// provided segment. This is distinct from NewFoo as this always
// creates a root tag. Typically the provided segment should be empty.
// Remember that a message is a tree of objects with a single root, and
// you usually have to create the root before any other object in a
// segment. The only exception would be for a multi-segment message.
func NewRootFoo(s *capn.Segment) Foo

// ReadRootFoo reads the root tag at the beginning of the provided
// segment and returns it as a Foo struct.
func ReadRootFoo(s *capn.Segment) Foo

// Foo_List is a value with pointer semantics. It is created for all
// structs, and is used for List(Foo) in the capnp file.
type Foo_List capn.List

// NewFooList creates a new orphaned List(Foo). This can then be added
// to a message by using a Set function which takes a Foo_List. sz
// specifies the list size. Due to the list using memory directly in
// the outgoing buffer (i.e. arena style memory management), the size
// can not be changed after creation.
func NewFooList(s *capn.Segment, sz int) Foo_List

// Len returns the list length. For composite lists this is the number
// of list elements.
func (s Foo_List) Len() int

// At returns a pointer to the i'th element. If i is an invalid index,
// this will return a null Foo (all getters will return default
// values, setters will fail). For a composite list the returned value
// will be a list member. Setting another value to point to list
// members forces a copy of the data. For pointer lists, the pointer
// value will be auto-derefenced.
func (s Foo_List) At(i int) Foo

// ToArray converts the capnproto list into a go list. For large lists
// this is inefficient as it has to read all elements. This can be
// quite convenient especially for iterating as it lets you use a for
// range clause:
//	for i, f := range mylist.ToArray() {}
func (s Foo_List) ToArray() []Foo

Groups

For each group a typedef is created with a different method set for just the groups fields:

struct Foo {
	group :Group {
		field @0 :Bool;
	}
}

type Foo capn.Struct
type FooGroup Foo

func (s Foo) Group() FooGroup
func (s FooGroup) Field() bool

That way the following may be used to access a field in a group:

var f Foo
value := f.Group().Field()

Note that Group accessors just cast the type and so have no overhead

func (s Foo) Group() FooGroup {return FooGroup(s)}

Unions

Named unions are treated as a group with an inner unnamed union. Unnamed unions generate an enum Type_Which and a corresponding Which() function:

struct Foo {
	union {
		a @0 :Bool;
		b @1 :Bool;
	}
}

type Foo_Which uint16

const (
	FOO_A Foo_Which = 0
	FOO_B           = 1
)

func (s Foo) A() bool
func (s Foo) B() bool
func (s Foo) SetA(v bool)
func (s Foo) SetB(v bool)
func (s Foo) Which() Foo_Which

Which() should be checked before using the getters, and the default case must always be handled.

Setters for single values will set the union discriminator as well as set the value.

For voids in unions, there is a void setter that just sets the discriminator. For example:

struct Foo {
	union {
		a @0 :Void;
		b @1 :Void;
	}
}

f.SetA() // Set that we are using A
f.SetB() // Set that we are using B

For groups in unions, there is a group setter that just sets the discriminator. This must be called before the group getter can be used to set values. For example:

struct Foo {
	union {
		a :group {
			v :Bool
		}
		b :group {
			v :Bool
		}
	}
}

f.SetA()         // Set that we are using group A
f.A().SetV(true) // then we can use the group A getter to set the inner values

Enums

capnpc-go generates enum values in all caps. For example in the capnp file:

enum ElementSize {
  empty @0;
  bit @1;
  byte @2;
  twoBytes @3;
  fourBytes @4;
  eightBytes @5;
  pointer @6;
  inlineComposite @7;
}

In the generated capnp.go file:

type ElementSize uint16

const (
	ELEMENTSIZE_EMPTY           ElementSize = 0
	ELEMENTSIZE_BIT                         = 1
	ELEMENTSIZE_BYTE                        = 2
	ELEMENTSIZE_TWOBYTES                    = 3
	ELEMENTSIZE_FOURBYTES                   = 4
	ELEMENTSIZE_EIGHTBYTES                  = 5
	ELEMENTSIZE_POINTER                     = 6
	ELEMENTSIZE_INLINECOMPOSITE             = 7
)

In addition an enum.String() function is generated that will convert the constants to a string for debugging or logging purposes. By default, the enum name is used as the tag value, but the tags can be customized with a $Go.tag or $Go.notag annotation.

For example:

enum ElementSize {
	empty @0           $Go.tag("void");
	bit @1             $Go.tag("1 bit");
	byte @2            $Go.tag("8 bits");
	inlineComposite @7 $Go.notag;
}

In the generated go file:

func (c ElementSize) String() string {
	switch c {
	case ELEMENTSIZE_EMPTY:
		return "void"
	case ELEMENTSIZE_BIT:
		return "1 bit"
	case ELEMENTSIZE_BYTE:
		return "8 bits"
	default:
		return ""
	}
}

Index

Examples

Constants

View Source
const (
	S_NORMAL DecompParseState = 0

	// The 1-3 states are for dealing with the 0xFF tag and the raw bytes that follow.
	// They tell us where to pick up if we are interrupted in the middle of anything
	// after the 0xFF tag, until we are done with the raw read.
	S_POSTFF = 1
	S_READN  = 2
	S_RAW    = 3
)
View Source
const CanonicalizableOn = true
View Source
const Customtype = uint64(0xfa10659ae02f2093)
View Source
const Doc = uint64(0xc58ad6bd519f935e)
View Source
const Import = uint64(0xe130b601260e44b5)
View Source
const JSON_enabled = true

    If you want to omit the json support in the generated code, to save space, it can be disabled here.

    View Source
    const Name = uint64(0xc2b96012172f8df1)
    View Source
    const Notag = uint64(0xc8768679ec52e012)
    View Source
    const Package = uint64(0xbea97f1023792be0)
    View Source
    const Tag = uint64(0xa574b41924caefc7)
    View Source
    const VerboseCompress = false
    View Source
    const VerboseDecomp = false

      externally available flag for compiling with debug info on/off

      Variables

      View Source
      var (
      	ErrOverlarge   = errors.New("capn: overlarge struct/list")
      	ErrOutOfBounds = errors.New("capn: write out of bounds")
      	ErrCopyDepth   = errors.New("capn: copy depth too large")
      	ErrOverlap     = errors.New("capn: overlapping data on copy")
      )
      View Source
      var (
      	ErrInvalidSegment = errors.New("capn: invalid segment id")
      	ErrTooMuchData    = errors.New("capn: too much data in stream")
      )
      View Source
      var (
      	MaxSegmentNumber = 1024
      	MaxTotalSize     = 1024 * 1024 * 1024
      )
      View Source
      var Zerohi32 uint64

        used in orable30BitOffsetPart() and signedOffsetFromStructPointer()

        Functions

        func A

        func A(val uint64) int

        func B

        func B(val uint64) int

        func CopyToFrom

        func CopyToFrom(dest, src Object) error

          For manually copying between segments. Not typically needed.

          func ListC

          func ListC(val uint64) int

          func ListCString

          func ListCString(val uint64) string

          func ListD

          func ListD(val uint64) int

          func ReadFromMemoryZeroCopyNoAlloc

          func ReadFromMemoryZeroCopyNoAlloc(data []byte, multi *MultiBuffer) (bytesRead int64, err error)

            ReadFromMemoryZeroCopyNoAlloc: like ReadFromMemoryZeroCopy, but avoid all allocations so we get zero GC pressure.

            This requires some strict but easy to meet pre-requisites:

            PRE: the capnp bytes in data must come from only one segment. Else we panic. PRE: multi must point to an existing MultiBuffer that has exactly one Segment

            that will be re-used and over-written. If in doubt,
            you can allocate a correct new one the first time
            by calling NewSingleSegmentMultiBuffer().
            

            func StructC

            func StructC(val uint64) int

            func StructD

            func StructD(val uint64) int

            Types

            type BitList

            type BitList Object

            func (BitList) At

            func (p BitList) At(i int) bool

            func (BitList) Len

            func (p BitList) Len() int

            func (BitList) Set

            func (p BitList) Set(i int, v bool)

            func (BitList) ToArray

            func (p BitList) ToArray() []bool

            type Compressor

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

            func NewCompressor

            func NewCompressor(w io.Writer) *Compressor

            func (*Compressor) Write

            func (c *Compressor) Write(v []byte) (n int, err error)

            type DataList

            type DataList Object

            func (DataList) At

            func (p DataList) At(i int) []byte

            func (DataList) Len

            func (p DataList) Len() int

            func (DataList) Set

            func (p DataList) Set(i int, v []byte)

            func (DataList) ToArray

            func (p DataList) ToArray() [][]byte

            type DecompParseState

            type DecompParseState uint8

            type Decompressor

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

            func NewDecompressor

            func NewDecompressor(r io.Reader) *Decompressor

            func (*Decompressor) Read

            func (c *Decompressor) Read(v []byte) (n int, err error)

            type Float32List

            type Float32List Object

            func (Float32List) At

            func (p Float32List) At(i int) float32

            func (Float32List) Len

            func (p Float32List) Len() int

            func (Float32List) Set

            func (p Float32List) Set(i int, v float32)

            func (Float32List) ToArray

            func (p Float32List) ToArray() []float32

            type Float64List

            type Float64List Object

            func (Float64List) At

            func (p Float64List) At(i int) float64

            func (Float64List) Len

            func (p Float64List) Len() int

            func (Float64List) Set

            func (p Float64List) Set(i int, v float64)

            func (Float64List) ToArray

            func (p Float64List) ToArray() []float64

            type Int16List

            type Int16List Object

            func (Int16List) At

            func (p Int16List) At(i int) int16

            func (Int16List) Len

            func (p Int16List) Len() int

            func (Int16List) Set

            func (p Int16List) Set(i int, v int16)

            func (Int16List) ToArray

            func (p Int16List) ToArray() []int16

            type Int32List

            type Int32List Object

            func (Int32List) At

            func (p Int32List) At(i int) int32

            func (Int32List) Len

            func (p Int32List) Len() int

            func (Int32List) Set

            func (p Int32List) Set(i int, v int32)

            func (Int32List) ToArray

            func (p Int32List) ToArray() []int32

            type Int64List

            type Int64List Object

            func (Int64List) At

            func (p Int64List) At(i int) int64

            func (Int64List) Len

            func (p Int64List) Len() int

            func (Int64List) Set

            func (p Int64List) Set(i int, v int64)

            func (Int64List) ToArray

            func (p Int64List) ToArray() []int64

            func (Int64List) ToIntArray

            func (p Int64List) ToIntArray() []int

            type Int8List

            type Int8List Object

            func (Int8List) At

            func (p Int8List) At(i int) int8

            func (Int8List) Len

            func (p Int8List) Len() int

            func (Int8List) Set

            func (p Int8List) Set(i int, v int8)

            func (Int8List) ToArray

            func (p Int8List) ToArray() []int8

            type Message

            type Message interface {
            	NewSegment(minsz int) (*Segment, error)
            	Lookup(segid uint32) (*Segment, error)
            }

            type MultiBuffer

            type MultiBuffer struct {
            	Segments []*Segment
            }

            func NewSingleSegmentMultiBuffer

            func NewSingleSegmentMultiBuffer() *MultiBuffer

            func (*MultiBuffer) Lookup

            func (m *MultiBuffer) Lookup(segid uint32) (*Segment, error)

            func (*MultiBuffer) NewSegment

            func (m *MultiBuffer) NewSegment(minsz int) (*Segment, error)

            type Object

            type Object struct {
            	Segment *Segment
            	// contains filtered or unexported fields
            }

            func (Object) DupWithOff

            func (o Object) DupWithOff(off int) Object

            func (Object) HasData

            func (p Object) HasData() bool

            func (Object) ToBitList

            func (p Object) ToBitList() BitList

            func (Object) ToData

            func (p Object) ToData() []byte

            func (Object) ToDataDefault

            func (p Object) ToDataDefault(def []byte) []byte

            func (Object) ToDataDefaultTrimLastByte

            func (p Object) ToDataDefaultTrimLastByte(def []byte) []byte

            func (Object) ToDataList

            func (p Object) ToDataList() DataList

            func (Object) ToDataTrimLastByte

            func (p Object) ToDataTrimLastByte() []byte

            func (Object) ToFloat32List

            func (p Object) ToFloat32List() Float32List

            func (Object) ToFloat64List

            func (p Object) ToFloat64List() Float64List

            func (Object) ToInt16List

            func (p Object) ToInt16List() Int16List

            func (Object) ToInt32List

            func (p Object) ToInt32List() Int32List

            func (Object) ToInt64List

            func (p Object) ToInt64List() Int64List

            func (Object) ToInt8List

            func (p Object) ToInt8List() Int8List

            func (Object) ToListDefault

            func (p Object) ToListDefault(s *Segment, tagoff int) Object

            func (Object) ToObjectDefault

            func (p Object) ToObjectDefault(s *Segment, tagoff int) Object

            func (Object) ToPointerList

            func (p Object) ToPointerList() PointerList

            func (Object) ToStruct

            func (p Object) ToStruct() Struct

            func (Object) ToStructDefault

            func (p Object) ToStructDefault(s *Segment, tagoff int) Struct

            func (Object) ToText

            func (p Object) ToText() string

            func (Object) ToTextDefault

            func (p Object) ToTextDefault(def string) string

            func (Object) ToTextList

            func (p Object) ToTextList() TextList

            func (Object) ToUInt16List

            func (p Object) ToUInt16List() UInt16List

            func (Object) ToUInt32List

            func (p Object) ToUInt32List() UInt32List

            func (Object) ToUInt64List

            func (p Object) ToUInt64List() UInt64List

            func (Object) ToUInt8List

            func (p Object) ToUInt8List() UInt8List

            func (Object) ToVoidList

            func (p Object) ToVoidList() VoidList

            func (Object) Type

            func (p Object) Type() ObjectType

            type ObjectType

            type ObjectType uint8
            const (
            	TypeNull ObjectType = iota
            	TypeStruct
            	TypeList
            	TypePointerList
            	TypeBitList
            )

            func (ObjectType) String

            func (o ObjectType) String() string

            type PointerList

            type PointerList Object

            func (PointerList) At

            func (p PointerList) At(i int) Object

            func (PointerList) Len

            func (p PointerList) Len() int

            func (PointerList) Set

            func (p PointerList) Set(i int, src Object) error

            func (PointerList) ToArray

            func (p PointerList) ToArray() *[]Object

            type Segment

            type Segment struct {
            	Message  Message
            	Data     []uint8
            	Id       uint32
            	RootDone bool
            }

            func NewBuffer

            func NewBuffer(data []byte) *Segment

              NewBuffer creates an expanding single segment buffer. Creating new objects will expand the buffer. Data can be nil (or length 0 with some capacity) if creating a new session. If parsing an existing segment then data should be the segment contents and will not be copied.

              func NewMultiBuffer

              func NewMultiBuffer(data [][]byte) *Segment

                NewMultiBuffer creates a new multi segment message. Creating new objects will try and reuse the buffers available, but will create new ones if there is insufficient capacity. When parsing an existing message data should be the list of segments. The data buffers will not be copied.

                func ReadFromMemoryZeroCopy

                func ReadFromMemoryZeroCopy(data []byte) (seg *Segment, bytesRead int64, err error)

                  ReadFromMemoryZeroCopy: like ReadFromStream, but reads a non-packed serialized stream that already resides in memory in the argument data. The returned segment is the first segment read, which contains the root pointer. The returned bytesRead says how many bytes were consumed from data in making seg. The caller should advance the data slice by doing data = data[bytesRead:] between successive calls to ReadFromMemoryZeroCopy().

                  func ReadFromPackedStream

                  func ReadFromPackedStream(r io.Reader, buf *bytes.Buffer) (*Segment, error)

                    ReadFromPackedStream reads a single message from the stream r in packed form returning the first segment. buf can be specified in order to reuse the buffer (or it is allocated each call if nil).

                    func ReadFromStream

                    func ReadFromStream(r io.Reader, buf *bytes.Buffer) (*Segment, error)

                      ReadFromStream reads a non-packed serialized stream from r. buf is used to buffer the read contents, can be nil, and is provided so that the buffer can be reused between messages. The returned segment is the first segment read, which contains the root pointer.

                      Warning about buf reuse: It is safer to just pass nil for buf. When making multiple calls to ReadFromStream() with the same buf argument, you may overwrite the data in a previously returned Segment. The re-use of buf is an optimization for when you are actually done with any previously returned Segment which may have data still alive in buf.

                      Example
                      Output:
                      
                      

                      func (*Segment) NewBitList

                      func (s *Segment) NewBitList(sz int) BitList

                      func (*Segment) NewCompositeList

                      func (s *Segment) NewCompositeList(datasz, ptrs, length int) PointerList

                      func (*Segment) NewData

                      func (s *Segment) NewData(v []byte) Object

                      func (*Segment) NewDataList

                      func (s *Segment) NewDataList(sz int) DataList

                      func (*Segment) NewFloat32List

                      func (s *Segment) NewFloat32List(sz int) Float32List

                      func (*Segment) NewFloat64List

                      func (s *Segment) NewFloat64List(sz int) Float64List

                      func (*Segment) NewInt16List

                      func (s *Segment) NewInt16List(sz int) Int16List

                      func (*Segment) NewInt32List

                      func (s *Segment) NewInt32List(sz int) Int32List

                      func (*Segment) NewInt64List

                      func (s *Segment) NewInt64List(sz int) Int64List

                      func (*Segment) NewInt8List

                      func (s *Segment) NewInt8List(sz int) Int8List

                      func (*Segment) NewPointerList

                      func (s *Segment) NewPointerList(sz int) PointerList

                      func (*Segment) NewRoot

                      func (s *Segment) NewRoot() (PointerList, int, error)

                      func (*Segment) NewRootStruct

                      func (s *Segment) NewRootStruct(datasz, ptrs int) Struct

                      func (*Segment) NewStruct

                      func (s *Segment) NewStruct(datasz, ptrs int) Struct

                      func (*Segment) NewStructAR

                      func (s *Segment) NewStructAR(datasz, ptrs int) Struct

                        NewStructAR (AutoRoot): experimental Root setting: assumes the struct is the root iff it is the first allocation in a segment.

                        func (*Segment) NewText

                        func (s *Segment) NewText(v string) Object

                        func (*Segment) NewTextList

                        func (s *Segment) NewTextList(sz int) TextList

                        func (*Segment) NewUInt16List

                        func (s *Segment) NewUInt16List(sz int) UInt16List

                        func (*Segment) NewUInt32List

                        func (s *Segment) NewUInt32List(sz int) UInt32List

                        func (*Segment) NewUInt64List

                        func (s *Segment) NewUInt64List(sz int) UInt64List

                        func (*Segment) NewUInt8List

                        func (s *Segment) NewUInt8List(sz int) UInt8List

                        func (*Segment) NewVoidList

                        func (s *Segment) NewVoidList(sz int) VoidList

                          func (s *Segment) NewVoidList(sz int) VoidList { return VoidList{typ: TypeList, length: sz, datasz: 0} }

                          func (*Segment) Root

                          func (s *Segment) Root(off int) Object

                          func (*Segment) WriteTo

                          func (s *Segment) WriteTo(w io.Writer) (int64, error)

                            WriteTo writes the message that the segment is part of to the provided stream in serialized form.

                            func (*Segment) WriteToPacked

                            func (s *Segment) WriteToPacked(w io.Writer) (int64, error)

                              WriteToPacked writes the message that the segment is part of to the provided stream in packed form.

                              type Struct

                              type Struct Object

                              func (Struct) Get1

                              func (p Struct) Get1(bitoff int) bool

                              func (Struct) Get16

                              func (p Struct) Get16(off int) uint16

                              func (Struct) Get32

                              func (p Struct) Get32(off int) uint32

                              func (Struct) Get64

                              func (p Struct) Get64(off int) uint64

                              func (Struct) Get8

                              func (p Struct) Get8(off int) uint8

                              func (Struct) GetObject

                              func (p Struct) GetObject(off int) Object

                              func (Struct) Set1

                              func (p Struct) Set1(bitoff int, v bool)

                              func (Struct) Set16

                              func (p Struct) Set16(off int, v uint16)

                              func (Struct) Set32

                              func (p Struct) Set32(off int, v uint32)

                              func (Struct) Set64

                              func (p Struct) Set64(off int, v uint64)

                              func (Struct) Set8

                              func (p Struct) Set8(off int, v uint8)

                              func (Struct) SetObject

                              func (p Struct) SetObject(i int, src Object)

                              type TextList

                              type TextList Object

                              func (TextList) At

                              func (p TextList) At(i int) string

                              func (TextList) AtAsBytes

                              func (p TextList) AtAsBytes(i int) []byte

                              func (TextList) Len

                              func (p TextList) Len() int

                              func (TextList) Set

                              func (p TextList) Set(i int, v string)

                              func (TextList) ToArray

                              func (p TextList) ToArray() []string

                              type UInt16List

                              type UInt16List Object

                              func (UInt16List) At

                              func (p UInt16List) At(i int) uint16

                              func (UInt16List) Len

                              func (p UInt16List) Len() int

                              func (UInt16List) Set

                              func (p UInt16List) Set(i int, v uint16)

                              func (UInt16List) ToArray

                              func (p UInt16List) ToArray() []uint16

                              func (UInt16List) ToEnumArray

                              func (p UInt16List) ToEnumArray() *[]uint16

                              type UInt32List

                              type UInt32List Object

                              func (UInt32List) At

                              func (p UInt32List) At(i int) uint32

                              func (UInt32List) Len

                              func (p UInt32List) Len() int

                              func (UInt32List) Set

                              func (p UInt32List) Set(i int, v uint32)

                              func (UInt32List) ToArray

                              func (p UInt32List) ToArray() []uint32

                              type UInt64List

                              type UInt64List Object

                              func (UInt64List) At

                              func (p UInt64List) At(i int) uint64

                              func (UInt64List) Len

                              func (p UInt64List) Len() int

                              func (UInt64List) Set

                              func (p UInt64List) Set(i int, v uint64)

                              func (UInt64List) ToArray

                              func (p UInt64List) ToArray() []uint64

                              type UInt8List

                              type UInt8List Object

                              func (UInt8List) At

                              func (p UInt8List) At(i int) uint8

                              func (UInt8List) Len

                              func (p UInt8List) Len() int

                              func (UInt8List) Set

                              func (p UInt8List) Set(i int, v uint8)

                              func (UInt8List) ToArray

                              func (p UInt8List) ToArray() []uint8

                                UInt8List.ToArray contains an important optimization: the returned slice points directly to the underlying segment bytes, not a copy. This is typically what is wanted, but be aware if you change the segment you will change the contents of the returned byte slice.

                                type Void

                                type Void struct{}

                                type VoidList

                                type VoidList Object

                                func (VoidList) Len

                                func (p VoidList) Len() int

                                Directories

                                Path Synopsis