diff --git a/coding.go b/coding.go index 428eacf..e5f706f 100644 --- a/coding.go +++ b/coding.go @@ -7,28 +7,27 @@ import ( "github.com/ipfs/go-cid" merkledag_pb "github.com/ipfs/go-merkledag/pb" - ipld "github.com/ipld/go-ipld-prime" cidlink "github.com/ipld/go-ipld-prime/linking/cid" "github.com/ipld/go-ipld-prime/schema" ) // DecodeDagProto is a fast path decoding to protobuf // from PBNode__NodeBuilders -func (nb _PBNode__NodeBuilder) DecodeDagProto(r io.Reader) (ipld.Node, error) { +func (nb _PBNode__NodeBuilder) DecodeDagProto(r io.Reader) error { var pbn merkledag_pb.PBNode encoded, err := ioutil.ReadAll(r) if err != nil { - return nil, fmt.Errorf("io error during unmarshal. %v", err) + return fmt.Errorf("io error during unmarshal. %v", err) } if err := pbn.Unmarshal(encoded); err != nil { - return nil, fmt.Errorf("unmarshal failed. %v", err) + return fmt.Errorf("unmarshal failed. %v", err) } pbLinks := make([]PBLink, 0, len(pbn.Links)) for _, link := range pbn.Links { hash, err := cid.Cast(link.GetHash()) if err != nil { - return nil, fmt.Errorf("unmarshal failed. %v", err) + return fmt.Errorf("unmarshal failed. %v", err) } pbLinks = append(pbLinks, PBLink{ d: PBLink__Content{ @@ -47,12 +46,9 @@ func (nb _PBNode__NodeBuilder) DecodeDagProto(r io.Reader) (ipld.Node, error) { }, }) } - pbData := Bytes{pbn.GetData()} - return PBNode{d: PBNode__Content{ - Links: PBLinks{x: pbLinks}, - Data: pbData, - }, - }, nil + nb.nd.d.Links.x = pbLinks + nb.nd.d.Data.x = pbn.GetData() + return nil } // EncodeDagProto is a fast path encoding to protobuf @@ -97,12 +93,13 @@ func (nd PBNode) EncodeDagProto(w io.Writer) error { // DecodeDagRaw is a fast path decoding to protobuf // from RawNode__NodeBuilders -func (nb _RawNode__NodeBuilder) DecodeDagRaw(r io.Reader) (ipld.Node, error) { +func (nb _RawNode__NodeBuilder) DecodeDagRaw(r io.Reader) error { data, err := ioutil.ReadAll(r) if err != nil { - return nil, fmt.Errorf("io error during unmarshal. %v", err) + return fmt.Errorf("io error during unmarshal. %v", err) } - return RawNode{data}, nil + nb.nd.x = data + return nil } // EncodeDagRaw is a fast path encoding to protobuf diff --git a/common_test.go b/common_test.go index 00d0646..b169271 100644 --- a/common_test.go +++ b/common_test.go @@ -3,10 +3,8 @@ package dagpb_test import ( "bytes" - blocks "github.com/ipfs/go-block-format" ipld "github.com/ipld/go-ipld-prime" dagpb "github.com/ipld/go-ipld-prime-proto" - cidlink "github.com/ipld/go-ipld-prime/linking/cid" "github.com/jbenet/go-random" ) @@ -20,12 +18,17 @@ func randomBytes(n int64) []byte { } func makeRawNode(randBytes []byte) (ipld.Node, error) { - raw_nb := dagpb.RawNode__NodeBuilder() - return raw_nb.CreateBytes(randBytes) + raw_nb := dagpb.Style.Raw.NewBuilder() + err := raw_nb.AssignBytes(randBytes) + if err != nil { + return nil, err + } + return raw_nb.Build(), nil } +/* func makeProtoNode(linkedNodes map[string]ipld.Node) (ipld.Node, error) { - dagpb_nb := dagpb.PBNode__NodeBuilder() + dag_ns := dagpb.PBNode__NodeBuilder() dagpb_mb, err := dagpb_nb.CreateMap() if err != nil { return nil, err @@ -120,3 +123,4 @@ func makeProtoNode(linkedNodes map[string]ipld.Node) (ipld.Node, error) { } return dagpb_mb.Build() } +*/ diff --git a/gen/main.go b/gen/main.go index e1c7a3e..c0ba2de 100644 --- a/gen/main.go +++ b/gen/main.go @@ -1,12 +1,106 @@ package main import ( + "io" + "io/ioutil" "os" + "regexp" "github.com/ipld/go-ipld-prime/schema" gengo "github.com/ipld/go-ipld-prime/schema/gen/go" ) +type typedNodeGenerator interface { + + // -- the natively-typed apis --> + // (might be more readable to group these in another interface and have it + // return a `typedNodeGenerator` with the rest? but structurally same.) + + EmitNativeType(io.Writer) + EmitNativeAccessors(io.Writer) // depends on the kind -- field accessors for struct, typed iterators for map, etc. + EmitNativeBuilder(io.Writer) // typically emits some kind of struct that has a Build method. + EmitNativeMaybe(io.Writer) // a pointer-free 'maybe' mechanism is generated for all types. + + // -- the schema.TypedNode.Type method and vars --> + + EmitTypedNodeMethodType(io.Writer) // these emit dummies for now + + // -- all node methods --> + // (and note that the nodeBuilder for this one should be the "semantic" one, + // e.g. it *always* acts like a map for structs, even if the repr is different.) + + nodeGenerator + + // -- and the representation and its node and nodebuilder --> + + EmitTypedNodeMethodRepresentation(io.Writer) +} + +type typedLinkNodeGenerator interface { + // all methods in typedNodeGenerator + typedNodeGenerator + + // as typed.LinkNode.ReferencedNodeBuilder generator + EmitTypedLinkNodeMethodReferencedNodeBuilder(io.Writer) +} + +type nodeGenerator interface { + EmitNodeType(io.Writer) + EmitNodeMethodReprKind(io.Writer) + EmitNodeMethodLookupString(io.Writer) + EmitNodeMethodLookup(io.Writer) + EmitNodeMethodLookupIndex(io.Writer) + EmitNodeMethodLookupSegment(io.Writer) + EmitNodeMethodMapIterator(io.Writer) // also iterator itself + EmitNodeMethodListIterator(io.Writer) // also iterator itself + EmitNodeMethodLength(io.Writer) + EmitNodeMethodIsUndefined(io.Writer) + EmitNodeMethodIsNull(io.Writer) + EmitNodeMethodAsBool(io.Writer) + EmitNodeMethodAsInt(io.Writer) + EmitNodeMethodAsFloat(io.Writer) + EmitNodeMethodAsString(io.Writer) + EmitNodeMethodAsBytes(io.Writer) + EmitNodeMethodAsLink(io.Writer) +} + +func emitEntireType(ng nodeGenerator, w io.Writer) { + if ng == nil { + return + } + ng.EmitNodeType(w) + ng.EmitNodeMethodReprKind(w) + ng.EmitNodeMethodLookupString(w) + ng.EmitNodeMethodLookup(w) + ng.EmitNodeMethodLookupIndex(w) + ng.EmitNodeMethodLookupSegment(w) + ng.EmitNodeMethodMapIterator(w) + ng.EmitNodeMethodListIterator(w) + ng.EmitNodeMethodLength(w) + ng.EmitNodeMethodIsUndefined(w) + ng.EmitNodeMethodIsNull(w) + ng.EmitNodeMethodAsBool(w) + ng.EmitNodeMethodAsInt(w) + ng.EmitNodeMethodAsFloat(w) + ng.EmitNodeMethodAsString(w) + ng.EmitNodeMethodAsBytes(w) + ng.EmitNodeMethodAsLink(w) + + tg, ok := ng.(typedNodeGenerator) + if ok { + tg.EmitNativeType(w) + tg.EmitNativeAccessors(w) + tg.EmitNativeBuilder(w) + tg.EmitNativeMaybe(w) + tg.EmitTypedNodeMethodType(w) + tg.EmitTypedNodeMethodRepresentation(w) + } + tlg, ok := ng.(typedLinkNodeGenerator) + if ok { + tlg.EmitTypedLinkNodeMethodReferencedNodeBuilder(w) + } +} + func main() { openOrPanic := func(filename string) *os.File { y, err := os.OpenFile(filename, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0644) @@ -47,15 +141,46 @@ func main() { f = openOrPanic("pb_node_gen.go") gengo.EmitFileHeader("dagpb", f) - gengo.EmitEntireType(gengo.NewGeneratorForKindString(tString), f) - gengo.EmitEntireType(gengo.NewGeneratorForKindInt(tInt), f) - gengo.EmitEntireType(gengo.NewGeneratorForKindBytes(tBytes), f) - gengo.EmitEntireType(gengo.NewGeneratorForKindLink(tLink), f) - gengo.EmitEntireType(gengo.NewGeneratorForKindStruct(tPBLink), f) - gengo.EmitEntireType(gengo.NewGeneratorForKindList(tPBLinks), f) - gengo.EmitEntireType(gengo.NewGeneratorForKindStruct(tPBNode), f) + tg := gengo.NewGeneratorForKindString(tString) + emitEntireType(tg, f) + emitEntireType(tg.GetRepresentationNodeGen(), f) + tg = gengo.NewGeneratorForKindInt(tInt) + emitEntireType(tg, f) + emitEntireType(tg.GetRepresentationNodeGen(), f) + tg = gengo.NewGeneratorForKindBytes(tBytes) + emitEntireType(tg, f) + emitEntireType(tg.GetRepresentationNodeGen(), f) + tg = gengo.NewGeneratorForKindLink(tLink) + emitEntireType(tg, f) + emitEntireType(tg.GetRepresentationNodeGen(), f) + tg = gengo.NewGeneratorForKindStruct(tPBLink) + emitEntireType(tg, f) + emitEntireType(tg.GetRepresentationNodeGen(), f) + tg = gengo.NewGeneratorForKindList(tPBLinks) + emitEntireType(tg, f) + emitEntireType(tg.GetRepresentationNodeGen(), f) + tg = gengo.NewGeneratorForKindStruct(tPBNode) + emitEntireType(tg, f) + emitEntireType(tg.GetRepresentationNodeGen(), f) + if err := f.Close(); err != nil { + panic(err) + } + read, err := ioutil.ReadFile("pb_node_gen.go") + if err != nil { + panic(err) + } + + re := regexp.MustCompile("ipld\\.ErrInvalidKey\\{[^}]*\\}") + newContents := re.ReplaceAll(read, []byte("err")) + + err = ioutil.WriteFile("pb_node_gen.go", []byte(newContents), 0) + if err != nil { + panic(err) + } f = openOrPanic("raw_node_gen.go") gengo.EmitFileHeader("dagpb", f) - gengo.EmitEntireType(gengo.NewGeneratorForKindBytes(tRaw), f) + tg = gengo.NewGeneratorForKindBytes(tRaw) + emitEntireType(tg, f) + emitEntireType(tg.GetRepresentationNodeGen(), f) } diff --git a/go.mod b/go.mod index 93b5623..e1b017d 100644 --- a/go.mod +++ b/go.mod @@ -14,7 +14,7 @@ require ( github.com/ipfs/go-ipld-format v0.2.0 github.com/ipfs/go-merkledag v0.3.1 github.com/ipfs/go-unixfs v0.2.4 - github.com/ipld/go-ipld-prime v0.0.2-0.20200229094926-eb71617f4aeb + github.com/ipld/go-ipld-prime v0.0.2-0.20200327122045-fc80c2b0149d github.com/jbenet/go-random v0.0.0-20190219211222-123a90aedc0c github.com/multiformats/go-multihash v0.0.13 github.com/warpfork/go-wish v0.0.0-20200122115046-b9ea61034e4a diff --git a/go.sum b/go.sum index 9e1f66a..b860212 100644 --- a/go.sum +++ b/go.sum @@ -152,8 +152,10 @@ github.com/ipfs/go-unixfs v0.2.4 h1:6NwppOXefWIyysZ4LR/qUBPvXd5//8J3jiMdvpbw6Lo= github.com/ipfs/go-unixfs v0.2.4/go.mod h1:SUdisfUjNoSDzzhGVxvCL9QO/nKdwXdr+gbMUdqcbYw= github.com/ipfs/go-verifcid v0.0.1 h1:m2HI7zIuR5TFyQ1b79Da5N9dnnCP1vcu2QqawmWlK2E= github.com/ipfs/go-verifcid v0.0.1/go.mod h1:5Hrva5KBeIog4A+UpqlaIU+DEstipcJYQQZc0g37pY0= -github.com/ipld/go-ipld-prime v0.0.2-0.20200229094926-eb71617f4aeb h1:uvoZ2aTjsTt/6W5hkzj3JkPMY3oHvcla4WA29k4Jk0I= -github.com/ipld/go-ipld-prime v0.0.2-0.20200229094926-eb71617f4aeb/go.mod h1:uVIwe/u0H4VdKv3kaN1ck7uCb6yD9cFLS9/ELyXbsw8= +github.com/ipld/go-ipld-prime v0.0.2-0.20191108012745-28a82f04c785 h1:fASnkvtR+SmB2y453RxmDD3Uvd4LonVUgFGk9JoDaZs= +github.com/ipld/go-ipld-prime v0.0.2-0.20191108012745-28a82f04c785/go.mod h1:bDDSvVz7vaK12FNvMeRYnpRFkSUPNQOiCYQezMD/P3w= +github.com/ipld/go-ipld-prime v0.0.2-0.20200327122045-fc80c2b0149d h1:0WIVGCHabeWlI/Zn0bfXdGUcHzcbOSe38ehBgIRdSck= +github.com/ipld/go-ipld-prime v0.0.2-0.20200327122045-fc80c2b0149d/go.mod h1:uVIwe/u0H4VdKv3kaN1ck7uCb6yD9cFLS9/ELyXbsw8= github.com/jackpal/gateway v1.0.5 h1:qzXWUJfuMdlLMtt0a3Dgt+xkWQiA5itDEITVJtuSwMc= github.com/jackpal/gateway v1.0.5/go.mod h1:lTpwd4ACLXmpyiCTRtfiNyVnUmqT9RivzCDQetPfnjA= github.com/jackpal/go-nat-pmp v1.0.1 h1:i0LektDkO1QlrTm/cSuP+PyBCDnYvjPLGl4LdWEMiaA= diff --git a/multicodec.go b/multicodec.go index d915aa8..00a2fb5 100644 --- a/multicodec.go +++ b/multicodec.go @@ -27,17 +27,17 @@ func init() { } // PBDecoder is a decoder function for Dag Protobuf nodes -func PBDecoder(nb ipld.NodeBuilder, r io.Reader) (ipld.Node, error) { +func PBDecoder(nb ipld.NodeAssembler, r io.Reader) error { // Probe for a builtin fast path. Shortcut to that if possible. // (ipldcbor.NodeBuilder supports this, for example.) type detectFastPath interface { - DecodeDagProto(io.Reader) (ipld.Node, error) + DecodeDagProto(io.Reader) error } if nb2, ok := nb.(detectFastPath); ok { return nb2.DecodeDagProto(r) } // Okay, generic builder path. - return nil, ErrNoAutomaticDecoding + return ErrNoAutomaticDecoding } // PBEncoder is a encoder function that encodes to Dag Protobuf @@ -55,17 +55,17 @@ func PBEncoder(n ipld.Node, w io.Writer) error { } // RawDecoder is a decoder function for raw coded nodes -func RawDecoder(nb ipld.NodeBuilder, r io.Reader) (ipld.Node, error) { +func RawDecoder(nb ipld.NodeAssembler, r io.Reader) error { // Probe for a builtin fast path. Shortcut to that if possible. // (ipldcbor.NodeBuilder supports this, for example.) type detectFastPath interface { - DecodeDagRaw(io.Reader) (ipld.Node, error) + DecodeDagRaw(io.Reader) error } if nb2, ok := nb.(detectFastPath); ok { return nb2.DecodeDagRaw(r) } // Okay, generic builder path. - return nil, ErrNoAutomaticDecoding + return ErrNoAutomaticDecoding } // RawEncoder encodes a node to a raw block structure diff --git a/multicodec_test.go b/multicodec_test.go index b595a64..7b8fc7c 100644 --- a/multicodec_test.go +++ b/multicodec_test.go @@ -4,7 +4,7 @@ import ( "bytes" "testing" - ipld "github.com/ipld/go-ipld-prime" + dag "github.com/ipfs/go-merkledag" dagpb "github.com/ipld/go-ipld-prime-proto" . "github.com/warpfork/go-wish" ) @@ -21,29 +21,43 @@ func TestRoundTripRaw(t *testing.T) { }) t.Run("decoding", func(t *testing.T) { buf := bytes.NewBuffer(randBytes) - rawNode2, err := dagpb.RawDecoder(dagpb.RawNode__NodeBuilder(), buf) + nb := dagpb.Style.Raw.NewBuilder() + err := dagpb.RawDecoder(nb, buf) Wish(t, err, ShouldEqual, nil) + rawNode2 := nb.Build() Wish(t, rawNode2, ShouldEqual, rawNode) }) } func TestRoundTripProtbuf(t *testing.T) { - randBytes1 := randomBytes(256) - rawNode1, err := makeRawNode(randBytes1) - Wish(t, err, ShouldEqual, nil) - randBytes2 := randomBytes(256) - rawNode2, err := makeRawNode(randBytes2) - Wish(t, err, ShouldEqual, nil) - pbNode, err := makeProtoNode(map[string]ipld.Node{ - "applesuace": rawNode1, - "oranges": rawNode2, - }) + a := dag.NewRawNode([]byte("aaaa")) + b := dag.NewRawNode([]byte("bbbb")) + c := dag.NewRawNode([]byte("cccc")) + + nd1 := &dag.ProtoNode{} + nd1.AddNodeLink("cat", a) + + nd2 := &dag.ProtoNode{} + nd2.AddNodeLink("first", nd1) + nd2.AddNodeLink("dog", b) + + nd3 := &dag.ProtoNode{} + nd3.AddNodeLink("second", nd2) + nd3.AddNodeLink("bear", c) + + data := nd3.RawData() + ibuf := bytes.NewBuffer(data) + nb := dagpb.Style.Protobuf.NewBuilder() + err := dagpb.PBDecoder(nb, ibuf) Wish(t, err, ShouldEqual, nil) + pbNode := nb.Build() t.Run("encode/decode equivalency", func(t *testing.T) { var buf bytes.Buffer err := dagpb.PBEncoder(pbNode, &buf) Wish(t, err, ShouldEqual, nil) - pbNode2, err := dagpb.PBDecoder(dagpb.PBNode__NodeBuilder(), &buf) + nb = dagpb.Style.Protobuf.NewBuilder() + err = dagpb.PBDecoder(nb, &buf) + pbNode2 := nb.Build() Wish(t, err, ShouldEqual, nil) Wish(t, pbNode2, ShouldEqual, pbNode) }) diff --git a/node_builder_chooser.go b/node_builder_chooser.go index 3e6da33..0d01e15 100644 --- a/node_builder_chooser.go +++ b/node_builder_chooser.go @@ -8,17 +8,17 @@ import ( // AddDagPBSupportToChooser takes an existing NodeBuilderChooser and subs in // Protobuf and Raw node builders where neccesary -func AddDagPBSupportToChooser(existing traversal.NodeBuilderChooser) traversal.NodeBuilderChooser { - return func(lnk ipld.Link, lnkCtx ipld.LinkContext) (ipld.NodeBuilder, error) { +func AddDagPBSupportToChooser(existing traversal.LinkTargetNodeStyleChooser) traversal.LinkTargetNodeStyleChooser { + return func(lnk ipld.Link, lnkCtx ipld.LinkContext) (ipld.NodeStyle, error) { c, ok := lnk.(cidlink.Link) if !ok { return existing(lnk, lnkCtx) } switch c.Cid.Prefix().Codec { case 0x70: - return PBNode__NodeBuilder(), nil + return _PBNode__NodeStyle{}, nil case 0x55: - return RawNode__NodeBuilder(), nil + return _RawNode__NodeStyle{}, nil default: return existing(lnk, lnkCtx) } diff --git a/node_builder_chooser_test.go b/node_builder_chooser_test.go index 5fc7050..0ce4b01 100644 --- a/node_builder_chooser_test.go +++ b/node_builder_chooser_test.go @@ -7,20 +7,20 @@ import ( "github.com/ipfs/go-merkledag" ipld "github.com/ipld/go-ipld-prime" dagpb "github.com/ipld/go-ipld-prime-proto" - ipldfree "github.com/ipld/go-ipld-prime/impl/free" cidlink "github.com/ipld/go-ipld-prime/linking/cid" + basicnode "github.com/ipld/go-ipld-prime/node/basic" "github.com/ipld/go-ipld-prime/traversal" mh "github.com/multiformats/go-multihash" . "github.com/warpfork/go-wish" ) func TestNodeBuilderChooser(t *testing.T) { - nb1 := ipldfree.NodeBuilder() - nb2 := dagpb.String__NodeBuilder() - var nb1Chooser traversal.NodeBuilderChooser = dagpb.AddDagPBSupportToChooser(func(ipld.Link, ipld.LinkContext) (ipld.NodeBuilder, error) { + nb1 := basicnode.Style__Any{} + nb2 := basicnode.Style__String{} + var nb1Chooser traversal.LinkTargetNodeStyleChooser = dagpb.AddDagPBSupportToChooser(func(ipld.Link, ipld.LinkContext) (ipld.NodeStyle, error) { return nb1, nil }) - var nb2Chooser traversal.NodeBuilderChooser = dagpb.AddDagPBSupportToChooser(func(ipld.Link, ipld.LinkContext) (ipld.NodeBuilder, error) { + var nb2Chooser traversal.LinkTargetNodeStyleChooser = dagpb.AddDagPBSupportToChooser(func(ipld.Link, ipld.LinkContext) (ipld.NodeStyle, error) { return nb2, nil }) bytes := randomBytes(256) @@ -48,23 +48,23 @@ func TestNodeBuilderChooser(t *testing.T) { rawLink := cidlink.Link{Cid: rawCid} cborLink := cidlink.Link{Cid: cborCid} - nb, err := nb1Chooser(protoLink, ipld.LinkContext{}) + ns, err := nb1Chooser(protoLink, ipld.LinkContext{}) Wish(t, err, ShouldEqual, nil) - Wish(t, nb, ShouldEqual, dagpb.PBNode__NodeBuilder()) - nb, err = nb1Chooser(rawLink, ipld.LinkContext{}) + Wish(t, ns, ShouldEqual, dagpb.Style.Protobuf) + ns, err = nb1Chooser(rawLink, ipld.LinkContext{}) Wish(t, err, ShouldEqual, nil) - Wish(t, nb, ShouldEqual, dagpb.RawNode__NodeBuilder()) - nb, err = nb1Chooser(cborLink, ipld.LinkContext{}) + Wish(t, ns, ShouldEqual, dagpb.Style.Raw) + ns, err = nb1Chooser(cborLink, ipld.LinkContext{}) Wish(t, err, ShouldEqual, nil) - Wish(t, nb, ShouldEqual, nb1) - nb, err = nb2Chooser(protoLink, ipld.LinkContext{}) + Wish(t, ns, ShouldEqual, nb1) + ns, err = nb2Chooser(protoLink, ipld.LinkContext{}) Wish(t, err, ShouldEqual, nil) - Wish(t, nb, ShouldEqual, dagpb.PBNode__NodeBuilder()) - nb, err = nb2Chooser(rawLink, ipld.LinkContext{}) + Wish(t, ns, ShouldEqual, dagpb.Style.Protobuf) + ns, err = nb2Chooser(rawLink, ipld.LinkContext{}) Wish(t, err, ShouldEqual, nil) - Wish(t, nb, ShouldEqual, dagpb.RawNode__NodeBuilder()) - nb, err = nb2Chooser(cborLink, ipld.LinkContext{}) + Wish(t, ns, ShouldEqual, dagpb.Style.Raw) + ns, err = nb2Chooser(cborLink, ipld.LinkContext{}) Wish(t, err, ShouldEqual, nil) - Wish(t, nb, ShouldEqual, nb2) + Wish(t, ns, ShouldEqual, nb2) } diff --git a/nodestyles.go b/nodestyles.go new file mode 100644 index 0000000..3481caa --- /dev/null +++ b/nodestyles.go @@ -0,0 +1,191 @@ +package dagpb + +import ( + ipld "github.com/ipld/go-ipld-prime" +) + +var Style style + +type style struct { + Protobuf _PBNode__NodeStyle + Raw _RawNode__NodeStyle +} + +type _PBNode__NodeStyle struct { +} + +func (ns _PBNode__NodeStyle) NewBuilder() ipld.NodeBuilder { + var nd PBNode + return &_PBNode__NodeBuilder{_PBNode__NodeAssembler{nd: &nd}} +} + +type _PBNode__NodeBuilder struct { + _PBNode__NodeAssembler +} + +func (nb *_PBNode__NodeBuilder) Build() ipld.Node { + return nb.nd +} + +func (nb *_PBNode__NodeBuilder) Reset() { + var nd PBNode + *nb = _PBNode__NodeBuilder{_PBNode__NodeAssembler{nd: &nd}} +} + +type _PBNode__NodeAssembler struct { + nd *PBNode +} + +func (na *_PBNode__NodeAssembler) BeginMap(sizeHint int) (ipld.MapAssembler, error) { + panic("not implemented") +} + +func (na *_PBNode__NodeAssembler) BeginList(sizeHint int) (ipld.ListAssembler, error) { + panic("not implemented") +} + +func (na *_PBNode__NodeAssembler) AssignNull() error { + panic("not implemented") +} + +func (na *_PBNode__NodeAssembler) AssignBool(_ bool) error { + panic("not implemented") +} + +func (na *_PBNode__NodeAssembler) AssignInt(_ int) error { + panic("not implemented") +} + +func (na *_PBNode__NodeAssembler) AssignFloat(_ float64) error { + panic("not implemented") +} + +func (na *_PBNode__NodeAssembler) AssignString(_ string) error { + panic("not implemented") +} + +func (na *_PBNode__NodeAssembler) AssignBytes(_ []byte) error { + panic("not implemented") +} + +func (na *_PBNode__NodeAssembler) AssignLink(_ ipld.Link) error { + panic("not implemented") +} + +func (na *_PBNode__NodeAssembler) AssignNode(_ ipld.Node) error { + panic("not implemented") +} + +func (na *_PBNode__NodeAssembler) Style() ipld.NodeStyle { + return _PBNode__NodeStyle{} +} + +func (nd PBNode) Style() ipld.NodeStyle { + return _PBNode__NodeStyle{} +} + +func (nd _PBNode__Repr) Style() ipld.NodeStyle { + return nil +} + +func (nd PBLinks) Style() ipld.NodeStyle { + return nil +} + +func (nd PBLink) Style() ipld.NodeStyle { + return nil +} + +func (nd _PBLink__Repr) Style() ipld.NodeStyle { + return nil +} + +func (nb Link) Style() ipld.NodeStyle { + return nil +} + +func (nb Bytes) Style() ipld.NodeStyle { + return nil +} + +func (nb Int) Style() ipld.NodeStyle { + return nil +} + +func (nb String) Style() ipld.NodeStyle { + return nil +} + +type _RawNode__NodeStyle struct { +} + +func (ns _RawNode__NodeStyle) NewBuilder() ipld.NodeBuilder { + var nd RawNode + return &_RawNode__NodeBuilder{_RawNode__NodeAssembler{nd: &nd}} +} + +type _RawNode__NodeBuilder struct { + _RawNode__NodeAssembler +} + +func (nb *_RawNode__NodeBuilder) Build() ipld.Node { + return nb.nd +} + +func (nb *_RawNode__NodeBuilder) Reset() { + var nd RawNode + *nb = _RawNode__NodeBuilder{_RawNode__NodeAssembler{nd: &nd}} +} + +type _RawNode__NodeAssembler struct { + nd *RawNode +} + +func (na *_RawNode__NodeAssembler) BeginMap(sizeHint int) (ipld.MapAssembler, error) { + panic("not implemented") +} + +func (na *_RawNode__NodeAssembler) BeginList(sizeHint int) (ipld.ListAssembler, error) { + panic("not implemented") +} + +func (na *_RawNode__NodeAssembler) AssignNull() error { + panic("not implemented") +} + +func (na *_RawNode__NodeAssembler) AssignBool(_ bool) error { + panic("not implemented") +} + +func (na *_RawNode__NodeAssembler) AssignInt(_ int) error { + panic("not implemented") +} + +func (na *_RawNode__NodeAssembler) AssignFloat(_ float64) error { + panic("not implemented") +} + +func (na *_RawNode__NodeAssembler) AssignString(_ string) error { + panic("not implemented") +} + +func (na *_RawNode__NodeAssembler) AssignBytes(x []byte) error { + na.nd.x = x + return nil +} + +func (na *_RawNode__NodeAssembler) AssignLink(_ ipld.Link) error { + panic("not implemented") +} + +func (na *_RawNode__NodeAssembler) AssignNode(_ ipld.Node) error { + panic("not implemented") +} + +func (na *_RawNode__NodeAssembler) Style() ipld.NodeStyle { + return _RawNode__NodeStyle{} +} + +func (nd RawNode) Style() ipld.NodeStyle { + return _RawNode__NodeStyle{} +} diff --git a/pb_node_gen.go b/pb_node_gen.go index 4e9b2b1..ee5fdea 100644 --- a/pb_node_gen.go +++ b/pb_node_gen.go @@ -7,49 +7,9 @@ import ( // Code generated go-ipld-prime DO NOT EDIT. -type String struct{ x string } - -func (x String) String() string { - return x.x -} -type String__Content struct { - Value string -} - -func (b String__Content) Build() (String, error) { - x := String{ - b.Value, - } - // FUTURE : want to support customizable validation. - // but 'if v, ok := x.(schema.Validatable); ok {' doesn't fly: need a way to work on concrete types. - return x, nil -} -func (b String__Content) MustBuild() String { - if x, err := b.Build(); err != nil { - panic(err) - } else { - return x - } -} - -type MaybeString struct { - Maybe schema.Maybe - Value String -} - -func (m MaybeString) Must() String { - if m.Maybe != schema.Maybe_Value { - panic("unbox of a maybe rejected") - } - return m.Value -} - var _ ipld.Node = String{} var _ schema.TypedNode = String{} -func (String) Type() schema.Type { - return nil /*TODO:typelit*/ -} func (String) ReprKind() ipld.ReprKind { return ipld.ReprKind_String } @@ -98,73 +58,55 @@ func (String) AsBytes() ([]byte, error) { func (String) AsLink() (ipld.Link, error) { return nil, ipld.ErrWrongKind{TypeName: "String", MethodName: "AsLink", AppropriateKind: ipld.ReprKindSet_JustLink, ActualKind: ipld.ReprKind_String} } -func (String) NodeBuilder() ipld.NodeBuilder { - return _String__NodeBuilder{} -} -type _String__NodeBuilder struct{} -func String__NodeBuilder() ipld.NodeBuilder { - return _String__NodeBuilder{} -} -func (_String__NodeBuilder) CreateMap() (ipld.MapBuilder, error) { - return nil, ipld.ErrWrongKind{TypeName: "String.Builder", MethodName: "CreateMap", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: ipld.ReprKind_String} -} -func (_String__NodeBuilder) AmendMap() (ipld.MapBuilder, error) { - return nil, ipld.ErrWrongKind{TypeName: "String.Builder", MethodName: "AmendMap", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: ipld.ReprKind_String} -} -func (_String__NodeBuilder) CreateList() (ipld.ListBuilder, error) { - return nil, ipld.ErrWrongKind{TypeName: "String.Builder", MethodName: "CreateList", AppropriateKind: ipld.ReprKindSet_JustList, ActualKind: ipld.ReprKind_String} -} -func (_String__NodeBuilder) AmendList() (ipld.ListBuilder, error) { - return nil, ipld.ErrWrongKind{TypeName: "String.Builder", MethodName: "AmendList", AppropriateKind: ipld.ReprKindSet_JustList, ActualKind: ipld.ReprKind_String} -} -func (_String__NodeBuilder) CreateNull() (ipld.Node, error) { - return nil, ipld.ErrWrongKind{TypeName: "String.Builder", MethodName: "CreateNull", AppropriateKind: ipld.ReprKindSet_JustNull, ActualKind: ipld.ReprKind_String} -} -func (_String__NodeBuilder) CreateBool(bool) (ipld.Node, error) { - return nil, ipld.ErrWrongKind{TypeName: "String.Builder", MethodName: "CreateBool", AppropriateKind: ipld.ReprKindSet_JustBool, ActualKind: ipld.ReprKind_String} -} -func (_String__NodeBuilder) CreateInt(int) (ipld.Node, error) { - return nil, ipld.ErrWrongKind{TypeName: "String.Builder", MethodName: "CreateInt", AppropriateKind: ipld.ReprKindSet_JustInt, ActualKind: ipld.ReprKind_String} -} -func (_String__NodeBuilder) CreateFloat(float64) (ipld.Node, error) { - return nil, ipld.ErrWrongKind{TypeName: "String.Builder", MethodName: "CreateFloat", AppropriateKind: ipld.ReprKindSet_JustFloat, ActualKind: ipld.ReprKind_String} -} -func (nb _String__NodeBuilder) CreateString(v string) (ipld.Node, error) { - return String{v}, nil + +type String struct{ x string } + +func (x String) String() string { + return x.x } -func (_String__NodeBuilder) CreateBytes([]byte) (ipld.Node, error) { - return nil, ipld.ErrWrongKind{TypeName: "String.Builder", MethodName: "CreateBytes", AppropriateKind: ipld.ReprKindSet_JustBytes, ActualKind: ipld.ReprKind_String} + +type String__Content struct { + Value string } -func (_String__NodeBuilder) CreateLink(ipld.Link) (ipld.Node, error) { - return nil, ipld.ErrWrongKind{TypeName: "String.Builder", MethodName: "CreateLink", AppropriateKind: ipld.ReprKindSet_JustLink, ActualKind: ipld.ReprKind_String} + +func (b String__Content) Build() (String, error) { + x := String{ + b.Value, + } + // FUTURE : want to support customizable validation. + // but 'if v, ok := x.(schema.Validatable); ok {' doesn't fly: need a way to work on concrete types. + return x, nil } -func (String) Representation() ipld.Node { - panic("TODO representation") +func (b String__Content) MustBuild() String { + if x, err := b.Build(); err != nil { + panic(err) + } else { + return x + } } -type Int struct{ x int } -func (x Int) Int() int { - return x.x -} -// TODO generateKindInt.EmitNativeBuilder -type MaybeInt struct { +type MaybeString struct { Maybe schema.Maybe - Value Int + Value String } -func (m MaybeInt) Must() Int { +func (m MaybeString) Must() String { if m.Maybe != schema.Maybe_Value { panic("unbox of a maybe rejected") } return m.Value } +func (String) Type() schema.Type { + return nil /*TODO:typelit*/ +} +func (String) Representation() ipld.Node { + panic("TODO representation") +} + var _ ipld.Node = Int{} var _ schema.TypedNode = Int{} -func (Int) Type() schema.Type { - return nil /*TODO:typelit*/ -} func (Int) ReprKind() ipld.ReprKind { return ipld.ReprKind_Int } @@ -213,71 +155,36 @@ func (Int) AsBytes() ([]byte, error) { func (Int) AsLink() (ipld.Link, error) { return nil, ipld.ErrWrongKind{TypeName: "Int", MethodName: "AsLink", AppropriateKind: ipld.ReprKindSet_JustLink, ActualKind: ipld.ReprKind_Int} } -func (Int) NodeBuilder() ipld.NodeBuilder { - return _Int__NodeBuilder{} -} -type _Int__NodeBuilder struct{} -func Int__NodeBuilder() ipld.NodeBuilder { - return _Int__NodeBuilder{} -} -func (_Int__NodeBuilder) CreateMap() (ipld.MapBuilder, error) { - return nil, ipld.ErrWrongKind{TypeName: "Int.Builder", MethodName: "CreateMap", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: ipld.ReprKind_Int} -} -func (_Int__NodeBuilder) AmendMap() (ipld.MapBuilder, error) { - return nil, ipld.ErrWrongKind{TypeName: "Int.Builder", MethodName: "AmendMap", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: ipld.ReprKind_Int} -} -func (_Int__NodeBuilder) CreateList() (ipld.ListBuilder, error) { - return nil, ipld.ErrWrongKind{TypeName: "Int.Builder", MethodName: "CreateList", AppropriateKind: ipld.ReprKindSet_JustList, ActualKind: ipld.ReprKind_Int} -} -func (_Int__NodeBuilder) AmendList() (ipld.ListBuilder, error) { - return nil, ipld.ErrWrongKind{TypeName: "Int.Builder", MethodName: "AmendList", AppropriateKind: ipld.ReprKindSet_JustList, ActualKind: ipld.ReprKind_Int} -} -func (_Int__NodeBuilder) CreateNull() (ipld.Node, error) { - return nil, ipld.ErrWrongKind{TypeName: "Int.Builder", MethodName: "CreateNull", AppropriateKind: ipld.ReprKindSet_JustNull, ActualKind: ipld.ReprKind_Int} -} -func (_Int__NodeBuilder) CreateBool(bool) (ipld.Node, error) { - return nil, ipld.ErrWrongKind{TypeName: "Int.Builder", MethodName: "CreateBool", AppropriateKind: ipld.ReprKindSet_JustBool, ActualKind: ipld.ReprKind_Int} -} -func (nb _Int__NodeBuilder) CreateInt(v int) (ipld.Node, error) { - return Int{v}, nil -} -func (_Int__NodeBuilder) CreateFloat(float64) (ipld.Node, error) { - return nil, ipld.ErrWrongKind{TypeName: "Int.Builder", MethodName: "CreateFloat", AppropriateKind: ipld.ReprKindSet_JustFloat, ActualKind: ipld.ReprKind_Int} -} -func (_Int__NodeBuilder) CreateString(string) (ipld.Node, error) { - return nil, ipld.ErrWrongKind{TypeName: "Int.Builder", MethodName: "CreateString", AppropriateKind: ipld.ReprKindSet_JustString, ActualKind: ipld.ReprKind_Int} -} -func (_Int__NodeBuilder) CreateBytes([]byte) (ipld.Node, error) { - return nil, ipld.ErrWrongKind{TypeName: "Int.Builder", MethodName: "CreateBytes", AppropriateKind: ipld.ReprKindSet_JustBytes, ActualKind: ipld.ReprKind_Int} -} -func (_Int__NodeBuilder) CreateLink(ipld.Link) (ipld.Node, error) { - return nil, ipld.ErrWrongKind{TypeName: "Int.Builder", MethodName: "CreateLink", AppropriateKind: ipld.ReprKindSet_JustLink, ActualKind: ipld.ReprKind_Int} -} -func (Int) Representation() ipld.Node { - panic("TODO representation") + +type Int struct{ x int } + +func (x Int) Int() int { + return x.x } -type Bytes struct{ x []byte } -// TODO generateKindBytes.EmitNativeAccessors -// TODO generateKindBytes.EmitNativeBuilder -type MaybeBytes struct { +// TODO generateKindInt.EmitNativeBuilder +type MaybeInt struct { Maybe schema.Maybe - Value Bytes + Value Int } -func (m MaybeBytes) Must() Bytes { +func (m MaybeInt) Must() Int { if m.Maybe != schema.Maybe_Value { panic("unbox of a maybe rejected") } return m.Value } +func (Int) Type() schema.Type { + return nil /*TODO:typelit*/ +} +func (Int) Representation() ipld.Node { + panic("TODO representation") +} + var _ ipld.Node = Bytes{} var _ schema.TypedNode = Bytes{} -func (Bytes) Type() schema.Type { - return nil /*TODO:typelit*/ -} func (Bytes) ReprKind() ipld.ReprKind { return ipld.ReprKind_Bytes } @@ -326,71 +233,33 @@ func (x Bytes) AsBytes() ([]byte, error) { func (Bytes) AsLink() (ipld.Link, error) { return nil, ipld.ErrWrongKind{TypeName: "Bytes", MethodName: "AsLink", AppropriateKind: ipld.ReprKindSet_JustLink, ActualKind: ipld.ReprKind_Bytes} } -func (Bytes) NodeBuilder() ipld.NodeBuilder { - return _Bytes__NodeBuilder{} -} -type _Bytes__NodeBuilder struct{} -func Bytes__NodeBuilder() ipld.NodeBuilder { - return _Bytes__NodeBuilder{} -} -func (_Bytes__NodeBuilder) CreateMap() (ipld.MapBuilder, error) { - return nil, ipld.ErrWrongKind{TypeName: "Bytes.Builder", MethodName: "CreateMap", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: ipld.ReprKind_Bytes} -} -func (_Bytes__NodeBuilder) AmendMap() (ipld.MapBuilder, error) { - return nil, ipld.ErrWrongKind{TypeName: "Bytes.Builder", MethodName: "AmendMap", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: ipld.ReprKind_Bytes} -} -func (_Bytes__NodeBuilder) CreateList() (ipld.ListBuilder, error) { - return nil, ipld.ErrWrongKind{TypeName: "Bytes.Builder", MethodName: "CreateList", AppropriateKind: ipld.ReprKindSet_JustList, ActualKind: ipld.ReprKind_Bytes} -} -func (_Bytes__NodeBuilder) AmendList() (ipld.ListBuilder, error) { - return nil, ipld.ErrWrongKind{TypeName: "Bytes.Builder", MethodName: "AmendList", AppropriateKind: ipld.ReprKindSet_JustList, ActualKind: ipld.ReprKind_Bytes} -} -func (_Bytes__NodeBuilder) CreateNull() (ipld.Node, error) { - return nil, ipld.ErrWrongKind{TypeName: "Bytes.Builder", MethodName: "CreateNull", AppropriateKind: ipld.ReprKindSet_JustNull, ActualKind: ipld.ReprKind_Bytes} -} -func (_Bytes__NodeBuilder) CreateBool(bool) (ipld.Node, error) { - return nil, ipld.ErrWrongKind{TypeName: "Bytes.Builder", MethodName: "CreateBool", AppropriateKind: ipld.ReprKindSet_JustBool, ActualKind: ipld.ReprKind_Bytes} -} -func (_Bytes__NodeBuilder) CreateInt(int) (ipld.Node, error) { - return nil, ipld.ErrWrongKind{TypeName: "Bytes.Builder", MethodName: "CreateInt", AppropriateKind: ipld.ReprKindSet_JustInt, ActualKind: ipld.ReprKind_Bytes} -} -func (_Bytes__NodeBuilder) CreateFloat(float64) (ipld.Node, error) { - return nil, ipld.ErrWrongKind{TypeName: "Bytes.Builder", MethodName: "CreateFloat", AppropriateKind: ipld.ReprKindSet_JustFloat, ActualKind: ipld.ReprKind_Bytes} -} -func (_Bytes__NodeBuilder) CreateString(string) (ipld.Node, error) { - return nil, ipld.ErrWrongKind{TypeName: "Bytes.Builder", MethodName: "CreateString", AppropriateKind: ipld.ReprKindSet_JustString, ActualKind: ipld.ReprKind_Bytes} -} -func (nb _Bytes__NodeBuilder) CreateBytes(v []byte) (ipld.Node, error) { - return Bytes{v}, nil -} -func (_Bytes__NodeBuilder) CreateLink(ipld.Link) (ipld.Node, error) { - return nil, ipld.ErrWrongKind{TypeName: "Bytes.Builder", MethodName: "CreateLink", AppropriateKind: ipld.ReprKindSet_JustLink, ActualKind: ipld.ReprKind_Bytes} -} -func (Bytes) Representation() ipld.Node { - panic("TODO representation") -} -type Link struct{ x ipld.Link } -// TODO generateKindLink.EmitNativeAccessors -// TODO generateKindLink.EmitNativeBuilder -type MaybeLink struct { +type Bytes struct{ x []byte } + +// TODO generateKindBytes.EmitNativeAccessors +// TODO generateKindBytes.EmitNativeBuilder +type MaybeBytes struct { Maybe schema.Maybe - Value Link + Value Bytes } -func (m MaybeLink) Must() Link { +func (m MaybeBytes) Must() Bytes { if m.Maybe != schema.Maybe_Value { panic("unbox of a maybe rejected") } return m.Value } +func (Bytes) Type() schema.Type { + return nil /*TODO:typelit*/ +} +func (Bytes) Representation() ipld.Node { + panic("TODO representation") +} + var _ ipld.Node = Link{} var _ schema.TypedNode = Link{} -func (Link) Type() schema.Type { - return nil /*TODO:typelit*/ -} func (Link) ReprKind() ipld.ReprKind { return ipld.ReprKind_Link } @@ -439,103 +308,33 @@ func (Link) AsBytes() ([]byte, error) { func (x Link) AsLink() (ipld.Link, error) { return x.x, nil } -func (Link) NodeBuilder() ipld.NodeBuilder { - return _Link__NodeBuilder{} -} -type _Link__NodeBuilder struct{} - -func Link__NodeBuilder() ipld.NodeBuilder { - return _Link__NodeBuilder{} -} -func (_Link__NodeBuilder) CreateMap() (ipld.MapBuilder, error) { - return nil, ipld.ErrWrongKind{TypeName: "Link.Builder", MethodName: "CreateMap", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: ipld.ReprKind_Link} -} -func (_Link__NodeBuilder) AmendMap() (ipld.MapBuilder, error) { - return nil, ipld.ErrWrongKind{TypeName: "Link.Builder", MethodName: "AmendMap", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: ipld.ReprKind_Link} -} -func (_Link__NodeBuilder) CreateList() (ipld.ListBuilder, error) { - return nil, ipld.ErrWrongKind{TypeName: "Link.Builder", MethodName: "CreateList", AppropriateKind: ipld.ReprKindSet_JustList, ActualKind: ipld.ReprKind_Link} -} -func (_Link__NodeBuilder) AmendList() (ipld.ListBuilder, error) { - return nil, ipld.ErrWrongKind{TypeName: "Link.Builder", MethodName: "AmendList", AppropriateKind: ipld.ReprKindSet_JustList, ActualKind: ipld.ReprKind_Link} -} -func (_Link__NodeBuilder) CreateNull() (ipld.Node, error) { - return nil, ipld.ErrWrongKind{TypeName: "Link.Builder", MethodName: "CreateNull", AppropriateKind: ipld.ReprKindSet_JustNull, ActualKind: ipld.ReprKind_Link} -} -func (_Link__NodeBuilder) CreateBool(bool) (ipld.Node, error) { - return nil, ipld.ErrWrongKind{TypeName: "Link.Builder", MethodName: "CreateBool", AppropriateKind: ipld.ReprKindSet_JustBool, ActualKind: ipld.ReprKind_Link} -} -func (_Link__NodeBuilder) CreateInt(int) (ipld.Node, error) { - return nil, ipld.ErrWrongKind{TypeName: "Link.Builder", MethodName: "CreateInt", AppropriateKind: ipld.ReprKindSet_JustInt, ActualKind: ipld.ReprKind_Link} -} -func (_Link__NodeBuilder) CreateFloat(float64) (ipld.Node, error) { - return nil, ipld.ErrWrongKind{TypeName: "Link.Builder", MethodName: "CreateFloat", AppropriateKind: ipld.ReprKindSet_JustFloat, ActualKind: ipld.ReprKind_Link} -} -func (_Link__NodeBuilder) CreateString(string) (ipld.Node, error) { - return nil, ipld.ErrWrongKind{TypeName: "Link.Builder", MethodName: "CreateString", AppropriateKind: ipld.ReprKindSet_JustString, ActualKind: ipld.ReprKind_Link} -} -func (_Link__NodeBuilder) CreateBytes([]byte) (ipld.Node, error) { - return nil, ipld.ErrWrongKind{TypeName: "Link.Builder", MethodName: "CreateBytes", AppropriateKind: ipld.ReprKindSet_JustBytes, ActualKind: ipld.ReprKind_Link} -} -func (nb _Link__NodeBuilder) CreateLink(v ipld.Link) (ipld.Node, error) { - return Link{v}, nil -} -func (Link) Representation() ipld.Node { - panic("TODO representation") -} -type PBLink struct{ - d PBLink__Content -} - -func (x PBLink) FieldHash()MaybeLink { - return x.d.Hash -} -func (x PBLink) FieldName()MaybeString { - return x.d.Name -} -func (x PBLink) FieldTsize()MaybeInt { - return x.d.Tsize -} - -type PBLink__Content struct { - Hash MaybeLink - Name MaybeString - Tsize MaybeInt -} - -func (b PBLink__Content) Build() (PBLink, error) { - x := PBLink{b} - // FUTURE : want to support customizable validation. - // but 'if v, ok := x.(schema.Validatable); ok {' doesn't fly: need a way to work on concrete types. - return x, nil -} -func (b PBLink__Content) MustBuild() PBLink { - if x, err := b.Build(); err != nil { - panic(err) - } else { - return x - } -} +type Link struct{ x ipld.Link } -type MaybePBLink struct { +// TODO generateKindLink.EmitNativeAccessors +// TODO generateKindLink.EmitNativeBuilder +type MaybeLink struct { Maybe schema.Maybe - Value PBLink + Value Link } -func (m MaybePBLink) Must() PBLink { +func (m MaybeLink) Must() Link { if m.Maybe != schema.Maybe_Value { panic("unbox of a maybe rejected") } return m.Value } +func (Link) Type() schema.Type { + return nil /*TODO:typelit*/ +} +func (Link) Representation() ipld.Node { + panic("TODO representation") +} + var _ ipld.Node = PBLink{} var _ schema.TypedNode = PBLink{} -func (PBLink) Type() schema.Type { - return nil /*TODO:typelit*/ -} func (PBLink) ReprKind() ipld.ReprKind { return ipld.ReprKind_Map } @@ -563,7 +362,7 @@ func (x PBLink) LookupString(key string) (ipld.Node, error) { func (x PBLink) Lookup(key ipld.Node) (ipld.Node, error) { ks, err := key.AsString() if err != nil { - return nil, ipld.ErrInvalidKey{"got " + key.ReprKind().String() + ", need string"} + return nil, err } return x.LookupString(ks) } @@ -648,140 +447,63 @@ func (PBLink) AsBytes() ([]byte, error) { func (PBLink) AsLink() (ipld.Link, error) { return nil, ipld.ErrWrongKind{TypeName: "PBLink", MethodName: "AsLink", AppropriateKind: ipld.ReprKindSet_JustLink, ActualKind: ipld.ReprKind_Map} } -func (PBLink) NodeBuilder() ipld.NodeBuilder { - return _PBLink__NodeBuilder{} -} -type _PBLink__NodeBuilder struct{} -func PBLink__NodeBuilder() ipld.NodeBuilder { - return _PBLink__NodeBuilder{} -} -func (nb _PBLink__NodeBuilder) CreateMap() (ipld.MapBuilder, error) { - mb := &_PBLink__MapBuilder{v:&PBLink{}} - mb.v.d.Hash.Maybe = schema.Maybe_Absent - mb.v.d.Name.Maybe = schema.Maybe_Absent - mb.v.d.Tsize.Maybe = schema.Maybe_Absent - return mb, nil +type PBLink struct { + d PBLink__Content } -type _PBLink__MapBuilder struct{ - v *PBLink +func (x PBLink) FieldHash() MaybeLink { + return x.d.Hash } - -func (mb *_PBLink__MapBuilder) Insert(k, v ipld.Node) error { - ks, err := k.AsString() - if err != nil { - return ipld.ErrInvalidKey{"not a string: " + err.Error()} - } - switch ks { - case "Hash": - if v.IsNull() { - panic("type mismatch on struct field assignment: cannot assign null to non-nullable field") // FIXME need an error type for this - } - tv, ok := v.(schema.TypedNode) - if !ok { - panic("need schema.TypedNode for insertion into struct") // FIXME need an error type for this - } - x, ok := v.(Link) - if !ok { - panic("field 'Hash' in type PBLink is type Link; cannot assign "+tv.Type().Name()) // FIXME need an error type for this - } - mb.v.d.Hash.Value = x - mb.v.d.Hash.Maybe = schema.Maybe_Value - case "Name": - if v.IsNull() { - panic("type mismatch on struct field assignment: cannot assign null to non-nullable field") // FIXME need an error type for this - } - tv, ok := v.(schema.TypedNode) - if !ok { - panic("need schema.TypedNode for insertion into struct") // FIXME need an error type for this - } - x, ok := v.(String) - if !ok { - panic("field 'Name' in type PBLink is type String; cannot assign "+tv.Type().Name()) // FIXME need an error type for this - } - mb.v.d.Name.Value = x - mb.v.d.Name.Maybe = schema.Maybe_Value - case "Tsize": - if v.IsNull() { - panic("type mismatch on struct field assignment: cannot assign null to non-nullable field") // FIXME need an error type for this - } - tv, ok := v.(schema.TypedNode) - if !ok { - panic("need schema.TypedNode for insertion into struct") // FIXME need an error type for this - } - x, ok := v.(Int) - if !ok { - panic("field 'Tsize' in type PBLink is type Int; cannot assign "+tv.Type().Name()) // FIXME need an error type for this - } - mb.v.d.Tsize.Value = x - mb.v.d.Tsize.Maybe = schema.Maybe_Value - default: - return schema.ErrNoSuchField{Type: nil /*TODO:typelit*/, FieldName: ks} - } - return nil +func (x PBLink) FieldName() MaybeString { + return x.d.Name } -func (mb *_PBLink__MapBuilder) Delete(k ipld.Node) error { - panic("TODO later") +func (x PBLink) FieldTsize() MaybeInt { + return x.d.Tsize } -func (mb *_PBLink__MapBuilder) Build() (ipld.Node, error) { - v := *mb.v - mb = nil - return v, nil + +type PBLink__Content struct { + Hash MaybeLink + Name MaybeString + Tsize MaybeInt } -func (mb *_PBLink__MapBuilder) BuilderForKeys() ipld.NodeBuilder { - return _String__NodeBuilder{} + +func (b PBLink__Content) Build() (PBLink, error) { + x := PBLink{b} + // FUTURE : want to support customizable validation. + // but 'if v, ok := x.(schema.Validatable); ok {' doesn't fly: need a way to work on concrete types. + return x, nil } -func (mb *_PBLink__MapBuilder) BuilderForValue(ks string) ipld.NodeBuilder { - switch ks { - case "Hash": - return Link__NodeBuilder() - case "Name": - return String__NodeBuilder() - case "Tsize": - return Int__NodeBuilder() - default: - panic(schema.ErrNoSuchField{Type: nil /*TODO:typelit*/, FieldName: ks}) +func (b PBLink__Content) MustBuild() PBLink { + if x, err := b.Build(); err != nil { + panic(err) + } else { + return x } - return nil } -func (nb _PBLink__NodeBuilder) AmendMap() (ipld.MapBuilder, error) { - panic("TODO later") -} -func (_PBLink__NodeBuilder) CreateList() (ipld.ListBuilder, error) { - return nil, ipld.ErrWrongKind{TypeName: "PBLink.Builder", MethodName: "CreateList", AppropriateKind: ipld.ReprKindSet_JustList, ActualKind: ipld.ReprKind_Map} -} -func (_PBLink__NodeBuilder) AmendList() (ipld.ListBuilder, error) { - return nil, ipld.ErrWrongKind{TypeName: "PBLink.Builder", MethodName: "AmendList", AppropriateKind: ipld.ReprKindSet_JustList, ActualKind: ipld.ReprKind_Map} -} -func (_PBLink__NodeBuilder) CreateNull() (ipld.Node, error) { - return nil, ipld.ErrWrongKind{TypeName: "PBLink.Builder", MethodName: "CreateNull", AppropriateKind: ipld.ReprKindSet_JustNull, ActualKind: ipld.ReprKind_Map} -} -func (_PBLink__NodeBuilder) CreateBool(bool) (ipld.Node, error) { - return nil, ipld.ErrWrongKind{TypeName: "PBLink.Builder", MethodName: "CreateBool", AppropriateKind: ipld.ReprKindSet_JustBool, ActualKind: ipld.ReprKind_Map} -} -func (_PBLink__NodeBuilder) CreateInt(int) (ipld.Node, error) { - return nil, ipld.ErrWrongKind{TypeName: "PBLink.Builder", MethodName: "CreateInt", AppropriateKind: ipld.ReprKindSet_JustInt, ActualKind: ipld.ReprKind_Map} -} -func (_PBLink__NodeBuilder) CreateFloat(float64) (ipld.Node, error) { - return nil, ipld.ErrWrongKind{TypeName: "PBLink.Builder", MethodName: "CreateFloat", AppropriateKind: ipld.ReprKindSet_JustFloat, ActualKind: ipld.ReprKind_Map} -} -func (_PBLink__NodeBuilder) CreateString(string) (ipld.Node, error) { - return nil, ipld.ErrWrongKind{TypeName: "PBLink.Builder", MethodName: "CreateString", AppropriateKind: ipld.ReprKindSet_JustString, ActualKind: ipld.ReprKind_Map} +type MaybePBLink struct { + Maybe schema.Maybe + Value PBLink } -func (_PBLink__NodeBuilder) CreateBytes([]byte) (ipld.Node, error) { - return nil, ipld.ErrWrongKind{TypeName: "PBLink.Builder", MethodName: "CreateBytes", AppropriateKind: ipld.ReprKindSet_JustBytes, ActualKind: ipld.ReprKind_Map} + +func (m MaybePBLink) Must() PBLink { + if m.Maybe != schema.Maybe_Value { + panic("unbox of a maybe rejected") + } + return m.Value } -func (_PBLink__NodeBuilder) CreateLink(ipld.Link) (ipld.Node, error) { - return nil, ipld.ErrWrongKind{TypeName: "PBLink.Builder", MethodName: "CreateLink", AppropriateKind: ipld.ReprKindSet_JustLink, ActualKind: ipld.ReprKind_Map} + +func (PBLink) Type() schema.Type { + return nil /*TODO:typelit*/ } func (n PBLink) Representation() ipld.Node { return _PBLink__Repr{&n} } + var _ ipld.Node = _PBLink__Repr{} -type _PBLink__Repr struct{ +type _PBLink__Repr struct { n *PBLink } @@ -812,7 +534,7 @@ func (rn _PBLink__Repr) LookupString(key string) (ipld.Node, error) { func (rn _PBLink__Repr) Lookup(key ipld.Node) (ipld.Node, error) { ks, err := key.AsString() if err != nil { - return nil, ipld.ErrInvalidKey{"got " + key.ReprKind().String() + ", need string"} + return nil, err } return rn.LookupString(ks) } @@ -909,172 +631,10 @@ func (_PBLink__Repr) AsBytes() ([]byte, error) { func (_PBLink__Repr) AsLink() (ipld.Link, error) { return nil, ipld.ErrWrongKind{TypeName: "PBLink.Representation", MethodName: "AsLink", AppropriateKind: ipld.ReprKindSet_JustLink, ActualKind: ipld.ReprKind_Map} } -func (_PBLink__Repr) NodeBuilder() ipld.NodeBuilder { - return _PBLink__ReprBuilder{} -} -type _PBLink__ReprBuilder struct{} - -func PBLink__ReprBuilder() ipld.NodeBuilder { - return _PBLink__ReprBuilder{} -} -func (nb _PBLink__ReprBuilder) CreateMap() (ipld.MapBuilder, error) { - mb := &_PBLink__ReprMapBuilder{v:&PBLink{}} - mb.v.d.Hash.Maybe = schema.Maybe_Absent - mb.v.d.Name.Maybe = schema.Maybe_Absent - mb.v.d.Tsize.Maybe = schema.Maybe_Absent - return mb, nil -} - -type _PBLink__ReprMapBuilder struct{ - v *PBLink - Hash__isset bool - Name__isset bool - Tsize__isset bool -} - -func (mb *_PBLink__ReprMapBuilder) Insert(k, v ipld.Node) error { - ks, err := k.AsString() - if err != nil { - return ipld.ErrInvalidKey{"not a string: " + err.Error()} - } - switch ks { - case "Hash": - if mb.Hash__isset { - panic("repeated assignment to field") // FIXME need an error type for this - } - if v.IsNull() { - panic("type mismatch on struct field assignment: cannot assign null to non-nullable field") // FIXME need an error type for this - } - tv, ok := v.(schema.TypedNode) - if !ok { - panic("need schema.TypedNode for insertion into struct") // FIXME need an error type for this - } - x, ok := v.(Link) - if !ok { - panic("field 'Hash' (key: 'Hash') in type PBLink is type Link; cannot assign "+tv.Type().Name()) // FIXME need an error type for this - } - mb.v.d.Hash.Value = x - mb.v.d.Hash.Maybe = schema.Maybe_Value - mb.Hash__isset = true - case "Name": - if mb.Name__isset { - panic("repeated assignment to field") // FIXME need an error type for this - } - if v.IsNull() { - panic("type mismatch on struct field assignment: cannot assign null to non-nullable field") // FIXME need an error type for this - } - tv, ok := v.(schema.TypedNode) - if !ok { - panic("need schema.TypedNode for insertion into struct") // FIXME need an error type for this - } - x, ok := v.(String) - if !ok { - panic("field 'Name' (key: 'Name') in type PBLink is type String; cannot assign "+tv.Type().Name()) // FIXME need an error type for this - } - mb.v.d.Name.Value = x - mb.v.d.Name.Maybe = schema.Maybe_Value - mb.Name__isset = true - case "Tsize": - if mb.Tsize__isset { - panic("repeated assignment to field") // FIXME need an error type for this - } - if v.IsNull() { - panic("type mismatch on struct field assignment: cannot assign null to non-nullable field") // FIXME need an error type for this - } - tv, ok := v.(schema.TypedNode) - if !ok { - panic("need schema.TypedNode for insertion into struct") // FIXME need an error type for this - } - x, ok := v.(Int) - if !ok { - panic("field 'Tsize' (key: 'Tsize') in type PBLink is type Int; cannot assign "+tv.Type().Name()) // FIXME need an error type for this - } - mb.v.d.Tsize.Value = x - mb.v.d.Tsize.Maybe = schema.Maybe_Value - mb.Tsize__isset = true - default: - return schema.ErrNoSuchField{Type: nil /*TODO:typelit*/, FieldName: ks} - } - return nil -} -func (mb *_PBLink__ReprMapBuilder) Delete(k ipld.Node) error { - panic("TODO later") -} -func (mb *_PBLink__ReprMapBuilder) Build() (ipld.Node, error) { - v := mb.v - mb = nil - return v, nil -} -func (mb *_PBLink__ReprMapBuilder) BuilderForKeys() ipld.NodeBuilder { - return _String__NodeBuilder{} -} -func (mb *_PBLink__ReprMapBuilder) BuilderForValue(ks string) ipld.NodeBuilder { - switch ks { - case "Hash": - return Link__NodeBuilder() - case "Name": - return String__NodeBuilder() - case "Tsize": - return Int__NodeBuilder() - default: - panic(schema.ErrNoSuchField{Type: nil /*TODO:typelit*/, FieldName: ks}) - } - return nil -} - -func (nb _PBLink__ReprBuilder) AmendMap() (ipld.MapBuilder, error) { - panic("TODO later") -} -func (_PBLink__ReprBuilder) CreateList() (ipld.ListBuilder, error) { - return nil, ipld.ErrWrongKind{TypeName: "PBLink.Representation.Builder", MethodName: "CreateList", AppropriateKind: ipld.ReprKindSet_JustList, ActualKind: ipld.ReprKind_Map} -} -func (_PBLink__ReprBuilder) AmendList() (ipld.ListBuilder, error) { - return nil, ipld.ErrWrongKind{TypeName: "PBLink.Representation.Builder", MethodName: "AmendList", AppropriateKind: ipld.ReprKindSet_JustList, ActualKind: ipld.ReprKind_Map} -} -func (_PBLink__ReprBuilder) CreateNull() (ipld.Node, error) { - return nil, ipld.ErrWrongKind{TypeName: "PBLink.Representation.Builder", MethodName: "CreateNull", AppropriateKind: ipld.ReprKindSet_JustNull, ActualKind: ipld.ReprKind_Map} -} -func (_PBLink__ReprBuilder) CreateBool(bool) (ipld.Node, error) { - return nil, ipld.ErrWrongKind{TypeName: "PBLink.Representation.Builder", MethodName: "CreateBool", AppropriateKind: ipld.ReprKindSet_JustBool, ActualKind: ipld.ReprKind_Map} -} -func (_PBLink__ReprBuilder) CreateInt(int) (ipld.Node, error) { - return nil, ipld.ErrWrongKind{TypeName: "PBLink.Representation.Builder", MethodName: "CreateInt", AppropriateKind: ipld.ReprKindSet_JustInt, ActualKind: ipld.ReprKind_Map} -} -func (_PBLink__ReprBuilder) CreateFloat(float64) (ipld.Node, error) { - return nil, ipld.ErrWrongKind{TypeName: "PBLink.Representation.Builder", MethodName: "CreateFloat", AppropriateKind: ipld.ReprKindSet_JustFloat, ActualKind: ipld.ReprKind_Map} -} -func (_PBLink__ReprBuilder) CreateString(string) (ipld.Node, error) { - return nil, ipld.ErrWrongKind{TypeName: "PBLink.Representation.Builder", MethodName: "CreateString", AppropriateKind: ipld.ReprKindSet_JustString, ActualKind: ipld.ReprKind_Map} -} -func (_PBLink__ReprBuilder) CreateBytes([]byte) (ipld.Node, error) { - return nil, ipld.ErrWrongKind{TypeName: "PBLink.Representation.Builder", MethodName: "CreateBytes", AppropriateKind: ipld.ReprKindSet_JustBytes, ActualKind: ipld.ReprKind_Map} -} -func (_PBLink__ReprBuilder) CreateLink(ipld.Link) (ipld.Node, error) { - return nil, ipld.ErrWrongKind{TypeName: "PBLink.Representation.Builder", MethodName: "CreateLink", AppropriateKind: ipld.ReprKindSet_JustLink, ActualKind: ipld.ReprKind_Map} -} -type PBLinks struct{ - x []PBLink -} -// TODO generateKindList.EmitNativeAccessors -// TODO generateKindList.EmitNativeBuilder -type MaybePBLinks struct { - Maybe schema.Maybe - Value PBLinks -} - -func (m MaybePBLinks) Must() PBLinks { - if m.Maybe != schema.Maybe_Value { - panic("unbox of a maybe rejected") - } - return m.Value -} var _ ipld.Node = PBLinks{} var _ schema.TypedNode = PBLinks{} -func (PBLinks) Type() schema.Type { - return nil /*TODO:typelit*/ -} func (PBLinks) ReprKind() ipld.ReprKind { return ipld.ReprKind_List } @@ -1084,7 +644,7 @@ func (PBLinks) LookupString(string) (ipld.Node, error) { func (x PBLinks) Lookup(key ipld.Node) (ipld.Node, error) { ki, err := key.AsInt() if err != nil { - return nil, ipld.ErrInvalidKey{"got " + key.ReprKind().String() + ", need Int"} + return nil, err } return x.LookupIndex(ki) } @@ -1113,7 +673,7 @@ type _PBLinks__Itr struct { idx int } -func (itr *_PBLinks__Itr) Next() (idx int, value ipld.Node, _ error) { +func (itr *_PBLinks__Itr) Next() (idx int, value ipld.Node, _ error) { if itr.idx >= len(itr.node.x) { return 0, nil, ipld.ErrIteratorOverread{} } @@ -1154,204 +714,35 @@ func (PBLinks) AsBytes() ([]byte, error) { func (PBLinks) AsLink() (ipld.Link, error) { return nil, ipld.ErrWrongKind{TypeName: "PBLinks", MethodName: "AsLink", AppropriateKind: ipld.ReprKindSet_JustLink, ActualKind: ipld.ReprKind_List} } -func (PBLinks) NodeBuilder() ipld.NodeBuilder { - return _PBLinks__NodeBuilder{} -} -type _PBLinks__NodeBuilder struct{} - -func PBLinks__NodeBuilder() ipld.NodeBuilder { - return _PBLinks__NodeBuilder{} -} -func (_PBLinks__NodeBuilder) CreateMap() (ipld.MapBuilder, error) { - return nil, ipld.ErrWrongKind{TypeName: "PBLinks.Builder", MethodName: "CreateMap", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: ipld.ReprKind_List} -} -func (_PBLinks__NodeBuilder) AmendMap() (ipld.MapBuilder, error) { - return nil, ipld.ErrWrongKind{TypeName: "PBLinks.Builder", MethodName: "AmendMap", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: ipld.ReprKind_List} -} -func (nb _PBLinks__NodeBuilder) CreateList() (ipld.ListBuilder, error) { - return &_PBLinks__ListBuilder{v:&PBLinks{}}, nil -} - -type _PBLinks__ListBuilder struct{ - v *PBLinks -} - -func (lb *_PBLinks__ListBuilder) growList(k int) { - oldLen := len(lb.v.x) - minLen := k + 1 - if minLen > oldLen { - // Grow. - oldCap := cap(lb.v.x) - if minLen > oldCap { - // Out of cap; do whole new backing array allocation. - // Growth maths are per stdlib's reflect.grow. - // First figure out how much growth to do. - newCap := oldCap - if newCap == 0 { - newCap = minLen - } else { - for minLen > newCap { - if minLen < 1024 { - newCap += newCap - } else { - newCap += newCap / 4 - } - } - } - // Now alloc and copy over old. - newArr := make([]PBLink, minLen, newCap) - copy(newArr, lb.v.x) - lb.v.x = newArr - } else { - // Still have cap, just extend the slice. - lb.v.x = lb.v.x[0:minLen] - } - } -} - -func (lb *_PBLinks__ListBuilder) validate(v ipld.Node) error { - if v.IsNull() { - panic("type mismatch on struct field assignment: cannot assign null to non-nullable field") // FIXME need an error type for this - } - tv, ok := v.(schema.TypedNode) - if !ok { - panic("need schema.TypedNode for insertion into struct") // FIXME need an error type for this - } - _, ok = v.(PBLink) - if !ok { - panic("value for type PBLinks is type PBLink; cannot assign "+tv.Type().Name()) // FIXME need an error type for this - } - return nil -} -func (lb *_PBLinks__ListBuilder) unsafeSet(idx int, v ipld.Node) { - x := v.(PBLink) - lb.v.x[idx] = x +type PBLinks struct { + x []PBLink } -func (lb *_PBLinks__ListBuilder) AppendAll(vs []ipld.Node) error { - for _, v := range vs { - err := lb.validate(v) - if err != nil { - return err - } - } - off := len(lb.v.x) - new := off + len(vs) - lb.growList(new-1) - for _, v := range vs { - lb.unsafeSet(off, v) - off++ - } - return nil +// TODO generateKindList.EmitNativeAccessors +// TODO generateKindList.EmitNativeBuilder +type MaybePBLinks struct { + Maybe schema.Maybe + Value PBLinks } -func (lb *_PBLinks__ListBuilder) Append(v ipld.Node) error { - err := lb.validate(v) - if err != nil { - return err - } - off := len(lb.v.x) - lb.growList(off) - lb.unsafeSet(off, v) - return nil -} -func (lb *_PBLinks__ListBuilder) Set(idx int, v ipld.Node) error { - err := lb.validate(v) - if err != nil { - return err +func (m MaybePBLinks) Must() PBLinks { + if m.Maybe != schema.Maybe_Value { + panic("unbox of a maybe rejected") } - lb.growList(idx) - lb.unsafeSet(idx, v) - return nil -} - -func (lb *_PBLinks__ListBuilder) Build() (ipld.Node, error) { - v := *lb.v - lb = nil - return v, nil -} - -func (lb *_PBLinks__ListBuilder) BuilderForValue(_ int) ipld.NodeBuilder { - return PBLink__NodeBuilder() + return m.Value } -func (nb _PBLinks__NodeBuilder) AmendList() (ipld.ListBuilder, error) { - panic("TODO later") -} -func (_PBLinks__NodeBuilder) CreateNull() (ipld.Node, error) { - return nil, ipld.ErrWrongKind{TypeName: "PBLinks.Builder", MethodName: "CreateNull", AppropriateKind: ipld.ReprKindSet_JustNull, ActualKind: ipld.ReprKind_List} -} -func (_PBLinks__NodeBuilder) CreateBool(bool) (ipld.Node, error) { - return nil, ipld.ErrWrongKind{TypeName: "PBLinks.Builder", MethodName: "CreateBool", AppropriateKind: ipld.ReprKindSet_JustBool, ActualKind: ipld.ReprKind_List} -} -func (_PBLinks__NodeBuilder) CreateInt(int) (ipld.Node, error) { - return nil, ipld.ErrWrongKind{TypeName: "PBLinks.Builder", MethodName: "CreateInt", AppropriateKind: ipld.ReprKindSet_JustInt, ActualKind: ipld.ReprKind_List} -} -func (_PBLinks__NodeBuilder) CreateFloat(float64) (ipld.Node, error) { - return nil, ipld.ErrWrongKind{TypeName: "PBLinks.Builder", MethodName: "CreateFloat", AppropriateKind: ipld.ReprKindSet_JustFloat, ActualKind: ipld.ReprKind_List} -} -func (_PBLinks__NodeBuilder) CreateString(string) (ipld.Node, error) { - return nil, ipld.ErrWrongKind{TypeName: "PBLinks.Builder", MethodName: "CreateString", AppropriateKind: ipld.ReprKindSet_JustString, ActualKind: ipld.ReprKind_List} -} -func (_PBLinks__NodeBuilder) CreateBytes([]byte) (ipld.Node, error) { - return nil, ipld.ErrWrongKind{TypeName: "PBLinks.Builder", MethodName: "CreateBytes", AppropriateKind: ipld.ReprKindSet_JustBytes, ActualKind: ipld.ReprKind_List} -} -func (_PBLinks__NodeBuilder) CreateLink(ipld.Link) (ipld.Node, error) { - return nil, ipld.ErrWrongKind{TypeName: "PBLinks.Builder", MethodName: "CreateLink", AppropriateKind: ipld.ReprKindSet_JustLink, ActualKind: ipld.ReprKind_List} +func (PBLinks) Type() schema.Type { + return nil /*TODO:typelit*/ } func (n PBLinks) Representation() ipld.Node { panic("TODO representation") } -type PBNode struct{ - d PBNode__Content -} - -func (x PBNode) FieldLinks()PBLinks { - return x.d.Links -} -func (x PBNode) FieldData()Bytes { - return x.d.Data -} - - -type PBNode__Content struct { - Links PBLinks - Data Bytes -} - -func (b PBNode__Content) Build() (PBNode, error) { - x := PBNode{b} - // FUTURE : want to support customizable validation. - // but 'if v, ok := x.(schema.Validatable); ok {' doesn't fly: need a way to work on concrete types. - return x, nil -} -func (b PBNode__Content) MustBuild() PBNode { - if x, err := b.Build(); err != nil { - panic(err) - } else { - return x - } -} - -type MaybePBNode struct { - Maybe schema.Maybe - Value PBNode -} - -func (m MaybePBNode) Must() PBNode { - if m.Maybe != schema.Maybe_Value { - panic("unbox of a maybe rejected") - } - return m.Value -} var _ ipld.Node = PBNode{} var _ schema.TypedNode = PBNode{} -func (PBNode) Type() schema.Type { - return nil /*TODO:typelit*/ -} func (PBNode) ReprKind() ipld.ReprKind { return ipld.ReprKind_Map } @@ -1368,7 +759,7 @@ func (x PBNode) LookupString(key string) (ipld.Node, error) { func (x PBNode) Lookup(key ipld.Node) (ipld.Node, error) { ks, err := key.AsString() if err != nil { - return nil, ipld.ErrInvalidKey{"got " + key.ReprKind().String() + ", need string"} + return nil, err } return x.LookupString(ks) } @@ -1438,129 +829,59 @@ func (PBNode) AsBytes() ([]byte, error) { func (PBNode) AsLink() (ipld.Link, error) { return nil, ipld.ErrWrongKind{TypeName: "PBNode", MethodName: "AsLink", AppropriateKind: ipld.ReprKindSet_JustLink, ActualKind: ipld.ReprKind_Map} } -func (PBNode) NodeBuilder() ipld.NodeBuilder { - return _PBNode__NodeBuilder{} + +type PBNode struct { + d PBNode__Content } -type _PBNode__NodeBuilder struct{} -func PBNode__NodeBuilder() ipld.NodeBuilder { - return _PBNode__NodeBuilder{} +func (x PBNode) FieldLinks() PBLinks { + return x.d.Links } -func (nb _PBNode__NodeBuilder) CreateMap() (ipld.MapBuilder, error) { - mb := &_PBNode__MapBuilder{v:&PBNode{}} - return mb, nil +func (x PBNode) FieldData() Bytes { + return x.d.Data } -type _PBNode__MapBuilder struct{ - v *PBNode - Links__isset bool - Data__isset bool +type PBNode__Content struct { + Links PBLinks + Data Bytes } -func (mb *_PBNode__MapBuilder) Insert(k, v ipld.Node) error { - ks, err := k.AsString() - if err != nil { - return ipld.ErrInvalidKey{"not a string: " + err.Error()} - } - switch ks { - case "Links": - if v.IsNull() { - panic("type mismatch on struct field assignment: cannot assign null to non-nullable field") // FIXME need an error type for this - } - tv, ok := v.(schema.TypedNode) - if !ok { - panic("need schema.TypedNode for insertion into struct") // FIXME need an error type for this - } - x, ok := v.(PBLinks) - if !ok { - panic("field 'Links' in type PBNode is type PBLinks; cannot assign "+tv.Type().Name()) // FIXME need an error type for this - } - mb.v.d.Links = x - mb.Links__isset = true - case "Data": - if v.IsNull() { - panic("type mismatch on struct field assignment: cannot assign null to non-nullable field") // FIXME need an error type for this - } - tv, ok := v.(schema.TypedNode) - if !ok { - panic("need schema.TypedNode for insertion into struct") // FIXME need an error type for this - } - x, ok := v.(Bytes) - if !ok { - panic("field 'Data' in type PBNode is type Bytes; cannot assign "+tv.Type().Name()) // FIXME need an error type for this - } - mb.v.d.Data = x - mb.Data__isset = true - default: - return schema.ErrNoSuchField{Type: nil /*TODO:typelit*/, FieldName: ks} - } - return nil -} -func (mb *_PBNode__MapBuilder) Delete(k ipld.Node) error { - panic("TODO later") +func (b PBNode__Content) Build() (PBNode, error) { + x := PBNode{b} + // FUTURE : want to support customizable validation. + // but 'if v, ok := x.(schema.Validatable); ok {' doesn't fly: need a way to work on concrete types. + return x, nil } -func (mb *_PBNode__MapBuilder) Build() (ipld.Node, error) { - if !mb.Links__isset { - panic("missing required field 'Links' in building struct PBNode") // FIXME need an error type for this - } - if !mb.Data__isset { - panic("missing required field 'Data' in building struct PBNode") // FIXME need an error type for this +func (b PBNode__Content) MustBuild() PBNode { + if x, err := b.Build(); err != nil { + panic(err) + } else { + return x } - v := *mb.v - mb = nil - return v, nil } -func (mb *_PBNode__MapBuilder) BuilderForKeys() ipld.NodeBuilder { - return _String__NodeBuilder{} + +type MaybePBNode struct { + Maybe schema.Maybe + Value PBNode } -func (mb *_PBNode__MapBuilder) BuilderForValue(ks string) ipld.NodeBuilder { - switch ks { - case "Links": - return PBLinks__NodeBuilder() - case "Data": - return Bytes__NodeBuilder() - default: - panic(schema.ErrNoSuchField{Type: nil /*TODO:typelit*/, FieldName: ks}) + +func (m MaybePBNode) Must() PBNode { + if m.Maybe != schema.Maybe_Value { + panic("unbox of a maybe rejected") } - return nil + return m.Value } -func (nb _PBNode__NodeBuilder) AmendMap() (ipld.MapBuilder, error) { - panic("TODO later") -} -func (_PBNode__NodeBuilder) CreateList() (ipld.ListBuilder, error) { - return nil, ipld.ErrWrongKind{TypeName: "PBNode.Builder", MethodName: "CreateList", AppropriateKind: ipld.ReprKindSet_JustList, ActualKind: ipld.ReprKind_Map} -} -func (_PBNode__NodeBuilder) AmendList() (ipld.ListBuilder, error) { - return nil, ipld.ErrWrongKind{TypeName: "PBNode.Builder", MethodName: "AmendList", AppropriateKind: ipld.ReprKindSet_JustList, ActualKind: ipld.ReprKind_Map} -} -func (_PBNode__NodeBuilder) CreateNull() (ipld.Node, error) { - return nil, ipld.ErrWrongKind{TypeName: "PBNode.Builder", MethodName: "CreateNull", AppropriateKind: ipld.ReprKindSet_JustNull, ActualKind: ipld.ReprKind_Map} -} -func (_PBNode__NodeBuilder) CreateBool(bool) (ipld.Node, error) { - return nil, ipld.ErrWrongKind{TypeName: "PBNode.Builder", MethodName: "CreateBool", AppropriateKind: ipld.ReprKindSet_JustBool, ActualKind: ipld.ReprKind_Map} -} -func (_PBNode__NodeBuilder) CreateInt(int) (ipld.Node, error) { - return nil, ipld.ErrWrongKind{TypeName: "PBNode.Builder", MethodName: "CreateInt", AppropriateKind: ipld.ReprKindSet_JustInt, ActualKind: ipld.ReprKind_Map} -} -func (_PBNode__NodeBuilder) CreateFloat(float64) (ipld.Node, error) { - return nil, ipld.ErrWrongKind{TypeName: "PBNode.Builder", MethodName: "CreateFloat", AppropriateKind: ipld.ReprKindSet_JustFloat, ActualKind: ipld.ReprKind_Map} -} -func (_PBNode__NodeBuilder) CreateString(string) (ipld.Node, error) { - return nil, ipld.ErrWrongKind{TypeName: "PBNode.Builder", MethodName: "CreateString", AppropriateKind: ipld.ReprKindSet_JustString, ActualKind: ipld.ReprKind_Map} -} -func (_PBNode__NodeBuilder) CreateBytes([]byte) (ipld.Node, error) { - return nil, ipld.ErrWrongKind{TypeName: "PBNode.Builder", MethodName: "CreateBytes", AppropriateKind: ipld.ReprKindSet_JustBytes, ActualKind: ipld.ReprKind_Map} -} -func (_PBNode__NodeBuilder) CreateLink(ipld.Link) (ipld.Node, error) { - return nil, ipld.ErrWrongKind{TypeName: "PBNode.Builder", MethodName: "CreateLink", AppropriateKind: ipld.ReprKindSet_JustLink, ActualKind: ipld.ReprKind_Map} +func (PBNode) Type() schema.Type { + return nil /*TODO:typelit*/ } func (n PBNode) Representation() ipld.Node { return _PBNode__Repr{&n} } + var _ ipld.Node = _PBNode__Repr{} -type _PBNode__Repr struct{ +type _PBNode__Repr struct { n *PBNode } @@ -1580,7 +901,7 @@ func (rn _PBNode__Repr) LookupString(key string) (ipld.Node, error) { func (rn _PBNode__Repr) Lookup(key ipld.Node) (ipld.Node, error) { ks, err := key.AsString() if err != nil { - return nil, ipld.ErrInvalidKey{"got " + key.ReprKind().String() + ", need string"} + return nil, err } return rn.LookupString(ks) } @@ -1653,126 +974,3 @@ func (_PBNode__Repr) AsBytes() ([]byte, error) { func (_PBNode__Repr) AsLink() (ipld.Link, error) { return nil, ipld.ErrWrongKind{TypeName: "PBNode.Representation", MethodName: "AsLink", AppropriateKind: ipld.ReprKindSet_JustLink, ActualKind: ipld.ReprKind_Map} } -func (_PBNode__Repr) NodeBuilder() ipld.NodeBuilder { - return _PBNode__ReprBuilder{} -} -type _PBNode__ReprBuilder struct{} - -func PBNode__ReprBuilder() ipld.NodeBuilder { - return _PBNode__ReprBuilder{} -} -func (nb _PBNode__ReprBuilder) CreateMap() (ipld.MapBuilder, error) { - mb := &_PBNode__ReprMapBuilder{v:&PBNode{}} - return mb, nil -} - -type _PBNode__ReprMapBuilder struct{ - v *PBNode - Links__isset bool - Data__isset bool -} - -func (mb *_PBNode__ReprMapBuilder) Insert(k, v ipld.Node) error { - ks, err := k.AsString() - if err != nil { - return ipld.ErrInvalidKey{"not a string: " + err.Error()} - } - switch ks { - case "Links": - if mb.Links__isset { - panic("repeated assignment to field") // FIXME need an error type for this - } - if v.IsNull() { - panic("type mismatch on struct field assignment: cannot assign null to non-nullable field") // FIXME need an error type for this - } - tv, ok := v.(schema.TypedNode) - if !ok { - panic("need schema.TypedNode for insertion into struct") // FIXME need an error type for this - } - x, ok := v.(PBLinks) - if !ok { - panic("field 'Links' (key: 'Links') in type PBNode is type PBLinks; cannot assign "+tv.Type().Name()) // FIXME need an error type for this - } - mb.v.d.Links = x - mb.Links__isset = true - case "Data": - if mb.Data__isset { - panic("repeated assignment to field") // FIXME need an error type for this - } - if v.IsNull() { - panic("type mismatch on struct field assignment: cannot assign null to non-nullable field") // FIXME need an error type for this - } - tv, ok := v.(schema.TypedNode) - if !ok { - panic("need schema.TypedNode for insertion into struct") // FIXME need an error type for this - } - x, ok := v.(Bytes) - if !ok { - panic("field 'Data' (key: 'Data') in type PBNode is type Bytes; cannot assign "+tv.Type().Name()) // FIXME need an error type for this - } - mb.v.d.Data = x - mb.Data__isset = true - default: - return schema.ErrNoSuchField{Type: nil /*TODO:typelit*/, FieldName: ks} - } - return nil -} -func (mb *_PBNode__ReprMapBuilder) Delete(k ipld.Node) error { - panic("TODO later") -} -func (mb *_PBNode__ReprMapBuilder) Build() (ipld.Node, error) { - if !mb.Links__isset { - panic("missing required field 'Links' (key: 'Links') in building struct PBNode") // FIXME need an error type for this - } - if !mb.Data__isset { - panic("missing required field 'Data' (key: 'Data') in building struct PBNode") // FIXME need an error type for this - } - v := mb.v - mb = nil - return v, nil -} -func (mb *_PBNode__ReprMapBuilder) BuilderForKeys() ipld.NodeBuilder { - return _String__NodeBuilder{} -} -func (mb *_PBNode__ReprMapBuilder) BuilderForValue(ks string) ipld.NodeBuilder { - switch ks { - case "Links": - return PBLinks__NodeBuilder() - case "Data": - return Bytes__NodeBuilder() - default: - panic(schema.ErrNoSuchField{Type: nil /*TODO:typelit*/, FieldName: ks}) - } - return nil -} - -func (nb _PBNode__ReprBuilder) AmendMap() (ipld.MapBuilder, error) { - panic("TODO later") -} -func (_PBNode__ReprBuilder) CreateList() (ipld.ListBuilder, error) { - return nil, ipld.ErrWrongKind{TypeName: "PBNode.Representation.Builder", MethodName: "CreateList", AppropriateKind: ipld.ReprKindSet_JustList, ActualKind: ipld.ReprKind_Map} -} -func (_PBNode__ReprBuilder) AmendList() (ipld.ListBuilder, error) { - return nil, ipld.ErrWrongKind{TypeName: "PBNode.Representation.Builder", MethodName: "AmendList", AppropriateKind: ipld.ReprKindSet_JustList, ActualKind: ipld.ReprKind_Map} -} -func (_PBNode__ReprBuilder) CreateNull() (ipld.Node, error) { - return nil, ipld.ErrWrongKind{TypeName: "PBNode.Representation.Builder", MethodName: "CreateNull", AppropriateKind: ipld.ReprKindSet_JustNull, ActualKind: ipld.ReprKind_Map} -} -func (_PBNode__ReprBuilder) CreateBool(bool) (ipld.Node, error) { - return nil, ipld.ErrWrongKind{TypeName: "PBNode.Representation.Builder", MethodName: "CreateBool", AppropriateKind: ipld.ReprKindSet_JustBool, ActualKind: ipld.ReprKind_Map} -} -func (_PBNode__ReprBuilder) CreateInt(int) (ipld.Node, error) { - return nil, ipld.ErrWrongKind{TypeName: "PBNode.Representation.Builder", MethodName: "CreateInt", AppropriateKind: ipld.ReprKindSet_JustInt, ActualKind: ipld.ReprKind_Map} -} -func (_PBNode__ReprBuilder) CreateFloat(float64) (ipld.Node, error) { - return nil, ipld.ErrWrongKind{TypeName: "PBNode.Representation.Builder", MethodName: "CreateFloat", AppropriateKind: ipld.ReprKindSet_JustFloat, ActualKind: ipld.ReprKind_Map} -} -func (_PBNode__ReprBuilder) CreateString(string) (ipld.Node, error) { - return nil, ipld.ErrWrongKind{TypeName: "PBNode.Representation.Builder", MethodName: "CreateString", AppropriateKind: ipld.ReprKindSet_JustString, ActualKind: ipld.ReprKind_Map} -} -func (_PBNode__ReprBuilder) CreateBytes([]byte) (ipld.Node, error) { - return nil, ipld.ErrWrongKind{TypeName: "PBNode.Representation.Builder", MethodName: "CreateBytes", AppropriateKind: ipld.ReprKindSet_JustBytes, ActualKind: ipld.ReprKind_Map} -} -func (_PBNode__ReprBuilder) CreateLink(ipld.Link) (ipld.Node, error) { - return nil, ipld.ErrWrongKind{TypeName: "PBNode.Representation.Builder", MethodName: "CreateLink", AppropriateKind: ipld.ReprKindSet_JustLink, ActualKind: ipld.ReprKind_Map} -} diff --git a/raw_node_gen.go b/raw_node_gen.go index 9c95bb0..e94a064 100644 --- a/raw_node_gen.go +++ b/raw_node_gen.go @@ -7,28 +7,9 @@ import ( // Code generated go-ipld-prime DO NOT EDIT. -type RawNode struct{ x []byte } - -// TODO generateKindBytes.EmitNativeAccessors -// TODO generateKindBytes.EmitNativeBuilder -type MaybeRawNode struct { - Maybe schema.Maybe - Value RawNode -} - -func (m MaybeRawNode) Must() RawNode { - if m.Maybe != schema.Maybe_Value { - panic("unbox of a maybe rejected") - } - return m.Value -} - var _ ipld.Node = RawNode{} var _ schema.TypedNode = RawNode{} -func (RawNode) Type() schema.Type { - return nil /*TODO:typelit*/ -} func (RawNode) ReprKind() ipld.ReprKind { return ipld.ReprKind_Bytes } @@ -77,45 +58,25 @@ func (x RawNode) AsBytes() ([]byte, error) { func (RawNode) AsLink() (ipld.Link, error) { return nil, ipld.ErrWrongKind{TypeName: "RawNode", MethodName: "AsLink", AppropriateKind: ipld.ReprKindSet_JustLink, ActualKind: ipld.ReprKind_Bytes} } -func (RawNode) NodeBuilder() ipld.NodeBuilder { - return _RawNode__NodeBuilder{} -} -type _RawNode__NodeBuilder struct{} -func RawNode__NodeBuilder() ipld.NodeBuilder { - return _RawNode__NodeBuilder{} -} -func (_RawNode__NodeBuilder) CreateMap() (ipld.MapBuilder, error) { - return nil, ipld.ErrWrongKind{TypeName: "RawNode.Builder", MethodName: "CreateMap", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: ipld.ReprKind_Bytes} -} -func (_RawNode__NodeBuilder) AmendMap() (ipld.MapBuilder, error) { - return nil, ipld.ErrWrongKind{TypeName: "RawNode.Builder", MethodName: "AmendMap", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: ipld.ReprKind_Bytes} -} -func (_RawNode__NodeBuilder) CreateList() (ipld.ListBuilder, error) { - return nil, ipld.ErrWrongKind{TypeName: "RawNode.Builder", MethodName: "CreateList", AppropriateKind: ipld.ReprKindSet_JustList, ActualKind: ipld.ReprKind_Bytes} -} -func (_RawNode__NodeBuilder) AmendList() (ipld.ListBuilder, error) { - return nil, ipld.ErrWrongKind{TypeName: "RawNode.Builder", MethodName: "AmendList", AppropriateKind: ipld.ReprKindSet_JustList, ActualKind: ipld.ReprKind_Bytes} -} -func (_RawNode__NodeBuilder) CreateNull() (ipld.Node, error) { - return nil, ipld.ErrWrongKind{TypeName: "RawNode.Builder", MethodName: "CreateNull", AppropriateKind: ipld.ReprKindSet_JustNull, ActualKind: ipld.ReprKind_Bytes} -} -func (_RawNode__NodeBuilder) CreateBool(bool) (ipld.Node, error) { - return nil, ipld.ErrWrongKind{TypeName: "RawNode.Builder", MethodName: "CreateBool", AppropriateKind: ipld.ReprKindSet_JustBool, ActualKind: ipld.ReprKind_Bytes} -} -func (_RawNode__NodeBuilder) CreateInt(int) (ipld.Node, error) { - return nil, ipld.ErrWrongKind{TypeName: "RawNode.Builder", MethodName: "CreateInt", AppropriateKind: ipld.ReprKindSet_JustInt, ActualKind: ipld.ReprKind_Bytes} -} -func (_RawNode__NodeBuilder) CreateFloat(float64) (ipld.Node, error) { - return nil, ipld.ErrWrongKind{TypeName: "RawNode.Builder", MethodName: "CreateFloat", AppropriateKind: ipld.ReprKindSet_JustFloat, ActualKind: ipld.ReprKind_Bytes} -} -func (_RawNode__NodeBuilder) CreateString(string) (ipld.Node, error) { - return nil, ipld.ErrWrongKind{TypeName: "RawNode.Builder", MethodName: "CreateString", AppropriateKind: ipld.ReprKindSet_JustString, ActualKind: ipld.ReprKind_Bytes} + +type RawNode struct{ x []byte } + +// TODO generateKindBytes.EmitNativeAccessors +// TODO generateKindBytes.EmitNativeBuilder +type MaybeRawNode struct { + Maybe schema.Maybe + Value RawNode } -func (nb _RawNode__NodeBuilder) CreateBytes(v []byte) (ipld.Node, error) { - return RawNode{v}, nil + +func (m MaybeRawNode) Must() RawNode { + if m.Maybe != schema.Maybe_Value { + panic("unbox of a maybe rejected") + } + return m.Value } -func (_RawNode__NodeBuilder) CreateLink(ipld.Link) (ipld.Node, error) { - return nil, ipld.ErrWrongKind{TypeName: "RawNode.Builder", MethodName: "CreateLink", AppropriateKind: ipld.ReprKindSet_JustLink, ActualKind: ipld.ReprKind_Bytes} + +func (RawNode) Type() schema.Type { + return nil /*TODO:typelit*/ } func (RawNode) Representation() ipld.Node { panic("TODO representation") diff --git a/unixfs_test.go b/unixfs_test.go index 2c94d80..8e4631a 100644 --- a/unixfs_test.go +++ b/unixfs_test.go @@ -24,8 +24,8 @@ import ( "github.com/ipfs/go-unixfs/importer/balanced" ihelper "github.com/ipfs/go-unixfs/importer/helpers" ipld "github.com/ipld/go-ipld-prime" - ipldfree "github.com/ipld/go-ipld-prime/impl/free" cidlink "github.com/ipld/go-ipld-prime/linking/cid" + basicnode "github.com/ipld/go-ipld-prime/node/basic" "github.com/ipld/go-ipld-prime/traversal" "github.com/ipld/go-ipld-prime/traversal/selector" "github.com/ipld/go-ipld-prime/traversal/selector/builder" @@ -130,9 +130,11 @@ func TestUnixFSSelectorCopy(t *testing.T) { // load the root of the UnixFS dag in go-ipld-prime clink := cidlink.Link{Cid: nd.Cid()} - primeNd, err := clink.Load(ctx, ipld.LinkContext{}, dagpb.PBNode__NodeBuilder(), loader) + nb := dagpb.Style.Protobuf.NewBuilder() + err = clink.Load(ctx, ipld.LinkContext{}, nb, loader) Wish(t, err, ShouldEqual, nil) + primeNd := nb.Build() // get a protobuf link builder pbLinkBuilder := clink.LinkBuilder() @@ -148,12 +150,12 @@ func TestUnixFSSelectorCopy(t *testing.T) { rawLinkBuilder := rawLinkLink.LinkBuilder() // setup a node builder chooser with DagPB + Raw support - var defaultChooser traversal.NodeBuilderChooser = dagpb.AddDagPBSupportToChooser(func(ipld.Link, ipld.LinkContext) (ipld.NodeBuilder, error) { - return ipldfree.NodeBuilder(), nil + var defaultChooser traversal.LinkTargetNodeStyleChooser = dagpb.AddDagPBSupportToChooser(func(ipld.Link, ipld.LinkContext) (ipld.NodeStyle, error) { + return basicnode.Style.Any, nil }) // create a selector for the whole UnixFS dag - ssb := builder.NewSelectorSpecBuilder(ipldfree.NodeBuilder()) + ssb := builder.NewSelectorSpecBuilder(basicnode.Style.Any) allSelector, err := ssb.ExploreRecursive(selector.RecursionLimitNone(), ssb.ExploreAll(ssb.ExploreRecursiveEdge())).Selector() @@ -162,18 +164,18 @@ func TestUnixFSSelectorCopy(t *testing.T) { // execute the traversal err = traversal.Progress{ Cfg: &traversal.Config{ - LinkLoader: loader, - LinkNodeBuilderChooser: defaultChooser, + LinkLoader: loader, + LinkTargetNodeStyleChooser: defaultChooser, }, }.WalkAdv(primeNd, allSelector, func(pg traversal.Progress, nd ipld.Node, r traversal.VisitReason) error { // for each node encountered, check if it's a DabPB Node or a Raw Node and if so // encode and store it in the new blockstore - pbNode, ok := nd.(dagpb.PBNode) + pbNode, ok := nd.(*dagpb.PBNode) if ok { _, err := pbLinkBuilder.Build(ctx, ipld.LinkContext{}, pbNode, storer) return err } - rawNode, ok := nd.(dagpb.RawNode) + rawNode, ok := nd.(*dagpb.RawNode) if ok { _, err := rawLinkBuilder.Build(ctx, ipld.LinkContext{}, rawNode, storer) return err