Skip to content

GitLab

Unverified Commit c93d8a66 authored by Rod Vagg's avatar Rod Vagg
Browse files
Options

go-ipld-prime codec impl

parent f82a0735
Expand all Hide whitespace changes
Inline Side-by-side
Showing with 4338 additions and 77 deletions
basics_test.go 0 → 100644
View file @ c93d8a66
package dagpb
import (
"bytes"
"encoding/hex"
"testing"
"github.com/ipfs/go-cid"
"github.com/ipld/go-ipld-prime"
basicnode "github.com/ipld/go-ipld-prime/node/basic"
pb "github.com/rvagg/go-dagpb/pb"
)
func mkcid(t *testing.T, cidStr string) cid.Cid {
c, err := cid.Decode(cidStr)
if err != nil {
t.Fatal(err)
}
return c
}
func validate(t *testing.T, actual ipld.Node, expected *pb.PBNode) {
mi := actual.MapIterator()
_, isTyped := actual.(*_PBNode)
hasLinks := false
hasData := false
for !mi.Done() {
key, val, err := mi.Next()
if err != nil {
t.Fatal(err)
}
keyStr, err := key.AsString()
if err != nil {
t.Fatal(err)
}
if keyStr == "Links" {
if val.ReprKind() != ipld.ReprKind_List {
t.Fatal("Links is not a list")
}
if val.IsAbsent() {
t.Fatal("Links is absent")
}
if val.IsNull() {
t.Fatal("Links is null")
}
if val.Length() != len(expected.Links) {
t.Fatal("non-empty Links list")
}
hasLinks = true
} else if keyStr == "Data" {
if isTyped && expected.Data == nil {
if !val.IsAbsent() {
t.Fatalf("Empty Data is not marked as absent")
}
if val.ReprKind() != ipld.ReprKind_Null {
t.Fatal("Empty Data is not null")
}
if val.IsNull() {
t.Fatal("Empty Data is null")
}
}
hasData = !isTyped || !val.IsAbsent()
if hasData {
if expected.Data == nil {
t.Fatal("Got unexpected Data")
} else {
byts, err := val.AsBytes()
if err != nil {
t.Fatal(err)
} else if bytes.Compare(expected.Data, byts) != 0 {
t.Fatal("Got unexpected Data contents")
}
}
}
} else {
t.Fatalf("Unexpected map key: %v", keyStr)
}
}
if !hasLinks {
t.Fatal("Did not find Links")
}
if expected.Data != nil && !hasData {
t.Fatal("Did not find Data")
}
}
func runTest(t *testing.T, bytsHex string, expected *pb.PBNode) {
byts, _ := hex.DecodeString(bytsHex)
t.Run("basicnode", func(t *testing.T) {
nb := basicnode.Prototype__Map{}.NewBuilder()
err := Unmarshal(nb, bytes.NewReader(byts))
if err != nil {
t.Fatal(err)
}
node := nb.Build()
validate(t, node, expected)
var buf bytes.Buffer
if err := Marshal(node, &buf); err != nil {
t.Fatal(err)
}
if bytes.Compare(buf.Bytes(), byts) != 0 {
t.Fatal("Round-trip resulted in different bytes")
}
})
t.Run("typed", func(t *testing.T) {
nb := Type.PBNode.NewBuilder()
err := Unmarshal(nb, bytes.NewReader(byts))
if err != nil {
t.Fatal(err)
}
validate(t, nb.Build(), expected)
})
}
func TestEmptyNode(t *testing.T) {
runTest(t, "", pb.NewPBNode())
}
func TestNodeWithData(t *testing.T) {
runTest(t, "0a050001020304", pb.NewPBNodeFromData([]byte{00, 01, 02, 03, 04}))
}
func TestNodeWithDataZero(t *testing.T) {
runTest(t, "0a00", pb.NewPBNodeFromData([]byte{}))
}
func TestNodeWithLink(t *testing.T) {
expected := pb.NewPBNode()
expected.Links = append(expected.Links, pb.NewPBLinkFromCid(mkcid(t, "QmWDtUQj38YLW8v3q4A6LwPn4vYKEbuKWpgSm6bjKW6Xfe")))
runTest(t, "12240a2212207521fe19c374a97759226dc5c0c8e674e73950e81b211f7dd3b6b30883a08a51", expected)
}
func TestNodeWithLinkAndData(t *testing.T) {
expected := pb.NewPBNodeFromData([]byte("some data"))
expected.Links = append(expected.Links, pb.NewPBLinkFromCid(mkcid(t, "QmWDtUQj38YLW8v3q4A6LwPn4vYKEbuKWpgSm6bjKW6Xfe")))
runTest(t, "12240a2212207521fe19c374a97759226dc5c0c8e674e73950e81b211f7dd3b6b30883a08a510a09736f6d652064617461", expected)
}
func TestNodeWithTwoUnsortedLinks(t *testing.T) {
expected := pb.NewPBNodeFromData([]byte("some data"))
expected.Links = append(expected.Links, pb.NewPBLink("some link", mkcid(t, "QmXg9Pp2ytZ14xgmQjYEiHjVjMFXzCVVEcRTWJBmLgR39U"), 100000000))
expected.Links = append(expected.Links, pb.NewPBLink("some other link", mkcid(t, "QmXg9Pp2ytZ14xgmQjYEiHjVjMFXzCVVEcRTWJBmLgR39V"), 8))
runTest(
t,
"12340a2212208ab7a6c5e74737878ac73863cb76739d15d4666de44e5756bf55a2f9e9ab5f431209736f6d65206c696e6b1880c2d72f12370a2212208ab7a6c5e74737878ac73863cb76739d15d4666de44e5756bf55a2f9e9ab5f44120f736f6d65206f74686572206c696e6b18080a09736f6d652064617461",
expected)
}
func TestNodeWithUnnamedLinks(t *testing.T) {
dataByts, _ := hex.DecodeString("080218cbc1819201208080e015208080e015208080e015208080e015208080e015208080e01520cbc1c10f")
expected := pb.NewPBNodeFromData(dataByts)
expected.Links = []*pb.PBLink{
pb.NewPBLink("", mkcid(t, "QmSbCgdsX12C4KDw3PDmpBN9iCzS87a5DjgSCoW9esqzXk"), 45623854),
pb.NewPBLink("", mkcid(t, "Qma4GxWNhywSvWFzPKtEswPGqeZ9mLs2Kt76JuBq9g3fi2"), 45623854),
pb.NewPBLink("", mkcid(t, "QmQfyxyys7a1e3mpz9XsntSsTGc8VgpjPj5BF1a1CGdGNc"), 45623854),
pb.NewPBLink("", mkcid(t, "QmSh2wTTZT4N8fuSeCFw7wterzdqbE93j1XDhfN3vQHzDV"), 45623854),
pb.NewPBLink("", mkcid(t, "QmVXsSVjwxMsCwKRCUxEkGb4f4B98gXVy3ih3v4otvcURK"), 45623854),
pb.NewPBLink("", mkcid(t, "QmZjhH97MEYwQXzCqSQbdjGDhXWuwW4RyikR24pNqytWLj"), 45623854),
pb.NewPBLink("", mkcid(t, "QmRs6U5YirCqC7taTynz3x2GNaHJZ3jDvMVAzaiXppwmNJ"), 32538395),
}
runTest(
t,
"122b0a2212203f29086b59b9e046b362b4b19c9371e834a9f5a80597af83be6d8b7d1a5ad33b120018aed4e015122b0a221220ae1a5afd7c770507dddf17f92bba7a326974af8ae5277c198cf13206373f7263120018aed4e015122b0a22122022ab2ebf9c3523077bd6a171d516ea0e1be1beb132d853778bcc62cd208e77f1120018aed4e015122b0a22122040a77fe7bc69bbef2491f7633b7c462d0bce968868f88e2cbcaae9d0996997e8120018aed4e015122b0a2212206ae1979b14dd43966b0241ebe80ac2a04ad48959078dc5affa12860648356ef6120018aed4e015122b0a221220a957d1f89eb9a861593bfcd19e0637b5c957699417e2b7f23c88653a240836c4120018aed4e015122b0a221220345f9c2137a2cd76d7b876af4bfecd01f80b7dd125f375cb0d56f8a2f96de2c31200189bfec10f0a2b080218cbc1819201208080e015208080e015208080e015208080e015208080e015208080e01520cbc1c10f",
expected)
}
func TestNodeWithNamedLinks(t *testing.T) {
dataByts, _ := hex.DecodeString("0801")
expected := pb.NewPBNodeFromData(dataByts)
expected.Links = []*pb.PBLink{
pb.NewPBLink("audio_only.m4a", mkcid(t, "QmaUAwAQJNtvUdJB42qNbTTgDpzPYD1qdsKNtctM5i7DGB"), 23319629),
pb.NewPBLink("chat.txt", mkcid(t, "QmNVrxbB25cKTRuKg2DuhUmBVEK9NmCwWEHtsHPV6YutHw"), 996),
pb.NewPBLink("playback.m3u", mkcid(t, "QmUcjKzDLXBPmB6BKHeKSh6ZoFZjss4XDhMRdLYRVuvVfu"), 116),
pb.NewPBLink("zoom_0.mp4", mkcid(t, "QmQqy2SiEkKgr2cw5UbQ93TtLKEMsD8TdcWggR8q9JabjX"), 306281879),
}
runTest(
t,
"12390a221220b4397c02da5513563d33eef894bf68f2ccdf1bdfc14a976956ab3d1c72f735a0120e617564696f5f6f6e6c792e6d346118cda88f0b12310a221220025c13fcd1a885df444f64a4a82a26aea867b1148c68cb671e83589f971149321208636861742e74787418e40712340a2212205d44a305b9b328ab80451d0daa72a12a7bf2763c5f8bbe327597a31ee40d1e48120c706c61796261636b2e6d3375187412360a2212202539ed6e85f2a6f9097db9d76cffd49bf3042eb2e3e8e9af4a3ce842d49dea22120a7a6f6f6d5f302e6d70341897fb8592010a020801",
expected)
}
gen/main.go 0 → 100644
View file @ c93d8a66
package main
// based on https://github.com/ipld/go-ipld-prime-proto/blob/master/gen/main.go
import (
"os/exec"
"github.com/ipld/go-ipld-prime/schema"
gengo "github.com/ipld/go-ipld-prime/schema/gen/go"
)
func main() {
ts := schema.TypeSystem{}
ts.Init()
adjCfg := &gengo.AdjunctCfg{}
pkgName := "dagpb"
ts.Accumulate(schema.SpawnString("String"))
ts.Accumulate(schema.SpawnInt("Int"))
ts.Accumulate(schema.SpawnLink("Link"))
ts.Accumulate(schema.SpawnBytes("Bytes"))
/*
type PBLink struct {
Hash Link
Name optional String
Tsize optional Int
}
*/
ts.Accumulate(schema.SpawnStruct("PBLink",
[]schema.StructField{
schema.SpawnStructField("Hash", "Link", false, false),
schema.SpawnStructField("Name", "String", true, false),
schema.SpawnStructField("Tsize", "Int", true, false),
},
schema.SpawnStructRepresentationMap(nil),
))
ts.Accumulate(schema.SpawnList("PBLinks", "PBLink", false))
/*
type PBNode struct {
Links [PBLink]
Data optional Bytes
}
*/
ts.Accumulate(schema.SpawnStruct("PBNode",
[]schema.StructField{
schema.SpawnStructField("Links", "PBLinks", false, false),
schema.SpawnStructField("Data", "Bytes", true, false),
},
schema.SpawnStructRepresentationMap(nil),
))
// note in scope: ts.Accumulate(schema.SpawnBytes("RawNode"))
gengo.Generate("./", pkgName, ts, adjCfg)
exec.Command("go", "fmt").Run()
}
go.mod 0 → 100644
View file @ c93d8a66
module github.com/rvagg/go-dagpb/dagpb
go 1.15
require (
github.com/ipfs/go-cid v0.0.7
github.com/ipld/go-ipld-prime v0.5.1-0.20201114141345-1110155de1fb
github.com/mr-tron/base58 v1.2.0 // indirect
github.com/multiformats/go-multihash v0.0.14 // indirect
github.com/multiformats/go-varint v0.0.6 // indirect
github.com/rvagg/go-dagpb/pb v0.0.0-00010101000000-000000000000
golang.org/x/crypto v0.0.0-20201124201722-c8d3bf9c5392 // indirect
golang.org/x/sys v0.0.0-20201202213521-69691e467435 // indirect
)
replace github.com/rvagg/go-dagpb/pb => ./pb
go.sum 0 → 100644
View file @ c93d8a66
github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1 h1:EGx4pi6eqNxGaHF6qqu48+N2wcFQ5qg5FXgOdqsJ5d8=
github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY=
github.com/ipfs/go-cid v0.0.4/go.mod h1:4LLaPOQwmk5z9LBgQnpkivrx8BJjUyGwTXCd5Xfj6+M=
github.com/ipfs/go-cid v0.0.7 h1:ysQJVJA3fNDF1qigJbsSQOdjhVLsOEoPdh0+R97k3jY=
github.com/ipfs/go-cid v0.0.7/go.mod h1:6Ux9z5e+HpkQdckYoX1PG/6xqKspzlEIR5SDmgqgC/I=
github.com/ipld/go-ipld-prime v0.5.1-0.20201114141345-1110155de1fb h1:sjIJ7bZVV4TJmfL6pCJQYoHCg7n5nkTZHgQMqpqiXHA=
github.com/ipld/go-ipld-prime v0.5.1-0.20201114141345-1110155de1fb/go.mod h1:0xEgdD6MKbZ1vF0GC+YcR/C4SQCAlRuOjIJ2i0HxqzM=
github.com/jtolds/gls v4.20.0+incompatible h1:xdiiI2gbIgH/gLH7ADydsJ1uDOEzR8yvV7C0MuV77Wo=
github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU=
github.com/minio/blake2b-simd v0.0.0-20160723061019-3f5f724cb5b1 h1:lYpkrQH5ajf0OXOcUbGjvZxxijuBwbbmlSxLiuofa+g=
github.com/minio/blake2b-simd v0.0.0-20160723061019-3f5f724cb5b1/go.mod h1:pD8RvIylQ358TN4wwqatJ8rNavkEINozVn9DtGI3dfQ=
github.com/minio/sha256-simd v0.1.1-0.20190913151208-6de447530771/go.mod h1:B5e1o+1/KgNmWrSQK08Y6Z1Vb5pwIktudl0J58iy0KM=
github.com/minio/sha256-simd v0.1.1 h1:5QHSlgo3nt5yKOJrC7W8w7X+NFl8cMPZm96iu8kKUJU=
github.com/minio/sha256-simd v0.1.1/go.mod h1:B5e1o+1/KgNmWrSQK08Y6Z1Vb5pwIktudl0J58iy0KM=
github.com/mr-tron/base58 v1.1.0/go.mod h1:xcD2VGqlgYjBdcBLw+TuYLr8afG+Hj8g2eTVqeSzSU8=
github.com/mr-tron/base58 v1.1.2/go.mod h1:BinMc/sQntlIE1frQmRFPUoPA1Zkr8VRgBdjWI2mNwc=
github.com/mr-tron/base58 v1.1.3 h1:v+sk57XuaCKGXpWtVBX8YJzO7hMGx4Aajh4TQbdEFdc=
github.com/mr-tron/base58 v1.1.3/go.mod h1:BinMc/sQntlIE1frQmRFPUoPA1Zkr8VRgBdjWI2mNwc=
github.com/mr-tron/base58 v1.2.0 h1:T/HDJBh4ZCPbU39/+c3rRvE0uKBQlU27+QI8LJ4t64o=
github.com/mr-tron/base58 v1.2.0/go.mod h1:BinMc/sQntlIE1frQmRFPUoPA1Zkr8VRgBdjWI2mNwc=
github.com/multiformats/go-base32 v0.0.3 h1:tw5+NhuwaOjJCC5Pp82QuXbrmLzWg7uxlMFp8Nq/kkI=
github.com/multiformats/go-base32 v0.0.3/go.mod h1:pLiuGC8y0QR3Ue4Zug5UzK9LjgbkL8NSQj0zQ5Nz/AA=
github.com/multiformats/go-base36 v0.1.0 h1:JR6TyF7JjGd3m6FbLU2cOxhC0Li8z8dLNGQ89tUg4F4=
github.com/multiformats/go-base36 v0.1.0/go.mod h1:kFGE83c6s80PklsHO9sRn2NCoffoRdUUOENyW/Vv6sM=
github.com/multiformats/go-multibase v0.0.1/go.mod h1:bja2MqRZ3ggyXtZSEDKpl0uO/gviWFaSteVbWT51qgs=
github.com/multiformats/go-multibase v0.0.3 h1:l/B6bJDQjvQ5G52jw4QGSYeOTZoAwIO77RblWplfIqk=
github.com/multiformats/go-multibase v0.0.3/go.mod h1:5+1R4eQrT3PkYZ24C3W2Ue2tPwIdYQD509ZjSb5y9Oc=
github.com/multiformats/go-multihash v0.0.10/go.mod h1:YSLudS+Pi8NHE7o6tb3D8vrpKa63epEDmG8nTduyAew=
github.com/multiformats/go-multihash v0.0.13 h1:06x+mk/zj1FoMsgNejLpy6QTvJqlSt/BhLEy87zidlc=
github.com/multiformats/go-multihash v0.0.13/go.mod h1:VdAWLKTwram9oKAatUcLxBNUjdtcVwxObEQBtRfuyjc=
github.com/multiformats/go-multihash v0.0.14 h1:QoBceQYQQtNUuf6s7wHxnE2c8bhbMqhfGzNI032se/I=
github.com/multiformats/go-multihash v0.0.14/go.mod h1:VdAWLKTwram9oKAatUcLxBNUjdtcVwxObEQBtRfuyjc=
github.com/multiformats/go-varint v0.0.5 h1:XVZwSo04Cs3j/jS0uAEPpT3JY6DzMcVLLoWOSnCxOjg=
github.com/multiformats/go-varint v0.0.5/go.mod h1:3Ls8CIEsrijN6+B7PbrXRPxHRPuXSrVKRY101jdMZYE=
github.com/multiformats/go-varint v0.0.6 h1:gk85QWKxh3TazbLxED/NlDVv8+q+ReFJk7Y2W/KhfNY=
github.com/multiformats/go-varint v0.0.6/go.mod h1:3Ls8CIEsrijN6+B7PbrXRPxHRPuXSrVKRY101jdMZYE=
github.com/polydawn/refmt v0.0.0-20190807091052-3d65705ee9f1 h1:CskT+S6Ay54OwxBGB0R3Rsx4Muto6UnEYTyKJbyRIAI=
github.com/polydawn/refmt v0.0.0-20190807091052-3d65705ee9f1/go.mod h1:uIp+gprXxxrWSjjklXD+mN4wed/tMfjMMmN/9+JsA9o=
github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d h1:zE9ykElWQ6/NYmHa3jpm/yHnI4xSofP+UP6SpjHcSeM=
github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d/go.mod h1:OnSkiWE9lh6wB0YB77sQom3nweQdgAjqCqsofrRNTgc=
github.com/smartystreets/goconvey v1.6.4 h1:fv0U8FUIMPNf1L9lnHLvLhgicrIVChEkdzIKYqbNC9s=
github.com/smartystreets/goconvey v1.6.4/go.mod h1:syvi0/a8iFYH4r/RixwvyeAJjdLS9QV7WQ/tjFTllLA=
github.com/spaolacci/murmur3 v1.1.0 h1:7c1g84S4BPRrfL5Xrdp6fOJ206sU9y293DDHaoy0bLI=
github.com/spaolacci/murmur3 v1.1.0/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA=
github.com/warpfork/go-wish v0.0.0-20200122115046-b9ea61034e4a h1:G++j5e0OC488te356JvdhaM8YS6nMsjLAYF7JxCv07w=
github.com/warpfork/go-wish v0.0.0-20200122115046-b9ea61034e4a/go.mod h1:x6AKhvSSexNrVSrViXSHUEbICjmGXhtgABaHIySUSGw=
golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
golang.org/x/crypto v0.0.0-20190611184440-5c40567a22f8/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
golang.org/x/crypto v0.0.0-20200117160349-530e935923ad h1:Jh8cai0fqIK+f6nG0UgPW5wFk8wmiMhM3AyciDBdtQg=
golang.org/x/crypto v0.0.0-20200117160349-530e935923ad/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
golang.org/x/crypto v0.0.0-20201124201722-c8d3bf9c5392 h1:xYJJ3S178yv++9zXV/hnr29plCAGO9vAFG9dorqaFQc=
golang.org/x/crypto v0.0.0-20201124201722-c8d3bf9c5392/go.mod h1:jdWPYTVW3xRLrWPugEBEK3UY2ZEsg3UU495nc5E+M+I=
golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200122134326-e047566fdf82 h1:ywK/j/KkyTHcdyYSZNXGjMwgmDSfjglYZ3vStQ/gSCU=
golang.org/x/sys v0.0.0-20200122134326-e047566fdf82/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20201202213521-69691e467435 h1:25AvDqqB9PrNqj1FLf2/70I4W0L19qqoaFq3gjNwbKk=
golang.org/x/sys v0.0.0-20201202213521-69691e467435/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw=
golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
golang.org/x/tools v0.0.0-20190328211700-ab21143f2384/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
marshal.go 0 → 100644
View file @ c93d8a66
package dagpb
import (
"fmt"
"io"
ipld "github.com/ipld/go-ipld-prime"
cidlink "github.com/ipld/go-ipld-prime/linking/cid"
pb "github.com/rvagg/go-dagpb/pb"
)
func Marshal(inNode ipld.Node, out io.Writer) error {
builder := Type.PBNode.NewBuilder()
if err := builder.AssignNode(inNode); err != nil {
return err
}
node := builder.Build()
curField := pb.TypeLinks
var linksIter ipld.ListIterator
var link ipld.Node
tokenSource := func() (pb.Token, error) {
if curField == pb.TypeLinks {
links, err := node.LookupByString("Links")
if err != nil {
return pb.Token{}, err
}
if links.Length() == 0 {
curField = pb.TypeData
} else {
curField = pb.TypeHash
linksIter = links.ListIterator()
_, link, err = linksIter.Next()
if err != nil {
return pb.Token{}, err
}
}
}
if curField == pb.TypeData {
curField = pb.TypeEnd
d, err := node.LookupByString("Data")
if err != nil {
return pb.Token{}, err
}
if !d.IsAbsent() {
b, err := d.AsBytes()
if err != nil {
return pb.Token{}, err
}
return pb.Token{Type: pb.TypeData, Bytes: b}, nil
}
}
if curField == pb.TypeEnd {
return pb.Token{Type: pb.TypeEnd}, nil
}
for {
if curField == pb.TypeHash {
curField = pb.TypeName
d, err := link.LookupByString("Hash")
if err != nil {
return pb.Token{}, err
}
l, err := d.AsLink()
if err != nil {
return pb.Token{}, err
}
if cl, ok := l.(cidlink.Link); ok {
return pb.Token{Type: pb.TypeHash, Cid: &cl.Cid}, nil
}
return pb.Token{}, fmt.Errorf("unexpected Link type [%v]", l)
}
if curField == pb.TypeName {
curField = pb.TypeTSize
nameNode, err := link.LookupByString("Name")
if err != nil {
return pb.Token{}, err
}
if !nameNode.IsAbsent() {
name, err := nameNode.AsString()
if err != nil {
return pb.Token{}, err
}
return pb.Token{Type: pb.TypeName, Bytes: []byte(name)}, nil
}
}
if curField == pb.TypeTSize {
curField = pb.TypeLinkEnd
tsizeNode, err := link.LookupByString("Tsize")
if err != nil {
return pb.Token{}, err
}
if !tsizeNode.IsAbsent() {
tsize, err := tsizeNode.AsInt()
if err != nil {
return pb.Token{}, err
}
if tsize < 0 {
return pb.Token{}, fmt.Errorf("Link has negative Tsize value [%v]", tsize)
}
return pb.Token{Type: pb.TypeTSize, Int: uint64(tsize)}, nil
}
}
if curField == pb.TypeLinkEnd {
if linksIter.Done() {
curField = pb.TypeData
} else {
curField = pb.TypeHash
var err error
_, link, err = linksIter.Next()
if err != nil {
return pb.Token{}, err
}
}
return pb.Token{Type: pb.TypeLinkEnd}, nil
}
if curField != pb.TypeHash {
return pb.Token{}, fmt.Errorf("unexpected and invalid token state")
}
}
}
return pb.Marshal(out, tokenSource)
}
minima.go 0 → 100644
View file @ c93d8a66
package dagpb
// Code generated by go-ipld-prime gengo. DO NOT EDIT.
import (
"fmt"
"github.com/ipld/go-ipld-prime"
"github.com/ipld/go-ipld-prime/schema"
)
const (
midvalue = schema.Maybe(4)
allowNull = schema.Maybe(5)
)
type maState uint8
const (
maState_initial maState = iota
maState_midKey
maState_expectValue
maState_midValue
maState_finished
)
type laState uint8
const (
laState_initial laState = iota
laState_midValue
laState_finished
)
type _ErrorThunkAssembler struct {
e error
}
func (ea _ErrorThunkAssembler) BeginMap(_ int) (ipld.MapAssembler, error) { return nil, ea.e }
func (ea _ErrorThunkAssembler) BeginList(_ int) (ipld.ListAssembler, error) { return nil, ea.e }
func (ea _ErrorThunkAssembler) AssignNull() error { return ea.e }
func (ea _ErrorThunkAssembler) AssignBool(bool) error { return ea.e }
func (ea _ErrorThunkAssembler) AssignInt(int) error { return ea.e }
func (ea _ErrorThunkAssembler) AssignFloat(float64) error { return ea.e }
func (ea _ErrorThunkAssembler) AssignString(string) error { return ea.e }
func (ea _ErrorThunkAssembler) AssignBytes([]byte) error { return ea.e }
func (ea _ErrorThunkAssembler) AssignLink(ipld.Link) error { return ea.e }
func (ea _ErrorThunkAssembler) AssignNode(ipld.Node) error { return ea.e }
func (ea _ErrorThunkAssembler) Prototype() ipld.NodePrototype {
panic(fmt.Errorf("cannot get prototype from error-carrying assembler: already derailed with error: %w", ea.e))
}
multicodec.go 0 → 100644
View file @ c93d8a66
package dagpb
import (
"io"
ipld "github.com/ipld/go-ipld-prime"
cidlink "github.com/ipld/go-ipld-prime/linking/cid"
)
var (
_ cidlink.MulticodecDecoder = Decoder
_ cidlink.MulticodecEncoder = Encoder
)
func init() {
cidlink.RegisterMulticodecDecoder(0x70, Decoder)
cidlink.RegisterMulticodecEncoder(0x70, Encoder)
}
func Decoder(na ipld.NodeAssembler, r io.Reader) error {
return Unmarshal(na, r)
}
func Encoder(n ipld.Node, w io.Writer) error {
// return Unmarshal(na, w)
return nil
}
pb/basics_test.go
View file @ c93d8a66
......@@ -19,7 +19,7 @@ func mkcid(t *testing.T, cidStr string) cid.Cid {
func TestEmptyNode(t *testing.T) {
n := NewPBNode()
byts, err := n.Marshal()
byts, err := MarshalPBNode(n)
if err != nil {
t.Fatal(err)
}
......@@ -38,7 +38,7 @@ func TestEmptyNode(t *testing.T) {
func TestNodeWithData(t *testing.T) {
n := NewPBNode()
n.Data = []byte{0, 1, 2, 3, 4}
byts, err := n.Marshal()
byts, err := MarshalPBNode(n)
if err != nil {
t.Fatal(err)
}
......@@ -60,7 +60,7 @@ func TestNodeWithData(t *testing.T) {
func TestNodeWithLink(t *testing.T) {
n := NewPBNode()
n.Links = append(n.Links, NewPBLinkFromCid(mkcid(t, "QmWDtUQj38YLW8v3q4A6LwPn4vYKEbuKWpgSm6bjKW6Xfe")))
byts, err := n.Marshal()
byts, err := MarshalPBNode(n)
if err != nil {
t.Fatal(err)
}
......@@ -86,13 +86,13 @@ func TestNodeWithTwoUnsortedLinks(t *testing.T) {
n := NewPBNodeFromData([]byte("some data"))
n.Links = append(n.Links, NewPBLink("some other link", mkcid(t, "QmXg9Pp2ytZ14xgmQjYEiHjVjMFXzCVVEcRTWJBmLgR39V"), 8))
n.Links = append(n.Links, NewPBLink("some link", mkcid(t, "QmXg9Pp2ytZ14xgmQjYEiHjVjMFXzCVVEcRTWJBmLgR39U"), 100000000))
byts, err := n.Marshal()
byts, err := MarshalPBNode(n)
if err == nil || !strings.Contains(err.Error(), "links must be sorted") || byts != nil {
t.Fatal("Expected to error from unsorted links")
}
n.SortLinks()
if byts, err = n.Marshal(); err != nil {
if byts, err = MarshalPBNode(n); err != nil {
t.Fatal(err)
}
......@@ -154,13 +154,13 @@ func TestNodeWithStableSortedLinks(t *testing.T) {
for _, c := range cids {
n.Links = append(n.Links, NewPBLink("", mkcid(t, c), 262158))
}
byts, err := n.Marshal()
byts, err := MarshalPBNode(n)
if err != nil {
t.Fatal(err)
}
n.SortLinks()
byts2, err := n.Marshal()
byts2, err := MarshalPBNode(n)
if err != nil {
t.Fatal(err)
}
......
pb/compat_test.go
View file @ c93d8a66
......@@ -250,7 +250,7 @@ func verifyRoundTrip(t *testing.T, tc testCase) {
}
func nodeToString(t *testing.T, n *PBNode) (string, error) {
bytes, err := n.Marshal()
bytes, err := MarshalPBNode(n)
if err != nil {
return "", err
}
......
pb/dagpb.go
View file @ c93d8a66
package pb
import (
"bytes"
"sort"
cid "github.com/ipfs/go-cid"
......@@ -30,61 +29,24 @@ func NewPBNodeFromData(data []byte) *PBNode {
return n
}
type linkBuilder struct {
link *PBLink
}
func (lb *linkBuilder) SetHash(hash *cid.Cid) error {
lb.link.Hash = hash
return nil
}
func (lb *linkBuilder) SetName(name *string) error {
lb.link.Name = name
return nil
}
func (lb *linkBuilder) SetTsize(tsize uint64) error {
lb.link.Tsize = &tsize
return nil
}
func (lb *linkBuilder) Done() error { return nil }
type nodeBuilder struct {
node *PBNode
}
type TokenType byte
func (nb *nodeBuilder) SetData(data []byte) error {
nb.node.Data = data
return nil
}
func (nb *nodeBuilder) AddLink() (PBLinkBuilder, error) {
nb.mklinks()
nb.node.Links = append(nb.node.Links, &PBLink{})
return &linkBuilder{nb.node.Links[len(nb.node.Links)-1]}, nil
}
func (nb *nodeBuilder) mklinks() {
if nb.node.Links == nil {
nb.node.Links = make([]*PBLink, 0)
}
}
func (nb *nodeBuilder) Done() error {
nb.mklinks()
return nil
}
func UnmarshalPBNode(byts []byte) (*PBNode, error) {
nb := nodeBuilder{NewPBNode()}
const (
TypeData TokenType = 'd'
TypeLinks TokenType = '['
TypeLink TokenType = 'l'
TypeLinkEnd TokenType = 'e'
TypeHash TokenType = 'h'
TypeName TokenType = 'n'
TypeTSize TokenType = 's'
TypeEnd TokenType = 'x'
)
if err := Unmarshal(bytes.NewReader(byts), &nb); err != nil {
return nil, err
}
nb.Done()
return nb.node, nil
type Token struct {
Type TokenType
Bytes []byte
Cid *cid.Cid
Int uint64
}
func NewPBLinkFromCid(c cid.Cid) *PBLink {
......
pb/go.mod 0 → 100644
View file @ c93d8a66
module github.com/rvagg/go-dagpb/pb
go 1.15
require (
github.com/ipfs/go-cid v0.0.7
github.com/polydawn/refmt v0.0.0-20190807091052-3d65705ee9f1
)
pb/go.sum 0 → 100644
View file @ c93d8a66
github.com/ipfs/go-cid v0.0.7 h1:ysQJVJA3fNDF1qigJbsSQOdjhVLsOEoPdh0+R97k3jY=
github.com/ipfs/go-cid v0.0.7/go.mod h1:6Ux9z5e+HpkQdckYoX1PG/6xqKspzlEIR5SDmgqgC/I=
github.com/minio/blake2b-simd v0.0.0-20160723061019-3f5f724cb5b1 h1:lYpkrQH5ajf0OXOcUbGjvZxxijuBwbbmlSxLiuofa+g=
github.com/minio/blake2b-simd v0.0.0-20160723061019-3f5f724cb5b1/go.mod h1:pD8RvIylQ358TN4wwqatJ8rNavkEINozVn9DtGI3dfQ=
github.com/minio/sha256-simd v0.1.1-0.20190913151208-6de447530771 h1:MHkK1uRtFbVqvAgvWxafZe54+5uBxLluGylDiKgdhwo=
github.com/minio/sha256-simd v0.1.1-0.20190913151208-6de447530771/go.mod h1:B5e1o+1/KgNmWrSQK08Y6Z1Vb5pwIktudl0J58iy0KM=
github.com/mr-tron/base58 v1.1.0/go.mod h1:xcD2VGqlgYjBdcBLw+TuYLr8afG+Hj8g2eTVqeSzSU8=
github.com/mr-tron/base58 v1.1.3 h1:v+sk57XuaCKGXpWtVBX8YJzO7hMGx4Aajh4TQbdEFdc=
github.com/mr-tron/base58 v1.1.3/go.mod h1:BinMc/sQntlIE1frQmRFPUoPA1Zkr8VRgBdjWI2mNwc=
github.com/multiformats/go-base32 v0.0.3 h1:tw5+NhuwaOjJCC5Pp82QuXbrmLzWg7uxlMFp8Nq/kkI=
github.com/multiformats/go-base32 v0.0.3/go.mod h1:pLiuGC8y0QR3Ue4Zug5UzK9LjgbkL8NSQj0zQ5Nz/AA=
github.com/multiformats/go-base36 v0.1.0 h1:JR6TyF7JjGd3m6FbLU2cOxhC0Li8z8dLNGQ89tUg4F4=
github.com/multiformats/go-base36 v0.1.0/go.mod h1:kFGE83c6s80PklsHO9sRn2NCoffoRdUUOENyW/Vv6sM=
github.com/multiformats/go-multibase v0.0.3 h1:l/B6bJDQjvQ5G52jw4QGSYeOTZoAwIO77RblWplfIqk=
github.com/multiformats/go-multibase v0.0.3/go.mod h1:5+1R4eQrT3PkYZ24C3W2Ue2tPwIdYQD509ZjSb5y9Oc=
github.com/multiformats/go-multihash v0.0.13 h1:06x+mk/zj1FoMsgNejLpy6QTvJqlSt/BhLEy87zidlc=
github.com/multiformats/go-multihash v0.0.13/go.mod h1:VdAWLKTwram9oKAatUcLxBNUjdtcVwxObEQBtRfuyjc=
github.com/multiformats/go-varint v0.0.5 h1:XVZwSo04Cs3j/jS0uAEPpT3JY6DzMcVLLoWOSnCxOjg=
github.com/multiformats/go-varint v0.0.5/go.mod h1:3Ls8CIEsrijN6+B7PbrXRPxHRPuXSrVKRY101jdMZYE=
github.com/polydawn/refmt v0.0.0-20190807091052-3d65705ee9f1 h1:CskT+S6Ay54OwxBGB0R3Rsx4Muto6UnEYTyKJbyRIAI=
github.com/polydawn/refmt v0.0.0-20190807091052-3d65705ee9f1/go.mod h1:uIp+gprXxxrWSjjklXD+mN4wed/tMfjMMmN/9+JsA9o=
github.com/spaolacci/murmur3 v1.1.0 h1:7c1g84S4BPRrfL5Xrdp6fOJ206sU9y293DDHaoy0bLI=
github.com/spaolacci/murmur3 v1.1.0/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA=
golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
golang.org/x/crypto v0.0.0-20190611184440-5c40567a22f8 h1:1wopBVtVdWnn03fZelqdXTqk7U7zPQCb+T4rbU9ZEoU=
golang.org/x/crypto v0.0.0-20190611184440-5c40567a22f8/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20190412213103-97732733099d h1:+R4KGOnez64A81RvjARKc4UT5/tI9ujCIVX+P5KiHuI=
golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
pb/marshal.go
View file @ c93d8a66
......@@ -4,16 +4,66 @@ package pb
import (
"fmt"
"io"
math_bits "math/bits"
)
// Marshal TODO
func (node *PBNode) Marshal() (data []byte, err error) {
func Marshal(out io.Writer, tokenSource func() (Token, error)) error {
writeLead := func(wire byte, size uint64) {
lead := make([]byte, sizeOfVarint(size)+1)
lead[0] = wire
encodeVarint(lead, len(lead), size)
out.Write(lead)
}
var link PBLink
for {
tok, err := tokenSource()
if err != nil {
return err
}
if tok.Type == TypeEnd {
break
}
switch tok.Type {
case TypeData:
writeLead(0xa, uint64(len(tok.Bytes)))
out.Write(tok.Bytes)
case TypeLinkEnd:
l := link.size()
writeLead(0x12, uint64(l))
chunk := make([]byte, l)
wrote, err := link.marshal(chunk)
if err != nil {
return err
}
if wrote != l {
return fmt.Errorf("bad PBLink marshal, wrote wrong number of bytes")
}
out.Write(chunk)
link = PBLink{}
case TypeHash:
link.Hash = tok.Cid
case TypeName:
s := string(tok.Bytes)
link.Name = &s
case TypeTSize:
link.Tsize = &tok.Int
}
}
return nil
}
func MarshalPBNode(node *PBNode) ([]byte, error) {
if err := node.validate(); err != nil {
return nil, err
}
size := node.size()
data = make([]byte, size)
data := make([]byte, size)
i := len(data)
if node.Data != nil {
......
pb/unmarshal.go
View file @ c93d8a66
package pb
import (
"bytes"
"fmt"
"io"
......@@ -21,7 +22,32 @@ type PBNodeBuilder interface {
Done() error
}
func Unmarshal(in io.Reader, builder PBNodeBuilder) error {
func UnmarshalPBNode(byts []byte) (*PBNode, error) {
node := NewPBNode()
tokenReceiver := func(tok Token) error {
switch tok.Type {
case TypeData:
node.Data = tok.Bytes
case TypeLink:
node.Links = append(node.Links, &PBLink{})
case TypeHash:
node.Links[len(node.Links)-1].Hash = tok.Cid
case TypeName:
s := string(tok.Bytes)
node.Links[len(node.Links)-1].Name = &s
case TypeTSize:
node.Links[len(node.Links)-1].Tsize = &tok.Int
}
return nil
}
if err := Unmarshal(bytes.NewReader(byts), tokenReceiver); err != nil {
return nil, err
}
return node, nil
}
func Unmarshal(in io.Reader, tokenReceiver func(tok Token) error) error {
haveData := false
reader := shared.NewReader(in)
for {
......@@ -47,7 +73,7 @@ func Unmarshal(in io.Reader, builder PBNodeBuilder) error {
if chunk, err = decodeBytes(reader); err != nil {
return err
}
if err := builder.SetData(chunk); err != nil {
if err := tokenReceiver(Token{Type: TypeData, Bytes: chunk}); err != nil {
return err
}
haveData = true
......@@ -60,11 +86,13 @@ func Unmarshal(in io.Reader, builder PBNodeBuilder) error {
if err != nil {
return err
}
lb, err := builder.AddLink()
if err != nil {
if err = tokenReceiver(Token{Type: TypeLink}); err != nil {
return err
}
if err = unmarshalLink(reader, int(bytesLen), lb); err != nil {
if err = unmarshalLink(reader, int(bytesLen), tokenReceiver); err != nil {
return err
}
if err = tokenReceiver(Token{Type: TypeLinkEnd}); err != nil {
return err
}
} else {
......@@ -72,10 +100,10 @@ func Unmarshal(in io.Reader, builder PBNodeBuilder) error {
}
}
return builder.Done()
return nil
}
func unmarshalLink(reader shared.SlickReader, length int, builder PBLinkBuilder) error {
func unmarshalLink(reader shared.SlickReader, length int, tokenReceiver func(tok Token) error) error {
haveHash := false
haveName := false
haveTsize := false
......@@ -114,7 +142,7 @@ func unmarshalLink(reader shared.SlickReader, length int, builder PBLinkBuilder)
if _, c, err = cid.CidFromBytes(chunk); err != nil {
return fmt.Errorf("invalid Hash field found in link, expected CID (%v)", err)
}
if err := builder.SetHash(&c); err != nil {
if err := tokenReceiver(Token{Type: TypeHash, Cid: &c}); err != nil {
return err
}
haveHash = true
......@@ -133,8 +161,7 @@ func unmarshalLink(reader shared.SlickReader, length int, builder PBLinkBuilder)
if chunk, err = decodeBytes(reader); err != nil {
return err
}
s := string(chunk)
if err := builder.SetName(&s); err != nil {
if err := tokenReceiver(Token{Type: TypeName, Bytes: chunk}); err != nil {
return err
}
haveName = true
......@@ -150,7 +177,7 @@ func unmarshalLink(reader shared.SlickReader, length int, builder PBLinkBuilder)
if v, err = decodeVarint(reader); err != nil {
return err
}
if err := builder.SetTsize(v); err != nil {
if err := tokenReceiver(Token{Type: TypeTSize, Int: v}); err != nil {
return err
}
haveTsize = true
......@@ -163,7 +190,7 @@ func unmarshalLink(reader shared.SlickReader, length int, builder PBLinkBuilder)
return fmt.Errorf("invalid Hash field found in link, expected CID")
}
return builder.Done()
return nil
}
func decodeKey(reader shared.SlickReader) (int, int, error) {
......@@ -175,7 +202,6 @@ func decodeKey(reader shared.SlickReader) (int, int, error) {
fieldNum := int(wire >> 3)
wireType := int(wire & 0x7)
return fieldNum, wireType, nil
}
func decodeBytes(reader shared.SlickReader) ([]byte, error) {
......
tBytes.go 0 → 100644
View file @ c93d8a66
package dagpb
// Code generated by go-ipld-prime gengo. DO NOT EDIT.
import (
ipld "github.com/ipld/go-ipld-prime"
"github.com/ipld/go-ipld-prime/node/mixins"
"github.com/ipld/go-ipld-prime/schema"
)
type _Bytes struct{ x []byte }
type Bytes = *_Bytes
func (n Bytes) Bytes() []byte {
return n.x
}
func (_Bytes__Prototype) FromBytes(v []byte) (Bytes, error) {
n := _Bytes{v}
return &n, nil
}
type _Bytes__Maybe struct {
m schema.Maybe
v Bytes
}
type MaybeBytes = *_Bytes__Maybe
func (m MaybeBytes) IsNull() bool {
return m.m == schema.Maybe_Null
}
func (m MaybeBytes) IsAbsent() bool {
return m.m == schema.Maybe_Absent
}
func (m MaybeBytes) Exists() bool {
return m.m == schema.Maybe_Value
}
func (m MaybeBytes) AsNode() ipld.Node {
switch m.m {
case schema.Maybe_Absent:
return ipld.Absent
case schema.Maybe_Null:
return ipld.Null
case schema.Maybe_Value:
return m.v
default:
panic("unreachable")
}
}
func (m MaybeBytes) Must() Bytes {
if !m.Exists() {
panic("unbox of a maybe rejected")
}
return m.v
}
var _ ipld.Node = (Bytes)(&_Bytes{})
var _ schema.TypedNode = (Bytes)(&_Bytes{})
func (Bytes) ReprKind() ipld.ReprKind {
return ipld.ReprKind_Bytes
}
func (Bytes) LookupByString(string) (ipld.Node, error) {
return mixins.Bytes{"dagpb.Bytes"}.LookupByString("")
}
func (Bytes) LookupByNode(ipld.Node) (ipld.Node, error) {
return mixins.Bytes{"dagpb.Bytes"}.LookupByNode(nil)
}
func (Bytes) LookupByIndex(idx int) (ipld.Node, error) {
return mixins.Bytes{"dagpb.Bytes"}.LookupByIndex(0)
}
func (Bytes) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) {
return mixins.Bytes{"dagpb.Bytes"}.LookupBySegment(seg)
}
func (Bytes) MapIterator() ipld.MapIterator {
return nil
}
func (Bytes) ListIterator() ipld.ListIterator {
return nil
}
func (Bytes) Length() int {
return -1
}
func (Bytes) IsAbsent() bool {
return false
}
func (Bytes) IsNull() bool {
return false
}
func (Bytes) AsBool() (bool, error) {
return mixins.Bytes{"dagpb.Bytes"}.AsBool()
}
func (Bytes) AsInt() (int, error) {
return mixins.Bytes{"dagpb.Bytes"}.AsInt()
}
func (Bytes) AsFloat() (float64, error) {
return mixins.Bytes{"dagpb.Bytes"}.AsFloat()
}
func (Bytes) AsString() (string, error) {
return mixins.Bytes{"dagpb.Bytes"}.AsString()
}
func (n Bytes) AsBytes() ([]byte, error) {
return n.x, nil
}
func (Bytes) AsLink() (ipld.Link, error) {
return mixins.Bytes{"dagpb.Bytes"}.AsLink()
}
func (Bytes) Prototype() ipld.NodePrototype {
return _Bytes__Prototype{}
}
type _Bytes__Prototype struct{}
func (_Bytes__Prototype) NewBuilder() ipld.NodeBuilder {
var nb _Bytes__Builder
nb.Reset()
return &nb
}
type _Bytes__Builder struct {
_Bytes__Assembler
}
func (nb *_Bytes__Builder) Build() ipld.Node {
if *nb.m != schema.Maybe_Value {
panic("invalid state: cannot call Build on an assembler that's not finished")
}
return nb.w
}
func (nb *_Bytes__Builder) Reset() {
var w _Bytes
var m schema.Maybe
*nb = _Bytes__Builder{_Bytes__Assembler{w: &w, m: &m}}
}
type _Bytes__Assembler struct {
w *_Bytes
m *schema.Maybe
}
func (na *_Bytes__Assembler) reset() {}
func (_Bytes__Assembler) BeginMap(sizeHint int) (ipld.MapAssembler, error) {
return mixins.BytesAssembler{"dagpb.Bytes"}.BeginMap(0)
}
func (_Bytes__Assembler) BeginList(sizeHint int) (ipld.ListAssembler, error) {
return mixins.BytesAssembler{"dagpb.Bytes"}.BeginList(0)
}
func (na *_Bytes__Assembler) AssignNull() error {
switch *na.m {
case allowNull:
*na.m = schema.Maybe_Null
return nil
case schema.Maybe_Absent:
return mixins.BytesAssembler{"dagpb.Bytes"}.AssignNull()
case schema.Maybe_Value, schema.Maybe_Null:
panic("invalid state: cannot assign into assembler that's already finished")
}
panic("unreachable")
}
func (_Bytes__Assembler) AssignBool(bool) error {
return mixins.BytesAssembler{"dagpb.Bytes"}.AssignBool(false)
}
func (_Bytes__Assembler) AssignInt(int) error {
return mixins.BytesAssembler{"dagpb.Bytes"}.AssignInt(0)
}
func (_Bytes__Assembler) AssignFloat(float64) error {
return mixins.BytesAssembler{"dagpb.Bytes"}.AssignFloat(0)
}
func (_Bytes__Assembler) AssignString(string) error {
return mixins.BytesAssembler{"dagpb.Bytes"}.AssignString("")
}
func (na *_Bytes__Assembler) AssignBytes(v []byte) error {
switch *na.m {
case schema.Maybe_Value, schema.Maybe_Null:
panic("invalid state: cannot assign into assembler that's already finished")
}
if na.w == nil {
na.w = &_Bytes{}
}
na.w.x = v
*na.m = schema.Maybe_Value
return nil
}
func (_Bytes__Assembler) AssignLink(ipld.Link) error {
return mixins.BytesAssembler{"dagpb.Bytes"}.AssignLink(nil)
}
func (na *_Bytes__Assembler) AssignNode(v ipld.Node) error {
if v.IsNull() {
return na.AssignNull()
}
if v2, ok := v.(*_Bytes); ok {
switch *na.m {
case schema.Maybe_Value, schema.Maybe_Null:
panic("invalid state: cannot assign into assembler that's already finished")
}
if na.w == nil {
na.w = v2
*na.m = schema.Maybe_Value
return nil
}
*na.w = *v2
*na.m = schema.Maybe_Value
return nil
}
if v2, err := v.AsBytes(); err != nil {
return err
} else {
return na.AssignBytes(v2)
}
}
func (_Bytes__Assembler) Prototype() ipld.NodePrototype {
return _Bytes__Prototype{}
}
func (Bytes) Type() schema.Type {
return nil /*TODO:typelit*/
}
func (n Bytes) Representation() ipld.Node {
return (*_Bytes__Repr)(n)
}
type _Bytes__Repr = _Bytes
var _ ipld.Node = &_Bytes__Repr{}
type _Bytes__ReprPrototype = _Bytes__Prototype
type _Bytes__ReprAssembler = _Bytes__Assembler
tInt.go 0 → 100644
View file @ c93d8a66
package dagpb
// Code generated by go-ipld-prime gengo. DO NOT EDIT.
import (
ipld "github.com/ipld/go-ipld-prime"
"github.com/ipld/go-ipld-prime/node/mixins"
"github.com/ipld/go-ipld-prime/schema"
)
type _Int struct{ x int }
type Int = *_Int
func (n Int) Int() int {
return n.x
}
func (_Int__Prototype) FromInt(v int) (Int, error) {
n := _Int{v}
return &n, nil
}
type _Int__Maybe struct {
m schema.Maybe
v Int
}
type MaybeInt = *_Int__Maybe
func (m MaybeInt) IsNull() bool {
return m.m == schema.Maybe_Null
}
func (m MaybeInt) IsAbsent() bool {
return m.m == schema.Maybe_Absent
}
func (m MaybeInt) Exists() bool {
return m.m == schema.Maybe_Value
}
func (m MaybeInt) AsNode() ipld.Node {
switch m.m {
case schema.Maybe_Absent:
return ipld.Absent
case schema.Maybe_Null:
return ipld.Null
case schema.Maybe_Value:
return m.v
default:
panic("unreachable")
}
}
func (m MaybeInt) Must() Int {
if !m.Exists() {
panic("unbox of a maybe rejected")
}
return m.v
}
var _ ipld.Node = (Int)(&_Int{})
var _ schema.TypedNode = (Int)(&_Int{})
func (Int) ReprKind() ipld.ReprKind {
return ipld.ReprKind_Int
}
func (Int) LookupByString(string) (ipld.Node, error) {
return mixins.Int{"dagpb.Int"}.LookupByString("")
}
func (Int) LookupByNode(ipld.Node) (ipld.Node, error) {
return mixins.Int{"dagpb.Int"}.LookupByNode(nil)
}
func (Int) LookupByIndex(idx int) (ipld.Node, error) {
return mixins.Int{"dagpb.Int"}.LookupByIndex(0)
}
func (Int) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) {
return mixins.Int{"dagpb.Int"}.LookupBySegment(seg)
}
func (Int) MapIterator() ipld.MapIterator {
return nil
}
func (Int) ListIterator() ipld.ListIterator {
return nil
}
func (Int) Length() int {
return -1
}
func (Int) IsAbsent() bool {
return false
}
func (Int) IsNull() bool {
return false
}
func (Int) AsBool() (bool, error) {
return mixins.Int{"dagpb.Int"}.AsBool()
}
func (n Int) AsInt() (int, error) {
return n.x, nil
}
func (Int) AsFloat() (float64, error) {
return mixins.Int{"dagpb.Int"}.AsFloat()
}
func (Int) AsString() (string, error) {
return mixins.Int{"dagpb.Int"}.AsString()
}
func (Int) AsBytes() ([]byte, error) {
return mixins.Int{"dagpb.Int"}.AsBytes()
}
func (Int) AsLink() (ipld.Link, error) {
return mixins.Int{"dagpb.Int"}.AsLink()
}
func (Int) Prototype() ipld.NodePrototype {
return _Int__Prototype{}
}
type _Int__Prototype struct{}
func (_Int__Prototype) NewBuilder() ipld.NodeBuilder {
var nb _Int__Builder
nb.Reset()
return &nb
}
type _Int__Builder struct {
_Int__Assembler
}
func (nb *_Int__Builder) Build() ipld.Node {
if *nb.m != schema.Maybe_Value {
panic("invalid state: cannot call Build on an assembler that's not finished")
}
return nb.w
}
func (nb *_Int__Builder) Reset() {
var w _Int
var m schema.Maybe
*nb = _Int__Builder{_Int__Assembler{w: &w, m: &m}}
}
type _Int__Assembler struct {
w *_Int
m *schema.Maybe
}
func (na *_Int__Assembler) reset() {}
func (_Int__Assembler) BeginMap(sizeHint int) (ipld.MapAssembler, error) {
return mixins.IntAssembler{"dagpb.Int"}.BeginMap(0)
}
func (_Int__Assembler) BeginList(sizeHint int) (ipld.ListAssembler, error) {
return mixins.IntAssembler{"dagpb.Int"}.BeginList(0)
}
func (na *_Int__Assembler) AssignNull() error {
switch *na.m {
case allowNull:
*na.m = schema.Maybe_Null
return nil
case schema.Maybe_Absent:
return mixins.IntAssembler{"dagpb.Int"}.AssignNull()
case schema.Maybe_Value, schema.Maybe_Null:
panic("invalid state: cannot assign into assembler that's already finished")
}
panic("unreachable")
}
func (_Int__Assembler) AssignBool(bool) error {
return mixins.IntAssembler{"dagpb.Int"}.AssignBool(false)
}
func (na *_Int__Assembler) AssignInt(v int) error {
switch *na.m {
case schema.Maybe_Value, schema.Maybe_Null:
panic("invalid state: cannot assign into assembler that's already finished")
}
if na.w == nil {
na.w = &_Int{}
}
na.w.x = v
*na.m = schema.Maybe_Value
return nil
}
func (_Int__Assembler) AssignFloat(float64) error {
return mixins.IntAssembler{"dagpb.Int"}.AssignFloat(0)
}
func (_Int__Assembler) AssignString(string) error {
return mixins.IntAssembler{"dagpb.Int"}.AssignString("")
}
func (_Int__Assembler) AssignBytes([]byte) error {
return mixins.IntAssembler{"dagpb.Int"}.AssignBytes(nil)
}
func (_Int__Assembler) AssignLink(ipld.Link) error {
return mixins.IntAssembler{"dagpb.Int"}.AssignLink(nil)
}
func (na *_Int__Assembler) AssignNode(v ipld.Node) error {
if v.IsNull() {
return na.AssignNull()
}
if v2, ok := v.(*_Int); ok {
switch *na.m {
case schema.Maybe_Value, schema.Maybe_Null:
panic("invalid state: cannot assign into assembler that's already finished")
}
if na.w == nil {
na.w = v2
*na.m = schema.Maybe_Value
return nil
}
*na.w = *v2
*na.m = schema.Maybe_Value
return nil
}
if v2, err := v.AsInt(); err != nil {
return err
} else {
return na.AssignInt(v2)
}
}
func (_Int__Assembler) Prototype() ipld.NodePrototype {
return _Int__Prototype{}
}
func (Int) Type() schema.Type {
return nil /*TODO:typelit*/
}
func (n Int) Representation() ipld.Node {
return (*_Int__Repr)(n)
}
type _Int__Repr = _Int
var _ ipld.Node = &_Int__Repr{}
type _Int__ReprPrototype = _Int__Prototype
type _Int__ReprAssembler = _Int__Assembler
tLink.go 0 → 100644
View file @ c93d8a66
package dagpb
// Code generated by go-ipld-prime gengo. DO NOT EDIT.
import (
ipld "github.com/ipld/go-ipld-prime"
"github.com/ipld/go-ipld-prime/node/mixins"
"github.com/ipld/go-ipld-prime/schema"
)
type _Link struct{ x ipld.Link }
type Link = *_Link
func (n Link) Link() ipld.Link {
return n.x
}
func (_Link__Prototype) FromLink(v ipld.Link) (Link, error) {
n := _Link{v}
return &n, nil
}
type _Link__Maybe struct {
m schema.Maybe
v Link
}
type MaybeLink = *_Link__Maybe
func (m MaybeLink) IsNull() bool {
return m.m == schema.Maybe_Null
}
func (m MaybeLink) IsAbsent() bool {
return m.m == schema.Maybe_Absent
}
func (m MaybeLink) Exists() bool {
return m.m == schema.Maybe_Value
}
func (m MaybeLink) AsNode() ipld.Node {
switch m.m {
case schema.Maybe_Absent:
return ipld.Absent
case schema.Maybe_Null:
return ipld.Null
case schema.Maybe_Value:
return m.v
default:
panic("unreachable")
}
}
func (m MaybeLink) Must() Link {
if !m.Exists() {
panic("unbox of a maybe rejected")
}
return m.v
}
var _ ipld.Node = (Link)(&_Link{})
var _ schema.TypedNode = (Link)(&_Link{})
func (Link) ReprKind() ipld.ReprKind {
return ipld.ReprKind_Link
}
func (Link) LookupByString(string) (ipld.Node, error) {
return mixins.Link{"dagpb.Link"}.LookupByString("")
}
func (Link) LookupByNode(ipld.Node) (ipld.Node, error) {
return mixins.Link{"dagpb.Link"}.LookupByNode(nil)
}
func (Link) LookupByIndex(idx int) (ipld.Node, error) {
return mixins.Link{"dagpb.Link"}.LookupByIndex(0)
}
func (Link) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) {
return mixins.Link{"dagpb.Link"}.LookupBySegment(seg)
}
func (Link) MapIterator() ipld.MapIterator {
return nil
}
func (Link) ListIterator() ipld.ListIterator {
return nil
}
func (Link) Length() int {
return -1
}
func (Link) IsAbsent() bool {
return false
}
func (Link) IsNull() bool {
return false
}
func (Link) AsBool() (bool, error) {
return mixins.Link{"dagpb.Link"}.AsBool()
}
func (Link) AsInt() (int, error) {
return mixins.Link{"dagpb.Link"}.AsInt()
}
func (Link) AsFloat() (float64, error) {
return mixins.Link{"dagpb.Link"}.AsFloat()
}
func (Link) AsString() (string, error) {
return mixins.Link{"dagpb.Link"}.AsString()
}
func (Link) AsBytes() ([]byte, error) {
return mixins.Link{"dagpb.Link"}.AsBytes()
}
func (n Link) AsLink() (ipld.Link, error) {
return n.x, nil
}
func (Link) Prototype() ipld.NodePrototype {
return _Link__Prototype{}
}
type _Link__Prototype struct{}
func (_Link__Prototype) NewBuilder() ipld.NodeBuilder {
var nb _Link__Builder
nb.Reset()
return &nb
}
type _Link__Builder struct {
_Link__Assembler
}
func (nb *_Link__Builder) Build() ipld.Node {
if *nb.m != schema.Maybe_Value {
panic("invalid state: cannot call Build on an assembler that's not finished")
}
return nb.w
}
func (nb *_Link__Builder) Reset() {
var w _Link
var m schema.Maybe
*nb = _Link__Builder{_Link__Assembler{w: &w, m: &m}}
}
type _Link__Assembler struct {
w *_Link
m *schema.Maybe
}
func (na *_Link__Assembler) reset() {}
func (_Link__Assembler) BeginMap(sizeHint int) (ipld.MapAssembler, error) {
return mixins.LinkAssembler{"dagpb.Link"}.BeginMap(0)
}
func (_Link__Assembler) BeginList(sizeHint int) (ipld.ListAssembler, error) {
return mixins.LinkAssembler{"dagpb.Link"}.BeginList(0)
}
func (na *_Link__Assembler) AssignNull() error {
switch *na.m {
case allowNull:
*na.m = schema.Maybe_Null
return nil
case schema.Maybe_Absent:
return mixins.LinkAssembler{"dagpb.Link"}.AssignNull()
case schema.Maybe_Value, schema.Maybe_Null:
panic("invalid state: cannot assign into assembler that's already finished")
}
panic("unreachable")
}
func (_Link__Assembler) AssignBool(bool) error {
return mixins.LinkAssembler{"dagpb.Link"}.AssignBool(false)
}
func (_Link__Assembler) AssignInt(int) error {
return mixins.LinkAssembler{"dagpb.Link"}.AssignInt(0)
}
func (_Link__Assembler) AssignFloat(float64) error {
return mixins.LinkAssembler{"dagpb.Link"}.AssignFloat(0)
}
func (_Link__Assembler) AssignString(string) error {
return mixins.LinkAssembler{"dagpb.Link"}.AssignString("")
}
func (_Link__Assembler) AssignBytes([]byte) error {
return mixins.LinkAssembler{"dagpb.Link"}.AssignBytes(nil)
}
func (na *_Link__Assembler) AssignLink(v ipld.Link) error {
switch *na.m {
case schema.Maybe_Value, schema.Maybe_Null:
panic("invalid state: cannot assign into assembler that's already finished")
}
if na.w == nil {
na.w = &_Link{}
}
na.w.x = v
*na.m = schema.Maybe_Value
return nil
}
func (na *_Link__Assembler) AssignNode(v ipld.Node) error {
if v.IsNull() {
return na.AssignNull()
}
if v2, ok := v.(*_Link); ok {
switch *na.m {
case schema.Maybe_Value, schema.Maybe_Null:
panic("invalid state: cannot assign into assembler that's already finished")
}
if na.w == nil {
na.w = v2
*na.m = schema.Maybe_Value
return nil
}
*na.w = *v2
*na.m = schema.Maybe_Value
return nil
}
if v2, err := v.AsLink(); err != nil {
return err
} else {
return na.AssignLink(v2)
}
}
func (_Link__Assembler) Prototype() ipld.NodePrototype {
return _Link__Prototype{}
}
func (Link) Type() schema.Type {
return nil /*TODO:typelit*/
}
func (n Link) Representation() ipld.Node {
return (*_Link__Repr)(n)
}
type _Link__Repr = _Link
var _ ipld.Node = &_Link__Repr{}
type _Link__ReprPrototype = _Link__Prototype
type _Link__ReprAssembler = _Link__Assembler
tPBLink.go 0 → 100644
View file @ c93d8a66
This diff is collapsed.
tPBLinks.go 0 → 100644
View file @ c93d8a66
package dagpb
// Code generated by go-ipld-prime gengo. DO NOT EDIT.
import (
ipld "github.com/ipld/go-ipld-prime"
"github.com/ipld/go-ipld-prime/node/mixins"
"github.com/ipld/go-ipld-prime/schema"
)
type _PBLinks struct {
x []_PBLink
}
type PBLinks = *_PBLinks
func (n *_PBLinks) Lookup(idx int) PBLink {
if n.Length() <= idx {
return nil
}
v := &n.x[idx]
return v
}
func (n *_PBLinks) LookupMaybe(idx int) MaybePBLink {
if n.Length() <= idx {
return nil
}
v := &n.x[idx]
return &_PBLink__Maybe{
m: schema.Maybe_Value,
v: v,
}
}
var _PBLinks__valueAbsent = _PBLink__Maybe{m: schema.Maybe_Absent}
func (n PBLinks) Iterator() *PBLinks__Itr {
return &PBLinks__Itr{n, 0}
}
type PBLinks__Itr struct {
n PBLinks
idx int
}
func (itr *PBLinks__Itr) Next() (idx int, v PBLink) {
if itr.idx >= len(itr.n.x) {
return -1, nil
}
idx = itr.idx
v = &itr.n.x[itr.idx]
itr.idx++
return
}
func (itr *PBLinks__Itr) Done() bool {
return itr.idx >= len(itr.n.x)
}
type _PBLinks__Maybe struct {
m schema.Maybe
v PBLinks
}
type MaybePBLinks = *_PBLinks__Maybe
func (m MaybePBLinks) IsNull() bool {
return m.m == schema.Maybe_Null
}
func (m MaybePBLinks) IsAbsent() bool {
return m.m == schema.Maybe_Absent
}
func (m MaybePBLinks) Exists() bool {
return m.m == schema.Maybe_Value
}
func (m MaybePBLinks) AsNode() ipld.Node {
switch m.m {
case schema.Maybe_Absent:
return ipld.Absent
case schema.Maybe_Null:
return ipld.Null
case schema.Maybe_Value:
return m.v
default:
panic("unreachable")
}
}
func (m MaybePBLinks) Must() PBLinks {
if !m.Exists() {
panic("unbox of a maybe rejected")
}
return m.v
}
var _ ipld.Node = (PBLinks)(&_PBLinks{})
var _ schema.TypedNode = (PBLinks)(&_PBLinks{})
func (PBLinks) ReprKind() ipld.ReprKind {
return ipld.ReprKind_List
}
func (PBLinks) LookupByString(string) (ipld.Node, error) {
return mixins.List{"dagpb.PBLinks"}.LookupByString("")
}
func (n PBLinks) LookupByNode(k ipld.Node) (ipld.Node, error) {
idx, err := k.AsInt()
if err != nil {
return nil, err
}
return n.LookupByIndex(idx)
}
func (n PBLinks) LookupByIndex(idx int) (ipld.Node, error) {
if n.Length() <= idx {
return nil, ipld.ErrNotExists{ipld.PathSegmentOfInt(idx)}
}
v := &n.x[idx]
return v, nil
}
func (n PBLinks) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) {
i, err := seg.Index()
if err != nil {
return nil, ipld.ErrInvalidSegmentForList{TypeName: "dagpb.PBLinks", TroubleSegment: seg, Reason: err}
}
return n.LookupByIndex(i)
}
func (PBLinks) MapIterator() ipld.MapIterator {
return nil
}
func (n PBLinks) ListIterator() ipld.ListIterator {
return &_PBLinks__ListItr{n, 0}
}
type _PBLinks__ListItr struct {
n PBLinks
idx int
}
func (itr *_PBLinks__ListItr) Next() (idx int, v ipld.Node, _ error) {
if itr.idx >= len(itr.n.x) {
return -1, nil, ipld.ErrIteratorOverread{}
}
idx = itr.idx
x := &itr.n.x[itr.idx]
v = x
itr.idx++
return
}
func (itr *_PBLinks__ListItr) Done() bool {
return itr.idx >= len(itr.n.x)
}
func (n PBLinks) Length() int {
return len(n.x)
}
func (PBLinks) IsAbsent() bool {
return false
}
func (PBLinks) IsNull() bool {
return false
}
func (PBLinks) AsBool() (bool, error) {
return mixins.List{"dagpb.PBLinks"}.AsBool()
}
func (PBLinks) AsInt() (int, error) {
return mixins.List{"dagpb.PBLinks"}.AsInt()
}
func (PBLinks) AsFloat() (float64, error) {
return mixins.List{"dagpb.PBLinks"}.AsFloat()
}
func (PBLinks) AsString() (string, error) {
return mixins.List{"dagpb.PBLinks"}.AsString()
}
func (PBLinks) AsBytes() ([]byte, error) {
return mixins.List{"dagpb.PBLinks"}.AsBytes()
}
func (PBLinks) AsLink() (ipld.Link, error) {
return mixins.List{"dagpb.PBLinks"}.AsLink()
}
func (PBLinks) Prototype() ipld.NodePrototype {
return _PBLinks__Prototype{}
}
type _PBLinks__Prototype struct{}
func (_PBLinks__Prototype) NewBuilder() ipld.NodeBuilder {
var nb _PBLinks__Builder
nb.Reset()
return &nb
}
type _PBLinks__Builder struct {
_PBLinks__Assembler
}
func (nb *_PBLinks__Builder) Build() ipld.Node {
if *nb.m != schema.Maybe_Value {
panic("invalid state: cannot call Build on an assembler that's not finished")
}
return nb.w
}
func (nb *_PBLinks__Builder) Reset() {
var w _PBLinks
var m schema.Maybe
*nb = _PBLinks__Builder{_PBLinks__Assembler{w: &w, m: &m}}
}
type _PBLinks__Assembler struct {
w *_PBLinks
m *schema.Maybe
state laState
cm schema.Maybe
va _PBLink__Assembler
}
func (na *_PBLinks__Assembler) reset() {
na.state = laState_initial
na.va.reset()
}
func (_PBLinks__Assembler) BeginMap(sizeHint int) (ipld.MapAssembler, error) {
return mixins.ListAssembler{"dagpb.PBLinks"}.BeginMap(0)
}
func (na *_PBLinks__Assembler) BeginList(sizeHint int) (ipld.ListAssembler, error) {
switch *na.m {
case schema.Maybe_Value, schema.Maybe_Null:
panic("invalid state: cannot assign into assembler that's already finished")
case midvalue:
panic("invalid state: it makes no sense to 'begin' twice on the same assembler!")
}
*na.m = midvalue
if sizeHint < 0 {
sizeHint = 0
}
if na.w == nil {
na.w = &_PBLinks{}
}
if sizeHint > 0 {
na.w.x = make([]_PBLink, 0, sizeHint)
}
return na, nil
}
func (na *_PBLinks__Assembler) AssignNull() error {
switch *na.m {
case allowNull:
*na.m = schema.Maybe_Null
return nil
case schema.Maybe_Absent:
return mixins.ListAssembler{"dagpb.PBLinks"}.AssignNull()
case schema.Maybe_Value, schema.Maybe_Null:
panic("invalid state: cannot assign into assembler that's already finished")
case midvalue:
panic("invalid state: cannot assign null into an assembler that's already begun working on recursive structures!")
}
panic("unreachable")
}
func (_PBLinks__Assembler) AssignBool(bool) error {
return mixins.ListAssembler{"dagpb.PBLinks"}.AssignBool(false)
}
func (_PBLinks__Assembler) AssignInt(int) error {
return mixins.ListAssembler{"dagpb.PBLinks"}.AssignInt(0)
}
func (_PBLinks__Assembler) AssignFloat(float64) error {
return mixins.ListAssembler{"dagpb.PBLinks"}.AssignFloat(0)
}
func (_PBLinks__Assembler) AssignString(string) error {
return mixins.ListAssembler{"dagpb.PBLinks"}.AssignString("")
}
func (_PBLinks__Assembler) AssignBytes([]byte) error {
return mixins.ListAssembler{"dagpb.PBLinks"}.AssignBytes(nil)
}
func (_PBLinks__Assembler) AssignLink(ipld.Link) error {
return mixins.ListAssembler{"dagpb.PBLinks"}.AssignLink(nil)
}
func (na *_PBLinks__Assembler) AssignNode(v ipld.Node) error {
if v.IsNull() {
return na.AssignNull()
}
if v2, ok := v.(*_PBLinks); ok {
switch *na.m {
case schema.Maybe_Value, schema.Maybe_Null:
panic("invalid state: cannot assign into assembler that's already finished")
case midvalue:
panic("invalid state: cannot assign null into an assembler that's already begun working on recursive structures!")
}
if na.w == nil {
na.w = v2
*na.m = schema.Maybe_Value
return nil
}
*na.w = *v2
*na.m = schema.Maybe_Value
return nil
}
if v.ReprKind() != ipld.ReprKind_List {
return ipld.ErrWrongKind{TypeName: "dagpb.PBLinks", MethodName: "AssignNode", AppropriateKind: ipld.ReprKindSet_JustList, ActualKind: v.ReprKind()}
}
itr := v.ListIterator()
for !itr.Done() {
_, v, err := itr.Next()
if err != nil {
return err
}
if err := na.AssembleValue().AssignNode(v); err != nil {
return err
}
}
return na.Finish()
}
func (_PBLinks__Assembler) Prototype() ipld.NodePrototype {
return _PBLinks__Prototype{}
}
func (la *_PBLinks__Assembler) valueFinishTidy() bool {
switch la.cm {
case schema.Maybe_Value:
la.va.w = nil
la.cm = schema.Maybe_Absent
la.state = laState_initial
la.va.reset()
return true
default:
return false
}
}
func (la *_PBLinks__Assembler) AssembleValue() ipld.NodeAssembler {
switch la.state {
case laState_initial:
// carry on
case laState_midValue:
if !la.valueFinishTidy() {
panic("invalid state: AssembleValue cannot be called when still in the middle of assembling the previous value")
} // if tidy success: carry on
case laState_finished:
panic("invalid state: AssembleValue cannot be called on an assembler that's already finished")
}
la.w.x = append(la.w.x, _PBLink{})
la.state = laState_midValue
row := &la.w.x[len(la.w.x)-1]
la.va.w = row
la.va.m = &la.cm
return &la.va
}
func (la *_PBLinks__Assembler) Finish() error {
switch la.state {
case laState_initial:
// carry on
case laState_midValue:
if !la.valueFinishTidy() {
panic("invalid state: Finish cannot be called when in the middle of assembling a value")
} // if tidy success: carry on
case laState_finished:
panic("invalid state: Finish cannot be called on an assembler that's already finished")
}
la.state = laState_finished
*la.m = schema.Maybe_Value
return nil
}
func (la *_PBLinks__Assembler) ValuePrototype(_ int) ipld.NodePrototype {
return _PBLink__Prototype{}
}
func (PBLinks) Type() schema.Type {
return nil /*TODO:typelit*/
}
func (n PBLinks) Representation() ipld.Node {
return (*_PBLinks__Repr)(n)
}
type _PBLinks__Repr _PBLinks
var _ ipld.Node = &_PBLinks__Repr{}
func (_PBLinks__Repr) ReprKind() ipld.ReprKind {
return ipld.ReprKind_List
}
func (_PBLinks__Repr) LookupByString(string) (ipld.Node, error) {
return mixins.List{"dagpb.PBLinks.Repr"}.LookupByString("")
}
func (nr *_PBLinks__Repr) LookupByNode(k ipld.Node) (ipld.Node, error) {
v, err := (PBLinks)(nr).LookupByNode(k)
if err != nil || v == ipld.Null {
return v, err
}
return v.(PBLink).Representation(), nil
}
func (nr *_PBLinks__Repr) LookupByIndex(idx int) (ipld.Node, error) {
v, err := (PBLinks)(nr).LookupByIndex(idx)
if err != nil || v == ipld.Null {
return v, err
}
return v.(PBLink).Representation(), nil
}
func (n _PBLinks__Repr) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) {
i, err := seg.Index()
if err != nil {
return nil, ipld.ErrInvalidSegmentForList{TypeName: "dagpb.PBLinks.Repr", TroubleSegment: seg, Reason: err}
}
return n.LookupByIndex(i)
}
func (_PBLinks__Repr) MapIterator() ipld.MapIterator {
return nil
}
func (nr *_PBLinks__Repr) ListIterator() ipld.ListIterator {
return &_PBLinks__ReprListItr{(PBLinks)(nr), 0}
}
type _PBLinks__ReprListItr _PBLinks__ListItr
func (itr *_PBLinks__ReprListItr) Next() (idx int, v ipld.Node, err error) {
idx, v, err = (*_PBLinks__ListItr)(itr).Next()
if err != nil || v == ipld.Null {
return
}
return idx, v.(PBLink).Representation(), nil
}
func (itr *_PBLinks__ReprListItr) Done() bool {
return (*_PBLinks__ListItr)(itr).Done()
}
func (rn *_PBLinks__Repr) Length() int {
return len(rn.x)
}
func (_PBLinks__Repr) IsAbsent() bool {
return false
}
func (_PBLinks__Repr) IsNull() bool {
return false
}
func (_PBLinks__Repr) AsBool() (bool, error) {
return mixins.List{"dagpb.PBLinks.Repr"}.AsBool()
}
func (_PBLinks__Repr) AsInt() (int, error) {
return mixins.List{"dagpb.PBLinks.Repr"}.AsInt()
}
func (_PBLinks__Repr) AsFloat() (float64, error) {
return mixins.List{"dagpb.PBLinks.Repr"}.AsFloat()
}
func (_PBLinks__Repr) AsString() (string, error) {
return mixins.List{"dagpb.PBLinks.Repr"}.AsString()
}
func (_PBLinks__Repr) AsBytes() ([]byte, error) {
return mixins.List{"dagpb.PBLinks.Repr"}.AsBytes()
}
func (_PBLinks__Repr) AsLink() (ipld.Link, error) {
return mixins.List{"dagpb.PBLinks.Repr"}.AsLink()
}
func (_PBLinks__Repr) Prototype() ipld.NodePrototype {
return _PBLinks__ReprPrototype{}
}
type _PBLinks__ReprPrototype struct{}
func (_PBLinks__ReprPrototype) NewBuilder() ipld.NodeBuilder {
var nb _PBLinks__ReprBuilder
nb.Reset()
return &nb
}
type _PBLinks__ReprBuilder struct {
_PBLinks__ReprAssembler
}
func (nb *_PBLinks__ReprBuilder) Build() ipld.Node {
if *nb.m != schema.Maybe_Value {
panic("invalid state: cannot call Build on an assembler that's not finished")
}
return nb.w
}
func (nb *_PBLinks__ReprBuilder) Reset() {
var w _PBLinks
var m schema.Maybe
*nb = _PBLinks__ReprBuilder{_PBLinks__ReprAssembler{w: &w, m: &m}}
}
type _PBLinks__ReprAssembler struct {
w *_PBLinks
m *schema.Maybe
state laState
cm schema.Maybe
va _PBLink__ReprAssembler
}
func (na *_PBLinks__ReprAssembler) reset() {
na.state = laState_initial
na.va.reset()
}
func (_PBLinks__ReprAssembler) BeginMap(sizeHint int) (ipld.MapAssembler, error) {
return mixins.ListAssembler{"dagpb.PBLinks.Repr"}.BeginMap(0)
}
func (na *_PBLinks__ReprAssembler) BeginList(sizeHint int) (ipld.ListAssembler, error) {
switch *na.m {
case schema.Maybe_Value, schema.Maybe_Null:
panic("invalid state: cannot assign into assembler that's already finished")
case midvalue:
panic("invalid state: it makes no sense to 'begin' twice on the same assembler!")
}
*na.m = midvalue
if sizeHint < 0 {
sizeHint = 0
}
if na.w == nil {
na.w = &_PBLinks{}
}
if sizeHint > 0 {
na.w.x = make([]_PBLink, 0, sizeHint)
}
return na, nil
}
func (na *_PBLinks__ReprAssembler) AssignNull() error {
switch *na.m {
case allowNull:
*na.m = schema.Maybe_Null
return nil
case schema.Maybe_Absent:
return mixins.ListAssembler{"dagpb.PBLinks.Repr.Repr"}.AssignNull()
case schema.Maybe_Value, schema.Maybe_Null:
panic("invalid state: cannot assign into assembler that's already finished")
case midvalue:
panic("invalid state: cannot assign null into an assembler that's already begun working on recursive structures!")
}
panic("unreachable")
}
func (_PBLinks__ReprAssembler) AssignBool(bool) error {
return mixins.ListAssembler{"dagpb.PBLinks.Repr"}.AssignBool(false)
}
func (_PBLinks__ReprAssembler) AssignInt(int) error {
return mixins.ListAssembler{"dagpb.PBLinks.Repr"}.AssignInt(0)
}
func (_PBLinks__ReprAssembler) AssignFloat(float64) error {
return mixins.ListAssembler{"dagpb.PBLinks.Repr"}.AssignFloat(0)
}
func (_PBLinks__ReprAssembler) AssignString(string) error {
return mixins.ListAssembler{"dagpb.PBLinks.Repr"}.AssignString("")
}
func (_PBLinks__ReprAssembler) AssignBytes([]byte) error {
return mixins.ListAssembler{"dagpb.PBLinks.Repr"}.AssignBytes(nil)
}
func (_PBLinks__ReprAssembler) AssignLink(ipld.Link) error {
return mixins.ListAssembler{"dagpb.PBLinks.Repr"}.AssignLink(nil)
}
func (na *_PBLinks__ReprAssembler) AssignNode(v ipld.Node) error {
if v.IsNull() {
return na.AssignNull()
}
if v2, ok := v.(*_PBLinks); ok {
switch *na.m {
case schema.Maybe_Value, schema.Maybe_Null:
panic("invalid state: cannot assign into assembler that's already finished")
case midvalue:
panic("invalid state: cannot assign null into an assembler that's already begun working on recursive structures!")
}
if na.w == nil {
na.w = v2
*na.m = schema.Maybe_Value
return nil
}
*na.w = *v2
*na.m = schema.Maybe_Value
return nil
}
if v.ReprKind() != ipld.ReprKind_List {
return ipld.ErrWrongKind{TypeName: "dagpb.PBLinks.Repr", MethodName: "AssignNode", AppropriateKind: ipld.ReprKindSet_JustList, ActualKind: v.ReprKind()}
}
itr := v.ListIterator()
for !itr.Done() {
_, v, err := itr.Next()
if err != nil {
return err
}
if err := na.AssembleValue().AssignNode(v); err != nil {
return err
}
}
return na.Finish()
}
func (_PBLinks__ReprAssembler) Prototype() ipld.NodePrototype {
return _PBLinks__ReprPrototype{}
}
func (la *_PBLinks__ReprAssembler) valueFinishTidy() bool {
switch la.cm {
case schema.Maybe_Value:
la.va.w = nil
la.cm = schema.Maybe_Absent
la.state = laState_initial
la.va.reset()
return true
default:
return false
}
}
func (la *_PBLinks__ReprAssembler) AssembleValue() ipld.NodeAssembler {
switch la.state {
case laState_initial:
// carry on
case laState_midValue:
if !la.valueFinishTidy() {
panic("invalid state: AssembleValue cannot be called when still in the middle of assembling the previous value")
} // if tidy success: carry on
case laState_finished:
panic("invalid state: AssembleValue cannot be called on an assembler that's already finished")
}
la.w.x = append(la.w.x, _PBLink{})
la.state = laState_midValue
row := &la.w.x[len(la.w.x)-1]
la.va.w = row
la.va.m = &la.cm
return &la.va
}
func (la *_PBLinks__ReprAssembler) Finish() error {
switch la.state {
case laState_initial:
// carry on
case laState_midValue:
if !la.valueFinishTidy() {
panic("invalid state: Finish cannot be called when in the middle of assembling a value")
} // if tidy success: carry on
case laState_finished:
panic("invalid state: Finish cannot be called on an assembler that's already finished")
}
la.state = laState_finished
*la.m = schema.Maybe_Value
return nil
}
func (la *_PBLinks__ReprAssembler) ValuePrototype(_ int) ipld.NodePrototype {
return _PBLink__ReprPrototype{}
}
tPBNode.go 0 → 100644
View file @ c93d8a66
This diff is collapsed.
tString.go 0 → 100644
View file @ c93d8a66
package dagpb
// Code generated by go-ipld-prime gengo. DO NOT EDIT.
import (
ipld "github.com/ipld/go-ipld-prime"
"github.com/ipld/go-ipld-prime/node/mixins"
"github.com/ipld/go-ipld-prime/schema"
)
type _String struct{ x string }
type String = *_String
func (n String) String() string {
return n.x
}
func (_String__Prototype) fromString(w *_String, v string) error {
*w = _String{v}
return nil
}
func (_String__Prototype) FromString(v string) (String, error) {
n := _String{v}
return &n, nil
}
type _String__Maybe struct {
m schema.Maybe
v String
}
type MaybeString = *_String__Maybe
func (m MaybeString) IsNull() bool {
return m.m == schema.Maybe_Null
}
func (m MaybeString) IsAbsent() bool {
return m.m == schema.Maybe_Absent
}
func (m MaybeString) Exists() bool {
return m.m == schema.Maybe_Value
}
func (m MaybeString) AsNode() ipld.Node {
switch m.m {
case schema.Maybe_Absent:
return ipld.Absent
case schema.Maybe_Null:
return ipld.Null
case schema.Maybe_Value:
return m.v
default:
panic("unreachable")
}
}
func (m MaybeString) Must() String {
if !m.Exists() {
panic("unbox of a maybe rejected")
}
return m.v
}
var _ ipld.Node = (String)(&_String{})
var _ schema.TypedNode = (String)(&_String{})
func (String) ReprKind() ipld.ReprKind {
return ipld.ReprKind_String
}
func (String) LookupByString(string) (ipld.Node, error) {
return mixins.String{"dagpb.String"}.LookupByString("")
}
func (String) LookupByNode(ipld.Node) (ipld.Node, error) {
return mixins.String{"dagpb.String"}.LookupByNode(nil)
}
func (String) LookupByIndex(idx int) (ipld.Node, error) {
return mixins.String{"dagpb.String"}.LookupByIndex(0)
}
func (String) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) {
return mixins.String{"dagpb.String"}.LookupBySegment(seg)
}
func (String) MapIterator() ipld.MapIterator {
return nil
}
func (String) ListIterator() ipld.ListIterator {
return nil
}
func (String) Length() int {
return -1
}
func (String) IsAbsent() bool {
return false
}
func (String) IsNull() bool {
return false
}
func (String) AsBool() (bool, error) {
return mixins.String{"dagpb.String"}.AsBool()
}
func (String) AsInt() (int, error) {
return mixins.String{"dagpb.String"}.AsInt()
}
func (String) AsFloat() (float64, error) {
return mixins.String{"dagpb.String"}.AsFloat()
}
func (n String) AsString() (string, error) {
return n.x, nil
}
func (String) AsBytes() ([]byte, error) {
return mixins.String{"dagpb.String"}.AsBytes()
}
func (String) AsLink() (ipld.Link, error) {
return mixins.String{"dagpb.String"}.AsLink()
}
func (String) Prototype() ipld.NodePrototype {
return _String__Prototype{}
}
type _String__Prototype struct{}
func (_String__Prototype) NewBuilder() ipld.NodeBuilder {
var nb _String__Builder
nb.Reset()
return &nb
}
type _String__Builder struct {
_String__Assembler
}
func (nb *_String__Builder) Build() ipld.Node {
if *nb.m != schema.Maybe_Value {
panic("invalid state: cannot call Build on an assembler that's not finished")
}
return nb.w
}
func (nb *_String__Builder) Reset() {
var w _String
var m schema.Maybe
*nb = _String__Builder{_String__Assembler{w: &w, m: &m}}
}
type _String__Assembler struct {
w *_String
m *schema.Maybe
}
func (na *_String__Assembler) reset() {}
func (_String__Assembler) BeginMap(sizeHint int) (ipld.MapAssembler, error) {
return mixins.StringAssembler{"dagpb.String"}.BeginMap(0)
}
func (_String__Assembler) BeginList(sizeHint int) (ipld.ListAssembler, error) {
return mixins.StringAssembler{"dagpb.String"}.BeginList(0)
}
func (na *_String__Assembler) AssignNull() error {
switch *na.m {
case allowNull:
*na.m = schema.Maybe_Null
return nil
case schema.Maybe_Absent:
return mixins.StringAssembler{"dagpb.String"}.AssignNull()
case schema.Maybe_Value, schema.Maybe_Null:
panic("invalid state: cannot assign into assembler that's already finished")
}
panic("unreachable")
}
func (_String__Assembler) AssignBool(bool) error {
return mixins.StringAssembler{"dagpb.String"}.AssignBool(false)
}
func (_String__Assembler) AssignInt(int) error {
return mixins.StringAssembler{"dagpb.String"}.AssignInt(0)
}
func (_String__Assembler) AssignFloat(float64) error {
return mixins.StringAssembler{"dagpb.String"}.AssignFloat(0)
}
func (na *_String__Assembler) AssignString(v string) error {
switch *na.m {
case schema.Maybe_Value, schema.Maybe_Null:
panic("invalid state: cannot assign into assembler that's already finished")
}
if na.w == nil {
na.w = &_String{}
}
na.w.x = v
*na.m = schema.Maybe_Value
return nil
}
func (_String__Assembler) AssignBytes([]byte) error {
return mixins.StringAssembler{"dagpb.String"}.AssignBytes(nil)
}
func (_String__Assembler) AssignLink(ipld.Link) error {
return mixins.StringAssembler{"dagpb.String"}.AssignLink(nil)
}
func (na *_String__Assembler) AssignNode(v ipld.Node) error {
if v.IsNull() {
return na.AssignNull()
}
if v2, ok := v.(*_String); ok {
switch *na.m {
case schema.Maybe_Value, schema.Maybe_Null:
panic("invalid state: cannot assign into assembler that's already finished")
}
if na.w == nil {
na.w = v2
*na.m = schema.Maybe_Value
return nil
}
*na.w = *v2
*na.m = schema.Maybe_Value
return nil
}
if v2, err := v.AsString(); err != nil {
return err
} else {
return na.AssignString(v2)
}
}
func (_String__Assembler) Prototype() ipld.NodePrototype {
return _String__Prototype{}
}
func (String) Type() schema.Type {
return nil /*TODO:typelit*/
}
func (n String) Representation() ipld.Node {
return (*_String__Repr)(n)
}
type _String__Repr = _String
var _ ipld.Node = &_String__Repr{}
type _String__ReprPrototype = _String__Prototype
type _String__ReprAssembler = _String__Assembler
typeTable.go 0 → 100644
View file @ c93d8a66
package dagpb
// Type is a struct embeding a NodePrototype/Type for every Node implementation in this package.
// One of its major uses is to start the construction of a value.
// You can use it like this:
//
// dagpb.Type.YourTypeName.NewBuilder().BeginMap() //...
//
// and:
//
// dagpb.Type.OtherTypeName.NewBuilder().AssignString("x") // ...
//
var Type typeSlab
type typeSlab struct {
Bytes _Bytes__Prototype
Bytes__Repr _Bytes__ReprPrototype
Int _Int__Prototype
Int__Repr _Int__ReprPrototype
Link _Link__Prototype
Link__Repr _Link__ReprPrototype
PBLink _PBLink__Prototype
PBLink__Repr _PBLink__ReprPrototype
PBLinks _PBLinks__Prototype
PBLinks__Repr _PBLinks__ReprPrototype
PBNode _PBNode__Prototype
PBNode__Repr _PBNode__ReprPrototype
String _String__Prototype
String__Repr _String__ReprPrototype
}
unmarshal.go 0 → 100644
View file @ c93d8a66
package dagpb
import (
"io"
ipld "github.com/ipld/go-ipld-prime"
cidlink "github.com/ipld/go-ipld-prime/linking/cid"
pb "github.com/rvagg/go-dagpb/pb"
)
func Unmarshal(na ipld.NodeAssembler, reader io.Reader) error {
var curLink ipld.MapAssembler
ma, err := na.BeginMap(2)
if err != nil {
return err
}
if err = ma.AssembleKey().AssignString("Links"); err != nil {
return err
}
links, err := ma.AssembleValue().BeginList(0)
if err != nil {
return err
}
tokenReceiver := func(tok pb.Token) error {
switch tok.Type {
case pb.TypeData:
if err := links.Finish(); err != nil {
return err
}
links = nil
if err := ma.AssembleKey().AssignString("Data"); err != nil {
return err
}
if err := ma.AssembleValue().AssignBytes(tok.Bytes); err != nil {
return err
}
case pb.TypeLink:
case pb.TypeLinkEnd:
if err := curLink.Finish(); err != nil {
return err
}
case pb.TypeHash:
curLink, err = links.AssembleValue().BeginMap(3)
if err != nil {
return err
}
if err := curLink.AssembleKey().AssignString("Hash"); err != nil {
return err
}
if err := curLink.AssembleValue().AssignLink(cidlink.Link{*tok.Cid}); err != nil {
return err
}
case pb.TypeName:
if err := curLink.AssembleKey().AssignString("Name"); err != nil {
return err
}
if err := curLink.AssembleValue().AssignString(string(tok.Bytes)); err != nil {
return err
}
case pb.TypeTSize:
if err := curLink.AssembleKey().AssignString("Tsize"); err != nil {
return err
}
if err := curLink.AssembleValue().AssignInt(int(tok.Int)); err != nil {
return err
}
}
return nil
}
if err := pb.Unmarshal(reader, tokenReceiver); err != nil {
return err
}
if links != nil {
if err := links.Finish(); err != nil {
return err
}
}
return ma.Finish()
}
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment