mixins

type Bool ¶

type Bool struct {
	TypeName string
}

Bool can be embedded in a struct to provide all the methods that have fixed output for any int-kinded nodes. (Mostly this includes all the methods which simply return ErrWrongKind.) Other methods will still need to be implemented to finish conforming to Node.

To conserve memory and get a TypeName in errors without embedding, write methods on your type with a body that simply initializes this struct and immediately uses the relevant method; this is more verbose in source, but compiles to a tighter result: in memory, there's no embed; and in runtime, the calls will be inlined and thus have no cost in execution time.

func (x Bool) AsBytes() ([]byte, error)

func (x Bool) AsFloat() (float64, error)

func (x Bool) AsInt() (int, error)

func (x Bool) AsLink() (ipld.Link, error)

func (x Bool) AsString() (string, error)

func (Bool) IsNull() bool

func (Bool) IsUndefined() bool

func (Bool) Length() int

func (Bool) ListIterator() ipld.ListIterator

func (x Bool) Lookup(key ipld.Node) (ipld.Node, error)

func (x Bool) LookupIndex(idx int) (ipld.Node, error)

func (x Bool) LookupSegment(ipld.PathSegment) (ipld.Node, error)

func (x Bool) LookupString(string) (ipld.Node, error)

func (Bool) MapIterator() ipld.MapIterator

func (Bool) ReprKind() ipld.ReprKind

type BoolAssembler ¶

type BoolAssembler struct {
	TypeName string
}

BoolAssembler has similar purpose as Bool, but for (you guessed it) the NodeAssembler interface rather than the Node interface.

func (x BoolAssembler) AssignBytes([]byte) error

func (x BoolAssembler) AssignFloat(float64) error

func (x BoolAssembler) AssignInt(int) error

func (x BoolAssembler) AssignLink(ipld.Link) error

func (x BoolAssembler) AssignNull() error

func (x BoolAssembler) AssignString(string) error

func (x BoolAssembler) BeginList(sizeHint int) (ipld.ListNodeAssembler, error)

func (x BoolAssembler) BeginMap(sizeHint int) (ipld.MapNodeAssembler, error)

type Bytes ¶

type Bytes struct {
	TypeName string
}

Bytes can be embedded in a struct to provide all the methods that have fixed output for any int-kinded nodes. (Mostly this includes all the methods which simply return ErrWrongKind.) Other methods will still need to be implemented to finish conforming to Node.

To conserve memory and get a TypeName in errors without embedding, write methods on your type with a body that simply initializes this struct and immediately uses the relevant method; this is more verbose in source, but compiles to a tighter result: in memory, there's no embed; and in runtime, the calls will be inlined and thus have no cost in execution time.

func (x Bytes) AsBool() (bool, error)

func (x Bytes) AsFloat() (float64, error)

func (x Bytes) AsInt() (int, error)

func (x Bytes) AsLink() (ipld.Link, error)

func (x Bytes) AsString() (string, error)

func (Bytes) IsNull() bool

func (Bytes) IsUndefined() bool

func (Bytes) Length() int

func (Bytes) ListIterator() ipld.ListIterator

func (x Bytes) Lookup(key ipld.Node) (ipld.Node, error)

func (x Bytes) LookupIndex(idx int) (ipld.Node, error)

func (x Bytes) LookupSegment(ipld.PathSegment) (ipld.Node, error)

func (x Bytes) LookupString(string) (ipld.Node, error)

func (Bytes) MapIterator() ipld.MapIterator

func (Bytes) ReprKind() ipld.ReprKind

type BytesAssembler ¶

type BytesAssembler struct {
	TypeName string
}

BytesAssembler has similar purpose as Bytes, but for (you guessed it) the NodeAssembler interface rather than the Node interface.

func (x BytesAssembler) AssignBool(bool) error

func (x BytesAssembler) AssignFloat(float64) error

func (x BytesAssembler) AssignInt(int) error

func (x BytesAssembler) AssignLink(ipld.Link) error

func (x BytesAssembler) AssignNull() error

func (x BytesAssembler) AssignString(string) error

func (x BytesAssembler) BeginList(sizeHint int) (ipld.ListNodeAssembler, error)

func (x BytesAssembler) BeginMap(sizeHint int) (ipld.MapNodeAssembler, error)

type Float ¶

type Float struct {
	TypeName string
}

Float can be embedded in a struct to provide all the methods that have fixed output for any int-kinded nodes. (Mostly this includes all the methods which simply return ErrWrongKind.) Other methods will still need to be implemented to finish conforming to Node.

To conserve memory and get a TypeName in errors without embedding, write methods on your type with a body that simply initializes this struct and immediately uses the relevant method; this is more verbose in source, but compiles to a tighter result: in memory, there's no embed; and in runtime, the calls will be inlined and thus have no cost in execution time.

func (x Float) AsBool() (bool, error)

func (x Float) AsBytes() ([]byte, error)

func (x Float) AsInt() (int, error)

func (x Float) AsLink() (ipld.Link, error)

func (x Float) AsString() (string, error)

func (Float) IsNull() bool

func (Float) IsUndefined() bool

func (Float) Length() int

func (Float) ListIterator() ipld.ListIterator

func (x Float) Lookup(key ipld.Node) (ipld.Node, error)

func (x Float) LookupIndex(idx int) (ipld.Node, error)

func (x Float) LookupSegment(ipld.PathSegment) (ipld.Node, error)

func (x Float) LookupString(string) (ipld.Node, error)

func (Float) MapIterator() ipld.MapIterator

func (Float) ReprKind() ipld.ReprKind

type FloatAssembler ¶

type FloatAssembler struct {
	TypeName string
}

FloatAssembler has similar purpose as Float, but for (you guessed it) the NodeAssembler interface rather than the Node interface.

func (x FloatAssembler) AssignBool(bool) error

func (x FloatAssembler) AssignBytes([]byte) error

func (x FloatAssembler) AssignInt(int) error

func (x FloatAssembler) AssignLink(ipld.Link) error

func (x FloatAssembler) AssignNull() error

func (x FloatAssembler) AssignString(string) error

func (x FloatAssembler) BeginList(sizeHint int) (ipld.ListNodeAssembler, error)

func (x FloatAssembler) BeginMap(sizeHint int) (ipld.MapNodeAssembler, error)

type Int ¶

type Int struct {
	TypeName string
}

Int can be embedded in a struct to provide all the methods that have fixed output for any int-kinded nodes. (Mostly this includes all the methods which simply return ErrWrongKind.) Other methods will still need to be implemented to finish conforming to Node.

To conserve memory and get a TypeName in errors without embedding, write methods on your type with a body that simply initializes this struct and immediately uses the relevant method; this is more verbose in source, but compiles to a tighter result: in memory, there's no embed; and in runtime, the calls will be inlined and thus have no cost in execution time.

func (x Int) AsBool() (bool, error)

func (x Int) AsBytes() ([]byte, error)

func (x Int) AsFloat() (float64, error)

func (x Int) AsLink() (ipld.Link, error)

func (x Int) AsString() (string, error)

func (Int) IsNull() bool

func (Int) IsUndefined() bool

func (Int) Length() int

func (Int) ListIterator() ipld.ListIterator

func (x Int) Lookup(key ipld.Node) (ipld.Node, error)

func (x Int) LookupIndex(idx int) (ipld.Node, error)

func (x Int) LookupSegment(ipld.PathSegment) (ipld.Node, error)

func (x Int) LookupString(string) (ipld.Node, error)

func (Int) MapIterator() ipld.MapIterator

func (Int) ReprKind() ipld.ReprKind

type IntAssembler ¶

type IntAssembler struct {
	TypeName string
}

IntAssembler has similar purpose as Int, but for (you guessed it) the NodeAssembler interface rather than the Node interface.

func (x IntAssembler) AssignBool(bool) error

func (x IntAssembler) AssignBytes([]byte) error

func (x IntAssembler) AssignFloat(float64) error

func (x IntAssembler) AssignLink(ipld.Link) error

func (x IntAssembler) AssignNull() error

func (x IntAssembler) AssignString(string) error

func (x IntAssembler) BeginList(sizeHint int) (ipld.ListNodeAssembler, error)

func (x IntAssembler) BeginMap(sizeHint int) (ipld.MapNodeAssembler, error)

type Link ¶

type Link struct {
	TypeName string
}

Link can be embedded in a struct to provide all the methods that have fixed output for any int-kinded nodes. (Mostly this includes all the methods which simply return ErrWrongKind.) Other methods will still need to be implemented to finish conforming to Node.

To conserve memory and get a TypeName in errors without embedding, write methods on your type with a body that simply initializes this struct and immediately uses the relevant method; this is more verbose in source, but compiles to a tighter result: in memory, there's no embed; and in runtime, the calls will be inlined and thus have no cost in execution time.

func (x Link) AsBool() (bool, error)

func (x Link) AsBytes() ([]byte, error)

func (x Link) AsFloat() (float64, error)

func (x Link) AsInt() (int, error)

func (x Link) AsString() (string, error)

func (Link) IsNull() bool

func (Link) IsUndefined() bool

func (Link) Length() int

func (Link) ListIterator() ipld.ListIterator

func (x Link) Lookup(key ipld.Node) (ipld.Node, error)

func (x Link) LookupIndex(idx int) (ipld.Node, error)

func (x Link) LookupSegment(ipld.PathSegment) (ipld.Node, error)

func (x Link) LookupString(string) (ipld.Node, error)

func (Link) MapIterator() ipld.MapIterator

func (Link) ReprKind() ipld.ReprKind

type LinkAssembler ¶

type LinkAssembler struct {
	TypeName string
}

LinkAssembler has similar purpose as Link, but for (you guessed it) the NodeAssembler interface rather than the Node interface.

func (x LinkAssembler) AssignBool(bool) error

func (x LinkAssembler) AssignBytes([]byte) error

func (x LinkAssembler) AssignFloat(float64) error

func (x LinkAssembler) AssignInt(int) error

func (x LinkAssembler) AssignNull() error

func (x LinkAssembler) AssignString(string) error

func (x LinkAssembler) BeginList(sizeHint int) (ipld.ListNodeAssembler, error)

func (x LinkAssembler) BeginMap(sizeHint int) (ipld.MapNodeAssembler, error)

type List ¶

type List struct {
	TypeName string
}

List can be embedded in a struct to provide all the methods that have fixed output for any int-kinded nodes. (Mostly this includes all the methods which simply return ErrWrongKind.) Other methods will still need to be implemented to finish conforming to Node.

To conserve memory and get a TypeName in errors without embedding, write methods on your type with a body that simply initializes this struct and immediately uses the relevant method; this is more verbose in source, but compiles to a tighter result: in memory, there's no embed; and in runtime, the calls will be inlined and thus have no cost in execution time.

func (x List) AsBool() (bool, error)

func (x List) AsBytes() ([]byte, error)

func (x List) AsFloat() (float64, error)

func (x List) AsInt() (int, error)

func (x List) AsLink() (ipld.Link, error)

func (x List) AsString() (string, error)

func (List) IsNull() bool

func (List) IsUndefined() bool

func (x List) Lookup(key ipld.Node) (ipld.Node, error)

func (x List) LookupString(string) (ipld.Node, error)

func (List) MapIterator() ipld.MapIterator

func (List) ReprKind() ipld.ReprKind

type ListAssembler ¶

type ListAssembler struct {
	TypeName string
}

ListAssembler has similar purpose as List, but for (you guessed it) the NodeAssembler interface rather than the Node interface.

func (x ListAssembler) AssignBool(bool) error

func (x ListAssembler) AssignBytes([]byte) error

func (x ListAssembler) AssignFloat(float64) error

func (x ListAssembler) AssignInt(int) error

func (x ListAssembler) AssignLink(ipld.Link) error

func (x ListAssembler) AssignNull() error

func (x ListAssembler) AssignString(string) error

func (x ListAssembler) BeginMap(sizeHint int) (ipld.MapNodeAssembler, error)

type Map ¶

type Map struct {
	TypeName string
}

Map can be embedded in a struct to provide all the methods that have fixed output for any map-kinded nodes. (Mostly this includes all the methods which simply return ErrWrongKind.) Other methods will still need to be implemented to finish conforming to Node.

To conserve memory and get a TypeName in errors without embedding, write methods on your type with a body that simply initializes this struct and immediately uses the relevant method; this is more verbose in source, but compiles to a tighter result: in memory, there's no embed; and in runtime, the calls will be inlined and thus have no cost in execution time.

func (x Map) AsBool() (bool, error)

func (x Map) AsBytes() ([]byte, error)

func (x Map) AsFloat() (float64, error)

func (x Map) AsInt() (int, error)

func (x Map) AsLink() (ipld.Link, error)

func (x Map) AsString() (string, error)

func (Map) IsNull() bool

func (Map) IsUndefined() bool

func (Map) ListIterator() ipld.ListIterator

func (x Map) LookupIndex(idx int) (ipld.Node, error)

func (Map) ReprKind() ipld.ReprKind

type MapAssembler ¶

type MapAssembler struct {
	TypeName string
}

MapAssembler has similar purpose as Map, but for (you guessed it) the NodeAssembler interface rather than the Node interface.

func (x MapAssembler) AssignBool(bool) error

func (x MapAssembler) AssignBytes([]byte) error

func (x MapAssembler) AssignFloat(float64) error

func (x MapAssembler) AssignInt(int) error

func (x MapAssembler) AssignLink(ipld.Link) error

func (x MapAssembler) AssignNull() error

func (x MapAssembler) AssignString(string) error

func (x MapAssembler) BeginList(sizeHint int) (ipld.ListNodeAssembler, error)

type String ¶

type String struct {
	TypeName string
}

String can be embedded in a struct to provide all the methods that have fixed output for any string-kinded nodes. (Mostly this includes all the methods which simply return ErrWrongKind.) Other methods will still need to be implemented to finish conforming to Node.

To conserve memory and get a TypeName in errors without embedding, write methods on your type with a body that simply initializes this struct and immediately uses the relevant method; this is more verbose in source, but compiles to a tighter result: in memory, there's no embed; and in runtime, the calls will be inlined and thus have no cost in execution time.

func (x String) AsBool() (bool, error)

func (x String) AsBytes() ([]byte, error)

func (x String) AsFloat() (float64, error)

func (x String) AsInt() (int, error)

func (x String) AsLink() (ipld.Link, error)

func (String) IsNull() bool

func (String) IsUndefined() bool

func (String) Length() int

func (String) ListIterator() ipld.ListIterator

func (x String) Lookup(key ipld.Node) (ipld.Node, error)

func (x String) LookupIndex(idx int) (ipld.Node, error)

func (x String) LookupSegment(ipld.PathSegment) (ipld.Node, error)

func (x String) LookupString(string) (ipld.Node, error)

func (String) MapIterator() ipld.MapIterator

func (String) ReprKind() ipld.ReprKind

type StringAssembler ¶

type StringAssembler struct {
	TypeName string
}

StringAssembler has similar purpose as String, but for (you guessed it) the NodeAssembler interface rather than the Node interface.

func (x StringAssembler) AssignBool(bool) error

func (x StringAssembler) AssignBytes([]byte) error

func (x StringAssembler) AssignFloat(float64) error

func (x StringAssembler) AssignInt(int) error

func (x StringAssembler) AssignLink(ipld.Link) error

func (x StringAssembler) AssignNull() error

func (x StringAssembler) BeginList(sizeHint int) (ipld.ListNodeAssembler, error)

func (x StringAssembler) BeginMap(sizeHint int) (ipld.MapNodeAssembler, error)