Why Go
- Case Studies
  
  Common problems companies solve with Go
- Use Cases
  
  Stories about how and why companies use Go
- Security Policy
  
  How Go can help keep you secure by default
Learn
Docs
- Effective Go
  
  Tips for writing clear, performant, and idiomatic Go code
- Go User Manual
  
  A complete introduction to building software with Go
- Standard library
  
  Reference documentation for Go's standard library
- Release Notes
  
  Learn what's new in each Go release
Packages
Community
- Recorded Talks
  
  Videos from prior events
- Meetups
  
  Meet other local Go developers
- Conferences
  
  Learn and network with Go developers from around the world
- Go blog
  
  The Go project's official blog.
- Go project
  
  Get help and stay informed from Go
- Get connected

zed21

package

Go to main page

Versions in this module

v1

v1.3.0

Nov 21, 2022

v1.2.0

Jul 14, 2022

v1.1.0

May 14, 2022

v1.0.0

Mar 26, 2022

Changes in this version

+ const AppEncodingBinary

+ const AppEncodingJSON

+ const AppEncodingString

+ const AppEncodingZNG

+ const AppEncodingZSON

+ const CtrlAppMessage

+ const CtrlCompressed

+ const CtrlEOS

+ const CtrlValueEscape

+ const IDBool

+ const IDBstring

+ const IDBytes

+ const IDDecimal

+ const IDDuration

+ const IDError

+ const IDFloat16

+ const IDFloat32

+ const IDFloat64

+ const IDIP

+ const IDInt16

+ const IDInt32

+ const IDInt64

+ const IDInt8

+ const IDNet

+ const IDNull

+ const IDString

+ const IDTime

+ const IDType

+ const IDTypeArray

+ const IDTypeDef

+ const IDTypeEnum

+ const IDTypeMap

+ const IDTypeName

+ const IDTypeRecord

+ const IDTypeSet

+ const IDTypeUnion

+ const IDUint16

+ const IDUint32

+ const IDUint64

+ const IDUint8

+ const MaxColumns

+ const MaxEnumSymbols

+ const MaxUnionTypes

+ const TypeDefArray

+ const TypeDefEnum

+ const TypeDefMap

+ const TypeDefNamed

+ const TypeDefRecord

+ const TypeDefSet

+ const TypeDefUnion

+ var ErrEnumIndex = errors.New("enum index out of bounds")

+ var ErrIndex = errors.New("array index out of bounds")

+ var ErrMissing = errors.New("missing")

+ var ErrNotArray = errors.New("cannot index a non-array")

+ var ErrTypeSyntax = errors.New("syntax error parsing type string")

+ var ErrUnionSelector = errors.New("union selector out of bounds")

+ var False = &Value

+ var Missing = &Value

+ var Null = &Value

+ var NullBool = &Value

+ var NullBytes = &Value

+ var NullDuration = &Value

+ var NullFloat32 = &Value

+ var NullFloat64 = &Value

+ var NullIP = &Value

+ var NullInt16 = &Value

+ var NullInt32 = &Value

+ var NullInt64 = &Value

+ var NullInt8 = &Value

+ var NullNet = &Value

+ var NullString = &Value

+ var NullTime = &Value

+ var NullType = &Value

+ var NullUint16 = &Value

+ var NullUint32 = &Value

+ var NullUint64 = &Value

+ var NullUint8 = &Value

+ var Quiet = &Value

+ var True = &Value

+ var TypeBool = &TypeOfBool

+ var TypeBstring = &TypeOfBstring

+ var TypeBytes = &TypeOfBytes

+ var TypeDuration = &TypeOfDuration

+ var TypeError = &TypeOfError

+ var TypeFloat32 = &TypeOfFloat32

+ var TypeFloat64 = &TypeOfFloat64

+ var TypeIP = &TypeOfIP

+ var TypeInt16 = &TypeOfInt16

+ var TypeInt32 = &TypeOfInt32

+ var TypeInt64 = &TypeOfInt64

+ var TypeInt8 = &TypeOfInt8

+ var TypeNet = &TypeOfNet

+ var TypeNull = &TypeOfNull

+ var TypeString = &TypeOfString

+ var TypeTime = &TypeOfTime

+ var TypeType = &TypeOfType

+ var TypeUint16 = &TypeOfUint16

+ var TypeUint32 = &TypeOfUint32

+ var TypeUint64 = &TypeOfUint64

+ var TypeUint8 = &TypeOfUint8

+ func AppendBool(zb zcode.Bytes, b bool) zcode.Bytes

+ func AppendDuration(bytes zcode.Bytes, d nano.Duration) zcode.Bytes

+ func AppendFloat32(zb zcode.Bytes, f float32) zcode.Bytes

+ func AppendFloat64(zb zcode.Bytes, d float64) zcode.Bytes

+ func AppendIP(zb zcode.Bytes, a net.IP) zcode.Bytes

+ func AppendInt(bytes zcode.Bytes, i int64) zcode.Bytes

+ func AppendNet(zb zcode.Bytes, subnet *net.IPNet) zcode.Bytes

+ func AppendTime(bytes zcode.Bytes, t nano.Ts) zcode.Bytes

+ func AppendUint(bytes zcode.Bytes, i uint64) zcode.Bytes

+ func ContainedType(typ Type) (Type, []Column)

+ func DecodeBool(zv zcode.Bytes) (bool, error)

+ func DecodeBytes(zv zcode.Bytes) ([]byte, error)

+ func DecodeDuration(zv zcode.Bytes) (nano.Duration, error)

+ func DecodeError(zv zcode.Bytes) (error, error)

+ func DecodeFloat(zb zcode.Bytes) (float64, error)

+ func DecodeFloat32(zb zcode.Bytes) (float32, error)

+ func DecodeFloat64(zv zcode.Bytes) (float64, error)

+ func DecodeIP(zv zcode.Bytes) (net.IP, error)

+ func DecodeInt(zv zcode.Bytes) (int64, error)

+ func DecodeNet(zv zcode.Bytes) (*net.IPNet, error)

+ func DecodeString(zv zcode.Bytes) (string, error)

+ func DecodeTime(zv zcode.Bytes) (nano.Ts, error)

+ func DecodeUint(zv zcode.Bytes) (uint64, error)

+ func EncodeBool(b bool) zcode.Bytes

+ func EncodeBytes(b []byte) zcode.Bytes

+ func EncodeDuration(d nano.Duration) zcode.Bytes

+ func EncodeError(err error) zcode.Bytes

+ func EncodeFloat32(d float32) zcode.Bytes

+ func EncodeFloat64(d float64) zcode.Bytes

+ func EncodeIP(a net.IP) zcode.Bytes

+ func EncodeInt(i int64) zcode.Bytes

+ func EncodeNet(subnet *net.IPNet) zcode.Bytes

+ func EncodeString(s string) zcode.Bytes

+ func EncodeTime(t nano.Ts) zcode.Bytes

+ func EncodeTypeValue(t Type) zcode.Bytes

+ func EncodeUint(i uint64) zcode.Bytes

+ func IDChar(c rune) bool

+ func IsContainerType(typ Type) bool

+ func IsIdentifier(s string) bool

+ func IsPrimitiveType(typ Type) bool

+ func IsRecordType(typ Type) bool

+ func IsTrue(zv zcode.Bytes) bool

+ func IsTypeName(s string) bool

+ func IsUnionType(typ Type) bool

+ func TypeChar(c rune) bool

+ func TypeID(typ Type) int

+ type Allocator interface

+ CopyValue func(Value) *Value

+ NewValue func(Type, zcode.Bytes) *Value

+ type Column struct

+ Name string

+ Type Type

+ func NewColumn(name string, typ Type) Column

+ type CompressionFormat int

+ const CompressionFormatLZ4

+ type Context struct

+ func NewContext() *Context

+ func (c *Context) Lookup(id int) *TypeRecord

+ func (c *Context) LookupByValue(tv zcode.Bytes) (Type, error)

+ func (c *Context) LookupType(id int) (Type, error)

+ func (c *Context) LookupTypeArray(inner Type) *TypeArray

+ func (c *Context) LookupTypeDef(name string) *TypeNamed

+ func (c *Context) LookupTypeEnum(symbols []string) *TypeEnum

+ func (c *Context) LookupTypeMap(keyType, valType Type) *TypeMap

+ func (c *Context) LookupTypeNamed(name string, target Type) (*TypeNamed, error)

+ func (c *Context) LookupTypeRecord(columns []Column) (*TypeRecord, error)

+ func (c *Context) LookupTypeSet(inner Type) *TypeSet

+ func (c *Context) LookupTypeUnion(types []Type) *TypeUnion

+ func (c *Context) LookupTypeValue(typ Type) *Value

+ func (c *Context) MustLookupTypeRecord(columns []Column) *TypeRecord

+ func (c *Context) Reset()

+ func (c *Context) TranslateType(ext Type) (Type, error)

+ func (t *Context) TranslateTypeRecord(ext *TypeRecord) (*TypeRecord, error)

+ type Type interface

+ ID func() int

+ func InnerType(typ Type) Type

+ func LookupPrimitive(name string) Type

+ func LookupPrimitiveByID(id int) Type

+ func TypeUnder(typ Type) Type

+ type TypeArray struct

+ Type Type

+ func NewTypeArray(id int, typ Type) *TypeArray

+ func (t *TypeArray) ID() int

+ type TypeEnum struct

+ Symbols []string

+ func NewTypeEnum(id int, symbols []string) *TypeEnum

+ func (t *TypeEnum) ID() int

+ func (t *TypeEnum) Lookup(symbol string) int

+ func (t *TypeEnum) Symbol(index int) (string, error)

+ type TypeMap struct

+ KeyType Type

+ ValType Type

+ func NewTypeMap(id int, keyType, valType Type) *TypeMap

+ func (t *TypeMap) ID() int

+ type TypeNamed struct

+ Name string

+ Type Type

+ func NewTypeNamed(id int, name string, typ Type) *TypeNamed

+ func (t *TypeNamed) ID() int

+ func (t *TypeNamed) NamedID() int

+ type TypeOfBool struct

+ func (t *TypeOfBool) Format(zv zcode.Bytes) string

+ func (t *TypeOfBool) ID() int

+ func (t *TypeOfBool) Marshal(zv zcode.Bytes) (interface{}, error)

+ func (t *TypeOfBool) String() string

+ type TypeOfBstring struct

+ func (t *TypeOfBstring) ID() int

+ type TypeOfBytes struct

+ func (t *TypeOfBytes) Format(zv zcode.Bytes) string

+ func (t *TypeOfBytes) ID() int

+ func (t *TypeOfBytes) Marshal(zv zcode.Bytes) (interface{}, error)

+ func (t *TypeOfBytes) String() string

+ type TypeOfDuration struct

+ func (t *TypeOfDuration) Format(zv zcode.Bytes) string

+ func (t *TypeOfDuration) ID() int

+ func (t *TypeOfDuration) Marshal(zv zcode.Bytes) (interface{}, error)

+ func (t *TypeOfDuration) String() string

+ type TypeOfError struct

+ func (t *TypeOfError) ID() int

+ type TypeOfFloat32 struct

+ func (t *TypeOfFloat32) Format(zb zcode.Bytes) string

+ func (t *TypeOfFloat32) ID() int

+ func (t *TypeOfFloat32) Marshal(zb zcode.Bytes) (interface{}, error)

+ func (t *TypeOfFloat32) String() string

+ type TypeOfFloat64 struct

+ func (t *TypeOfFloat64) Format(zv zcode.Bytes) string

+ func (t *TypeOfFloat64) ID() int

+ func (t *TypeOfFloat64) Marshal(zv zcode.Bytes) (interface{}, error)

+ func (t *TypeOfFloat64) String() string

+ type TypeOfIP struct

+ func (t *TypeOfIP) Format(zv zcode.Bytes) string

+ func (t *TypeOfIP) ID() int

+ func (t *TypeOfIP) Marshal(zv zcode.Bytes) (interface{}, error)

+ func (t *TypeOfIP) String() string

+ type TypeOfInt16 struct

+ func (t *TypeOfInt16) Format(zv zcode.Bytes) string

+ func (t *TypeOfInt16) ID() int

+ func (t *TypeOfInt16) Marshal(zv zcode.Bytes) (interface{}, error)

+ func (t *TypeOfInt16) String() string

+ type TypeOfInt32 struct

+ func (t *TypeOfInt32) Format(zv zcode.Bytes) string

+ func (t *TypeOfInt32) ID() int

+ func (t *TypeOfInt32) Marshal(zv zcode.Bytes) (interface{}, error)

+ func (t *TypeOfInt32) String() string

+ type TypeOfInt64 struct

+ func (t *TypeOfInt64) Format(zv zcode.Bytes) string

+ func (t *TypeOfInt64) ID() int

+ func (t *TypeOfInt64) Marshal(zv zcode.Bytes) (interface{}, error)

+ func (t *TypeOfInt64) String() string

+ type TypeOfInt8 struct

+ func (t *TypeOfInt8) Format(zv zcode.Bytes) string

+ func (t *TypeOfInt8) ID() int

+ func (t *TypeOfInt8) Marshal(zv zcode.Bytes) (interface{}, error)

+ func (t *TypeOfInt8) String() string

+ type TypeOfNet struct

+ func (t *TypeOfNet) Format(zv zcode.Bytes) string

+ func (t *TypeOfNet) ID() int

+ func (t *TypeOfNet) Marshal(zv zcode.Bytes) (interface{}, error)

+ func (t *TypeOfNet) String() string

+ type TypeOfNull struct

+ func (t *TypeOfNull) Format(zv zcode.Bytes) string

+ func (t *TypeOfNull) ID() int

+ func (t *TypeOfNull) Marshal(zv zcode.Bytes) (interface{}, error)

+ func (t *TypeOfNull) String() string

+ type TypeOfString struct

+ func (t *TypeOfString) ID() int

+ type TypeOfTime struct

+ func (t *TypeOfTime) Format(zv zcode.Bytes) string

+ func (t *TypeOfTime) ID() int

+ func (t *TypeOfTime) Marshal(zv zcode.Bytes) (interface{}, error)

+ func (t *TypeOfTime) String() string

+ type TypeOfType struct

+ func (t *TypeOfType) ID() int

+ type TypeOfUint16 struct

+ func (t *TypeOfUint16) Format(zv zcode.Bytes) string

+ func (t *TypeOfUint16) ID() int

+ func (t *TypeOfUint16) Marshal(zv zcode.Bytes) (interface{}, error)

+ func (t *TypeOfUint16) String() string

+ type TypeOfUint32 struct

+ func (t *TypeOfUint32) Format(zv zcode.Bytes) string

+ func (t *TypeOfUint32) ID() int

+ func (t *TypeOfUint32) Marshal(zv zcode.Bytes) (interface{}, error)

+ func (t *TypeOfUint32) String() string

+ type TypeOfUint64 struct

+ func (t *TypeOfUint64) Format(zv zcode.Bytes) string

+ func (t *TypeOfUint64) ID() int

+ func (t *TypeOfUint64) Marshal(zv zcode.Bytes) (interface{}, error)

+ func (t *TypeOfUint64) String() string

+ type TypeOfUint8 struct

+ func (t *TypeOfUint8) Format(zv zcode.Bytes) string

+ func (t *TypeOfUint8) ID() int

+ func (t *TypeOfUint8) Marshal(zv zcode.Bytes) (interface{}, error)

+ func (t *TypeOfUint8) String() string

+ type TypeRecord struct

+ Columns []Column

+ LUT map[string]int

+ func NewTypeRecord(id int, columns []Column) *TypeRecord

+ func TypeRecordOf(typ Type) *TypeRecord

+ func (t *TypeRecord) ID() int

+ type TypeSet struct

+ Type Type

+ func NewTypeSet(id int, typ Type) *TypeSet

+ func (t *TypeSet) ID() int

+ type TypeUnion struct

+ Types []Type

+ func NewTypeUnion(id int, types []Type) *TypeUnion

+ func (t *TypeUnion) ID() int

+ func (t *TypeUnion) Type(selector int) (Type, error)

+ type Value struct

+ Bytes zcode.Bytes

+ Type Type

+ func NewBool(b bool) *Value

+ func NewBstring(s string) *Value

+ func NewBytes(b []byte) *Value

+ func NewDuration(d nano.Duration) *Value

+ func NewError(err error) *Value

+ func NewErrorf(format string, args ...interface{}) *Value

+ func NewFloat32(f float32) *Value

+ func NewFloat64(f float64) *Value

+ func NewIP(a net.IP) *Value

+ func NewNet(s *net.IPNet) *Value

+ func NewString(s string) *Value

+ func NewTime(ts nano.Ts) *Value

+ func NewTypeValue(t Type) *Value

+ func NewUint64(v uint64) *Value

+ func NewValue(zt Type, zb zcode.Bytes) *Value

+ func Not(zb zcode.Bytes) *Value

+ func (v *Value) Copy() *Value

+ func (v *Value) CopyFrom(from *Value)

+ func (v *Value) Equal(p Value) bool

+ func (v *Value) IsContainer() bool

+ func (v *Value) IsNull() bool

+ func (v *Value) Iter() zcode.Iter

v0

v0.34.0-test1

Feb 13, 2022