From 716ba8d03cbd9fc47e7453278b16ef457d90c6b3 Mon Sep 17 00:00:00 2001 From: Will Scott Date: Mon, 22 Feb 2021 12:34:37 -0800 Subject: [PATCH 01/22] remove GX cruft --- .gx/lastpubver | 1 - ci/Jenkinsfile | 1 - package.json | 42 ------------------------------------------ 3 files changed, 44 deletions(-) delete mode 100644 .gx/lastpubver delete mode 100644 ci/Jenkinsfile delete mode 100644 package.json diff --git a/.gx/lastpubver b/.gx/lastpubver deleted file mode 100644 index bc0b7c2..0000000 --- a/.gx/lastpubver +++ /dev/null @@ -1 +0,0 @@ -0.3.6: QmQFmr7d1V38H5E8T6pBLoZvZNH1bVvtJSaCkRVHgRpFXu diff --git a/ci/Jenkinsfile b/ci/Jenkinsfile deleted file mode 100644 index b2067e6..0000000 --- a/ci/Jenkinsfile +++ /dev/null @@ -1 +0,0 @@ -golang() diff --git a/package.json b/package.json deleted file mode 100644 index cff29bc..0000000 --- a/package.json +++ /dev/null @@ -1,42 +0,0 @@ -{ - "author": "whyrusleeping", - "bugs": { - "url": "https://github.com/ipfs/go-ipld-git" - }, - "gx": { - "dvcsimport": "github.com/ipfs/go-ipld-git" - }, - "gxDependencies": [ - { - "author": "whyrusleeping", - "hash": "QmZ6nzCLwGLVfRzYLpD7pW6UNuBDKEcA2imJtVpbEx2rxy", - "name": "go-ipld-format", - "version": "0.8.1" - }, - { - "author": "whyrusleeping", - "hash": "QmTbxNB1NwDesLmKTscr4udL2tVP7MaxvXnD1D9yX7g3PN", - "name": "go-cid", - "version": "0.9.3" - }, - { - "author": "stebalien", - "hash": "QmYYLnAzR28nAQ4U5MFniLprnktu6eTFKibeNt96V21EZK", - "name": "go-block-format", - "version": "0.2.2" - }, - { - "author": "multiformats", - "hash": "QmerPMzPk1mJVowm8KgmoknWa4yCYvvugMPsgWmDNUvDLW", - "name": "go-multihash", - "version": "1.0.9" - } - ], - "gxVersion": "0.10.0", - "language": "go", - "license": "", - "name": "go-ipld-git", - "releaseCmd": "git commit -a -m \"gx publish $VERSION\"", - "version": "0.3.6" -} - From dae2706ba739c397d6b191e7b11d534f75069a88 Mon Sep 17 00:00:00 2001 From: Will Scott Date: Tue, 23 Feb 2021 00:13:54 -0800 Subject: [PATCH 02/22] Codec for decoding from byte stream to ipld prime Nodes for git data --- blob.go | 83 +- commit.go | 371 +- gen/gen.go | 66 + git.go | 2 + git_test.go | 2 + go.mod | 7 +- go.sum | 60 +- ipld_missing.go | 19 + ipldsch_minima.go | 50 + ipldsch_satisfaction.go | 7673 +++++++++++++++++++++++++++++++++++++++ ipldsch_types.go | 137 + personinfo.go | 71 + tag.go | 205 +- tree.go | 186 +- unmarshal.go | 33 + util.go | 11 + 16 files changed, 8357 insertions(+), 619 deletions(-) create mode 100644 gen/gen.go create mode 100644 ipld_missing.go create mode 100644 ipldsch_minima.go create mode 100644 ipldsch_satisfaction.go create mode 100644 ipldsch_types.go create mode 100644 personinfo.go create mode 100644 unmarshal.go create mode 100644 util.go diff --git a/blob.go b/blob.go index 8a67b98..fa010c6 100644 --- a/blob.go +++ b/blob.go @@ -1,71 +1,38 @@ package ipldgit import ( - "encoding/json" - "errors" + "bufio" + "bytes" + "fmt" + "io" + "strconv" - cid "github.com/ipfs/go-cid" - node "github.com/ipfs/go-ipld-format" + "github.com/ipld/go-ipld-prime" ) -type Blob struct { - rawData []byte - cid cid.Cid -} - -func (b *Blob) Cid() cid.Cid { - return b.cid -} - -func (b *Blob) Copy() node.Node { - nb := *b - return &nb -} - -func (b *Blob) Links() []*node.Link { - return nil -} - -func (b *Blob) Resolve(_ []string) (interface{}, []string, error) { - return nil, nil, errors.New("no such link") -} - -func (b *Blob) ResolveLink(_ []string) (*node.Link, []string, error) { - return nil, nil, errors.New("no such link") -} - -func (b *Blob) Loggable() map[string]interface{} { - return map[string]interface{}{ - "type": "git_blob", +// DecodeBlob fills a NodeAssembler (from `Type.Blob__Repr.NewBuilder()`) from a stream of bytes +func DecodeBlob(na ipld.NodeAssembler, rd *bufio.Reader) error { + size, err := rd.ReadString(0) + if err != nil { + return err } -} -func (b *Blob) MarshalJSON() ([]byte, error) { - return json.Marshal(b.rawData) -} - -func (b *Blob) RawData() []byte { - return []byte(b.rawData) -} - -func (b *Blob) Size() (uint64, error) { - return uint64(len(b.rawData)), nil -} + sizen, err := strconv.Atoi(size[:len(size)-1]) + if err != nil { + return err + } -func (b *Blob) Stat() (*node.NodeStat, error) { - return &node.NodeStat{}, nil -} + buf := new(bytes.Buffer) + fmt.Fprintf(buf, "blob %d\x00", sizen) -func (b *Blob) String() string { - return "[git blob]" -} + n, err := io.Copy(buf, rd) + if err != nil { + return err + } -func (b *Blob) Tree(p string, depth int) []string { - return nil -} + if n != int64(sizen) { + return fmt.Errorf("blob size was not accurate") + } -func (b *Blob) GitSha() []byte { - return cidToSha(b.Cid()) + return na.AssignBytes(buf.Bytes()) } - -var _ node.Node = (*Blob)(nil) diff --git a/commit.go b/commit.go index 77e2170..633f2bd 100644 --- a/commit.go +++ b/commit.go @@ -1,321 +1,150 @@ package ipldgit import ( + "bufio" "bytes" "encoding/hex" - "encoding/json" - "errors" "fmt" - "strconv" - "sync" - "time" + "io" + "io/ioutil" + "strings" - cid "github.com/ipfs/go-cid" - node "github.com/ipfs/go-ipld-format" + "github.com/ipld/go-ipld-prime" + cidlink "github.com/ipld/go-ipld-prime/linking/cid" + "github.com/ipld/go-ipld-prime/schema" ) -type Commit struct { - DataSize string `json:"-"` - GitTree cid.Cid `json:"tree"` - Parents []cid.Cid `json:"parents"` - Message string `json:"message"` - Author *PersonInfo `json:"author"` - Committer *PersonInfo `json:"committer"` - Encoding string `json:"encoding,omitempty"` - Sig *GpgSig `json:"signature,omitempty"` - MergeTag []*MergeTag `json:"mergetag,omitempty"` - - // Other contains all the non-standard headers, such as 'HG:extra' - Other []string `json:"other,omitempty"` - - cid cid.Cid - - rawData []byte - rawDataOnce sync.Once -} - -type PersonInfo struct { - Name string - Email string - Date string - Timezone string -} - -func (pi *PersonInfo) MarshalJSON() ([]byte, error) { - date, err := pi.date() +// DecodeCommit fills a NodeAssembler (from `Type.Commit__Repr.NewBuilder()`) from a stream of bytes +func DecodeCommit(na ipld.NodeAssembler, rd *bufio.Reader) error { + size, err := rd.ReadString(0) if err != nil { - return nil, err - } - return json.Marshal(map[string]interface{}{ - "name": pi.Name, - "email": pi.Email, - "date": *date, - }) -} - -func (pi *PersonInfo) String() string { - f := "%s <%s>" - arg := []interface{}{pi.Name, pi.Email} - if pi.Date != "" { - f = f + " %s" - arg = append(arg, pi.Date) + return err } - if pi.Timezone != "" { - f = f + " %s" - arg = append(arg, pi.Timezone) + c := _Commit{ + Parents: _ListParents{[]_Link{}}, + MergeTag: _ListTag{[]_Tag{}}, + Other: _ListString{[]_String{}}, } - return fmt.Sprintf(f, arg...) -} - -func (pi *PersonInfo) tree(name string, depth int) []string { - if depth == 1 { - return []string{name} - } - return []string{name + "/name", name + "/email", name + "/date"} -} - -func (pi *PersonInfo) resolve(p []string) (interface{}, []string, error) { - switch p[0] { - case "name": - return pi.Name, p[1:], nil - case "email": - return pi.Email, p[1:], nil - case "date": - date, err := pi.date() + c.DataSize = _String{size} + for { + line, _, err := rd.ReadLine() if err != nil { - return nil, nil, err + if err == io.EOF { + break + } + return err } - return date.Format(time.RFC3339), p[1:], nil - default: - return nil, nil, errors.New("no such link") - } -} - -func (pi *PersonInfo) date() (*time.Time, error) { - sec, err := strconv.ParseInt(pi.Date, 10, 64) - if err != nil { - return nil, err - } - zoneOffset, err := strconv.Atoi(pi.Timezone) - if err != nil { - return nil, err - } - hr, mm := zoneOffset/100, zoneOffset%100 - location := time.FixedZone("UTC", hr*60*60+mm*60) - date := time.Unix(sec, 0).In(location) - return &date, nil -} -type MergeTag struct { - Object cid.Cid `json:"object"` - Type string `json:"type"` - Tag string `json:"tag"` - Tagger *PersonInfo `json:"tagger"` - Text string `json:"text"` -} - -type GpgSig struct { - Text string -} - -func (c *Commit) Cid() cid.Cid { - return c.cid -} - -func (c *Commit) Copy() node.Node { - return &Commit{ - DataSize: c.DataSize, - GitTree: c.GitTree, - Parents: c.Parents, - Message: c.Message, - Author: c.Author, - Committer: c.Committer, - Encoding: c.Encoding, - Sig: c.Sig, - MergeTag: c.MergeTag, - Other: c.Other, - cid: c.cid, - } -} - -func (c *Commit) Links() []*node.Link { - out := []*node.Link{ - {Cid: c.GitTree}, - } - - for _, p := range c.Parents { - out = append(out, &node.Link{Cid: p}) + err = decodeCommitLine(&c, line, rd) + if err != nil { + return err + } } - return out -} -func (c *Commit) Loggable() map[string]interface{} { - return map[string]interface{}{ - "type": "git_commit", - } + return na.AssignNode(&c) } -func (c *Commit) RawData() []byte { - c.rawDataOnce.Do(func() { - buf := new(bytes.Buffer) - fmt.Fprintf(buf, "commit %s\x00", c.DataSize) - fmt.Fprintf(buf, "tree %s\n", hex.EncodeToString(cidToSha(c.GitTree))) - for _, p := range c.Parents { - fmt.Fprintf(buf, "parent %s\n", hex.EncodeToString(cidToSha(p))) - } - fmt.Fprintf(buf, "author %s\n", c.Author.String()) - fmt.Fprintf(buf, "committer %s\n", c.Committer.String()) - if len(c.Encoding) > 0 { - fmt.Fprintf(buf, "encoding %s\n", c.Encoding) - } - for _, mtag := range c.MergeTag { - fmt.Fprintf(buf, "mergetag object %s\n", hex.EncodeToString(cidToSha(mtag.Object))) - fmt.Fprintf(buf, " type %s\n", mtag.Type) - fmt.Fprintf(buf, " tag %s\n", mtag.Tag) - fmt.Fprintf(buf, " tagger %s\n \n", mtag.Tagger.String()) - fmt.Fprintf(buf, "%s", mtag.Text) - } - if c.Sig != nil { - fmt.Fprintln(buf, "gpgsig -----BEGIN PGP SIGNATURE-----") - fmt.Fprint(buf, c.Sig.Text) - fmt.Fprintln(buf, " -----END PGP SIGNATURE-----") - } - for _, line := range c.Other { - fmt.Fprintln(buf, line) +func decodeCommitLine(c Commit, line []byte, rd *bufio.Reader) error { + switch { + case bytes.HasPrefix(line, []byte("tree ")): + sha, err := hex.DecodeString(string(line[5:])) + if err != nil { + return err } - fmt.Fprintf(buf, "\n%s", c.Message) - c.rawData = buf.Bytes() - }) - return c.rawData -} - -func (c *Commit) Resolve(path []string) (interface{}, []string, error) { - if len(path) == 0 { - return nil, nil, fmt.Errorf("zero length path") - } - - switch path[0] { - case "parents": - if len(path) == 1 { - return c.Parents, nil, nil + c.GitTree = _LinkTree{cidlink.Link{Cid: shaToCid(sha)}} + case bytes.HasPrefix(line, []byte("parent ")): + psha, err := hex.DecodeString(string(line[7:])) + if err != nil { + return err } - i, err := strconv.Atoi(path[1]) + c.Parents.x = append(c.Parents.x, _Link{cidlink.Link{Cid: shaToCid(psha)}}) + case bytes.HasPrefix(line, []byte("author ")): + a, err := parsePersonInfo(line) if err != nil { - return nil, nil, err + return err } - if i < 0 || i >= len(c.Parents) { - return nil, nil, fmt.Errorf("index out of range") + c.Author = _PersonInfo__Maybe{m: schema.Maybe_Value, v: a} + case bytes.HasPrefix(line, []byte("committer ")): + com, err := parsePersonInfo(line) + if err != nil { + return err } - return &node.Link{Cid: c.Parents[i]}, path[2:], nil - case "author": - if len(path) == 1 { - return c.Author, nil, nil - } - return c.Author.resolve(path[1:]) - case "committer": - if len(path) == 1 { - return c.Committer, nil, nil - } - return c.Committer.resolve(path[1:]) - case "signature": - return c.Sig.Text, path[1:], nil - case "message": - return c.Message, path[1:], nil - case "tree": - return &node.Link{Cid: c.GitTree}, path[1:], nil - case "mergetag": - if len(path) == 1 { - return c.MergeTag, nil, nil + c.Committer = _PersonInfo__Maybe{m: schema.Maybe_Value, v: com} + case bytes.HasPrefix(line, []byte("encoding ")): + c.Encoding = _String__Maybe{m: schema.Maybe_Value, v: &_String{string(line[9:])}} + case bytes.HasPrefix(line, []byte("mergetag object ")): + sha, err := hex.DecodeString(string(line)[16:]) + if err != nil { + return err } - i, err := strconv.Atoi(path[1]) + mt, rest, err := readMergeTag(sha, rd) if err != nil { - return nil, nil, err + return err } - if i < 0 || i >= len(c.MergeTag) { - return nil, nil, fmt.Errorf("index out of range") - } + c.MergeTag.x = append(c.MergeTag.x, *mt) - if len(path) == 2 { - return c.MergeTag[i], nil, nil + if rest != nil { + err = decodeCommitLine(c, rest, rd) + if err != nil { + return err + } + } + case bytes.HasPrefix(line, []byte("gpgsig ")): + sig, err := decodeGpgSig(rd) + if err != nil { + return err + } + c.Sig = _GpgSig__Maybe{m: schema.Maybe_Value, v: sig} + case len(line) == 0: + rest, err := ioutil.ReadAll(rd) + if err != nil { + return err } - return c.MergeTag[i].resolve(path[2:]) + + c.Message = _String{string(rest)} default: - return nil, nil, errors.New("no such link") + c.Other.x = append(c.Other.x, _String{string(line)}) } + return nil } -func (c *Commit) ResolveLink(path []string) (*node.Link, []string, error) { - out, rest, err := c.Resolve(path) +func decodeGpgSig(rd *bufio.Reader) (GpgSig, error) { + line, _, err := rd.ReadLine() if err != nil { - return nil, nil, err - } - - lnk, ok := out.(*node.Link) - if !ok { - return nil, nil, errors.New("not a link") + return nil, err } - return lnk, rest, nil -} - -func (c *Commit) Size() (uint64, error) { - return uint64(len(c.RawData())), nil -} + out := _GpgSig{} -func (c *Commit) Stat() (*node.NodeStat, error) { - return &node.NodeStat{}, nil -} - -func (c *Commit) String() string { - return "[git commit object]" -} - -func (c *Commit) Tree(p string, depth int) []string { - if depth != -1 { - panic("proper tree not yet implemented") - } - tree := []string{"tree", "parents", "message", "gpgsig"} - tree = append(tree, c.Author.tree("author", depth)...) - tree = append(tree, c.Committer.tree("committer", depth)...) - for i := range c.Parents { - tree = append(tree, fmt.Sprintf("parents/%d", i)) + if string(line) != " " { + if strings.HasPrefix(string(line), " Version: ") || strings.HasPrefix(string(line), " Comment: ") { + out.x += string(line) + "\n" + } else { + return nil, fmt.Errorf("expected first line of sig to be a single space or version") + } + } else { + out.x += " \n" } - return tree -} - -func (c *Commit) GitSha() []byte { - return cidToSha(c.Cid()) -} -func (t *MergeTag) resolve(path []string) (interface{}, []string, error) { - if len(path) == 0 { - return nil, nil, fmt.Errorf("zero length path") - } + for { + line, _, err := rd.ReadLine() + if err != nil { + return nil, err + } - switch path[0] { - case "object": - return &node.Link{Cid: t.Object}, path[1:], nil - case "tag": - return t.Tag, path[1:], nil - case "tagger": - if len(path) == 1 { - return t.Tagger, nil, nil + if bytes.Equal(line, []byte(" -----END PGP SIGNATURE-----")) { + break } - return t.Tagger.resolve(path[1:]) - case "text": - return t.Text, path[1:], nil - case "type": - return t.Type, path[1:], nil - default: - return nil, nil, errors.New("no such link") + + out.x += string(line) + "\n" } -} -var _ node.Node = (*Commit)(nil) + return &out, nil +} diff --git a/gen/gen.go b/gen/gen.go new file mode 100644 index 0000000..0bf9fa6 --- /dev/null +++ b/gen/gen.go @@ -0,0 +1,66 @@ +package main + +import ( + "fmt" + "os" + + "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{ + CfgUnionMemlayout: map[schema.TypeName]string{}, + } + ts.Accumulate(schema.SpawnString("String")) + ts.Accumulate(schema.SpawnList("ListString", "String", false)) + ts.Accumulate(schema.SpawnLink("Link")) + ts.Accumulate(schema.SpawnStruct("PersonInfo", []schema.StructField{ + schema.SpawnStructField("Name", "String", false, false), + schema.SpawnStructField("Email", "String", false, false), + schema.SpawnStructField("Date", "String", false, false), + schema.SpawnStructField("Timezone", "String", false, false), + }, schema.SpawnStructRepresentationStringjoin(" "))) + ts.Accumulate(schema.SpawnString("GpgSig")) + ts.Accumulate(schema.SpawnStruct("Tag", []schema.StructField{ + schema.SpawnStructField("Object", "Link", false, false), + schema.SpawnStructField("TagType", "String", false, false), + schema.SpawnStructField("Tag", "String", false, false), + schema.SpawnStructField("Tagger", "PersonInfo", false, false), + schema.SpawnStructField("Text", "String", false, false), + }, schema.SpawnStructRepresentationMap(map[string]string{"Type": "TagType"}))) + ts.Accumulate(schema.SpawnList("ListTag", "Tag", false)) + ts.Accumulate(schema.SpawnList("ListParents", "Link", false)) //Todo: type 'Parents' links + ts.Accumulate(schema.SpawnStruct("Commit", []schema.StructField{ + schema.SpawnStructField("DataSize", "String", false, false), + schema.SpawnStructField("GitTree", "LinkTree", false, false), + schema.SpawnStructField("Parents", "ListParents", false, false), + schema.SpawnStructField("Message", "String", false, false), + schema.SpawnStructField("Author", "PersonInfo", true, false), + schema.SpawnStructField("Committer", "PersonInfo", true, false), + schema.SpawnStructField("Encoding", "String", true, false), + schema.SpawnStructField("Sig", "GpgSig", true, false), + schema.SpawnStructField("MergeTag", "ListTag", false, false), + schema.SpawnStructField("Other", "ListString", false, false), + }, schema.SpawnStructRepresentationMap(map[string]string{}))) + ts.Accumulate(schema.SpawnBytes("Blob")) + + ts.Accumulate(schema.SpawnList("Tree", "TreeEntry", false)) + ts.Accumulate(schema.SpawnLinkReference("LinkTree", "Tree")) + ts.Accumulate(schema.SpawnStruct("TreeEntry", []schema.StructField{ + schema.SpawnStructField("Mode", "String", false, false), + schema.SpawnStructField("Name", "String", false, false), + schema.SpawnStructField("Hash", "Link", false, false), + }, schema.SpawnStructRepresentationStringjoin(" "))) + + if errs := ts.ValidateGraph(); errs != nil { + for _, err := range errs { + fmt.Printf("- %s\n", err) + } + panic("not happening") + } + + gengo.Generate(os.Args[1], "ipldgit", ts, adjCfg) +} diff --git a/git.go b/git.go index 2d69441..4f9b29c 100644 --- a/git.go +++ b/git.go @@ -1,5 +1,6 @@ package ipldgit +/* import ( "bufio" "bytes" @@ -476,3 +477,4 @@ func ReadEntry(r *bufio.Reader) (*TreeEntry, error) { Hash: shaToCid(sha), }, nil } +*/ diff --git a/git_test.go b/git_test.go index 7916861..fe548bb 100644 --- a/git_test.go +++ b/git_test.go @@ -1,5 +1,6 @@ package ipldgit +/* import ( "archive/tar" "compress/gzip" @@ -446,3 +447,4 @@ func BenchmarkCid(b *testing.B) { } } } +*/ diff --git a/go.mod b/go.mod index 23e9b1e..76e5dab 100644 --- a/go.mod +++ b/go.mod @@ -3,8 +3,7 @@ module github.com/ipfs/go-ipld-git go 1.15 require ( - github.com/ipfs/go-block-format v0.0.2 - github.com/ipfs/go-cid v0.0.2 - github.com/ipfs/go-ipld-format v0.0.1 - github.com/multiformats/go-multihash v0.0.1 + github.com/ipfs/go-cid v0.0.4 + github.com/ipld/go-ipld-prime v0.7.0 + github.com/multiformats/go-multihash v0.0.10 ) diff --git a/go.sum b/go.sum index fa54375..9b713a4 100644 --- a/go.sum +++ b/go.sum @@ -1,29 +1,45 @@ -github.com/gxed/hashland/keccakpg v0.0.1 h1:wrk3uMNaMxbXiHibbPO4S0ymqJMm41WiudyFSs7UnsU= -github.com/gxed/hashland/keccakpg v0.0.1/go.mod h1:kRzw3HkwxFU1mpmPP8v1WyQzwdGfmKFJ6tItnhQ67kU= -github.com/gxed/hashland/murmur3 v0.0.1 h1:SheiaIt0sda5K+8FLz952/1iWS9zrnKsEJaOJu4ZbSc= -github.com/gxed/hashland/murmur3 v0.0.1/go.mod h1:KjXop02n4/ckmZSnY2+HKcLud/tcmvhST0bie/0lS48= -github.com/ipfs/go-block-format v0.0.2 h1:qPDvcP19izTjU8rgo6p7gTXZlkMkF5bz5G3fqIsSCPE= -github.com/ipfs/go-block-format v0.0.2/go.mod h1:AWR46JfpcObNfg3ok2JHDUfdiHRgWhJgCQF+KIgOPJY= -github.com/ipfs/go-cid v0.0.1/go.mod h1:GHWU/WuQdMPmIosc4Yn1bcCT7dSeX4lBafM7iqUPQvM= -github.com/ipfs/go-cid v0.0.2 h1:tuuKaZPU1M6HcejsO3AcYWW8sZ8MTvyxfc4uqB4eFE8= -github.com/ipfs/go-cid v0.0.2/go.mod h1:GHWU/WuQdMPmIosc4Yn1bcCT7dSeX4lBafM7iqUPQvM= -github.com/ipfs/go-ipfs-util v0.0.1 h1:Wz9bL2wB2YBJqggkA4dD7oSmqB4cAnpNbGrlHJulv50= -github.com/ipfs/go-ipfs-util v0.0.1/go.mod h1:spsl5z8KUnrve+73pOhSVZND1SIxPW5RyBCNzQxlJBc= -github.com/ipfs/go-ipld-format v0.0.1 h1:HCu4eB/Gh+KD/Q0M8u888RFkorTWNIL3da4oc5dwc80= -github.com/ipfs/go-ipld-format v0.0.1/go.mod h1:kyJtbkDALmFHv3QR6et67i35QzO3S0dCDnkOJhcZkms= +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 h1:UlfXKrZx1DjZoBhQHmNHLC1fK1dUJDN20Y28A7s+gJ8= +github.com/ipfs/go-cid v0.0.4/go.mod h1:4LLaPOQwmk5z9LBgQnpkivrx8BJjUyGwTXCd5Xfj6+M= +github.com/ipld/go-ipld-prime v0.7.0 h1:eigF1ZpaL1prbsKYVMqPLoPJqD/pzkQOe2j1uzvVg7w= +github.com/ipld/go-ipld-prime v0.7.0/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.0.0-20190131020904-2d45a736cd16 h1:5W7KhL8HVF3XCFOweFD3BNESdnO8ewyYTFT2R+/b8FQ= -github.com/minio/sha256-simd v0.0.0-20190131020904-2d45a736cd16/go.mod h1:2FMWW+8GMoPweT6+pI63m9YE3Lmw4J71hV56Chs1E/U= -github.com/mr-tron/base58 v1.1.0 h1:Y51FGVJ91WBqCEabAi5OPUz38eAx8DakuAm5svLcsfQ= +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/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-multibase v0.0.1 h1:PN9/v21eLywrFWdFNsFKaU04kLJzuYzmrJR+ubhT9qA= github.com/multiformats/go-multibase v0.0.1/go.mod h1:bja2MqRZ3ggyXtZSEDKpl0uO/gviWFaSteVbWT51qgs= -github.com/multiformats/go-multihash v0.0.1 h1:HHwN1K12I+XllBCrqKnhX949Orn4oawPkegHMu2vDqQ= -github.com/multiformats/go-multihash v0.0.1/go.mod h1:w/5tugSrLEbWqlcgJabL3oHFKTwfvkofsjW2Qa1ct4U= -golang.org/x/crypto v0.0.0-20190211182817-74369b46fc67 h1:ng3VDlRp5/DHpSWl02R4rM9I+8M2rhmsuLwAMmkLQWE= -golang.org/x/crypto v0.0.0-20190211182817-74369b46fc67/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= -golang.org/x/sys v0.0.0-20190219092855-153ac476189d h1:Z0Ahzd7HltpJtjAHHxX8QFP3j1yYgiuvjbjRzDj/KH0= -golang.org/x/sys v0.0.0-20190219092855-153ac476189d/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +github.com/multiformats/go-multihash v0.0.10 h1:lMoNbh2Ssd9PUF74Nz008KGzGPlfeV6wH3rit5IIGCM= +github.com/multiformats/go-multihash v0.0.10/go.mod h1:YSLudS+Pi8NHE7o6tb3D8vrpKa63epEDmG8nTduyAew= +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/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-20200122134326-e047566fdf82 h1:ywK/j/KkyTHcdyYSZNXGjMwgmDSfjglYZ3vStQ/gSCU= +golang.org/x/sys v0.0.0-20200122134326-e047566fdf82/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +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= diff --git a/ipld_missing.go b/ipld_missing.go new file mode 100644 index 0000000..23f7012 --- /dev/null +++ b/ipld_missing.go @@ -0,0 +1,19 @@ +package ipldgit + +import ( + "github.com/ipfs/go-cid" + cidlink "github.com/ipld/go-ipld-prime/linking/cid" +) + +func (ip _Link__Prototype) fromString(l *_Link, s string) error { + c, err := cid.Decode(s) + if err != nil { + return err + } + l.x = cidlink.Link{Cid: c} + return nil +} + +func (ip *_Link) String() string { + return ip.String() +} diff --git a/ipldsch_minima.go b/ipldsch_minima.go new file mode 100644 index 0000000..39e7432 --- /dev/null +++ b/ipldsch_minima.go @@ -0,0 +1,50 @@ +package ipldgit + +// 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(_ int64) (ipld.MapAssembler, error) { return nil, ea.e } +func (ea _ErrorThunkAssembler) BeginList(_ int64) (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(int64) 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)) +} diff --git a/ipldsch_satisfaction.go b/ipldsch_satisfaction.go new file mode 100644 index 0000000..695dde6 --- /dev/null +++ b/ipldsch_satisfaction.go @@ -0,0 +1,7673 @@ +package ipldgit + +// 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" +) + +func (n Blob) Bytes() []byte { + return n.x +} +func (_Blob__Prototype) FromBytes(v []byte) (Blob, error) { + n := _Blob{v} + return &n, nil +} +type _Blob__Maybe struct { + m schema.Maybe + v Blob +} +type MaybeBlob = *_Blob__Maybe + +func (m MaybeBlob) IsNull() bool { + return m.m == schema.Maybe_Null +} +func (m MaybeBlob) IsAbsent() bool { + return m.m == schema.Maybe_Absent +} +func (m MaybeBlob) Exists() bool { + return m.m == schema.Maybe_Value +} +func (m MaybeBlob) 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 MaybeBlob) Must() Blob { + if !m.Exists() { + panic("unbox of a maybe rejected") + } + return m.v +} +var _ ipld.Node = (Blob)(&_Blob{}) +var _ schema.TypedNode = (Blob)(&_Blob{}) +func (Blob) Kind() ipld.Kind { + return ipld.Kind_Bytes +} +func (Blob) LookupByString(string) (ipld.Node, error) { + return mixins.Bytes{"ipldgit.Blob"}.LookupByString("") +} +func (Blob) LookupByNode(ipld.Node) (ipld.Node, error) { + return mixins.Bytes{"ipldgit.Blob"}.LookupByNode(nil) +} +func (Blob) LookupByIndex(idx int64) (ipld.Node, error) { + return mixins.Bytes{"ipldgit.Blob"}.LookupByIndex(0) +} +func (Blob) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { + return mixins.Bytes{"ipldgit.Blob"}.LookupBySegment(seg) +} +func (Blob) MapIterator() ipld.MapIterator { + return nil +} +func (Blob) ListIterator() ipld.ListIterator { + return nil +} +func (Blob) Length() int64 { + return -1 +} +func (Blob) IsAbsent() bool { + return false +} +func (Blob) IsNull() bool { + return false +} +func (Blob) AsBool() (bool, error) { + return mixins.Bytes{"ipldgit.Blob"}.AsBool() +} +func (Blob) AsInt() (int64, error) { + return mixins.Bytes{"ipldgit.Blob"}.AsInt() +} +func (Blob) AsFloat() (float64, error) { + return mixins.Bytes{"ipldgit.Blob"}.AsFloat() +} +func (Blob) AsString() (string, error) { + return mixins.Bytes{"ipldgit.Blob"}.AsString() +} +func (n Blob) AsBytes() ([]byte, error) { + return n.x, nil +} +func (Blob) AsLink() (ipld.Link, error) { + return mixins.Bytes{"ipldgit.Blob"}.AsLink() +} +func (Blob) Prototype() ipld.NodePrototype { + return _Blob__Prototype{} +} +type _Blob__Prototype struct{} + +func (_Blob__Prototype) NewBuilder() ipld.NodeBuilder { + var nb _Blob__Builder + nb.Reset() + return &nb +} +type _Blob__Builder struct { + _Blob__Assembler +} +func (nb *_Blob__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 *_Blob__Builder) Reset() { + var w _Blob + var m schema.Maybe + *nb = _Blob__Builder{_Blob__Assembler{w: &w, m: &m}} +} +type _Blob__Assembler struct { + w *_Blob + m *schema.Maybe +} + +func (na *_Blob__Assembler) reset() {} +func (_Blob__Assembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { + return mixins.BytesAssembler{"ipldgit.Blob"}.BeginMap(0) +} +func (_Blob__Assembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { + return mixins.BytesAssembler{"ipldgit.Blob"}.BeginList(0) +} +func (na *_Blob__Assembler) AssignNull() error { + switch *na.m { + case allowNull: + *na.m = schema.Maybe_Null + return nil + case schema.Maybe_Absent: + return mixins.BytesAssembler{"ipldgit.Blob"}.AssignNull() + case schema.Maybe_Value, schema.Maybe_Null: + panic("invalid state: cannot assign into assembler that's already finished") + } + panic("unreachable") +} +func (_Blob__Assembler) AssignBool(bool) error { + return mixins.BytesAssembler{"ipldgit.Blob"}.AssignBool(false) +} +func (_Blob__Assembler) AssignInt(int64) error { + return mixins.BytesAssembler{"ipldgit.Blob"}.AssignInt(0) +} +func (_Blob__Assembler) AssignFloat(float64) error { + return mixins.BytesAssembler{"ipldgit.Blob"}.AssignFloat(0) +} +func (_Blob__Assembler) AssignString(string) error { + return mixins.BytesAssembler{"ipldgit.Blob"}.AssignString("") +} +func (na *_Blob__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 = &_Blob{} + } + na.w.x = v + *na.m = schema.Maybe_Value + return nil +} +func (_Blob__Assembler) AssignLink(ipld.Link) error { + return mixins.BytesAssembler{"ipldgit.Blob"}.AssignLink(nil) +} +func (na *_Blob__Assembler) AssignNode(v ipld.Node) error { + if v.IsNull() { + return na.AssignNull() + } + if v2, ok := v.(*_Blob); 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 (_Blob__Assembler) Prototype() ipld.NodePrototype { + return _Blob__Prototype{} +} +func (Blob) Type() schema.Type { + return nil /*TODO:typelit*/ +} +func (n Blob) Representation() ipld.Node { + return (*_Blob__Repr)(n) +} +type _Blob__Repr = _Blob +var _ ipld.Node = &_Blob__Repr{} +type _Blob__ReprPrototype = _Blob__Prototype +type _Blob__ReprAssembler = _Blob__Assembler + + +func (n _Commit) FieldDataSize() String { + return &n.DataSize +} +func (n _Commit) FieldGitTree() LinkTree { + return &n.GitTree +} +func (n _Commit) FieldParents() ListParents { + return &n.Parents +} +func (n _Commit) FieldMessage() String { + return &n.Message +} +func (n _Commit) FieldAuthor() MaybePersonInfo { + return &n.Author +} +func (n _Commit) FieldCommitter() MaybePersonInfo { + return &n.Committer +} +func (n _Commit) FieldEncoding() MaybeString { + return &n.Encoding +} +func (n _Commit) FieldSig() MaybeGpgSig { + return &n.Sig +} +func (n _Commit) FieldMergeTag() ListTag { + return &n.MergeTag +} +func (n _Commit) FieldOther() ListString { + return &n.Other +} +type _Commit__Maybe struct { + m schema.Maybe + v Commit +} +type MaybeCommit = *_Commit__Maybe + +func (m MaybeCommit) IsNull() bool { + return m.m == schema.Maybe_Null +} +func (m MaybeCommit) IsAbsent() bool { + return m.m == schema.Maybe_Absent +} +func (m MaybeCommit) Exists() bool { + return m.m == schema.Maybe_Value +} +func (m MaybeCommit) 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 MaybeCommit) Must() Commit { + if !m.Exists() { + panic("unbox of a maybe rejected") + } + return m.v +} +var ( + fieldName__Commit_DataSize = _String{"DataSize"} + fieldName__Commit_GitTree = _String{"GitTree"} + fieldName__Commit_Parents = _String{"Parents"} + fieldName__Commit_Message = _String{"Message"} + fieldName__Commit_Author = _String{"Author"} + fieldName__Commit_Committer = _String{"Committer"} + fieldName__Commit_Encoding = _String{"Encoding"} + fieldName__Commit_Sig = _String{"Sig"} + fieldName__Commit_MergeTag = _String{"MergeTag"} + fieldName__Commit_Other = _String{"Other"} +) +var _ ipld.Node = (Commit)(&_Commit{}) +var _ schema.TypedNode = (Commit)(&_Commit{}) +func (Commit) Kind() ipld.Kind { + return ipld.Kind_Map +} +func (n Commit) LookupByString(key string) (ipld.Node, error) { + switch key { + case "DataSize": + return &n.DataSize, nil + case "GitTree": + return &n.GitTree, nil + case "Parents": + return &n.Parents, nil + case "Message": + return &n.Message, nil + case "Author": + if n.Author.m == schema.Maybe_Absent { + return ipld.Absent, nil + } + return n.Author.v, nil + case "Committer": + if n.Committer.m == schema.Maybe_Absent { + return ipld.Absent, nil + } + return n.Committer.v, nil + case "Encoding": + if n.Encoding.m == schema.Maybe_Absent { + return ipld.Absent, nil + } + return n.Encoding.v, nil + case "Sig": + if n.Sig.m == schema.Maybe_Absent { + return ipld.Absent, nil + } + return n.Sig.v, nil + case "MergeTag": + return &n.MergeTag, nil + case "Other": + return &n.Other, nil + default: + return nil, schema.ErrNoSuchField{Type: nil /*TODO*/, Field: ipld.PathSegmentOfString(key)} + } +} +func (n Commit) LookupByNode(key ipld.Node) (ipld.Node, error) { + ks, err := key.AsString() + if err != nil { + return nil, err + } + return n.LookupByString(ks) +} +func (Commit) LookupByIndex(idx int64) (ipld.Node, error) { + return mixins.Map{"ipldgit.Commit"}.LookupByIndex(0) +} +func (n Commit) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { + return n.LookupByString(seg.String()) +} +func (n Commit) MapIterator() ipld.MapIterator { + return &_Commit__MapItr{n, 0} +} + +type _Commit__MapItr struct { + n Commit + idx int +} + +func (itr *_Commit__MapItr) Next() (k ipld.Node, v ipld.Node, _ error) { + if itr.idx >= 10 { + return nil, nil, ipld.ErrIteratorOverread{} + } + switch itr.idx { + case 0: + k = &fieldName__Commit_DataSize + v = &itr.n.DataSize + case 1: + k = &fieldName__Commit_GitTree + v = &itr.n.GitTree + case 2: + k = &fieldName__Commit_Parents + v = &itr.n.Parents + case 3: + k = &fieldName__Commit_Message + v = &itr.n.Message + case 4: + k = &fieldName__Commit_Author + if itr.n.Author.m == schema.Maybe_Absent { + v = ipld.Absent + break + } + v = itr.n.Author.v + case 5: + k = &fieldName__Commit_Committer + if itr.n.Committer.m == schema.Maybe_Absent { + v = ipld.Absent + break + } + v = itr.n.Committer.v + case 6: + k = &fieldName__Commit_Encoding + if itr.n.Encoding.m == schema.Maybe_Absent { + v = ipld.Absent + break + } + v = itr.n.Encoding.v + case 7: + k = &fieldName__Commit_Sig + if itr.n.Sig.m == schema.Maybe_Absent { + v = ipld.Absent + break + } + v = itr.n.Sig.v + case 8: + k = &fieldName__Commit_MergeTag + v = &itr.n.MergeTag + case 9: + k = &fieldName__Commit_Other + v = &itr.n.Other + default: + panic("unreachable") + } + itr.idx++ + return +} +func (itr *_Commit__MapItr) Done() bool { + return itr.idx >= 10 +} + +func (Commit) ListIterator() ipld.ListIterator { + return nil +} +func (Commit) Length() int64 { + return 10 +} +func (Commit) IsAbsent() bool { + return false +} +func (Commit) IsNull() bool { + return false +} +func (Commit) AsBool() (bool, error) { + return mixins.Map{"ipldgit.Commit"}.AsBool() +} +func (Commit) AsInt() (int64, error) { + return mixins.Map{"ipldgit.Commit"}.AsInt() +} +func (Commit) AsFloat() (float64, error) { + return mixins.Map{"ipldgit.Commit"}.AsFloat() +} +func (Commit) AsString() (string, error) { + return mixins.Map{"ipldgit.Commit"}.AsString() +} +func (Commit) AsBytes() ([]byte, error) { + return mixins.Map{"ipldgit.Commit"}.AsBytes() +} +func (Commit) AsLink() (ipld.Link, error) { + return mixins.Map{"ipldgit.Commit"}.AsLink() +} +func (Commit) Prototype() ipld.NodePrototype { + return _Commit__Prototype{} +} +type _Commit__Prototype struct{} + +func (_Commit__Prototype) NewBuilder() ipld.NodeBuilder { + var nb _Commit__Builder + nb.Reset() + return &nb +} +type _Commit__Builder struct { + _Commit__Assembler +} +func (nb *_Commit__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 *_Commit__Builder) Reset() { + var w _Commit + var m schema.Maybe + *nb = _Commit__Builder{_Commit__Assembler{w: &w, m: &m}} +} +type _Commit__Assembler struct { + w *_Commit + m *schema.Maybe + state maState + s int + f int + + cm schema.Maybe + ca_DataSize _String__Assembler + ca_GitTree _LinkTree__Assembler + ca_Parents _ListParents__Assembler + ca_Message _String__Assembler + ca_Author _PersonInfo__Assembler + ca_Committer _PersonInfo__Assembler + ca_Encoding _String__Assembler + ca_Sig _GpgSig__Assembler + ca_MergeTag _ListTag__Assembler + ca_Other _ListString__Assembler + } + +func (na *_Commit__Assembler) reset() { + na.state = maState_initial + na.s = 0 + na.ca_DataSize.reset() + na.ca_GitTree.reset() + na.ca_Parents.reset() + na.ca_Message.reset() + na.ca_Author.reset() + na.ca_Committer.reset() + na.ca_Encoding.reset() + na.ca_Sig.reset() + na.ca_MergeTag.reset() + na.ca_Other.reset() +} + +var ( + fieldBit__Commit_DataSize = 1 << 0 + fieldBit__Commit_GitTree = 1 << 1 + fieldBit__Commit_Parents = 1 << 2 + fieldBit__Commit_Message = 1 << 3 + fieldBit__Commit_Author = 1 << 4 + fieldBit__Commit_Committer = 1 << 5 + fieldBit__Commit_Encoding = 1 << 6 + fieldBit__Commit_Sig = 1 << 7 + fieldBit__Commit_MergeTag = 1 << 8 + fieldBit__Commit_Other = 1 << 9 + fieldBits__Commit_sufficient = 0 + 1 << 0 + 1 << 1 + 1 << 2 + 1 << 3 + 1 << 8 + 1 << 9 +) +func (na *_Commit__Assembler) BeginMap(int64) (ipld.MapAssembler, 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 na.w == nil { + na.w = &_Commit{} + } + return na, nil +} +func (_Commit__Assembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { + return mixins.MapAssembler{"ipldgit.Commit"}.BeginList(0) +} +func (na *_Commit__Assembler) AssignNull() error { + switch *na.m { + case allowNull: + *na.m = schema.Maybe_Null + return nil + case schema.Maybe_Absent: + return mixins.MapAssembler{"ipldgit.Commit"}.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 (_Commit__Assembler) AssignBool(bool) error { + return mixins.MapAssembler{"ipldgit.Commit"}.AssignBool(false) +} +func (_Commit__Assembler) AssignInt(int64) error { + return mixins.MapAssembler{"ipldgit.Commit"}.AssignInt(0) +} +func (_Commit__Assembler) AssignFloat(float64) error { + return mixins.MapAssembler{"ipldgit.Commit"}.AssignFloat(0) +} +func (_Commit__Assembler) AssignString(string) error { + return mixins.MapAssembler{"ipldgit.Commit"}.AssignString("") +} +func (_Commit__Assembler) AssignBytes([]byte) error { + return mixins.MapAssembler{"ipldgit.Commit"}.AssignBytes(nil) +} +func (_Commit__Assembler) AssignLink(ipld.Link) error { + return mixins.MapAssembler{"ipldgit.Commit"}.AssignLink(nil) +} +func (na *_Commit__Assembler) AssignNode(v ipld.Node) error { + if v.IsNull() { + return na.AssignNull() + } + if v2, ok := v.(*_Commit); 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.Kind() != ipld.Kind_Map { + return ipld.ErrWrongKind{TypeName: "ipldgit.Commit", MethodName: "AssignNode", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()} + } + itr := v.MapIterator() + for !itr.Done() { + k, v, err := itr.Next() + if err != nil { + return err + } + if err := na.AssembleKey().AssignNode(k); err != nil { + return err + } + if err := na.AssembleValue().AssignNode(v); err != nil { + return err + } + } + return na.Finish() +} +func (_Commit__Assembler) Prototype() ipld.NodePrototype { + return _Commit__Prototype{} +} +func (ma *_Commit__Assembler) valueFinishTidy() bool { + switch ma.f { + case 0: + switch ma.cm { + case schema.Maybe_Value: + ma.ca_DataSize.w = nil + ma.cm = schema.Maybe_Absent + ma.state = maState_initial + return true + default: + return false + } + case 1: + switch ma.cm { + case schema.Maybe_Value: + ma.ca_GitTree.w = nil + ma.cm = schema.Maybe_Absent + ma.state = maState_initial + return true + default: + return false + } + case 2: + switch ma.cm { + case schema.Maybe_Value: + ma.ca_Parents.w = nil + ma.cm = schema.Maybe_Absent + ma.state = maState_initial + return true + default: + return false + } + case 3: + switch ma.cm { + case schema.Maybe_Value: + ma.ca_Message.w = nil + ma.cm = schema.Maybe_Absent + ma.state = maState_initial + return true + default: + return false + } + case 4: + switch ma.w.Author.m { + case schema.Maybe_Value: + ma.w.Author.v = ma.ca_Author.w + ma.state = maState_initial + return true + default: + return false + } + case 5: + switch ma.w.Committer.m { + case schema.Maybe_Value: + ma.w.Committer.v = ma.ca_Committer.w + ma.state = maState_initial + return true + default: + return false + } + case 6: + switch ma.w.Encoding.m { + case schema.Maybe_Value: + ma.w.Encoding.v = ma.ca_Encoding.w + ma.state = maState_initial + return true + default: + return false + } + case 7: + switch ma.w.Sig.m { + case schema.Maybe_Value: + ma.w.Sig.v = ma.ca_Sig.w + ma.state = maState_initial + return true + default: + return false + } + case 8: + switch ma.cm { + case schema.Maybe_Value: + ma.ca_MergeTag.w = nil + ma.cm = schema.Maybe_Absent + ma.state = maState_initial + return true + default: + return false + } + case 9: + switch ma.cm { + case schema.Maybe_Value: + ma.ca_Other.w = nil + ma.cm = schema.Maybe_Absent + ma.state = maState_initial + return true + default: + return false + } + default: + panic("unreachable") + } +} +func (ma *_Commit__Assembler) AssembleEntry(k string) (ipld.NodeAssembler, error) { + switch ma.state { + case maState_initial: + // carry on + case maState_midKey: + panic("invalid state: AssembleEntry cannot be called when in the middle of assembling another key") + case maState_expectValue: + panic("invalid state: AssembleEntry cannot be called when expecting start of value assembly") + case maState_midValue: + if !ma.valueFinishTidy() { + panic("invalid state: AssembleEntry cannot be called when in the middle of assembling a value") + } // if tidy success: carry on + case maState_finished: + panic("invalid state: AssembleEntry cannot be called on an assembler that's already finished") + } + switch k { + case "DataSize": + if ma.s & fieldBit__Commit_DataSize != 0 { + return nil, ipld.ErrRepeatedMapKey{&fieldName__Commit_DataSize} + } + ma.s += fieldBit__Commit_DataSize + ma.state = maState_midValue + ma.f = 0 + ma.ca_DataSize.w = &ma.w.DataSize + ma.ca_DataSize.m = &ma.cm + return &ma.ca_DataSize, nil + case "GitTree": + if ma.s & fieldBit__Commit_GitTree != 0 { + return nil, ipld.ErrRepeatedMapKey{&fieldName__Commit_GitTree} + } + ma.s += fieldBit__Commit_GitTree + ma.state = maState_midValue + ma.f = 1 + ma.ca_GitTree.w = &ma.w.GitTree + ma.ca_GitTree.m = &ma.cm + return &ma.ca_GitTree, nil + case "Parents": + if ma.s & fieldBit__Commit_Parents != 0 { + return nil, ipld.ErrRepeatedMapKey{&fieldName__Commit_Parents} + } + ma.s += fieldBit__Commit_Parents + ma.state = maState_midValue + ma.f = 2 + ma.ca_Parents.w = &ma.w.Parents + ma.ca_Parents.m = &ma.cm + return &ma.ca_Parents, nil + case "Message": + if ma.s & fieldBit__Commit_Message != 0 { + return nil, ipld.ErrRepeatedMapKey{&fieldName__Commit_Message} + } + ma.s += fieldBit__Commit_Message + ma.state = maState_midValue + ma.f = 3 + ma.ca_Message.w = &ma.w.Message + ma.ca_Message.m = &ma.cm + return &ma.ca_Message, nil + case "Author": + if ma.s & fieldBit__Commit_Author != 0 { + return nil, ipld.ErrRepeatedMapKey{&fieldName__Commit_Author} + } + ma.s += fieldBit__Commit_Author + ma.state = maState_midValue + ma.f = 4 + ma.ca_Author.w = ma.w.Author.v + ma.ca_Author.m = &ma.w.Author.m + return &ma.ca_Author, nil + case "Committer": + if ma.s & fieldBit__Commit_Committer != 0 { + return nil, ipld.ErrRepeatedMapKey{&fieldName__Commit_Committer} + } + ma.s += fieldBit__Commit_Committer + ma.state = maState_midValue + ma.f = 5 + ma.ca_Committer.w = ma.w.Committer.v + ma.ca_Committer.m = &ma.w.Committer.m + return &ma.ca_Committer, nil + case "Encoding": + if ma.s & fieldBit__Commit_Encoding != 0 { + return nil, ipld.ErrRepeatedMapKey{&fieldName__Commit_Encoding} + } + ma.s += fieldBit__Commit_Encoding + ma.state = maState_midValue + ma.f = 6 + ma.ca_Encoding.w = ma.w.Encoding.v + ma.ca_Encoding.m = &ma.w.Encoding.m + return &ma.ca_Encoding, nil + case "Sig": + if ma.s & fieldBit__Commit_Sig != 0 { + return nil, ipld.ErrRepeatedMapKey{&fieldName__Commit_Sig} + } + ma.s += fieldBit__Commit_Sig + ma.state = maState_midValue + ma.f = 7 + ma.ca_Sig.w = ma.w.Sig.v + ma.ca_Sig.m = &ma.w.Sig.m + return &ma.ca_Sig, nil + case "MergeTag": + if ma.s & fieldBit__Commit_MergeTag != 0 { + return nil, ipld.ErrRepeatedMapKey{&fieldName__Commit_MergeTag} + } + ma.s += fieldBit__Commit_MergeTag + ma.state = maState_midValue + ma.f = 8 + ma.ca_MergeTag.w = &ma.w.MergeTag + ma.ca_MergeTag.m = &ma.cm + return &ma.ca_MergeTag, nil + case "Other": + if ma.s & fieldBit__Commit_Other != 0 { + return nil, ipld.ErrRepeatedMapKey{&fieldName__Commit_Other} + } + ma.s += fieldBit__Commit_Other + ma.state = maState_midValue + ma.f = 9 + ma.ca_Other.w = &ma.w.Other + ma.ca_Other.m = &ma.cm + return &ma.ca_Other, nil + default: + return nil, ipld.ErrInvalidKey{TypeName:"ipldgit.Commit", Key:&_String{k}} + } +} +func (ma *_Commit__Assembler) AssembleKey() ipld.NodeAssembler { + switch ma.state { + case maState_initial: + // carry on + case maState_midKey: + panic("invalid state: AssembleKey cannot be called when in the middle of assembling another key") + case maState_expectValue: + panic("invalid state: AssembleKey cannot be called when expecting start of value assembly") + case maState_midValue: + if !ma.valueFinishTidy() { + panic("invalid state: AssembleKey cannot be called when in the middle of assembling a value") + } // if tidy success: carry on + case maState_finished: + panic("invalid state: AssembleKey cannot be called on an assembler that's already finished") + } + ma.state = maState_midKey + return (*_Commit__KeyAssembler)(ma) +} +func (ma *_Commit__Assembler) AssembleValue() ipld.NodeAssembler { + switch ma.state { + case maState_initial: + panic("invalid state: AssembleValue cannot be called when no key is primed") + case maState_midKey: + panic("invalid state: AssembleValue cannot be called when in the middle of assembling a key") + case maState_expectValue: + // carry on + case maState_midValue: + panic("invalid state: AssembleValue cannot be called when in the middle of assembling another value") + case maState_finished: + panic("invalid state: AssembleValue cannot be called on an assembler that's already finished") + } + ma.state = maState_midValue + switch ma.f { + case 0: + ma.ca_DataSize.w = &ma.w.DataSize + ma.ca_DataSize.m = &ma.cm + return &ma.ca_DataSize + case 1: + ma.ca_GitTree.w = &ma.w.GitTree + ma.ca_GitTree.m = &ma.cm + return &ma.ca_GitTree + case 2: + ma.ca_Parents.w = &ma.w.Parents + ma.ca_Parents.m = &ma.cm + return &ma.ca_Parents + case 3: + ma.ca_Message.w = &ma.w.Message + ma.ca_Message.m = &ma.cm + return &ma.ca_Message + case 4: + ma.ca_Author.w = ma.w.Author.v + ma.ca_Author.m = &ma.w.Author.m + return &ma.ca_Author + case 5: + ma.ca_Committer.w = ma.w.Committer.v + ma.ca_Committer.m = &ma.w.Committer.m + return &ma.ca_Committer + case 6: + ma.ca_Encoding.w = ma.w.Encoding.v + ma.ca_Encoding.m = &ma.w.Encoding.m + return &ma.ca_Encoding + case 7: + ma.ca_Sig.w = ma.w.Sig.v + ma.ca_Sig.m = &ma.w.Sig.m + return &ma.ca_Sig + case 8: + ma.ca_MergeTag.w = &ma.w.MergeTag + ma.ca_MergeTag.m = &ma.cm + return &ma.ca_MergeTag + case 9: + ma.ca_Other.w = &ma.w.Other + ma.ca_Other.m = &ma.cm + return &ma.ca_Other + default: + panic("unreachable") + } +} +func (ma *_Commit__Assembler) Finish() error { + switch ma.state { + case maState_initial: + // carry on + case maState_midKey: + panic("invalid state: Finish cannot be called when in the middle of assembling a key") + case maState_expectValue: + panic("invalid state: Finish cannot be called when expecting start of value assembly") + case maState_midValue: + if !ma.valueFinishTidy() { + panic("invalid state: Finish cannot be called when in the middle of assembling a value") + } // if tidy success: carry on + case maState_finished: + panic("invalid state: Finish cannot be called on an assembler that's already finished") + } + if ma.s & fieldBits__Commit_sufficient != fieldBits__Commit_sufficient { + err := ipld.ErrMissingRequiredField{Missing: make([]string, 0)} + if ma.s & fieldBit__Commit_DataSize == 0 { + err.Missing = append(err.Missing, "DataSize") + } + if ma.s & fieldBit__Commit_GitTree == 0 { + err.Missing = append(err.Missing, "GitTree") + } + if ma.s & fieldBit__Commit_Parents == 0 { + err.Missing = append(err.Missing, "Parents") + } + if ma.s & fieldBit__Commit_Message == 0 { + err.Missing = append(err.Missing, "Message") + } + if ma.s & fieldBit__Commit_MergeTag == 0 { + err.Missing = append(err.Missing, "MergeTag") + } + if ma.s & fieldBit__Commit_Other == 0 { + err.Missing = append(err.Missing, "Other") + } + return err + } + ma.state = maState_finished + *ma.m = schema.Maybe_Value + return nil +} +func (ma *_Commit__Assembler) KeyPrototype() ipld.NodePrototype { + return _String__Prototype{} +} +func (ma *_Commit__Assembler) ValuePrototype(k string) ipld.NodePrototype { + panic("todo structbuilder mapassembler valueprototype") +} +type _Commit__KeyAssembler _Commit__Assembler +func (_Commit__KeyAssembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { + return mixins.StringAssembler{"ipldgit.Commit.KeyAssembler"}.BeginMap(0) +} +func (_Commit__KeyAssembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { + return mixins.StringAssembler{"ipldgit.Commit.KeyAssembler"}.BeginList(0) +} +func (na *_Commit__KeyAssembler) AssignNull() error { + return mixins.StringAssembler{"ipldgit.Commit.KeyAssembler"}.AssignNull() +} +func (_Commit__KeyAssembler) AssignBool(bool) error { + return mixins.StringAssembler{"ipldgit.Commit.KeyAssembler"}.AssignBool(false) +} +func (_Commit__KeyAssembler) AssignInt(int64) error { + return mixins.StringAssembler{"ipldgit.Commit.KeyAssembler"}.AssignInt(0) +} +func (_Commit__KeyAssembler) AssignFloat(float64) error { + return mixins.StringAssembler{"ipldgit.Commit.KeyAssembler"}.AssignFloat(0) +} +func (ka *_Commit__KeyAssembler) AssignString(k string) error { + if ka.state != maState_midKey { + panic("misuse: KeyAssembler held beyond its valid lifetime") + } + switch k { + case "DataSize": + if ka.s & fieldBit__Commit_DataSize != 0 { + return ipld.ErrRepeatedMapKey{&fieldName__Commit_DataSize} + } + ka.s += fieldBit__Commit_DataSize + ka.state = maState_expectValue + ka.f = 0 + case "GitTree": + if ka.s & fieldBit__Commit_GitTree != 0 { + return ipld.ErrRepeatedMapKey{&fieldName__Commit_GitTree} + } + ka.s += fieldBit__Commit_GitTree + ka.state = maState_expectValue + ka.f = 1 + case "Parents": + if ka.s & fieldBit__Commit_Parents != 0 { + return ipld.ErrRepeatedMapKey{&fieldName__Commit_Parents} + } + ka.s += fieldBit__Commit_Parents + ka.state = maState_expectValue + ka.f = 2 + case "Message": + if ka.s & fieldBit__Commit_Message != 0 { + return ipld.ErrRepeatedMapKey{&fieldName__Commit_Message} + } + ka.s += fieldBit__Commit_Message + ka.state = maState_expectValue + ka.f = 3 + case "Author": + if ka.s & fieldBit__Commit_Author != 0 { + return ipld.ErrRepeatedMapKey{&fieldName__Commit_Author} + } + ka.s += fieldBit__Commit_Author + ka.state = maState_expectValue + ka.f = 4 + case "Committer": + if ka.s & fieldBit__Commit_Committer != 0 { + return ipld.ErrRepeatedMapKey{&fieldName__Commit_Committer} + } + ka.s += fieldBit__Commit_Committer + ka.state = maState_expectValue + ka.f = 5 + case "Encoding": + if ka.s & fieldBit__Commit_Encoding != 0 { + return ipld.ErrRepeatedMapKey{&fieldName__Commit_Encoding} + } + ka.s += fieldBit__Commit_Encoding + ka.state = maState_expectValue + ka.f = 6 + case "Sig": + if ka.s & fieldBit__Commit_Sig != 0 { + return ipld.ErrRepeatedMapKey{&fieldName__Commit_Sig} + } + ka.s += fieldBit__Commit_Sig + ka.state = maState_expectValue + ka.f = 7 + case "MergeTag": + if ka.s & fieldBit__Commit_MergeTag != 0 { + return ipld.ErrRepeatedMapKey{&fieldName__Commit_MergeTag} + } + ka.s += fieldBit__Commit_MergeTag + ka.state = maState_expectValue + ka.f = 8 + case "Other": + if ka.s & fieldBit__Commit_Other != 0 { + return ipld.ErrRepeatedMapKey{&fieldName__Commit_Other} + } + ka.s += fieldBit__Commit_Other + ka.state = maState_expectValue + ka.f = 9 + default: + return ipld.ErrInvalidKey{TypeName:"ipldgit.Commit", Key:&_String{k}} + } + return nil +} +func (_Commit__KeyAssembler) AssignBytes([]byte) error { + return mixins.StringAssembler{"ipldgit.Commit.KeyAssembler"}.AssignBytes(nil) +} +func (_Commit__KeyAssembler) AssignLink(ipld.Link) error { + return mixins.StringAssembler{"ipldgit.Commit.KeyAssembler"}.AssignLink(nil) +} +func (ka *_Commit__KeyAssembler) AssignNode(v ipld.Node) error { + if v2, err := v.AsString(); err != nil { + return err + } else { + return ka.AssignString(v2) + } +} +func (_Commit__KeyAssembler) Prototype() ipld.NodePrototype { + return _String__Prototype{} +} +func (Commit) Type() schema.Type { + return nil /*TODO:typelit*/ +} +func (n Commit) Representation() ipld.Node { + return (*_Commit__Repr)(n) +} +type _Commit__Repr _Commit +var ( + fieldName__Commit_DataSize_serial = _String{"DataSize"} + fieldName__Commit_GitTree_serial = _String{"GitTree"} + fieldName__Commit_Parents_serial = _String{"Parents"} + fieldName__Commit_Message_serial = _String{"Message"} + fieldName__Commit_Author_serial = _String{"Author"} + fieldName__Commit_Committer_serial = _String{"Committer"} + fieldName__Commit_Encoding_serial = _String{"Encoding"} + fieldName__Commit_Sig_serial = _String{"Sig"} + fieldName__Commit_MergeTag_serial = _String{"MergeTag"} + fieldName__Commit_Other_serial = _String{"Other"} +) +var _ ipld.Node = &_Commit__Repr{} +func (_Commit__Repr) Kind() ipld.Kind { + return ipld.Kind_Map +} +func (n *_Commit__Repr) LookupByString(key string) (ipld.Node, error) { + switch key { + case "DataSize": + return n.DataSize.Representation(), nil + case "GitTree": + return n.GitTree.Representation(), nil + case "Parents": + return n.Parents.Representation(), nil + case "Message": + return n.Message.Representation(), nil + case "Author": + if n.Author.m == schema.Maybe_Absent { + return ipld.Absent, ipld.ErrNotExists{ipld.PathSegmentOfString(key)} + } + return n.Author.v.Representation(), nil + case "Committer": + if n.Committer.m == schema.Maybe_Absent { + return ipld.Absent, ipld.ErrNotExists{ipld.PathSegmentOfString(key)} + } + return n.Committer.v.Representation(), nil + case "Encoding": + if n.Encoding.m == schema.Maybe_Absent { + return ipld.Absent, ipld.ErrNotExists{ipld.PathSegmentOfString(key)} + } + return n.Encoding.v.Representation(), nil + case "Sig": + if n.Sig.m == schema.Maybe_Absent { + return ipld.Absent, ipld.ErrNotExists{ipld.PathSegmentOfString(key)} + } + return n.Sig.v.Representation(), nil + case "MergeTag": + return n.MergeTag.Representation(), nil + case "Other": + return n.Other.Representation(), nil + default: + return nil, schema.ErrNoSuchField{Type: nil /*TODO*/, Field: ipld.PathSegmentOfString(key)} + } +} +func (n *_Commit__Repr) LookupByNode(key ipld.Node) (ipld.Node, error) { + ks, err := key.AsString() + if err != nil { + return nil, err + } + return n.LookupByString(ks) +} +func (_Commit__Repr) LookupByIndex(idx int64) (ipld.Node, error) { + return mixins.Map{"ipldgit.Commit.Repr"}.LookupByIndex(0) +} +func (n _Commit__Repr) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { + return n.LookupByString(seg.String()) +} +func (n *_Commit__Repr) MapIterator() ipld.MapIterator { + return &_Commit__ReprMapItr{n, 0} +} + +type _Commit__ReprMapItr struct { + n *_Commit__Repr + idx int + +} + +func (itr *_Commit__ReprMapItr) Next() (k ipld.Node, v ipld.Node, _ error) { +advance:if itr.idx >= 10 { + return nil, nil, ipld.ErrIteratorOverread{} + } + switch itr.idx { + case 0: + k = &fieldName__Commit_DataSize_serial + v = itr.n.DataSize.Representation() + case 1: + k = &fieldName__Commit_GitTree_serial + v = itr.n.GitTree.Representation() + case 2: + k = &fieldName__Commit_Parents_serial + v = itr.n.Parents.Representation() + case 3: + k = &fieldName__Commit_Message_serial + v = itr.n.Message.Representation() + case 4: + k = &fieldName__Commit_Author_serial + if itr.n.Author.m == schema.Maybe_Absent { + itr.idx++ + goto advance + } + v = itr.n.Author.v.Representation() + case 5: + k = &fieldName__Commit_Committer_serial + if itr.n.Committer.m == schema.Maybe_Absent { + itr.idx++ + goto advance + } + v = itr.n.Committer.v.Representation() + case 6: + k = &fieldName__Commit_Encoding_serial + if itr.n.Encoding.m == schema.Maybe_Absent { + itr.idx++ + goto advance + } + v = itr.n.Encoding.v.Representation() + case 7: + k = &fieldName__Commit_Sig_serial + if itr.n.Sig.m == schema.Maybe_Absent { + itr.idx++ + goto advance + } + v = itr.n.Sig.v.Representation() + case 8: + k = &fieldName__Commit_MergeTag_serial + v = itr.n.MergeTag.Representation() + case 9: + k = &fieldName__Commit_Other_serial + v = itr.n.Other.Representation() + default: + panic("unreachable") + } + itr.idx++ + return +} +func (itr *_Commit__ReprMapItr) Done() bool { + return itr.idx >= 10 +} +func (_Commit__Repr) ListIterator() ipld.ListIterator { + return nil +} +func (rn *_Commit__Repr) Length() int64 { + l := 10 + if rn.Author.m == schema.Maybe_Absent { + l-- + } + if rn.Committer.m == schema.Maybe_Absent { + l-- + } + if rn.Encoding.m == schema.Maybe_Absent { + l-- + } + if rn.Sig.m == schema.Maybe_Absent { + l-- + } + return int64(l) +} +func (_Commit__Repr) IsAbsent() bool { + return false +} +func (_Commit__Repr) IsNull() bool { + return false +} +func (_Commit__Repr) AsBool() (bool, error) { + return mixins.Map{"ipldgit.Commit.Repr"}.AsBool() +} +func (_Commit__Repr) AsInt() (int64, error) { + return mixins.Map{"ipldgit.Commit.Repr"}.AsInt() +} +func (_Commit__Repr) AsFloat() (float64, error) { + return mixins.Map{"ipldgit.Commit.Repr"}.AsFloat() +} +func (_Commit__Repr) AsString() (string, error) { + return mixins.Map{"ipldgit.Commit.Repr"}.AsString() +} +func (_Commit__Repr) AsBytes() ([]byte, error) { + return mixins.Map{"ipldgit.Commit.Repr"}.AsBytes() +} +func (_Commit__Repr) AsLink() (ipld.Link, error) { + return mixins.Map{"ipldgit.Commit.Repr"}.AsLink() +} +func (_Commit__Repr) Prototype() ipld.NodePrototype { + return _Commit__ReprPrototype{} +} +type _Commit__ReprPrototype struct{} + +func (_Commit__ReprPrototype) NewBuilder() ipld.NodeBuilder { + var nb _Commit__ReprBuilder + nb.Reset() + return &nb +} +type _Commit__ReprBuilder struct { + _Commit__ReprAssembler +} +func (nb *_Commit__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 *_Commit__ReprBuilder) Reset() { + var w _Commit + var m schema.Maybe + *nb = _Commit__ReprBuilder{_Commit__ReprAssembler{w: &w, m: &m}} +} +type _Commit__ReprAssembler struct { + w *_Commit + m *schema.Maybe + state maState + s int + f int + + cm schema.Maybe + ca_DataSize _String__ReprAssembler + ca_GitTree _LinkTree__ReprAssembler + ca_Parents _ListParents__ReprAssembler + ca_Message _String__ReprAssembler + ca_Author _PersonInfo__ReprAssembler + ca_Committer _PersonInfo__ReprAssembler + ca_Encoding _String__ReprAssembler + ca_Sig _GpgSig__ReprAssembler + ca_MergeTag _ListTag__ReprAssembler + ca_Other _ListString__ReprAssembler + } + +func (na *_Commit__ReprAssembler) reset() { + na.state = maState_initial + na.s = 0 + na.ca_DataSize.reset() + na.ca_GitTree.reset() + na.ca_Parents.reset() + na.ca_Message.reset() + na.ca_Author.reset() + na.ca_Committer.reset() + na.ca_Encoding.reset() + na.ca_Sig.reset() + na.ca_MergeTag.reset() + na.ca_Other.reset() +} +func (na *_Commit__ReprAssembler) BeginMap(int64) (ipld.MapAssembler, 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 na.w == nil { + na.w = &_Commit{} + } + return na, nil +} +func (_Commit__ReprAssembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { + return mixins.MapAssembler{"ipldgit.Commit.Repr"}.BeginList(0) +} +func (na *_Commit__ReprAssembler) AssignNull() error { + switch *na.m { + case allowNull: + *na.m = schema.Maybe_Null + return nil + case schema.Maybe_Absent: + return mixins.MapAssembler{"ipldgit.Commit.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 (_Commit__ReprAssembler) AssignBool(bool) error { + return mixins.MapAssembler{"ipldgit.Commit.Repr"}.AssignBool(false) +} +func (_Commit__ReprAssembler) AssignInt(int64) error { + return mixins.MapAssembler{"ipldgit.Commit.Repr"}.AssignInt(0) +} +func (_Commit__ReprAssembler) AssignFloat(float64) error { + return mixins.MapAssembler{"ipldgit.Commit.Repr"}.AssignFloat(0) +} +func (_Commit__ReprAssembler) AssignString(string) error { + return mixins.MapAssembler{"ipldgit.Commit.Repr"}.AssignString("") +} +func (_Commit__ReprAssembler) AssignBytes([]byte) error { + return mixins.MapAssembler{"ipldgit.Commit.Repr"}.AssignBytes(nil) +} +func (_Commit__ReprAssembler) AssignLink(ipld.Link) error { + return mixins.MapAssembler{"ipldgit.Commit.Repr"}.AssignLink(nil) +} +func (na *_Commit__ReprAssembler) AssignNode(v ipld.Node) error { + if v.IsNull() { + return na.AssignNull() + } + if v2, ok := v.(*_Commit); 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.Kind() != ipld.Kind_Map { + return ipld.ErrWrongKind{TypeName: "ipldgit.Commit.Repr", MethodName: "AssignNode", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()} + } + itr := v.MapIterator() + for !itr.Done() { + k, v, err := itr.Next() + if err != nil { + return err + } + if err := na.AssembleKey().AssignNode(k); err != nil { + return err + } + if err := na.AssembleValue().AssignNode(v); err != nil { + return err + } + } + return na.Finish() +} +func (_Commit__ReprAssembler) Prototype() ipld.NodePrototype { + return _Commit__ReprPrototype{} +} +func (ma *_Commit__ReprAssembler) valueFinishTidy() bool { + switch ma.f { + case 0: + switch ma.cm { + case schema.Maybe_Value:ma.cm = schema.Maybe_Absent + ma.state = maState_initial + return true + default: + return false + } + case 1: + switch ma.cm { + case schema.Maybe_Value:ma.cm = schema.Maybe_Absent + ma.state = maState_initial + return true + default: + return false + } + case 2: + switch ma.cm { + case schema.Maybe_Value:ma.cm = schema.Maybe_Absent + ma.state = maState_initial + return true + default: + return false + } + case 3: + switch ma.cm { + case schema.Maybe_Value:ma.cm = schema.Maybe_Absent + ma.state = maState_initial + return true + default: + return false + } + case 4: + switch ma.w.Author.m { + case schema.Maybe_Value: + ma.w.Author.v = ma.ca_Author.w + ma.state = maState_initial + return true + default: + return false + } + case 5: + switch ma.w.Committer.m { + case schema.Maybe_Value: + ma.w.Committer.v = ma.ca_Committer.w + ma.state = maState_initial + return true + default: + return false + } + case 6: + switch ma.w.Encoding.m { + case schema.Maybe_Value: + ma.w.Encoding.v = ma.ca_Encoding.w + ma.state = maState_initial + return true + default: + return false + } + case 7: + switch ma.w.Sig.m { + case schema.Maybe_Value: + ma.w.Sig.v = ma.ca_Sig.w + ma.state = maState_initial + return true + default: + return false + } + case 8: + switch ma.cm { + case schema.Maybe_Value:ma.cm = schema.Maybe_Absent + ma.state = maState_initial + return true + default: + return false + } + case 9: + switch ma.cm { + case schema.Maybe_Value:ma.cm = schema.Maybe_Absent + ma.state = maState_initial + return true + default: + return false + } + default: + panic("unreachable") + } +} +func (ma *_Commit__ReprAssembler) AssembleEntry(k string) (ipld.NodeAssembler, error) { + switch ma.state { + case maState_initial: + // carry on + case maState_midKey: + panic("invalid state: AssembleEntry cannot be called when in the middle of assembling another key") + case maState_expectValue: + panic("invalid state: AssembleEntry cannot be called when expecting start of value assembly") + case maState_midValue: + if !ma.valueFinishTidy() { + panic("invalid state: AssembleEntry cannot be called when in the middle of assembling a value") + } // if tidy success: carry on + case maState_finished: + panic("invalid state: AssembleEntry cannot be called on an assembler that's already finished") + } + switch k { + case "DataSize": + if ma.s & fieldBit__Commit_DataSize != 0 { + return nil, ipld.ErrRepeatedMapKey{&fieldName__Commit_DataSize_serial} + } + ma.s += fieldBit__Commit_DataSize + ma.state = maState_midValue + ma.f = 0 + ma.ca_DataSize.w = &ma.w.DataSize + ma.ca_DataSize.m = &ma.cm + return &ma.ca_DataSize, nil + case "GitTree": + if ma.s & fieldBit__Commit_GitTree != 0 { + return nil, ipld.ErrRepeatedMapKey{&fieldName__Commit_GitTree_serial} + } + ma.s += fieldBit__Commit_GitTree + ma.state = maState_midValue + ma.f = 1 + ma.ca_GitTree.w = &ma.w.GitTree + ma.ca_GitTree.m = &ma.cm + return &ma.ca_GitTree, nil + case "Parents": + if ma.s & fieldBit__Commit_Parents != 0 { + return nil, ipld.ErrRepeatedMapKey{&fieldName__Commit_Parents_serial} + } + ma.s += fieldBit__Commit_Parents + ma.state = maState_midValue + ma.f = 2 + ma.ca_Parents.w = &ma.w.Parents + ma.ca_Parents.m = &ma.cm + return &ma.ca_Parents, nil + case "Message": + if ma.s & fieldBit__Commit_Message != 0 { + return nil, ipld.ErrRepeatedMapKey{&fieldName__Commit_Message_serial} + } + ma.s += fieldBit__Commit_Message + ma.state = maState_midValue + ma.f = 3 + ma.ca_Message.w = &ma.w.Message + ma.ca_Message.m = &ma.cm + return &ma.ca_Message, nil + case "Author": + if ma.s & fieldBit__Commit_Author != 0 { + return nil, ipld.ErrRepeatedMapKey{&fieldName__Commit_Author_serial} + } + ma.s += fieldBit__Commit_Author + ma.state = maState_midValue + ma.f = 4 + ma.ca_Author.w = ma.w.Author.v + ma.ca_Author.m = &ma.w.Author.m + + return &ma.ca_Author, nil + case "Committer": + if ma.s & fieldBit__Commit_Committer != 0 { + return nil, ipld.ErrRepeatedMapKey{&fieldName__Commit_Committer_serial} + } + ma.s += fieldBit__Commit_Committer + ma.state = maState_midValue + ma.f = 5 + ma.ca_Committer.w = ma.w.Committer.v + ma.ca_Committer.m = &ma.w.Committer.m + + return &ma.ca_Committer, nil + case "Encoding": + if ma.s & fieldBit__Commit_Encoding != 0 { + return nil, ipld.ErrRepeatedMapKey{&fieldName__Commit_Encoding_serial} + } + ma.s += fieldBit__Commit_Encoding + ma.state = maState_midValue + ma.f = 6 + ma.ca_Encoding.w = ma.w.Encoding.v + ma.ca_Encoding.m = &ma.w.Encoding.m + + return &ma.ca_Encoding, nil + case "Sig": + if ma.s & fieldBit__Commit_Sig != 0 { + return nil, ipld.ErrRepeatedMapKey{&fieldName__Commit_Sig_serial} + } + ma.s += fieldBit__Commit_Sig + ma.state = maState_midValue + ma.f = 7 + ma.ca_Sig.w = ma.w.Sig.v + ma.ca_Sig.m = &ma.w.Sig.m + + return &ma.ca_Sig, nil + case "MergeTag": + if ma.s & fieldBit__Commit_MergeTag != 0 { + return nil, ipld.ErrRepeatedMapKey{&fieldName__Commit_MergeTag_serial} + } + ma.s += fieldBit__Commit_MergeTag + ma.state = maState_midValue + ma.f = 8 + ma.ca_MergeTag.w = &ma.w.MergeTag + ma.ca_MergeTag.m = &ma.cm + return &ma.ca_MergeTag, nil + case "Other": + if ma.s & fieldBit__Commit_Other != 0 { + return nil, ipld.ErrRepeatedMapKey{&fieldName__Commit_Other_serial} + } + ma.s += fieldBit__Commit_Other + ma.state = maState_midValue + ma.f = 9 + ma.ca_Other.w = &ma.w.Other + ma.ca_Other.m = &ma.cm + return &ma.ca_Other, nil + default: + return nil, ipld.ErrInvalidKey{TypeName:"ipldgit.Commit.Repr", Key:&_String{k}} + } +} +func (ma *_Commit__ReprAssembler) AssembleKey() ipld.NodeAssembler { + switch ma.state { + case maState_initial: + // carry on + case maState_midKey: + panic("invalid state: AssembleKey cannot be called when in the middle of assembling another key") + case maState_expectValue: + panic("invalid state: AssembleKey cannot be called when expecting start of value assembly") + case maState_midValue: + if !ma.valueFinishTidy() { + panic("invalid state: AssembleKey cannot be called when in the middle of assembling a value") + } // if tidy success: carry on + case maState_finished: + panic("invalid state: AssembleKey cannot be called on an assembler that's already finished") + } + ma.state = maState_midKey + return (*_Commit__ReprKeyAssembler)(ma) +} +func (ma *_Commit__ReprAssembler) AssembleValue() ipld.NodeAssembler { + switch ma.state { + case maState_initial: + panic("invalid state: AssembleValue cannot be called when no key is primed") + case maState_midKey: + panic("invalid state: AssembleValue cannot be called when in the middle of assembling a key") + case maState_expectValue: + // carry on + case maState_midValue: + panic("invalid state: AssembleValue cannot be called when in the middle of assembling another value") + case maState_finished: + panic("invalid state: AssembleValue cannot be called on an assembler that's already finished") + } + ma.state = maState_midValue + switch ma.f { + case 0: + ma.ca_DataSize.w = &ma.w.DataSize + ma.ca_DataSize.m = &ma.cm + return &ma.ca_DataSize + case 1: + ma.ca_GitTree.w = &ma.w.GitTree + ma.ca_GitTree.m = &ma.cm + return &ma.ca_GitTree + case 2: + ma.ca_Parents.w = &ma.w.Parents + ma.ca_Parents.m = &ma.cm + return &ma.ca_Parents + case 3: + ma.ca_Message.w = &ma.w.Message + ma.ca_Message.m = &ma.cm + return &ma.ca_Message + case 4: + ma.ca_Author.w = ma.w.Author.v + ma.ca_Author.m = &ma.w.Author.m + + return &ma.ca_Author + case 5: + ma.ca_Committer.w = ma.w.Committer.v + ma.ca_Committer.m = &ma.w.Committer.m + + return &ma.ca_Committer + case 6: + ma.ca_Encoding.w = ma.w.Encoding.v + ma.ca_Encoding.m = &ma.w.Encoding.m + + return &ma.ca_Encoding + case 7: + ma.ca_Sig.w = ma.w.Sig.v + ma.ca_Sig.m = &ma.w.Sig.m + + return &ma.ca_Sig + case 8: + ma.ca_MergeTag.w = &ma.w.MergeTag + ma.ca_MergeTag.m = &ma.cm + return &ma.ca_MergeTag + case 9: + ma.ca_Other.w = &ma.w.Other + ma.ca_Other.m = &ma.cm + return &ma.ca_Other + default: + panic("unreachable") + } +} +func (ma *_Commit__ReprAssembler) Finish() error { + switch ma.state { + case maState_initial: + // carry on + case maState_midKey: + panic("invalid state: Finish cannot be called when in the middle of assembling a key") + case maState_expectValue: + panic("invalid state: Finish cannot be called when expecting start of value assembly") + case maState_midValue: + if !ma.valueFinishTidy() { + panic("invalid state: Finish cannot be called when in the middle of assembling a value") + } // if tidy success: carry on + case maState_finished: + panic("invalid state: Finish cannot be called on an assembler that's already finished") + } + if ma.s & fieldBits__Commit_sufficient != fieldBits__Commit_sufficient { + err := ipld.ErrMissingRequiredField{Missing: make([]string, 0)} + if ma.s & fieldBit__Commit_DataSize == 0 { + err.Missing = append(err.Missing, "DataSize") + } + if ma.s & fieldBit__Commit_GitTree == 0 { + err.Missing = append(err.Missing, "GitTree") + } + if ma.s & fieldBit__Commit_Parents == 0 { + err.Missing = append(err.Missing, "Parents") + } + if ma.s & fieldBit__Commit_Message == 0 { + err.Missing = append(err.Missing, "Message") + } + if ma.s & fieldBit__Commit_MergeTag == 0 { + err.Missing = append(err.Missing, "MergeTag") + } + if ma.s & fieldBit__Commit_Other == 0 { + err.Missing = append(err.Missing, "Other") + } + return err + } + ma.state = maState_finished + *ma.m = schema.Maybe_Value + return nil +} +func (ma *_Commit__ReprAssembler) KeyPrototype() ipld.NodePrototype { + return _String__Prototype{} +} +func (ma *_Commit__ReprAssembler) ValuePrototype(k string) ipld.NodePrototype { + panic("todo structbuilder mapassembler repr valueprototype") +} +type _Commit__ReprKeyAssembler _Commit__ReprAssembler +func (_Commit__ReprKeyAssembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { + return mixins.StringAssembler{"ipldgit.Commit.Repr.KeyAssembler"}.BeginMap(0) +} +func (_Commit__ReprKeyAssembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { + return mixins.StringAssembler{"ipldgit.Commit.Repr.KeyAssembler"}.BeginList(0) +} +func (na *_Commit__ReprKeyAssembler) AssignNull() error { + return mixins.StringAssembler{"ipldgit.Commit.Repr.KeyAssembler"}.AssignNull() +} +func (_Commit__ReprKeyAssembler) AssignBool(bool) error { + return mixins.StringAssembler{"ipldgit.Commit.Repr.KeyAssembler"}.AssignBool(false) +} +func (_Commit__ReprKeyAssembler) AssignInt(int64) error { + return mixins.StringAssembler{"ipldgit.Commit.Repr.KeyAssembler"}.AssignInt(0) +} +func (_Commit__ReprKeyAssembler) AssignFloat(float64) error { + return mixins.StringAssembler{"ipldgit.Commit.Repr.KeyAssembler"}.AssignFloat(0) +} +func (ka *_Commit__ReprKeyAssembler) AssignString(k string) error { + if ka.state != maState_midKey { + panic("misuse: KeyAssembler held beyond its valid lifetime") + } + switch k { + case "DataSize": + if ka.s & fieldBit__Commit_DataSize != 0 { + return ipld.ErrRepeatedMapKey{&fieldName__Commit_DataSize_serial} + } + ka.s += fieldBit__Commit_DataSize + ka.state = maState_expectValue + ka.f = 0 + case "GitTree": + if ka.s & fieldBit__Commit_GitTree != 0 { + return ipld.ErrRepeatedMapKey{&fieldName__Commit_GitTree_serial} + } + ka.s += fieldBit__Commit_GitTree + ka.state = maState_expectValue + ka.f = 1 + case "Parents": + if ka.s & fieldBit__Commit_Parents != 0 { + return ipld.ErrRepeatedMapKey{&fieldName__Commit_Parents_serial} + } + ka.s += fieldBit__Commit_Parents + ka.state = maState_expectValue + ka.f = 2 + case "Message": + if ka.s & fieldBit__Commit_Message != 0 { + return ipld.ErrRepeatedMapKey{&fieldName__Commit_Message_serial} + } + ka.s += fieldBit__Commit_Message + ka.state = maState_expectValue + ka.f = 3 + case "Author": + if ka.s & fieldBit__Commit_Author != 0 { + return ipld.ErrRepeatedMapKey{&fieldName__Commit_Author_serial} + } + ka.s += fieldBit__Commit_Author + ka.state = maState_expectValue + ka.f = 4 + case "Committer": + if ka.s & fieldBit__Commit_Committer != 0 { + return ipld.ErrRepeatedMapKey{&fieldName__Commit_Committer_serial} + } + ka.s += fieldBit__Commit_Committer + ka.state = maState_expectValue + ka.f = 5 + case "Encoding": + if ka.s & fieldBit__Commit_Encoding != 0 { + return ipld.ErrRepeatedMapKey{&fieldName__Commit_Encoding_serial} + } + ka.s += fieldBit__Commit_Encoding + ka.state = maState_expectValue + ka.f = 6 + case "Sig": + if ka.s & fieldBit__Commit_Sig != 0 { + return ipld.ErrRepeatedMapKey{&fieldName__Commit_Sig_serial} + } + ka.s += fieldBit__Commit_Sig + ka.state = maState_expectValue + ka.f = 7 + case "MergeTag": + if ka.s & fieldBit__Commit_MergeTag != 0 { + return ipld.ErrRepeatedMapKey{&fieldName__Commit_MergeTag_serial} + } + ka.s += fieldBit__Commit_MergeTag + ka.state = maState_expectValue + ka.f = 8 + case "Other": + if ka.s & fieldBit__Commit_Other != 0 { + return ipld.ErrRepeatedMapKey{&fieldName__Commit_Other_serial} + } + ka.s += fieldBit__Commit_Other + ka.state = maState_expectValue + ka.f = 9 + default: + return ipld.ErrInvalidKey{TypeName:"ipldgit.Commit.Repr", Key:&_String{k}} + } + return nil +} +func (_Commit__ReprKeyAssembler) AssignBytes([]byte) error { + return mixins.StringAssembler{"ipldgit.Commit.Repr.KeyAssembler"}.AssignBytes(nil) +} +func (_Commit__ReprKeyAssembler) AssignLink(ipld.Link) error { + return mixins.StringAssembler{"ipldgit.Commit.Repr.KeyAssembler"}.AssignLink(nil) +} +func (ka *_Commit__ReprKeyAssembler) AssignNode(v ipld.Node) error { + if v2, err := v.AsString(); err != nil { + return err + } else { + return ka.AssignString(v2) + } +} +func (_Commit__ReprKeyAssembler) Prototype() ipld.NodePrototype { + return _String__Prototype{} +} + +func (n GpgSig) String() string { + return n.x +} +func (_GpgSig__Prototype) fromString(w *_GpgSig, v string) error { + *w = _GpgSig{v} + return nil +} +func (_GpgSig__Prototype) FromString(v string) (GpgSig, error) { + n := _GpgSig{v} + return &n, nil +} +type _GpgSig__Maybe struct { + m schema.Maybe + v GpgSig +} +type MaybeGpgSig = *_GpgSig__Maybe + +func (m MaybeGpgSig) IsNull() bool { + return m.m == schema.Maybe_Null +} +func (m MaybeGpgSig) IsAbsent() bool { + return m.m == schema.Maybe_Absent +} +func (m MaybeGpgSig) Exists() bool { + return m.m == schema.Maybe_Value +} +func (m MaybeGpgSig) 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 MaybeGpgSig) Must() GpgSig { + if !m.Exists() { + panic("unbox of a maybe rejected") + } + return m.v +} +var _ ipld.Node = (GpgSig)(&_GpgSig{}) +var _ schema.TypedNode = (GpgSig)(&_GpgSig{}) +func (GpgSig) Kind() ipld.Kind { + return ipld.Kind_String +} +func (GpgSig) LookupByString(string) (ipld.Node, error) { + return mixins.String{"ipldgit.GpgSig"}.LookupByString("") +} +func (GpgSig) LookupByNode(ipld.Node) (ipld.Node, error) { + return mixins.String{"ipldgit.GpgSig"}.LookupByNode(nil) +} +func (GpgSig) LookupByIndex(idx int64) (ipld.Node, error) { + return mixins.String{"ipldgit.GpgSig"}.LookupByIndex(0) +} +func (GpgSig) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { + return mixins.String{"ipldgit.GpgSig"}.LookupBySegment(seg) +} +func (GpgSig) MapIterator() ipld.MapIterator { + return nil +} +func (GpgSig) ListIterator() ipld.ListIterator { + return nil +} +func (GpgSig) Length() int64 { + return -1 +} +func (GpgSig) IsAbsent() bool { + return false +} +func (GpgSig) IsNull() bool { + return false +} +func (GpgSig) AsBool() (bool, error) { + return mixins.String{"ipldgit.GpgSig"}.AsBool() +} +func (GpgSig) AsInt() (int64, error) { + return mixins.String{"ipldgit.GpgSig"}.AsInt() +} +func (GpgSig) AsFloat() (float64, error) { + return mixins.String{"ipldgit.GpgSig"}.AsFloat() +} +func (n GpgSig) AsString() (string, error) { + return n.x, nil +} +func (GpgSig) AsBytes() ([]byte, error) { + return mixins.String{"ipldgit.GpgSig"}.AsBytes() +} +func (GpgSig) AsLink() (ipld.Link, error) { + return mixins.String{"ipldgit.GpgSig"}.AsLink() +} +func (GpgSig) Prototype() ipld.NodePrototype { + return _GpgSig__Prototype{} +} +type _GpgSig__Prototype struct{} + +func (_GpgSig__Prototype) NewBuilder() ipld.NodeBuilder { + var nb _GpgSig__Builder + nb.Reset() + return &nb +} +type _GpgSig__Builder struct { + _GpgSig__Assembler +} +func (nb *_GpgSig__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 *_GpgSig__Builder) Reset() { + var w _GpgSig + var m schema.Maybe + *nb = _GpgSig__Builder{_GpgSig__Assembler{w: &w, m: &m}} +} +type _GpgSig__Assembler struct { + w *_GpgSig + m *schema.Maybe +} + +func (na *_GpgSig__Assembler) reset() {} +func (_GpgSig__Assembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { + return mixins.StringAssembler{"ipldgit.GpgSig"}.BeginMap(0) +} +func (_GpgSig__Assembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { + return mixins.StringAssembler{"ipldgit.GpgSig"}.BeginList(0) +} +func (na *_GpgSig__Assembler) AssignNull() error { + switch *na.m { + case allowNull: + *na.m = schema.Maybe_Null + return nil + case schema.Maybe_Absent: + return mixins.StringAssembler{"ipldgit.GpgSig"}.AssignNull() + case schema.Maybe_Value, schema.Maybe_Null: + panic("invalid state: cannot assign into assembler that's already finished") + } + panic("unreachable") +} +func (_GpgSig__Assembler) AssignBool(bool) error { + return mixins.StringAssembler{"ipldgit.GpgSig"}.AssignBool(false) +} +func (_GpgSig__Assembler) AssignInt(int64) error { + return mixins.StringAssembler{"ipldgit.GpgSig"}.AssignInt(0) +} +func (_GpgSig__Assembler) AssignFloat(float64) error { + return mixins.StringAssembler{"ipldgit.GpgSig"}.AssignFloat(0) +} +func (na *_GpgSig__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 = &_GpgSig{} + } + na.w.x = v + *na.m = schema.Maybe_Value + return nil +} +func (_GpgSig__Assembler) AssignBytes([]byte) error { + return mixins.StringAssembler{"ipldgit.GpgSig"}.AssignBytes(nil) +} +func (_GpgSig__Assembler) AssignLink(ipld.Link) error { + return mixins.StringAssembler{"ipldgit.GpgSig"}.AssignLink(nil) +} +func (na *_GpgSig__Assembler) AssignNode(v ipld.Node) error { + if v.IsNull() { + return na.AssignNull() + } + if v2, ok := v.(*_GpgSig); 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 (_GpgSig__Assembler) Prototype() ipld.NodePrototype { + return _GpgSig__Prototype{} +} +func (GpgSig) Type() schema.Type { + return nil /*TODO:typelit*/ +} +func (n GpgSig) Representation() ipld.Node { + return (*_GpgSig__Repr)(n) +} +type _GpgSig__Repr = _GpgSig +var _ ipld.Node = &_GpgSig__Repr{} +type _GpgSig__ReprPrototype = _GpgSig__Prototype +type _GpgSig__ReprAssembler = _GpgSig__Assembler + +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) Kind() ipld.Kind { + return ipld.Kind_Link +} +func (Link) LookupByString(string) (ipld.Node, error) { + return mixins.Link{"ipldgit.Link"}.LookupByString("") +} +func (Link) LookupByNode(ipld.Node) (ipld.Node, error) { + return mixins.Link{"ipldgit.Link"}.LookupByNode(nil) +} +func (Link) LookupByIndex(idx int64) (ipld.Node, error) { + return mixins.Link{"ipldgit.Link"}.LookupByIndex(0) +} +func (Link) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { + return mixins.Link{"ipldgit.Link"}.LookupBySegment(seg) +} +func (Link) MapIterator() ipld.MapIterator { + return nil +} +func (Link) ListIterator() ipld.ListIterator { + return nil +} +func (Link) Length() int64 { + return -1 +} +func (Link) IsAbsent() bool { + return false +} +func (Link) IsNull() bool { + return false +} +func (Link) AsBool() (bool, error) { + return mixins.Link{"ipldgit.Link"}.AsBool() +} +func (Link) AsInt() (int64, error) { + return mixins.Link{"ipldgit.Link"}.AsInt() +} +func (Link) AsFloat() (float64, error) { + return mixins.Link{"ipldgit.Link"}.AsFloat() +} +func (Link) AsString() (string, error) { + return mixins.Link{"ipldgit.Link"}.AsString() +} +func (Link) AsBytes() ([]byte, error) { + return mixins.Link{"ipldgit.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 int64) (ipld.MapAssembler, error) { + return mixins.LinkAssembler{"ipldgit.Link"}.BeginMap(0) +} +func (_Link__Assembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { + return mixins.LinkAssembler{"ipldgit.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{"ipldgit.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{"ipldgit.Link"}.AssignBool(false) +} +func (_Link__Assembler) AssignInt(int64) error { + return mixins.LinkAssembler{"ipldgit.Link"}.AssignInt(0) +} +func (_Link__Assembler) AssignFloat(float64) error { + return mixins.LinkAssembler{"ipldgit.Link"}.AssignFloat(0) +} +func (_Link__Assembler) AssignString(string) error { + return mixins.LinkAssembler{"ipldgit.Link"}.AssignString("") +} +func (_Link__Assembler) AssignBytes([]byte) error { + return mixins.LinkAssembler{"ipldgit.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 + +func (n LinkTree) Link() ipld.Link { + return n.x +} +func (_LinkTree__Prototype) FromLink(v ipld.Link) (LinkTree, error) { + n := _LinkTree{v} + return &n, nil +} +type _LinkTree__Maybe struct { + m schema.Maybe + v LinkTree +} +type MaybeLinkTree = *_LinkTree__Maybe + +func (m MaybeLinkTree) IsNull() bool { + return m.m == schema.Maybe_Null +} +func (m MaybeLinkTree) IsAbsent() bool { + return m.m == schema.Maybe_Absent +} +func (m MaybeLinkTree) Exists() bool { + return m.m == schema.Maybe_Value +} +func (m MaybeLinkTree) 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 MaybeLinkTree) Must() LinkTree { + if !m.Exists() { + panic("unbox of a maybe rejected") + } + return m.v +} +var _ ipld.Node = (LinkTree)(&_LinkTree{}) +var _ schema.TypedNode = (LinkTree)(&_LinkTree{}) +func (LinkTree) Kind() ipld.Kind { + return ipld.Kind_Link +} +func (LinkTree) LookupByString(string) (ipld.Node, error) { + return mixins.Link{"ipldgit.LinkTree"}.LookupByString("") +} +func (LinkTree) LookupByNode(ipld.Node) (ipld.Node, error) { + return mixins.Link{"ipldgit.LinkTree"}.LookupByNode(nil) +} +func (LinkTree) LookupByIndex(idx int64) (ipld.Node, error) { + return mixins.Link{"ipldgit.LinkTree"}.LookupByIndex(0) +} +func (LinkTree) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { + return mixins.Link{"ipldgit.LinkTree"}.LookupBySegment(seg) +} +func (LinkTree) MapIterator() ipld.MapIterator { + return nil +} +func (LinkTree) ListIterator() ipld.ListIterator { + return nil +} +func (LinkTree) Length() int64 { + return -1 +} +func (LinkTree) IsAbsent() bool { + return false +} +func (LinkTree) IsNull() bool { + return false +} +func (LinkTree) AsBool() (bool, error) { + return mixins.Link{"ipldgit.LinkTree"}.AsBool() +} +func (LinkTree) AsInt() (int64, error) { + return mixins.Link{"ipldgit.LinkTree"}.AsInt() +} +func (LinkTree) AsFloat() (float64, error) { + return mixins.Link{"ipldgit.LinkTree"}.AsFloat() +} +func (LinkTree) AsString() (string, error) { + return mixins.Link{"ipldgit.LinkTree"}.AsString() +} +func (LinkTree) AsBytes() ([]byte, error) { + return mixins.Link{"ipldgit.LinkTree"}.AsBytes() +} +func (n LinkTree) AsLink() (ipld.Link, error) { + return n.x, nil +} +func (LinkTree) Prototype() ipld.NodePrototype { + return _LinkTree__Prototype{} +} +type _LinkTree__Prototype struct{} + +func (_LinkTree__Prototype) NewBuilder() ipld.NodeBuilder { + var nb _LinkTree__Builder + nb.Reset() + return &nb +} +type _LinkTree__Builder struct { + _LinkTree__Assembler +} +func (nb *_LinkTree__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 *_LinkTree__Builder) Reset() { + var w _LinkTree + var m schema.Maybe + *nb = _LinkTree__Builder{_LinkTree__Assembler{w: &w, m: &m}} +} +type _LinkTree__Assembler struct { + w *_LinkTree + m *schema.Maybe +} + +func (na *_LinkTree__Assembler) reset() {} +func (_LinkTree__Assembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { + return mixins.LinkAssembler{"ipldgit.LinkTree"}.BeginMap(0) +} +func (_LinkTree__Assembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { + return mixins.LinkAssembler{"ipldgit.LinkTree"}.BeginList(0) +} +func (na *_LinkTree__Assembler) AssignNull() error { + switch *na.m { + case allowNull: + *na.m = schema.Maybe_Null + return nil + case schema.Maybe_Absent: + return mixins.LinkAssembler{"ipldgit.LinkTree"}.AssignNull() + case schema.Maybe_Value, schema.Maybe_Null: + panic("invalid state: cannot assign into assembler that's already finished") + } + panic("unreachable") +} +func (_LinkTree__Assembler) AssignBool(bool) error { + return mixins.LinkAssembler{"ipldgit.LinkTree"}.AssignBool(false) +} +func (_LinkTree__Assembler) AssignInt(int64) error { + return mixins.LinkAssembler{"ipldgit.LinkTree"}.AssignInt(0) +} +func (_LinkTree__Assembler) AssignFloat(float64) error { + return mixins.LinkAssembler{"ipldgit.LinkTree"}.AssignFloat(0) +} +func (_LinkTree__Assembler) AssignString(string) error { + return mixins.LinkAssembler{"ipldgit.LinkTree"}.AssignString("") +} +func (_LinkTree__Assembler) AssignBytes([]byte) error { + return mixins.LinkAssembler{"ipldgit.LinkTree"}.AssignBytes(nil) +} +func (na *_LinkTree__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 = &_LinkTree{} + } + na.w.x = v + *na.m = schema.Maybe_Value + return nil +} +func (na *_LinkTree__Assembler) AssignNode(v ipld.Node) error { + if v.IsNull() { + return na.AssignNull() + } + if v2, ok := v.(*_LinkTree); 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 (_LinkTree__Assembler) Prototype() ipld.NodePrototype { + return _LinkTree__Prototype{} +} +func (LinkTree) Type() schema.Type { + return nil /*TODO:typelit*/ +} +func (LinkTree) LinkTargetNodePrototype() ipld.NodePrototype { + return Type.LinkTree__Repr +} +func (n LinkTree) Representation() ipld.Node { + return (*_LinkTree__Repr)(n) +} +type _LinkTree__Repr = _LinkTree +var _ ipld.Node = &_LinkTree__Repr{} +type _LinkTree__ReprPrototype = _LinkTree__Prototype +type _LinkTree__ReprAssembler = _LinkTree__Assembler + +func (n *_ListParents) Lookup(idx int64) Link { + if n.Length() <= idx { + return nil + } + v := &n.x[idx] + return v +} +func (n *_ListParents) LookupMaybe(idx int64) MaybeLink { + if n.Length() <= idx { + return nil + } + v := &n.x[idx] + return &_Link__Maybe{ + m: schema.Maybe_Value, + v: v, + } +} + +var _ListParents__valueAbsent = _Link__Maybe{m:schema.Maybe_Absent} +func (n ListParents) Iterator() *ListParents__Itr { + return &ListParents__Itr{n, 0} +} + +type ListParents__Itr struct { + n ListParents + idx int +} + +func (itr *ListParents__Itr) Next() (idx int64, v Link) { + if itr.idx >= len(itr.n.x) { + return -1, nil + } + idx = int64(itr.idx) + v = &itr.n.x[itr.idx] + itr.idx++ + return +} +func (itr *ListParents__Itr) Done() bool { + return itr.idx >= len(itr.n.x) +} + +type _ListParents__Maybe struct { + m schema.Maybe + v ListParents +} +type MaybeListParents = *_ListParents__Maybe + +func (m MaybeListParents) IsNull() bool { + return m.m == schema.Maybe_Null +} +func (m MaybeListParents) IsAbsent() bool { + return m.m == schema.Maybe_Absent +} +func (m MaybeListParents) Exists() bool { + return m.m == schema.Maybe_Value +} +func (m MaybeListParents) 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 MaybeListParents) Must() ListParents { + if !m.Exists() { + panic("unbox of a maybe rejected") + } + return m.v +} +var _ ipld.Node = (ListParents)(&_ListParents{}) +var _ schema.TypedNode = (ListParents)(&_ListParents{}) +func (ListParents) Kind() ipld.Kind { + return ipld.Kind_List +} +func (ListParents) LookupByString(string) (ipld.Node, error) { + return mixins.List{"ipldgit.ListParents"}.LookupByString("") +} +func (n ListParents) LookupByNode(k ipld.Node) (ipld.Node, error) { + idx, err := k.AsInt() + if err != nil { + return nil, err + } + return n.LookupByIndex(idx) +} +func (n ListParents) LookupByIndex(idx int64) (ipld.Node, error) { + if n.Length() <= idx { + return nil, ipld.ErrNotExists{ipld.PathSegmentOfInt(idx)} + } + v := &n.x[idx] + return v, nil +} +func (n ListParents) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { + i, err := seg.Index() + if err != nil { + return nil, ipld.ErrInvalidSegmentForList{TypeName: "ipldgit.ListParents", TroubleSegment: seg, Reason: err} + } + return n.LookupByIndex(i) +} +func (ListParents) MapIterator() ipld.MapIterator { + return nil +} +func (n ListParents) ListIterator() ipld.ListIterator { + return &_ListParents__ListItr{n, 0} +} + +type _ListParents__ListItr struct { + n ListParents + idx int +} + +func (itr *_ListParents__ListItr) Next() (idx int64, v ipld.Node, _ error) { + if itr.idx >= len(itr.n.x) { + return -1, nil, ipld.ErrIteratorOverread{} + } + idx = int64(itr.idx) + x := &itr.n.x[itr.idx] + v = x + itr.idx++ + return +} +func (itr *_ListParents__ListItr) Done() bool { + return itr.idx >= len(itr.n.x) +} + +func (n ListParents) Length() int64 { + return int64(len(n.x)) +} +func (ListParents) IsAbsent() bool { + return false +} +func (ListParents) IsNull() bool { + return false +} +func (ListParents) AsBool() (bool, error) { + return mixins.List{"ipldgit.ListParents"}.AsBool() +} +func (ListParents) AsInt() (int64, error) { + return mixins.List{"ipldgit.ListParents"}.AsInt() +} +func (ListParents) AsFloat() (float64, error) { + return mixins.List{"ipldgit.ListParents"}.AsFloat() +} +func (ListParents) AsString() (string, error) { + return mixins.List{"ipldgit.ListParents"}.AsString() +} +func (ListParents) AsBytes() ([]byte, error) { + return mixins.List{"ipldgit.ListParents"}.AsBytes() +} +func (ListParents) AsLink() (ipld.Link, error) { + return mixins.List{"ipldgit.ListParents"}.AsLink() +} +func (ListParents) Prototype() ipld.NodePrototype { + return _ListParents__Prototype{} +} +type _ListParents__Prototype struct{} + +func (_ListParents__Prototype) NewBuilder() ipld.NodeBuilder { + var nb _ListParents__Builder + nb.Reset() + return &nb +} +type _ListParents__Builder struct { + _ListParents__Assembler +} +func (nb *_ListParents__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 *_ListParents__Builder) Reset() { + var w _ListParents + var m schema.Maybe + *nb = _ListParents__Builder{_ListParents__Assembler{w: &w, m: &m}} +} +type _ListParents__Assembler struct { + w *_ListParents + m *schema.Maybe + state laState + + cm schema.Maybe + va _Link__Assembler +} + +func (na *_ListParents__Assembler) reset() { + na.state = laState_initial + na.va.reset() +} +func (_ListParents__Assembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { + return mixins.ListAssembler{"ipldgit.ListParents"}.BeginMap(0) +} +func (na *_ListParents__Assembler) BeginList(sizeHint int64) (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 = &_ListParents{} + } + if sizeHint > 0 { + na.w.x = make([]_Link, 0, sizeHint) + } + return na, nil +} +func (na *_ListParents__Assembler) AssignNull() error { + switch *na.m { + case allowNull: + *na.m = schema.Maybe_Null + return nil + case schema.Maybe_Absent: + return mixins.ListAssembler{"ipldgit.ListParents"}.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 (_ListParents__Assembler) AssignBool(bool) error { + return mixins.ListAssembler{"ipldgit.ListParents"}.AssignBool(false) +} +func (_ListParents__Assembler) AssignInt(int64) error { + return mixins.ListAssembler{"ipldgit.ListParents"}.AssignInt(0) +} +func (_ListParents__Assembler) AssignFloat(float64) error { + return mixins.ListAssembler{"ipldgit.ListParents"}.AssignFloat(0) +} +func (_ListParents__Assembler) AssignString(string) error { + return mixins.ListAssembler{"ipldgit.ListParents"}.AssignString("") +} +func (_ListParents__Assembler) AssignBytes([]byte) error { + return mixins.ListAssembler{"ipldgit.ListParents"}.AssignBytes(nil) +} +func (_ListParents__Assembler) AssignLink(ipld.Link) error { + return mixins.ListAssembler{"ipldgit.ListParents"}.AssignLink(nil) +} +func (na *_ListParents__Assembler) AssignNode(v ipld.Node) error { + if v.IsNull() { + return na.AssignNull() + } + if v2, ok := v.(*_ListParents); 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.Kind() != ipld.Kind_List { + return ipld.ErrWrongKind{TypeName: "ipldgit.ListParents", MethodName: "AssignNode", AppropriateKind: ipld.KindSet_JustList, ActualKind: v.Kind()} + } + 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 (_ListParents__Assembler) Prototype() ipld.NodePrototype { + return _ListParents__Prototype{} +} +func (la *_ListParents__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 *_ListParents__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, _Link{}) + 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 *_ListParents__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 *_ListParents__Assembler) ValuePrototype(_ int64) ipld.NodePrototype { + return _Link__Prototype{} +} +func (ListParents) Type() schema.Type { + return nil /*TODO:typelit*/ +} +func (n ListParents) Representation() ipld.Node { + return (*_ListParents__Repr)(n) +} +type _ListParents__Repr _ListParents +var _ ipld.Node = &_ListParents__Repr{} +func (_ListParents__Repr) Kind() ipld.Kind { + return ipld.Kind_List +} +func (_ListParents__Repr) LookupByString(string) (ipld.Node, error) { + return mixins.List{"ipldgit.ListParents.Repr"}.LookupByString("") +} +func (nr *_ListParents__Repr) LookupByNode(k ipld.Node) (ipld.Node, error) { + v, err := (ListParents)(nr).LookupByNode(k) + if err != nil || v == ipld.Null { + return v, err + } + return v.(Link).Representation(), nil +} +func (nr *_ListParents__Repr) LookupByIndex(idx int64) (ipld.Node, error) { + v, err := (ListParents)(nr).LookupByIndex(idx) + if err != nil || v == ipld.Null { + return v, err + } + return v.(Link).Representation(), nil +} +func (n _ListParents__Repr) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { + i, err := seg.Index() + if err != nil { + return nil, ipld.ErrInvalidSegmentForList{TypeName: "ipldgit.ListParents.Repr", TroubleSegment: seg, Reason: err} + } + return n.LookupByIndex(i) +} +func (_ListParents__Repr) MapIterator() ipld.MapIterator { + return nil +} +func (nr *_ListParents__Repr) ListIterator() ipld.ListIterator { + return &_ListParents__ReprListItr{(ListParents)(nr), 0} +} + +type _ListParents__ReprListItr _ListParents__ListItr + +func (itr *_ListParents__ReprListItr) Next() (idx int64, v ipld.Node, err error) { + idx, v, err = (*_ListParents__ListItr)(itr).Next() + if err != nil || v == ipld.Null { + return + } + return idx, v.(Link).Representation(), nil +} +func (itr *_ListParents__ReprListItr) Done() bool { + return (*_ListParents__ListItr)(itr).Done() +} + +func (rn *_ListParents__Repr) Length() int64 { + return int64(len(rn.x)) +} +func (_ListParents__Repr) IsAbsent() bool { + return false +} +func (_ListParents__Repr) IsNull() bool { + return false +} +func (_ListParents__Repr) AsBool() (bool, error) { + return mixins.List{"ipldgit.ListParents.Repr"}.AsBool() +} +func (_ListParents__Repr) AsInt() (int64, error) { + return mixins.List{"ipldgit.ListParents.Repr"}.AsInt() +} +func (_ListParents__Repr) AsFloat() (float64, error) { + return mixins.List{"ipldgit.ListParents.Repr"}.AsFloat() +} +func (_ListParents__Repr) AsString() (string, error) { + return mixins.List{"ipldgit.ListParents.Repr"}.AsString() +} +func (_ListParents__Repr) AsBytes() ([]byte, error) { + return mixins.List{"ipldgit.ListParents.Repr"}.AsBytes() +} +func (_ListParents__Repr) AsLink() (ipld.Link, error) { + return mixins.List{"ipldgit.ListParents.Repr"}.AsLink() +} +func (_ListParents__Repr) Prototype() ipld.NodePrototype { + return _ListParents__ReprPrototype{} +} +type _ListParents__ReprPrototype struct{} + +func (_ListParents__ReprPrototype) NewBuilder() ipld.NodeBuilder { + var nb _ListParents__ReprBuilder + nb.Reset() + return &nb +} +type _ListParents__ReprBuilder struct { + _ListParents__ReprAssembler +} +func (nb *_ListParents__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 *_ListParents__ReprBuilder) Reset() { + var w _ListParents + var m schema.Maybe + *nb = _ListParents__ReprBuilder{_ListParents__ReprAssembler{w: &w, m: &m}} +} +type _ListParents__ReprAssembler struct { + w *_ListParents + m *schema.Maybe + state laState + + cm schema.Maybe + va _Link__ReprAssembler +} + +func (na *_ListParents__ReprAssembler) reset() { + na.state = laState_initial + na.va.reset() +} +func (_ListParents__ReprAssembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { + return mixins.ListAssembler{"ipldgit.ListParents.Repr"}.BeginMap(0) +} +func (na *_ListParents__ReprAssembler) BeginList(sizeHint int64) (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 = &_ListParents{} + } + if sizeHint > 0 { + na.w.x = make([]_Link, 0, sizeHint) + } + return na, nil +} +func (na *_ListParents__ReprAssembler) AssignNull() error { + switch *na.m { + case allowNull: + *na.m = schema.Maybe_Null + return nil + case schema.Maybe_Absent: + return mixins.ListAssembler{"ipldgit.ListParents.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 (_ListParents__ReprAssembler) AssignBool(bool) error { + return mixins.ListAssembler{"ipldgit.ListParents.Repr"}.AssignBool(false) +} +func (_ListParents__ReprAssembler) AssignInt(int64) error { + return mixins.ListAssembler{"ipldgit.ListParents.Repr"}.AssignInt(0) +} +func (_ListParents__ReprAssembler) AssignFloat(float64) error { + return mixins.ListAssembler{"ipldgit.ListParents.Repr"}.AssignFloat(0) +} +func (_ListParents__ReprAssembler) AssignString(string) error { + return mixins.ListAssembler{"ipldgit.ListParents.Repr"}.AssignString("") +} +func (_ListParents__ReprAssembler) AssignBytes([]byte) error { + return mixins.ListAssembler{"ipldgit.ListParents.Repr"}.AssignBytes(nil) +} +func (_ListParents__ReprAssembler) AssignLink(ipld.Link) error { + return mixins.ListAssembler{"ipldgit.ListParents.Repr"}.AssignLink(nil) +} +func (na *_ListParents__ReprAssembler) AssignNode(v ipld.Node) error { + if v.IsNull() { + return na.AssignNull() + } + if v2, ok := v.(*_ListParents); 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.Kind() != ipld.Kind_List { + return ipld.ErrWrongKind{TypeName: "ipldgit.ListParents.Repr", MethodName: "AssignNode", AppropriateKind: ipld.KindSet_JustList, ActualKind: v.Kind()} + } + 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 (_ListParents__ReprAssembler) Prototype() ipld.NodePrototype { + return _ListParents__ReprPrototype{} +} +func (la *_ListParents__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 *_ListParents__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, _Link{}) + 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 *_ListParents__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 *_ListParents__ReprAssembler) ValuePrototype(_ int64) ipld.NodePrototype { + return _Link__ReprPrototype{} +} + +func (n *_ListString) Lookup(idx int64) String { + if n.Length() <= idx { + return nil + } + v := &n.x[idx] + return v +} +func (n *_ListString) LookupMaybe(idx int64) MaybeString { + if n.Length() <= idx { + return nil + } + v := &n.x[idx] + return &_String__Maybe{ + m: schema.Maybe_Value, + v: v, + } +} + +var _ListString__valueAbsent = _String__Maybe{m:schema.Maybe_Absent} +func (n ListString) Iterator() *ListString__Itr { + return &ListString__Itr{n, 0} +} + +type ListString__Itr struct { + n ListString + idx int +} + +func (itr *ListString__Itr) Next() (idx int64, v String) { + if itr.idx >= len(itr.n.x) { + return -1, nil + } + idx = int64(itr.idx) + v = &itr.n.x[itr.idx] + itr.idx++ + return +} +func (itr *ListString__Itr) Done() bool { + return itr.idx >= len(itr.n.x) +} + +type _ListString__Maybe struct { + m schema.Maybe + v ListString +} +type MaybeListString = *_ListString__Maybe + +func (m MaybeListString) IsNull() bool { + return m.m == schema.Maybe_Null +} +func (m MaybeListString) IsAbsent() bool { + return m.m == schema.Maybe_Absent +} +func (m MaybeListString) Exists() bool { + return m.m == schema.Maybe_Value +} +func (m MaybeListString) 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 MaybeListString) Must() ListString { + if !m.Exists() { + panic("unbox of a maybe rejected") + } + return m.v +} +var _ ipld.Node = (ListString)(&_ListString{}) +var _ schema.TypedNode = (ListString)(&_ListString{}) +func (ListString) Kind() ipld.Kind { + return ipld.Kind_List +} +func (ListString) LookupByString(string) (ipld.Node, error) { + return mixins.List{"ipldgit.ListString"}.LookupByString("") +} +func (n ListString) LookupByNode(k ipld.Node) (ipld.Node, error) { + idx, err := k.AsInt() + if err != nil { + return nil, err + } + return n.LookupByIndex(idx) +} +func (n ListString) LookupByIndex(idx int64) (ipld.Node, error) { + if n.Length() <= idx { + return nil, ipld.ErrNotExists{ipld.PathSegmentOfInt(idx)} + } + v := &n.x[idx] + return v, nil +} +func (n ListString) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { + i, err := seg.Index() + if err != nil { + return nil, ipld.ErrInvalidSegmentForList{TypeName: "ipldgit.ListString", TroubleSegment: seg, Reason: err} + } + return n.LookupByIndex(i) +} +func (ListString) MapIterator() ipld.MapIterator { + return nil +} +func (n ListString) ListIterator() ipld.ListIterator { + return &_ListString__ListItr{n, 0} +} + +type _ListString__ListItr struct { + n ListString + idx int +} + +func (itr *_ListString__ListItr) Next() (idx int64, v ipld.Node, _ error) { + if itr.idx >= len(itr.n.x) { + return -1, nil, ipld.ErrIteratorOverread{} + } + idx = int64(itr.idx) + x := &itr.n.x[itr.idx] + v = x + itr.idx++ + return +} +func (itr *_ListString__ListItr) Done() bool { + return itr.idx >= len(itr.n.x) +} + +func (n ListString) Length() int64 { + return int64(len(n.x)) +} +func (ListString) IsAbsent() bool { + return false +} +func (ListString) IsNull() bool { + return false +} +func (ListString) AsBool() (bool, error) { + return mixins.List{"ipldgit.ListString"}.AsBool() +} +func (ListString) AsInt() (int64, error) { + return mixins.List{"ipldgit.ListString"}.AsInt() +} +func (ListString) AsFloat() (float64, error) { + return mixins.List{"ipldgit.ListString"}.AsFloat() +} +func (ListString) AsString() (string, error) { + return mixins.List{"ipldgit.ListString"}.AsString() +} +func (ListString) AsBytes() ([]byte, error) { + return mixins.List{"ipldgit.ListString"}.AsBytes() +} +func (ListString) AsLink() (ipld.Link, error) { + return mixins.List{"ipldgit.ListString"}.AsLink() +} +func (ListString) Prototype() ipld.NodePrototype { + return _ListString__Prototype{} +} +type _ListString__Prototype struct{} + +func (_ListString__Prototype) NewBuilder() ipld.NodeBuilder { + var nb _ListString__Builder + nb.Reset() + return &nb +} +type _ListString__Builder struct { + _ListString__Assembler +} +func (nb *_ListString__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 *_ListString__Builder) Reset() { + var w _ListString + var m schema.Maybe + *nb = _ListString__Builder{_ListString__Assembler{w: &w, m: &m}} +} +type _ListString__Assembler struct { + w *_ListString + m *schema.Maybe + state laState + + cm schema.Maybe + va _String__Assembler +} + +func (na *_ListString__Assembler) reset() { + na.state = laState_initial + na.va.reset() +} +func (_ListString__Assembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { + return mixins.ListAssembler{"ipldgit.ListString"}.BeginMap(0) +} +func (na *_ListString__Assembler) BeginList(sizeHint int64) (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 = &_ListString{} + } + if sizeHint > 0 { + na.w.x = make([]_String, 0, sizeHint) + } + return na, nil +} +func (na *_ListString__Assembler) AssignNull() error { + switch *na.m { + case allowNull: + *na.m = schema.Maybe_Null + return nil + case schema.Maybe_Absent: + return mixins.ListAssembler{"ipldgit.ListString"}.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 (_ListString__Assembler) AssignBool(bool) error { + return mixins.ListAssembler{"ipldgit.ListString"}.AssignBool(false) +} +func (_ListString__Assembler) AssignInt(int64) error { + return mixins.ListAssembler{"ipldgit.ListString"}.AssignInt(0) +} +func (_ListString__Assembler) AssignFloat(float64) error { + return mixins.ListAssembler{"ipldgit.ListString"}.AssignFloat(0) +} +func (_ListString__Assembler) AssignString(string) error { + return mixins.ListAssembler{"ipldgit.ListString"}.AssignString("") +} +func (_ListString__Assembler) AssignBytes([]byte) error { + return mixins.ListAssembler{"ipldgit.ListString"}.AssignBytes(nil) +} +func (_ListString__Assembler) AssignLink(ipld.Link) error { + return mixins.ListAssembler{"ipldgit.ListString"}.AssignLink(nil) +} +func (na *_ListString__Assembler) AssignNode(v ipld.Node) error { + if v.IsNull() { + return na.AssignNull() + } + if v2, ok := v.(*_ListString); 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.Kind() != ipld.Kind_List { + return ipld.ErrWrongKind{TypeName: "ipldgit.ListString", MethodName: "AssignNode", AppropriateKind: ipld.KindSet_JustList, ActualKind: v.Kind()} + } + 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 (_ListString__Assembler) Prototype() ipld.NodePrototype { + return _ListString__Prototype{} +} +func (la *_ListString__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 *_ListString__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, _String{}) + 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 *_ListString__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 *_ListString__Assembler) ValuePrototype(_ int64) ipld.NodePrototype { + return _String__Prototype{} +} +func (ListString) Type() schema.Type { + return nil /*TODO:typelit*/ +} +func (n ListString) Representation() ipld.Node { + return (*_ListString__Repr)(n) +} +type _ListString__Repr _ListString +var _ ipld.Node = &_ListString__Repr{} +func (_ListString__Repr) Kind() ipld.Kind { + return ipld.Kind_List +} +func (_ListString__Repr) LookupByString(string) (ipld.Node, error) { + return mixins.List{"ipldgit.ListString.Repr"}.LookupByString("") +} +func (nr *_ListString__Repr) LookupByNode(k ipld.Node) (ipld.Node, error) { + v, err := (ListString)(nr).LookupByNode(k) + if err != nil || v == ipld.Null { + return v, err + } + return v.(String).Representation(), nil +} +func (nr *_ListString__Repr) LookupByIndex(idx int64) (ipld.Node, error) { + v, err := (ListString)(nr).LookupByIndex(idx) + if err != nil || v == ipld.Null { + return v, err + } + return v.(String).Representation(), nil +} +func (n _ListString__Repr) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { + i, err := seg.Index() + if err != nil { + return nil, ipld.ErrInvalidSegmentForList{TypeName: "ipldgit.ListString.Repr", TroubleSegment: seg, Reason: err} + } + return n.LookupByIndex(i) +} +func (_ListString__Repr) MapIterator() ipld.MapIterator { + return nil +} +func (nr *_ListString__Repr) ListIterator() ipld.ListIterator { + return &_ListString__ReprListItr{(ListString)(nr), 0} +} + +type _ListString__ReprListItr _ListString__ListItr + +func (itr *_ListString__ReprListItr) Next() (idx int64, v ipld.Node, err error) { + idx, v, err = (*_ListString__ListItr)(itr).Next() + if err != nil || v == ipld.Null { + return + } + return idx, v.(String).Representation(), nil +} +func (itr *_ListString__ReprListItr) Done() bool { + return (*_ListString__ListItr)(itr).Done() +} + +func (rn *_ListString__Repr) Length() int64 { + return int64(len(rn.x)) +} +func (_ListString__Repr) IsAbsent() bool { + return false +} +func (_ListString__Repr) IsNull() bool { + return false +} +func (_ListString__Repr) AsBool() (bool, error) { + return mixins.List{"ipldgit.ListString.Repr"}.AsBool() +} +func (_ListString__Repr) AsInt() (int64, error) { + return mixins.List{"ipldgit.ListString.Repr"}.AsInt() +} +func (_ListString__Repr) AsFloat() (float64, error) { + return mixins.List{"ipldgit.ListString.Repr"}.AsFloat() +} +func (_ListString__Repr) AsString() (string, error) { + return mixins.List{"ipldgit.ListString.Repr"}.AsString() +} +func (_ListString__Repr) AsBytes() ([]byte, error) { + return mixins.List{"ipldgit.ListString.Repr"}.AsBytes() +} +func (_ListString__Repr) AsLink() (ipld.Link, error) { + return mixins.List{"ipldgit.ListString.Repr"}.AsLink() +} +func (_ListString__Repr) Prototype() ipld.NodePrototype { + return _ListString__ReprPrototype{} +} +type _ListString__ReprPrototype struct{} + +func (_ListString__ReprPrototype) NewBuilder() ipld.NodeBuilder { + var nb _ListString__ReprBuilder + nb.Reset() + return &nb +} +type _ListString__ReprBuilder struct { + _ListString__ReprAssembler +} +func (nb *_ListString__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 *_ListString__ReprBuilder) Reset() { + var w _ListString + var m schema.Maybe + *nb = _ListString__ReprBuilder{_ListString__ReprAssembler{w: &w, m: &m}} +} +type _ListString__ReprAssembler struct { + w *_ListString + m *schema.Maybe + state laState + + cm schema.Maybe + va _String__ReprAssembler +} + +func (na *_ListString__ReprAssembler) reset() { + na.state = laState_initial + na.va.reset() +} +func (_ListString__ReprAssembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { + return mixins.ListAssembler{"ipldgit.ListString.Repr"}.BeginMap(0) +} +func (na *_ListString__ReprAssembler) BeginList(sizeHint int64) (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 = &_ListString{} + } + if sizeHint > 0 { + na.w.x = make([]_String, 0, sizeHint) + } + return na, nil +} +func (na *_ListString__ReprAssembler) AssignNull() error { + switch *na.m { + case allowNull: + *na.m = schema.Maybe_Null + return nil + case schema.Maybe_Absent: + return mixins.ListAssembler{"ipldgit.ListString.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 (_ListString__ReprAssembler) AssignBool(bool) error { + return mixins.ListAssembler{"ipldgit.ListString.Repr"}.AssignBool(false) +} +func (_ListString__ReprAssembler) AssignInt(int64) error { + return mixins.ListAssembler{"ipldgit.ListString.Repr"}.AssignInt(0) +} +func (_ListString__ReprAssembler) AssignFloat(float64) error { + return mixins.ListAssembler{"ipldgit.ListString.Repr"}.AssignFloat(0) +} +func (_ListString__ReprAssembler) AssignString(string) error { + return mixins.ListAssembler{"ipldgit.ListString.Repr"}.AssignString("") +} +func (_ListString__ReprAssembler) AssignBytes([]byte) error { + return mixins.ListAssembler{"ipldgit.ListString.Repr"}.AssignBytes(nil) +} +func (_ListString__ReprAssembler) AssignLink(ipld.Link) error { + return mixins.ListAssembler{"ipldgit.ListString.Repr"}.AssignLink(nil) +} +func (na *_ListString__ReprAssembler) AssignNode(v ipld.Node) error { + if v.IsNull() { + return na.AssignNull() + } + if v2, ok := v.(*_ListString); 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.Kind() != ipld.Kind_List { + return ipld.ErrWrongKind{TypeName: "ipldgit.ListString.Repr", MethodName: "AssignNode", AppropriateKind: ipld.KindSet_JustList, ActualKind: v.Kind()} + } + 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 (_ListString__ReprAssembler) Prototype() ipld.NodePrototype { + return _ListString__ReprPrototype{} +} +func (la *_ListString__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 *_ListString__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, _String{}) + 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 *_ListString__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 *_ListString__ReprAssembler) ValuePrototype(_ int64) ipld.NodePrototype { + return _String__ReprPrototype{} +} + +func (n *_ListTag) Lookup(idx int64) Tag { + if n.Length() <= idx { + return nil + } + v := &n.x[idx] + return v +} +func (n *_ListTag) LookupMaybe(idx int64) MaybeTag { + if n.Length() <= idx { + return nil + } + v := &n.x[idx] + return &_Tag__Maybe{ + m: schema.Maybe_Value, + v: v, + } +} + +var _ListTag__valueAbsent = _Tag__Maybe{m:schema.Maybe_Absent} +func (n ListTag) Iterator() *ListTag__Itr { + return &ListTag__Itr{n, 0} +} + +type ListTag__Itr struct { + n ListTag + idx int +} + +func (itr *ListTag__Itr) Next() (idx int64, v Tag) { + if itr.idx >= len(itr.n.x) { + return -1, nil + } + idx = int64(itr.idx) + v = &itr.n.x[itr.idx] + itr.idx++ + return +} +func (itr *ListTag__Itr) Done() bool { + return itr.idx >= len(itr.n.x) +} + +type _ListTag__Maybe struct { + m schema.Maybe + v ListTag +} +type MaybeListTag = *_ListTag__Maybe + +func (m MaybeListTag) IsNull() bool { + return m.m == schema.Maybe_Null +} +func (m MaybeListTag) IsAbsent() bool { + return m.m == schema.Maybe_Absent +} +func (m MaybeListTag) Exists() bool { + return m.m == schema.Maybe_Value +} +func (m MaybeListTag) 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 MaybeListTag) Must() ListTag { + if !m.Exists() { + panic("unbox of a maybe rejected") + } + return m.v +} +var _ ipld.Node = (ListTag)(&_ListTag{}) +var _ schema.TypedNode = (ListTag)(&_ListTag{}) +func (ListTag) Kind() ipld.Kind { + return ipld.Kind_List +} +func (ListTag) LookupByString(string) (ipld.Node, error) { + return mixins.List{"ipldgit.ListTag"}.LookupByString("") +} +func (n ListTag) LookupByNode(k ipld.Node) (ipld.Node, error) { + idx, err := k.AsInt() + if err != nil { + return nil, err + } + return n.LookupByIndex(idx) +} +func (n ListTag) LookupByIndex(idx int64) (ipld.Node, error) { + if n.Length() <= idx { + return nil, ipld.ErrNotExists{ipld.PathSegmentOfInt(idx)} + } + v := &n.x[idx] + return v, nil +} +func (n ListTag) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { + i, err := seg.Index() + if err != nil { + return nil, ipld.ErrInvalidSegmentForList{TypeName: "ipldgit.ListTag", TroubleSegment: seg, Reason: err} + } + return n.LookupByIndex(i) +} +func (ListTag) MapIterator() ipld.MapIterator { + return nil +} +func (n ListTag) ListIterator() ipld.ListIterator { + return &_ListTag__ListItr{n, 0} +} + +type _ListTag__ListItr struct { + n ListTag + idx int +} + +func (itr *_ListTag__ListItr) Next() (idx int64, v ipld.Node, _ error) { + if itr.idx >= len(itr.n.x) { + return -1, nil, ipld.ErrIteratorOverread{} + } + idx = int64(itr.idx) + x := &itr.n.x[itr.idx] + v = x + itr.idx++ + return +} +func (itr *_ListTag__ListItr) Done() bool { + return itr.idx >= len(itr.n.x) +} + +func (n ListTag) Length() int64 { + return int64(len(n.x)) +} +func (ListTag) IsAbsent() bool { + return false +} +func (ListTag) IsNull() bool { + return false +} +func (ListTag) AsBool() (bool, error) { + return mixins.List{"ipldgit.ListTag"}.AsBool() +} +func (ListTag) AsInt() (int64, error) { + return mixins.List{"ipldgit.ListTag"}.AsInt() +} +func (ListTag) AsFloat() (float64, error) { + return mixins.List{"ipldgit.ListTag"}.AsFloat() +} +func (ListTag) AsString() (string, error) { + return mixins.List{"ipldgit.ListTag"}.AsString() +} +func (ListTag) AsBytes() ([]byte, error) { + return mixins.List{"ipldgit.ListTag"}.AsBytes() +} +func (ListTag) AsLink() (ipld.Link, error) { + return mixins.List{"ipldgit.ListTag"}.AsLink() +} +func (ListTag) Prototype() ipld.NodePrototype { + return _ListTag__Prototype{} +} +type _ListTag__Prototype struct{} + +func (_ListTag__Prototype) NewBuilder() ipld.NodeBuilder { + var nb _ListTag__Builder + nb.Reset() + return &nb +} +type _ListTag__Builder struct { + _ListTag__Assembler +} +func (nb *_ListTag__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 *_ListTag__Builder) Reset() { + var w _ListTag + var m schema.Maybe + *nb = _ListTag__Builder{_ListTag__Assembler{w: &w, m: &m}} +} +type _ListTag__Assembler struct { + w *_ListTag + m *schema.Maybe + state laState + + cm schema.Maybe + va _Tag__Assembler +} + +func (na *_ListTag__Assembler) reset() { + na.state = laState_initial + na.va.reset() +} +func (_ListTag__Assembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { + return mixins.ListAssembler{"ipldgit.ListTag"}.BeginMap(0) +} +func (na *_ListTag__Assembler) BeginList(sizeHint int64) (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 = &_ListTag{} + } + if sizeHint > 0 { + na.w.x = make([]_Tag, 0, sizeHint) + } + return na, nil +} +func (na *_ListTag__Assembler) AssignNull() error { + switch *na.m { + case allowNull: + *na.m = schema.Maybe_Null + return nil + case schema.Maybe_Absent: + return mixins.ListAssembler{"ipldgit.ListTag"}.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 (_ListTag__Assembler) AssignBool(bool) error { + return mixins.ListAssembler{"ipldgit.ListTag"}.AssignBool(false) +} +func (_ListTag__Assembler) AssignInt(int64) error { + return mixins.ListAssembler{"ipldgit.ListTag"}.AssignInt(0) +} +func (_ListTag__Assembler) AssignFloat(float64) error { + return mixins.ListAssembler{"ipldgit.ListTag"}.AssignFloat(0) +} +func (_ListTag__Assembler) AssignString(string) error { + return mixins.ListAssembler{"ipldgit.ListTag"}.AssignString("") +} +func (_ListTag__Assembler) AssignBytes([]byte) error { + return mixins.ListAssembler{"ipldgit.ListTag"}.AssignBytes(nil) +} +func (_ListTag__Assembler) AssignLink(ipld.Link) error { + return mixins.ListAssembler{"ipldgit.ListTag"}.AssignLink(nil) +} +func (na *_ListTag__Assembler) AssignNode(v ipld.Node) error { + if v.IsNull() { + return na.AssignNull() + } + if v2, ok := v.(*_ListTag); 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.Kind() != ipld.Kind_List { + return ipld.ErrWrongKind{TypeName: "ipldgit.ListTag", MethodName: "AssignNode", AppropriateKind: ipld.KindSet_JustList, ActualKind: v.Kind()} + } + 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 (_ListTag__Assembler) Prototype() ipld.NodePrototype { + return _ListTag__Prototype{} +} +func (la *_ListTag__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 *_ListTag__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, _Tag{}) + 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 *_ListTag__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 *_ListTag__Assembler) ValuePrototype(_ int64) ipld.NodePrototype { + return _Tag__Prototype{} +} +func (ListTag) Type() schema.Type { + return nil /*TODO:typelit*/ +} +func (n ListTag) Representation() ipld.Node { + return (*_ListTag__Repr)(n) +} +type _ListTag__Repr _ListTag +var _ ipld.Node = &_ListTag__Repr{} +func (_ListTag__Repr) Kind() ipld.Kind { + return ipld.Kind_List +} +func (_ListTag__Repr) LookupByString(string) (ipld.Node, error) { + return mixins.List{"ipldgit.ListTag.Repr"}.LookupByString("") +} +func (nr *_ListTag__Repr) LookupByNode(k ipld.Node) (ipld.Node, error) { + v, err := (ListTag)(nr).LookupByNode(k) + if err != nil || v == ipld.Null { + return v, err + } + return v.(Tag).Representation(), nil +} +func (nr *_ListTag__Repr) LookupByIndex(idx int64) (ipld.Node, error) { + v, err := (ListTag)(nr).LookupByIndex(idx) + if err != nil || v == ipld.Null { + return v, err + } + return v.(Tag).Representation(), nil +} +func (n _ListTag__Repr) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { + i, err := seg.Index() + if err != nil { + return nil, ipld.ErrInvalidSegmentForList{TypeName: "ipldgit.ListTag.Repr", TroubleSegment: seg, Reason: err} + } + return n.LookupByIndex(i) +} +func (_ListTag__Repr) MapIterator() ipld.MapIterator { + return nil +} +func (nr *_ListTag__Repr) ListIterator() ipld.ListIterator { + return &_ListTag__ReprListItr{(ListTag)(nr), 0} +} + +type _ListTag__ReprListItr _ListTag__ListItr + +func (itr *_ListTag__ReprListItr) Next() (idx int64, v ipld.Node, err error) { + idx, v, err = (*_ListTag__ListItr)(itr).Next() + if err != nil || v == ipld.Null { + return + } + return idx, v.(Tag).Representation(), nil +} +func (itr *_ListTag__ReprListItr) Done() bool { + return (*_ListTag__ListItr)(itr).Done() +} + +func (rn *_ListTag__Repr) Length() int64 { + return int64(len(rn.x)) +} +func (_ListTag__Repr) IsAbsent() bool { + return false +} +func (_ListTag__Repr) IsNull() bool { + return false +} +func (_ListTag__Repr) AsBool() (bool, error) { + return mixins.List{"ipldgit.ListTag.Repr"}.AsBool() +} +func (_ListTag__Repr) AsInt() (int64, error) { + return mixins.List{"ipldgit.ListTag.Repr"}.AsInt() +} +func (_ListTag__Repr) AsFloat() (float64, error) { + return mixins.List{"ipldgit.ListTag.Repr"}.AsFloat() +} +func (_ListTag__Repr) AsString() (string, error) { + return mixins.List{"ipldgit.ListTag.Repr"}.AsString() +} +func (_ListTag__Repr) AsBytes() ([]byte, error) { + return mixins.List{"ipldgit.ListTag.Repr"}.AsBytes() +} +func (_ListTag__Repr) AsLink() (ipld.Link, error) { + return mixins.List{"ipldgit.ListTag.Repr"}.AsLink() +} +func (_ListTag__Repr) Prototype() ipld.NodePrototype { + return _ListTag__ReprPrototype{} +} +type _ListTag__ReprPrototype struct{} + +func (_ListTag__ReprPrototype) NewBuilder() ipld.NodeBuilder { + var nb _ListTag__ReprBuilder + nb.Reset() + return &nb +} +type _ListTag__ReprBuilder struct { + _ListTag__ReprAssembler +} +func (nb *_ListTag__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 *_ListTag__ReprBuilder) Reset() { + var w _ListTag + var m schema.Maybe + *nb = _ListTag__ReprBuilder{_ListTag__ReprAssembler{w: &w, m: &m}} +} +type _ListTag__ReprAssembler struct { + w *_ListTag + m *schema.Maybe + state laState + + cm schema.Maybe + va _Tag__ReprAssembler +} + +func (na *_ListTag__ReprAssembler) reset() { + na.state = laState_initial + na.va.reset() +} +func (_ListTag__ReprAssembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { + return mixins.ListAssembler{"ipldgit.ListTag.Repr"}.BeginMap(0) +} +func (na *_ListTag__ReprAssembler) BeginList(sizeHint int64) (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 = &_ListTag{} + } + if sizeHint > 0 { + na.w.x = make([]_Tag, 0, sizeHint) + } + return na, nil +} +func (na *_ListTag__ReprAssembler) AssignNull() error { + switch *na.m { + case allowNull: + *na.m = schema.Maybe_Null + return nil + case schema.Maybe_Absent: + return mixins.ListAssembler{"ipldgit.ListTag.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 (_ListTag__ReprAssembler) AssignBool(bool) error { + return mixins.ListAssembler{"ipldgit.ListTag.Repr"}.AssignBool(false) +} +func (_ListTag__ReprAssembler) AssignInt(int64) error { + return mixins.ListAssembler{"ipldgit.ListTag.Repr"}.AssignInt(0) +} +func (_ListTag__ReprAssembler) AssignFloat(float64) error { + return mixins.ListAssembler{"ipldgit.ListTag.Repr"}.AssignFloat(0) +} +func (_ListTag__ReprAssembler) AssignString(string) error { + return mixins.ListAssembler{"ipldgit.ListTag.Repr"}.AssignString("") +} +func (_ListTag__ReprAssembler) AssignBytes([]byte) error { + return mixins.ListAssembler{"ipldgit.ListTag.Repr"}.AssignBytes(nil) +} +func (_ListTag__ReprAssembler) AssignLink(ipld.Link) error { + return mixins.ListAssembler{"ipldgit.ListTag.Repr"}.AssignLink(nil) +} +func (na *_ListTag__ReprAssembler) AssignNode(v ipld.Node) error { + if v.IsNull() { + return na.AssignNull() + } + if v2, ok := v.(*_ListTag); 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.Kind() != ipld.Kind_List { + return ipld.ErrWrongKind{TypeName: "ipldgit.ListTag.Repr", MethodName: "AssignNode", AppropriateKind: ipld.KindSet_JustList, ActualKind: v.Kind()} + } + 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 (_ListTag__ReprAssembler) Prototype() ipld.NodePrototype { + return _ListTag__ReprPrototype{} +} +func (la *_ListTag__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 *_ListTag__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, _Tag{}) + 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 *_ListTag__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 *_ListTag__ReprAssembler) ValuePrototype(_ int64) ipld.NodePrototype { + return _Tag__ReprPrototype{} +} + + +func (n _PersonInfo) FieldName() String { + return &n.Name +} +func (n _PersonInfo) FieldEmail() String { + return &n.Email +} +func (n _PersonInfo) FieldDate() String { + return &n.Date +} +func (n _PersonInfo) FieldTimezone() String { + return &n.Timezone +} +type _PersonInfo__Maybe struct { + m schema.Maybe + v PersonInfo +} +type MaybePersonInfo = *_PersonInfo__Maybe + +func (m MaybePersonInfo) IsNull() bool { + return m.m == schema.Maybe_Null +} +func (m MaybePersonInfo) IsAbsent() bool { + return m.m == schema.Maybe_Absent +} +func (m MaybePersonInfo) Exists() bool { + return m.m == schema.Maybe_Value +} +func (m MaybePersonInfo) 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 MaybePersonInfo) Must() PersonInfo { + if !m.Exists() { + panic("unbox of a maybe rejected") + } + return m.v +} +var ( + fieldName__PersonInfo_Name = _String{"Name"} + fieldName__PersonInfo_Email = _String{"Email"} + fieldName__PersonInfo_Date = _String{"Date"} + fieldName__PersonInfo_Timezone = _String{"Timezone"} +) +var _ ipld.Node = (PersonInfo)(&_PersonInfo{}) +var _ schema.TypedNode = (PersonInfo)(&_PersonInfo{}) +func (PersonInfo) Kind() ipld.Kind { + return ipld.Kind_Map +} +func (n PersonInfo) LookupByString(key string) (ipld.Node, error) { + switch key { + case "Name": + return &n.Name, nil + case "Email": + return &n.Email, nil + case "Date": + return &n.Date, nil + case "Timezone": + return &n.Timezone, nil + default: + return nil, schema.ErrNoSuchField{Type: nil /*TODO*/, Field: ipld.PathSegmentOfString(key)} + } +} +func (n PersonInfo) LookupByNode(key ipld.Node) (ipld.Node, error) { + ks, err := key.AsString() + if err != nil { + return nil, err + } + return n.LookupByString(ks) +} +func (PersonInfo) LookupByIndex(idx int64) (ipld.Node, error) { + return mixins.Map{"ipldgit.PersonInfo"}.LookupByIndex(0) +} +func (n PersonInfo) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { + return n.LookupByString(seg.String()) +} +func (n PersonInfo) MapIterator() ipld.MapIterator { + return &_PersonInfo__MapItr{n, 0} +} + +type _PersonInfo__MapItr struct { + n PersonInfo + idx int +} + +func (itr *_PersonInfo__MapItr) Next() (k ipld.Node, v ipld.Node, _ error) { + if itr.idx >= 4 { + return nil, nil, ipld.ErrIteratorOverread{} + } + switch itr.idx { + case 0: + k = &fieldName__PersonInfo_Name + v = &itr.n.Name + case 1: + k = &fieldName__PersonInfo_Email + v = &itr.n.Email + case 2: + k = &fieldName__PersonInfo_Date + v = &itr.n.Date + case 3: + k = &fieldName__PersonInfo_Timezone + v = &itr.n.Timezone + default: + panic("unreachable") + } + itr.idx++ + return +} +func (itr *_PersonInfo__MapItr) Done() bool { + return itr.idx >= 4 +} + +func (PersonInfo) ListIterator() ipld.ListIterator { + return nil +} +func (PersonInfo) Length() int64 { + return 4 +} +func (PersonInfo) IsAbsent() bool { + return false +} +func (PersonInfo) IsNull() bool { + return false +} +func (PersonInfo) AsBool() (bool, error) { + return mixins.Map{"ipldgit.PersonInfo"}.AsBool() +} +func (PersonInfo) AsInt() (int64, error) { + return mixins.Map{"ipldgit.PersonInfo"}.AsInt() +} +func (PersonInfo) AsFloat() (float64, error) { + return mixins.Map{"ipldgit.PersonInfo"}.AsFloat() +} +func (PersonInfo) AsString() (string, error) { + return mixins.Map{"ipldgit.PersonInfo"}.AsString() +} +func (PersonInfo) AsBytes() ([]byte, error) { + return mixins.Map{"ipldgit.PersonInfo"}.AsBytes() +} +func (PersonInfo) AsLink() (ipld.Link, error) { + return mixins.Map{"ipldgit.PersonInfo"}.AsLink() +} +func (PersonInfo) Prototype() ipld.NodePrototype { + return _PersonInfo__Prototype{} +} +type _PersonInfo__Prototype struct{} + +func (_PersonInfo__Prototype) NewBuilder() ipld.NodeBuilder { + var nb _PersonInfo__Builder + nb.Reset() + return &nb +} +type _PersonInfo__Builder struct { + _PersonInfo__Assembler +} +func (nb *_PersonInfo__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 *_PersonInfo__Builder) Reset() { + var w _PersonInfo + var m schema.Maybe + *nb = _PersonInfo__Builder{_PersonInfo__Assembler{w: &w, m: &m}} +} +type _PersonInfo__Assembler struct { + w *_PersonInfo + m *schema.Maybe + state maState + s int + f int + + cm schema.Maybe + ca_Name _String__Assembler + ca_Email _String__Assembler + ca_Date _String__Assembler + ca_Timezone _String__Assembler + } + +func (na *_PersonInfo__Assembler) reset() { + na.state = maState_initial + na.s = 0 + na.ca_Name.reset() + na.ca_Email.reset() + na.ca_Date.reset() + na.ca_Timezone.reset() +} + +var ( + fieldBit__PersonInfo_Name = 1 << 0 + fieldBit__PersonInfo_Email = 1 << 1 + fieldBit__PersonInfo_Date = 1 << 2 + fieldBit__PersonInfo_Timezone = 1 << 3 + fieldBits__PersonInfo_sufficient = 0 + 1 << 0 + 1 << 1 + 1 << 2 + 1 << 3 +) +func (na *_PersonInfo__Assembler) BeginMap(int64) (ipld.MapAssembler, 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 na.w == nil { + na.w = &_PersonInfo{} + } + return na, nil +} +func (_PersonInfo__Assembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { + return mixins.MapAssembler{"ipldgit.PersonInfo"}.BeginList(0) +} +func (na *_PersonInfo__Assembler) AssignNull() error { + switch *na.m { + case allowNull: + *na.m = schema.Maybe_Null + return nil + case schema.Maybe_Absent: + return mixins.MapAssembler{"ipldgit.PersonInfo"}.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 (_PersonInfo__Assembler) AssignBool(bool) error { + return mixins.MapAssembler{"ipldgit.PersonInfo"}.AssignBool(false) +} +func (_PersonInfo__Assembler) AssignInt(int64) error { + return mixins.MapAssembler{"ipldgit.PersonInfo"}.AssignInt(0) +} +func (_PersonInfo__Assembler) AssignFloat(float64) error { + return mixins.MapAssembler{"ipldgit.PersonInfo"}.AssignFloat(0) +} +func (_PersonInfo__Assembler) AssignString(string) error { + return mixins.MapAssembler{"ipldgit.PersonInfo"}.AssignString("") +} +func (_PersonInfo__Assembler) AssignBytes([]byte) error { + return mixins.MapAssembler{"ipldgit.PersonInfo"}.AssignBytes(nil) +} +func (_PersonInfo__Assembler) AssignLink(ipld.Link) error { + return mixins.MapAssembler{"ipldgit.PersonInfo"}.AssignLink(nil) +} +func (na *_PersonInfo__Assembler) AssignNode(v ipld.Node) error { + if v.IsNull() { + return na.AssignNull() + } + if v2, ok := v.(*_PersonInfo); 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.Kind() != ipld.Kind_Map { + return ipld.ErrWrongKind{TypeName: "ipldgit.PersonInfo", MethodName: "AssignNode", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()} + } + itr := v.MapIterator() + for !itr.Done() { + k, v, err := itr.Next() + if err != nil { + return err + } + if err := na.AssembleKey().AssignNode(k); err != nil { + return err + } + if err := na.AssembleValue().AssignNode(v); err != nil { + return err + } + } + return na.Finish() +} +func (_PersonInfo__Assembler) Prototype() ipld.NodePrototype { + return _PersonInfo__Prototype{} +} +func (ma *_PersonInfo__Assembler) valueFinishTidy() bool { + switch ma.f { + case 0: + switch ma.cm { + case schema.Maybe_Value: + ma.ca_Name.w = nil + ma.cm = schema.Maybe_Absent + ma.state = maState_initial + return true + default: + return false + } + case 1: + switch ma.cm { + case schema.Maybe_Value: + ma.ca_Email.w = nil + ma.cm = schema.Maybe_Absent + ma.state = maState_initial + return true + default: + return false + } + case 2: + switch ma.cm { + case schema.Maybe_Value: + ma.ca_Date.w = nil + ma.cm = schema.Maybe_Absent + ma.state = maState_initial + return true + default: + return false + } + case 3: + switch ma.cm { + case schema.Maybe_Value: + ma.ca_Timezone.w = nil + ma.cm = schema.Maybe_Absent + ma.state = maState_initial + return true + default: + return false + } + default: + panic("unreachable") + } +} +func (ma *_PersonInfo__Assembler) AssembleEntry(k string) (ipld.NodeAssembler, error) { + switch ma.state { + case maState_initial: + // carry on + case maState_midKey: + panic("invalid state: AssembleEntry cannot be called when in the middle of assembling another key") + case maState_expectValue: + panic("invalid state: AssembleEntry cannot be called when expecting start of value assembly") + case maState_midValue: + if !ma.valueFinishTidy() { + panic("invalid state: AssembleEntry cannot be called when in the middle of assembling a value") + } // if tidy success: carry on + case maState_finished: + panic("invalid state: AssembleEntry cannot be called on an assembler that's already finished") + } + switch k { + case "Name": + if ma.s & fieldBit__PersonInfo_Name != 0 { + return nil, ipld.ErrRepeatedMapKey{&fieldName__PersonInfo_Name} + } + ma.s += fieldBit__PersonInfo_Name + ma.state = maState_midValue + ma.f = 0 + ma.ca_Name.w = &ma.w.Name + ma.ca_Name.m = &ma.cm + return &ma.ca_Name, nil + case "Email": + if ma.s & fieldBit__PersonInfo_Email != 0 { + return nil, ipld.ErrRepeatedMapKey{&fieldName__PersonInfo_Email} + } + ma.s += fieldBit__PersonInfo_Email + ma.state = maState_midValue + ma.f = 1 + ma.ca_Email.w = &ma.w.Email + ma.ca_Email.m = &ma.cm + return &ma.ca_Email, nil + case "Date": + if ma.s & fieldBit__PersonInfo_Date != 0 { + return nil, ipld.ErrRepeatedMapKey{&fieldName__PersonInfo_Date} + } + ma.s += fieldBit__PersonInfo_Date + ma.state = maState_midValue + ma.f = 2 + ma.ca_Date.w = &ma.w.Date + ma.ca_Date.m = &ma.cm + return &ma.ca_Date, nil + case "Timezone": + if ma.s & fieldBit__PersonInfo_Timezone != 0 { + return nil, ipld.ErrRepeatedMapKey{&fieldName__PersonInfo_Timezone} + } + ma.s += fieldBit__PersonInfo_Timezone + ma.state = maState_midValue + ma.f = 3 + ma.ca_Timezone.w = &ma.w.Timezone + ma.ca_Timezone.m = &ma.cm + return &ma.ca_Timezone, nil + default: + return nil, ipld.ErrInvalidKey{TypeName:"ipldgit.PersonInfo", Key:&_String{k}} + } +} +func (ma *_PersonInfo__Assembler) AssembleKey() ipld.NodeAssembler { + switch ma.state { + case maState_initial: + // carry on + case maState_midKey: + panic("invalid state: AssembleKey cannot be called when in the middle of assembling another key") + case maState_expectValue: + panic("invalid state: AssembleKey cannot be called when expecting start of value assembly") + case maState_midValue: + if !ma.valueFinishTidy() { + panic("invalid state: AssembleKey cannot be called when in the middle of assembling a value") + } // if tidy success: carry on + case maState_finished: + panic("invalid state: AssembleKey cannot be called on an assembler that's already finished") + } + ma.state = maState_midKey + return (*_PersonInfo__KeyAssembler)(ma) +} +func (ma *_PersonInfo__Assembler) AssembleValue() ipld.NodeAssembler { + switch ma.state { + case maState_initial: + panic("invalid state: AssembleValue cannot be called when no key is primed") + case maState_midKey: + panic("invalid state: AssembleValue cannot be called when in the middle of assembling a key") + case maState_expectValue: + // carry on + case maState_midValue: + panic("invalid state: AssembleValue cannot be called when in the middle of assembling another value") + case maState_finished: + panic("invalid state: AssembleValue cannot be called on an assembler that's already finished") + } + ma.state = maState_midValue + switch ma.f { + case 0: + ma.ca_Name.w = &ma.w.Name + ma.ca_Name.m = &ma.cm + return &ma.ca_Name + case 1: + ma.ca_Email.w = &ma.w.Email + ma.ca_Email.m = &ma.cm + return &ma.ca_Email + case 2: + ma.ca_Date.w = &ma.w.Date + ma.ca_Date.m = &ma.cm + return &ma.ca_Date + case 3: + ma.ca_Timezone.w = &ma.w.Timezone + ma.ca_Timezone.m = &ma.cm + return &ma.ca_Timezone + default: + panic("unreachable") + } +} +func (ma *_PersonInfo__Assembler) Finish() error { + switch ma.state { + case maState_initial: + // carry on + case maState_midKey: + panic("invalid state: Finish cannot be called when in the middle of assembling a key") + case maState_expectValue: + panic("invalid state: Finish cannot be called when expecting start of value assembly") + case maState_midValue: + if !ma.valueFinishTidy() { + panic("invalid state: Finish cannot be called when in the middle of assembling a value") + } // if tidy success: carry on + case maState_finished: + panic("invalid state: Finish cannot be called on an assembler that's already finished") + } + if ma.s & fieldBits__PersonInfo_sufficient != fieldBits__PersonInfo_sufficient { + err := ipld.ErrMissingRequiredField{Missing: make([]string, 0)} + if ma.s & fieldBit__PersonInfo_Name == 0 { + err.Missing = append(err.Missing, "Name") + } + if ma.s & fieldBit__PersonInfo_Email == 0 { + err.Missing = append(err.Missing, "Email") + } + if ma.s & fieldBit__PersonInfo_Date == 0 { + err.Missing = append(err.Missing, "Date") + } + if ma.s & fieldBit__PersonInfo_Timezone == 0 { + err.Missing = append(err.Missing, "Timezone") + } + return err + } + ma.state = maState_finished + *ma.m = schema.Maybe_Value + return nil +} +func (ma *_PersonInfo__Assembler) KeyPrototype() ipld.NodePrototype { + return _String__Prototype{} +} +func (ma *_PersonInfo__Assembler) ValuePrototype(k string) ipld.NodePrototype { + panic("todo structbuilder mapassembler valueprototype") +} +type _PersonInfo__KeyAssembler _PersonInfo__Assembler +func (_PersonInfo__KeyAssembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { + return mixins.StringAssembler{"ipldgit.PersonInfo.KeyAssembler"}.BeginMap(0) +} +func (_PersonInfo__KeyAssembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { + return mixins.StringAssembler{"ipldgit.PersonInfo.KeyAssembler"}.BeginList(0) +} +func (na *_PersonInfo__KeyAssembler) AssignNull() error { + return mixins.StringAssembler{"ipldgit.PersonInfo.KeyAssembler"}.AssignNull() +} +func (_PersonInfo__KeyAssembler) AssignBool(bool) error { + return mixins.StringAssembler{"ipldgit.PersonInfo.KeyAssembler"}.AssignBool(false) +} +func (_PersonInfo__KeyAssembler) AssignInt(int64) error { + return mixins.StringAssembler{"ipldgit.PersonInfo.KeyAssembler"}.AssignInt(0) +} +func (_PersonInfo__KeyAssembler) AssignFloat(float64) error { + return mixins.StringAssembler{"ipldgit.PersonInfo.KeyAssembler"}.AssignFloat(0) +} +func (ka *_PersonInfo__KeyAssembler) AssignString(k string) error { + if ka.state != maState_midKey { + panic("misuse: KeyAssembler held beyond its valid lifetime") + } + switch k { + case "Name": + if ka.s & fieldBit__PersonInfo_Name != 0 { + return ipld.ErrRepeatedMapKey{&fieldName__PersonInfo_Name} + } + ka.s += fieldBit__PersonInfo_Name + ka.state = maState_expectValue + ka.f = 0 + case "Email": + if ka.s & fieldBit__PersonInfo_Email != 0 { + return ipld.ErrRepeatedMapKey{&fieldName__PersonInfo_Email} + } + ka.s += fieldBit__PersonInfo_Email + ka.state = maState_expectValue + ka.f = 1 + case "Date": + if ka.s & fieldBit__PersonInfo_Date != 0 { + return ipld.ErrRepeatedMapKey{&fieldName__PersonInfo_Date} + } + ka.s += fieldBit__PersonInfo_Date + ka.state = maState_expectValue + ka.f = 2 + case "Timezone": + if ka.s & fieldBit__PersonInfo_Timezone != 0 { + return ipld.ErrRepeatedMapKey{&fieldName__PersonInfo_Timezone} + } + ka.s += fieldBit__PersonInfo_Timezone + ka.state = maState_expectValue + ka.f = 3 + default: + return ipld.ErrInvalidKey{TypeName:"ipldgit.PersonInfo", Key:&_String{k}} + } + return nil +} +func (_PersonInfo__KeyAssembler) AssignBytes([]byte) error { + return mixins.StringAssembler{"ipldgit.PersonInfo.KeyAssembler"}.AssignBytes(nil) +} +func (_PersonInfo__KeyAssembler) AssignLink(ipld.Link) error { + return mixins.StringAssembler{"ipldgit.PersonInfo.KeyAssembler"}.AssignLink(nil) +} +func (ka *_PersonInfo__KeyAssembler) AssignNode(v ipld.Node) error { + if v2, err := v.AsString(); err != nil { + return err + } else { + return ka.AssignString(v2) + } +} +func (_PersonInfo__KeyAssembler) Prototype() ipld.NodePrototype { + return _String__Prototype{} +} +func (PersonInfo) Type() schema.Type { + return nil /*TODO:typelit*/ +} +func (n PersonInfo) Representation() ipld.Node { + return (*_PersonInfo__Repr)(n) +} +type _PersonInfo__Repr _PersonInfo +var _ ipld.Node = &_PersonInfo__Repr{} +func (_PersonInfo__Repr) Kind() ipld.Kind { + return ipld.Kind_String +} +func (_PersonInfo__Repr) LookupByString(string) (ipld.Node, error) { + return mixins.String{"ipldgit.PersonInfo.Repr"}.LookupByString("") +} +func (_PersonInfo__Repr) LookupByNode(ipld.Node) (ipld.Node, error) { + return mixins.String{"ipldgit.PersonInfo.Repr"}.LookupByNode(nil) +} +func (_PersonInfo__Repr) LookupByIndex(idx int64) (ipld.Node, error) { + return mixins.String{"ipldgit.PersonInfo.Repr"}.LookupByIndex(0) +} +func (_PersonInfo__Repr) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { + return mixins.String{"ipldgit.PersonInfo.Repr"}.LookupBySegment(seg) +} +func (_PersonInfo__Repr) MapIterator() ipld.MapIterator { + return nil +} +func (_PersonInfo__Repr) ListIterator() ipld.ListIterator { + return nil +} +func (_PersonInfo__Repr) Length() int64 { + return -1 +} +func (_PersonInfo__Repr) IsAbsent() bool { + return false +} +func (_PersonInfo__Repr) IsNull() bool { + return false +} +func (_PersonInfo__Repr) AsBool() (bool, error) { + return mixins.String{"ipldgit.PersonInfo.Repr"}.AsBool() +} +func (_PersonInfo__Repr) AsInt() (int64, error) { + return mixins.String{"ipldgit.PersonInfo.Repr"}.AsInt() +} +func (_PersonInfo__Repr) AsFloat() (float64, error) { + return mixins.String{"ipldgit.PersonInfo.Repr"}.AsFloat() +} +func (n *_PersonInfo__Repr) AsString() (string, error) { + return n.String(), nil +} +func (n *_PersonInfo__Repr) String() string { + return (*_String__Repr)(&n.Name).String() + " " + (*_String__Repr)(&n.Email).String() + " " + (*_String__Repr)(&n.Date).String() + " " + (*_String__Repr)(&n.Timezone).String() +} +func (n PersonInfo) String() string { + return (*_PersonInfo__Repr)(n).String() +} +func (_PersonInfo__Repr) AsBytes() ([]byte, error) { + return mixins.String{"ipldgit.PersonInfo.Repr"}.AsBytes() +} +func (_PersonInfo__Repr) AsLink() (ipld.Link, error) { + return mixins.String{"ipldgit.PersonInfo.Repr"}.AsLink() +} +func (_PersonInfo__Repr) Prototype() ipld.NodePrototype { + return _PersonInfo__ReprPrototype{} +} +type _PersonInfo__ReprPrototype struct{} + +func (_PersonInfo__ReprPrototype) NewBuilder() ipld.NodeBuilder { + var nb _PersonInfo__ReprBuilder + nb.Reset() + return &nb +} +type _PersonInfo__ReprBuilder struct { + _PersonInfo__ReprAssembler +} +func (nb *_PersonInfo__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 *_PersonInfo__ReprBuilder) Reset() { + var w _PersonInfo + var m schema.Maybe + *nb = _PersonInfo__ReprBuilder{_PersonInfo__ReprAssembler{w: &w, m: &m}} +} +func (_PersonInfo__ReprPrototype) fromString(w *_PersonInfo, v string) error { + ss, err := mixins.SplitExact(v, " ", 4) + if err != nil { + return ipld.ErrUnmatchable{TypeName:"ipldgit.PersonInfo.Repr", Reason: err} + } + if err := (_String__ReprPrototype{}).fromString(&w.Name, ss[0]); err != nil { + return ipld.ErrUnmatchable{TypeName:"ipldgit.PersonInfo.Repr", Reason: err} + } + if err := (_String__ReprPrototype{}).fromString(&w.Email, ss[1]); err != nil { + return ipld.ErrUnmatchable{TypeName:"ipldgit.PersonInfo.Repr", Reason: err} + } + if err := (_String__ReprPrototype{}).fromString(&w.Date, ss[2]); err != nil { + return ipld.ErrUnmatchable{TypeName:"ipldgit.PersonInfo.Repr", Reason: err} + } + if err := (_String__ReprPrototype{}).fromString(&w.Timezone, ss[3]); err != nil { + return ipld.ErrUnmatchable{TypeName:"ipldgit.PersonInfo.Repr", Reason: err} + } + return nil +} +type _PersonInfo__ReprAssembler struct { + w *_PersonInfo + m *schema.Maybe +} + +func (na *_PersonInfo__ReprAssembler) reset() {} +func (_PersonInfo__ReprAssembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { + return mixins.StringAssembler{"ipldgit.PersonInfo.Repr"}.BeginMap(0) +} +func (_PersonInfo__ReprAssembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { + return mixins.StringAssembler{"ipldgit.PersonInfo.Repr"}.BeginList(0) +} +func (na *_PersonInfo__ReprAssembler) AssignNull() error { + switch *na.m { + case allowNull: + *na.m = schema.Maybe_Null + return nil + case schema.Maybe_Absent: + return mixins.StringAssembler{"ipldgit.PersonInfo.Repr.Repr"}.AssignNull() + case schema.Maybe_Value, schema.Maybe_Null: + panic("invalid state: cannot assign into assembler that's already finished") + } + panic("unreachable") +} +func (_PersonInfo__ReprAssembler) AssignBool(bool) error { + return mixins.StringAssembler{"ipldgit.PersonInfo.Repr"}.AssignBool(false) +} +func (_PersonInfo__ReprAssembler) AssignInt(int64) error { + return mixins.StringAssembler{"ipldgit.PersonInfo.Repr"}.AssignInt(0) +} +func (_PersonInfo__ReprAssembler) AssignFloat(float64) error { + return mixins.StringAssembler{"ipldgit.PersonInfo.Repr"}.AssignFloat(0) +} +func (na *_PersonInfo__ReprAssembler) 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 = &_PersonInfo{} + } + if err := (_PersonInfo__ReprPrototype{}).fromString(na.w, v); err != nil { + return err + } + *na.m = schema.Maybe_Value + return nil +} +func (_PersonInfo__ReprAssembler) AssignBytes([]byte) error { + return mixins.StringAssembler{"ipldgit.PersonInfo.Repr"}.AssignBytes(nil) +} +func (_PersonInfo__ReprAssembler) AssignLink(ipld.Link) error { + return mixins.StringAssembler{"ipldgit.PersonInfo.Repr"}.AssignLink(nil) +} +func (na *_PersonInfo__ReprAssembler) AssignNode(v ipld.Node) error { + if v.IsNull() { + return na.AssignNull() + } + if v2, ok := v.(*_PersonInfo); 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 (_PersonInfo__ReprAssembler) Prototype() ipld.NodePrototype { + return _PersonInfo__ReprPrototype{} +} + +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) Kind() ipld.Kind { + return ipld.Kind_String +} +func (String) LookupByString(string) (ipld.Node, error) { + return mixins.String{"ipldgit.String"}.LookupByString("") +} +func (String) LookupByNode(ipld.Node) (ipld.Node, error) { + return mixins.String{"ipldgit.String"}.LookupByNode(nil) +} +func (String) LookupByIndex(idx int64) (ipld.Node, error) { + return mixins.String{"ipldgit.String"}.LookupByIndex(0) +} +func (String) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { + return mixins.String{"ipldgit.String"}.LookupBySegment(seg) +} +func (String) MapIterator() ipld.MapIterator { + return nil +} +func (String) ListIterator() ipld.ListIterator { + return nil +} +func (String) Length() int64 { + return -1 +} +func (String) IsAbsent() bool { + return false +} +func (String) IsNull() bool { + return false +} +func (String) AsBool() (bool, error) { + return mixins.String{"ipldgit.String"}.AsBool() +} +func (String) AsInt() (int64, error) { + return mixins.String{"ipldgit.String"}.AsInt() +} +func (String) AsFloat() (float64, error) { + return mixins.String{"ipldgit.String"}.AsFloat() +} +func (n String) AsString() (string, error) { + return n.x, nil +} +func (String) AsBytes() ([]byte, error) { + return mixins.String{"ipldgit.String"}.AsBytes() +} +func (String) AsLink() (ipld.Link, error) { + return mixins.String{"ipldgit.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 int64) (ipld.MapAssembler, error) { + return mixins.StringAssembler{"ipldgit.String"}.BeginMap(0) +} +func (_String__Assembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { + return mixins.StringAssembler{"ipldgit.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{"ipldgit.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{"ipldgit.String"}.AssignBool(false) +} +func (_String__Assembler) AssignInt(int64) error { + return mixins.StringAssembler{"ipldgit.String"}.AssignInt(0) +} +func (_String__Assembler) AssignFloat(float64) error { + return mixins.StringAssembler{"ipldgit.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{"ipldgit.String"}.AssignBytes(nil) +} +func (_String__Assembler) AssignLink(ipld.Link) error { + return mixins.StringAssembler{"ipldgit.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 + + +func (n _Tag) FieldObject() Link { + return &n.Object +} +func (n _Tag) FieldTagType() String { + return &n.TagType +} +func (n _Tag) FieldTag() String { + return &n.Tag +} +func (n _Tag) FieldTagger() PersonInfo { + return &n.Tagger +} +func (n _Tag) FieldText() String { + return &n.Text +} +type _Tag__Maybe struct { + m schema.Maybe + v Tag +} +type MaybeTag = *_Tag__Maybe + +func (m MaybeTag) IsNull() bool { + return m.m == schema.Maybe_Null +} +func (m MaybeTag) IsAbsent() bool { + return m.m == schema.Maybe_Absent +} +func (m MaybeTag) Exists() bool { + return m.m == schema.Maybe_Value +} +func (m MaybeTag) 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 MaybeTag) Must() Tag { + if !m.Exists() { + panic("unbox of a maybe rejected") + } + return m.v +} +var ( + fieldName__Tag_Object = _String{"Object"} + fieldName__Tag_TagType = _String{"TagType"} + fieldName__Tag_Tag = _String{"Tag"} + fieldName__Tag_Tagger = _String{"Tagger"} + fieldName__Tag_Text = _String{"Text"} +) +var _ ipld.Node = (Tag)(&_Tag{}) +var _ schema.TypedNode = (Tag)(&_Tag{}) +func (Tag) Kind() ipld.Kind { + return ipld.Kind_Map +} +func (n Tag) LookupByString(key string) (ipld.Node, error) { + switch key { + case "Object": + return &n.Object, nil + case "TagType": + return &n.TagType, nil + case "Tag": + return &n.Tag, nil + case "Tagger": + return &n.Tagger, nil + case "Text": + return &n.Text, nil + default: + return nil, schema.ErrNoSuchField{Type: nil /*TODO*/, Field: ipld.PathSegmentOfString(key)} + } +} +func (n Tag) LookupByNode(key ipld.Node) (ipld.Node, error) { + ks, err := key.AsString() + if err != nil { + return nil, err + } + return n.LookupByString(ks) +} +func (Tag) LookupByIndex(idx int64) (ipld.Node, error) { + return mixins.Map{"ipldgit.Tag"}.LookupByIndex(0) +} +func (n Tag) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { + return n.LookupByString(seg.String()) +} +func (n Tag) MapIterator() ipld.MapIterator { + return &_Tag__MapItr{n, 0} +} + +type _Tag__MapItr struct { + n Tag + idx int +} + +func (itr *_Tag__MapItr) Next() (k ipld.Node, v ipld.Node, _ error) { + if itr.idx >= 5 { + return nil, nil, ipld.ErrIteratorOverread{} + } + switch itr.idx { + case 0: + k = &fieldName__Tag_Object + v = &itr.n.Object + case 1: + k = &fieldName__Tag_TagType + v = &itr.n.TagType + case 2: + k = &fieldName__Tag_Tag + v = &itr.n.Tag + case 3: + k = &fieldName__Tag_Tagger + v = &itr.n.Tagger + case 4: + k = &fieldName__Tag_Text + v = &itr.n.Text + default: + panic("unreachable") + } + itr.idx++ + return +} +func (itr *_Tag__MapItr) Done() bool { + return itr.idx >= 5 +} + +func (Tag) ListIterator() ipld.ListIterator { + return nil +} +func (Tag) Length() int64 { + return 5 +} +func (Tag) IsAbsent() bool { + return false +} +func (Tag) IsNull() bool { + return false +} +func (Tag) AsBool() (bool, error) { + return mixins.Map{"ipldgit.Tag"}.AsBool() +} +func (Tag) AsInt() (int64, error) { + return mixins.Map{"ipldgit.Tag"}.AsInt() +} +func (Tag) AsFloat() (float64, error) { + return mixins.Map{"ipldgit.Tag"}.AsFloat() +} +func (Tag) AsString() (string, error) { + return mixins.Map{"ipldgit.Tag"}.AsString() +} +func (Tag) AsBytes() ([]byte, error) { + return mixins.Map{"ipldgit.Tag"}.AsBytes() +} +func (Tag) AsLink() (ipld.Link, error) { + return mixins.Map{"ipldgit.Tag"}.AsLink() +} +func (Tag) Prototype() ipld.NodePrototype { + return _Tag__Prototype{} +} +type _Tag__Prototype struct{} + +func (_Tag__Prototype) NewBuilder() ipld.NodeBuilder { + var nb _Tag__Builder + nb.Reset() + return &nb +} +type _Tag__Builder struct { + _Tag__Assembler +} +func (nb *_Tag__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 *_Tag__Builder) Reset() { + var w _Tag + var m schema.Maybe + *nb = _Tag__Builder{_Tag__Assembler{w: &w, m: &m}} +} +type _Tag__Assembler struct { + w *_Tag + m *schema.Maybe + state maState + s int + f int + + cm schema.Maybe + ca_Object _Link__Assembler + ca_TagType _String__Assembler + ca_Tag _String__Assembler + ca_Tagger _PersonInfo__Assembler + ca_Text _String__Assembler + } + +func (na *_Tag__Assembler) reset() { + na.state = maState_initial + na.s = 0 + na.ca_Object.reset() + na.ca_TagType.reset() + na.ca_Tag.reset() + na.ca_Tagger.reset() + na.ca_Text.reset() +} + +var ( + fieldBit__Tag_Object = 1 << 0 + fieldBit__Tag_TagType = 1 << 1 + fieldBit__Tag_Tag = 1 << 2 + fieldBit__Tag_Tagger = 1 << 3 + fieldBit__Tag_Text = 1 << 4 + fieldBits__Tag_sufficient = 0 + 1 << 0 + 1 << 1 + 1 << 2 + 1 << 3 + 1 << 4 +) +func (na *_Tag__Assembler) BeginMap(int64) (ipld.MapAssembler, 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 na.w == nil { + na.w = &_Tag{} + } + return na, nil +} +func (_Tag__Assembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { + return mixins.MapAssembler{"ipldgit.Tag"}.BeginList(0) +} +func (na *_Tag__Assembler) AssignNull() error { + switch *na.m { + case allowNull: + *na.m = schema.Maybe_Null + return nil + case schema.Maybe_Absent: + return mixins.MapAssembler{"ipldgit.Tag"}.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 (_Tag__Assembler) AssignBool(bool) error { + return mixins.MapAssembler{"ipldgit.Tag"}.AssignBool(false) +} +func (_Tag__Assembler) AssignInt(int64) error { + return mixins.MapAssembler{"ipldgit.Tag"}.AssignInt(0) +} +func (_Tag__Assembler) AssignFloat(float64) error { + return mixins.MapAssembler{"ipldgit.Tag"}.AssignFloat(0) +} +func (_Tag__Assembler) AssignString(string) error { + return mixins.MapAssembler{"ipldgit.Tag"}.AssignString("") +} +func (_Tag__Assembler) AssignBytes([]byte) error { + return mixins.MapAssembler{"ipldgit.Tag"}.AssignBytes(nil) +} +func (_Tag__Assembler) AssignLink(ipld.Link) error { + return mixins.MapAssembler{"ipldgit.Tag"}.AssignLink(nil) +} +func (na *_Tag__Assembler) AssignNode(v ipld.Node) error { + if v.IsNull() { + return na.AssignNull() + } + if v2, ok := v.(*_Tag); 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.Kind() != ipld.Kind_Map { + return ipld.ErrWrongKind{TypeName: "ipldgit.Tag", MethodName: "AssignNode", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()} + } + itr := v.MapIterator() + for !itr.Done() { + k, v, err := itr.Next() + if err != nil { + return err + } + if err := na.AssembleKey().AssignNode(k); err != nil { + return err + } + if err := na.AssembleValue().AssignNode(v); err != nil { + return err + } + } + return na.Finish() +} +func (_Tag__Assembler) Prototype() ipld.NodePrototype { + return _Tag__Prototype{} +} +func (ma *_Tag__Assembler) valueFinishTidy() bool { + switch ma.f { + case 0: + switch ma.cm { + case schema.Maybe_Value: + ma.ca_Object.w = nil + ma.cm = schema.Maybe_Absent + ma.state = maState_initial + return true + default: + return false + } + case 1: + switch ma.cm { + case schema.Maybe_Value: + ma.ca_TagType.w = nil + ma.cm = schema.Maybe_Absent + ma.state = maState_initial + return true + default: + return false + } + case 2: + switch ma.cm { + case schema.Maybe_Value: + ma.ca_Tag.w = nil + ma.cm = schema.Maybe_Absent + ma.state = maState_initial + return true + default: + return false + } + case 3: + switch ma.cm { + case schema.Maybe_Value: + ma.ca_Tagger.w = nil + ma.cm = schema.Maybe_Absent + ma.state = maState_initial + return true + default: + return false + } + case 4: + switch ma.cm { + case schema.Maybe_Value: + ma.ca_Text.w = nil + ma.cm = schema.Maybe_Absent + ma.state = maState_initial + return true + default: + return false + } + default: + panic("unreachable") + } +} +func (ma *_Tag__Assembler) AssembleEntry(k string) (ipld.NodeAssembler, error) { + switch ma.state { + case maState_initial: + // carry on + case maState_midKey: + panic("invalid state: AssembleEntry cannot be called when in the middle of assembling another key") + case maState_expectValue: + panic("invalid state: AssembleEntry cannot be called when expecting start of value assembly") + case maState_midValue: + if !ma.valueFinishTidy() { + panic("invalid state: AssembleEntry cannot be called when in the middle of assembling a value") + } // if tidy success: carry on + case maState_finished: + panic("invalid state: AssembleEntry cannot be called on an assembler that's already finished") + } + switch k { + case "Object": + if ma.s & fieldBit__Tag_Object != 0 { + return nil, ipld.ErrRepeatedMapKey{&fieldName__Tag_Object} + } + ma.s += fieldBit__Tag_Object + ma.state = maState_midValue + ma.f = 0 + ma.ca_Object.w = &ma.w.Object + ma.ca_Object.m = &ma.cm + return &ma.ca_Object, nil + case "TagType": + if ma.s & fieldBit__Tag_TagType != 0 { + return nil, ipld.ErrRepeatedMapKey{&fieldName__Tag_TagType} + } + ma.s += fieldBit__Tag_TagType + ma.state = maState_midValue + ma.f = 1 + ma.ca_TagType.w = &ma.w.TagType + ma.ca_TagType.m = &ma.cm + return &ma.ca_TagType, nil + case "Tag": + if ma.s & fieldBit__Tag_Tag != 0 { + return nil, ipld.ErrRepeatedMapKey{&fieldName__Tag_Tag} + } + ma.s += fieldBit__Tag_Tag + ma.state = maState_midValue + ma.f = 2 + ma.ca_Tag.w = &ma.w.Tag + ma.ca_Tag.m = &ma.cm + return &ma.ca_Tag, nil + case "Tagger": + if ma.s & fieldBit__Tag_Tagger != 0 { + return nil, ipld.ErrRepeatedMapKey{&fieldName__Tag_Tagger} + } + ma.s += fieldBit__Tag_Tagger + ma.state = maState_midValue + ma.f = 3 + ma.ca_Tagger.w = &ma.w.Tagger + ma.ca_Tagger.m = &ma.cm + return &ma.ca_Tagger, nil + case "Text": + if ma.s & fieldBit__Tag_Text != 0 { + return nil, ipld.ErrRepeatedMapKey{&fieldName__Tag_Text} + } + ma.s += fieldBit__Tag_Text + ma.state = maState_midValue + ma.f = 4 + ma.ca_Text.w = &ma.w.Text + ma.ca_Text.m = &ma.cm + return &ma.ca_Text, nil + default: + return nil, ipld.ErrInvalidKey{TypeName:"ipldgit.Tag", Key:&_String{k}} + } +} +func (ma *_Tag__Assembler) AssembleKey() ipld.NodeAssembler { + switch ma.state { + case maState_initial: + // carry on + case maState_midKey: + panic("invalid state: AssembleKey cannot be called when in the middle of assembling another key") + case maState_expectValue: + panic("invalid state: AssembleKey cannot be called when expecting start of value assembly") + case maState_midValue: + if !ma.valueFinishTidy() { + panic("invalid state: AssembleKey cannot be called when in the middle of assembling a value") + } // if tidy success: carry on + case maState_finished: + panic("invalid state: AssembleKey cannot be called on an assembler that's already finished") + } + ma.state = maState_midKey + return (*_Tag__KeyAssembler)(ma) +} +func (ma *_Tag__Assembler) AssembleValue() ipld.NodeAssembler { + switch ma.state { + case maState_initial: + panic("invalid state: AssembleValue cannot be called when no key is primed") + case maState_midKey: + panic("invalid state: AssembleValue cannot be called when in the middle of assembling a key") + case maState_expectValue: + // carry on + case maState_midValue: + panic("invalid state: AssembleValue cannot be called when in the middle of assembling another value") + case maState_finished: + panic("invalid state: AssembleValue cannot be called on an assembler that's already finished") + } + ma.state = maState_midValue + switch ma.f { + case 0: + ma.ca_Object.w = &ma.w.Object + ma.ca_Object.m = &ma.cm + return &ma.ca_Object + case 1: + ma.ca_TagType.w = &ma.w.TagType + ma.ca_TagType.m = &ma.cm + return &ma.ca_TagType + case 2: + ma.ca_Tag.w = &ma.w.Tag + ma.ca_Tag.m = &ma.cm + return &ma.ca_Tag + case 3: + ma.ca_Tagger.w = &ma.w.Tagger + ma.ca_Tagger.m = &ma.cm + return &ma.ca_Tagger + case 4: + ma.ca_Text.w = &ma.w.Text + ma.ca_Text.m = &ma.cm + return &ma.ca_Text + default: + panic("unreachable") + } +} +func (ma *_Tag__Assembler) Finish() error { + switch ma.state { + case maState_initial: + // carry on + case maState_midKey: + panic("invalid state: Finish cannot be called when in the middle of assembling a key") + case maState_expectValue: + panic("invalid state: Finish cannot be called when expecting start of value assembly") + case maState_midValue: + if !ma.valueFinishTidy() { + panic("invalid state: Finish cannot be called when in the middle of assembling a value") + } // if tidy success: carry on + case maState_finished: + panic("invalid state: Finish cannot be called on an assembler that's already finished") + } + if ma.s & fieldBits__Tag_sufficient != fieldBits__Tag_sufficient { + err := ipld.ErrMissingRequiredField{Missing: make([]string, 0)} + if ma.s & fieldBit__Tag_Object == 0 { + err.Missing = append(err.Missing, "Object") + } + if ma.s & fieldBit__Tag_TagType == 0 { + err.Missing = append(err.Missing, "TagType") + } + if ma.s & fieldBit__Tag_Tag == 0 { + err.Missing = append(err.Missing, "Tag") + } + if ma.s & fieldBit__Tag_Tagger == 0 { + err.Missing = append(err.Missing, "Tagger") + } + if ma.s & fieldBit__Tag_Text == 0 { + err.Missing = append(err.Missing, "Text") + } + return err + } + ma.state = maState_finished + *ma.m = schema.Maybe_Value + return nil +} +func (ma *_Tag__Assembler) KeyPrototype() ipld.NodePrototype { + return _String__Prototype{} +} +func (ma *_Tag__Assembler) ValuePrototype(k string) ipld.NodePrototype { + panic("todo structbuilder mapassembler valueprototype") +} +type _Tag__KeyAssembler _Tag__Assembler +func (_Tag__KeyAssembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { + return mixins.StringAssembler{"ipldgit.Tag.KeyAssembler"}.BeginMap(0) +} +func (_Tag__KeyAssembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { + return mixins.StringAssembler{"ipldgit.Tag.KeyAssembler"}.BeginList(0) +} +func (na *_Tag__KeyAssembler) AssignNull() error { + return mixins.StringAssembler{"ipldgit.Tag.KeyAssembler"}.AssignNull() +} +func (_Tag__KeyAssembler) AssignBool(bool) error { + return mixins.StringAssembler{"ipldgit.Tag.KeyAssembler"}.AssignBool(false) +} +func (_Tag__KeyAssembler) AssignInt(int64) error { + return mixins.StringAssembler{"ipldgit.Tag.KeyAssembler"}.AssignInt(0) +} +func (_Tag__KeyAssembler) AssignFloat(float64) error { + return mixins.StringAssembler{"ipldgit.Tag.KeyAssembler"}.AssignFloat(0) +} +func (ka *_Tag__KeyAssembler) AssignString(k string) error { + if ka.state != maState_midKey { + panic("misuse: KeyAssembler held beyond its valid lifetime") + } + switch k { + case "Object": + if ka.s & fieldBit__Tag_Object != 0 { + return ipld.ErrRepeatedMapKey{&fieldName__Tag_Object} + } + ka.s += fieldBit__Tag_Object + ka.state = maState_expectValue + ka.f = 0 + case "TagType": + if ka.s & fieldBit__Tag_TagType != 0 { + return ipld.ErrRepeatedMapKey{&fieldName__Tag_TagType} + } + ka.s += fieldBit__Tag_TagType + ka.state = maState_expectValue + ka.f = 1 + case "Tag": + if ka.s & fieldBit__Tag_Tag != 0 { + return ipld.ErrRepeatedMapKey{&fieldName__Tag_Tag} + } + ka.s += fieldBit__Tag_Tag + ka.state = maState_expectValue + ka.f = 2 + case "Tagger": + if ka.s & fieldBit__Tag_Tagger != 0 { + return ipld.ErrRepeatedMapKey{&fieldName__Tag_Tagger} + } + ka.s += fieldBit__Tag_Tagger + ka.state = maState_expectValue + ka.f = 3 + case "Text": + if ka.s & fieldBit__Tag_Text != 0 { + return ipld.ErrRepeatedMapKey{&fieldName__Tag_Text} + } + ka.s += fieldBit__Tag_Text + ka.state = maState_expectValue + ka.f = 4 + default: + return ipld.ErrInvalidKey{TypeName:"ipldgit.Tag", Key:&_String{k}} + } + return nil +} +func (_Tag__KeyAssembler) AssignBytes([]byte) error { + return mixins.StringAssembler{"ipldgit.Tag.KeyAssembler"}.AssignBytes(nil) +} +func (_Tag__KeyAssembler) AssignLink(ipld.Link) error { + return mixins.StringAssembler{"ipldgit.Tag.KeyAssembler"}.AssignLink(nil) +} +func (ka *_Tag__KeyAssembler) AssignNode(v ipld.Node) error { + if v2, err := v.AsString(); err != nil { + return err + } else { + return ka.AssignString(v2) + } +} +func (_Tag__KeyAssembler) Prototype() ipld.NodePrototype { + return _String__Prototype{} +} +func (Tag) Type() schema.Type { + return nil /*TODO:typelit*/ +} +func (n Tag) Representation() ipld.Node { + return (*_Tag__Repr)(n) +} +type _Tag__Repr _Tag +var ( + fieldName__Tag_Object_serial = _String{"Object"} + fieldName__Tag_TagType_serial = _String{"TagType"} + fieldName__Tag_Tag_serial = _String{"Tag"} + fieldName__Tag_Tagger_serial = _String{"Tagger"} + fieldName__Tag_Text_serial = _String{"Text"} +) +var _ ipld.Node = &_Tag__Repr{} +func (_Tag__Repr) Kind() ipld.Kind { + return ipld.Kind_Map +} +func (n *_Tag__Repr) LookupByString(key string) (ipld.Node, error) { + switch key { + case "Object": + return n.Object.Representation(), nil + case "TagType": + return n.TagType.Representation(), nil + case "Tag": + return n.Tag.Representation(), nil + case "Tagger": + return n.Tagger.Representation(), nil + case "Text": + return n.Text.Representation(), nil + default: + return nil, schema.ErrNoSuchField{Type: nil /*TODO*/, Field: ipld.PathSegmentOfString(key)} + } +} +func (n *_Tag__Repr) LookupByNode(key ipld.Node) (ipld.Node, error) { + ks, err := key.AsString() + if err != nil { + return nil, err + } + return n.LookupByString(ks) +} +func (_Tag__Repr) LookupByIndex(idx int64) (ipld.Node, error) { + return mixins.Map{"ipldgit.Tag.Repr"}.LookupByIndex(0) +} +func (n _Tag__Repr) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { + return n.LookupByString(seg.String()) +} +func (n *_Tag__Repr) MapIterator() ipld.MapIterator { + return &_Tag__ReprMapItr{n, 0} +} + +type _Tag__ReprMapItr struct { + n *_Tag__Repr + idx int + +} + +func (itr *_Tag__ReprMapItr) Next() (k ipld.Node, v ipld.Node, _ error) { +if itr.idx >= 5 { + return nil, nil, ipld.ErrIteratorOverread{} + } + switch itr.idx { + case 0: + k = &fieldName__Tag_Object_serial + v = itr.n.Object.Representation() + case 1: + k = &fieldName__Tag_TagType_serial + v = itr.n.TagType.Representation() + case 2: + k = &fieldName__Tag_Tag_serial + v = itr.n.Tag.Representation() + case 3: + k = &fieldName__Tag_Tagger_serial + v = itr.n.Tagger.Representation() + case 4: + k = &fieldName__Tag_Text_serial + v = itr.n.Text.Representation() + default: + panic("unreachable") + } + itr.idx++ + return +} +func (itr *_Tag__ReprMapItr) Done() bool { + return itr.idx >= 5 +} +func (_Tag__Repr) ListIterator() ipld.ListIterator { + return nil +} +func (rn *_Tag__Repr) Length() int64 { + l := 5 + return int64(l) +} +func (_Tag__Repr) IsAbsent() bool { + return false +} +func (_Tag__Repr) IsNull() bool { + return false +} +func (_Tag__Repr) AsBool() (bool, error) { + return mixins.Map{"ipldgit.Tag.Repr"}.AsBool() +} +func (_Tag__Repr) AsInt() (int64, error) { + return mixins.Map{"ipldgit.Tag.Repr"}.AsInt() +} +func (_Tag__Repr) AsFloat() (float64, error) { + return mixins.Map{"ipldgit.Tag.Repr"}.AsFloat() +} +func (_Tag__Repr) AsString() (string, error) { + return mixins.Map{"ipldgit.Tag.Repr"}.AsString() +} +func (_Tag__Repr) AsBytes() ([]byte, error) { + return mixins.Map{"ipldgit.Tag.Repr"}.AsBytes() +} +func (_Tag__Repr) AsLink() (ipld.Link, error) { + return mixins.Map{"ipldgit.Tag.Repr"}.AsLink() +} +func (_Tag__Repr) Prototype() ipld.NodePrototype { + return _Tag__ReprPrototype{} +} +type _Tag__ReprPrototype struct{} + +func (_Tag__ReprPrototype) NewBuilder() ipld.NodeBuilder { + var nb _Tag__ReprBuilder + nb.Reset() + return &nb +} +type _Tag__ReprBuilder struct { + _Tag__ReprAssembler +} +func (nb *_Tag__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 *_Tag__ReprBuilder) Reset() { + var w _Tag + var m schema.Maybe + *nb = _Tag__ReprBuilder{_Tag__ReprAssembler{w: &w, m: &m}} +} +type _Tag__ReprAssembler struct { + w *_Tag + m *schema.Maybe + state maState + s int + f int + + cm schema.Maybe + ca_Object _Link__ReprAssembler + ca_TagType _String__ReprAssembler + ca_Tag _String__ReprAssembler + ca_Tagger _PersonInfo__ReprAssembler + ca_Text _String__ReprAssembler + } + +func (na *_Tag__ReprAssembler) reset() { + na.state = maState_initial + na.s = 0 + na.ca_Object.reset() + na.ca_TagType.reset() + na.ca_Tag.reset() + na.ca_Tagger.reset() + na.ca_Text.reset() +} +func (na *_Tag__ReprAssembler) BeginMap(int64) (ipld.MapAssembler, 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 na.w == nil { + na.w = &_Tag{} + } + return na, nil +} +func (_Tag__ReprAssembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { + return mixins.MapAssembler{"ipldgit.Tag.Repr"}.BeginList(0) +} +func (na *_Tag__ReprAssembler) AssignNull() error { + switch *na.m { + case allowNull: + *na.m = schema.Maybe_Null + return nil + case schema.Maybe_Absent: + return mixins.MapAssembler{"ipldgit.Tag.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 (_Tag__ReprAssembler) AssignBool(bool) error { + return mixins.MapAssembler{"ipldgit.Tag.Repr"}.AssignBool(false) +} +func (_Tag__ReprAssembler) AssignInt(int64) error { + return mixins.MapAssembler{"ipldgit.Tag.Repr"}.AssignInt(0) +} +func (_Tag__ReprAssembler) AssignFloat(float64) error { + return mixins.MapAssembler{"ipldgit.Tag.Repr"}.AssignFloat(0) +} +func (_Tag__ReprAssembler) AssignString(string) error { + return mixins.MapAssembler{"ipldgit.Tag.Repr"}.AssignString("") +} +func (_Tag__ReprAssembler) AssignBytes([]byte) error { + return mixins.MapAssembler{"ipldgit.Tag.Repr"}.AssignBytes(nil) +} +func (_Tag__ReprAssembler) AssignLink(ipld.Link) error { + return mixins.MapAssembler{"ipldgit.Tag.Repr"}.AssignLink(nil) +} +func (na *_Tag__ReprAssembler) AssignNode(v ipld.Node) error { + if v.IsNull() { + return na.AssignNull() + } + if v2, ok := v.(*_Tag); 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.Kind() != ipld.Kind_Map { + return ipld.ErrWrongKind{TypeName: "ipldgit.Tag.Repr", MethodName: "AssignNode", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()} + } + itr := v.MapIterator() + for !itr.Done() { + k, v, err := itr.Next() + if err != nil { + return err + } + if err := na.AssembleKey().AssignNode(k); err != nil { + return err + } + if err := na.AssembleValue().AssignNode(v); err != nil { + return err + } + } + return na.Finish() +} +func (_Tag__ReprAssembler) Prototype() ipld.NodePrototype { + return _Tag__ReprPrototype{} +} +func (ma *_Tag__ReprAssembler) valueFinishTidy() bool { + switch ma.f { + case 0: + switch ma.cm { + case schema.Maybe_Value:ma.cm = schema.Maybe_Absent + ma.state = maState_initial + return true + default: + return false + } + case 1: + switch ma.cm { + case schema.Maybe_Value:ma.cm = schema.Maybe_Absent + ma.state = maState_initial + return true + default: + return false + } + case 2: + switch ma.cm { + case schema.Maybe_Value:ma.cm = schema.Maybe_Absent + ma.state = maState_initial + return true + default: + return false + } + case 3: + switch ma.cm { + case schema.Maybe_Value:ma.cm = schema.Maybe_Absent + ma.state = maState_initial + return true + default: + return false + } + case 4: + switch ma.cm { + case schema.Maybe_Value:ma.cm = schema.Maybe_Absent + ma.state = maState_initial + return true + default: + return false + } + default: + panic("unreachable") + } +} +func (ma *_Tag__ReprAssembler) AssembleEntry(k string) (ipld.NodeAssembler, error) { + switch ma.state { + case maState_initial: + // carry on + case maState_midKey: + panic("invalid state: AssembleEntry cannot be called when in the middle of assembling another key") + case maState_expectValue: + panic("invalid state: AssembleEntry cannot be called when expecting start of value assembly") + case maState_midValue: + if !ma.valueFinishTidy() { + panic("invalid state: AssembleEntry cannot be called when in the middle of assembling a value") + } // if tidy success: carry on + case maState_finished: + panic("invalid state: AssembleEntry cannot be called on an assembler that's already finished") + } + switch k { + case "Object": + if ma.s & fieldBit__Tag_Object != 0 { + return nil, ipld.ErrRepeatedMapKey{&fieldName__Tag_Object_serial} + } + ma.s += fieldBit__Tag_Object + ma.state = maState_midValue + ma.f = 0 + ma.ca_Object.w = &ma.w.Object + ma.ca_Object.m = &ma.cm + return &ma.ca_Object, nil + case "TagType": + if ma.s & fieldBit__Tag_TagType != 0 { + return nil, ipld.ErrRepeatedMapKey{&fieldName__Tag_TagType_serial} + } + ma.s += fieldBit__Tag_TagType + ma.state = maState_midValue + ma.f = 1 + ma.ca_TagType.w = &ma.w.TagType + ma.ca_TagType.m = &ma.cm + return &ma.ca_TagType, nil + case "Tag": + if ma.s & fieldBit__Tag_Tag != 0 { + return nil, ipld.ErrRepeatedMapKey{&fieldName__Tag_Tag_serial} + } + ma.s += fieldBit__Tag_Tag + ma.state = maState_midValue + ma.f = 2 + ma.ca_Tag.w = &ma.w.Tag + ma.ca_Tag.m = &ma.cm + return &ma.ca_Tag, nil + case "Tagger": + if ma.s & fieldBit__Tag_Tagger != 0 { + return nil, ipld.ErrRepeatedMapKey{&fieldName__Tag_Tagger_serial} + } + ma.s += fieldBit__Tag_Tagger + ma.state = maState_midValue + ma.f = 3 + ma.ca_Tagger.w = &ma.w.Tagger + ma.ca_Tagger.m = &ma.cm + return &ma.ca_Tagger, nil + case "Text": + if ma.s & fieldBit__Tag_Text != 0 { + return nil, ipld.ErrRepeatedMapKey{&fieldName__Tag_Text_serial} + } + ma.s += fieldBit__Tag_Text + ma.state = maState_midValue + ma.f = 4 + ma.ca_Text.w = &ma.w.Text + ma.ca_Text.m = &ma.cm + return &ma.ca_Text, nil + default: + return nil, ipld.ErrInvalidKey{TypeName:"ipldgit.Tag.Repr", Key:&_String{k}} + } +} +func (ma *_Tag__ReprAssembler) AssembleKey() ipld.NodeAssembler { + switch ma.state { + case maState_initial: + // carry on + case maState_midKey: + panic("invalid state: AssembleKey cannot be called when in the middle of assembling another key") + case maState_expectValue: + panic("invalid state: AssembleKey cannot be called when expecting start of value assembly") + case maState_midValue: + if !ma.valueFinishTidy() { + panic("invalid state: AssembleKey cannot be called when in the middle of assembling a value") + } // if tidy success: carry on + case maState_finished: + panic("invalid state: AssembleKey cannot be called on an assembler that's already finished") + } + ma.state = maState_midKey + return (*_Tag__ReprKeyAssembler)(ma) +} +func (ma *_Tag__ReprAssembler) AssembleValue() ipld.NodeAssembler { + switch ma.state { + case maState_initial: + panic("invalid state: AssembleValue cannot be called when no key is primed") + case maState_midKey: + panic("invalid state: AssembleValue cannot be called when in the middle of assembling a key") + case maState_expectValue: + // carry on + case maState_midValue: + panic("invalid state: AssembleValue cannot be called when in the middle of assembling another value") + case maState_finished: + panic("invalid state: AssembleValue cannot be called on an assembler that's already finished") + } + ma.state = maState_midValue + switch ma.f { + case 0: + ma.ca_Object.w = &ma.w.Object + ma.ca_Object.m = &ma.cm + return &ma.ca_Object + case 1: + ma.ca_TagType.w = &ma.w.TagType + ma.ca_TagType.m = &ma.cm + return &ma.ca_TagType + case 2: + ma.ca_Tag.w = &ma.w.Tag + ma.ca_Tag.m = &ma.cm + return &ma.ca_Tag + case 3: + ma.ca_Tagger.w = &ma.w.Tagger + ma.ca_Tagger.m = &ma.cm + return &ma.ca_Tagger + case 4: + ma.ca_Text.w = &ma.w.Text + ma.ca_Text.m = &ma.cm + return &ma.ca_Text + default: + panic("unreachable") + } +} +func (ma *_Tag__ReprAssembler) Finish() error { + switch ma.state { + case maState_initial: + // carry on + case maState_midKey: + panic("invalid state: Finish cannot be called when in the middle of assembling a key") + case maState_expectValue: + panic("invalid state: Finish cannot be called when expecting start of value assembly") + case maState_midValue: + if !ma.valueFinishTidy() { + panic("invalid state: Finish cannot be called when in the middle of assembling a value") + } // if tidy success: carry on + case maState_finished: + panic("invalid state: Finish cannot be called on an assembler that's already finished") + } + if ma.s & fieldBits__Tag_sufficient != fieldBits__Tag_sufficient { + err := ipld.ErrMissingRequiredField{Missing: make([]string, 0)} + if ma.s & fieldBit__Tag_Object == 0 { + err.Missing = append(err.Missing, "Object") + } + if ma.s & fieldBit__Tag_TagType == 0 { + err.Missing = append(err.Missing, "TagType") + } + if ma.s & fieldBit__Tag_Tag == 0 { + err.Missing = append(err.Missing, "Tag") + } + if ma.s & fieldBit__Tag_Tagger == 0 { + err.Missing = append(err.Missing, "Tagger") + } + if ma.s & fieldBit__Tag_Text == 0 { + err.Missing = append(err.Missing, "Text") + } + return err + } + ma.state = maState_finished + *ma.m = schema.Maybe_Value + return nil +} +func (ma *_Tag__ReprAssembler) KeyPrototype() ipld.NodePrototype { + return _String__Prototype{} +} +func (ma *_Tag__ReprAssembler) ValuePrototype(k string) ipld.NodePrototype { + panic("todo structbuilder mapassembler repr valueprototype") +} +type _Tag__ReprKeyAssembler _Tag__ReprAssembler +func (_Tag__ReprKeyAssembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { + return mixins.StringAssembler{"ipldgit.Tag.Repr.KeyAssembler"}.BeginMap(0) +} +func (_Tag__ReprKeyAssembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { + return mixins.StringAssembler{"ipldgit.Tag.Repr.KeyAssembler"}.BeginList(0) +} +func (na *_Tag__ReprKeyAssembler) AssignNull() error { + return mixins.StringAssembler{"ipldgit.Tag.Repr.KeyAssembler"}.AssignNull() +} +func (_Tag__ReprKeyAssembler) AssignBool(bool) error { + return mixins.StringAssembler{"ipldgit.Tag.Repr.KeyAssembler"}.AssignBool(false) +} +func (_Tag__ReprKeyAssembler) AssignInt(int64) error { + return mixins.StringAssembler{"ipldgit.Tag.Repr.KeyAssembler"}.AssignInt(0) +} +func (_Tag__ReprKeyAssembler) AssignFloat(float64) error { + return mixins.StringAssembler{"ipldgit.Tag.Repr.KeyAssembler"}.AssignFloat(0) +} +func (ka *_Tag__ReprKeyAssembler) AssignString(k string) error { + if ka.state != maState_midKey { + panic("misuse: KeyAssembler held beyond its valid lifetime") + } + switch k { + case "Object": + if ka.s & fieldBit__Tag_Object != 0 { + return ipld.ErrRepeatedMapKey{&fieldName__Tag_Object_serial} + } + ka.s += fieldBit__Tag_Object + ka.state = maState_expectValue + ka.f = 0 + case "TagType": + if ka.s & fieldBit__Tag_TagType != 0 { + return ipld.ErrRepeatedMapKey{&fieldName__Tag_TagType_serial} + } + ka.s += fieldBit__Tag_TagType + ka.state = maState_expectValue + ka.f = 1 + case "Tag": + if ka.s & fieldBit__Tag_Tag != 0 { + return ipld.ErrRepeatedMapKey{&fieldName__Tag_Tag_serial} + } + ka.s += fieldBit__Tag_Tag + ka.state = maState_expectValue + ka.f = 2 + case "Tagger": + if ka.s & fieldBit__Tag_Tagger != 0 { + return ipld.ErrRepeatedMapKey{&fieldName__Tag_Tagger_serial} + } + ka.s += fieldBit__Tag_Tagger + ka.state = maState_expectValue + ka.f = 3 + case "Text": + if ka.s & fieldBit__Tag_Text != 0 { + return ipld.ErrRepeatedMapKey{&fieldName__Tag_Text_serial} + } + ka.s += fieldBit__Tag_Text + ka.state = maState_expectValue + ka.f = 4 + default: + return ipld.ErrInvalidKey{TypeName:"ipldgit.Tag.Repr", Key:&_String{k}} + } + return nil +} +func (_Tag__ReprKeyAssembler) AssignBytes([]byte) error { + return mixins.StringAssembler{"ipldgit.Tag.Repr.KeyAssembler"}.AssignBytes(nil) +} +func (_Tag__ReprKeyAssembler) AssignLink(ipld.Link) error { + return mixins.StringAssembler{"ipldgit.Tag.Repr.KeyAssembler"}.AssignLink(nil) +} +func (ka *_Tag__ReprKeyAssembler) AssignNode(v ipld.Node) error { + if v2, err := v.AsString(); err != nil { + return err + } else { + return ka.AssignString(v2) + } +} +func (_Tag__ReprKeyAssembler) Prototype() ipld.NodePrototype { + return _String__Prototype{} +} + +func (n *_Tree) Lookup(idx int64) TreeEntry { + if n.Length() <= idx { + return nil + } + v := &n.x[idx] + return v +} +func (n *_Tree) LookupMaybe(idx int64) MaybeTreeEntry { + if n.Length() <= idx { + return nil + } + v := &n.x[idx] + return &_TreeEntry__Maybe{ + m: schema.Maybe_Value, + v: v, + } +} + +var _Tree__valueAbsent = _TreeEntry__Maybe{m:schema.Maybe_Absent} +func (n Tree) Iterator() *Tree__Itr { + return &Tree__Itr{n, 0} +} + +type Tree__Itr struct { + n Tree + idx int +} + +func (itr *Tree__Itr) Next() (idx int64, v TreeEntry) { + if itr.idx >= len(itr.n.x) { + return -1, nil + } + idx = int64(itr.idx) + v = &itr.n.x[itr.idx] + itr.idx++ + return +} +func (itr *Tree__Itr) Done() bool { + return itr.idx >= len(itr.n.x) +} + +type _Tree__Maybe struct { + m schema.Maybe + v Tree +} +type MaybeTree = *_Tree__Maybe + +func (m MaybeTree) IsNull() bool { + return m.m == schema.Maybe_Null +} +func (m MaybeTree) IsAbsent() bool { + return m.m == schema.Maybe_Absent +} +func (m MaybeTree) Exists() bool { + return m.m == schema.Maybe_Value +} +func (m MaybeTree) 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 MaybeTree) Must() Tree { + if !m.Exists() { + panic("unbox of a maybe rejected") + } + return m.v +} +var _ ipld.Node = (Tree)(&_Tree{}) +var _ schema.TypedNode = (Tree)(&_Tree{}) +func (Tree) Kind() ipld.Kind { + return ipld.Kind_List +} +func (Tree) LookupByString(string) (ipld.Node, error) { + return mixins.List{"ipldgit.Tree"}.LookupByString("") +} +func (n Tree) LookupByNode(k ipld.Node) (ipld.Node, error) { + idx, err := k.AsInt() + if err != nil { + return nil, err + } + return n.LookupByIndex(idx) +} +func (n Tree) LookupByIndex(idx int64) (ipld.Node, error) { + if n.Length() <= idx { + return nil, ipld.ErrNotExists{ipld.PathSegmentOfInt(idx)} + } + v := &n.x[idx] + return v, nil +} +func (n Tree) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { + i, err := seg.Index() + if err != nil { + return nil, ipld.ErrInvalidSegmentForList{TypeName: "ipldgit.Tree", TroubleSegment: seg, Reason: err} + } + return n.LookupByIndex(i) +} +func (Tree) MapIterator() ipld.MapIterator { + return nil +} +func (n Tree) ListIterator() ipld.ListIterator { + return &_Tree__ListItr{n, 0} +} + +type _Tree__ListItr struct { + n Tree + idx int +} + +func (itr *_Tree__ListItr) Next() (idx int64, v ipld.Node, _ error) { + if itr.idx >= len(itr.n.x) { + return -1, nil, ipld.ErrIteratorOverread{} + } + idx = int64(itr.idx) + x := &itr.n.x[itr.idx] + v = x + itr.idx++ + return +} +func (itr *_Tree__ListItr) Done() bool { + return itr.idx >= len(itr.n.x) +} + +func (n Tree) Length() int64 { + return int64(len(n.x)) +} +func (Tree) IsAbsent() bool { + return false +} +func (Tree) IsNull() bool { + return false +} +func (Tree) AsBool() (bool, error) { + return mixins.List{"ipldgit.Tree"}.AsBool() +} +func (Tree) AsInt() (int64, error) { + return mixins.List{"ipldgit.Tree"}.AsInt() +} +func (Tree) AsFloat() (float64, error) { + return mixins.List{"ipldgit.Tree"}.AsFloat() +} +func (Tree) AsString() (string, error) { + return mixins.List{"ipldgit.Tree"}.AsString() +} +func (Tree) AsBytes() ([]byte, error) { + return mixins.List{"ipldgit.Tree"}.AsBytes() +} +func (Tree) AsLink() (ipld.Link, error) { + return mixins.List{"ipldgit.Tree"}.AsLink() +} +func (Tree) Prototype() ipld.NodePrototype { + return _Tree__Prototype{} +} +type _Tree__Prototype struct{} + +func (_Tree__Prototype) NewBuilder() ipld.NodeBuilder { + var nb _Tree__Builder + nb.Reset() + return &nb +} +type _Tree__Builder struct { + _Tree__Assembler +} +func (nb *_Tree__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 *_Tree__Builder) Reset() { + var w _Tree + var m schema.Maybe + *nb = _Tree__Builder{_Tree__Assembler{w: &w, m: &m}} +} +type _Tree__Assembler struct { + w *_Tree + m *schema.Maybe + state laState + + cm schema.Maybe + va _TreeEntry__Assembler +} + +func (na *_Tree__Assembler) reset() { + na.state = laState_initial + na.va.reset() +} +func (_Tree__Assembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { + return mixins.ListAssembler{"ipldgit.Tree"}.BeginMap(0) +} +func (na *_Tree__Assembler) BeginList(sizeHint int64) (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 = &_Tree{} + } + if sizeHint > 0 { + na.w.x = make([]_TreeEntry, 0, sizeHint) + } + return na, nil +} +func (na *_Tree__Assembler) AssignNull() error { + switch *na.m { + case allowNull: + *na.m = schema.Maybe_Null + return nil + case schema.Maybe_Absent: + return mixins.ListAssembler{"ipldgit.Tree"}.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 (_Tree__Assembler) AssignBool(bool) error { + return mixins.ListAssembler{"ipldgit.Tree"}.AssignBool(false) +} +func (_Tree__Assembler) AssignInt(int64) error { + return mixins.ListAssembler{"ipldgit.Tree"}.AssignInt(0) +} +func (_Tree__Assembler) AssignFloat(float64) error { + return mixins.ListAssembler{"ipldgit.Tree"}.AssignFloat(0) +} +func (_Tree__Assembler) AssignString(string) error { + return mixins.ListAssembler{"ipldgit.Tree"}.AssignString("") +} +func (_Tree__Assembler) AssignBytes([]byte) error { + return mixins.ListAssembler{"ipldgit.Tree"}.AssignBytes(nil) +} +func (_Tree__Assembler) AssignLink(ipld.Link) error { + return mixins.ListAssembler{"ipldgit.Tree"}.AssignLink(nil) +} +func (na *_Tree__Assembler) AssignNode(v ipld.Node) error { + if v.IsNull() { + return na.AssignNull() + } + if v2, ok := v.(*_Tree); 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.Kind() != ipld.Kind_List { + return ipld.ErrWrongKind{TypeName: "ipldgit.Tree", MethodName: "AssignNode", AppropriateKind: ipld.KindSet_JustList, ActualKind: v.Kind()} + } + 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 (_Tree__Assembler) Prototype() ipld.NodePrototype { + return _Tree__Prototype{} +} +func (la *_Tree__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 *_Tree__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, _TreeEntry{}) + 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 *_Tree__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 *_Tree__Assembler) ValuePrototype(_ int64) ipld.NodePrototype { + return _TreeEntry__Prototype{} +} +func (Tree) Type() schema.Type { + return nil /*TODO:typelit*/ +} +func (n Tree) Representation() ipld.Node { + return (*_Tree__Repr)(n) +} +type _Tree__Repr _Tree +var _ ipld.Node = &_Tree__Repr{} +func (_Tree__Repr) Kind() ipld.Kind { + return ipld.Kind_List +} +func (_Tree__Repr) LookupByString(string) (ipld.Node, error) { + return mixins.List{"ipldgit.Tree.Repr"}.LookupByString("") +} +func (nr *_Tree__Repr) LookupByNode(k ipld.Node) (ipld.Node, error) { + v, err := (Tree)(nr).LookupByNode(k) + if err != nil || v == ipld.Null { + return v, err + } + return v.(TreeEntry).Representation(), nil +} +func (nr *_Tree__Repr) LookupByIndex(idx int64) (ipld.Node, error) { + v, err := (Tree)(nr).LookupByIndex(idx) + if err != nil || v == ipld.Null { + return v, err + } + return v.(TreeEntry).Representation(), nil +} +func (n _Tree__Repr) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { + i, err := seg.Index() + if err != nil { + return nil, ipld.ErrInvalidSegmentForList{TypeName: "ipldgit.Tree.Repr", TroubleSegment: seg, Reason: err} + } + return n.LookupByIndex(i) +} +func (_Tree__Repr) MapIterator() ipld.MapIterator { + return nil +} +func (nr *_Tree__Repr) ListIterator() ipld.ListIterator { + return &_Tree__ReprListItr{(Tree)(nr), 0} +} + +type _Tree__ReprListItr _Tree__ListItr + +func (itr *_Tree__ReprListItr) Next() (idx int64, v ipld.Node, err error) { + idx, v, err = (*_Tree__ListItr)(itr).Next() + if err != nil || v == ipld.Null { + return + } + return idx, v.(TreeEntry).Representation(), nil +} +func (itr *_Tree__ReprListItr) Done() bool { + return (*_Tree__ListItr)(itr).Done() +} + +func (rn *_Tree__Repr) Length() int64 { + return int64(len(rn.x)) +} +func (_Tree__Repr) IsAbsent() bool { + return false +} +func (_Tree__Repr) IsNull() bool { + return false +} +func (_Tree__Repr) AsBool() (bool, error) { + return mixins.List{"ipldgit.Tree.Repr"}.AsBool() +} +func (_Tree__Repr) AsInt() (int64, error) { + return mixins.List{"ipldgit.Tree.Repr"}.AsInt() +} +func (_Tree__Repr) AsFloat() (float64, error) { + return mixins.List{"ipldgit.Tree.Repr"}.AsFloat() +} +func (_Tree__Repr) AsString() (string, error) { + return mixins.List{"ipldgit.Tree.Repr"}.AsString() +} +func (_Tree__Repr) AsBytes() ([]byte, error) { + return mixins.List{"ipldgit.Tree.Repr"}.AsBytes() +} +func (_Tree__Repr) AsLink() (ipld.Link, error) { + return mixins.List{"ipldgit.Tree.Repr"}.AsLink() +} +func (_Tree__Repr) Prototype() ipld.NodePrototype { + return _Tree__ReprPrototype{} +} +type _Tree__ReprPrototype struct{} + +func (_Tree__ReprPrototype) NewBuilder() ipld.NodeBuilder { + var nb _Tree__ReprBuilder + nb.Reset() + return &nb +} +type _Tree__ReprBuilder struct { + _Tree__ReprAssembler +} +func (nb *_Tree__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 *_Tree__ReprBuilder) Reset() { + var w _Tree + var m schema.Maybe + *nb = _Tree__ReprBuilder{_Tree__ReprAssembler{w: &w, m: &m}} +} +type _Tree__ReprAssembler struct { + w *_Tree + m *schema.Maybe + state laState + + cm schema.Maybe + va _TreeEntry__ReprAssembler +} + +func (na *_Tree__ReprAssembler) reset() { + na.state = laState_initial + na.va.reset() +} +func (_Tree__ReprAssembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { + return mixins.ListAssembler{"ipldgit.Tree.Repr"}.BeginMap(0) +} +func (na *_Tree__ReprAssembler) BeginList(sizeHint int64) (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 = &_Tree{} + } + if sizeHint > 0 { + na.w.x = make([]_TreeEntry, 0, sizeHint) + } + return na, nil +} +func (na *_Tree__ReprAssembler) AssignNull() error { + switch *na.m { + case allowNull: + *na.m = schema.Maybe_Null + return nil + case schema.Maybe_Absent: + return mixins.ListAssembler{"ipldgit.Tree.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 (_Tree__ReprAssembler) AssignBool(bool) error { + return mixins.ListAssembler{"ipldgit.Tree.Repr"}.AssignBool(false) +} +func (_Tree__ReprAssembler) AssignInt(int64) error { + return mixins.ListAssembler{"ipldgit.Tree.Repr"}.AssignInt(0) +} +func (_Tree__ReprAssembler) AssignFloat(float64) error { + return mixins.ListAssembler{"ipldgit.Tree.Repr"}.AssignFloat(0) +} +func (_Tree__ReprAssembler) AssignString(string) error { + return mixins.ListAssembler{"ipldgit.Tree.Repr"}.AssignString("") +} +func (_Tree__ReprAssembler) AssignBytes([]byte) error { + return mixins.ListAssembler{"ipldgit.Tree.Repr"}.AssignBytes(nil) +} +func (_Tree__ReprAssembler) AssignLink(ipld.Link) error { + return mixins.ListAssembler{"ipldgit.Tree.Repr"}.AssignLink(nil) +} +func (na *_Tree__ReprAssembler) AssignNode(v ipld.Node) error { + if v.IsNull() { + return na.AssignNull() + } + if v2, ok := v.(*_Tree); 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.Kind() != ipld.Kind_List { + return ipld.ErrWrongKind{TypeName: "ipldgit.Tree.Repr", MethodName: "AssignNode", AppropriateKind: ipld.KindSet_JustList, ActualKind: v.Kind()} + } + 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 (_Tree__ReprAssembler) Prototype() ipld.NodePrototype { + return _Tree__ReprPrototype{} +} +func (la *_Tree__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 *_Tree__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, _TreeEntry{}) + 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 *_Tree__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 *_Tree__ReprAssembler) ValuePrototype(_ int64) ipld.NodePrototype { + return _TreeEntry__ReprPrototype{} +} + + +func (n _TreeEntry) FieldMode() String { + return &n.Mode +} +func (n _TreeEntry) FieldName() String { + return &n.Name +} +func (n _TreeEntry) FieldHash() Link { + return &n.Hash +} +type _TreeEntry__Maybe struct { + m schema.Maybe + v TreeEntry +} +type MaybeTreeEntry = *_TreeEntry__Maybe + +func (m MaybeTreeEntry) IsNull() bool { + return m.m == schema.Maybe_Null +} +func (m MaybeTreeEntry) IsAbsent() bool { + return m.m == schema.Maybe_Absent +} +func (m MaybeTreeEntry) Exists() bool { + return m.m == schema.Maybe_Value +} +func (m MaybeTreeEntry) 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 MaybeTreeEntry) Must() TreeEntry { + if !m.Exists() { + panic("unbox of a maybe rejected") + } + return m.v +} +var ( + fieldName__TreeEntry_Mode = _String{"Mode"} + fieldName__TreeEntry_Name = _String{"Name"} + fieldName__TreeEntry_Hash = _String{"Hash"} +) +var _ ipld.Node = (TreeEntry)(&_TreeEntry{}) +var _ schema.TypedNode = (TreeEntry)(&_TreeEntry{}) +func (TreeEntry) Kind() ipld.Kind { + return ipld.Kind_Map +} +func (n TreeEntry) LookupByString(key string) (ipld.Node, error) { + switch key { + case "Mode": + return &n.Mode, nil + case "Name": + return &n.Name, nil + case "Hash": + return &n.Hash, nil + default: + return nil, schema.ErrNoSuchField{Type: nil /*TODO*/, Field: ipld.PathSegmentOfString(key)} + } +} +func (n TreeEntry) LookupByNode(key ipld.Node) (ipld.Node, error) { + ks, err := key.AsString() + if err != nil { + return nil, err + } + return n.LookupByString(ks) +} +func (TreeEntry) LookupByIndex(idx int64) (ipld.Node, error) { + return mixins.Map{"ipldgit.TreeEntry"}.LookupByIndex(0) +} +func (n TreeEntry) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { + return n.LookupByString(seg.String()) +} +func (n TreeEntry) MapIterator() ipld.MapIterator { + return &_TreeEntry__MapItr{n, 0} +} + +type _TreeEntry__MapItr struct { + n TreeEntry + idx int +} + +func (itr *_TreeEntry__MapItr) Next() (k ipld.Node, v ipld.Node, _ error) { + if itr.idx >= 3 { + return nil, nil, ipld.ErrIteratorOverread{} + } + switch itr.idx { + case 0: + k = &fieldName__TreeEntry_Mode + v = &itr.n.Mode + case 1: + k = &fieldName__TreeEntry_Name + v = &itr.n.Name + case 2: + k = &fieldName__TreeEntry_Hash + v = &itr.n.Hash + default: + panic("unreachable") + } + itr.idx++ + return +} +func (itr *_TreeEntry__MapItr) Done() bool { + return itr.idx >= 3 +} + +func (TreeEntry) ListIterator() ipld.ListIterator { + return nil +} +func (TreeEntry) Length() int64 { + return 3 +} +func (TreeEntry) IsAbsent() bool { + return false +} +func (TreeEntry) IsNull() bool { + return false +} +func (TreeEntry) AsBool() (bool, error) { + return mixins.Map{"ipldgit.TreeEntry"}.AsBool() +} +func (TreeEntry) AsInt() (int64, error) { + return mixins.Map{"ipldgit.TreeEntry"}.AsInt() +} +func (TreeEntry) AsFloat() (float64, error) { + return mixins.Map{"ipldgit.TreeEntry"}.AsFloat() +} +func (TreeEntry) AsString() (string, error) { + return mixins.Map{"ipldgit.TreeEntry"}.AsString() +} +func (TreeEntry) AsBytes() ([]byte, error) { + return mixins.Map{"ipldgit.TreeEntry"}.AsBytes() +} +func (TreeEntry) AsLink() (ipld.Link, error) { + return mixins.Map{"ipldgit.TreeEntry"}.AsLink() +} +func (TreeEntry) Prototype() ipld.NodePrototype { + return _TreeEntry__Prototype{} +} +type _TreeEntry__Prototype struct{} + +func (_TreeEntry__Prototype) NewBuilder() ipld.NodeBuilder { + var nb _TreeEntry__Builder + nb.Reset() + return &nb +} +type _TreeEntry__Builder struct { + _TreeEntry__Assembler +} +func (nb *_TreeEntry__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 *_TreeEntry__Builder) Reset() { + var w _TreeEntry + var m schema.Maybe + *nb = _TreeEntry__Builder{_TreeEntry__Assembler{w: &w, m: &m}} +} +type _TreeEntry__Assembler struct { + w *_TreeEntry + m *schema.Maybe + state maState + s int + f int + + cm schema.Maybe + ca_Mode _String__Assembler + ca_Name _String__Assembler + ca_Hash _Link__Assembler + } + +func (na *_TreeEntry__Assembler) reset() { + na.state = maState_initial + na.s = 0 + na.ca_Mode.reset() + na.ca_Name.reset() + na.ca_Hash.reset() +} + +var ( + fieldBit__TreeEntry_Mode = 1 << 0 + fieldBit__TreeEntry_Name = 1 << 1 + fieldBit__TreeEntry_Hash = 1 << 2 + fieldBits__TreeEntry_sufficient = 0 + 1 << 0 + 1 << 1 + 1 << 2 +) +func (na *_TreeEntry__Assembler) BeginMap(int64) (ipld.MapAssembler, 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 na.w == nil { + na.w = &_TreeEntry{} + } + return na, nil +} +func (_TreeEntry__Assembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { + return mixins.MapAssembler{"ipldgit.TreeEntry"}.BeginList(0) +} +func (na *_TreeEntry__Assembler) AssignNull() error { + switch *na.m { + case allowNull: + *na.m = schema.Maybe_Null + return nil + case schema.Maybe_Absent: + return mixins.MapAssembler{"ipldgit.TreeEntry"}.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 (_TreeEntry__Assembler) AssignBool(bool) error { + return mixins.MapAssembler{"ipldgit.TreeEntry"}.AssignBool(false) +} +func (_TreeEntry__Assembler) AssignInt(int64) error { + return mixins.MapAssembler{"ipldgit.TreeEntry"}.AssignInt(0) +} +func (_TreeEntry__Assembler) AssignFloat(float64) error { + return mixins.MapAssembler{"ipldgit.TreeEntry"}.AssignFloat(0) +} +func (_TreeEntry__Assembler) AssignString(string) error { + return mixins.MapAssembler{"ipldgit.TreeEntry"}.AssignString("") +} +func (_TreeEntry__Assembler) AssignBytes([]byte) error { + return mixins.MapAssembler{"ipldgit.TreeEntry"}.AssignBytes(nil) +} +func (_TreeEntry__Assembler) AssignLink(ipld.Link) error { + return mixins.MapAssembler{"ipldgit.TreeEntry"}.AssignLink(nil) +} +func (na *_TreeEntry__Assembler) AssignNode(v ipld.Node) error { + if v.IsNull() { + return na.AssignNull() + } + if v2, ok := v.(*_TreeEntry); 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.Kind() != ipld.Kind_Map { + return ipld.ErrWrongKind{TypeName: "ipldgit.TreeEntry", MethodName: "AssignNode", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()} + } + itr := v.MapIterator() + for !itr.Done() { + k, v, err := itr.Next() + if err != nil { + return err + } + if err := na.AssembleKey().AssignNode(k); err != nil { + return err + } + if err := na.AssembleValue().AssignNode(v); err != nil { + return err + } + } + return na.Finish() +} +func (_TreeEntry__Assembler) Prototype() ipld.NodePrototype { + return _TreeEntry__Prototype{} +} +func (ma *_TreeEntry__Assembler) valueFinishTidy() bool { + switch ma.f { + case 0: + switch ma.cm { + case schema.Maybe_Value: + ma.ca_Mode.w = nil + ma.cm = schema.Maybe_Absent + ma.state = maState_initial + return true + default: + return false + } + case 1: + switch ma.cm { + case schema.Maybe_Value: + ma.ca_Name.w = nil + ma.cm = schema.Maybe_Absent + ma.state = maState_initial + return true + default: + return false + } + case 2: + switch ma.cm { + case schema.Maybe_Value: + ma.ca_Hash.w = nil + ma.cm = schema.Maybe_Absent + ma.state = maState_initial + return true + default: + return false + } + default: + panic("unreachable") + } +} +func (ma *_TreeEntry__Assembler) AssembleEntry(k string) (ipld.NodeAssembler, error) { + switch ma.state { + case maState_initial: + // carry on + case maState_midKey: + panic("invalid state: AssembleEntry cannot be called when in the middle of assembling another key") + case maState_expectValue: + panic("invalid state: AssembleEntry cannot be called when expecting start of value assembly") + case maState_midValue: + if !ma.valueFinishTidy() { + panic("invalid state: AssembleEntry cannot be called when in the middle of assembling a value") + } // if tidy success: carry on + case maState_finished: + panic("invalid state: AssembleEntry cannot be called on an assembler that's already finished") + } + switch k { + case "Mode": + if ma.s & fieldBit__TreeEntry_Mode != 0 { + return nil, ipld.ErrRepeatedMapKey{&fieldName__TreeEntry_Mode} + } + ma.s += fieldBit__TreeEntry_Mode + ma.state = maState_midValue + ma.f = 0 + ma.ca_Mode.w = &ma.w.Mode + ma.ca_Mode.m = &ma.cm + return &ma.ca_Mode, nil + case "Name": + if ma.s & fieldBit__TreeEntry_Name != 0 { + return nil, ipld.ErrRepeatedMapKey{&fieldName__TreeEntry_Name} + } + ma.s += fieldBit__TreeEntry_Name + ma.state = maState_midValue + ma.f = 1 + ma.ca_Name.w = &ma.w.Name + ma.ca_Name.m = &ma.cm + return &ma.ca_Name, nil + case "Hash": + if ma.s & fieldBit__TreeEntry_Hash != 0 { + return nil, ipld.ErrRepeatedMapKey{&fieldName__TreeEntry_Hash} + } + ma.s += fieldBit__TreeEntry_Hash + ma.state = maState_midValue + ma.f = 2 + ma.ca_Hash.w = &ma.w.Hash + ma.ca_Hash.m = &ma.cm + return &ma.ca_Hash, nil + default: + return nil, ipld.ErrInvalidKey{TypeName:"ipldgit.TreeEntry", Key:&_String{k}} + } +} +func (ma *_TreeEntry__Assembler) AssembleKey() ipld.NodeAssembler { + switch ma.state { + case maState_initial: + // carry on + case maState_midKey: + panic("invalid state: AssembleKey cannot be called when in the middle of assembling another key") + case maState_expectValue: + panic("invalid state: AssembleKey cannot be called when expecting start of value assembly") + case maState_midValue: + if !ma.valueFinishTidy() { + panic("invalid state: AssembleKey cannot be called when in the middle of assembling a value") + } // if tidy success: carry on + case maState_finished: + panic("invalid state: AssembleKey cannot be called on an assembler that's already finished") + } + ma.state = maState_midKey + return (*_TreeEntry__KeyAssembler)(ma) +} +func (ma *_TreeEntry__Assembler) AssembleValue() ipld.NodeAssembler { + switch ma.state { + case maState_initial: + panic("invalid state: AssembleValue cannot be called when no key is primed") + case maState_midKey: + panic("invalid state: AssembleValue cannot be called when in the middle of assembling a key") + case maState_expectValue: + // carry on + case maState_midValue: + panic("invalid state: AssembleValue cannot be called when in the middle of assembling another value") + case maState_finished: + panic("invalid state: AssembleValue cannot be called on an assembler that's already finished") + } + ma.state = maState_midValue + switch ma.f { + case 0: + ma.ca_Mode.w = &ma.w.Mode + ma.ca_Mode.m = &ma.cm + return &ma.ca_Mode + case 1: + ma.ca_Name.w = &ma.w.Name + ma.ca_Name.m = &ma.cm + return &ma.ca_Name + case 2: + ma.ca_Hash.w = &ma.w.Hash + ma.ca_Hash.m = &ma.cm + return &ma.ca_Hash + default: + panic("unreachable") + } +} +func (ma *_TreeEntry__Assembler) Finish() error { + switch ma.state { + case maState_initial: + // carry on + case maState_midKey: + panic("invalid state: Finish cannot be called when in the middle of assembling a key") + case maState_expectValue: + panic("invalid state: Finish cannot be called when expecting start of value assembly") + case maState_midValue: + if !ma.valueFinishTidy() { + panic("invalid state: Finish cannot be called when in the middle of assembling a value") + } // if tidy success: carry on + case maState_finished: + panic("invalid state: Finish cannot be called on an assembler that's already finished") + } + if ma.s & fieldBits__TreeEntry_sufficient != fieldBits__TreeEntry_sufficient { + err := ipld.ErrMissingRequiredField{Missing: make([]string, 0)} + if ma.s & fieldBit__TreeEntry_Mode == 0 { + err.Missing = append(err.Missing, "Mode") + } + if ma.s & fieldBit__TreeEntry_Name == 0 { + err.Missing = append(err.Missing, "Name") + } + if ma.s & fieldBit__TreeEntry_Hash == 0 { + err.Missing = append(err.Missing, "Hash") + } + return err + } + ma.state = maState_finished + *ma.m = schema.Maybe_Value + return nil +} +func (ma *_TreeEntry__Assembler) KeyPrototype() ipld.NodePrototype { + return _String__Prototype{} +} +func (ma *_TreeEntry__Assembler) ValuePrototype(k string) ipld.NodePrototype { + panic("todo structbuilder mapassembler valueprototype") +} +type _TreeEntry__KeyAssembler _TreeEntry__Assembler +func (_TreeEntry__KeyAssembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { + return mixins.StringAssembler{"ipldgit.TreeEntry.KeyAssembler"}.BeginMap(0) +} +func (_TreeEntry__KeyAssembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { + return mixins.StringAssembler{"ipldgit.TreeEntry.KeyAssembler"}.BeginList(0) +} +func (na *_TreeEntry__KeyAssembler) AssignNull() error { + return mixins.StringAssembler{"ipldgit.TreeEntry.KeyAssembler"}.AssignNull() +} +func (_TreeEntry__KeyAssembler) AssignBool(bool) error { + return mixins.StringAssembler{"ipldgit.TreeEntry.KeyAssembler"}.AssignBool(false) +} +func (_TreeEntry__KeyAssembler) AssignInt(int64) error { + return mixins.StringAssembler{"ipldgit.TreeEntry.KeyAssembler"}.AssignInt(0) +} +func (_TreeEntry__KeyAssembler) AssignFloat(float64) error { + return mixins.StringAssembler{"ipldgit.TreeEntry.KeyAssembler"}.AssignFloat(0) +} +func (ka *_TreeEntry__KeyAssembler) AssignString(k string) error { + if ka.state != maState_midKey { + panic("misuse: KeyAssembler held beyond its valid lifetime") + } + switch k { + case "Mode": + if ka.s & fieldBit__TreeEntry_Mode != 0 { + return ipld.ErrRepeatedMapKey{&fieldName__TreeEntry_Mode} + } + ka.s += fieldBit__TreeEntry_Mode + ka.state = maState_expectValue + ka.f = 0 + case "Name": + if ka.s & fieldBit__TreeEntry_Name != 0 { + return ipld.ErrRepeatedMapKey{&fieldName__TreeEntry_Name} + } + ka.s += fieldBit__TreeEntry_Name + ka.state = maState_expectValue + ka.f = 1 + case "Hash": + if ka.s & fieldBit__TreeEntry_Hash != 0 { + return ipld.ErrRepeatedMapKey{&fieldName__TreeEntry_Hash} + } + ka.s += fieldBit__TreeEntry_Hash + ka.state = maState_expectValue + ka.f = 2 + default: + return ipld.ErrInvalidKey{TypeName:"ipldgit.TreeEntry", Key:&_String{k}} + } + return nil +} +func (_TreeEntry__KeyAssembler) AssignBytes([]byte) error { + return mixins.StringAssembler{"ipldgit.TreeEntry.KeyAssembler"}.AssignBytes(nil) +} +func (_TreeEntry__KeyAssembler) AssignLink(ipld.Link) error { + return mixins.StringAssembler{"ipldgit.TreeEntry.KeyAssembler"}.AssignLink(nil) +} +func (ka *_TreeEntry__KeyAssembler) AssignNode(v ipld.Node) error { + if v2, err := v.AsString(); err != nil { + return err + } else { + return ka.AssignString(v2) + } +} +func (_TreeEntry__KeyAssembler) Prototype() ipld.NodePrototype { + return _String__Prototype{} +} +func (TreeEntry) Type() schema.Type { + return nil /*TODO:typelit*/ +} +func (n TreeEntry) Representation() ipld.Node { + return (*_TreeEntry__Repr)(n) +} +type _TreeEntry__Repr _TreeEntry +var _ ipld.Node = &_TreeEntry__Repr{} +func (_TreeEntry__Repr) Kind() ipld.Kind { + return ipld.Kind_String +} +func (_TreeEntry__Repr) LookupByString(string) (ipld.Node, error) { + return mixins.String{"ipldgit.TreeEntry.Repr"}.LookupByString("") +} +func (_TreeEntry__Repr) LookupByNode(ipld.Node) (ipld.Node, error) { + return mixins.String{"ipldgit.TreeEntry.Repr"}.LookupByNode(nil) +} +func (_TreeEntry__Repr) LookupByIndex(idx int64) (ipld.Node, error) { + return mixins.String{"ipldgit.TreeEntry.Repr"}.LookupByIndex(0) +} +func (_TreeEntry__Repr) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { + return mixins.String{"ipldgit.TreeEntry.Repr"}.LookupBySegment(seg) +} +func (_TreeEntry__Repr) MapIterator() ipld.MapIterator { + return nil +} +func (_TreeEntry__Repr) ListIterator() ipld.ListIterator { + return nil +} +func (_TreeEntry__Repr) Length() int64 { + return -1 +} +func (_TreeEntry__Repr) IsAbsent() bool { + return false +} +func (_TreeEntry__Repr) IsNull() bool { + return false +} +func (_TreeEntry__Repr) AsBool() (bool, error) { + return mixins.String{"ipldgit.TreeEntry.Repr"}.AsBool() +} +func (_TreeEntry__Repr) AsInt() (int64, error) { + return mixins.String{"ipldgit.TreeEntry.Repr"}.AsInt() +} +func (_TreeEntry__Repr) AsFloat() (float64, error) { + return mixins.String{"ipldgit.TreeEntry.Repr"}.AsFloat() +} +func (n *_TreeEntry__Repr) AsString() (string, error) { + return n.String(), nil +} +func (n *_TreeEntry__Repr) String() string { + return (*_String__Repr)(&n.Mode).String() + " " + (*_String__Repr)(&n.Name).String() + " " + (*_Link__Repr)(&n.Hash).String() +} +func (n TreeEntry) String() string { + return (*_TreeEntry__Repr)(n).String() +} +func (_TreeEntry__Repr) AsBytes() ([]byte, error) { + return mixins.String{"ipldgit.TreeEntry.Repr"}.AsBytes() +} +func (_TreeEntry__Repr) AsLink() (ipld.Link, error) { + return mixins.String{"ipldgit.TreeEntry.Repr"}.AsLink() +} +func (_TreeEntry__Repr) Prototype() ipld.NodePrototype { + return _TreeEntry__ReprPrototype{} +} +type _TreeEntry__ReprPrototype struct{} + +func (_TreeEntry__ReprPrototype) NewBuilder() ipld.NodeBuilder { + var nb _TreeEntry__ReprBuilder + nb.Reset() + return &nb +} +type _TreeEntry__ReprBuilder struct { + _TreeEntry__ReprAssembler +} +func (nb *_TreeEntry__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 *_TreeEntry__ReprBuilder) Reset() { + var w _TreeEntry + var m schema.Maybe + *nb = _TreeEntry__ReprBuilder{_TreeEntry__ReprAssembler{w: &w, m: &m}} +} +func (_TreeEntry__ReprPrototype) fromString(w *_TreeEntry, v string) error { + ss, err := mixins.SplitExact(v, " ", 3) + if err != nil { + return ipld.ErrUnmatchable{TypeName:"ipldgit.TreeEntry.Repr", Reason: err} + } + if err := (_String__ReprPrototype{}).fromString(&w.Mode, ss[0]); err != nil { + return ipld.ErrUnmatchable{TypeName:"ipldgit.TreeEntry.Repr", Reason: err} + } + if err := (_String__ReprPrototype{}).fromString(&w.Name, ss[1]); err != nil { + return ipld.ErrUnmatchable{TypeName:"ipldgit.TreeEntry.Repr", Reason: err} + } + if err := (_Link__ReprPrototype{}).fromString(&w.Hash, ss[2]); err != nil { + return ipld.ErrUnmatchable{TypeName:"ipldgit.TreeEntry.Repr", Reason: err} + } + return nil +} +type _TreeEntry__ReprAssembler struct { + w *_TreeEntry + m *schema.Maybe +} + +func (na *_TreeEntry__ReprAssembler) reset() {} +func (_TreeEntry__ReprAssembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { + return mixins.StringAssembler{"ipldgit.TreeEntry.Repr"}.BeginMap(0) +} +func (_TreeEntry__ReprAssembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { + return mixins.StringAssembler{"ipldgit.TreeEntry.Repr"}.BeginList(0) +} +func (na *_TreeEntry__ReprAssembler) AssignNull() error { + switch *na.m { + case allowNull: + *na.m = schema.Maybe_Null + return nil + case schema.Maybe_Absent: + return mixins.StringAssembler{"ipldgit.TreeEntry.Repr.Repr"}.AssignNull() + case schema.Maybe_Value, schema.Maybe_Null: + panic("invalid state: cannot assign into assembler that's already finished") + } + panic("unreachable") +} +func (_TreeEntry__ReprAssembler) AssignBool(bool) error { + return mixins.StringAssembler{"ipldgit.TreeEntry.Repr"}.AssignBool(false) +} +func (_TreeEntry__ReprAssembler) AssignInt(int64) error { + return mixins.StringAssembler{"ipldgit.TreeEntry.Repr"}.AssignInt(0) +} +func (_TreeEntry__ReprAssembler) AssignFloat(float64) error { + return mixins.StringAssembler{"ipldgit.TreeEntry.Repr"}.AssignFloat(0) +} +func (na *_TreeEntry__ReprAssembler) 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 = &_TreeEntry{} + } + if err := (_TreeEntry__ReprPrototype{}).fromString(na.w, v); err != nil { + return err + } + *na.m = schema.Maybe_Value + return nil +} +func (_TreeEntry__ReprAssembler) AssignBytes([]byte) error { + return mixins.StringAssembler{"ipldgit.TreeEntry.Repr"}.AssignBytes(nil) +} +func (_TreeEntry__ReprAssembler) AssignLink(ipld.Link) error { + return mixins.StringAssembler{"ipldgit.TreeEntry.Repr"}.AssignLink(nil) +} +func (na *_TreeEntry__ReprAssembler) AssignNode(v ipld.Node) error { + if v.IsNull() { + return na.AssignNull() + } + if v2, ok := v.(*_TreeEntry); 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 (_TreeEntry__ReprAssembler) Prototype() ipld.NodePrototype { + return _TreeEntry__ReprPrototype{} +} + diff --git a/ipldsch_types.go b/ipldsch_types.go new file mode 100644 index 0000000..bfc73c1 --- /dev/null +++ b/ipldsch_types.go @@ -0,0 +1,137 @@ +package ipldgit + +// Code generated by go-ipld-prime gengo. DO NOT EDIT. + +import ( + ipld "github.com/ipld/go-ipld-prime" +) +var _ ipld.Node = nil // suppress errors when this dependency is not referenced +// 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: +// +// ipldgit.Type.YourTypeName.NewBuilder().BeginMap() //... +// +// and: +// +// ipldgit.Type.OtherTypeName.NewBuilder().AssignString("x") // ... +// +var Type typeSlab + +type typeSlab struct { + Blob _Blob__Prototype + Blob__Repr _Blob__ReprPrototype + Commit _Commit__Prototype + Commit__Repr _Commit__ReprPrototype + GpgSig _GpgSig__Prototype + GpgSig__Repr _GpgSig__ReprPrototype + Link _Link__Prototype + Link__Repr _Link__ReprPrototype + LinkTree _LinkTree__Prototype + LinkTree__Repr _LinkTree__ReprPrototype + ListParents _ListParents__Prototype + ListParents__Repr _ListParents__ReprPrototype + ListString _ListString__Prototype + ListString__Repr _ListString__ReprPrototype + ListTag _ListTag__Prototype + ListTag__Repr _ListTag__ReprPrototype + PersonInfo _PersonInfo__Prototype + PersonInfo__Repr _PersonInfo__ReprPrototype + String _String__Prototype + String__Repr _String__ReprPrototype + Tag _Tag__Prototype + Tag__Repr _Tag__ReprPrototype + Tree _Tree__Prototype + Tree__Repr _Tree__ReprPrototype + TreeEntry _TreeEntry__Prototype + TreeEntry__Repr _TreeEntry__ReprPrototype +} + +// --- type definitions follow --- + +// Blob matches the IPLD Schema type "Blob". It has bytes kind. +type Blob = *_Blob +type _Blob struct{ x []byte } + +// Commit matches the IPLD Schema type "Commit". It has Struct type-kind, and may be interrogated like map kind. +type Commit = *_Commit +type _Commit struct { + DataSize _String + GitTree _LinkTree + Parents _ListParents + Message _String + Author _PersonInfo__Maybe + Committer _PersonInfo__Maybe + Encoding _String__Maybe + Sig _GpgSig__Maybe + MergeTag _ListTag + Other _ListString +} + +// GpgSig matches the IPLD Schema type "GpgSig". It has string kind. +type GpgSig = *_GpgSig +type _GpgSig struct{ x string } + +// Link matches the IPLD Schema type "Link". It has link kind. +type Link = *_Link +type _Link struct{ x ipld.Link } + +// LinkTree matches the IPLD Schema type "LinkTree". It has link kind. +type LinkTree = *_LinkTree +type _LinkTree struct{ x ipld.Link } + +// ListParents matches the IPLD Schema type "ListParents". It has list kind. +type ListParents = *_ListParents +type _ListParents struct { + x []_Link +} + +// ListString matches the IPLD Schema type "ListString". It has list kind. +type ListString = *_ListString +type _ListString struct { + x []_String +} + +// ListTag matches the IPLD Schema type "ListTag". It has list kind. +type ListTag = *_ListTag +type _ListTag struct { + x []_Tag +} + +// PersonInfo matches the IPLD Schema type "PersonInfo". It has Struct type-kind, and may be interrogated like map kind. +type PersonInfo = *_PersonInfo +type _PersonInfo struct { + Name _String + Email _String + Date _String + Timezone _String +} + +// String matches the IPLD Schema type "String". It has string kind. +type String = *_String +type _String struct{ x string } + +// Tag matches the IPLD Schema type "Tag". It has Struct type-kind, and may be interrogated like map kind. +type Tag = *_Tag +type _Tag struct { + Object _Link + TagType _String + Tag _String + Tagger _PersonInfo + Text _String +} + +// Tree matches the IPLD Schema type "Tree". It has list kind. +type Tree = *_Tree +type _Tree struct { + x []_TreeEntry +} + +// TreeEntry matches the IPLD Schema type "TreeEntry". It has Struct type-kind, and may be interrogated like map kind. +type TreeEntry = *_TreeEntry +type _TreeEntry struct { + Mode _String + Name _String + Hash _Link +} + diff --git a/personinfo.go b/personinfo.go new file mode 100644 index 0000000..082bb9c --- /dev/null +++ b/personinfo.go @@ -0,0 +1,71 @@ +package ipldgit + +import ( + "bytes" + "fmt" +) + +func parsePersonInfo(line []byte) (PersonInfo, error) { + parts := bytes.Split(line, []byte{' '}) + if len(parts) < 3 { + fmt.Println(string(line)) + return nil, fmt.Errorf("incorrectly formatted person info line") + } + + //TODO: just use regex? + //skip prefix + at := 1 + + var pi _PersonInfo + var name string + + for { + if at == len(parts) { + return nil, fmt.Errorf("invalid personInfo: %s", line) + } + part := parts[at] + if len(part) != 0 { + if part[0] == '<' { + break + } + name += string(part) + " " + } else if len(name) > 0 { + name += " " + } + at++ + } + if len(name) != 0 { + pi.Name = _String{name[:len(name)-1]} + } + + var email string + for { + if at == len(parts) { + return nil, fmt.Errorf("invalid personInfo: %s", line) + } + part := parts[at] + if part[0] == '<' { + part = part[1:] + } + + at++ + if part[len(part)-1] == '>' { + email += string(part[:len(part)-1]) + break + } + email += string(part) + " " + } + pi.Email = _String{email} + + if at == len(parts) { + return &pi, nil + } + pi.Date = _String{string(parts[at])} + + at++ + if at == len(parts) { + return &pi, nil + } + pi.Timezone = _String{string(parts[at])} + return &pi, nil +} diff --git a/tag.go b/tag.go index 4babb0b..481435d 100644 --- a/tag.go +++ b/tag.go @@ -1,143 +1,108 @@ package ipldgit import ( + "bufio" "bytes" "encoding/hex" - "errors" "fmt" - "sync" + "io" + "io/ioutil" - cid "github.com/ipfs/go-cid" - node "github.com/ipfs/go-ipld-format" + "github.com/ipld/go-ipld-prime" + cidlink "github.com/ipld/go-ipld-prime/linking/cid" ) -type Tag struct { - Object cid.Cid `json:"object"` - Type string `json:"type"` - Tag string `json:"tag"` - Tagger *PersonInfo `json:"tagger"` - Message string `json:"message"` - dataSize string - - cid cid.Cid - - rawData []byte - rawDataOnce sync.Once -} - -func (t *Tag) Cid() cid.Cid { - return t.cid -} - -func (t *Tag) Copy() node.Node { - return &Tag{ - Object: t.Object, - Type: t.Type, - Tag: t.Tag, - Tagger: t.Tagger, - Message: t.Message, - dataSize: t.dataSize, - cid: t.cid, +// DecodeTag fills a NodeAssembler (from `Type.Tag__Repr.NewBuilder()`) from a stream of bytes +func DecodeTag(na ipld.NodeAssembler, rd *bufio.Reader) error { + _, err := rd.ReadString(0) + if err != nil { + return err } -} -func (t *Tag) Links() []*node.Link { - return []*node.Link{{Cid: t.Object}} -} + out := _Tag{} -func (t *Tag) Loggable() map[string]interface{} { - return map[string]interface{}{ - "type": "git_tag", - } -} - -func (t *Tag) RawData() []byte { - t.rawDataOnce.Do(func() { - buf := new(bytes.Buffer) - fmt.Fprintf(buf, "tag %s\x00", t.dataSize) - fmt.Fprintf(buf, "object %s\n", hex.EncodeToString(cidToSha(t.Object))) - fmt.Fprintf(buf, "type %s\n", t.Type) - fmt.Fprintf(buf, "tag %s\n", t.Tag) - if t.Tagger != nil { - fmt.Fprintf(buf, "tagger %s\n", t.Tagger.String()) - } - if t.Message != "" { - fmt.Fprintf(buf, "\n%s", t.Message) + for { + line, _, err := rd.ReadLine() + if err != nil { + if err == io.EOF { + break + } + return err } - t.rawData = buf.Bytes() - }) - - return t.rawData -} - -func (t *Tag) Resolve(path []string) (interface{}, []string, error) { - if len(path) == 0 { - return nil, nil, fmt.Errorf("zero length path") - } - switch path[0] { - case "object": - return &node.Link{Cid: t.Object}, path[1:], nil - case "type": - return t.Type, path[1:], nil - case "tagger": - if len(path) == 1 { - return t.Tagger, nil, nil + switch { + case bytes.HasPrefix(line, []byte("object ")): + sha, err := hex.DecodeString(string(line[7:])) + if err != nil { + return err + } + + out.Object = _Link{cidlink.Link{Cid: shaToCid(sha)}} + case bytes.HasPrefix(line, []byte("tag ")): + out.Tag = _String{string(line[4:])} + case bytes.HasPrefix(line, []byte("tagger ")): + c, err := parsePersonInfo(line) + if err != nil { + return err + } + + out.Tagger = *c + case bytes.HasPrefix(line, []byte("type ")): + out.TagType = _String{string(line[5:])} + case len(line) == 0: + rest, err := ioutil.ReadAll(rd) + if err != nil { + return err + } + + out.Text = _String{string(rest)} + default: + fmt.Println("unhandled line: ", string(line)) } - return t.Tagger.resolve(path[1:]) - case "message": - return t.Message, path[1:], nil - case "tag": - return t.Tag, path[1:], nil - default: - return nil, nil, errors.New("no such link") } -} -func (t *Tag) ResolveLink(path []string) (*node.Link, []string, error) { - out, rest, err := t.Resolve(path) - if err != nil { - return nil, nil, err - } - - lnk, ok := out.(*node.Link) - if !ok { - return nil, nil, errors.New("not a link") - } - - return lnk, rest, nil -} - -func (t *Tag) Size() (uint64, error) { - return uint64(len(t.RawData())), nil + return na.AssignNode(&out) } -func (t *Tag) Stat() (*node.NodeStat, error) { - return &node.NodeStat{}, nil -} - -func (t *Tag) String() string { - return "[git tag object]" -} +// readMergeTag works for tags within commits like DecodeTag +func readMergeTag(hash []byte, rd *bufio.Reader) (Tag, []byte, error) { + out := _Tag{} + + out.Object = _Link{cidlink.Link{Cid: shaToCid(hash)}} + for { + line, _, err := rd.ReadLine() + if err != nil { + if err == io.EOF { + break + } + return nil, nil, err + } -func (t *Tag) Tree(p string, depth int) []string { - if p != "" { - if p == "tagger" { - return []string{"name", "email", "date"} + switch { + case bytes.HasPrefix(line, []byte(" type ")): + out.TagType = _String{string(line[6:])} + case bytes.HasPrefix(line, []byte(" tag ")): + out.Tag = _String{string(line[5:])} + case bytes.HasPrefix(line, []byte(" tagger ")): + tagger, err := parsePersonInfo(line[1:]) + if err != nil { + return nil, nil, err + } + out.Tagger = *tagger + case string(line) == " ": + for { + line, _, err := rd.ReadLine() + if err != nil { + return nil, nil, err + } + + if !bytes.HasPrefix(line, []byte(" ")) { + return &out, line, nil + } + + out.Text.x += string(line) + "\n" + } } - return nil - } - if depth == 0 { - return nil } - - tree := []string{"object", "type", "tag", "message"} - tree = append(tree, t.Tagger.tree("tagger", depth)...) - return tree -} - -func (t *Tag) GitSha() []byte { - return cidToSha(t.Cid()) + return &out, nil, nil } - -var _ node.Node = (*Tag)(nil) diff --git a/tree.go b/tree.go index 9054df4..f4f2427 100644 --- a/tree.go +++ b/tree.go @@ -1,170 +1,68 @@ package ipldgit import ( - "bytes" - "encoding/json" - "errors" - "fmt" + "bufio" "io" - "sync" + "strconv" - cid "github.com/ipfs/go-cid" - node "github.com/ipfs/go-ipld-format" + "github.com/ipld/go-ipld-prime" + cidlink "github.com/ipld/go-ipld-prime/linking/cid" ) -type Tree struct { - entries map[string]*TreeEntry - size int - order []string - cid cid.Cid - rawData []byte - rawDataOnce sync.Once -} - -type TreeEntry struct { - name string - Mode string `json:"mode"` - Hash cid.Cid `json:"hash"` -} - -func (t *Tree) Cid() cid.Cid { - return t.cid -} - -func (t *Tree) String() string { - return "[git tree object]" -} - -func (t *Tree) GitSha() []byte { - return cidToSha(t.cid) -} - -func (t *Tree) Copy() node.Node { - out := &Tree{ - entries: make(map[string]*TreeEntry), - cid: t.cid, - size: t.size, - order: t.order, // TODO: make a deep copy of this - } - - for k, v := range t.entries { - nv := *v - out.entries[k] = &nv - } - return out -} - -func (t *Tree) MarshalJSON() ([]byte, error) { - return json.Marshal(t.entries) -} - -func (t *Tree) Tree(p string, depth int) []string { - if p != "" { - _, ok := t.entries[p] - if !ok { - return nil - } - - return []string{"mode", "type", "hash"} - } - - if depth == 0 { - return nil - } - - if depth == 1 { - return t.order - } - - var out []string - for k := range t.entries { - out = append(out, k, k+"/mode", k+"/type", k+"/hash") +// DecodeTree fills a NodeAssembler (from `Type.Tree__Repr.NewBuilder()`) from a stream of bytes +func DecodeTree(na ipld.NodeAssembler, rd *bufio.Reader) error { + lstr, err := rd.ReadString(0) + if err != nil { + return err } - return out -} + lstr = lstr[:len(lstr)-1] -func (t *Tree) Links() []*node.Link { - var out []*node.Link - for _, v := range t.entries { - out = append(out, &node.Link{Cid: v.Hash}) + n, err := strconv.Atoi(lstr) + if err != nil { + return err } - return out -} -func (t *Tree) Loggable() map[string]interface{} { - return map[string]interface{}{ - "type": "git tree object", + t := Type.Tree__Repr.NewBuilder() + la, err := t.BeginList(int64(n)) + if err != nil { + return err } -} - -func (t *Tree) RawData() []byte { - t.rawDataOnce.Do(func() { - buf := new(bytes.Buffer) - - fmt.Fprintf(buf, "tree %d\x00", t.size) - for _, s := range t.order { - t.entries[s].WriteTo(buf) + for { + err := DecodeTreeEntry(la.AssembleValue(), rd) + if err != nil { + if err == io.EOF { + break + } + return err } - t.rawData = buf.Bytes() - }) - - return t.rawData -} - -func (t *Tree) Resolve(p []string) (interface{}, []string, error) { - e, ok := t.entries[p[0]] - if !ok { - return nil, nil, errors.New("no such link") - } - - if len(p) == 1 { - return e, nil, nil - } - - switch p[1] { - case "hash": - return &node.Link{Cid: e.Hash}, p[2:], nil - case "mode": - return e.Mode, p[2:], nil - default: - return nil, nil, errors.New("no such link") } + return na.AssignNode(t.Build()) } -func (t *Tree) ResolveLink(path []string) (*node.Link, []string, error) { - out, rest, err := t.Resolve(path) +// DecodeTreeEntry fills a NodeAssembler (from `Type.TreeEntry__Repr.NewBuilder()`) from a stream of bytes +func DecodeTreeEntry(na ipld.NodeAssembler, rd *bufio.Reader) error { + data, err := rd.ReadString(' ') if err != nil { - return nil, nil, err - } - - lnk, ok := out.(*node.Link) - if !ok { - return nil, nil, errors.New("not a link") + return err } + data = data[:len(data)-1] - return lnk, rest, nil -} - -func (t *Tree) Size() (uint64, error) { - return uint64(len(t.RawData())), nil -} - -func (t *Tree) Stat() (*node.NodeStat, error) { - return &node.NodeStat{}, nil -} - -func (te *TreeEntry) WriteTo(w io.Writer) (int64, error) { - n, err := fmt.Fprintf(w, "%s %s\x00", te.Mode, te.name) + name, err := rd.ReadString(0) if err != nil { - return 0, err + return err } + name = name[:len(name)-1] - nn, err := w.Write(cidToSha(te.Hash)) + sha := make([]byte, 20) + _, err = io.ReadFull(rd, sha) if err != nil { - return int64(n), err + return err } - return int64(n + nn), nil + te := _TreeEntry{ + Mode: _String{data}, + Name: _String{name}, + Hash: _Link{cidlink.Link{Cid: shaToCid(sha)}}, + } + return na.AssignNode(&te) } - -var _ node.Node = (*Tree)(nil) diff --git a/unmarshal.go b/unmarshal.go new file mode 100644 index 0000000..0e00be7 --- /dev/null +++ b/unmarshal.go @@ -0,0 +1,33 @@ +package ipldgit + +import ( + "bufio" + "fmt" + "io" + + "github.com/ipld/go-ipld-prime" +) + +// Decoder reads from a reader to fill a NodeAssembler +func Decoder(na ipld.NodeAssembler, r io.Reader) error { + rd := bufio.NewReader(r) + + typ, err := rd.ReadString(' ') + if err != nil { + return err + } + typ = typ[:len(typ)-1] + + switch typ { + case "tree": + return DecodeTree(na, rd) + case "commit": + return DecodeCommit(na, rd) + case "blob": + return DecodeBlob(na, rd) + case "tag": + return DecodeTag(na, rd) + default: + return fmt.Errorf("unrecognized object type: %s", typ) + } +} diff --git a/util.go b/util.go new file mode 100644 index 0000000..d5cfed3 --- /dev/null +++ b/util.go @@ -0,0 +1,11 @@ +package ipldgit + +import ( + "github.com/ipfs/go-cid" + mh "github.com/multiformats/go-multihash" +) + +func shaToCid(sha []byte) cid.Cid { + h, _ := mh.Encode(sha, mh.SHA1) + return cid.NewCidV1(cid.GitRaw, h) +} From 9889aa2719e86678dcfc7aa441f34f4e37a9c830 Mon Sep 17 00:00:00 2001 From: Will Scott Date: Tue, 23 Feb 2021 23:10:01 -0800 Subject: [PATCH 03/22] add encode path --- blob.go | 9 +++ commit.go | 53 +++++++++++++++++ gen/gen.go | 1 + init.go | 16 ++++++ ipldsch_satisfaction.go | 122 +++++++++++++++++++++++++++++++++++++--- ipldsch_types.go | 1 + marshal.go | 24 ++++++++ tag.go | 26 ++++++++- tree.go | 64 +++++++++++++++++++++ util.go | 22 ++++++++ 10 files changed, 329 insertions(+), 9 deletions(-) create mode 100644 init.go create mode 100644 marshal.go diff --git a/blob.go b/blob.go index fa010c6..51b68e4 100644 --- a/blob.go +++ b/blob.go @@ -36,3 +36,12 @@ func DecodeBlob(na ipld.NodeAssembler, rd *bufio.Reader) error { return na.AssignBytes(buf.Bytes()) } + +func encodeBlob(n ipld.Node, w io.Writer) error { + bytes, err := n.AsBytes() + if err != nil { + return err + } + _, err = bufio.NewWriter(w).Write(bytes) + return err +} diff --git a/commit.go b/commit.go index 633f2bd..72fac9b 100644 --- a/commit.go +++ b/commit.go @@ -148,3 +148,56 @@ func decodeGpgSig(rd *bufio.Reader) (GpgSig, error) { return &out, nil } + +func encodeCommit(n ipld.Node, w io.Writer) error { + c, ok := n.(Commit) + if !ok { + return fmt.Errorf("not a Commit: %T", n) + } + + buf := new(bytes.Buffer) + fmt.Fprintf(buf, "commit %s\x00", c.DataSize.x) + fmt.Fprintf(buf, "tree %s\n", hex.EncodeToString(c.GitTree.sha())) + for _, p := range c.Parents.x { + fmt.Fprintf(buf, "parent %s\n", hex.EncodeToString(p.sha())) + } + fmt.Fprintf(buf, "author %s\n", c.Author.v.GitString()) + fmt.Fprintf(buf, "committer %s\n", c.Committer.v.GitString()) + if len(c.Encoding.v.x) > 0 { + fmt.Fprintf(buf, "encoding %s\n", c.Encoding.v.x) + } + for _, mtag := range c.MergeTag.x { + fmt.Fprintf(buf, "mergetag object %s\n", hex.EncodeToString(mtag.Object.sha())) + fmt.Fprintf(buf, " type %s\n", mtag.TagType.x) + fmt.Fprintf(buf, " tag %s\n", mtag.Tag.x) + fmt.Fprintf(buf, " tagger %s\n \n", mtag.Tagger.GitString()) + fmt.Fprintf(buf, "%s", mtag.Text.x) + } + if c.Sig.m == schema.Maybe_Value { + fmt.Fprintln(buf, "gpgsig -----BEGIN PGP SIGNATURE-----") + fmt.Fprint(buf, c.Sig.v.x) + fmt.Fprintln(buf, " -----END PGP SIGNATURE-----") + } + for _, line := range c.Other.x { + fmt.Fprintln(buf, line.x) + } + fmt.Fprintf(buf, "\n%s", c.Message.x) + + _, err := bufio.NewWriter(w).Write(buf.Bytes()) + return err +} + +func (p _PersonInfo) GitString() string { + f := "%s <%s>" + arg := []interface{}{p.Name.x, p.Email.x} + if p.Date.x != "" { + f = f + " %s" + arg = append(arg, p.Date.x) + } + + if p.Timezone.x != "" { + f = f + " %s" + arg = append(arg, p.Timezone.x) + } + return fmt.Sprintf(f, arg...) +} diff --git a/gen/gen.go b/gen/gen.go index 0bf9fa6..2de777e 100644 --- a/gen/gen.go +++ b/gen/gen.go @@ -30,6 +30,7 @@ func main() { schema.SpawnStructField("Tag", "String", false, false), schema.SpawnStructField("Tagger", "PersonInfo", false, false), schema.SpawnStructField("Text", "String", false, false), + schema.SpawnStructField("DataSize", "String", true, false), }, schema.SpawnStructRepresentationMap(map[string]string{"Type": "TagType"}))) ts.Accumulate(schema.SpawnList("ListTag", "Tag", false)) ts.Accumulate(schema.SpawnList("ListParents", "Link", false)) //Todo: type 'Parents' links diff --git a/init.go b/init.go new file mode 100644 index 0000000..518100b --- /dev/null +++ b/init.go @@ -0,0 +1,16 @@ +package ipldgit + +import ( + "github.com/ipfs/go-cid" + cidlink "github.com/ipld/go-ipld-prime/linking/cid" +) + +var ( + _ cidlink.MulticodecDecoder = Decoder + _ cidlink.MulticodecEncoder = Encoder +) + +func init() { + cidlink.RegisterMulticodecDecoder(cid.GitRaw, Decoder) + cidlink.RegisterMulticodecEncoder(cid.GitRaw, Encoder) +} diff --git a/ipldsch_satisfaction.go b/ipldsch_satisfaction.go index 695dde6..06248f4 100644 --- a/ipldsch_satisfaction.go +++ b/ipldsch_satisfaction.go @@ -5227,6 +5227,9 @@ func (n _Tag) FieldTagger() PersonInfo { func (n _Tag) FieldText() String { return &n.Text } +func (n _Tag) FieldDataSize() MaybeString { + return &n.DataSize +} type _Tag__Maybe struct { m schema.Maybe v Tag @@ -5266,6 +5269,7 @@ var ( fieldName__Tag_Tag = _String{"Tag"} fieldName__Tag_Tagger = _String{"Tagger"} fieldName__Tag_Text = _String{"Text"} + fieldName__Tag_DataSize = _String{"DataSize"} ) var _ ipld.Node = (Tag)(&_Tag{}) var _ schema.TypedNode = (Tag)(&_Tag{}) @@ -5284,6 +5288,11 @@ func (n Tag) LookupByString(key string) (ipld.Node, error) { return &n.Tagger, nil case "Text": return &n.Text, nil + case "DataSize": + if n.DataSize.m == schema.Maybe_Absent { + return ipld.Absent, nil + } + return n.DataSize.v, nil default: return nil, schema.ErrNoSuchField{Type: nil /*TODO*/, Field: ipld.PathSegmentOfString(key)} } @@ -5311,7 +5320,7 @@ type _Tag__MapItr struct { } func (itr *_Tag__MapItr) Next() (k ipld.Node, v ipld.Node, _ error) { - if itr.idx >= 5 { + if itr.idx >= 6 { return nil, nil, ipld.ErrIteratorOverread{} } switch itr.idx { @@ -5330,6 +5339,13 @@ func (itr *_Tag__MapItr) Next() (k ipld.Node, v ipld.Node, _ error) { case 4: k = &fieldName__Tag_Text v = &itr.n.Text + case 5: + k = &fieldName__Tag_DataSize + if itr.n.DataSize.m == schema.Maybe_Absent { + v = ipld.Absent + break + } + v = itr.n.DataSize.v default: panic("unreachable") } @@ -5337,14 +5353,14 @@ func (itr *_Tag__MapItr) Next() (k ipld.Node, v ipld.Node, _ error) { return } func (itr *_Tag__MapItr) Done() bool { - return itr.idx >= 5 + return itr.idx >= 6 } func (Tag) ListIterator() ipld.ListIterator { return nil } func (Tag) Length() int64 { - return 5 + return 6 } func (Tag) IsAbsent() bool { return false @@ -5407,6 +5423,7 @@ type _Tag__Assembler struct { ca_Tag _String__Assembler ca_Tagger _PersonInfo__Assembler ca_Text _String__Assembler + ca_DataSize _String__Assembler } func (na *_Tag__Assembler) reset() { @@ -5417,6 +5434,7 @@ func (na *_Tag__Assembler) reset() { na.ca_Tag.reset() na.ca_Tagger.reset() na.ca_Text.reset() + na.ca_DataSize.reset() } var ( @@ -5425,6 +5443,7 @@ var ( fieldBit__Tag_Tag = 1 << 2 fieldBit__Tag_Tagger = 1 << 3 fieldBit__Tag_Text = 1 << 4 + fieldBit__Tag_DataSize = 1 << 5 fieldBits__Tag_sufficient = 0 + 1 << 0 + 1 << 1 + 1 << 2 + 1 << 3 + 1 << 4 ) func (na *_Tag__Assembler) BeginMap(int64) (ipld.MapAssembler, error) { @@ -5568,6 +5587,15 @@ func (ma *_Tag__Assembler) valueFinishTidy() bool { default: return false } + case 5: + switch ma.w.DataSize.m { + case schema.Maybe_Value: + ma.w.DataSize.v = ma.ca_DataSize.w + ma.state = maState_initial + return true + default: + return false + } default: panic("unreachable") } @@ -5638,6 +5666,16 @@ func (ma *_Tag__Assembler) AssembleEntry(k string) (ipld.NodeAssembler, error) { ma.ca_Text.w = &ma.w.Text ma.ca_Text.m = &ma.cm return &ma.ca_Text, nil + case "DataSize": + if ma.s & fieldBit__Tag_DataSize != 0 { + return nil, ipld.ErrRepeatedMapKey{&fieldName__Tag_DataSize} + } + ma.s += fieldBit__Tag_DataSize + ma.state = maState_midValue + ma.f = 5 + ma.ca_DataSize.w = ma.w.DataSize.v + ma.ca_DataSize.m = &ma.w.DataSize.m + return &ma.ca_DataSize, nil default: return nil, ipld.ErrInvalidKey{TypeName:"ipldgit.Tag", Key:&_String{k}} } @@ -5695,6 +5733,10 @@ func (ma *_Tag__Assembler) AssembleValue() ipld.NodeAssembler { ma.ca_Text.w = &ma.w.Text ma.ca_Text.m = &ma.cm return &ma.ca_Text + case 5: + ma.ca_DataSize.w = ma.w.DataSize.v + ma.ca_DataSize.m = &ma.w.DataSize.m + return &ma.ca_DataSize default: panic("unreachable") } @@ -5802,6 +5844,13 @@ func (ka *_Tag__KeyAssembler) AssignString(k string) error { ka.s += fieldBit__Tag_Text ka.state = maState_expectValue ka.f = 4 + case "DataSize": + if ka.s & fieldBit__Tag_DataSize != 0 { + return ipld.ErrRepeatedMapKey{&fieldName__Tag_DataSize} + } + ka.s += fieldBit__Tag_DataSize + ka.state = maState_expectValue + ka.f = 5 default: return ipld.ErrInvalidKey{TypeName:"ipldgit.Tag", Key:&_String{k}} } @@ -5836,6 +5885,7 @@ var ( fieldName__Tag_Tag_serial = _String{"Tag"} fieldName__Tag_Tagger_serial = _String{"Tagger"} fieldName__Tag_Text_serial = _String{"Text"} + fieldName__Tag_DataSize_serial = _String{"DataSize"} ) var _ ipld.Node = &_Tag__Repr{} func (_Tag__Repr) Kind() ipld.Kind { @@ -5853,6 +5903,11 @@ func (n *_Tag__Repr) LookupByString(key string) (ipld.Node, error) { return n.Tagger.Representation(), nil case "Text": return n.Text.Representation(), nil + case "DataSize": + if n.DataSize.m == schema.Maybe_Absent { + return ipld.Absent, ipld.ErrNotExists{ipld.PathSegmentOfString(key)} + } + return n.DataSize.v.Representation(), nil default: return nil, schema.ErrNoSuchField{Type: nil /*TODO*/, Field: ipld.PathSegmentOfString(key)} } @@ -5871,17 +5926,24 @@ func (n _Tag__Repr) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { return n.LookupByString(seg.String()) } func (n *_Tag__Repr) MapIterator() ipld.MapIterator { - return &_Tag__ReprMapItr{n, 0} + end := 6 + if n.DataSize.m == schema.Maybe_Absent { + end = 5 + } else { + goto done + } +done: + return &_Tag__ReprMapItr{n, 0, end} } type _Tag__ReprMapItr struct { n *_Tag__Repr idx int - + end int } func (itr *_Tag__ReprMapItr) Next() (k ipld.Node, v ipld.Node, _ error) { -if itr.idx >= 5 { +advance:if itr.idx >= 6 { return nil, nil, ipld.ErrIteratorOverread{} } switch itr.idx { @@ -5900,6 +5962,13 @@ if itr.idx >= 5 { case 4: k = &fieldName__Tag_Text_serial v = itr.n.Text.Representation() + case 5: + k = &fieldName__Tag_DataSize_serial + if itr.n.DataSize.m == schema.Maybe_Absent { + itr.idx++ + goto advance + } + v = itr.n.DataSize.v.Representation() default: panic("unreachable") } @@ -5907,13 +5976,16 @@ if itr.idx >= 5 { return } func (itr *_Tag__ReprMapItr) Done() bool { - return itr.idx >= 5 + return itr.idx >= itr.end } func (_Tag__Repr) ListIterator() ipld.ListIterator { return nil } func (rn *_Tag__Repr) Length() int64 { - l := 5 + l := 6 + if rn.DataSize.m == schema.Maybe_Absent { + l-- + } return int64(l) } func (_Tag__Repr) IsAbsent() bool { @@ -5977,6 +6049,7 @@ type _Tag__ReprAssembler struct { ca_Tag _String__ReprAssembler ca_Tagger _PersonInfo__ReprAssembler ca_Text _String__ReprAssembler + ca_DataSize _String__ReprAssembler } func (na *_Tag__ReprAssembler) reset() { @@ -5987,6 +6060,7 @@ func (na *_Tag__ReprAssembler) reset() { na.ca_Tag.reset() na.ca_Tagger.reset() na.ca_Text.reset() + na.ca_DataSize.reset() } func (na *_Tag__ReprAssembler) BeginMap(int64) (ipld.MapAssembler, error) { switch *na.m { @@ -6119,6 +6193,15 @@ func (ma *_Tag__ReprAssembler) valueFinishTidy() bool { default: return false } + case 5: + switch ma.w.DataSize.m { + case schema.Maybe_Value: + ma.w.DataSize.v = ma.ca_DataSize.w + ma.state = maState_initial + return true + default: + return false + } default: panic("unreachable") } @@ -6189,6 +6272,17 @@ func (ma *_Tag__ReprAssembler) AssembleEntry(k string) (ipld.NodeAssembler, erro ma.ca_Text.w = &ma.w.Text ma.ca_Text.m = &ma.cm return &ma.ca_Text, nil + case "DataSize": + if ma.s & fieldBit__Tag_DataSize != 0 { + return nil, ipld.ErrRepeatedMapKey{&fieldName__Tag_DataSize_serial} + } + ma.s += fieldBit__Tag_DataSize + ma.state = maState_midValue + ma.f = 5 + ma.ca_DataSize.w = ma.w.DataSize.v + ma.ca_DataSize.m = &ma.w.DataSize.m + + return &ma.ca_DataSize, nil default: return nil, ipld.ErrInvalidKey{TypeName:"ipldgit.Tag.Repr", Key:&_String{k}} } @@ -6246,6 +6340,11 @@ func (ma *_Tag__ReprAssembler) AssembleValue() ipld.NodeAssembler { ma.ca_Text.w = &ma.w.Text ma.ca_Text.m = &ma.cm return &ma.ca_Text + case 5: + ma.ca_DataSize.w = ma.w.DataSize.v + ma.ca_DataSize.m = &ma.w.DataSize.m + + return &ma.ca_DataSize default: panic("unreachable") } @@ -6353,6 +6452,13 @@ func (ka *_Tag__ReprKeyAssembler) AssignString(k string) error { ka.s += fieldBit__Tag_Text ka.state = maState_expectValue ka.f = 4 + case "DataSize": + if ka.s & fieldBit__Tag_DataSize != 0 { + return ipld.ErrRepeatedMapKey{&fieldName__Tag_DataSize_serial} + } + ka.s += fieldBit__Tag_DataSize + ka.state = maState_expectValue + ka.f = 5 default: return ipld.ErrInvalidKey{TypeName:"ipldgit.Tag.Repr", Key:&_String{k}} } diff --git a/ipldsch_types.go b/ipldsch_types.go index bfc73c1..1cfe4b1 100644 --- a/ipldsch_types.go +++ b/ipldsch_types.go @@ -119,6 +119,7 @@ type _Tag struct { Tag _String Tagger _PersonInfo Text _String + DataSize _String__Maybe } // Tree matches the IPLD Schema type "Tree". It has list kind. diff --git a/marshal.go b/marshal.go new file mode 100644 index 0000000..09a0a1f --- /dev/null +++ b/marshal.go @@ -0,0 +1,24 @@ +package ipldgit + +import ( + "fmt" + "io" + + "github.com/ipld/go-ipld-prime" +) + +// Encoder serializes a git node to a raw binary form. +func Encoder(n ipld.Node, w io.Writer) error { + switch n.Prototype() { + case Type.Blob, Type.Blob__Repr: + return encodeBlob(n, w) + case Type.Commit, Type.Commit__Repr: + return encodeCommit(n, w) + case Type.Tree, Type.Tree__Repr: + return encodeTree(n, w) + case Type.Tag, Type.Tag__Repr: + return encodeTag(n, w) + default: + return fmt.Errorf("unrecognized object type: %T", n.Prototype()) + } +} diff --git a/tag.go b/tag.go index 481435d..087c503 100644 --- a/tag.go +++ b/tag.go @@ -10,16 +10,19 @@ import ( "github.com/ipld/go-ipld-prime" cidlink "github.com/ipld/go-ipld-prime/linking/cid" + "github.com/ipld/go-ipld-prime/schema" ) // DecodeTag fills a NodeAssembler (from `Type.Tag__Repr.NewBuilder()`) from a stream of bytes func DecodeTag(na ipld.NodeAssembler, rd *bufio.Reader) error { - _, err := rd.ReadString(0) + size, err := rd.ReadString(0) if err != nil { return err } out := _Tag{} + out.DataSize.m = schema.Maybe_Value + out.DataSize.v = &_String{size} for { line, _, err := rd.ReadLine() @@ -106,3 +109,24 @@ func readMergeTag(hash []byte, rd *bufio.Reader) (Tag, []byte, error) { } return &out, nil, nil } + +func encodeTag(n ipld.Node, w io.Writer) error { + t, ok := n.(Tag) + if !ok { + return fmt.Errorf("not a Commit: %T", n) + } + + buf := new(bytes.Buffer) + fmt.Fprintf(buf, "tag %s\x00", t.DataSize.Must().x) + fmt.Fprintf(buf, "object %s\n", hex.EncodeToString(t.Object.sha())) + fmt.Fprintf(buf, "type %s\n", t.TagType.x) + fmt.Fprintf(buf, "tag %s\n", t.Tag.x) + if !t.Tagger.IsNull() { + fmt.Fprintf(buf, "tagger %s\n", t.Tagger.GitString()) + } + if t.Text.x != "" { + fmt.Fprintf(buf, "\n%s", t.Text.x) + } + _, err := buf.WriteTo(w) + return err +} diff --git a/tree.go b/tree.go index f4f2427..8807a3a 100644 --- a/tree.go +++ b/tree.go @@ -2,6 +2,8 @@ package ipldgit import ( "bufio" + "bytes" + "fmt" "io" "strconv" @@ -66,3 +68,65 @@ func DecodeTreeEntry(na ipld.NodeAssembler, rd *bufio.Reader) error { } return na.AssignNode(&te) } + +func encodeTree(n ipld.Node, w io.Writer) error { + buf := new(bytes.Buffer) + + cnt := 0 + li := n.ListIterator() + for !li.Done() { + _, te, err := li.Next() + if err != nil { + return err + } + cnt++ + if err := encodeTreeEntry(te, buf); err != nil { + return err + } + } + if _, err := fmt.Fprintf(w, "tree %d\x00", cnt); err != nil { + return err + } + + _, err := bufio.NewWriter(w).Write(buf.Bytes()) + return err + +} + +func encodeTreeEntry(n ipld.Node, w io.Writer) error { + m, err := n.LookupByString("Mode") + if err != nil { + return err + } + ms, err := m.AsString() + if err != nil { + return err + } + na, err := n.LookupByString("Name") + if err != nil { + return err + } + ns, err := na.AsString() + if err != nil { + return err + } + ha, err := n.LookupByString("Hash") + if err != nil { + return err + } + _, err = fmt.Fprintf(w, "%s %s\x00", ms, ns) + if err != nil { + return err + } + + hal, err := ha.AsLink() + if err != nil { + return err + } + _, err = w.Write(cidToSha(hal.(cidlink.Link).Cid)) + if err != nil { + return err + } + + return nil +} diff --git a/util.go b/util.go index d5cfed3..a5040b9 100644 --- a/util.go +++ b/util.go @@ -2,6 +2,7 @@ package ipldgit import ( "github.com/ipfs/go-cid" + cidlink "github.com/ipld/go-ipld-prime/linking/cid" mh "github.com/multiformats/go-multihash" ) @@ -9,3 +10,24 @@ func shaToCid(sha []byte) cid.Cid { h, _ := mh.Encode(sha, mh.SHA1) return cid.NewCidV1(cid.GitRaw, h) } + +func cidToSha(c cid.Cid) []byte { + h := c.Hash() + return h[len(h)-20:] +} + +func (l Link) sha() []byte { + cl, ok := l.x.(cidlink.Link) + if !ok { + return nil + } + return cidToSha(cl.Cid) +} + +func (l LinkTree) sha() []byte { + cl, ok := l.x.(cidlink.Link) + if !ok { + return nil + } + return cidToSha(cl.Cid) +} From fc1615bdc19a942d1aed94bad1ed55575f09dd58 Mon Sep 17 00:00:00 2001 From: Will Scott Date: Wed, 24 Feb 2021 12:25:18 -0800 Subject: [PATCH 04/22] tests updated. waiting for working link system (https://github.com/ipld/go-ipld-prime/pull/143) to test sha1 (currently link system doesn't do the hashing) --- git.go | 480 ------------------ git_test.go | 293 ++++++----- go.mod | 5 +- go.sum | 18 +- helper.go | 40 ++ init.go | 3 + ipldsch_minima.go | 25 +- ipldsch_satisfaction.go | 1065 +++++++++++++++++++++++---------------- ipldsch_types.go | 84 +-- unmarshal.go | 35 ++ 10 files changed, 934 insertions(+), 1114 deletions(-) delete mode 100644 git.go create mode 100644 helper.go diff --git a/git.go b/git.go deleted file mode 100644 index 4f9b29c..0000000 --- a/git.go +++ /dev/null @@ -1,480 +0,0 @@ -package ipldgit - -/* -import ( - "bufio" - "bytes" - "compress/zlib" - "encoding/hex" - "errors" - "fmt" - "io" - "io/ioutil" - "strconv" - "strings" - - blocks "github.com/ipfs/go-block-format" - cid "github.com/ipfs/go-cid" - node "github.com/ipfs/go-ipld-format" - mh "github.com/multiformats/go-multihash" -) - -func DecodeBlock(block blocks.Block) (node.Node, error) { - prefix := block.Cid().Prefix() - - if prefix.Codec != cid.GitRaw || prefix.MhType != mh.SHA1 || prefix.MhLength != mh.DefaultLengths[mh.SHA1] { - return nil, errors.New("invalid CID prefix") - } - - return ParseObjectFromBuffer(block.RawData()) -} - -var _ node.DecodeBlockFunc = DecodeBlock - -func ParseObjectFromBuffer(b []byte) (node.Node, error) { - return ParseObject(bytes.NewReader(b)) -} - -func ParseCompressedObject(r io.Reader) (node.Node, error) { - rc, err := zlib.NewReader(r) - if err != nil { - return nil, err - } - defer rc.Close() - - return ParseObject(rc) -} - -func ParseObject(r io.Reader) (node.Node, error) { - rd := bufio.NewReader(r) - - typ, err := rd.ReadString(' ') - if err != nil { - return nil, err - } - typ = typ[:len(typ)-1] - - switch typ { - case "tree": - return ReadTree(rd) - case "commit": - return ReadCommit(rd) - case "blob": - return ReadBlob(rd) - case "tag": - return ReadTag(rd) - default: - return nil, fmt.Errorf("unrecognized object type: %s", typ) - } -} - -func ReadBlob(rd *bufio.Reader) (*Blob, error) { - size, err := rd.ReadString(0) - if err != nil { - return nil, err - } - - sizen, err := strconv.Atoi(size[:len(size)-1]) - if err != nil { - return nil, err - } - - buf := new(bytes.Buffer) - fmt.Fprintf(buf, "blob %d\x00", sizen) - - n, err := io.Copy(buf, rd) - if err != nil { - return nil, err - } - - if n != int64(sizen) { - return nil, fmt.Errorf("blob size was not accurate") - } - - out := &Blob{} - out.rawData = buf.Bytes() - out.cid = hashObject(out.RawData()) - - return out, nil -} - -func ReadCommit(rd *bufio.Reader) (*Commit, error) { - size, err := rd.ReadString(0) - if err != nil { - return nil, err - } - - out := &Commit{ - DataSize: size[:len(size)-1], - } - - for { - line, _, err := rd.ReadLine() - if err != nil { - if err == io.EOF { - break - } - return nil, err - } - - err = parseCommitLine(out, line, rd) - if err != nil { - return nil, err - } - } - - out.cid = hashObject(out.RawData()) - - return out, nil -} - -func parseCommitLine(out *Commit, line []byte, rd *bufio.Reader) error { - switch { - case bytes.HasPrefix(line, []byte("tree ")): - sha, err := hex.DecodeString(string(line[5:])) - if err != nil { - return err - } - - out.GitTree = shaToCid(sha) - case bytes.HasPrefix(line, []byte("parent ")): - psha, err := hex.DecodeString(string(line[7:])) - if err != nil { - return err - } - - out.Parents = append(out.Parents, shaToCid(psha)) - case bytes.HasPrefix(line, []byte("author ")): - a, err := parsePersonInfo(line) - if err != nil { - return err - } - - out.Author = a - case bytes.HasPrefix(line, []byte("committer ")): - c, err := parsePersonInfo(line) - if err != nil { - return err - } - - out.Committer = c - case bytes.HasPrefix(line, []byte("encoding ")): - out.Encoding = string(line[9:]) - case bytes.HasPrefix(line, []byte("mergetag object ")): - sha, err := hex.DecodeString(string(line)[16:]) - if err != nil { - return err - } - - mt, rest, err := ReadMergeTag(sha, rd) - if err != nil { - return err - } - - out.MergeTag = append(out.MergeTag, mt) - - if rest != nil { - err = parseCommitLine(out, rest, rd) - if err != nil { - return err - } - } - case bytes.HasPrefix(line, []byte("gpgsig ")): - sig, err := ReadGpgSig(rd) - if err != nil { - return err - } - out.Sig = sig - case len(line) == 0: - rest, err := ioutil.ReadAll(rd) - if err != nil { - return err - } - - out.Message = string(rest) - default: - out.Other = append(out.Other, string(line)) - } - return nil -} - -func ReadTag(rd *bufio.Reader) (*Tag, error) { - size, err := rd.ReadString(0) - if err != nil { - return nil, err - } - - out := &Tag{ - dataSize: size[:len(size)-1], - } - - for { - line, _, err := rd.ReadLine() - if err != nil { - if err == io.EOF { - break - } - return nil, err - } - - switch { - case bytes.HasPrefix(line, []byte("object ")): - sha, err := hex.DecodeString(string(line[7:])) - if err != nil { - return nil, err - } - - out.Object = shaToCid(sha) - case bytes.HasPrefix(line, []byte("tag ")): - out.Tag = string(line[4:]) - case bytes.HasPrefix(line, []byte("tagger ")): - c, err := parsePersonInfo(line) - if err != nil { - return nil, err - } - - out.Tagger = c - case bytes.HasPrefix(line, []byte("type ")): - out.Type = string(line[5:]) - case len(line) == 0: - rest, err := ioutil.ReadAll(rd) - if err != nil { - return nil, err - } - - out.Message = string(rest) - default: - fmt.Println("unhandled line: ", string(line)) - } - } - - out.cid = hashObject(out.RawData()) - - return out, nil -} - -func hashObject(data []byte) cid.Cid { - c, err := cid.Prefix{ - MhType: mh.SHA1, - MhLength: -1, - Codec: cid.GitRaw, - Version: 1, - }.Sum(data) - if err != nil { - panic(err) - } - return c -} - -func ReadMergeTag(hash []byte, rd *bufio.Reader) (*MergeTag, []byte, error) { - out := new(MergeTag) - - out.Object = shaToCid(hash) - for { - line, _, err := rd.ReadLine() - if err != nil { - if err == io.EOF { - break - } - return nil, nil, err - } - - switch { - case bytes.HasPrefix(line, []byte(" type ")): - out.Type = string(line[6:]) - case bytes.HasPrefix(line, []byte(" tag ")): - out.Tag = string(line[5:]) - case bytes.HasPrefix(line, []byte(" tagger ")): - tagger, err := parsePersonInfo(line[1:]) - if err != nil { - return nil, nil, err - } - out.Tagger = tagger - case string(line) == " ": - for { - line, _, err := rd.ReadLine() - if err != nil { - return nil, nil, err - } - - if !bytes.HasPrefix(line, []byte(" ")) { - return out, line, nil - } - - out.Text += string(line) + "\n" - } - } - } - return out, nil, nil -} - -func ReadGpgSig(rd *bufio.Reader) (*GpgSig, error) { - line, _, err := rd.ReadLine() - if err != nil { - return nil, err - } - - out := new(GpgSig) - - if string(line) != " " { - if strings.HasPrefix(string(line), " Version: ") || strings.HasPrefix(string(line), " Comment: ") { - out.Text += string(line) + "\n" - } else { - return nil, fmt.Errorf("expected first line of sig to be a single space or version") - } - } else { - out.Text += " \n" - } - - for { - line, _, err := rd.ReadLine() - if err != nil { - return nil, err - } - - if bytes.Equal(line, []byte(" -----END PGP SIGNATURE-----")) { - break - } - - out.Text += string(line) + "\n" - } - - return out, nil -} - -func parsePersonInfo(line []byte) (*PersonInfo, error) { - parts := bytes.Split(line, []byte{' '}) - if len(parts) < 3 { - fmt.Println(string(line)) - return nil, fmt.Errorf("incorrectly formatted person info line") - } - - //TODO: just use regex? - //skip prefix - at := 1 - - var pi PersonInfo - var name string - - for { - if at == len(parts) { - return nil, fmt.Errorf("invalid personInfo: %s", line) - } - part := parts[at] - if len(part) != 0 { - if part[0] == '<' { - break - } - name += string(part) + " " - } else if len(name) > 0 { - name += " " - } - at++ - } - if len(name) != 0 { - pi.Name = name[:len(name)-1] - } - - var email string - for { - if at == len(parts) { - return nil, fmt.Errorf("invalid personInfo: %s", line) - } - part := parts[at] - if part[0] == '<' { - part = part[1:] - } - - at++ - if part[len(part)-1] == '>' { - email += string(part[:len(part)-1]) - break - } - email += string(part) + " " - } - pi.Email = email - - if at == len(parts) { - return &pi, nil - } - pi.Date = string(parts[at]) - - at++ - if at == len(parts) { - return &pi, nil - } - pi.Timezone = string(parts[at]) - return &pi, nil -} - -func ReadTree(rd *bufio.Reader) (*Tree, error) { - lstr, err := rd.ReadString(0) - if err != nil { - return nil, err - } - lstr = lstr[:len(lstr)-1] - - n, err := strconv.Atoi(lstr) - if err != nil { - return nil, err - } - - t := &Tree{ - entries: make(map[string]*TreeEntry), - size: n, - } - var order []string - for { - e, err := ReadEntry(rd) - if err != nil { - if err == io.EOF { - break - } - return nil, err - } - - order = append(order, e.name) - t.entries[e.name] = e - } - t.order = order - t.cid = hashObject(t.RawData()) - - return t, nil -} - -func cidToSha(c cid.Cid) []byte { - h := c.Hash() - return h[len(h)-20:] -} - -func shaToCid(sha []byte) cid.Cid { - h, _ := mh.Encode(sha, mh.SHA1) - return cid.NewCidV1(cid.GitRaw, h) -} - -func ReadEntry(r *bufio.Reader) (*TreeEntry, error) { - data, err := r.ReadString(' ') - if err != nil { - return nil, err - } - data = data[:len(data)-1] - - name, err := r.ReadString(0) - if err != nil { - return nil, err - } - name = name[:len(name)-1] - - sha := make([]byte, 20) - _, err = io.ReadFull(r, sha) - if err != nil { - return nil, err - } - - return &TreeEntry{ - name: name, - Mode: data, - Hash: shaToCid(sha), - }, nil -} -*/ diff --git a/git_test.go b/git_test.go index fe548bb..182e4e9 100644 --- a/git_test.go +++ b/git_test.go @@ -1,25 +1,32 @@ package ipldgit -/* import ( "archive/tar" + "bytes" "compress/gzip" + "context" "fmt" "io" "os" "path/filepath" - "reflect" "strings" "testing" - node "github.com/ipfs/go-ipld-format" + "github.com/ipfs/go-cid" + "github.com/ipld/go-ipld-prime" + cidlink "github.com/ipld/go-ipld-prime/linking/cid" + mh "github.com/multiformats/go-multihash" ) -type GitObj interface { - GitSha() []byte -} - func TestObjectParse(t *testing.T) { + lb := cidlink.LinkBuilder{Prefix: cid.NewCidV1(cid.GitRaw, mh.Multihash{}).Prefix()} + sc := func(ipld.Link) error { + return nil + } + storer := func(lnkCtx ipld.LinkContext) (io.Writer, ipld.StoreCommitter, error) { + return bytes.NewBuffer([]byte{}), sc, nil + } + i := 0 err := filepath.Walk(".git/objects", func(path string, info os.FileInfo, err error) error { if err != nil { @@ -52,14 +59,18 @@ func TestObjectParse(t *testing.T) { fmt.Printf("%d %s\r", i, path) } - sha := thing.(GitObj).GitSha() + shal, err := lb.Build(context.Background(), ipld.LinkContext{}, thing, storer) + if err != nil { + t.Fatal(err) + } + sha := shal.(cidlink.Link).Cid.Hash() if fmt.Sprintf("%x", sha) != parts[len(parts)-2]+parts[len(parts)-1] { fmt.Printf("\nsha: %x\n", sha) fmt.Printf("path: %s\n", path) fmt.Printf("mismatch on: %T\n", thing) fmt.Printf("%#v\n", thing) fmt.Println("vvvvvv") - fmt.Println(string(thing.RawData())) + fmt.Println(thing.AsBytes()) fmt.Println("^^^^^^") t.Fatal("mismatch!") } @@ -77,6 +88,19 @@ func TestObjectParse(t *testing.T) { } func TestArchiveObjectParse(t *testing.T) { + lb := cidlink.LinkBuilder{Prefix: cid.Prefix{ + Version: 1, + Codec: cid.GitRaw, + MhType: 0x11, + MhLength: 20, + }} + sc := func(ipld.Link) error { + return nil + } + storer := func(lnkCtx ipld.LinkContext) (io.Writer, ipld.StoreCommitter, error) { + return bytes.NewBuffer([]byte{}), sc, nil + } + archive, err := os.Open("testdata.tar.gz") if err != nil { fmt.Println("ERROR: ", err) @@ -129,14 +153,18 @@ func TestArchiveObjectParse(t *testing.T) { fmt.Printf("%s\r", name) - sha := thing.(GitObj).GitSha() + shal, err := lb.Build(context.Background(), ipld.LinkContext{}, thing, storer) + if err != nil { + t.Fatal(err) + } + sha := shal.(cidlink.Link).Cid.Hash() if fmt.Sprintf("%x", sha) != parts[len(parts)-2]+parts[len(parts)-1] { fmt.Printf("\nsha: %x\n", sha) fmt.Printf("path: %s\n", name) fmt.Printf("mismatch on: %T\n", thing) fmt.Printf("%#v\n", thing) fmt.Println("vvvvvv") - fmt.Println(string(thing.RawData())) + fmt.Println(thing.AsBytes()) fmt.Println("^^^^^^") t.Fatal("mismatch!") } @@ -152,201 +180,188 @@ func TestArchiveObjectParse(t *testing.T) { } -func testNode(t *testing.T, nd node.Node) error { - switch nd.String() { - case "[git blob]": - blob, ok := nd.(*Blob) +func testNode(t *testing.T, nd ipld.Node) error { + switch nd.Prototype() { + case Type.Blob: + blob, ok := nd.(Blob) if !ok { t.Fatalf("Blob is not a blob") } - assert(t, blob.Links() == nil) - assert(t, blob.Tree("", 0) == nil) - assert(t, blob.Loggable()["type"] == "git_blob") + b, err := blob.AsBytes() + assert(t, err == nil) + assert(t, len(b) != 0) - s, _ := blob.Size() - assert(t, len(blob.RawData()) == int(s)) - case "[git commit object]": - commit, ok := nd.(*Commit) + case Type.Commit: + commit, ok := nd.(Commit) if !ok { t.Fatalf("Commit is not a commit") } - s, _ := commit.Size() - assert(t, len(commit.RawData()) == int(s)) - assert(t, reflect.DeepEqual(commit.RawData(), commit.RawData())) - assert(t, commit.GitTree.Defined()) - assert(t, commit.Links() != nil) - assert(t, commit.Loggable()["type"] == "git_commit") - - assert(t, commit.Tree("", -1) != nil) - lnk, rest, err := commit.ResolveLink([]string{"tree", "aoeu"}) - assert(t, err == nil) - assert(t, lnk != nil) - assert(t, len(rest) == 1) - assert(t, rest[0] == "aoeu") - - lnk, rest, err = commit.ResolveLink([]string{"parents", "0"}) - assert(t, err == nil || err.Error() == "index out of range") - assert(t, lnk != nil || err.Error() == "index out of range") - assert(t, len(rest) == 0) - - mt, _, err := commit.Resolve([]string{"mergetag"}) - assert(t, err == nil) - if len(mt.([]*MergeTag)) > 0 { - mtag, _, err := commit.Resolve([]string{"mergetag", "0"}) - assert(t, err == nil) - tag, ok := mtag.(*MergeTag) - if !ok { - t.Fatal("Invalid mergetag") - } + assert(t, !commit.GitTree.IsNull()) + assert(t, len(commit.FieldMergeTag().x) > 0) - ttype, rest, err := commit.Resolve([]string{"mergetag", "0", "type"}) - assert(t, err == nil) - assert(t, len(rest) == 0) - assert(t, ttype.(string) == "commit") - - tagger, rest, err := commit.Resolve([]string{"mergetag", "0", "tagger"}) - assert(t, err == nil) - assert(t, len(rest) == 0) - assert(t, tagger == tag.Tagger) - - link, rest, err := commit.Resolve([]string{"mergetag", "0", "object"}) - assert(t, err == nil) - assert(t, len(rest) == 0) - assert(t, link.(*node.Link).Cid == tag.Object) - - text, rest, err := commit.Resolve([]string{"mergetag", "0", "tag"}) - assert(t, err == nil) - assert(t, len(rest) == 0) - assert(t, text.(string) == tag.Tag) - - text, rest, err = commit.Resolve([]string{"mergetag", "0", "text"}) - assert(t, err == nil) - assert(t, len(rest) == 0) - assert(t, text.(string) == tag.Text) - } - - case "[git tag object]": - tag, ok := nd.(*Tag) + case Type.Tag: + tag, ok := nd.(Tag) if !ok { t.Fatalf("Tag is not a tag") } - assert(t, tag.Type == "commit" || tag.Type == "tree" || tag.Type == "blob" || tag.Type == "tag") - assert(t, reflect.DeepEqual(tag.RawData(), tag.RawData())) - assert(t, tag.Object.Defined()) - assert(t, tag.Loggable()["type"] == "git_tag") - assert(t, tag.Tree("", -1) != nil) - obj, rest, err := tag.ResolveLink([]string{"object", "aoeu"}) + tt, err := tag.TagType.AsString() assert(t, err == nil) - assert(t, obj != nil) - assert(t, rest != nil) - assert(t, len(rest) == 1) - //lint:ignore SA5011 see lines above - assert(t, rest[0] == "aoeu") - case "[git tree object]": - tree, ok := nd.(*Tree) + + assert(t, tt == "commit" || tt == "tree" || tt == "blob" || tt == "tag") + assert(t, !tag.Object.IsNull()) + + case Type.Tree: + tree, ok := nd.(Tree) if !ok { t.Fatalf("Tree is not a tree") } - assert(t, reflect.DeepEqual(tree.RawData(), tree.RawData())) - assert(t, tree.entries != nil) - assert(t, tree.Tree("", 0) == nil) + assert(t, len(tree.x) > 0) } return nil } func TestParsePersonInfo(t *testing.T) { - pi, err := parsePersonInfo([]byte("prefix Someone 123456 +0123")) + p1 := []byte("prefix Someone 123456 +0123") + pi, err := parsePersonInfo(p1) if err != nil { t.Fatal(err) } + if !bytes.Equal([]byte(pi.GitString()), p1) { + t.Fatal("not equal", p1, pi.GitString()) + } - if pi.Date != "123456" { - t.Fatalf("invalid date, got %s\n", pi.Date) + if d, err := pi.LookupByString("Date"); err != nil { + t.Fatalf("invalid date, got %s\n", err) + } else if ds, _ := d.AsString(); ds != "123456" { + t.Fatalf("invalid date, got %s\n", ds) } - if pi.Timezone != "+0123" { - t.Fatalf("invalid timezone, got %s\n", pi.Timezone) + if d, err := pi.LookupByString("Timezone"); err != nil { + t.Fatalf("invalid timezone, got %s\n", err) + } else if ds, _ := d.AsString(); ds != "+0123" { + t.Fatalf("invalid timezone, got %s\n", ds) } - if pi.Email != "some@one.somewhere" { - t.Fatalf("invalid email, got %s\n", pi.Email) + if d, err := pi.LookupByString("Email"); err != nil { + t.Fatalf("invalid email, got %s\n", err) + } else if ds, _ := d.AsString(); ds != "some@one.somewhere" { + t.Fatalf("invalid email, got %s\n", ds) } - if pi.Name != "Someone" { - t.Fatalf("invalid name, got %s\n", pi.Name) + if d, err := pi.LookupByString("Name"); err != nil { + t.Fatalf("invalid name, got %s\n", err) + } else if ds, _ := d.AsString(); ds != "Someone" { + t.Fatalf("invalid name, got %s\n", ds) } - pi, err = parsePersonInfo([]byte("prefix So Me One 123456 +0123")) + p2 := []byte("prefix So Me One 123456 +0123") + pi, err = parsePersonInfo(p2) if err != nil { t.Fatal(err) } + if !bytes.Equal([]byte(pi.GitString()), p2) { + t.Fatal("not equal", p2, pi.GitString()) + } - if pi.Name != "So Me One" { - t.Fatalf("invalid name, got %s\n", pi.Name) + if d, err := pi.LookupByString("Name"); err != nil { + t.Fatalf("invalid name, got %s\n", err) + } else if ds, _ := d.AsString(); ds != "So Me One" { + t.Fatalf("invalid name, got %s\n", ds) } - pi, err = parsePersonInfo([]byte("prefix Some One & Other One 987654 +4321")) + p3 := []byte("prefix Some One & Other One 987654 +4321") + pi, err = parsePersonInfo(p3) if err != nil { t.Fatal(err) } - - if pi.Date != "987654" { - t.Fatalf("invalid date, got %s\n", pi.Date) + if !bytes.Equal([]byte(pi.GitString()), p3) { + t.Fatal("not equal", p3, pi.GitString()) + } + if d, err := pi.LookupByString("Date"); err != nil { + t.Fatalf("invalid date, got %s\n", err) + } else if ds, _ := d.AsString(); ds != "987654" { + t.Fatalf("invalid date, got %s\n", ds) } - if pi.Timezone != "+4321" { - t.Fatalf("invalid timezone, got %s\n", pi.Timezone) + if d, err := pi.LookupByString("Timezone"); err != nil { + t.Fatalf("invalid tz, got %s\n", err) + } else if ds, _ := d.AsString(); ds != "+4321" { + t.Fatalf("invalid tz, got %s\n", ds) } - if pi.Email != "some@one.somewhere, other@one.elsewhere" { - t.Fatalf("invalid email, got %s\n", pi.Email) + if d, err := pi.LookupByString("Email"); err != nil { + t.Fatalf("invalid email, got %s\n", err) + } else if ds, _ := d.AsString(); ds != "some@one.somewhere, other@one.elsewhere" { + t.Fatalf("invalid email, got %s\n", ds) } - if pi.Name != "Some One & Other One" { - t.Fatalf("invalid name, got %s\n", pi.Name) + if d, err := pi.LookupByString("Name"); err != nil { + t.Fatalf("invalid name, got %s\n", err) + } else if ds, _ := d.AsString(); ds != "Some One & Other One" { + t.Fatalf("invalid name, got %s\n", ds) } - pi, err = parsePersonInfo([]byte("prefix 987654 +4321")) + p4 := []byte("prefix 987654 +4321") + pi, err = parsePersonInfo(p4) if err != nil { t.Fatal(err) } + if !bytes.Equal([]byte(pi.GitString()), p4) { + t.Fatal("not equal", p4, pi.GitString()) + } - if pi.Name != "" { - t.Fatalf("invalid name, got %s\n", pi.Name) + if d, err := pi.LookupByString("Name"); err != nil { + t.Fatalf("invalid name, got %s\n", err) + } else if ds, _ := d.AsString(); ds != "" { + t.Fatalf("invalid name, got %s\n", ds) } - if pi.Email != "some@one.somewhere" { - t.Fatalf("invalid email, got %s\n", pi.Email) + if d, err := pi.LookupByString("Email"); err != nil { + t.Fatalf("invalid email, got %s\n", err) + } else if ds, _ := d.AsString(); ds != "some@one.somewhere" { + t.Fatalf("invalid email, got %s\n", ds) } - if pi.Date != "987654" { - t.Fatalf("invalid date, got %s\n", pi.Date) + if d, err := pi.LookupByString("Date"); err != nil { + t.Fatalf("invalid date, got %s\n", err) + } else if ds, _ := d.AsString(); ds != "987654" { + t.Fatalf("invalid date, got %s\n", ds) } - if pi.Timezone != "+4321" { - t.Fatalf("invalid timezone, got %s\n", pi.Timezone) + if d, err := pi.LookupByString("Timezone"); err != nil { + t.Fatalf("invalid tz, got %s\n", err) + } else if ds, _ := d.AsString(); ds != "+4321" { + t.Fatalf("invalid tz, got %s\n", ds) } - pi, err = parsePersonInfo([]byte("prefix Someone 987654 +4321")) + p5 := []byte("prefix Someone 987654 +4321") + pi, err = parsePersonInfo(p5) if err != nil { t.Fatal(err) } + if !bytes.Equal([]byte(pi.GitString()), p5) { + t.Fatal("not equal", p5, pi.GitString()) + } - if pi.Name != "Someone " { - t.Fatalf("invalid name, got %s\n", pi.Name) + if d, err := pi.LookupByString("Name"); err != nil { + t.Fatalf("invalid name, got %s\n", err) + } else if ds, _ := d.AsString(); ds != "Someone " { + t.Fatalf("invalid name, got %s\n", ds) } - pi, err = parsePersonInfo([]byte("prefix Someone ")) + p6 := []byte("prefix Someone ") + pi, err = parsePersonInfo(p6) if err != nil { t.Fatal(err) } - assert(t, pi.String() == "Someone ") + assert(t, pi.GitString() == "Someone ") + /* TODO: json pi, err = parsePersonInfo([]byte("prefix Łukasz Magiera 1546187652 +0100")) assert(t, err == nil) piJSON, err := pi.MarshalJSON() @@ -373,6 +388,7 @@ func TestParsePersonInfo(t *testing.T) { piJSON, err = pi.MarshalJSON() assert(t, err == nil) assert(t, string(piJSON) == `{"date":"2018-12-18T14:03:19-05:45","email":"sameer@users.noreply.github.com","name":"Sameer"}`) + */ } func assert(t *testing.T, ok bool) { @@ -406,8 +422,8 @@ func BenchmarkRawData(b *testing.B) { if err != nil { return err } - thing.RawData() - return nil + buf := bytes.NewBuffer([]byte{}) + return Encoder(thing, buf) }) if err != nil { b.Fatal(err) @@ -416,6 +432,13 @@ func BenchmarkRawData(b *testing.B) { } func BenchmarkCid(b *testing.B) { + lb := cidlink.LinkBuilder{Prefix: cid.NewCidV1(cid.GitRaw, mh.Multihash{}).Prefix()} + sc := func(ipld.Link) error { + return nil + } + storer := func(lnkCtx ipld.LinkContext) (io.Writer, ipld.StoreCommitter, error) { + return bytes.NewBuffer([]byte{}), sc, nil + } for i := 0; i < b.N; i++ { err := filepath.Walk(".git/objects", func(path string, info os.FileInfo, err error) error { if err != nil { @@ -439,12 +462,12 @@ func BenchmarkCid(b *testing.B) { if err != nil { return err } - thing.Cid() - return nil + + _, err = lb.Build(context.Background(), ipld.LinkContext{}, thing, storer) + return err }) if err != nil { b.Fatal(err) } } } -*/ diff --git a/go.mod b/go.mod index 76e5dab..bf96acf 100644 --- a/go.mod +++ b/go.mod @@ -3,7 +3,8 @@ module github.com/ipfs/go-ipld-git go 1.15 require ( - github.com/ipfs/go-cid v0.0.4 + github.com/ipfs/go-block-format v0.0.3 + github.com/ipfs/go-cid v0.0.7 github.com/ipld/go-ipld-prime v0.7.0 - github.com/multiformats/go-multihash v0.0.10 + github.com/multiformats/go-multihash v0.0.14 ) diff --git a/go.sum b/go.sum index 9b713a4..cabe97a 100644 --- a/go.sum +++ b/go.sum @@ -1,7 +1,12 @@ 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 h1:UlfXKrZx1DjZoBhQHmNHLC1fK1dUJDN20Y28A7s+gJ8= +github.com/ipfs/go-block-format v0.0.3 h1:r8t66QstRp/pd/or4dpnbVfXT5Gt7lOqRvC+/dDTpMc= +github.com/ipfs/go-block-format v0.0.3/go.mod h1:4LmD4ZUw0mhO+JSKdpWwrzATiEfM7WWgQ8H5l6P8MVk= 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/ipfs/go-ipfs-util v0.0.2 h1:59Sswnk1MFaiq+VcaknX7aYEyGyGDAA73ilhEK2POp8= +github.com/ipfs/go-ipfs-util v0.0.2/go.mod h1:CbPtkWJzjLdEcezDns2XYaehFVNXG9zrdrtMecczcsQ= github.com/ipld/go-ipld-prime v0.7.0 h1:eigF1ZpaL1prbsKYVMqPLoPJqD/pzkQOe2j1uzvVg7w= github.com/ipld/go-ipld-prime v0.7.0/go.mod h1:0xEgdD6MKbZ1vF0GC+YcR/C4SQCAlRuOjIJ2i0HxqzM= github.com/jtolds/gls v4.20.0+incompatible h1:xdiiI2gbIgH/gLH7ADydsJ1uDOEzR8yvV7C0MuV77Wo= @@ -17,10 +22,17 @@ 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-multibase v0.0.1 h1:PN9/v21eLywrFWdFNsFKaU04kLJzuYzmrJR+ubhT9qA= +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-multihash v0.0.10 h1:lMoNbh2Ssd9PUF74Nz008KGzGPlfeV6wH3rit5IIGCM= +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/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/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= diff --git a/helper.go b/helper.go new file mode 100644 index 0000000..26819f6 --- /dev/null +++ b/helper.go @@ -0,0 +1,40 @@ +package ipldgit + +import ( + "bytes" + "compress/zlib" + "errors" + "io" + + blocks "github.com/ipfs/go-block-format" + "github.com/ipfs/go-cid" + "github.com/ipld/go-ipld-prime" + mh "github.com/multiformats/go-multihash" +) + +// DecodeBlock attempts to parse a serialized ipfs block into an ipld node dag +func DecodeBlock(block blocks.Block) (ipld.Node, error) { + prefix := block.Cid().Prefix() + + if prefix.Codec != cid.GitRaw || prefix.MhType != mh.SHA1 || prefix.MhLength != mh.DefaultLengths[mh.SHA1] { + return nil, errors.New("invalid CID prefix") + } + + return ParseObjectFromBuffer(block.RawData()) +} + +// ParseCompressedObject works like ParseObject, but with a surrounding zlib compression. +func ParseCompressedObject(r io.Reader) (ipld.Node, error) { + rc, err := zlib.NewReader(r) + if err != nil { + return nil, err + } + defer rc.Close() + + return ParseObject(rc) +} + +// ParseObjectFromBuffer is like ParseObject, but with a fully in-memory stream +func ParseObjectFromBuffer(b []byte) (ipld.Node, error) { + return ParseObject(bytes.NewReader(b)) +} diff --git a/init.go b/init.go index 518100b..530cd30 100644 --- a/init.go +++ b/init.go @@ -1,5 +1,8 @@ package ipldgit +//go:generate go run ./gen . +//go:generate go fmt ./ + import ( "github.com/ipfs/go-cid" cidlink "github.com/ipld/go-ipld-prime/linking/cid" diff --git a/ipldsch_minima.go b/ipldsch_minima.go index 39e7432..2d05a1d 100644 --- a/ipldsch_minima.go +++ b/ipldsch_minima.go @@ -10,14 +10,14 @@ import ( ) const ( - midvalue = schema.Maybe(4) + midvalue = schema.Maybe(4) allowNull = schema.Maybe(5) ) type maState uint8 const ( - maState_initial maState = iota + maState_initial maState = iota maState_midKey maState_expectValue maState_midValue @@ -27,24 +27,25 @@ const ( type laState uint8 const ( - laState_initial laState = iota + laState_initial laState = iota laState_midValue laState_finished ) + type _ErrorThunkAssembler struct { e error } -func (ea _ErrorThunkAssembler) BeginMap(_ int64) (ipld.MapAssembler, error) { return nil, ea.e } +func (ea _ErrorThunkAssembler) BeginMap(_ int64) (ipld.MapAssembler, error) { return nil, ea.e } func (ea _ErrorThunkAssembler) BeginList(_ int64) (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(int64) 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) AssignNull() error { return ea.e } +func (ea _ErrorThunkAssembler) AssignBool(bool) error { return ea.e } +func (ea _ErrorThunkAssembler) AssignInt(int64) 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)) } diff --git a/ipldsch_satisfaction.go b/ipldsch_satisfaction.go index 06248f4..0b66061 100644 --- a/ipldsch_satisfaction.go +++ b/ipldsch_satisfaction.go @@ -15,6 +15,7 @@ func (_Blob__Prototype) FromBytes(v []byte) (Blob, error) { n := _Blob{v} return &n, nil } + type _Blob__Maybe struct { m schema.Maybe v Blob @@ -32,14 +33,14 @@ func (m MaybeBlob) Exists() bool { } func (m MaybeBlob) 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") + 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 MaybeBlob) Must() Blob { @@ -48,8 +49,10 @@ func (m MaybeBlob) Must() Blob { } return m.v } + var _ ipld.Node = (Blob)(&_Blob{}) var _ schema.TypedNode = (Blob)(&_Blob{}) + func (Blob) Kind() ipld.Kind { return ipld.Kind_Bytes } @@ -101,6 +104,7 @@ func (Blob) AsLink() (ipld.Link, error) { func (Blob) Prototype() ipld.NodePrototype { return _Blob__Prototype{} } + type _Blob__Prototype struct{} func (_Blob__Prototype) NewBuilder() ipld.NodeBuilder { @@ -108,9 +112,11 @@ func (_Blob__Prototype) NewBuilder() ipld.NodeBuilder { nb.Reset() return &nb } + type _Blob__Builder struct { _Blob__Assembler } + func (nb *_Blob__Builder) Build() ipld.Node { if *nb.m != schema.Maybe_Value { panic("invalid state: cannot call Build on an assembler that's not finished") @@ -122,6 +128,7 @@ func (nb *_Blob__Builder) Reset() { var m schema.Maybe *nb = _Blob__Builder{_Blob__Assembler{w: &w, m: &m}} } + type _Blob__Assembler struct { w *_Blob m *schema.Maybe @@ -206,12 +213,14 @@ func (Blob) Type() schema.Type { func (n Blob) Representation() ipld.Node { return (*_Blob__Repr)(n) } + type _Blob__Repr = _Blob + var _ ipld.Node = &_Blob__Repr{} + type _Blob__ReprPrototype = _Blob__Prototype type _Blob__ReprAssembler = _Blob__Assembler - func (n _Commit) FieldDataSize() String { return &n.DataSize } @@ -242,6 +251,7 @@ func (n _Commit) FieldMergeTag() ListTag { func (n _Commit) FieldOther() ListString { return &n.Other } + type _Commit__Maybe struct { m schema.Maybe v Commit @@ -259,14 +269,14 @@ func (m MaybeCommit) Exists() bool { } func (m MaybeCommit) 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") + 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 MaybeCommit) Must() Commit { @@ -275,20 +285,22 @@ func (m MaybeCommit) Must() Commit { } return m.v } + var ( - fieldName__Commit_DataSize = _String{"DataSize"} - fieldName__Commit_GitTree = _String{"GitTree"} - fieldName__Commit_Parents = _String{"Parents"} - fieldName__Commit_Message = _String{"Message"} - fieldName__Commit_Author = _String{"Author"} + fieldName__Commit_DataSize = _String{"DataSize"} + fieldName__Commit_GitTree = _String{"GitTree"} + fieldName__Commit_Parents = _String{"Parents"} + fieldName__Commit_Message = _String{"Message"} + fieldName__Commit_Author = _String{"Author"} fieldName__Commit_Committer = _String{"Committer"} - fieldName__Commit_Encoding = _String{"Encoding"} - fieldName__Commit_Sig = _String{"Sig"} - fieldName__Commit_MergeTag = _String{"MergeTag"} - fieldName__Commit_Other = _String{"Other"} + fieldName__Commit_Encoding = _String{"Encoding"} + fieldName__Commit_Sig = _String{"Sig"} + fieldName__Commit_MergeTag = _String{"MergeTag"} + fieldName__Commit_Other = _String{"Other"} ) var _ ipld.Node = (Commit)(&_Commit{}) var _ schema.TypedNode = (Commit)(&_Commit{}) + func (Commit) Kind() ipld.Kind { return ipld.Kind_Map } @@ -348,8 +360,8 @@ func (n Commit) MapIterator() ipld.MapIterator { } type _Commit__MapItr struct { - n Commit - idx int + n Commit + idx int } func (itr *_Commit__MapItr) Next() (k ipld.Node, v ipld.Node, _ error) { @@ -446,6 +458,7 @@ func (Commit) AsLink() (ipld.Link, error) { func (Commit) Prototype() ipld.NodePrototype { return _Commit__Prototype{} } + type _Commit__Prototype struct{} func (_Commit__Prototype) NewBuilder() ipld.NodeBuilder { @@ -453,9 +466,11 @@ func (_Commit__Prototype) NewBuilder() ipld.NodeBuilder { nb.Reset() return &nb } + type _Commit__Builder struct { _Commit__Assembler } + func (nb *_Commit__Builder) Build() ipld.Node { if *nb.m != schema.Maybe_Value { panic("invalid state: cannot call Build on an assembler that's not finished") @@ -467,25 +482,26 @@ func (nb *_Commit__Builder) Reset() { var m schema.Maybe *nb = _Commit__Builder{_Commit__Assembler{w: &w, m: &m}} } + type _Commit__Assembler struct { - w *_Commit - m *schema.Maybe + w *_Commit + m *schema.Maybe state maState - s int - f int - - cm schema.Maybe - ca_DataSize _String__Assembler - ca_GitTree _LinkTree__Assembler - ca_Parents _ListParents__Assembler - ca_Message _String__Assembler - ca_Author _PersonInfo__Assembler + s int + f int + + cm schema.Maybe + ca_DataSize _String__Assembler + ca_GitTree _LinkTree__Assembler + ca_Parents _ListParents__Assembler + ca_Message _String__Assembler + ca_Author _PersonInfo__Assembler ca_Committer _PersonInfo__Assembler - ca_Encoding _String__Assembler - ca_Sig _GpgSig__Assembler - ca_MergeTag _ListTag__Assembler - ca_Other _ListString__Assembler - } + ca_Encoding _String__Assembler + ca_Sig _GpgSig__Assembler + ca_MergeTag _ListTag__Assembler + ca_Other _ListString__Assembler +} func (na *_Commit__Assembler) reset() { na.state = maState_initial @@ -503,18 +519,19 @@ func (na *_Commit__Assembler) reset() { } var ( - fieldBit__Commit_DataSize = 1 << 0 - fieldBit__Commit_GitTree = 1 << 1 - fieldBit__Commit_Parents = 1 << 2 - fieldBit__Commit_Message = 1 << 3 - fieldBit__Commit_Author = 1 << 4 - fieldBit__Commit_Committer = 1 << 5 - fieldBit__Commit_Encoding = 1 << 6 - fieldBit__Commit_Sig = 1 << 7 - fieldBit__Commit_MergeTag = 1 << 8 - fieldBit__Commit_Other = 1 << 9 - fieldBits__Commit_sufficient = 0 + 1 << 0 + 1 << 1 + 1 << 2 + 1 << 3 + 1 << 8 + 1 << 9 + fieldBit__Commit_DataSize = 1 << 0 + fieldBit__Commit_GitTree = 1 << 1 + fieldBit__Commit_Parents = 1 << 2 + fieldBit__Commit_Message = 1 << 3 + fieldBit__Commit_Author = 1 << 4 + fieldBit__Commit_Committer = 1 << 5 + fieldBit__Commit_Encoding = 1 << 6 + fieldBit__Commit_Sig = 1 << 7 + fieldBit__Commit_MergeTag = 1 << 8 + fieldBit__Commit_Other = 1 << 9 + fieldBits__Commit_sufficient = 0 + 1<<0 + 1<<1 + 1<<2 + 1<<3 + 1<<8 + 1<<9 ) + func (na *_Commit__Assembler) BeginMap(int64) (ipld.MapAssembler, error) { switch *na.m { case schema.Maybe_Value, schema.Maybe_Null: @@ -723,7 +740,7 @@ func (ma *_Commit__Assembler) AssembleEntry(k string) (ipld.NodeAssembler, error } switch k { case "DataSize": - if ma.s & fieldBit__Commit_DataSize != 0 { + if ma.s&fieldBit__Commit_DataSize != 0 { return nil, ipld.ErrRepeatedMapKey{&fieldName__Commit_DataSize} } ma.s += fieldBit__Commit_DataSize @@ -733,7 +750,7 @@ func (ma *_Commit__Assembler) AssembleEntry(k string) (ipld.NodeAssembler, error ma.ca_DataSize.m = &ma.cm return &ma.ca_DataSize, nil case "GitTree": - if ma.s & fieldBit__Commit_GitTree != 0 { + if ma.s&fieldBit__Commit_GitTree != 0 { return nil, ipld.ErrRepeatedMapKey{&fieldName__Commit_GitTree} } ma.s += fieldBit__Commit_GitTree @@ -743,7 +760,7 @@ func (ma *_Commit__Assembler) AssembleEntry(k string) (ipld.NodeAssembler, error ma.ca_GitTree.m = &ma.cm return &ma.ca_GitTree, nil case "Parents": - if ma.s & fieldBit__Commit_Parents != 0 { + if ma.s&fieldBit__Commit_Parents != 0 { return nil, ipld.ErrRepeatedMapKey{&fieldName__Commit_Parents} } ma.s += fieldBit__Commit_Parents @@ -753,7 +770,7 @@ func (ma *_Commit__Assembler) AssembleEntry(k string) (ipld.NodeAssembler, error ma.ca_Parents.m = &ma.cm return &ma.ca_Parents, nil case "Message": - if ma.s & fieldBit__Commit_Message != 0 { + if ma.s&fieldBit__Commit_Message != 0 { return nil, ipld.ErrRepeatedMapKey{&fieldName__Commit_Message} } ma.s += fieldBit__Commit_Message @@ -763,7 +780,7 @@ func (ma *_Commit__Assembler) AssembleEntry(k string) (ipld.NodeAssembler, error ma.ca_Message.m = &ma.cm return &ma.ca_Message, nil case "Author": - if ma.s & fieldBit__Commit_Author != 0 { + if ma.s&fieldBit__Commit_Author != 0 { return nil, ipld.ErrRepeatedMapKey{&fieldName__Commit_Author} } ma.s += fieldBit__Commit_Author @@ -773,7 +790,7 @@ func (ma *_Commit__Assembler) AssembleEntry(k string) (ipld.NodeAssembler, error ma.ca_Author.m = &ma.w.Author.m return &ma.ca_Author, nil case "Committer": - if ma.s & fieldBit__Commit_Committer != 0 { + if ma.s&fieldBit__Commit_Committer != 0 { return nil, ipld.ErrRepeatedMapKey{&fieldName__Commit_Committer} } ma.s += fieldBit__Commit_Committer @@ -783,7 +800,7 @@ func (ma *_Commit__Assembler) AssembleEntry(k string) (ipld.NodeAssembler, error ma.ca_Committer.m = &ma.w.Committer.m return &ma.ca_Committer, nil case "Encoding": - if ma.s & fieldBit__Commit_Encoding != 0 { + if ma.s&fieldBit__Commit_Encoding != 0 { return nil, ipld.ErrRepeatedMapKey{&fieldName__Commit_Encoding} } ma.s += fieldBit__Commit_Encoding @@ -793,7 +810,7 @@ func (ma *_Commit__Assembler) AssembleEntry(k string) (ipld.NodeAssembler, error ma.ca_Encoding.m = &ma.w.Encoding.m return &ma.ca_Encoding, nil case "Sig": - if ma.s & fieldBit__Commit_Sig != 0 { + if ma.s&fieldBit__Commit_Sig != 0 { return nil, ipld.ErrRepeatedMapKey{&fieldName__Commit_Sig} } ma.s += fieldBit__Commit_Sig @@ -803,7 +820,7 @@ func (ma *_Commit__Assembler) AssembleEntry(k string) (ipld.NodeAssembler, error ma.ca_Sig.m = &ma.w.Sig.m return &ma.ca_Sig, nil case "MergeTag": - if ma.s & fieldBit__Commit_MergeTag != 0 { + if ma.s&fieldBit__Commit_MergeTag != 0 { return nil, ipld.ErrRepeatedMapKey{&fieldName__Commit_MergeTag} } ma.s += fieldBit__Commit_MergeTag @@ -813,7 +830,7 @@ func (ma *_Commit__Assembler) AssembleEntry(k string) (ipld.NodeAssembler, error ma.ca_MergeTag.m = &ma.cm return &ma.ca_MergeTag, nil case "Other": - if ma.s & fieldBit__Commit_Other != 0 { + if ma.s&fieldBit__Commit_Other != 0 { return nil, ipld.ErrRepeatedMapKey{&fieldName__Commit_Other} } ma.s += fieldBit__Commit_Other @@ -823,7 +840,7 @@ func (ma *_Commit__Assembler) AssembleEntry(k string) (ipld.NodeAssembler, error ma.ca_Other.m = &ma.cm return &ma.ca_Other, nil default: - return nil, ipld.ErrInvalidKey{TypeName:"ipldgit.Commit", Key:&_String{k}} + return nil, ipld.ErrInvalidKey{TypeName: "ipldgit.Commit", Key: &_String{k}} } } func (ma *_Commit__Assembler) AssembleKey() ipld.NodeAssembler { @@ -918,24 +935,24 @@ func (ma *_Commit__Assembler) Finish() error { case maState_finished: panic("invalid state: Finish cannot be called on an assembler that's already finished") } - if ma.s & fieldBits__Commit_sufficient != fieldBits__Commit_sufficient { + if ma.s&fieldBits__Commit_sufficient != fieldBits__Commit_sufficient { err := ipld.ErrMissingRequiredField{Missing: make([]string, 0)} - if ma.s & fieldBit__Commit_DataSize == 0 { + if ma.s&fieldBit__Commit_DataSize == 0 { err.Missing = append(err.Missing, "DataSize") } - if ma.s & fieldBit__Commit_GitTree == 0 { + if ma.s&fieldBit__Commit_GitTree == 0 { err.Missing = append(err.Missing, "GitTree") } - if ma.s & fieldBit__Commit_Parents == 0 { + if ma.s&fieldBit__Commit_Parents == 0 { err.Missing = append(err.Missing, "Parents") } - if ma.s & fieldBit__Commit_Message == 0 { + if ma.s&fieldBit__Commit_Message == 0 { err.Missing = append(err.Missing, "Message") } - if ma.s & fieldBit__Commit_MergeTag == 0 { + if ma.s&fieldBit__Commit_MergeTag == 0 { err.Missing = append(err.Missing, "MergeTag") } - if ma.s & fieldBit__Commit_Other == 0 { + if ma.s&fieldBit__Commit_Other == 0 { err.Missing = append(err.Missing, "Other") } return err @@ -950,7 +967,9 @@ func (ma *_Commit__Assembler) KeyPrototype() ipld.NodePrototype { func (ma *_Commit__Assembler) ValuePrototype(k string) ipld.NodePrototype { panic("todo structbuilder mapassembler valueprototype") } + type _Commit__KeyAssembler _Commit__Assembler + func (_Commit__KeyAssembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { return mixins.StringAssembler{"ipldgit.Commit.KeyAssembler"}.BeginMap(0) } @@ -975,77 +994,77 @@ func (ka *_Commit__KeyAssembler) AssignString(k string) error { } switch k { case "DataSize": - if ka.s & fieldBit__Commit_DataSize != 0 { + if ka.s&fieldBit__Commit_DataSize != 0 { return ipld.ErrRepeatedMapKey{&fieldName__Commit_DataSize} } ka.s += fieldBit__Commit_DataSize ka.state = maState_expectValue ka.f = 0 case "GitTree": - if ka.s & fieldBit__Commit_GitTree != 0 { + if ka.s&fieldBit__Commit_GitTree != 0 { return ipld.ErrRepeatedMapKey{&fieldName__Commit_GitTree} } ka.s += fieldBit__Commit_GitTree ka.state = maState_expectValue ka.f = 1 case "Parents": - if ka.s & fieldBit__Commit_Parents != 0 { + if ka.s&fieldBit__Commit_Parents != 0 { return ipld.ErrRepeatedMapKey{&fieldName__Commit_Parents} } ka.s += fieldBit__Commit_Parents ka.state = maState_expectValue ka.f = 2 case "Message": - if ka.s & fieldBit__Commit_Message != 0 { + if ka.s&fieldBit__Commit_Message != 0 { return ipld.ErrRepeatedMapKey{&fieldName__Commit_Message} } ka.s += fieldBit__Commit_Message ka.state = maState_expectValue ka.f = 3 case "Author": - if ka.s & fieldBit__Commit_Author != 0 { + if ka.s&fieldBit__Commit_Author != 0 { return ipld.ErrRepeatedMapKey{&fieldName__Commit_Author} } ka.s += fieldBit__Commit_Author ka.state = maState_expectValue ka.f = 4 case "Committer": - if ka.s & fieldBit__Commit_Committer != 0 { + if ka.s&fieldBit__Commit_Committer != 0 { return ipld.ErrRepeatedMapKey{&fieldName__Commit_Committer} } ka.s += fieldBit__Commit_Committer ka.state = maState_expectValue ka.f = 5 case "Encoding": - if ka.s & fieldBit__Commit_Encoding != 0 { + if ka.s&fieldBit__Commit_Encoding != 0 { return ipld.ErrRepeatedMapKey{&fieldName__Commit_Encoding} } ka.s += fieldBit__Commit_Encoding ka.state = maState_expectValue ka.f = 6 case "Sig": - if ka.s & fieldBit__Commit_Sig != 0 { + if ka.s&fieldBit__Commit_Sig != 0 { return ipld.ErrRepeatedMapKey{&fieldName__Commit_Sig} } ka.s += fieldBit__Commit_Sig ka.state = maState_expectValue ka.f = 7 case "MergeTag": - if ka.s & fieldBit__Commit_MergeTag != 0 { + if ka.s&fieldBit__Commit_MergeTag != 0 { return ipld.ErrRepeatedMapKey{&fieldName__Commit_MergeTag} } ka.s += fieldBit__Commit_MergeTag ka.state = maState_expectValue ka.f = 8 case "Other": - if ka.s & fieldBit__Commit_Other != 0 { + if ka.s&fieldBit__Commit_Other != 0 { return ipld.ErrRepeatedMapKey{&fieldName__Commit_Other} } ka.s += fieldBit__Commit_Other ka.state = maState_expectValue ka.f = 9 default: - return ipld.ErrInvalidKey{TypeName:"ipldgit.Commit", Key:&_String{k}} + return ipld.ErrInvalidKey{TypeName: "ipldgit.Commit", Key: &_String{k}} } return nil } @@ -1071,20 +1090,23 @@ func (Commit) Type() schema.Type { func (n Commit) Representation() ipld.Node { return (*_Commit__Repr)(n) } + type _Commit__Repr _Commit + var ( - fieldName__Commit_DataSize_serial = _String{"DataSize"} - fieldName__Commit_GitTree_serial = _String{"GitTree"} - fieldName__Commit_Parents_serial = _String{"Parents"} - fieldName__Commit_Message_serial = _String{"Message"} - fieldName__Commit_Author_serial = _String{"Author"} + fieldName__Commit_DataSize_serial = _String{"DataSize"} + fieldName__Commit_GitTree_serial = _String{"GitTree"} + fieldName__Commit_Parents_serial = _String{"Parents"} + fieldName__Commit_Message_serial = _String{"Message"} + fieldName__Commit_Author_serial = _String{"Author"} fieldName__Commit_Committer_serial = _String{"Committer"} - fieldName__Commit_Encoding_serial = _String{"Encoding"} - fieldName__Commit_Sig_serial = _String{"Sig"} - fieldName__Commit_MergeTag_serial = _String{"MergeTag"} - fieldName__Commit_Other_serial = _String{"Other"} + fieldName__Commit_Encoding_serial = _String{"Encoding"} + fieldName__Commit_Sig_serial = _String{"Sig"} + fieldName__Commit_MergeTag_serial = _String{"MergeTag"} + fieldName__Commit_Other_serial = _String{"Other"} ) var _ ipld.Node = &_Commit__Repr{} + func (_Commit__Repr) Kind() ipld.Kind { return ipld.Kind_Map } @@ -1146,11 +1168,11 @@ func (n *_Commit__Repr) MapIterator() ipld.MapIterator { type _Commit__ReprMapItr struct { n *_Commit__Repr idx int - } func (itr *_Commit__ReprMapItr) Next() (k ipld.Node, v ipld.Node, _ error) { -advance:if itr.idx >= 10 { +advance: + if itr.idx >= 10 { return nil, nil, ipld.ErrIteratorOverread{} } switch itr.idx { @@ -1255,6 +1277,7 @@ func (_Commit__Repr) AsLink() (ipld.Link, error) { func (_Commit__Repr) Prototype() ipld.NodePrototype { return _Commit__ReprPrototype{} } + type _Commit__ReprPrototype struct{} func (_Commit__ReprPrototype) NewBuilder() ipld.NodeBuilder { @@ -1262,9 +1285,11 @@ func (_Commit__ReprPrototype) NewBuilder() ipld.NodeBuilder { nb.Reset() return &nb } + type _Commit__ReprBuilder struct { _Commit__ReprAssembler } + func (nb *_Commit__ReprBuilder) Build() ipld.Node { if *nb.m != schema.Maybe_Value { panic("invalid state: cannot call Build on an assembler that's not finished") @@ -1276,25 +1301,26 @@ func (nb *_Commit__ReprBuilder) Reset() { var m schema.Maybe *nb = _Commit__ReprBuilder{_Commit__ReprAssembler{w: &w, m: &m}} } + type _Commit__ReprAssembler struct { - w *_Commit - m *schema.Maybe + w *_Commit + m *schema.Maybe state maState - s int - f int - - cm schema.Maybe - ca_DataSize _String__ReprAssembler - ca_GitTree _LinkTree__ReprAssembler - ca_Parents _ListParents__ReprAssembler - ca_Message _String__ReprAssembler - ca_Author _PersonInfo__ReprAssembler + s int + f int + + cm schema.Maybe + ca_DataSize _String__ReprAssembler + ca_GitTree _LinkTree__ReprAssembler + ca_Parents _ListParents__ReprAssembler + ca_Message _String__ReprAssembler + ca_Author _PersonInfo__ReprAssembler ca_Committer _PersonInfo__ReprAssembler - ca_Encoding _String__ReprAssembler - ca_Sig _GpgSig__ReprAssembler - ca_MergeTag _ListTag__ReprAssembler - ca_Other _ListString__ReprAssembler - } + ca_Encoding _String__ReprAssembler + ca_Sig _GpgSig__ReprAssembler + ca_MergeTag _ListTag__ReprAssembler + ca_Other _ListString__ReprAssembler +} func (na *_Commit__ReprAssembler) reset() { na.state = maState_initial @@ -1403,7 +1429,8 @@ func (ma *_Commit__ReprAssembler) valueFinishTidy() bool { switch ma.f { case 0: switch ma.cm { - case schema.Maybe_Value:ma.cm = schema.Maybe_Absent + case schema.Maybe_Value: + ma.cm = schema.Maybe_Absent ma.state = maState_initial return true default: @@ -1411,7 +1438,8 @@ func (ma *_Commit__ReprAssembler) valueFinishTidy() bool { } case 1: switch ma.cm { - case schema.Maybe_Value:ma.cm = schema.Maybe_Absent + case schema.Maybe_Value: + ma.cm = schema.Maybe_Absent ma.state = maState_initial return true default: @@ -1419,7 +1447,8 @@ func (ma *_Commit__ReprAssembler) valueFinishTidy() bool { } case 2: switch ma.cm { - case schema.Maybe_Value:ma.cm = schema.Maybe_Absent + case schema.Maybe_Value: + ma.cm = schema.Maybe_Absent ma.state = maState_initial return true default: @@ -1427,7 +1456,8 @@ func (ma *_Commit__ReprAssembler) valueFinishTidy() bool { } case 3: switch ma.cm { - case schema.Maybe_Value:ma.cm = schema.Maybe_Absent + case schema.Maybe_Value: + ma.cm = schema.Maybe_Absent ma.state = maState_initial return true default: @@ -1471,7 +1501,8 @@ func (ma *_Commit__ReprAssembler) valueFinishTidy() bool { } case 8: switch ma.cm { - case schema.Maybe_Value:ma.cm = schema.Maybe_Absent + case schema.Maybe_Value: + ma.cm = schema.Maybe_Absent ma.state = maState_initial return true default: @@ -1479,7 +1510,8 @@ func (ma *_Commit__ReprAssembler) valueFinishTidy() bool { } case 9: switch ma.cm { - case schema.Maybe_Value:ma.cm = schema.Maybe_Absent + case schema.Maybe_Value: + ma.cm = schema.Maybe_Absent ma.state = maState_initial return true default: @@ -1506,7 +1538,7 @@ func (ma *_Commit__ReprAssembler) AssembleEntry(k string) (ipld.NodeAssembler, e } switch k { case "DataSize": - if ma.s & fieldBit__Commit_DataSize != 0 { + if ma.s&fieldBit__Commit_DataSize != 0 { return nil, ipld.ErrRepeatedMapKey{&fieldName__Commit_DataSize_serial} } ma.s += fieldBit__Commit_DataSize @@ -1516,7 +1548,7 @@ func (ma *_Commit__ReprAssembler) AssembleEntry(k string) (ipld.NodeAssembler, e ma.ca_DataSize.m = &ma.cm return &ma.ca_DataSize, nil case "GitTree": - if ma.s & fieldBit__Commit_GitTree != 0 { + if ma.s&fieldBit__Commit_GitTree != 0 { return nil, ipld.ErrRepeatedMapKey{&fieldName__Commit_GitTree_serial} } ma.s += fieldBit__Commit_GitTree @@ -1526,7 +1558,7 @@ func (ma *_Commit__ReprAssembler) AssembleEntry(k string) (ipld.NodeAssembler, e ma.ca_GitTree.m = &ma.cm return &ma.ca_GitTree, nil case "Parents": - if ma.s & fieldBit__Commit_Parents != 0 { + if ma.s&fieldBit__Commit_Parents != 0 { return nil, ipld.ErrRepeatedMapKey{&fieldName__Commit_Parents_serial} } ma.s += fieldBit__Commit_Parents @@ -1536,7 +1568,7 @@ func (ma *_Commit__ReprAssembler) AssembleEntry(k string) (ipld.NodeAssembler, e ma.ca_Parents.m = &ma.cm return &ma.ca_Parents, nil case "Message": - if ma.s & fieldBit__Commit_Message != 0 { + if ma.s&fieldBit__Commit_Message != 0 { return nil, ipld.ErrRepeatedMapKey{&fieldName__Commit_Message_serial} } ma.s += fieldBit__Commit_Message @@ -1546,7 +1578,7 @@ func (ma *_Commit__ReprAssembler) AssembleEntry(k string) (ipld.NodeAssembler, e ma.ca_Message.m = &ma.cm return &ma.ca_Message, nil case "Author": - if ma.s & fieldBit__Commit_Author != 0 { + if ma.s&fieldBit__Commit_Author != 0 { return nil, ipld.ErrRepeatedMapKey{&fieldName__Commit_Author_serial} } ma.s += fieldBit__Commit_Author @@ -1554,10 +1586,10 @@ func (ma *_Commit__ReprAssembler) AssembleEntry(k string) (ipld.NodeAssembler, e ma.f = 4 ma.ca_Author.w = ma.w.Author.v ma.ca_Author.m = &ma.w.Author.m - + return &ma.ca_Author, nil case "Committer": - if ma.s & fieldBit__Commit_Committer != 0 { + if ma.s&fieldBit__Commit_Committer != 0 { return nil, ipld.ErrRepeatedMapKey{&fieldName__Commit_Committer_serial} } ma.s += fieldBit__Commit_Committer @@ -1565,10 +1597,10 @@ func (ma *_Commit__ReprAssembler) AssembleEntry(k string) (ipld.NodeAssembler, e ma.f = 5 ma.ca_Committer.w = ma.w.Committer.v ma.ca_Committer.m = &ma.w.Committer.m - + return &ma.ca_Committer, nil case "Encoding": - if ma.s & fieldBit__Commit_Encoding != 0 { + if ma.s&fieldBit__Commit_Encoding != 0 { return nil, ipld.ErrRepeatedMapKey{&fieldName__Commit_Encoding_serial} } ma.s += fieldBit__Commit_Encoding @@ -1576,10 +1608,10 @@ func (ma *_Commit__ReprAssembler) AssembleEntry(k string) (ipld.NodeAssembler, e ma.f = 6 ma.ca_Encoding.w = ma.w.Encoding.v ma.ca_Encoding.m = &ma.w.Encoding.m - + return &ma.ca_Encoding, nil case "Sig": - if ma.s & fieldBit__Commit_Sig != 0 { + if ma.s&fieldBit__Commit_Sig != 0 { return nil, ipld.ErrRepeatedMapKey{&fieldName__Commit_Sig_serial} } ma.s += fieldBit__Commit_Sig @@ -1587,10 +1619,10 @@ func (ma *_Commit__ReprAssembler) AssembleEntry(k string) (ipld.NodeAssembler, e ma.f = 7 ma.ca_Sig.w = ma.w.Sig.v ma.ca_Sig.m = &ma.w.Sig.m - + return &ma.ca_Sig, nil case "MergeTag": - if ma.s & fieldBit__Commit_MergeTag != 0 { + if ma.s&fieldBit__Commit_MergeTag != 0 { return nil, ipld.ErrRepeatedMapKey{&fieldName__Commit_MergeTag_serial} } ma.s += fieldBit__Commit_MergeTag @@ -1600,7 +1632,7 @@ func (ma *_Commit__ReprAssembler) AssembleEntry(k string) (ipld.NodeAssembler, e ma.ca_MergeTag.m = &ma.cm return &ma.ca_MergeTag, nil case "Other": - if ma.s & fieldBit__Commit_Other != 0 { + if ma.s&fieldBit__Commit_Other != 0 { return nil, ipld.ErrRepeatedMapKey{&fieldName__Commit_Other_serial} } ma.s += fieldBit__Commit_Other @@ -1610,7 +1642,7 @@ func (ma *_Commit__ReprAssembler) AssembleEntry(k string) (ipld.NodeAssembler, e ma.ca_Other.m = &ma.cm return &ma.ca_Other, nil default: - return nil, ipld.ErrInvalidKey{TypeName:"ipldgit.Commit.Repr", Key:&_String{k}} + return nil, ipld.ErrInvalidKey{TypeName: "ipldgit.Commit.Repr", Key: &_String{k}} } } func (ma *_Commit__ReprAssembler) AssembleKey() ipld.NodeAssembler { @@ -1665,22 +1697,22 @@ func (ma *_Commit__ReprAssembler) AssembleValue() ipld.NodeAssembler { case 4: ma.ca_Author.w = ma.w.Author.v ma.ca_Author.m = &ma.w.Author.m - + return &ma.ca_Author case 5: ma.ca_Committer.w = ma.w.Committer.v ma.ca_Committer.m = &ma.w.Committer.m - + return &ma.ca_Committer case 6: ma.ca_Encoding.w = ma.w.Encoding.v ma.ca_Encoding.m = &ma.w.Encoding.m - + return &ma.ca_Encoding case 7: ma.ca_Sig.w = ma.w.Sig.v ma.ca_Sig.m = &ma.w.Sig.m - + return &ma.ca_Sig case 8: ma.ca_MergeTag.w = &ma.w.MergeTag @@ -1709,24 +1741,24 @@ func (ma *_Commit__ReprAssembler) Finish() error { case maState_finished: panic("invalid state: Finish cannot be called on an assembler that's already finished") } - if ma.s & fieldBits__Commit_sufficient != fieldBits__Commit_sufficient { + if ma.s&fieldBits__Commit_sufficient != fieldBits__Commit_sufficient { err := ipld.ErrMissingRequiredField{Missing: make([]string, 0)} - if ma.s & fieldBit__Commit_DataSize == 0 { + if ma.s&fieldBit__Commit_DataSize == 0 { err.Missing = append(err.Missing, "DataSize") } - if ma.s & fieldBit__Commit_GitTree == 0 { + if ma.s&fieldBit__Commit_GitTree == 0 { err.Missing = append(err.Missing, "GitTree") } - if ma.s & fieldBit__Commit_Parents == 0 { + if ma.s&fieldBit__Commit_Parents == 0 { err.Missing = append(err.Missing, "Parents") } - if ma.s & fieldBit__Commit_Message == 0 { + if ma.s&fieldBit__Commit_Message == 0 { err.Missing = append(err.Missing, "Message") } - if ma.s & fieldBit__Commit_MergeTag == 0 { + if ma.s&fieldBit__Commit_MergeTag == 0 { err.Missing = append(err.Missing, "MergeTag") } - if ma.s & fieldBit__Commit_Other == 0 { + if ma.s&fieldBit__Commit_Other == 0 { err.Missing = append(err.Missing, "Other") } return err @@ -1741,7 +1773,9 @@ func (ma *_Commit__ReprAssembler) KeyPrototype() ipld.NodePrototype { func (ma *_Commit__ReprAssembler) ValuePrototype(k string) ipld.NodePrototype { panic("todo structbuilder mapassembler repr valueprototype") } + type _Commit__ReprKeyAssembler _Commit__ReprAssembler + func (_Commit__ReprKeyAssembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { return mixins.StringAssembler{"ipldgit.Commit.Repr.KeyAssembler"}.BeginMap(0) } @@ -1766,77 +1800,77 @@ func (ka *_Commit__ReprKeyAssembler) AssignString(k string) error { } switch k { case "DataSize": - if ka.s & fieldBit__Commit_DataSize != 0 { + if ka.s&fieldBit__Commit_DataSize != 0 { return ipld.ErrRepeatedMapKey{&fieldName__Commit_DataSize_serial} } ka.s += fieldBit__Commit_DataSize ka.state = maState_expectValue ka.f = 0 case "GitTree": - if ka.s & fieldBit__Commit_GitTree != 0 { + if ka.s&fieldBit__Commit_GitTree != 0 { return ipld.ErrRepeatedMapKey{&fieldName__Commit_GitTree_serial} } ka.s += fieldBit__Commit_GitTree ka.state = maState_expectValue ka.f = 1 case "Parents": - if ka.s & fieldBit__Commit_Parents != 0 { + if ka.s&fieldBit__Commit_Parents != 0 { return ipld.ErrRepeatedMapKey{&fieldName__Commit_Parents_serial} } ka.s += fieldBit__Commit_Parents ka.state = maState_expectValue ka.f = 2 case "Message": - if ka.s & fieldBit__Commit_Message != 0 { + if ka.s&fieldBit__Commit_Message != 0 { return ipld.ErrRepeatedMapKey{&fieldName__Commit_Message_serial} } ka.s += fieldBit__Commit_Message ka.state = maState_expectValue ka.f = 3 case "Author": - if ka.s & fieldBit__Commit_Author != 0 { + if ka.s&fieldBit__Commit_Author != 0 { return ipld.ErrRepeatedMapKey{&fieldName__Commit_Author_serial} } ka.s += fieldBit__Commit_Author ka.state = maState_expectValue ka.f = 4 case "Committer": - if ka.s & fieldBit__Commit_Committer != 0 { + if ka.s&fieldBit__Commit_Committer != 0 { return ipld.ErrRepeatedMapKey{&fieldName__Commit_Committer_serial} } ka.s += fieldBit__Commit_Committer ka.state = maState_expectValue ka.f = 5 case "Encoding": - if ka.s & fieldBit__Commit_Encoding != 0 { + if ka.s&fieldBit__Commit_Encoding != 0 { return ipld.ErrRepeatedMapKey{&fieldName__Commit_Encoding_serial} } ka.s += fieldBit__Commit_Encoding ka.state = maState_expectValue ka.f = 6 case "Sig": - if ka.s & fieldBit__Commit_Sig != 0 { + if ka.s&fieldBit__Commit_Sig != 0 { return ipld.ErrRepeatedMapKey{&fieldName__Commit_Sig_serial} } ka.s += fieldBit__Commit_Sig ka.state = maState_expectValue ka.f = 7 case "MergeTag": - if ka.s & fieldBit__Commit_MergeTag != 0 { + if ka.s&fieldBit__Commit_MergeTag != 0 { return ipld.ErrRepeatedMapKey{&fieldName__Commit_MergeTag_serial} } ka.s += fieldBit__Commit_MergeTag ka.state = maState_expectValue ka.f = 8 case "Other": - if ka.s & fieldBit__Commit_Other != 0 { + if ka.s&fieldBit__Commit_Other != 0 { return ipld.ErrRepeatedMapKey{&fieldName__Commit_Other_serial} } ka.s += fieldBit__Commit_Other ka.state = maState_expectValue ka.f = 9 default: - return ipld.ErrInvalidKey{TypeName:"ipldgit.Commit.Repr", Key:&_String{k}} + return ipld.ErrInvalidKey{TypeName: "ipldgit.Commit.Repr", Key: &_String{k}} } return nil } @@ -1868,6 +1902,7 @@ func (_GpgSig__Prototype) FromString(v string) (GpgSig, error) { n := _GpgSig{v} return &n, nil } + type _GpgSig__Maybe struct { m schema.Maybe v GpgSig @@ -1885,14 +1920,14 @@ func (m MaybeGpgSig) Exists() bool { } func (m MaybeGpgSig) 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") + 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 MaybeGpgSig) Must() GpgSig { @@ -1901,8 +1936,10 @@ func (m MaybeGpgSig) Must() GpgSig { } return m.v } + var _ ipld.Node = (GpgSig)(&_GpgSig{}) var _ schema.TypedNode = (GpgSig)(&_GpgSig{}) + func (GpgSig) Kind() ipld.Kind { return ipld.Kind_String } @@ -1954,6 +1991,7 @@ func (GpgSig) AsLink() (ipld.Link, error) { func (GpgSig) Prototype() ipld.NodePrototype { return _GpgSig__Prototype{} } + type _GpgSig__Prototype struct{} func (_GpgSig__Prototype) NewBuilder() ipld.NodeBuilder { @@ -1961,9 +1999,11 @@ func (_GpgSig__Prototype) NewBuilder() ipld.NodeBuilder { nb.Reset() return &nb } + type _GpgSig__Builder struct { _GpgSig__Assembler } + func (nb *_GpgSig__Builder) Build() ipld.Node { if *nb.m != schema.Maybe_Value { panic("invalid state: cannot call Build on an assembler that's not finished") @@ -1975,6 +2015,7 @@ func (nb *_GpgSig__Builder) Reset() { var m schema.Maybe *nb = _GpgSig__Builder{_GpgSig__Assembler{w: &w, m: &m}} } + type _GpgSig__Assembler struct { w *_GpgSig m *schema.Maybe @@ -2059,8 +2100,11 @@ func (GpgSig) Type() schema.Type { func (n GpgSig) Representation() ipld.Node { return (*_GpgSig__Repr)(n) } + type _GpgSig__Repr = _GpgSig + var _ ipld.Node = &_GpgSig__Repr{} + type _GpgSig__ReprPrototype = _GpgSig__Prototype type _GpgSig__ReprAssembler = _GpgSig__Assembler @@ -2071,6 +2115,7 @@ func (_Link__Prototype) FromLink(v ipld.Link) (Link, error) { n := _Link{v} return &n, nil } + type _Link__Maybe struct { m schema.Maybe v Link @@ -2088,14 +2133,14 @@ func (m MaybeLink) Exists() bool { } 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") + 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 { @@ -2104,8 +2149,10 @@ func (m MaybeLink) Must() Link { } return m.v } + var _ ipld.Node = (Link)(&_Link{}) var _ schema.TypedNode = (Link)(&_Link{}) + func (Link) Kind() ipld.Kind { return ipld.Kind_Link } @@ -2157,6 +2204,7 @@ func (n Link) AsLink() (ipld.Link, error) { func (Link) Prototype() ipld.NodePrototype { return _Link__Prototype{} } + type _Link__Prototype struct{} func (_Link__Prototype) NewBuilder() ipld.NodeBuilder { @@ -2164,9 +2212,11 @@ func (_Link__Prototype) NewBuilder() ipld.NodeBuilder { 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") @@ -2178,6 +2228,7 @@ func (nb *_Link__Builder) Reset() { var m schema.Maybe *nb = _Link__Builder{_Link__Assembler{w: &w, m: &m}} } + type _Link__Assembler struct { w *_Link m *schema.Maybe @@ -2262,8 +2313,11 @@ func (Link) Type() schema.Type { 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 @@ -2274,6 +2328,7 @@ func (_LinkTree__Prototype) FromLink(v ipld.Link) (LinkTree, error) { n := _LinkTree{v} return &n, nil } + type _LinkTree__Maybe struct { m schema.Maybe v LinkTree @@ -2291,14 +2346,14 @@ func (m MaybeLinkTree) Exists() bool { } func (m MaybeLinkTree) 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") + 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 MaybeLinkTree) Must() LinkTree { @@ -2307,8 +2362,10 @@ func (m MaybeLinkTree) Must() LinkTree { } return m.v } + var _ ipld.Node = (LinkTree)(&_LinkTree{}) var _ schema.TypedNode = (LinkTree)(&_LinkTree{}) + func (LinkTree) Kind() ipld.Kind { return ipld.Kind_Link } @@ -2360,6 +2417,7 @@ func (n LinkTree) AsLink() (ipld.Link, error) { func (LinkTree) Prototype() ipld.NodePrototype { return _LinkTree__Prototype{} } + type _LinkTree__Prototype struct{} func (_LinkTree__Prototype) NewBuilder() ipld.NodeBuilder { @@ -2367,9 +2425,11 @@ func (_LinkTree__Prototype) NewBuilder() ipld.NodeBuilder { nb.Reset() return &nb } + type _LinkTree__Builder struct { _LinkTree__Assembler } + func (nb *_LinkTree__Builder) Build() ipld.Node { if *nb.m != schema.Maybe_Value { panic("invalid state: cannot call Build on an assembler that's not finished") @@ -2381,6 +2441,7 @@ func (nb *_LinkTree__Builder) Reset() { var m schema.Maybe *nb = _LinkTree__Builder{_LinkTree__Assembler{w: &w, m: &m}} } + type _LinkTree__Assembler struct { w *_LinkTree m *schema.Maybe @@ -2468,8 +2529,11 @@ func (LinkTree) LinkTargetNodePrototype() ipld.NodePrototype { func (n LinkTree) Representation() ipld.Node { return (*_LinkTree__Repr)(n) } + type _LinkTree__Repr = _LinkTree + var _ ipld.Node = &_LinkTree__Repr{} + type _LinkTree__ReprPrototype = _LinkTree__Prototype type _LinkTree__ReprAssembler = _LinkTree__Assembler @@ -2491,14 +2555,15 @@ func (n *_ListParents) LookupMaybe(idx int64) MaybeLink { } } -var _ListParents__valueAbsent = _Link__Maybe{m:schema.Maybe_Absent} +var _ListParents__valueAbsent = _Link__Maybe{m: schema.Maybe_Absent} + func (n ListParents) Iterator() *ListParents__Itr { return &ListParents__Itr{n, 0} } type ListParents__Itr struct { - n ListParents - idx int + n ListParents + idx int } func (itr *ListParents__Itr) Next() (idx int64, v Link) { @@ -2531,14 +2596,14 @@ func (m MaybeListParents) Exists() bool { } func (m MaybeListParents) 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") + 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 MaybeListParents) Must() ListParents { @@ -2547,8 +2612,10 @@ func (m MaybeListParents) Must() ListParents { } return m.v } + var _ ipld.Node = (ListParents)(&_ListParents{}) var _ schema.TypedNode = (ListParents)(&_ListParents{}) + func (ListParents) Kind() ipld.Kind { return ipld.Kind_List } @@ -2584,8 +2651,8 @@ func (n ListParents) ListIterator() ipld.ListIterator { } type _ListParents__ListItr struct { - n ListParents - idx int + n ListParents + idx int } func (itr *_ListParents__ListItr) Next() (idx int64, v ipld.Node, _ error) { @@ -2632,6 +2699,7 @@ func (ListParents) AsLink() (ipld.Link, error) { func (ListParents) Prototype() ipld.NodePrototype { return _ListParents__Prototype{} } + type _ListParents__Prototype struct{} func (_ListParents__Prototype) NewBuilder() ipld.NodeBuilder { @@ -2639,9 +2707,11 @@ func (_ListParents__Prototype) NewBuilder() ipld.NodeBuilder { nb.Reset() return &nb } + type _ListParents__Builder struct { _ListParents__Assembler } + func (nb *_ListParents__Builder) Build() ipld.Node { if *nb.m != schema.Maybe_Value { panic("invalid state: cannot call Build on an assembler that's not finished") @@ -2653,9 +2723,10 @@ func (nb *_ListParents__Builder) Reset() { var m schema.Maybe *nb = _ListParents__Builder{_ListParents__Assembler{w: &w, m: &m}} } + type _ListParents__Assembler struct { - w *_ListParents - m *schema.Maybe + w *_ListParents + m *schema.Maybe state laState cm schema.Maybe @@ -2812,8 +2883,11 @@ func (ListParents) Type() schema.Type { func (n ListParents) Representation() ipld.Node { return (*_ListParents__Repr)(n) } + type _ListParents__Repr _ListParents + var _ ipld.Node = &_ListParents__Repr{} + func (_ListParents__Repr) Kind() ipld.Kind { return ipld.Kind_List } @@ -2891,6 +2965,7 @@ func (_ListParents__Repr) AsLink() (ipld.Link, error) { func (_ListParents__Repr) Prototype() ipld.NodePrototype { return _ListParents__ReprPrototype{} } + type _ListParents__ReprPrototype struct{} func (_ListParents__ReprPrototype) NewBuilder() ipld.NodeBuilder { @@ -2898,9 +2973,11 @@ func (_ListParents__ReprPrototype) NewBuilder() ipld.NodeBuilder { nb.Reset() return &nb } + type _ListParents__ReprBuilder struct { _ListParents__ReprAssembler } + func (nb *_ListParents__ReprBuilder) Build() ipld.Node { if *nb.m != schema.Maybe_Value { panic("invalid state: cannot call Build on an assembler that's not finished") @@ -2912,9 +2989,10 @@ func (nb *_ListParents__ReprBuilder) Reset() { var m schema.Maybe *nb = _ListParents__ReprBuilder{_ListParents__ReprAssembler{w: &w, m: &m}} } + type _ListParents__ReprAssembler struct { - w *_ListParents - m *schema.Maybe + w *_ListParents + m *schema.Maybe state laState cm schema.Maybe @@ -3084,14 +3162,15 @@ func (n *_ListString) LookupMaybe(idx int64) MaybeString { } } -var _ListString__valueAbsent = _String__Maybe{m:schema.Maybe_Absent} +var _ListString__valueAbsent = _String__Maybe{m: schema.Maybe_Absent} + func (n ListString) Iterator() *ListString__Itr { return &ListString__Itr{n, 0} } type ListString__Itr struct { - n ListString - idx int + n ListString + idx int } func (itr *ListString__Itr) Next() (idx int64, v String) { @@ -3124,14 +3203,14 @@ func (m MaybeListString) Exists() bool { } func (m MaybeListString) 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") + 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 MaybeListString) Must() ListString { @@ -3140,8 +3219,10 @@ func (m MaybeListString) Must() ListString { } return m.v } + var _ ipld.Node = (ListString)(&_ListString{}) var _ schema.TypedNode = (ListString)(&_ListString{}) + func (ListString) Kind() ipld.Kind { return ipld.Kind_List } @@ -3177,8 +3258,8 @@ func (n ListString) ListIterator() ipld.ListIterator { } type _ListString__ListItr struct { - n ListString - idx int + n ListString + idx int } func (itr *_ListString__ListItr) Next() (idx int64, v ipld.Node, _ error) { @@ -3225,6 +3306,7 @@ func (ListString) AsLink() (ipld.Link, error) { func (ListString) Prototype() ipld.NodePrototype { return _ListString__Prototype{} } + type _ListString__Prototype struct{} func (_ListString__Prototype) NewBuilder() ipld.NodeBuilder { @@ -3232,9 +3314,11 @@ func (_ListString__Prototype) NewBuilder() ipld.NodeBuilder { nb.Reset() return &nb } + type _ListString__Builder struct { _ListString__Assembler } + func (nb *_ListString__Builder) Build() ipld.Node { if *nb.m != schema.Maybe_Value { panic("invalid state: cannot call Build on an assembler that's not finished") @@ -3246,9 +3330,10 @@ func (nb *_ListString__Builder) Reset() { var m schema.Maybe *nb = _ListString__Builder{_ListString__Assembler{w: &w, m: &m}} } + type _ListString__Assembler struct { - w *_ListString - m *schema.Maybe + w *_ListString + m *schema.Maybe state laState cm schema.Maybe @@ -3405,8 +3490,11 @@ func (ListString) Type() schema.Type { func (n ListString) Representation() ipld.Node { return (*_ListString__Repr)(n) } + type _ListString__Repr _ListString + var _ ipld.Node = &_ListString__Repr{} + func (_ListString__Repr) Kind() ipld.Kind { return ipld.Kind_List } @@ -3484,6 +3572,7 @@ func (_ListString__Repr) AsLink() (ipld.Link, error) { func (_ListString__Repr) Prototype() ipld.NodePrototype { return _ListString__ReprPrototype{} } + type _ListString__ReprPrototype struct{} func (_ListString__ReprPrototype) NewBuilder() ipld.NodeBuilder { @@ -3491,9 +3580,11 @@ func (_ListString__ReprPrototype) NewBuilder() ipld.NodeBuilder { nb.Reset() return &nb } + type _ListString__ReprBuilder struct { _ListString__ReprAssembler } + func (nb *_ListString__ReprBuilder) Build() ipld.Node { if *nb.m != schema.Maybe_Value { panic("invalid state: cannot call Build on an assembler that's not finished") @@ -3505,9 +3596,10 @@ func (nb *_ListString__ReprBuilder) Reset() { var m schema.Maybe *nb = _ListString__ReprBuilder{_ListString__ReprAssembler{w: &w, m: &m}} } + type _ListString__ReprAssembler struct { - w *_ListString - m *schema.Maybe + w *_ListString + m *schema.Maybe state laState cm schema.Maybe @@ -3677,14 +3769,15 @@ func (n *_ListTag) LookupMaybe(idx int64) MaybeTag { } } -var _ListTag__valueAbsent = _Tag__Maybe{m:schema.Maybe_Absent} +var _ListTag__valueAbsent = _Tag__Maybe{m: schema.Maybe_Absent} + func (n ListTag) Iterator() *ListTag__Itr { return &ListTag__Itr{n, 0} } type ListTag__Itr struct { - n ListTag - idx int + n ListTag + idx int } func (itr *ListTag__Itr) Next() (idx int64, v Tag) { @@ -3717,14 +3810,14 @@ func (m MaybeListTag) Exists() bool { } func (m MaybeListTag) 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") + 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 MaybeListTag) Must() ListTag { @@ -3733,8 +3826,10 @@ func (m MaybeListTag) Must() ListTag { } return m.v } + var _ ipld.Node = (ListTag)(&_ListTag{}) var _ schema.TypedNode = (ListTag)(&_ListTag{}) + func (ListTag) Kind() ipld.Kind { return ipld.Kind_List } @@ -3770,8 +3865,8 @@ func (n ListTag) ListIterator() ipld.ListIterator { } type _ListTag__ListItr struct { - n ListTag - idx int + n ListTag + idx int } func (itr *_ListTag__ListItr) Next() (idx int64, v ipld.Node, _ error) { @@ -3818,6 +3913,7 @@ func (ListTag) AsLink() (ipld.Link, error) { func (ListTag) Prototype() ipld.NodePrototype { return _ListTag__Prototype{} } + type _ListTag__Prototype struct{} func (_ListTag__Prototype) NewBuilder() ipld.NodeBuilder { @@ -3825,9 +3921,11 @@ func (_ListTag__Prototype) NewBuilder() ipld.NodeBuilder { nb.Reset() return &nb } + type _ListTag__Builder struct { _ListTag__Assembler } + func (nb *_ListTag__Builder) Build() ipld.Node { if *nb.m != schema.Maybe_Value { panic("invalid state: cannot call Build on an assembler that's not finished") @@ -3839,9 +3937,10 @@ func (nb *_ListTag__Builder) Reset() { var m schema.Maybe *nb = _ListTag__Builder{_ListTag__Assembler{w: &w, m: &m}} } + type _ListTag__Assembler struct { - w *_ListTag - m *schema.Maybe + w *_ListTag + m *schema.Maybe state laState cm schema.Maybe @@ -3998,8 +4097,11 @@ func (ListTag) Type() schema.Type { func (n ListTag) Representation() ipld.Node { return (*_ListTag__Repr)(n) } + type _ListTag__Repr _ListTag + var _ ipld.Node = &_ListTag__Repr{} + func (_ListTag__Repr) Kind() ipld.Kind { return ipld.Kind_List } @@ -4077,6 +4179,7 @@ func (_ListTag__Repr) AsLink() (ipld.Link, error) { func (_ListTag__Repr) Prototype() ipld.NodePrototype { return _ListTag__ReprPrototype{} } + type _ListTag__ReprPrototype struct{} func (_ListTag__ReprPrototype) NewBuilder() ipld.NodeBuilder { @@ -4084,9 +4187,11 @@ func (_ListTag__ReprPrototype) NewBuilder() ipld.NodeBuilder { nb.Reset() return &nb } + type _ListTag__ReprBuilder struct { _ListTag__ReprAssembler } + func (nb *_ListTag__ReprBuilder) Build() ipld.Node { if *nb.m != schema.Maybe_Value { panic("invalid state: cannot call Build on an assembler that's not finished") @@ -4098,9 +4203,10 @@ func (nb *_ListTag__ReprBuilder) Reset() { var m schema.Maybe *nb = _ListTag__ReprBuilder{_ListTag__ReprAssembler{w: &w, m: &m}} } + type _ListTag__ReprAssembler struct { - w *_ListTag - m *schema.Maybe + w *_ListTag + m *schema.Maybe state laState cm schema.Maybe @@ -4252,7 +4358,6 @@ func (la *_ListTag__ReprAssembler) ValuePrototype(_ int64) ipld.NodePrototype { return _Tag__ReprPrototype{} } - func (n _PersonInfo) FieldName() String { return &n.Name } @@ -4265,6 +4370,7 @@ func (n _PersonInfo) FieldDate() String { func (n _PersonInfo) FieldTimezone() String { return &n.Timezone } + type _PersonInfo__Maybe struct { m schema.Maybe v PersonInfo @@ -4282,14 +4388,14 @@ func (m MaybePersonInfo) Exists() bool { } func (m MaybePersonInfo) 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") + 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 MaybePersonInfo) Must() PersonInfo { @@ -4298,14 +4404,16 @@ func (m MaybePersonInfo) Must() PersonInfo { } return m.v } + var ( - fieldName__PersonInfo_Name = _String{"Name"} - fieldName__PersonInfo_Email = _String{"Email"} - fieldName__PersonInfo_Date = _String{"Date"} + fieldName__PersonInfo_Name = _String{"Name"} + fieldName__PersonInfo_Email = _String{"Email"} + fieldName__PersonInfo_Date = _String{"Date"} fieldName__PersonInfo_Timezone = _String{"Timezone"} ) var _ ipld.Node = (PersonInfo)(&_PersonInfo{}) var _ schema.TypedNode = (PersonInfo)(&_PersonInfo{}) + func (PersonInfo) Kind() ipld.Kind { return ipld.Kind_Map } @@ -4341,8 +4449,8 @@ func (n PersonInfo) MapIterator() ipld.MapIterator { } type _PersonInfo__MapItr struct { - n PersonInfo - idx int + n PersonInfo + idx int } func (itr *_PersonInfo__MapItr) Next() (k ipld.Node, v ipld.Node, _ error) { @@ -4405,6 +4513,7 @@ func (PersonInfo) AsLink() (ipld.Link, error) { func (PersonInfo) Prototype() ipld.NodePrototype { return _PersonInfo__Prototype{} } + type _PersonInfo__Prototype struct{} func (_PersonInfo__Prototype) NewBuilder() ipld.NodeBuilder { @@ -4412,9 +4521,11 @@ func (_PersonInfo__Prototype) NewBuilder() ipld.NodeBuilder { nb.Reset() return &nb } + type _PersonInfo__Builder struct { _PersonInfo__Assembler } + func (nb *_PersonInfo__Builder) Build() ipld.Node { if *nb.m != schema.Maybe_Value { panic("invalid state: cannot call Build on an assembler that's not finished") @@ -4426,19 +4537,20 @@ func (nb *_PersonInfo__Builder) Reset() { var m schema.Maybe *nb = _PersonInfo__Builder{_PersonInfo__Assembler{w: &w, m: &m}} } + type _PersonInfo__Assembler struct { - w *_PersonInfo - m *schema.Maybe + w *_PersonInfo + m *schema.Maybe state maState - s int - f int + s int + f int - cm schema.Maybe - ca_Name _String__Assembler - ca_Email _String__Assembler - ca_Date _String__Assembler + cm schema.Maybe + ca_Name _String__Assembler + ca_Email _String__Assembler + ca_Date _String__Assembler ca_Timezone _String__Assembler - } +} func (na *_PersonInfo__Assembler) reset() { na.state = maState_initial @@ -4450,12 +4562,13 @@ func (na *_PersonInfo__Assembler) reset() { } var ( - fieldBit__PersonInfo_Name = 1 << 0 - fieldBit__PersonInfo_Email = 1 << 1 - fieldBit__PersonInfo_Date = 1 << 2 - fieldBit__PersonInfo_Timezone = 1 << 3 - fieldBits__PersonInfo_sufficient = 0 + 1 << 0 + 1 << 1 + 1 << 2 + 1 << 3 + fieldBit__PersonInfo_Name = 1 << 0 + fieldBit__PersonInfo_Email = 1 << 1 + fieldBit__PersonInfo_Date = 1 << 2 + fieldBit__PersonInfo_Timezone = 1 << 3 + fieldBits__PersonInfo_sufficient = 0 + 1<<0 + 1<<1 + 1<<2 + 1<<3 ) + func (na *_PersonInfo__Assembler) BeginMap(int64) (ipld.MapAssembler, error) { switch *na.m { case schema.Maybe_Value, schema.Maybe_Null: @@ -4608,7 +4721,7 @@ func (ma *_PersonInfo__Assembler) AssembleEntry(k string) (ipld.NodeAssembler, e } switch k { case "Name": - if ma.s & fieldBit__PersonInfo_Name != 0 { + if ma.s&fieldBit__PersonInfo_Name != 0 { return nil, ipld.ErrRepeatedMapKey{&fieldName__PersonInfo_Name} } ma.s += fieldBit__PersonInfo_Name @@ -4618,7 +4731,7 @@ func (ma *_PersonInfo__Assembler) AssembleEntry(k string) (ipld.NodeAssembler, e ma.ca_Name.m = &ma.cm return &ma.ca_Name, nil case "Email": - if ma.s & fieldBit__PersonInfo_Email != 0 { + if ma.s&fieldBit__PersonInfo_Email != 0 { return nil, ipld.ErrRepeatedMapKey{&fieldName__PersonInfo_Email} } ma.s += fieldBit__PersonInfo_Email @@ -4628,7 +4741,7 @@ func (ma *_PersonInfo__Assembler) AssembleEntry(k string) (ipld.NodeAssembler, e ma.ca_Email.m = &ma.cm return &ma.ca_Email, nil case "Date": - if ma.s & fieldBit__PersonInfo_Date != 0 { + if ma.s&fieldBit__PersonInfo_Date != 0 { return nil, ipld.ErrRepeatedMapKey{&fieldName__PersonInfo_Date} } ma.s += fieldBit__PersonInfo_Date @@ -4638,7 +4751,7 @@ func (ma *_PersonInfo__Assembler) AssembleEntry(k string) (ipld.NodeAssembler, e ma.ca_Date.m = &ma.cm return &ma.ca_Date, nil case "Timezone": - if ma.s & fieldBit__PersonInfo_Timezone != 0 { + if ma.s&fieldBit__PersonInfo_Timezone != 0 { return nil, ipld.ErrRepeatedMapKey{&fieldName__PersonInfo_Timezone} } ma.s += fieldBit__PersonInfo_Timezone @@ -4648,7 +4761,7 @@ func (ma *_PersonInfo__Assembler) AssembleEntry(k string) (ipld.NodeAssembler, e ma.ca_Timezone.m = &ma.cm return &ma.ca_Timezone, nil default: - return nil, ipld.ErrInvalidKey{TypeName:"ipldgit.PersonInfo", Key:&_String{k}} + return nil, ipld.ErrInvalidKey{TypeName: "ipldgit.PersonInfo", Key: &_String{k}} } } func (ma *_PersonInfo__Assembler) AssembleKey() ipld.NodeAssembler { @@ -4719,18 +4832,18 @@ func (ma *_PersonInfo__Assembler) Finish() error { case maState_finished: panic("invalid state: Finish cannot be called on an assembler that's already finished") } - if ma.s & fieldBits__PersonInfo_sufficient != fieldBits__PersonInfo_sufficient { + if ma.s&fieldBits__PersonInfo_sufficient != fieldBits__PersonInfo_sufficient { err := ipld.ErrMissingRequiredField{Missing: make([]string, 0)} - if ma.s & fieldBit__PersonInfo_Name == 0 { + if ma.s&fieldBit__PersonInfo_Name == 0 { err.Missing = append(err.Missing, "Name") } - if ma.s & fieldBit__PersonInfo_Email == 0 { + if ma.s&fieldBit__PersonInfo_Email == 0 { err.Missing = append(err.Missing, "Email") } - if ma.s & fieldBit__PersonInfo_Date == 0 { + if ma.s&fieldBit__PersonInfo_Date == 0 { err.Missing = append(err.Missing, "Date") } - if ma.s & fieldBit__PersonInfo_Timezone == 0 { + if ma.s&fieldBit__PersonInfo_Timezone == 0 { err.Missing = append(err.Missing, "Timezone") } return err @@ -4745,7 +4858,9 @@ func (ma *_PersonInfo__Assembler) KeyPrototype() ipld.NodePrototype { func (ma *_PersonInfo__Assembler) ValuePrototype(k string) ipld.NodePrototype { panic("todo structbuilder mapassembler valueprototype") } + type _PersonInfo__KeyAssembler _PersonInfo__Assembler + func (_PersonInfo__KeyAssembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { return mixins.StringAssembler{"ipldgit.PersonInfo.KeyAssembler"}.BeginMap(0) } @@ -4770,35 +4885,35 @@ func (ka *_PersonInfo__KeyAssembler) AssignString(k string) error { } switch k { case "Name": - if ka.s & fieldBit__PersonInfo_Name != 0 { + if ka.s&fieldBit__PersonInfo_Name != 0 { return ipld.ErrRepeatedMapKey{&fieldName__PersonInfo_Name} } ka.s += fieldBit__PersonInfo_Name ka.state = maState_expectValue ka.f = 0 case "Email": - if ka.s & fieldBit__PersonInfo_Email != 0 { + if ka.s&fieldBit__PersonInfo_Email != 0 { return ipld.ErrRepeatedMapKey{&fieldName__PersonInfo_Email} } ka.s += fieldBit__PersonInfo_Email ka.state = maState_expectValue ka.f = 1 case "Date": - if ka.s & fieldBit__PersonInfo_Date != 0 { + if ka.s&fieldBit__PersonInfo_Date != 0 { return ipld.ErrRepeatedMapKey{&fieldName__PersonInfo_Date} } ka.s += fieldBit__PersonInfo_Date ka.state = maState_expectValue ka.f = 2 case "Timezone": - if ka.s & fieldBit__PersonInfo_Timezone != 0 { + if ka.s&fieldBit__PersonInfo_Timezone != 0 { return ipld.ErrRepeatedMapKey{&fieldName__PersonInfo_Timezone} } ka.s += fieldBit__PersonInfo_Timezone ka.state = maState_expectValue ka.f = 3 default: - return ipld.ErrInvalidKey{TypeName:"ipldgit.PersonInfo", Key:&_String{k}} + return ipld.ErrInvalidKey{TypeName: "ipldgit.PersonInfo", Key: &_String{k}} } return nil } @@ -4824,8 +4939,11 @@ func (PersonInfo) Type() schema.Type { func (n PersonInfo) Representation() ipld.Node { return (*_PersonInfo__Repr)(n) } + type _PersonInfo__Repr _PersonInfo + var _ ipld.Node = &_PersonInfo__Repr{} + func (_PersonInfo__Repr) Kind() ipld.Kind { return ipld.Kind_String } @@ -4883,6 +5001,7 @@ func (_PersonInfo__Repr) AsLink() (ipld.Link, error) { func (_PersonInfo__Repr) Prototype() ipld.NodePrototype { return _PersonInfo__ReprPrototype{} } + type _PersonInfo__ReprPrototype struct{} func (_PersonInfo__ReprPrototype) NewBuilder() ipld.NodeBuilder { @@ -4890,9 +5009,11 @@ func (_PersonInfo__ReprPrototype) NewBuilder() ipld.NodeBuilder { nb.Reset() return &nb } + type _PersonInfo__ReprBuilder struct { _PersonInfo__ReprAssembler } + func (nb *_PersonInfo__ReprBuilder) Build() ipld.Node { if *nb.m != schema.Maybe_Value { panic("invalid state: cannot call Build on an assembler that's not finished") @@ -4907,22 +5028,23 @@ func (nb *_PersonInfo__ReprBuilder) Reset() { func (_PersonInfo__ReprPrototype) fromString(w *_PersonInfo, v string) error { ss, err := mixins.SplitExact(v, " ", 4) if err != nil { - return ipld.ErrUnmatchable{TypeName:"ipldgit.PersonInfo.Repr", Reason: err} + return ipld.ErrUnmatchable{TypeName: "ipldgit.PersonInfo.Repr", Reason: err} } if err := (_String__ReprPrototype{}).fromString(&w.Name, ss[0]); err != nil { - return ipld.ErrUnmatchable{TypeName:"ipldgit.PersonInfo.Repr", Reason: err} + return ipld.ErrUnmatchable{TypeName: "ipldgit.PersonInfo.Repr", Reason: err} } if err := (_String__ReprPrototype{}).fromString(&w.Email, ss[1]); err != nil { - return ipld.ErrUnmatchable{TypeName:"ipldgit.PersonInfo.Repr", Reason: err} + return ipld.ErrUnmatchable{TypeName: "ipldgit.PersonInfo.Repr", Reason: err} } if err := (_String__ReprPrototype{}).fromString(&w.Date, ss[2]); err != nil { - return ipld.ErrUnmatchable{TypeName:"ipldgit.PersonInfo.Repr", Reason: err} + return ipld.ErrUnmatchable{TypeName: "ipldgit.PersonInfo.Repr", Reason: err} } if err := (_String__ReprPrototype{}).fromString(&w.Timezone, ss[3]); err != nil { - return ipld.ErrUnmatchable{TypeName:"ipldgit.PersonInfo.Repr", Reason: err} + return ipld.ErrUnmatchable{TypeName: "ipldgit.PersonInfo.Repr", Reason: err} } return nil } + type _PersonInfo__ReprAssembler struct { w *_PersonInfo m *schema.Maybe @@ -5015,6 +5137,7 @@ func (_String__Prototype) FromString(v string) (String, error) { n := _String{v} return &n, nil } + type _String__Maybe struct { m schema.Maybe v String @@ -5032,14 +5155,14 @@ func (m MaybeString) Exists() bool { } 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") + 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 { @@ -5048,8 +5171,10 @@ func (m MaybeString) Must() String { } return m.v } + var _ ipld.Node = (String)(&_String{}) var _ schema.TypedNode = (String)(&_String{}) + func (String) Kind() ipld.Kind { return ipld.Kind_String } @@ -5101,6 +5226,7 @@ func (String) AsLink() (ipld.Link, error) { func (String) Prototype() ipld.NodePrototype { return _String__Prototype{} } + type _String__Prototype struct{} func (_String__Prototype) NewBuilder() ipld.NodeBuilder { @@ -5108,9 +5234,11 @@ func (_String__Prototype) NewBuilder() ipld.NodeBuilder { 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") @@ -5122,6 +5250,7 @@ func (nb *_String__Builder) Reset() { var m schema.Maybe *nb = _String__Builder{_String__Assembler{w: &w, m: &m}} } + type _String__Assembler struct { w *_String m *schema.Maybe @@ -5206,12 +5335,14 @@ func (String) Type() schema.Type { 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 - func (n _Tag) FieldObject() Link { return &n.Object } @@ -5230,6 +5361,7 @@ func (n _Tag) FieldText() String { func (n _Tag) FieldDataSize() MaybeString { return &n.DataSize } + type _Tag__Maybe struct { m schema.Maybe v Tag @@ -5247,14 +5379,14 @@ func (m MaybeTag) Exists() bool { } func (m MaybeTag) 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") + 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 MaybeTag) Must() Tag { @@ -5263,16 +5395,18 @@ func (m MaybeTag) Must() Tag { } return m.v } + var ( - fieldName__Tag_Object = _String{"Object"} - fieldName__Tag_TagType = _String{"TagType"} - fieldName__Tag_Tag = _String{"Tag"} - fieldName__Tag_Tagger = _String{"Tagger"} - fieldName__Tag_Text = _String{"Text"} + fieldName__Tag_Object = _String{"Object"} + fieldName__Tag_TagType = _String{"TagType"} + fieldName__Tag_Tag = _String{"Tag"} + fieldName__Tag_Tagger = _String{"Tagger"} + fieldName__Tag_Text = _String{"Text"} fieldName__Tag_DataSize = _String{"DataSize"} ) var _ ipld.Node = (Tag)(&_Tag{}) var _ schema.TypedNode = (Tag)(&_Tag{}) + func (Tag) Kind() ipld.Kind { return ipld.Kind_Map } @@ -5315,8 +5449,8 @@ func (n Tag) MapIterator() ipld.MapIterator { } type _Tag__MapItr struct { - n Tag - idx int + n Tag + idx int } func (itr *_Tag__MapItr) Next() (k ipld.Node, v ipld.Node, _ error) { @@ -5389,6 +5523,7 @@ func (Tag) AsLink() (ipld.Link, error) { func (Tag) Prototype() ipld.NodePrototype { return _Tag__Prototype{} } + type _Tag__Prototype struct{} func (_Tag__Prototype) NewBuilder() ipld.NodeBuilder { @@ -5396,9 +5531,11 @@ func (_Tag__Prototype) NewBuilder() ipld.NodeBuilder { nb.Reset() return &nb } + type _Tag__Builder struct { _Tag__Assembler } + func (nb *_Tag__Builder) Build() ipld.Node { if *nb.m != schema.Maybe_Value { panic("invalid state: cannot call Build on an assembler that's not finished") @@ -5410,21 +5547,22 @@ func (nb *_Tag__Builder) Reset() { var m schema.Maybe *nb = _Tag__Builder{_Tag__Assembler{w: &w, m: &m}} } + type _Tag__Assembler struct { - w *_Tag - m *schema.Maybe + w *_Tag + m *schema.Maybe state maState - s int - f int - - cm schema.Maybe - ca_Object _Link__Assembler - ca_TagType _String__Assembler - ca_Tag _String__Assembler - ca_Tagger _PersonInfo__Assembler - ca_Text _String__Assembler + s int + f int + + cm schema.Maybe + ca_Object _Link__Assembler + ca_TagType _String__Assembler + ca_Tag _String__Assembler + ca_Tagger _PersonInfo__Assembler + ca_Text _String__Assembler ca_DataSize _String__Assembler - } +} func (na *_Tag__Assembler) reset() { na.state = maState_initial @@ -5438,14 +5576,15 @@ func (na *_Tag__Assembler) reset() { } var ( - fieldBit__Tag_Object = 1 << 0 - fieldBit__Tag_TagType = 1 << 1 - fieldBit__Tag_Tag = 1 << 2 - fieldBit__Tag_Tagger = 1 << 3 - fieldBit__Tag_Text = 1 << 4 - fieldBit__Tag_DataSize = 1 << 5 - fieldBits__Tag_sufficient = 0 + 1 << 0 + 1 << 1 + 1 << 2 + 1 << 3 + 1 << 4 + fieldBit__Tag_Object = 1 << 0 + fieldBit__Tag_TagType = 1 << 1 + fieldBit__Tag_Tag = 1 << 2 + fieldBit__Tag_Tagger = 1 << 3 + fieldBit__Tag_Text = 1 << 4 + fieldBit__Tag_DataSize = 1 << 5 + fieldBits__Tag_sufficient = 0 + 1<<0 + 1<<1 + 1<<2 + 1<<3 + 1<<4 ) + func (na *_Tag__Assembler) BeginMap(int64) (ipld.MapAssembler, error) { switch *na.m { case schema.Maybe_Value, schema.Maybe_Null: @@ -5617,7 +5756,7 @@ func (ma *_Tag__Assembler) AssembleEntry(k string) (ipld.NodeAssembler, error) { } switch k { case "Object": - if ma.s & fieldBit__Tag_Object != 0 { + if ma.s&fieldBit__Tag_Object != 0 { return nil, ipld.ErrRepeatedMapKey{&fieldName__Tag_Object} } ma.s += fieldBit__Tag_Object @@ -5627,7 +5766,7 @@ func (ma *_Tag__Assembler) AssembleEntry(k string) (ipld.NodeAssembler, error) { ma.ca_Object.m = &ma.cm return &ma.ca_Object, nil case "TagType": - if ma.s & fieldBit__Tag_TagType != 0 { + if ma.s&fieldBit__Tag_TagType != 0 { return nil, ipld.ErrRepeatedMapKey{&fieldName__Tag_TagType} } ma.s += fieldBit__Tag_TagType @@ -5637,7 +5776,7 @@ func (ma *_Tag__Assembler) AssembleEntry(k string) (ipld.NodeAssembler, error) { ma.ca_TagType.m = &ma.cm return &ma.ca_TagType, nil case "Tag": - if ma.s & fieldBit__Tag_Tag != 0 { + if ma.s&fieldBit__Tag_Tag != 0 { return nil, ipld.ErrRepeatedMapKey{&fieldName__Tag_Tag} } ma.s += fieldBit__Tag_Tag @@ -5647,7 +5786,7 @@ func (ma *_Tag__Assembler) AssembleEntry(k string) (ipld.NodeAssembler, error) { ma.ca_Tag.m = &ma.cm return &ma.ca_Tag, nil case "Tagger": - if ma.s & fieldBit__Tag_Tagger != 0 { + if ma.s&fieldBit__Tag_Tagger != 0 { return nil, ipld.ErrRepeatedMapKey{&fieldName__Tag_Tagger} } ma.s += fieldBit__Tag_Tagger @@ -5657,7 +5796,7 @@ func (ma *_Tag__Assembler) AssembleEntry(k string) (ipld.NodeAssembler, error) { ma.ca_Tagger.m = &ma.cm return &ma.ca_Tagger, nil case "Text": - if ma.s & fieldBit__Tag_Text != 0 { + if ma.s&fieldBit__Tag_Text != 0 { return nil, ipld.ErrRepeatedMapKey{&fieldName__Tag_Text} } ma.s += fieldBit__Tag_Text @@ -5667,7 +5806,7 @@ func (ma *_Tag__Assembler) AssembleEntry(k string) (ipld.NodeAssembler, error) { ma.ca_Text.m = &ma.cm return &ma.ca_Text, nil case "DataSize": - if ma.s & fieldBit__Tag_DataSize != 0 { + if ma.s&fieldBit__Tag_DataSize != 0 { return nil, ipld.ErrRepeatedMapKey{&fieldName__Tag_DataSize} } ma.s += fieldBit__Tag_DataSize @@ -5677,7 +5816,7 @@ func (ma *_Tag__Assembler) AssembleEntry(k string) (ipld.NodeAssembler, error) { ma.ca_DataSize.m = &ma.w.DataSize.m return &ma.ca_DataSize, nil default: - return nil, ipld.ErrInvalidKey{TypeName:"ipldgit.Tag", Key:&_String{k}} + return nil, ipld.ErrInvalidKey{TypeName: "ipldgit.Tag", Key: &_String{k}} } } func (ma *_Tag__Assembler) AssembleKey() ipld.NodeAssembler { @@ -5756,21 +5895,21 @@ func (ma *_Tag__Assembler) Finish() error { case maState_finished: panic("invalid state: Finish cannot be called on an assembler that's already finished") } - if ma.s & fieldBits__Tag_sufficient != fieldBits__Tag_sufficient { + if ma.s&fieldBits__Tag_sufficient != fieldBits__Tag_sufficient { err := ipld.ErrMissingRequiredField{Missing: make([]string, 0)} - if ma.s & fieldBit__Tag_Object == 0 { + if ma.s&fieldBit__Tag_Object == 0 { err.Missing = append(err.Missing, "Object") } - if ma.s & fieldBit__Tag_TagType == 0 { + if ma.s&fieldBit__Tag_TagType == 0 { err.Missing = append(err.Missing, "TagType") } - if ma.s & fieldBit__Tag_Tag == 0 { + if ma.s&fieldBit__Tag_Tag == 0 { err.Missing = append(err.Missing, "Tag") } - if ma.s & fieldBit__Tag_Tagger == 0 { + if ma.s&fieldBit__Tag_Tagger == 0 { err.Missing = append(err.Missing, "Tagger") } - if ma.s & fieldBit__Tag_Text == 0 { + if ma.s&fieldBit__Tag_Text == 0 { err.Missing = append(err.Missing, "Text") } return err @@ -5785,7 +5924,9 @@ func (ma *_Tag__Assembler) KeyPrototype() ipld.NodePrototype { func (ma *_Tag__Assembler) ValuePrototype(k string) ipld.NodePrototype { panic("todo structbuilder mapassembler valueprototype") } + type _Tag__KeyAssembler _Tag__Assembler + func (_Tag__KeyAssembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { return mixins.StringAssembler{"ipldgit.Tag.KeyAssembler"}.BeginMap(0) } @@ -5810,49 +5951,49 @@ func (ka *_Tag__KeyAssembler) AssignString(k string) error { } switch k { case "Object": - if ka.s & fieldBit__Tag_Object != 0 { + if ka.s&fieldBit__Tag_Object != 0 { return ipld.ErrRepeatedMapKey{&fieldName__Tag_Object} } ka.s += fieldBit__Tag_Object ka.state = maState_expectValue ka.f = 0 case "TagType": - if ka.s & fieldBit__Tag_TagType != 0 { + if ka.s&fieldBit__Tag_TagType != 0 { return ipld.ErrRepeatedMapKey{&fieldName__Tag_TagType} } ka.s += fieldBit__Tag_TagType ka.state = maState_expectValue ka.f = 1 case "Tag": - if ka.s & fieldBit__Tag_Tag != 0 { + if ka.s&fieldBit__Tag_Tag != 0 { return ipld.ErrRepeatedMapKey{&fieldName__Tag_Tag} } ka.s += fieldBit__Tag_Tag ka.state = maState_expectValue ka.f = 2 case "Tagger": - if ka.s & fieldBit__Tag_Tagger != 0 { + if ka.s&fieldBit__Tag_Tagger != 0 { return ipld.ErrRepeatedMapKey{&fieldName__Tag_Tagger} } ka.s += fieldBit__Tag_Tagger ka.state = maState_expectValue ka.f = 3 case "Text": - if ka.s & fieldBit__Tag_Text != 0 { + if ka.s&fieldBit__Tag_Text != 0 { return ipld.ErrRepeatedMapKey{&fieldName__Tag_Text} } ka.s += fieldBit__Tag_Text ka.state = maState_expectValue ka.f = 4 case "DataSize": - if ka.s & fieldBit__Tag_DataSize != 0 { + if ka.s&fieldBit__Tag_DataSize != 0 { return ipld.ErrRepeatedMapKey{&fieldName__Tag_DataSize} } ka.s += fieldBit__Tag_DataSize ka.state = maState_expectValue ka.f = 5 default: - return ipld.ErrInvalidKey{TypeName:"ipldgit.Tag", Key:&_String{k}} + return ipld.ErrInvalidKey{TypeName: "ipldgit.Tag", Key: &_String{k}} } return nil } @@ -5878,16 +6019,19 @@ func (Tag) Type() schema.Type { func (n Tag) Representation() ipld.Node { return (*_Tag__Repr)(n) } + type _Tag__Repr _Tag + var ( - fieldName__Tag_Object_serial = _String{"Object"} - fieldName__Tag_TagType_serial = _String{"TagType"} - fieldName__Tag_Tag_serial = _String{"Tag"} - fieldName__Tag_Tagger_serial = _String{"Tagger"} - fieldName__Tag_Text_serial = _String{"Text"} + fieldName__Tag_Object_serial = _String{"Object"} + fieldName__Tag_TagType_serial = _String{"TagType"} + fieldName__Tag_Tag_serial = _String{"Tag"} + fieldName__Tag_Tagger_serial = _String{"Tagger"} + fieldName__Tag_Text_serial = _String{"Text"} fieldName__Tag_DataSize_serial = _String{"DataSize"} ) var _ ipld.Node = &_Tag__Repr{} + func (_Tag__Repr) Kind() ipld.Kind { return ipld.Kind_Map } @@ -5943,7 +6087,8 @@ type _Tag__ReprMapItr struct { } func (itr *_Tag__ReprMapItr) Next() (k ipld.Node, v ipld.Node, _ error) { -advance:if itr.idx >= 6 { +advance: + if itr.idx >= 6 { return nil, nil, ipld.ErrIteratorOverread{} } switch itr.idx { @@ -6015,6 +6160,7 @@ func (_Tag__Repr) AsLink() (ipld.Link, error) { func (_Tag__Repr) Prototype() ipld.NodePrototype { return _Tag__ReprPrototype{} } + type _Tag__ReprPrototype struct{} func (_Tag__ReprPrototype) NewBuilder() ipld.NodeBuilder { @@ -6022,9 +6168,11 @@ func (_Tag__ReprPrototype) NewBuilder() ipld.NodeBuilder { nb.Reset() return &nb } + type _Tag__ReprBuilder struct { _Tag__ReprAssembler } + func (nb *_Tag__ReprBuilder) Build() ipld.Node { if *nb.m != schema.Maybe_Value { panic("invalid state: cannot call Build on an assembler that's not finished") @@ -6036,21 +6184,22 @@ func (nb *_Tag__ReprBuilder) Reset() { var m schema.Maybe *nb = _Tag__ReprBuilder{_Tag__ReprAssembler{w: &w, m: &m}} } + type _Tag__ReprAssembler struct { - w *_Tag - m *schema.Maybe + w *_Tag + m *schema.Maybe state maState - s int - f int - - cm schema.Maybe - ca_Object _Link__ReprAssembler - ca_TagType _String__ReprAssembler - ca_Tag _String__ReprAssembler - ca_Tagger _PersonInfo__ReprAssembler - ca_Text _String__ReprAssembler + s int + f int + + cm schema.Maybe + ca_Object _Link__ReprAssembler + ca_TagType _String__ReprAssembler + ca_Tag _String__ReprAssembler + ca_Tagger _PersonInfo__ReprAssembler + ca_Text _String__ReprAssembler ca_DataSize _String__ReprAssembler - } +} func (na *_Tag__ReprAssembler) reset() { na.state = maState_initial @@ -6155,7 +6304,8 @@ func (ma *_Tag__ReprAssembler) valueFinishTidy() bool { switch ma.f { case 0: switch ma.cm { - case schema.Maybe_Value:ma.cm = schema.Maybe_Absent + case schema.Maybe_Value: + ma.cm = schema.Maybe_Absent ma.state = maState_initial return true default: @@ -6163,7 +6313,8 @@ func (ma *_Tag__ReprAssembler) valueFinishTidy() bool { } case 1: switch ma.cm { - case schema.Maybe_Value:ma.cm = schema.Maybe_Absent + case schema.Maybe_Value: + ma.cm = schema.Maybe_Absent ma.state = maState_initial return true default: @@ -6171,7 +6322,8 @@ func (ma *_Tag__ReprAssembler) valueFinishTidy() bool { } case 2: switch ma.cm { - case schema.Maybe_Value:ma.cm = schema.Maybe_Absent + case schema.Maybe_Value: + ma.cm = schema.Maybe_Absent ma.state = maState_initial return true default: @@ -6179,7 +6331,8 @@ func (ma *_Tag__ReprAssembler) valueFinishTidy() bool { } case 3: switch ma.cm { - case schema.Maybe_Value:ma.cm = schema.Maybe_Absent + case schema.Maybe_Value: + ma.cm = schema.Maybe_Absent ma.state = maState_initial return true default: @@ -6187,7 +6340,8 @@ func (ma *_Tag__ReprAssembler) valueFinishTidy() bool { } case 4: switch ma.cm { - case schema.Maybe_Value:ma.cm = schema.Maybe_Absent + case schema.Maybe_Value: + ma.cm = schema.Maybe_Absent ma.state = maState_initial return true default: @@ -6223,7 +6377,7 @@ func (ma *_Tag__ReprAssembler) AssembleEntry(k string) (ipld.NodeAssembler, erro } switch k { case "Object": - if ma.s & fieldBit__Tag_Object != 0 { + if ma.s&fieldBit__Tag_Object != 0 { return nil, ipld.ErrRepeatedMapKey{&fieldName__Tag_Object_serial} } ma.s += fieldBit__Tag_Object @@ -6233,7 +6387,7 @@ func (ma *_Tag__ReprAssembler) AssembleEntry(k string) (ipld.NodeAssembler, erro ma.ca_Object.m = &ma.cm return &ma.ca_Object, nil case "TagType": - if ma.s & fieldBit__Tag_TagType != 0 { + if ma.s&fieldBit__Tag_TagType != 0 { return nil, ipld.ErrRepeatedMapKey{&fieldName__Tag_TagType_serial} } ma.s += fieldBit__Tag_TagType @@ -6243,7 +6397,7 @@ func (ma *_Tag__ReprAssembler) AssembleEntry(k string) (ipld.NodeAssembler, erro ma.ca_TagType.m = &ma.cm return &ma.ca_TagType, nil case "Tag": - if ma.s & fieldBit__Tag_Tag != 0 { + if ma.s&fieldBit__Tag_Tag != 0 { return nil, ipld.ErrRepeatedMapKey{&fieldName__Tag_Tag_serial} } ma.s += fieldBit__Tag_Tag @@ -6253,7 +6407,7 @@ func (ma *_Tag__ReprAssembler) AssembleEntry(k string) (ipld.NodeAssembler, erro ma.ca_Tag.m = &ma.cm return &ma.ca_Tag, nil case "Tagger": - if ma.s & fieldBit__Tag_Tagger != 0 { + if ma.s&fieldBit__Tag_Tagger != 0 { return nil, ipld.ErrRepeatedMapKey{&fieldName__Tag_Tagger_serial} } ma.s += fieldBit__Tag_Tagger @@ -6263,7 +6417,7 @@ func (ma *_Tag__ReprAssembler) AssembleEntry(k string) (ipld.NodeAssembler, erro ma.ca_Tagger.m = &ma.cm return &ma.ca_Tagger, nil case "Text": - if ma.s & fieldBit__Tag_Text != 0 { + if ma.s&fieldBit__Tag_Text != 0 { return nil, ipld.ErrRepeatedMapKey{&fieldName__Tag_Text_serial} } ma.s += fieldBit__Tag_Text @@ -6273,7 +6427,7 @@ func (ma *_Tag__ReprAssembler) AssembleEntry(k string) (ipld.NodeAssembler, erro ma.ca_Text.m = &ma.cm return &ma.ca_Text, nil case "DataSize": - if ma.s & fieldBit__Tag_DataSize != 0 { + if ma.s&fieldBit__Tag_DataSize != 0 { return nil, ipld.ErrRepeatedMapKey{&fieldName__Tag_DataSize_serial} } ma.s += fieldBit__Tag_DataSize @@ -6281,10 +6435,10 @@ func (ma *_Tag__ReprAssembler) AssembleEntry(k string) (ipld.NodeAssembler, erro ma.f = 5 ma.ca_DataSize.w = ma.w.DataSize.v ma.ca_DataSize.m = &ma.w.DataSize.m - + return &ma.ca_DataSize, nil default: - return nil, ipld.ErrInvalidKey{TypeName:"ipldgit.Tag.Repr", Key:&_String{k}} + return nil, ipld.ErrInvalidKey{TypeName: "ipldgit.Tag.Repr", Key: &_String{k}} } } func (ma *_Tag__ReprAssembler) AssembleKey() ipld.NodeAssembler { @@ -6343,7 +6497,7 @@ func (ma *_Tag__ReprAssembler) AssembleValue() ipld.NodeAssembler { case 5: ma.ca_DataSize.w = ma.w.DataSize.v ma.ca_DataSize.m = &ma.w.DataSize.m - + return &ma.ca_DataSize default: panic("unreachable") @@ -6364,21 +6518,21 @@ func (ma *_Tag__ReprAssembler) Finish() error { case maState_finished: panic("invalid state: Finish cannot be called on an assembler that's already finished") } - if ma.s & fieldBits__Tag_sufficient != fieldBits__Tag_sufficient { + if ma.s&fieldBits__Tag_sufficient != fieldBits__Tag_sufficient { err := ipld.ErrMissingRequiredField{Missing: make([]string, 0)} - if ma.s & fieldBit__Tag_Object == 0 { + if ma.s&fieldBit__Tag_Object == 0 { err.Missing = append(err.Missing, "Object") } - if ma.s & fieldBit__Tag_TagType == 0 { + if ma.s&fieldBit__Tag_TagType == 0 { err.Missing = append(err.Missing, "TagType") } - if ma.s & fieldBit__Tag_Tag == 0 { + if ma.s&fieldBit__Tag_Tag == 0 { err.Missing = append(err.Missing, "Tag") } - if ma.s & fieldBit__Tag_Tagger == 0 { + if ma.s&fieldBit__Tag_Tagger == 0 { err.Missing = append(err.Missing, "Tagger") } - if ma.s & fieldBit__Tag_Text == 0 { + if ma.s&fieldBit__Tag_Text == 0 { err.Missing = append(err.Missing, "Text") } return err @@ -6393,7 +6547,9 @@ func (ma *_Tag__ReprAssembler) KeyPrototype() ipld.NodePrototype { func (ma *_Tag__ReprAssembler) ValuePrototype(k string) ipld.NodePrototype { panic("todo structbuilder mapassembler repr valueprototype") } + type _Tag__ReprKeyAssembler _Tag__ReprAssembler + func (_Tag__ReprKeyAssembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { return mixins.StringAssembler{"ipldgit.Tag.Repr.KeyAssembler"}.BeginMap(0) } @@ -6418,49 +6574,49 @@ func (ka *_Tag__ReprKeyAssembler) AssignString(k string) error { } switch k { case "Object": - if ka.s & fieldBit__Tag_Object != 0 { + if ka.s&fieldBit__Tag_Object != 0 { return ipld.ErrRepeatedMapKey{&fieldName__Tag_Object_serial} } ka.s += fieldBit__Tag_Object ka.state = maState_expectValue ka.f = 0 case "TagType": - if ka.s & fieldBit__Tag_TagType != 0 { + if ka.s&fieldBit__Tag_TagType != 0 { return ipld.ErrRepeatedMapKey{&fieldName__Tag_TagType_serial} } ka.s += fieldBit__Tag_TagType ka.state = maState_expectValue ka.f = 1 case "Tag": - if ka.s & fieldBit__Tag_Tag != 0 { + if ka.s&fieldBit__Tag_Tag != 0 { return ipld.ErrRepeatedMapKey{&fieldName__Tag_Tag_serial} } ka.s += fieldBit__Tag_Tag ka.state = maState_expectValue ka.f = 2 case "Tagger": - if ka.s & fieldBit__Tag_Tagger != 0 { + if ka.s&fieldBit__Tag_Tagger != 0 { return ipld.ErrRepeatedMapKey{&fieldName__Tag_Tagger_serial} } ka.s += fieldBit__Tag_Tagger ka.state = maState_expectValue ka.f = 3 case "Text": - if ka.s & fieldBit__Tag_Text != 0 { + if ka.s&fieldBit__Tag_Text != 0 { return ipld.ErrRepeatedMapKey{&fieldName__Tag_Text_serial} } ka.s += fieldBit__Tag_Text ka.state = maState_expectValue ka.f = 4 case "DataSize": - if ka.s & fieldBit__Tag_DataSize != 0 { + if ka.s&fieldBit__Tag_DataSize != 0 { return ipld.ErrRepeatedMapKey{&fieldName__Tag_DataSize_serial} } ka.s += fieldBit__Tag_DataSize ka.state = maState_expectValue ka.f = 5 default: - return ipld.ErrInvalidKey{TypeName:"ipldgit.Tag.Repr", Key:&_String{k}} + return ipld.ErrInvalidKey{TypeName: "ipldgit.Tag.Repr", Key: &_String{k}} } return nil } @@ -6499,14 +6655,15 @@ func (n *_Tree) LookupMaybe(idx int64) MaybeTreeEntry { } } -var _Tree__valueAbsent = _TreeEntry__Maybe{m:schema.Maybe_Absent} +var _Tree__valueAbsent = _TreeEntry__Maybe{m: schema.Maybe_Absent} + func (n Tree) Iterator() *Tree__Itr { return &Tree__Itr{n, 0} } type Tree__Itr struct { - n Tree - idx int + n Tree + idx int } func (itr *Tree__Itr) Next() (idx int64, v TreeEntry) { @@ -6539,14 +6696,14 @@ func (m MaybeTree) Exists() bool { } func (m MaybeTree) 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") + 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 MaybeTree) Must() Tree { @@ -6555,8 +6712,10 @@ func (m MaybeTree) Must() Tree { } return m.v } + var _ ipld.Node = (Tree)(&_Tree{}) var _ schema.TypedNode = (Tree)(&_Tree{}) + func (Tree) Kind() ipld.Kind { return ipld.Kind_List } @@ -6592,8 +6751,8 @@ func (n Tree) ListIterator() ipld.ListIterator { } type _Tree__ListItr struct { - n Tree - idx int + n Tree + idx int } func (itr *_Tree__ListItr) Next() (idx int64, v ipld.Node, _ error) { @@ -6640,6 +6799,7 @@ func (Tree) AsLink() (ipld.Link, error) { func (Tree) Prototype() ipld.NodePrototype { return _Tree__Prototype{} } + type _Tree__Prototype struct{} func (_Tree__Prototype) NewBuilder() ipld.NodeBuilder { @@ -6647,9 +6807,11 @@ func (_Tree__Prototype) NewBuilder() ipld.NodeBuilder { nb.Reset() return &nb } + type _Tree__Builder struct { _Tree__Assembler } + func (nb *_Tree__Builder) Build() ipld.Node { if *nb.m != schema.Maybe_Value { panic("invalid state: cannot call Build on an assembler that's not finished") @@ -6661,9 +6823,10 @@ func (nb *_Tree__Builder) Reset() { var m schema.Maybe *nb = _Tree__Builder{_Tree__Assembler{w: &w, m: &m}} } + type _Tree__Assembler struct { - w *_Tree - m *schema.Maybe + w *_Tree + m *schema.Maybe state laState cm schema.Maybe @@ -6820,8 +6983,11 @@ func (Tree) Type() schema.Type { func (n Tree) Representation() ipld.Node { return (*_Tree__Repr)(n) } + type _Tree__Repr _Tree + var _ ipld.Node = &_Tree__Repr{} + func (_Tree__Repr) Kind() ipld.Kind { return ipld.Kind_List } @@ -6899,6 +7065,7 @@ func (_Tree__Repr) AsLink() (ipld.Link, error) { func (_Tree__Repr) Prototype() ipld.NodePrototype { return _Tree__ReprPrototype{} } + type _Tree__ReprPrototype struct{} func (_Tree__ReprPrototype) NewBuilder() ipld.NodeBuilder { @@ -6906,9 +7073,11 @@ func (_Tree__ReprPrototype) NewBuilder() ipld.NodeBuilder { nb.Reset() return &nb } + type _Tree__ReprBuilder struct { _Tree__ReprAssembler } + func (nb *_Tree__ReprBuilder) Build() ipld.Node { if *nb.m != schema.Maybe_Value { panic("invalid state: cannot call Build on an assembler that's not finished") @@ -6920,9 +7089,10 @@ func (nb *_Tree__ReprBuilder) Reset() { var m schema.Maybe *nb = _Tree__ReprBuilder{_Tree__ReprAssembler{w: &w, m: &m}} } + type _Tree__ReprAssembler struct { - w *_Tree - m *schema.Maybe + w *_Tree + m *schema.Maybe state laState cm schema.Maybe @@ -7074,7 +7244,6 @@ func (la *_Tree__ReprAssembler) ValuePrototype(_ int64) ipld.NodePrototype { return _TreeEntry__ReprPrototype{} } - func (n _TreeEntry) FieldMode() String { return &n.Mode } @@ -7084,6 +7253,7 @@ func (n _TreeEntry) FieldName() String { func (n _TreeEntry) FieldHash() Link { return &n.Hash } + type _TreeEntry__Maybe struct { m schema.Maybe v TreeEntry @@ -7101,14 +7271,14 @@ func (m MaybeTreeEntry) Exists() bool { } func (m MaybeTreeEntry) 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") + 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 MaybeTreeEntry) Must() TreeEntry { @@ -7117,6 +7287,7 @@ func (m MaybeTreeEntry) Must() TreeEntry { } return m.v } + var ( fieldName__TreeEntry_Mode = _String{"Mode"} fieldName__TreeEntry_Name = _String{"Name"} @@ -7124,6 +7295,7 @@ var ( ) var _ ipld.Node = (TreeEntry)(&_TreeEntry{}) var _ schema.TypedNode = (TreeEntry)(&_TreeEntry{}) + func (TreeEntry) Kind() ipld.Kind { return ipld.Kind_Map } @@ -7157,8 +7329,8 @@ func (n TreeEntry) MapIterator() ipld.MapIterator { } type _TreeEntry__MapItr struct { - n TreeEntry - idx int + n TreeEntry + idx int } func (itr *_TreeEntry__MapItr) Next() (k ipld.Node, v ipld.Node, _ error) { @@ -7218,6 +7390,7 @@ func (TreeEntry) AsLink() (ipld.Link, error) { func (TreeEntry) Prototype() ipld.NodePrototype { return _TreeEntry__Prototype{} } + type _TreeEntry__Prototype struct{} func (_TreeEntry__Prototype) NewBuilder() ipld.NodeBuilder { @@ -7225,9 +7398,11 @@ func (_TreeEntry__Prototype) NewBuilder() ipld.NodeBuilder { nb.Reset() return &nb } + type _TreeEntry__Builder struct { _TreeEntry__Assembler } + func (nb *_TreeEntry__Builder) Build() ipld.Node { if *nb.m != schema.Maybe_Value { panic("invalid state: cannot call Build on an assembler that's not finished") @@ -7239,18 +7414,19 @@ func (nb *_TreeEntry__Builder) Reset() { var m schema.Maybe *nb = _TreeEntry__Builder{_TreeEntry__Assembler{w: &w, m: &m}} } + type _TreeEntry__Assembler struct { - w *_TreeEntry - m *schema.Maybe + w *_TreeEntry + m *schema.Maybe state maState - s int - f int + s int + f int - cm schema.Maybe + cm schema.Maybe ca_Mode _String__Assembler ca_Name _String__Assembler ca_Hash _Link__Assembler - } +} func (na *_TreeEntry__Assembler) reset() { na.state = maState_initial @@ -7261,11 +7437,12 @@ func (na *_TreeEntry__Assembler) reset() { } var ( - fieldBit__TreeEntry_Mode = 1 << 0 - fieldBit__TreeEntry_Name = 1 << 1 - fieldBit__TreeEntry_Hash = 1 << 2 - fieldBits__TreeEntry_sufficient = 0 + 1 << 0 + 1 << 1 + 1 << 2 + fieldBit__TreeEntry_Mode = 1 << 0 + fieldBit__TreeEntry_Name = 1 << 1 + fieldBit__TreeEntry_Hash = 1 << 2 + fieldBits__TreeEntry_sufficient = 0 + 1<<0 + 1<<1 + 1<<2 ) + func (na *_TreeEntry__Assembler) BeginMap(int64) (ipld.MapAssembler, error) { switch *na.m { case schema.Maybe_Value, schema.Maybe_Null: @@ -7408,7 +7585,7 @@ func (ma *_TreeEntry__Assembler) AssembleEntry(k string) (ipld.NodeAssembler, er } switch k { case "Mode": - if ma.s & fieldBit__TreeEntry_Mode != 0 { + if ma.s&fieldBit__TreeEntry_Mode != 0 { return nil, ipld.ErrRepeatedMapKey{&fieldName__TreeEntry_Mode} } ma.s += fieldBit__TreeEntry_Mode @@ -7418,7 +7595,7 @@ func (ma *_TreeEntry__Assembler) AssembleEntry(k string) (ipld.NodeAssembler, er ma.ca_Mode.m = &ma.cm return &ma.ca_Mode, nil case "Name": - if ma.s & fieldBit__TreeEntry_Name != 0 { + if ma.s&fieldBit__TreeEntry_Name != 0 { return nil, ipld.ErrRepeatedMapKey{&fieldName__TreeEntry_Name} } ma.s += fieldBit__TreeEntry_Name @@ -7428,7 +7605,7 @@ func (ma *_TreeEntry__Assembler) AssembleEntry(k string) (ipld.NodeAssembler, er ma.ca_Name.m = &ma.cm return &ma.ca_Name, nil case "Hash": - if ma.s & fieldBit__TreeEntry_Hash != 0 { + if ma.s&fieldBit__TreeEntry_Hash != 0 { return nil, ipld.ErrRepeatedMapKey{&fieldName__TreeEntry_Hash} } ma.s += fieldBit__TreeEntry_Hash @@ -7438,7 +7615,7 @@ func (ma *_TreeEntry__Assembler) AssembleEntry(k string) (ipld.NodeAssembler, er ma.ca_Hash.m = &ma.cm return &ma.ca_Hash, nil default: - return nil, ipld.ErrInvalidKey{TypeName:"ipldgit.TreeEntry", Key:&_String{k}} + return nil, ipld.ErrInvalidKey{TypeName: "ipldgit.TreeEntry", Key: &_String{k}} } } func (ma *_TreeEntry__Assembler) AssembleKey() ipld.NodeAssembler { @@ -7505,15 +7682,15 @@ func (ma *_TreeEntry__Assembler) Finish() error { case maState_finished: panic("invalid state: Finish cannot be called on an assembler that's already finished") } - if ma.s & fieldBits__TreeEntry_sufficient != fieldBits__TreeEntry_sufficient { + if ma.s&fieldBits__TreeEntry_sufficient != fieldBits__TreeEntry_sufficient { err := ipld.ErrMissingRequiredField{Missing: make([]string, 0)} - if ma.s & fieldBit__TreeEntry_Mode == 0 { + if ma.s&fieldBit__TreeEntry_Mode == 0 { err.Missing = append(err.Missing, "Mode") } - if ma.s & fieldBit__TreeEntry_Name == 0 { + if ma.s&fieldBit__TreeEntry_Name == 0 { err.Missing = append(err.Missing, "Name") } - if ma.s & fieldBit__TreeEntry_Hash == 0 { + if ma.s&fieldBit__TreeEntry_Hash == 0 { err.Missing = append(err.Missing, "Hash") } return err @@ -7528,7 +7705,9 @@ func (ma *_TreeEntry__Assembler) KeyPrototype() ipld.NodePrototype { func (ma *_TreeEntry__Assembler) ValuePrototype(k string) ipld.NodePrototype { panic("todo structbuilder mapassembler valueprototype") } + type _TreeEntry__KeyAssembler _TreeEntry__Assembler + func (_TreeEntry__KeyAssembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { return mixins.StringAssembler{"ipldgit.TreeEntry.KeyAssembler"}.BeginMap(0) } @@ -7553,28 +7732,28 @@ func (ka *_TreeEntry__KeyAssembler) AssignString(k string) error { } switch k { case "Mode": - if ka.s & fieldBit__TreeEntry_Mode != 0 { + if ka.s&fieldBit__TreeEntry_Mode != 0 { return ipld.ErrRepeatedMapKey{&fieldName__TreeEntry_Mode} } ka.s += fieldBit__TreeEntry_Mode ka.state = maState_expectValue ka.f = 0 case "Name": - if ka.s & fieldBit__TreeEntry_Name != 0 { + if ka.s&fieldBit__TreeEntry_Name != 0 { return ipld.ErrRepeatedMapKey{&fieldName__TreeEntry_Name} } ka.s += fieldBit__TreeEntry_Name ka.state = maState_expectValue ka.f = 1 case "Hash": - if ka.s & fieldBit__TreeEntry_Hash != 0 { + if ka.s&fieldBit__TreeEntry_Hash != 0 { return ipld.ErrRepeatedMapKey{&fieldName__TreeEntry_Hash} } ka.s += fieldBit__TreeEntry_Hash ka.state = maState_expectValue ka.f = 2 default: - return ipld.ErrInvalidKey{TypeName:"ipldgit.TreeEntry", Key:&_String{k}} + return ipld.ErrInvalidKey{TypeName: "ipldgit.TreeEntry", Key: &_String{k}} } return nil } @@ -7600,8 +7779,11 @@ func (TreeEntry) Type() schema.Type { func (n TreeEntry) Representation() ipld.Node { return (*_TreeEntry__Repr)(n) } + type _TreeEntry__Repr _TreeEntry + var _ ipld.Node = &_TreeEntry__Repr{} + func (_TreeEntry__Repr) Kind() ipld.Kind { return ipld.Kind_String } @@ -7659,6 +7841,7 @@ func (_TreeEntry__Repr) AsLink() (ipld.Link, error) { func (_TreeEntry__Repr) Prototype() ipld.NodePrototype { return _TreeEntry__ReprPrototype{} } + type _TreeEntry__ReprPrototype struct{} func (_TreeEntry__ReprPrototype) NewBuilder() ipld.NodeBuilder { @@ -7666,9 +7849,11 @@ func (_TreeEntry__ReprPrototype) NewBuilder() ipld.NodeBuilder { nb.Reset() return &nb } + type _TreeEntry__ReprBuilder struct { _TreeEntry__ReprAssembler } + func (nb *_TreeEntry__ReprBuilder) Build() ipld.Node { if *nb.m != schema.Maybe_Value { panic("invalid state: cannot call Build on an assembler that's not finished") @@ -7683,19 +7868,20 @@ func (nb *_TreeEntry__ReprBuilder) Reset() { func (_TreeEntry__ReprPrototype) fromString(w *_TreeEntry, v string) error { ss, err := mixins.SplitExact(v, " ", 3) if err != nil { - return ipld.ErrUnmatchable{TypeName:"ipldgit.TreeEntry.Repr", Reason: err} + return ipld.ErrUnmatchable{TypeName: "ipldgit.TreeEntry.Repr", Reason: err} } if err := (_String__ReprPrototype{}).fromString(&w.Mode, ss[0]); err != nil { - return ipld.ErrUnmatchable{TypeName:"ipldgit.TreeEntry.Repr", Reason: err} + return ipld.ErrUnmatchable{TypeName: "ipldgit.TreeEntry.Repr", Reason: err} } if err := (_String__ReprPrototype{}).fromString(&w.Name, ss[1]); err != nil { - return ipld.ErrUnmatchable{TypeName:"ipldgit.TreeEntry.Repr", Reason: err} + return ipld.ErrUnmatchable{TypeName: "ipldgit.TreeEntry.Repr", Reason: err} } if err := (_Link__ReprPrototype{}).fromString(&w.Hash, ss[2]); err != nil { - return ipld.ErrUnmatchable{TypeName:"ipldgit.TreeEntry.Repr", Reason: err} + return ipld.ErrUnmatchable{TypeName: "ipldgit.TreeEntry.Repr", Reason: err} } return nil } + type _TreeEntry__ReprAssembler struct { w *_TreeEntry m *schema.Maybe @@ -7776,4 +7962,3 @@ func (na *_TreeEntry__ReprAssembler) AssignNode(v ipld.Node) error { func (_TreeEntry__ReprAssembler) Prototype() ipld.NodePrototype { return _TreeEntry__ReprPrototype{} } - diff --git a/ipldsch_types.go b/ipldsch_types.go index 1cfe4b1..3efcc69 100644 --- a/ipldsch_types.go +++ b/ipldsch_types.go @@ -5,6 +5,7 @@ package ipldgit import ( ipld "github.com/ipld/go-ipld-prime" ) + var _ ipld.Node = nil // suppress errors when this dependency is not referenced // 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. @@ -19,32 +20,32 @@ var _ ipld.Node = nil // suppress errors when this dependency is not referenced var Type typeSlab type typeSlab struct { - Blob _Blob__Prototype - Blob__Repr _Blob__ReprPrototype - Commit _Commit__Prototype - Commit__Repr _Commit__ReprPrototype - GpgSig _GpgSig__Prototype - GpgSig__Repr _GpgSig__ReprPrototype - Link _Link__Prototype - Link__Repr _Link__ReprPrototype - LinkTree _LinkTree__Prototype - LinkTree__Repr _LinkTree__ReprPrototype + Blob _Blob__Prototype + Blob__Repr _Blob__ReprPrototype + Commit _Commit__Prototype + Commit__Repr _Commit__ReprPrototype + GpgSig _GpgSig__Prototype + GpgSig__Repr _GpgSig__ReprPrototype + Link _Link__Prototype + Link__Repr _Link__ReprPrototype + LinkTree _LinkTree__Prototype + LinkTree__Repr _LinkTree__ReprPrototype ListParents _ListParents__Prototype ListParents__Repr _ListParents__ReprPrototype - ListString _ListString__Prototype - ListString__Repr _ListString__ReprPrototype - ListTag _ListTag__Prototype - ListTag__Repr _ListTag__ReprPrototype - PersonInfo _PersonInfo__Prototype - PersonInfo__Repr _PersonInfo__ReprPrototype - String _String__Prototype - String__Repr _String__ReprPrototype - Tag _Tag__Prototype - Tag__Repr _Tag__ReprPrototype - Tree _Tree__Prototype - Tree__Repr _Tree__ReprPrototype - TreeEntry _TreeEntry__Prototype - TreeEntry__Repr _TreeEntry__ReprPrototype + ListString _ListString__Prototype + ListString__Repr _ListString__ReprPrototype + ListTag _ListTag__Prototype + ListTag__Repr _ListTag__ReprPrototype + PersonInfo _PersonInfo__Prototype + PersonInfo__Repr _PersonInfo__ReprPrototype + String _String__Prototype + String__Repr _String__ReprPrototype + Tag _Tag__Prototype + Tag__Repr _Tag__ReprPrototype + Tree _Tree__Prototype + Tree__Repr _Tree__ReprPrototype + TreeEntry _TreeEntry__Prototype + TreeEntry__Repr _TreeEntry__ReprPrototype } // --- type definitions follow --- @@ -56,16 +57,16 @@ type _Blob struct{ x []byte } // Commit matches the IPLD Schema type "Commit". It has Struct type-kind, and may be interrogated like map kind. type Commit = *_Commit type _Commit struct { - DataSize _String - GitTree _LinkTree - Parents _ListParents - Message _String - Author _PersonInfo__Maybe + DataSize _String + GitTree _LinkTree + Parents _ListParents + Message _String + Author _PersonInfo__Maybe Committer _PersonInfo__Maybe - Encoding _String__Maybe - Sig _GpgSig__Maybe - MergeTag _ListTag - Other _ListString + Encoding _String__Maybe + Sig _GpgSig__Maybe + MergeTag _ListTag + Other _ListString } // GpgSig matches the IPLD Schema type "GpgSig". It has string kind. @@ -101,9 +102,9 @@ type _ListTag struct { // PersonInfo matches the IPLD Schema type "PersonInfo". It has Struct type-kind, and may be interrogated like map kind. type PersonInfo = *_PersonInfo type _PersonInfo struct { - Name _String - Email _String - Date _String + Name _String + Email _String + Date _String Timezone _String } @@ -114,11 +115,11 @@ type _String struct{ x string } // Tag matches the IPLD Schema type "Tag". It has Struct type-kind, and may be interrogated like map kind. type Tag = *_Tag type _Tag struct { - Object _Link - TagType _String - Tag _String - Tagger _PersonInfo - Text _String + Object _Link + TagType _String + Tag _String + Tagger _PersonInfo + Text _String DataSize _String__Maybe } @@ -135,4 +136,3 @@ type _TreeEntry struct { Name _String Hash _Link } - diff --git a/unmarshal.go b/unmarshal.go index 0e00be7..94b6040 100644 --- a/unmarshal.go +++ b/unmarshal.go @@ -31,3 +31,38 @@ func Decoder(na ipld.NodeAssembler, r io.Reader) error { return fmt.Errorf("unrecognized object type: %s", typ) } } + +// ParseObject produces an ipld.Node from a stream / binary represnetation. +func ParseObject(r io.Reader) (ipld.Node, error) { + rd := bufio.NewReader(r) + + typ, err := rd.ReadString(' ') + if err != nil { + return nil, err + } + typ = typ[:len(typ)-1] + + var na ipld.NodeBuilder + var f func(ipld.NodeAssembler, *bufio.Reader) error + switch typ { + case "tree": + na = Type.Tree.NewBuilder() + f = DecodeTree + case "commit": + na = Type.Commit.NewBuilder() + f = DecodeCommit + case "blob": + na = Type.Blob.NewBuilder() + f = DecodeBlob + case "tag": + na = Type.Tag.NewBuilder() + f = DecodeTag + default: + return nil, fmt.Errorf("unrecognized object type: %s", typ) + } + + if err := f(na, rd); err != nil { + return nil, err + } + return na.Build(), nil +} From d2d95b3b9f8eabe0bfbee7f3c929f0571bd85e42 Mon Sep 17 00:00:00 2001 From: Will Scott Date: Wed, 3 Mar 2021 15:02:02 -0800 Subject: [PATCH 05/22] back to linksystem --- git_test.go | 58 ++++++++++++++++++++++------------------------------- go.mod | 3 ++- go.sum | 7 ++++--- init.go | 11 +++++----- 4 files changed, 36 insertions(+), 43 deletions(-) diff --git a/git_test.go b/git_test.go index 182e4e9..bd3c47e 100644 --- a/git_test.go +++ b/git_test.go @@ -4,7 +4,6 @@ import ( "archive/tar" "bytes" "compress/gzip" - "context" "fmt" "io" "os" @@ -15,17 +14,15 @@ import ( "github.com/ipfs/go-cid" "github.com/ipld/go-ipld-prime" cidlink "github.com/ipld/go-ipld-prime/linking/cid" - mh "github.com/multiformats/go-multihash" ) func TestObjectParse(t *testing.T) { - lb := cidlink.LinkBuilder{Prefix: cid.NewCidV1(cid.GitRaw, mh.Multihash{}).Prefix()} - sc := func(ipld.Link) error { - return nil - } - storer := func(lnkCtx ipld.LinkContext) (io.Writer, ipld.StoreCommitter, error) { - return bytes.NewBuffer([]byte{}), sc, nil - } + lb := cidlink.LinkPrototype{cid.Prefix{ + Version: 1, + Codec: cid.GitRaw, + MhType: 0x11, + MhLength: 20, + }} i := 0 err := filepath.Walk(".git/objects", func(path string, info os.FileInfo, err error) error { @@ -59,11 +56,10 @@ func TestObjectParse(t *testing.T) { fmt.Printf("%d %s\r", i, path) } - shal, err := lb.Build(context.Background(), ipld.LinkContext{}, thing, storer) - if err != nil { - t.Fatal(err) - } - sha := shal.(cidlink.Link).Cid.Hash() + ls := cidlink.DefaultLinkSystem() + lnk := ls.MustComputeLink(lb, thing) + + sha := lnk.(cidlink.Link).Cid.Hash() if fmt.Sprintf("%x", sha) != parts[len(parts)-2]+parts[len(parts)-1] { fmt.Printf("\nsha: %x\n", sha) fmt.Printf("path: %s\n", path) @@ -88,18 +84,12 @@ func TestObjectParse(t *testing.T) { } func TestArchiveObjectParse(t *testing.T) { - lb := cidlink.LinkBuilder{Prefix: cid.Prefix{ + lb := cidlink.LinkPrototype{cid.Prefix{ Version: 1, Codec: cid.GitRaw, MhType: 0x11, MhLength: 20, }} - sc := func(ipld.Link) error { - return nil - } - storer := func(lnkCtx ipld.LinkContext) (io.Writer, ipld.StoreCommitter, error) { - return bytes.NewBuffer([]byte{}), sc, nil - } archive, err := os.Open("testdata.tar.gz") if err != nil { @@ -153,11 +143,10 @@ func TestArchiveObjectParse(t *testing.T) { fmt.Printf("%s\r", name) - shal, err := lb.Build(context.Background(), ipld.LinkContext{}, thing, storer) - if err != nil { - t.Fatal(err) - } - sha := shal.(cidlink.Link).Cid.Hash() + ls := cidlink.DefaultLinkSystem() + lnk := ls.MustComputeLink(lb, thing) + + sha := lnk.(cidlink.Link).Cid.Hash() if fmt.Sprintf("%x", sha) != parts[len(parts)-2]+parts[len(parts)-1] { fmt.Printf("\nsha: %x\n", sha) fmt.Printf("path: %s\n", name) @@ -432,13 +421,14 @@ func BenchmarkRawData(b *testing.B) { } func BenchmarkCid(b *testing.B) { - lb := cidlink.LinkBuilder{Prefix: cid.NewCidV1(cid.GitRaw, mh.Multihash{}).Prefix()} - sc := func(ipld.Link) error { - return nil - } - storer := func(lnkCtx ipld.LinkContext) (io.Writer, ipld.StoreCommitter, error) { - return bytes.NewBuffer([]byte{}), sc, nil - } + lb := cidlink.LinkPrototype{cid.Prefix{ + Version: 1, + Codec: cid.GitRaw, + MhType: 0x11, + MhLength: 20, + }} + ls := cidlink.DefaultLinkSystem() + for i := 0; i < b.N; i++ { err := filepath.Walk(".git/objects", func(path string, info os.FileInfo, err error) error { if err != nil { @@ -463,7 +453,7 @@ func BenchmarkCid(b *testing.B) { return err } - _, err = lb.Build(context.Background(), ipld.LinkContext{}, thing, storer) + _, err = ls.ComputeLink(lb, thing) return err }) if err != nil { diff --git a/go.mod b/go.mod index bf96acf..5d74faa 100644 --- a/go.mod +++ b/go.mod @@ -5,6 +5,7 @@ go 1.15 require ( github.com/ipfs/go-block-format v0.0.3 github.com/ipfs/go-cid v0.0.7 - github.com/ipld/go-ipld-prime v0.7.0 + github.com/ipld/go-ipld-prime v0.7.1-0.20210225173718-8fef5312eb12 github.com/multiformats/go-multihash v0.0.14 + github.com/multiformats/go-varint v0.0.6 // indirect ) diff --git a/go.sum b/go.sum index cabe97a..18ecaf3 100644 --- a/go.sum +++ b/go.sum @@ -7,8 +7,8 @@ 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/ipfs/go-ipfs-util v0.0.2 h1:59Sswnk1MFaiq+VcaknX7aYEyGyGDAA73ilhEK2POp8= github.com/ipfs/go-ipfs-util v0.0.2/go.mod h1:CbPtkWJzjLdEcezDns2XYaehFVNXG9zrdrtMecczcsQ= -github.com/ipld/go-ipld-prime v0.7.0 h1:eigF1ZpaL1prbsKYVMqPLoPJqD/pzkQOe2j1uzvVg7w= -github.com/ipld/go-ipld-prime v0.7.0/go.mod h1:0xEgdD6MKbZ1vF0GC+YcR/C4SQCAlRuOjIJ2i0HxqzM= +github.com/ipld/go-ipld-prime v0.7.1-0.20210225173718-8fef5312eb12 h1:O9VMUYa2ktly9ql6W0LG0k8lXqg3bqz2ZfbaHXN3law= +github.com/ipld/go-ipld-prime v0.7.1-0.20210225173718-8fef5312eb12/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= @@ -31,8 +31,9 @@ github.com/multiformats/go-multihash v0.0.10/go.mod h1:YSLudS+Pi8NHE7o6tb3D8vrpK 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= diff --git a/init.go b/init.go index 530cd30..fe9d272 100644 --- a/init.go +++ b/init.go @@ -5,15 +5,16 @@ package ipldgit import ( "github.com/ipfs/go-cid" - cidlink "github.com/ipld/go-ipld-prime/linking/cid" + "github.com/ipld/go-ipld-prime" + mc "github.com/ipld/go-ipld-prime/multicodec" ) var ( - _ cidlink.MulticodecDecoder = Decoder - _ cidlink.MulticodecEncoder = Encoder + _ ipld.Decoder = Decoder + _ ipld.Encoder = Encoder ) func init() { - cidlink.RegisterMulticodecDecoder(cid.GitRaw, Decoder) - cidlink.RegisterMulticodecEncoder(cid.GitRaw, Encoder) + mc.EncoderRegistry[cid.GitRaw]= Encoder + mc.DecoderRegistry[cid.GitRaw]= Decoder } From d0f7f53e885f6b8436a8217a901160e9058de84d Mon Sep 17 00:00:00 2001 From: Will Scott Date: Wed, 3 Mar 2021 16:17:29 -0800 Subject: [PATCH 06/22] tests run, but something is unhappy --- blob.go | 1 + git_test.go | 15 ++++++++++++--- unmarshal.go | 1 + 3 files changed, 14 insertions(+), 3 deletions(-) diff --git a/blob.go b/blob.go index 51b68e4..c146afb 100644 --- a/blob.go +++ b/blob.go @@ -16,6 +16,7 @@ func DecodeBlob(na ipld.NodeAssembler, rd *bufio.Reader) error { if err != nil { return err } + fmt.Printf("Size of blob was %s\n", size) sizen, err := strconv.Atoi(size[:len(size)-1]) if err != nil { diff --git a/git_test.go b/git_test.go index bd3c47e..3763611 100644 --- a/git_test.go +++ b/git_test.go @@ -14,6 +14,7 @@ import ( "github.com/ipfs/go-cid" "github.com/ipld/go-ipld-prime" cidlink "github.com/ipld/go-ipld-prime/linking/cid" + "github.com/multiformats/go-multihash" ) func TestObjectParse(t *testing.T) { @@ -23,6 +24,7 @@ func TestObjectParse(t *testing.T) { MhType: 0x11, MhLength: 20, }} + ls := cidlink.DefaultLinkSystem() i := 0 err := filepath.Walk(".git/objects", func(path string, info os.FileInfo, err error) error { @@ -46,21 +48,26 @@ func TestObjectParse(t *testing.T) { } defer fi.Close() + fmt.Printf("parsing for %s\n", path) thing, err := ParseCompressedObject(fi) if err != nil { fmt.Println("ERROR: ", path, err) return err } + fmt.Printf("parsed.. now compute link.\n") if i%64 == 0 { fmt.Printf("%d %s\r", i, path) } - ls := cidlink.DefaultLinkSystem() lnk := ls.MustComputeLink(lb, thing) - sha := lnk.(cidlink.Link).Cid.Hash() - if fmt.Sprintf("%x", sha) != parts[len(parts)-2]+parts[len(parts)-1] { + mh, err := multihash.Decode(sha) + if err != nil { + t.Fatal(err) + } + if fmt.Sprintf("%x", mh.Digest) != parts[len(parts)-2]+parts[len(parts)-1] { + fmt.Printf("\n") fmt.Printf("\nsha: %x\n", sha) fmt.Printf("path: %s\n", path) fmt.Printf("mismatch on: %T\n", thing) @@ -69,6 +76,8 @@ func TestObjectParse(t *testing.T) { fmt.Println(thing.AsBytes()) fmt.Println("^^^^^^") t.Fatal("mismatch!") + } else { + fmt.Printf("\nsha: %x\n", mh.Digest) } err = testNode(t, thing) diff --git a/unmarshal.go b/unmarshal.go index 94b6040..68d748e 100644 --- a/unmarshal.go +++ b/unmarshal.go @@ -41,6 +41,7 @@ func ParseObject(r io.Reader) (ipld.Node, error) { return nil, err } typ = typ[:len(typ)-1] + fmt.Printf("type is %s\n", typ) var na ipld.NodeBuilder var f func(ipld.NodeAssembler, *bufio.Reader) error From 8a2857668351b425ed238ffe23b582fb89ee74ef Mon Sep 17 00:00:00 2001 From: Will Scott Date: Wed, 3 Mar 2021 18:14:21 -0800 Subject: [PATCH 07/22] fix some bugs --- blob.go | 6 +++--- tree.go | 20 ++++++++++++-------- unmarshal.go | 2 +- 3 files changed, 16 insertions(+), 12 deletions(-) diff --git a/blob.go b/blob.go index c146afb..45584c6 100644 --- a/blob.go +++ b/blob.go @@ -16,7 +16,6 @@ func DecodeBlob(na ipld.NodeAssembler, rd *bufio.Reader) error { if err != nil { return err } - fmt.Printf("Size of blob was %s\n", size) sizen, err := strconv.Atoi(size[:len(size)-1]) if err != nil { @@ -39,10 +38,11 @@ func DecodeBlob(na ipld.NodeAssembler, rd *bufio.Reader) error { } func encodeBlob(n ipld.Node, w io.Writer) error { - bytes, err := n.AsBytes() + b, err := n.AsBytes() if err != nil { return err } - _, err = bufio.NewWriter(w).Write(bytes) + + _, err = bytes.NewBuffer(b).WriteTo(w) return err } diff --git a/tree.go b/tree.go index 8807a3a..c7e0a74 100644 --- a/tree.go +++ b/tree.go @@ -19,46 +19,50 @@ func DecodeTree(na ipld.NodeAssembler, rd *bufio.Reader) error { } lstr = lstr[:len(lstr)-1] - n, err := strconv.Atoi(lstr) + _, err = strconv.Atoi(lstr) if err != nil { return err } t := Type.Tree__Repr.NewBuilder() - la, err := t.BeginList(int64(n)) + la, err := t.BeginList(-1) if err != nil { return err } for { - err := DecodeTreeEntry(la.AssembleValue(), rd) + node, err := DecodeTreeEntry(rd) if err != nil { if err == io.EOF { break } return err } + la.AssembleValue().AssignNode(node) + } + if err := la.Finish(); err != nil { + return err } return na.AssignNode(t.Build()) } // DecodeTreeEntry fills a NodeAssembler (from `Type.TreeEntry__Repr.NewBuilder()`) from a stream of bytes -func DecodeTreeEntry(na ipld.NodeAssembler, rd *bufio.Reader) error { +func DecodeTreeEntry(rd *bufio.Reader) (ipld.Node, error) { data, err := rd.ReadString(' ') if err != nil { - return err + return nil, err } data = data[:len(data)-1] name, err := rd.ReadString(0) if err != nil { - return err + return nil, err } name = name[:len(name)-1] sha := make([]byte, 20) _, err = io.ReadFull(rd, sha) if err != nil { - return err + return nil, err } te := _TreeEntry{ @@ -66,7 +70,7 @@ func DecodeTreeEntry(na ipld.NodeAssembler, rd *bufio.Reader) error { Name: _String{name}, Hash: _Link{cidlink.Link{Cid: shaToCid(sha)}}, } - return na.AssignNode(&te) + return &te, nil } func encodeTree(n ipld.Node, w io.Writer) error { diff --git a/unmarshal.go b/unmarshal.go index 68d748e..bc4b4f8 100644 --- a/unmarshal.go +++ b/unmarshal.go @@ -41,7 +41,6 @@ func ParseObject(r io.Reader) (ipld.Node, error) { return nil, err } typ = typ[:len(typ)-1] - fmt.Printf("type is %s\n", typ) var na ipld.NodeBuilder var f func(ipld.NodeAssembler, *bufio.Reader) error @@ -61,6 +60,7 @@ func ParseObject(r io.Reader) (ipld.Node, error) { default: return nil, fmt.Errorf("unrecognized object type: %s", typ) } + fmt.Printf("type %s\n", typ) if err := f(na, rd); err != nil { return nil, err From e3c68b044997b1c97396cef74d8959fee1469b59 Mon Sep 17 00:00:00 2001 From: Will Scott Date: Wed, 3 Mar 2021 19:20:54 -0800 Subject: [PATCH 08/22] fix bugs in tree and commit handling --- commit.go | 21 +++------------------ git_test.go | 4 ++-- personinfo.go | 15 +++++++++++++++ tree.go | 6 ++---- 4 files changed, 22 insertions(+), 24 deletions(-) diff --git a/commit.go b/commit.go index 72fac9b..56df35f 100644 --- a/commit.go +++ b/commit.go @@ -26,7 +26,7 @@ func DecodeCommit(na ipld.NodeAssembler, rd *bufio.Reader) error { MergeTag: _ListTag{[]_Tag{}}, Other: _ListString{[]_String{}}, } - c.DataSize = _String{size} + c.DataSize = _String{size[:len(size)-1]} for { line, _, err := rd.ReadLine() if err != nil { @@ -163,7 +163,7 @@ func encodeCommit(n ipld.Node, w io.Writer) error { } fmt.Fprintf(buf, "author %s\n", c.Author.v.GitString()) fmt.Fprintf(buf, "committer %s\n", c.Committer.v.GitString()) - if len(c.Encoding.v.x) > 0 { + if c.Encoding.m == schema.Maybe_Value { fmt.Fprintf(buf, "encoding %s\n", c.Encoding.v.x) } for _, mtag := range c.MergeTag.x { @@ -183,21 +183,6 @@ func encodeCommit(n ipld.Node, w io.Writer) error { } fmt.Fprintf(buf, "\n%s", c.Message.x) - _, err := bufio.NewWriter(w).Write(buf.Bytes()) + _, err := buf.WriteTo(w) return err } - -func (p _PersonInfo) GitString() string { - f := "%s <%s>" - arg := []interface{}{p.Name.x, p.Email.x} - if p.Date.x != "" { - f = f + " %s" - arg = append(arg, p.Date.x) - } - - if p.Timezone.x != "" { - f = f + " %s" - arg = append(arg, p.Timezone.x) - } - return fmt.Sprintf(f, arg...) -} diff --git a/git_test.go b/git_test.go index 3763611..a4ee2a9 100644 --- a/git_test.go +++ b/git_test.go @@ -229,7 +229,7 @@ func TestParsePersonInfo(t *testing.T) { t.Fatal(err) } if !bytes.Equal([]byte(pi.GitString()), p1) { - t.Fatal("not equal", p1, pi.GitString()) + t.Fatal("not equal:", string(p1), "vs: ", pi.GitString()) } if d, err := pi.LookupByString("Date"); err != nil { @@ -357,7 +357,7 @@ func TestParsePersonInfo(t *testing.T) { t.Fatal(err) } - assert(t, pi.GitString() == "Someone ") + assert(t, pi.GitString() == "prefix Someone ") /* TODO: json pi, err = parsePersonInfo([]byte("prefix Łukasz Magiera 1546187652 +0100")) diff --git a/personinfo.go b/personinfo.go index 082bb9c..ccbc8b8 100644 --- a/personinfo.go +++ b/personinfo.go @@ -69,3 +69,18 @@ func parsePersonInfo(line []byte) (PersonInfo, error) { pi.Timezone = _String{string(parts[at])} return &pi, nil } + +func (p _PersonInfo) GitString() string { + f := "prefix %s <%s>" + arg := []interface{}{p.Name.x, p.Email.x} + if p.Date.x != "" { + f = f + " %s" + arg = append(arg, p.Date.x) + } + + if p.Timezone.x != "" { + f = f + " %s" + arg = append(arg, p.Timezone.x) + } + return fmt.Sprintf(f, arg...) +} diff --git a/tree.go b/tree.go index c7e0a74..ee86e29 100644 --- a/tree.go +++ b/tree.go @@ -76,25 +76,23 @@ func DecodeTreeEntry(rd *bufio.Reader) (ipld.Node, error) { func encodeTree(n ipld.Node, w io.Writer) error { buf := new(bytes.Buffer) - cnt := 0 li := n.ListIterator() for !li.Done() { _, te, err := li.Next() if err != nil { return err } - cnt++ if err := encodeTreeEntry(te, buf); err != nil { return err } } + cnt := buf.Len() if _, err := fmt.Fprintf(w, "tree %d\x00", cnt); err != nil { return err } - _, err := bufio.NewWriter(w).Write(buf.Bytes()) + _, err := buf.WriteTo(w) return err - } func encodeTreeEntry(n ipld.Node, w io.Writer) error { From 59665727920cde283fb95018af4e9a28db63c39f Mon Sep 17 00:00:00 2001 From: Will Scott Date: Wed, 3 Mar 2021 20:23:13 -0800 Subject: [PATCH 09/22] tests pass --- commit.go | 14 +- gen/gen.go | 2 - git_test.go | 27 +- init.go | 4 +- ipldsch_satisfaction.go | 641 ++++++++++++++-------------------------- ipldsch_types.go | 12 +- personinfo.go | 2 +- tag.go | 10 +- 8 files changed, 264 insertions(+), 448 deletions(-) diff --git a/commit.go b/commit.go index 56df35f..85138e3 100644 --- a/commit.go +++ b/commit.go @@ -16,7 +16,7 @@ import ( // DecodeCommit fills a NodeAssembler (from `Type.Commit__Repr.NewBuilder()`) from a stream of bytes func DecodeCommit(na ipld.NodeAssembler, rd *bufio.Reader) error { - size, err := rd.ReadString(0) + _, err := rd.ReadString(0) if err != nil { return err } @@ -26,7 +26,6 @@ func DecodeCommit(na ipld.NodeAssembler, rd *bufio.Reader) error { MergeTag: _ListTag{[]_Tag{}}, Other: _ListString{[]_String{}}, } - c.DataSize = _String{size[:len(size)-1]} for { line, _, err := rd.ReadLine() if err != nil { @@ -156,7 +155,7 @@ func encodeCommit(n ipld.Node, w io.Writer) error { } buf := new(bytes.Buffer) - fmt.Fprintf(buf, "commit %s\x00", c.DataSize.x) + fmt.Fprintf(buf, "tree %s\n", hex.EncodeToString(c.GitTree.sha())) for _, p := range c.Parents.x { fmt.Fprintf(buf, "parent %s\n", hex.EncodeToString(p.sha())) @@ -183,6 +182,13 @@ func encodeCommit(n ipld.Node, w io.Writer) error { } fmt.Fprintf(buf, "\n%s", c.Message.x) - _, err := buf.WriteTo(w) + fmt.Printf("encode commit len: %d \n", buf.Len()) + // fmt.Printf("out: %s\n", string(buf.Bytes())) + _, err := fmt.Fprintf(w, "commit %d\x00", buf.Len()) + if err != nil { + return err + } + + _, err = buf.WriteTo(w) return err } diff --git a/gen/gen.go b/gen/gen.go index 2de777e..7793703 100644 --- a/gen/gen.go +++ b/gen/gen.go @@ -30,12 +30,10 @@ func main() { schema.SpawnStructField("Tag", "String", false, false), schema.SpawnStructField("Tagger", "PersonInfo", false, false), schema.SpawnStructField("Text", "String", false, false), - schema.SpawnStructField("DataSize", "String", true, false), }, schema.SpawnStructRepresentationMap(map[string]string{"Type": "TagType"}))) ts.Accumulate(schema.SpawnList("ListTag", "Tag", false)) ts.Accumulate(schema.SpawnList("ListParents", "Link", false)) //Todo: type 'Parents' links ts.Accumulate(schema.SpawnStruct("Commit", []schema.StructField{ - schema.SpawnStructField("DataSize", "String", false, false), schema.SpawnStructField("GitTree", "LinkTree", false, false), schema.SpawnStructField("Parents", "ListParents", false, false), schema.SpawnStructField("Message", "String", false, false), diff --git a/git_test.go b/git_test.go index a4ee2a9..648c663 100644 --- a/git_test.go +++ b/git_test.go @@ -99,6 +99,7 @@ func TestArchiveObjectParse(t *testing.T) { MhType: 0x11, MhLength: 20, }} + ls := cidlink.DefaultLinkSystem() archive, err := os.Open("testdata.tar.gz") if err != nil { @@ -152,17 +153,21 @@ func TestArchiveObjectParse(t *testing.T) { fmt.Printf("%s\r", name) - ls := cidlink.DefaultLinkSystem() lnk := ls.MustComputeLink(lb, thing) - sha := lnk.(cidlink.Link).Cid.Hash() - if fmt.Sprintf("%x", sha) != parts[len(parts)-2]+parts[len(parts)-1] { + mh, err := multihash.Decode(sha) + if err != nil { + t.Fatal(err) + } + if fmt.Sprintf("%x", mh.Digest) != parts[len(parts)-2]+parts[len(parts)-1] { fmt.Printf("\nsha: %x\n", sha) fmt.Printf("path: %s\n", name) fmt.Printf("mismatch on: %T\n", thing) fmt.Printf("%#v\n", thing) fmt.Println("vvvvvv") - fmt.Println(thing.AsBytes()) + buf := bytes.NewBuffer([]byte{}) + Encoder(thing, buf) + fmt.Println(string(buf.Bytes())) fmt.Println("^^^^^^") t.Fatal("mismatch!") } @@ -197,8 +202,6 @@ func testNode(t *testing.T, nd ipld.Node) error { } assert(t, !commit.GitTree.IsNull()) - assert(t, len(commit.FieldMergeTag().x) > 0) - case Type.Tag: tag, ok := nd.(Tag) if !ok { @@ -228,7 +231,7 @@ func TestParsePersonInfo(t *testing.T) { if err != nil { t.Fatal(err) } - if !bytes.Equal([]byte(pi.GitString()), p1) { + if !bytes.Equal([]byte(pi.GitString()), p1[7:]) { t.Fatal("not equal:", string(p1), "vs: ", pi.GitString()) } @@ -261,7 +264,7 @@ func TestParsePersonInfo(t *testing.T) { if err != nil { t.Fatal(err) } - if !bytes.Equal([]byte(pi.GitString()), p2) { + if !bytes.Equal([]byte(pi.GitString()), p2[7:]) { t.Fatal("not equal", p2, pi.GitString()) } @@ -276,7 +279,7 @@ func TestParsePersonInfo(t *testing.T) { if err != nil { t.Fatal(err) } - if !bytes.Equal([]byte(pi.GitString()), p3) { + if !bytes.Equal([]byte(pi.GitString()), p3[7:]) { t.Fatal("not equal", p3, pi.GitString()) } if d, err := pi.LookupByString("Date"); err != nil { @@ -308,7 +311,7 @@ func TestParsePersonInfo(t *testing.T) { if err != nil { t.Fatal(err) } - if !bytes.Equal([]byte(pi.GitString()), p4) { + if !bytes.Equal([]byte(pi.GitString()), p4[7:]) { t.Fatal("not equal", p4, pi.GitString()) } @@ -341,7 +344,7 @@ func TestParsePersonInfo(t *testing.T) { if err != nil { t.Fatal(err) } - if !bytes.Equal([]byte(pi.GitString()), p5) { + if !bytes.Equal([]byte(pi.GitString()), p5[7:]) { t.Fatal("not equal", p5, pi.GitString()) } @@ -357,7 +360,7 @@ func TestParsePersonInfo(t *testing.T) { t.Fatal(err) } - assert(t, pi.GitString() == "prefix Someone ") + assert(t, pi.GitString() == "Someone ") /* TODO: json pi, err = parsePersonInfo([]byte("prefix Łukasz Magiera 1546187652 +0100")) diff --git a/init.go b/init.go index fe9d272..4a8b862 100644 --- a/init.go +++ b/init.go @@ -15,6 +15,6 @@ var ( ) func init() { - mc.EncoderRegistry[cid.GitRaw]= Encoder - mc.DecoderRegistry[cid.GitRaw]= Decoder + mc.EncoderRegistry[cid.GitRaw] = Encoder + mc.DecoderRegistry[cid.GitRaw] = Decoder } diff --git a/ipldsch_satisfaction.go b/ipldsch_satisfaction.go index 0b66061..ea4250f 100644 --- a/ipldsch_satisfaction.go +++ b/ipldsch_satisfaction.go @@ -221,9 +221,6 @@ var _ ipld.Node = &_Blob__Repr{} type _Blob__ReprPrototype = _Blob__Prototype type _Blob__ReprAssembler = _Blob__Assembler -func (n _Commit) FieldDataSize() String { - return &n.DataSize -} func (n _Commit) FieldGitTree() LinkTree { return &n.GitTree } @@ -287,7 +284,6 @@ func (m MaybeCommit) Must() Commit { } var ( - fieldName__Commit_DataSize = _String{"DataSize"} fieldName__Commit_GitTree = _String{"GitTree"} fieldName__Commit_Parents = _String{"Parents"} fieldName__Commit_Message = _String{"Message"} @@ -306,8 +302,6 @@ func (Commit) Kind() ipld.Kind { } func (n Commit) LookupByString(key string) (ipld.Node, error) { switch key { - case "DataSize": - return &n.DataSize, nil case "GitTree": return &n.GitTree, nil case "Parents": @@ -365,54 +359,51 @@ type _Commit__MapItr struct { } func (itr *_Commit__MapItr) Next() (k ipld.Node, v ipld.Node, _ error) { - if itr.idx >= 10 { + if itr.idx >= 9 { return nil, nil, ipld.ErrIteratorOverread{} } switch itr.idx { case 0: - k = &fieldName__Commit_DataSize - v = &itr.n.DataSize - case 1: k = &fieldName__Commit_GitTree v = &itr.n.GitTree - case 2: + case 1: k = &fieldName__Commit_Parents v = &itr.n.Parents - case 3: + case 2: k = &fieldName__Commit_Message v = &itr.n.Message - case 4: + case 3: k = &fieldName__Commit_Author if itr.n.Author.m == schema.Maybe_Absent { v = ipld.Absent break } v = itr.n.Author.v - case 5: + case 4: k = &fieldName__Commit_Committer if itr.n.Committer.m == schema.Maybe_Absent { v = ipld.Absent break } v = itr.n.Committer.v - case 6: + case 5: k = &fieldName__Commit_Encoding if itr.n.Encoding.m == schema.Maybe_Absent { v = ipld.Absent break } v = itr.n.Encoding.v - case 7: + case 6: k = &fieldName__Commit_Sig if itr.n.Sig.m == schema.Maybe_Absent { v = ipld.Absent break } v = itr.n.Sig.v - case 8: + case 7: k = &fieldName__Commit_MergeTag v = &itr.n.MergeTag - case 9: + case 8: k = &fieldName__Commit_Other v = &itr.n.Other default: @@ -422,14 +413,14 @@ func (itr *_Commit__MapItr) Next() (k ipld.Node, v ipld.Node, _ error) { return } func (itr *_Commit__MapItr) Done() bool { - return itr.idx >= 10 + return itr.idx >= 9 } func (Commit) ListIterator() ipld.ListIterator { return nil } func (Commit) Length() int64 { - return 10 + return 9 } func (Commit) IsAbsent() bool { return false @@ -491,7 +482,6 @@ type _Commit__Assembler struct { f int cm schema.Maybe - ca_DataSize _String__Assembler ca_GitTree _LinkTree__Assembler ca_Parents _ListParents__Assembler ca_Message _String__Assembler @@ -506,7 +496,6 @@ type _Commit__Assembler struct { func (na *_Commit__Assembler) reset() { na.state = maState_initial na.s = 0 - na.ca_DataSize.reset() na.ca_GitTree.reset() na.ca_Parents.reset() na.ca_Message.reset() @@ -519,17 +508,16 @@ func (na *_Commit__Assembler) reset() { } var ( - fieldBit__Commit_DataSize = 1 << 0 - fieldBit__Commit_GitTree = 1 << 1 - fieldBit__Commit_Parents = 1 << 2 - fieldBit__Commit_Message = 1 << 3 - fieldBit__Commit_Author = 1 << 4 - fieldBit__Commit_Committer = 1 << 5 - fieldBit__Commit_Encoding = 1 << 6 - fieldBit__Commit_Sig = 1 << 7 - fieldBit__Commit_MergeTag = 1 << 8 - fieldBit__Commit_Other = 1 << 9 - fieldBits__Commit_sufficient = 0 + 1<<0 + 1<<1 + 1<<2 + 1<<3 + 1<<8 + 1<<9 + fieldBit__Commit_GitTree = 1 << 0 + fieldBit__Commit_Parents = 1 << 1 + fieldBit__Commit_Message = 1 << 2 + fieldBit__Commit_Author = 1 << 3 + fieldBit__Commit_Committer = 1 << 4 + fieldBit__Commit_Encoding = 1 << 5 + fieldBit__Commit_Sig = 1 << 6 + fieldBit__Commit_MergeTag = 1 << 7 + fieldBit__Commit_Other = 1 << 8 + fieldBits__Commit_sufficient = 0 + 1<<0 + 1<<1 + 1<<2 + 1<<7 + 1<<8 ) func (na *_Commit__Assembler) BeginMap(int64) (ipld.MapAssembler, error) { @@ -624,16 +612,6 @@ func (_Commit__Assembler) Prototype() ipld.NodePrototype { func (ma *_Commit__Assembler) valueFinishTidy() bool { switch ma.f { case 0: - switch ma.cm { - case schema.Maybe_Value: - ma.ca_DataSize.w = nil - ma.cm = schema.Maybe_Absent - ma.state = maState_initial - return true - default: - return false - } - case 1: switch ma.cm { case schema.Maybe_Value: ma.ca_GitTree.w = nil @@ -643,7 +621,7 @@ func (ma *_Commit__Assembler) valueFinishTidy() bool { default: return false } - case 2: + case 1: switch ma.cm { case schema.Maybe_Value: ma.ca_Parents.w = nil @@ -653,7 +631,7 @@ func (ma *_Commit__Assembler) valueFinishTidy() bool { default: return false } - case 3: + case 2: switch ma.cm { case schema.Maybe_Value: ma.ca_Message.w = nil @@ -663,7 +641,7 @@ func (ma *_Commit__Assembler) valueFinishTidy() bool { default: return false } - case 4: + case 3: switch ma.w.Author.m { case schema.Maybe_Value: ma.w.Author.v = ma.ca_Author.w @@ -672,7 +650,7 @@ func (ma *_Commit__Assembler) valueFinishTidy() bool { default: return false } - case 5: + case 4: switch ma.w.Committer.m { case schema.Maybe_Value: ma.w.Committer.v = ma.ca_Committer.w @@ -681,7 +659,7 @@ func (ma *_Commit__Assembler) valueFinishTidy() bool { default: return false } - case 6: + case 5: switch ma.w.Encoding.m { case schema.Maybe_Value: ma.w.Encoding.v = ma.ca_Encoding.w @@ -690,7 +668,7 @@ func (ma *_Commit__Assembler) valueFinishTidy() bool { default: return false } - case 7: + case 6: switch ma.w.Sig.m { case schema.Maybe_Value: ma.w.Sig.v = ma.ca_Sig.w @@ -699,7 +677,7 @@ func (ma *_Commit__Assembler) valueFinishTidy() bool { default: return false } - case 8: + case 7: switch ma.cm { case schema.Maybe_Value: ma.ca_MergeTag.w = nil @@ -709,7 +687,7 @@ func (ma *_Commit__Assembler) valueFinishTidy() bool { default: return false } - case 9: + case 8: switch ma.cm { case schema.Maybe_Value: ma.ca_Other.w = nil @@ -739,109 +717,98 @@ func (ma *_Commit__Assembler) AssembleEntry(k string) (ipld.NodeAssembler, error panic("invalid state: AssembleEntry cannot be called on an assembler that's already finished") } switch k { - case "DataSize": - if ma.s&fieldBit__Commit_DataSize != 0 { - return nil, ipld.ErrRepeatedMapKey{&fieldName__Commit_DataSize} - } - ma.s += fieldBit__Commit_DataSize - ma.state = maState_midValue - ma.f = 0 - ma.ca_DataSize.w = &ma.w.DataSize - ma.ca_DataSize.m = &ma.cm - return &ma.ca_DataSize, nil case "GitTree": if ma.s&fieldBit__Commit_GitTree != 0 { - return nil, ipld.ErrRepeatedMapKey{&fieldName__Commit_GitTree} + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_GitTree} } ma.s += fieldBit__Commit_GitTree ma.state = maState_midValue - ma.f = 1 + ma.f = 0 ma.ca_GitTree.w = &ma.w.GitTree ma.ca_GitTree.m = &ma.cm return &ma.ca_GitTree, nil case "Parents": if ma.s&fieldBit__Commit_Parents != 0 { - return nil, ipld.ErrRepeatedMapKey{&fieldName__Commit_Parents} + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Parents} } ma.s += fieldBit__Commit_Parents ma.state = maState_midValue - ma.f = 2 + ma.f = 1 ma.ca_Parents.w = &ma.w.Parents ma.ca_Parents.m = &ma.cm return &ma.ca_Parents, nil case "Message": if ma.s&fieldBit__Commit_Message != 0 { - return nil, ipld.ErrRepeatedMapKey{&fieldName__Commit_Message} + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Message} } ma.s += fieldBit__Commit_Message ma.state = maState_midValue - ma.f = 3 + ma.f = 2 ma.ca_Message.w = &ma.w.Message ma.ca_Message.m = &ma.cm return &ma.ca_Message, nil case "Author": if ma.s&fieldBit__Commit_Author != 0 { - return nil, ipld.ErrRepeatedMapKey{&fieldName__Commit_Author} + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Author} } ma.s += fieldBit__Commit_Author ma.state = maState_midValue - ma.f = 4 + ma.f = 3 ma.ca_Author.w = ma.w.Author.v ma.ca_Author.m = &ma.w.Author.m return &ma.ca_Author, nil case "Committer": if ma.s&fieldBit__Commit_Committer != 0 { - return nil, ipld.ErrRepeatedMapKey{&fieldName__Commit_Committer} + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Committer} } ma.s += fieldBit__Commit_Committer ma.state = maState_midValue - ma.f = 5 + ma.f = 4 ma.ca_Committer.w = ma.w.Committer.v ma.ca_Committer.m = &ma.w.Committer.m return &ma.ca_Committer, nil case "Encoding": if ma.s&fieldBit__Commit_Encoding != 0 { - return nil, ipld.ErrRepeatedMapKey{&fieldName__Commit_Encoding} + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Encoding} } ma.s += fieldBit__Commit_Encoding ma.state = maState_midValue - ma.f = 6 + ma.f = 5 ma.ca_Encoding.w = ma.w.Encoding.v ma.ca_Encoding.m = &ma.w.Encoding.m return &ma.ca_Encoding, nil case "Sig": if ma.s&fieldBit__Commit_Sig != 0 { - return nil, ipld.ErrRepeatedMapKey{&fieldName__Commit_Sig} + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Sig} } ma.s += fieldBit__Commit_Sig ma.state = maState_midValue - ma.f = 7 + ma.f = 6 ma.ca_Sig.w = ma.w.Sig.v ma.ca_Sig.m = &ma.w.Sig.m return &ma.ca_Sig, nil case "MergeTag": if ma.s&fieldBit__Commit_MergeTag != 0 { - return nil, ipld.ErrRepeatedMapKey{&fieldName__Commit_MergeTag} + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_MergeTag} } ma.s += fieldBit__Commit_MergeTag ma.state = maState_midValue - ma.f = 8 + ma.f = 7 ma.ca_MergeTag.w = &ma.w.MergeTag ma.ca_MergeTag.m = &ma.cm return &ma.ca_MergeTag, nil case "Other": if ma.s&fieldBit__Commit_Other != 0 { - return nil, ipld.ErrRepeatedMapKey{&fieldName__Commit_Other} + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Other} } ma.s += fieldBit__Commit_Other ma.state = maState_midValue - ma.f = 9 + ma.f = 8 ma.ca_Other.w = &ma.w.Other ma.ca_Other.m = &ma.cm return &ma.ca_Other, nil - default: - return nil, ipld.ErrInvalidKey{TypeName: "ipldgit.Commit", Key: &_String{k}} } + return nil, ipld.ErrInvalidKey{TypeName: "ipldgit.Commit", Key: &_String{k}} } func (ma *_Commit__Assembler) AssembleKey() ipld.NodeAssembler { switch ma.state { @@ -877,42 +844,38 @@ func (ma *_Commit__Assembler) AssembleValue() ipld.NodeAssembler { ma.state = maState_midValue switch ma.f { case 0: - ma.ca_DataSize.w = &ma.w.DataSize - ma.ca_DataSize.m = &ma.cm - return &ma.ca_DataSize - case 1: ma.ca_GitTree.w = &ma.w.GitTree ma.ca_GitTree.m = &ma.cm return &ma.ca_GitTree - case 2: + case 1: ma.ca_Parents.w = &ma.w.Parents ma.ca_Parents.m = &ma.cm return &ma.ca_Parents - case 3: + case 2: ma.ca_Message.w = &ma.w.Message ma.ca_Message.m = &ma.cm return &ma.ca_Message - case 4: + case 3: ma.ca_Author.w = ma.w.Author.v ma.ca_Author.m = &ma.w.Author.m return &ma.ca_Author - case 5: + case 4: ma.ca_Committer.w = ma.w.Committer.v ma.ca_Committer.m = &ma.w.Committer.m return &ma.ca_Committer - case 6: + case 5: ma.ca_Encoding.w = ma.w.Encoding.v ma.ca_Encoding.m = &ma.w.Encoding.m return &ma.ca_Encoding - case 7: + case 6: ma.ca_Sig.w = ma.w.Sig.v ma.ca_Sig.m = &ma.w.Sig.m return &ma.ca_Sig - case 8: + case 7: ma.ca_MergeTag.w = &ma.w.MergeTag ma.ca_MergeTag.m = &ma.cm return &ma.ca_MergeTag - case 9: + case 8: ma.ca_Other.w = &ma.w.Other ma.ca_Other.m = &ma.cm return &ma.ca_Other @@ -937,9 +900,6 @@ func (ma *_Commit__Assembler) Finish() error { } if ma.s&fieldBits__Commit_sufficient != fieldBits__Commit_sufficient { err := ipld.ErrMissingRequiredField{Missing: make([]string, 0)} - if ma.s&fieldBit__Commit_DataSize == 0 { - err.Missing = append(err.Missing, "DataSize") - } if ma.s&fieldBit__Commit_GitTree == 0 { err.Missing = append(err.Missing, "GitTree") } @@ -993,76 +953,69 @@ func (ka *_Commit__KeyAssembler) AssignString(k string) error { panic("misuse: KeyAssembler held beyond its valid lifetime") } switch k { - case "DataSize": - if ka.s&fieldBit__Commit_DataSize != 0 { - return ipld.ErrRepeatedMapKey{&fieldName__Commit_DataSize} - } - ka.s += fieldBit__Commit_DataSize - ka.state = maState_expectValue - ka.f = 0 case "GitTree": if ka.s&fieldBit__Commit_GitTree != 0 { - return ipld.ErrRepeatedMapKey{&fieldName__Commit_GitTree} + return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_GitTree} } ka.s += fieldBit__Commit_GitTree ka.state = maState_expectValue - ka.f = 1 + ka.f = 0 case "Parents": if ka.s&fieldBit__Commit_Parents != 0 { - return ipld.ErrRepeatedMapKey{&fieldName__Commit_Parents} + return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Parents} } ka.s += fieldBit__Commit_Parents ka.state = maState_expectValue - ka.f = 2 + ka.f = 1 case "Message": if ka.s&fieldBit__Commit_Message != 0 { - return ipld.ErrRepeatedMapKey{&fieldName__Commit_Message} + return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Message} } ka.s += fieldBit__Commit_Message ka.state = maState_expectValue - ka.f = 3 + ka.f = 2 case "Author": if ka.s&fieldBit__Commit_Author != 0 { - return ipld.ErrRepeatedMapKey{&fieldName__Commit_Author} + return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Author} } ka.s += fieldBit__Commit_Author ka.state = maState_expectValue - ka.f = 4 + ka.f = 3 case "Committer": if ka.s&fieldBit__Commit_Committer != 0 { - return ipld.ErrRepeatedMapKey{&fieldName__Commit_Committer} + return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Committer} } ka.s += fieldBit__Commit_Committer ka.state = maState_expectValue - ka.f = 5 + ka.f = 4 case "Encoding": if ka.s&fieldBit__Commit_Encoding != 0 { - return ipld.ErrRepeatedMapKey{&fieldName__Commit_Encoding} + return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Encoding} } ka.s += fieldBit__Commit_Encoding ka.state = maState_expectValue - ka.f = 6 + ka.f = 5 case "Sig": if ka.s&fieldBit__Commit_Sig != 0 { - return ipld.ErrRepeatedMapKey{&fieldName__Commit_Sig} + return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Sig} } ka.s += fieldBit__Commit_Sig ka.state = maState_expectValue - ka.f = 7 + ka.f = 6 case "MergeTag": if ka.s&fieldBit__Commit_MergeTag != 0 { - return ipld.ErrRepeatedMapKey{&fieldName__Commit_MergeTag} + return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_MergeTag} } ka.s += fieldBit__Commit_MergeTag ka.state = maState_expectValue - ka.f = 8 + ka.f = 7 case "Other": if ka.s&fieldBit__Commit_Other != 0 { - return ipld.ErrRepeatedMapKey{&fieldName__Commit_Other} + return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Other} } ka.s += fieldBit__Commit_Other ka.state = maState_expectValue - ka.f = 9 + ka.f = 8 default: return ipld.ErrInvalidKey{TypeName: "ipldgit.Commit", Key: &_String{k}} } @@ -1094,7 +1047,6 @@ func (n Commit) Representation() ipld.Node { type _Commit__Repr _Commit var ( - fieldName__Commit_DataSize_serial = _String{"DataSize"} fieldName__Commit_GitTree_serial = _String{"GitTree"} fieldName__Commit_Parents_serial = _String{"Parents"} fieldName__Commit_Message_serial = _String{"Message"} @@ -1112,8 +1064,6 @@ func (_Commit__Repr) Kind() ipld.Kind { } func (n *_Commit__Repr) LookupByString(key string) (ipld.Node, error) { switch key { - case "DataSize": - return n.DataSize.Representation(), nil case "GitTree": return n.GitTree.Representation(), nil case "Parents": @@ -1122,22 +1072,22 @@ func (n *_Commit__Repr) LookupByString(key string) (ipld.Node, error) { return n.Message.Representation(), nil case "Author": if n.Author.m == schema.Maybe_Absent { - return ipld.Absent, ipld.ErrNotExists{ipld.PathSegmentOfString(key)} + return ipld.Absent, ipld.ErrNotExists{Segment: ipld.PathSegmentOfString(key)} } return n.Author.v.Representation(), nil case "Committer": if n.Committer.m == schema.Maybe_Absent { - return ipld.Absent, ipld.ErrNotExists{ipld.PathSegmentOfString(key)} + return ipld.Absent, ipld.ErrNotExists{Segment: ipld.PathSegmentOfString(key)} } return n.Committer.v.Representation(), nil case "Encoding": if n.Encoding.m == schema.Maybe_Absent { - return ipld.Absent, ipld.ErrNotExists{ipld.PathSegmentOfString(key)} + return ipld.Absent, ipld.ErrNotExists{Segment: ipld.PathSegmentOfString(key)} } return n.Encoding.v.Representation(), nil case "Sig": if n.Sig.m == schema.Maybe_Absent { - return ipld.Absent, ipld.ErrNotExists{ipld.PathSegmentOfString(key)} + return ipld.Absent, ipld.ErrNotExists{Segment: ipld.PathSegmentOfString(key)} } return n.Sig.v.Representation(), nil case "MergeTag": @@ -1172,54 +1122,51 @@ type _Commit__ReprMapItr struct { func (itr *_Commit__ReprMapItr) Next() (k ipld.Node, v ipld.Node, _ error) { advance: - if itr.idx >= 10 { + if itr.idx >= 9 { return nil, nil, ipld.ErrIteratorOverread{} } switch itr.idx { case 0: - k = &fieldName__Commit_DataSize_serial - v = itr.n.DataSize.Representation() - case 1: k = &fieldName__Commit_GitTree_serial v = itr.n.GitTree.Representation() - case 2: + case 1: k = &fieldName__Commit_Parents_serial v = itr.n.Parents.Representation() - case 3: + case 2: k = &fieldName__Commit_Message_serial v = itr.n.Message.Representation() - case 4: + case 3: k = &fieldName__Commit_Author_serial if itr.n.Author.m == schema.Maybe_Absent { itr.idx++ goto advance } v = itr.n.Author.v.Representation() - case 5: + case 4: k = &fieldName__Commit_Committer_serial if itr.n.Committer.m == schema.Maybe_Absent { itr.idx++ goto advance } v = itr.n.Committer.v.Representation() - case 6: + case 5: k = &fieldName__Commit_Encoding_serial if itr.n.Encoding.m == schema.Maybe_Absent { itr.idx++ goto advance } v = itr.n.Encoding.v.Representation() - case 7: + case 6: k = &fieldName__Commit_Sig_serial if itr.n.Sig.m == schema.Maybe_Absent { itr.idx++ goto advance } v = itr.n.Sig.v.Representation() - case 8: + case 7: k = &fieldName__Commit_MergeTag_serial v = itr.n.MergeTag.Representation() - case 9: + case 8: k = &fieldName__Commit_Other_serial v = itr.n.Other.Representation() default: @@ -1229,13 +1176,13 @@ advance: return } func (itr *_Commit__ReprMapItr) Done() bool { - return itr.idx >= 10 + return itr.idx >= 9 } func (_Commit__Repr) ListIterator() ipld.ListIterator { return nil } func (rn *_Commit__Repr) Length() int64 { - l := 10 + l := 9 if rn.Author.m == schema.Maybe_Absent { l-- } @@ -1310,7 +1257,6 @@ type _Commit__ReprAssembler struct { f int cm schema.Maybe - ca_DataSize _String__ReprAssembler ca_GitTree _LinkTree__ReprAssembler ca_Parents _ListParents__ReprAssembler ca_Message _String__ReprAssembler @@ -1325,7 +1271,6 @@ type _Commit__ReprAssembler struct { func (na *_Commit__ReprAssembler) reset() { na.state = maState_initial na.s = 0 - na.ca_DataSize.reset() na.ca_GitTree.reset() na.ca_Parents.reset() na.ca_Message.reset() @@ -1455,15 +1400,6 @@ func (ma *_Commit__ReprAssembler) valueFinishTidy() bool { return false } case 3: - switch ma.cm { - case schema.Maybe_Value: - ma.cm = schema.Maybe_Absent - ma.state = maState_initial - return true - default: - return false - } - case 4: switch ma.w.Author.m { case schema.Maybe_Value: ma.w.Author.v = ma.ca_Author.w @@ -1472,7 +1408,7 @@ func (ma *_Commit__ReprAssembler) valueFinishTidy() bool { default: return false } - case 5: + case 4: switch ma.w.Committer.m { case schema.Maybe_Value: ma.w.Committer.v = ma.ca_Committer.w @@ -1481,7 +1417,7 @@ func (ma *_Commit__ReprAssembler) valueFinishTidy() bool { default: return false } - case 6: + case 5: switch ma.w.Encoding.m { case schema.Maybe_Value: ma.w.Encoding.v = ma.ca_Encoding.w @@ -1490,7 +1426,7 @@ func (ma *_Commit__ReprAssembler) valueFinishTidy() bool { default: return false } - case 7: + case 6: switch ma.w.Sig.m { case schema.Maybe_Value: ma.w.Sig.v = ma.ca_Sig.w @@ -1499,7 +1435,7 @@ func (ma *_Commit__ReprAssembler) valueFinishTidy() bool { default: return false } - case 8: + case 7: switch ma.cm { case schema.Maybe_Value: ma.cm = schema.Maybe_Absent @@ -1508,7 +1444,7 @@ func (ma *_Commit__ReprAssembler) valueFinishTidy() bool { default: return false } - case 9: + case 8: switch ma.cm { case schema.Maybe_Value: ma.cm = schema.Maybe_Absent @@ -1537,113 +1473,103 @@ func (ma *_Commit__ReprAssembler) AssembleEntry(k string) (ipld.NodeAssembler, e panic("invalid state: AssembleEntry cannot be called on an assembler that's already finished") } switch k { - case "DataSize": - if ma.s&fieldBit__Commit_DataSize != 0 { - return nil, ipld.ErrRepeatedMapKey{&fieldName__Commit_DataSize_serial} - } - ma.s += fieldBit__Commit_DataSize - ma.state = maState_midValue - ma.f = 0 - ma.ca_DataSize.w = &ma.w.DataSize - ma.ca_DataSize.m = &ma.cm - return &ma.ca_DataSize, nil case "GitTree": if ma.s&fieldBit__Commit_GitTree != 0 { - return nil, ipld.ErrRepeatedMapKey{&fieldName__Commit_GitTree_serial} + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_GitTree_serial} } ma.s += fieldBit__Commit_GitTree ma.state = maState_midValue - ma.f = 1 + ma.f = 0 ma.ca_GitTree.w = &ma.w.GitTree ma.ca_GitTree.m = &ma.cm return &ma.ca_GitTree, nil case "Parents": if ma.s&fieldBit__Commit_Parents != 0 { - return nil, ipld.ErrRepeatedMapKey{&fieldName__Commit_Parents_serial} + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Parents_serial} } ma.s += fieldBit__Commit_Parents ma.state = maState_midValue - ma.f = 2 + ma.f = 1 ma.ca_Parents.w = &ma.w.Parents ma.ca_Parents.m = &ma.cm return &ma.ca_Parents, nil case "Message": if ma.s&fieldBit__Commit_Message != 0 { - return nil, ipld.ErrRepeatedMapKey{&fieldName__Commit_Message_serial} + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Message_serial} } ma.s += fieldBit__Commit_Message ma.state = maState_midValue - ma.f = 3 + ma.f = 2 ma.ca_Message.w = &ma.w.Message ma.ca_Message.m = &ma.cm return &ma.ca_Message, nil case "Author": if ma.s&fieldBit__Commit_Author != 0 { - return nil, ipld.ErrRepeatedMapKey{&fieldName__Commit_Author_serial} + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Author_serial} } ma.s += fieldBit__Commit_Author ma.state = maState_midValue - ma.f = 4 + ma.f = 3 ma.ca_Author.w = ma.w.Author.v ma.ca_Author.m = &ma.w.Author.m return &ma.ca_Author, nil case "Committer": if ma.s&fieldBit__Commit_Committer != 0 { - return nil, ipld.ErrRepeatedMapKey{&fieldName__Commit_Committer_serial} + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Committer_serial} } ma.s += fieldBit__Commit_Committer ma.state = maState_midValue - ma.f = 5 + ma.f = 4 ma.ca_Committer.w = ma.w.Committer.v ma.ca_Committer.m = &ma.w.Committer.m return &ma.ca_Committer, nil case "Encoding": if ma.s&fieldBit__Commit_Encoding != 0 { - return nil, ipld.ErrRepeatedMapKey{&fieldName__Commit_Encoding_serial} + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Encoding_serial} } ma.s += fieldBit__Commit_Encoding ma.state = maState_midValue - ma.f = 6 + ma.f = 5 ma.ca_Encoding.w = ma.w.Encoding.v ma.ca_Encoding.m = &ma.w.Encoding.m return &ma.ca_Encoding, nil case "Sig": if ma.s&fieldBit__Commit_Sig != 0 { - return nil, ipld.ErrRepeatedMapKey{&fieldName__Commit_Sig_serial} + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Sig_serial} } ma.s += fieldBit__Commit_Sig ma.state = maState_midValue - ma.f = 7 + ma.f = 6 ma.ca_Sig.w = ma.w.Sig.v ma.ca_Sig.m = &ma.w.Sig.m return &ma.ca_Sig, nil case "MergeTag": if ma.s&fieldBit__Commit_MergeTag != 0 { - return nil, ipld.ErrRepeatedMapKey{&fieldName__Commit_MergeTag_serial} + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_MergeTag_serial} } ma.s += fieldBit__Commit_MergeTag ma.state = maState_midValue - ma.f = 8 + ma.f = 7 ma.ca_MergeTag.w = &ma.w.MergeTag ma.ca_MergeTag.m = &ma.cm return &ma.ca_MergeTag, nil case "Other": if ma.s&fieldBit__Commit_Other != 0 { - return nil, ipld.ErrRepeatedMapKey{&fieldName__Commit_Other_serial} + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Other_serial} } ma.s += fieldBit__Commit_Other ma.state = maState_midValue - ma.f = 9 + ma.f = 8 ma.ca_Other.w = &ma.w.Other ma.ca_Other.m = &ma.cm return &ma.ca_Other, nil default: - return nil, ipld.ErrInvalidKey{TypeName: "ipldgit.Commit.Repr", Key: &_String{k}} } + return nil, ipld.ErrInvalidKey{TypeName: "ipldgit.Commit.Repr", Key: &_String{k}} } func (ma *_Commit__ReprAssembler) AssembleKey() ipld.NodeAssembler { switch ma.state { @@ -1679,46 +1605,42 @@ func (ma *_Commit__ReprAssembler) AssembleValue() ipld.NodeAssembler { ma.state = maState_midValue switch ma.f { case 0: - ma.ca_DataSize.w = &ma.w.DataSize - ma.ca_DataSize.m = &ma.cm - return &ma.ca_DataSize - case 1: ma.ca_GitTree.w = &ma.w.GitTree ma.ca_GitTree.m = &ma.cm return &ma.ca_GitTree - case 2: + case 1: ma.ca_Parents.w = &ma.w.Parents ma.ca_Parents.m = &ma.cm return &ma.ca_Parents - case 3: + case 2: ma.ca_Message.w = &ma.w.Message ma.ca_Message.m = &ma.cm return &ma.ca_Message - case 4: + case 3: ma.ca_Author.w = ma.w.Author.v ma.ca_Author.m = &ma.w.Author.m return &ma.ca_Author - case 5: + case 4: ma.ca_Committer.w = ma.w.Committer.v ma.ca_Committer.m = &ma.w.Committer.m return &ma.ca_Committer - case 6: + case 5: ma.ca_Encoding.w = ma.w.Encoding.v ma.ca_Encoding.m = &ma.w.Encoding.m return &ma.ca_Encoding - case 7: + case 6: ma.ca_Sig.w = ma.w.Sig.v ma.ca_Sig.m = &ma.w.Sig.m return &ma.ca_Sig - case 8: + case 7: ma.ca_MergeTag.w = &ma.w.MergeTag ma.ca_MergeTag.m = &ma.cm return &ma.ca_MergeTag - case 9: + case 8: ma.ca_Other.w = &ma.w.Other ma.ca_Other.m = &ma.cm return &ma.ca_Other @@ -1743,9 +1665,6 @@ func (ma *_Commit__ReprAssembler) Finish() error { } if ma.s&fieldBits__Commit_sufficient != fieldBits__Commit_sufficient { err := ipld.ErrMissingRequiredField{Missing: make([]string, 0)} - if ma.s&fieldBit__Commit_DataSize == 0 { - err.Missing = append(err.Missing, "DataSize") - } if ma.s&fieldBit__Commit_GitTree == 0 { err.Missing = append(err.Missing, "GitTree") } @@ -1799,80 +1718,80 @@ func (ka *_Commit__ReprKeyAssembler) AssignString(k string) error { panic("misuse: KeyAssembler held beyond its valid lifetime") } switch k { - case "DataSize": - if ka.s&fieldBit__Commit_DataSize != 0 { - return ipld.ErrRepeatedMapKey{&fieldName__Commit_DataSize_serial} - } - ka.s += fieldBit__Commit_DataSize - ka.state = maState_expectValue - ka.f = 0 case "GitTree": if ka.s&fieldBit__Commit_GitTree != 0 { - return ipld.ErrRepeatedMapKey{&fieldName__Commit_GitTree_serial} + return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_GitTree_serial} } ka.s += fieldBit__Commit_GitTree ka.state = maState_expectValue - ka.f = 1 + ka.f = 0 + return nil case "Parents": if ka.s&fieldBit__Commit_Parents != 0 { - return ipld.ErrRepeatedMapKey{&fieldName__Commit_Parents_serial} + return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Parents_serial} } ka.s += fieldBit__Commit_Parents ka.state = maState_expectValue - ka.f = 2 + ka.f = 1 + return nil case "Message": if ka.s&fieldBit__Commit_Message != 0 { - return ipld.ErrRepeatedMapKey{&fieldName__Commit_Message_serial} + return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Message_serial} } ka.s += fieldBit__Commit_Message ka.state = maState_expectValue - ka.f = 3 + ka.f = 2 + return nil case "Author": if ka.s&fieldBit__Commit_Author != 0 { - return ipld.ErrRepeatedMapKey{&fieldName__Commit_Author_serial} + return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Author_serial} } ka.s += fieldBit__Commit_Author ka.state = maState_expectValue - ka.f = 4 + ka.f = 3 + return nil case "Committer": if ka.s&fieldBit__Commit_Committer != 0 { - return ipld.ErrRepeatedMapKey{&fieldName__Commit_Committer_serial} + return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Committer_serial} } ka.s += fieldBit__Commit_Committer ka.state = maState_expectValue - ka.f = 5 + ka.f = 4 + return nil case "Encoding": if ka.s&fieldBit__Commit_Encoding != 0 { - return ipld.ErrRepeatedMapKey{&fieldName__Commit_Encoding_serial} + return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Encoding_serial} } ka.s += fieldBit__Commit_Encoding ka.state = maState_expectValue - ka.f = 6 + ka.f = 5 + return nil case "Sig": if ka.s&fieldBit__Commit_Sig != 0 { - return ipld.ErrRepeatedMapKey{&fieldName__Commit_Sig_serial} + return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Sig_serial} } ka.s += fieldBit__Commit_Sig ka.state = maState_expectValue - ka.f = 7 + ka.f = 6 + return nil case "MergeTag": if ka.s&fieldBit__Commit_MergeTag != 0 { - return ipld.ErrRepeatedMapKey{&fieldName__Commit_MergeTag_serial} + return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_MergeTag_serial} } ka.s += fieldBit__Commit_MergeTag ka.state = maState_expectValue - ka.f = 8 + ka.f = 7 + return nil case "Other": if ka.s&fieldBit__Commit_Other != 0 { - return ipld.ErrRepeatedMapKey{&fieldName__Commit_Other_serial} + return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Other_serial} } ka.s += fieldBit__Commit_Other ka.state = maState_expectValue - ka.f = 9 - default: - return ipld.ErrInvalidKey{TypeName: "ipldgit.Commit.Repr", Key: &_String{k}} + ka.f = 8 + return nil } - return nil + return ipld.ErrInvalidKey{TypeName: "ipldgit.Commit.Repr", Key: &_String{k}} } func (_Commit__ReprKeyAssembler) AssignBytes([]byte) error { return mixins.StringAssembler{"ipldgit.Commit.Repr.KeyAssembler"}.AssignBytes(nil) @@ -2631,7 +2550,7 @@ func (n ListParents) LookupByNode(k ipld.Node) (ipld.Node, error) { } func (n ListParents) LookupByIndex(idx int64) (ipld.Node, error) { if n.Length() <= idx { - return nil, ipld.ErrNotExists{ipld.PathSegmentOfInt(idx)} + return nil, ipld.ErrNotExists{Segment: ipld.PathSegmentOfInt(idx)} } v := &n.x[idx] return v, nil @@ -3238,7 +3157,7 @@ func (n ListString) LookupByNode(k ipld.Node) (ipld.Node, error) { } func (n ListString) LookupByIndex(idx int64) (ipld.Node, error) { if n.Length() <= idx { - return nil, ipld.ErrNotExists{ipld.PathSegmentOfInt(idx)} + return nil, ipld.ErrNotExists{Segment: ipld.PathSegmentOfInt(idx)} } v := &n.x[idx] return v, nil @@ -3845,7 +3764,7 @@ func (n ListTag) LookupByNode(k ipld.Node) (ipld.Node, error) { } func (n ListTag) LookupByIndex(idx int64) (ipld.Node, error) { if n.Length() <= idx { - return nil, ipld.ErrNotExists{ipld.PathSegmentOfInt(idx)} + return nil, ipld.ErrNotExists{Segment: ipld.PathSegmentOfInt(idx)} } v := &n.x[idx] return v, nil @@ -4722,7 +4641,7 @@ func (ma *_PersonInfo__Assembler) AssembleEntry(k string) (ipld.NodeAssembler, e switch k { case "Name": if ma.s&fieldBit__PersonInfo_Name != 0 { - return nil, ipld.ErrRepeatedMapKey{&fieldName__PersonInfo_Name} + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Name} } ma.s += fieldBit__PersonInfo_Name ma.state = maState_midValue @@ -4732,7 +4651,7 @@ func (ma *_PersonInfo__Assembler) AssembleEntry(k string) (ipld.NodeAssembler, e return &ma.ca_Name, nil case "Email": if ma.s&fieldBit__PersonInfo_Email != 0 { - return nil, ipld.ErrRepeatedMapKey{&fieldName__PersonInfo_Email} + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Email} } ma.s += fieldBit__PersonInfo_Email ma.state = maState_midValue @@ -4742,7 +4661,7 @@ func (ma *_PersonInfo__Assembler) AssembleEntry(k string) (ipld.NodeAssembler, e return &ma.ca_Email, nil case "Date": if ma.s&fieldBit__PersonInfo_Date != 0 { - return nil, ipld.ErrRepeatedMapKey{&fieldName__PersonInfo_Date} + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Date} } ma.s += fieldBit__PersonInfo_Date ma.state = maState_midValue @@ -4752,7 +4671,7 @@ func (ma *_PersonInfo__Assembler) AssembleEntry(k string) (ipld.NodeAssembler, e return &ma.ca_Date, nil case "Timezone": if ma.s&fieldBit__PersonInfo_Timezone != 0 { - return nil, ipld.ErrRepeatedMapKey{&fieldName__PersonInfo_Timezone} + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Timezone} } ma.s += fieldBit__PersonInfo_Timezone ma.state = maState_midValue @@ -4760,9 +4679,8 @@ func (ma *_PersonInfo__Assembler) AssembleEntry(k string) (ipld.NodeAssembler, e ma.ca_Timezone.w = &ma.w.Timezone ma.ca_Timezone.m = &ma.cm return &ma.ca_Timezone, nil - default: - return nil, ipld.ErrInvalidKey{TypeName: "ipldgit.PersonInfo", Key: &_String{k}} } + return nil, ipld.ErrInvalidKey{TypeName: "ipldgit.PersonInfo", Key: &_String{k}} } func (ma *_PersonInfo__Assembler) AssembleKey() ipld.NodeAssembler { switch ma.state { @@ -4886,28 +4804,28 @@ func (ka *_PersonInfo__KeyAssembler) AssignString(k string) error { switch k { case "Name": if ka.s&fieldBit__PersonInfo_Name != 0 { - return ipld.ErrRepeatedMapKey{&fieldName__PersonInfo_Name} + return ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Name} } ka.s += fieldBit__PersonInfo_Name ka.state = maState_expectValue ka.f = 0 case "Email": if ka.s&fieldBit__PersonInfo_Email != 0 { - return ipld.ErrRepeatedMapKey{&fieldName__PersonInfo_Email} + return ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Email} } ka.s += fieldBit__PersonInfo_Email ka.state = maState_expectValue ka.f = 1 case "Date": if ka.s&fieldBit__PersonInfo_Date != 0 { - return ipld.ErrRepeatedMapKey{&fieldName__PersonInfo_Date} + return ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Date} } ka.s += fieldBit__PersonInfo_Date ka.state = maState_expectValue ka.f = 2 case "Timezone": if ka.s&fieldBit__PersonInfo_Timezone != 0 { - return ipld.ErrRepeatedMapKey{&fieldName__PersonInfo_Timezone} + return ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Timezone} } ka.s += fieldBit__PersonInfo_Timezone ka.state = maState_expectValue @@ -5358,9 +5276,6 @@ func (n _Tag) FieldTagger() PersonInfo { func (n _Tag) FieldText() String { return &n.Text } -func (n _Tag) FieldDataSize() MaybeString { - return &n.DataSize -} type _Tag__Maybe struct { m schema.Maybe @@ -5397,12 +5312,11 @@ func (m MaybeTag) Must() Tag { } var ( - fieldName__Tag_Object = _String{"Object"} - fieldName__Tag_TagType = _String{"TagType"} - fieldName__Tag_Tag = _String{"Tag"} - fieldName__Tag_Tagger = _String{"Tagger"} - fieldName__Tag_Text = _String{"Text"} - fieldName__Tag_DataSize = _String{"DataSize"} + fieldName__Tag_Object = _String{"Object"} + fieldName__Tag_TagType = _String{"TagType"} + fieldName__Tag_Tag = _String{"Tag"} + fieldName__Tag_Tagger = _String{"Tagger"} + fieldName__Tag_Text = _String{"Text"} ) var _ ipld.Node = (Tag)(&_Tag{}) var _ schema.TypedNode = (Tag)(&_Tag{}) @@ -5422,11 +5336,6 @@ func (n Tag) LookupByString(key string) (ipld.Node, error) { return &n.Tagger, nil case "Text": return &n.Text, nil - case "DataSize": - if n.DataSize.m == schema.Maybe_Absent { - return ipld.Absent, nil - } - return n.DataSize.v, nil default: return nil, schema.ErrNoSuchField{Type: nil /*TODO*/, Field: ipld.PathSegmentOfString(key)} } @@ -5454,7 +5363,7 @@ type _Tag__MapItr struct { } func (itr *_Tag__MapItr) Next() (k ipld.Node, v ipld.Node, _ error) { - if itr.idx >= 6 { + if itr.idx >= 5 { return nil, nil, ipld.ErrIteratorOverread{} } switch itr.idx { @@ -5473,13 +5382,6 @@ func (itr *_Tag__MapItr) Next() (k ipld.Node, v ipld.Node, _ error) { case 4: k = &fieldName__Tag_Text v = &itr.n.Text - case 5: - k = &fieldName__Tag_DataSize - if itr.n.DataSize.m == schema.Maybe_Absent { - v = ipld.Absent - break - } - v = itr.n.DataSize.v default: panic("unreachable") } @@ -5487,14 +5389,14 @@ func (itr *_Tag__MapItr) Next() (k ipld.Node, v ipld.Node, _ error) { return } func (itr *_Tag__MapItr) Done() bool { - return itr.idx >= 6 + return itr.idx >= 5 } func (Tag) ListIterator() ipld.ListIterator { return nil } func (Tag) Length() int64 { - return 6 + return 5 } func (Tag) IsAbsent() bool { return false @@ -5555,13 +5457,12 @@ type _Tag__Assembler struct { s int f int - cm schema.Maybe - ca_Object _Link__Assembler - ca_TagType _String__Assembler - ca_Tag _String__Assembler - ca_Tagger _PersonInfo__Assembler - ca_Text _String__Assembler - ca_DataSize _String__Assembler + cm schema.Maybe + ca_Object _Link__Assembler + ca_TagType _String__Assembler + ca_Tag _String__Assembler + ca_Tagger _PersonInfo__Assembler + ca_Text _String__Assembler } func (na *_Tag__Assembler) reset() { @@ -5572,7 +5473,6 @@ func (na *_Tag__Assembler) reset() { na.ca_Tag.reset() na.ca_Tagger.reset() na.ca_Text.reset() - na.ca_DataSize.reset() } var ( @@ -5581,7 +5481,6 @@ var ( fieldBit__Tag_Tag = 1 << 2 fieldBit__Tag_Tagger = 1 << 3 fieldBit__Tag_Text = 1 << 4 - fieldBit__Tag_DataSize = 1 << 5 fieldBits__Tag_sufficient = 0 + 1<<0 + 1<<1 + 1<<2 + 1<<3 + 1<<4 ) @@ -5726,15 +5625,6 @@ func (ma *_Tag__Assembler) valueFinishTidy() bool { default: return false } - case 5: - switch ma.w.DataSize.m { - case schema.Maybe_Value: - ma.w.DataSize.v = ma.ca_DataSize.w - ma.state = maState_initial - return true - default: - return false - } default: panic("unreachable") } @@ -5757,7 +5647,7 @@ func (ma *_Tag__Assembler) AssembleEntry(k string) (ipld.NodeAssembler, error) { switch k { case "Object": if ma.s&fieldBit__Tag_Object != 0 { - return nil, ipld.ErrRepeatedMapKey{&fieldName__Tag_Object} + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Object} } ma.s += fieldBit__Tag_Object ma.state = maState_midValue @@ -5767,7 +5657,7 @@ func (ma *_Tag__Assembler) AssembleEntry(k string) (ipld.NodeAssembler, error) { return &ma.ca_Object, nil case "TagType": if ma.s&fieldBit__Tag_TagType != 0 { - return nil, ipld.ErrRepeatedMapKey{&fieldName__Tag_TagType} + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_TagType} } ma.s += fieldBit__Tag_TagType ma.state = maState_midValue @@ -5777,7 +5667,7 @@ func (ma *_Tag__Assembler) AssembleEntry(k string) (ipld.NodeAssembler, error) { return &ma.ca_TagType, nil case "Tag": if ma.s&fieldBit__Tag_Tag != 0 { - return nil, ipld.ErrRepeatedMapKey{&fieldName__Tag_Tag} + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Tag} } ma.s += fieldBit__Tag_Tag ma.state = maState_midValue @@ -5787,7 +5677,7 @@ func (ma *_Tag__Assembler) AssembleEntry(k string) (ipld.NodeAssembler, error) { return &ma.ca_Tag, nil case "Tagger": if ma.s&fieldBit__Tag_Tagger != 0 { - return nil, ipld.ErrRepeatedMapKey{&fieldName__Tag_Tagger} + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Tagger} } ma.s += fieldBit__Tag_Tagger ma.state = maState_midValue @@ -5797,7 +5687,7 @@ func (ma *_Tag__Assembler) AssembleEntry(k string) (ipld.NodeAssembler, error) { return &ma.ca_Tagger, nil case "Text": if ma.s&fieldBit__Tag_Text != 0 { - return nil, ipld.ErrRepeatedMapKey{&fieldName__Tag_Text} + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Text} } ma.s += fieldBit__Tag_Text ma.state = maState_midValue @@ -5805,19 +5695,8 @@ func (ma *_Tag__Assembler) AssembleEntry(k string) (ipld.NodeAssembler, error) { ma.ca_Text.w = &ma.w.Text ma.ca_Text.m = &ma.cm return &ma.ca_Text, nil - case "DataSize": - if ma.s&fieldBit__Tag_DataSize != 0 { - return nil, ipld.ErrRepeatedMapKey{&fieldName__Tag_DataSize} - } - ma.s += fieldBit__Tag_DataSize - ma.state = maState_midValue - ma.f = 5 - ma.ca_DataSize.w = ma.w.DataSize.v - ma.ca_DataSize.m = &ma.w.DataSize.m - return &ma.ca_DataSize, nil - default: - return nil, ipld.ErrInvalidKey{TypeName: "ipldgit.Tag", Key: &_String{k}} } + return nil, ipld.ErrInvalidKey{TypeName: "ipldgit.Tag", Key: &_String{k}} } func (ma *_Tag__Assembler) AssembleKey() ipld.NodeAssembler { switch ma.state { @@ -5872,10 +5751,6 @@ func (ma *_Tag__Assembler) AssembleValue() ipld.NodeAssembler { ma.ca_Text.w = &ma.w.Text ma.ca_Text.m = &ma.cm return &ma.ca_Text - case 5: - ma.ca_DataSize.w = ma.w.DataSize.v - ma.ca_DataSize.m = &ma.w.DataSize.m - return &ma.ca_DataSize default: panic("unreachable") } @@ -5952,46 +5827,39 @@ func (ka *_Tag__KeyAssembler) AssignString(k string) error { switch k { case "Object": if ka.s&fieldBit__Tag_Object != 0 { - return ipld.ErrRepeatedMapKey{&fieldName__Tag_Object} + return ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Object} } ka.s += fieldBit__Tag_Object ka.state = maState_expectValue ka.f = 0 case "TagType": if ka.s&fieldBit__Tag_TagType != 0 { - return ipld.ErrRepeatedMapKey{&fieldName__Tag_TagType} + return ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_TagType} } ka.s += fieldBit__Tag_TagType ka.state = maState_expectValue ka.f = 1 case "Tag": if ka.s&fieldBit__Tag_Tag != 0 { - return ipld.ErrRepeatedMapKey{&fieldName__Tag_Tag} + return ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Tag} } ka.s += fieldBit__Tag_Tag ka.state = maState_expectValue ka.f = 2 case "Tagger": if ka.s&fieldBit__Tag_Tagger != 0 { - return ipld.ErrRepeatedMapKey{&fieldName__Tag_Tagger} + return ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Tagger} } ka.s += fieldBit__Tag_Tagger ka.state = maState_expectValue ka.f = 3 case "Text": if ka.s&fieldBit__Tag_Text != 0 { - return ipld.ErrRepeatedMapKey{&fieldName__Tag_Text} + return ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Text} } ka.s += fieldBit__Tag_Text ka.state = maState_expectValue ka.f = 4 - case "DataSize": - if ka.s&fieldBit__Tag_DataSize != 0 { - return ipld.ErrRepeatedMapKey{&fieldName__Tag_DataSize} - } - ka.s += fieldBit__Tag_DataSize - ka.state = maState_expectValue - ka.f = 5 default: return ipld.ErrInvalidKey{TypeName: "ipldgit.Tag", Key: &_String{k}} } @@ -6023,12 +5891,11 @@ func (n Tag) Representation() ipld.Node { type _Tag__Repr _Tag var ( - fieldName__Tag_Object_serial = _String{"Object"} - fieldName__Tag_TagType_serial = _String{"TagType"} - fieldName__Tag_Tag_serial = _String{"Tag"} - fieldName__Tag_Tagger_serial = _String{"Tagger"} - fieldName__Tag_Text_serial = _String{"Text"} - fieldName__Tag_DataSize_serial = _String{"DataSize"} + fieldName__Tag_Object_serial = _String{"Object"} + fieldName__Tag_TagType_serial = _String{"TagType"} + fieldName__Tag_Tag_serial = _String{"Tag"} + fieldName__Tag_Tagger_serial = _String{"Tagger"} + fieldName__Tag_Text_serial = _String{"Text"} ) var _ ipld.Node = &_Tag__Repr{} @@ -6047,11 +5914,6 @@ func (n *_Tag__Repr) LookupByString(key string) (ipld.Node, error) { return n.Tagger.Representation(), nil case "Text": return n.Text.Representation(), nil - case "DataSize": - if n.DataSize.m == schema.Maybe_Absent { - return ipld.Absent, ipld.ErrNotExists{ipld.PathSegmentOfString(key)} - } - return n.DataSize.v.Representation(), nil default: return nil, schema.ErrNoSuchField{Type: nil /*TODO*/, Field: ipld.PathSegmentOfString(key)} } @@ -6070,25 +5932,16 @@ func (n _Tag__Repr) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { return n.LookupByString(seg.String()) } func (n *_Tag__Repr) MapIterator() ipld.MapIterator { - end := 6 - if n.DataSize.m == schema.Maybe_Absent { - end = 5 - } else { - goto done - } -done: - return &_Tag__ReprMapItr{n, 0, end} + return &_Tag__ReprMapItr{n, 0} } type _Tag__ReprMapItr struct { n *_Tag__Repr idx int - end int } func (itr *_Tag__ReprMapItr) Next() (k ipld.Node, v ipld.Node, _ error) { -advance: - if itr.idx >= 6 { + if itr.idx >= 5 { return nil, nil, ipld.ErrIteratorOverread{} } switch itr.idx { @@ -6107,13 +5960,6 @@ advance: case 4: k = &fieldName__Tag_Text_serial v = itr.n.Text.Representation() - case 5: - k = &fieldName__Tag_DataSize_serial - if itr.n.DataSize.m == schema.Maybe_Absent { - itr.idx++ - goto advance - } - v = itr.n.DataSize.v.Representation() default: panic("unreachable") } @@ -6121,16 +5967,13 @@ advance: return } func (itr *_Tag__ReprMapItr) Done() bool { - return itr.idx >= itr.end + return itr.idx >= 5 } func (_Tag__Repr) ListIterator() ipld.ListIterator { return nil } func (rn *_Tag__Repr) Length() int64 { - l := 6 - if rn.DataSize.m == schema.Maybe_Absent { - l-- - } + l := 5 return int64(l) } func (_Tag__Repr) IsAbsent() bool { @@ -6192,13 +6035,12 @@ type _Tag__ReprAssembler struct { s int f int - cm schema.Maybe - ca_Object _Link__ReprAssembler - ca_TagType _String__ReprAssembler - ca_Tag _String__ReprAssembler - ca_Tagger _PersonInfo__ReprAssembler - ca_Text _String__ReprAssembler - ca_DataSize _String__ReprAssembler + cm schema.Maybe + ca_Object _Link__ReprAssembler + ca_TagType _String__ReprAssembler + ca_Tag _String__ReprAssembler + ca_Tagger _PersonInfo__ReprAssembler + ca_Text _String__ReprAssembler } func (na *_Tag__ReprAssembler) reset() { @@ -6209,7 +6051,6 @@ func (na *_Tag__ReprAssembler) reset() { na.ca_Tag.reset() na.ca_Tagger.reset() na.ca_Text.reset() - na.ca_DataSize.reset() } func (na *_Tag__ReprAssembler) BeginMap(int64) (ipld.MapAssembler, error) { switch *na.m { @@ -6347,15 +6188,6 @@ func (ma *_Tag__ReprAssembler) valueFinishTidy() bool { default: return false } - case 5: - switch ma.w.DataSize.m { - case schema.Maybe_Value: - ma.w.DataSize.v = ma.ca_DataSize.w - ma.state = maState_initial - return true - default: - return false - } default: panic("unreachable") } @@ -6378,7 +6210,7 @@ func (ma *_Tag__ReprAssembler) AssembleEntry(k string) (ipld.NodeAssembler, erro switch k { case "Object": if ma.s&fieldBit__Tag_Object != 0 { - return nil, ipld.ErrRepeatedMapKey{&fieldName__Tag_Object_serial} + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Object_serial} } ma.s += fieldBit__Tag_Object ma.state = maState_midValue @@ -6388,7 +6220,7 @@ func (ma *_Tag__ReprAssembler) AssembleEntry(k string) (ipld.NodeAssembler, erro return &ma.ca_Object, nil case "TagType": if ma.s&fieldBit__Tag_TagType != 0 { - return nil, ipld.ErrRepeatedMapKey{&fieldName__Tag_TagType_serial} + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_TagType_serial} } ma.s += fieldBit__Tag_TagType ma.state = maState_midValue @@ -6398,7 +6230,7 @@ func (ma *_Tag__ReprAssembler) AssembleEntry(k string) (ipld.NodeAssembler, erro return &ma.ca_TagType, nil case "Tag": if ma.s&fieldBit__Tag_Tag != 0 { - return nil, ipld.ErrRepeatedMapKey{&fieldName__Tag_Tag_serial} + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Tag_serial} } ma.s += fieldBit__Tag_Tag ma.state = maState_midValue @@ -6408,7 +6240,7 @@ func (ma *_Tag__ReprAssembler) AssembleEntry(k string) (ipld.NodeAssembler, erro return &ma.ca_Tag, nil case "Tagger": if ma.s&fieldBit__Tag_Tagger != 0 { - return nil, ipld.ErrRepeatedMapKey{&fieldName__Tag_Tagger_serial} + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Tagger_serial} } ma.s += fieldBit__Tag_Tagger ma.state = maState_midValue @@ -6418,7 +6250,7 @@ func (ma *_Tag__ReprAssembler) AssembleEntry(k string) (ipld.NodeAssembler, erro return &ma.ca_Tagger, nil case "Text": if ma.s&fieldBit__Tag_Text != 0 { - return nil, ipld.ErrRepeatedMapKey{&fieldName__Tag_Text_serial} + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Text_serial} } ma.s += fieldBit__Tag_Text ma.state = maState_midValue @@ -6426,20 +6258,9 @@ func (ma *_Tag__ReprAssembler) AssembleEntry(k string) (ipld.NodeAssembler, erro ma.ca_Text.w = &ma.w.Text ma.ca_Text.m = &ma.cm return &ma.ca_Text, nil - case "DataSize": - if ma.s&fieldBit__Tag_DataSize != 0 { - return nil, ipld.ErrRepeatedMapKey{&fieldName__Tag_DataSize_serial} - } - ma.s += fieldBit__Tag_DataSize - ma.state = maState_midValue - ma.f = 5 - ma.ca_DataSize.w = ma.w.DataSize.v - ma.ca_DataSize.m = &ma.w.DataSize.m - - return &ma.ca_DataSize, nil default: - return nil, ipld.ErrInvalidKey{TypeName: "ipldgit.Tag.Repr", Key: &_String{k}} } + return nil, ipld.ErrInvalidKey{TypeName: "ipldgit.Tag.Repr", Key: &_String{k}} } func (ma *_Tag__ReprAssembler) AssembleKey() ipld.NodeAssembler { switch ma.state { @@ -6494,11 +6315,6 @@ func (ma *_Tag__ReprAssembler) AssembleValue() ipld.NodeAssembler { ma.ca_Text.w = &ma.w.Text ma.ca_Text.m = &ma.cm return &ma.ca_Text - case 5: - ma.ca_DataSize.w = ma.w.DataSize.v - ma.ca_DataSize.m = &ma.w.DataSize.m - - return &ma.ca_DataSize default: panic("unreachable") } @@ -6575,50 +6391,46 @@ func (ka *_Tag__ReprKeyAssembler) AssignString(k string) error { switch k { case "Object": if ka.s&fieldBit__Tag_Object != 0 { - return ipld.ErrRepeatedMapKey{&fieldName__Tag_Object_serial} + return ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Object_serial} } ka.s += fieldBit__Tag_Object ka.state = maState_expectValue ka.f = 0 + return nil case "TagType": if ka.s&fieldBit__Tag_TagType != 0 { - return ipld.ErrRepeatedMapKey{&fieldName__Tag_TagType_serial} + return ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_TagType_serial} } ka.s += fieldBit__Tag_TagType ka.state = maState_expectValue ka.f = 1 + return nil case "Tag": if ka.s&fieldBit__Tag_Tag != 0 { - return ipld.ErrRepeatedMapKey{&fieldName__Tag_Tag_serial} + return ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Tag_serial} } ka.s += fieldBit__Tag_Tag ka.state = maState_expectValue ka.f = 2 + return nil case "Tagger": if ka.s&fieldBit__Tag_Tagger != 0 { - return ipld.ErrRepeatedMapKey{&fieldName__Tag_Tagger_serial} + return ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Tagger_serial} } ka.s += fieldBit__Tag_Tagger ka.state = maState_expectValue ka.f = 3 + return nil case "Text": if ka.s&fieldBit__Tag_Text != 0 { - return ipld.ErrRepeatedMapKey{&fieldName__Tag_Text_serial} + return ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Text_serial} } ka.s += fieldBit__Tag_Text ka.state = maState_expectValue ka.f = 4 - case "DataSize": - if ka.s&fieldBit__Tag_DataSize != 0 { - return ipld.ErrRepeatedMapKey{&fieldName__Tag_DataSize_serial} - } - ka.s += fieldBit__Tag_DataSize - ka.state = maState_expectValue - ka.f = 5 - default: - return ipld.ErrInvalidKey{TypeName: "ipldgit.Tag.Repr", Key: &_String{k}} + return nil } - return nil + return ipld.ErrInvalidKey{TypeName: "ipldgit.Tag.Repr", Key: &_String{k}} } func (_Tag__ReprKeyAssembler) AssignBytes([]byte) error { return mixins.StringAssembler{"ipldgit.Tag.Repr.KeyAssembler"}.AssignBytes(nil) @@ -6731,7 +6543,7 @@ func (n Tree) LookupByNode(k ipld.Node) (ipld.Node, error) { } func (n Tree) LookupByIndex(idx int64) (ipld.Node, error) { if n.Length() <= idx { - return nil, ipld.ErrNotExists{ipld.PathSegmentOfInt(idx)} + return nil, ipld.ErrNotExists{Segment: ipld.PathSegmentOfInt(idx)} } v := &n.x[idx] return v, nil @@ -7586,7 +7398,7 @@ func (ma *_TreeEntry__Assembler) AssembleEntry(k string) (ipld.NodeAssembler, er switch k { case "Mode": if ma.s&fieldBit__TreeEntry_Mode != 0 { - return nil, ipld.ErrRepeatedMapKey{&fieldName__TreeEntry_Mode} + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__TreeEntry_Mode} } ma.s += fieldBit__TreeEntry_Mode ma.state = maState_midValue @@ -7596,7 +7408,7 @@ func (ma *_TreeEntry__Assembler) AssembleEntry(k string) (ipld.NodeAssembler, er return &ma.ca_Mode, nil case "Name": if ma.s&fieldBit__TreeEntry_Name != 0 { - return nil, ipld.ErrRepeatedMapKey{&fieldName__TreeEntry_Name} + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__TreeEntry_Name} } ma.s += fieldBit__TreeEntry_Name ma.state = maState_midValue @@ -7606,7 +7418,7 @@ func (ma *_TreeEntry__Assembler) AssembleEntry(k string) (ipld.NodeAssembler, er return &ma.ca_Name, nil case "Hash": if ma.s&fieldBit__TreeEntry_Hash != 0 { - return nil, ipld.ErrRepeatedMapKey{&fieldName__TreeEntry_Hash} + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__TreeEntry_Hash} } ma.s += fieldBit__TreeEntry_Hash ma.state = maState_midValue @@ -7614,9 +7426,8 @@ func (ma *_TreeEntry__Assembler) AssembleEntry(k string) (ipld.NodeAssembler, er ma.ca_Hash.w = &ma.w.Hash ma.ca_Hash.m = &ma.cm return &ma.ca_Hash, nil - default: - return nil, ipld.ErrInvalidKey{TypeName: "ipldgit.TreeEntry", Key: &_String{k}} } + return nil, ipld.ErrInvalidKey{TypeName: "ipldgit.TreeEntry", Key: &_String{k}} } func (ma *_TreeEntry__Assembler) AssembleKey() ipld.NodeAssembler { switch ma.state { @@ -7733,21 +7544,21 @@ func (ka *_TreeEntry__KeyAssembler) AssignString(k string) error { switch k { case "Mode": if ka.s&fieldBit__TreeEntry_Mode != 0 { - return ipld.ErrRepeatedMapKey{&fieldName__TreeEntry_Mode} + return ipld.ErrRepeatedMapKey{Key: &fieldName__TreeEntry_Mode} } ka.s += fieldBit__TreeEntry_Mode ka.state = maState_expectValue ka.f = 0 case "Name": if ka.s&fieldBit__TreeEntry_Name != 0 { - return ipld.ErrRepeatedMapKey{&fieldName__TreeEntry_Name} + return ipld.ErrRepeatedMapKey{Key: &fieldName__TreeEntry_Name} } ka.s += fieldBit__TreeEntry_Name ka.state = maState_expectValue ka.f = 1 case "Hash": if ka.s&fieldBit__TreeEntry_Hash != 0 { - return ipld.ErrRepeatedMapKey{&fieldName__TreeEntry_Hash} + return ipld.ErrRepeatedMapKey{Key: &fieldName__TreeEntry_Hash} } ka.s += fieldBit__TreeEntry_Hash ka.state = maState_expectValue diff --git a/ipldsch_types.go b/ipldsch_types.go index 3efcc69..6b8f572 100644 --- a/ipldsch_types.go +++ b/ipldsch_types.go @@ -57,7 +57,6 @@ type _Blob struct{ x []byte } // Commit matches the IPLD Schema type "Commit". It has Struct type-kind, and may be interrogated like map kind. type Commit = *_Commit type _Commit struct { - DataSize _String GitTree _LinkTree Parents _ListParents Message _String @@ -115,12 +114,11 @@ type _String struct{ x string } // Tag matches the IPLD Schema type "Tag". It has Struct type-kind, and may be interrogated like map kind. type Tag = *_Tag type _Tag struct { - Object _Link - TagType _String - Tag _String - Tagger _PersonInfo - Text _String - DataSize _String__Maybe + Object _Link + TagType _String + Tag _String + Tagger _PersonInfo + Text _String } // Tree matches the IPLD Schema type "Tree". It has list kind. diff --git a/personinfo.go b/personinfo.go index ccbc8b8..8697ab4 100644 --- a/personinfo.go +++ b/personinfo.go @@ -71,7 +71,7 @@ func parsePersonInfo(line []byte) (PersonInfo, error) { } func (p _PersonInfo) GitString() string { - f := "prefix %s <%s>" + f := "%s <%s>" arg := []interface{}{p.Name.x, p.Email.x} if p.Date.x != "" { f = f + " %s" diff --git a/tag.go b/tag.go index 087c503..4a89380 100644 --- a/tag.go +++ b/tag.go @@ -10,19 +10,16 @@ import ( "github.com/ipld/go-ipld-prime" cidlink "github.com/ipld/go-ipld-prime/linking/cid" - "github.com/ipld/go-ipld-prime/schema" ) // DecodeTag fills a NodeAssembler (from `Type.Tag__Repr.NewBuilder()`) from a stream of bytes func DecodeTag(na ipld.NodeAssembler, rd *bufio.Reader) error { - size, err := rd.ReadString(0) + _, err := rd.ReadString(0) if err != nil { return err } out := _Tag{} - out.DataSize.m = schema.Maybe_Value - out.DataSize.v = &_String{size} for { line, _, err := rd.ReadLine() @@ -117,7 +114,6 @@ func encodeTag(n ipld.Node, w io.Writer) error { } buf := new(bytes.Buffer) - fmt.Fprintf(buf, "tag %s\x00", t.DataSize.Must().x) fmt.Fprintf(buf, "object %s\n", hex.EncodeToString(t.Object.sha())) fmt.Fprintf(buf, "type %s\n", t.TagType.x) fmt.Fprintf(buf, "tag %s\n", t.Tag.x) @@ -127,6 +123,10 @@ func encodeTag(n ipld.Node, w io.Writer) error { if t.Text.x != "" { fmt.Fprintf(buf, "\n%s", t.Text.x) } + + if _, err := fmt.Fprintf(w, "tag %d\x00", buf.Len()); err != nil { + return err + } _, err := buf.WriteTo(w) return err } From 59d8b00e9531d32cc1b836bae4aabf08c22470e2 Mon Sep 17 00:00:00 2001 From: Will Scott Date: Wed, 24 Mar 2021 10:49:25 -0700 Subject: [PATCH 10/22] update to newer ipld-prime interface / mc registry --- git_test.go | 4 ++-- go.mod | 5 ++--- go.sum | 33 ++++++++++++++++++++++----------- init.go | 8 ++++---- marshal.go | 4 ++-- unmarshal.go | 4 ++-- 6 files changed, 34 insertions(+), 24 deletions(-) diff --git a/git_test.go b/git_test.go index 648c663..4aac376 100644 --- a/git_test.go +++ b/git_test.go @@ -166,7 +166,7 @@ func TestArchiveObjectParse(t *testing.T) { fmt.Printf("%#v\n", thing) fmt.Println("vvvvvv") buf := bytes.NewBuffer([]byte{}) - Encoder(thing, buf) + Encode(thing, buf) fmt.Println(string(buf.Bytes())) fmt.Println("^^^^^^") t.Fatal("mismatch!") @@ -424,7 +424,7 @@ func BenchmarkRawData(b *testing.B) { return err } buf := bytes.NewBuffer([]byte{}) - return Encoder(thing, buf) + return Encode(thing, buf) }) if err != nil { b.Fatal(err) diff --git a/go.mod b/go.mod index 5d74faa..7859556 100644 --- a/go.mod +++ b/go.mod @@ -5,7 +5,6 @@ go 1.15 require ( github.com/ipfs/go-block-format v0.0.3 github.com/ipfs/go-cid v0.0.7 - github.com/ipld/go-ipld-prime v0.7.1-0.20210225173718-8fef5312eb12 - github.com/multiformats/go-multihash v0.0.14 - github.com/multiformats/go-varint v0.0.6 // indirect + github.com/ipld/go-ipld-prime v0.9.1-0.20210324083106-dc342a9917db + github.com/multiformats/go-multihash v0.0.15 ) diff --git a/go.sum b/go.sum index 18ecaf3..fd0d926 100644 --- a/go.sum +++ b/go.sum @@ -1,3 +1,5 @@ +github.com/frankban/quicktest v1.11.3/go.mod h1:wRf/ReqHper53s+kmmSZizM8NamnL3IM0I9ntUbOk+k= +github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= 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-block-format v0.0.3 h1:r8t66QstRp/pd/or4dpnbVfXT5Gt7lOqRvC+/dDTpMc= @@ -7,19 +9,25 @@ 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/ipfs/go-ipfs-util v0.0.2 h1:59Sswnk1MFaiq+VcaknX7aYEyGyGDAA73ilhEK2POp8= github.com/ipfs/go-ipfs-util v0.0.2/go.mod h1:CbPtkWJzjLdEcezDns2XYaehFVNXG9zrdrtMecczcsQ= -github.com/ipld/go-ipld-prime v0.7.1-0.20210225173718-8fef5312eb12 h1:O9VMUYa2ktly9ql6W0LG0k8lXqg3bqz2ZfbaHXN3law= -github.com/ipld/go-ipld-prime v0.7.1-0.20210225173718-8fef5312eb12/go.mod h1:0xEgdD6MKbZ1vF0GC+YcR/C4SQCAlRuOjIJ2i0HxqzM= +github.com/ipld/go-ipld-prime v0.9.1-0.20210324083106-dc342a9917db h1:kFwGn8rXa/Z31ev1OFNQsYeNKNCdifnTPl/NvPy5L38= +github.com/ipld/go-ipld-prime v0.9.1-0.20210324083106-dc342a9917db/go.mod h1:KvBLMr4PX1gWptgkzRjVZCrLmSGcZCb/jioOQwCqZN8= 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/klauspost/cpuid/v2 v2.0.4 h1:g0I61F2K2DjRHz1cnxlkNSBIaePVoJIjjnHui8QHbiw= +github.com/klauspost/cpuid/v2 v2.0.4/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg= +github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI= +github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= +github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= 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/minio/sha256-simd v1.0.0 h1:v1ta+49hkWZyvaKwrQB8elexRqm6Y0aMLjCNsrYxo6g= +github.com/minio/sha256-simd v1.0.0/go.mod h1:OuYzVNI5vcoYIAmbIvHPl3N3jUzVedXbKy5RFepssQM= 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= @@ -29,8 +37,9 @@ github.com/multiformats/go-multibase v0.0.3 h1:l/B6bJDQjvQ5G52jw4QGSYeOTZoAwIO77 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/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-multihash v0.0.15 h1:hWOPdrNqDjwHDx82vsYGSDZNyktOJJ2dzZJzFkOV1jM= +github.com/multiformats/go-multihash v0.0.15/go.mod h1:D6aZrWNLFTV/ynMpKsNtB40mJzmCl4jb1alC0OvHiHg= 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= @@ -40,19 +49,21 @@ github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d h1:zE9ykE 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-20210220033148-5ea612d1eb83 h1:/ZScEX8SfEmUGRHs0gxpqteO5nfNW6axyZbBdw9A12g= +golang.org/x/crypto v0.0.0-20210220033148-5ea612d1eb83/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-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-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210309074719-68d13333faf2 h1:46ULzRKLh1CwgRq2dC5SlBzEqqNCi8rreOZnNrbqcIY= +golang.org/x/sys v0.0.0-20210309074719-68d13333faf2/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= +golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= diff --git a/init.go b/init.go index 4a8b862..4c7861d 100644 --- a/init.go +++ b/init.go @@ -10,11 +10,11 @@ import ( ) var ( - _ ipld.Decoder = Decoder - _ ipld.Encoder = Encoder + _ ipld.Decoder = Decode + _ ipld.Encoder = Encode ) func init() { - mc.EncoderRegistry[cid.GitRaw] = Encoder - mc.DecoderRegistry[cid.GitRaw] = Decoder + mc.RegisterEncoder(cid.GitRaw, Encode) + mc.RegisterDecoder(cid.GitRaw, Decode) } diff --git a/marshal.go b/marshal.go index 09a0a1f..ce6c7b0 100644 --- a/marshal.go +++ b/marshal.go @@ -7,8 +7,8 @@ import ( "github.com/ipld/go-ipld-prime" ) -// Encoder serializes a git node to a raw binary form. -func Encoder(n ipld.Node, w io.Writer) error { +// Encode serializes a git node to a raw binary form. +func Encode(n ipld.Node, w io.Writer) error { switch n.Prototype() { case Type.Blob, Type.Blob__Repr: return encodeBlob(n, w) diff --git a/unmarshal.go b/unmarshal.go index bc4b4f8..07a8703 100644 --- a/unmarshal.go +++ b/unmarshal.go @@ -8,8 +8,8 @@ import ( "github.com/ipld/go-ipld-prime" ) -// Decoder reads from a reader to fill a NodeAssembler -func Decoder(na ipld.NodeAssembler, r io.Reader) error { +// Decode reads from a reader to fill a NodeAssembler +func Decode(na ipld.NodeAssembler, r io.Reader) error { rd := bufio.NewReader(r) typ, err := rd.ReadString(' ') From a4c429b648254cc5310883916be33ed40295df0f Mon Sep 17 00:00:00 2001 From: Will Scott Date: Thu, 25 Mar 2021 22:49:12 -0700 Subject: [PATCH 11/22] allow encoding of non-native types --- commit.go | 7 +++++- marshal.go | 27 +++++++++++++++++++++++ tag.go | 64 ++++++++++++++++++++++++++++++++++++++++++++---------- util.go | 9 ++++++++ 4 files changed, 95 insertions(+), 12 deletions(-) diff --git a/commit.go b/commit.go index 85138e3..c45bdf9 100644 --- a/commit.go +++ b/commit.go @@ -151,7 +151,12 @@ func decodeGpgSig(rd *bufio.Reader) (GpgSig, error) { func encodeCommit(n ipld.Node, w io.Writer) error { c, ok := n.(Commit) if !ok { - return fmt.Errorf("not a Commit: %T", n) + ci := Type.Commit__Repr.NewBuilder() + if err := ci.AssignNode(n); err != nil { + return fmt.Errorf("not a Commit: %T %w", n, err) + } + ciN := ci.Build() + c, ok = ciN.(Commit) } buf := new(bytes.Buffer) diff --git a/marshal.go b/marshal.go index ce6c7b0..f326a7a 100644 --- a/marshal.go +++ b/marshal.go @@ -18,6 +18,33 @@ func Encode(n ipld.Node, w io.Writer) error { return encodeTree(n, w) case Type.Tag, Type.Tag__Repr: return encodeTag(n, w) + default: + } + switch n.Kind() { + case ipld.Kind_Bytes: + return encodeBlob(n, w) + case ipld.Kind_List: + return encodeTree(n, w) + case ipld.Kind_Map: + k, _, err := n.MapIterator().Next() + if err != nil { + return err + } + repKey, err := k.AsString() + if err != nil { + return err + } + switch repKey { + case + "Object", + "TagType", + "Tag", + "Tagger", + "Text": + return encodeTag(n, w) + default: + return encodeCommit(n, w) + } default: return fmt.Errorf("unrecognized object type: %T", n.Prototype()) } diff --git a/tag.go b/tag.go index 4a89380..16367e3 100644 --- a/tag.go +++ b/tag.go @@ -108,25 +108,67 @@ func readMergeTag(hash []byte, rd *bufio.Reader) (Tag, []byte, error) { } func encodeTag(n ipld.Node, w io.Writer) error { - t, ok := n.(Tag) - if !ok { - return fmt.Errorf("not a Commit: %T", n) + obj, err := n.LookupByString("Object") + if err != nil { + return err + } + objLnk, err := obj.AsLink() + if err != nil { + return err + } + + tt, err := n.LookupByString("TagType") + if err != nil { + return err + } + ttStr, err := tt.AsString() + if err != nil { + return err + } + + tag, err := n.LookupByString("Tag") + if err != nil { + return err + } + tagStr, err := tag.AsString() + if err != nil { + return err } + text, err := n.LookupByString("Text") + if err != nil { + return err + } + textStr, err := text.AsString() + if err != nil { + return err + } + + tagger, taggerErr := n.LookupByString("Tagger") + buf := new(bytes.Buffer) - fmt.Fprintf(buf, "object %s\n", hex.EncodeToString(t.Object.sha())) - fmt.Fprintf(buf, "type %s\n", t.TagType.x) - fmt.Fprintf(buf, "tag %s\n", t.Tag.x) - if !t.Tagger.IsNull() { - fmt.Fprintf(buf, "tagger %s\n", t.Tagger.GitString()) + fmt.Fprintf(buf, "object %s\n", hex.EncodeToString(sha(objLnk))) + fmt.Fprintf(buf, "type %s\n", ttStr) + fmt.Fprintf(buf, "tag %s\n", tagStr) + if taggerErr == nil && !tagger.IsNull() { + pi := Type.PersonInfo__Repr.NewBuilder() + if err := pi.AssignNode(tagger); err != nil { + return err + } + piN := pi.Build() + parsed, ok := piN.(*_PersonInfo) + if !ok { + return fmt.Errorf("Could not parse tagger person info %v", tagger) + } + fmt.Fprintf(buf, "tagger %s\n", parsed.GitString()) } - if t.Text.x != "" { - fmt.Fprintf(buf, "\n%s", t.Text.x) + if textStr != "" { + fmt.Fprintf(buf, "\n%s", textStr) } if _, err := fmt.Fprintf(w, "tag %d\x00", buf.Len()); err != nil { return err } - _, err := buf.WriteTo(w) + _, err = buf.WriteTo(w) return err } diff --git a/util.go b/util.go index a5040b9..025c4f1 100644 --- a/util.go +++ b/util.go @@ -2,6 +2,7 @@ package ipldgit import ( "github.com/ipfs/go-cid" + "github.com/ipld/go-ipld-prime" cidlink "github.com/ipld/go-ipld-prime/linking/cid" mh "github.com/multiformats/go-multihash" ) @@ -16,6 +17,14 @@ func cidToSha(c cid.Cid) []byte { return h[len(h)-20:] } +func sha(l ipld.Link) []byte { + cl, ok := l.(cidlink.Link) + if !ok { + return nil + } + return cidToSha(cl.Cid) +} + func (l Link) sha() []byte { cl, ok := l.x.(cidlink.Link) if !ok { From 67a7768192fab39f08126710c3eed1d2296789d4 Mon Sep 17 00:00:00 2001 From: Will Scott Date: Mon, 5 Apr 2021 10:56:53 -0700 Subject: [PATCH 12/22] cleanup per code review --- blob.go | 22 ++++++++-------------- commit.go | 19 ++++++++----------- helper.go | 13 +++++++++++++ personinfo.go | 7 +++---- tag.go | 14 +++++++++----- tree.go | 14 ++++---------- unmarshal.go | 12 ++++++------ 7 files changed, 51 insertions(+), 50 deletions(-) diff --git a/blob.go b/blob.go index 45584c6..55e8686 100644 --- a/blob.go +++ b/blob.go @@ -2,39 +2,33 @@ package ipldgit import ( "bufio" - "bytes" "fmt" "io" - "strconv" "github.com/ipld/go-ipld-prime" ) // DecodeBlob fills a NodeAssembler (from `Type.Blob__Repr.NewBuilder()`) from a stream of bytes func DecodeBlob(na ipld.NodeAssembler, rd *bufio.Reader) error { - size, err := rd.ReadString(0) + sizen, err := readNullTerminatedNumber(rd) if err != nil { return err } - sizen, err := strconv.Atoi(size[:len(size)-1]) - if err != nil { - return err - } - - buf := new(bytes.Buffer) - fmt.Fprintf(buf, "blob %d\x00", sizen) + prefix := fmt.Sprintf("blob %d\x00", sizen) + buf := make([]byte, len(prefix)+sizen) + copy(buf, prefix) - n, err := io.Copy(buf, rd) + n, err := io.ReadFull(rd, buf[len(prefix):]) if err != nil { return err } - if n != int64(sizen) { + if n != sizen { return fmt.Errorf("blob size was not accurate") } - return na.AssignBytes(buf.Bytes()) + return na.AssignBytes(buf) } func encodeBlob(n ipld.Node, w io.Writer) error { @@ -43,6 +37,6 @@ func encodeBlob(n ipld.Node, w io.Writer) error { return err } - _, err = bytes.NewBuffer(b).WriteTo(w) + _, err = w.Write(b) return err } diff --git a/commit.go b/commit.go index c45bdf9..8b81522 100644 --- a/commit.go +++ b/commit.go @@ -14,10 +14,11 @@ import ( "github.com/ipld/go-ipld-prime/schema" ) +const prefixMergetag = 16 // the length of "mergetag object " + // DecodeCommit fills a NodeAssembler (from `Type.Commit__Repr.NewBuilder()`) from a stream of bytes func DecodeCommit(na ipld.NodeAssembler, rd *bufio.Reader) error { - _, err := rd.ReadString(0) - if err != nil { + if _, err := readNullTerminatedNumber(rd); err != nil { return err } @@ -77,7 +78,7 @@ func decodeCommitLine(c Commit, line []byte, rd *bufio.Reader) error { case bytes.HasPrefix(line, []byte("encoding ")): c.Encoding = _String__Maybe{m: schema.Maybe_Value, v: &_String{string(line[9:])}} case bytes.HasPrefix(line, []byte("mergetag object ")): - sha, err := hex.DecodeString(string(line)[16:]) + sha, err := hex.DecodeString(string(line)[prefixMergetag:]) if err != nil { return err } @@ -149,15 +150,11 @@ func decodeGpgSig(rd *bufio.Reader) (GpgSig, error) { } func encodeCommit(n ipld.Node, w io.Writer) error { - c, ok := n.(Commit) - if !ok { - ci := Type.Commit__Repr.NewBuilder() - if err := ci.AssignNode(n); err != nil { - return fmt.Errorf("not a Commit: %T %w", n, err) - } - ciN := ci.Build() - c, ok = ciN.(Commit) + ci := Type.Commit__Repr.NewBuilder() + if err := ci.AssignNode(n); err != nil { + return fmt.Errorf("not a Commit: %T %w", n, err) } + c := ci.Build().(Commit) buf := new(bytes.Buffer) diff --git a/helper.go b/helper.go index 26819f6..602cefe 100644 --- a/helper.go +++ b/helper.go @@ -1,10 +1,12 @@ package ipldgit import ( + "bufio" "bytes" "compress/zlib" "errors" "io" + "strconv" blocks "github.com/ipfs/go-block-format" "github.com/ipfs/go-cid" @@ -13,6 +15,7 @@ import ( ) // DecodeBlock attempts to parse a serialized ipfs block into an ipld node dag +// Deprecated: Parse ifrom data instead. func DecodeBlock(block blocks.Block) (ipld.Node, error) { prefix := block.Cid().Prefix() @@ -38,3 +41,13 @@ func ParseCompressedObject(r io.Reader) (ipld.Node, error) { func ParseObjectFromBuffer(b []byte) (ipld.Node, error) { return ParseObject(bytes.NewReader(b)) } + +func readNullTerminatedNumber(rd *bufio.Reader) (int, error) { + lstr, err := rd.ReadString(0) + if err != nil { + return 0, err + } + lstr = lstr[:len(lstr)-1] + + return strconv.Atoi(lstr) +} diff --git a/personinfo.go b/personinfo.go index 8697ab4..367bf7d 100644 --- a/personinfo.go +++ b/personinfo.go @@ -8,8 +8,7 @@ import ( func parsePersonInfo(line []byte) (PersonInfo, error) { parts := bytes.Split(line, []byte{' '}) if len(parts) < 3 { - fmt.Println(string(line)) - return nil, fmt.Errorf("incorrectly formatted person info line") + return nil, fmt.Errorf("incorrectly formatted person info line: %q", line) } //TODO: just use regex? @@ -21,7 +20,7 @@ func parsePersonInfo(line []byte) (PersonInfo, error) { for { if at == len(parts) { - return nil, fmt.Errorf("invalid personInfo: %s", line) + return nil, fmt.Errorf("invalid personInfo: %q", line) } part := parts[at] if len(part) != 0 { @@ -41,7 +40,7 @@ func parsePersonInfo(line []byte) (PersonInfo, error) { var email string for { if at == len(parts) { - return nil, fmt.Errorf("invalid personInfo: %s", line) + return nil, fmt.Errorf("invalid personInfo: %q", line) } part := parts[at] if part[0] == '<' { diff --git a/tag.go b/tag.go index 16367e3..584f396 100644 --- a/tag.go +++ b/tag.go @@ -12,6 +12,10 @@ import ( cidlink "github.com/ipld/go-ipld-prime/linking/cid" ) +const tagObjectPrefixLen = 7 // "prefix 'object '" +const tagTagPrefixLen = 4 // "prefix 'tag '" +const tagTypePrefixLen = 5 // "prefix 'type '" + // DecodeTag fills a NodeAssembler (from `Type.Tag__Repr.NewBuilder()`) from a stream of bytes func DecodeTag(na ipld.NodeAssembler, rd *bufio.Reader) error { _, err := rd.ReadString(0) @@ -32,14 +36,14 @@ func DecodeTag(na ipld.NodeAssembler, rd *bufio.Reader) error { switch { case bytes.HasPrefix(line, []byte("object ")): - sha, err := hex.DecodeString(string(line[7:])) + sha, err := hex.DecodeString(string(line[tagObjectPrefixLen:])) if err != nil { return err } out.Object = _Link{cidlink.Link{Cid: shaToCid(sha)}} case bytes.HasPrefix(line, []byte("tag ")): - out.Tag = _String{string(line[4:])} + out.Tag = _String{string(line[tagTagPrefixLen:])} case bytes.HasPrefix(line, []byte("tagger ")): c, err := parsePersonInfo(line) if err != nil { @@ -48,7 +52,7 @@ func DecodeTag(na ipld.NodeAssembler, rd *bufio.Reader) error { out.Tagger = *c case bytes.HasPrefix(line, []byte("type ")): - out.TagType = _String{string(line[5:])} + out.TagType = _String{string(line[tagTypePrefixLen:])} case len(line) == 0: rest, err := ioutil.ReadAll(rd) if err != nil { @@ -80,9 +84,9 @@ func readMergeTag(hash []byte, rd *bufio.Reader) (Tag, []byte, error) { switch { case bytes.HasPrefix(line, []byte(" type ")): - out.TagType = _String{string(line[6:])} + out.TagType = _String{string(line[1+tagTypePrefixLen:])} case bytes.HasPrefix(line, []byte(" tag ")): - out.Tag = _String{string(line[5:])} + out.Tag = _String{string(line[1+tagTagPrefixLen:])} case bytes.HasPrefix(line, []byte(" tagger ")): tagger, err := parsePersonInfo(line[1:]) if err != nil { diff --git a/tree.go b/tree.go index ee86e29..fa05c0a 100644 --- a/tree.go +++ b/tree.go @@ -5,7 +5,6 @@ import ( "bytes" "fmt" "io" - "strconv" "github.com/ipld/go-ipld-prime" cidlink "github.com/ipld/go-ipld-prime/linking/cid" @@ -13,14 +12,7 @@ import ( // DecodeTree fills a NodeAssembler (from `Type.Tree__Repr.NewBuilder()`) from a stream of bytes func DecodeTree(na ipld.NodeAssembler, rd *bufio.Reader) error { - lstr, err := rd.ReadString(0) - if err != nil { - return err - } - lstr = lstr[:len(lstr)-1] - - _, err = strconv.Atoi(lstr) - if err != nil { + if _, err := readNullTerminatedNumber(rd); err != nil { return err } @@ -37,7 +29,9 @@ func DecodeTree(na ipld.NodeAssembler, rd *bufio.Reader) error { } return err } - la.AssembleValue().AssignNode(node) + if err := la.AssembleValue().AssignNode(node); err != nil { + return err + } } if err := la.Finish(); err != nil { return err diff --git a/unmarshal.go b/unmarshal.go index 07a8703..eca92a3 100644 --- a/unmarshal.go +++ b/unmarshal.go @@ -43,26 +43,26 @@ func ParseObject(r io.Reader) (ipld.Node, error) { typ = typ[:len(typ)-1] var na ipld.NodeBuilder - var f func(ipld.NodeAssembler, *bufio.Reader) error + var decode func(ipld.NodeAssembler, *bufio.Reader) error switch typ { case "tree": na = Type.Tree.NewBuilder() - f = DecodeTree + decode = DecodeTree case "commit": na = Type.Commit.NewBuilder() - f = DecodeCommit + decode = DecodeCommit case "blob": na = Type.Blob.NewBuilder() - f = DecodeBlob + decode = DecodeBlob case "tag": na = Type.Tag.NewBuilder() - f = DecodeTag + decode = DecodeTag default: return nil, fmt.Errorf("unrecognized object type: %s", typ) } fmt.Printf("type %s\n", typ) - if err := f(na, rd); err != nil { + if err := decode(na, rd); err != nil { return nil, err } return na.Build(), nil From cced9d64cd991ab86975c750971bd3978ef3f0a2 Mon Sep 17 00:00:00 2001 From: Rod Vagg Date: Thu, 22 Jul 2021 21:49:52 +1000 Subject: [PATCH 13/22] Match original field names, tree as map --- commit.go | 56 +- gen/gen.go | 50 +- git_test.go | 42 +- ipldsch_satisfaction.go | 2665 ++++++++++++++++++++++++--------------- ipldsch_types.go | 50 +- marshal.go | 10 +- personinfo.go | 18 +- tag.go | 30 +- tree.go | 55 +- 9 files changed, 1839 insertions(+), 1137 deletions(-) diff --git a/commit.go b/commit.go index 8b81522..07b3a94 100644 --- a/commit.go +++ b/commit.go @@ -23,9 +23,9 @@ func DecodeCommit(na ipld.NodeAssembler, rd *bufio.Reader) error { } c := _Commit{ - Parents: _ListParents{[]_Link{}}, - MergeTag: _ListTag{[]_Tag{}}, - Other: _ListString{[]_String{}}, + parents: _ListParents{[]_Link{}}, + mergeTag: _ListTag{[]_Tag{}}, + other: _ListString{[]_String{}}, } for { line, _, err := rd.ReadLine() @@ -53,30 +53,30 @@ func decodeCommitLine(c Commit, line []byte, rd *bufio.Reader) error { return err } - c.GitTree = _LinkTree{cidlink.Link{Cid: shaToCid(sha)}} + c.tree = _LinkTree{cidlink.Link{Cid: shaToCid(sha)}} case bytes.HasPrefix(line, []byte("parent ")): psha, err := hex.DecodeString(string(line[7:])) if err != nil { return err } - c.Parents.x = append(c.Parents.x, _Link{cidlink.Link{Cid: shaToCid(psha)}}) + c.parents.x = append(c.parents.x, _Link{cidlink.Link{Cid: shaToCid(psha)}}) case bytes.HasPrefix(line, []byte("author ")): a, err := parsePersonInfo(line) if err != nil { return err } - c.Author = _PersonInfo__Maybe{m: schema.Maybe_Value, v: a} + c.author = _PersonInfo__Maybe{m: schema.Maybe_Value, v: a} case bytes.HasPrefix(line, []byte("committer ")): com, err := parsePersonInfo(line) if err != nil { return err } - c.Committer = _PersonInfo__Maybe{m: schema.Maybe_Value, v: com} + c.committer = _PersonInfo__Maybe{m: schema.Maybe_Value, v: com} case bytes.HasPrefix(line, []byte("encoding ")): - c.Encoding = _String__Maybe{m: schema.Maybe_Value, v: &_String{string(line[9:])}} + c.encoding = _String__Maybe{m: schema.Maybe_Value, v: &_String{string(line[9:])}} case bytes.HasPrefix(line, []byte("mergetag object ")): sha, err := hex.DecodeString(string(line)[prefixMergetag:]) if err != nil { @@ -88,7 +88,7 @@ func decodeCommitLine(c Commit, line []byte, rd *bufio.Reader) error { return err } - c.MergeTag.x = append(c.MergeTag.x, *mt) + c.mergeTag.x = append(c.mergeTag.x, *mt) if rest != nil { err = decodeCommitLine(c, rest, rd) @@ -101,16 +101,16 @@ func decodeCommitLine(c Commit, line []byte, rd *bufio.Reader) error { if err != nil { return err } - c.Sig = _GpgSig__Maybe{m: schema.Maybe_Value, v: sig} + c.signature = _GpgSig__Maybe{m: schema.Maybe_Value, v: sig} case len(line) == 0: rest, err := ioutil.ReadAll(rd) if err != nil { return err } - c.Message = _String{string(rest)} + c.message = _String{string(rest)} default: - c.Other.x = append(c.Other.x, _String{string(line)}) + c.other.x = append(c.other.x, _String{string(line)}) } return nil } @@ -158,31 +158,31 @@ func encodeCommit(n ipld.Node, w io.Writer) error { buf := new(bytes.Buffer) - fmt.Fprintf(buf, "tree %s\n", hex.EncodeToString(c.GitTree.sha())) - for _, p := range c.Parents.x { + fmt.Fprintf(buf, "tree %s\n", hex.EncodeToString(c.tree.sha())) + for _, p := range c.parents.x { fmt.Fprintf(buf, "parent %s\n", hex.EncodeToString(p.sha())) } - fmt.Fprintf(buf, "author %s\n", c.Author.v.GitString()) - fmt.Fprintf(buf, "committer %s\n", c.Committer.v.GitString()) - if c.Encoding.m == schema.Maybe_Value { - fmt.Fprintf(buf, "encoding %s\n", c.Encoding.v.x) + fmt.Fprintf(buf, "author %s\n", c.author.v.GitString()) + fmt.Fprintf(buf, "committer %s\n", c.committer.v.GitString()) + if c.encoding.m == schema.Maybe_Value { + fmt.Fprintf(buf, "encoding %s\n", c.encoding.v.x) } - for _, mtag := range c.MergeTag.x { - fmt.Fprintf(buf, "mergetag object %s\n", hex.EncodeToString(mtag.Object.sha())) - fmt.Fprintf(buf, " type %s\n", mtag.TagType.x) - fmt.Fprintf(buf, " tag %s\n", mtag.Tag.x) - fmt.Fprintf(buf, " tagger %s\n \n", mtag.Tagger.GitString()) - fmt.Fprintf(buf, "%s", mtag.Text.x) + for _, mtag := range c.mergeTag.x { + fmt.Fprintf(buf, "mergetag object %s\n", hex.EncodeToString(mtag.object.sha())) + fmt.Fprintf(buf, " type %s\n", mtag.tagType.x) + fmt.Fprintf(buf, " tag %s\n", mtag.tag.x) + fmt.Fprintf(buf, " tagger %s\n \n", mtag.tagger.GitString()) + fmt.Fprintf(buf, "%s", mtag.text.x) } - if c.Sig.m == schema.Maybe_Value { + if c.signature.m == schema.Maybe_Value { fmt.Fprintln(buf, "gpgsig -----BEGIN PGP SIGNATURE-----") - fmt.Fprint(buf, c.Sig.v.x) + fmt.Fprint(buf, c.signature.v.x) fmt.Fprintln(buf, " -----END PGP SIGNATURE-----") } - for _, line := range c.Other.x { + for _, line := range c.other.x { fmt.Fprintln(buf, line.x) } - fmt.Fprintf(buf, "\n%s", c.Message.x) + fmt.Fprintf(buf, "\n%s", c.message.x) fmt.Printf("encode commit len: %d \n", buf.Len()) // fmt.Printf("out: %s\n", string(buf.Bytes())) diff --git a/gen/gen.go b/gen/gen.go index 7793703..04cec8d 100644 --- a/gen/gen.go +++ b/gen/gen.go @@ -18,41 +18,39 @@ func main() { ts.Accumulate(schema.SpawnList("ListString", "String", false)) ts.Accumulate(schema.SpawnLink("Link")) ts.Accumulate(schema.SpawnStruct("PersonInfo", []schema.StructField{ - schema.SpawnStructField("Name", "String", false, false), - schema.SpawnStructField("Email", "String", false, false), - schema.SpawnStructField("Date", "String", false, false), - schema.SpawnStructField("Timezone", "String", false, false), - }, schema.SpawnStructRepresentationStringjoin(" "))) + schema.SpawnStructField("name", "String", false, false), + schema.SpawnStructField("email", "String", false, false), + schema.SpawnStructField("date", "String", false, false), + schema.SpawnStructField("timezone", "String", false, false), + }, schema.SpawnStructRepresentationMap(map[string]string{}))) ts.Accumulate(schema.SpawnString("GpgSig")) ts.Accumulate(schema.SpawnStruct("Tag", []schema.StructField{ - schema.SpawnStructField("Object", "Link", false, false), - schema.SpawnStructField("TagType", "String", false, false), - schema.SpawnStructField("Tag", "String", false, false), - schema.SpawnStructField("Tagger", "PersonInfo", false, false), - schema.SpawnStructField("Text", "String", false, false), - }, schema.SpawnStructRepresentationMap(map[string]string{"Type": "TagType"}))) + schema.SpawnStructField("object", "Link", false, false), + schema.SpawnStructField("tagType", "String", false, false), + schema.SpawnStructField("tag", "String", false, false), + schema.SpawnStructField("tagger", "PersonInfo", false, false), + schema.SpawnStructField("text", "String", false, false), + }, schema.SpawnStructRepresentationMap(map[string]string{}))) ts.Accumulate(schema.SpawnList("ListTag", "Tag", false)) ts.Accumulate(schema.SpawnList("ListParents", "Link", false)) //Todo: type 'Parents' links ts.Accumulate(schema.SpawnStruct("Commit", []schema.StructField{ - schema.SpawnStructField("GitTree", "LinkTree", false, false), - schema.SpawnStructField("Parents", "ListParents", false, false), - schema.SpawnStructField("Message", "String", false, false), - schema.SpawnStructField("Author", "PersonInfo", true, false), - schema.SpawnStructField("Committer", "PersonInfo", true, false), - schema.SpawnStructField("Encoding", "String", true, false), - schema.SpawnStructField("Sig", "GpgSig", true, false), - schema.SpawnStructField("MergeTag", "ListTag", false, false), - schema.SpawnStructField("Other", "ListString", false, false), + schema.SpawnStructField("tree", "LinkTree", false, false), + schema.SpawnStructField("parents", "ListParents", false, false), + schema.SpawnStructField("message", "String", false, false), + schema.SpawnStructField("author", "PersonInfo", true, false), + schema.SpawnStructField("committer", "PersonInfo", true, false), + schema.SpawnStructField("encoding", "String", true, false), + schema.SpawnStructField("signature", "GpgSig", true, false), + schema.SpawnStructField("mergeTag", "ListTag", false, false), + schema.SpawnStructField("other", "ListString", false, false), }, schema.SpawnStructRepresentationMap(map[string]string{}))) ts.Accumulate(schema.SpawnBytes("Blob")) - - ts.Accumulate(schema.SpawnList("Tree", "TreeEntry", false)) + ts.Accumulate(schema.SpawnMap("Tree", "String", "TreeEntry", false)) ts.Accumulate(schema.SpawnLinkReference("LinkTree", "Tree")) ts.Accumulate(schema.SpawnStruct("TreeEntry", []schema.StructField{ - schema.SpawnStructField("Mode", "String", false, false), - schema.SpawnStructField("Name", "String", false, false), - schema.SpawnStructField("Hash", "Link", false, false), - }, schema.SpawnStructRepresentationStringjoin(" "))) + schema.SpawnStructField("mode", "String", false, false), + schema.SpawnStructField("hash", "Link", false, false), + }, schema.SpawnStructRepresentationMap(map[string]string{}))) if errs := ts.ValidateGraph(); errs != nil { for _, err := range errs { diff --git a/git_test.go b/git_test.go index 4aac376..83e0e17 100644 --- a/git_test.go +++ b/git_test.go @@ -18,7 +18,7 @@ import ( ) func TestObjectParse(t *testing.T) { - lb := cidlink.LinkPrototype{cid.Prefix{ + lb := cidlink.LinkPrototype{Prefix: cid.Prefix{ Version: 1, Codec: cid.GitRaw, MhType: 0x11, @@ -93,7 +93,7 @@ func TestObjectParse(t *testing.T) { } func TestArchiveObjectParse(t *testing.T) { - lb := cidlink.LinkPrototype{cid.Prefix{ + lb := cidlink.LinkPrototype{Prefix: cid.Prefix{ Version: 1, Codec: cid.GitRaw, MhType: 0x11, @@ -201,18 +201,18 @@ func testNode(t *testing.T, nd ipld.Node) error { t.Fatalf("Commit is not a commit") } - assert(t, !commit.GitTree.IsNull()) + assert(t, !commit.tree.IsNull()) case Type.Tag: tag, ok := nd.(Tag) if !ok { t.Fatalf("Tag is not a tag") } - tt, err := tag.TagType.AsString() + tt, err := tag.tagType.AsString() assert(t, err == nil) assert(t, tt == "commit" || tt == "tree" || tt == "blob" || tt == "tag") - assert(t, !tag.Object.IsNull()) + assert(t, !tag.object.IsNull()) case Type.Tree: tree, ok := nd.(Tree) @@ -220,7 +220,7 @@ func testNode(t *testing.T, nd ipld.Node) error { t.Fatalf("Tree is not a tree") } - assert(t, len(tree.x) > 0) + assert(t, len(tree.m) > 0) } return nil } @@ -235,25 +235,25 @@ func TestParsePersonInfo(t *testing.T) { t.Fatal("not equal:", string(p1), "vs: ", pi.GitString()) } - if d, err := pi.LookupByString("Date"); err != nil { + if d, err := pi.LookupByString("date"); err != nil { t.Fatalf("invalid date, got %s\n", err) } else if ds, _ := d.AsString(); ds != "123456" { t.Fatalf("invalid date, got %s\n", ds) } - if d, err := pi.LookupByString("Timezone"); err != nil { + if d, err := pi.LookupByString("timezone"); err != nil { t.Fatalf("invalid timezone, got %s\n", err) } else if ds, _ := d.AsString(); ds != "+0123" { t.Fatalf("invalid timezone, got %s\n", ds) } - if d, err := pi.LookupByString("Email"); err != nil { + if d, err := pi.LookupByString("email"); err != nil { t.Fatalf("invalid email, got %s\n", err) } else if ds, _ := d.AsString(); ds != "some@one.somewhere" { t.Fatalf("invalid email, got %s\n", ds) } - if d, err := pi.LookupByString("Name"); err != nil { + if d, err := pi.LookupByString("name"); err != nil { t.Fatalf("invalid name, got %s\n", err) } else if ds, _ := d.AsString(); ds != "Someone" { t.Fatalf("invalid name, got %s\n", ds) @@ -268,7 +268,7 @@ func TestParsePersonInfo(t *testing.T) { t.Fatal("not equal", p2, pi.GitString()) } - if d, err := pi.LookupByString("Name"); err != nil { + if d, err := pi.LookupByString("name"); err != nil { t.Fatalf("invalid name, got %s\n", err) } else if ds, _ := d.AsString(); ds != "So Me One" { t.Fatalf("invalid name, got %s\n", ds) @@ -282,25 +282,25 @@ func TestParsePersonInfo(t *testing.T) { if !bytes.Equal([]byte(pi.GitString()), p3[7:]) { t.Fatal("not equal", p3, pi.GitString()) } - if d, err := pi.LookupByString("Date"); err != nil { + if d, err := pi.LookupByString("date"); err != nil { t.Fatalf("invalid date, got %s\n", err) } else if ds, _ := d.AsString(); ds != "987654" { t.Fatalf("invalid date, got %s\n", ds) } - if d, err := pi.LookupByString("Timezone"); err != nil { + if d, err := pi.LookupByString("timezone"); err != nil { t.Fatalf("invalid tz, got %s\n", err) } else if ds, _ := d.AsString(); ds != "+4321" { t.Fatalf("invalid tz, got %s\n", ds) } - if d, err := pi.LookupByString("Email"); err != nil { + if d, err := pi.LookupByString("email"); err != nil { t.Fatalf("invalid email, got %s\n", err) } else if ds, _ := d.AsString(); ds != "some@one.somewhere, other@one.elsewhere" { t.Fatalf("invalid email, got %s\n", ds) } - if d, err := pi.LookupByString("Name"); err != nil { + if d, err := pi.LookupByString("name"); err != nil { t.Fatalf("invalid name, got %s\n", err) } else if ds, _ := d.AsString(); ds != "Some One & Other One" { t.Fatalf("invalid name, got %s\n", ds) @@ -315,25 +315,25 @@ func TestParsePersonInfo(t *testing.T) { t.Fatal("not equal", p4, pi.GitString()) } - if d, err := pi.LookupByString("Name"); err != nil { + if d, err := pi.LookupByString("name"); err != nil { t.Fatalf("invalid name, got %s\n", err) } else if ds, _ := d.AsString(); ds != "" { t.Fatalf("invalid name, got %s\n", ds) } - if d, err := pi.LookupByString("Email"); err != nil { + if d, err := pi.LookupByString("email"); err != nil { t.Fatalf("invalid email, got %s\n", err) } else if ds, _ := d.AsString(); ds != "some@one.somewhere" { t.Fatalf("invalid email, got %s\n", ds) } - if d, err := pi.LookupByString("Date"); err != nil { + if d, err := pi.LookupByString("date"); err != nil { t.Fatalf("invalid date, got %s\n", err) } else if ds, _ := d.AsString(); ds != "987654" { t.Fatalf("invalid date, got %s\n", ds) } - if d, err := pi.LookupByString("Timezone"); err != nil { + if d, err := pi.LookupByString("timezone"); err != nil { t.Fatalf("invalid tz, got %s\n", err) } else if ds, _ := d.AsString(); ds != "+4321" { t.Fatalf("invalid tz, got %s\n", ds) @@ -348,7 +348,7 @@ func TestParsePersonInfo(t *testing.T) { t.Fatal("not equal", p5, pi.GitString()) } - if d, err := pi.LookupByString("Name"); err != nil { + if d, err := pi.LookupByString("name"); err != nil { t.Fatalf("invalid name, got %s\n", err) } else if ds, _ := d.AsString(); ds != "Someone " { t.Fatalf("invalid name, got %s\n", ds) @@ -433,7 +433,7 @@ func BenchmarkRawData(b *testing.B) { } func BenchmarkCid(b *testing.B) { - lb := cidlink.LinkPrototype{cid.Prefix{ + lb := cidlink.LinkPrototype{Prefix: cid.Prefix{ Version: 1, Codec: cid.GitRaw, MhType: 0x11, diff --git a/ipldsch_satisfaction.go b/ipldsch_satisfaction.go index ea4250f..93d0235 100644 --- a/ipldsch_satisfaction.go +++ b/ipldsch_satisfaction.go @@ -221,32 +221,32 @@ var _ ipld.Node = &_Blob__Repr{} type _Blob__ReprPrototype = _Blob__Prototype type _Blob__ReprAssembler = _Blob__Assembler -func (n _Commit) FieldGitTree() LinkTree { - return &n.GitTree +func (n _Commit) FieldTree() LinkTree { + return &n.tree } func (n _Commit) FieldParents() ListParents { - return &n.Parents + return &n.parents } func (n _Commit) FieldMessage() String { - return &n.Message + return &n.message } func (n _Commit) FieldAuthor() MaybePersonInfo { - return &n.Author + return &n.author } func (n _Commit) FieldCommitter() MaybePersonInfo { - return &n.Committer + return &n.committer } func (n _Commit) FieldEncoding() MaybeString { - return &n.Encoding + return &n.encoding } -func (n _Commit) FieldSig() MaybeGpgSig { - return &n.Sig +func (n _Commit) FieldSignature() MaybeGpgSig { + return &n.signature } func (n _Commit) FieldMergeTag() ListTag { - return &n.MergeTag + return &n.mergeTag } func (n _Commit) FieldOther() ListString { - return &n.Other + return &n.other } type _Commit__Maybe struct { @@ -284,15 +284,15 @@ func (m MaybeCommit) Must() Commit { } var ( - fieldName__Commit_GitTree = _String{"GitTree"} - fieldName__Commit_Parents = _String{"Parents"} - fieldName__Commit_Message = _String{"Message"} - fieldName__Commit_Author = _String{"Author"} - fieldName__Commit_Committer = _String{"Committer"} - fieldName__Commit_Encoding = _String{"Encoding"} - fieldName__Commit_Sig = _String{"Sig"} - fieldName__Commit_MergeTag = _String{"MergeTag"} - fieldName__Commit_Other = _String{"Other"} + fieldName__Commit_Tree = _String{"tree"} + fieldName__Commit_Parents = _String{"parents"} + fieldName__Commit_Message = _String{"message"} + fieldName__Commit_Author = _String{"author"} + fieldName__Commit_Committer = _String{"committer"} + fieldName__Commit_Encoding = _String{"encoding"} + fieldName__Commit_Signature = _String{"signature"} + fieldName__Commit_MergeTag = _String{"mergeTag"} + fieldName__Commit_Other = _String{"other"} ) var _ ipld.Node = (Commit)(&_Commit{}) var _ schema.TypedNode = (Commit)(&_Commit{}) @@ -302,36 +302,36 @@ func (Commit) Kind() ipld.Kind { } func (n Commit) LookupByString(key string) (ipld.Node, error) { switch key { - case "GitTree": - return &n.GitTree, nil - case "Parents": - return &n.Parents, nil - case "Message": - return &n.Message, nil - case "Author": - if n.Author.m == schema.Maybe_Absent { + case "tree": + return &n.tree, nil + case "parents": + return &n.parents, nil + case "message": + return &n.message, nil + case "author": + if n.author.m == schema.Maybe_Absent { return ipld.Absent, nil } - return n.Author.v, nil - case "Committer": - if n.Committer.m == schema.Maybe_Absent { + return n.author.v, nil + case "committer": + if n.committer.m == schema.Maybe_Absent { return ipld.Absent, nil } - return n.Committer.v, nil - case "Encoding": - if n.Encoding.m == schema.Maybe_Absent { + return n.committer.v, nil + case "encoding": + if n.encoding.m == schema.Maybe_Absent { return ipld.Absent, nil } - return n.Encoding.v, nil - case "Sig": - if n.Sig.m == schema.Maybe_Absent { + return n.encoding.v, nil + case "signature": + if n.signature.m == schema.Maybe_Absent { return ipld.Absent, nil } - return n.Sig.v, nil - case "MergeTag": - return &n.MergeTag, nil - case "Other": - return &n.Other, nil + return n.signature.v, nil + case "mergeTag": + return &n.mergeTag, nil + case "other": + return &n.other, nil default: return nil, schema.ErrNoSuchField{Type: nil /*TODO*/, Field: ipld.PathSegmentOfString(key)} } @@ -364,48 +364,48 @@ func (itr *_Commit__MapItr) Next() (k ipld.Node, v ipld.Node, _ error) { } switch itr.idx { case 0: - k = &fieldName__Commit_GitTree - v = &itr.n.GitTree + k = &fieldName__Commit_Tree + v = &itr.n.tree case 1: k = &fieldName__Commit_Parents - v = &itr.n.Parents + v = &itr.n.parents case 2: k = &fieldName__Commit_Message - v = &itr.n.Message + v = &itr.n.message case 3: k = &fieldName__Commit_Author - if itr.n.Author.m == schema.Maybe_Absent { + if itr.n.author.m == schema.Maybe_Absent { v = ipld.Absent break } - v = itr.n.Author.v + v = itr.n.author.v case 4: k = &fieldName__Commit_Committer - if itr.n.Committer.m == schema.Maybe_Absent { + if itr.n.committer.m == schema.Maybe_Absent { v = ipld.Absent break } - v = itr.n.Committer.v + v = itr.n.committer.v case 5: k = &fieldName__Commit_Encoding - if itr.n.Encoding.m == schema.Maybe_Absent { + if itr.n.encoding.m == schema.Maybe_Absent { v = ipld.Absent break } - v = itr.n.Encoding.v + v = itr.n.encoding.v case 6: - k = &fieldName__Commit_Sig - if itr.n.Sig.m == schema.Maybe_Absent { + k = &fieldName__Commit_Signature + if itr.n.signature.m == schema.Maybe_Absent { v = ipld.Absent break } - v = itr.n.Sig.v + v = itr.n.signature.v case 7: k = &fieldName__Commit_MergeTag - v = &itr.n.MergeTag + v = &itr.n.mergeTag case 8: k = &fieldName__Commit_Other - v = &itr.n.Other + v = &itr.n.other default: panic("unreachable") } @@ -482,39 +482,39 @@ type _Commit__Assembler struct { f int cm schema.Maybe - ca_GitTree _LinkTree__Assembler - ca_Parents _ListParents__Assembler - ca_Message _String__Assembler - ca_Author _PersonInfo__Assembler - ca_Committer _PersonInfo__Assembler - ca_Encoding _String__Assembler - ca_Sig _GpgSig__Assembler - ca_MergeTag _ListTag__Assembler - ca_Other _ListString__Assembler + ca_tree _LinkTree__Assembler + ca_parents _ListParents__Assembler + ca_message _String__Assembler + ca_author _PersonInfo__Assembler + ca_committer _PersonInfo__Assembler + ca_encoding _String__Assembler + ca_signature _GpgSig__Assembler + ca_mergeTag _ListTag__Assembler + ca_other _ListString__Assembler } func (na *_Commit__Assembler) reset() { na.state = maState_initial na.s = 0 - na.ca_GitTree.reset() - na.ca_Parents.reset() - na.ca_Message.reset() - na.ca_Author.reset() - na.ca_Committer.reset() - na.ca_Encoding.reset() - na.ca_Sig.reset() - na.ca_MergeTag.reset() - na.ca_Other.reset() + na.ca_tree.reset() + na.ca_parents.reset() + na.ca_message.reset() + na.ca_author.reset() + na.ca_committer.reset() + na.ca_encoding.reset() + na.ca_signature.reset() + na.ca_mergeTag.reset() + na.ca_other.reset() } var ( - fieldBit__Commit_GitTree = 1 << 0 + fieldBit__Commit_Tree = 1 << 0 fieldBit__Commit_Parents = 1 << 1 fieldBit__Commit_Message = 1 << 2 fieldBit__Commit_Author = 1 << 3 fieldBit__Commit_Committer = 1 << 4 fieldBit__Commit_Encoding = 1 << 5 - fieldBit__Commit_Sig = 1 << 6 + fieldBit__Commit_Signature = 1 << 6 fieldBit__Commit_MergeTag = 1 << 7 fieldBit__Commit_Other = 1 << 8 fieldBits__Commit_sufficient = 0 + 1<<0 + 1<<1 + 1<<2 + 1<<7 + 1<<8 @@ -614,7 +614,7 @@ func (ma *_Commit__Assembler) valueFinishTidy() bool { case 0: switch ma.cm { case schema.Maybe_Value: - ma.ca_GitTree.w = nil + ma.ca_tree.w = nil ma.cm = schema.Maybe_Absent ma.state = maState_initial return true @@ -624,7 +624,7 @@ func (ma *_Commit__Assembler) valueFinishTidy() bool { case 1: switch ma.cm { case schema.Maybe_Value: - ma.ca_Parents.w = nil + ma.ca_parents.w = nil ma.cm = schema.Maybe_Absent ma.state = maState_initial return true @@ -634,7 +634,7 @@ func (ma *_Commit__Assembler) valueFinishTidy() bool { case 2: switch ma.cm { case schema.Maybe_Value: - ma.ca_Message.w = nil + ma.ca_message.w = nil ma.cm = schema.Maybe_Absent ma.state = maState_initial return true @@ -642,36 +642,36 @@ func (ma *_Commit__Assembler) valueFinishTidy() bool { return false } case 3: - switch ma.w.Author.m { + switch ma.w.author.m { case schema.Maybe_Value: - ma.w.Author.v = ma.ca_Author.w + ma.w.author.v = ma.ca_author.w ma.state = maState_initial return true default: return false } case 4: - switch ma.w.Committer.m { + switch ma.w.committer.m { case schema.Maybe_Value: - ma.w.Committer.v = ma.ca_Committer.w + ma.w.committer.v = ma.ca_committer.w ma.state = maState_initial return true default: return false } case 5: - switch ma.w.Encoding.m { + switch ma.w.encoding.m { case schema.Maybe_Value: - ma.w.Encoding.v = ma.ca_Encoding.w + ma.w.encoding.v = ma.ca_encoding.w ma.state = maState_initial return true default: return false } case 6: - switch ma.w.Sig.m { + switch ma.w.signature.m { case schema.Maybe_Value: - ma.w.Sig.v = ma.ca_Sig.w + ma.w.signature.v = ma.ca_signature.w ma.state = maState_initial return true default: @@ -680,7 +680,7 @@ func (ma *_Commit__Assembler) valueFinishTidy() bool { case 7: switch ma.cm { case schema.Maybe_Value: - ma.ca_MergeTag.w = nil + ma.ca_mergeTag.w = nil ma.cm = schema.Maybe_Absent ma.state = maState_initial return true @@ -690,7 +690,7 @@ func (ma *_Commit__Assembler) valueFinishTidy() bool { case 8: switch ma.cm { case schema.Maybe_Value: - ma.ca_Other.w = nil + ma.ca_other.w = nil ma.cm = schema.Maybe_Absent ma.state = maState_initial return true @@ -717,96 +717,96 @@ func (ma *_Commit__Assembler) AssembleEntry(k string) (ipld.NodeAssembler, error panic("invalid state: AssembleEntry cannot be called on an assembler that's already finished") } switch k { - case "GitTree": - if ma.s&fieldBit__Commit_GitTree != 0 { - return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_GitTree} + case "tree": + if ma.s&fieldBit__Commit_Tree != 0 { + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Tree} } - ma.s += fieldBit__Commit_GitTree + ma.s += fieldBit__Commit_Tree ma.state = maState_midValue ma.f = 0 - ma.ca_GitTree.w = &ma.w.GitTree - ma.ca_GitTree.m = &ma.cm - return &ma.ca_GitTree, nil - case "Parents": + ma.ca_tree.w = &ma.w.tree + ma.ca_tree.m = &ma.cm + return &ma.ca_tree, nil + case "parents": if ma.s&fieldBit__Commit_Parents != 0 { return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Parents} } ma.s += fieldBit__Commit_Parents ma.state = maState_midValue ma.f = 1 - ma.ca_Parents.w = &ma.w.Parents - ma.ca_Parents.m = &ma.cm - return &ma.ca_Parents, nil - case "Message": + ma.ca_parents.w = &ma.w.parents + ma.ca_parents.m = &ma.cm + return &ma.ca_parents, nil + case "message": if ma.s&fieldBit__Commit_Message != 0 { return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Message} } ma.s += fieldBit__Commit_Message ma.state = maState_midValue ma.f = 2 - ma.ca_Message.w = &ma.w.Message - ma.ca_Message.m = &ma.cm - return &ma.ca_Message, nil - case "Author": + ma.ca_message.w = &ma.w.message + ma.ca_message.m = &ma.cm + return &ma.ca_message, nil + case "author": if ma.s&fieldBit__Commit_Author != 0 { return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Author} } ma.s += fieldBit__Commit_Author ma.state = maState_midValue ma.f = 3 - ma.ca_Author.w = ma.w.Author.v - ma.ca_Author.m = &ma.w.Author.m - return &ma.ca_Author, nil - case "Committer": + ma.ca_author.w = ma.w.author.v + ma.ca_author.m = &ma.w.author.m + return &ma.ca_author, nil + case "committer": if ma.s&fieldBit__Commit_Committer != 0 { return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Committer} } ma.s += fieldBit__Commit_Committer ma.state = maState_midValue ma.f = 4 - ma.ca_Committer.w = ma.w.Committer.v - ma.ca_Committer.m = &ma.w.Committer.m - return &ma.ca_Committer, nil - case "Encoding": + ma.ca_committer.w = ma.w.committer.v + ma.ca_committer.m = &ma.w.committer.m + return &ma.ca_committer, nil + case "encoding": if ma.s&fieldBit__Commit_Encoding != 0 { return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Encoding} } ma.s += fieldBit__Commit_Encoding ma.state = maState_midValue ma.f = 5 - ma.ca_Encoding.w = ma.w.Encoding.v - ma.ca_Encoding.m = &ma.w.Encoding.m - return &ma.ca_Encoding, nil - case "Sig": - if ma.s&fieldBit__Commit_Sig != 0 { - return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Sig} - } - ma.s += fieldBit__Commit_Sig + ma.ca_encoding.w = ma.w.encoding.v + ma.ca_encoding.m = &ma.w.encoding.m + return &ma.ca_encoding, nil + case "signature": + if ma.s&fieldBit__Commit_Signature != 0 { + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Signature} + } + ma.s += fieldBit__Commit_Signature ma.state = maState_midValue ma.f = 6 - ma.ca_Sig.w = ma.w.Sig.v - ma.ca_Sig.m = &ma.w.Sig.m - return &ma.ca_Sig, nil - case "MergeTag": + ma.ca_signature.w = ma.w.signature.v + ma.ca_signature.m = &ma.w.signature.m + return &ma.ca_signature, nil + case "mergeTag": if ma.s&fieldBit__Commit_MergeTag != 0 { return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_MergeTag} } ma.s += fieldBit__Commit_MergeTag ma.state = maState_midValue ma.f = 7 - ma.ca_MergeTag.w = &ma.w.MergeTag - ma.ca_MergeTag.m = &ma.cm - return &ma.ca_MergeTag, nil - case "Other": + ma.ca_mergeTag.w = &ma.w.mergeTag + ma.ca_mergeTag.m = &ma.cm + return &ma.ca_mergeTag, nil + case "other": if ma.s&fieldBit__Commit_Other != 0 { return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Other} } ma.s += fieldBit__Commit_Other ma.state = maState_midValue ma.f = 8 - ma.ca_Other.w = &ma.w.Other - ma.ca_Other.m = &ma.cm - return &ma.ca_Other, nil + ma.ca_other.w = &ma.w.other + ma.ca_other.m = &ma.cm + return &ma.ca_other, nil } return nil, ipld.ErrInvalidKey{TypeName: "ipldgit.Commit", Key: &_String{k}} } @@ -844,41 +844,41 @@ func (ma *_Commit__Assembler) AssembleValue() ipld.NodeAssembler { ma.state = maState_midValue switch ma.f { case 0: - ma.ca_GitTree.w = &ma.w.GitTree - ma.ca_GitTree.m = &ma.cm - return &ma.ca_GitTree + ma.ca_tree.w = &ma.w.tree + ma.ca_tree.m = &ma.cm + return &ma.ca_tree case 1: - ma.ca_Parents.w = &ma.w.Parents - ma.ca_Parents.m = &ma.cm - return &ma.ca_Parents + ma.ca_parents.w = &ma.w.parents + ma.ca_parents.m = &ma.cm + return &ma.ca_parents case 2: - ma.ca_Message.w = &ma.w.Message - ma.ca_Message.m = &ma.cm - return &ma.ca_Message + ma.ca_message.w = &ma.w.message + ma.ca_message.m = &ma.cm + return &ma.ca_message case 3: - ma.ca_Author.w = ma.w.Author.v - ma.ca_Author.m = &ma.w.Author.m - return &ma.ca_Author + ma.ca_author.w = ma.w.author.v + ma.ca_author.m = &ma.w.author.m + return &ma.ca_author case 4: - ma.ca_Committer.w = ma.w.Committer.v - ma.ca_Committer.m = &ma.w.Committer.m - return &ma.ca_Committer + ma.ca_committer.w = ma.w.committer.v + ma.ca_committer.m = &ma.w.committer.m + return &ma.ca_committer case 5: - ma.ca_Encoding.w = ma.w.Encoding.v - ma.ca_Encoding.m = &ma.w.Encoding.m - return &ma.ca_Encoding + ma.ca_encoding.w = ma.w.encoding.v + ma.ca_encoding.m = &ma.w.encoding.m + return &ma.ca_encoding case 6: - ma.ca_Sig.w = ma.w.Sig.v - ma.ca_Sig.m = &ma.w.Sig.m - return &ma.ca_Sig + ma.ca_signature.w = ma.w.signature.v + ma.ca_signature.m = &ma.w.signature.m + return &ma.ca_signature case 7: - ma.ca_MergeTag.w = &ma.w.MergeTag - ma.ca_MergeTag.m = &ma.cm - return &ma.ca_MergeTag + ma.ca_mergeTag.w = &ma.w.mergeTag + ma.ca_mergeTag.m = &ma.cm + return &ma.ca_mergeTag case 8: - ma.ca_Other.w = &ma.w.Other - ma.ca_Other.m = &ma.cm - return &ma.ca_Other + ma.ca_other.w = &ma.w.other + ma.ca_other.m = &ma.cm + return &ma.ca_other default: panic("unreachable") } @@ -900,20 +900,20 @@ func (ma *_Commit__Assembler) Finish() error { } if ma.s&fieldBits__Commit_sufficient != fieldBits__Commit_sufficient { err := ipld.ErrMissingRequiredField{Missing: make([]string, 0)} - if ma.s&fieldBit__Commit_GitTree == 0 { - err.Missing = append(err.Missing, "GitTree") + if ma.s&fieldBit__Commit_Tree == 0 { + err.Missing = append(err.Missing, "tree") } if ma.s&fieldBit__Commit_Parents == 0 { - err.Missing = append(err.Missing, "Parents") + err.Missing = append(err.Missing, "parents") } if ma.s&fieldBit__Commit_Message == 0 { - err.Missing = append(err.Missing, "Message") + err.Missing = append(err.Missing, "message") } if ma.s&fieldBit__Commit_MergeTag == 0 { - err.Missing = append(err.Missing, "MergeTag") + err.Missing = append(err.Missing, "mergeTag") } if ma.s&fieldBit__Commit_Other == 0 { - err.Missing = append(err.Missing, "Other") + err.Missing = append(err.Missing, "other") } return err } @@ -953,63 +953,63 @@ func (ka *_Commit__KeyAssembler) AssignString(k string) error { panic("misuse: KeyAssembler held beyond its valid lifetime") } switch k { - case "GitTree": - if ka.s&fieldBit__Commit_GitTree != 0 { - return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_GitTree} + case "tree": + if ka.s&fieldBit__Commit_Tree != 0 { + return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Tree} } - ka.s += fieldBit__Commit_GitTree + ka.s += fieldBit__Commit_Tree ka.state = maState_expectValue ka.f = 0 - case "Parents": + case "parents": if ka.s&fieldBit__Commit_Parents != 0 { return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Parents} } ka.s += fieldBit__Commit_Parents ka.state = maState_expectValue ka.f = 1 - case "Message": + case "message": if ka.s&fieldBit__Commit_Message != 0 { return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Message} } ka.s += fieldBit__Commit_Message ka.state = maState_expectValue ka.f = 2 - case "Author": + case "author": if ka.s&fieldBit__Commit_Author != 0 { return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Author} } ka.s += fieldBit__Commit_Author ka.state = maState_expectValue ka.f = 3 - case "Committer": + case "committer": if ka.s&fieldBit__Commit_Committer != 0 { return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Committer} } ka.s += fieldBit__Commit_Committer ka.state = maState_expectValue ka.f = 4 - case "Encoding": + case "encoding": if ka.s&fieldBit__Commit_Encoding != 0 { return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Encoding} } ka.s += fieldBit__Commit_Encoding ka.state = maState_expectValue ka.f = 5 - case "Sig": - if ka.s&fieldBit__Commit_Sig != 0 { - return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Sig} + case "signature": + if ka.s&fieldBit__Commit_Signature != 0 { + return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Signature} } - ka.s += fieldBit__Commit_Sig + ka.s += fieldBit__Commit_Signature ka.state = maState_expectValue ka.f = 6 - case "MergeTag": + case "mergeTag": if ka.s&fieldBit__Commit_MergeTag != 0 { return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_MergeTag} } ka.s += fieldBit__Commit_MergeTag ka.state = maState_expectValue ka.f = 7 - case "Other": + case "other": if ka.s&fieldBit__Commit_Other != 0 { return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Other} } @@ -1047,15 +1047,15 @@ func (n Commit) Representation() ipld.Node { type _Commit__Repr _Commit var ( - fieldName__Commit_GitTree_serial = _String{"GitTree"} - fieldName__Commit_Parents_serial = _String{"Parents"} - fieldName__Commit_Message_serial = _String{"Message"} - fieldName__Commit_Author_serial = _String{"Author"} - fieldName__Commit_Committer_serial = _String{"Committer"} - fieldName__Commit_Encoding_serial = _String{"Encoding"} - fieldName__Commit_Sig_serial = _String{"Sig"} - fieldName__Commit_MergeTag_serial = _String{"MergeTag"} - fieldName__Commit_Other_serial = _String{"Other"} + fieldName__Commit_Tree_serial = _String{"tree"} + fieldName__Commit_Parents_serial = _String{"parents"} + fieldName__Commit_Message_serial = _String{"message"} + fieldName__Commit_Author_serial = _String{"author"} + fieldName__Commit_Committer_serial = _String{"committer"} + fieldName__Commit_Encoding_serial = _String{"encoding"} + fieldName__Commit_Signature_serial = _String{"signature"} + fieldName__Commit_MergeTag_serial = _String{"mergeTag"} + fieldName__Commit_Other_serial = _String{"other"} ) var _ ipld.Node = &_Commit__Repr{} @@ -1064,36 +1064,36 @@ func (_Commit__Repr) Kind() ipld.Kind { } func (n *_Commit__Repr) LookupByString(key string) (ipld.Node, error) { switch key { - case "GitTree": - return n.GitTree.Representation(), nil - case "Parents": - return n.Parents.Representation(), nil - case "Message": - return n.Message.Representation(), nil - case "Author": - if n.Author.m == schema.Maybe_Absent { + case "tree": + return n.tree.Representation(), nil + case "parents": + return n.parents.Representation(), nil + case "message": + return n.message.Representation(), nil + case "author": + if n.author.m == schema.Maybe_Absent { return ipld.Absent, ipld.ErrNotExists{Segment: ipld.PathSegmentOfString(key)} } - return n.Author.v.Representation(), nil - case "Committer": - if n.Committer.m == schema.Maybe_Absent { + return n.author.v.Representation(), nil + case "committer": + if n.committer.m == schema.Maybe_Absent { return ipld.Absent, ipld.ErrNotExists{Segment: ipld.PathSegmentOfString(key)} } - return n.Committer.v.Representation(), nil - case "Encoding": - if n.Encoding.m == schema.Maybe_Absent { + return n.committer.v.Representation(), nil + case "encoding": + if n.encoding.m == schema.Maybe_Absent { return ipld.Absent, ipld.ErrNotExists{Segment: ipld.PathSegmentOfString(key)} } - return n.Encoding.v.Representation(), nil - case "Sig": - if n.Sig.m == schema.Maybe_Absent { + return n.encoding.v.Representation(), nil + case "signature": + if n.signature.m == schema.Maybe_Absent { return ipld.Absent, ipld.ErrNotExists{Segment: ipld.PathSegmentOfString(key)} } - return n.Sig.v.Representation(), nil - case "MergeTag": - return n.MergeTag.Representation(), nil - case "Other": - return n.Other.Representation(), nil + return n.signature.v.Representation(), nil + case "mergeTag": + return n.mergeTag.Representation(), nil + case "other": + return n.other.Representation(), nil default: return nil, schema.ErrNoSuchField{Type: nil /*TODO*/, Field: ipld.PathSegmentOfString(key)} } @@ -1127,48 +1127,48 @@ advance: } switch itr.idx { case 0: - k = &fieldName__Commit_GitTree_serial - v = itr.n.GitTree.Representation() + k = &fieldName__Commit_Tree_serial + v = itr.n.tree.Representation() case 1: k = &fieldName__Commit_Parents_serial - v = itr.n.Parents.Representation() + v = itr.n.parents.Representation() case 2: k = &fieldName__Commit_Message_serial - v = itr.n.Message.Representation() + v = itr.n.message.Representation() case 3: k = &fieldName__Commit_Author_serial - if itr.n.Author.m == schema.Maybe_Absent { + if itr.n.author.m == schema.Maybe_Absent { itr.idx++ goto advance } - v = itr.n.Author.v.Representation() + v = itr.n.author.v.Representation() case 4: k = &fieldName__Commit_Committer_serial - if itr.n.Committer.m == schema.Maybe_Absent { + if itr.n.committer.m == schema.Maybe_Absent { itr.idx++ goto advance } - v = itr.n.Committer.v.Representation() + v = itr.n.committer.v.Representation() case 5: k = &fieldName__Commit_Encoding_serial - if itr.n.Encoding.m == schema.Maybe_Absent { + if itr.n.encoding.m == schema.Maybe_Absent { itr.idx++ goto advance } - v = itr.n.Encoding.v.Representation() + v = itr.n.encoding.v.Representation() case 6: - k = &fieldName__Commit_Sig_serial - if itr.n.Sig.m == schema.Maybe_Absent { + k = &fieldName__Commit_Signature_serial + if itr.n.signature.m == schema.Maybe_Absent { itr.idx++ goto advance } - v = itr.n.Sig.v.Representation() + v = itr.n.signature.v.Representation() case 7: k = &fieldName__Commit_MergeTag_serial - v = itr.n.MergeTag.Representation() + v = itr.n.mergeTag.Representation() case 8: k = &fieldName__Commit_Other_serial - v = itr.n.Other.Representation() + v = itr.n.other.Representation() default: panic("unreachable") } @@ -1183,16 +1183,16 @@ func (_Commit__Repr) ListIterator() ipld.ListIterator { } func (rn *_Commit__Repr) Length() int64 { l := 9 - if rn.Author.m == schema.Maybe_Absent { + if rn.author.m == schema.Maybe_Absent { l-- } - if rn.Committer.m == schema.Maybe_Absent { + if rn.committer.m == schema.Maybe_Absent { l-- } - if rn.Encoding.m == schema.Maybe_Absent { + if rn.encoding.m == schema.Maybe_Absent { l-- } - if rn.Sig.m == schema.Maybe_Absent { + if rn.signature.m == schema.Maybe_Absent { l-- } return int64(l) @@ -1257,29 +1257,29 @@ type _Commit__ReprAssembler struct { f int cm schema.Maybe - ca_GitTree _LinkTree__ReprAssembler - ca_Parents _ListParents__ReprAssembler - ca_Message _String__ReprAssembler - ca_Author _PersonInfo__ReprAssembler - ca_Committer _PersonInfo__ReprAssembler - ca_Encoding _String__ReprAssembler - ca_Sig _GpgSig__ReprAssembler - ca_MergeTag _ListTag__ReprAssembler - ca_Other _ListString__ReprAssembler + ca_tree _LinkTree__ReprAssembler + ca_parents _ListParents__ReprAssembler + ca_message _String__ReprAssembler + ca_author _PersonInfo__ReprAssembler + ca_committer _PersonInfo__ReprAssembler + ca_encoding _String__ReprAssembler + ca_signature _GpgSig__ReprAssembler + ca_mergeTag _ListTag__ReprAssembler + ca_other _ListString__ReprAssembler } func (na *_Commit__ReprAssembler) reset() { na.state = maState_initial na.s = 0 - na.ca_GitTree.reset() - na.ca_Parents.reset() - na.ca_Message.reset() - na.ca_Author.reset() - na.ca_Committer.reset() - na.ca_Encoding.reset() - na.ca_Sig.reset() - na.ca_MergeTag.reset() - na.ca_Other.reset() + na.ca_tree.reset() + na.ca_parents.reset() + na.ca_message.reset() + na.ca_author.reset() + na.ca_committer.reset() + na.ca_encoding.reset() + na.ca_signature.reset() + na.ca_mergeTag.reset() + na.ca_other.reset() } func (na *_Commit__ReprAssembler) BeginMap(int64) (ipld.MapAssembler, error) { switch *na.m { @@ -1400,36 +1400,36 @@ func (ma *_Commit__ReprAssembler) valueFinishTidy() bool { return false } case 3: - switch ma.w.Author.m { + switch ma.w.author.m { case schema.Maybe_Value: - ma.w.Author.v = ma.ca_Author.w + ma.w.author.v = ma.ca_author.w ma.state = maState_initial return true default: return false } case 4: - switch ma.w.Committer.m { + switch ma.w.committer.m { case schema.Maybe_Value: - ma.w.Committer.v = ma.ca_Committer.w + ma.w.committer.v = ma.ca_committer.w ma.state = maState_initial return true default: return false } case 5: - switch ma.w.Encoding.m { + switch ma.w.encoding.m { case schema.Maybe_Value: - ma.w.Encoding.v = ma.ca_Encoding.w + ma.w.encoding.v = ma.ca_encoding.w ma.state = maState_initial return true default: return false } case 6: - switch ma.w.Sig.m { + switch ma.w.signature.m { case schema.Maybe_Value: - ma.w.Sig.v = ma.ca_Sig.w + ma.w.signature.v = ma.ca_signature.w ma.state = maState_initial return true default: @@ -1473,100 +1473,100 @@ func (ma *_Commit__ReprAssembler) AssembleEntry(k string) (ipld.NodeAssembler, e panic("invalid state: AssembleEntry cannot be called on an assembler that's already finished") } switch k { - case "GitTree": - if ma.s&fieldBit__Commit_GitTree != 0 { - return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_GitTree_serial} + case "tree": + if ma.s&fieldBit__Commit_Tree != 0 { + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Tree_serial} } - ma.s += fieldBit__Commit_GitTree + ma.s += fieldBit__Commit_Tree ma.state = maState_midValue ma.f = 0 - ma.ca_GitTree.w = &ma.w.GitTree - ma.ca_GitTree.m = &ma.cm - return &ma.ca_GitTree, nil - case "Parents": + ma.ca_tree.w = &ma.w.tree + ma.ca_tree.m = &ma.cm + return &ma.ca_tree, nil + case "parents": if ma.s&fieldBit__Commit_Parents != 0 { return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Parents_serial} } ma.s += fieldBit__Commit_Parents ma.state = maState_midValue ma.f = 1 - ma.ca_Parents.w = &ma.w.Parents - ma.ca_Parents.m = &ma.cm - return &ma.ca_Parents, nil - case "Message": + ma.ca_parents.w = &ma.w.parents + ma.ca_parents.m = &ma.cm + return &ma.ca_parents, nil + case "message": if ma.s&fieldBit__Commit_Message != 0 { return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Message_serial} } ma.s += fieldBit__Commit_Message ma.state = maState_midValue ma.f = 2 - ma.ca_Message.w = &ma.w.Message - ma.ca_Message.m = &ma.cm - return &ma.ca_Message, nil - case "Author": + ma.ca_message.w = &ma.w.message + ma.ca_message.m = &ma.cm + return &ma.ca_message, nil + case "author": if ma.s&fieldBit__Commit_Author != 0 { return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Author_serial} } ma.s += fieldBit__Commit_Author ma.state = maState_midValue ma.f = 3 - ma.ca_Author.w = ma.w.Author.v - ma.ca_Author.m = &ma.w.Author.m + ma.ca_author.w = ma.w.author.v + ma.ca_author.m = &ma.w.author.m - return &ma.ca_Author, nil - case "Committer": + return &ma.ca_author, nil + case "committer": if ma.s&fieldBit__Commit_Committer != 0 { return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Committer_serial} } ma.s += fieldBit__Commit_Committer ma.state = maState_midValue ma.f = 4 - ma.ca_Committer.w = ma.w.Committer.v - ma.ca_Committer.m = &ma.w.Committer.m + ma.ca_committer.w = ma.w.committer.v + ma.ca_committer.m = &ma.w.committer.m - return &ma.ca_Committer, nil - case "Encoding": + return &ma.ca_committer, nil + case "encoding": if ma.s&fieldBit__Commit_Encoding != 0 { return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Encoding_serial} } ma.s += fieldBit__Commit_Encoding ma.state = maState_midValue ma.f = 5 - ma.ca_Encoding.w = ma.w.Encoding.v - ma.ca_Encoding.m = &ma.w.Encoding.m + ma.ca_encoding.w = ma.w.encoding.v + ma.ca_encoding.m = &ma.w.encoding.m - return &ma.ca_Encoding, nil - case "Sig": - if ma.s&fieldBit__Commit_Sig != 0 { - return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Sig_serial} + return &ma.ca_encoding, nil + case "signature": + if ma.s&fieldBit__Commit_Signature != 0 { + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Signature_serial} } - ma.s += fieldBit__Commit_Sig + ma.s += fieldBit__Commit_Signature ma.state = maState_midValue ma.f = 6 - ma.ca_Sig.w = ma.w.Sig.v - ma.ca_Sig.m = &ma.w.Sig.m + ma.ca_signature.w = ma.w.signature.v + ma.ca_signature.m = &ma.w.signature.m - return &ma.ca_Sig, nil - case "MergeTag": + return &ma.ca_signature, nil + case "mergeTag": if ma.s&fieldBit__Commit_MergeTag != 0 { return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_MergeTag_serial} } ma.s += fieldBit__Commit_MergeTag ma.state = maState_midValue ma.f = 7 - ma.ca_MergeTag.w = &ma.w.MergeTag - ma.ca_MergeTag.m = &ma.cm - return &ma.ca_MergeTag, nil - case "Other": + ma.ca_mergeTag.w = &ma.w.mergeTag + ma.ca_mergeTag.m = &ma.cm + return &ma.ca_mergeTag, nil + case "other": if ma.s&fieldBit__Commit_Other != 0 { return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Other_serial} } ma.s += fieldBit__Commit_Other ma.state = maState_midValue ma.f = 8 - ma.ca_Other.w = &ma.w.Other - ma.ca_Other.m = &ma.cm - return &ma.ca_Other, nil + ma.ca_other.w = &ma.w.other + ma.ca_other.m = &ma.cm + return &ma.ca_other, nil default: } return nil, ipld.ErrInvalidKey{TypeName: "ipldgit.Commit.Repr", Key: &_String{k}} @@ -1605,45 +1605,45 @@ func (ma *_Commit__ReprAssembler) AssembleValue() ipld.NodeAssembler { ma.state = maState_midValue switch ma.f { case 0: - ma.ca_GitTree.w = &ma.w.GitTree - ma.ca_GitTree.m = &ma.cm - return &ma.ca_GitTree + ma.ca_tree.w = &ma.w.tree + ma.ca_tree.m = &ma.cm + return &ma.ca_tree case 1: - ma.ca_Parents.w = &ma.w.Parents - ma.ca_Parents.m = &ma.cm - return &ma.ca_Parents + ma.ca_parents.w = &ma.w.parents + ma.ca_parents.m = &ma.cm + return &ma.ca_parents case 2: - ma.ca_Message.w = &ma.w.Message - ma.ca_Message.m = &ma.cm - return &ma.ca_Message + ma.ca_message.w = &ma.w.message + ma.ca_message.m = &ma.cm + return &ma.ca_message case 3: - ma.ca_Author.w = ma.w.Author.v - ma.ca_Author.m = &ma.w.Author.m + ma.ca_author.w = ma.w.author.v + ma.ca_author.m = &ma.w.author.m - return &ma.ca_Author + return &ma.ca_author case 4: - ma.ca_Committer.w = ma.w.Committer.v - ma.ca_Committer.m = &ma.w.Committer.m + ma.ca_committer.w = ma.w.committer.v + ma.ca_committer.m = &ma.w.committer.m - return &ma.ca_Committer + return &ma.ca_committer case 5: - ma.ca_Encoding.w = ma.w.Encoding.v - ma.ca_Encoding.m = &ma.w.Encoding.m + ma.ca_encoding.w = ma.w.encoding.v + ma.ca_encoding.m = &ma.w.encoding.m - return &ma.ca_Encoding + return &ma.ca_encoding case 6: - ma.ca_Sig.w = ma.w.Sig.v - ma.ca_Sig.m = &ma.w.Sig.m + ma.ca_signature.w = ma.w.signature.v + ma.ca_signature.m = &ma.w.signature.m - return &ma.ca_Sig + return &ma.ca_signature case 7: - ma.ca_MergeTag.w = &ma.w.MergeTag - ma.ca_MergeTag.m = &ma.cm - return &ma.ca_MergeTag + ma.ca_mergeTag.w = &ma.w.mergeTag + ma.ca_mergeTag.m = &ma.cm + return &ma.ca_mergeTag case 8: - ma.ca_Other.w = &ma.w.Other - ma.ca_Other.m = &ma.cm - return &ma.ca_Other + ma.ca_other.w = &ma.w.other + ma.ca_other.m = &ma.cm + return &ma.ca_other default: panic("unreachable") } @@ -1665,20 +1665,20 @@ func (ma *_Commit__ReprAssembler) Finish() error { } if ma.s&fieldBits__Commit_sufficient != fieldBits__Commit_sufficient { err := ipld.ErrMissingRequiredField{Missing: make([]string, 0)} - if ma.s&fieldBit__Commit_GitTree == 0 { - err.Missing = append(err.Missing, "GitTree") + if ma.s&fieldBit__Commit_Tree == 0 { + err.Missing = append(err.Missing, "tree") } if ma.s&fieldBit__Commit_Parents == 0 { - err.Missing = append(err.Missing, "Parents") + err.Missing = append(err.Missing, "parents") } if ma.s&fieldBit__Commit_Message == 0 { - err.Missing = append(err.Missing, "Message") + err.Missing = append(err.Missing, "message") } if ma.s&fieldBit__Commit_MergeTag == 0 { - err.Missing = append(err.Missing, "MergeTag") + err.Missing = append(err.Missing, "mergeTag") } if ma.s&fieldBit__Commit_Other == 0 { - err.Missing = append(err.Missing, "Other") + err.Missing = append(err.Missing, "other") } return err } @@ -1718,15 +1718,15 @@ func (ka *_Commit__ReprKeyAssembler) AssignString(k string) error { panic("misuse: KeyAssembler held beyond its valid lifetime") } switch k { - case "GitTree": - if ka.s&fieldBit__Commit_GitTree != 0 { - return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_GitTree_serial} + case "tree": + if ka.s&fieldBit__Commit_Tree != 0 { + return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Tree_serial} } - ka.s += fieldBit__Commit_GitTree + ka.s += fieldBit__Commit_Tree ka.state = maState_expectValue ka.f = 0 return nil - case "Parents": + case "parents": if ka.s&fieldBit__Commit_Parents != 0 { return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Parents_serial} } @@ -1734,7 +1734,7 @@ func (ka *_Commit__ReprKeyAssembler) AssignString(k string) error { ka.state = maState_expectValue ka.f = 1 return nil - case "Message": + case "message": if ka.s&fieldBit__Commit_Message != 0 { return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Message_serial} } @@ -1742,7 +1742,7 @@ func (ka *_Commit__ReprKeyAssembler) AssignString(k string) error { ka.state = maState_expectValue ka.f = 2 return nil - case "Author": + case "author": if ka.s&fieldBit__Commit_Author != 0 { return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Author_serial} } @@ -1750,7 +1750,7 @@ func (ka *_Commit__ReprKeyAssembler) AssignString(k string) error { ka.state = maState_expectValue ka.f = 3 return nil - case "Committer": + case "committer": if ka.s&fieldBit__Commit_Committer != 0 { return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Committer_serial} } @@ -1758,7 +1758,7 @@ func (ka *_Commit__ReprKeyAssembler) AssignString(k string) error { ka.state = maState_expectValue ka.f = 4 return nil - case "Encoding": + case "encoding": if ka.s&fieldBit__Commit_Encoding != 0 { return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Encoding_serial} } @@ -1766,15 +1766,15 @@ func (ka *_Commit__ReprKeyAssembler) AssignString(k string) error { ka.state = maState_expectValue ka.f = 5 return nil - case "Sig": - if ka.s&fieldBit__Commit_Sig != 0 { - return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Sig_serial} + case "signature": + if ka.s&fieldBit__Commit_Signature != 0 { + return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Signature_serial} } - ka.s += fieldBit__Commit_Sig + ka.s += fieldBit__Commit_Signature ka.state = maState_expectValue ka.f = 6 return nil - case "MergeTag": + case "mergeTag": if ka.s&fieldBit__Commit_MergeTag != 0 { return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_MergeTag_serial} } @@ -1782,7 +1782,7 @@ func (ka *_Commit__ReprKeyAssembler) AssignString(k string) error { ka.state = maState_expectValue ka.f = 7 return nil - case "Other": + case "other": if ka.s&fieldBit__Commit_Other != 0 { return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Other_serial} } @@ -4278,16 +4278,16 @@ func (la *_ListTag__ReprAssembler) ValuePrototype(_ int64) ipld.NodePrototype { } func (n _PersonInfo) FieldName() String { - return &n.Name + return &n.name } func (n _PersonInfo) FieldEmail() String { - return &n.Email + return &n.email } func (n _PersonInfo) FieldDate() String { - return &n.Date + return &n.date } func (n _PersonInfo) FieldTimezone() String { - return &n.Timezone + return &n.timezone } type _PersonInfo__Maybe struct { @@ -4325,10 +4325,10 @@ func (m MaybePersonInfo) Must() PersonInfo { } var ( - fieldName__PersonInfo_Name = _String{"Name"} - fieldName__PersonInfo_Email = _String{"Email"} - fieldName__PersonInfo_Date = _String{"Date"} - fieldName__PersonInfo_Timezone = _String{"Timezone"} + fieldName__PersonInfo_Name = _String{"name"} + fieldName__PersonInfo_Email = _String{"email"} + fieldName__PersonInfo_Date = _String{"date"} + fieldName__PersonInfo_Timezone = _String{"timezone"} ) var _ ipld.Node = (PersonInfo)(&_PersonInfo{}) var _ schema.TypedNode = (PersonInfo)(&_PersonInfo{}) @@ -4338,14 +4338,14 @@ func (PersonInfo) Kind() ipld.Kind { } func (n PersonInfo) LookupByString(key string) (ipld.Node, error) { switch key { - case "Name": - return &n.Name, nil - case "Email": - return &n.Email, nil - case "Date": - return &n.Date, nil - case "Timezone": - return &n.Timezone, nil + case "name": + return &n.name, nil + case "email": + return &n.email, nil + case "date": + return &n.date, nil + case "timezone": + return &n.timezone, nil default: return nil, schema.ErrNoSuchField{Type: nil /*TODO*/, Field: ipld.PathSegmentOfString(key)} } @@ -4379,16 +4379,16 @@ func (itr *_PersonInfo__MapItr) Next() (k ipld.Node, v ipld.Node, _ error) { switch itr.idx { case 0: k = &fieldName__PersonInfo_Name - v = &itr.n.Name + v = &itr.n.name case 1: k = &fieldName__PersonInfo_Email - v = &itr.n.Email + v = &itr.n.email case 2: k = &fieldName__PersonInfo_Date - v = &itr.n.Date + v = &itr.n.date case 3: k = &fieldName__PersonInfo_Timezone - v = &itr.n.Timezone + v = &itr.n.timezone default: panic("unreachable") } @@ -4465,19 +4465,19 @@ type _PersonInfo__Assembler struct { f int cm schema.Maybe - ca_Name _String__Assembler - ca_Email _String__Assembler - ca_Date _String__Assembler - ca_Timezone _String__Assembler + ca_name _String__Assembler + ca_email _String__Assembler + ca_date _String__Assembler + ca_timezone _String__Assembler } func (na *_PersonInfo__Assembler) reset() { na.state = maState_initial na.s = 0 - na.ca_Name.reset() - na.ca_Email.reset() - na.ca_Date.reset() - na.ca_Timezone.reset() + na.ca_name.reset() + na.ca_email.reset() + na.ca_date.reset() + na.ca_timezone.reset() } var ( @@ -4582,7 +4582,7 @@ func (ma *_PersonInfo__Assembler) valueFinishTidy() bool { case 0: switch ma.cm { case schema.Maybe_Value: - ma.ca_Name.w = nil + ma.ca_name.w = nil ma.cm = schema.Maybe_Absent ma.state = maState_initial return true @@ -4592,7 +4592,7 @@ func (ma *_PersonInfo__Assembler) valueFinishTidy() bool { case 1: switch ma.cm { case schema.Maybe_Value: - ma.ca_Email.w = nil + ma.ca_email.w = nil ma.cm = schema.Maybe_Absent ma.state = maState_initial return true @@ -4602,7 +4602,7 @@ func (ma *_PersonInfo__Assembler) valueFinishTidy() bool { case 2: switch ma.cm { case schema.Maybe_Value: - ma.ca_Date.w = nil + ma.ca_date.w = nil ma.cm = schema.Maybe_Absent ma.state = maState_initial return true @@ -4612,7 +4612,7 @@ func (ma *_PersonInfo__Assembler) valueFinishTidy() bool { case 3: switch ma.cm { case schema.Maybe_Value: - ma.ca_Timezone.w = nil + ma.ca_timezone.w = nil ma.cm = schema.Maybe_Absent ma.state = maState_initial return true @@ -4639,46 +4639,46 @@ func (ma *_PersonInfo__Assembler) AssembleEntry(k string) (ipld.NodeAssembler, e panic("invalid state: AssembleEntry cannot be called on an assembler that's already finished") } switch k { - case "Name": + case "name": if ma.s&fieldBit__PersonInfo_Name != 0 { return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Name} } ma.s += fieldBit__PersonInfo_Name ma.state = maState_midValue ma.f = 0 - ma.ca_Name.w = &ma.w.Name - ma.ca_Name.m = &ma.cm - return &ma.ca_Name, nil - case "Email": + ma.ca_name.w = &ma.w.name + ma.ca_name.m = &ma.cm + return &ma.ca_name, nil + case "email": if ma.s&fieldBit__PersonInfo_Email != 0 { return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Email} } ma.s += fieldBit__PersonInfo_Email ma.state = maState_midValue ma.f = 1 - ma.ca_Email.w = &ma.w.Email - ma.ca_Email.m = &ma.cm - return &ma.ca_Email, nil - case "Date": + ma.ca_email.w = &ma.w.email + ma.ca_email.m = &ma.cm + return &ma.ca_email, nil + case "date": if ma.s&fieldBit__PersonInfo_Date != 0 { return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Date} } ma.s += fieldBit__PersonInfo_Date ma.state = maState_midValue ma.f = 2 - ma.ca_Date.w = &ma.w.Date - ma.ca_Date.m = &ma.cm - return &ma.ca_Date, nil - case "Timezone": + ma.ca_date.w = &ma.w.date + ma.ca_date.m = &ma.cm + return &ma.ca_date, nil + case "timezone": if ma.s&fieldBit__PersonInfo_Timezone != 0 { return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Timezone} } ma.s += fieldBit__PersonInfo_Timezone ma.state = maState_midValue ma.f = 3 - ma.ca_Timezone.w = &ma.w.Timezone - ma.ca_Timezone.m = &ma.cm - return &ma.ca_Timezone, nil + ma.ca_timezone.w = &ma.w.timezone + ma.ca_timezone.m = &ma.cm + return &ma.ca_timezone, nil } return nil, ipld.ErrInvalidKey{TypeName: "ipldgit.PersonInfo", Key: &_String{k}} } @@ -4716,21 +4716,21 @@ func (ma *_PersonInfo__Assembler) AssembleValue() ipld.NodeAssembler { ma.state = maState_midValue switch ma.f { case 0: - ma.ca_Name.w = &ma.w.Name - ma.ca_Name.m = &ma.cm - return &ma.ca_Name + ma.ca_name.w = &ma.w.name + ma.ca_name.m = &ma.cm + return &ma.ca_name case 1: - ma.ca_Email.w = &ma.w.Email - ma.ca_Email.m = &ma.cm - return &ma.ca_Email + ma.ca_email.w = &ma.w.email + ma.ca_email.m = &ma.cm + return &ma.ca_email case 2: - ma.ca_Date.w = &ma.w.Date - ma.ca_Date.m = &ma.cm - return &ma.ca_Date + ma.ca_date.w = &ma.w.date + ma.ca_date.m = &ma.cm + return &ma.ca_date case 3: - ma.ca_Timezone.w = &ma.w.Timezone - ma.ca_Timezone.m = &ma.cm - return &ma.ca_Timezone + ma.ca_timezone.w = &ma.w.timezone + ma.ca_timezone.m = &ma.cm + return &ma.ca_timezone default: panic("unreachable") } @@ -4753,16 +4753,16 @@ func (ma *_PersonInfo__Assembler) Finish() error { if ma.s&fieldBits__PersonInfo_sufficient != fieldBits__PersonInfo_sufficient { err := ipld.ErrMissingRequiredField{Missing: make([]string, 0)} if ma.s&fieldBit__PersonInfo_Name == 0 { - err.Missing = append(err.Missing, "Name") + err.Missing = append(err.Missing, "name") } if ma.s&fieldBit__PersonInfo_Email == 0 { - err.Missing = append(err.Missing, "Email") + err.Missing = append(err.Missing, "email") } if ma.s&fieldBit__PersonInfo_Date == 0 { - err.Missing = append(err.Missing, "Date") + err.Missing = append(err.Missing, "date") } if ma.s&fieldBit__PersonInfo_Timezone == 0 { - err.Missing = append(err.Missing, "Timezone") + err.Missing = append(err.Missing, "timezone") } return err } @@ -4802,28 +4802,28 @@ func (ka *_PersonInfo__KeyAssembler) AssignString(k string) error { panic("misuse: KeyAssembler held beyond its valid lifetime") } switch k { - case "Name": + case "name": if ka.s&fieldBit__PersonInfo_Name != 0 { return ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Name} } ka.s += fieldBit__PersonInfo_Name ka.state = maState_expectValue ka.f = 0 - case "Email": + case "email": if ka.s&fieldBit__PersonInfo_Email != 0 { return ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Email} } ka.s += fieldBit__PersonInfo_Email ka.state = maState_expectValue ka.f = 1 - case "Date": + case "date": if ka.s&fieldBit__PersonInfo_Date != 0 { return ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Date} } ka.s += fieldBit__PersonInfo_Date ka.state = maState_expectValue ka.f = 2 - case "Timezone": + case "timezone": if ka.s&fieldBit__PersonInfo_Timezone != 0 { return ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Timezone} } @@ -4860,31 +4860,85 @@ func (n PersonInfo) Representation() ipld.Node { type _PersonInfo__Repr _PersonInfo +var ( + fieldName__PersonInfo_Name_serial = _String{"name"} + fieldName__PersonInfo_Email_serial = _String{"email"} + fieldName__PersonInfo_Date_serial = _String{"date"} + fieldName__PersonInfo_Timezone_serial = _String{"timezone"} +) var _ ipld.Node = &_PersonInfo__Repr{} func (_PersonInfo__Repr) Kind() ipld.Kind { - return ipld.Kind_String + return ipld.Kind_Map } -func (_PersonInfo__Repr) LookupByString(string) (ipld.Node, error) { - return mixins.String{"ipldgit.PersonInfo.Repr"}.LookupByString("") +func (n *_PersonInfo__Repr) LookupByString(key string) (ipld.Node, error) { + switch key { + case "name": + return n.name.Representation(), nil + case "email": + return n.email.Representation(), nil + case "date": + return n.date.Representation(), nil + case "timezone": + return n.timezone.Representation(), nil + default: + return nil, schema.ErrNoSuchField{Type: nil /*TODO*/, Field: ipld.PathSegmentOfString(key)} + } } -func (_PersonInfo__Repr) LookupByNode(ipld.Node) (ipld.Node, error) { - return mixins.String{"ipldgit.PersonInfo.Repr"}.LookupByNode(nil) +func (n *_PersonInfo__Repr) LookupByNode(key ipld.Node) (ipld.Node, error) { + ks, err := key.AsString() + if err != nil { + return nil, err + } + return n.LookupByString(ks) } func (_PersonInfo__Repr) LookupByIndex(idx int64) (ipld.Node, error) { - return mixins.String{"ipldgit.PersonInfo.Repr"}.LookupByIndex(0) + return mixins.Map{"ipldgit.PersonInfo.Repr"}.LookupByIndex(0) } -func (_PersonInfo__Repr) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { - return mixins.String{"ipldgit.PersonInfo.Repr"}.LookupBySegment(seg) +func (n _PersonInfo__Repr) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { + return n.LookupByString(seg.String()) } -func (_PersonInfo__Repr) MapIterator() ipld.MapIterator { - return nil +func (n *_PersonInfo__Repr) MapIterator() ipld.MapIterator { + return &_PersonInfo__ReprMapItr{n, 0} +} + +type _PersonInfo__ReprMapItr struct { + n *_PersonInfo__Repr + idx int +} + +func (itr *_PersonInfo__ReprMapItr) Next() (k ipld.Node, v ipld.Node, _ error) { + if itr.idx >= 4 { + return nil, nil, ipld.ErrIteratorOverread{} + } + switch itr.idx { + case 0: + k = &fieldName__PersonInfo_Name_serial + v = itr.n.name.Representation() + case 1: + k = &fieldName__PersonInfo_Email_serial + v = itr.n.email.Representation() + case 2: + k = &fieldName__PersonInfo_Date_serial + v = itr.n.date.Representation() + case 3: + k = &fieldName__PersonInfo_Timezone_serial + v = itr.n.timezone.Representation() + default: + panic("unreachable") + } + itr.idx++ + return +} +func (itr *_PersonInfo__ReprMapItr) Done() bool { + return itr.idx >= 4 } func (_PersonInfo__Repr) ListIterator() ipld.ListIterator { return nil } -func (_PersonInfo__Repr) Length() int64 { - return -1 +func (rn *_PersonInfo__Repr) Length() int64 { + l := 4 + return int64(l) } func (_PersonInfo__Repr) IsAbsent() bool { return false @@ -4893,28 +4947,22 @@ func (_PersonInfo__Repr) IsNull() bool { return false } func (_PersonInfo__Repr) AsBool() (bool, error) { - return mixins.String{"ipldgit.PersonInfo.Repr"}.AsBool() + return mixins.Map{"ipldgit.PersonInfo.Repr"}.AsBool() } func (_PersonInfo__Repr) AsInt() (int64, error) { - return mixins.String{"ipldgit.PersonInfo.Repr"}.AsInt() + return mixins.Map{"ipldgit.PersonInfo.Repr"}.AsInt() } func (_PersonInfo__Repr) AsFloat() (float64, error) { - return mixins.String{"ipldgit.PersonInfo.Repr"}.AsFloat() -} -func (n *_PersonInfo__Repr) AsString() (string, error) { - return n.String(), nil -} -func (n *_PersonInfo__Repr) String() string { - return (*_String__Repr)(&n.Name).String() + " " + (*_String__Repr)(&n.Email).String() + " " + (*_String__Repr)(&n.Date).String() + " " + (*_String__Repr)(&n.Timezone).String() + return mixins.Map{"ipldgit.PersonInfo.Repr"}.AsFloat() } -func (n PersonInfo) String() string { - return (*_PersonInfo__Repr)(n).String() +func (_PersonInfo__Repr) AsString() (string, error) { + return mixins.Map{"ipldgit.PersonInfo.Repr"}.AsString() } func (_PersonInfo__Repr) AsBytes() ([]byte, error) { - return mixins.String{"ipldgit.PersonInfo.Repr"}.AsBytes() + return mixins.Map{"ipldgit.PersonInfo.Repr"}.AsBytes() } func (_PersonInfo__Repr) AsLink() (ipld.Link, error) { - return mixins.String{"ipldgit.PersonInfo.Repr"}.AsLink() + return mixins.Map{"ipldgit.PersonInfo.Repr"}.AsLink() } func (_PersonInfo__Repr) Prototype() ipld.NodePrototype { return _PersonInfo__ReprPrototype{} @@ -4943,37 +4991,44 @@ func (nb *_PersonInfo__ReprBuilder) Reset() { var m schema.Maybe *nb = _PersonInfo__ReprBuilder{_PersonInfo__ReprAssembler{w: &w, m: &m}} } -func (_PersonInfo__ReprPrototype) fromString(w *_PersonInfo, v string) error { - ss, err := mixins.SplitExact(v, " ", 4) - if err != nil { - return ipld.ErrUnmatchable{TypeName: "ipldgit.PersonInfo.Repr", Reason: err} - } - if err := (_String__ReprPrototype{}).fromString(&w.Name, ss[0]); err != nil { - return ipld.ErrUnmatchable{TypeName: "ipldgit.PersonInfo.Repr", Reason: err} - } - if err := (_String__ReprPrototype{}).fromString(&w.Email, ss[1]); err != nil { - return ipld.ErrUnmatchable{TypeName: "ipldgit.PersonInfo.Repr", Reason: err} - } - if err := (_String__ReprPrototype{}).fromString(&w.Date, ss[2]); err != nil { - return ipld.ErrUnmatchable{TypeName: "ipldgit.PersonInfo.Repr", Reason: err} - } - if err := (_String__ReprPrototype{}).fromString(&w.Timezone, ss[3]); err != nil { - return ipld.ErrUnmatchable{TypeName: "ipldgit.PersonInfo.Repr", Reason: err} - } - return nil -} type _PersonInfo__ReprAssembler struct { - w *_PersonInfo - m *schema.Maybe + w *_PersonInfo + m *schema.Maybe + state maState + s int + f int + + cm schema.Maybe + ca_name _String__ReprAssembler + ca_email _String__ReprAssembler + ca_date _String__ReprAssembler + ca_timezone _String__ReprAssembler } -func (na *_PersonInfo__ReprAssembler) reset() {} -func (_PersonInfo__ReprAssembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { - return mixins.StringAssembler{"ipldgit.PersonInfo.Repr"}.BeginMap(0) +func (na *_PersonInfo__ReprAssembler) reset() { + na.state = maState_initial + na.s = 0 + na.ca_name.reset() + na.ca_email.reset() + na.ca_date.reset() + na.ca_timezone.reset() +} +func (na *_PersonInfo__ReprAssembler) BeginMap(int64) (ipld.MapAssembler, 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 na.w == nil { + na.w = &_PersonInfo{} + } + return na, nil } func (_PersonInfo__ReprAssembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { - return mixins.StringAssembler{"ipldgit.PersonInfo.Repr"}.BeginList(0) + return mixins.MapAssembler{"ipldgit.PersonInfo.Repr"}.BeginList(0) } func (na *_PersonInfo__ReprAssembler) AssignNull() error { switch *na.m { @@ -4981,40 +5036,31 @@ func (na *_PersonInfo__ReprAssembler) AssignNull() error { *na.m = schema.Maybe_Null return nil case schema.Maybe_Absent: - return mixins.StringAssembler{"ipldgit.PersonInfo.Repr.Repr"}.AssignNull() + return mixins.MapAssembler{"ipldgit.PersonInfo.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 (_PersonInfo__ReprAssembler) AssignBool(bool) error { - return mixins.StringAssembler{"ipldgit.PersonInfo.Repr"}.AssignBool(false) + return mixins.MapAssembler{"ipldgit.PersonInfo.Repr"}.AssignBool(false) } func (_PersonInfo__ReprAssembler) AssignInt(int64) error { - return mixins.StringAssembler{"ipldgit.PersonInfo.Repr"}.AssignInt(0) + return mixins.MapAssembler{"ipldgit.PersonInfo.Repr"}.AssignInt(0) } func (_PersonInfo__ReprAssembler) AssignFloat(float64) error { - return mixins.StringAssembler{"ipldgit.PersonInfo.Repr"}.AssignFloat(0) + return mixins.MapAssembler{"ipldgit.PersonInfo.Repr"}.AssignFloat(0) } -func (na *_PersonInfo__ReprAssembler) 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 = &_PersonInfo{} - } - if err := (_PersonInfo__ReprPrototype{}).fromString(na.w, v); err != nil { - return err - } - *na.m = schema.Maybe_Value - return nil +func (_PersonInfo__ReprAssembler) AssignString(string) error { + return mixins.MapAssembler{"ipldgit.PersonInfo.Repr"}.AssignString("") } func (_PersonInfo__ReprAssembler) AssignBytes([]byte) error { - return mixins.StringAssembler{"ipldgit.PersonInfo.Repr"}.AssignBytes(nil) + return mixins.MapAssembler{"ipldgit.PersonInfo.Repr"}.AssignBytes(nil) } func (_PersonInfo__ReprAssembler) AssignLink(ipld.Link) error { - return mixins.StringAssembler{"ipldgit.PersonInfo.Repr"}.AssignLink(nil) + return mixins.MapAssembler{"ipldgit.PersonInfo.Repr"}.AssignLink(nil) } func (na *_PersonInfo__ReprAssembler) AssignNode(v ipld.Node) error { if v.IsNull() { @@ -5024,6 +5070,8 @@ func (na *_PersonInfo__ReprAssembler) AssignNode(v ipld.Node) 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: cannot assign null into an assembler that's already begun working on recursive structures!") } if na.w == nil { na.w = v2 @@ -5034,14 +5082,299 @@ func (na *_PersonInfo__ReprAssembler) AssignNode(v ipld.Node) error { *na.m = schema.Maybe_Value return nil } + if v.Kind() != ipld.Kind_Map { + return ipld.ErrWrongKind{TypeName: "ipldgit.PersonInfo.Repr", MethodName: "AssignNode", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()} + } + itr := v.MapIterator() + for !itr.Done() { + k, v, err := itr.Next() + if err != nil { + return err + } + if err := na.AssembleKey().AssignNode(k); err != nil { + return err + } + if err := na.AssembleValue().AssignNode(v); err != nil { + return err + } + } + return na.Finish() +} +func (_PersonInfo__ReprAssembler) Prototype() ipld.NodePrototype { + return _PersonInfo__ReprPrototype{} +} +func (ma *_PersonInfo__ReprAssembler) valueFinishTidy() bool { + switch ma.f { + case 0: + switch ma.cm { + case schema.Maybe_Value: + ma.cm = schema.Maybe_Absent + ma.state = maState_initial + return true + default: + return false + } + case 1: + switch ma.cm { + case schema.Maybe_Value: + ma.cm = schema.Maybe_Absent + ma.state = maState_initial + return true + default: + return false + } + case 2: + switch ma.cm { + case schema.Maybe_Value: + ma.cm = schema.Maybe_Absent + ma.state = maState_initial + return true + default: + return false + } + case 3: + switch ma.cm { + case schema.Maybe_Value: + ma.cm = schema.Maybe_Absent + ma.state = maState_initial + return true + default: + return false + } + default: + panic("unreachable") + } +} +func (ma *_PersonInfo__ReprAssembler) AssembleEntry(k string) (ipld.NodeAssembler, error) { + switch ma.state { + case maState_initial: + // carry on + case maState_midKey: + panic("invalid state: AssembleEntry cannot be called when in the middle of assembling another key") + case maState_expectValue: + panic("invalid state: AssembleEntry cannot be called when expecting start of value assembly") + case maState_midValue: + if !ma.valueFinishTidy() { + panic("invalid state: AssembleEntry cannot be called when in the middle of assembling a value") + } // if tidy success: carry on + case maState_finished: + panic("invalid state: AssembleEntry cannot be called on an assembler that's already finished") + } + switch k { + case "name": + if ma.s&fieldBit__PersonInfo_Name != 0 { + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Name_serial} + } + ma.s += fieldBit__PersonInfo_Name + ma.state = maState_midValue + ma.f = 0 + ma.ca_name.w = &ma.w.name + ma.ca_name.m = &ma.cm + return &ma.ca_name, nil + case "email": + if ma.s&fieldBit__PersonInfo_Email != 0 { + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Email_serial} + } + ma.s += fieldBit__PersonInfo_Email + ma.state = maState_midValue + ma.f = 1 + ma.ca_email.w = &ma.w.email + ma.ca_email.m = &ma.cm + return &ma.ca_email, nil + case "date": + if ma.s&fieldBit__PersonInfo_Date != 0 { + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Date_serial} + } + ma.s += fieldBit__PersonInfo_Date + ma.state = maState_midValue + ma.f = 2 + ma.ca_date.w = &ma.w.date + ma.ca_date.m = &ma.cm + return &ma.ca_date, nil + case "timezone": + if ma.s&fieldBit__PersonInfo_Timezone != 0 { + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Timezone_serial} + } + ma.s += fieldBit__PersonInfo_Timezone + ma.state = maState_midValue + ma.f = 3 + ma.ca_timezone.w = &ma.w.timezone + ma.ca_timezone.m = &ma.cm + return &ma.ca_timezone, nil + default: + } + return nil, ipld.ErrInvalidKey{TypeName: "ipldgit.PersonInfo.Repr", Key: &_String{k}} +} +func (ma *_PersonInfo__ReprAssembler) AssembleKey() ipld.NodeAssembler { + switch ma.state { + case maState_initial: + // carry on + case maState_midKey: + panic("invalid state: AssembleKey cannot be called when in the middle of assembling another key") + case maState_expectValue: + panic("invalid state: AssembleKey cannot be called when expecting start of value assembly") + case maState_midValue: + if !ma.valueFinishTidy() { + panic("invalid state: AssembleKey cannot be called when in the middle of assembling a value") + } // if tidy success: carry on + case maState_finished: + panic("invalid state: AssembleKey cannot be called on an assembler that's already finished") + } + ma.state = maState_midKey + return (*_PersonInfo__ReprKeyAssembler)(ma) +} +func (ma *_PersonInfo__ReprAssembler) AssembleValue() ipld.NodeAssembler { + switch ma.state { + case maState_initial: + panic("invalid state: AssembleValue cannot be called when no key is primed") + case maState_midKey: + panic("invalid state: AssembleValue cannot be called when in the middle of assembling a key") + case maState_expectValue: + // carry on + case maState_midValue: + panic("invalid state: AssembleValue cannot be called when in the middle of assembling another value") + case maState_finished: + panic("invalid state: AssembleValue cannot be called on an assembler that's already finished") + } + ma.state = maState_midValue + switch ma.f { + case 0: + ma.ca_name.w = &ma.w.name + ma.ca_name.m = &ma.cm + return &ma.ca_name + case 1: + ma.ca_email.w = &ma.w.email + ma.ca_email.m = &ma.cm + return &ma.ca_email + case 2: + ma.ca_date.w = &ma.w.date + ma.ca_date.m = &ma.cm + return &ma.ca_date + case 3: + ma.ca_timezone.w = &ma.w.timezone + ma.ca_timezone.m = &ma.cm + return &ma.ca_timezone + default: + panic("unreachable") + } +} +func (ma *_PersonInfo__ReprAssembler) Finish() error { + switch ma.state { + case maState_initial: + // carry on + case maState_midKey: + panic("invalid state: Finish cannot be called when in the middle of assembling a key") + case maState_expectValue: + panic("invalid state: Finish cannot be called when expecting start of value assembly") + case maState_midValue: + if !ma.valueFinishTidy() { + panic("invalid state: Finish cannot be called when in the middle of assembling a value") + } // if tidy success: carry on + case maState_finished: + panic("invalid state: Finish cannot be called on an assembler that's already finished") + } + if ma.s&fieldBits__PersonInfo_sufficient != fieldBits__PersonInfo_sufficient { + err := ipld.ErrMissingRequiredField{Missing: make([]string, 0)} + if ma.s&fieldBit__PersonInfo_Name == 0 { + err.Missing = append(err.Missing, "name") + } + if ma.s&fieldBit__PersonInfo_Email == 0 { + err.Missing = append(err.Missing, "email") + } + if ma.s&fieldBit__PersonInfo_Date == 0 { + err.Missing = append(err.Missing, "date") + } + if ma.s&fieldBit__PersonInfo_Timezone == 0 { + err.Missing = append(err.Missing, "timezone") + } + return err + } + ma.state = maState_finished + *ma.m = schema.Maybe_Value + return nil +} +func (ma *_PersonInfo__ReprAssembler) KeyPrototype() ipld.NodePrototype { + return _String__Prototype{} +} +func (ma *_PersonInfo__ReprAssembler) ValuePrototype(k string) ipld.NodePrototype { + panic("todo structbuilder mapassembler repr valueprototype") +} + +type _PersonInfo__ReprKeyAssembler _PersonInfo__ReprAssembler + +func (_PersonInfo__ReprKeyAssembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { + return mixins.StringAssembler{"ipldgit.PersonInfo.Repr.KeyAssembler"}.BeginMap(0) +} +func (_PersonInfo__ReprKeyAssembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { + return mixins.StringAssembler{"ipldgit.PersonInfo.Repr.KeyAssembler"}.BeginList(0) +} +func (na *_PersonInfo__ReprKeyAssembler) AssignNull() error { + return mixins.StringAssembler{"ipldgit.PersonInfo.Repr.KeyAssembler"}.AssignNull() +} +func (_PersonInfo__ReprKeyAssembler) AssignBool(bool) error { + return mixins.StringAssembler{"ipldgit.PersonInfo.Repr.KeyAssembler"}.AssignBool(false) +} +func (_PersonInfo__ReprKeyAssembler) AssignInt(int64) error { + return mixins.StringAssembler{"ipldgit.PersonInfo.Repr.KeyAssembler"}.AssignInt(0) +} +func (_PersonInfo__ReprKeyAssembler) AssignFloat(float64) error { + return mixins.StringAssembler{"ipldgit.PersonInfo.Repr.KeyAssembler"}.AssignFloat(0) +} +func (ka *_PersonInfo__ReprKeyAssembler) AssignString(k string) error { + if ka.state != maState_midKey { + panic("misuse: KeyAssembler held beyond its valid lifetime") + } + switch k { + case "name": + if ka.s&fieldBit__PersonInfo_Name != 0 { + return ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Name_serial} + } + ka.s += fieldBit__PersonInfo_Name + ka.state = maState_expectValue + ka.f = 0 + return nil + case "email": + if ka.s&fieldBit__PersonInfo_Email != 0 { + return ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Email_serial} + } + ka.s += fieldBit__PersonInfo_Email + ka.state = maState_expectValue + ka.f = 1 + return nil + case "date": + if ka.s&fieldBit__PersonInfo_Date != 0 { + return ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Date_serial} + } + ka.s += fieldBit__PersonInfo_Date + ka.state = maState_expectValue + ka.f = 2 + return nil + case "timezone": + if ka.s&fieldBit__PersonInfo_Timezone != 0 { + return ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Timezone_serial} + } + ka.s += fieldBit__PersonInfo_Timezone + ka.state = maState_expectValue + ka.f = 3 + return nil + } + return ipld.ErrInvalidKey{TypeName: "ipldgit.PersonInfo.Repr", Key: &_String{k}} +} +func (_PersonInfo__ReprKeyAssembler) AssignBytes([]byte) error { + return mixins.StringAssembler{"ipldgit.PersonInfo.Repr.KeyAssembler"}.AssignBytes(nil) +} +func (_PersonInfo__ReprKeyAssembler) AssignLink(ipld.Link) error { + return mixins.StringAssembler{"ipldgit.PersonInfo.Repr.KeyAssembler"}.AssignLink(nil) +} +func (ka *_PersonInfo__ReprKeyAssembler) AssignNode(v ipld.Node) error { if v2, err := v.AsString(); err != nil { return err } else { - return na.AssignString(v2) + return ka.AssignString(v2) } } -func (_PersonInfo__ReprAssembler) Prototype() ipld.NodePrototype { - return _PersonInfo__ReprPrototype{} +func (_PersonInfo__ReprKeyAssembler) Prototype() ipld.NodePrototype { + return _String__Prototype{} } func (n String) String() string { @@ -5262,19 +5595,19 @@ type _String__ReprPrototype = _String__Prototype type _String__ReprAssembler = _String__Assembler func (n _Tag) FieldObject() Link { - return &n.Object + return &n.object } func (n _Tag) FieldTagType() String { - return &n.TagType + return &n.tagType } func (n _Tag) FieldTag() String { - return &n.Tag + return &n.tag } func (n _Tag) FieldTagger() PersonInfo { - return &n.Tagger + return &n.tagger } func (n _Tag) FieldText() String { - return &n.Text + return &n.text } type _Tag__Maybe struct { @@ -5312,11 +5645,11 @@ func (m MaybeTag) Must() Tag { } var ( - fieldName__Tag_Object = _String{"Object"} - fieldName__Tag_TagType = _String{"TagType"} - fieldName__Tag_Tag = _String{"Tag"} - fieldName__Tag_Tagger = _String{"Tagger"} - fieldName__Tag_Text = _String{"Text"} + fieldName__Tag_Object = _String{"object"} + fieldName__Tag_TagType = _String{"tagType"} + fieldName__Tag_Tag = _String{"tag"} + fieldName__Tag_Tagger = _String{"tagger"} + fieldName__Tag_Text = _String{"text"} ) var _ ipld.Node = (Tag)(&_Tag{}) var _ schema.TypedNode = (Tag)(&_Tag{}) @@ -5326,16 +5659,16 @@ func (Tag) Kind() ipld.Kind { } func (n Tag) LookupByString(key string) (ipld.Node, error) { switch key { - case "Object": - return &n.Object, nil - case "TagType": - return &n.TagType, nil - case "Tag": - return &n.Tag, nil - case "Tagger": - return &n.Tagger, nil - case "Text": - return &n.Text, nil + case "object": + return &n.object, nil + case "tagType": + return &n.tagType, nil + case "tag": + return &n.tag, nil + case "tagger": + return &n.tagger, nil + case "text": + return &n.text, nil default: return nil, schema.ErrNoSuchField{Type: nil /*TODO*/, Field: ipld.PathSegmentOfString(key)} } @@ -5369,19 +5702,19 @@ func (itr *_Tag__MapItr) Next() (k ipld.Node, v ipld.Node, _ error) { switch itr.idx { case 0: k = &fieldName__Tag_Object - v = &itr.n.Object + v = &itr.n.object case 1: k = &fieldName__Tag_TagType - v = &itr.n.TagType + v = &itr.n.tagType case 2: k = &fieldName__Tag_Tag - v = &itr.n.Tag + v = &itr.n.tag case 3: k = &fieldName__Tag_Tagger - v = &itr.n.Tagger + v = &itr.n.tagger case 4: k = &fieldName__Tag_Text - v = &itr.n.Text + v = &itr.n.text default: panic("unreachable") } @@ -5458,21 +5791,21 @@ type _Tag__Assembler struct { f int cm schema.Maybe - ca_Object _Link__Assembler - ca_TagType _String__Assembler - ca_Tag _String__Assembler - ca_Tagger _PersonInfo__Assembler - ca_Text _String__Assembler + ca_object _Link__Assembler + ca_tagType _String__Assembler + ca_tag _String__Assembler + ca_tagger _PersonInfo__Assembler + ca_text _String__Assembler } func (na *_Tag__Assembler) reset() { na.state = maState_initial na.s = 0 - na.ca_Object.reset() - na.ca_TagType.reset() - na.ca_Tag.reset() - na.ca_Tagger.reset() - na.ca_Text.reset() + na.ca_object.reset() + na.ca_tagType.reset() + na.ca_tag.reset() + na.ca_tagger.reset() + na.ca_text.reset() } var ( @@ -5578,7 +5911,7 @@ func (ma *_Tag__Assembler) valueFinishTidy() bool { case 0: switch ma.cm { case schema.Maybe_Value: - ma.ca_Object.w = nil + ma.ca_object.w = nil ma.cm = schema.Maybe_Absent ma.state = maState_initial return true @@ -5588,7 +5921,7 @@ func (ma *_Tag__Assembler) valueFinishTidy() bool { case 1: switch ma.cm { case schema.Maybe_Value: - ma.ca_TagType.w = nil + ma.ca_tagType.w = nil ma.cm = schema.Maybe_Absent ma.state = maState_initial return true @@ -5598,7 +5931,7 @@ func (ma *_Tag__Assembler) valueFinishTidy() bool { case 2: switch ma.cm { case schema.Maybe_Value: - ma.ca_Tag.w = nil + ma.ca_tag.w = nil ma.cm = schema.Maybe_Absent ma.state = maState_initial return true @@ -5608,7 +5941,7 @@ func (ma *_Tag__Assembler) valueFinishTidy() bool { case 3: switch ma.cm { case schema.Maybe_Value: - ma.ca_Tagger.w = nil + ma.ca_tagger.w = nil ma.cm = schema.Maybe_Absent ma.state = maState_initial return true @@ -5618,7 +5951,7 @@ func (ma *_Tag__Assembler) valueFinishTidy() bool { case 4: switch ma.cm { case schema.Maybe_Value: - ma.ca_Text.w = nil + ma.ca_text.w = nil ma.cm = schema.Maybe_Absent ma.state = maState_initial return true @@ -5645,56 +5978,56 @@ func (ma *_Tag__Assembler) AssembleEntry(k string) (ipld.NodeAssembler, error) { panic("invalid state: AssembleEntry cannot be called on an assembler that's already finished") } switch k { - case "Object": + case "object": if ma.s&fieldBit__Tag_Object != 0 { return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Object} } ma.s += fieldBit__Tag_Object ma.state = maState_midValue ma.f = 0 - ma.ca_Object.w = &ma.w.Object - ma.ca_Object.m = &ma.cm - return &ma.ca_Object, nil - case "TagType": + ma.ca_object.w = &ma.w.object + ma.ca_object.m = &ma.cm + return &ma.ca_object, nil + case "tagType": if ma.s&fieldBit__Tag_TagType != 0 { return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_TagType} } ma.s += fieldBit__Tag_TagType ma.state = maState_midValue ma.f = 1 - ma.ca_TagType.w = &ma.w.TagType - ma.ca_TagType.m = &ma.cm - return &ma.ca_TagType, nil - case "Tag": + ma.ca_tagType.w = &ma.w.tagType + ma.ca_tagType.m = &ma.cm + return &ma.ca_tagType, nil + case "tag": if ma.s&fieldBit__Tag_Tag != 0 { return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Tag} } ma.s += fieldBit__Tag_Tag ma.state = maState_midValue ma.f = 2 - ma.ca_Tag.w = &ma.w.Tag - ma.ca_Tag.m = &ma.cm - return &ma.ca_Tag, nil - case "Tagger": + ma.ca_tag.w = &ma.w.tag + ma.ca_tag.m = &ma.cm + return &ma.ca_tag, nil + case "tagger": if ma.s&fieldBit__Tag_Tagger != 0 { return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Tagger} } ma.s += fieldBit__Tag_Tagger ma.state = maState_midValue ma.f = 3 - ma.ca_Tagger.w = &ma.w.Tagger - ma.ca_Tagger.m = &ma.cm - return &ma.ca_Tagger, nil - case "Text": + ma.ca_tagger.w = &ma.w.tagger + ma.ca_tagger.m = &ma.cm + return &ma.ca_tagger, nil + case "text": if ma.s&fieldBit__Tag_Text != 0 { return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Text} } ma.s += fieldBit__Tag_Text ma.state = maState_midValue ma.f = 4 - ma.ca_Text.w = &ma.w.Text - ma.ca_Text.m = &ma.cm - return &ma.ca_Text, nil + ma.ca_text.w = &ma.w.text + ma.ca_text.m = &ma.cm + return &ma.ca_text, nil } return nil, ipld.ErrInvalidKey{TypeName: "ipldgit.Tag", Key: &_String{k}} } @@ -5732,25 +6065,25 @@ func (ma *_Tag__Assembler) AssembleValue() ipld.NodeAssembler { ma.state = maState_midValue switch ma.f { case 0: - ma.ca_Object.w = &ma.w.Object - ma.ca_Object.m = &ma.cm - return &ma.ca_Object + ma.ca_object.w = &ma.w.object + ma.ca_object.m = &ma.cm + return &ma.ca_object case 1: - ma.ca_TagType.w = &ma.w.TagType - ma.ca_TagType.m = &ma.cm - return &ma.ca_TagType + ma.ca_tagType.w = &ma.w.tagType + ma.ca_tagType.m = &ma.cm + return &ma.ca_tagType case 2: - ma.ca_Tag.w = &ma.w.Tag - ma.ca_Tag.m = &ma.cm - return &ma.ca_Tag + ma.ca_tag.w = &ma.w.tag + ma.ca_tag.m = &ma.cm + return &ma.ca_tag case 3: - ma.ca_Tagger.w = &ma.w.Tagger - ma.ca_Tagger.m = &ma.cm - return &ma.ca_Tagger + ma.ca_tagger.w = &ma.w.tagger + ma.ca_tagger.m = &ma.cm + return &ma.ca_tagger case 4: - ma.ca_Text.w = &ma.w.Text - ma.ca_Text.m = &ma.cm - return &ma.ca_Text + ma.ca_text.w = &ma.w.text + ma.ca_text.m = &ma.cm + return &ma.ca_text default: panic("unreachable") } @@ -5773,19 +6106,19 @@ func (ma *_Tag__Assembler) Finish() error { if ma.s&fieldBits__Tag_sufficient != fieldBits__Tag_sufficient { err := ipld.ErrMissingRequiredField{Missing: make([]string, 0)} if ma.s&fieldBit__Tag_Object == 0 { - err.Missing = append(err.Missing, "Object") + err.Missing = append(err.Missing, "object") } if ma.s&fieldBit__Tag_TagType == 0 { - err.Missing = append(err.Missing, "TagType") + err.Missing = append(err.Missing, "tagType") } if ma.s&fieldBit__Tag_Tag == 0 { - err.Missing = append(err.Missing, "Tag") + err.Missing = append(err.Missing, "tag") } if ma.s&fieldBit__Tag_Tagger == 0 { - err.Missing = append(err.Missing, "Tagger") + err.Missing = append(err.Missing, "tagger") } if ma.s&fieldBit__Tag_Text == 0 { - err.Missing = append(err.Missing, "Text") + err.Missing = append(err.Missing, "text") } return err } @@ -5825,35 +6158,35 @@ func (ka *_Tag__KeyAssembler) AssignString(k string) error { panic("misuse: KeyAssembler held beyond its valid lifetime") } switch k { - case "Object": + case "object": if ka.s&fieldBit__Tag_Object != 0 { return ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Object} } ka.s += fieldBit__Tag_Object ka.state = maState_expectValue ka.f = 0 - case "TagType": + case "tagType": if ka.s&fieldBit__Tag_TagType != 0 { return ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_TagType} } ka.s += fieldBit__Tag_TagType ka.state = maState_expectValue ka.f = 1 - case "Tag": + case "tag": if ka.s&fieldBit__Tag_Tag != 0 { return ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Tag} } ka.s += fieldBit__Tag_Tag ka.state = maState_expectValue ka.f = 2 - case "Tagger": + case "tagger": if ka.s&fieldBit__Tag_Tagger != 0 { return ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Tagger} } ka.s += fieldBit__Tag_Tagger ka.state = maState_expectValue ka.f = 3 - case "Text": + case "text": if ka.s&fieldBit__Tag_Text != 0 { return ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Text} } @@ -5891,11 +6224,11 @@ func (n Tag) Representation() ipld.Node { type _Tag__Repr _Tag var ( - fieldName__Tag_Object_serial = _String{"Object"} - fieldName__Tag_TagType_serial = _String{"TagType"} - fieldName__Tag_Tag_serial = _String{"Tag"} - fieldName__Tag_Tagger_serial = _String{"Tagger"} - fieldName__Tag_Text_serial = _String{"Text"} + fieldName__Tag_Object_serial = _String{"object"} + fieldName__Tag_TagType_serial = _String{"tagType"} + fieldName__Tag_Tag_serial = _String{"tag"} + fieldName__Tag_Tagger_serial = _String{"tagger"} + fieldName__Tag_Text_serial = _String{"text"} ) var _ ipld.Node = &_Tag__Repr{} @@ -5904,16 +6237,16 @@ func (_Tag__Repr) Kind() ipld.Kind { } func (n *_Tag__Repr) LookupByString(key string) (ipld.Node, error) { switch key { - case "Object": - return n.Object.Representation(), nil - case "TagType": - return n.TagType.Representation(), nil - case "Tag": - return n.Tag.Representation(), nil - case "Tagger": - return n.Tagger.Representation(), nil - case "Text": - return n.Text.Representation(), nil + case "object": + return n.object.Representation(), nil + case "tagType": + return n.tagType.Representation(), nil + case "tag": + return n.tag.Representation(), nil + case "tagger": + return n.tagger.Representation(), nil + case "text": + return n.text.Representation(), nil default: return nil, schema.ErrNoSuchField{Type: nil /*TODO*/, Field: ipld.PathSegmentOfString(key)} } @@ -5947,19 +6280,19 @@ func (itr *_Tag__ReprMapItr) Next() (k ipld.Node, v ipld.Node, _ error) { switch itr.idx { case 0: k = &fieldName__Tag_Object_serial - v = itr.n.Object.Representation() + v = itr.n.object.Representation() case 1: k = &fieldName__Tag_TagType_serial - v = itr.n.TagType.Representation() + v = itr.n.tagType.Representation() case 2: k = &fieldName__Tag_Tag_serial - v = itr.n.Tag.Representation() + v = itr.n.tag.Representation() case 3: k = &fieldName__Tag_Tagger_serial - v = itr.n.Tagger.Representation() + v = itr.n.tagger.Representation() case 4: k = &fieldName__Tag_Text_serial - v = itr.n.Text.Representation() + v = itr.n.text.Representation() default: panic("unreachable") } @@ -6036,21 +6369,21 @@ type _Tag__ReprAssembler struct { f int cm schema.Maybe - ca_Object _Link__ReprAssembler - ca_TagType _String__ReprAssembler - ca_Tag _String__ReprAssembler - ca_Tagger _PersonInfo__ReprAssembler - ca_Text _String__ReprAssembler + ca_object _Link__ReprAssembler + ca_tagType _String__ReprAssembler + ca_tag _String__ReprAssembler + ca_tagger _PersonInfo__ReprAssembler + ca_text _String__ReprAssembler } func (na *_Tag__ReprAssembler) reset() { na.state = maState_initial na.s = 0 - na.ca_Object.reset() - na.ca_TagType.reset() - na.ca_Tag.reset() - na.ca_Tagger.reset() - na.ca_Text.reset() + na.ca_object.reset() + na.ca_tagType.reset() + na.ca_tag.reset() + na.ca_tagger.reset() + na.ca_text.reset() } func (na *_Tag__ReprAssembler) BeginMap(int64) (ipld.MapAssembler, error) { switch *na.m { @@ -6208,56 +6541,56 @@ func (ma *_Tag__ReprAssembler) AssembleEntry(k string) (ipld.NodeAssembler, erro panic("invalid state: AssembleEntry cannot be called on an assembler that's already finished") } switch k { - case "Object": + case "object": if ma.s&fieldBit__Tag_Object != 0 { return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Object_serial} } ma.s += fieldBit__Tag_Object ma.state = maState_midValue ma.f = 0 - ma.ca_Object.w = &ma.w.Object - ma.ca_Object.m = &ma.cm - return &ma.ca_Object, nil - case "TagType": + ma.ca_object.w = &ma.w.object + ma.ca_object.m = &ma.cm + return &ma.ca_object, nil + case "tagType": if ma.s&fieldBit__Tag_TagType != 0 { return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_TagType_serial} } ma.s += fieldBit__Tag_TagType ma.state = maState_midValue ma.f = 1 - ma.ca_TagType.w = &ma.w.TagType - ma.ca_TagType.m = &ma.cm - return &ma.ca_TagType, nil - case "Tag": + ma.ca_tagType.w = &ma.w.tagType + ma.ca_tagType.m = &ma.cm + return &ma.ca_tagType, nil + case "tag": if ma.s&fieldBit__Tag_Tag != 0 { return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Tag_serial} } ma.s += fieldBit__Tag_Tag ma.state = maState_midValue ma.f = 2 - ma.ca_Tag.w = &ma.w.Tag - ma.ca_Tag.m = &ma.cm - return &ma.ca_Tag, nil - case "Tagger": + ma.ca_tag.w = &ma.w.tag + ma.ca_tag.m = &ma.cm + return &ma.ca_tag, nil + case "tagger": if ma.s&fieldBit__Tag_Tagger != 0 { return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Tagger_serial} } ma.s += fieldBit__Tag_Tagger ma.state = maState_midValue ma.f = 3 - ma.ca_Tagger.w = &ma.w.Tagger - ma.ca_Tagger.m = &ma.cm - return &ma.ca_Tagger, nil - case "Text": + ma.ca_tagger.w = &ma.w.tagger + ma.ca_tagger.m = &ma.cm + return &ma.ca_tagger, nil + case "text": if ma.s&fieldBit__Tag_Text != 0 { return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Text_serial} } ma.s += fieldBit__Tag_Text ma.state = maState_midValue ma.f = 4 - ma.ca_Text.w = &ma.w.Text - ma.ca_Text.m = &ma.cm - return &ma.ca_Text, nil + ma.ca_text.w = &ma.w.text + ma.ca_text.m = &ma.cm + return &ma.ca_text, nil default: } return nil, ipld.ErrInvalidKey{TypeName: "ipldgit.Tag.Repr", Key: &_String{k}} @@ -6296,25 +6629,25 @@ func (ma *_Tag__ReprAssembler) AssembleValue() ipld.NodeAssembler { ma.state = maState_midValue switch ma.f { case 0: - ma.ca_Object.w = &ma.w.Object - ma.ca_Object.m = &ma.cm - return &ma.ca_Object + ma.ca_object.w = &ma.w.object + ma.ca_object.m = &ma.cm + return &ma.ca_object case 1: - ma.ca_TagType.w = &ma.w.TagType - ma.ca_TagType.m = &ma.cm - return &ma.ca_TagType + ma.ca_tagType.w = &ma.w.tagType + ma.ca_tagType.m = &ma.cm + return &ma.ca_tagType case 2: - ma.ca_Tag.w = &ma.w.Tag - ma.ca_Tag.m = &ma.cm - return &ma.ca_Tag + ma.ca_tag.w = &ma.w.tag + ma.ca_tag.m = &ma.cm + return &ma.ca_tag case 3: - ma.ca_Tagger.w = &ma.w.Tagger - ma.ca_Tagger.m = &ma.cm - return &ma.ca_Tagger + ma.ca_tagger.w = &ma.w.tagger + ma.ca_tagger.m = &ma.cm + return &ma.ca_tagger case 4: - ma.ca_Text.w = &ma.w.Text - ma.ca_Text.m = &ma.cm - return &ma.ca_Text + ma.ca_text.w = &ma.w.text + ma.ca_text.m = &ma.cm + return &ma.ca_text default: panic("unreachable") } @@ -6337,19 +6670,19 @@ func (ma *_Tag__ReprAssembler) Finish() error { if ma.s&fieldBits__Tag_sufficient != fieldBits__Tag_sufficient { err := ipld.ErrMissingRequiredField{Missing: make([]string, 0)} if ma.s&fieldBit__Tag_Object == 0 { - err.Missing = append(err.Missing, "Object") + err.Missing = append(err.Missing, "object") } if ma.s&fieldBit__Tag_TagType == 0 { - err.Missing = append(err.Missing, "TagType") + err.Missing = append(err.Missing, "tagType") } if ma.s&fieldBit__Tag_Tag == 0 { - err.Missing = append(err.Missing, "Tag") + err.Missing = append(err.Missing, "tag") } if ma.s&fieldBit__Tag_Tagger == 0 { - err.Missing = append(err.Missing, "Tagger") + err.Missing = append(err.Missing, "tagger") } if ma.s&fieldBit__Tag_Text == 0 { - err.Missing = append(err.Missing, "Text") + err.Missing = append(err.Missing, "text") } return err } @@ -6389,7 +6722,7 @@ func (ka *_Tag__ReprKeyAssembler) AssignString(k string) error { panic("misuse: KeyAssembler held beyond its valid lifetime") } switch k { - case "Object": + case "object": if ka.s&fieldBit__Tag_Object != 0 { return ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Object_serial} } @@ -6397,7 +6730,7 @@ func (ka *_Tag__ReprKeyAssembler) AssignString(k string) error { ka.state = maState_expectValue ka.f = 0 return nil - case "TagType": + case "tagType": if ka.s&fieldBit__Tag_TagType != 0 { return ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_TagType_serial} } @@ -6405,7 +6738,7 @@ func (ka *_Tag__ReprKeyAssembler) AssignString(k string) error { ka.state = maState_expectValue ka.f = 1 return nil - case "Tag": + case "tag": if ka.s&fieldBit__Tag_Tag != 0 { return ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Tag_serial} } @@ -6413,7 +6746,7 @@ func (ka *_Tag__ReprKeyAssembler) AssignString(k string) error { ka.state = maState_expectValue ka.f = 2 return nil - case "Tagger": + case "tagger": if ka.s&fieldBit__Tag_Tagger != 0 { return ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Tagger_serial} } @@ -6421,7 +6754,7 @@ func (ka *_Tag__ReprKeyAssembler) AssignString(k string) error { ka.state = maState_expectValue ka.f = 3 return nil - case "Text": + case "text": if ka.s&fieldBit__Tag_Text != 0 { return ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Text_serial} } @@ -6449,18 +6782,18 @@ func (_Tag__ReprKeyAssembler) Prototype() ipld.NodePrototype { return _String__Prototype{} } -func (n *_Tree) Lookup(idx int64) TreeEntry { - if n.Length() <= idx { +func (n *_Tree) Lookup(k String) TreeEntry { + v, exists := n.m[*k] + if !exists { return nil } - v := &n.x[idx] return v } -func (n *_Tree) LookupMaybe(idx int64) MaybeTreeEntry { - if n.Length() <= idx { - return nil +func (n *_Tree) LookupMaybe(k String) MaybeTreeEntry { + v, exists := n.m[*k] + if !exists { + return &_Tree__valueAbsent } - v := &n.x[idx] return &_TreeEntry__Maybe{ m: schema.Maybe_Value, v: v, @@ -6478,17 +6811,18 @@ type Tree__Itr struct { idx int } -func (itr *Tree__Itr) Next() (idx int64, v TreeEntry) { - if itr.idx >= len(itr.n.x) { - return -1, nil +func (itr *Tree__Itr) Next() (k String, v TreeEntry) { + if itr.idx >= len(itr.n.t) { + return nil, nil } - idx = int64(itr.idx) - v = &itr.n.x[itr.idx] + x := &itr.n.t[itr.idx] + k = &x.k + v = &x.v itr.idx++ return } func (itr *Tree__Itr) Done() bool { - return itr.idx >= len(itr.n.x) + return itr.idx >= len(itr.n.t) } type _Tree__Maybe struct { @@ -6529,60 +6863,65 @@ var _ ipld.Node = (Tree)(&_Tree{}) var _ schema.TypedNode = (Tree)(&_Tree{}) func (Tree) Kind() ipld.Kind { - return ipld.Kind_List -} -func (Tree) LookupByString(string) (ipld.Node, error) { - return mixins.List{"ipldgit.Tree"}.LookupByString("") + return ipld.Kind_Map } -func (n Tree) LookupByNode(k ipld.Node) (ipld.Node, error) { - idx, err := k.AsInt() - if err != nil { - return nil, err +func (n Tree) LookupByString(k string) (ipld.Node, error) { + var k2 _String + if err := (_String__Prototype{}).fromString(&k2, k); err != nil { + return nil, err // TODO wrap in some kind of ErrInvalidKey } - return n.LookupByIndex(idx) -} -func (n Tree) LookupByIndex(idx int64) (ipld.Node, error) { - if n.Length() <= idx { - return nil, ipld.ErrNotExists{Segment: ipld.PathSegmentOfInt(idx)} + v, exists := n.m[k2] + if !exists { + return nil, ipld.ErrNotExists{Segment: ipld.PathSegmentOfString(k)} } - v := &n.x[idx] return v, nil } -func (n Tree) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { - i, err := seg.Index() - if err != nil { - return nil, ipld.ErrInvalidSegmentForList{TypeName: "ipldgit.Tree", TroubleSegment: seg, Reason: err} +func (n Tree) LookupByNode(k ipld.Node) (ipld.Node, error) { + k2, ok := k.(String) + if !ok { + panic("todo invalid key type error") + // 'ipld.ErrInvalidKey{TypeName:"ipldgit.Tree", Key:&_String{k}}' doesn't quite cut it: need room to explain the type, and it's not guaranteed k can be turned into a string at all } - return n.LookupByIndex(i) + v, exists := n.m[*k2] + if !exists { + return nil, ipld.ErrNotExists{Segment: ipld.PathSegmentOfString(k2.String())} + } + return v, nil } -func (Tree) MapIterator() ipld.MapIterator { - return nil +func (Tree) LookupByIndex(idx int64) (ipld.Node, error) { + return mixins.Map{"ipldgit.Tree"}.LookupByIndex(0) +} +func (n Tree) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { + return n.LookupByString(seg.String()) } -func (n Tree) ListIterator() ipld.ListIterator { - return &_Tree__ListItr{n, 0} +func (n Tree) MapIterator() ipld.MapIterator { + return &_Tree__MapItr{n, 0} } -type _Tree__ListItr struct { +type _Tree__MapItr struct { n Tree idx int } -func (itr *_Tree__ListItr) Next() (idx int64, v ipld.Node, _ error) { - if itr.idx >= len(itr.n.x) { - return -1, nil, ipld.ErrIteratorOverread{} +func (itr *_Tree__MapItr) Next() (k ipld.Node, v ipld.Node, _ error) { + if itr.idx >= len(itr.n.t) { + return nil, nil, ipld.ErrIteratorOverread{} } - idx = int64(itr.idx) - x := &itr.n.x[itr.idx] - v = x + x := &itr.n.t[itr.idx] + k = &x.k + v = &x.v itr.idx++ return } -func (itr *_Tree__ListItr) Done() bool { - return itr.idx >= len(itr.n.x) +func (itr *_Tree__MapItr) Done() bool { + return itr.idx >= len(itr.n.t) } +func (Tree) ListIterator() ipld.ListIterator { + return nil +} func (n Tree) Length() int64 { - return int64(len(n.x)) + return int64(len(n.t)) } func (Tree) IsAbsent() bool { return false @@ -6591,22 +6930,22 @@ func (Tree) IsNull() bool { return false } func (Tree) AsBool() (bool, error) { - return mixins.List{"ipldgit.Tree"}.AsBool() + return mixins.Map{"ipldgit.Tree"}.AsBool() } func (Tree) AsInt() (int64, error) { - return mixins.List{"ipldgit.Tree"}.AsInt() + return mixins.Map{"ipldgit.Tree"}.AsInt() } func (Tree) AsFloat() (float64, error) { - return mixins.List{"ipldgit.Tree"}.AsFloat() + return mixins.Map{"ipldgit.Tree"}.AsFloat() } func (Tree) AsString() (string, error) { - return mixins.List{"ipldgit.Tree"}.AsString() + return mixins.Map{"ipldgit.Tree"}.AsString() } func (Tree) AsBytes() ([]byte, error) { - return mixins.List{"ipldgit.Tree"}.AsBytes() + return mixins.Map{"ipldgit.Tree"}.AsBytes() } func (Tree) AsLink() (ipld.Link, error) { - return mixins.List{"ipldgit.Tree"}.AsLink() + return mixins.Map{"ipldgit.Tree"}.AsLink() } func (Tree) Prototype() ipld.NodePrototype { return _Tree__Prototype{} @@ -6639,20 +6978,19 @@ func (nb *_Tree__Builder) Reset() { type _Tree__Assembler struct { w *_Tree m *schema.Maybe - state laState + state maState cm schema.Maybe + ka _String__Assembler va _TreeEntry__Assembler } func (na *_Tree__Assembler) reset() { - na.state = laState_initial + na.state = maState_initial + na.ka.reset() na.va.reset() } -func (_Tree__Assembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { - return mixins.ListAssembler{"ipldgit.Tree"}.BeginMap(0) -} -func (na *_Tree__Assembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { +func (na *_Tree__Assembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { switch *na.m { case schema.Maybe_Value, schema.Maybe_Null: panic("invalid state: cannot assign into assembler that's already finished") @@ -6666,18 +7004,20 @@ func (na *_Tree__Assembler) BeginList(sizeHint int64) (ipld.ListAssembler, error if na.w == nil { na.w = &_Tree{} } - if sizeHint > 0 { - na.w.x = make([]_TreeEntry, 0, sizeHint) - } + na.w.m = make(map[_String]*_TreeEntry, sizeHint) + na.w.t = make([]_Tree__entry, 0, sizeHint) return na, nil } +func (_Tree__Assembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { + return mixins.MapAssembler{"ipldgit.Tree"}.BeginList(0) +} func (na *_Tree__Assembler) AssignNull() error { switch *na.m { case allowNull: *na.m = schema.Maybe_Null return nil case schema.Maybe_Absent: - return mixins.ListAssembler{"ipldgit.Tree"}.AssignNull() + return mixins.MapAssembler{"ipldgit.Tree"}.AssignNull() case schema.Maybe_Value, schema.Maybe_Null: panic("invalid state: cannot assign into assembler that's already finished") case midvalue: @@ -6686,22 +7026,22 @@ func (na *_Tree__Assembler) AssignNull() error { panic("unreachable") } func (_Tree__Assembler) AssignBool(bool) error { - return mixins.ListAssembler{"ipldgit.Tree"}.AssignBool(false) + return mixins.MapAssembler{"ipldgit.Tree"}.AssignBool(false) } func (_Tree__Assembler) AssignInt(int64) error { - return mixins.ListAssembler{"ipldgit.Tree"}.AssignInt(0) + return mixins.MapAssembler{"ipldgit.Tree"}.AssignInt(0) } func (_Tree__Assembler) AssignFloat(float64) error { - return mixins.ListAssembler{"ipldgit.Tree"}.AssignFloat(0) + return mixins.MapAssembler{"ipldgit.Tree"}.AssignFloat(0) } func (_Tree__Assembler) AssignString(string) error { - return mixins.ListAssembler{"ipldgit.Tree"}.AssignString("") + return mixins.MapAssembler{"ipldgit.Tree"}.AssignString("") } func (_Tree__Assembler) AssignBytes([]byte) error { - return mixins.ListAssembler{"ipldgit.Tree"}.AssignBytes(nil) + return mixins.MapAssembler{"ipldgit.Tree"}.AssignBytes(nil) } func (_Tree__Assembler) AssignLink(ipld.Link) error { - return mixins.ListAssembler{"ipldgit.Tree"}.AssignLink(nil) + return mixins.MapAssembler{"ipldgit.Tree"}.AssignLink(nil) } func (na *_Tree__Assembler) AssignNode(v ipld.Node) error { if v.IsNull() { @@ -6723,15 +7063,18 @@ func (na *_Tree__Assembler) AssignNode(v ipld.Node) error { *na.m = schema.Maybe_Value return nil } - if v.Kind() != ipld.Kind_List { - return ipld.ErrWrongKind{TypeName: "ipldgit.Tree", MethodName: "AssignNode", AppropriateKind: ipld.KindSet_JustList, ActualKind: v.Kind()} + if v.Kind() != ipld.Kind_Map { + return ipld.ErrWrongKind{TypeName: "ipldgit.Tree", MethodName: "AssignNode", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()} } - itr := v.ListIterator() + itr := v.MapIterator() for !itr.Done() { - _, v, err := itr.Next() + k, v, err := itr.Next() if err != nil { return err } + if err := na.AssembleKey().AssignNode(k); err != nil { + return err + } if err := na.AssembleValue().AssignNode(v); err != nil { return err } @@ -6741,52 +7084,128 @@ func (na *_Tree__Assembler) AssignNode(v ipld.Node) error { func (_Tree__Assembler) Prototype() ipld.NodePrototype { return _Tree__Prototype{} } -func (la *_Tree__Assembler) valueFinishTidy() bool { - switch la.cm { +func (ma *_Tree__Assembler) keyFinishTidy() bool { + switch ma.cm { case schema.Maybe_Value: - la.va.w = nil - la.cm = schema.Maybe_Absent - la.state = laState_initial - la.va.reset() + ma.ka.w = nil + tz := &ma.w.t[len(ma.w.t)-1] + ma.cm = schema.Maybe_Absent + ma.state = maState_expectValue + ma.w.m[tz.k] = &tz.v + ma.va.w = &tz.v + ma.va.m = &ma.cm + ma.ka.reset() return true default: return false } } -func (la *_Tree__Assembler) AssembleValue() ipld.NodeAssembler { - switch la.state { - case laState_initial: +func (ma *_Tree__Assembler) valueFinishTidy() bool { + switch ma.cm { + case schema.Maybe_Value: + ma.va.w = nil + ma.cm = schema.Maybe_Absent + ma.state = maState_initial + ma.va.reset() + return true + default: + return false + } +} +func (ma *_Tree__Assembler) AssembleEntry(k string) (ipld.NodeAssembler, error) { + switch ma.state { + case maState_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") + case maState_midKey: + panic("invalid state: AssembleEntry cannot be called when in the middle of assembling another key") + case maState_expectValue: + panic("invalid state: AssembleEntry cannot be called when expecting start of value assembly") + case maState_midValue: + if !ma.valueFinishTidy() { + panic("invalid state: AssembleEntry cannot be called when in the middle of assembling a value") } // if tidy success: carry on - case laState_finished: + case maState_finished: + panic("invalid state: AssembleEntry cannot be called on an assembler that's already finished") + } + + var k2 _String + if err := (_String__Prototype{}).fromString(&k2, k); err != nil { + return nil, err // TODO wrap in some kind of ErrInvalidKey + } + if _, exists := ma.w.m[k2]; exists { + return nil, ipld.ErrRepeatedMapKey{Key: &k2} + } + ma.w.t = append(ma.w.t, _Tree__entry{k: k2}) + tz := &ma.w.t[len(ma.w.t)-1] + ma.state = maState_midValue + + ma.w.m[k2] = &tz.v + ma.va.w = &tz.v + ma.va.m = &ma.cm + return &ma.va, nil +} +func (ma *_Tree__Assembler) AssembleKey() ipld.NodeAssembler { + switch ma.state { + case maState_initial: + // carry on + case maState_midKey: + panic("invalid state: AssembleKey cannot be called when in the middle of assembling another key") + case maState_expectValue: + panic("invalid state: AssembleKey cannot be called when expecting start of value assembly") + case maState_midValue: + if !ma.valueFinishTidy() { + panic("invalid state: AssembleKey cannot be called when in the middle of assembling a value") + } // if tidy success: carry on + case maState_finished: + panic("invalid state: AssembleKey cannot be called on an assembler that's already finished") + } + ma.w.t = append(ma.w.t, _Tree__entry{}) + ma.state = maState_midKey + ma.ka.m = &ma.cm + ma.ka.w = &ma.w.t[len(ma.w.t)-1].k + return &ma.ka +} +func (ma *_Tree__Assembler) AssembleValue() ipld.NodeAssembler { + switch ma.state { + case maState_initial: + panic("invalid state: AssembleValue cannot be called when no key is primed") + case maState_midKey: + if !ma.keyFinishTidy() { + panic("invalid state: AssembleValue cannot be called when in the middle of assembling a key") + } // if tidy success: carry on + case maState_expectValue: + // carry on + case maState_midValue: + panic("invalid state: AssembleValue cannot be called when in the middle of assembling another value") + case maState_finished: panic("invalid state: AssembleValue cannot be called on an assembler that's already finished") } - la.w.x = append(la.w.x, _TreeEntry{}) - 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 + ma.state = maState_midValue + return &ma.va } -func (la *_Tree__Assembler) Finish() error { - switch la.state { - case laState_initial: +func (ma *_Tree__Assembler) Finish() error { + switch ma.state { + case maState_initial: // carry on - case laState_midValue: - if !la.valueFinishTidy() { + case maState_midKey: + panic("invalid state: Finish cannot be called when in the middle of assembling a key") + case maState_expectValue: + panic("invalid state: Finish cannot be called when expecting start of value assembly") + case maState_midValue: + if !ma.valueFinishTidy() { panic("invalid state: Finish cannot be called when in the middle of assembling a value") } // if tidy success: carry on - case laState_finished: + case maState_finished: panic("invalid state: Finish cannot be called on an assembler that's already finished") } - la.state = laState_finished - *la.m = schema.Maybe_Value + ma.state = maState_finished + *ma.m = schema.Maybe_Value return nil } -func (la *_Tree__Assembler) ValuePrototype(_ int64) ipld.NodePrototype { +func (ma *_Tree__Assembler) KeyPrototype() ipld.NodePrototype { + return _String__Prototype{} +} +func (ma *_Tree__Assembler) ValuePrototype(_ string) ipld.NodePrototype { return _TreeEntry__Prototype{} } func (Tree) Type() schema.Type { @@ -6801,54 +7220,50 @@ type _Tree__Repr _Tree var _ ipld.Node = &_Tree__Repr{} func (_Tree__Repr) Kind() ipld.Kind { - return ipld.Kind_List -} -func (_Tree__Repr) LookupByString(string) (ipld.Node, error) { - return mixins.List{"ipldgit.Tree.Repr"}.LookupByString("") + return ipld.Kind_Map } -func (nr *_Tree__Repr) LookupByNode(k ipld.Node) (ipld.Node, error) { - v, err := (Tree)(nr).LookupByNode(k) +func (nr *_Tree__Repr) LookupByString(k string) (ipld.Node, error) { + v, err := (Tree)(nr).LookupByString(k) if err != nil || v == ipld.Null { return v, err } return v.(TreeEntry).Representation(), nil } -func (nr *_Tree__Repr) LookupByIndex(idx int64) (ipld.Node, error) { - v, err := (Tree)(nr).LookupByIndex(idx) +func (nr *_Tree__Repr) LookupByNode(k ipld.Node) (ipld.Node, error) { + v, err := (Tree)(nr).LookupByNode(k) if err != nil || v == ipld.Null { return v, err } return v.(TreeEntry).Representation(), nil } -func (n _Tree__Repr) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { - i, err := seg.Index() - if err != nil { - return nil, ipld.ErrInvalidSegmentForList{TypeName: "ipldgit.Tree.Repr", TroubleSegment: seg, Reason: err} - } - return n.LookupByIndex(i) +func (_Tree__Repr) LookupByIndex(idx int64) (ipld.Node, error) { + return mixins.Map{"ipldgit.Tree.Repr"}.LookupByIndex(0) } -func (_Tree__Repr) MapIterator() ipld.MapIterator { - return nil +func (n _Tree__Repr) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { + return n.LookupByString(seg.String()) } -func (nr *_Tree__Repr) ListIterator() ipld.ListIterator { - return &_Tree__ReprListItr{(Tree)(nr), 0} +func (nr *_Tree__Repr) MapIterator() ipld.MapIterator { + return &_Tree__ReprMapItr{(Tree)(nr), 0} } -type _Tree__ReprListItr _Tree__ListItr +type _Tree__ReprMapItr _Tree__MapItr -func (itr *_Tree__ReprListItr) Next() (idx int64, v ipld.Node, err error) { - idx, v, err = (*_Tree__ListItr)(itr).Next() +func (itr *_Tree__ReprMapItr) Next() (k ipld.Node, v ipld.Node, err error) { + k, v, err = (*_Tree__MapItr)(itr).Next() if err != nil || v == ipld.Null { return } - return idx, v.(TreeEntry).Representation(), nil + return k, v.(TreeEntry).Representation(), nil } -func (itr *_Tree__ReprListItr) Done() bool { - return (*_Tree__ListItr)(itr).Done() +func (itr *_Tree__ReprMapItr) Done() bool { + return (*_Tree__MapItr)(itr).Done() } +func (_Tree__Repr) ListIterator() ipld.ListIterator { + return nil +} func (rn *_Tree__Repr) Length() int64 { - return int64(len(rn.x)) + return int64(len(rn.t)) } func (_Tree__Repr) IsAbsent() bool { return false @@ -6857,22 +7272,22 @@ func (_Tree__Repr) IsNull() bool { return false } func (_Tree__Repr) AsBool() (bool, error) { - return mixins.List{"ipldgit.Tree.Repr"}.AsBool() + return mixins.Map{"ipldgit.Tree.Repr"}.AsBool() } func (_Tree__Repr) AsInt() (int64, error) { - return mixins.List{"ipldgit.Tree.Repr"}.AsInt() + return mixins.Map{"ipldgit.Tree.Repr"}.AsInt() } func (_Tree__Repr) AsFloat() (float64, error) { - return mixins.List{"ipldgit.Tree.Repr"}.AsFloat() + return mixins.Map{"ipldgit.Tree.Repr"}.AsFloat() } func (_Tree__Repr) AsString() (string, error) { - return mixins.List{"ipldgit.Tree.Repr"}.AsString() + return mixins.Map{"ipldgit.Tree.Repr"}.AsString() } func (_Tree__Repr) AsBytes() ([]byte, error) { - return mixins.List{"ipldgit.Tree.Repr"}.AsBytes() + return mixins.Map{"ipldgit.Tree.Repr"}.AsBytes() } func (_Tree__Repr) AsLink() (ipld.Link, error) { - return mixins.List{"ipldgit.Tree.Repr"}.AsLink() + return mixins.Map{"ipldgit.Tree.Repr"}.AsLink() } func (_Tree__Repr) Prototype() ipld.NodePrototype { return _Tree__ReprPrototype{} @@ -6905,20 +7320,19 @@ func (nb *_Tree__ReprBuilder) Reset() { type _Tree__ReprAssembler struct { w *_Tree m *schema.Maybe - state laState + state maState cm schema.Maybe + ka _String__ReprAssembler va _TreeEntry__ReprAssembler } func (na *_Tree__ReprAssembler) reset() { - na.state = laState_initial + na.state = maState_initial + na.ka.reset() na.va.reset() } -func (_Tree__ReprAssembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { - return mixins.ListAssembler{"ipldgit.Tree.Repr"}.BeginMap(0) -} -func (na *_Tree__ReprAssembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { +func (na *_Tree__ReprAssembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { switch *na.m { case schema.Maybe_Value, schema.Maybe_Null: panic("invalid state: cannot assign into assembler that's already finished") @@ -6932,18 +7346,20 @@ func (na *_Tree__ReprAssembler) BeginList(sizeHint int64) (ipld.ListAssembler, e if na.w == nil { na.w = &_Tree{} } - if sizeHint > 0 { - na.w.x = make([]_TreeEntry, 0, sizeHint) - } + na.w.m = make(map[_String]*_TreeEntry, sizeHint) + na.w.t = make([]_Tree__entry, 0, sizeHint) return na, nil } +func (_Tree__ReprAssembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { + return mixins.MapAssembler{"ipldgit.Tree.Repr"}.BeginList(0) +} func (na *_Tree__ReprAssembler) AssignNull() error { switch *na.m { case allowNull: *na.m = schema.Maybe_Null return nil case schema.Maybe_Absent: - return mixins.ListAssembler{"ipldgit.Tree.Repr.Repr"}.AssignNull() + return mixins.MapAssembler{"ipldgit.Tree.Repr.Repr"}.AssignNull() case schema.Maybe_Value, schema.Maybe_Null: panic("invalid state: cannot assign into assembler that's already finished") case midvalue: @@ -6952,22 +7368,22 @@ func (na *_Tree__ReprAssembler) AssignNull() error { panic("unreachable") } func (_Tree__ReprAssembler) AssignBool(bool) error { - return mixins.ListAssembler{"ipldgit.Tree.Repr"}.AssignBool(false) + return mixins.MapAssembler{"ipldgit.Tree.Repr"}.AssignBool(false) } func (_Tree__ReprAssembler) AssignInt(int64) error { - return mixins.ListAssembler{"ipldgit.Tree.Repr"}.AssignInt(0) + return mixins.MapAssembler{"ipldgit.Tree.Repr"}.AssignInt(0) } func (_Tree__ReprAssembler) AssignFloat(float64) error { - return mixins.ListAssembler{"ipldgit.Tree.Repr"}.AssignFloat(0) + return mixins.MapAssembler{"ipldgit.Tree.Repr"}.AssignFloat(0) } func (_Tree__ReprAssembler) AssignString(string) error { - return mixins.ListAssembler{"ipldgit.Tree.Repr"}.AssignString("") + return mixins.MapAssembler{"ipldgit.Tree.Repr"}.AssignString("") } func (_Tree__ReprAssembler) AssignBytes([]byte) error { - return mixins.ListAssembler{"ipldgit.Tree.Repr"}.AssignBytes(nil) + return mixins.MapAssembler{"ipldgit.Tree.Repr"}.AssignBytes(nil) } func (_Tree__ReprAssembler) AssignLink(ipld.Link) error { - return mixins.ListAssembler{"ipldgit.Tree.Repr"}.AssignLink(nil) + return mixins.MapAssembler{"ipldgit.Tree.Repr"}.AssignLink(nil) } func (na *_Tree__ReprAssembler) AssignNode(v ipld.Node) error { if v.IsNull() { @@ -6989,15 +7405,18 @@ func (na *_Tree__ReprAssembler) AssignNode(v ipld.Node) error { *na.m = schema.Maybe_Value return nil } - if v.Kind() != ipld.Kind_List { - return ipld.ErrWrongKind{TypeName: "ipldgit.Tree.Repr", MethodName: "AssignNode", AppropriateKind: ipld.KindSet_JustList, ActualKind: v.Kind()} + if v.Kind() != ipld.Kind_Map { + return ipld.ErrWrongKind{TypeName: "ipldgit.Tree.Repr", MethodName: "AssignNode", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()} } - itr := v.ListIterator() + itr := v.MapIterator() for !itr.Done() { - _, v, err := itr.Next() + k, v, err := itr.Next() if err != nil { return err } + if err := na.AssembleKey().AssignNode(k); err != nil { + return err + } if err := na.AssembleValue().AssignNode(v); err != nil { return err } @@ -7007,63 +7426,136 @@ func (na *_Tree__ReprAssembler) AssignNode(v ipld.Node) error { func (_Tree__ReprAssembler) Prototype() ipld.NodePrototype { return _Tree__ReprPrototype{} } -func (la *_Tree__ReprAssembler) valueFinishTidy() bool { - switch la.cm { +func (ma *_Tree__ReprAssembler) keyFinishTidy() bool { + switch ma.cm { case schema.Maybe_Value: - la.va.w = nil - la.cm = schema.Maybe_Absent - la.state = laState_initial - la.va.reset() + ma.ka.w = nil + tz := &ma.w.t[len(ma.w.t)-1] + ma.cm = schema.Maybe_Absent + ma.state = maState_expectValue + ma.w.m[tz.k] = &tz.v + ma.va.w = &tz.v + ma.va.m = &ma.cm + ma.ka.reset() return true default: return false } } -func (la *_Tree__ReprAssembler) AssembleValue() ipld.NodeAssembler { - switch la.state { - case laState_initial: +func (ma *_Tree__ReprAssembler) valueFinishTidy() bool { + switch ma.cm { + case schema.Maybe_Value: + ma.va.w = nil + ma.cm = schema.Maybe_Absent + ma.state = maState_initial + ma.va.reset() + return true + default: + return false + } +} +func (ma *_Tree__ReprAssembler) AssembleEntry(k string) (ipld.NodeAssembler, error) { + switch ma.state { + case maState_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") + case maState_midKey: + panic("invalid state: AssembleEntry cannot be called when in the middle of assembling another key") + case maState_expectValue: + panic("invalid state: AssembleEntry cannot be called when expecting start of value assembly") + case maState_midValue: + if !ma.valueFinishTidy() { + panic("invalid state: AssembleEntry cannot be called when in the middle of assembling a value") } // if tidy success: carry on - case laState_finished: + case maState_finished: + panic("invalid state: AssembleEntry cannot be called on an assembler that's already finished") + } + + var k2 _String + if err := (_String__ReprPrototype{}).fromString(&k2, k); err != nil { + return nil, err // TODO wrap in some kind of ErrInvalidKey + } + if _, exists := ma.w.m[k2]; exists { + return nil, ipld.ErrRepeatedMapKey{Key: &k2} + } + ma.w.t = append(ma.w.t, _Tree__entry{k: k2}) + tz := &ma.w.t[len(ma.w.t)-1] + ma.state = maState_midValue + + ma.w.m[k2] = &tz.v + ma.va.w = &tz.v + ma.va.m = &ma.cm + return &ma.va, nil +} +func (ma *_Tree__ReprAssembler) AssembleKey() ipld.NodeAssembler { + switch ma.state { + case maState_initial: + // carry on + case maState_midKey: + panic("invalid state: AssembleKey cannot be called when in the middle of assembling another key") + case maState_expectValue: + panic("invalid state: AssembleKey cannot be called when expecting start of value assembly") + case maState_midValue: + if !ma.valueFinishTidy() { + panic("invalid state: AssembleKey cannot be called when in the middle of assembling a value") + } // if tidy success: carry on + case maState_finished: + panic("invalid state: AssembleKey cannot be called on an assembler that's already finished") + } + ma.w.t = append(ma.w.t, _Tree__entry{}) + ma.state = maState_midKey + ma.ka.m = &ma.cm + ma.ka.w = &ma.w.t[len(ma.w.t)-1].k + return &ma.ka +} +func (ma *_Tree__ReprAssembler) AssembleValue() ipld.NodeAssembler { + switch ma.state { + case maState_initial: + panic("invalid state: AssembleValue cannot be called when no key is primed") + case maState_midKey: + if !ma.keyFinishTidy() { + panic("invalid state: AssembleValue cannot be called when in the middle of assembling a key") + } // if tidy success: carry on + case maState_expectValue: + // carry on + case maState_midValue: + panic("invalid state: AssembleValue cannot be called when in the middle of assembling another value") + case maState_finished: panic("invalid state: AssembleValue cannot be called on an assembler that's already finished") } - la.w.x = append(la.w.x, _TreeEntry{}) - 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 + ma.state = maState_midValue + return &ma.va } -func (la *_Tree__ReprAssembler) Finish() error { - switch la.state { - case laState_initial: +func (ma *_Tree__ReprAssembler) Finish() error { + switch ma.state { + case maState_initial: // carry on - case laState_midValue: - if !la.valueFinishTidy() { + case maState_midKey: + panic("invalid state: Finish cannot be called when in the middle of assembling a key") + case maState_expectValue: + panic("invalid state: Finish cannot be called when expecting start of value assembly") + case maState_midValue: + if !ma.valueFinishTidy() { panic("invalid state: Finish cannot be called when in the middle of assembling a value") } // if tidy success: carry on - case laState_finished: + case maState_finished: panic("invalid state: Finish cannot be called on an assembler that's already finished") } - la.state = laState_finished - *la.m = schema.Maybe_Value + ma.state = maState_finished + *ma.m = schema.Maybe_Value return nil } -func (la *_Tree__ReprAssembler) ValuePrototype(_ int64) ipld.NodePrototype { +func (ma *_Tree__ReprAssembler) KeyPrototype() ipld.NodePrototype { + return _String__ReprPrototype{} +} +func (ma *_Tree__ReprAssembler) ValuePrototype(_ string) ipld.NodePrototype { return _TreeEntry__ReprPrototype{} } func (n _TreeEntry) FieldMode() String { - return &n.Mode -} -func (n _TreeEntry) FieldName() String { - return &n.Name + return &n.mode } func (n _TreeEntry) FieldHash() Link { - return &n.Hash + return &n.hash } type _TreeEntry__Maybe struct { @@ -7101,9 +7593,8 @@ func (m MaybeTreeEntry) Must() TreeEntry { } var ( - fieldName__TreeEntry_Mode = _String{"Mode"} - fieldName__TreeEntry_Name = _String{"Name"} - fieldName__TreeEntry_Hash = _String{"Hash"} + fieldName__TreeEntry_Mode = _String{"mode"} + fieldName__TreeEntry_Hash = _String{"hash"} ) var _ ipld.Node = (TreeEntry)(&_TreeEntry{}) var _ schema.TypedNode = (TreeEntry)(&_TreeEntry{}) @@ -7113,12 +7604,10 @@ func (TreeEntry) Kind() ipld.Kind { } func (n TreeEntry) LookupByString(key string) (ipld.Node, error) { switch key { - case "Mode": - return &n.Mode, nil - case "Name": - return &n.Name, nil - case "Hash": - return &n.Hash, nil + case "mode": + return &n.mode, nil + case "hash": + return &n.hash, nil default: return nil, schema.ErrNoSuchField{Type: nil /*TODO*/, Field: ipld.PathSegmentOfString(key)} } @@ -7146,19 +7635,16 @@ type _TreeEntry__MapItr struct { } func (itr *_TreeEntry__MapItr) Next() (k ipld.Node, v ipld.Node, _ error) { - if itr.idx >= 3 { + if itr.idx >= 2 { return nil, nil, ipld.ErrIteratorOverread{} } switch itr.idx { case 0: k = &fieldName__TreeEntry_Mode - v = &itr.n.Mode + v = &itr.n.mode case 1: - k = &fieldName__TreeEntry_Name - v = &itr.n.Name - case 2: k = &fieldName__TreeEntry_Hash - v = &itr.n.Hash + v = &itr.n.hash default: panic("unreachable") } @@ -7166,14 +7652,14 @@ func (itr *_TreeEntry__MapItr) Next() (k ipld.Node, v ipld.Node, _ error) { return } func (itr *_TreeEntry__MapItr) Done() bool { - return itr.idx >= 3 + return itr.idx >= 2 } func (TreeEntry) ListIterator() ipld.ListIterator { return nil } func (TreeEntry) Length() int64 { - return 3 + return 2 } func (TreeEntry) IsAbsent() bool { return false @@ -7235,24 +7721,21 @@ type _TreeEntry__Assembler struct { f int cm schema.Maybe - ca_Mode _String__Assembler - ca_Name _String__Assembler - ca_Hash _Link__Assembler + ca_mode _String__Assembler + ca_hash _Link__Assembler } func (na *_TreeEntry__Assembler) reset() { na.state = maState_initial na.s = 0 - na.ca_Mode.reset() - na.ca_Name.reset() - na.ca_Hash.reset() + na.ca_mode.reset() + na.ca_hash.reset() } var ( fieldBit__TreeEntry_Mode = 1 << 0 - fieldBit__TreeEntry_Name = 1 << 1 - fieldBit__TreeEntry_Hash = 1 << 2 - fieldBits__TreeEntry_sufficient = 0 + 1<<0 + 1<<1 + 1<<2 + fieldBit__TreeEntry_Hash = 1 << 1 + fieldBits__TreeEntry_sufficient = 0 + 1<<0 + 1<<1 ) func (na *_TreeEntry__Assembler) BeginMap(int64) (ipld.MapAssembler, error) { @@ -7349,7 +7832,7 @@ func (ma *_TreeEntry__Assembler) valueFinishTidy() bool { case 0: switch ma.cm { case schema.Maybe_Value: - ma.ca_Mode.w = nil + ma.ca_mode.w = nil ma.cm = schema.Maybe_Absent ma.state = maState_initial return true @@ -7359,17 +7842,7 @@ func (ma *_TreeEntry__Assembler) valueFinishTidy() bool { case 1: switch ma.cm { case schema.Maybe_Value: - ma.ca_Name.w = nil - ma.cm = schema.Maybe_Absent - ma.state = maState_initial - return true - default: - return false - } - case 2: - switch ma.cm { - case schema.Maybe_Value: - ma.ca_Hash.w = nil + ma.ca_hash.w = nil ma.cm = schema.Maybe_Absent ma.state = maState_initial return true @@ -7396,36 +7869,26 @@ func (ma *_TreeEntry__Assembler) AssembleEntry(k string) (ipld.NodeAssembler, er panic("invalid state: AssembleEntry cannot be called on an assembler that's already finished") } switch k { - case "Mode": + case "mode": if ma.s&fieldBit__TreeEntry_Mode != 0 { return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__TreeEntry_Mode} } ma.s += fieldBit__TreeEntry_Mode ma.state = maState_midValue ma.f = 0 - ma.ca_Mode.w = &ma.w.Mode - ma.ca_Mode.m = &ma.cm - return &ma.ca_Mode, nil - case "Name": - if ma.s&fieldBit__TreeEntry_Name != 0 { - return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__TreeEntry_Name} - } - ma.s += fieldBit__TreeEntry_Name - ma.state = maState_midValue - ma.f = 1 - ma.ca_Name.w = &ma.w.Name - ma.ca_Name.m = &ma.cm - return &ma.ca_Name, nil - case "Hash": + ma.ca_mode.w = &ma.w.mode + ma.ca_mode.m = &ma.cm + return &ma.ca_mode, nil + case "hash": if ma.s&fieldBit__TreeEntry_Hash != 0 { return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__TreeEntry_Hash} } ma.s += fieldBit__TreeEntry_Hash ma.state = maState_midValue - ma.f = 2 - ma.ca_Hash.w = &ma.w.Hash - ma.ca_Hash.m = &ma.cm - return &ma.ca_Hash, nil + ma.f = 1 + ma.ca_hash.w = &ma.w.hash + ma.ca_hash.m = &ma.cm + return &ma.ca_hash, nil } return nil, ipld.ErrInvalidKey{TypeName: "ipldgit.TreeEntry", Key: &_String{k}} } @@ -7463,17 +7926,13 @@ func (ma *_TreeEntry__Assembler) AssembleValue() ipld.NodeAssembler { ma.state = maState_midValue switch ma.f { case 0: - ma.ca_Mode.w = &ma.w.Mode - ma.ca_Mode.m = &ma.cm - return &ma.ca_Mode + ma.ca_mode.w = &ma.w.mode + ma.ca_mode.m = &ma.cm + return &ma.ca_mode case 1: - ma.ca_Name.w = &ma.w.Name - ma.ca_Name.m = &ma.cm - return &ma.ca_Name - case 2: - ma.ca_Hash.w = &ma.w.Hash - ma.ca_Hash.m = &ma.cm - return &ma.ca_Hash + ma.ca_hash.w = &ma.w.hash + ma.ca_hash.m = &ma.cm + return &ma.ca_hash default: panic("unreachable") } @@ -7496,13 +7955,10 @@ func (ma *_TreeEntry__Assembler) Finish() error { if ma.s&fieldBits__TreeEntry_sufficient != fieldBits__TreeEntry_sufficient { err := ipld.ErrMissingRequiredField{Missing: make([]string, 0)} if ma.s&fieldBit__TreeEntry_Mode == 0 { - err.Missing = append(err.Missing, "Mode") - } - if ma.s&fieldBit__TreeEntry_Name == 0 { - err.Missing = append(err.Missing, "Name") + err.Missing = append(err.Missing, "mode") } if ma.s&fieldBit__TreeEntry_Hash == 0 { - err.Missing = append(err.Missing, "Hash") + err.Missing = append(err.Missing, "hash") } return err } @@ -7542,27 +7998,20 @@ func (ka *_TreeEntry__KeyAssembler) AssignString(k string) error { panic("misuse: KeyAssembler held beyond its valid lifetime") } switch k { - case "Mode": + case "mode": if ka.s&fieldBit__TreeEntry_Mode != 0 { return ipld.ErrRepeatedMapKey{Key: &fieldName__TreeEntry_Mode} } ka.s += fieldBit__TreeEntry_Mode ka.state = maState_expectValue ka.f = 0 - case "Name": - if ka.s&fieldBit__TreeEntry_Name != 0 { - return ipld.ErrRepeatedMapKey{Key: &fieldName__TreeEntry_Name} - } - ka.s += fieldBit__TreeEntry_Name - ka.state = maState_expectValue - ka.f = 1 - case "Hash": + case "hash": if ka.s&fieldBit__TreeEntry_Hash != 0 { return ipld.ErrRepeatedMapKey{Key: &fieldName__TreeEntry_Hash} } ka.s += fieldBit__TreeEntry_Hash ka.state = maState_expectValue - ka.f = 2 + ka.f = 1 default: return ipld.ErrInvalidKey{TypeName: "ipldgit.TreeEntry", Key: &_String{k}} } @@ -7593,31 +8042,73 @@ func (n TreeEntry) Representation() ipld.Node { type _TreeEntry__Repr _TreeEntry +var ( + fieldName__TreeEntry_Mode_serial = _String{"mode"} + fieldName__TreeEntry_Hash_serial = _String{"hash"} +) var _ ipld.Node = &_TreeEntry__Repr{} func (_TreeEntry__Repr) Kind() ipld.Kind { - return ipld.Kind_String + return ipld.Kind_Map } -func (_TreeEntry__Repr) LookupByString(string) (ipld.Node, error) { - return mixins.String{"ipldgit.TreeEntry.Repr"}.LookupByString("") +func (n *_TreeEntry__Repr) LookupByString(key string) (ipld.Node, error) { + switch key { + case "mode": + return n.mode.Representation(), nil + case "hash": + return n.hash.Representation(), nil + default: + return nil, schema.ErrNoSuchField{Type: nil /*TODO*/, Field: ipld.PathSegmentOfString(key)} + } } -func (_TreeEntry__Repr) LookupByNode(ipld.Node) (ipld.Node, error) { - return mixins.String{"ipldgit.TreeEntry.Repr"}.LookupByNode(nil) +func (n *_TreeEntry__Repr) LookupByNode(key ipld.Node) (ipld.Node, error) { + ks, err := key.AsString() + if err != nil { + return nil, err + } + return n.LookupByString(ks) } func (_TreeEntry__Repr) LookupByIndex(idx int64) (ipld.Node, error) { - return mixins.String{"ipldgit.TreeEntry.Repr"}.LookupByIndex(0) + return mixins.Map{"ipldgit.TreeEntry.Repr"}.LookupByIndex(0) } -func (_TreeEntry__Repr) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { - return mixins.String{"ipldgit.TreeEntry.Repr"}.LookupBySegment(seg) +func (n _TreeEntry__Repr) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { + return n.LookupByString(seg.String()) } -func (_TreeEntry__Repr) MapIterator() ipld.MapIterator { - return nil +func (n *_TreeEntry__Repr) MapIterator() ipld.MapIterator { + return &_TreeEntry__ReprMapItr{n, 0} +} + +type _TreeEntry__ReprMapItr struct { + n *_TreeEntry__Repr + idx int +} + +func (itr *_TreeEntry__ReprMapItr) Next() (k ipld.Node, v ipld.Node, _ error) { + if itr.idx >= 2 { + return nil, nil, ipld.ErrIteratorOverread{} + } + switch itr.idx { + case 0: + k = &fieldName__TreeEntry_Mode_serial + v = itr.n.mode.Representation() + case 1: + k = &fieldName__TreeEntry_Hash_serial + v = itr.n.hash.Representation() + default: + panic("unreachable") + } + itr.idx++ + return +} +func (itr *_TreeEntry__ReprMapItr) Done() bool { + return itr.idx >= 2 } func (_TreeEntry__Repr) ListIterator() ipld.ListIterator { return nil } -func (_TreeEntry__Repr) Length() int64 { - return -1 +func (rn *_TreeEntry__Repr) Length() int64 { + l := 2 + return int64(l) } func (_TreeEntry__Repr) IsAbsent() bool { return false @@ -7626,28 +8117,22 @@ func (_TreeEntry__Repr) IsNull() bool { return false } func (_TreeEntry__Repr) AsBool() (bool, error) { - return mixins.String{"ipldgit.TreeEntry.Repr"}.AsBool() + return mixins.Map{"ipldgit.TreeEntry.Repr"}.AsBool() } func (_TreeEntry__Repr) AsInt() (int64, error) { - return mixins.String{"ipldgit.TreeEntry.Repr"}.AsInt() + return mixins.Map{"ipldgit.TreeEntry.Repr"}.AsInt() } func (_TreeEntry__Repr) AsFloat() (float64, error) { - return mixins.String{"ipldgit.TreeEntry.Repr"}.AsFloat() + return mixins.Map{"ipldgit.TreeEntry.Repr"}.AsFloat() } -func (n *_TreeEntry__Repr) AsString() (string, error) { - return n.String(), nil -} -func (n *_TreeEntry__Repr) String() string { - return (*_String__Repr)(&n.Mode).String() + " " + (*_String__Repr)(&n.Name).String() + " " + (*_Link__Repr)(&n.Hash).String() -} -func (n TreeEntry) String() string { - return (*_TreeEntry__Repr)(n).String() +func (_TreeEntry__Repr) AsString() (string, error) { + return mixins.Map{"ipldgit.TreeEntry.Repr"}.AsString() } func (_TreeEntry__Repr) AsBytes() ([]byte, error) { - return mixins.String{"ipldgit.TreeEntry.Repr"}.AsBytes() + return mixins.Map{"ipldgit.TreeEntry.Repr"}.AsBytes() } func (_TreeEntry__Repr) AsLink() (ipld.Link, error) { - return mixins.String{"ipldgit.TreeEntry.Repr"}.AsLink() + return mixins.Map{"ipldgit.TreeEntry.Repr"}.AsLink() } func (_TreeEntry__Repr) Prototype() ipld.NodePrototype { return _TreeEntry__ReprPrototype{} @@ -7676,34 +8161,40 @@ func (nb *_TreeEntry__ReprBuilder) Reset() { var m schema.Maybe *nb = _TreeEntry__ReprBuilder{_TreeEntry__ReprAssembler{w: &w, m: &m}} } -func (_TreeEntry__ReprPrototype) fromString(w *_TreeEntry, v string) error { - ss, err := mixins.SplitExact(v, " ", 3) - if err != nil { - return ipld.ErrUnmatchable{TypeName: "ipldgit.TreeEntry.Repr", Reason: err} - } - if err := (_String__ReprPrototype{}).fromString(&w.Mode, ss[0]); err != nil { - return ipld.ErrUnmatchable{TypeName: "ipldgit.TreeEntry.Repr", Reason: err} - } - if err := (_String__ReprPrototype{}).fromString(&w.Name, ss[1]); err != nil { - return ipld.ErrUnmatchable{TypeName: "ipldgit.TreeEntry.Repr", Reason: err} - } - if err := (_Link__ReprPrototype{}).fromString(&w.Hash, ss[2]); err != nil { - return ipld.ErrUnmatchable{TypeName: "ipldgit.TreeEntry.Repr", Reason: err} - } - return nil -} type _TreeEntry__ReprAssembler struct { - w *_TreeEntry - m *schema.Maybe + w *_TreeEntry + m *schema.Maybe + state maState + s int + f int + + cm schema.Maybe + ca_mode _String__ReprAssembler + ca_hash _Link__ReprAssembler } -func (na *_TreeEntry__ReprAssembler) reset() {} -func (_TreeEntry__ReprAssembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { - return mixins.StringAssembler{"ipldgit.TreeEntry.Repr"}.BeginMap(0) +func (na *_TreeEntry__ReprAssembler) reset() { + na.state = maState_initial + na.s = 0 + na.ca_mode.reset() + na.ca_hash.reset() +} +func (na *_TreeEntry__ReprAssembler) BeginMap(int64) (ipld.MapAssembler, 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 na.w == nil { + na.w = &_TreeEntry{} + } + return na, nil } func (_TreeEntry__ReprAssembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { - return mixins.StringAssembler{"ipldgit.TreeEntry.Repr"}.BeginList(0) + return mixins.MapAssembler{"ipldgit.TreeEntry.Repr"}.BeginList(0) } func (na *_TreeEntry__ReprAssembler) AssignNull() error { switch *na.m { @@ -7711,40 +8202,31 @@ func (na *_TreeEntry__ReprAssembler) AssignNull() error { *na.m = schema.Maybe_Null return nil case schema.Maybe_Absent: - return mixins.StringAssembler{"ipldgit.TreeEntry.Repr.Repr"}.AssignNull() + return mixins.MapAssembler{"ipldgit.TreeEntry.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 (_TreeEntry__ReprAssembler) AssignBool(bool) error { - return mixins.StringAssembler{"ipldgit.TreeEntry.Repr"}.AssignBool(false) + return mixins.MapAssembler{"ipldgit.TreeEntry.Repr"}.AssignBool(false) } func (_TreeEntry__ReprAssembler) AssignInt(int64) error { - return mixins.StringAssembler{"ipldgit.TreeEntry.Repr"}.AssignInt(0) + return mixins.MapAssembler{"ipldgit.TreeEntry.Repr"}.AssignInt(0) } func (_TreeEntry__ReprAssembler) AssignFloat(float64) error { - return mixins.StringAssembler{"ipldgit.TreeEntry.Repr"}.AssignFloat(0) + return mixins.MapAssembler{"ipldgit.TreeEntry.Repr"}.AssignFloat(0) } -func (na *_TreeEntry__ReprAssembler) 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 = &_TreeEntry{} - } - if err := (_TreeEntry__ReprPrototype{}).fromString(na.w, v); err != nil { - return err - } - *na.m = schema.Maybe_Value - return nil +func (_TreeEntry__ReprAssembler) AssignString(string) error { + return mixins.MapAssembler{"ipldgit.TreeEntry.Repr"}.AssignString("") } func (_TreeEntry__ReprAssembler) AssignBytes([]byte) error { - return mixins.StringAssembler{"ipldgit.TreeEntry.Repr"}.AssignBytes(nil) + return mixins.MapAssembler{"ipldgit.TreeEntry.Repr"}.AssignBytes(nil) } func (_TreeEntry__ReprAssembler) AssignLink(ipld.Link) error { - return mixins.StringAssembler{"ipldgit.TreeEntry.Repr"}.AssignLink(nil) + return mixins.MapAssembler{"ipldgit.TreeEntry.Repr"}.AssignLink(nil) } func (na *_TreeEntry__ReprAssembler) AssignNode(v ipld.Node) error { if v.IsNull() { @@ -7754,6 +8236,8 @@ func (na *_TreeEntry__ReprAssembler) AssignNode(v ipld.Node) 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: cannot assign null into an assembler that's already begun working on recursive structures!") } if na.w == nil { na.w = v2 @@ -7764,12 +8248,229 @@ func (na *_TreeEntry__ReprAssembler) AssignNode(v ipld.Node) error { *na.m = schema.Maybe_Value return nil } + if v.Kind() != ipld.Kind_Map { + return ipld.ErrWrongKind{TypeName: "ipldgit.TreeEntry.Repr", MethodName: "AssignNode", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()} + } + itr := v.MapIterator() + for !itr.Done() { + k, v, err := itr.Next() + if err != nil { + return err + } + if err := na.AssembleKey().AssignNode(k); err != nil { + return err + } + if err := na.AssembleValue().AssignNode(v); err != nil { + return err + } + } + return na.Finish() +} +func (_TreeEntry__ReprAssembler) Prototype() ipld.NodePrototype { + return _TreeEntry__ReprPrototype{} +} +func (ma *_TreeEntry__ReprAssembler) valueFinishTidy() bool { + switch ma.f { + case 0: + switch ma.cm { + case schema.Maybe_Value: + ma.cm = schema.Maybe_Absent + ma.state = maState_initial + return true + default: + return false + } + case 1: + switch ma.cm { + case schema.Maybe_Value: + ma.cm = schema.Maybe_Absent + ma.state = maState_initial + return true + default: + return false + } + default: + panic("unreachable") + } +} +func (ma *_TreeEntry__ReprAssembler) AssembleEntry(k string) (ipld.NodeAssembler, error) { + switch ma.state { + case maState_initial: + // carry on + case maState_midKey: + panic("invalid state: AssembleEntry cannot be called when in the middle of assembling another key") + case maState_expectValue: + panic("invalid state: AssembleEntry cannot be called when expecting start of value assembly") + case maState_midValue: + if !ma.valueFinishTidy() { + panic("invalid state: AssembleEntry cannot be called when in the middle of assembling a value") + } // if tidy success: carry on + case maState_finished: + panic("invalid state: AssembleEntry cannot be called on an assembler that's already finished") + } + switch k { + case "mode": + if ma.s&fieldBit__TreeEntry_Mode != 0 { + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__TreeEntry_Mode_serial} + } + ma.s += fieldBit__TreeEntry_Mode + ma.state = maState_midValue + ma.f = 0 + ma.ca_mode.w = &ma.w.mode + ma.ca_mode.m = &ma.cm + return &ma.ca_mode, nil + case "hash": + if ma.s&fieldBit__TreeEntry_Hash != 0 { + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__TreeEntry_Hash_serial} + } + ma.s += fieldBit__TreeEntry_Hash + ma.state = maState_midValue + ma.f = 1 + ma.ca_hash.w = &ma.w.hash + ma.ca_hash.m = &ma.cm + return &ma.ca_hash, nil + default: + } + return nil, ipld.ErrInvalidKey{TypeName: "ipldgit.TreeEntry.Repr", Key: &_String{k}} +} +func (ma *_TreeEntry__ReprAssembler) AssembleKey() ipld.NodeAssembler { + switch ma.state { + case maState_initial: + // carry on + case maState_midKey: + panic("invalid state: AssembleKey cannot be called when in the middle of assembling another key") + case maState_expectValue: + panic("invalid state: AssembleKey cannot be called when expecting start of value assembly") + case maState_midValue: + if !ma.valueFinishTidy() { + panic("invalid state: AssembleKey cannot be called when in the middle of assembling a value") + } // if tidy success: carry on + case maState_finished: + panic("invalid state: AssembleKey cannot be called on an assembler that's already finished") + } + ma.state = maState_midKey + return (*_TreeEntry__ReprKeyAssembler)(ma) +} +func (ma *_TreeEntry__ReprAssembler) AssembleValue() ipld.NodeAssembler { + switch ma.state { + case maState_initial: + panic("invalid state: AssembleValue cannot be called when no key is primed") + case maState_midKey: + panic("invalid state: AssembleValue cannot be called when in the middle of assembling a key") + case maState_expectValue: + // carry on + case maState_midValue: + panic("invalid state: AssembleValue cannot be called when in the middle of assembling another value") + case maState_finished: + panic("invalid state: AssembleValue cannot be called on an assembler that's already finished") + } + ma.state = maState_midValue + switch ma.f { + case 0: + ma.ca_mode.w = &ma.w.mode + ma.ca_mode.m = &ma.cm + return &ma.ca_mode + case 1: + ma.ca_hash.w = &ma.w.hash + ma.ca_hash.m = &ma.cm + return &ma.ca_hash + default: + panic("unreachable") + } +} +func (ma *_TreeEntry__ReprAssembler) Finish() error { + switch ma.state { + case maState_initial: + // carry on + case maState_midKey: + panic("invalid state: Finish cannot be called when in the middle of assembling a key") + case maState_expectValue: + panic("invalid state: Finish cannot be called when expecting start of value assembly") + case maState_midValue: + if !ma.valueFinishTidy() { + panic("invalid state: Finish cannot be called when in the middle of assembling a value") + } // if tidy success: carry on + case maState_finished: + panic("invalid state: Finish cannot be called on an assembler that's already finished") + } + if ma.s&fieldBits__TreeEntry_sufficient != fieldBits__TreeEntry_sufficient { + err := ipld.ErrMissingRequiredField{Missing: make([]string, 0)} + if ma.s&fieldBit__TreeEntry_Mode == 0 { + err.Missing = append(err.Missing, "mode") + } + if ma.s&fieldBit__TreeEntry_Hash == 0 { + err.Missing = append(err.Missing, "hash") + } + return err + } + ma.state = maState_finished + *ma.m = schema.Maybe_Value + return nil +} +func (ma *_TreeEntry__ReprAssembler) KeyPrototype() ipld.NodePrototype { + return _String__Prototype{} +} +func (ma *_TreeEntry__ReprAssembler) ValuePrototype(k string) ipld.NodePrototype { + panic("todo structbuilder mapassembler repr valueprototype") +} + +type _TreeEntry__ReprKeyAssembler _TreeEntry__ReprAssembler + +func (_TreeEntry__ReprKeyAssembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { + return mixins.StringAssembler{"ipldgit.TreeEntry.Repr.KeyAssembler"}.BeginMap(0) +} +func (_TreeEntry__ReprKeyAssembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { + return mixins.StringAssembler{"ipldgit.TreeEntry.Repr.KeyAssembler"}.BeginList(0) +} +func (na *_TreeEntry__ReprKeyAssembler) AssignNull() error { + return mixins.StringAssembler{"ipldgit.TreeEntry.Repr.KeyAssembler"}.AssignNull() +} +func (_TreeEntry__ReprKeyAssembler) AssignBool(bool) error { + return mixins.StringAssembler{"ipldgit.TreeEntry.Repr.KeyAssembler"}.AssignBool(false) +} +func (_TreeEntry__ReprKeyAssembler) AssignInt(int64) error { + return mixins.StringAssembler{"ipldgit.TreeEntry.Repr.KeyAssembler"}.AssignInt(0) +} +func (_TreeEntry__ReprKeyAssembler) AssignFloat(float64) error { + return mixins.StringAssembler{"ipldgit.TreeEntry.Repr.KeyAssembler"}.AssignFloat(0) +} +func (ka *_TreeEntry__ReprKeyAssembler) AssignString(k string) error { + if ka.state != maState_midKey { + panic("misuse: KeyAssembler held beyond its valid lifetime") + } + switch k { + case "mode": + if ka.s&fieldBit__TreeEntry_Mode != 0 { + return ipld.ErrRepeatedMapKey{Key: &fieldName__TreeEntry_Mode_serial} + } + ka.s += fieldBit__TreeEntry_Mode + ka.state = maState_expectValue + ka.f = 0 + return nil + case "hash": + if ka.s&fieldBit__TreeEntry_Hash != 0 { + return ipld.ErrRepeatedMapKey{Key: &fieldName__TreeEntry_Hash_serial} + } + ka.s += fieldBit__TreeEntry_Hash + ka.state = maState_expectValue + ka.f = 1 + return nil + } + return ipld.ErrInvalidKey{TypeName: "ipldgit.TreeEntry.Repr", Key: &_String{k}} +} +func (_TreeEntry__ReprKeyAssembler) AssignBytes([]byte) error { + return mixins.StringAssembler{"ipldgit.TreeEntry.Repr.KeyAssembler"}.AssignBytes(nil) +} +func (_TreeEntry__ReprKeyAssembler) AssignLink(ipld.Link) error { + return mixins.StringAssembler{"ipldgit.TreeEntry.Repr.KeyAssembler"}.AssignLink(nil) +} +func (ka *_TreeEntry__ReprKeyAssembler) AssignNode(v ipld.Node) error { if v2, err := v.AsString(); err != nil { return err } else { - return na.AssignString(v2) + return ka.AssignString(v2) } } -func (_TreeEntry__ReprAssembler) Prototype() ipld.NodePrototype { - return _TreeEntry__ReprPrototype{} +func (_TreeEntry__ReprKeyAssembler) Prototype() ipld.NodePrototype { + return _String__Prototype{} } diff --git a/ipldsch_types.go b/ipldsch_types.go index 6b8f572..77ef630 100644 --- a/ipldsch_types.go +++ b/ipldsch_types.go @@ -57,15 +57,15 @@ type _Blob struct{ x []byte } // Commit matches the IPLD Schema type "Commit". It has Struct type-kind, and may be interrogated like map kind. type Commit = *_Commit type _Commit struct { - GitTree _LinkTree - Parents _ListParents - Message _String - Author _PersonInfo__Maybe - Committer _PersonInfo__Maybe - Encoding _String__Maybe - Sig _GpgSig__Maybe - MergeTag _ListTag - Other _ListString + tree _LinkTree + parents _ListParents + message _String + author _PersonInfo__Maybe + committer _PersonInfo__Maybe + encoding _String__Maybe + signature _GpgSig__Maybe + mergeTag _ListTag + other _ListString } // GpgSig matches the IPLD Schema type "GpgSig". It has string kind. @@ -101,10 +101,10 @@ type _ListTag struct { // PersonInfo matches the IPLD Schema type "PersonInfo". It has Struct type-kind, and may be interrogated like map kind. type PersonInfo = *_PersonInfo type _PersonInfo struct { - Name _String - Email _String - Date _String - Timezone _String + name _String + email _String + date _String + timezone _String } // String matches the IPLD Schema type "String". It has string kind. @@ -114,23 +114,27 @@ type _String struct{ x string } // Tag matches the IPLD Schema type "Tag". It has Struct type-kind, and may be interrogated like map kind. type Tag = *_Tag type _Tag struct { - Object _Link - TagType _String - Tag _String - Tagger _PersonInfo - Text _String + object _Link + tagType _String + tag _String + tagger _PersonInfo + text _String } -// Tree matches the IPLD Schema type "Tree". It has list kind. +// Tree matches the IPLD Schema type "Tree". It has map kind. type Tree = *_Tree type _Tree struct { - x []_TreeEntry + m map[_String]*_TreeEntry + t []_Tree__entry +} +type _Tree__entry struct { + k _String + v _TreeEntry } // TreeEntry matches the IPLD Schema type "TreeEntry". It has Struct type-kind, and may be interrogated like map kind. type TreeEntry = *_TreeEntry type _TreeEntry struct { - Mode _String - Name _String - Hash _Link + mode _String + hash _Link } diff --git a/marshal.go b/marshal.go index f326a7a..2a54d1a 100644 --- a/marshal.go +++ b/marshal.go @@ -36,11 +36,11 @@ func Encode(n ipld.Node, w io.Writer) error { } switch repKey { case - "Object", - "TagType", - "Tag", - "Tagger", - "Text": + "object", + "tagType", + "tag", + "tagger", + "text": return encodeTag(n, w) default: return encodeCommit(n, w) diff --git a/personinfo.go b/personinfo.go index 367bf7d..c756884 100644 --- a/personinfo.go +++ b/personinfo.go @@ -34,7 +34,7 @@ func parsePersonInfo(line []byte) (PersonInfo, error) { at++ } if len(name) != 0 { - pi.Name = _String{name[:len(name)-1]} + pi.name = _String{name[:len(name)-1]} } var email string @@ -54,32 +54,32 @@ func parsePersonInfo(line []byte) (PersonInfo, error) { } email += string(part) + " " } - pi.Email = _String{email} + pi.email = _String{email} if at == len(parts) { return &pi, nil } - pi.Date = _String{string(parts[at])} + pi.date = _String{string(parts[at])} at++ if at == len(parts) { return &pi, nil } - pi.Timezone = _String{string(parts[at])} + pi.timezone = _String{string(parts[at])} return &pi, nil } func (p _PersonInfo) GitString() string { f := "%s <%s>" - arg := []interface{}{p.Name.x, p.Email.x} - if p.Date.x != "" { + arg := []interface{}{p.name.x, p.email.x} + if p.date.x != "" { f = f + " %s" - arg = append(arg, p.Date.x) + arg = append(arg, p.date.x) } - if p.Timezone.x != "" { + if p.timezone.x != "" { f = f + " %s" - arg = append(arg, p.Timezone.x) + arg = append(arg, p.timezone.x) } return fmt.Sprintf(f, arg...) } diff --git a/tag.go b/tag.go index 584f396..9c88ce7 100644 --- a/tag.go +++ b/tag.go @@ -41,25 +41,25 @@ func DecodeTag(na ipld.NodeAssembler, rd *bufio.Reader) error { return err } - out.Object = _Link{cidlink.Link{Cid: shaToCid(sha)}} + out.object = _Link{cidlink.Link{Cid: shaToCid(sha)}} case bytes.HasPrefix(line, []byte("tag ")): - out.Tag = _String{string(line[tagTagPrefixLen:])} + out.tag = _String{string(line[tagTagPrefixLen:])} case bytes.HasPrefix(line, []byte("tagger ")): c, err := parsePersonInfo(line) if err != nil { return err } - out.Tagger = *c + out.tagger = *c case bytes.HasPrefix(line, []byte("type ")): - out.TagType = _String{string(line[tagTypePrefixLen:])} + out.tagType = _String{string(line[tagTypePrefixLen:])} case len(line) == 0: rest, err := ioutil.ReadAll(rd) if err != nil { return err } - out.Text = _String{string(rest)} + out.text = _String{string(rest)} default: fmt.Println("unhandled line: ", string(line)) } @@ -72,7 +72,7 @@ func DecodeTag(na ipld.NodeAssembler, rd *bufio.Reader) error { func readMergeTag(hash []byte, rd *bufio.Reader) (Tag, []byte, error) { out := _Tag{} - out.Object = _Link{cidlink.Link{Cid: shaToCid(hash)}} + out.object = _Link{cidlink.Link{Cid: shaToCid(hash)}} for { line, _, err := rd.ReadLine() if err != nil { @@ -84,15 +84,15 @@ func readMergeTag(hash []byte, rd *bufio.Reader) (Tag, []byte, error) { switch { case bytes.HasPrefix(line, []byte(" type ")): - out.TagType = _String{string(line[1+tagTypePrefixLen:])} + out.tagType = _String{string(line[1+tagTypePrefixLen:])} case bytes.HasPrefix(line, []byte(" tag ")): - out.Tag = _String{string(line[1+tagTagPrefixLen:])} + out.tag = _String{string(line[1+tagTagPrefixLen:])} case bytes.HasPrefix(line, []byte(" tagger ")): tagger, err := parsePersonInfo(line[1:]) if err != nil { return nil, nil, err } - out.Tagger = *tagger + out.tagger = *tagger case string(line) == " ": for { line, _, err := rd.ReadLine() @@ -104,7 +104,7 @@ func readMergeTag(hash []byte, rd *bufio.Reader) (Tag, []byte, error) { return &out, line, nil } - out.Text.x += string(line) + "\n" + out.text.x += string(line) + "\n" } } } @@ -112,7 +112,7 @@ func readMergeTag(hash []byte, rd *bufio.Reader) (Tag, []byte, error) { } func encodeTag(n ipld.Node, w io.Writer) error { - obj, err := n.LookupByString("Object") + obj, err := n.LookupByString("object") if err != nil { return err } @@ -121,7 +121,7 @@ func encodeTag(n ipld.Node, w io.Writer) error { return err } - tt, err := n.LookupByString("TagType") + tt, err := n.LookupByString("tagType") if err != nil { return err } @@ -130,7 +130,7 @@ func encodeTag(n ipld.Node, w io.Writer) error { return err } - tag, err := n.LookupByString("Tag") + tag, err := n.LookupByString("tag") if err != nil { return err } @@ -139,7 +139,7 @@ func encodeTag(n ipld.Node, w io.Writer) error { return err } - text, err := n.LookupByString("Text") + text, err := n.LookupByString("text") if err != nil { return err } @@ -148,7 +148,7 @@ func encodeTag(n ipld.Node, w io.Writer) error { return err } - tagger, taggerErr := n.LookupByString("Tagger") + tagger, taggerErr := n.LookupByString("tagger") buf := new(bytes.Buffer) fmt.Fprintf(buf, "object %s\n", hex.EncodeToString(sha(objLnk))) diff --git a/tree.go b/tree.go index fa05c0a..14d7e71 100644 --- a/tree.go +++ b/tree.go @@ -17,66 +17,73 @@ func DecodeTree(na ipld.NodeAssembler, rd *bufio.Reader) error { } t := Type.Tree__Repr.NewBuilder() - la, err := t.BeginList(-1) + ma, err := t.BeginMap(-1) if err != nil { return err } for { - node, err := DecodeTreeEntry(rd) + name, node, err := DecodeTreeEntry(rd) if err != nil { if err == io.EOF { break } return err } - if err := la.AssembleValue().AssignNode(node); err != nil { + ee, err := ma.AssembleEntry(name) + if err != nil { + return err + } + if err = ee.AssignNode(node); err != nil { return err } } - if err := la.Finish(); err != nil { + if err := ma.Finish(); err != nil { return err } return na.AssignNode(t.Build()) } // DecodeTreeEntry fills a NodeAssembler (from `Type.TreeEntry__Repr.NewBuilder()`) from a stream of bytes -func DecodeTreeEntry(rd *bufio.Reader) (ipld.Node, error) { +func DecodeTreeEntry(rd *bufio.Reader) (string, ipld.Node, error) { data, err := rd.ReadString(' ') if err != nil { - return nil, err + return "", nil, err } data = data[:len(data)-1] name, err := rd.ReadString(0) if err != nil { - return nil, err + return "", nil, err } name = name[:len(name)-1] sha := make([]byte, 20) _, err = io.ReadFull(rd, sha) if err != nil { - return nil, err + return "", nil, err } te := _TreeEntry{ - Mode: _String{data}, - Name: _String{name}, - Hash: _Link{cidlink.Link{Cid: shaToCid(sha)}}, + mode: _String{data}, + hash: _Link{cidlink.Link{Cid: shaToCid(sha)}}, } - return &te, nil + return name, &te, nil } func encodeTree(n ipld.Node, w io.Writer) error { buf := new(bytes.Buffer) - li := n.ListIterator() - for !li.Done() { - _, te, err := li.Next() + mi := n.MapIterator() + for !mi.Done() { + key, te, err := mi.Next() + if err != nil { + return err + } + name, err := key.AsString() if err != nil { return err } - if err := encodeTreeEntry(te, buf); err != nil { + if err := encodeTreeEntry(name, te, buf); err != nil { return err } } @@ -89,8 +96,8 @@ func encodeTree(n ipld.Node, w io.Writer) error { return err } -func encodeTreeEntry(n ipld.Node, w io.Writer) error { - m, err := n.LookupByString("Mode") +func encodeTreeEntry(name string, n ipld.Node, w io.Writer) error { + m, err := n.LookupByString("mode") if err != nil { return err } @@ -98,19 +105,11 @@ func encodeTreeEntry(n ipld.Node, w io.Writer) error { if err != nil { return err } - na, err := n.LookupByString("Name") - if err != nil { - return err - } - ns, err := na.AsString() - if err != nil { - return err - } - ha, err := n.LookupByString("Hash") + ha, err := n.LookupByString("hash") if err != nil { return err } - _, err = fmt.Fprintf(w, "%s %s\x00", ms, ns) + _, err = fmt.Fprintf(w, "%s %s\x00", ms, name) if err != nil { return err } From fc090117f357894e81aae6d692b085db6ca70a5f Mon Sep 17 00:00:00 2001 From: Rod Vagg Date: Mon, 26 Jul 2021 17:19:18 +1000 Subject: [PATCH 14/22] Update go-ipld-prime, manually fix LinkTree.LinkTargetNodePrototype --- commit.go | 18 +- go.mod | 2 +- go.sum | 9 +- ipld_missing.go | 19 - ipldsch_satisfaction.go | 970 ++++++++++++++++++---------------------- unmarshal.go | 2 +- 6 files changed, 449 insertions(+), 571 deletions(-) delete mode 100644 ipld_missing.go diff --git a/commit.go b/commit.go index 07b3a94..13c432b 100644 --- a/commit.go +++ b/commit.go @@ -76,7 +76,7 @@ func decodeCommitLine(c Commit, line []byte, rd *bufio.Reader) error { c.committer = _PersonInfo__Maybe{m: schema.Maybe_Value, v: com} case bytes.HasPrefix(line, []byte("encoding ")): - c.encoding = _String__Maybe{m: schema.Maybe_Value, v: &_String{string(line[9:])}} + c.encoding = _String__Maybe{m: schema.Maybe_Value, v: _String{string(line[9:])}} case bytes.HasPrefix(line, []byte("mergetag object ")): sha, err := hex.DecodeString(string(line)[prefixMergetag:]) if err != nil { @@ -115,19 +115,19 @@ func decodeCommitLine(c Commit, line []byte, rd *bufio.Reader) error { return nil } -func decodeGpgSig(rd *bufio.Reader) (GpgSig, error) { +func decodeGpgSig(rd *bufio.Reader) (_GpgSig, error) { + out := _GpgSig{} + line, _, err := rd.ReadLine() if err != nil { - return nil, err + return out, err } - out := _GpgSig{} - if string(line) != " " { if strings.HasPrefix(string(line), " Version: ") || strings.HasPrefix(string(line), " Comment: ") { out.x += string(line) + "\n" } else { - return nil, fmt.Errorf("expected first line of sig to be a single space or version") + return out, fmt.Errorf("expected first line of sig to be a single space or version") } } else { out.x += " \n" @@ -136,7 +136,7 @@ func decodeGpgSig(rd *bufio.Reader) (GpgSig, error) { for { line, _, err := rd.ReadLine() if err != nil { - return nil, err + return out, err } if bytes.Equal(line, []byte(" -----END PGP SIGNATURE-----")) { @@ -146,7 +146,7 @@ func decodeGpgSig(rd *bufio.Reader) (GpgSig, error) { out.x += string(line) + "\n" } - return &out, nil + return out, nil } func encodeCommit(n ipld.Node, w io.Writer) error { @@ -184,7 +184,7 @@ func encodeCommit(n ipld.Node, w io.Writer) error { } fmt.Fprintf(buf, "\n%s", c.message.x) - fmt.Printf("encode commit len: %d \n", buf.Len()) + // fmt.Printf("encode commit len: %d \n", buf.Len()) // fmt.Printf("out: %s\n", string(buf.Bytes())) _, err := fmt.Fprintf(w, "commit %d\x00", buf.Len()) if err != nil { diff --git a/go.mod b/go.mod index 7859556..f9cfce8 100644 --- a/go.mod +++ b/go.mod @@ -5,6 +5,6 @@ go 1.15 require ( github.com/ipfs/go-block-format v0.0.3 github.com/ipfs/go-cid v0.0.7 - github.com/ipld/go-ipld-prime v0.9.1-0.20210324083106-dc342a9917db + github.com/ipld/go-ipld-prime v0.10.1-0.20210723093545-ebe39c7bab39 github.com/multiformats/go-multihash v0.0.15 ) diff --git a/go.sum b/go.sum index fd0d926..38fde86 100644 --- a/go.sum +++ b/go.sum @@ -1,4 +1,6 @@ +github.com/frankban/quicktest v1.11.3 h1:8sXhOn0uLys67V8EsXLc6eszDs8VXWxL3iRvebPhedY= github.com/frankban/quicktest v1.11.3/go.mod h1:wRf/ReqHper53s+kmmSZizM8NamnL3IM0I9ntUbOk+k= +github.com/google/go-cmp v0.5.4 h1:L8R9j+yAqZuZjsqh/z+F1NCffTKKLShY6zXTItVIZ8M= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= 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= @@ -9,14 +11,16 @@ 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/ipfs/go-ipfs-util v0.0.2 h1:59Sswnk1MFaiq+VcaknX7aYEyGyGDAA73ilhEK2POp8= github.com/ipfs/go-ipfs-util v0.0.2/go.mod h1:CbPtkWJzjLdEcezDns2XYaehFVNXG9zrdrtMecczcsQ= -github.com/ipld/go-ipld-prime v0.9.1-0.20210324083106-dc342a9917db h1:kFwGn8rXa/Z31ev1OFNQsYeNKNCdifnTPl/NvPy5L38= -github.com/ipld/go-ipld-prime v0.9.1-0.20210324083106-dc342a9917db/go.mod h1:KvBLMr4PX1gWptgkzRjVZCrLmSGcZCb/jioOQwCqZN8= +github.com/ipld/go-ipld-prime v0.10.1-0.20210723093545-ebe39c7bab39 h1:70/42k1tU7ZHuyjFDd7vbd6dgnMyFnC0fe8LKeF9ZPg= +github.com/ipld/go-ipld-prime v0.10.1-0.20210723093545-ebe39c7bab39/go.mod h1:KvBLMr4PX1gWptgkzRjVZCrLmSGcZCb/jioOQwCqZN8= 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/klauspost/cpuid/v2 v2.0.4 h1:g0I61F2K2DjRHz1cnxlkNSBIaePVoJIjjnHui8QHbiw= github.com/klauspost/cpuid/v2 v2.0.4/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg= +github.com/kr/pretty v0.2.1 h1:Fmg33tUaq4/8ym9TJN1x7sLJnHVwhP33CNkpYV/7rwI= github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI= github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= +github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE= github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= 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= @@ -66,4 +70,5 @@ golang.org/x/sys v0.0.0-20210309074719-68d13333faf2/go.mod h1:h1NjWce9XRLGQEsW7w 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= +golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4= golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= diff --git a/ipld_missing.go b/ipld_missing.go deleted file mode 100644 index 23f7012..0000000 --- a/ipld_missing.go +++ /dev/null @@ -1,19 +0,0 @@ -package ipldgit - -import ( - "github.com/ipfs/go-cid" - cidlink "github.com/ipld/go-ipld-prime/linking/cid" -) - -func (ip _Link__Prototype) fromString(l *_Link, s string) error { - c, err := cid.Decode(s) - if err != nil { - return err - } - l.x = cidlink.Link{Cid: c} - return nil -} - -func (ip *_Link) String() string { - return ip.String() -} diff --git a/ipldsch_satisfaction.go b/ipldsch_satisfaction.go index 93d0235..91cd843 100644 --- a/ipldsch_satisfaction.go +++ b/ipldsch_satisfaction.go @@ -18,7 +18,7 @@ func (_Blob__Prototype) FromBytes(v []byte) (Blob, error) { type _Blob__Maybe struct { m schema.Maybe - v Blob + v _Blob } type MaybeBlob = *_Blob__Maybe @@ -38,7 +38,7 @@ func (m MaybeBlob) AsNode() ipld.Node { case schema.Maybe_Null: return ipld.Null case schema.Maybe_Value: - return m.v + return &m.v default: panic("unreachable") } @@ -47,7 +47,7 @@ func (m MaybeBlob) Must() Blob { if !m.Exists() { panic("unbox of a maybe rejected") } - return m.v + return &m.v } var _ ipld.Node = (Blob)(&_Blob{}) @@ -57,16 +57,16 @@ func (Blob) Kind() ipld.Kind { return ipld.Kind_Bytes } func (Blob) LookupByString(string) (ipld.Node, error) { - return mixins.Bytes{"ipldgit.Blob"}.LookupByString("") + return mixins.Bytes{TypeName: "ipldgit.Blob"}.LookupByString("") } func (Blob) LookupByNode(ipld.Node) (ipld.Node, error) { - return mixins.Bytes{"ipldgit.Blob"}.LookupByNode(nil) + return mixins.Bytes{TypeName: "ipldgit.Blob"}.LookupByNode(nil) } func (Blob) LookupByIndex(idx int64) (ipld.Node, error) { - return mixins.Bytes{"ipldgit.Blob"}.LookupByIndex(0) + return mixins.Bytes{TypeName: "ipldgit.Blob"}.LookupByIndex(0) } func (Blob) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { - return mixins.Bytes{"ipldgit.Blob"}.LookupBySegment(seg) + return mixins.Bytes{TypeName: "ipldgit.Blob"}.LookupBySegment(seg) } func (Blob) MapIterator() ipld.MapIterator { return nil @@ -84,22 +84,22 @@ func (Blob) IsNull() bool { return false } func (Blob) AsBool() (bool, error) { - return mixins.Bytes{"ipldgit.Blob"}.AsBool() + return mixins.Bytes{TypeName: "ipldgit.Blob"}.AsBool() } func (Blob) AsInt() (int64, error) { - return mixins.Bytes{"ipldgit.Blob"}.AsInt() + return mixins.Bytes{TypeName: "ipldgit.Blob"}.AsInt() } func (Blob) AsFloat() (float64, error) { - return mixins.Bytes{"ipldgit.Blob"}.AsFloat() + return mixins.Bytes{TypeName: "ipldgit.Blob"}.AsFloat() } func (Blob) AsString() (string, error) { - return mixins.Bytes{"ipldgit.Blob"}.AsString() + return mixins.Bytes{TypeName: "ipldgit.Blob"}.AsString() } func (n Blob) AsBytes() ([]byte, error) { return n.x, nil } func (Blob) AsLink() (ipld.Link, error) { - return mixins.Bytes{"ipldgit.Blob"}.AsLink() + return mixins.Bytes{TypeName: "ipldgit.Blob"}.AsLink() } func (Blob) Prototype() ipld.NodePrototype { return _Blob__Prototype{} @@ -136,10 +136,10 @@ type _Blob__Assembler struct { func (na *_Blob__Assembler) reset() {} func (_Blob__Assembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { - return mixins.BytesAssembler{"ipldgit.Blob"}.BeginMap(0) + return mixins.BytesAssembler{TypeName: "ipldgit.Blob"}.BeginMap(0) } func (_Blob__Assembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { - return mixins.BytesAssembler{"ipldgit.Blob"}.BeginList(0) + return mixins.BytesAssembler{TypeName: "ipldgit.Blob"}.BeginList(0) } func (na *_Blob__Assembler) AssignNull() error { switch *na.m { @@ -147,38 +147,35 @@ func (na *_Blob__Assembler) AssignNull() error { *na.m = schema.Maybe_Null return nil case schema.Maybe_Absent: - return mixins.BytesAssembler{"ipldgit.Blob"}.AssignNull() + return mixins.BytesAssembler{TypeName: "ipldgit.Blob"}.AssignNull() case schema.Maybe_Value, schema.Maybe_Null: panic("invalid state: cannot assign into assembler that's already finished") } panic("unreachable") } func (_Blob__Assembler) AssignBool(bool) error { - return mixins.BytesAssembler{"ipldgit.Blob"}.AssignBool(false) + return mixins.BytesAssembler{TypeName: "ipldgit.Blob"}.AssignBool(false) } func (_Blob__Assembler) AssignInt(int64) error { - return mixins.BytesAssembler{"ipldgit.Blob"}.AssignInt(0) + return mixins.BytesAssembler{TypeName: "ipldgit.Blob"}.AssignInt(0) } func (_Blob__Assembler) AssignFloat(float64) error { - return mixins.BytesAssembler{"ipldgit.Blob"}.AssignFloat(0) + return mixins.BytesAssembler{TypeName: "ipldgit.Blob"}.AssignFloat(0) } func (_Blob__Assembler) AssignString(string) error { - return mixins.BytesAssembler{"ipldgit.Blob"}.AssignString("") + return mixins.BytesAssembler{TypeName: "ipldgit.Blob"}.AssignString("") } func (na *_Blob__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 = &_Blob{} - } na.w.x = v *na.m = schema.Maybe_Value return nil } func (_Blob__Assembler) AssignLink(ipld.Link) error { - return mixins.BytesAssembler{"ipldgit.Blob"}.AssignLink(nil) + return mixins.BytesAssembler{TypeName: "ipldgit.Blob"}.AssignLink(nil) } func (na *_Blob__Assembler) AssignNode(v ipld.Node) error { if v.IsNull() { @@ -189,11 +186,6 @@ func (na *_Blob__Assembler) AssignNode(v ipld.Node) error { 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 @@ -322,12 +314,12 @@ func (n Commit) LookupByString(key string) (ipld.Node, error) { if n.encoding.m == schema.Maybe_Absent { return ipld.Absent, nil } - return n.encoding.v, nil + return &n.encoding.v, nil case "signature": if n.signature.m == schema.Maybe_Absent { return ipld.Absent, nil } - return n.signature.v, nil + return &n.signature.v, nil case "mergeTag": return &n.mergeTag, nil case "other": @@ -344,7 +336,7 @@ func (n Commit) LookupByNode(key ipld.Node) (ipld.Node, error) { return n.LookupByString(ks) } func (Commit) LookupByIndex(idx int64) (ipld.Node, error) { - return mixins.Map{"ipldgit.Commit"}.LookupByIndex(0) + return mixins.Map{TypeName: "ipldgit.Commit"}.LookupByIndex(0) } func (n Commit) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { return n.LookupByString(seg.String()) @@ -392,14 +384,14 @@ func (itr *_Commit__MapItr) Next() (k ipld.Node, v ipld.Node, _ error) { v = ipld.Absent break } - v = itr.n.encoding.v + v = &itr.n.encoding.v case 6: k = &fieldName__Commit_Signature if itr.n.signature.m == schema.Maybe_Absent { v = ipld.Absent break } - v = itr.n.signature.v + v = &itr.n.signature.v case 7: k = &fieldName__Commit_MergeTag v = &itr.n.mergeTag @@ -429,22 +421,22 @@ func (Commit) IsNull() bool { return false } func (Commit) AsBool() (bool, error) { - return mixins.Map{"ipldgit.Commit"}.AsBool() + return mixins.Map{TypeName: "ipldgit.Commit"}.AsBool() } func (Commit) AsInt() (int64, error) { - return mixins.Map{"ipldgit.Commit"}.AsInt() + return mixins.Map{TypeName: "ipldgit.Commit"}.AsInt() } func (Commit) AsFloat() (float64, error) { - return mixins.Map{"ipldgit.Commit"}.AsFloat() + return mixins.Map{TypeName: "ipldgit.Commit"}.AsFloat() } func (Commit) AsString() (string, error) { - return mixins.Map{"ipldgit.Commit"}.AsString() + return mixins.Map{TypeName: "ipldgit.Commit"}.AsString() } func (Commit) AsBytes() ([]byte, error) { - return mixins.Map{"ipldgit.Commit"}.AsBytes() + return mixins.Map{TypeName: "ipldgit.Commit"}.AsBytes() } func (Commit) AsLink() (ipld.Link, error) { - return mixins.Map{"ipldgit.Commit"}.AsLink() + return mixins.Map{TypeName: "ipldgit.Commit"}.AsLink() } func (Commit) Prototype() ipld.NodePrototype { return _Commit__Prototype{} @@ -534,7 +526,7 @@ func (na *_Commit__Assembler) BeginMap(int64) (ipld.MapAssembler, error) { return na, nil } func (_Commit__Assembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { - return mixins.MapAssembler{"ipldgit.Commit"}.BeginList(0) + return mixins.MapAssembler{TypeName: "ipldgit.Commit"}.BeginList(0) } func (na *_Commit__Assembler) AssignNull() error { switch *na.m { @@ -542,7 +534,7 @@ func (na *_Commit__Assembler) AssignNull() error { *na.m = schema.Maybe_Null return nil case schema.Maybe_Absent: - return mixins.MapAssembler{"ipldgit.Commit"}.AssignNull() + return mixins.MapAssembler{TypeName: "ipldgit.Commit"}.AssignNull() case schema.Maybe_Value, schema.Maybe_Null: panic("invalid state: cannot assign into assembler that's already finished") case midvalue: @@ -551,22 +543,22 @@ func (na *_Commit__Assembler) AssignNull() error { panic("unreachable") } func (_Commit__Assembler) AssignBool(bool) error { - return mixins.MapAssembler{"ipldgit.Commit"}.AssignBool(false) + return mixins.MapAssembler{TypeName: "ipldgit.Commit"}.AssignBool(false) } func (_Commit__Assembler) AssignInt(int64) error { - return mixins.MapAssembler{"ipldgit.Commit"}.AssignInt(0) + return mixins.MapAssembler{TypeName: "ipldgit.Commit"}.AssignInt(0) } func (_Commit__Assembler) AssignFloat(float64) error { - return mixins.MapAssembler{"ipldgit.Commit"}.AssignFloat(0) + return mixins.MapAssembler{TypeName: "ipldgit.Commit"}.AssignFloat(0) } func (_Commit__Assembler) AssignString(string) error { - return mixins.MapAssembler{"ipldgit.Commit"}.AssignString("") + return mixins.MapAssembler{TypeName: "ipldgit.Commit"}.AssignString("") } func (_Commit__Assembler) AssignBytes([]byte) error { - return mixins.MapAssembler{"ipldgit.Commit"}.AssignBytes(nil) + return mixins.MapAssembler{TypeName: "ipldgit.Commit"}.AssignBytes(nil) } func (_Commit__Assembler) AssignLink(ipld.Link) error { - return mixins.MapAssembler{"ipldgit.Commit"}.AssignLink(nil) + return mixins.MapAssembler{TypeName: "ipldgit.Commit"}.AssignLink(nil) } func (na *_Commit__Assembler) AssignNode(v ipld.Node) error { if v.IsNull() { @@ -662,7 +654,6 @@ func (ma *_Commit__Assembler) valueFinishTidy() bool { case 5: switch ma.w.encoding.m { case schema.Maybe_Value: - ma.w.encoding.v = ma.ca_encoding.w ma.state = maState_initial return true default: @@ -671,7 +662,6 @@ func (ma *_Commit__Assembler) valueFinishTidy() bool { case 6: switch ma.w.signature.m { case schema.Maybe_Value: - ma.w.signature.v = ma.ca_signature.w ma.state = maState_initial return true default: @@ -774,7 +764,7 @@ func (ma *_Commit__Assembler) AssembleEntry(k string) (ipld.NodeAssembler, error ma.s += fieldBit__Commit_Encoding ma.state = maState_midValue ma.f = 5 - ma.ca_encoding.w = ma.w.encoding.v + ma.ca_encoding.w = &ma.w.encoding.v ma.ca_encoding.m = &ma.w.encoding.m return &ma.ca_encoding, nil case "signature": @@ -784,7 +774,7 @@ func (ma *_Commit__Assembler) AssembleEntry(k string) (ipld.NodeAssembler, error ma.s += fieldBit__Commit_Signature ma.state = maState_midValue ma.f = 6 - ma.ca_signature.w = ma.w.signature.v + ma.ca_signature.w = &ma.w.signature.v ma.ca_signature.m = &ma.w.signature.m return &ma.ca_signature, nil case "mergeTag": @@ -864,11 +854,11 @@ func (ma *_Commit__Assembler) AssembleValue() ipld.NodeAssembler { ma.ca_committer.m = &ma.w.committer.m return &ma.ca_committer case 5: - ma.ca_encoding.w = ma.w.encoding.v + ma.ca_encoding.w = &ma.w.encoding.v ma.ca_encoding.m = &ma.w.encoding.m return &ma.ca_encoding case 6: - ma.ca_signature.w = ma.w.signature.v + ma.ca_signature.w = &ma.w.signature.v ma.ca_signature.m = &ma.w.signature.m return &ma.ca_signature case 7: @@ -931,22 +921,22 @@ func (ma *_Commit__Assembler) ValuePrototype(k string) ipld.NodePrototype { type _Commit__KeyAssembler _Commit__Assembler func (_Commit__KeyAssembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { - return mixins.StringAssembler{"ipldgit.Commit.KeyAssembler"}.BeginMap(0) + return mixins.StringAssembler{TypeName: "ipldgit.Commit.KeyAssembler"}.BeginMap(0) } func (_Commit__KeyAssembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { - return mixins.StringAssembler{"ipldgit.Commit.KeyAssembler"}.BeginList(0) + return mixins.StringAssembler{TypeName: "ipldgit.Commit.KeyAssembler"}.BeginList(0) } func (na *_Commit__KeyAssembler) AssignNull() error { - return mixins.StringAssembler{"ipldgit.Commit.KeyAssembler"}.AssignNull() + return mixins.StringAssembler{TypeName: "ipldgit.Commit.KeyAssembler"}.AssignNull() } func (_Commit__KeyAssembler) AssignBool(bool) error { - return mixins.StringAssembler{"ipldgit.Commit.KeyAssembler"}.AssignBool(false) + return mixins.StringAssembler{TypeName: "ipldgit.Commit.KeyAssembler"}.AssignBool(false) } func (_Commit__KeyAssembler) AssignInt(int64) error { - return mixins.StringAssembler{"ipldgit.Commit.KeyAssembler"}.AssignInt(0) + return mixins.StringAssembler{TypeName: "ipldgit.Commit.KeyAssembler"}.AssignInt(0) } func (_Commit__KeyAssembler) AssignFloat(float64) error { - return mixins.StringAssembler{"ipldgit.Commit.KeyAssembler"}.AssignFloat(0) + return mixins.StringAssembler{TypeName: "ipldgit.Commit.KeyAssembler"}.AssignFloat(0) } func (ka *_Commit__KeyAssembler) AssignString(k string) error { if ka.state != maState_midKey { @@ -1022,10 +1012,10 @@ func (ka *_Commit__KeyAssembler) AssignString(k string) error { return nil } func (_Commit__KeyAssembler) AssignBytes([]byte) error { - return mixins.StringAssembler{"ipldgit.Commit.KeyAssembler"}.AssignBytes(nil) + return mixins.StringAssembler{TypeName: "ipldgit.Commit.KeyAssembler"}.AssignBytes(nil) } func (_Commit__KeyAssembler) AssignLink(ipld.Link) error { - return mixins.StringAssembler{"ipldgit.Commit.KeyAssembler"}.AssignLink(nil) + return mixins.StringAssembler{TypeName: "ipldgit.Commit.KeyAssembler"}.AssignLink(nil) } func (ka *_Commit__KeyAssembler) AssignNode(v ipld.Node) error { if v2, err := v.AsString(); err != nil { @@ -1106,7 +1096,7 @@ func (n *_Commit__Repr) LookupByNode(key ipld.Node) (ipld.Node, error) { return n.LookupByString(ks) } func (_Commit__Repr) LookupByIndex(idx int64) (ipld.Node, error) { - return mixins.Map{"ipldgit.Commit.Repr"}.LookupByIndex(0) + return mixins.Map{TypeName: "ipldgit.Commit.Repr"}.LookupByIndex(0) } func (n _Commit__Repr) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { return n.LookupByString(seg.String()) @@ -1204,22 +1194,22 @@ func (_Commit__Repr) IsNull() bool { return false } func (_Commit__Repr) AsBool() (bool, error) { - return mixins.Map{"ipldgit.Commit.Repr"}.AsBool() + return mixins.Map{TypeName: "ipldgit.Commit.Repr"}.AsBool() } func (_Commit__Repr) AsInt() (int64, error) { - return mixins.Map{"ipldgit.Commit.Repr"}.AsInt() + return mixins.Map{TypeName: "ipldgit.Commit.Repr"}.AsInt() } func (_Commit__Repr) AsFloat() (float64, error) { - return mixins.Map{"ipldgit.Commit.Repr"}.AsFloat() + return mixins.Map{TypeName: "ipldgit.Commit.Repr"}.AsFloat() } func (_Commit__Repr) AsString() (string, error) { - return mixins.Map{"ipldgit.Commit.Repr"}.AsString() + return mixins.Map{TypeName: "ipldgit.Commit.Repr"}.AsString() } func (_Commit__Repr) AsBytes() ([]byte, error) { - return mixins.Map{"ipldgit.Commit.Repr"}.AsBytes() + return mixins.Map{TypeName: "ipldgit.Commit.Repr"}.AsBytes() } func (_Commit__Repr) AsLink() (ipld.Link, error) { - return mixins.Map{"ipldgit.Commit.Repr"}.AsLink() + return mixins.Map{TypeName: "ipldgit.Commit.Repr"}.AsLink() } func (_Commit__Repr) Prototype() ipld.NodePrototype { return _Commit__ReprPrototype{} @@ -1295,7 +1285,7 @@ func (na *_Commit__ReprAssembler) BeginMap(int64) (ipld.MapAssembler, error) { return na, nil } func (_Commit__ReprAssembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { - return mixins.MapAssembler{"ipldgit.Commit.Repr"}.BeginList(0) + return mixins.MapAssembler{TypeName: "ipldgit.Commit.Repr"}.BeginList(0) } func (na *_Commit__ReprAssembler) AssignNull() error { switch *na.m { @@ -1303,7 +1293,7 @@ func (na *_Commit__ReprAssembler) AssignNull() error { *na.m = schema.Maybe_Null return nil case schema.Maybe_Absent: - return mixins.MapAssembler{"ipldgit.Commit.Repr.Repr"}.AssignNull() + return mixins.MapAssembler{TypeName: "ipldgit.Commit.Repr.Repr"}.AssignNull() case schema.Maybe_Value, schema.Maybe_Null: panic("invalid state: cannot assign into assembler that's already finished") case midvalue: @@ -1312,22 +1302,22 @@ func (na *_Commit__ReprAssembler) AssignNull() error { panic("unreachable") } func (_Commit__ReprAssembler) AssignBool(bool) error { - return mixins.MapAssembler{"ipldgit.Commit.Repr"}.AssignBool(false) + return mixins.MapAssembler{TypeName: "ipldgit.Commit.Repr"}.AssignBool(false) } func (_Commit__ReprAssembler) AssignInt(int64) error { - return mixins.MapAssembler{"ipldgit.Commit.Repr"}.AssignInt(0) + return mixins.MapAssembler{TypeName: "ipldgit.Commit.Repr"}.AssignInt(0) } func (_Commit__ReprAssembler) AssignFloat(float64) error { - return mixins.MapAssembler{"ipldgit.Commit.Repr"}.AssignFloat(0) + return mixins.MapAssembler{TypeName: "ipldgit.Commit.Repr"}.AssignFloat(0) } func (_Commit__ReprAssembler) AssignString(string) error { - return mixins.MapAssembler{"ipldgit.Commit.Repr"}.AssignString("") + return mixins.MapAssembler{TypeName: "ipldgit.Commit.Repr"}.AssignString("") } func (_Commit__ReprAssembler) AssignBytes([]byte) error { - return mixins.MapAssembler{"ipldgit.Commit.Repr"}.AssignBytes(nil) + return mixins.MapAssembler{TypeName: "ipldgit.Commit.Repr"}.AssignBytes(nil) } func (_Commit__ReprAssembler) AssignLink(ipld.Link) error { - return mixins.MapAssembler{"ipldgit.Commit.Repr"}.AssignLink(nil) + return mixins.MapAssembler{TypeName: "ipldgit.Commit.Repr"}.AssignLink(nil) } func (na *_Commit__ReprAssembler) AssignNode(v ipld.Node) error { if v.IsNull() { @@ -1420,7 +1410,6 @@ func (ma *_Commit__ReprAssembler) valueFinishTidy() bool { case 5: switch ma.w.encoding.m { case schema.Maybe_Value: - ma.w.encoding.v = ma.ca_encoding.w ma.state = maState_initial return true default: @@ -1429,7 +1418,6 @@ func (ma *_Commit__ReprAssembler) valueFinishTidy() bool { case 6: switch ma.w.signature.m { case schema.Maybe_Value: - ma.w.signature.v = ma.ca_signature.w ma.state = maState_initial return true default: @@ -1532,7 +1520,7 @@ func (ma *_Commit__ReprAssembler) AssembleEntry(k string) (ipld.NodeAssembler, e ma.s += fieldBit__Commit_Encoding ma.state = maState_midValue ma.f = 5 - ma.ca_encoding.w = ma.w.encoding.v + ma.ca_encoding.w = &ma.w.encoding.v ma.ca_encoding.m = &ma.w.encoding.m return &ma.ca_encoding, nil @@ -1543,7 +1531,7 @@ func (ma *_Commit__ReprAssembler) AssembleEntry(k string) (ipld.NodeAssembler, e ma.s += fieldBit__Commit_Signature ma.state = maState_midValue ma.f = 6 - ma.ca_signature.w = ma.w.signature.v + ma.ca_signature.w = &ma.w.signature.v ma.ca_signature.m = &ma.w.signature.m return &ma.ca_signature, nil @@ -1627,12 +1615,12 @@ func (ma *_Commit__ReprAssembler) AssembleValue() ipld.NodeAssembler { return &ma.ca_committer case 5: - ma.ca_encoding.w = ma.w.encoding.v + ma.ca_encoding.w = &ma.w.encoding.v ma.ca_encoding.m = &ma.w.encoding.m return &ma.ca_encoding case 6: - ma.ca_signature.w = ma.w.signature.v + ma.ca_signature.w = &ma.w.signature.v ma.ca_signature.m = &ma.w.signature.m return &ma.ca_signature @@ -1696,22 +1684,22 @@ func (ma *_Commit__ReprAssembler) ValuePrototype(k string) ipld.NodePrototype { type _Commit__ReprKeyAssembler _Commit__ReprAssembler func (_Commit__ReprKeyAssembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { - return mixins.StringAssembler{"ipldgit.Commit.Repr.KeyAssembler"}.BeginMap(0) + return mixins.StringAssembler{TypeName: "ipldgit.Commit.Repr.KeyAssembler"}.BeginMap(0) } func (_Commit__ReprKeyAssembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { - return mixins.StringAssembler{"ipldgit.Commit.Repr.KeyAssembler"}.BeginList(0) + return mixins.StringAssembler{TypeName: "ipldgit.Commit.Repr.KeyAssembler"}.BeginList(0) } func (na *_Commit__ReprKeyAssembler) AssignNull() error { - return mixins.StringAssembler{"ipldgit.Commit.Repr.KeyAssembler"}.AssignNull() + return mixins.StringAssembler{TypeName: "ipldgit.Commit.Repr.KeyAssembler"}.AssignNull() } func (_Commit__ReprKeyAssembler) AssignBool(bool) error { - return mixins.StringAssembler{"ipldgit.Commit.Repr.KeyAssembler"}.AssignBool(false) + return mixins.StringAssembler{TypeName: "ipldgit.Commit.Repr.KeyAssembler"}.AssignBool(false) } func (_Commit__ReprKeyAssembler) AssignInt(int64) error { - return mixins.StringAssembler{"ipldgit.Commit.Repr.KeyAssembler"}.AssignInt(0) + return mixins.StringAssembler{TypeName: "ipldgit.Commit.Repr.KeyAssembler"}.AssignInt(0) } func (_Commit__ReprKeyAssembler) AssignFloat(float64) error { - return mixins.StringAssembler{"ipldgit.Commit.Repr.KeyAssembler"}.AssignFloat(0) + return mixins.StringAssembler{TypeName: "ipldgit.Commit.Repr.KeyAssembler"}.AssignFloat(0) } func (ka *_Commit__ReprKeyAssembler) AssignString(k string) error { if ka.state != maState_midKey { @@ -1794,10 +1782,10 @@ func (ka *_Commit__ReprKeyAssembler) AssignString(k string) error { return ipld.ErrInvalidKey{TypeName: "ipldgit.Commit.Repr", Key: &_String{k}} } func (_Commit__ReprKeyAssembler) AssignBytes([]byte) error { - return mixins.StringAssembler{"ipldgit.Commit.Repr.KeyAssembler"}.AssignBytes(nil) + return mixins.StringAssembler{TypeName: "ipldgit.Commit.Repr.KeyAssembler"}.AssignBytes(nil) } func (_Commit__ReprKeyAssembler) AssignLink(ipld.Link) error { - return mixins.StringAssembler{"ipldgit.Commit.Repr.KeyAssembler"}.AssignLink(nil) + return mixins.StringAssembler{TypeName: "ipldgit.Commit.Repr.KeyAssembler"}.AssignLink(nil) } func (ka *_Commit__ReprKeyAssembler) AssignNode(v ipld.Node) error { if v2, err := v.AsString(); err != nil { @@ -1824,7 +1812,7 @@ func (_GpgSig__Prototype) FromString(v string) (GpgSig, error) { type _GpgSig__Maybe struct { m schema.Maybe - v GpgSig + v _GpgSig } type MaybeGpgSig = *_GpgSig__Maybe @@ -1844,7 +1832,7 @@ func (m MaybeGpgSig) AsNode() ipld.Node { case schema.Maybe_Null: return ipld.Null case schema.Maybe_Value: - return m.v + return &m.v default: panic("unreachable") } @@ -1853,7 +1841,7 @@ func (m MaybeGpgSig) Must() GpgSig { if !m.Exists() { panic("unbox of a maybe rejected") } - return m.v + return &m.v } var _ ipld.Node = (GpgSig)(&_GpgSig{}) @@ -1863,16 +1851,16 @@ func (GpgSig) Kind() ipld.Kind { return ipld.Kind_String } func (GpgSig) LookupByString(string) (ipld.Node, error) { - return mixins.String{"ipldgit.GpgSig"}.LookupByString("") + return mixins.String{TypeName: "ipldgit.GpgSig"}.LookupByString("") } func (GpgSig) LookupByNode(ipld.Node) (ipld.Node, error) { - return mixins.String{"ipldgit.GpgSig"}.LookupByNode(nil) + return mixins.String{TypeName: "ipldgit.GpgSig"}.LookupByNode(nil) } func (GpgSig) LookupByIndex(idx int64) (ipld.Node, error) { - return mixins.String{"ipldgit.GpgSig"}.LookupByIndex(0) + return mixins.String{TypeName: "ipldgit.GpgSig"}.LookupByIndex(0) } func (GpgSig) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { - return mixins.String{"ipldgit.GpgSig"}.LookupBySegment(seg) + return mixins.String{TypeName: "ipldgit.GpgSig"}.LookupBySegment(seg) } func (GpgSig) MapIterator() ipld.MapIterator { return nil @@ -1890,22 +1878,22 @@ func (GpgSig) IsNull() bool { return false } func (GpgSig) AsBool() (bool, error) { - return mixins.String{"ipldgit.GpgSig"}.AsBool() + return mixins.String{TypeName: "ipldgit.GpgSig"}.AsBool() } func (GpgSig) AsInt() (int64, error) { - return mixins.String{"ipldgit.GpgSig"}.AsInt() + return mixins.String{TypeName: "ipldgit.GpgSig"}.AsInt() } func (GpgSig) AsFloat() (float64, error) { - return mixins.String{"ipldgit.GpgSig"}.AsFloat() + return mixins.String{TypeName: "ipldgit.GpgSig"}.AsFloat() } func (n GpgSig) AsString() (string, error) { return n.x, nil } func (GpgSig) AsBytes() ([]byte, error) { - return mixins.String{"ipldgit.GpgSig"}.AsBytes() + return mixins.String{TypeName: "ipldgit.GpgSig"}.AsBytes() } func (GpgSig) AsLink() (ipld.Link, error) { - return mixins.String{"ipldgit.GpgSig"}.AsLink() + return mixins.String{TypeName: "ipldgit.GpgSig"}.AsLink() } func (GpgSig) Prototype() ipld.NodePrototype { return _GpgSig__Prototype{} @@ -1942,10 +1930,10 @@ type _GpgSig__Assembler struct { func (na *_GpgSig__Assembler) reset() {} func (_GpgSig__Assembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { - return mixins.StringAssembler{"ipldgit.GpgSig"}.BeginMap(0) + return mixins.StringAssembler{TypeName: "ipldgit.GpgSig"}.BeginMap(0) } func (_GpgSig__Assembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { - return mixins.StringAssembler{"ipldgit.GpgSig"}.BeginList(0) + return mixins.StringAssembler{TypeName: "ipldgit.GpgSig"}.BeginList(0) } func (na *_GpgSig__Assembler) AssignNull() error { switch *na.m { @@ -1953,38 +1941,35 @@ func (na *_GpgSig__Assembler) AssignNull() error { *na.m = schema.Maybe_Null return nil case schema.Maybe_Absent: - return mixins.StringAssembler{"ipldgit.GpgSig"}.AssignNull() + return mixins.StringAssembler{TypeName: "ipldgit.GpgSig"}.AssignNull() case schema.Maybe_Value, schema.Maybe_Null: panic("invalid state: cannot assign into assembler that's already finished") } panic("unreachable") } func (_GpgSig__Assembler) AssignBool(bool) error { - return mixins.StringAssembler{"ipldgit.GpgSig"}.AssignBool(false) + return mixins.StringAssembler{TypeName: "ipldgit.GpgSig"}.AssignBool(false) } func (_GpgSig__Assembler) AssignInt(int64) error { - return mixins.StringAssembler{"ipldgit.GpgSig"}.AssignInt(0) + return mixins.StringAssembler{TypeName: "ipldgit.GpgSig"}.AssignInt(0) } func (_GpgSig__Assembler) AssignFloat(float64) error { - return mixins.StringAssembler{"ipldgit.GpgSig"}.AssignFloat(0) + return mixins.StringAssembler{TypeName: "ipldgit.GpgSig"}.AssignFloat(0) } func (na *_GpgSig__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 = &_GpgSig{} - } na.w.x = v *na.m = schema.Maybe_Value return nil } func (_GpgSig__Assembler) AssignBytes([]byte) error { - return mixins.StringAssembler{"ipldgit.GpgSig"}.AssignBytes(nil) + return mixins.StringAssembler{TypeName: "ipldgit.GpgSig"}.AssignBytes(nil) } func (_GpgSig__Assembler) AssignLink(ipld.Link) error { - return mixins.StringAssembler{"ipldgit.GpgSig"}.AssignLink(nil) + return mixins.StringAssembler{TypeName: "ipldgit.GpgSig"}.AssignLink(nil) } func (na *_GpgSig__Assembler) AssignNode(v ipld.Node) error { if v.IsNull() { @@ -1995,11 +1980,6 @@ func (na *_GpgSig__Assembler) AssignNode(v ipld.Node) error { 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 @@ -2037,7 +2017,7 @@ func (_Link__Prototype) FromLink(v ipld.Link) (Link, error) { type _Link__Maybe struct { m schema.Maybe - v Link + v _Link } type MaybeLink = *_Link__Maybe @@ -2057,7 +2037,7 @@ func (m MaybeLink) AsNode() ipld.Node { case schema.Maybe_Null: return ipld.Null case schema.Maybe_Value: - return m.v + return &m.v default: panic("unreachable") } @@ -2066,7 +2046,7 @@ func (m MaybeLink) Must() Link { if !m.Exists() { panic("unbox of a maybe rejected") } - return m.v + return &m.v } var _ ipld.Node = (Link)(&_Link{}) @@ -2076,16 +2056,16 @@ func (Link) Kind() ipld.Kind { return ipld.Kind_Link } func (Link) LookupByString(string) (ipld.Node, error) { - return mixins.Link{"ipldgit.Link"}.LookupByString("") + return mixins.Link{TypeName: "ipldgit.Link"}.LookupByString("") } func (Link) LookupByNode(ipld.Node) (ipld.Node, error) { - return mixins.Link{"ipldgit.Link"}.LookupByNode(nil) + return mixins.Link{TypeName: "ipldgit.Link"}.LookupByNode(nil) } func (Link) LookupByIndex(idx int64) (ipld.Node, error) { - return mixins.Link{"ipldgit.Link"}.LookupByIndex(0) + return mixins.Link{TypeName: "ipldgit.Link"}.LookupByIndex(0) } func (Link) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { - return mixins.Link{"ipldgit.Link"}.LookupBySegment(seg) + return mixins.Link{TypeName: "ipldgit.Link"}.LookupBySegment(seg) } func (Link) MapIterator() ipld.MapIterator { return nil @@ -2103,19 +2083,19 @@ func (Link) IsNull() bool { return false } func (Link) AsBool() (bool, error) { - return mixins.Link{"ipldgit.Link"}.AsBool() + return mixins.Link{TypeName: "ipldgit.Link"}.AsBool() } func (Link) AsInt() (int64, error) { - return mixins.Link{"ipldgit.Link"}.AsInt() + return mixins.Link{TypeName: "ipldgit.Link"}.AsInt() } func (Link) AsFloat() (float64, error) { - return mixins.Link{"ipldgit.Link"}.AsFloat() + return mixins.Link{TypeName: "ipldgit.Link"}.AsFloat() } func (Link) AsString() (string, error) { - return mixins.Link{"ipldgit.Link"}.AsString() + return mixins.Link{TypeName: "ipldgit.Link"}.AsString() } func (Link) AsBytes() ([]byte, error) { - return mixins.Link{"ipldgit.Link"}.AsBytes() + return mixins.Link{TypeName: "ipldgit.Link"}.AsBytes() } func (n Link) AsLink() (ipld.Link, error) { return n.x, nil @@ -2155,10 +2135,10 @@ type _Link__Assembler struct { func (na *_Link__Assembler) reset() {} func (_Link__Assembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { - return mixins.LinkAssembler{"ipldgit.Link"}.BeginMap(0) + return mixins.LinkAssembler{TypeName: "ipldgit.Link"}.BeginMap(0) } func (_Link__Assembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { - return mixins.LinkAssembler{"ipldgit.Link"}.BeginList(0) + return mixins.LinkAssembler{TypeName: "ipldgit.Link"}.BeginList(0) } func (na *_Link__Assembler) AssignNull() error { switch *na.m { @@ -2166,35 +2146,32 @@ func (na *_Link__Assembler) AssignNull() error { *na.m = schema.Maybe_Null return nil case schema.Maybe_Absent: - return mixins.LinkAssembler{"ipldgit.Link"}.AssignNull() + return mixins.LinkAssembler{TypeName: "ipldgit.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{"ipldgit.Link"}.AssignBool(false) + return mixins.LinkAssembler{TypeName: "ipldgit.Link"}.AssignBool(false) } func (_Link__Assembler) AssignInt(int64) error { - return mixins.LinkAssembler{"ipldgit.Link"}.AssignInt(0) + return mixins.LinkAssembler{TypeName: "ipldgit.Link"}.AssignInt(0) } func (_Link__Assembler) AssignFloat(float64) error { - return mixins.LinkAssembler{"ipldgit.Link"}.AssignFloat(0) + return mixins.LinkAssembler{TypeName: "ipldgit.Link"}.AssignFloat(0) } func (_Link__Assembler) AssignString(string) error { - return mixins.LinkAssembler{"ipldgit.Link"}.AssignString("") + return mixins.LinkAssembler{TypeName: "ipldgit.Link"}.AssignString("") } func (_Link__Assembler) AssignBytes([]byte) error { - return mixins.LinkAssembler{"ipldgit.Link"}.AssignBytes(nil) + return mixins.LinkAssembler{TypeName: "ipldgit.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 @@ -2208,11 +2185,6 @@ func (na *_Link__Assembler) AssignNode(v ipld.Node) error { 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 @@ -2250,7 +2222,7 @@ func (_LinkTree__Prototype) FromLink(v ipld.Link) (LinkTree, error) { type _LinkTree__Maybe struct { m schema.Maybe - v LinkTree + v _LinkTree } type MaybeLinkTree = *_LinkTree__Maybe @@ -2270,7 +2242,7 @@ func (m MaybeLinkTree) AsNode() ipld.Node { case schema.Maybe_Null: return ipld.Null case schema.Maybe_Value: - return m.v + return &m.v default: panic("unreachable") } @@ -2279,7 +2251,7 @@ func (m MaybeLinkTree) Must() LinkTree { if !m.Exists() { panic("unbox of a maybe rejected") } - return m.v + return &m.v } var _ ipld.Node = (LinkTree)(&_LinkTree{}) @@ -2289,16 +2261,16 @@ func (LinkTree) Kind() ipld.Kind { return ipld.Kind_Link } func (LinkTree) LookupByString(string) (ipld.Node, error) { - return mixins.Link{"ipldgit.LinkTree"}.LookupByString("") + return mixins.Link{TypeName: "ipldgit.LinkTree"}.LookupByString("") } func (LinkTree) LookupByNode(ipld.Node) (ipld.Node, error) { - return mixins.Link{"ipldgit.LinkTree"}.LookupByNode(nil) + return mixins.Link{TypeName: "ipldgit.LinkTree"}.LookupByNode(nil) } func (LinkTree) LookupByIndex(idx int64) (ipld.Node, error) { - return mixins.Link{"ipldgit.LinkTree"}.LookupByIndex(0) + return mixins.Link{TypeName: "ipldgit.LinkTree"}.LookupByIndex(0) } func (LinkTree) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { - return mixins.Link{"ipldgit.LinkTree"}.LookupBySegment(seg) + return mixins.Link{TypeName: "ipldgit.LinkTree"}.LookupBySegment(seg) } func (LinkTree) MapIterator() ipld.MapIterator { return nil @@ -2316,19 +2288,19 @@ func (LinkTree) IsNull() bool { return false } func (LinkTree) AsBool() (bool, error) { - return mixins.Link{"ipldgit.LinkTree"}.AsBool() + return mixins.Link{TypeName: "ipldgit.LinkTree"}.AsBool() } func (LinkTree) AsInt() (int64, error) { - return mixins.Link{"ipldgit.LinkTree"}.AsInt() + return mixins.Link{TypeName: "ipldgit.LinkTree"}.AsInt() } func (LinkTree) AsFloat() (float64, error) { - return mixins.Link{"ipldgit.LinkTree"}.AsFloat() + return mixins.Link{TypeName: "ipldgit.LinkTree"}.AsFloat() } func (LinkTree) AsString() (string, error) { - return mixins.Link{"ipldgit.LinkTree"}.AsString() + return mixins.Link{TypeName: "ipldgit.LinkTree"}.AsString() } func (LinkTree) AsBytes() ([]byte, error) { - return mixins.Link{"ipldgit.LinkTree"}.AsBytes() + return mixins.Link{TypeName: "ipldgit.LinkTree"}.AsBytes() } func (n LinkTree) AsLink() (ipld.Link, error) { return n.x, nil @@ -2368,10 +2340,10 @@ type _LinkTree__Assembler struct { func (na *_LinkTree__Assembler) reset() {} func (_LinkTree__Assembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { - return mixins.LinkAssembler{"ipldgit.LinkTree"}.BeginMap(0) + return mixins.LinkAssembler{TypeName: "ipldgit.LinkTree"}.BeginMap(0) } func (_LinkTree__Assembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { - return mixins.LinkAssembler{"ipldgit.LinkTree"}.BeginList(0) + return mixins.LinkAssembler{TypeName: "ipldgit.LinkTree"}.BeginList(0) } func (na *_LinkTree__Assembler) AssignNull() error { switch *na.m { @@ -2379,35 +2351,32 @@ func (na *_LinkTree__Assembler) AssignNull() error { *na.m = schema.Maybe_Null return nil case schema.Maybe_Absent: - return mixins.LinkAssembler{"ipldgit.LinkTree"}.AssignNull() + return mixins.LinkAssembler{TypeName: "ipldgit.LinkTree"}.AssignNull() case schema.Maybe_Value, schema.Maybe_Null: panic("invalid state: cannot assign into assembler that's already finished") } panic("unreachable") } func (_LinkTree__Assembler) AssignBool(bool) error { - return mixins.LinkAssembler{"ipldgit.LinkTree"}.AssignBool(false) + return mixins.LinkAssembler{TypeName: "ipldgit.LinkTree"}.AssignBool(false) } func (_LinkTree__Assembler) AssignInt(int64) error { - return mixins.LinkAssembler{"ipldgit.LinkTree"}.AssignInt(0) + return mixins.LinkAssembler{TypeName: "ipldgit.LinkTree"}.AssignInt(0) } func (_LinkTree__Assembler) AssignFloat(float64) error { - return mixins.LinkAssembler{"ipldgit.LinkTree"}.AssignFloat(0) + return mixins.LinkAssembler{TypeName: "ipldgit.LinkTree"}.AssignFloat(0) } func (_LinkTree__Assembler) AssignString(string) error { - return mixins.LinkAssembler{"ipldgit.LinkTree"}.AssignString("") + return mixins.LinkAssembler{TypeName: "ipldgit.LinkTree"}.AssignString("") } func (_LinkTree__Assembler) AssignBytes([]byte) error { - return mixins.LinkAssembler{"ipldgit.LinkTree"}.AssignBytes(nil) + return mixins.LinkAssembler{TypeName: "ipldgit.LinkTree"}.AssignBytes(nil) } func (na *_LinkTree__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 = &_LinkTree{} - } na.w.x = v *na.m = schema.Maybe_Value return nil @@ -2421,11 +2390,6 @@ func (na *_LinkTree__Assembler) AssignNode(v ipld.Node) error { 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 @@ -2443,7 +2407,7 @@ func (LinkTree) Type() schema.Type { return nil /*TODO:typelit*/ } func (LinkTree) LinkTargetNodePrototype() ipld.NodePrototype { - return Type.LinkTree__Repr + return Type.Tree__Repr } func (n LinkTree) Representation() ipld.Node { return (*_LinkTree__Repr)(n) @@ -2470,7 +2434,7 @@ func (n *_ListParents) LookupMaybe(idx int64) MaybeLink { v := &n.x[idx] return &_Link__Maybe{ m: schema.Maybe_Value, - v: v, + v: *v, } } @@ -2500,7 +2464,7 @@ func (itr *ListParents__Itr) Done() bool { type _ListParents__Maybe struct { m schema.Maybe - v ListParents + v _ListParents } type MaybeListParents = *_ListParents__Maybe @@ -2520,7 +2484,7 @@ func (m MaybeListParents) AsNode() ipld.Node { case schema.Maybe_Null: return ipld.Null case schema.Maybe_Value: - return m.v + return &m.v default: panic("unreachable") } @@ -2529,7 +2493,7 @@ func (m MaybeListParents) Must() ListParents { if !m.Exists() { panic("unbox of a maybe rejected") } - return m.v + return &m.v } var _ ipld.Node = (ListParents)(&_ListParents{}) @@ -2539,7 +2503,7 @@ func (ListParents) Kind() ipld.Kind { return ipld.Kind_List } func (ListParents) LookupByString(string) (ipld.Node, error) { - return mixins.List{"ipldgit.ListParents"}.LookupByString("") + return mixins.List{TypeName: "ipldgit.ListParents"}.LookupByString("") } func (n ListParents) LookupByNode(k ipld.Node) (ipld.Node, error) { idx, err := k.AsInt() @@ -2598,22 +2562,22 @@ func (ListParents) IsNull() bool { return false } func (ListParents) AsBool() (bool, error) { - return mixins.List{"ipldgit.ListParents"}.AsBool() + return mixins.List{TypeName: "ipldgit.ListParents"}.AsBool() } func (ListParents) AsInt() (int64, error) { - return mixins.List{"ipldgit.ListParents"}.AsInt() + return mixins.List{TypeName: "ipldgit.ListParents"}.AsInt() } func (ListParents) AsFloat() (float64, error) { - return mixins.List{"ipldgit.ListParents"}.AsFloat() + return mixins.List{TypeName: "ipldgit.ListParents"}.AsFloat() } func (ListParents) AsString() (string, error) { - return mixins.List{"ipldgit.ListParents"}.AsString() + return mixins.List{TypeName: "ipldgit.ListParents"}.AsString() } func (ListParents) AsBytes() ([]byte, error) { - return mixins.List{"ipldgit.ListParents"}.AsBytes() + return mixins.List{TypeName: "ipldgit.ListParents"}.AsBytes() } func (ListParents) AsLink() (ipld.Link, error) { - return mixins.List{"ipldgit.ListParents"}.AsLink() + return mixins.List{TypeName: "ipldgit.ListParents"}.AsLink() } func (ListParents) Prototype() ipld.NodePrototype { return _ListParents__Prototype{} @@ -2657,7 +2621,7 @@ func (na *_ListParents__Assembler) reset() { na.va.reset() } func (_ListParents__Assembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { - return mixins.ListAssembler{"ipldgit.ListParents"}.BeginMap(0) + return mixins.ListAssembler{TypeName: "ipldgit.ListParents"}.BeginMap(0) } func (na *_ListParents__Assembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { switch *na.m { @@ -2670,9 +2634,6 @@ func (na *_ListParents__Assembler) BeginList(sizeHint int64) (ipld.ListAssembler if sizeHint < 0 { sizeHint = 0 } - if na.w == nil { - na.w = &_ListParents{} - } if sizeHint > 0 { na.w.x = make([]_Link, 0, sizeHint) } @@ -2684,7 +2645,7 @@ func (na *_ListParents__Assembler) AssignNull() error { *na.m = schema.Maybe_Null return nil case schema.Maybe_Absent: - return mixins.ListAssembler{"ipldgit.ListParents"}.AssignNull() + return mixins.ListAssembler{TypeName: "ipldgit.ListParents"}.AssignNull() case schema.Maybe_Value, schema.Maybe_Null: panic("invalid state: cannot assign into assembler that's already finished") case midvalue: @@ -2693,22 +2654,22 @@ func (na *_ListParents__Assembler) AssignNull() error { panic("unreachable") } func (_ListParents__Assembler) AssignBool(bool) error { - return mixins.ListAssembler{"ipldgit.ListParents"}.AssignBool(false) + return mixins.ListAssembler{TypeName: "ipldgit.ListParents"}.AssignBool(false) } func (_ListParents__Assembler) AssignInt(int64) error { - return mixins.ListAssembler{"ipldgit.ListParents"}.AssignInt(0) + return mixins.ListAssembler{TypeName: "ipldgit.ListParents"}.AssignInt(0) } func (_ListParents__Assembler) AssignFloat(float64) error { - return mixins.ListAssembler{"ipldgit.ListParents"}.AssignFloat(0) + return mixins.ListAssembler{TypeName: "ipldgit.ListParents"}.AssignFloat(0) } func (_ListParents__Assembler) AssignString(string) error { - return mixins.ListAssembler{"ipldgit.ListParents"}.AssignString("") + return mixins.ListAssembler{TypeName: "ipldgit.ListParents"}.AssignString("") } func (_ListParents__Assembler) AssignBytes([]byte) error { - return mixins.ListAssembler{"ipldgit.ListParents"}.AssignBytes(nil) + return mixins.ListAssembler{TypeName: "ipldgit.ListParents"}.AssignBytes(nil) } func (_ListParents__Assembler) AssignLink(ipld.Link) error { - return mixins.ListAssembler{"ipldgit.ListParents"}.AssignLink(nil) + return mixins.ListAssembler{TypeName: "ipldgit.ListParents"}.AssignLink(nil) } func (na *_ListParents__Assembler) AssignNode(v ipld.Node) error { if v.IsNull() { @@ -2721,11 +2682,6 @@ func (na *_ListParents__Assembler) AssignNode(v ipld.Node) error { 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 @@ -2811,7 +2767,7 @@ func (_ListParents__Repr) Kind() ipld.Kind { return ipld.Kind_List } func (_ListParents__Repr) LookupByString(string) (ipld.Node, error) { - return mixins.List{"ipldgit.ListParents.Repr"}.LookupByString("") + return mixins.List{TypeName: "ipldgit.ListParents.Repr"}.LookupByString("") } func (nr *_ListParents__Repr) LookupByNode(k ipld.Node) (ipld.Node, error) { v, err := (ListParents)(nr).LookupByNode(k) @@ -2864,22 +2820,22 @@ func (_ListParents__Repr) IsNull() bool { return false } func (_ListParents__Repr) AsBool() (bool, error) { - return mixins.List{"ipldgit.ListParents.Repr"}.AsBool() + return mixins.List{TypeName: "ipldgit.ListParents.Repr"}.AsBool() } func (_ListParents__Repr) AsInt() (int64, error) { - return mixins.List{"ipldgit.ListParents.Repr"}.AsInt() + return mixins.List{TypeName: "ipldgit.ListParents.Repr"}.AsInt() } func (_ListParents__Repr) AsFloat() (float64, error) { - return mixins.List{"ipldgit.ListParents.Repr"}.AsFloat() + return mixins.List{TypeName: "ipldgit.ListParents.Repr"}.AsFloat() } func (_ListParents__Repr) AsString() (string, error) { - return mixins.List{"ipldgit.ListParents.Repr"}.AsString() + return mixins.List{TypeName: "ipldgit.ListParents.Repr"}.AsString() } func (_ListParents__Repr) AsBytes() ([]byte, error) { - return mixins.List{"ipldgit.ListParents.Repr"}.AsBytes() + return mixins.List{TypeName: "ipldgit.ListParents.Repr"}.AsBytes() } func (_ListParents__Repr) AsLink() (ipld.Link, error) { - return mixins.List{"ipldgit.ListParents.Repr"}.AsLink() + return mixins.List{TypeName: "ipldgit.ListParents.Repr"}.AsLink() } func (_ListParents__Repr) Prototype() ipld.NodePrototype { return _ListParents__ReprPrototype{} @@ -2923,7 +2879,7 @@ func (na *_ListParents__ReprAssembler) reset() { na.va.reset() } func (_ListParents__ReprAssembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { - return mixins.ListAssembler{"ipldgit.ListParents.Repr"}.BeginMap(0) + return mixins.ListAssembler{TypeName: "ipldgit.ListParents.Repr"}.BeginMap(0) } func (na *_ListParents__ReprAssembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { switch *na.m { @@ -2936,9 +2892,6 @@ func (na *_ListParents__ReprAssembler) BeginList(sizeHint int64) (ipld.ListAssem if sizeHint < 0 { sizeHint = 0 } - if na.w == nil { - na.w = &_ListParents{} - } if sizeHint > 0 { na.w.x = make([]_Link, 0, sizeHint) } @@ -2950,7 +2903,7 @@ func (na *_ListParents__ReprAssembler) AssignNull() error { *na.m = schema.Maybe_Null return nil case schema.Maybe_Absent: - return mixins.ListAssembler{"ipldgit.ListParents.Repr.Repr"}.AssignNull() + return mixins.ListAssembler{TypeName: "ipldgit.ListParents.Repr.Repr"}.AssignNull() case schema.Maybe_Value, schema.Maybe_Null: panic("invalid state: cannot assign into assembler that's already finished") case midvalue: @@ -2959,22 +2912,22 @@ func (na *_ListParents__ReprAssembler) AssignNull() error { panic("unreachable") } func (_ListParents__ReprAssembler) AssignBool(bool) error { - return mixins.ListAssembler{"ipldgit.ListParents.Repr"}.AssignBool(false) + return mixins.ListAssembler{TypeName: "ipldgit.ListParents.Repr"}.AssignBool(false) } func (_ListParents__ReprAssembler) AssignInt(int64) error { - return mixins.ListAssembler{"ipldgit.ListParents.Repr"}.AssignInt(0) + return mixins.ListAssembler{TypeName: "ipldgit.ListParents.Repr"}.AssignInt(0) } func (_ListParents__ReprAssembler) AssignFloat(float64) error { - return mixins.ListAssembler{"ipldgit.ListParents.Repr"}.AssignFloat(0) + return mixins.ListAssembler{TypeName: "ipldgit.ListParents.Repr"}.AssignFloat(0) } func (_ListParents__ReprAssembler) AssignString(string) error { - return mixins.ListAssembler{"ipldgit.ListParents.Repr"}.AssignString("") + return mixins.ListAssembler{TypeName: "ipldgit.ListParents.Repr"}.AssignString("") } func (_ListParents__ReprAssembler) AssignBytes([]byte) error { - return mixins.ListAssembler{"ipldgit.ListParents.Repr"}.AssignBytes(nil) + return mixins.ListAssembler{TypeName: "ipldgit.ListParents.Repr"}.AssignBytes(nil) } func (_ListParents__ReprAssembler) AssignLink(ipld.Link) error { - return mixins.ListAssembler{"ipldgit.ListParents.Repr"}.AssignLink(nil) + return mixins.ListAssembler{TypeName: "ipldgit.ListParents.Repr"}.AssignLink(nil) } func (na *_ListParents__ReprAssembler) AssignNode(v ipld.Node) error { if v.IsNull() { @@ -2987,11 +2940,6 @@ func (na *_ListParents__ReprAssembler) AssignNode(v ipld.Node) error { 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 @@ -3077,7 +3025,7 @@ func (n *_ListString) LookupMaybe(idx int64) MaybeString { v := &n.x[idx] return &_String__Maybe{ m: schema.Maybe_Value, - v: v, + v: *v, } } @@ -3107,7 +3055,7 @@ func (itr *ListString__Itr) Done() bool { type _ListString__Maybe struct { m schema.Maybe - v ListString + v _ListString } type MaybeListString = *_ListString__Maybe @@ -3127,7 +3075,7 @@ func (m MaybeListString) AsNode() ipld.Node { case schema.Maybe_Null: return ipld.Null case schema.Maybe_Value: - return m.v + return &m.v default: panic("unreachable") } @@ -3136,7 +3084,7 @@ func (m MaybeListString) Must() ListString { if !m.Exists() { panic("unbox of a maybe rejected") } - return m.v + return &m.v } var _ ipld.Node = (ListString)(&_ListString{}) @@ -3146,7 +3094,7 @@ func (ListString) Kind() ipld.Kind { return ipld.Kind_List } func (ListString) LookupByString(string) (ipld.Node, error) { - return mixins.List{"ipldgit.ListString"}.LookupByString("") + return mixins.List{TypeName: "ipldgit.ListString"}.LookupByString("") } func (n ListString) LookupByNode(k ipld.Node) (ipld.Node, error) { idx, err := k.AsInt() @@ -3205,22 +3153,22 @@ func (ListString) IsNull() bool { return false } func (ListString) AsBool() (bool, error) { - return mixins.List{"ipldgit.ListString"}.AsBool() + return mixins.List{TypeName: "ipldgit.ListString"}.AsBool() } func (ListString) AsInt() (int64, error) { - return mixins.List{"ipldgit.ListString"}.AsInt() + return mixins.List{TypeName: "ipldgit.ListString"}.AsInt() } func (ListString) AsFloat() (float64, error) { - return mixins.List{"ipldgit.ListString"}.AsFloat() + return mixins.List{TypeName: "ipldgit.ListString"}.AsFloat() } func (ListString) AsString() (string, error) { - return mixins.List{"ipldgit.ListString"}.AsString() + return mixins.List{TypeName: "ipldgit.ListString"}.AsString() } func (ListString) AsBytes() ([]byte, error) { - return mixins.List{"ipldgit.ListString"}.AsBytes() + return mixins.List{TypeName: "ipldgit.ListString"}.AsBytes() } func (ListString) AsLink() (ipld.Link, error) { - return mixins.List{"ipldgit.ListString"}.AsLink() + return mixins.List{TypeName: "ipldgit.ListString"}.AsLink() } func (ListString) Prototype() ipld.NodePrototype { return _ListString__Prototype{} @@ -3264,7 +3212,7 @@ func (na *_ListString__Assembler) reset() { na.va.reset() } func (_ListString__Assembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { - return mixins.ListAssembler{"ipldgit.ListString"}.BeginMap(0) + return mixins.ListAssembler{TypeName: "ipldgit.ListString"}.BeginMap(0) } func (na *_ListString__Assembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { switch *na.m { @@ -3277,9 +3225,6 @@ func (na *_ListString__Assembler) BeginList(sizeHint int64) (ipld.ListAssembler, if sizeHint < 0 { sizeHint = 0 } - if na.w == nil { - na.w = &_ListString{} - } if sizeHint > 0 { na.w.x = make([]_String, 0, sizeHint) } @@ -3291,7 +3236,7 @@ func (na *_ListString__Assembler) AssignNull() error { *na.m = schema.Maybe_Null return nil case schema.Maybe_Absent: - return mixins.ListAssembler{"ipldgit.ListString"}.AssignNull() + return mixins.ListAssembler{TypeName: "ipldgit.ListString"}.AssignNull() case schema.Maybe_Value, schema.Maybe_Null: panic("invalid state: cannot assign into assembler that's already finished") case midvalue: @@ -3300,22 +3245,22 @@ func (na *_ListString__Assembler) AssignNull() error { panic("unreachable") } func (_ListString__Assembler) AssignBool(bool) error { - return mixins.ListAssembler{"ipldgit.ListString"}.AssignBool(false) + return mixins.ListAssembler{TypeName: "ipldgit.ListString"}.AssignBool(false) } func (_ListString__Assembler) AssignInt(int64) error { - return mixins.ListAssembler{"ipldgit.ListString"}.AssignInt(0) + return mixins.ListAssembler{TypeName: "ipldgit.ListString"}.AssignInt(0) } func (_ListString__Assembler) AssignFloat(float64) error { - return mixins.ListAssembler{"ipldgit.ListString"}.AssignFloat(0) + return mixins.ListAssembler{TypeName: "ipldgit.ListString"}.AssignFloat(0) } func (_ListString__Assembler) AssignString(string) error { - return mixins.ListAssembler{"ipldgit.ListString"}.AssignString("") + return mixins.ListAssembler{TypeName: "ipldgit.ListString"}.AssignString("") } func (_ListString__Assembler) AssignBytes([]byte) error { - return mixins.ListAssembler{"ipldgit.ListString"}.AssignBytes(nil) + return mixins.ListAssembler{TypeName: "ipldgit.ListString"}.AssignBytes(nil) } func (_ListString__Assembler) AssignLink(ipld.Link) error { - return mixins.ListAssembler{"ipldgit.ListString"}.AssignLink(nil) + return mixins.ListAssembler{TypeName: "ipldgit.ListString"}.AssignLink(nil) } func (na *_ListString__Assembler) AssignNode(v ipld.Node) error { if v.IsNull() { @@ -3328,11 +3273,6 @@ func (na *_ListString__Assembler) AssignNode(v ipld.Node) error { 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 @@ -3418,7 +3358,7 @@ func (_ListString__Repr) Kind() ipld.Kind { return ipld.Kind_List } func (_ListString__Repr) LookupByString(string) (ipld.Node, error) { - return mixins.List{"ipldgit.ListString.Repr"}.LookupByString("") + return mixins.List{TypeName: "ipldgit.ListString.Repr"}.LookupByString("") } func (nr *_ListString__Repr) LookupByNode(k ipld.Node) (ipld.Node, error) { v, err := (ListString)(nr).LookupByNode(k) @@ -3471,22 +3411,22 @@ func (_ListString__Repr) IsNull() bool { return false } func (_ListString__Repr) AsBool() (bool, error) { - return mixins.List{"ipldgit.ListString.Repr"}.AsBool() + return mixins.List{TypeName: "ipldgit.ListString.Repr"}.AsBool() } func (_ListString__Repr) AsInt() (int64, error) { - return mixins.List{"ipldgit.ListString.Repr"}.AsInt() + return mixins.List{TypeName: "ipldgit.ListString.Repr"}.AsInt() } func (_ListString__Repr) AsFloat() (float64, error) { - return mixins.List{"ipldgit.ListString.Repr"}.AsFloat() + return mixins.List{TypeName: "ipldgit.ListString.Repr"}.AsFloat() } func (_ListString__Repr) AsString() (string, error) { - return mixins.List{"ipldgit.ListString.Repr"}.AsString() + return mixins.List{TypeName: "ipldgit.ListString.Repr"}.AsString() } func (_ListString__Repr) AsBytes() ([]byte, error) { - return mixins.List{"ipldgit.ListString.Repr"}.AsBytes() + return mixins.List{TypeName: "ipldgit.ListString.Repr"}.AsBytes() } func (_ListString__Repr) AsLink() (ipld.Link, error) { - return mixins.List{"ipldgit.ListString.Repr"}.AsLink() + return mixins.List{TypeName: "ipldgit.ListString.Repr"}.AsLink() } func (_ListString__Repr) Prototype() ipld.NodePrototype { return _ListString__ReprPrototype{} @@ -3530,7 +3470,7 @@ func (na *_ListString__ReprAssembler) reset() { na.va.reset() } func (_ListString__ReprAssembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { - return mixins.ListAssembler{"ipldgit.ListString.Repr"}.BeginMap(0) + return mixins.ListAssembler{TypeName: "ipldgit.ListString.Repr"}.BeginMap(0) } func (na *_ListString__ReprAssembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { switch *na.m { @@ -3543,9 +3483,6 @@ func (na *_ListString__ReprAssembler) BeginList(sizeHint int64) (ipld.ListAssemb if sizeHint < 0 { sizeHint = 0 } - if na.w == nil { - na.w = &_ListString{} - } if sizeHint > 0 { na.w.x = make([]_String, 0, sizeHint) } @@ -3557,7 +3494,7 @@ func (na *_ListString__ReprAssembler) AssignNull() error { *na.m = schema.Maybe_Null return nil case schema.Maybe_Absent: - return mixins.ListAssembler{"ipldgit.ListString.Repr.Repr"}.AssignNull() + return mixins.ListAssembler{TypeName: "ipldgit.ListString.Repr.Repr"}.AssignNull() case schema.Maybe_Value, schema.Maybe_Null: panic("invalid state: cannot assign into assembler that's already finished") case midvalue: @@ -3566,22 +3503,22 @@ func (na *_ListString__ReprAssembler) AssignNull() error { panic("unreachable") } func (_ListString__ReprAssembler) AssignBool(bool) error { - return mixins.ListAssembler{"ipldgit.ListString.Repr"}.AssignBool(false) + return mixins.ListAssembler{TypeName: "ipldgit.ListString.Repr"}.AssignBool(false) } func (_ListString__ReprAssembler) AssignInt(int64) error { - return mixins.ListAssembler{"ipldgit.ListString.Repr"}.AssignInt(0) + return mixins.ListAssembler{TypeName: "ipldgit.ListString.Repr"}.AssignInt(0) } func (_ListString__ReprAssembler) AssignFloat(float64) error { - return mixins.ListAssembler{"ipldgit.ListString.Repr"}.AssignFloat(0) + return mixins.ListAssembler{TypeName: "ipldgit.ListString.Repr"}.AssignFloat(0) } func (_ListString__ReprAssembler) AssignString(string) error { - return mixins.ListAssembler{"ipldgit.ListString.Repr"}.AssignString("") + return mixins.ListAssembler{TypeName: "ipldgit.ListString.Repr"}.AssignString("") } func (_ListString__ReprAssembler) AssignBytes([]byte) error { - return mixins.ListAssembler{"ipldgit.ListString.Repr"}.AssignBytes(nil) + return mixins.ListAssembler{TypeName: "ipldgit.ListString.Repr"}.AssignBytes(nil) } func (_ListString__ReprAssembler) AssignLink(ipld.Link) error { - return mixins.ListAssembler{"ipldgit.ListString.Repr"}.AssignLink(nil) + return mixins.ListAssembler{TypeName: "ipldgit.ListString.Repr"}.AssignLink(nil) } func (na *_ListString__ReprAssembler) AssignNode(v ipld.Node) error { if v.IsNull() { @@ -3594,11 +3531,6 @@ func (na *_ListString__ReprAssembler) AssignNode(v ipld.Node) error { 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 @@ -3714,7 +3646,7 @@ func (itr *ListTag__Itr) Done() bool { type _ListTag__Maybe struct { m schema.Maybe - v ListTag + v _ListTag } type MaybeListTag = *_ListTag__Maybe @@ -3734,7 +3666,7 @@ func (m MaybeListTag) AsNode() ipld.Node { case schema.Maybe_Null: return ipld.Null case schema.Maybe_Value: - return m.v + return &m.v default: panic("unreachable") } @@ -3743,7 +3675,7 @@ func (m MaybeListTag) Must() ListTag { if !m.Exists() { panic("unbox of a maybe rejected") } - return m.v + return &m.v } var _ ipld.Node = (ListTag)(&_ListTag{}) @@ -3753,7 +3685,7 @@ func (ListTag) Kind() ipld.Kind { return ipld.Kind_List } func (ListTag) LookupByString(string) (ipld.Node, error) { - return mixins.List{"ipldgit.ListTag"}.LookupByString("") + return mixins.List{TypeName: "ipldgit.ListTag"}.LookupByString("") } func (n ListTag) LookupByNode(k ipld.Node) (ipld.Node, error) { idx, err := k.AsInt() @@ -3812,22 +3744,22 @@ func (ListTag) IsNull() bool { return false } func (ListTag) AsBool() (bool, error) { - return mixins.List{"ipldgit.ListTag"}.AsBool() + return mixins.List{TypeName: "ipldgit.ListTag"}.AsBool() } func (ListTag) AsInt() (int64, error) { - return mixins.List{"ipldgit.ListTag"}.AsInt() + return mixins.List{TypeName: "ipldgit.ListTag"}.AsInt() } func (ListTag) AsFloat() (float64, error) { - return mixins.List{"ipldgit.ListTag"}.AsFloat() + return mixins.List{TypeName: "ipldgit.ListTag"}.AsFloat() } func (ListTag) AsString() (string, error) { - return mixins.List{"ipldgit.ListTag"}.AsString() + return mixins.List{TypeName: "ipldgit.ListTag"}.AsString() } func (ListTag) AsBytes() ([]byte, error) { - return mixins.List{"ipldgit.ListTag"}.AsBytes() + return mixins.List{TypeName: "ipldgit.ListTag"}.AsBytes() } func (ListTag) AsLink() (ipld.Link, error) { - return mixins.List{"ipldgit.ListTag"}.AsLink() + return mixins.List{TypeName: "ipldgit.ListTag"}.AsLink() } func (ListTag) Prototype() ipld.NodePrototype { return _ListTag__Prototype{} @@ -3871,7 +3803,7 @@ func (na *_ListTag__Assembler) reset() { na.va.reset() } func (_ListTag__Assembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { - return mixins.ListAssembler{"ipldgit.ListTag"}.BeginMap(0) + return mixins.ListAssembler{TypeName: "ipldgit.ListTag"}.BeginMap(0) } func (na *_ListTag__Assembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { switch *na.m { @@ -3884,9 +3816,6 @@ func (na *_ListTag__Assembler) BeginList(sizeHint int64) (ipld.ListAssembler, er if sizeHint < 0 { sizeHint = 0 } - if na.w == nil { - na.w = &_ListTag{} - } if sizeHint > 0 { na.w.x = make([]_Tag, 0, sizeHint) } @@ -3898,7 +3827,7 @@ func (na *_ListTag__Assembler) AssignNull() error { *na.m = schema.Maybe_Null return nil case schema.Maybe_Absent: - return mixins.ListAssembler{"ipldgit.ListTag"}.AssignNull() + return mixins.ListAssembler{TypeName: "ipldgit.ListTag"}.AssignNull() case schema.Maybe_Value, schema.Maybe_Null: panic("invalid state: cannot assign into assembler that's already finished") case midvalue: @@ -3907,22 +3836,22 @@ func (na *_ListTag__Assembler) AssignNull() error { panic("unreachable") } func (_ListTag__Assembler) AssignBool(bool) error { - return mixins.ListAssembler{"ipldgit.ListTag"}.AssignBool(false) + return mixins.ListAssembler{TypeName: "ipldgit.ListTag"}.AssignBool(false) } func (_ListTag__Assembler) AssignInt(int64) error { - return mixins.ListAssembler{"ipldgit.ListTag"}.AssignInt(0) + return mixins.ListAssembler{TypeName: "ipldgit.ListTag"}.AssignInt(0) } func (_ListTag__Assembler) AssignFloat(float64) error { - return mixins.ListAssembler{"ipldgit.ListTag"}.AssignFloat(0) + return mixins.ListAssembler{TypeName: "ipldgit.ListTag"}.AssignFloat(0) } func (_ListTag__Assembler) AssignString(string) error { - return mixins.ListAssembler{"ipldgit.ListTag"}.AssignString("") + return mixins.ListAssembler{TypeName: "ipldgit.ListTag"}.AssignString("") } func (_ListTag__Assembler) AssignBytes([]byte) error { - return mixins.ListAssembler{"ipldgit.ListTag"}.AssignBytes(nil) + return mixins.ListAssembler{TypeName: "ipldgit.ListTag"}.AssignBytes(nil) } func (_ListTag__Assembler) AssignLink(ipld.Link) error { - return mixins.ListAssembler{"ipldgit.ListTag"}.AssignLink(nil) + return mixins.ListAssembler{TypeName: "ipldgit.ListTag"}.AssignLink(nil) } func (na *_ListTag__Assembler) AssignNode(v ipld.Node) error { if v.IsNull() { @@ -3935,11 +3864,6 @@ func (na *_ListTag__Assembler) AssignNode(v ipld.Node) error { 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 @@ -4025,7 +3949,7 @@ func (_ListTag__Repr) Kind() ipld.Kind { return ipld.Kind_List } func (_ListTag__Repr) LookupByString(string) (ipld.Node, error) { - return mixins.List{"ipldgit.ListTag.Repr"}.LookupByString("") + return mixins.List{TypeName: "ipldgit.ListTag.Repr"}.LookupByString("") } func (nr *_ListTag__Repr) LookupByNode(k ipld.Node) (ipld.Node, error) { v, err := (ListTag)(nr).LookupByNode(k) @@ -4078,22 +4002,22 @@ func (_ListTag__Repr) IsNull() bool { return false } func (_ListTag__Repr) AsBool() (bool, error) { - return mixins.List{"ipldgit.ListTag.Repr"}.AsBool() + return mixins.List{TypeName: "ipldgit.ListTag.Repr"}.AsBool() } func (_ListTag__Repr) AsInt() (int64, error) { - return mixins.List{"ipldgit.ListTag.Repr"}.AsInt() + return mixins.List{TypeName: "ipldgit.ListTag.Repr"}.AsInt() } func (_ListTag__Repr) AsFloat() (float64, error) { - return mixins.List{"ipldgit.ListTag.Repr"}.AsFloat() + return mixins.List{TypeName: "ipldgit.ListTag.Repr"}.AsFloat() } func (_ListTag__Repr) AsString() (string, error) { - return mixins.List{"ipldgit.ListTag.Repr"}.AsString() + return mixins.List{TypeName: "ipldgit.ListTag.Repr"}.AsString() } func (_ListTag__Repr) AsBytes() ([]byte, error) { - return mixins.List{"ipldgit.ListTag.Repr"}.AsBytes() + return mixins.List{TypeName: "ipldgit.ListTag.Repr"}.AsBytes() } func (_ListTag__Repr) AsLink() (ipld.Link, error) { - return mixins.List{"ipldgit.ListTag.Repr"}.AsLink() + return mixins.List{TypeName: "ipldgit.ListTag.Repr"}.AsLink() } func (_ListTag__Repr) Prototype() ipld.NodePrototype { return _ListTag__ReprPrototype{} @@ -4137,7 +4061,7 @@ func (na *_ListTag__ReprAssembler) reset() { na.va.reset() } func (_ListTag__ReprAssembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { - return mixins.ListAssembler{"ipldgit.ListTag.Repr"}.BeginMap(0) + return mixins.ListAssembler{TypeName: "ipldgit.ListTag.Repr"}.BeginMap(0) } func (na *_ListTag__ReprAssembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { switch *na.m { @@ -4150,9 +4074,6 @@ func (na *_ListTag__ReprAssembler) BeginList(sizeHint int64) (ipld.ListAssembler if sizeHint < 0 { sizeHint = 0 } - if na.w == nil { - na.w = &_ListTag{} - } if sizeHint > 0 { na.w.x = make([]_Tag, 0, sizeHint) } @@ -4164,7 +4085,7 @@ func (na *_ListTag__ReprAssembler) AssignNull() error { *na.m = schema.Maybe_Null return nil case schema.Maybe_Absent: - return mixins.ListAssembler{"ipldgit.ListTag.Repr.Repr"}.AssignNull() + return mixins.ListAssembler{TypeName: "ipldgit.ListTag.Repr.Repr"}.AssignNull() case schema.Maybe_Value, schema.Maybe_Null: panic("invalid state: cannot assign into assembler that's already finished") case midvalue: @@ -4173,22 +4094,22 @@ func (na *_ListTag__ReprAssembler) AssignNull() error { panic("unreachable") } func (_ListTag__ReprAssembler) AssignBool(bool) error { - return mixins.ListAssembler{"ipldgit.ListTag.Repr"}.AssignBool(false) + return mixins.ListAssembler{TypeName: "ipldgit.ListTag.Repr"}.AssignBool(false) } func (_ListTag__ReprAssembler) AssignInt(int64) error { - return mixins.ListAssembler{"ipldgit.ListTag.Repr"}.AssignInt(0) + return mixins.ListAssembler{TypeName: "ipldgit.ListTag.Repr"}.AssignInt(0) } func (_ListTag__ReprAssembler) AssignFloat(float64) error { - return mixins.ListAssembler{"ipldgit.ListTag.Repr"}.AssignFloat(0) + return mixins.ListAssembler{TypeName: "ipldgit.ListTag.Repr"}.AssignFloat(0) } func (_ListTag__ReprAssembler) AssignString(string) error { - return mixins.ListAssembler{"ipldgit.ListTag.Repr"}.AssignString("") + return mixins.ListAssembler{TypeName: "ipldgit.ListTag.Repr"}.AssignString("") } func (_ListTag__ReprAssembler) AssignBytes([]byte) error { - return mixins.ListAssembler{"ipldgit.ListTag.Repr"}.AssignBytes(nil) + return mixins.ListAssembler{TypeName: "ipldgit.ListTag.Repr"}.AssignBytes(nil) } func (_ListTag__ReprAssembler) AssignLink(ipld.Link) error { - return mixins.ListAssembler{"ipldgit.ListTag.Repr"}.AssignLink(nil) + return mixins.ListAssembler{TypeName: "ipldgit.ListTag.Repr"}.AssignLink(nil) } func (na *_ListTag__ReprAssembler) AssignNode(v ipld.Node) error { if v.IsNull() { @@ -4201,11 +4122,6 @@ func (na *_ListTag__ReprAssembler) AssignNode(v ipld.Node) error { 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 @@ -4358,7 +4274,7 @@ func (n PersonInfo) LookupByNode(key ipld.Node) (ipld.Node, error) { return n.LookupByString(ks) } func (PersonInfo) LookupByIndex(idx int64) (ipld.Node, error) { - return mixins.Map{"ipldgit.PersonInfo"}.LookupByIndex(0) + return mixins.Map{TypeName: "ipldgit.PersonInfo"}.LookupByIndex(0) } func (n PersonInfo) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { return n.LookupByString(seg.String()) @@ -4412,22 +4328,22 @@ func (PersonInfo) IsNull() bool { return false } func (PersonInfo) AsBool() (bool, error) { - return mixins.Map{"ipldgit.PersonInfo"}.AsBool() + return mixins.Map{TypeName: "ipldgit.PersonInfo"}.AsBool() } func (PersonInfo) AsInt() (int64, error) { - return mixins.Map{"ipldgit.PersonInfo"}.AsInt() + return mixins.Map{TypeName: "ipldgit.PersonInfo"}.AsInt() } func (PersonInfo) AsFloat() (float64, error) { - return mixins.Map{"ipldgit.PersonInfo"}.AsFloat() + return mixins.Map{TypeName: "ipldgit.PersonInfo"}.AsFloat() } func (PersonInfo) AsString() (string, error) { - return mixins.Map{"ipldgit.PersonInfo"}.AsString() + return mixins.Map{TypeName: "ipldgit.PersonInfo"}.AsString() } func (PersonInfo) AsBytes() ([]byte, error) { - return mixins.Map{"ipldgit.PersonInfo"}.AsBytes() + return mixins.Map{TypeName: "ipldgit.PersonInfo"}.AsBytes() } func (PersonInfo) AsLink() (ipld.Link, error) { - return mixins.Map{"ipldgit.PersonInfo"}.AsLink() + return mixins.Map{TypeName: "ipldgit.PersonInfo"}.AsLink() } func (PersonInfo) Prototype() ipld.NodePrototype { return _PersonInfo__Prototype{} @@ -4502,7 +4418,7 @@ func (na *_PersonInfo__Assembler) BeginMap(int64) (ipld.MapAssembler, error) { return na, nil } func (_PersonInfo__Assembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { - return mixins.MapAssembler{"ipldgit.PersonInfo"}.BeginList(0) + return mixins.MapAssembler{TypeName: "ipldgit.PersonInfo"}.BeginList(0) } func (na *_PersonInfo__Assembler) AssignNull() error { switch *na.m { @@ -4510,7 +4426,7 @@ func (na *_PersonInfo__Assembler) AssignNull() error { *na.m = schema.Maybe_Null return nil case schema.Maybe_Absent: - return mixins.MapAssembler{"ipldgit.PersonInfo"}.AssignNull() + return mixins.MapAssembler{TypeName: "ipldgit.PersonInfo"}.AssignNull() case schema.Maybe_Value, schema.Maybe_Null: panic("invalid state: cannot assign into assembler that's already finished") case midvalue: @@ -4519,22 +4435,22 @@ func (na *_PersonInfo__Assembler) AssignNull() error { panic("unreachable") } func (_PersonInfo__Assembler) AssignBool(bool) error { - return mixins.MapAssembler{"ipldgit.PersonInfo"}.AssignBool(false) + return mixins.MapAssembler{TypeName: "ipldgit.PersonInfo"}.AssignBool(false) } func (_PersonInfo__Assembler) AssignInt(int64) error { - return mixins.MapAssembler{"ipldgit.PersonInfo"}.AssignInt(0) + return mixins.MapAssembler{TypeName: "ipldgit.PersonInfo"}.AssignInt(0) } func (_PersonInfo__Assembler) AssignFloat(float64) error { - return mixins.MapAssembler{"ipldgit.PersonInfo"}.AssignFloat(0) + return mixins.MapAssembler{TypeName: "ipldgit.PersonInfo"}.AssignFloat(0) } func (_PersonInfo__Assembler) AssignString(string) error { - return mixins.MapAssembler{"ipldgit.PersonInfo"}.AssignString("") + return mixins.MapAssembler{TypeName: "ipldgit.PersonInfo"}.AssignString("") } func (_PersonInfo__Assembler) AssignBytes([]byte) error { - return mixins.MapAssembler{"ipldgit.PersonInfo"}.AssignBytes(nil) + return mixins.MapAssembler{TypeName: "ipldgit.PersonInfo"}.AssignBytes(nil) } func (_PersonInfo__Assembler) AssignLink(ipld.Link) error { - return mixins.MapAssembler{"ipldgit.PersonInfo"}.AssignLink(nil) + return mixins.MapAssembler{TypeName: "ipldgit.PersonInfo"}.AssignLink(nil) } func (na *_PersonInfo__Assembler) AssignNode(v ipld.Node) error { if v.IsNull() { @@ -4780,22 +4696,22 @@ func (ma *_PersonInfo__Assembler) ValuePrototype(k string) ipld.NodePrototype { type _PersonInfo__KeyAssembler _PersonInfo__Assembler func (_PersonInfo__KeyAssembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { - return mixins.StringAssembler{"ipldgit.PersonInfo.KeyAssembler"}.BeginMap(0) + return mixins.StringAssembler{TypeName: "ipldgit.PersonInfo.KeyAssembler"}.BeginMap(0) } func (_PersonInfo__KeyAssembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { - return mixins.StringAssembler{"ipldgit.PersonInfo.KeyAssembler"}.BeginList(0) + return mixins.StringAssembler{TypeName: "ipldgit.PersonInfo.KeyAssembler"}.BeginList(0) } func (na *_PersonInfo__KeyAssembler) AssignNull() error { - return mixins.StringAssembler{"ipldgit.PersonInfo.KeyAssembler"}.AssignNull() + return mixins.StringAssembler{TypeName: "ipldgit.PersonInfo.KeyAssembler"}.AssignNull() } func (_PersonInfo__KeyAssembler) AssignBool(bool) error { - return mixins.StringAssembler{"ipldgit.PersonInfo.KeyAssembler"}.AssignBool(false) + return mixins.StringAssembler{TypeName: "ipldgit.PersonInfo.KeyAssembler"}.AssignBool(false) } func (_PersonInfo__KeyAssembler) AssignInt(int64) error { - return mixins.StringAssembler{"ipldgit.PersonInfo.KeyAssembler"}.AssignInt(0) + return mixins.StringAssembler{TypeName: "ipldgit.PersonInfo.KeyAssembler"}.AssignInt(0) } func (_PersonInfo__KeyAssembler) AssignFloat(float64) error { - return mixins.StringAssembler{"ipldgit.PersonInfo.KeyAssembler"}.AssignFloat(0) + return mixins.StringAssembler{TypeName: "ipldgit.PersonInfo.KeyAssembler"}.AssignFloat(0) } func (ka *_PersonInfo__KeyAssembler) AssignString(k string) error { if ka.state != maState_midKey { @@ -4836,10 +4752,10 @@ func (ka *_PersonInfo__KeyAssembler) AssignString(k string) error { return nil } func (_PersonInfo__KeyAssembler) AssignBytes([]byte) error { - return mixins.StringAssembler{"ipldgit.PersonInfo.KeyAssembler"}.AssignBytes(nil) + return mixins.StringAssembler{TypeName: "ipldgit.PersonInfo.KeyAssembler"}.AssignBytes(nil) } func (_PersonInfo__KeyAssembler) AssignLink(ipld.Link) error { - return mixins.StringAssembler{"ipldgit.PersonInfo.KeyAssembler"}.AssignLink(nil) + return mixins.StringAssembler{TypeName: "ipldgit.PersonInfo.KeyAssembler"}.AssignLink(nil) } func (ka *_PersonInfo__KeyAssembler) AssignNode(v ipld.Node) error { if v2, err := v.AsString(); err != nil { @@ -4893,7 +4809,7 @@ func (n *_PersonInfo__Repr) LookupByNode(key ipld.Node) (ipld.Node, error) { return n.LookupByString(ks) } func (_PersonInfo__Repr) LookupByIndex(idx int64) (ipld.Node, error) { - return mixins.Map{"ipldgit.PersonInfo.Repr"}.LookupByIndex(0) + return mixins.Map{TypeName: "ipldgit.PersonInfo.Repr"}.LookupByIndex(0) } func (n _PersonInfo__Repr) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { return n.LookupByString(seg.String()) @@ -4947,22 +4863,22 @@ func (_PersonInfo__Repr) IsNull() bool { return false } func (_PersonInfo__Repr) AsBool() (bool, error) { - return mixins.Map{"ipldgit.PersonInfo.Repr"}.AsBool() + return mixins.Map{TypeName: "ipldgit.PersonInfo.Repr"}.AsBool() } func (_PersonInfo__Repr) AsInt() (int64, error) { - return mixins.Map{"ipldgit.PersonInfo.Repr"}.AsInt() + return mixins.Map{TypeName: "ipldgit.PersonInfo.Repr"}.AsInt() } func (_PersonInfo__Repr) AsFloat() (float64, error) { - return mixins.Map{"ipldgit.PersonInfo.Repr"}.AsFloat() + return mixins.Map{TypeName: "ipldgit.PersonInfo.Repr"}.AsFloat() } func (_PersonInfo__Repr) AsString() (string, error) { - return mixins.Map{"ipldgit.PersonInfo.Repr"}.AsString() + return mixins.Map{TypeName: "ipldgit.PersonInfo.Repr"}.AsString() } func (_PersonInfo__Repr) AsBytes() ([]byte, error) { - return mixins.Map{"ipldgit.PersonInfo.Repr"}.AsBytes() + return mixins.Map{TypeName: "ipldgit.PersonInfo.Repr"}.AsBytes() } func (_PersonInfo__Repr) AsLink() (ipld.Link, error) { - return mixins.Map{"ipldgit.PersonInfo.Repr"}.AsLink() + return mixins.Map{TypeName: "ipldgit.PersonInfo.Repr"}.AsLink() } func (_PersonInfo__Repr) Prototype() ipld.NodePrototype { return _PersonInfo__ReprPrototype{} @@ -5028,7 +4944,7 @@ func (na *_PersonInfo__ReprAssembler) BeginMap(int64) (ipld.MapAssembler, error) return na, nil } func (_PersonInfo__ReprAssembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { - return mixins.MapAssembler{"ipldgit.PersonInfo.Repr"}.BeginList(0) + return mixins.MapAssembler{TypeName: "ipldgit.PersonInfo.Repr"}.BeginList(0) } func (na *_PersonInfo__ReprAssembler) AssignNull() error { switch *na.m { @@ -5036,7 +4952,7 @@ func (na *_PersonInfo__ReprAssembler) AssignNull() error { *na.m = schema.Maybe_Null return nil case schema.Maybe_Absent: - return mixins.MapAssembler{"ipldgit.PersonInfo.Repr.Repr"}.AssignNull() + return mixins.MapAssembler{TypeName: "ipldgit.PersonInfo.Repr.Repr"}.AssignNull() case schema.Maybe_Value, schema.Maybe_Null: panic("invalid state: cannot assign into assembler that's already finished") case midvalue: @@ -5045,22 +4961,22 @@ func (na *_PersonInfo__ReprAssembler) AssignNull() error { panic("unreachable") } func (_PersonInfo__ReprAssembler) AssignBool(bool) error { - return mixins.MapAssembler{"ipldgit.PersonInfo.Repr"}.AssignBool(false) + return mixins.MapAssembler{TypeName: "ipldgit.PersonInfo.Repr"}.AssignBool(false) } func (_PersonInfo__ReprAssembler) AssignInt(int64) error { - return mixins.MapAssembler{"ipldgit.PersonInfo.Repr"}.AssignInt(0) + return mixins.MapAssembler{TypeName: "ipldgit.PersonInfo.Repr"}.AssignInt(0) } func (_PersonInfo__ReprAssembler) AssignFloat(float64) error { - return mixins.MapAssembler{"ipldgit.PersonInfo.Repr"}.AssignFloat(0) + return mixins.MapAssembler{TypeName: "ipldgit.PersonInfo.Repr"}.AssignFloat(0) } func (_PersonInfo__ReprAssembler) AssignString(string) error { - return mixins.MapAssembler{"ipldgit.PersonInfo.Repr"}.AssignString("") + return mixins.MapAssembler{TypeName: "ipldgit.PersonInfo.Repr"}.AssignString("") } func (_PersonInfo__ReprAssembler) AssignBytes([]byte) error { - return mixins.MapAssembler{"ipldgit.PersonInfo.Repr"}.AssignBytes(nil) + return mixins.MapAssembler{TypeName: "ipldgit.PersonInfo.Repr"}.AssignBytes(nil) } func (_PersonInfo__ReprAssembler) AssignLink(ipld.Link) error { - return mixins.MapAssembler{"ipldgit.PersonInfo.Repr"}.AssignLink(nil) + return mixins.MapAssembler{TypeName: "ipldgit.PersonInfo.Repr"}.AssignLink(nil) } func (na *_PersonInfo__ReprAssembler) AssignNode(v ipld.Node) error { if v.IsNull() { @@ -5303,22 +5219,22 @@ func (ma *_PersonInfo__ReprAssembler) ValuePrototype(k string) ipld.NodePrototyp type _PersonInfo__ReprKeyAssembler _PersonInfo__ReprAssembler func (_PersonInfo__ReprKeyAssembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { - return mixins.StringAssembler{"ipldgit.PersonInfo.Repr.KeyAssembler"}.BeginMap(0) + return mixins.StringAssembler{TypeName: "ipldgit.PersonInfo.Repr.KeyAssembler"}.BeginMap(0) } func (_PersonInfo__ReprKeyAssembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { - return mixins.StringAssembler{"ipldgit.PersonInfo.Repr.KeyAssembler"}.BeginList(0) + return mixins.StringAssembler{TypeName: "ipldgit.PersonInfo.Repr.KeyAssembler"}.BeginList(0) } func (na *_PersonInfo__ReprKeyAssembler) AssignNull() error { - return mixins.StringAssembler{"ipldgit.PersonInfo.Repr.KeyAssembler"}.AssignNull() + return mixins.StringAssembler{TypeName: "ipldgit.PersonInfo.Repr.KeyAssembler"}.AssignNull() } func (_PersonInfo__ReprKeyAssembler) AssignBool(bool) error { - return mixins.StringAssembler{"ipldgit.PersonInfo.Repr.KeyAssembler"}.AssignBool(false) + return mixins.StringAssembler{TypeName: "ipldgit.PersonInfo.Repr.KeyAssembler"}.AssignBool(false) } func (_PersonInfo__ReprKeyAssembler) AssignInt(int64) error { - return mixins.StringAssembler{"ipldgit.PersonInfo.Repr.KeyAssembler"}.AssignInt(0) + return mixins.StringAssembler{TypeName: "ipldgit.PersonInfo.Repr.KeyAssembler"}.AssignInt(0) } func (_PersonInfo__ReprKeyAssembler) AssignFloat(float64) error { - return mixins.StringAssembler{"ipldgit.PersonInfo.Repr.KeyAssembler"}.AssignFloat(0) + return mixins.StringAssembler{TypeName: "ipldgit.PersonInfo.Repr.KeyAssembler"}.AssignFloat(0) } func (ka *_PersonInfo__ReprKeyAssembler) AssignString(k string) error { if ka.state != maState_midKey { @@ -5361,10 +5277,10 @@ func (ka *_PersonInfo__ReprKeyAssembler) AssignString(k string) error { return ipld.ErrInvalidKey{TypeName: "ipldgit.PersonInfo.Repr", Key: &_String{k}} } func (_PersonInfo__ReprKeyAssembler) AssignBytes([]byte) error { - return mixins.StringAssembler{"ipldgit.PersonInfo.Repr.KeyAssembler"}.AssignBytes(nil) + return mixins.StringAssembler{TypeName: "ipldgit.PersonInfo.Repr.KeyAssembler"}.AssignBytes(nil) } func (_PersonInfo__ReprKeyAssembler) AssignLink(ipld.Link) error { - return mixins.StringAssembler{"ipldgit.PersonInfo.Repr.KeyAssembler"}.AssignLink(nil) + return mixins.StringAssembler{TypeName: "ipldgit.PersonInfo.Repr.KeyAssembler"}.AssignLink(nil) } func (ka *_PersonInfo__ReprKeyAssembler) AssignNode(v ipld.Node) error { if v2, err := v.AsString(); err != nil { @@ -5391,7 +5307,7 @@ func (_String__Prototype) FromString(v string) (String, error) { type _String__Maybe struct { m schema.Maybe - v String + v _String } type MaybeString = *_String__Maybe @@ -5411,7 +5327,7 @@ func (m MaybeString) AsNode() ipld.Node { case schema.Maybe_Null: return ipld.Null case schema.Maybe_Value: - return m.v + return &m.v default: panic("unreachable") } @@ -5420,7 +5336,7 @@ func (m MaybeString) Must() String { if !m.Exists() { panic("unbox of a maybe rejected") } - return m.v + return &m.v } var _ ipld.Node = (String)(&_String{}) @@ -5430,16 +5346,16 @@ func (String) Kind() ipld.Kind { return ipld.Kind_String } func (String) LookupByString(string) (ipld.Node, error) { - return mixins.String{"ipldgit.String"}.LookupByString("") + return mixins.String{TypeName: "ipldgit.String"}.LookupByString("") } func (String) LookupByNode(ipld.Node) (ipld.Node, error) { - return mixins.String{"ipldgit.String"}.LookupByNode(nil) + return mixins.String{TypeName: "ipldgit.String"}.LookupByNode(nil) } func (String) LookupByIndex(idx int64) (ipld.Node, error) { - return mixins.String{"ipldgit.String"}.LookupByIndex(0) + return mixins.String{TypeName: "ipldgit.String"}.LookupByIndex(0) } func (String) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { - return mixins.String{"ipldgit.String"}.LookupBySegment(seg) + return mixins.String{TypeName: "ipldgit.String"}.LookupBySegment(seg) } func (String) MapIterator() ipld.MapIterator { return nil @@ -5457,22 +5373,22 @@ func (String) IsNull() bool { return false } func (String) AsBool() (bool, error) { - return mixins.String{"ipldgit.String"}.AsBool() + return mixins.String{TypeName: "ipldgit.String"}.AsBool() } func (String) AsInt() (int64, error) { - return mixins.String{"ipldgit.String"}.AsInt() + return mixins.String{TypeName: "ipldgit.String"}.AsInt() } func (String) AsFloat() (float64, error) { - return mixins.String{"ipldgit.String"}.AsFloat() + return mixins.String{TypeName: "ipldgit.String"}.AsFloat() } func (n String) AsString() (string, error) { return n.x, nil } func (String) AsBytes() ([]byte, error) { - return mixins.String{"ipldgit.String"}.AsBytes() + return mixins.String{TypeName: "ipldgit.String"}.AsBytes() } func (String) AsLink() (ipld.Link, error) { - return mixins.String{"ipldgit.String"}.AsLink() + return mixins.String{TypeName: "ipldgit.String"}.AsLink() } func (String) Prototype() ipld.NodePrototype { return _String__Prototype{} @@ -5509,10 +5425,10 @@ type _String__Assembler struct { func (na *_String__Assembler) reset() {} func (_String__Assembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { - return mixins.StringAssembler{"ipldgit.String"}.BeginMap(0) + return mixins.StringAssembler{TypeName: "ipldgit.String"}.BeginMap(0) } func (_String__Assembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { - return mixins.StringAssembler{"ipldgit.String"}.BeginList(0) + return mixins.StringAssembler{TypeName: "ipldgit.String"}.BeginList(0) } func (na *_String__Assembler) AssignNull() error { switch *na.m { @@ -5520,38 +5436,35 @@ func (na *_String__Assembler) AssignNull() error { *na.m = schema.Maybe_Null return nil case schema.Maybe_Absent: - return mixins.StringAssembler{"ipldgit.String"}.AssignNull() + return mixins.StringAssembler{TypeName: "ipldgit.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{"ipldgit.String"}.AssignBool(false) + return mixins.StringAssembler{TypeName: "ipldgit.String"}.AssignBool(false) } func (_String__Assembler) AssignInt(int64) error { - return mixins.StringAssembler{"ipldgit.String"}.AssignInt(0) + return mixins.StringAssembler{TypeName: "ipldgit.String"}.AssignInt(0) } func (_String__Assembler) AssignFloat(float64) error { - return mixins.StringAssembler{"ipldgit.String"}.AssignFloat(0) + return mixins.StringAssembler{TypeName: "ipldgit.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{"ipldgit.String"}.AssignBytes(nil) + return mixins.StringAssembler{TypeName: "ipldgit.String"}.AssignBytes(nil) } func (_String__Assembler) AssignLink(ipld.Link) error { - return mixins.StringAssembler{"ipldgit.String"}.AssignLink(nil) + return mixins.StringAssembler{TypeName: "ipldgit.String"}.AssignLink(nil) } func (na *_String__Assembler) AssignNode(v ipld.Node) error { if v.IsNull() { @@ -5562,11 +5475,6 @@ func (na *_String__Assembler) AssignNode(v ipld.Node) error { 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 @@ -5681,7 +5589,7 @@ func (n Tag) LookupByNode(key ipld.Node) (ipld.Node, error) { return n.LookupByString(ks) } func (Tag) LookupByIndex(idx int64) (ipld.Node, error) { - return mixins.Map{"ipldgit.Tag"}.LookupByIndex(0) + return mixins.Map{TypeName: "ipldgit.Tag"}.LookupByIndex(0) } func (n Tag) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { return n.LookupByString(seg.String()) @@ -5738,22 +5646,22 @@ func (Tag) IsNull() bool { return false } func (Tag) AsBool() (bool, error) { - return mixins.Map{"ipldgit.Tag"}.AsBool() + return mixins.Map{TypeName: "ipldgit.Tag"}.AsBool() } func (Tag) AsInt() (int64, error) { - return mixins.Map{"ipldgit.Tag"}.AsInt() + return mixins.Map{TypeName: "ipldgit.Tag"}.AsInt() } func (Tag) AsFloat() (float64, error) { - return mixins.Map{"ipldgit.Tag"}.AsFloat() + return mixins.Map{TypeName: "ipldgit.Tag"}.AsFloat() } func (Tag) AsString() (string, error) { - return mixins.Map{"ipldgit.Tag"}.AsString() + return mixins.Map{TypeName: "ipldgit.Tag"}.AsString() } func (Tag) AsBytes() ([]byte, error) { - return mixins.Map{"ipldgit.Tag"}.AsBytes() + return mixins.Map{TypeName: "ipldgit.Tag"}.AsBytes() } func (Tag) AsLink() (ipld.Link, error) { - return mixins.Map{"ipldgit.Tag"}.AsLink() + return mixins.Map{TypeName: "ipldgit.Tag"}.AsLink() } func (Tag) Prototype() ipld.NodePrototype { return _Tag__Prototype{} @@ -5831,7 +5739,7 @@ func (na *_Tag__Assembler) BeginMap(int64) (ipld.MapAssembler, error) { return na, nil } func (_Tag__Assembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { - return mixins.MapAssembler{"ipldgit.Tag"}.BeginList(0) + return mixins.MapAssembler{TypeName: "ipldgit.Tag"}.BeginList(0) } func (na *_Tag__Assembler) AssignNull() error { switch *na.m { @@ -5839,7 +5747,7 @@ func (na *_Tag__Assembler) AssignNull() error { *na.m = schema.Maybe_Null return nil case schema.Maybe_Absent: - return mixins.MapAssembler{"ipldgit.Tag"}.AssignNull() + return mixins.MapAssembler{TypeName: "ipldgit.Tag"}.AssignNull() case schema.Maybe_Value, schema.Maybe_Null: panic("invalid state: cannot assign into assembler that's already finished") case midvalue: @@ -5848,22 +5756,22 @@ func (na *_Tag__Assembler) AssignNull() error { panic("unreachable") } func (_Tag__Assembler) AssignBool(bool) error { - return mixins.MapAssembler{"ipldgit.Tag"}.AssignBool(false) + return mixins.MapAssembler{TypeName: "ipldgit.Tag"}.AssignBool(false) } func (_Tag__Assembler) AssignInt(int64) error { - return mixins.MapAssembler{"ipldgit.Tag"}.AssignInt(0) + return mixins.MapAssembler{TypeName: "ipldgit.Tag"}.AssignInt(0) } func (_Tag__Assembler) AssignFloat(float64) error { - return mixins.MapAssembler{"ipldgit.Tag"}.AssignFloat(0) + return mixins.MapAssembler{TypeName: "ipldgit.Tag"}.AssignFloat(0) } func (_Tag__Assembler) AssignString(string) error { - return mixins.MapAssembler{"ipldgit.Tag"}.AssignString("") + return mixins.MapAssembler{TypeName: "ipldgit.Tag"}.AssignString("") } func (_Tag__Assembler) AssignBytes([]byte) error { - return mixins.MapAssembler{"ipldgit.Tag"}.AssignBytes(nil) + return mixins.MapAssembler{TypeName: "ipldgit.Tag"}.AssignBytes(nil) } func (_Tag__Assembler) AssignLink(ipld.Link) error { - return mixins.MapAssembler{"ipldgit.Tag"}.AssignLink(nil) + return mixins.MapAssembler{TypeName: "ipldgit.Tag"}.AssignLink(nil) } func (na *_Tag__Assembler) AssignNode(v ipld.Node) error { if v.IsNull() { @@ -6136,22 +6044,22 @@ func (ma *_Tag__Assembler) ValuePrototype(k string) ipld.NodePrototype { type _Tag__KeyAssembler _Tag__Assembler func (_Tag__KeyAssembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { - return mixins.StringAssembler{"ipldgit.Tag.KeyAssembler"}.BeginMap(0) + return mixins.StringAssembler{TypeName: "ipldgit.Tag.KeyAssembler"}.BeginMap(0) } func (_Tag__KeyAssembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { - return mixins.StringAssembler{"ipldgit.Tag.KeyAssembler"}.BeginList(0) + return mixins.StringAssembler{TypeName: "ipldgit.Tag.KeyAssembler"}.BeginList(0) } func (na *_Tag__KeyAssembler) AssignNull() error { - return mixins.StringAssembler{"ipldgit.Tag.KeyAssembler"}.AssignNull() + return mixins.StringAssembler{TypeName: "ipldgit.Tag.KeyAssembler"}.AssignNull() } func (_Tag__KeyAssembler) AssignBool(bool) error { - return mixins.StringAssembler{"ipldgit.Tag.KeyAssembler"}.AssignBool(false) + return mixins.StringAssembler{TypeName: "ipldgit.Tag.KeyAssembler"}.AssignBool(false) } func (_Tag__KeyAssembler) AssignInt(int64) error { - return mixins.StringAssembler{"ipldgit.Tag.KeyAssembler"}.AssignInt(0) + return mixins.StringAssembler{TypeName: "ipldgit.Tag.KeyAssembler"}.AssignInt(0) } func (_Tag__KeyAssembler) AssignFloat(float64) error { - return mixins.StringAssembler{"ipldgit.Tag.KeyAssembler"}.AssignFloat(0) + return mixins.StringAssembler{TypeName: "ipldgit.Tag.KeyAssembler"}.AssignFloat(0) } func (ka *_Tag__KeyAssembler) AssignString(k string) error { if ka.state != maState_midKey { @@ -6199,10 +6107,10 @@ func (ka *_Tag__KeyAssembler) AssignString(k string) error { return nil } func (_Tag__KeyAssembler) AssignBytes([]byte) error { - return mixins.StringAssembler{"ipldgit.Tag.KeyAssembler"}.AssignBytes(nil) + return mixins.StringAssembler{TypeName: "ipldgit.Tag.KeyAssembler"}.AssignBytes(nil) } func (_Tag__KeyAssembler) AssignLink(ipld.Link) error { - return mixins.StringAssembler{"ipldgit.Tag.KeyAssembler"}.AssignLink(nil) + return mixins.StringAssembler{TypeName: "ipldgit.Tag.KeyAssembler"}.AssignLink(nil) } func (ka *_Tag__KeyAssembler) AssignNode(v ipld.Node) error { if v2, err := v.AsString(); err != nil { @@ -6259,7 +6167,7 @@ func (n *_Tag__Repr) LookupByNode(key ipld.Node) (ipld.Node, error) { return n.LookupByString(ks) } func (_Tag__Repr) LookupByIndex(idx int64) (ipld.Node, error) { - return mixins.Map{"ipldgit.Tag.Repr"}.LookupByIndex(0) + return mixins.Map{TypeName: "ipldgit.Tag.Repr"}.LookupByIndex(0) } func (n _Tag__Repr) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { return n.LookupByString(seg.String()) @@ -6316,22 +6224,22 @@ func (_Tag__Repr) IsNull() bool { return false } func (_Tag__Repr) AsBool() (bool, error) { - return mixins.Map{"ipldgit.Tag.Repr"}.AsBool() + return mixins.Map{TypeName: "ipldgit.Tag.Repr"}.AsBool() } func (_Tag__Repr) AsInt() (int64, error) { - return mixins.Map{"ipldgit.Tag.Repr"}.AsInt() + return mixins.Map{TypeName: "ipldgit.Tag.Repr"}.AsInt() } func (_Tag__Repr) AsFloat() (float64, error) { - return mixins.Map{"ipldgit.Tag.Repr"}.AsFloat() + return mixins.Map{TypeName: "ipldgit.Tag.Repr"}.AsFloat() } func (_Tag__Repr) AsString() (string, error) { - return mixins.Map{"ipldgit.Tag.Repr"}.AsString() + return mixins.Map{TypeName: "ipldgit.Tag.Repr"}.AsString() } func (_Tag__Repr) AsBytes() ([]byte, error) { - return mixins.Map{"ipldgit.Tag.Repr"}.AsBytes() + return mixins.Map{TypeName: "ipldgit.Tag.Repr"}.AsBytes() } func (_Tag__Repr) AsLink() (ipld.Link, error) { - return mixins.Map{"ipldgit.Tag.Repr"}.AsLink() + return mixins.Map{TypeName: "ipldgit.Tag.Repr"}.AsLink() } func (_Tag__Repr) Prototype() ipld.NodePrototype { return _Tag__ReprPrototype{} @@ -6399,7 +6307,7 @@ func (na *_Tag__ReprAssembler) BeginMap(int64) (ipld.MapAssembler, error) { return na, nil } func (_Tag__ReprAssembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { - return mixins.MapAssembler{"ipldgit.Tag.Repr"}.BeginList(0) + return mixins.MapAssembler{TypeName: "ipldgit.Tag.Repr"}.BeginList(0) } func (na *_Tag__ReprAssembler) AssignNull() error { switch *na.m { @@ -6407,7 +6315,7 @@ func (na *_Tag__ReprAssembler) AssignNull() error { *na.m = schema.Maybe_Null return nil case schema.Maybe_Absent: - return mixins.MapAssembler{"ipldgit.Tag.Repr.Repr"}.AssignNull() + return mixins.MapAssembler{TypeName: "ipldgit.Tag.Repr.Repr"}.AssignNull() case schema.Maybe_Value, schema.Maybe_Null: panic("invalid state: cannot assign into assembler that's already finished") case midvalue: @@ -6416,22 +6324,22 @@ func (na *_Tag__ReprAssembler) AssignNull() error { panic("unreachable") } func (_Tag__ReprAssembler) AssignBool(bool) error { - return mixins.MapAssembler{"ipldgit.Tag.Repr"}.AssignBool(false) + return mixins.MapAssembler{TypeName: "ipldgit.Tag.Repr"}.AssignBool(false) } func (_Tag__ReprAssembler) AssignInt(int64) error { - return mixins.MapAssembler{"ipldgit.Tag.Repr"}.AssignInt(0) + return mixins.MapAssembler{TypeName: "ipldgit.Tag.Repr"}.AssignInt(0) } func (_Tag__ReprAssembler) AssignFloat(float64) error { - return mixins.MapAssembler{"ipldgit.Tag.Repr"}.AssignFloat(0) + return mixins.MapAssembler{TypeName: "ipldgit.Tag.Repr"}.AssignFloat(0) } func (_Tag__ReprAssembler) AssignString(string) error { - return mixins.MapAssembler{"ipldgit.Tag.Repr"}.AssignString("") + return mixins.MapAssembler{TypeName: "ipldgit.Tag.Repr"}.AssignString("") } func (_Tag__ReprAssembler) AssignBytes([]byte) error { - return mixins.MapAssembler{"ipldgit.Tag.Repr"}.AssignBytes(nil) + return mixins.MapAssembler{TypeName: "ipldgit.Tag.Repr"}.AssignBytes(nil) } func (_Tag__ReprAssembler) AssignLink(ipld.Link) error { - return mixins.MapAssembler{"ipldgit.Tag.Repr"}.AssignLink(nil) + return mixins.MapAssembler{TypeName: "ipldgit.Tag.Repr"}.AssignLink(nil) } func (na *_Tag__ReprAssembler) AssignNode(v ipld.Node) error { if v.IsNull() { @@ -6700,22 +6608,22 @@ func (ma *_Tag__ReprAssembler) ValuePrototype(k string) ipld.NodePrototype { type _Tag__ReprKeyAssembler _Tag__ReprAssembler func (_Tag__ReprKeyAssembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { - return mixins.StringAssembler{"ipldgit.Tag.Repr.KeyAssembler"}.BeginMap(0) + return mixins.StringAssembler{TypeName: "ipldgit.Tag.Repr.KeyAssembler"}.BeginMap(0) } func (_Tag__ReprKeyAssembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { - return mixins.StringAssembler{"ipldgit.Tag.Repr.KeyAssembler"}.BeginList(0) + return mixins.StringAssembler{TypeName: "ipldgit.Tag.Repr.KeyAssembler"}.BeginList(0) } func (na *_Tag__ReprKeyAssembler) AssignNull() error { - return mixins.StringAssembler{"ipldgit.Tag.Repr.KeyAssembler"}.AssignNull() + return mixins.StringAssembler{TypeName: "ipldgit.Tag.Repr.KeyAssembler"}.AssignNull() } func (_Tag__ReprKeyAssembler) AssignBool(bool) error { - return mixins.StringAssembler{"ipldgit.Tag.Repr.KeyAssembler"}.AssignBool(false) + return mixins.StringAssembler{TypeName: "ipldgit.Tag.Repr.KeyAssembler"}.AssignBool(false) } func (_Tag__ReprKeyAssembler) AssignInt(int64) error { - return mixins.StringAssembler{"ipldgit.Tag.Repr.KeyAssembler"}.AssignInt(0) + return mixins.StringAssembler{TypeName: "ipldgit.Tag.Repr.KeyAssembler"}.AssignInt(0) } func (_Tag__ReprKeyAssembler) AssignFloat(float64) error { - return mixins.StringAssembler{"ipldgit.Tag.Repr.KeyAssembler"}.AssignFloat(0) + return mixins.StringAssembler{TypeName: "ipldgit.Tag.Repr.KeyAssembler"}.AssignFloat(0) } func (ka *_Tag__ReprKeyAssembler) AssignString(k string) error { if ka.state != maState_midKey { @@ -6766,10 +6674,10 @@ func (ka *_Tag__ReprKeyAssembler) AssignString(k string) error { return ipld.ErrInvalidKey{TypeName: "ipldgit.Tag.Repr", Key: &_String{k}} } func (_Tag__ReprKeyAssembler) AssignBytes([]byte) error { - return mixins.StringAssembler{"ipldgit.Tag.Repr.KeyAssembler"}.AssignBytes(nil) + return mixins.StringAssembler{TypeName: "ipldgit.Tag.Repr.KeyAssembler"}.AssignBytes(nil) } func (_Tag__ReprKeyAssembler) AssignLink(ipld.Link) error { - return mixins.StringAssembler{"ipldgit.Tag.Repr.KeyAssembler"}.AssignLink(nil) + return mixins.StringAssembler{TypeName: "ipldgit.Tag.Repr.KeyAssembler"}.AssignLink(nil) } func (ka *_Tag__ReprKeyAssembler) AssignNode(v ipld.Node) error { if v2, err := v.AsString(); err != nil { @@ -6827,7 +6735,7 @@ func (itr *Tree__Itr) Done() bool { type _Tree__Maybe struct { m schema.Maybe - v Tree + v _Tree } type MaybeTree = *_Tree__Maybe @@ -6847,7 +6755,7 @@ func (m MaybeTree) AsNode() ipld.Node { case schema.Maybe_Null: return ipld.Null case schema.Maybe_Value: - return m.v + return &m.v default: panic("unreachable") } @@ -6856,7 +6764,7 @@ func (m MaybeTree) Must() Tree { if !m.Exists() { panic("unbox of a maybe rejected") } - return m.v + return &m.v } var _ ipld.Node = (Tree)(&_Tree{}) @@ -6889,7 +6797,7 @@ func (n Tree) LookupByNode(k ipld.Node) (ipld.Node, error) { return v, nil } func (Tree) LookupByIndex(idx int64) (ipld.Node, error) { - return mixins.Map{"ipldgit.Tree"}.LookupByIndex(0) + return mixins.Map{TypeName: "ipldgit.Tree"}.LookupByIndex(0) } func (n Tree) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { return n.LookupByString(seg.String()) @@ -6930,22 +6838,22 @@ func (Tree) IsNull() bool { return false } func (Tree) AsBool() (bool, error) { - return mixins.Map{"ipldgit.Tree"}.AsBool() + return mixins.Map{TypeName: "ipldgit.Tree"}.AsBool() } func (Tree) AsInt() (int64, error) { - return mixins.Map{"ipldgit.Tree"}.AsInt() + return mixins.Map{TypeName: "ipldgit.Tree"}.AsInt() } func (Tree) AsFloat() (float64, error) { - return mixins.Map{"ipldgit.Tree"}.AsFloat() + return mixins.Map{TypeName: "ipldgit.Tree"}.AsFloat() } func (Tree) AsString() (string, error) { - return mixins.Map{"ipldgit.Tree"}.AsString() + return mixins.Map{TypeName: "ipldgit.Tree"}.AsString() } func (Tree) AsBytes() ([]byte, error) { - return mixins.Map{"ipldgit.Tree"}.AsBytes() + return mixins.Map{TypeName: "ipldgit.Tree"}.AsBytes() } func (Tree) AsLink() (ipld.Link, error) { - return mixins.Map{"ipldgit.Tree"}.AsLink() + return mixins.Map{TypeName: "ipldgit.Tree"}.AsLink() } func (Tree) Prototype() ipld.NodePrototype { return _Tree__Prototype{} @@ -7001,15 +6909,12 @@ func (na *_Tree__Assembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) if sizeHint < 0 { sizeHint = 0 } - if na.w == nil { - na.w = &_Tree{} - } na.w.m = make(map[_String]*_TreeEntry, sizeHint) na.w.t = make([]_Tree__entry, 0, sizeHint) return na, nil } func (_Tree__Assembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { - return mixins.MapAssembler{"ipldgit.Tree"}.BeginList(0) + return mixins.MapAssembler{TypeName: "ipldgit.Tree"}.BeginList(0) } func (na *_Tree__Assembler) AssignNull() error { switch *na.m { @@ -7017,7 +6922,7 @@ func (na *_Tree__Assembler) AssignNull() error { *na.m = schema.Maybe_Null return nil case schema.Maybe_Absent: - return mixins.MapAssembler{"ipldgit.Tree"}.AssignNull() + return mixins.MapAssembler{TypeName: "ipldgit.Tree"}.AssignNull() case schema.Maybe_Value, schema.Maybe_Null: panic("invalid state: cannot assign into assembler that's already finished") case midvalue: @@ -7026,22 +6931,22 @@ func (na *_Tree__Assembler) AssignNull() error { panic("unreachable") } func (_Tree__Assembler) AssignBool(bool) error { - return mixins.MapAssembler{"ipldgit.Tree"}.AssignBool(false) + return mixins.MapAssembler{TypeName: "ipldgit.Tree"}.AssignBool(false) } func (_Tree__Assembler) AssignInt(int64) error { - return mixins.MapAssembler{"ipldgit.Tree"}.AssignInt(0) + return mixins.MapAssembler{TypeName: "ipldgit.Tree"}.AssignInt(0) } func (_Tree__Assembler) AssignFloat(float64) error { - return mixins.MapAssembler{"ipldgit.Tree"}.AssignFloat(0) + return mixins.MapAssembler{TypeName: "ipldgit.Tree"}.AssignFloat(0) } func (_Tree__Assembler) AssignString(string) error { - return mixins.MapAssembler{"ipldgit.Tree"}.AssignString("") + return mixins.MapAssembler{TypeName: "ipldgit.Tree"}.AssignString("") } func (_Tree__Assembler) AssignBytes([]byte) error { - return mixins.MapAssembler{"ipldgit.Tree"}.AssignBytes(nil) + return mixins.MapAssembler{TypeName: "ipldgit.Tree"}.AssignBytes(nil) } func (_Tree__Assembler) AssignLink(ipld.Link) error { - return mixins.MapAssembler{"ipldgit.Tree"}.AssignLink(nil) + return mixins.MapAssembler{TypeName: "ipldgit.Tree"}.AssignLink(nil) } func (na *_Tree__Assembler) AssignNode(v ipld.Node) error { if v.IsNull() { @@ -7054,11 +6959,6 @@ func (na *_Tree__Assembler) AssignNode(v ipld.Node) error { 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 @@ -7237,7 +7137,7 @@ func (nr *_Tree__Repr) LookupByNode(k ipld.Node) (ipld.Node, error) { return v.(TreeEntry).Representation(), nil } func (_Tree__Repr) LookupByIndex(idx int64) (ipld.Node, error) { - return mixins.Map{"ipldgit.Tree.Repr"}.LookupByIndex(0) + return mixins.Map{TypeName: "ipldgit.Tree.Repr"}.LookupByIndex(0) } func (n _Tree__Repr) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { return n.LookupByString(seg.String()) @@ -7272,22 +7172,22 @@ func (_Tree__Repr) IsNull() bool { return false } func (_Tree__Repr) AsBool() (bool, error) { - return mixins.Map{"ipldgit.Tree.Repr"}.AsBool() + return mixins.Map{TypeName: "ipldgit.Tree.Repr"}.AsBool() } func (_Tree__Repr) AsInt() (int64, error) { - return mixins.Map{"ipldgit.Tree.Repr"}.AsInt() + return mixins.Map{TypeName: "ipldgit.Tree.Repr"}.AsInt() } func (_Tree__Repr) AsFloat() (float64, error) { - return mixins.Map{"ipldgit.Tree.Repr"}.AsFloat() + return mixins.Map{TypeName: "ipldgit.Tree.Repr"}.AsFloat() } func (_Tree__Repr) AsString() (string, error) { - return mixins.Map{"ipldgit.Tree.Repr"}.AsString() + return mixins.Map{TypeName: "ipldgit.Tree.Repr"}.AsString() } func (_Tree__Repr) AsBytes() ([]byte, error) { - return mixins.Map{"ipldgit.Tree.Repr"}.AsBytes() + return mixins.Map{TypeName: "ipldgit.Tree.Repr"}.AsBytes() } func (_Tree__Repr) AsLink() (ipld.Link, error) { - return mixins.Map{"ipldgit.Tree.Repr"}.AsLink() + return mixins.Map{TypeName: "ipldgit.Tree.Repr"}.AsLink() } func (_Tree__Repr) Prototype() ipld.NodePrototype { return _Tree__ReprPrototype{} @@ -7343,15 +7243,12 @@ func (na *_Tree__ReprAssembler) BeginMap(sizeHint int64) (ipld.MapAssembler, err if sizeHint < 0 { sizeHint = 0 } - if na.w == nil { - na.w = &_Tree{} - } na.w.m = make(map[_String]*_TreeEntry, sizeHint) na.w.t = make([]_Tree__entry, 0, sizeHint) return na, nil } func (_Tree__ReprAssembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { - return mixins.MapAssembler{"ipldgit.Tree.Repr"}.BeginList(0) + return mixins.MapAssembler{TypeName: "ipldgit.Tree.Repr"}.BeginList(0) } func (na *_Tree__ReprAssembler) AssignNull() error { switch *na.m { @@ -7359,7 +7256,7 @@ func (na *_Tree__ReprAssembler) AssignNull() error { *na.m = schema.Maybe_Null return nil case schema.Maybe_Absent: - return mixins.MapAssembler{"ipldgit.Tree.Repr.Repr"}.AssignNull() + return mixins.MapAssembler{TypeName: "ipldgit.Tree.Repr.Repr"}.AssignNull() case schema.Maybe_Value, schema.Maybe_Null: panic("invalid state: cannot assign into assembler that's already finished") case midvalue: @@ -7368,22 +7265,22 @@ func (na *_Tree__ReprAssembler) AssignNull() error { panic("unreachable") } func (_Tree__ReprAssembler) AssignBool(bool) error { - return mixins.MapAssembler{"ipldgit.Tree.Repr"}.AssignBool(false) + return mixins.MapAssembler{TypeName: "ipldgit.Tree.Repr"}.AssignBool(false) } func (_Tree__ReprAssembler) AssignInt(int64) error { - return mixins.MapAssembler{"ipldgit.Tree.Repr"}.AssignInt(0) + return mixins.MapAssembler{TypeName: "ipldgit.Tree.Repr"}.AssignInt(0) } func (_Tree__ReprAssembler) AssignFloat(float64) error { - return mixins.MapAssembler{"ipldgit.Tree.Repr"}.AssignFloat(0) + return mixins.MapAssembler{TypeName: "ipldgit.Tree.Repr"}.AssignFloat(0) } func (_Tree__ReprAssembler) AssignString(string) error { - return mixins.MapAssembler{"ipldgit.Tree.Repr"}.AssignString("") + return mixins.MapAssembler{TypeName: "ipldgit.Tree.Repr"}.AssignString("") } func (_Tree__ReprAssembler) AssignBytes([]byte) error { - return mixins.MapAssembler{"ipldgit.Tree.Repr"}.AssignBytes(nil) + return mixins.MapAssembler{TypeName: "ipldgit.Tree.Repr"}.AssignBytes(nil) } func (_Tree__ReprAssembler) AssignLink(ipld.Link) error { - return mixins.MapAssembler{"ipldgit.Tree.Repr"}.AssignLink(nil) + return mixins.MapAssembler{TypeName: "ipldgit.Tree.Repr"}.AssignLink(nil) } func (na *_Tree__ReprAssembler) AssignNode(v ipld.Node) error { if v.IsNull() { @@ -7396,11 +7293,6 @@ func (na *_Tree__ReprAssembler) AssignNode(v ipld.Node) error { 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 @@ -7620,7 +7512,7 @@ func (n TreeEntry) LookupByNode(key ipld.Node) (ipld.Node, error) { return n.LookupByString(ks) } func (TreeEntry) LookupByIndex(idx int64) (ipld.Node, error) { - return mixins.Map{"ipldgit.TreeEntry"}.LookupByIndex(0) + return mixins.Map{TypeName: "ipldgit.TreeEntry"}.LookupByIndex(0) } func (n TreeEntry) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { return n.LookupByString(seg.String()) @@ -7668,22 +7560,22 @@ func (TreeEntry) IsNull() bool { return false } func (TreeEntry) AsBool() (bool, error) { - return mixins.Map{"ipldgit.TreeEntry"}.AsBool() + return mixins.Map{TypeName: "ipldgit.TreeEntry"}.AsBool() } func (TreeEntry) AsInt() (int64, error) { - return mixins.Map{"ipldgit.TreeEntry"}.AsInt() + return mixins.Map{TypeName: "ipldgit.TreeEntry"}.AsInt() } func (TreeEntry) AsFloat() (float64, error) { - return mixins.Map{"ipldgit.TreeEntry"}.AsFloat() + return mixins.Map{TypeName: "ipldgit.TreeEntry"}.AsFloat() } func (TreeEntry) AsString() (string, error) { - return mixins.Map{"ipldgit.TreeEntry"}.AsString() + return mixins.Map{TypeName: "ipldgit.TreeEntry"}.AsString() } func (TreeEntry) AsBytes() ([]byte, error) { - return mixins.Map{"ipldgit.TreeEntry"}.AsBytes() + return mixins.Map{TypeName: "ipldgit.TreeEntry"}.AsBytes() } func (TreeEntry) AsLink() (ipld.Link, error) { - return mixins.Map{"ipldgit.TreeEntry"}.AsLink() + return mixins.Map{TypeName: "ipldgit.TreeEntry"}.AsLink() } func (TreeEntry) Prototype() ipld.NodePrototype { return _TreeEntry__Prototype{} @@ -7752,7 +7644,7 @@ func (na *_TreeEntry__Assembler) BeginMap(int64) (ipld.MapAssembler, error) { return na, nil } func (_TreeEntry__Assembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { - return mixins.MapAssembler{"ipldgit.TreeEntry"}.BeginList(0) + return mixins.MapAssembler{TypeName: "ipldgit.TreeEntry"}.BeginList(0) } func (na *_TreeEntry__Assembler) AssignNull() error { switch *na.m { @@ -7760,7 +7652,7 @@ func (na *_TreeEntry__Assembler) AssignNull() error { *na.m = schema.Maybe_Null return nil case schema.Maybe_Absent: - return mixins.MapAssembler{"ipldgit.TreeEntry"}.AssignNull() + return mixins.MapAssembler{TypeName: "ipldgit.TreeEntry"}.AssignNull() case schema.Maybe_Value, schema.Maybe_Null: panic("invalid state: cannot assign into assembler that's already finished") case midvalue: @@ -7769,22 +7661,22 @@ func (na *_TreeEntry__Assembler) AssignNull() error { panic("unreachable") } func (_TreeEntry__Assembler) AssignBool(bool) error { - return mixins.MapAssembler{"ipldgit.TreeEntry"}.AssignBool(false) + return mixins.MapAssembler{TypeName: "ipldgit.TreeEntry"}.AssignBool(false) } func (_TreeEntry__Assembler) AssignInt(int64) error { - return mixins.MapAssembler{"ipldgit.TreeEntry"}.AssignInt(0) + return mixins.MapAssembler{TypeName: "ipldgit.TreeEntry"}.AssignInt(0) } func (_TreeEntry__Assembler) AssignFloat(float64) error { - return mixins.MapAssembler{"ipldgit.TreeEntry"}.AssignFloat(0) + return mixins.MapAssembler{TypeName: "ipldgit.TreeEntry"}.AssignFloat(0) } func (_TreeEntry__Assembler) AssignString(string) error { - return mixins.MapAssembler{"ipldgit.TreeEntry"}.AssignString("") + return mixins.MapAssembler{TypeName: "ipldgit.TreeEntry"}.AssignString("") } func (_TreeEntry__Assembler) AssignBytes([]byte) error { - return mixins.MapAssembler{"ipldgit.TreeEntry"}.AssignBytes(nil) + return mixins.MapAssembler{TypeName: "ipldgit.TreeEntry"}.AssignBytes(nil) } func (_TreeEntry__Assembler) AssignLink(ipld.Link) error { - return mixins.MapAssembler{"ipldgit.TreeEntry"}.AssignLink(nil) + return mixins.MapAssembler{TypeName: "ipldgit.TreeEntry"}.AssignLink(nil) } func (na *_TreeEntry__Assembler) AssignNode(v ipld.Node) error { if v.IsNull() { @@ -7976,22 +7868,22 @@ func (ma *_TreeEntry__Assembler) ValuePrototype(k string) ipld.NodePrototype { type _TreeEntry__KeyAssembler _TreeEntry__Assembler func (_TreeEntry__KeyAssembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { - return mixins.StringAssembler{"ipldgit.TreeEntry.KeyAssembler"}.BeginMap(0) + return mixins.StringAssembler{TypeName: "ipldgit.TreeEntry.KeyAssembler"}.BeginMap(0) } func (_TreeEntry__KeyAssembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { - return mixins.StringAssembler{"ipldgit.TreeEntry.KeyAssembler"}.BeginList(0) + return mixins.StringAssembler{TypeName: "ipldgit.TreeEntry.KeyAssembler"}.BeginList(0) } func (na *_TreeEntry__KeyAssembler) AssignNull() error { - return mixins.StringAssembler{"ipldgit.TreeEntry.KeyAssembler"}.AssignNull() + return mixins.StringAssembler{TypeName: "ipldgit.TreeEntry.KeyAssembler"}.AssignNull() } func (_TreeEntry__KeyAssembler) AssignBool(bool) error { - return mixins.StringAssembler{"ipldgit.TreeEntry.KeyAssembler"}.AssignBool(false) + return mixins.StringAssembler{TypeName: "ipldgit.TreeEntry.KeyAssembler"}.AssignBool(false) } func (_TreeEntry__KeyAssembler) AssignInt(int64) error { - return mixins.StringAssembler{"ipldgit.TreeEntry.KeyAssembler"}.AssignInt(0) + return mixins.StringAssembler{TypeName: "ipldgit.TreeEntry.KeyAssembler"}.AssignInt(0) } func (_TreeEntry__KeyAssembler) AssignFloat(float64) error { - return mixins.StringAssembler{"ipldgit.TreeEntry.KeyAssembler"}.AssignFloat(0) + return mixins.StringAssembler{TypeName: "ipldgit.TreeEntry.KeyAssembler"}.AssignFloat(0) } func (ka *_TreeEntry__KeyAssembler) AssignString(k string) error { if ka.state != maState_midKey { @@ -8018,10 +7910,10 @@ func (ka *_TreeEntry__KeyAssembler) AssignString(k string) error { return nil } func (_TreeEntry__KeyAssembler) AssignBytes([]byte) error { - return mixins.StringAssembler{"ipldgit.TreeEntry.KeyAssembler"}.AssignBytes(nil) + return mixins.StringAssembler{TypeName: "ipldgit.TreeEntry.KeyAssembler"}.AssignBytes(nil) } func (_TreeEntry__KeyAssembler) AssignLink(ipld.Link) error { - return mixins.StringAssembler{"ipldgit.TreeEntry.KeyAssembler"}.AssignLink(nil) + return mixins.StringAssembler{TypeName: "ipldgit.TreeEntry.KeyAssembler"}.AssignLink(nil) } func (ka *_TreeEntry__KeyAssembler) AssignNode(v ipld.Node) error { if v2, err := v.AsString(); err != nil { @@ -8069,7 +7961,7 @@ func (n *_TreeEntry__Repr) LookupByNode(key ipld.Node) (ipld.Node, error) { return n.LookupByString(ks) } func (_TreeEntry__Repr) LookupByIndex(idx int64) (ipld.Node, error) { - return mixins.Map{"ipldgit.TreeEntry.Repr"}.LookupByIndex(0) + return mixins.Map{TypeName: "ipldgit.TreeEntry.Repr"}.LookupByIndex(0) } func (n _TreeEntry__Repr) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { return n.LookupByString(seg.String()) @@ -8117,22 +8009,22 @@ func (_TreeEntry__Repr) IsNull() bool { return false } func (_TreeEntry__Repr) AsBool() (bool, error) { - return mixins.Map{"ipldgit.TreeEntry.Repr"}.AsBool() + return mixins.Map{TypeName: "ipldgit.TreeEntry.Repr"}.AsBool() } func (_TreeEntry__Repr) AsInt() (int64, error) { - return mixins.Map{"ipldgit.TreeEntry.Repr"}.AsInt() + return mixins.Map{TypeName: "ipldgit.TreeEntry.Repr"}.AsInt() } func (_TreeEntry__Repr) AsFloat() (float64, error) { - return mixins.Map{"ipldgit.TreeEntry.Repr"}.AsFloat() + return mixins.Map{TypeName: "ipldgit.TreeEntry.Repr"}.AsFloat() } func (_TreeEntry__Repr) AsString() (string, error) { - return mixins.Map{"ipldgit.TreeEntry.Repr"}.AsString() + return mixins.Map{TypeName: "ipldgit.TreeEntry.Repr"}.AsString() } func (_TreeEntry__Repr) AsBytes() ([]byte, error) { - return mixins.Map{"ipldgit.TreeEntry.Repr"}.AsBytes() + return mixins.Map{TypeName: "ipldgit.TreeEntry.Repr"}.AsBytes() } func (_TreeEntry__Repr) AsLink() (ipld.Link, error) { - return mixins.Map{"ipldgit.TreeEntry.Repr"}.AsLink() + return mixins.Map{TypeName: "ipldgit.TreeEntry.Repr"}.AsLink() } func (_TreeEntry__Repr) Prototype() ipld.NodePrototype { return _TreeEntry__ReprPrototype{} @@ -8194,7 +8086,7 @@ func (na *_TreeEntry__ReprAssembler) BeginMap(int64) (ipld.MapAssembler, error) return na, nil } func (_TreeEntry__ReprAssembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { - return mixins.MapAssembler{"ipldgit.TreeEntry.Repr"}.BeginList(0) + return mixins.MapAssembler{TypeName: "ipldgit.TreeEntry.Repr"}.BeginList(0) } func (na *_TreeEntry__ReprAssembler) AssignNull() error { switch *na.m { @@ -8202,7 +8094,7 @@ func (na *_TreeEntry__ReprAssembler) AssignNull() error { *na.m = schema.Maybe_Null return nil case schema.Maybe_Absent: - return mixins.MapAssembler{"ipldgit.TreeEntry.Repr.Repr"}.AssignNull() + return mixins.MapAssembler{TypeName: "ipldgit.TreeEntry.Repr.Repr"}.AssignNull() case schema.Maybe_Value, schema.Maybe_Null: panic("invalid state: cannot assign into assembler that's already finished") case midvalue: @@ -8211,22 +8103,22 @@ func (na *_TreeEntry__ReprAssembler) AssignNull() error { panic("unreachable") } func (_TreeEntry__ReprAssembler) AssignBool(bool) error { - return mixins.MapAssembler{"ipldgit.TreeEntry.Repr"}.AssignBool(false) + return mixins.MapAssembler{TypeName: "ipldgit.TreeEntry.Repr"}.AssignBool(false) } func (_TreeEntry__ReprAssembler) AssignInt(int64) error { - return mixins.MapAssembler{"ipldgit.TreeEntry.Repr"}.AssignInt(0) + return mixins.MapAssembler{TypeName: "ipldgit.TreeEntry.Repr"}.AssignInt(0) } func (_TreeEntry__ReprAssembler) AssignFloat(float64) error { - return mixins.MapAssembler{"ipldgit.TreeEntry.Repr"}.AssignFloat(0) + return mixins.MapAssembler{TypeName: "ipldgit.TreeEntry.Repr"}.AssignFloat(0) } func (_TreeEntry__ReprAssembler) AssignString(string) error { - return mixins.MapAssembler{"ipldgit.TreeEntry.Repr"}.AssignString("") + return mixins.MapAssembler{TypeName: "ipldgit.TreeEntry.Repr"}.AssignString("") } func (_TreeEntry__ReprAssembler) AssignBytes([]byte) error { - return mixins.MapAssembler{"ipldgit.TreeEntry.Repr"}.AssignBytes(nil) + return mixins.MapAssembler{TypeName: "ipldgit.TreeEntry.Repr"}.AssignBytes(nil) } func (_TreeEntry__ReprAssembler) AssignLink(ipld.Link) error { - return mixins.MapAssembler{"ipldgit.TreeEntry.Repr"}.AssignLink(nil) + return mixins.MapAssembler{TypeName: "ipldgit.TreeEntry.Repr"}.AssignLink(nil) } func (na *_TreeEntry__ReprAssembler) AssignNode(v ipld.Node) error { if v.IsNull() { @@ -8417,22 +8309,22 @@ func (ma *_TreeEntry__ReprAssembler) ValuePrototype(k string) ipld.NodePrototype type _TreeEntry__ReprKeyAssembler _TreeEntry__ReprAssembler func (_TreeEntry__ReprKeyAssembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { - return mixins.StringAssembler{"ipldgit.TreeEntry.Repr.KeyAssembler"}.BeginMap(0) + return mixins.StringAssembler{TypeName: "ipldgit.TreeEntry.Repr.KeyAssembler"}.BeginMap(0) } func (_TreeEntry__ReprKeyAssembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { - return mixins.StringAssembler{"ipldgit.TreeEntry.Repr.KeyAssembler"}.BeginList(0) + return mixins.StringAssembler{TypeName: "ipldgit.TreeEntry.Repr.KeyAssembler"}.BeginList(0) } func (na *_TreeEntry__ReprKeyAssembler) AssignNull() error { - return mixins.StringAssembler{"ipldgit.TreeEntry.Repr.KeyAssembler"}.AssignNull() + return mixins.StringAssembler{TypeName: "ipldgit.TreeEntry.Repr.KeyAssembler"}.AssignNull() } func (_TreeEntry__ReprKeyAssembler) AssignBool(bool) error { - return mixins.StringAssembler{"ipldgit.TreeEntry.Repr.KeyAssembler"}.AssignBool(false) + return mixins.StringAssembler{TypeName: "ipldgit.TreeEntry.Repr.KeyAssembler"}.AssignBool(false) } func (_TreeEntry__ReprKeyAssembler) AssignInt(int64) error { - return mixins.StringAssembler{"ipldgit.TreeEntry.Repr.KeyAssembler"}.AssignInt(0) + return mixins.StringAssembler{TypeName: "ipldgit.TreeEntry.Repr.KeyAssembler"}.AssignInt(0) } func (_TreeEntry__ReprKeyAssembler) AssignFloat(float64) error { - return mixins.StringAssembler{"ipldgit.TreeEntry.Repr.KeyAssembler"}.AssignFloat(0) + return mixins.StringAssembler{TypeName: "ipldgit.TreeEntry.Repr.KeyAssembler"}.AssignFloat(0) } func (ka *_TreeEntry__ReprKeyAssembler) AssignString(k string) error { if ka.state != maState_midKey { @@ -8459,10 +8351,10 @@ func (ka *_TreeEntry__ReprKeyAssembler) AssignString(k string) error { return ipld.ErrInvalidKey{TypeName: "ipldgit.TreeEntry.Repr", Key: &_String{k}} } func (_TreeEntry__ReprKeyAssembler) AssignBytes([]byte) error { - return mixins.StringAssembler{"ipldgit.TreeEntry.Repr.KeyAssembler"}.AssignBytes(nil) + return mixins.StringAssembler{TypeName: "ipldgit.TreeEntry.Repr.KeyAssembler"}.AssignBytes(nil) } func (_TreeEntry__ReprKeyAssembler) AssignLink(ipld.Link) error { - return mixins.StringAssembler{"ipldgit.TreeEntry.Repr.KeyAssembler"}.AssignLink(nil) + return mixins.StringAssembler{TypeName: "ipldgit.TreeEntry.Repr.KeyAssembler"}.AssignLink(nil) } func (ka *_TreeEntry__ReprKeyAssembler) AssignNode(v ipld.Node) error { if v2, err := v.AsString(); err != nil { diff --git a/unmarshal.go b/unmarshal.go index eca92a3..cb8d37c 100644 --- a/unmarshal.go +++ b/unmarshal.go @@ -60,7 +60,7 @@ func ParseObject(r io.Reader) (ipld.Node, error) { default: return nil, fmt.Errorf("unrecognized object type: %s", typ) } - fmt.Printf("type %s\n", typ) + // fmt.Printf("type %s\n", typ) if err := decode(na, rd); err != nil { return nil, err From 91ee580ecafb3ef032a9642bf7b8401d9962b104 Mon Sep 17 00:00:00 2001 From: Rod Vagg Date: Thu, 29 Jul 2021 12:21:19 +1000 Subject: [PATCH 15/22] chore: update go-ipld-prime, re-gen, fix staticcheck flags --- git_test.go | 2 +- go.mod | 2 +- go.sum | 4 ++-- ipldsch_satisfaction.go | 24 ++++++++++++++++++++---- tag.go | 2 +- 5 files changed, 25 insertions(+), 9 deletions(-) diff --git a/git_test.go b/git_test.go index 83e0e17..d608791 100644 --- a/git_test.go +++ b/git_test.go @@ -167,7 +167,7 @@ func TestArchiveObjectParse(t *testing.T) { fmt.Println("vvvvvv") buf := bytes.NewBuffer([]byte{}) Encode(thing, buf) - fmt.Println(string(buf.Bytes())) + fmt.Println(buf.String()) fmt.Println("^^^^^^") t.Fatal("mismatch!") } diff --git a/go.mod b/go.mod index f9cfce8..348bf95 100644 --- a/go.mod +++ b/go.mod @@ -5,6 +5,6 @@ go 1.15 require ( github.com/ipfs/go-block-format v0.0.3 github.com/ipfs/go-cid v0.0.7 - github.com/ipld/go-ipld-prime v0.10.1-0.20210723093545-ebe39c7bab39 + github.com/ipld/go-ipld-prime v0.10.1-0.20210729021320-145d8235e5de github.com/multiformats/go-multihash v0.0.15 ) diff --git a/go.sum b/go.sum index 38fde86..798a095 100644 --- a/go.sum +++ b/go.sum @@ -11,8 +11,8 @@ 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/ipfs/go-ipfs-util v0.0.2 h1:59Sswnk1MFaiq+VcaknX7aYEyGyGDAA73ilhEK2POp8= github.com/ipfs/go-ipfs-util v0.0.2/go.mod h1:CbPtkWJzjLdEcezDns2XYaehFVNXG9zrdrtMecczcsQ= -github.com/ipld/go-ipld-prime v0.10.1-0.20210723093545-ebe39c7bab39 h1:70/42k1tU7ZHuyjFDd7vbd6dgnMyFnC0fe8LKeF9ZPg= -github.com/ipld/go-ipld-prime v0.10.1-0.20210723093545-ebe39c7bab39/go.mod h1:KvBLMr4PX1gWptgkzRjVZCrLmSGcZCb/jioOQwCqZN8= +github.com/ipld/go-ipld-prime v0.10.1-0.20210729021320-145d8235e5de h1:ywbFKcs58Qbb+SNoSG3b0ZfTSXLUkZmyJDy9Dg33KHU= +github.com/ipld/go-ipld-prime v0.10.1-0.20210729021320-145d8235e5de/go.mod h1:KvBLMr4PX1gWptgkzRjVZCrLmSGcZCb/jioOQwCqZN8= 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/klauspost/cpuid/v2 v2.0.4 h1:g0I61F2K2DjRHz1cnxlkNSBIaePVoJIjjnHui8QHbiw= diff --git a/ipldsch_satisfaction.go b/ipldsch_satisfaction.go index 91cd843..9fd1133 100644 --- a/ipldsch_satisfaction.go +++ b/ipldsch_satisfaction.go @@ -950,6 +950,7 @@ func (ka *_Commit__KeyAssembler) AssignString(k string) error { ka.s += fieldBit__Commit_Tree ka.state = maState_expectValue ka.f = 0 + return nil case "parents": if ka.s&fieldBit__Commit_Parents != 0 { return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Parents} @@ -957,6 +958,7 @@ func (ka *_Commit__KeyAssembler) AssignString(k string) error { ka.s += fieldBit__Commit_Parents ka.state = maState_expectValue ka.f = 1 + return nil case "message": if ka.s&fieldBit__Commit_Message != 0 { return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Message} @@ -964,6 +966,7 @@ func (ka *_Commit__KeyAssembler) AssignString(k string) error { ka.s += fieldBit__Commit_Message ka.state = maState_expectValue ka.f = 2 + return nil case "author": if ka.s&fieldBit__Commit_Author != 0 { return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Author} @@ -971,6 +974,7 @@ func (ka *_Commit__KeyAssembler) AssignString(k string) error { ka.s += fieldBit__Commit_Author ka.state = maState_expectValue ka.f = 3 + return nil case "committer": if ka.s&fieldBit__Commit_Committer != 0 { return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Committer} @@ -978,6 +982,7 @@ func (ka *_Commit__KeyAssembler) AssignString(k string) error { ka.s += fieldBit__Commit_Committer ka.state = maState_expectValue ka.f = 4 + return nil case "encoding": if ka.s&fieldBit__Commit_Encoding != 0 { return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Encoding} @@ -985,6 +990,7 @@ func (ka *_Commit__KeyAssembler) AssignString(k string) error { ka.s += fieldBit__Commit_Encoding ka.state = maState_expectValue ka.f = 5 + return nil case "signature": if ka.s&fieldBit__Commit_Signature != 0 { return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Signature} @@ -992,6 +998,7 @@ func (ka *_Commit__KeyAssembler) AssignString(k string) error { ka.s += fieldBit__Commit_Signature ka.state = maState_expectValue ka.f = 6 + return nil case "mergeTag": if ka.s&fieldBit__Commit_MergeTag != 0 { return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_MergeTag} @@ -999,6 +1006,7 @@ func (ka *_Commit__KeyAssembler) AssignString(k string) error { ka.s += fieldBit__Commit_MergeTag ka.state = maState_expectValue ka.f = 7 + return nil case "other": if ka.s&fieldBit__Commit_Other != 0 { return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Other} @@ -1006,10 +1014,10 @@ func (ka *_Commit__KeyAssembler) AssignString(k string) error { ka.s += fieldBit__Commit_Other ka.state = maState_expectValue ka.f = 8 + return nil default: return ipld.ErrInvalidKey{TypeName: "ipldgit.Commit", Key: &_String{k}} } - return nil } func (_Commit__KeyAssembler) AssignBytes([]byte) error { return mixins.StringAssembler{TypeName: "ipldgit.Commit.KeyAssembler"}.AssignBytes(nil) @@ -4725,6 +4733,7 @@ func (ka *_PersonInfo__KeyAssembler) AssignString(k string) error { ka.s += fieldBit__PersonInfo_Name ka.state = maState_expectValue ka.f = 0 + return nil case "email": if ka.s&fieldBit__PersonInfo_Email != 0 { return ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Email} @@ -4732,6 +4741,7 @@ func (ka *_PersonInfo__KeyAssembler) AssignString(k string) error { ka.s += fieldBit__PersonInfo_Email ka.state = maState_expectValue ka.f = 1 + return nil case "date": if ka.s&fieldBit__PersonInfo_Date != 0 { return ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Date} @@ -4739,6 +4749,7 @@ func (ka *_PersonInfo__KeyAssembler) AssignString(k string) error { ka.s += fieldBit__PersonInfo_Date ka.state = maState_expectValue ka.f = 2 + return nil case "timezone": if ka.s&fieldBit__PersonInfo_Timezone != 0 { return ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Timezone} @@ -4746,10 +4757,10 @@ func (ka *_PersonInfo__KeyAssembler) AssignString(k string) error { ka.s += fieldBit__PersonInfo_Timezone ka.state = maState_expectValue ka.f = 3 + return nil default: return ipld.ErrInvalidKey{TypeName: "ipldgit.PersonInfo", Key: &_String{k}} } - return nil } func (_PersonInfo__KeyAssembler) AssignBytes([]byte) error { return mixins.StringAssembler{TypeName: "ipldgit.PersonInfo.KeyAssembler"}.AssignBytes(nil) @@ -6073,6 +6084,7 @@ func (ka *_Tag__KeyAssembler) AssignString(k string) error { ka.s += fieldBit__Tag_Object ka.state = maState_expectValue ka.f = 0 + return nil case "tagType": if ka.s&fieldBit__Tag_TagType != 0 { return ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_TagType} @@ -6080,6 +6092,7 @@ func (ka *_Tag__KeyAssembler) AssignString(k string) error { ka.s += fieldBit__Tag_TagType ka.state = maState_expectValue ka.f = 1 + return nil case "tag": if ka.s&fieldBit__Tag_Tag != 0 { return ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Tag} @@ -6087,6 +6100,7 @@ func (ka *_Tag__KeyAssembler) AssignString(k string) error { ka.s += fieldBit__Tag_Tag ka.state = maState_expectValue ka.f = 2 + return nil case "tagger": if ka.s&fieldBit__Tag_Tagger != 0 { return ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Tagger} @@ -6094,6 +6108,7 @@ func (ka *_Tag__KeyAssembler) AssignString(k string) error { ka.s += fieldBit__Tag_Tagger ka.state = maState_expectValue ka.f = 3 + return nil case "text": if ka.s&fieldBit__Tag_Text != 0 { return ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Text} @@ -6101,10 +6116,10 @@ func (ka *_Tag__KeyAssembler) AssignString(k string) error { ka.s += fieldBit__Tag_Text ka.state = maState_expectValue ka.f = 4 + return nil default: return ipld.ErrInvalidKey{TypeName: "ipldgit.Tag", Key: &_String{k}} } - return nil } func (_Tag__KeyAssembler) AssignBytes([]byte) error { return mixins.StringAssembler{TypeName: "ipldgit.Tag.KeyAssembler"}.AssignBytes(nil) @@ -7897,6 +7912,7 @@ func (ka *_TreeEntry__KeyAssembler) AssignString(k string) error { ka.s += fieldBit__TreeEntry_Mode ka.state = maState_expectValue ka.f = 0 + return nil case "hash": if ka.s&fieldBit__TreeEntry_Hash != 0 { return ipld.ErrRepeatedMapKey{Key: &fieldName__TreeEntry_Hash} @@ -7904,10 +7920,10 @@ func (ka *_TreeEntry__KeyAssembler) AssignString(k string) error { ka.s += fieldBit__TreeEntry_Hash ka.state = maState_expectValue ka.f = 1 + return nil default: return ipld.ErrInvalidKey{TypeName: "ipldgit.TreeEntry", Key: &_String{k}} } - return nil } func (_TreeEntry__KeyAssembler) AssignBytes([]byte) error { return mixins.StringAssembler{TypeName: "ipldgit.TreeEntry.KeyAssembler"}.AssignBytes(nil) diff --git a/tag.go b/tag.go index 9c88ce7..d38d5ed 100644 --- a/tag.go +++ b/tag.go @@ -162,7 +162,7 @@ func encodeTag(n ipld.Node, w io.Writer) error { piN := pi.Build() parsed, ok := piN.(*_PersonInfo) if !ok { - return fmt.Errorf("Could not parse tagger person info %v", tagger) + return fmt.Errorf("could not parse tagger person info %v", tagger) } fmt.Fprintf(buf, "tagger %s\n", parsed.GitString()) } From a3ace0d150a2821863696d800ee8539c1ff5b082 Mon Sep 17 00:00:00 2001 From: Rod Vagg Date: Thu, 29 Jul 2021 12:30:34 +1000 Subject: [PATCH 16/22] feat: type Parents links --- commit.go | 4 +- gen/gen.go | 3 +- ipldsch_satisfaction.go | 240 +++++++++++++++++++++++++++++++++++++--- ipldsch_types.go | 8 +- util.go | 8 ++ 5 files changed, 243 insertions(+), 20 deletions(-) diff --git a/commit.go b/commit.go index 13c432b..c78a235 100644 --- a/commit.go +++ b/commit.go @@ -23,7 +23,7 @@ func DecodeCommit(na ipld.NodeAssembler, rd *bufio.Reader) error { } c := _Commit{ - parents: _ListParents{[]_Link{}}, + parents: _ListParents{[]_LinkCommit{}}, mergeTag: _ListTag{[]_Tag{}}, other: _ListString{[]_String{}}, } @@ -60,7 +60,7 @@ func decodeCommitLine(c Commit, line []byte, rd *bufio.Reader) error { return err } - c.parents.x = append(c.parents.x, _Link{cidlink.Link{Cid: shaToCid(psha)}}) + c.parents.x = append(c.parents.x, _LinkCommit{cidlink.Link{Cid: shaToCid(psha)}}) case bytes.HasPrefix(line, []byte("author ")): a, err := parsePersonInfo(line) if err != nil { diff --git a/gen/gen.go b/gen/gen.go index 04cec8d..d525d4c 100644 --- a/gen/gen.go +++ b/gen/gen.go @@ -32,7 +32,8 @@ func main() { schema.SpawnStructField("text", "String", false, false), }, schema.SpawnStructRepresentationMap(map[string]string{}))) ts.Accumulate(schema.SpawnList("ListTag", "Tag", false)) - ts.Accumulate(schema.SpawnList("ListParents", "Link", false)) //Todo: type 'Parents' links + ts.Accumulate(schema.SpawnLinkReference("LinkCommit", "Commit")) + ts.Accumulate(schema.SpawnList("ListParents", "LinkCommit", false)) ts.Accumulate(schema.SpawnStruct("Commit", []schema.StructField{ schema.SpawnStructField("tree", "LinkTree", false, false), schema.SpawnStructField("parents", "ListParents", false, false), diff --git a/ipldsch_satisfaction.go b/ipldsch_satisfaction.go index 9fd1133..7c326bd 100644 --- a/ipldsch_satisfaction.go +++ b/ipldsch_satisfaction.go @@ -2220,6 +2220,214 @@ var _ ipld.Node = &_Link__Repr{} type _Link__ReprPrototype = _Link__Prototype type _Link__ReprAssembler = _Link__Assembler +func (n LinkCommit) Link() ipld.Link { + return n.x +} +func (_LinkCommit__Prototype) FromLink(v ipld.Link) (LinkCommit, error) { + n := _LinkCommit{v} + return &n, nil +} + +type _LinkCommit__Maybe struct { + m schema.Maybe + v _LinkCommit +} +type MaybeLinkCommit = *_LinkCommit__Maybe + +func (m MaybeLinkCommit) IsNull() bool { + return m.m == schema.Maybe_Null +} +func (m MaybeLinkCommit) IsAbsent() bool { + return m.m == schema.Maybe_Absent +} +func (m MaybeLinkCommit) Exists() bool { + return m.m == schema.Maybe_Value +} +func (m MaybeLinkCommit) 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 MaybeLinkCommit) Must() LinkCommit { + if !m.Exists() { + panic("unbox of a maybe rejected") + } + return &m.v +} + +var _ ipld.Node = (LinkCommit)(&_LinkCommit{}) +var _ schema.TypedNode = (LinkCommit)(&_LinkCommit{}) + +func (LinkCommit) Kind() ipld.Kind { + return ipld.Kind_Link +} +func (LinkCommit) LookupByString(string) (ipld.Node, error) { + return mixins.Link{TypeName: "ipldgit.LinkCommit"}.LookupByString("") +} +func (LinkCommit) LookupByNode(ipld.Node) (ipld.Node, error) { + return mixins.Link{TypeName: "ipldgit.LinkCommit"}.LookupByNode(nil) +} +func (LinkCommit) LookupByIndex(idx int64) (ipld.Node, error) { + return mixins.Link{TypeName: "ipldgit.LinkCommit"}.LookupByIndex(0) +} +func (LinkCommit) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { + return mixins.Link{TypeName: "ipldgit.LinkCommit"}.LookupBySegment(seg) +} +func (LinkCommit) MapIterator() ipld.MapIterator { + return nil +} +func (LinkCommit) ListIterator() ipld.ListIterator { + return nil +} +func (LinkCommit) Length() int64 { + return -1 +} +func (LinkCommit) IsAbsent() bool { + return false +} +func (LinkCommit) IsNull() bool { + return false +} +func (LinkCommit) AsBool() (bool, error) { + return mixins.Link{TypeName: "ipldgit.LinkCommit"}.AsBool() +} +func (LinkCommit) AsInt() (int64, error) { + return mixins.Link{TypeName: "ipldgit.LinkCommit"}.AsInt() +} +func (LinkCommit) AsFloat() (float64, error) { + return mixins.Link{TypeName: "ipldgit.LinkCommit"}.AsFloat() +} +func (LinkCommit) AsString() (string, error) { + return mixins.Link{TypeName: "ipldgit.LinkCommit"}.AsString() +} +func (LinkCommit) AsBytes() ([]byte, error) { + return mixins.Link{TypeName: "ipldgit.LinkCommit"}.AsBytes() +} +func (n LinkCommit) AsLink() (ipld.Link, error) { + return n.x, nil +} +func (LinkCommit) Prototype() ipld.NodePrototype { + return _LinkCommit__Prototype{} +} + +type _LinkCommit__Prototype struct{} + +func (_LinkCommit__Prototype) NewBuilder() ipld.NodeBuilder { + var nb _LinkCommit__Builder + nb.Reset() + return &nb +} + +type _LinkCommit__Builder struct { + _LinkCommit__Assembler +} + +func (nb *_LinkCommit__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 *_LinkCommit__Builder) Reset() { + var w _LinkCommit + var m schema.Maybe + *nb = _LinkCommit__Builder{_LinkCommit__Assembler{w: &w, m: &m}} +} + +type _LinkCommit__Assembler struct { + w *_LinkCommit + m *schema.Maybe +} + +func (na *_LinkCommit__Assembler) reset() {} +func (_LinkCommit__Assembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { + return mixins.LinkAssembler{TypeName: "ipldgit.LinkCommit"}.BeginMap(0) +} +func (_LinkCommit__Assembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { + return mixins.LinkAssembler{TypeName: "ipldgit.LinkCommit"}.BeginList(0) +} +func (na *_LinkCommit__Assembler) AssignNull() error { + switch *na.m { + case allowNull: + *na.m = schema.Maybe_Null + return nil + case schema.Maybe_Absent: + return mixins.LinkAssembler{TypeName: "ipldgit.LinkCommit"}.AssignNull() + case schema.Maybe_Value, schema.Maybe_Null: + panic("invalid state: cannot assign into assembler that's already finished") + } + panic("unreachable") +} +func (_LinkCommit__Assembler) AssignBool(bool) error { + return mixins.LinkAssembler{TypeName: "ipldgit.LinkCommit"}.AssignBool(false) +} +func (_LinkCommit__Assembler) AssignInt(int64) error { + return mixins.LinkAssembler{TypeName: "ipldgit.LinkCommit"}.AssignInt(0) +} +func (_LinkCommit__Assembler) AssignFloat(float64) error { + return mixins.LinkAssembler{TypeName: "ipldgit.LinkCommit"}.AssignFloat(0) +} +func (_LinkCommit__Assembler) AssignString(string) error { + return mixins.LinkAssembler{TypeName: "ipldgit.LinkCommit"}.AssignString("") +} +func (_LinkCommit__Assembler) AssignBytes([]byte) error { + return mixins.LinkAssembler{TypeName: "ipldgit.LinkCommit"}.AssignBytes(nil) +} +func (na *_LinkCommit__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") + } + na.w.x = v + *na.m = schema.Maybe_Value + return nil +} +func (na *_LinkCommit__Assembler) AssignNode(v ipld.Node) error { + if v.IsNull() { + return na.AssignNull() + } + if v2, ok := v.(*_LinkCommit); ok { + switch *na.m { + case schema.Maybe_Value, schema.Maybe_Null: + panic("invalid state: cannot assign into assembler that's already finished") + } + *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 (_LinkCommit__Assembler) Prototype() ipld.NodePrototype { + return _LinkCommit__Prototype{} +} +func (LinkCommit) Type() schema.Type { + return nil /*TODO:typelit*/ +} +func (LinkCommit) LinkTargetNodePrototype() ipld.NodePrototype { + return Type.Commit__Repr +} +func (n LinkCommit) Representation() ipld.Node { + return (*_LinkCommit__Repr)(n) +} + +type _LinkCommit__Repr = _LinkCommit + +var _ ipld.Node = &_LinkCommit__Repr{} + +type _LinkCommit__ReprPrototype = _LinkCommit__Prototype +type _LinkCommit__ReprAssembler = _LinkCommit__Assembler + func (n LinkTree) Link() ipld.Link { return n.x } @@ -2428,25 +2636,25 @@ var _ ipld.Node = &_LinkTree__Repr{} type _LinkTree__ReprPrototype = _LinkTree__Prototype type _LinkTree__ReprAssembler = _LinkTree__Assembler -func (n *_ListParents) Lookup(idx int64) Link { +func (n *_ListParents) Lookup(idx int64) LinkCommit { if n.Length() <= idx { return nil } v := &n.x[idx] return v } -func (n *_ListParents) LookupMaybe(idx int64) MaybeLink { +func (n *_ListParents) LookupMaybe(idx int64) MaybeLinkCommit { if n.Length() <= idx { return nil } v := &n.x[idx] - return &_Link__Maybe{ + return &_LinkCommit__Maybe{ m: schema.Maybe_Value, v: *v, } } -var _ListParents__valueAbsent = _Link__Maybe{m: schema.Maybe_Absent} +var _ListParents__valueAbsent = _LinkCommit__Maybe{m: schema.Maybe_Absent} func (n ListParents) Iterator() *ListParents__Itr { return &ListParents__Itr{n, 0} @@ -2457,7 +2665,7 @@ type ListParents__Itr struct { idx int } -func (itr *ListParents__Itr) Next() (idx int64, v Link) { +func (itr *ListParents__Itr) Next() (idx int64, v LinkCommit) { if itr.idx >= len(itr.n.x) { return -1, nil } @@ -2621,7 +2829,7 @@ type _ListParents__Assembler struct { state laState cm schema.Maybe - va _Link__Assembler + va _LinkCommit__Assembler } func (na *_ListParents__Assembler) reset() { @@ -2643,7 +2851,7 @@ func (na *_ListParents__Assembler) BeginList(sizeHint int64) (ipld.ListAssembler sizeHint = 0 } if sizeHint > 0 { - na.w.x = make([]_Link, 0, sizeHint) + na.w.x = make([]_LinkCommit, 0, sizeHint) } return na, nil } @@ -2735,7 +2943,7 @@ func (la *_ListParents__Assembler) AssembleValue() ipld.NodeAssembler { case laState_finished: panic("invalid state: AssembleValue cannot be called on an assembler that's already finished") } - la.w.x = append(la.w.x, _Link{}) + la.w.x = append(la.w.x, _LinkCommit{}) la.state = laState_midValue row := &la.w.x[len(la.w.x)-1] la.va.w = row @@ -2758,7 +2966,7 @@ func (la *_ListParents__Assembler) Finish() error { return nil } func (la *_ListParents__Assembler) ValuePrototype(_ int64) ipld.NodePrototype { - return _Link__Prototype{} + return _LinkCommit__Prototype{} } func (ListParents) Type() schema.Type { return nil /*TODO:typelit*/ @@ -2782,14 +2990,14 @@ func (nr *_ListParents__Repr) LookupByNode(k ipld.Node) (ipld.Node, error) { if err != nil || v == ipld.Null { return v, err } - return v.(Link).Representation(), nil + return v.(LinkCommit).Representation(), nil } func (nr *_ListParents__Repr) LookupByIndex(idx int64) (ipld.Node, error) { v, err := (ListParents)(nr).LookupByIndex(idx) if err != nil || v == ipld.Null { return v, err } - return v.(Link).Representation(), nil + return v.(LinkCommit).Representation(), nil } func (n _ListParents__Repr) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { i, err := seg.Index() @@ -2812,7 +3020,7 @@ func (itr *_ListParents__ReprListItr) Next() (idx int64, v ipld.Node, err error) if err != nil || v == ipld.Null { return } - return idx, v.(Link).Representation(), nil + return idx, v.(LinkCommit).Representation(), nil } func (itr *_ListParents__ReprListItr) Done() bool { return (*_ListParents__ListItr)(itr).Done() @@ -2879,7 +3087,7 @@ type _ListParents__ReprAssembler struct { state laState cm schema.Maybe - va _Link__ReprAssembler + va _LinkCommit__ReprAssembler } func (na *_ListParents__ReprAssembler) reset() { @@ -2901,7 +3109,7 @@ func (na *_ListParents__ReprAssembler) BeginList(sizeHint int64) (ipld.ListAssem sizeHint = 0 } if sizeHint > 0 { - na.w.x = make([]_Link, 0, sizeHint) + na.w.x = make([]_LinkCommit, 0, sizeHint) } return na, nil } @@ -2993,7 +3201,7 @@ func (la *_ListParents__ReprAssembler) AssembleValue() ipld.NodeAssembler { case laState_finished: panic("invalid state: AssembleValue cannot be called on an assembler that's already finished") } - la.w.x = append(la.w.x, _Link{}) + la.w.x = append(la.w.x, _LinkCommit{}) la.state = laState_midValue row := &la.w.x[len(la.w.x)-1] la.va.w = row @@ -3016,7 +3224,7 @@ func (la *_ListParents__ReprAssembler) Finish() error { return nil } func (la *_ListParents__ReprAssembler) ValuePrototype(_ int64) ipld.NodePrototype { - return _Link__ReprPrototype{} + return _LinkCommit__ReprPrototype{} } func (n *_ListString) Lookup(idx int64) String { diff --git a/ipldsch_types.go b/ipldsch_types.go index 77ef630..683a8e0 100644 --- a/ipldsch_types.go +++ b/ipldsch_types.go @@ -28,6 +28,8 @@ type typeSlab struct { GpgSig__Repr _GpgSig__ReprPrototype Link _Link__Prototype Link__Repr _Link__ReprPrototype + LinkCommit _LinkCommit__Prototype + LinkCommit__Repr _LinkCommit__ReprPrototype LinkTree _LinkTree__Prototype LinkTree__Repr _LinkTree__ReprPrototype ListParents _ListParents__Prototype @@ -76,6 +78,10 @@ type _GpgSig struct{ x string } type Link = *_Link type _Link struct{ x ipld.Link } +// LinkCommit matches the IPLD Schema type "LinkCommit". It has link kind. +type LinkCommit = *_LinkCommit +type _LinkCommit struct{ x ipld.Link } + // LinkTree matches the IPLD Schema type "LinkTree". It has link kind. type LinkTree = *_LinkTree type _LinkTree struct{ x ipld.Link } @@ -83,7 +89,7 @@ type _LinkTree struct{ x ipld.Link } // ListParents matches the IPLD Schema type "ListParents". It has list kind. type ListParents = *_ListParents type _ListParents struct { - x []_Link + x []_LinkCommit } // ListString matches the IPLD Schema type "ListString". It has list kind. diff --git a/util.go b/util.go index 025c4f1..cce6858 100644 --- a/util.go +++ b/util.go @@ -40,3 +40,11 @@ func (l LinkTree) sha() []byte { } return cidToSha(cl.Cid) } + +func (l LinkCommit) sha() []byte { + cl, ok := l.x.(cidlink.Link) + if !ok { + return nil + } + return cidToSha(cl.Cid) +} From d8111459033f6f2a9c331e778945bfca4ea74af3 Mon Sep 17 00:00:00 2001 From: Rod Vagg Date: Thu, 29 Jul 2021 12:43:40 +1000 Subject: [PATCH 17/22] chore: update docs, reconcile with gen types (ordering and s/text/message) --- README.md | 87 +++- commit.go | 2 +- gen/gen.go | 14 +- ipldsch_satisfaction.go | 976 ++++++++++++++++++++-------------------- ipldsch_types.go | 14 +- tag.go | 12 +- 6 files changed, 578 insertions(+), 527 deletions(-) diff --git a/README.md b/README.md index 2388810..8287513 100644 --- a/README.md +++ b/README.md @@ -3,17 +3,8 @@ Git ipld format [![](https://img.shields.io/badge/made%20by-Protocol%20Labs-blue.svg?style=flat-square)](http://ipn.io) [![](https://img.shields.io/badge/project-IPFS-blue.svg?style=flat-square)](http://ipfs.io/) -[![](https://img.shields.io/badge/freenode-%23ipfs-blue.svg?style=flat-square)](http://webchat.freenode.net/?channels=%23ipfs) -[![Coverage Status](https://codecov.io/gh/ipfs/go-ipld-git/branch/master/graph/badge.svg)](https://codecov.io/gh/ipfs/go-ipld-git/branch/master) -[![Travis CI](https://travis-ci.org/ipfs/go-ipld-git.svg?branch=master)](https://travis-ci.org/ipfs/go-ipld-git) -> An ipld codec for git objects allowing path traversals across the git graph! - -Note: This is WIP and may not be an entirely correct parser. - -## Lead Maintainer - -[Łukasz Magiera](https://github.com/magik6k) +> An IPLD codec for git objects allowing path traversals across the git graph. ## Table of Contents @@ -29,19 +20,49 @@ go get github.com/ipfs/go-ipld-git ``` ## About + This is an IPLD codec which handles git objects. Objects are transformed -into IPLD graph in the following way: +into IPLD graph as detailed below. Objects are demonstrated here using both +[IPLD Schemas](https://ipld.io/docs/schemas/) and example JSON forms. + +### Commit + +```ipldsch +type GpgSig string + +type PersonInfo struct { + date String + timezone String + email String + name String +} + +type Commit struct { + author optional PersonInfo + committer optional PersonInfo + message String + parents [&Commit] + tree &Tree # see "Tree" section below + encoding optional String + signature optional GpgSig + mergeTag [Tag] + other [String] +} +``` + +As JSON, real data would look something like: -* Commit: ```json { "author": { - "date": "1503667703 +0200", + "date": "1503667703", + "timezone": "+0200", "email": "author@mail", "name": "Author Name" }, "committer": { - "date": "1503667703 +0200", + "date": "1503667703", + "timezone": "+0200", "email": "author@mail", "name": "Author Name" }, @@ -51,10 +72,22 @@ into IPLD graph in the following way: ], "tree": } +``` + +### Tag +```ipldsch +type Tag struct { + message String + object &Any + tag String + tagger PersonInfo + tagType String +} ``` -* Tag: +As JSON, real data would look something like: + ```json { "message": "message\n", @@ -67,12 +100,23 @@ into IPLD graph in the following way: "email": "author@mail", "name": "Author Name" }, - "type": "commit" + "tagType": "commit" } +``` + +### Tree + +```ipldsch +type Tree {String:TreeEntry} +type TreeEntry struct { + mode String + hash &Any +} ``` -* Tree: +As JSON, real data would look something like: + ```json { "file.name": { @@ -87,11 +131,18 @@ into IPLD graph in the following way: } ``` +### Blob + +```ipldsch +type Blob bytes +``` + +As JSON, real data would look something like: -* Blob: ```json "\0'>" ``` + ## Contribute PRs are welcome! diff --git a/commit.go b/commit.go index c78a235..51953ae 100644 --- a/commit.go +++ b/commit.go @@ -172,7 +172,7 @@ func encodeCommit(n ipld.Node, w io.Writer) error { fmt.Fprintf(buf, " type %s\n", mtag.tagType.x) fmt.Fprintf(buf, " tag %s\n", mtag.tag.x) fmt.Fprintf(buf, " tagger %s\n \n", mtag.tagger.GitString()) - fmt.Fprintf(buf, "%s", mtag.text.x) + fmt.Fprintf(buf, "%s", mtag.message.x) } if c.signature.m == schema.Maybe_Value { fmt.Fprintln(buf, "gpgsig -----BEGIN PGP SIGNATURE-----") diff --git a/gen/gen.go b/gen/gen.go index d525d4c..34ddd07 100644 --- a/gen/gen.go +++ b/gen/gen.go @@ -18,28 +18,28 @@ func main() { ts.Accumulate(schema.SpawnList("ListString", "String", false)) ts.Accumulate(schema.SpawnLink("Link")) ts.Accumulate(schema.SpawnStruct("PersonInfo", []schema.StructField{ - schema.SpawnStructField("name", "String", false, false), - schema.SpawnStructField("email", "String", false, false), schema.SpawnStructField("date", "String", false, false), schema.SpawnStructField("timezone", "String", false, false), + schema.SpawnStructField("email", "String", false, false), + schema.SpawnStructField("name", "String", false, false), }, schema.SpawnStructRepresentationMap(map[string]string{}))) ts.Accumulate(schema.SpawnString("GpgSig")) ts.Accumulate(schema.SpawnStruct("Tag", []schema.StructField{ + schema.SpawnStructField("message", "String", false, false), schema.SpawnStructField("object", "Link", false, false), - schema.SpawnStructField("tagType", "String", false, false), schema.SpawnStructField("tag", "String", false, false), schema.SpawnStructField("tagger", "PersonInfo", false, false), - schema.SpawnStructField("text", "String", false, false), + schema.SpawnStructField("tagType", "String", false, false), }, schema.SpawnStructRepresentationMap(map[string]string{}))) ts.Accumulate(schema.SpawnList("ListTag", "Tag", false)) ts.Accumulate(schema.SpawnLinkReference("LinkCommit", "Commit")) ts.Accumulate(schema.SpawnList("ListParents", "LinkCommit", false)) ts.Accumulate(schema.SpawnStruct("Commit", []schema.StructField{ - schema.SpawnStructField("tree", "LinkTree", false, false), - schema.SpawnStructField("parents", "ListParents", false, false), - schema.SpawnStructField("message", "String", false, false), schema.SpawnStructField("author", "PersonInfo", true, false), schema.SpawnStructField("committer", "PersonInfo", true, false), + schema.SpawnStructField("message", "String", false, false), + schema.SpawnStructField("parents", "ListParents", false, false), + schema.SpawnStructField("tree", "LinkTree", false, false), schema.SpawnStructField("encoding", "String", true, false), schema.SpawnStructField("signature", "GpgSig", true, false), schema.SpawnStructField("mergeTag", "ListTag", false, false), diff --git a/ipldsch_satisfaction.go b/ipldsch_satisfaction.go index 7c326bd..58496dd 100644 --- a/ipldsch_satisfaction.go +++ b/ipldsch_satisfaction.go @@ -213,20 +213,20 @@ var _ ipld.Node = &_Blob__Repr{} type _Blob__ReprPrototype = _Blob__Prototype type _Blob__ReprAssembler = _Blob__Assembler -func (n _Commit) FieldTree() LinkTree { - return &n.tree +func (n _Commit) FieldAuthor() MaybePersonInfo { + return &n.author } -func (n _Commit) FieldParents() ListParents { - return &n.parents +func (n _Commit) FieldCommitter() MaybePersonInfo { + return &n.committer } func (n _Commit) FieldMessage() String { return &n.message } -func (n _Commit) FieldAuthor() MaybePersonInfo { - return &n.author +func (n _Commit) FieldParents() ListParents { + return &n.parents } -func (n _Commit) FieldCommitter() MaybePersonInfo { - return &n.committer +func (n _Commit) FieldTree() LinkTree { + return &n.tree } func (n _Commit) FieldEncoding() MaybeString { return &n.encoding @@ -276,11 +276,11 @@ func (m MaybeCommit) Must() Commit { } var ( - fieldName__Commit_Tree = _String{"tree"} - fieldName__Commit_Parents = _String{"parents"} - fieldName__Commit_Message = _String{"message"} fieldName__Commit_Author = _String{"author"} fieldName__Commit_Committer = _String{"committer"} + fieldName__Commit_Message = _String{"message"} + fieldName__Commit_Parents = _String{"parents"} + fieldName__Commit_Tree = _String{"tree"} fieldName__Commit_Encoding = _String{"encoding"} fieldName__Commit_Signature = _String{"signature"} fieldName__Commit_MergeTag = _String{"mergeTag"} @@ -294,12 +294,6 @@ func (Commit) Kind() ipld.Kind { } func (n Commit) LookupByString(key string) (ipld.Node, error) { switch key { - case "tree": - return &n.tree, nil - case "parents": - return &n.parents, nil - case "message": - return &n.message, nil case "author": if n.author.m == schema.Maybe_Absent { return ipld.Absent, nil @@ -310,6 +304,12 @@ func (n Commit) LookupByString(key string) (ipld.Node, error) { return ipld.Absent, nil } return n.committer.v, nil + case "message": + return &n.message, nil + case "parents": + return &n.parents, nil + case "tree": + return &n.tree, nil case "encoding": if n.encoding.m == schema.Maybe_Absent { return ipld.Absent, nil @@ -356,28 +356,28 @@ func (itr *_Commit__MapItr) Next() (k ipld.Node, v ipld.Node, _ error) { } switch itr.idx { case 0: - k = &fieldName__Commit_Tree - v = &itr.n.tree - case 1: - k = &fieldName__Commit_Parents - v = &itr.n.parents - case 2: - k = &fieldName__Commit_Message - v = &itr.n.message - case 3: k = &fieldName__Commit_Author if itr.n.author.m == schema.Maybe_Absent { v = ipld.Absent break } v = itr.n.author.v - case 4: + case 1: k = &fieldName__Commit_Committer if itr.n.committer.m == schema.Maybe_Absent { v = ipld.Absent break } v = itr.n.committer.v + case 2: + k = &fieldName__Commit_Message + v = &itr.n.message + case 3: + k = &fieldName__Commit_Parents + v = &itr.n.parents + case 4: + k = &fieldName__Commit_Tree + v = &itr.n.tree case 5: k = &fieldName__Commit_Encoding if itr.n.encoding.m == schema.Maybe_Absent { @@ -474,11 +474,11 @@ type _Commit__Assembler struct { f int cm schema.Maybe - ca_tree _LinkTree__Assembler - ca_parents _ListParents__Assembler - ca_message _String__Assembler ca_author _PersonInfo__Assembler ca_committer _PersonInfo__Assembler + ca_message _String__Assembler + ca_parents _ListParents__Assembler + ca_tree _LinkTree__Assembler ca_encoding _String__Assembler ca_signature _GpgSig__Assembler ca_mergeTag _ListTag__Assembler @@ -488,11 +488,11 @@ type _Commit__Assembler struct { func (na *_Commit__Assembler) reset() { na.state = maState_initial na.s = 0 - na.ca_tree.reset() - na.ca_parents.reset() - na.ca_message.reset() na.ca_author.reset() na.ca_committer.reset() + na.ca_message.reset() + na.ca_parents.reset() + na.ca_tree.reset() na.ca_encoding.reset() na.ca_signature.reset() na.ca_mergeTag.reset() @@ -500,16 +500,16 @@ func (na *_Commit__Assembler) reset() { } var ( - fieldBit__Commit_Tree = 1 << 0 - fieldBit__Commit_Parents = 1 << 1 + fieldBit__Commit_Author = 1 << 0 + fieldBit__Commit_Committer = 1 << 1 fieldBit__Commit_Message = 1 << 2 - fieldBit__Commit_Author = 1 << 3 - fieldBit__Commit_Committer = 1 << 4 + fieldBit__Commit_Parents = 1 << 3 + fieldBit__Commit_Tree = 1 << 4 fieldBit__Commit_Encoding = 1 << 5 fieldBit__Commit_Signature = 1 << 6 fieldBit__Commit_MergeTag = 1 << 7 fieldBit__Commit_Other = 1 << 8 - fieldBits__Commit_sufficient = 0 + 1<<0 + 1<<1 + 1<<2 + 1<<7 + 1<<8 + fieldBits__Commit_sufficient = 0 + 1<<2 + 1<<3 + 1<<4 + 1<<7 + 1<<8 ) func (na *_Commit__Assembler) BeginMap(int64) (ipld.MapAssembler, error) { @@ -604,20 +604,18 @@ func (_Commit__Assembler) Prototype() ipld.NodePrototype { func (ma *_Commit__Assembler) valueFinishTidy() bool { switch ma.f { case 0: - switch ma.cm { + switch ma.w.author.m { case schema.Maybe_Value: - ma.ca_tree.w = nil - ma.cm = schema.Maybe_Absent + ma.w.author.v = ma.ca_author.w ma.state = maState_initial return true default: return false } case 1: - switch ma.cm { + switch ma.w.committer.m { case schema.Maybe_Value: - ma.ca_parents.w = nil - ma.cm = schema.Maybe_Absent + ma.w.committer.v = ma.ca_committer.w ma.state = maState_initial return true default: @@ -634,18 +632,20 @@ func (ma *_Commit__Assembler) valueFinishTidy() bool { return false } case 3: - switch ma.w.author.m { + switch ma.cm { case schema.Maybe_Value: - ma.w.author.v = ma.ca_author.w + ma.ca_parents.w = nil + ma.cm = schema.Maybe_Absent ma.state = maState_initial return true default: return false } case 4: - switch ma.w.committer.m { + switch ma.cm { case schema.Maybe_Value: - ma.w.committer.v = ma.ca_committer.w + ma.ca_tree.w = nil + ma.cm = schema.Maybe_Absent ma.state = maState_initial return true default: @@ -707,26 +707,26 @@ func (ma *_Commit__Assembler) AssembleEntry(k string) (ipld.NodeAssembler, error panic("invalid state: AssembleEntry cannot be called on an assembler that's already finished") } switch k { - case "tree": - if ma.s&fieldBit__Commit_Tree != 0 { - return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Tree} + case "author": + if ma.s&fieldBit__Commit_Author != 0 { + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Author} } - ma.s += fieldBit__Commit_Tree + ma.s += fieldBit__Commit_Author ma.state = maState_midValue ma.f = 0 - ma.ca_tree.w = &ma.w.tree - ma.ca_tree.m = &ma.cm - return &ma.ca_tree, nil - case "parents": - if ma.s&fieldBit__Commit_Parents != 0 { - return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Parents} + ma.ca_author.w = ma.w.author.v + ma.ca_author.m = &ma.w.author.m + return &ma.ca_author, nil + case "committer": + if ma.s&fieldBit__Commit_Committer != 0 { + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Committer} } - ma.s += fieldBit__Commit_Parents + ma.s += fieldBit__Commit_Committer ma.state = maState_midValue ma.f = 1 - ma.ca_parents.w = &ma.w.parents - ma.ca_parents.m = &ma.cm - return &ma.ca_parents, nil + ma.ca_committer.w = ma.w.committer.v + ma.ca_committer.m = &ma.w.committer.m + return &ma.ca_committer, nil case "message": if ma.s&fieldBit__Commit_Message != 0 { return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Message} @@ -737,26 +737,26 @@ func (ma *_Commit__Assembler) AssembleEntry(k string) (ipld.NodeAssembler, error ma.ca_message.w = &ma.w.message ma.ca_message.m = &ma.cm return &ma.ca_message, nil - case "author": - if ma.s&fieldBit__Commit_Author != 0 { - return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Author} + case "parents": + if ma.s&fieldBit__Commit_Parents != 0 { + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Parents} } - ma.s += fieldBit__Commit_Author + ma.s += fieldBit__Commit_Parents ma.state = maState_midValue ma.f = 3 - ma.ca_author.w = ma.w.author.v - ma.ca_author.m = &ma.w.author.m - return &ma.ca_author, nil - case "committer": - if ma.s&fieldBit__Commit_Committer != 0 { - return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Committer} + ma.ca_parents.w = &ma.w.parents + ma.ca_parents.m = &ma.cm + return &ma.ca_parents, nil + case "tree": + if ma.s&fieldBit__Commit_Tree != 0 { + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Tree} } - ma.s += fieldBit__Commit_Committer + ma.s += fieldBit__Commit_Tree ma.state = maState_midValue ma.f = 4 - ma.ca_committer.w = ma.w.committer.v - ma.ca_committer.m = &ma.w.committer.m - return &ma.ca_committer, nil + ma.ca_tree.w = &ma.w.tree + ma.ca_tree.m = &ma.cm + return &ma.ca_tree, nil case "encoding": if ma.s&fieldBit__Commit_Encoding != 0 { return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Encoding} @@ -834,25 +834,25 @@ func (ma *_Commit__Assembler) AssembleValue() ipld.NodeAssembler { ma.state = maState_midValue switch ma.f { case 0: - ma.ca_tree.w = &ma.w.tree - ma.ca_tree.m = &ma.cm - return &ma.ca_tree + ma.ca_author.w = ma.w.author.v + ma.ca_author.m = &ma.w.author.m + return &ma.ca_author case 1: - ma.ca_parents.w = &ma.w.parents - ma.ca_parents.m = &ma.cm - return &ma.ca_parents + ma.ca_committer.w = ma.w.committer.v + ma.ca_committer.m = &ma.w.committer.m + return &ma.ca_committer case 2: ma.ca_message.w = &ma.w.message ma.ca_message.m = &ma.cm return &ma.ca_message case 3: - ma.ca_author.w = ma.w.author.v - ma.ca_author.m = &ma.w.author.m - return &ma.ca_author + ma.ca_parents.w = &ma.w.parents + ma.ca_parents.m = &ma.cm + return &ma.ca_parents case 4: - ma.ca_committer.w = ma.w.committer.v - ma.ca_committer.m = &ma.w.committer.m - return &ma.ca_committer + ma.ca_tree.w = &ma.w.tree + ma.ca_tree.m = &ma.cm + return &ma.ca_tree case 5: ma.ca_encoding.w = &ma.w.encoding.v ma.ca_encoding.m = &ma.w.encoding.m @@ -890,14 +890,14 @@ func (ma *_Commit__Assembler) Finish() error { } if ma.s&fieldBits__Commit_sufficient != fieldBits__Commit_sufficient { err := ipld.ErrMissingRequiredField{Missing: make([]string, 0)} - if ma.s&fieldBit__Commit_Tree == 0 { - err.Missing = append(err.Missing, "tree") + if ma.s&fieldBit__Commit_Message == 0 { + err.Missing = append(err.Missing, "message") } if ma.s&fieldBit__Commit_Parents == 0 { err.Missing = append(err.Missing, "parents") } - if ma.s&fieldBit__Commit_Message == 0 { - err.Missing = append(err.Missing, "message") + if ma.s&fieldBit__Commit_Tree == 0 { + err.Missing = append(err.Missing, "tree") } if ma.s&fieldBit__Commit_MergeTag == 0 { err.Missing = append(err.Missing, "mergeTag") @@ -943,19 +943,19 @@ func (ka *_Commit__KeyAssembler) AssignString(k string) error { panic("misuse: KeyAssembler held beyond its valid lifetime") } switch k { - case "tree": - if ka.s&fieldBit__Commit_Tree != 0 { - return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Tree} + case "author": + if ka.s&fieldBit__Commit_Author != 0 { + return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Author} } - ka.s += fieldBit__Commit_Tree + ka.s += fieldBit__Commit_Author ka.state = maState_expectValue ka.f = 0 return nil - case "parents": - if ka.s&fieldBit__Commit_Parents != 0 { - return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Parents} + case "committer": + if ka.s&fieldBit__Commit_Committer != 0 { + return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Committer} } - ka.s += fieldBit__Commit_Parents + ka.s += fieldBit__Commit_Committer ka.state = maState_expectValue ka.f = 1 return nil @@ -967,19 +967,19 @@ func (ka *_Commit__KeyAssembler) AssignString(k string) error { ka.state = maState_expectValue ka.f = 2 return nil - case "author": - if ka.s&fieldBit__Commit_Author != 0 { - return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Author} + case "parents": + if ka.s&fieldBit__Commit_Parents != 0 { + return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Parents} } - ka.s += fieldBit__Commit_Author + ka.s += fieldBit__Commit_Parents ka.state = maState_expectValue ka.f = 3 return nil - case "committer": - if ka.s&fieldBit__Commit_Committer != 0 { - return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Committer} + case "tree": + if ka.s&fieldBit__Commit_Tree != 0 { + return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Tree} } - ka.s += fieldBit__Commit_Committer + ka.s += fieldBit__Commit_Tree ka.state = maState_expectValue ka.f = 4 return nil @@ -1045,11 +1045,11 @@ func (n Commit) Representation() ipld.Node { type _Commit__Repr _Commit var ( - fieldName__Commit_Tree_serial = _String{"tree"} - fieldName__Commit_Parents_serial = _String{"parents"} - fieldName__Commit_Message_serial = _String{"message"} fieldName__Commit_Author_serial = _String{"author"} fieldName__Commit_Committer_serial = _String{"committer"} + fieldName__Commit_Message_serial = _String{"message"} + fieldName__Commit_Parents_serial = _String{"parents"} + fieldName__Commit_Tree_serial = _String{"tree"} fieldName__Commit_Encoding_serial = _String{"encoding"} fieldName__Commit_Signature_serial = _String{"signature"} fieldName__Commit_MergeTag_serial = _String{"mergeTag"} @@ -1062,12 +1062,6 @@ func (_Commit__Repr) Kind() ipld.Kind { } func (n *_Commit__Repr) LookupByString(key string) (ipld.Node, error) { switch key { - case "tree": - return n.tree.Representation(), nil - case "parents": - return n.parents.Representation(), nil - case "message": - return n.message.Representation(), nil case "author": if n.author.m == schema.Maybe_Absent { return ipld.Absent, ipld.ErrNotExists{Segment: ipld.PathSegmentOfString(key)} @@ -1078,6 +1072,12 @@ func (n *_Commit__Repr) LookupByString(key string) (ipld.Node, error) { return ipld.Absent, ipld.ErrNotExists{Segment: ipld.PathSegmentOfString(key)} } return n.committer.v.Representation(), nil + case "message": + return n.message.Representation(), nil + case "parents": + return n.parents.Representation(), nil + case "tree": + return n.tree.Representation(), nil case "encoding": if n.encoding.m == schema.Maybe_Absent { return ipld.Absent, ipld.ErrNotExists{Segment: ipld.PathSegmentOfString(key)} @@ -1125,28 +1125,28 @@ advance: } switch itr.idx { case 0: - k = &fieldName__Commit_Tree_serial - v = itr.n.tree.Representation() - case 1: - k = &fieldName__Commit_Parents_serial - v = itr.n.parents.Representation() - case 2: - k = &fieldName__Commit_Message_serial - v = itr.n.message.Representation() - case 3: k = &fieldName__Commit_Author_serial if itr.n.author.m == schema.Maybe_Absent { itr.idx++ goto advance } v = itr.n.author.v.Representation() - case 4: + case 1: k = &fieldName__Commit_Committer_serial if itr.n.committer.m == schema.Maybe_Absent { itr.idx++ goto advance } v = itr.n.committer.v.Representation() + case 2: + k = &fieldName__Commit_Message_serial + v = itr.n.message.Representation() + case 3: + k = &fieldName__Commit_Parents_serial + v = itr.n.parents.Representation() + case 4: + k = &fieldName__Commit_Tree_serial + v = itr.n.tree.Representation() case 5: k = &fieldName__Commit_Encoding_serial if itr.n.encoding.m == schema.Maybe_Absent { @@ -1255,11 +1255,11 @@ type _Commit__ReprAssembler struct { f int cm schema.Maybe - ca_tree _LinkTree__ReprAssembler - ca_parents _ListParents__ReprAssembler - ca_message _String__ReprAssembler ca_author _PersonInfo__ReprAssembler ca_committer _PersonInfo__ReprAssembler + ca_message _String__ReprAssembler + ca_parents _ListParents__ReprAssembler + ca_tree _LinkTree__ReprAssembler ca_encoding _String__ReprAssembler ca_signature _GpgSig__ReprAssembler ca_mergeTag _ListTag__ReprAssembler @@ -1269,11 +1269,11 @@ type _Commit__ReprAssembler struct { func (na *_Commit__ReprAssembler) reset() { na.state = maState_initial na.s = 0 - na.ca_tree.reset() - na.ca_parents.reset() - na.ca_message.reset() na.ca_author.reset() na.ca_committer.reset() + na.ca_message.reset() + na.ca_parents.reset() + na.ca_tree.reset() na.ca_encoding.reset() na.ca_signature.reset() na.ca_mergeTag.reset() @@ -1371,18 +1371,18 @@ func (_Commit__ReprAssembler) Prototype() ipld.NodePrototype { func (ma *_Commit__ReprAssembler) valueFinishTidy() bool { switch ma.f { case 0: - switch ma.cm { + switch ma.w.author.m { case schema.Maybe_Value: - ma.cm = schema.Maybe_Absent + ma.w.author.v = ma.ca_author.w ma.state = maState_initial return true default: return false } case 1: - switch ma.cm { + switch ma.w.committer.m { case schema.Maybe_Value: - ma.cm = schema.Maybe_Absent + ma.w.committer.v = ma.ca_committer.w ma.state = maState_initial return true default: @@ -1398,18 +1398,18 @@ func (ma *_Commit__ReprAssembler) valueFinishTidy() bool { return false } case 3: - switch ma.w.author.m { + switch ma.cm { case schema.Maybe_Value: - ma.w.author.v = ma.ca_author.w + ma.cm = schema.Maybe_Absent ma.state = maState_initial return true default: return false } case 4: - switch ma.w.committer.m { + switch ma.cm { case schema.Maybe_Value: - ma.w.committer.v = ma.ca_committer.w + ma.cm = schema.Maybe_Absent ma.state = maState_initial return true default: @@ -1469,26 +1469,28 @@ func (ma *_Commit__ReprAssembler) AssembleEntry(k string) (ipld.NodeAssembler, e panic("invalid state: AssembleEntry cannot be called on an assembler that's already finished") } switch k { - case "tree": - if ma.s&fieldBit__Commit_Tree != 0 { - return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Tree_serial} + case "author": + if ma.s&fieldBit__Commit_Author != 0 { + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Author_serial} } - ma.s += fieldBit__Commit_Tree + ma.s += fieldBit__Commit_Author ma.state = maState_midValue ma.f = 0 - ma.ca_tree.w = &ma.w.tree - ma.ca_tree.m = &ma.cm - return &ma.ca_tree, nil - case "parents": - if ma.s&fieldBit__Commit_Parents != 0 { - return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Parents_serial} + ma.ca_author.w = ma.w.author.v + ma.ca_author.m = &ma.w.author.m + + return &ma.ca_author, nil + case "committer": + if ma.s&fieldBit__Commit_Committer != 0 { + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Committer_serial} } - ma.s += fieldBit__Commit_Parents + ma.s += fieldBit__Commit_Committer ma.state = maState_midValue ma.f = 1 - ma.ca_parents.w = &ma.w.parents - ma.ca_parents.m = &ma.cm - return &ma.ca_parents, nil + ma.ca_committer.w = ma.w.committer.v + ma.ca_committer.m = &ma.w.committer.m + + return &ma.ca_committer, nil case "message": if ma.s&fieldBit__Commit_Message != 0 { return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Message_serial} @@ -1499,28 +1501,26 @@ func (ma *_Commit__ReprAssembler) AssembleEntry(k string) (ipld.NodeAssembler, e ma.ca_message.w = &ma.w.message ma.ca_message.m = &ma.cm return &ma.ca_message, nil - case "author": - if ma.s&fieldBit__Commit_Author != 0 { - return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Author_serial} + case "parents": + if ma.s&fieldBit__Commit_Parents != 0 { + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Parents_serial} } - ma.s += fieldBit__Commit_Author + ma.s += fieldBit__Commit_Parents ma.state = maState_midValue ma.f = 3 - ma.ca_author.w = ma.w.author.v - ma.ca_author.m = &ma.w.author.m - - return &ma.ca_author, nil - case "committer": - if ma.s&fieldBit__Commit_Committer != 0 { - return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Committer_serial} + ma.ca_parents.w = &ma.w.parents + ma.ca_parents.m = &ma.cm + return &ma.ca_parents, nil + case "tree": + if ma.s&fieldBit__Commit_Tree != 0 { + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Tree_serial} } - ma.s += fieldBit__Commit_Committer + ma.s += fieldBit__Commit_Tree ma.state = maState_midValue ma.f = 4 - ma.ca_committer.w = ma.w.committer.v - ma.ca_committer.m = &ma.w.committer.m - - return &ma.ca_committer, nil + ma.ca_tree.w = &ma.w.tree + ma.ca_tree.m = &ma.cm + return &ma.ca_tree, nil case "encoding": if ma.s&fieldBit__Commit_Encoding != 0 { return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Encoding_serial} @@ -1601,27 +1601,27 @@ func (ma *_Commit__ReprAssembler) AssembleValue() ipld.NodeAssembler { ma.state = maState_midValue switch ma.f { case 0: - ma.ca_tree.w = &ma.w.tree - ma.ca_tree.m = &ma.cm - return &ma.ca_tree - case 1: - ma.ca_parents.w = &ma.w.parents - ma.ca_parents.m = &ma.cm - return &ma.ca_parents - case 2: - ma.ca_message.w = &ma.w.message - ma.ca_message.m = &ma.cm - return &ma.ca_message - case 3: ma.ca_author.w = ma.w.author.v ma.ca_author.m = &ma.w.author.m return &ma.ca_author - case 4: + case 1: ma.ca_committer.w = ma.w.committer.v ma.ca_committer.m = &ma.w.committer.m return &ma.ca_committer + case 2: + ma.ca_message.w = &ma.w.message + ma.ca_message.m = &ma.cm + return &ma.ca_message + case 3: + ma.ca_parents.w = &ma.w.parents + ma.ca_parents.m = &ma.cm + return &ma.ca_parents + case 4: + ma.ca_tree.w = &ma.w.tree + ma.ca_tree.m = &ma.cm + return &ma.ca_tree case 5: ma.ca_encoding.w = &ma.w.encoding.v ma.ca_encoding.m = &ma.w.encoding.m @@ -1661,14 +1661,14 @@ func (ma *_Commit__ReprAssembler) Finish() error { } if ma.s&fieldBits__Commit_sufficient != fieldBits__Commit_sufficient { err := ipld.ErrMissingRequiredField{Missing: make([]string, 0)} - if ma.s&fieldBit__Commit_Tree == 0 { - err.Missing = append(err.Missing, "tree") + if ma.s&fieldBit__Commit_Message == 0 { + err.Missing = append(err.Missing, "message") } if ma.s&fieldBit__Commit_Parents == 0 { err.Missing = append(err.Missing, "parents") } - if ma.s&fieldBit__Commit_Message == 0 { - err.Missing = append(err.Missing, "message") + if ma.s&fieldBit__Commit_Tree == 0 { + err.Missing = append(err.Missing, "tree") } if ma.s&fieldBit__Commit_MergeTag == 0 { err.Missing = append(err.Missing, "mergeTag") @@ -1714,19 +1714,19 @@ func (ka *_Commit__ReprKeyAssembler) AssignString(k string) error { panic("misuse: KeyAssembler held beyond its valid lifetime") } switch k { - case "tree": - if ka.s&fieldBit__Commit_Tree != 0 { - return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Tree_serial} + case "author": + if ka.s&fieldBit__Commit_Author != 0 { + return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Author_serial} } - ka.s += fieldBit__Commit_Tree + ka.s += fieldBit__Commit_Author ka.state = maState_expectValue ka.f = 0 return nil - case "parents": - if ka.s&fieldBit__Commit_Parents != 0 { - return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Parents_serial} + case "committer": + if ka.s&fieldBit__Commit_Committer != 0 { + return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Committer_serial} } - ka.s += fieldBit__Commit_Parents + ka.s += fieldBit__Commit_Committer ka.state = maState_expectValue ka.f = 1 return nil @@ -1738,19 +1738,19 @@ func (ka *_Commit__ReprKeyAssembler) AssignString(k string) error { ka.state = maState_expectValue ka.f = 2 return nil - case "author": - if ka.s&fieldBit__Commit_Author != 0 { - return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Author_serial} + case "parents": + if ka.s&fieldBit__Commit_Parents != 0 { + return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Parents_serial} } - ka.s += fieldBit__Commit_Author + ka.s += fieldBit__Commit_Parents ka.state = maState_expectValue ka.f = 3 return nil - case "committer": - if ka.s&fieldBit__Commit_Committer != 0 { - return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Committer_serial} + case "tree": + if ka.s&fieldBit__Commit_Tree != 0 { + return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Tree_serial} } - ka.s += fieldBit__Commit_Committer + ka.s += fieldBit__Commit_Tree ka.state = maState_expectValue ka.f = 4 return nil @@ -4409,18 +4409,18 @@ func (la *_ListTag__ReprAssembler) ValuePrototype(_ int64) ipld.NodePrototype { return _Tag__ReprPrototype{} } -func (n _PersonInfo) FieldName() String { - return &n.name -} -func (n _PersonInfo) FieldEmail() String { - return &n.email -} func (n _PersonInfo) FieldDate() String { return &n.date } func (n _PersonInfo) FieldTimezone() String { return &n.timezone } +func (n _PersonInfo) FieldEmail() String { + return &n.email +} +func (n _PersonInfo) FieldName() String { + return &n.name +} type _PersonInfo__Maybe struct { m schema.Maybe @@ -4457,10 +4457,10 @@ func (m MaybePersonInfo) Must() PersonInfo { } var ( - fieldName__PersonInfo_Name = _String{"name"} - fieldName__PersonInfo_Email = _String{"email"} fieldName__PersonInfo_Date = _String{"date"} fieldName__PersonInfo_Timezone = _String{"timezone"} + fieldName__PersonInfo_Email = _String{"email"} + fieldName__PersonInfo_Name = _String{"name"} ) var _ ipld.Node = (PersonInfo)(&_PersonInfo{}) var _ schema.TypedNode = (PersonInfo)(&_PersonInfo{}) @@ -4470,14 +4470,14 @@ func (PersonInfo) Kind() ipld.Kind { } func (n PersonInfo) LookupByString(key string) (ipld.Node, error) { switch key { - case "name": - return &n.name, nil - case "email": - return &n.email, nil case "date": return &n.date, nil case "timezone": return &n.timezone, nil + case "email": + return &n.email, nil + case "name": + return &n.name, nil default: return nil, schema.ErrNoSuchField{Type: nil /*TODO*/, Field: ipld.PathSegmentOfString(key)} } @@ -4510,17 +4510,17 @@ func (itr *_PersonInfo__MapItr) Next() (k ipld.Node, v ipld.Node, _ error) { } switch itr.idx { case 0: - k = &fieldName__PersonInfo_Name - v = &itr.n.name - case 1: - k = &fieldName__PersonInfo_Email - v = &itr.n.email - case 2: k = &fieldName__PersonInfo_Date v = &itr.n.date - case 3: + case 1: k = &fieldName__PersonInfo_Timezone v = &itr.n.timezone + case 2: + k = &fieldName__PersonInfo_Email + v = &itr.n.email + case 3: + k = &fieldName__PersonInfo_Name + v = &itr.n.name default: panic("unreachable") } @@ -4597,26 +4597,26 @@ type _PersonInfo__Assembler struct { f int cm schema.Maybe - ca_name _String__Assembler - ca_email _String__Assembler ca_date _String__Assembler ca_timezone _String__Assembler + ca_email _String__Assembler + ca_name _String__Assembler } func (na *_PersonInfo__Assembler) reset() { na.state = maState_initial na.s = 0 - na.ca_name.reset() - na.ca_email.reset() na.ca_date.reset() na.ca_timezone.reset() + na.ca_email.reset() + na.ca_name.reset() } var ( - fieldBit__PersonInfo_Name = 1 << 0 - fieldBit__PersonInfo_Email = 1 << 1 - fieldBit__PersonInfo_Date = 1 << 2 - fieldBit__PersonInfo_Timezone = 1 << 3 + fieldBit__PersonInfo_Date = 1 << 0 + fieldBit__PersonInfo_Timezone = 1 << 1 + fieldBit__PersonInfo_Email = 1 << 2 + fieldBit__PersonInfo_Name = 1 << 3 fieldBits__PersonInfo_sufficient = 0 + 1<<0 + 1<<1 + 1<<2 + 1<<3 ) @@ -4714,7 +4714,7 @@ func (ma *_PersonInfo__Assembler) valueFinishTidy() bool { case 0: switch ma.cm { case schema.Maybe_Value: - ma.ca_name.w = nil + ma.ca_date.w = nil ma.cm = schema.Maybe_Absent ma.state = maState_initial return true @@ -4724,7 +4724,7 @@ func (ma *_PersonInfo__Assembler) valueFinishTidy() bool { case 1: switch ma.cm { case schema.Maybe_Value: - ma.ca_email.w = nil + ma.ca_timezone.w = nil ma.cm = schema.Maybe_Absent ma.state = maState_initial return true @@ -4734,7 +4734,7 @@ func (ma *_PersonInfo__Assembler) valueFinishTidy() bool { case 2: switch ma.cm { case schema.Maybe_Value: - ma.ca_date.w = nil + ma.ca_email.w = nil ma.cm = schema.Maybe_Absent ma.state = maState_initial return true @@ -4744,7 +4744,7 @@ func (ma *_PersonInfo__Assembler) valueFinishTidy() bool { case 3: switch ma.cm { case schema.Maybe_Value: - ma.ca_timezone.w = nil + ma.ca_name.w = nil ma.cm = schema.Maybe_Absent ma.state = maState_initial return true @@ -4771,33 +4771,13 @@ func (ma *_PersonInfo__Assembler) AssembleEntry(k string) (ipld.NodeAssembler, e panic("invalid state: AssembleEntry cannot be called on an assembler that's already finished") } switch k { - case "name": - if ma.s&fieldBit__PersonInfo_Name != 0 { - return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Name} - } - ma.s += fieldBit__PersonInfo_Name - ma.state = maState_midValue - ma.f = 0 - ma.ca_name.w = &ma.w.name - ma.ca_name.m = &ma.cm - return &ma.ca_name, nil - case "email": - if ma.s&fieldBit__PersonInfo_Email != 0 { - return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Email} - } - ma.s += fieldBit__PersonInfo_Email - ma.state = maState_midValue - ma.f = 1 - ma.ca_email.w = &ma.w.email - ma.ca_email.m = &ma.cm - return &ma.ca_email, nil case "date": if ma.s&fieldBit__PersonInfo_Date != 0 { return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Date} } ma.s += fieldBit__PersonInfo_Date ma.state = maState_midValue - ma.f = 2 + ma.f = 0 ma.ca_date.w = &ma.w.date ma.ca_date.m = &ma.cm return &ma.ca_date, nil @@ -4807,10 +4787,30 @@ func (ma *_PersonInfo__Assembler) AssembleEntry(k string) (ipld.NodeAssembler, e } ma.s += fieldBit__PersonInfo_Timezone ma.state = maState_midValue - ma.f = 3 + ma.f = 1 ma.ca_timezone.w = &ma.w.timezone ma.ca_timezone.m = &ma.cm return &ma.ca_timezone, nil + case "email": + if ma.s&fieldBit__PersonInfo_Email != 0 { + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Email} + } + ma.s += fieldBit__PersonInfo_Email + ma.state = maState_midValue + ma.f = 2 + ma.ca_email.w = &ma.w.email + ma.ca_email.m = &ma.cm + return &ma.ca_email, nil + case "name": + if ma.s&fieldBit__PersonInfo_Name != 0 { + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Name} + } + ma.s += fieldBit__PersonInfo_Name + ma.state = maState_midValue + ma.f = 3 + ma.ca_name.w = &ma.w.name + ma.ca_name.m = &ma.cm + return &ma.ca_name, nil } return nil, ipld.ErrInvalidKey{TypeName: "ipldgit.PersonInfo", Key: &_String{k}} } @@ -4848,21 +4848,21 @@ func (ma *_PersonInfo__Assembler) AssembleValue() ipld.NodeAssembler { ma.state = maState_midValue switch ma.f { case 0: - ma.ca_name.w = &ma.w.name - ma.ca_name.m = &ma.cm - return &ma.ca_name - case 1: - ma.ca_email.w = &ma.w.email - ma.ca_email.m = &ma.cm - return &ma.ca_email - case 2: ma.ca_date.w = &ma.w.date ma.ca_date.m = &ma.cm return &ma.ca_date - case 3: + case 1: ma.ca_timezone.w = &ma.w.timezone ma.ca_timezone.m = &ma.cm return &ma.ca_timezone + case 2: + ma.ca_email.w = &ma.w.email + ma.ca_email.m = &ma.cm + return &ma.ca_email + case 3: + ma.ca_name.w = &ma.w.name + ma.ca_name.m = &ma.cm + return &ma.ca_name default: panic("unreachable") } @@ -4884,18 +4884,18 @@ func (ma *_PersonInfo__Assembler) Finish() error { } if ma.s&fieldBits__PersonInfo_sufficient != fieldBits__PersonInfo_sufficient { err := ipld.ErrMissingRequiredField{Missing: make([]string, 0)} - if ma.s&fieldBit__PersonInfo_Name == 0 { - err.Missing = append(err.Missing, "name") - } - if ma.s&fieldBit__PersonInfo_Email == 0 { - err.Missing = append(err.Missing, "email") - } if ma.s&fieldBit__PersonInfo_Date == 0 { err.Missing = append(err.Missing, "date") } if ma.s&fieldBit__PersonInfo_Timezone == 0 { err.Missing = append(err.Missing, "timezone") } + if ma.s&fieldBit__PersonInfo_Email == 0 { + err.Missing = append(err.Missing, "email") + } + if ma.s&fieldBit__PersonInfo_Name == 0 { + err.Missing = append(err.Missing, "name") + } return err } ma.state = maState_finished @@ -4934,35 +4934,35 @@ func (ka *_PersonInfo__KeyAssembler) AssignString(k string) error { panic("misuse: KeyAssembler held beyond its valid lifetime") } switch k { - case "name": - if ka.s&fieldBit__PersonInfo_Name != 0 { - return ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Name} + case "date": + if ka.s&fieldBit__PersonInfo_Date != 0 { + return ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Date} } - ka.s += fieldBit__PersonInfo_Name + ka.s += fieldBit__PersonInfo_Date ka.state = maState_expectValue ka.f = 0 return nil - case "email": - if ka.s&fieldBit__PersonInfo_Email != 0 { - return ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Email} + case "timezone": + if ka.s&fieldBit__PersonInfo_Timezone != 0 { + return ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Timezone} } - ka.s += fieldBit__PersonInfo_Email + ka.s += fieldBit__PersonInfo_Timezone ka.state = maState_expectValue ka.f = 1 return nil - case "date": - if ka.s&fieldBit__PersonInfo_Date != 0 { - return ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Date} + case "email": + if ka.s&fieldBit__PersonInfo_Email != 0 { + return ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Email} } - ka.s += fieldBit__PersonInfo_Date + ka.s += fieldBit__PersonInfo_Email ka.state = maState_expectValue ka.f = 2 return nil - case "timezone": - if ka.s&fieldBit__PersonInfo_Timezone != 0 { - return ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Timezone} + case "name": + if ka.s&fieldBit__PersonInfo_Name != 0 { + return ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Name} } - ka.s += fieldBit__PersonInfo_Timezone + ka.s += fieldBit__PersonInfo_Name ka.state = maState_expectValue ka.f = 3 return nil @@ -4996,10 +4996,10 @@ func (n PersonInfo) Representation() ipld.Node { type _PersonInfo__Repr _PersonInfo var ( - fieldName__PersonInfo_Name_serial = _String{"name"} - fieldName__PersonInfo_Email_serial = _String{"email"} fieldName__PersonInfo_Date_serial = _String{"date"} fieldName__PersonInfo_Timezone_serial = _String{"timezone"} + fieldName__PersonInfo_Email_serial = _String{"email"} + fieldName__PersonInfo_Name_serial = _String{"name"} ) var _ ipld.Node = &_PersonInfo__Repr{} @@ -5008,14 +5008,14 @@ func (_PersonInfo__Repr) Kind() ipld.Kind { } func (n *_PersonInfo__Repr) LookupByString(key string) (ipld.Node, error) { switch key { - case "name": - return n.name.Representation(), nil - case "email": - return n.email.Representation(), nil case "date": return n.date.Representation(), nil case "timezone": return n.timezone.Representation(), nil + case "email": + return n.email.Representation(), nil + case "name": + return n.name.Representation(), nil default: return nil, schema.ErrNoSuchField{Type: nil /*TODO*/, Field: ipld.PathSegmentOfString(key)} } @@ -5048,17 +5048,17 @@ func (itr *_PersonInfo__ReprMapItr) Next() (k ipld.Node, v ipld.Node, _ error) { } switch itr.idx { case 0: - k = &fieldName__PersonInfo_Name_serial - v = itr.n.name.Representation() - case 1: - k = &fieldName__PersonInfo_Email_serial - v = itr.n.email.Representation() - case 2: k = &fieldName__PersonInfo_Date_serial v = itr.n.date.Representation() - case 3: + case 1: k = &fieldName__PersonInfo_Timezone_serial v = itr.n.timezone.Representation() + case 2: + k = &fieldName__PersonInfo_Email_serial + v = itr.n.email.Representation() + case 3: + k = &fieldName__PersonInfo_Name_serial + v = itr.n.name.Representation() default: panic("unreachable") } @@ -5135,19 +5135,19 @@ type _PersonInfo__ReprAssembler struct { f int cm schema.Maybe - ca_name _String__ReprAssembler - ca_email _String__ReprAssembler ca_date _String__ReprAssembler ca_timezone _String__ReprAssembler + ca_email _String__ReprAssembler + ca_name _String__ReprAssembler } func (na *_PersonInfo__ReprAssembler) reset() { na.state = maState_initial na.s = 0 - na.ca_name.reset() - na.ca_email.reset() na.ca_date.reset() na.ca_timezone.reset() + na.ca_email.reset() + na.ca_name.reset() } func (na *_PersonInfo__ReprAssembler) BeginMap(int64) (ipld.MapAssembler, error) { switch *na.m { @@ -5296,46 +5296,46 @@ func (ma *_PersonInfo__ReprAssembler) AssembleEntry(k string) (ipld.NodeAssemble panic("invalid state: AssembleEntry cannot be called on an assembler that's already finished") } switch k { - case "name": - if ma.s&fieldBit__PersonInfo_Name != 0 { - return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Name_serial} + case "date": + if ma.s&fieldBit__PersonInfo_Date != 0 { + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Date_serial} } - ma.s += fieldBit__PersonInfo_Name + ma.s += fieldBit__PersonInfo_Date ma.state = maState_midValue ma.f = 0 - ma.ca_name.w = &ma.w.name - ma.ca_name.m = &ma.cm - return &ma.ca_name, nil + ma.ca_date.w = &ma.w.date + ma.ca_date.m = &ma.cm + return &ma.ca_date, nil + case "timezone": + if ma.s&fieldBit__PersonInfo_Timezone != 0 { + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Timezone_serial} + } + ma.s += fieldBit__PersonInfo_Timezone + ma.state = maState_midValue + ma.f = 1 + ma.ca_timezone.w = &ma.w.timezone + ma.ca_timezone.m = &ma.cm + return &ma.ca_timezone, nil case "email": if ma.s&fieldBit__PersonInfo_Email != 0 { return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Email_serial} } ma.s += fieldBit__PersonInfo_Email ma.state = maState_midValue - ma.f = 1 - ma.ca_email.w = &ma.w.email - ma.ca_email.m = &ma.cm - return &ma.ca_email, nil - case "date": - if ma.s&fieldBit__PersonInfo_Date != 0 { - return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Date_serial} - } - ma.s += fieldBit__PersonInfo_Date - ma.state = maState_midValue ma.f = 2 - ma.ca_date.w = &ma.w.date - ma.ca_date.m = &ma.cm - return &ma.ca_date, nil - case "timezone": - if ma.s&fieldBit__PersonInfo_Timezone != 0 { - return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Timezone_serial} + ma.ca_email.w = &ma.w.email + ma.ca_email.m = &ma.cm + return &ma.ca_email, nil + case "name": + if ma.s&fieldBit__PersonInfo_Name != 0 { + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Name_serial} } - ma.s += fieldBit__PersonInfo_Timezone + ma.s += fieldBit__PersonInfo_Name ma.state = maState_midValue ma.f = 3 - ma.ca_timezone.w = &ma.w.timezone - ma.ca_timezone.m = &ma.cm - return &ma.ca_timezone, nil + ma.ca_name.w = &ma.w.name + ma.ca_name.m = &ma.cm + return &ma.ca_name, nil default: } return nil, ipld.ErrInvalidKey{TypeName: "ipldgit.PersonInfo.Repr", Key: &_String{k}} @@ -5374,21 +5374,21 @@ func (ma *_PersonInfo__ReprAssembler) AssembleValue() ipld.NodeAssembler { ma.state = maState_midValue switch ma.f { case 0: - ma.ca_name.w = &ma.w.name - ma.ca_name.m = &ma.cm - return &ma.ca_name - case 1: - ma.ca_email.w = &ma.w.email - ma.ca_email.m = &ma.cm - return &ma.ca_email - case 2: ma.ca_date.w = &ma.w.date ma.ca_date.m = &ma.cm return &ma.ca_date - case 3: + case 1: ma.ca_timezone.w = &ma.w.timezone ma.ca_timezone.m = &ma.cm return &ma.ca_timezone + case 2: + ma.ca_email.w = &ma.w.email + ma.ca_email.m = &ma.cm + return &ma.ca_email + case 3: + ma.ca_name.w = &ma.w.name + ma.ca_name.m = &ma.cm + return &ma.ca_name default: panic("unreachable") } @@ -5410,18 +5410,18 @@ func (ma *_PersonInfo__ReprAssembler) Finish() error { } if ma.s&fieldBits__PersonInfo_sufficient != fieldBits__PersonInfo_sufficient { err := ipld.ErrMissingRequiredField{Missing: make([]string, 0)} - if ma.s&fieldBit__PersonInfo_Name == 0 { - err.Missing = append(err.Missing, "name") - } - if ma.s&fieldBit__PersonInfo_Email == 0 { - err.Missing = append(err.Missing, "email") - } if ma.s&fieldBit__PersonInfo_Date == 0 { err.Missing = append(err.Missing, "date") } if ma.s&fieldBit__PersonInfo_Timezone == 0 { err.Missing = append(err.Missing, "timezone") } + if ma.s&fieldBit__PersonInfo_Email == 0 { + err.Missing = append(err.Missing, "email") + } + if ma.s&fieldBit__PersonInfo_Name == 0 { + err.Missing = append(err.Missing, "name") + } return err } ma.state = maState_finished @@ -5460,35 +5460,35 @@ func (ka *_PersonInfo__ReprKeyAssembler) AssignString(k string) error { panic("misuse: KeyAssembler held beyond its valid lifetime") } switch k { - case "name": - if ka.s&fieldBit__PersonInfo_Name != 0 { - return ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Name_serial} + case "date": + if ka.s&fieldBit__PersonInfo_Date != 0 { + return ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Date_serial} } - ka.s += fieldBit__PersonInfo_Name + ka.s += fieldBit__PersonInfo_Date ka.state = maState_expectValue ka.f = 0 return nil - case "email": - if ka.s&fieldBit__PersonInfo_Email != 0 { - return ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Email_serial} + case "timezone": + if ka.s&fieldBit__PersonInfo_Timezone != 0 { + return ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Timezone_serial} } - ka.s += fieldBit__PersonInfo_Email + ka.s += fieldBit__PersonInfo_Timezone ka.state = maState_expectValue ka.f = 1 return nil - case "date": - if ka.s&fieldBit__PersonInfo_Date != 0 { - return ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Date_serial} + case "email": + if ka.s&fieldBit__PersonInfo_Email != 0 { + return ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Email_serial} } - ka.s += fieldBit__PersonInfo_Date + ka.s += fieldBit__PersonInfo_Email ka.state = maState_expectValue ka.f = 2 return nil - case "timezone": - if ka.s&fieldBit__PersonInfo_Timezone != 0 { - return ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Timezone_serial} + case "name": + if ka.s&fieldBit__PersonInfo_Name != 0 { + return ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Name_serial} } - ka.s += fieldBit__PersonInfo_Timezone + ka.s += fieldBit__PersonInfo_Name ka.state = maState_expectValue ka.f = 3 return nil @@ -5721,20 +5721,20 @@ var _ ipld.Node = &_String__Repr{} type _String__ReprPrototype = _String__Prototype type _String__ReprAssembler = _String__Assembler +func (n _Tag) FieldMessage() String { + return &n.message +} func (n _Tag) FieldObject() Link { return &n.object } -func (n _Tag) FieldTagType() String { - return &n.tagType -} func (n _Tag) FieldTag() String { return &n.tag } func (n _Tag) FieldTagger() PersonInfo { return &n.tagger } -func (n _Tag) FieldText() String { - return &n.text +func (n _Tag) FieldTagType() String { + return &n.tagType } type _Tag__Maybe struct { @@ -5772,11 +5772,11 @@ func (m MaybeTag) Must() Tag { } var ( + fieldName__Tag_Message = _String{"message"} fieldName__Tag_Object = _String{"object"} - fieldName__Tag_TagType = _String{"tagType"} fieldName__Tag_Tag = _String{"tag"} fieldName__Tag_Tagger = _String{"tagger"} - fieldName__Tag_Text = _String{"text"} + fieldName__Tag_TagType = _String{"tagType"} ) var _ ipld.Node = (Tag)(&_Tag{}) var _ schema.TypedNode = (Tag)(&_Tag{}) @@ -5786,16 +5786,16 @@ func (Tag) Kind() ipld.Kind { } func (n Tag) LookupByString(key string) (ipld.Node, error) { switch key { + case "message": + return &n.message, nil case "object": return &n.object, nil - case "tagType": - return &n.tagType, nil case "tag": return &n.tag, nil case "tagger": return &n.tagger, nil - case "text": - return &n.text, nil + case "tagType": + return &n.tagType, nil default: return nil, schema.ErrNoSuchField{Type: nil /*TODO*/, Field: ipld.PathSegmentOfString(key)} } @@ -5828,11 +5828,11 @@ func (itr *_Tag__MapItr) Next() (k ipld.Node, v ipld.Node, _ error) { } switch itr.idx { case 0: + k = &fieldName__Tag_Message + v = &itr.n.message + case 1: k = &fieldName__Tag_Object v = &itr.n.object - case 1: - k = &fieldName__Tag_TagType - v = &itr.n.tagType case 2: k = &fieldName__Tag_Tag v = &itr.n.tag @@ -5840,8 +5840,8 @@ func (itr *_Tag__MapItr) Next() (k ipld.Node, v ipld.Node, _ error) { k = &fieldName__Tag_Tagger v = &itr.n.tagger case 4: - k = &fieldName__Tag_Text - v = &itr.n.text + k = &fieldName__Tag_TagType + v = &itr.n.tagType default: panic("unreachable") } @@ -5918,29 +5918,29 @@ type _Tag__Assembler struct { f int cm schema.Maybe + ca_message _String__Assembler ca_object _Link__Assembler - ca_tagType _String__Assembler ca_tag _String__Assembler ca_tagger _PersonInfo__Assembler - ca_text _String__Assembler + ca_tagType _String__Assembler } func (na *_Tag__Assembler) reset() { na.state = maState_initial na.s = 0 + na.ca_message.reset() na.ca_object.reset() - na.ca_tagType.reset() na.ca_tag.reset() na.ca_tagger.reset() - na.ca_text.reset() + na.ca_tagType.reset() } var ( - fieldBit__Tag_Object = 1 << 0 - fieldBit__Tag_TagType = 1 << 1 + fieldBit__Tag_Message = 1 << 0 + fieldBit__Tag_Object = 1 << 1 fieldBit__Tag_Tag = 1 << 2 fieldBit__Tag_Tagger = 1 << 3 - fieldBit__Tag_Text = 1 << 4 + fieldBit__Tag_TagType = 1 << 4 fieldBits__Tag_sufficient = 0 + 1<<0 + 1<<1 + 1<<2 + 1<<3 + 1<<4 ) @@ -6038,7 +6038,7 @@ func (ma *_Tag__Assembler) valueFinishTidy() bool { case 0: switch ma.cm { case schema.Maybe_Value: - ma.ca_object.w = nil + ma.ca_message.w = nil ma.cm = schema.Maybe_Absent ma.state = maState_initial return true @@ -6048,7 +6048,7 @@ func (ma *_Tag__Assembler) valueFinishTidy() bool { case 1: switch ma.cm { case schema.Maybe_Value: - ma.ca_tagType.w = nil + ma.ca_object.w = nil ma.cm = schema.Maybe_Absent ma.state = maState_initial return true @@ -6078,7 +6078,7 @@ func (ma *_Tag__Assembler) valueFinishTidy() bool { case 4: switch ma.cm { case schema.Maybe_Value: - ma.ca_text.w = nil + ma.ca_tagType.w = nil ma.cm = schema.Maybe_Absent ma.state = maState_initial return true @@ -6105,26 +6105,26 @@ func (ma *_Tag__Assembler) AssembleEntry(k string) (ipld.NodeAssembler, error) { panic("invalid state: AssembleEntry cannot be called on an assembler that's already finished") } switch k { + case "message": + if ma.s&fieldBit__Tag_Message != 0 { + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Message} + } + ma.s += fieldBit__Tag_Message + ma.state = maState_midValue + ma.f = 0 + ma.ca_message.w = &ma.w.message + ma.ca_message.m = &ma.cm + return &ma.ca_message, nil case "object": if ma.s&fieldBit__Tag_Object != 0 { return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Object} } ma.s += fieldBit__Tag_Object ma.state = maState_midValue - ma.f = 0 + ma.f = 1 ma.ca_object.w = &ma.w.object ma.ca_object.m = &ma.cm return &ma.ca_object, nil - case "tagType": - if ma.s&fieldBit__Tag_TagType != 0 { - return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_TagType} - } - ma.s += fieldBit__Tag_TagType - ma.state = maState_midValue - ma.f = 1 - ma.ca_tagType.w = &ma.w.tagType - ma.ca_tagType.m = &ma.cm - return &ma.ca_tagType, nil case "tag": if ma.s&fieldBit__Tag_Tag != 0 { return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Tag} @@ -6145,16 +6145,16 @@ func (ma *_Tag__Assembler) AssembleEntry(k string) (ipld.NodeAssembler, error) { ma.ca_tagger.w = &ma.w.tagger ma.ca_tagger.m = &ma.cm return &ma.ca_tagger, nil - case "text": - if ma.s&fieldBit__Tag_Text != 0 { - return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Text} + case "tagType": + if ma.s&fieldBit__Tag_TagType != 0 { + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_TagType} } - ma.s += fieldBit__Tag_Text + ma.s += fieldBit__Tag_TagType ma.state = maState_midValue ma.f = 4 - ma.ca_text.w = &ma.w.text - ma.ca_text.m = &ma.cm - return &ma.ca_text, nil + ma.ca_tagType.w = &ma.w.tagType + ma.ca_tagType.m = &ma.cm + return &ma.ca_tagType, nil } return nil, ipld.ErrInvalidKey{TypeName: "ipldgit.Tag", Key: &_String{k}} } @@ -6192,13 +6192,13 @@ func (ma *_Tag__Assembler) AssembleValue() ipld.NodeAssembler { ma.state = maState_midValue switch ma.f { case 0: + ma.ca_message.w = &ma.w.message + ma.ca_message.m = &ma.cm + return &ma.ca_message + case 1: ma.ca_object.w = &ma.w.object ma.ca_object.m = &ma.cm return &ma.ca_object - case 1: - ma.ca_tagType.w = &ma.w.tagType - ma.ca_tagType.m = &ma.cm - return &ma.ca_tagType case 2: ma.ca_tag.w = &ma.w.tag ma.ca_tag.m = &ma.cm @@ -6208,9 +6208,9 @@ func (ma *_Tag__Assembler) AssembleValue() ipld.NodeAssembler { ma.ca_tagger.m = &ma.cm return &ma.ca_tagger case 4: - ma.ca_text.w = &ma.w.text - ma.ca_text.m = &ma.cm - return &ma.ca_text + ma.ca_tagType.w = &ma.w.tagType + ma.ca_tagType.m = &ma.cm + return &ma.ca_tagType default: panic("unreachable") } @@ -6232,20 +6232,20 @@ func (ma *_Tag__Assembler) Finish() error { } if ma.s&fieldBits__Tag_sufficient != fieldBits__Tag_sufficient { err := ipld.ErrMissingRequiredField{Missing: make([]string, 0)} + if ma.s&fieldBit__Tag_Message == 0 { + err.Missing = append(err.Missing, "message") + } if ma.s&fieldBit__Tag_Object == 0 { err.Missing = append(err.Missing, "object") } - if ma.s&fieldBit__Tag_TagType == 0 { - err.Missing = append(err.Missing, "tagType") - } if ma.s&fieldBit__Tag_Tag == 0 { err.Missing = append(err.Missing, "tag") } if ma.s&fieldBit__Tag_Tagger == 0 { err.Missing = append(err.Missing, "tagger") } - if ma.s&fieldBit__Tag_Text == 0 { - err.Missing = append(err.Missing, "text") + if ma.s&fieldBit__Tag_TagType == 0 { + err.Missing = append(err.Missing, "tagType") } return err } @@ -6285,19 +6285,19 @@ func (ka *_Tag__KeyAssembler) AssignString(k string) error { panic("misuse: KeyAssembler held beyond its valid lifetime") } switch k { - case "object": - if ka.s&fieldBit__Tag_Object != 0 { - return ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Object} + case "message": + if ka.s&fieldBit__Tag_Message != 0 { + return ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Message} } - ka.s += fieldBit__Tag_Object + ka.s += fieldBit__Tag_Message ka.state = maState_expectValue ka.f = 0 return nil - case "tagType": - if ka.s&fieldBit__Tag_TagType != 0 { - return ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_TagType} + case "object": + if ka.s&fieldBit__Tag_Object != 0 { + return ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Object} } - ka.s += fieldBit__Tag_TagType + ka.s += fieldBit__Tag_Object ka.state = maState_expectValue ka.f = 1 return nil @@ -6317,11 +6317,11 @@ func (ka *_Tag__KeyAssembler) AssignString(k string) error { ka.state = maState_expectValue ka.f = 3 return nil - case "text": - if ka.s&fieldBit__Tag_Text != 0 { - return ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Text} + case "tagType": + if ka.s&fieldBit__Tag_TagType != 0 { + return ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_TagType} } - ka.s += fieldBit__Tag_Text + ka.s += fieldBit__Tag_TagType ka.state = maState_expectValue ka.f = 4 return nil @@ -6355,11 +6355,11 @@ func (n Tag) Representation() ipld.Node { type _Tag__Repr _Tag var ( + fieldName__Tag_Message_serial = _String{"message"} fieldName__Tag_Object_serial = _String{"object"} - fieldName__Tag_TagType_serial = _String{"tagType"} fieldName__Tag_Tag_serial = _String{"tag"} fieldName__Tag_Tagger_serial = _String{"tagger"} - fieldName__Tag_Text_serial = _String{"text"} + fieldName__Tag_TagType_serial = _String{"tagType"} ) var _ ipld.Node = &_Tag__Repr{} @@ -6368,16 +6368,16 @@ func (_Tag__Repr) Kind() ipld.Kind { } func (n *_Tag__Repr) LookupByString(key string) (ipld.Node, error) { switch key { + case "message": + return n.message.Representation(), nil case "object": return n.object.Representation(), nil - case "tagType": - return n.tagType.Representation(), nil case "tag": return n.tag.Representation(), nil case "tagger": return n.tagger.Representation(), nil - case "text": - return n.text.Representation(), nil + case "tagType": + return n.tagType.Representation(), nil default: return nil, schema.ErrNoSuchField{Type: nil /*TODO*/, Field: ipld.PathSegmentOfString(key)} } @@ -6410,11 +6410,11 @@ func (itr *_Tag__ReprMapItr) Next() (k ipld.Node, v ipld.Node, _ error) { } switch itr.idx { case 0: + k = &fieldName__Tag_Message_serial + v = itr.n.message.Representation() + case 1: k = &fieldName__Tag_Object_serial v = itr.n.object.Representation() - case 1: - k = &fieldName__Tag_TagType_serial - v = itr.n.tagType.Representation() case 2: k = &fieldName__Tag_Tag_serial v = itr.n.tag.Representation() @@ -6422,8 +6422,8 @@ func (itr *_Tag__ReprMapItr) Next() (k ipld.Node, v ipld.Node, _ error) { k = &fieldName__Tag_Tagger_serial v = itr.n.tagger.Representation() case 4: - k = &fieldName__Tag_Text_serial - v = itr.n.text.Representation() + k = &fieldName__Tag_TagType_serial + v = itr.n.tagType.Representation() default: panic("unreachable") } @@ -6500,21 +6500,21 @@ type _Tag__ReprAssembler struct { f int cm schema.Maybe + ca_message _String__ReprAssembler ca_object _Link__ReprAssembler - ca_tagType _String__ReprAssembler ca_tag _String__ReprAssembler ca_tagger _PersonInfo__ReprAssembler - ca_text _String__ReprAssembler + ca_tagType _String__ReprAssembler } func (na *_Tag__ReprAssembler) reset() { na.state = maState_initial na.s = 0 + na.ca_message.reset() na.ca_object.reset() - na.ca_tagType.reset() na.ca_tag.reset() na.ca_tagger.reset() - na.ca_text.reset() + na.ca_tagType.reset() } func (na *_Tag__ReprAssembler) BeginMap(int64) (ipld.MapAssembler, error) { switch *na.m { @@ -6672,26 +6672,26 @@ func (ma *_Tag__ReprAssembler) AssembleEntry(k string) (ipld.NodeAssembler, erro panic("invalid state: AssembleEntry cannot be called on an assembler that's already finished") } switch k { + case "message": + if ma.s&fieldBit__Tag_Message != 0 { + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Message_serial} + } + ma.s += fieldBit__Tag_Message + ma.state = maState_midValue + ma.f = 0 + ma.ca_message.w = &ma.w.message + ma.ca_message.m = &ma.cm + return &ma.ca_message, nil case "object": if ma.s&fieldBit__Tag_Object != 0 { return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Object_serial} } ma.s += fieldBit__Tag_Object ma.state = maState_midValue - ma.f = 0 + ma.f = 1 ma.ca_object.w = &ma.w.object ma.ca_object.m = &ma.cm return &ma.ca_object, nil - case "tagType": - if ma.s&fieldBit__Tag_TagType != 0 { - return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_TagType_serial} - } - ma.s += fieldBit__Tag_TagType - ma.state = maState_midValue - ma.f = 1 - ma.ca_tagType.w = &ma.w.tagType - ma.ca_tagType.m = &ma.cm - return &ma.ca_tagType, nil case "tag": if ma.s&fieldBit__Tag_Tag != 0 { return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Tag_serial} @@ -6712,16 +6712,16 @@ func (ma *_Tag__ReprAssembler) AssembleEntry(k string) (ipld.NodeAssembler, erro ma.ca_tagger.w = &ma.w.tagger ma.ca_tagger.m = &ma.cm return &ma.ca_tagger, nil - case "text": - if ma.s&fieldBit__Tag_Text != 0 { - return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Text_serial} + case "tagType": + if ma.s&fieldBit__Tag_TagType != 0 { + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_TagType_serial} } - ma.s += fieldBit__Tag_Text + ma.s += fieldBit__Tag_TagType ma.state = maState_midValue ma.f = 4 - ma.ca_text.w = &ma.w.text - ma.ca_text.m = &ma.cm - return &ma.ca_text, nil + ma.ca_tagType.w = &ma.w.tagType + ma.ca_tagType.m = &ma.cm + return &ma.ca_tagType, nil default: } return nil, ipld.ErrInvalidKey{TypeName: "ipldgit.Tag.Repr", Key: &_String{k}} @@ -6760,13 +6760,13 @@ func (ma *_Tag__ReprAssembler) AssembleValue() ipld.NodeAssembler { ma.state = maState_midValue switch ma.f { case 0: + ma.ca_message.w = &ma.w.message + ma.ca_message.m = &ma.cm + return &ma.ca_message + case 1: ma.ca_object.w = &ma.w.object ma.ca_object.m = &ma.cm return &ma.ca_object - case 1: - ma.ca_tagType.w = &ma.w.tagType - ma.ca_tagType.m = &ma.cm - return &ma.ca_tagType case 2: ma.ca_tag.w = &ma.w.tag ma.ca_tag.m = &ma.cm @@ -6776,9 +6776,9 @@ func (ma *_Tag__ReprAssembler) AssembleValue() ipld.NodeAssembler { ma.ca_tagger.m = &ma.cm return &ma.ca_tagger case 4: - ma.ca_text.w = &ma.w.text - ma.ca_text.m = &ma.cm - return &ma.ca_text + ma.ca_tagType.w = &ma.w.tagType + ma.ca_tagType.m = &ma.cm + return &ma.ca_tagType default: panic("unreachable") } @@ -6800,20 +6800,20 @@ func (ma *_Tag__ReprAssembler) Finish() error { } if ma.s&fieldBits__Tag_sufficient != fieldBits__Tag_sufficient { err := ipld.ErrMissingRequiredField{Missing: make([]string, 0)} + if ma.s&fieldBit__Tag_Message == 0 { + err.Missing = append(err.Missing, "message") + } if ma.s&fieldBit__Tag_Object == 0 { err.Missing = append(err.Missing, "object") } - if ma.s&fieldBit__Tag_TagType == 0 { - err.Missing = append(err.Missing, "tagType") - } if ma.s&fieldBit__Tag_Tag == 0 { err.Missing = append(err.Missing, "tag") } if ma.s&fieldBit__Tag_Tagger == 0 { err.Missing = append(err.Missing, "tagger") } - if ma.s&fieldBit__Tag_Text == 0 { - err.Missing = append(err.Missing, "text") + if ma.s&fieldBit__Tag_TagType == 0 { + err.Missing = append(err.Missing, "tagType") } return err } @@ -6853,19 +6853,19 @@ func (ka *_Tag__ReprKeyAssembler) AssignString(k string) error { panic("misuse: KeyAssembler held beyond its valid lifetime") } switch k { - case "object": - if ka.s&fieldBit__Tag_Object != 0 { - return ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Object_serial} + case "message": + if ka.s&fieldBit__Tag_Message != 0 { + return ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Message_serial} } - ka.s += fieldBit__Tag_Object + ka.s += fieldBit__Tag_Message ka.state = maState_expectValue ka.f = 0 return nil - case "tagType": - if ka.s&fieldBit__Tag_TagType != 0 { - return ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_TagType_serial} + case "object": + if ka.s&fieldBit__Tag_Object != 0 { + return ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Object_serial} } - ka.s += fieldBit__Tag_TagType + ka.s += fieldBit__Tag_Object ka.state = maState_expectValue ka.f = 1 return nil @@ -6885,11 +6885,11 @@ func (ka *_Tag__ReprKeyAssembler) AssignString(k string) error { ka.state = maState_expectValue ka.f = 3 return nil - case "text": - if ka.s&fieldBit__Tag_Text != 0 { - return ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Text_serial} + case "tagType": + if ka.s&fieldBit__Tag_TagType != 0 { + return ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_TagType_serial} } - ka.s += fieldBit__Tag_Text + ka.s += fieldBit__Tag_TagType ka.state = maState_expectValue ka.f = 4 return nil diff --git a/ipldsch_types.go b/ipldsch_types.go index 683a8e0..aa6e294 100644 --- a/ipldsch_types.go +++ b/ipldsch_types.go @@ -59,11 +59,11 @@ type _Blob struct{ x []byte } // Commit matches the IPLD Schema type "Commit". It has Struct type-kind, and may be interrogated like map kind. type Commit = *_Commit type _Commit struct { - tree _LinkTree - parents _ListParents - message _String author _PersonInfo__Maybe committer _PersonInfo__Maybe + message _String + parents _ListParents + tree _LinkTree encoding _String__Maybe signature _GpgSig__Maybe mergeTag _ListTag @@ -107,10 +107,10 @@ type _ListTag struct { // PersonInfo matches the IPLD Schema type "PersonInfo". It has Struct type-kind, and may be interrogated like map kind. type PersonInfo = *_PersonInfo type _PersonInfo struct { - name _String - email _String date _String timezone _String + email _String + name _String } // String matches the IPLD Schema type "String". It has string kind. @@ -120,11 +120,11 @@ type _String struct{ x string } // Tag matches the IPLD Schema type "Tag". It has Struct type-kind, and may be interrogated like map kind. type Tag = *_Tag type _Tag struct { + message _String object _Link - tagType _String tag _String tagger _PersonInfo - text _String + tagType _String } // Tree matches the IPLD Schema type "Tree". It has map kind. diff --git a/tag.go b/tag.go index d38d5ed..9cd6384 100644 --- a/tag.go +++ b/tag.go @@ -59,7 +59,7 @@ func DecodeTag(na ipld.NodeAssembler, rd *bufio.Reader) error { return err } - out.text = _String{string(rest)} + out.message = _String{string(rest)} default: fmt.Println("unhandled line: ", string(line)) } @@ -104,7 +104,7 @@ func readMergeTag(hash []byte, rd *bufio.Reader) (Tag, []byte, error) { return &out, line, nil } - out.text.x += string(line) + "\n" + out.message.x += string(line) + "\n" } } } @@ -139,11 +139,11 @@ func encodeTag(n ipld.Node, w io.Writer) error { return err } - text, err := n.LookupByString("text") + message, err := n.LookupByString("message") if err != nil { return err } - textStr, err := text.AsString() + messageStr, err := message.AsString() if err != nil { return err } @@ -166,8 +166,8 @@ func encodeTag(n ipld.Node, w io.Writer) error { } fmt.Fprintf(buf, "tagger %s\n", parsed.GitString()) } - if textStr != "" { - fmt.Fprintf(buf, "\n%s", textStr) + if messageStr != "" { + fmt.Fprintf(buf, "\n%s", messageStr) } if _, err := fmt.Fprintf(w, "tag %d\x00", buf.Len()); err != nil { From b2b169a9960314bfc376296546d6491d7d835ae2 Mon Sep 17 00:00:00 2001 From: Rod Vagg Date: Thu, 29 Jul 2021 13:07:57 +1000 Subject: [PATCH 18/22] fix: add back json tests --- git_test.go | 28 +++++++++++++++------------- 1 file changed, 15 insertions(+), 13 deletions(-) diff --git a/git_test.go b/git_test.go index d608791..55f6a2c 100644 --- a/git_test.go +++ b/git_test.go @@ -13,6 +13,7 @@ import ( "github.com/ipfs/go-cid" "github.com/ipld/go-ipld-prime" + "github.com/ipld/go-ipld-prime/codec/dagjson" cidlink "github.com/ipld/go-ipld-prime/linking/cid" "github.com/multiformats/go-multihash" ) @@ -362,34 +363,35 @@ func TestParsePersonInfo(t *testing.T) { assert(t, pi.GitString() == "Someone ") - /* TODO: json + buf := new(bytes.Buffer) + pi, err = parsePersonInfo([]byte("prefix Łukasz Magiera 1546187652 +0100")) assert(t, err == nil) - piJSON, err := pi.MarshalJSON() - assert(t, err == nil) - date, _, err := pi.resolve([]string{"date"}) + buf.Reset() + err = dagjson.Encode(pi, buf) assert(t, err == nil) - assert(t, string(piJSON) == `{"date":"2018-12-30T17:34:12+01:00","email":"magik6k@users.noreply.github.com","name":"Łukasz Magiera"}`) - assert(t, date == "2018-12-30T17:34:12+01:00") + assert(t, buf.String() == `{"date":"1546187652","email":"magik6k@users.noreply.github.com","name":"Łukasz Magiera","timezone":"+0100"}`) pi, err = parsePersonInfo([]byte("prefix Sameer 1545162499 -0500")) assert(t, err == nil) - piJSON, err = pi.MarshalJSON() + buf.Reset() + err = dagjson.Encode(pi, buf) assert(t, err == nil) - assert(t, string(piJSON) == `{"date":"2018-12-18T14:48:19-05:00","email":"sameer@users.noreply.github.com","name":"Sameer"}`) + assert(t, buf.String() == `{"date":"1545162499","email":"sameer@users.noreply.github.com","name":"Sameer","timezone":"-0500"}`) pi, err = parsePersonInfo([]byte("prefix Łukasz Magiera 1546187652 +0122")) assert(t, err == nil) - piJSON, err = pi.MarshalJSON() + buf.Reset() + err = dagjson.Encode(pi, buf) assert(t, err == nil) - assert(t, string(piJSON) == `{"date":"2018-12-30T17:56:12+01:22","email":"magik6k@users.noreply.github.com","name":"Łukasz Magiera"}`) + assert(t, buf.String() == `{"date":"1546187652","email":"magik6k@users.noreply.github.com","name":"Łukasz Magiera","timezone":"+0122"}`) pi, err = parsePersonInfo([]byte("prefix Sameer 1545162499 -0545")) assert(t, err == nil) - piJSON, err = pi.MarshalJSON() + buf.Reset() + err = dagjson.Encode(pi, buf) assert(t, err == nil) - assert(t, string(piJSON) == `{"date":"2018-12-18T14:03:19-05:45","email":"sameer@users.noreply.github.com","name":"Sameer"}`) - */ + assert(t, buf.String() == `{"date":"1545162499","email":"sameer@users.noreply.github.com","name":"Sameer","timezone":"-0545"}`) } func assert(t *testing.T, ok bool) { From 4e0e59b7d5d86dc88a7bf03a638883627d3f6ca5 Mon Sep 17 00:00:00 2001 From: Will Scott Date: Fri, 30 Jul 2021 15:12:41 -0700 Subject: [PATCH 19/22] add back maintainers to readme --- README.md | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/README.md b/README.md index 8287513..6725735 100644 --- a/README.md +++ b/README.md @@ -143,6 +143,11 @@ As JSON, real data would look something like: "\0'>" ``` +## Lead Maintainers + +[Will Scott](https://github.com/willscott) +[Rod Vagg](https://github.com/rvagg) + ## Contribute PRs are welcome! From 5cc00cffc6d19207a229836d9998294a9f8b0735 Mon Sep 17 00:00:00 2001 From: Rod Vagg Date: Sat, 31 Jul 2021 15:16:30 +1000 Subject: [PATCH 20/22] Further minimise changes to current release * mergeTag -> mergetag * tagType -> type --- README.md | 16 +- commit.go | 14 +- gen/gen.go | 36 +- git_test.go | 6 +- ipldsch_satisfaction.go | 6506 +++++++++++++++++++-------------------- ipldsch_types.go | 122 +- marshal.go | 2 +- tag.go | 6 +- util.go | 4 +- 9 files changed, 3363 insertions(+), 3349 deletions(-) diff --git a/README.md b/README.md index 6725735..9de69ba 100644 --- a/README.md +++ b/README.md @@ -38,14 +38,14 @@ type PersonInfo struct { } type Commit struct { + tree &Tree # see "Tree" section below + parents [&Commit] + message String author optional PersonInfo committer optional PersonInfo - message String - parents [&Commit] - tree &Tree # see "Tree" section below encoding optional String signature optional GpgSig - mergeTag [Tag] + mergetag [Tag] other [String] } ``` @@ -78,11 +78,11 @@ As JSON, real data would look something like: ```ipldsch type Tag struct { - message String object &Any + type String tag String tagger PersonInfo - tagType String + message String } ``` @@ -145,8 +145,8 @@ As JSON, real data would look something like: ## Lead Maintainers -[Will Scott](https://github.com/willscott) -[Rod Vagg](https://github.com/rvagg) +* [Will Scott](https://github.com/willscott) +* [Rod Vagg](https://github.com/rvagg) ## Contribute diff --git a/commit.go b/commit.go index 51953ae..aa16693 100644 --- a/commit.go +++ b/commit.go @@ -23,9 +23,7 @@ func DecodeCommit(na ipld.NodeAssembler, rd *bufio.Reader) error { } c := _Commit{ - parents: _ListParents{[]_LinkCommit{}}, - mergeTag: _ListTag{[]_Tag{}}, - other: _ListString{[]_String{}}, + parents: _Commit_Link_List{[]_Commit_Link{}}, } for { line, _, err := rd.ReadLine() @@ -53,14 +51,14 @@ func decodeCommitLine(c Commit, line []byte, rd *bufio.Reader) error { return err } - c.tree = _LinkTree{cidlink.Link{Cid: shaToCid(sha)}} + c.tree = _Tree_Link{cidlink.Link{Cid: shaToCid(sha)}} case bytes.HasPrefix(line, []byte("parent ")): psha, err := hex.DecodeString(string(line[7:])) if err != nil { return err } - c.parents.x = append(c.parents.x, _LinkCommit{cidlink.Link{Cid: shaToCid(psha)}}) + c.parents.x = append(c.parents.x, _Commit_Link{cidlink.Link{Cid: shaToCid(psha)}}) case bytes.HasPrefix(line, []byte("author ")): a, err := parsePersonInfo(line) if err != nil { @@ -88,7 +86,7 @@ func decodeCommitLine(c Commit, line []byte, rd *bufio.Reader) error { return err } - c.mergeTag.x = append(c.mergeTag.x, *mt) + c.mergetag.x = append(c.mergetag.x, *mt) if rest != nil { err = decodeCommitLine(c, rest, rd) @@ -167,9 +165,9 @@ func encodeCommit(n ipld.Node, w io.Writer) error { if c.encoding.m == schema.Maybe_Value { fmt.Fprintf(buf, "encoding %s\n", c.encoding.v.x) } - for _, mtag := range c.mergeTag.x { + for _, mtag := range c.mergetag.x { fmt.Fprintf(buf, "mergetag object %s\n", hex.EncodeToString(mtag.object.sha())) - fmt.Fprintf(buf, " type %s\n", mtag.tagType.x) + fmt.Fprintf(buf, " type %s\n", mtag.typ.x) fmt.Fprintf(buf, " tag %s\n", mtag.tag.x) fmt.Fprintf(buf, " tagger %s\n \n", mtag.tagger.GitString()) fmt.Fprintf(buf, "%s", mtag.message.x) diff --git a/gen/gen.go b/gen/gen.go index 34ddd07..c29d1b8 100644 --- a/gen/gen.go +++ b/gen/gen.go @@ -13,45 +13,57 @@ func main() { ts.Init() adjCfg := &gengo.AdjunctCfg{ CfgUnionMemlayout: map[schema.TypeName]string{}, + FieldSymbolLowerOverrides: map[gengo.FieldTuple]string{ + {TypeName: "Tag", FieldName: "type"}: "typ", + }, } + ts.Accumulate(schema.SpawnString("String")) - ts.Accumulate(schema.SpawnList("ListString", "String", false)) ts.Accumulate(schema.SpawnLink("Link")) + + ts.Accumulate(schema.SpawnList("String_List", "String", false)) + ts.Accumulate(schema.SpawnStruct("PersonInfo", []schema.StructField{ schema.SpawnStructField("date", "String", false, false), schema.SpawnStructField("timezone", "String", false, false), schema.SpawnStructField("email", "String", false, false), schema.SpawnStructField("name", "String", false, false), }, schema.SpawnStructRepresentationMap(map[string]string{}))) + ts.Accumulate(schema.SpawnString("GpgSig")) + ts.Accumulate(schema.SpawnStruct("Tag", []schema.StructField{ - schema.SpawnStructField("message", "String", false, false), schema.SpawnStructField("object", "Link", false, false), + schema.SpawnStructField("type", "String", false, false), schema.SpawnStructField("tag", "String", false, false), schema.SpawnStructField("tagger", "PersonInfo", false, false), - schema.SpawnStructField("tagType", "String", false, false), + schema.SpawnStructField("message", "String", false, false), }, schema.SpawnStructRepresentationMap(map[string]string{}))) - ts.Accumulate(schema.SpawnList("ListTag", "Tag", false)) - ts.Accumulate(schema.SpawnLinkReference("LinkCommit", "Commit")) - ts.Accumulate(schema.SpawnList("ListParents", "LinkCommit", false)) + + ts.Accumulate(schema.SpawnList("Tag_List", "Tag", false)) + ts.Accumulate(schema.SpawnStruct("Commit", []schema.StructField{ + schema.SpawnStructField("tree", "Tree_Link", false, false), + schema.SpawnStructField("parents", "Commit_Link_List", false, false), + schema.SpawnStructField("message", "String", false, false), schema.SpawnStructField("author", "PersonInfo", true, false), schema.SpawnStructField("committer", "PersonInfo", true, false), - schema.SpawnStructField("message", "String", false, false), - schema.SpawnStructField("parents", "ListParents", false, false), - schema.SpawnStructField("tree", "LinkTree", false, false), schema.SpawnStructField("encoding", "String", true, false), schema.SpawnStructField("signature", "GpgSig", true, false), - schema.SpawnStructField("mergeTag", "ListTag", false, false), - schema.SpawnStructField("other", "ListString", false, false), + schema.SpawnStructField("mergetag", "Tag_List", false, false), + schema.SpawnStructField("other", "String_List", false, false), }, schema.SpawnStructRepresentationMap(map[string]string{}))) + ts.Accumulate(schema.SpawnLinkReference("Commit_Link", "Commit")) + ts.Accumulate(schema.SpawnList("Commit_Link_List", "Commit_Link", false)) + ts.Accumulate(schema.SpawnBytes("Blob")) + ts.Accumulate(schema.SpawnMap("Tree", "String", "TreeEntry", false)) - ts.Accumulate(schema.SpawnLinkReference("LinkTree", "Tree")) ts.Accumulate(schema.SpawnStruct("TreeEntry", []schema.StructField{ schema.SpawnStructField("mode", "String", false, false), schema.SpawnStructField("hash", "Link", false, false), }, schema.SpawnStructRepresentationMap(map[string]string{}))) + ts.Accumulate(schema.SpawnLinkReference("Tree_Link", "Tree")) if errs := ts.ValidateGraph(); errs != nil { for _, err := range errs { diff --git a/git_test.go b/git_test.go index 55f6a2c..354e91b 100644 --- a/git_test.go +++ b/git_test.go @@ -209,7 +209,7 @@ func testNode(t *testing.T, nd ipld.Node) error { t.Fatalf("Tag is not a tag") } - tt, err := tag.tagType.AsString() + tt, err := tag.typ.AsString() assert(t, err == nil) assert(t, tt == "commit" || tt == "tree" || tt == "blob" || tt == "tag") @@ -222,7 +222,11 @@ func testNode(t *testing.T, nd ipld.Node) error { } assert(t, len(tree.m) > 0) + + default: + return fmt.Errorf("unexpected or unknown NodePrototype %v", nd.Prototype()) } + return nil } diff --git a/ipldsch_satisfaction.go b/ipldsch_satisfaction.go index 58496dd..47301f4 100644 --- a/ipldsch_satisfaction.go +++ b/ipldsch_satisfaction.go @@ -213,20 +213,20 @@ var _ ipld.Node = &_Blob__Repr{} type _Blob__ReprPrototype = _Blob__Prototype type _Blob__ReprAssembler = _Blob__Assembler -func (n _Commit) FieldAuthor() MaybePersonInfo { - return &n.author +func (n _Commit) FieldTree() Tree_Link { + return &n.tree } -func (n _Commit) FieldCommitter() MaybePersonInfo { - return &n.committer +func (n _Commit) FieldParents() Commit_Link_List { + return &n.parents } func (n _Commit) FieldMessage() String { return &n.message } -func (n _Commit) FieldParents() ListParents { - return &n.parents +func (n _Commit) FieldAuthor() MaybePersonInfo { + return &n.author } -func (n _Commit) FieldTree() LinkTree { - return &n.tree +func (n _Commit) FieldCommitter() MaybePersonInfo { + return &n.committer } func (n _Commit) FieldEncoding() MaybeString { return &n.encoding @@ -234,10 +234,10 @@ func (n _Commit) FieldEncoding() MaybeString { func (n _Commit) FieldSignature() MaybeGpgSig { return &n.signature } -func (n _Commit) FieldMergeTag() ListTag { - return &n.mergeTag +func (n _Commit) FieldMergetag() Tag_List { + return &n.mergetag } -func (n _Commit) FieldOther() ListString { +func (n _Commit) FieldOther() String_List { return &n.other } @@ -276,14 +276,14 @@ func (m MaybeCommit) Must() Commit { } var ( + fieldName__Commit_Tree = _String{"tree"} + fieldName__Commit_Parents = _String{"parents"} + fieldName__Commit_Message = _String{"message"} fieldName__Commit_Author = _String{"author"} fieldName__Commit_Committer = _String{"committer"} - fieldName__Commit_Message = _String{"message"} - fieldName__Commit_Parents = _String{"parents"} - fieldName__Commit_Tree = _String{"tree"} fieldName__Commit_Encoding = _String{"encoding"} fieldName__Commit_Signature = _String{"signature"} - fieldName__Commit_MergeTag = _String{"mergeTag"} + fieldName__Commit_Mergetag = _String{"mergetag"} fieldName__Commit_Other = _String{"other"} ) var _ ipld.Node = (Commit)(&_Commit{}) @@ -294,6 +294,12 @@ func (Commit) Kind() ipld.Kind { } func (n Commit) LookupByString(key string) (ipld.Node, error) { switch key { + case "tree": + return &n.tree, nil + case "parents": + return &n.parents, nil + case "message": + return &n.message, nil case "author": if n.author.m == schema.Maybe_Absent { return ipld.Absent, nil @@ -304,12 +310,6 @@ func (n Commit) LookupByString(key string) (ipld.Node, error) { return ipld.Absent, nil } return n.committer.v, nil - case "message": - return &n.message, nil - case "parents": - return &n.parents, nil - case "tree": - return &n.tree, nil case "encoding": if n.encoding.m == schema.Maybe_Absent { return ipld.Absent, nil @@ -320,8 +320,8 @@ func (n Commit) LookupByString(key string) (ipld.Node, error) { return ipld.Absent, nil } return &n.signature.v, nil - case "mergeTag": - return &n.mergeTag, nil + case "mergetag": + return &n.mergetag, nil case "other": return &n.other, nil default: @@ -356,28 +356,28 @@ func (itr *_Commit__MapItr) Next() (k ipld.Node, v ipld.Node, _ error) { } switch itr.idx { case 0: + k = &fieldName__Commit_Tree + v = &itr.n.tree + case 1: + k = &fieldName__Commit_Parents + v = &itr.n.parents + case 2: + k = &fieldName__Commit_Message + v = &itr.n.message + case 3: k = &fieldName__Commit_Author if itr.n.author.m == schema.Maybe_Absent { v = ipld.Absent break } v = itr.n.author.v - case 1: + case 4: k = &fieldName__Commit_Committer if itr.n.committer.m == schema.Maybe_Absent { v = ipld.Absent break } v = itr.n.committer.v - case 2: - k = &fieldName__Commit_Message - v = &itr.n.message - case 3: - k = &fieldName__Commit_Parents - v = &itr.n.parents - case 4: - k = &fieldName__Commit_Tree - v = &itr.n.tree case 5: k = &fieldName__Commit_Encoding if itr.n.encoding.m == schema.Maybe_Absent { @@ -393,8 +393,8 @@ func (itr *_Commit__MapItr) Next() (k ipld.Node, v ipld.Node, _ error) { } v = &itr.n.signature.v case 7: - k = &fieldName__Commit_MergeTag - v = &itr.n.mergeTag + k = &fieldName__Commit_Mergetag + v = &itr.n.mergetag case 8: k = &fieldName__Commit_Other v = &itr.n.other @@ -474,42 +474,42 @@ type _Commit__Assembler struct { f int cm schema.Maybe + ca_tree _Tree_Link__Assembler + ca_parents _Commit_Link_List__Assembler + ca_message _String__Assembler ca_author _PersonInfo__Assembler ca_committer _PersonInfo__Assembler - ca_message _String__Assembler - ca_parents _ListParents__Assembler - ca_tree _LinkTree__Assembler ca_encoding _String__Assembler ca_signature _GpgSig__Assembler - ca_mergeTag _ListTag__Assembler - ca_other _ListString__Assembler + ca_mergetag _Tag_List__Assembler + ca_other _String_List__Assembler } func (na *_Commit__Assembler) reset() { na.state = maState_initial na.s = 0 + na.ca_tree.reset() + na.ca_parents.reset() + na.ca_message.reset() na.ca_author.reset() na.ca_committer.reset() - na.ca_message.reset() - na.ca_parents.reset() - na.ca_tree.reset() na.ca_encoding.reset() na.ca_signature.reset() - na.ca_mergeTag.reset() + na.ca_mergetag.reset() na.ca_other.reset() } var ( - fieldBit__Commit_Author = 1 << 0 - fieldBit__Commit_Committer = 1 << 1 + fieldBit__Commit_Tree = 1 << 0 + fieldBit__Commit_Parents = 1 << 1 fieldBit__Commit_Message = 1 << 2 - fieldBit__Commit_Parents = 1 << 3 - fieldBit__Commit_Tree = 1 << 4 + fieldBit__Commit_Author = 1 << 3 + fieldBit__Commit_Committer = 1 << 4 fieldBit__Commit_Encoding = 1 << 5 fieldBit__Commit_Signature = 1 << 6 - fieldBit__Commit_MergeTag = 1 << 7 + fieldBit__Commit_Mergetag = 1 << 7 fieldBit__Commit_Other = 1 << 8 - fieldBits__Commit_sufficient = 0 + 1<<2 + 1<<3 + 1<<4 + 1<<7 + 1<<8 + fieldBits__Commit_sufficient = 0 + 1<<0 + 1<<1 + 1<<2 + 1<<7 + 1<<8 ) func (na *_Commit__Assembler) BeginMap(int64) (ipld.MapAssembler, error) { @@ -604,18 +604,20 @@ func (_Commit__Assembler) Prototype() ipld.NodePrototype { func (ma *_Commit__Assembler) valueFinishTidy() bool { switch ma.f { case 0: - switch ma.w.author.m { + switch ma.cm { case schema.Maybe_Value: - ma.w.author.v = ma.ca_author.w + ma.ca_tree.w = nil + ma.cm = schema.Maybe_Absent ma.state = maState_initial return true default: return false } case 1: - switch ma.w.committer.m { + switch ma.cm { case schema.Maybe_Value: - ma.w.committer.v = ma.ca_committer.w + ma.ca_parents.w = nil + ma.cm = schema.Maybe_Absent ma.state = maState_initial return true default: @@ -632,20 +634,18 @@ func (ma *_Commit__Assembler) valueFinishTidy() bool { return false } case 3: - switch ma.cm { + switch ma.w.author.m { case schema.Maybe_Value: - ma.ca_parents.w = nil - ma.cm = schema.Maybe_Absent + ma.w.author.v = ma.ca_author.w ma.state = maState_initial return true default: return false } case 4: - switch ma.cm { + switch ma.w.committer.m { case schema.Maybe_Value: - ma.ca_tree.w = nil - ma.cm = schema.Maybe_Absent + ma.w.committer.v = ma.ca_committer.w ma.state = maState_initial return true default: @@ -670,7 +670,7 @@ func (ma *_Commit__Assembler) valueFinishTidy() bool { case 7: switch ma.cm { case schema.Maybe_Value: - ma.ca_mergeTag.w = nil + ma.ca_mergetag.w = nil ma.cm = schema.Maybe_Absent ma.state = maState_initial return true @@ -707,26 +707,26 @@ func (ma *_Commit__Assembler) AssembleEntry(k string) (ipld.NodeAssembler, error panic("invalid state: AssembleEntry cannot be called on an assembler that's already finished") } switch k { - case "author": - if ma.s&fieldBit__Commit_Author != 0 { - return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Author} + case "tree": + if ma.s&fieldBit__Commit_Tree != 0 { + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Tree} } - ma.s += fieldBit__Commit_Author + ma.s += fieldBit__Commit_Tree ma.state = maState_midValue ma.f = 0 - ma.ca_author.w = ma.w.author.v - ma.ca_author.m = &ma.w.author.m - return &ma.ca_author, nil - case "committer": - if ma.s&fieldBit__Commit_Committer != 0 { - return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Committer} + ma.ca_tree.w = &ma.w.tree + ma.ca_tree.m = &ma.cm + return &ma.ca_tree, nil + case "parents": + if ma.s&fieldBit__Commit_Parents != 0 { + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Parents} } - ma.s += fieldBit__Commit_Committer + ma.s += fieldBit__Commit_Parents ma.state = maState_midValue ma.f = 1 - ma.ca_committer.w = ma.w.committer.v - ma.ca_committer.m = &ma.w.committer.m - return &ma.ca_committer, nil + ma.ca_parents.w = &ma.w.parents + ma.ca_parents.m = &ma.cm + return &ma.ca_parents, nil case "message": if ma.s&fieldBit__Commit_Message != 0 { return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Message} @@ -737,26 +737,26 @@ func (ma *_Commit__Assembler) AssembleEntry(k string) (ipld.NodeAssembler, error ma.ca_message.w = &ma.w.message ma.ca_message.m = &ma.cm return &ma.ca_message, nil - case "parents": - if ma.s&fieldBit__Commit_Parents != 0 { - return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Parents} + case "author": + if ma.s&fieldBit__Commit_Author != 0 { + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Author} } - ma.s += fieldBit__Commit_Parents + ma.s += fieldBit__Commit_Author ma.state = maState_midValue ma.f = 3 - ma.ca_parents.w = &ma.w.parents - ma.ca_parents.m = &ma.cm - return &ma.ca_parents, nil - case "tree": - if ma.s&fieldBit__Commit_Tree != 0 { - return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Tree} + ma.ca_author.w = ma.w.author.v + ma.ca_author.m = &ma.w.author.m + return &ma.ca_author, nil + case "committer": + if ma.s&fieldBit__Commit_Committer != 0 { + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Committer} } - ma.s += fieldBit__Commit_Tree + ma.s += fieldBit__Commit_Committer ma.state = maState_midValue ma.f = 4 - ma.ca_tree.w = &ma.w.tree - ma.ca_tree.m = &ma.cm - return &ma.ca_tree, nil + ma.ca_committer.w = ma.w.committer.v + ma.ca_committer.m = &ma.w.committer.m + return &ma.ca_committer, nil case "encoding": if ma.s&fieldBit__Commit_Encoding != 0 { return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Encoding} @@ -777,16 +777,16 @@ func (ma *_Commit__Assembler) AssembleEntry(k string) (ipld.NodeAssembler, error ma.ca_signature.w = &ma.w.signature.v ma.ca_signature.m = &ma.w.signature.m return &ma.ca_signature, nil - case "mergeTag": - if ma.s&fieldBit__Commit_MergeTag != 0 { - return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_MergeTag} + case "mergetag": + if ma.s&fieldBit__Commit_Mergetag != 0 { + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Mergetag} } - ma.s += fieldBit__Commit_MergeTag + ma.s += fieldBit__Commit_Mergetag ma.state = maState_midValue ma.f = 7 - ma.ca_mergeTag.w = &ma.w.mergeTag - ma.ca_mergeTag.m = &ma.cm - return &ma.ca_mergeTag, nil + ma.ca_mergetag.w = &ma.w.mergetag + ma.ca_mergetag.m = &ma.cm + return &ma.ca_mergetag, nil case "other": if ma.s&fieldBit__Commit_Other != 0 { return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Other} @@ -834,25 +834,25 @@ func (ma *_Commit__Assembler) AssembleValue() ipld.NodeAssembler { ma.state = maState_midValue switch ma.f { case 0: - ma.ca_author.w = ma.w.author.v - ma.ca_author.m = &ma.w.author.m - return &ma.ca_author + ma.ca_tree.w = &ma.w.tree + ma.ca_tree.m = &ma.cm + return &ma.ca_tree case 1: - ma.ca_committer.w = ma.w.committer.v - ma.ca_committer.m = &ma.w.committer.m - return &ma.ca_committer + ma.ca_parents.w = &ma.w.parents + ma.ca_parents.m = &ma.cm + return &ma.ca_parents case 2: ma.ca_message.w = &ma.w.message ma.ca_message.m = &ma.cm return &ma.ca_message case 3: - ma.ca_parents.w = &ma.w.parents - ma.ca_parents.m = &ma.cm - return &ma.ca_parents + ma.ca_author.w = ma.w.author.v + ma.ca_author.m = &ma.w.author.m + return &ma.ca_author case 4: - ma.ca_tree.w = &ma.w.tree - ma.ca_tree.m = &ma.cm - return &ma.ca_tree + ma.ca_committer.w = ma.w.committer.v + ma.ca_committer.m = &ma.w.committer.m + return &ma.ca_committer case 5: ma.ca_encoding.w = &ma.w.encoding.v ma.ca_encoding.m = &ma.w.encoding.m @@ -862,9 +862,9 @@ func (ma *_Commit__Assembler) AssembleValue() ipld.NodeAssembler { ma.ca_signature.m = &ma.w.signature.m return &ma.ca_signature case 7: - ma.ca_mergeTag.w = &ma.w.mergeTag - ma.ca_mergeTag.m = &ma.cm - return &ma.ca_mergeTag + ma.ca_mergetag.w = &ma.w.mergetag + ma.ca_mergetag.m = &ma.cm + return &ma.ca_mergetag case 8: ma.ca_other.w = &ma.w.other ma.ca_other.m = &ma.cm @@ -890,17 +890,17 @@ func (ma *_Commit__Assembler) Finish() error { } if ma.s&fieldBits__Commit_sufficient != fieldBits__Commit_sufficient { err := ipld.ErrMissingRequiredField{Missing: make([]string, 0)} - if ma.s&fieldBit__Commit_Message == 0 { - err.Missing = append(err.Missing, "message") + if ma.s&fieldBit__Commit_Tree == 0 { + err.Missing = append(err.Missing, "tree") } if ma.s&fieldBit__Commit_Parents == 0 { err.Missing = append(err.Missing, "parents") } - if ma.s&fieldBit__Commit_Tree == 0 { - err.Missing = append(err.Missing, "tree") + if ma.s&fieldBit__Commit_Message == 0 { + err.Missing = append(err.Missing, "message") } - if ma.s&fieldBit__Commit_MergeTag == 0 { - err.Missing = append(err.Missing, "mergeTag") + if ma.s&fieldBit__Commit_Mergetag == 0 { + err.Missing = append(err.Missing, "mergetag") } if ma.s&fieldBit__Commit_Other == 0 { err.Missing = append(err.Missing, "other") @@ -943,19 +943,19 @@ func (ka *_Commit__KeyAssembler) AssignString(k string) error { panic("misuse: KeyAssembler held beyond its valid lifetime") } switch k { - case "author": - if ka.s&fieldBit__Commit_Author != 0 { - return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Author} + case "tree": + if ka.s&fieldBit__Commit_Tree != 0 { + return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Tree} } - ka.s += fieldBit__Commit_Author + ka.s += fieldBit__Commit_Tree ka.state = maState_expectValue ka.f = 0 return nil - case "committer": - if ka.s&fieldBit__Commit_Committer != 0 { - return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Committer} + case "parents": + if ka.s&fieldBit__Commit_Parents != 0 { + return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Parents} } - ka.s += fieldBit__Commit_Committer + ka.s += fieldBit__Commit_Parents ka.state = maState_expectValue ka.f = 1 return nil @@ -967,19 +967,19 @@ func (ka *_Commit__KeyAssembler) AssignString(k string) error { ka.state = maState_expectValue ka.f = 2 return nil - case "parents": - if ka.s&fieldBit__Commit_Parents != 0 { - return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Parents} + case "author": + if ka.s&fieldBit__Commit_Author != 0 { + return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Author} } - ka.s += fieldBit__Commit_Parents + ka.s += fieldBit__Commit_Author ka.state = maState_expectValue ka.f = 3 return nil - case "tree": - if ka.s&fieldBit__Commit_Tree != 0 { - return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Tree} + case "committer": + if ka.s&fieldBit__Commit_Committer != 0 { + return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Committer} } - ka.s += fieldBit__Commit_Tree + ka.s += fieldBit__Commit_Committer ka.state = maState_expectValue ka.f = 4 return nil @@ -999,11 +999,11 @@ func (ka *_Commit__KeyAssembler) AssignString(k string) error { ka.state = maState_expectValue ka.f = 6 return nil - case "mergeTag": - if ka.s&fieldBit__Commit_MergeTag != 0 { - return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_MergeTag} + case "mergetag": + if ka.s&fieldBit__Commit_Mergetag != 0 { + return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Mergetag} } - ka.s += fieldBit__Commit_MergeTag + ka.s += fieldBit__Commit_Mergetag ka.state = maState_expectValue ka.f = 7 return nil @@ -1045,14 +1045,14 @@ func (n Commit) Representation() ipld.Node { type _Commit__Repr _Commit var ( + fieldName__Commit_Tree_serial = _String{"tree"} + fieldName__Commit_Parents_serial = _String{"parents"} + fieldName__Commit_Message_serial = _String{"message"} fieldName__Commit_Author_serial = _String{"author"} fieldName__Commit_Committer_serial = _String{"committer"} - fieldName__Commit_Message_serial = _String{"message"} - fieldName__Commit_Parents_serial = _String{"parents"} - fieldName__Commit_Tree_serial = _String{"tree"} fieldName__Commit_Encoding_serial = _String{"encoding"} fieldName__Commit_Signature_serial = _String{"signature"} - fieldName__Commit_MergeTag_serial = _String{"mergeTag"} + fieldName__Commit_Mergetag_serial = _String{"mergetag"} fieldName__Commit_Other_serial = _String{"other"} ) var _ ipld.Node = &_Commit__Repr{} @@ -1062,6 +1062,12 @@ func (_Commit__Repr) Kind() ipld.Kind { } func (n *_Commit__Repr) LookupByString(key string) (ipld.Node, error) { switch key { + case "tree": + return n.tree.Representation(), nil + case "parents": + return n.parents.Representation(), nil + case "message": + return n.message.Representation(), nil case "author": if n.author.m == schema.Maybe_Absent { return ipld.Absent, ipld.ErrNotExists{Segment: ipld.PathSegmentOfString(key)} @@ -1072,12 +1078,6 @@ func (n *_Commit__Repr) LookupByString(key string) (ipld.Node, error) { return ipld.Absent, ipld.ErrNotExists{Segment: ipld.PathSegmentOfString(key)} } return n.committer.v.Representation(), nil - case "message": - return n.message.Representation(), nil - case "parents": - return n.parents.Representation(), nil - case "tree": - return n.tree.Representation(), nil case "encoding": if n.encoding.m == schema.Maybe_Absent { return ipld.Absent, ipld.ErrNotExists{Segment: ipld.PathSegmentOfString(key)} @@ -1088,8 +1088,8 @@ func (n *_Commit__Repr) LookupByString(key string) (ipld.Node, error) { return ipld.Absent, ipld.ErrNotExists{Segment: ipld.PathSegmentOfString(key)} } return n.signature.v.Representation(), nil - case "mergeTag": - return n.mergeTag.Representation(), nil + case "mergetag": + return n.mergetag.Representation(), nil case "other": return n.other.Representation(), nil default: @@ -1125,28 +1125,28 @@ advance: } switch itr.idx { case 0: + k = &fieldName__Commit_Tree_serial + v = itr.n.tree.Representation() + case 1: + k = &fieldName__Commit_Parents_serial + v = itr.n.parents.Representation() + case 2: + k = &fieldName__Commit_Message_serial + v = itr.n.message.Representation() + case 3: k = &fieldName__Commit_Author_serial if itr.n.author.m == schema.Maybe_Absent { itr.idx++ goto advance } v = itr.n.author.v.Representation() - case 1: + case 4: k = &fieldName__Commit_Committer_serial if itr.n.committer.m == schema.Maybe_Absent { itr.idx++ goto advance } v = itr.n.committer.v.Representation() - case 2: - k = &fieldName__Commit_Message_serial - v = itr.n.message.Representation() - case 3: - k = &fieldName__Commit_Parents_serial - v = itr.n.parents.Representation() - case 4: - k = &fieldName__Commit_Tree_serial - v = itr.n.tree.Representation() case 5: k = &fieldName__Commit_Encoding_serial if itr.n.encoding.m == schema.Maybe_Absent { @@ -1162,8 +1162,8 @@ advance: } v = itr.n.signature.v.Representation() case 7: - k = &fieldName__Commit_MergeTag_serial - v = itr.n.mergeTag.Representation() + k = &fieldName__Commit_Mergetag_serial + v = itr.n.mergetag.Representation() case 8: k = &fieldName__Commit_Other_serial v = itr.n.other.Representation() @@ -1255,28 +1255,28 @@ type _Commit__ReprAssembler struct { f int cm schema.Maybe + ca_tree _Tree_Link__ReprAssembler + ca_parents _Commit_Link_List__ReprAssembler + ca_message _String__ReprAssembler ca_author _PersonInfo__ReprAssembler ca_committer _PersonInfo__ReprAssembler - ca_message _String__ReprAssembler - ca_parents _ListParents__ReprAssembler - ca_tree _LinkTree__ReprAssembler ca_encoding _String__ReprAssembler ca_signature _GpgSig__ReprAssembler - ca_mergeTag _ListTag__ReprAssembler - ca_other _ListString__ReprAssembler + ca_mergetag _Tag_List__ReprAssembler + ca_other _String_List__ReprAssembler } func (na *_Commit__ReprAssembler) reset() { na.state = maState_initial na.s = 0 + na.ca_tree.reset() + na.ca_parents.reset() + na.ca_message.reset() na.ca_author.reset() na.ca_committer.reset() - na.ca_message.reset() - na.ca_parents.reset() - na.ca_tree.reset() na.ca_encoding.reset() na.ca_signature.reset() - na.ca_mergeTag.reset() + na.ca_mergetag.reset() na.ca_other.reset() } func (na *_Commit__ReprAssembler) BeginMap(int64) (ipld.MapAssembler, error) { @@ -1371,18 +1371,18 @@ func (_Commit__ReprAssembler) Prototype() ipld.NodePrototype { func (ma *_Commit__ReprAssembler) valueFinishTidy() bool { switch ma.f { case 0: - switch ma.w.author.m { + switch ma.cm { case schema.Maybe_Value: - ma.w.author.v = ma.ca_author.w + ma.cm = schema.Maybe_Absent ma.state = maState_initial return true default: return false } case 1: - switch ma.w.committer.m { + switch ma.cm { case schema.Maybe_Value: - ma.w.committer.v = ma.ca_committer.w + ma.cm = schema.Maybe_Absent ma.state = maState_initial return true default: @@ -1398,18 +1398,18 @@ func (ma *_Commit__ReprAssembler) valueFinishTidy() bool { return false } case 3: - switch ma.cm { + switch ma.w.author.m { case schema.Maybe_Value: - ma.cm = schema.Maybe_Absent + ma.w.author.v = ma.ca_author.w ma.state = maState_initial return true default: return false } case 4: - switch ma.cm { + switch ma.w.committer.m { case schema.Maybe_Value: - ma.cm = schema.Maybe_Absent + ma.w.committer.v = ma.ca_committer.w ma.state = maState_initial return true default: @@ -1469,28 +1469,26 @@ func (ma *_Commit__ReprAssembler) AssembleEntry(k string) (ipld.NodeAssembler, e panic("invalid state: AssembleEntry cannot be called on an assembler that's already finished") } switch k { - case "author": - if ma.s&fieldBit__Commit_Author != 0 { - return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Author_serial} + case "tree": + if ma.s&fieldBit__Commit_Tree != 0 { + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Tree_serial} } - ma.s += fieldBit__Commit_Author + ma.s += fieldBit__Commit_Tree ma.state = maState_midValue ma.f = 0 - ma.ca_author.w = ma.w.author.v - ma.ca_author.m = &ma.w.author.m - - return &ma.ca_author, nil - case "committer": - if ma.s&fieldBit__Commit_Committer != 0 { - return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Committer_serial} + ma.ca_tree.w = &ma.w.tree + ma.ca_tree.m = &ma.cm + return &ma.ca_tree, nil + case "parents": + if ma.s&fieldBit__Commit_Parents != 0 { + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Parents_serial} } - ma.s += fieldBit__Commit_Committer + ma.s += fieldBit__Commit_Parents ma.state = maState_midValue ma.f = 1 - ma.ca_committer.w = ma.w.committer.v - ma.ca_committer.m = &ma.w.committer.m - - return &ma.ca_committer, nil + ma.ca_parents.w = &ma.w.parents + ma.ca_parents.m = &ma.cm + return &ma.ca_parents, nil case "message": if ma.s&fieldBit__Commit_Message != 0 { return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Message_serial} @@ -1501,26 +1499,28 @@ func (ma *_Commit__ReprAssembler) AssembleEntry(k string) (ipld.NodeAssembler, e ma.ca_message.w = &ma.w.message ma.ca_message.m = &ma.cm return &ma.ca_message, nil - case "parents": - if ma.s&fieldBit__Commit_Parents != 0 { - return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Parents_serial} + case "author": + if ma.s&fieldBit__Commit_Author != 0 { + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Author_serial} } - ma.s += fieldBit__Commit_Parents + ma.s += fieldBit__Commit_Author ma.state = maState_midValue ma.f = 3 - ma.ca_parents.w = &ma.w.parents - ma.ca_parents.m = &ma.cm - return &ma.ca_parents, nil - case "tree": - if ma.s&fieldBit__Commit_Tree != 0 { - return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Tree_serial} + ma.ca_author.w = ma.w.author.v + ma.ca_author.m = &ma.w.author.m + + return &ma.ca_author, nil + case "committer": + if ma.s&fieldBit__Commit_Committer != 0 { + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Committer_serial} } - ma.s += fieldBit__Commit_Tree + ma.s += fieldBit__Commit_Committer ma.state = maState_midValue ma.f = 4 - ma.ca_tree.w = &ma.w.tree - ma.ca_tree.m = &ma.cm - return &ma.ca_tree, nil + ma.ca_committer.w = ma.w.committer.v + ma.ca_committer.m = &ma.w.committer.m + + return &ma.ca_committer, nil case "encoding": if ma.s&fieldBit__Commit_Encoding != 0 { return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Encoding_serial} @@ -1543,16 +1543,16 @@ func (ma *_Commit__ReprAssembler) AssembleEntry(k string) (ipld.NodeAssembler, e ma.ca_signature.m = &ma.w.signature.m return &ma.ca_signature, nil - case "mergeTag": - if ma.s&fieldBit__Commit_MergeTag != 0 { - return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_MergeTag_serial} + case "mergetag": + if ma.s&fieldBit__Commit_Mergetag != 0 { + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Mergetag_serial} } - ma.s += fieldBit__Commit_MergeTag + ma.s += fieldBit__Commit_Mergetag ma.state = maState_midValue ma.f = 7 - ma.ca_mergeTag.w = &ma.w.mergeTag - ma.ca_mergeTag.m = &ma.cm - return &ma.ca_mergeTag, nil + ma.ca_mergetag.w = &ma.w.mergetag + ma.ca_mergetag.m = &ma.cm + return &ma.ca_mergetag, nil case "other": if ma.s&fieldBit__Commit_Other != 0 { return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Other_serial} @@ -1601,27 +1601,27 @@ func (ma *_Commit__ReprAssembler) AssembleValue() ipld.NodeAssembler { ma.state = maState_midValue switch ma.f { case 0: + ma.ca_tree.w = &ma.w.tree + ma.ca_tree.m = &ma.cm + return &ma.ca_tree + case 1: + ma.ca_parents.w = &ma.w.parents + ma.ca_parents.m = &ma.cm + return &ma.ca_parents + case 2: + ma.ca_message.w = &ma.w.message + ma.ca_message.m = &ma.cm + return &ma.ca_message + case 3: ma.ca_author.w = ma.w.author.v ma.ca_author.m = &ma.w.author.m return &ma.ca_author - case 1: + case 4: ma.ca_committer.w = ma.w.committer.v ma.ca_committer.m = &ma.w.committer.m return &ma.ca_committer - case 2: - ma.ca_message.w = &ma.w.message - ma.ca_message.m = &ma.cm - return &ma.ca_message - case 3: - ma.ca_parents.w = &ma.w.parents - ma.ca_parents.m = &ma.cm - return &ma.ca_parents - case 4: - ma.ca_tree.w = &ma.w.tree - ma.ca_tree.m = &ma.cm - return &ma.ca_tree case 5: ma.ca_encoding.w = &ma.w.encoding.v ma.ca_encoding.m = &ma.w.encoding.m @@ -1633,9 +1633,9 @@ func (ma *_Commit__ReprAssembler) AssembleValue() ipld.NodeAssembler { return &ma.ca_signature case 7: - ma.ca_mergeTag.w = &ma.w.mergeTag - ma.ca_mergeTag.m = &ma.cm - return &ma.ca_mergeTag + ma.ca_mergetag.w = &ma.w.mergetag + ma.ca_mergetag.m = &ma.cm + return &ma.ca_mergetag case 8: ma.ca_other.w = &ma.w.other ma.ca_other.m = &ma.cm @@ -1661,17 +1661,17 @@ func (ma *_Commit__ReprAssembler) Finish() error { } if ma.s&fieldBits__Commit_sufficient != fieldBits__Commit_sufficient { err := ipld.ErrMissingRequiredField{Missing: make([]string, 0)} - if ma.s&fieldBit__Commit_Message == 0 { - err.Missing = append(err.Missing, "message") + if ma.s&fieldBit__Commit_Tree == 0 { + err.Missing = append(err.Missing, "tree") } if ma.s&fieldBit__Commit_Parents == 0 { err.Missing = append(err.Missing, "parents") } - if ma.s&fieldBit__Commit_Tree == 0 { - err.Missing = append(err.Missing, "tree") + if ma.s&fieldBit__Commit_Message == 0 { + err.Missing = append(err.Missing, "message") } - if ma.s&fieldBit__Commit_MergeTag == 0 { - err.Missing = append(err.Missing, "mergeTag") + if ma.s&fieldBit__Commit_Mergetag == 0 { + err.Missing = append(err.Missing, "mergetag") } if ma.s&fieldBit__Commit_Other == 0 { err.Missing = append(err.Missing, "other") @@ -1714,19 +1714,19 @@ func (ka *_Commit__ReprKeyAssembler) AssignString(k string) error { panic("misuse: KeyAssembler held beyond its valid lifetime") } switch k { - case "author": - if ka.s&fieldBit__Commit_Author != 0 { - return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Author_serial} + case "tree": + if ka.s&fieldBit__Commit_Tree != 0 { + return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Tree_serial} } - ka.s += fieldBit__Commit_Author + ka.s += fieldBit__Commit_Tree ka.state = maState_expectValue ka.f = 0 return nil - case "committer": - if ka.s&fieldBit__Commit_Committer != 0 { - return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Committer_serial} + case "parents": + if ka.s&fieldBit__Commit_Parents != 0 { + return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Parents_serial} } - ka.s += fieldBit__Commit_Committer + ka.s += fieldBit__Commit_Parents ka.state = maState_expectValue ka.f = 1 return nil @@ -1738,19 +1738,19 @@ func (ka *_Commit__ReprKeyAssembler) AssignString(k string) error { ka.state = maState_expectValue ka.f = 2 return nil - case "parents": - if ka.s&fieldBit__Commit_Parents != 0 { - return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Parents_serial} + case "author": + if ka.s&fieldBit__Commit_Author != 0 { + return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Author_serial} } - ka.s += fieldBit__Commit_Parents + ka.s += fieldBit__Commit_Author ka.state = maState_expectValue ka.f = 3 return nil - case "tree": - if ka.s&fieldBit__Commit_Tree != 0 { - return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Tree_serial} + case "committer": + if ka.s&fieldBit__Commit_Committer != 0 { + return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Committer_serial} } - ka.s += fieldBit__Commit_Tree + ka.s += fieldBit__Commit_Committer ka.state = maState_expectValue ka.f = 4 return nil @@ -1770,11 +1770,11 @@ func (ka *_Commit__ReprKeyAssembler) AssignString(k string) error { ka.state = maState_expectValue ka.f = 6 return nil - case "mergeTag": - if ka.s&fieldBit__Commit_MergeTag != 0 { - return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_MergeTag_serial} + case "mergetag": + if ka.s&fieldBit__Commit_Mergetag != 0 { + return ipld.ErrRepeatedMapKey{Key: &fieldName__Commit_Mergetag_serial} } - ka.s += fieldBit__Commit_MergeTag + ka.s += fieldBit__Commit_Mergetag ka.state = maState_expectValue ka.f = 7 return nil @@ -1806,34 +1806,30 @@ func (_Commit__ReprKeyAssembler) Prototype() ipld.NodePrototype { return _String__Prototype{} } -func (n GpgSig) String() string { +func (n Commit_Link) Link() ipld.Link { return n.x } -func (_GpgSig__Prototype) fromString(w *_GpgSig, v string) error { - *w = _GpgSig{v} - return nil -} -func (_GpgSig__Prototype) FromString(v string) (GpgSig, error) { - n := _GpgSig{v} +func (_Commit_Link__Prototype) FromLink(v ipld.Link) (Commit_Link, error) { + n := _Commit_Link{v} return &n, nil } -type _GpgSig__Maybe struct { +type _Commit_Link__Maybe struct { m schema.Maybe - v _GpgSig + v _Commit_Link } -type MaybeGpgSig = *_GpgSig__Maybe +type MaybeCommit_Link = *_Commit_Link__Maybe -func (m MaybeGpgSig) IsNull() bool { +func (m MaybeCommit_Link) IsNull() bool { return m.m == schema.Maybe_Null } -func (m MaybeGpgSig) IsAbsent() bool { +func (m MaybeCommit_Link) IsAbsent() bool { return m.m == schema.Maybe_Absent } -func (m MaybeGpgSig) Exists() bool { +func (m MaybeCommit_Link) Exists() bool { return m.m == schema.Maybe_Value } -func (m MaybeGpgSig) AsNode() ipld.Node { +func (m MaybeCommit_Link) AsNode() ipld.Node { switch m.m { case schema.Maybe_Absent: return ipld.Absent @@ -1845,126 +1841,132 @@ func (m MaybeGpgSig) AsNode() ipld.Node { panic("unreachable") } } -func (m MaybeGpgSig) Must() GpgSig { +func (m MaybeCommit_Link) Must() Commit_Link { if !m.Exists() { panic("unbox of a maybe rejected") } return &m.v } -var _ ipld.Node = (GpgSig)(&_GpgSig{}) -var _ schema.TypedNode = (GpgSig)(&_GpgSig{}) +var _ ipld.Node = (Commit_Link)(&_Commit_Link{}) +var _ schema.TypedNode = (Commit_Link)(&_Commit_Link{}) -func (GpgSig) Kind() ipld.Kind { - return ipld.Kind_String +func (Commit_Link) Kind() ipld.Kind { + return ipld.Kind_Link } -func (GpgSig) LookupByString(string) (ipld.Node, error) { - return mixins.String{TypeName: "ipldgit.GpgSig"}.LookupByString("") +func (Commit_Link) LookupByString(string) (ipld.Node, error) { + return mixins.Link{TypeName: "ipldgit.Commit_Link"}.LookupByString("") } -func (GpgSig) LookupByNode(ipld.Node) (ipld.Node, error) { - return mixins.String{TypeName: "ipldgit.GpgSig"}.LookupByNode(nil) +func (Commit_Link) LookupByNode(ipld.Node) (ipld.Node, error) { + return mixins.Link{TypeName: "ipldgit.Commit_Link"}.LookupByNode(nil) } -func (GpgSig) LookupByIndex(idx int64) (ipld.Node, error) { - return mixins.String{TypeName: "ipldgit.GpgSig"}.LookupByIndex(0) +func (Commit_Link) LookupByIndex(idx int64) (ipld.Node, error) { + return mixins.Link{TypeName: "ipldgit.Commit_Link"}.LookupByIndex(0) } -func (GpgSig) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { - return mixins.String{TypeName: "ipldgit.GpgSig"}.LookupBySegment(seg) +func (Commit_Link) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { + return mixins.Link{TypeName: "ipldgit.Commit_Link"}.LookupBySegment(seg) } -func (GpgSig) MapIterator() ipld.MapIterator { +func (Commit_Link) MapIterator() ipld.MapIterator { return nil } -func (GpgSig) ListIterator() ipld.ListIterator { +func (Commit_Link) ListIterator() ipld.ListIterator { return nil } -func (GpgSig) Length() int64 { +func (Commit_Link) Length() int64 { return -1 } -func (GpgSig) IsAbsent() bool { +func (Commit_Link) IsAbsent() bool { return false } -func (GpgSig) IsNull() bool { +func (Commit_Link) IsNull() bool { return false } -func (GpgSig) AsBool() (bool, error) { - return mixins.String{TypeName: "ipldgit.GpgSig"}.AsBool() +func (Commit_Link) AsBool() (bool, error) { + return mixins.Link{TypeName: "ipldgit.Commit_Link"}.AsBool() } -func (GpgSig) AsInt() (int64, error) { - return mixins.String{TypeName: "ipldgit.GpgSig"}.AsInt() +func (Commit_Link) AsInt() (int64, error) { + return mixins.Link{TypeName: "ipldgit.Commit_Link"}.AsInt() } -func (GpgSig) AsFloat() (float64, error) { - return mixins.String{TypeName: "ipldgit.GpgSig"}.AsFloat() +func (Commit_Link) AsFloat() (float64, error) { + return mixins.Link{TypeName: "ipldgit.Commit_Link"}.AsFloat() } -func (n GpgSig) AsString() (string, error) { - return n.x, nil +func (Commit_Link) AsString() (string, error) { + return mixins.Link{TypeName: "ipldgit.Commit_Link"}.AsString() } -func (GpgSig) AsBytes() ([]byte, error) { - return mixins.String{TypeName: "ipldgit.GpgSig"}.AsBytes() +func (Commit_Link) AsBytes() ([]byte, error) { + return mixins.Link{TypeName: "ipldgit.Commit_Link"}.AsBytes() } -func (GpgSig) AsLink() (ipld.Link, error) { - return mixins.String{TypeName: "ipldgit.GpgSig"}.AsLink() +func (n Commit_Link) AsLink() (ipld.Link, error) { + return n.x, nil } -func (GpgSig) Prototype() ipld.NodePrototype { - return _GpgSig__Prototype{} +func (Commit_Link) Prototype() ipld.NodePrototype { + return _Commit_Link__Prototype{} } -type _GpgSig__Prototype struct{} +type _Commit_Link__Prototype struct{} -func (_GpgSig__Prototype) NewBuilder() ipld.NodeBuilder { - var nb _GpgSig__Builder +func (_Commit_Link__Prototype) NewBuilder() ipld.NodeBuilder { + var nb _Commit_Link__Builder nb.Reset() return &nb } -type _GpgSig__Builder struct { - _GpgSig__Assembler +type _Commit_Link__Builder struct { + _Commit_Link__Assembler } -func (nb *_GpgSig__Builder) Build() ipld.Node { +func (nb *_Commit_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 *_GpgSig__Builder) Reset() { - var w _GpgSig +func (nb *_Commit_Link__Builder) Reset() { + var w _Commit_Link var m schema.Maybe - *nb = _GpgSig__Builder{_GpgSig__Assembler{w: &w, m: &m}} + *nb = _Commit_Link__Builder{_Commit_Link__Assembler{w: &w, m: &m}} } -type _GpgSig__Assembler struct { - w *_GpgSig +type _Commit_Link__Assembler struct { + w *_Commit_Link m *schema.Maybe } -func (na *_GpgSig__Assembler) reset() {} -func (_GpgSig__Assembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { - return mixins.StringAssembler{TypeName: "ipldgit.GpgSig"}.BeginMap(0) +func (na *_Commit_Link__Assembler) reset() {} +func (_Commit_Link__Assembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { + return mixins.LinkAssembler{TypeName: "ipldgit.Commit_Link"}.BeginMap(0) } -func (_GpgSig__Assembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { - return mixins.StringAssembler{TypeName: "ipldgit.GpgSig"}.BeginList(0) +func (_Commit_Link__Assembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { + return mixins.LinkAssembler{TypeName: "ipldgit.Commit_Link"}.BeginList(0) } -func (na *_GpgSig__Assembler) AssignNull() error { +func (na *_Commit_Link__Assembler) AssignNull() error { switch *na.m { case allowNull: *na.m = schema.Maybe_Null return nil case schema.Maybe_Absent: - return mixins.StringAssembler{TypeName: "ipldgit.GpgSig"}.AssignNull() + return mixins.LinkAssembler{TypeName: "ipldgit.Commit_Link"}.AssignNull() case schema.Maybe_Value, schema.Maybe_Null: panic("invalid state: cannot assign into assembler that's already finished") } panic("unreachable") } -func (_GpgSig__Assembler) AssignBool(bool) error { - return mixins.StringAssembler{TypeName: "ipldgit.GpgSig"}.AssignBool(false) +func (_Commit_Link__Assembler) AssignBool(bool) error { + return mixins.LinkAssembler{TypeName: "ipldgit.Commit_Link"}.AssignBool(false) } -func (_GpgSig__Assembler) AssignInt(int64) error { - return mixins.StringAssembler{TypeName: "ipldgit.GpgSig"}.AssignInt(0) +func (_Commit_Link__Assembler) AssignInt(int64) error { + return mixins.LinkAssembler{TypeName: "ipldgit.Commit_Link"}.AssignInt(0) } -func (_GpgSig__Assembler) AssignFloat(float64) error { - return mixins.StringAssembler{TypeName: "ipldgit.GpgSig"}.AssignFloat(0) +func (_Commit_Link__Assembler) AssignFloat(float64) error { + return mixins.LinkAssembler{TypeName: "ipldgit.Commit_Link"}.AssignFloat(0) } -func (na *_GpgSig__Assembler) AssignString(v string) error { +func (_Commit_Link__Assembler) AssignString(string) error { + return mixins.LinkAssembler{TypeName: "ipldgit.Commit_Link"}.AssignString("") +} +func (_Commit_Link__Assembler) AssignBytes([]byte) error { + return mixins.LinkAssembler{TypeName: "ipldgit.Commit_Link"}.AssignBytes(nil) +} +func (na *_Commit_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") @@ -1973,17 +1975,11 @@ func (na *_GpgSig__Assembler) AssignString(v string) error { *na.m = schema.Maybe_Value return nil } -func (_GpgSig__Assembler) AssignBytes([]byte) error { - return mixins.StringAssembler{TypeName: "ipldgit.GpgSig"}.AssignBytes(nil) -} -func (_GpgSig__Assembler) AssignLink(ipld.Link) error { - return mixins.StringAssembler{TypeName: "ipldgit.GpgSig"}.AssignLink(nil) -} -func (na *_GpgSig__Assembler) AssignNode(v ipld.Node) error { +func (na *_Commit_Link__Assembler) AssignNode(v ipld.Node) error { if v.IsNull() { return na.AssignNull() } - if v2, ok := v.(*_GpgSig); ok { + if v2, ok := v.(*_Commit_Link); ok { switch *na.m { case schema.Maybe_Value, schema.Maybe_Null: panic("invalid state: cannot assign into assembler that's already finished") @@ -1992,53 +1988,90 @@ func (na *_GpgSig__Assembler) AssignNode(v ipld.Node) error { *na.m = schema.Maybe_Value return nil } - if v2, err := v.AsString(); err != nil { + if v2, err := v.AsLink(); err != nil { return err } else { - return na.AssignString(v2) + return na.AssignLink(v2) } } -func (_GpgSig__Assembler) Prototype() ipld.NodePrototype { - return _GpgSig__Prototype{} +func (_Commit_Link__Assembler) Prototype() ipld.NodePrototype { + return _Commit_Link__Prototype{} } -func (GpgSig) Type() schema.Type { +func (Commit_Link) Type() schema.Type { return nil /*TODO:typelit*/ } -func (n GpgSig) Representation() ipld.Node { - return (*_GpgSig__Repr)(n) +func (Commit_Link) LinkTargetNodePrototype() ipld.NodePrototype { + return Type.Commit__Repr +} +func (n Commit_Link) Representation() ipld.Node { + return (*_Commit_Link__Repr)(n) } -type _GpgSig__Repr = _GpgSig +type _Commit_Link__Repr = _Commit_Link -var _ ipld.Node = &_GpgSig__Repr{} +var _ ipld.Node = &_Commit_Link__Repr{} -type _GpgSig__ReprPrototype = _GpgSig__Prototype -type _GpgSig__ReprAssembler = _GpgSig__Assembler +type _Commit_Link__ReprPrototype = _Commit_Link__Prototype +type _Commit_Link__ReprAssembler = _Commit_Link__Assembler -func (n Link) Link() ipld.Link { - return n.x +func (n *_Commit_Link_List) Lookup(idx int64) Commit_Link { + if n.Length() <= idx { + return nil + } + v := &n.x[idx] + return v } -func (_Link__Prototype) FromLink(v ipld.Link) (Link, error) { - n := _Link{v} - return &n, nil +func (n *_Commit_Link_List) LookupMaybe(idx int64) MaybeCommit_Link { + if n.Length() <= idx { + return nil + } + v := &n.x[idx] + return &_Commit_Link__Maybe{ + m: schema.Maybe_Value, + v: *v, + } } -type _Link__Maybe struct { - m schema.Maybe - v _Link -} -type MaybeLink = *_Link__Maybe +var _Commit_Link_List__valueAbsent = _Commit_Link__Maybe{m: schema.Maybe_Absent} -func (m MaybeLink) IsNull() bool { - return m.m == schema.Maybe_Null +func (n Commit_Link_List) Iterator() *Commit_Link_List__Itr { + return &Commit_Link_List__Itr{n, 0} } -func (m MaybeLink) IsAbsent() bool { - return m.m == schema.Maybe_Absent + +type Commit_Link_List__Itr struct { + n Commit_Link_List + idx int } -func (m MaybeLink) Exists() bool { + +func (itr *Commit_Link_List__Itr) Next() (idx int64, v Commit_Link) { + if itr.idx >= len(itr.n.x) { + return -1, nil + } + idx = int64(itr.idx) + v = &itr.n.x[itr.idx] + itr.idx++ + return +} +func (itr *Commit_Link_List__Itr) Done() bool { + return itr.idx >= len(itr.n.x) +} + +type _Commit_Link_List__Maybe struct { + m schema.Maybe + v _Commit_Link_List +} +type MaybeCommit_Link_List = *_Commit_Link_List__Maybe + +func (m MaybeCommit_Link_List) IsNull() bool { + return m.m == schema.Maybe_Null +} +func (m MaybeCommit_Link_List) IsAbsent() bool { + return m.m == schema.Maybe_Absent +} +func (m MaybeCommit_Link_List) Exists() bool { return m.m == schema.Maybe_Value } -func (m MaybeLink) AsNode() ipld.Node { +func (m MaybeCommit_Link_List) AsNode() ipld.Node { switch m.m { case schema.Maybe_Absent: return ipld.Absent @@ -2050,408 +2083,556 @@ func (m MaybeLink) AsNode() ipld.Node { panic("unreachable") } } -func (m MaybeLink) Must() Link { +func (m MaybeCommit_Link_List) Must() Commit_Link_List { if !m.Exists() { panic("unbox of a maybe rejected") } return &m.v } -var _ ipld.Node = (Link)(&_Link{}) -var _ schema.TypedNode = (Link)(&_Link{}) +var _ ipld.Node = (Commit_Link_List)(&_Commit_Link_List{}) +var _ schema.TypedNode = (Commit_Link_List)(&_Commit_Link_List{}) -func (Link) Kind() ipld.Kind { - return ipld.Kind_Link +func (Commit_Link_List) Kind() ipld.Kind { + return ipld.Kind_List } -func (Link) LookupByString(string) (ipld.Node, error) { - return mixins.Link{TypeName: "ipldgit.Link"}.LookupByString("") +func (Commit_Link_List) LookupByString(string) (ipld.Node, error) { + return mixins.List{TypeName: "ipldgit.Commit_Link_List"}.LookupByString("") } -func (Link) LookupByNode(ipld.Node) (ipld.Node, error) { - return mixins.Link{TypeName: "ipldgit.Link"}.LookupByNode(nil) +func (n Commit_Link_List) LookupByNode(k ipld.Node) (ipld.Node, error) { + idx, err := k.AsInt() + if err != nil { + return nil, err + } + return n.LookupByIndex(idx) } -func (Link) LookupByIndex(idx int64) (ipld.Node, error) { - return mixins.Link{TypeName: "ipldgit.Link"}.LookupByIndex(0) +func (n Commit_Link_List) LookupByIndex(idx int64) (ipld.Node, error) { + if n.Length() <= idx { + return nil, ipld.ErrNotExists{Segment: ipld.PathSegmentOfInt(idx)} + } + v := &n.x[idx] + return v, nil } -func (Link) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { - return mixins.Link{TypeName: "ipldgit.Link"}.LookupBySegment(seg) +func (n Commit_Link_List) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { + i, err := seg.Index() + if err != nil { + return nil, ipld.ErrInvalidSegmentForList{TypeName: "ipldgit.Commit_Link_List", TroubleSegment: seg, Reason: err} + } + return n.LookupByIndex(i) } -func (Link) MapIterator() ipld.MapIterator { +func (Commit_Link_List) MapIterator() ipld.MapIterator { return nil } -func (Link) ListIterator() ipld.ListIterator { - return nil +func (n Commit_Link_List) ListIterator() ipld.ListIterator { + return &_Commit_Link_List__ListItr{n, 0} } -func (Link) Length() int64 { - return -1 + +type _Commit_Link_List__ListItr struct { + n Commit_Link_List + idx int } -func (Link) IsAbsent() bool { + +func (itr *_Commit_Link_List__ListItr) Next() (idx int64, v ipld.Node, _ error) { + if itr.idx >= len(itr.n.x) { + return -1, nil, ipld.ErrIteratorOverread{} + } + idx = int64(itr.idx) + x := &itr.n.x[itr.idx] + v = x + itr.idx++ + return +} +func (itr *_Commit_Link_List__ListItr) Done() bool { + return itr.idx >= len(itr.n.x) +} + +func (n Commit_Link_List) Length() int64 { + return int64(len(n.x)) +} +func (Commit_Link_List) IsAbsent() bool { return false } -func (Link) IsNull() bool { +func (Commit_Link_List) IsNull() bool { return false } -func (Link) AsBool() (bool, error) { - return mixins.Link{TypeName: "ipldgit.Link"}.AsBool() +func (Commit_Link_List) AsBool() (bool, error) { + return mixins.List{TypeName: "ipldgit.Commit_Link_List"}.AsBool() } -func (Link) AsInt() (int64, error) { - return mixins.Link{TypeName: "ipldgit.Link"}.AsInt() +func (Commit_Link_List) AsInt() (int64, error) { + return mixins.List{TypeName: "ipldgit.Commit_Link_List"}.AsInt() } -func (Link) AsFloat() (float64, error) { - return mixins.Link{TypeName: "ipldgit.Link"}.AsFloat() +func (Commit_Link_List) AsFloat() (float64, error) { + return mixins.List{TypeName: "ipldgit.Commit_Link_List"}.AsFloat() } -func (Link) AsString() (string, error) { - return mixins.Link{TypeName: "ipldgit.Link"}.AsString() +func (Commit_Link_List) AsString() (string, error) { + return mixins.List{TypeName: "ipldgit.Commit_Link_List"}.AsString() } -func (Link) AsBytes() ([]byte, error) { - return mixins.Link{TypeName: "ipldgit.Link"}.AsBytes() +func (Commit_Link_List) AsBytes() ([]byte, error) { + return mixins.List{TypeName: "ipldgit.Commit_Link_List"}.AsBytes() } -func (n Link) AsLink() (ipld.Link, error) { - return n.x, nil +func (Commit_Link_List) AsLink() (ipld.Link, error) { + return mixins.List{TypeName: "ipldgit.Commit_Link_List"}.AsLink() } -func (Link) Prototype() ipld.NodePrototype { - return _Link__Prototype{} +func (Commit_Link_List) Prototype() ipld.NodePrototype { + return _Commit_Link_List__Prototype{} } -type _Link__Prototype struct{} +type _Commit_Link_List__Prototype struct{} -func (_Link__Prototype) NewBuilder() ipld.NodeBuilder { - var nb _Link__Builder +func (_Commit_Link_List__Prototype) NewBuilder() ipld.NodeBuilder { + var nb _Commit_Link_List__Builder nb.Reset() return &nb } -type _Link__Builder struct { - _Link__Assembler +type _Commit_Link_List__Builder struct { + _Commit_Link_List__Assembler } -func (nb *_Link__Builder) Build() ipld.Node { +func (nb *_Commit_Link_List__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 +func (nb *_Commit_Link_List__Builder) Reset() { + var w _Commit_Link_List var m schema.Maybe - *nb = _Link__Builder{_Link__Assembler{w: &w, m: &m}} + *nb = _Commit_Link_List__Builder{_Commit_Link_List__Assembler{w: &w, m: &m}} } -type _Link__Assembler struct { - w *_Link - m *schema.Maybe +type _Commit_Link_List__Assembler struct { + w *_Commit_Link_List + m *schema.Maybe + state laState + + cm schema.Maybe + va _Commit_Link__Assembler } -func (na *_Link__Assembler) reset() {} -func (_Link__Assembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { - return mixins.LinkAssembler{TypeName: "ipldgit.Link"}.BeginMap(0) +func (na *_Commit_Link_List__Assembler) reset() { + na.state = laState_initial + na.va.reset() } -func (_Link__Assembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { - return mixins.LinkAssembler{TypeName: "ipldgit.Link"}.BeginList(0) +func (_Commit_Link_List__Assembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { + return mixins.ListAssembler{TypeName: "ipldgit.Commit_Link_List"}.BeginMap(0) } -func (na *_Link__Assembler) AssignNull() error { +func (na *_Commit_Link_List__Assembler) BeginList(sizeHint int64) (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 sizeHint > 0 { + na.w.x = make([]_Commit_Link, 0, sizeHint) + } + return na, nil +} +func (na *_Commit_Link_List__Assembler) AssignNull() error { switch *na.m { case allowNull: *na.m = schema.Maybe_Null return nil case schema.Maybe_Absent: - return mixins.LinkAssembler{TypeName: "ipldgit.Link"}.AssignNull() + return mixins.ListAssembler{TypeName: "ipldgit.Commit_Link_List"}.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 (_Link__Assembler) AssignBool(bool) error { - return mixins.LinkAssembler{TypeName: "ipldgit.Link"}.AssignBool(false) +func (_Commit_Link_List__Assembler) AssignBool(bool) error { + return mixins.ListAssembler{TypeName: "ipldgit.Commit_Link_List"}.AssignBool(false) } -func (_Link__Assembler) AssignInt(int64) error { - return mixins.LinkAssembler{TypeName: "ipldgit.Link"}.AssignInt(0) +func (_Commit_Link_List__Assembler) AssignInt(int64) error { + return mixins.ListAssembler{TypeName: "ipldgit.Commit_Link_List"}.AssignInt(0) } -func (_Link__Assembler) AssignFloat(float64) error { - return mixins.LinkAssembler{TypeName: "ipldgit.Link"}.AssignFloat(0) +func (_Commit_Link_List__Assembler) AssignFloat(float64) error { + return mixins.ListAssembler{TypeName: "ipldgit.Commit_Link_List"}.AssignFloat(0) } -func (_Link__Assembler) AssignString(string) error { - return mixins.LinkAssembler{TypeName: "ipldgit.Link"}.AssignString("") +func (_Commit_Link_List__Assembler) AssignString(string) error { + return mixins.ListAssembler{TypeName: "ipldgit.Commit_Link_List"}.AssignString("") } -func (_Link__Assembler) AssignBytes([]byte) error { - return mixins.LinkAssembler{TypeName: "ipldgit.Link"}.AssignBytes(nil) +func (_Commit_Link_List__Assembler) AssignBytes([]byte) error { + return mixins.ListAssembler{TypeName: "ipldgit.Commit_Link_List"}.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") - } - na.w.x = v - *na.m = schema.Maybe_Value - return nil +func (_Commit_Link_List__Assembler) AssignLink(ipld.Link) error { + return mixins.ListAssembler{TypeName: "ipldgit.Commit_Link_List"}.AssignLink(nil) } -func (na *_Link__Assembler) AssignNode(v ipld.Node) error { +func (na *_Commit_Link_List__Assembler) AssignNode(v ipld.Node) error { if v.IsNull() { return na.AssignNull() } - if v2, ok := v.(*_Link); ok { + if v2, ok := v.(*_Commit_Link_List); 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!") } *na.w = *v2 *na.m = schema.Maybe_Value return nil } - if v2, err := v.AsLink(); err != nil { - return err - } else { - return na.AssignLink(v2) + if v.Kind() != ipld.Kind_List { + return ipld.ErrWrongKind{TypeName: "ipldgit.Commit_Link_List", MethodName: "AssignNode", AppropriateKind: ipld.KindSet_JustList, ActualKind: v.Kind()} + } + 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 (_Link__Assembler) Prototype() ipld.NodePrototype { - return _Link__Prototype{} +func (_Commit_Link_List__Assembler) Prototype() ipld.NodePrototype { + return _Commit_Link_List__Prototype{} } -func (Link) Type() schema.Type { +func (la *_Commit_Link_List__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 *_Commit_Link_List__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, _Commit_Link{}) + 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 *_Commit_Link_List__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 *_Commit_Link_List__Assembler) ValuePrototype(_ int64) ipld.NodePrototype { + return _Commit_Link__Prototype{} +} +func (Commit_Link_List) Type() schema.Type { return nil /*TODO:typelit*/ } -func (n Link) Representation() ipld.Node { - return (*_Link__Repr)(n) +func (n Commit_Link_List) Representation() ipld.Node { + return (*_Commit_Link_List__Repr)(n) } -type _Link__Repr = _Link - -var _ ipld.Node = &_Link__Repr{} +type _Commit_Link_List__Repr _Commit_Link_List -type _Link__ReprPrototype = _Link__Prototype -type _Link__ReprAssembler = _Link__Assembler +var _ ipld.Node = &_Commit_Link_List__Repr{} -func (n LinkCommit) Link() ipld.Link { - return n.x +func (_Commit_Link_List__Repr) Kind() ipld.Kind { + return ipld.Kind_List } -func (_LinkCommit__Prototype) FromLink(v ipld.Link) (LinkCommit, error) { - n := _LinkCommit{v} - return &n, nil +func (_Commit_Link_List__Repr) LookupByString(string) (ipld.Node, error) { + return mixins.List{TypeName: "ipldgit.Commit_Link_List.Repr"}.LookupByString("") } - -type _LinkCommit__Maybe struct { - m schema.Maybe - v _LinkCommit +func (nr *_Commit_Link_List__Repr) LookupByNode(k ipld.Node) (ipld.Node, error) { + v, err := (Commit_Link_List)(nr).LookupByNode(k) + if err != nil || v == ipld.Null { + return v, err + } + return v.(Commit_Link).Representation(), nil } -type MaybeLinkCommit = *_LinkCommit__Maybe - -func (m MaybeLinkCommit) IsNull() bool { - return m.m == schema.Maybe_Null +func (nr *_Commit_Link_List__Repr) LookupByIndex(idx int64) (ipld.Node, error) { + v, err := (Commit_Link_List)(nr).LookupByIndex(idx) + if err != nil || v == ipld.Null { + return v, err + } + return v.(Commit_Link).Representation(), nil } -func (m MaybeLinkCommit) IsAbsent() bool { - return m.m == schema.Maybe_Absent +func (n _Commit_Link_List__Repr) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { + i, err := seg.Index() + if err != nil { + return nil, ipld.ErrInvalidSegmentForList{TypeName: "ipldgit.Commit_Link_List.Repr", TroubleSegment: seg, Reason: err} + } + return n.LookupByIndex(i) } -func (m MaybeLinkCommit) Exists() bool { - return m.m == schema.Maybe_Value +func (_Commit_Link_List__Repr) MapIterator() ipld.MapIterator { + return nil } -func (m MaybeLinkCommit) 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 (nr *_Commit_Link_List__Repr) ListIterator() ipld.ListIterator { + return &_Commit_Link_List__ReprListItr{(Commit_Link_List)(nr), 0} } -func (m MaybeLinkCommit) Must() LinkCommit { - if !m.Exists() { - panic("unbox of a maybe rejected") + +type _Commit_Link_List__ReprListItr _Commit_Link_List__ListItr + +func (itr *_Commit_Link_List__ReprListItr) Next() (idx int64, v ipld.Node, err error) { + idx, v, err = (*_Commit_Link_List__ListItr)(itr).Next() + if err != nil || v == ipld.Null { + return } - return &m.v + return idx, v.(Commit_Link).Representation(), nil +} +func (itr *_Commit_Link_List__ReprListItr) Done() bool { + return (*_Commit_Link_List__ListItr)(itr).Done() } -var _ ipld.Node = (LinkCommit)(&_LinkCommit{}) -var _ schema.TypedNode = (LinkCommit)(&_LinkCommit{}) - -func (LinkCommit) Kind() ipld.Kind { - return ipld.Kind_Link -} -func (LinkCommit) LookupByString(string) (ipld.Node, error) { - return mixins.Link{TypeName: "ipldgit.LinkCommit"}.LookupByString("") -} -func (LinkCommit) LookupByNode(ipld.Node) (ipld.Node, error) { - return mixins.Link{TypeName: "ipldgit.LinkCommit"}.LookupByNode(nil) -} -func (LinkCommit) LookupByIndex(idx int64) (ipld.Node, error) { - return mixins.Link{TypeName: "ipldgit.LinkCommit"}.LookupByIndex(0) -} -func (LinkCommit) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { - return mixins.Link{TypeName: "ipldgit.LinkCommit"}.LookupBySegment(seg) -} -func (LinkCommit) MapIterator() ipld.MapIterator { - return nil -} -func (LinkCommit) ListIterator() ipld.ListIterator { - return nil -} -func (LinkCommit) Length() int64 { - return -1 +func (rn *_Commit_Link_List__Repr) Length() int64 { + return int64(len(rn.x)) } -func (LinkCommit) IsAbsent() bool { +func (_Commit_Link_List__Repr) IsAbsent() bool { return false } -func (LinkCommit) IsNull() bool { +func (_Commit_Link_List__Repr) IsNull() bool { return false } -func (LinkCommit) AsBool() (bool, error) { - return mixins.Link{TypeName: "ipldgit.LinkCommit"}.AsBool() +func (_Commit_Link_List__Repr) AsBool() (bool, error) { + return mixins.List{TypeName: "ipldgit.Commit_Link_List.Repr"}.AsBool() } -func (LinkCommit) AsInt() (int64, error) { - return mixins.Link{TypeName: "ipldgit.LinkCommit"}.AsInt() +func (_Commit_Link_List__Repr) AsInt() (int64, error) { + return mixins.List{TypeName: "ipldgit.Commit_Link_List.Repr"}.AsInt() } -func (LinkCommit) AsFloat() (float64, error) { - return mixins.Link{TypeName: "ipldgit.LinkCommit"}.AsFloat() +func (_Commit_Link_List__Repr) AsFloat() (float64, error) { + return mixins.List{TypeName: "ipldgit.Commit_Link_List.Repr"}.AsFloat() } -func (LinkCommit) AsString() (string, error) { - return mixins.Link{TypeName: "ipldgit.LinkCommit"}.AsString() +func (_Commit_Link_List__Repr) AsString() (string, error) { + return mixins.List{TypeName: "ipldgit.Commit_Link_List.Repr"}.AsString() } -func (LinkCommit) AsBytes() ([]byte, error) { - return mixins.Link{TypeName: "ipldgit.LinkCommit"}.AsBytes() +func (_Commit_Link_List__Repr) AsBytes() ([]byte, error) { + return mixins.List{TypeName: "ipldgit.Commit_Link_List.Repr"}.AsBytes() } -func (n LinkCommit) AsLink() (ipld.Link, error) { - return n.x, nil +func (_Commit_Link_List__Repr) AsLink() (ipld.Link, error) { + return mixins.List{TypeName: "ipldgit.Commit_Link_List.Repr"}.AsLink() } -func (LinkCommit) Prototype() ipld.NodePrototype { - return _LinkCommit__Prototype{} +func (_Commit_Link_List__Repr) Prototype() ipld.NodePrototype { + return _Commit_Link_List__ReprPrototype{} } -type _LinkCommit__Prototype struct{} +type _Commit_Link_List__ReprPrototype struct{} -func (_LinkCommit__Prototype) NewBuilder() ipld.NodeBuilder { - var nb _LinkCommit__Builder +func (_Commit_Link_List__ReprPrototype) NewBuilder() ipld.NodeBuilder { + var nb _Commit_Link_List__ReprBuilder nb.Reset() return &nb } -type _LinkCommit__Builder struct { - _LinkCommit__Assembler +type _Commit_Link_List__ReprBuilder struct { + _Commit_Link_List__ReprAssembler } -func (nb *_LinkCommit__Builder) Build() ipld.Node { +func (nb *_Commit_Link_List__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 *_LinkCommit__Builder) Reset() { - var w _LinkCommit +func (nb *_Commit_Link_List__ReprBuilder) Reset() { + var w _Commit_Link_List var m schema.Maybe - *nb = _LinkCommit__Builder{_LinkCommit__Assembler{w: &w, m: &m}} + *nb = _Commit_Link_List__ReprBuilder{_Commit_Link_List__ReprAssembler{w: &w, m: &m}} } -type _LinkCommit__Assembler struct { - w *_LinkCommit - m *schema.Maybe +type _Commit_Link_List__ReprAssembler struct { + w *_Commit_Link_List + m *schema.Maybe + state laState + + cm schema.Maybe + va _Commit_Link__ReprAssembler } -func (na *_LinkCommit__Assembler) reset() {} -func (_LinkCommit__Assembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { - return mixins.LinkAssembler{TypeName: "ipldgit.LinkCommit"}.BeginMap(0) +func (na *_Commit_Link_List__ReprAssembler) reset() { + na.state = laState_initial + na.va.reset() +} +func (_Commit_Link_List__ReprAssembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { + return mixins.ListAssembler{TypeName: "ipldgit.Commit_Link_List.Repr"}.BeginMap(0) } -func (_LinkCommit__Assembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { - return mixins.LinkAssembler{TypeName: "ipldgit.LinkCommit"}.BeginList(0) +func (na *_Commit_Link_List__ReprAssembler) BeginList(sizeHint int64) (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 sizeHint > 0 { + na.w.x = make([]_Commit_Link, 0, sizeHint) + } + return na, nil } -func (na *_LinkCommit__Assembler) AssignNull() error { +func (na *_Commit_Link_List__ReprAssembler) AssignNull() error { switch *na.m { case allowNull: *na.m = schema.Maybe_Null return nil case schema.Maybe_Absent: - return mixins.LinkAssembler{TypeName: "ipldgit.LinkCommit"}.AssignNull() + return mixins.ListAssembler{TypeName: "ipldgit.Commit_Link_List.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 (_LinkCommit__Assembler) AssignBool(bool) error { - return mixins.LinkAssembler{TypeName: "ipldgit.LinkCommit"}.AssignBool(false) +func (_Commit_Link_List__ReprAssembler) AssignBool(bool) error { + return mixins.ListAssembler{TypeName: "ipldgit.Commit_Link_List.Repr"}.AssignBool(false) } -func (_LinkCommit__Assembler) AssignInt(int64) error { - return mixins.LinkAssembler{TypeName: "ipldgit.LinkCommit"}.AssignInt(0) +func (_Commit_Link_List__ReprAssembler) AssignInt(int64) error { + return mixins.ListAssembler{TypeName: "ipldgit.Commit_Link_List.Repr"}.AssignInt(0) } -func (_LinkCommit__Assembler) AssignFloat(float64) error { - return mixins.LinkAssembler{TypeName: "ipldgit.LinkCommit"}.AssignFloat(0) +func (_Commit_Link_List__ReprAssembler) AssignFloat(float64) error { + return mixins.ListAssembler{TypeName: "ipldgit.Commit_Link_List.Repr"}.AssignFloat(0) } -func (_LinkCommit__Assembler) AssignString(string) error { - return mixins.LinkAssembler{TypeName: "ipldgit.LinkCommit"}.AssignString("") +func (_Commit_Link_List__ReprAssembler) AssignString(string) error { + return mixins.ListAssembler{TypeName: "ipldgit.Commit_Link_List.Repr"}.AssignString("") } -func (_LinkCommit__Assembler) AssignBytes([]byte) error { - return mixins.LinkAssembler{TypeName: "ipldgit.LinkCommit"}.AssignBytes(nil) +func (_Commit_Link_List__ReprAssembler) AssignBytes([]byte) error { + return mixins.ListAssembler{TypeName: "ipldgit.Commit_Link_List.Repr"}.AssignBytes(nil) } -func (na *_LinkCommit__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") - } - na.w.x = v - *na.m = schema.Maybe_Value - return nil +func (_Commit_Link_List__ReprAssembler) AssignLink(ipld.Link) error { + return mixins.ListAssembler{TypeName: "ipldgit.Commit_Link_List.Repr"}.AssignLink(nil) } -func (na *_LinkCommit__Assembler) AssignNode(v ipld.Node) error { +func (na *_Commit_Link_List__ReprAssembler) AssignNode(v ipld.Node) error { if v.IsNull() { return na.AssignNull() } - if v2, ok := v.(*_LinkCommit); ok { + if v2, ok := v.(*_Commit_Link_List); 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!") } *na.w = *v2 *na.m = schema.Maybe_Value return nil } - if v2, err := v.AsLink(); err != nil { - return err - } else { - return na.AssignLink(v2) + if v.Kind() != ipld.Kind_List { + return ipld.ErrWrongKind{TypeName: "ipldgit.Commit_Link_List.Repr", MethodName: "AssignNode", AppropriateKind: ipld.KindSet_JustList, ActualKind: v.Kind()} + } + 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 (_LinkCommit__Assembler) Prototype() ipld.NodePrototype { - return _LinkCommit__Prototype{} +func (_Commit_Link_List__ReprAssembler) Prototype() ipld.NodePrototype { + return _Commit_Link_List__ReprPrototype{} } -func (LinkCommit) Type() schema.Type { - return nil /*TODO:typelit*/ +func (la *_Commit_Link_List__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 (LinkCommit) LinkTargetNodePrototype() ipld.NodePrototype { - return Type.Commit__Repr +func (la *_Commit_Link_List__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, _Commit_Link{}) + 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 *_Commit_Link_List__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 (n LinkCommit) Representation() ipld.Node { - return (*_LinkCommit__Repr)(n) +func (la *_Commit_Link_List__ReprAssembler) ValuePrototype(_ int64) ipld.NodePrototype { + return _Commit_Link__ReprPrototype{} } -type _LinkCommit__Repr = _LinkCommit - -var _ ipld.Node = &_LinkCommit__Repr{} - -type _LinkCommit__ReprPrototype = _LinkCommit__Prototype -type _LinkCommit__ReprAssembler = _LinkCommit__Assembler - -func (n LinkTree) Link() ipld.Link { +func (n GpgSig) String() string { return n.x } -func (_LinkTree__Prototype) FromLink(v ipld.Link) (LinkTree, error) { - n := _LinkTree{v} +func (_GpgSig__Prototype) fromString(w *_GpgSig, v string) error { + *w = _GpgSig{v} + return nil +} +func (_GpgSig__Prototype) FromString(v string) (GpgSig, error) { + n := _GpgSig{v} return &n, nil } -type _LinkTree__Maybe struct { +type _GpgSig__Maybe struct { m schema.Maybe - v _LinkTree + v _GpgSig } -type MaybeLinkTree = *_LinkTree__Maybe +type MaybeGpgSig = *_GpgSig__Maybe -func (m MaybeLinkTree) IsNull() bool { +func (m MaybeGpgSig) IsNull() bool { return m.m == schema.Maybe_Null } -func (m MaybeLinkTree) IsAbsent() bool { +func (m MaybeGpgSig) IsAbsent() bool { return m.m == schema.Maybe_Absent } -func (m MaybeLinkTree) Exists() bool { +func (m MaybeGpgSig) Exists() bool { return m.m == schema.Maybe_Value } -func (m MaybeLinkTree) AsNode() ipld.Node { +func (m MaybeGpgSig) AsNode() ipld.Node { switch m.m { case schema.Maybe_Absent: return ipld.Absent @@ -2463,132 +2644,126 @@ func (m MaybeLinkTree) AsNode() ipld.Node { panic("unreachable") } } -func (m MaybeLinkTree) Must() LinkTree { +func (m MaybeGpgSig) Must() GpgSig { if !m.Exists() { panic("unbox of a maybe rejected") } return &m.v } -var _ ipld.Node = (LinkTree)(&_LinkTree{}) -var _ schema.TypedNode = (LinkTree)(&_LinkTree{}) +var _ ipld.Node = (GpgSig)(&_GpgSig{}) +var _ schema.TypedNode = (GpgSig)(&_GpgSig{}) -func (LinkTree) Kind() ipld.Kind { - return ipld.Kind_Link +func (GpgSig) Kind() ipld.Kind { + return ipld.Kind_String } -func (LinkTree) LookupByString(string) (ipld.Node, error) { - return mixins.Link{TypeName: "ipldgit.LinkTree"}.LookupByString("") +func (GpgSig) LookupByString(string) (ipld.Node, error) { + return mixins.String{TypeName: "ipldgit.GpgSig"}.LookupByString("") } -func (LinkTree) LookupByNode(ipld.Node) (ipld.Node, error) { - return mixins.Link{TypeName: "ipldgit.LinkTree"}.LookupByNode(nil) +func (GpgSig) LookupByNode(ipld.Node) (ipld.Node, error) { + return mixins.String{TypeName: "ipldgit.GpgSig"}.LookupByNode(nil) } -func (LinkTree) LookupByIndex(idx int64) (ipld.Node, error) { - return mixins.Link{TypeName: "ipldgit.LinkTree"}.LookupByIndex(0) +func (GpgSig) LookupByIndex(idx int64) (ipld.Node, error) { + return mixins.String{TypeName: "ipldgit.GpgSig"}.LookupByIndex(0) } -func (LinkTree) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { - return mixins.Link{TypeName: "ipldgit.LinkTree"}.LookupBySegment(seg) +func (GpgSig) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { + return mixins.String{TypeName: "ipldgit.GpgSig"}.LookupBySegment(seg) } -func (LinkTree) MapIterator() ipld.MapIterator { +func (GpgSig) MapIterator() ipld.MapIterator { return nil } -func (LinkTree) ListIterator() ipld.ListIterator { +func (GpgSig) ListIterator() ipld.ListIterator { return nil } -func (LinkTree) Length() int64 { +func (GpgSig) Length() int64 { return -1 } -func (LinkTree) IsAbsent() bool { +func (GpgSig) IsAbsent() bool { return false } -func (LinkTree) IsNull() bool { +func (GpgSig) IsNull() bool { return false } -func (LinkTree) AsBool() (bool, error) { - return mixins.Link{TypeName: "ipldgit.LinkTree"}.AsBool() +func (GpgSig) AsBool() (bool, error) { + return mixins.String{TypeName: "ipldgit.GpgSig"}.AsBool() } -func (LinkTree) AsInt() (int64, error) { - return mixins.Link{TypeName: "ipldgit.LinkTree"}.AsInt() +func (GpgSig) AsInt() (int64, error) { + return mixins.String{TypeName: "ipldgit.GpgSig"}.AsInt() } -func (LinkTree) AsFloat() (float64, error) { - return mixins.Link{TypeName: "ipldgit.LinkTree"}.AsFloat() +func (GpgSig) AsFloat() (float64, error) { + return mixins.String{TypeName: "ipldgit.GpgSig"}.AsFloat() } -func (LinkTree) AsString() (string, error) { - return mixins.Link{TypeName: "ipldgit.LinkTree"}.AsString() +func (n GpgSig) AsString() (string, error) { + return n.x, nil } -func (LinkTree) AsBytes() ([]byte, error) { - return mixins.Link{TypeName: "ipldgit.LinkTree"}.AsBytes() +func (GpgSig) AsBytes() ([]byte, error) { + return mixins.String{TypeName: "ipldgit.GpgSig"}.AsBytes() } -func (n LinkTree) AsLink() (ipld.Link, error) { - return n.x, nil +func (GpgSig) AsLink() (ipld.Link, error) { + return mixins.String{TypeName: "ipldgit.GpgSig"}.AsLink() } -func (LinkTree) Prototype() ipld.NodePrototype { - return _LinkTree__Prototype{} +func (GpgSig) Prototype() ipld.NodePrototype { + return _GpgSig__Prototype{} } -type _LinkTree__Prototype struct{} +type _GpgSig__Prototype struct{} -func (_LinkTree__Prototype) NewBuilder() ipld.NodeBuilder { - var nb _LinkTree__Builder +func (_GpgSig__Prototype) NewBuilder() ipld.NodeBuilder { + var nb _GpgSig__Builder nb.Reset() return &nb } -type _LinkTree__Builder struct { - _LinkTree__Assembler +type _GpgSig__Builder struct { + _GpgSig__Assembler } -func (nb *_LinkTree__Builder) Build() ipld.Node { +func (nb *_GpgSig__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 *_LinkTree__Builder) Reset() { - var w _LinkTree +func (nb *_GpgSig__Builder) Reset() { + var w _GpgSig var m schema.Maybe - *nb = _LinkTree__Builder{_LinkTree__Assembler{w: &w, m: &m}} + *nb = _GpgSig__Builder{_GpgSig__Assembler{w: &w, m: &m}} } -type _LinkTree__Assembler struct { - w *_LinkTree +type _GpgSig__Assembler struct { + w *_GpgSig m *schema.Maybe } -func (na *_LinkTree__Assembler) reset() {} -func (_LinkTree__Assembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { - return mixins.LinkAssembler{TypeName: "ipldgit.LinkTree"}.BeginMap(0) +func (na *_GpgSig__Assembler) reset() {} +func (_GpgSig__Assembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { + return mixins.StringAssembler{TypeName: "ipldgit.GpgSig"}.BeginMap(0) } -func (_LinkTree__Assembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { - return mixins.LinkAssembler{TypeName: "ipldgit.LinkTree"}.BeginList(0) +func (_GpgSig__Assembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { + return mixins.StringAssembler{TypeName: "ipldgit.GpgSig"}.BeginList(0) } -func (na *_LinkTree__Assembler) AssignNull() error { +func (na *_GpgSig__Assembler) AssignNull() error { switch *na.m { case allowNull: *na.m = schema.Maybe_Null return nil case schema.Maybe_Absent: - return mixins.LinkAssembler{TypeName: "ipldgit.LinkTree"}.AssignNull() + return mixins.StringAssembler{TypeName: "ipldgit.GpgSig"}.AssignNull() case schema.Maybe_Value, schema.Maybe_Null: panic("invalid state: cannot assign into assembler that's already finished") } panic("unreachable") } -func (_LinkTree__Assembler) AssignBool(bool) error { - return mixins.LinkAssembler{TypeName: "ipldgit.LinkTree"}.AssignBool(false) -} -func (_LinkTree__Assembler) AssignInt(int64) error { - return mixins.LinkAssembler{TypeName: "ipldgit.LinkTree"}.AssignInt(0) -} -func (_LinkTree__Assembler) AssignFloat(float64) error { - return mixins.LinkAssembler{TypeName: "ipldgit.LinkTree"}.AssignFloat(0) +func (_GpgSig__Assembler) AssignBool(bool) error { + return mixins.StringAssembler{TypeName: "ipldgit.GpgSig"}.AssignBool(false) } -func (_LinkTree__Assembler) AssignString(string) error { - return mixins.LinkAssembler{TypeName: "ipldgit.LinkTree"}.AssignString("") +func (_GpgSig__Assembler) AssignInt(int64) error { + return mixins.StringAssembler{TypeName: "ipldgit.GpgSig"}.AssignInt(0) } -func (_LinkTree__Assembler) AssignBytes([]byte) error { - return mixins.LinkAssembler{TypeName: "ipldgit.LinkTree"}.AssignBytes(nil) +func (_GpgSig__Assembler) AssignFloat(float64) error { + return mixins.StringAssembler{TypeName: "ipldgit.GpgSig"}.AssignFloat(0) } -func (na *_LinkTree__Assembler) AssignLink(v ipld.Link) error { +func (na *_GpgSig__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") @@ -2597,11 +2772,17 @@ func (na *_LinkTree__Assembler) AssignLink(v ipld.Link) error { *na.m = schema.Maybe_Value return nil } -func (na *_LinkTree__Assembler) AssignNode(v ipld.Node) error { +func (_GpgSig__Assembler) AssignBytes([]byte) error { + return mixins.StringAssembler{TypeName: "ipldgit.GpgSig"}.AssignBytes(nil) +} +func (_GpgSig__Assembler) AssignLink(ipld.Link) error { + return mixins.StringAssembler{TypeName: "ipldgit.GpgSig"}.AssignLink(nil) +} +func (na *_GpgSig__Assembler) AssignNode(v ipld.Node) error { if v.IsNull() { return na.AssignNull() } - if v2, ok := v.(*_LinkTree); ok { + if v2, ok := v.(*_GpgSig); ok { switch *na.m { case schema.Maybe_Value, schema.Maybe_Null: panic("invalid state: cannot assign into assembler that's already finished") @@ -2610,90 +2791,53 @@ func (na *_LinkTree__Assembler) AssignNode(v ipld.Node) error { *na.m = schema.Maybe_Value return nil } - if v2, err := v.AsLink(); err != nil { + if v2, err := v.AsString(); err != nil { return err } else { - return na.AssignLink(v2) + return na.AssignString(v2) } } -func (_LinkTree__Assembler) Prototype() ipld.NodePrototype { - return _LinkTree__Prototype{} +func (_GpgSig__Assembler) Prototype() ipld.NodePrototype { + return _GpgSig__Prototype{} } -func (LinkTree) Type() schema.Type { +func (GpgSig) Type() schema.Type { return nil /*TODO:typelit*/ } -func (LinkTree) LinkTargetNodePrototype() ipld.NodePrototype { - return Type.Tree__Repr -} -func (n LinkTree) Representation() ipld.Node { - return (*_LinkTree__Repr)(n) -} - -type _LinkTree__Repr = _LinkTree - -var _ ipld.Node = &_LinkTree__Repr{} - -type _LinkTree__ReprPrototype = _LinkTree__Prototype -type _LinkTree__ReprAssembler = _LinkTree__Assembler - -func (n *_ListParents) Lookup(idx int64) LinkCommit { - if n.Length() <= idx { - return nil - } - v := &n.x[idx] - return v -} -func (n *_ListParents) LookupMaybe(idx int64) MaybeLinkCommit { - if n.Length() <= idx { - return nil - } - v := &n.x[idx] - return &_LinkCommit__Maybe{ - m: schema.Maybe_Value, - v: *v, - } +func (n GpgSig) Representation() ipld.Node { + return (*_GpgSig__Repr)(n) } -var _ListParents__valueAbsent = _LinkCommit__Maybe{m: schema.Maybe_Absent} +type _GpgSig__Repr = _GpgSig -func (n ListParents) Iterator() *ListParents__Itr { - return &ListParents__Itr{n, 0} -} +var _ ipld.Node = &_GpgSig__Repr{} -type ListParents__Itr struct { - n ListParents - idx int -} +type _GpgSig__ReprPrototype = _GpgSig__Prototype +type _GpgSig__ReprAssembler = _GpgSig__Assembler -func (itr *ListParents__Itr) Next() (idx int64, v LinkCommit) { - if itr.idx >= len(itr.n.x) { - return -1, nil - } - idx = int64(itr.idx) - v = &itr.n.x[itr.idx] - itr.idx++ - return +func (n Link) Link() ipld.Link { + return n.x } -func (itr *ListParents__Itr) Done() bool { - return itr.idx >= len(itr.n.x) +func (_Link__Prototype) FromLink(v ipld.Link) (Link, error) { + n := _Link{v} + return &n, nil } -type _ListParents__Maybe struct { +type _Link__Maybe struct { m schema.Maybe - v _ListParents + v _Link } -type MaybeListParents = *_ListParents__Maybe +type MaybeLink = *_Link__Maybe -func (m MaybeListParents) IsNull() bool { +func (m MaybeLink) IsNull() bool { return m.m == schema.Maybe_Null } -func (m MaybeListParents) IsAbsent() bool { +func (m MaybeLink) IsAbsent() bool { return m.m == schema.Maybe_Absent } -func (m MaybeListParents) Exists() bool { +func (m MaybeLink) Exists() bool { return m.m == schema.Maybe_Value } -func (m MaybeListParents) AsNode() ipld.Node { +func (m MaybeLink) AsNode() ipld.Node { switch m.m { case schema.Maybe_Absent: return ipld.Absent @@ -2705,399 +2849,388 @@ func (m MaybeListParents) AsNode() ipld.Node { panic("unreachable") } } -func (m MaybeListParents) Must() ListParents { +func (m MaybeLink) Must() Link { if !m.Exists() { panic("unbox of a maybe rejected") } return &m.v } -var _ ipld.Node = (ListParents)(&_ListParents{}) -var _ schema.TypedNode = (ListParents)(&_ListParents{}) +var _ ipld.Node = (Link)(&_Link{}) +var _ schema.TypedNode = (Link)(&_Link{}) -func (ListParents) Kind() ipld.Kind { - return ipld.Kind_List +func (Link) Kind() ipld.Kind { + return ipld.Kind_Link } -func (ListParents) LookupByString(string) (ipld.Node, error) { - return mixins.List{TypeName: "ipldgit.ListParents"}.LookupByString("") +func (Link) LookupByString(string) (ipld.Node, error) { + return mixins.Link{TypeName: "ipldgit.Link"}.LookupByString("") } -func (n ListParents) LookupByNode(k ipld.Node) (ipld.Node, error) { - idx, err := k.AsInt() - if err != nil { - return nil, err - } - return n.LookupByIndex(idx) +func (Link) LookupByNode(ipld.Node) (ipld.Node, error) { + return mixins.Link{TypeName: "ipldgit.Link"}.LookupByNode(nil) } -func (n ListParents) LookupByIndex(idx int64) (ipld.Node, error) { - if n.Length() <= idx { - return nil, ipld.ErrNotExists{Segment: ipld.PathSegmentOfInt(idx)} - } - v := &n.x[idx] - return v, nil +func (Link) LookupByIndex(idx int64) (ipld.Node, error) { + return mixins.Link{TypeName: "ipldgit.Link"}.LookupByIndex(0) } -func (n ListParents) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { - i, err := seg.Index() - if err != nil { - return nil, ipld.ErrInvalidSegmentForList{TypeName: "ipldgit.ListParents", TroubleSegment: seg, Reason: err} - } - return n.LookupByIndex(i) +func (Link) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { + return mixins.Link{TypeName: "ipldgit.Link"}.LookupBySegment(seg) } -func (ListParents) MapIterator() ipld.MapIterator { +func (Link) MapIterator() ipld.MapIterator { return nil } -func (n ListParents) ListIterator() ipld.ListIterator { - return &_ListParents__ListItr{n, 0} -} - -type _ListParents__ListItr struct { - n ListParents - idx int -} - -func (itr *_ListParents__ListItr) Next() (idx int64, v ipld.Node, _ error) { - if itr.idx >= len(itr.n.x) { - return -1, nil, ipld.ErrIteratorOverread{} - } - idx = int64(itr.idx) - x := &itr.n.x[itr.idx] - v = x - itr.idx++ - return -} -func (itr *_ListParents__ListItr) Done() bool { - return itr.idx >= len(itr.n.x) +func (Link) ListIterator() ipld.ListIterator { + return nil } - -func (n ListParents) Length() int64 { - return int64(len(n.x)) +func (Link) Length() int64 { + return -1 } -func (ListParents) IsAbsent() bool { +func (Link) IsAbsent() bool { return false } -func (ListParents) IsNull() bool { +func (Link) IsNull() bool { return false } -func (ListParents) AsBool() (bool, error) { - return mixins.List{TypeName: "ipldgit.ListParents"}.AsBool() +func (Link) AsBool() (bool, error) { + return mixins.Link{TypeName: "ipldgit.Link"}.AsBool() } -func (ListParents) AsInt() (int64, error) { - return mixins.List{TypeName: "ipldgit.ListParents"}.AsInt() +func (Link) AsInt() (int64, error) { + return mixins.Link{TypeName: "ipldgit.Link"}.AsInt() } -func (ListParents) AsFloat() (float64, error) { - return mixins.List{TypeName: "ipldgit.ListParents"}.AsFloat() +func (Link) AsFloat() (float64, error) { + return mixins.Link{TypeName: "ipldgit.Link"}.AsFloat() } -func (ListParents) AsString() (string, error) { - return mixins.List{TypeName: "ipldgit.ListParents"}.AsString() +func (Link) AsString() (string, error) { + return mixins.Link{TypeName: "ipldgit.Link"}.AsString() } -func (ListParents) AsBytes() ([]byte, error) { - return mixins.List{TypeName: "ipldgit.ListParents"}.AsBytes() +func (Link) AsBytes() ([]byte, error) { + return mixins.Link{TypeName: "ipldgit.Link"}.AsBytes() } -func (ListParents) AsLink() (ipld.Link, error) { - return mixins.List{TypeName: "ipldgit.ListParents"}.AsLink() +func (n Link) AsLink() (ipld.Link, error) { + return n.x, nil } -func (ListParents) Prototype() ipld.NodePrototype { - return _ListParents__Prototype{} +func (Link) Prototype() ipld.NodePrototype { + return _Link__Prototype{} } -type _ListParents__Prototype struct{} +type _Link__Prototype struct{} -func (_ListParents__Prototype) NewBuilder() ipld.NodeBuilder { - var nb _ListParents__Builder +func (_Link__Prototype) NewBuilder() ipld.NodeBuilder { + var nb _Link__Builder nb.Reset() return &nb } -type _ListParents__Builder struct { - _ListParents__Assembler +type _Link__Builder struct { + _Link__Assembler } -func (nb *_ListParents__Builder) Build() ipld.Node { +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 *_ListParents__Builder) Reset() { - var w _ListParents +func (nb *_Link__Builder) Reset() { + var w _Link var m schema.Maybe - *nb = _ListParents__Builder{_ListParents__Assembler{w: &w, m: &m}} + *nb = _Link__Builder{_Link__Assembler{w: &w, m: &m}} } -type _ListParents__Assembler struct { - w *_ListParents - m *schema.Maybe - state laState - - cm schema.Maybe - va _LinkCommit__Assembler +type _Link__Assembler struct { + w *_Link + m *schema.Maybe } -func (na *_ListParents__Assembler) reset() { - na.state = laState_initial - na.va.reset() -} -func (_ListParents__Assembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { - return mixins.ListAssembler{TypeName: "ipldgit.ListParents"}.BeginMap(0) +func (na *_Link__Assembler) reset() {} +func (_Link__Assembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { + return mixins.LinkAssembler{TypeName: "ipldgit.Link"}.BeginMap(0) } -func (na *_ListParents__Assembler) BeginList(sizeHint int64) (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 sizeHint > 0 { - na.w.x = make([]_LinkCommit, 0, sizeHint) - } - return na, nil +func (_Link__Assembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { + return mixins.LinkAssembler{TypeName: "ipldgit.Link"}.BeginList(0) } -func (na *_ListParents__Assembler) AssignNull() error { +func (na *_Link__Assembler) AssignNull() error { switch *na.m { case allowNull: *na.m = schema.Maybe_Null return nil case schema.Maybe_Absent: - return mixins.ListAssembler{TypeName: "ipldgit.ListParents"}.AssignNull() + return mixins.LinkAssembler{TypeName: "ipldgit.Link"}.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 (_ListParents__Assembler) AssignBool(bool) error { - return mixins.ListAssembler{TypeName: "ipldgit.ListParents"}.AssignBool(false) +func (_Link__Assembler) AssignBool(bool) error { + return mixins.LinkAssembler{TypeName: "ipldgit.Link"}.AssignBool(false) } -func (_ListParents__Assembler) AssignInt(int64) error { - return mixins.ListAssembler{TypeName: "ipldgit.ListParents"}.AssignInt(0) +func (_Link__Assembler) AssignInt(int64) error { + return mixins.LinkAssembler{TypeName: "ipldgit.Link"}.AssignInt(0) } -func (_ListParents__Assembler) AssignFloat(float64) error { - return mixins.ListAssembler{TypeName: "ipldgit.ListParents"}.AssignFloat(0) +func (_Link__Assembler) AssignFloat(float64) error { + return mixins.LinkAssembler{TypeName: "ipldgit.Link"}.AssignFloat(0) } -func (_ListParents__Assembler) AssignString(string) error { - return mixins.ListAssembler{TypeName: "ipldgit.ListParents"}.AssignString("") +func (_Link__Assembler) AssignString(string) error { + return mixins.LinkAssembler{TypeName: "ipldgit.Link"}.AssignString("") } -func (_ListParents__Assembler) AssignBytes([]byte) error { - return mixins.ListAssembler{TypeName: "ipldgit.ListParents"}.AssignBytes(nil) +func (_Link__Assembler) AssignBytes([]byte) error { + return mixins.LinkAssembler{TypeName: "ipldgit.Link"}.AssignBytes(nil) } -func (_ListParents__Assembler) AssignLink(ipld.Link) error { - return mixins.ListAssembler{TypeName: "ipldgit.ListParents"}.AssignLink(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") + } + na.w.x = v + *na.m = schema.Maybe_Value + return nil } -func (na *_ListParents__Assembler) AssignNode(v ipld.Node) error { +func (na *_Link__Assembler) AssignNode(v ipld.Node) error { if v.IsNull() { return na.AssignNull() } - if v2, ok := v.(*_ListParents); ok { + 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") - case midvalue: - panic("invalid state: cannot assign null into an assembler that's already begun working on recursive structures!") } *na.w = *v2 *na.m = schema.Maybe_Value return nil } - if v.Kind() != ipld.Kind_List { - return ipld.ErrWrongKind{TypeName: "ipldgit.ListParents", MethodName: "AssignNode", AppropriateKind: ipld.KindSet_JustList, ActualKind: v.Kind()} - } - 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 (_ListParents__Assembler) Prototype() ipld.NodePrototype { - return _ListParents__Prototype{} -} -func (la *_ListParents__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 *_ListParents__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, _LinkCommit{}) - 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 *_ListParents__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") + if v2, err := v.AsLink(); err != nil { + return err + } else { + return na.AssignLink(v2) } - la.state = laState_finished - *la.m = schema.Maybe_Value - return nil } -func (la *_ListParents__Assembler) ValuePrototype(_ int64) ipld.NodePrototype { - return _LinkCommit__Prototype{} +func (_Link__Assembler) Prototype() ipld.NodePrototype { + return _Link__Prototype{} } -func (ListParents) Type() schema.Type { +func (Link) Type() schema.Type { return nil /*TODO:typelit*/ } -func (n ListParents) Representation() ipld.Node { - return (*_ListParents__Repr)(n) +func (n Link) Representation() ipld.Node { + return (*_Link__Repr)(n) } -type _ListParents__Repr _ListParents +type _Link__Repr = _Link -var _ ipld.Node = &_ListParents__Repr{} +var _ ipld.Node = &_Link__Repr{} -func (_ListParents__Repr) Kind() ipld.Kind { - return ipld.Kind_List -} -func (_ListParents__Repr) LookupByString(string) (ipld.Node, error) { - return mixins.List{TypeName: "ipldgit.ListParents.Repr"}.LookupByString("") -} -func (nr *_ListParents__Repr) LookupByNode(k ipld.Node) (ipld.Node, error) { - v, err := (ListParents)(nr).LookupByNode(k) - if err != nil || v == ipld.Null { - return v, err - } - return v.(LinkCommit).Representation(), nil -} -func (nr *_ListParents__Repr) LookupByIndex(idx int64) (ipld.Node, error) { - v, err := (ListParents)(nr).LookupByIndex(idx) - if err != nil || v == ipld.Null { - return v, err - } - return v.(LinkCommit).Representation(), nil +type _Link__ReprPrototype = _Link__Prototype +type _Link__ReprAssembler = _Link__Assembler + +func (n _PersonInfo) FieldDate() String { + return &n.date } -func (n _ListParents__Repr) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { - i, err := seg.Index() - if err != nil { - return nil, ipld.ErrInvalidSegmentForList{TypeName: "ipldgit.ListParents.Repr", TroubleSegment: seg, Reason: err} - } - return n.LookupByIndex(i) +func (n _PersonInfo) FieldTimezone() String { + return &n.timezone } -func (_ListParents__Repr) MapIterator() ipld.MapIterator { - return nil +func (n _PersonInfo) FieldEmail() String { + return &n.email } -func (nr *_ListParents__Repr) ListIterator() ipld.ListIterator { - return &_ListParents__ReprListItr{(ListParents)(nr), 0} +func (n _PersonInfo) FieldName() String { + return &n.name } -type _ListParents__ReprListItr _ListParents__ListItr - -func (itr *_ListParents__ReprListItr) Next() (idx int64, v ipld.Node, err error) { - idx, v, err = (*_ListParents__ListItr)(itr).Next() - if err != nil || v == ipld.Null { - return - } - return idx, v.(LinkCommit).Representation(), nil -} -func (itr *_ListParents__ReprListItr) Done() bool { - return (*_ListParents__ListItr)(itr).Done() +type _PersonInfo__Maybe struct { + m schema.Maybe + v PersonInfo } +type MaybePersonInfo = *_PersonInfo__Maybe -func (rn *_ListParents__Repr) Length() int64 { - return int64(len(rn.x)) -} -func (_ListParents__Repr) IsAbsent() bool { - return false -} -func (_ListParents__Repr) IsNull() bool { - return false -} -func (_ListParents__Repr) AsBool() (bool, error) { - return mixins.List{TypeName: "ipldgit.ListParents.Repr"}.AsBool() -} -func (_ListParents__Repr) AsInt() (int64, error) { - return mixins.List{TypeName: "ipldgit.ListParents.Repr"}.AsInt() -} -func (_ListParents__Repr) AsFloat() (float64, error) { - return mixins.List{TypeName: "ipldgit.ListParents.Repr"}.AsFloat() +func (m MaybePersonInfo) IsNull() bool { + return m.m == schema.Maybe_Null } -func (_ListParents__Repr) AsString() (string, error) { - return mixins.List{TypeName: "ipldgit.ListParents.Repr"}.AsString() +func (m MaybePersonInfo) IsAbsent() bool { + return m.m == schema.Maybe_Absent } -func (_ListParents__Repr) AsBytes() ([]byte, error) { - return mixins.List{TypeName: "ipldgit.ListParents.Repr"}.AsBytes() +func (m MaybePersonInfo) Exists() bool { + return m.m == schema.Maybe_Value } -func (_ListParents__Repr) AsLink() (ipld.Link, error) { - return mixins.List{TypeName: "ipldgit.ListParents.Repr"}.AsLink() +func (m MaybePersonInfo) 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 (_ListParents__Repr) Prototype() ipld.NodePrototype { - return _ListParents__ReprPrototype{} +func (m MaybePersonInfo) Must() PersonInfo { + if !m.Exists() { + panic("unbox of a maybe rejected") + } + return m.v } -type _ListParents__ReprPrototype struct{} +var ( + fieldName__PersonInfo_Date = _String{"date"} + fieldName__PersonInfo_Timezone = _String{"timezone"} + fieldName__PersonInfo_Email = _String{"email"} + fieldName__PersonInfo_Name = _String{"name"} +) +var _ ipld.Node = (PersonInfo)(&_PersonInfo{}) +var _ schema.TypedNode = (PersonInfo)(&_PersonInfo{}) -func (_ListParents__ReprPrototype) NewBuilder() ipld.NodeBuilder { - var nb _ListParents__ReprBuilder +func (PersonInfo) Kind() ipld.Kind { + return ipld.Kind_Map +} +func (n PersonInfo) LookupByString(key string) (ipld.Node, error) { + switch key { + case "date": + return &n.date, nil + case "timezone": + return &n.timezone, nil + case "email": + return &n.email, nil + case "name": + return &n.name, nil + default: + return nil, schema.ErrNoSuchField{Type: nil /*TODO*/, Field: ipld.PathSegmentOfString(key)} + } +} +func (n PersonInfo) LookupByNode(key ipld.Node) (ipld.Node, error) { + ks, err := key.AsString() + if err != nil { + return nil, err + } + return n.LookupByString(ks) +} +func (PersonInfo) LookupByIndex(idx int64) (ipld.Node, error) { + return mixins.Map{TypeName: "ipldgit.PersonInfo"}.LookupByIndex(0) +} +func (n PersonInfo) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { + return n.LookupByString(seg.String()) +} +func (n PersonInfo) MapIterator() ipld.MapIterator { + return &_PersonInfo__MapItr{n, 0} +} + +type _PersonInfo__MapItr struct { + n PersonInfo + idx int +} + +func (itr *_PersonInfo__MapItr) Next() (k ipld.Node, v ipld.Node, _ error) { + if itr.idx >= 4 { + return nil, nil, ipld.ErrIteratorOverread{} + } + switch itr.idx { + case 0: + k = &fieldName__PersonInfo_Date + v = &itr.n.date + case 1: + k = &fieldName__PersonInfo_Timezone + v = &itr.n.timezone + case 2: + k = &fieldName__PersonInfo_Email + v = &itr.n.email + case 3: + k = &fieldName__PersonInfo_Name + v = &itr.n.name + default: + panic("unreachable") + } + itr.idx++ + return +} +func (itr *_PersonInfo__MapItr) Done() bool { + return itr.idx >= 4 +} + +func (PersonInfo) ListIterator() ipld.ListIterator { + return nil +} +func (PersonInfo) Length() int64 { + return 4 +} +func (PersonInfo) IsAbsent() bool { + return false +} +func (PersonInfo) IsNull() bool { + return false +} +func (PersonInfo) AsBool() (bool, error) { + return mixins.Map{TypeName: "ipldgit.PersonInfo"}.AsBool() +} +func (PersonInfo) AsInt() (int64, error) { + return mixins.Map{TypeName: "ipldgit.PersonInfo"}.AsInt() +} +func (PersonInfo) AsFloat() (float64, error) { + return mixins.Map{TypeName: "ipldgit.PersonInfo"}.AsFloat() +} +func (PersonInfo) AsString() (string, error) { + return mixins.Map{TypeName: "ipldgit.PersonInfo"}.AsString() +} +func (PersonInfo) AsBytes() ([]byte, error) { + return mixins.Map{TypeName: "ipldgit.PersonInfo"}.AsBytes() +} +func (PersonInfo) AsLink() (ipld.Link, error) { + return mixins.Map{TypeName: "ipldgit.PersonInfo"}.AsLink() +} +func (PersonInfo) Prototype() ipld.NodePrototype { + return _PersonInfo__Prototype{} +} + +type _PersonInfo__Prototype struct{} + +func (_PersonInfo__Prototype) NewBuilder() ipld.NodeBuilder { + var nb _PersonInfo__Builder nb.Reset() return &nb } -type _ListParents__ReprBuilder struct { - _ListParents__ReprAssembler +type _PersonInfo__Builder struct { + _PersonInfo__Assembler } -func (nb *_ListParents__ReprBuilder) Build() ipld.Node { +func (nb *_PersonInfo__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 *_ListParents__ReprBuilder) Reset() { - var w _ListParents +func (nb *_PersonInfo__Builder) Reset() { + var w _PersonInfo var m schema.Maybe - *nb = _ListParents__ReprBuilder{_ListParents__ReprAssembler{w: &w, m: &m}} + *nb = _PersonInfo__Builder{_PersonInfo__Assembler{w: &w, m: &m}} } -type _ListParents__ReprAssembler struct { - w *_ListParents +type _PersonInfo__Assembler struct { + w *_PersonInfo m *schema.Maybe - state laState + state maState + s int + f int - cm schema.Maybe - va _LinkCommit__ReprAssembler + cm schema.Maybe + ca_date _String__Assembler + ca_timezone _String__Assembler + ca_email _String__Assembler + ca_name _String__Assembler } -func (na *_ListParents__ReprAssembler) reset() { - na.state = laState_initial - na.va.reset() -} -func (_ListParents__ReprAssembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { - return mixins.ListAssembler{TypeName: "ipldgit.ListParents.Repr"}.BeginMap(0) +func (na *_PersonInfo__Assembler) reset() { + na.state = maState_initial + na.s = 0 + na.ca_date.reset() + na.ca_timezone.reset() + na.ca_email.reset() + na.ca_name.reset() } -func (na *_ListParents__ReprAssembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { + +var ( + fieldBit__PersonInfo_Date = 1 << 0 + fieldBit__PersonInfo_Timezone = 1 << 1 + fieldBit__PersonInfo_Email = 1 << 2 + fieldBit__PersonInfo_Name = 1 << 3 + fieldBits__PersonInfo_sufficient = 0 + 1<<0 + 1<<1 + 1<<2 + 1<<3 +) + +func (na *_PersonInfo__Assembler) BeginMap(int64) (ipld.MapAssembler, error) { switch *na.m { case schema.Maybe_Value, schema.Maybe_Null: panic("invalid state: cannot assign into assembler that's already finished") @@ -3105,21 +3238,21 @@ func (na *_ListParents__ReprAssembler) BeginList(sizeHint int64) (ipld.ListAssem panic("invalid state: it makes no sense to 'begin' twice on the same assembler!") } *na.m = midvalue - if sizeHint < 0 { - sizeHint = 0 - } - if sizeHint > 0 { - na.w.x = make([]_LinkCommit, 0, sizeHint) + if na.w == nil { + na.w = &_PersonInfo{} } return na, nil } -func (na *_ListParents__ReprAssembler) AssignNull() error { +func (_PersonInfo__Assembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { + return mixins.MapAssembler{TypeName: "ipldgit.PersonInfo"}.BeginList(0) +} +func (na *_PersonInfo__Assembler) AssignNull() error { switch *na.m { case allowNull: *na.m = schema.Maybe_Null return nil case schema.Maybe_Absent: - return mixins.ListAssembler{TypeName: "ipldgit.ListParents.Repr.Repr"}.AssignNull() + return mixins.MapAssembler{TypeName: "ipldgit.PersonInfo"}.AssignNull() case schema.Maybe_Value, schema.Maybe_Null: panic("invalid state: cannot assign into assembler that's already finished") case midvalue: @@ -3127,310 +3260,506 @@ func (na *_ListParents__ReprAssembler) AssignNull() error { } panic("unreachable") } -func (_ListParents__ReprAssembler) AssignBool(bool) error { - return mixins.ListAssembler{TypeName: "ipldgit.ListParents.Repr"}.AssignBool(false) +func (_PersonInfo__Assembler) AssignBool(bool) error { + return mixins.MapAssembler{TypeName: "ipldgit.PersonInfo"}.AssignBool(false) } -func (_ListParents__ReprAssembler) AssignInt(int64) error { - return mixins.ListAssembler{TypeName: "ipldgit.ListParents.Repr"}.AssignInt(0) +func (_PersonInfo__Assembler) AssignInt(int64) error { + return mixins.MapAssembler{TypeName: "ipldgit.PersonInfo"}.AssignInt(0) } -func (_ListParents__ReprAssembler) AssignFloat(float64) error { - return mixins.ListAssembler{TypeName: "ipldgit.ListParents.Repr"}.AssignFloat(0) +func (_PersonInfo__Assembler) AssignFloat(float64) error { + return mixins.MapAssembler{TypeName: "ipldgit.PersonInfo"}.AssignFloat(0) } -func (_ListParents__ReprAssembler) AssignString(string) error { - return mixins.ListAssembler{TypeName: "ipldgit.ListParents.Repr"}.AssignString("") +func (_PersonInfo__Assembler) AssignString(string) error { + return mixins.MapAssembler{TypeName: "ipldgit.PersonInfo"}.AssignString("") } -func (_ListParents__ReprAssembler) AssignBytes([]byte) error { - return mixins.ListAssembler{TypeName: "ipldgit.ListParents.Repr"}.AssignBytes(nil) +func (_PersonInfo__Assembler) AssignBytes([]byte) error { + return mixins.MapAssembler{TypeName: "ipldgit.PersonInfo"}.AssignBytes(nil) } -func (_ListParents__ReprAssembler) AssignLink(ipld.Link) error { - return mixins.ListAssembler{TypeName: "ipldgit.ListParents.Repr"}.AssignLink(nil) +func (_PersonInfo__Assembler) AssignLink(ipld.Link) error { + return mixins.MapAssembler{TypeName: "ipldgit.PersonInfo"}.AssignLink(nil) } -func (na *_ListParents__ReprAssembler) AssignNode(v ipld.Node) error { +func (na *_PersonInfo__Assembler) AssignNode(v ipld.Node) error { if v.IsNull() { return na.AssignNull() } - if v2, ok := v.(*_ListParents); ok { + if v2, ok := v.(*_PersonInfo); 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.Kind() != ipld.Kind_List { - return ipld.ErrWrongKind{TypeName: "ipldgit.ListParents.Repr", MethodName: "AssignNode", AppropriateKind: ipld.KindSet_JustList, ActualKind: v.Kind()} + if v.Kind() != ipld.Kind_Map { + return ipld.ErrWrongKind{TypeName: "ipldgit.PersonInfo", MethodName: "AssignNode", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()} } - itr := v.ListIterator() + itr := v.MapIterator() for !itr.Done() { - _, v, err := itr.Next() + k, v, err := itr.Next() if err != nil { return err } + if err := na.AssembleKey().AssignNode(k); err != nil { + return err + } if err := na.AssembleValue().AssignNode(v); err != nil { return err } } return na.Finish() } -func (_ListParents__ReprAssembler) Prototype() ipld.NodePrototype { - return _ListParents__ReprPrototype{} +func (_PersonInfo__Assembler) Prototype() ipld.NodePrototype { + return _PersonInfo__Prototype{} } -func (la *_ListParents__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 +func (ma *_PersonInfo__Assembler) valueFinishTidy() bool { + switch ma.f { + case 0: + switch ma.cm { + case schema.Maybe_Value: + ma.ca_date.w = nil + ma.cm = schema.Maybe_Absent + ma.state = maState_initial + return true + default: + return false + } + case 1: + switch ma.cm { + case schema.Maybe_Value: + ma.ca_timezone.w = nil + ma.cm = schema.Maybe_Absent + ma.state = maState_initial + return true + default: + return false + } + case 2: + switch ma.cm { + case schema.Maybe_Value: + ma.ca_email.w = nil + ma.cm = schema.Maybe_Absent + ma.state = maState_initial + return true + default: + return false + } + case 3: + switch ma.cm { + case schema.Maybe_Value: + ma.ca_name.w = nil + ma.cm = schema.Maybe_Absent + ma.state = maState_initial + return true + default: + return false + } default: - return false + panic("unreachable") } } -func (la *_ListParents__ReprAssembler) AssembleValue() ipld.NodeAssembler { - switch la.state { - case laState_initial: +func (ma *_PersonInfo__Assembler) AssembleEntry(k string) (ipld.NodeAssembler, error) { + switch ma.state { + case maState_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") + case maState_midKey: + panic("invalid state: AssembleEntry cannot be called when in the middle of assembling another key") + case maState_expectValue: + panic("invalid state: AssembleEntry cannot be called when expecting start of value assembly") + case maState_midValue: + if !ma.valueFinishTidy() { + panic("invalid state: AssembleEntry cannot be called when in the middle of assembling a value") } // if tidy success: carry on - case laState_finished: - panic("invalid state: AssembleValue cannot be called on an assembler that's already finished") + case maState_finished: + panic("invalid state: AssembleEntry cannot be called on an assembler that's already finished") } - la.w.x = append(la.w.x, _LinkCommit{}) - 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 + switch k { + case "date": + if ma.s&fieldBit__PersonInfo_Date != 0 { + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Date} + } + ma.s += fieldBit__PersonInfo_Date + ma.state = maState_midValue + ma.f = 0 + ma.ca_date.w = &ma.w.date + ma.ca_date.m = &ma.cm + return &ma.ca_date, nil + case "timezone": + if ma.s&fieldBit__PersonInfo_Timezone != 0 { + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Timezone} + } + ma.s += fieldBit__PersonInfo_Timezone + ma.state = maState_midValue + ma.f = 1 + ma.ca_timezone.w = &ma.w.timezone + ma.ca_timezone.m = &ma.cm + return &ma.ca_timezone, nil + case "email": + if ma.s&fieldBit__PersonInfo_Email != 0 { + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Email} + } + ma.s += fieldBit__PersonInfo_Email + ma.state = maState_midValue + ma.f = 2 + ma.ca_email.w = &ma.w.email + ma.ca_email.m = &ma.cm + return &ma.ca_email, nil + case "name": + if ma.s&fieldBit__PersonInfo_Name != 0 { + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Name} + } + ma.s += fieldBit__PersonInfo_Name + ma.state = maState_midValue + ma.f = 3 + ma.ca_name.w = &ma.w.name + ma.ca_name.m = &ma.cm + return &ma.ca_name, nil + } + return nil, ipld.ErrInvalidKey{TypeName: "ipldgit.PersonInfo", Key: &_String{k}} } -func (la *_ListParents__ReprAssembler) Finish() error { - switch la.state { - case laState_initial: +func (ma *_PersonInfo__Assembler) AssembleKey() ipld.NodeAssembler { + switch ma.state { + case maState_initial: // carry on - case laState_midValue: - if !la.valueFinishTidy() { - panic("invalid state: Finish cannot be called when in the middle of assembling a value") + case maState_midKey: + panic("invalid state: AssembleKey cannot be called when in the middle of assembling another key") + case maState_expectValue: + panic("invalid state: AssembleKey cannot be called when expecting start of value assembly") + case maState_midValue: + if !ma.valueFinishTidy() { + panic("invalid state: AssembleKey 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") + case maState_finished: + panic("invalid state: AssembleKey cannot be called on an assembler that's already finished") } - la.state = laState_finished - *la.m = schema.Maybe_Value - return nil -} -func (la *_ListParents__ReprAssembler) ValuePrototype(_ int64) ipld.NodePrototype { - return _LinkCommit__ReprPrototype{} + ma.state = maState_midKey + return (*_PersonInfo__KeyAssembler)(ma) } - -func (n *_ListString) Lookup(idx int64) String { - if n.Length() <= idx { - return nil +func (ma *_PersonInfo__Assembler) AssembleValue() ipld.NodeAssembler { + switch ma.state { + case maState_initial: + panic("invalid state: AssembleValue cannot be called when no key is primed") + case maState_midKey: + panic("invalid state: AssembleValue cannot be called when in the middle of assembling a key") + case maState_expectValue: + // carry on + case maState_midValue: + panic("invalid state: AssembleValue cannot be called when in the middle of assembling another value") + case maState_finished: + panic("invalid state: AssembleValue cannot be called on an assembler that's already finished") + } + ma.state = maState_midValue + switch ma.f { + case 0: + ma.ca_date.w = &ma.w.date + ma.ca_date.m = &ma.cm + return &ma.ca_date + case 1: + ma.ca_timezone.w = &ma.w.timezone + ma.ca_timezone.m = &ma.cm + return &ma.ca_timezone + case 2: + ma.ca_email.w = &ma.w.email + ma.ca_email.m = &ma.cm + return &ma.ca_email + case 3: + ma.ca_name.w = &ma.w.name + ma.ca_name.m = &ma.cm + return &ma.ca_name + default: + panic("unreachable") } - v := &n.x[idx] - return v } -func (n *_ListString) LookupMaybe(idx int64) MaybeString { - if n.Length() <= idx { - return nil +func (ma *_PersonInfo__Assembler) Finish() error { + switch ma.state { + case maState_initial: + // carry on + case maState_midKey: + panic("invalid state: Finish cannot be called when in the middle of assembling a key") + case maState_expectValue: + panic("invalid state: Finish cannot be called when expecting start of value assembly") + case maState_midValue: + if !ma.valueFinishTidy() { + panic("invalid state: Finish cannot be called when in the middle of assembling a value") + } // if tidy success: carry on + case maState_finished: + panic("invalid state: Finish cannot be called on an assembler that's already finished") } - v := &n.x[idx] - return &_String__Maybe{ - m: schema.Maybe_Value, - v: *v, + if ma.s&fieldBits__PersonInfo_sufficient != fieldBits__PersonInfo_sufficient { + err := ipld.ErrMissingRequiredField{Missing: make([]string, 0)} + if ma.s&fieldBit__PersonInfo_Date == 0 { + err.Missing = append(err.Missing, "date") + } + if ma.s&fieldBit__PersonInfo_Timezone == 0 { + err.Missing = append(err.Missing, "timezone") + } + if ma.s&fieldBit__PersonInfo_Email == 0 { + err.Missing = append(err.Missing, "email") + } + if ma.s&fieldBit__PersonInfo_Name == 0 { + err.Missing = append(err.Missing, "name") + } + return err } + ma.state = maState_finished + *ma.m = schema.Maybe_Value + return nil } - -var _ListString__valueAbsent = _String__Maybe{m: schema.Maybe_Absent} - -func (n ListString) Iterator() *ListString__Itr { - return &ListString__Itr{n, 0} +func (ma *_PersonInfo__Assembler) KeyPrototype() ipld.NodePrototype { + return _String__Prototype{} } - -type ListString__Itr struct { - n ListString - idx int +func (ma *_PersonInfo__Assembler) ValuePrototype(k string) ipld.NodePrototype { + panic("todo structbuilder mapassembler valueprototype") } -func (itr *ListString__Itr) Next() (idx int64, v String) { - if itr.idx >= len(itr.n.x) { - return -1, nil - } - idx = int64(itr.idx) - v = &itr.n.x[itr.idx] - itr.idx++ - return +type _PersonInfo__KeyAssembler _PersonInfo__Assembler + +func (_PersonInfo__KeyAssembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { + return mixins.StringAssembler{TypeName: "ipldgit.PersonInfo.KeyAssembler"}.BeginMap(0) } -func (itr *ListString__Itr) Done() bool { - return itr.idx >= len(itr.n.x) +func (_PersonInfo__KeyAssembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { + return mixins.StringAssembler{TypeName: "ipldgit.PersonInfo.KeyAssembler"}.BeginList(0) } - -type _ListString__Maybe struct { - m schema.Maybe - v _ListString +func (na *_PersonInfo__KeyAssembler) AssignNull() error { + return mixins.StringAssembler{TypeName: "ipldgit.PersonInfo.KeyAssembler"}.AssignNull() } -type MaybeListString = *_ListString__Maybe - -func (m MaybeListString) IsNull() bool { - return m.m == schema.Maybe_Null +func (_PersonInfo__KeyAssembler) AssignBool(bool) error { + return mixins.StringAssembler{TypeName: "ipldgit.PersonInfo.KeyAssembler"}.AssignBool(false) } -func (m MaybeListString) IsAbsent() bool { - return m.m == schema.Maybe_Absent +func (_PersonInfo__KeyAssembler) AssignInt(int64) error { + return mixins.StringAssembler{TypeName: "ipldgit.PersonInfo.KeyAssembler"}.AssignInt(0) } -func (m MaybeListString) Exists() bool { - return m.m == schema.Maybe_Value +func (_PersonInfo__KeyAssembler) AssignFloat(float64) error { + return mixins.StringAssembler{TypeName: "ipldgit.PersonInfo.KeyAssembler"}.AssignFloat(0) } -func (m MaybeListString) 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 (ka *_PersonInfo__KeyAssembler) AssignString(k string) error { + if ka.state != maState_midKey { + panic("misuse: KeyAssembler held beyond its valid lifetime") } -} -func (m MaybeListString) Must() ListString { - if !m.Exists() { - panic("unbox of a maybe rejected") + switch k { + case "date": + if ka.s&fieldBit__PersonInfo_Date != 0 { + return ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Date} + } + ka.s += fieldBit__PersonInfo_Date + ka.state = maState_expectValue + ka.f = 0 + return nil + case "timezone": + if ka.s&fieldBit__PersonInfo_Timezone != 0 { + return ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Timezone} + } + ka.s += fieldBit__PersonInfo_Timezone + ka.state = maState_expectValue + ka.f = 1 + return nil + case "email": + if ka.s&fieldBit__PersonInfo_Email != 0 { + return ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Email} + } + ka.s += fieldBit__PersonInfo_Email + ka.state = maState_expectValue + ka.f = 2 + return nil + case "name": + if ka.s&fieldBit__PersonInfo_Name != 0 { + return ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Name} + } + ka.s += fieldBit__PersonInfo_Name + ka.state = maState_expectValue + ka.f = 3 + return nil + default: + return ipld.ErrInvalidKey{TypeName: "ipldgit.PersonInfo", Key: &_String{k}} } - return &m.v -} - -var _ ipld.Node = (ListString)(&_ListString{}) -var _ schema.TypedNode = (ListString)(&_ListString{}) - -func (ListString) Kind() ipld.Kind { - return ipld.Kind_List } -func (ListString) LookupByString(string) (ipld.Node, error) { - return mixins.List{TypeName: "ipldgit.ListString"}.LookupByString("") +func (_PersonInfo__KeyAssembler) AssignBytes([]byte) error { + return mixins.StringAssembler{TypeName: "ipldgit.PersonInfo.KeyAssembler"}.AssignBytes(nil) } -func (n ListString) LookupByNode(k ipld.Node) (ipld.Node, error) { - idx, err := k.AsInt() - if err != nil { - return nil, err - } - return n.LookupByIndex(idx) +func (_PersonInfo__KeyAssembler) AssignLink(ipld.Link) error { + return mixins.StringAssembler{TypeName: "ipldgit.PersonInfo.KeyAssembler"}.AssignLink(nil) } -func (n ListString) LookupByIndex(idx int64) (ipld.Node, error) { - if n.Length() <= idx { - return nil, ipld.ErrNotExists{Segment: ipld.PathSegmentOfInt(idx)} +func (ka *_PersonInfo__KeyAssembler) AssignNode(v ipld.Node) error { + if v2, err := v.AsString(); err != nil { + return err + } else { + return ka.AssignString(v2) } - v := &n.x[idx] - return v, nil } -func (n ListString) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { - i, err := seg.Index() +func (_PersonInfo__KeyAssembler) Prototype() ipld.NodePrototype { + return _String__Prototype{} +} +func (PersonInfo) Type() schema.Type { + return nil /*TODO:typelit*/ +} +func (n PersonInfo) Representation() ipld.Node { + return (*_PersonInfo__Repr)(n) +} + +type _PersonInfo__Repr _PersonInfo + +var ( + fieldName__PersonInfo_Date_serial = _String{"date"} + fieldName__PersonInfo_Timezone_serial = _String{"timezone"} + fieldName__PersonInfo_Email_serial = _String{"email"} + fieldName__PersonInfo_Name_serial = _String{"name"} +) +var _ ipld.Node = &_PersonInfo__Repr{} + +func (_PersonInfo__Repr) Kind() ipld.Kind { + return ipld.Kind_Map +} +func (n *_PersonInfo__Repr) LookupByString(key string) (ipld.Node, error) { + switch key { + case "date": + return n.date.Representation(), nil + case "timezone": + return n.timezone.Representation(), nil + case "email": + return n.email.Representation(), nil + case "name": + return n.name.Representation(), nil + default: + return nil, schema.ErrNoSuchField{Type: nil /*TODO*/, Field: ipld.PathSegmentOfString(key)} + } +} +func (n *_PersonInfo__Repr) LookupByNode(key ipld.Node) (ipld.Node, error) { + ks, err := key.AsString() if err != nil { - return nil, ipld.ErrInvalidSegmentForList{TypeName: "ipldgit.ListString", TroubleSegment: seg, Reason: err} + return nil, err } - return n.LookupByIndex(i) + return n.LookupByString(ks) } -func (ListString) MapIterator() ipld.MapIterator { - return nil +func (_PersonInfo__Repr) LookupByIndex(idx int64) (ipld.Node, error) { + return mixins.Map{TypeName: "ipldgit.PersonInfo.Repr"}.LookupByIndex(0) +} +func (n _PersonInfo__Repr) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { + return n.LookupByString(seg.String()) } -func (n ListString) ListIterator() ipld.ListIterator { - return &_ListString__ListItr{n, 0} +func (n *_PersonInfo__Repr) MapIterator() ipld.MapIterator { + return &_PersonInfo__ReprMapItr{n, 0} } -type _ListString__ListItr struct { - n ListString +type _PersonInfo__ReprMapItr struct { + n *_PersonInfo__Repr idx int } -func (itr *_ListString__ListItr) Next() (idx int64, v ipld.Node, _ error) { - if itr.idx >= len(itr.n.x) { - return -1, nil, ipld.ErrIteratorOverread{} +func (itr *_PersonInfo__ReprMapItr) Next() (k ipld.Node, v ipld.Node, _ error) { + if itr.idx >= 4 { + return nil, nil, ipld.ErrIteratorOverread{} + } + switch itr.idx { + case 0: + k = &fieldName__PersonInfo_Date_serial + v = itr.n.date.Representation() + case 1: + k = &fieldName__PersonInfo_Timezone_serial + v = itr.n.timezone.Representation() + case 2: + k = &fieldName__PersonInfo_Email_serial + v = itr.n.email.Representation() + case 3: + k = &fieldName__PersonInfo_Name_serial + v = itr.n.name.Representation() + default: + panic("unreachable") } - idx = int64(itr.idx) - x := &itr.n.x[itr.idx] - v = x itr.idx++ return } -func (itr *_ListString__ListItr) Done() bool { - return itr.idx >= len(itr.n.x) +func (itr *_PersonInfo__ReprMapItr) Done() bool { + return itr.idx >= 4 } - -func (n ListString) Length() int64 { - return int64(len(n.x)) +func (_PersonInfo__Repr) ListIterator() ipld.ListIterator { + return nil +} +func (rn *_PersonInfo__Repr) Length() int64 { + l := 4 + return int64(l) } -func (ListString) IsAbsent() bool { +func (_PersonInfo__Repr) IsAbsent() bool { return false } -func (ListString) IsNull() bool { +func (_PersonInfo__Repr) IsNull() bool { return false } -func (ListString) AsBool() (bool, error) { - return mixins.List{TypeName: "ipldgit.ListString"}.AsBool() +func (_PersonInfo__Repr) AsBool() (bool, error) { + return mixins.Map{TypeName: "ipldgit.PersonInfo.Repr"}.AsBool() } -func (ListString) AsInt() (int64, error) { - return mixins.List{TypeName: "ipldgit.ListString"}.AsInt() +func (_PersonInfo__Repr) AsInt() (int64, error) { + return mixins.Map{TypeName: "ipldgit.PersonInfo.Repr"}.AsInt() } -func (ListString) AsFloat() (float64, error) { - return mixins.List{TypeName: "ipldgit.ListString"}.AsFloat() +func (_PersonInfo__Repr) AsFloat() (float64, error) { + return mixins.Map{TypeName: "ipldgit.PersonInfo.Repr"}.AsFloat() } -func (ListString) AsString() (string, error) { - return mixins.List{TypeName: "ipldgit.ListString"}.AsString() +func (_PersonInfo__Repr) AsString() (string, error) { + return mixins.Map{TypeName: "ipldgit.PersonInfo.Repr"}.AsString() } -func (ListString) AsBytes() ([]byte, error) { - return mixins.List{TypeName: "ipldgit.ListString"}.AsBytes() +func (_PersonInfo__Repr) AsBytes() ([]byte, error) { + return mixins.Map{TypeName: "ipldgit.PersonInfo.Repr"}.AsBytes() } -func (ListString) AsLink() (ipld.Link, error) { - return mixins.List{TypeName: "ipldgit.ListString"}.AsLink() +func (_PersonInfo__Repr) AsLink() (ipld.Link, error) { + return mixins.Map{TypeName: "ipldgit.PersonInfo.Repr"}.AsLink() } -func (ListString) Prototype() ipld.NodePrototype { - return _ListString__Prototype{} +func (_PersonInfo__Repr) Prototype() ipld.NodePrototype { + return _PersonInfo__ReprPrototype{} } -type _ListString__Prototype struct{} +type _PersonInfo__ReprPrototype struct{} -func (_ListString__Prototype) NewBuilder() ipld.NodeBuilder { - var nb _ListString__Builder +func (_PersonInfo__ReprPrototype) NewBuilder() ipld.NodeBuilder { + var nb _PersonInfo__ReprBuilder nb.Reset() return &nb } -type _ListString__Builder struct { - _ListString__Assembler +type _PersonInfo__ReprBuilder struct { + _PersonInfo__ReprAssembler } -func (nb *_ListString__Builder) Build() ipld.Node { +func (nb *_PersonInfo__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 *_ListString__Builder) Reset() { - var w _ListString +func (nb *_PersonInfo__ReprBuilder) Reset() { + var w _PersonInfo var m schema.Maybe - *nb = _ListString__Builder{_ListString__Assembler{w: &w, m: &m}} + *nb = _PersonInfo__ReprBuilder{_PersonInfo__ReprAssembler{w: &w, m: &m}} } -type _ListString__Assembler struct { - w *_ListString +type _PersonInfo__ReprAssembler struct { + w *_PersonInfo m *schema.Maybe - state laState + state maState + s int + f int - cm schema.Maybe - va _String__Assembler + cm schema.Maybe + ca_date _String__ReprAssembler + ca_timezone _String__ReprAssembler + ca_email _String__ReprAssembler + ca_name _String__ReprAssembler } -func (na *_ListString__Assembler) reset() { - na.state = laState_initial - na.va.reset() -} -func (_ListString__Assembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { - return mixins.ListAssembler{TypeName: "ipldgit.ListString"}.BeginMap(0) +func (na *_PersonInfo__ReprAssembler) reset() { + na.state = maState_initial + na.s = 0 + na.ca_date.reset() + na.ca_timezone.reset() + na.ca_email.reset() + na.ca_name.reset() } -func (na *_ListString__Assembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { +func (na *_PersonInfo__ReprAssembler) BeginMap(int64) (ipld.MapAssembler, error) { switch *na.m { case schema.Maybe_Value, schema.Maybe_Null: panic("invalid state: cannot assign into assembler that's already finished") @@ -3438,21 +3767,21 @@ func (na *_ListString__Assembler) BeginList(sizeHint int64) (ipld.ListAssembler, panic("invalid state: it makes no sense to 'begin' twice on the same assembler!") } *na.m = midvalue - if sizeHint < 0 { - sizeHint = 0 - } - if sizeHint > 0 { - na.w.x = make([]_String, 0, sizeHint) + if na.w == nil { + na.w = &_PersonInfo{} } return na, nil } -func (na *_ListString__Assembler) AssignNull() error { +func (_PersonInfo__ReprAssembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { + return mixins.MapAssembler{TypeName: "ipldgit.PersonInfo.Repr"}.BeginList(0) +} +func (na *_PersonInfo__ReprAssembler) AssignNull() error { switch *na.m { case allowNull: *na.m = schema.Maybe_Null return nil case schema.Maybe_Absent: - return mixins.ListAssembler{TypeName: "ipldgit.ListString"}.AssignNull() + return mixins.MapAssembler{TypeName: "ipldgit.PersonInfo.Repr.Repr"}.AssignNull() case schema.Maybe_Value, schema.Maybe_Null: panic("invalid state: cannot assign into assembler that's already finished") case midvalue: @@ -3460,394 +3789,578 @@ func (na *_ListString__Assembler) AssignNull() error { } panic("unreachable") } -func (_ListString__Assembler) AssignBool(bool) error { - return mixins.ListAssembler{TypeName: "ipldgit.ListString"}.AssignBool(false) +func (_PersonInfo__ReprAssembler) AssignBool(bool) error { + return mixins.MapAssembler{TypeName: "ipldgit.PersonInfo.Repr"}.AssignBool(false) } -func (_ListString__Assembler) AssignInt(int64) error { - return mixins.ListAssembler{TypeName: "ipldgit.ListString"}.AssignInt(0) +func (_PersonInfo__ReprAssembler) AssignInt(int64) error { + return mixins.MapAssembler{TypeName: "ipldgit.PersonInfo.Repr"}.AssignInt(0) } -func (_ListString__Assembler) AssignFloat(float64) error { - return mixins.ListAssembler{TypeName: "ipldgit.ListString"}.AssignFloat(0) +func (_PersonInfo__ReprAssembler) AssignFloat(float64) error { + return mixins.MapAssembler{TypeName: "ipldgit.PersonInfo.Repr"}.AssignFloat(0) } -func (_ListString__Assembler) AssignString(string) error { - return mixins.ListAssembler{TypeName: "ipldgit.ListString"}.AssignString("") +func (_PersonInfo__ReprAssembler) AssignString(string) error { + return mixins.MapAssembler{TypeName: "ipldgit.PersonInfo.Repr"}.AssignString("") } -func (_ListString__Assembler) AssignBytes([]byte) error { - return mixins.ListAssembler{TypeName: "ipldgit.ListString"}.AssignBytes(nil) +func (_PersonInfo__ReprAssembler) AssignBytes([]byte) error { + return mixins.MapAssembler{TypeName: "ipldgit.PersonInfo.Repr"}.AssignBytes(nil) } -func (_ListString__Assembler) AssignLink(ipld.Link) error { - return mixins.ListAssembler{TypeName: "ipldgit.ListString"}.AssignLink(nil) +func (_PersonInfo__ReprAssembler) AssignLink(ipld.Link) error { + return mixins.MapAssembler{TypeName: "ipldgit.PersonInfo.Repr"}.AssignLink(nil) } -func (na *_ListString__Assembler) AssignNode(v ipld.Node) error { +func (na *_PersonInfo__ReprAssembler) AssignNode(v ipld.Node) error { if v.IsNull() { return na.AssignNull() } - if v2, ok := v.(*_ListString); ok { + if v2, ok := v.(*_PersonInfo); 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.Kind() != ipld.Kind_List { - return ipld.ErrWrongKind{TypeName: "ipldgit.ListString", MethodName: "AssignNode", AppropriateKind: ipld.KindSet_JustList, ActualKind: v.Kind()} + if v.Kind() != ipld.Kind_Map { + return ipld.ErrWrongKind{TypeName: "ipldgit.PersonInfo.Repr", MethodName: "AssignNode", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()} } - itr := v.ListIterator() + itr := v.MapIterator() for !itr.Done() { - _, v, err := itr.Next() + k, v, err := itr.Next() if err != nil { return err } + if err := na.AssembleKey().AssignNode(k); err != nil { + return err + } if err := na.AssembleValue().AssignNode(v); err != nil { return err } } return na.Finish() } -func (_ListString__Assembler) Prototype() ipld.NodePrototype { - return _ListString__Prototype{} +func (_PersonInfo__ReprAssembler) Prototype() ipld.NodePrototype { + return _PersonInfo__ReprPrototype{} } -func (la *_ListString__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 +func (ma *_PersonInfo__ReprAssembler) valueFinishTidy() bool { + switch ma.f { + case 0: + switch ma.cm { + case schema.Maybe_Value: + ma.cm = schema.Maybe_Absent + ma.state = maState_initial + return true + default: + return false + } + case 1: + switch ma.cm { + case schema.Maybe_Value: + ma.cm = schema.Maybe_Absent + ma.state = maState_initial + return true + default: + return false + } + case 2: + switch ma.cm { + case schema.Maybe_Value: + ma.cm = schema.Maybe_Absent + ma.state = maState_initial + return true + default: + return false + } + case 3: + switch ma.cm { + case schema.Maybe_Value: + ma.cm = schema.Maybe_Absent + ma.state = maState_initial + return true + default: + return false + } default: - return false + panic("unreachable") } } -func (la *_ListString__Assembler) AssembleValue() ipld.NodeAssembler { - switch la.state { - case laState_initial: +func (ma *_PersonInfo__ReprAssembler) AssembleEntry(k string) (ipld.NodeAssembler, error) { + switch ma.state { + case maState_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") + case maState_midKey: + panic("invalid state: AssembleEntry cannot be called when in the middle of assembling another key") + case maState_expectValue: + panic("invalid state: AssembleEntry cannot be called when expecting start of value assembly") + case maState_midValue: + if !ma.valueFinishTidy() { + panic("invalid state: AssembleEntry cannot be called when in the middle of assembling a value") } // if tidy success: carry on - case laState_finished: - panic("invalid state: AssembleValue cannot be called on an assembler that's already finished") + case maState_finished: + panic("invalid state: AssembleEntry cannot be called on an assembler that's already finished") } - la.w.x = append(la.w.x, _String{}) - 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 *_ListString__Assembler) Finish() error { - switch la.state { - case laState_initial: - // carry on - case laState_midValue: - if !la.valueFinishTidy() { + switch k { + case "date": + if ma.s&fieldBit__PersonInfo_Date != 0 { + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Date_serial} + } + ma.s += fieldBit__PersonInfo_Date + ma.state = maState_midValue + ma.f = 0 + ma.ca_date.w = &ma.w.date + ma.ca_date.m = &ma.cm + return &ma.ca_date, nil + case "timezone": + if ma.s&fieldBit__PersonInfo_Timezone != 0 { + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Timezone_serial} + } + ma.s += fieldBit__PersonInfo_Timezone + ma.state = maState_midValue + ma.f = 1 + ma.ca_timezone.w = &ma.w.timezone + ma.ca_timezone.m = &ma.cm + return &ma.ca_timezone, nil + case "email": + if ma.s&fieldBit__PersonInfo_Email != 0 { + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Email_serial} + } + ma.s += fieldBit__PersonInfo_Email + ma.state = maState_midValue + ma.f = 2 + ma.ca_email.w = &ma.w.email + ma.ca_email.m = &ma.cm + return &ma.ca_email, nil + case "name": + if ma.s&fieldBit__PersonInfo_Name != 0 { + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Name_serial} + } + ma.s += fieldBit__PersonInfo_Name + ma.state = maState_midValue + ma.f = 3 + ma.ca_name.w = &ma.w.name + ma.ca_name.m = &ma.cm + return &ma.ca_name, nil + default: + } + return nil, ipld.ErrInvalidKey{TypeName: "ipldgit.PersonInfo.Repr", Key: &_String{k}} +} +func (ma *_PersonInfo__ReprAssembler) AssembleKey() ipld.NodeAssembler { + switch ma.state { + case maState_initial: + // carry on + case maState_midKey: + panic("invalid state: AssembleKey cannot be called when in the middle of assembling another key") + case maState_expectValue: + panic("invalid state: AssembleKey cannot be called when expecting start of value assembly") + case maState_midValue: + if !ma.valueFinishTidy() { + panic("invalid state: AssembleKey cannot be called when in the middle of assembling a value") + } // if tidy success: carry on + case maState_finished: + panic("invalid state: AssembleKey cannot be called on an assembler that's already finished") + } + ma.state = maState_midKey + return (*_PersonInfo__ReprKeyAssembler)(ma) +} +func (ma *_PersonInfo__ReprAssembler) AssembleValue() ipld.NodeAssembler { + switch ma.state { + case maState_initial: + panic("invalid state: AssembleValue cannot be called when no key is primed") + case maState_midKey: + panic("invalid state: AssembleValue cannot be called when in the middle of assembling a key") + case maState_expectValue: + // carry on + case maState_midValue: + panic("invalid state: AssembleValue cannot be called when in the middle of assembling another value") + case maState_finished: + panic("invalid state: AssembleValue cannot be called on an assembler that's already finished") + } + ma.state = maState_midValue + switch ma.f { + case 0: + ma.ca_date.w = &ma.w.date + ma.ca_date.m = &ma.cm + return &ma.ca_date + case 1: + ma.ca_timezone.w = &ma.w.timezone + ma.ca_timezone.m = &ma.cm + return &ma.ca_timezone + case 2: + ma.ca_email.w = &ma.w.email + ma.ca_email.m = &ma.cm + return &ma.ca_email + case 3: + ma.ca_name.w = &ma.w.name + ma.ca_name.m = &ma.cm + return &ma.ca_name + default: + panic("unreachable") + } +} +func (ma *_PersonInfo__ReprAssembler) Finish() error { + switch ma.state { + case maState_initial: + // carry on + case maState_midKey: + panic("invalid state: Finish cannot be called when in the middle of assembling a key") + case maState_expectValue: + panic("invalid state: Finish cannot be called when expecting start of value assembly") + case maState_midValue: + if !ma.valueFinishTidy() { panic("invalid state: Finish cannot be called when in the middle of assembling a value") } // if tidy success: carry on - case laState_finished: + case maState_finished: panic("invalid state: Finish cannot be called on an assembler that's already finished") } - la.state = laState_finished - *la.m = schema.Maybe_Value + if ma.s&fieldBits__PersonInfo_sufficient != fieldBits__PersonInfo_sufficient { + err := ipld.ErrMissingRequiredField{Missing: make([]string, 0)} + if ma.s&fieldBit__PersonInfo_Date == 0 { + err.Missing = append(err.Missing, "date") + } + if ma.s&fieldBit__PersonInfo_Timezone == 0 { + err.Missing = append(err.Missing, "timezone") + } + if ma.s&fieldBit__PersonInfo_Email == 0 { + err.Missing = append(err.Missing, "email") + } + if ma.s&fieldBit__PersonInfo_Name == 0 { + err.Missing = append(err.Missing, "name") + } + return err + } + ma.state = maState_finished + *ma.m = schema.Maybe_Value return nil } -func (la *_ListString__Assembler) ValuePrototype(_ int64) ipld.NodePrototype { +func (ma *_PersonInfo__ReprAssembler) KeyPrototype() ipld.NodePrototype { return _String__Prototype{} } -func (ListString) Type() schema.Type { - return nil /*TODO:typelit*/ -} -func (n ListString) Representation() ipld.Node { - return (*_ListString__Repr)(n) +func (ma *_PersonInfo__ReprAssembler) ValuePrototype(k string) ipld.NodePrototype { + panic("todo structbuilder mapassembler repr valueprototype") } -type _ListString__Repr _ListString - -var _ ipld.Node = &_ListString__Repr{} +type _PersonInfo__ReprKeyAssembler _PersonInfo__ReprAssembler -func (_ListString__Repr) Kind() ipld.Kind { - return ipld.Kind_List -} -func (_ListString__Repr) LookupByString(string) (ipld.Node, error) { - return mixins.List{TypeName: "ipldgit.ListString.Repr"}.LookupByString("") +func (_PersonInfo__ReprKeyAssembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { + return mixins.StringAssembler{TypeName: "ipldgit.PersonInfo.Repr.KeyAssembler"}.BeginMap(0) } -func (nr *_ListString__Repr) LookupByNode(k ipld.Node) (ipld.Node, error) { - v, err := (ListString)(nr).LookupByNode(k) - if err != nil || v == ipld.Null { - return v, err - } - return v.(String).Representation(), nil +func (_PersonInfo__ReprKeyAssembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { + return mixins.StringAssembler{TypeName: "ipldgit.PersonInfo.Repr.KeyAssembler"}.BeginList(0) } -func (nr *_ListString__Repr) LookupByIndex(idx int64) (ipld.Node, error) { - v, err := (ListString)(nr).LookupByIndex(idx) - if err != nil || v == ipld.Null { - return v, err - } - return v.(String).Representation(), nil +func (na *_PersonInfo__ReprKeyAssembler) AssignNull() error { + return mixins.StringAssembler{TypeName: "ipldgit.PersonInfo.Repr.KeyAssembler"}.AssignNull() } -func (n _ListString__Repr) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { - i, err := seg.Index() - if err != nil { - return nil, ipld.ErrInvalidSegmentForList{TypeName: "ipldgit.ListString.Repr", TroubleSegment: seg, Reason: err} - } - return n.LookupByIndex(i) +func (_PersonInfo__ReprKeyAssembler) AssignBool(bool) error { + return mixins.StringAssembler{TypeName: "ipldgit.PersonInfo.Repr.KeyAssembler"}.AssignBool(false) } -func (_ListString__Repr) MapIterator() ipld.MapIterator { - return nil +func (_PersonInfo__ReprKeyAssembler) AssignInt(int64) error { + return mixins.StringAssembler{TypeName: "ipldgit.PersonInfo.Repr.KeyAssembler"}.AssignInt(0) } -func (nr *_ListString__Repr) ListIterator() ipld.ListIterator { - return &_ListString__ReprListItr{(ListString)(nr), 0} +func (_PersonInfo__ReprKeyAssembler) AssignFloat(float64) error { + return mixins.StringAssembler{TypeName: "ipldgit.PersonInfo.Repr.KeyAssembler"}.AssignFloat(0) } - -type _ListString__ReprListItr _ListString__ListItr - -func (itr *_ListString__ReprListItr) Next() (idx int64, v ipld.Node, err error) { - idx, v, err = (*_ListString__ListItr)(itr).Next() - if err != nil || v == ipld.Null { - return +func (ka *_PersonInfo__ReprKeyAssembler) AssignString(k string) error { + if ka.state != maState_midKey { + panic("misuse: KeyAssembler held beyond its valid lifetime") } - return idx, v.(String).Representation(), nil -} -func (itr *_ListString__ReprListItr) Done() bool { - return (*_ListString__ListItr)(itr).Done() -} - -func (rn *_ListString__Repr) Length() int64 { - return int64(len(rn.x)) -} -func (_ListString__Repr) IsAbsent() bool { - return false -} -func (_ListString__Repr) IsNull() bool { - return false -} -func (_ListString__Repr) AsBool() (bool, error) { - return mixins.List{TypeName: "ipldgit.ListString.Repr"}.AsBool() + switch k { + case "date": + if ka.s&fieldBit__PersonInfo_Date != 0 { + return ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Date_serial} + } + ka.s += fieldBit__PersonInfo_Date + ka.state = maState_expectValue + ka.f = 0 + return nil + case "timezone": + if ka.s&fieldBit__PersonInfo_Timezone != 0 { + return ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Timezone_serial} + } + ka.s += fieldBit__PersonInfo_Timezone + ka.state = maState_expectValue + ka.f = 1 + return nil + case "email": + if ka.s&fieldBit__PersonInfo_Email != 0 { + return ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Email_serial} + } + ka.s += fieldBit__PersonInfo_Email + ka.state = maState_expectValue + ka.f = 2 + return nil + case "name": + if ka.s&fieldBit__PersonInfo_Name != 0 { + return ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Name_serial} + } + ka.s += fieldBit__PersonInfo_Name + ka.state = maState_expectValue + ka.f = 3 + return nil + } + return ipld.ErrInvalidKey{TypeName: "ipldgit.PersonInfo.Repr", Key: &_String{k}} } -func (_ListString__Repr) AsInt() (int64, error) { - return mixins.List{TypeName: "ipldgit.ListString.Repr"}.AsInt() +func (_PersonInfo__ReprKeyAssembler) AssignBytes([]byte) error { + return mixins.StringAssembler{TypeName: "ipldgit.PersonInfo.Repr.KeyAssembler"}.AssignBytes(nil) } -func (_ListString__Repr) AsFloat() (float64, error) { - return mixins.List{TypeName: "ipldgit.ListString.Repr"}.AsFloat() +func (_PersonInfo__ReprKeyAssembler) AssignLink(ipld.Link) error { + return mixins.StringAssembler{TypeName: "ipldgit.PersonInfo.Repr.KeyAssembler"}.AssignLink(nil) } -func (_ListString__Repr) AsString() (string, error) { - return mixins.List{TypeName: "ipldgit.ListString.Repr"}.AsString() +func (ka *_PersonInfo__ReprKeyAssembler) AssignNode(v ipld.Node) error { + if v2, err := v.AsString(); err != nil { + return err + } else { + return ka.AssignString(v2) + } } -func (_ListString__Repr) AsBytes() ([]byte, error) { - return mixins.List{TypeName: "ipldgit.ListString.Repr"}.AsBytes() +func (_PersonInfo__ReprKeyAssembler) Prototype() ipld.NodePrototype { + return _String__Prototype{} } -func (_ListString__Repr) AsLink() (ipld.Link, error) { - return mixins.List{TypeName: "ipldgit.ListString.Repr"}.AsLink() + +func (n String) String() string { + return n.x } -func (_ListString__Repr) Prototype() ipld.NodePrototype { - return _ListString__ReprPrototype{} +func (_String__Prototype) fromString(w *_String, v string) error { + *w = _String{v} + return nil } - -type _ListString__ReprPrototype struct{} - -func (_ListString__ReprPrototype) NewBuilder() ipld.NodeBuilder { - var nb _ListString__ReprBuilder - nb.Reset() - return &nb +func (_String__Prototype) FromString(v string) (String, error) { + n := _String{v} + return &n, nil } -type _ListString__ReprBuilder struct { - _ListString__ReprAssembler +type _String__Maybe struct { + m schema.Maybe + v _String } +type MaybeString = *_String__Maybe -func (nb *_ListString__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 (m MaybeString) IsNull() bool { + return m.m == schema.Maybe_Null } -func (nb *_ListString__ReprBuilder) Reset() { - var w _ListString - var m schema.Maybe - *nb = _ListString__ReprBuilder{_ListString__ReprAssembler{w: &w, m: &m}} +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 } -type _ListString__ReprAssembler struct { - w *_ListString - m *schema.Maybe - state laState +var _ ipld.Node = (String)(&_String{}) +var _ schema.TypedNode = (String)(&_String{}) - cm schema.Maybe - va _String__ReprAssembler +func (String) Kind() ipld.Kind { + return ipld.Kind_String +} +func (String) LookupByString(string) (ipld.Node, error) { + return mixins.String{TypeName: "ipldgit.String"}.LookupByString("") +} +func (String) LookupByNode(ipld.Node) (ipld.Node, error) { + return mixins.String{TypeName: "ipldgit.String"}.LookupByNode(nil) +} +func (String) LookupByIndex(idx int64) (ipld.Node, error) { + return mixins.String{TypeName: "ipldgit.String"}.LookupByIndex(0) +} +func (String) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { + return mixins.String{TypeName: "ipldgit.String"}.LookupBySegment(seg) +} +func (String) MapIterator() ipld.MapIterator { + return nil +} +func (String) ListIterator() ipld.ListIterator { + return nil +} +func (String) Length() int64 { + return -1 +} +func (String) IsAbsent() bool { + return false +} +func (String) IsNull() bool { + return false +} +func (String) AsBool() (bool, error) { + return mixins.String{TypeName: "ipldgit.String"}.AsBool() +} +func (String) AsInt() (int64, error) { + return mixins.String{TypeName: "ipldgit.String"}.AsInt() +} +func (String) AsFloat() (float64, error) { + return mixins.String{TypeName: "ipldgit.String"}.AsFloat() +} +func (n String) AsString() (string, error) { + return n.x, nil +} +func (String) AsBytes() ([]byte, error) { + return mixins.String{TypeName: "ipldgit.String"}.AsBytes() +} +func (String) AsLink() (ipld.Link, error) { + return mixins.String{TypeName: "ipldgit.String"}.AsLink() +} +func (String) Prototype() ipld.NodePrototype { + return _String__Prototype{} } -func (na *_ListString__ReprAssembler) reset() { - na.state = laState_initial - na.va.reset() +type _String__Prototype struct{} + +func (_String__Prototype) NewBuilder() ipld.NodeBuilder { + var nb _String__Builder + nb.Reset() + return &nb } -func (_ListString__ReprAssembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { - return mixins.ListAssembler{TypeName: "ipldgit.ListString.Repr"}.BeginMap(0) + +type _String__Builder struct { + _String__Assembler } -func (na *_ListString__ReprAssembler) BeginList(sizeHint int64) (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 sizeHint > 0 { - na.w.x = make([]_String, 0, sizeHint) + +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 na, nil + 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 int64) (ipld.MapAssembler, error) { + return mixins.StringAssembler{TypeName: "ipldgit.String"}.BeginMap(0) +} +func (_String__Assembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { + return mixins.StringAssembler{TypeName: "ipldgit.String"}.BeginList(0) } -func (na *_ListString__ReprAssembler) AssignNull() error { +func (na *_String__Assembler) AssignNull() error { switch *na.m { case allowNull: *na.m = schema.Maybe_Null return nil case schema.Maybe_Absent: - return mixins.ListAssembler{TypeName: "ipldgit.ListString.Repr.Repr"}.AssignNull() + return mixins.StringAssembler{TypeName: "ipldgit.String"}.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 (_ListString__ReprAssembler) AssignBool(bool) error { - return mixins.ListAssembler{TypeName: "ipldgit.ListString.Repr"}.AssignBool(false) +func (_String__Assembler) AssignBool(bool) error { + return mixins.StringAssembler{TypeName: "ipldgit.String"}.AssignBool(false) } -func (_ListString__ReprAssembler) AssignInt(int64) error { - return mixins.ListAssembler{TypeName: "ipldgit.ListString.Repr"}.AssignInt(0) +func (_String__Assembler) AssignInt(int64) error { + return mixins.StringAssembler{TypeName: "ipldgit.String"}.AssignInt(0) } -func (_ListString__ReprAssembler) AssignFloat(float64) error { - return mixins.ListAssembler{TypeName: "ipldgit.ListString.Repr"}.AssignFloat(0) +func (_String__Assembler) AssignFloat(float64) error { + return mixins.StringAssembler{TypeName: "ipldgit.String"}.AssignFloat(0) } -func (_ListString__ReprAssembler) AssignString(string) error { - return mixins.ListAssembler{TypeName: "ipldgit.ListString.Repr"}.AssignString("") +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") + } + na.w.x = v + *na.m = schema.Maybe_Value + return nil } -func (_ListString__ReprAssembler) AssignBytes([]byte) error { - return mixins.ListAssembler{TypeName: "ipldgit.ListString.Repr"}.AssignBytes(nil) +func (_String__Assembler) AssignBytes([]byte) error { + return mixins.StringAssembler{TypeName: "ipldgit.String"}.AssignBytes(nil) } -func (_ListString__ReprAssembler) AssignLink(ipld.Link) error { - return mixins.ListAssembler{TypeName: "ipldgit.ListString.Repr"}.AssignLink(nil) +func (_String__Assembler) AssignLink(ipld.Link) error { + return mixins.StringAssembler{TypeName: "ipldgit.String"}.AssignLink(nil) } -func (na *_ListString__ReprAssembler) AssignNode(v ipld.Node) error { +func (na *_String__Assembler) AssignNode(v ipld.Node) error { if v.IsNull() { return na.AssignNull() } - if v2, ok := v.(*_ListString); ok { + 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") - case midvalue: - panic("invalid state: cannot assign null into an assembler that's already begun working on recursive structures!") } *na.w = *v2 *na.m = schema.Maybe_Value return nil } - if v.Kind() != ipld.Kind_List { - return ipld.ErrWrongKind{TypeName: "ipldgit.ListString.Repr", MethodName: "AssignNode", AppropriateKind: ipld.KindSet_JustList, ActualKind: v.Kind()} - } - 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 (_ListString__ReprAssembler) Prototype() ipld.NodePrototype { - return _ListString__ReprPrototype{} -} -func (la *_ListString__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 + if v2, err := v.AsString(); err != nil { + return err + } else { + return na.AssignString(v2) } } -func (la *_ListString__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, _String{}) - 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 (_String__Assembler) Prototype() ipld.NodePrototype { + return _String__Prototype{} } -func (la *_ListString__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 (String) Type() schema.Type { + return nil /*TODO:typelit*/ } -func (la *_ListString__ReprAssembler) ValuePrototype(_ int64) ipld.NodePrototype { - return _String__ReprPrototype{} +func (n String) Representation() ipld.Node { + return (*_String__Repr)(n) } -func (n *_ListTag) Lookup(idx int64) Tag { +type _String__Repr = _String + +var _ ipld.Node = &_String__Repr{} + +type _String__ReprPrototype = _String__Prototype +type _String__ReprAssembler = _String__Assembler + +func (n *_String_List) Lookup(idx int64) String { if n.Length() <= idx { return nil } v := &n.x[idx] return v } -func (n *_ListTag) LookupMaybe(idx int64) MaybeTag { +func (n *_String_List) LookupMaybe(idx int64) MaybeString { if n.Length() <= idx { return nil } v := &n.x[idx] - return &_Tag__Maybe{ + return &_String__Maybe{ m: schema.Maybe_Value, - v: v, + v: *v, } } -var _ListTag__valueAbsent = _Tag__Maybe{m: schema.Maybe_Absent} +var _String_List__valueAbsent = _String__Maybe{m: schema.Maybe_Absent} -func (n ListTag) Iterator() *ListTag__Itr { - return &ListTag__Itr{n, 0} +func (n String_List) Iterator() *String_List__Itr { + return &String_List__Itr{n, 0} } -type ListTag__Itr struct { - n ListTag +type String_List__Itr struct { + n String_List idx int } -func (itr *ListTag__Itr) Next() (idx int64, v Tag) { +func (itr *String_List__Itr) Next() (idx int64, v String) { if itr.idx >= len(itr.n.x) { return -1, nil } @@ -3856,26 +4369,26 @@ func (itr *ListTag__Itr) Next() (idx int64, v Tag) { itr.idx++ return } -func (itr *ListTag__Itr) Done() bool { +func (itr *String_List__Itr) Done() bool { return itr.idx >= len(itr.n.x) } -type _ListTag__Maybe struct { +type _String_List__Maybe struct { m schema.Maybe - v _ListTag + v _String_List } -type MaybeListTag = *_ListTag__Maybe +type MaybeString_List = *_String_List__Maybe -func (m MaybeListTag) IsNull() bool { +func (m MaybeString_List) IsNull() bool { return m.m == schema.Maybe_Null } -func (m MaybeListTag) IsAbsent() bool { +func (m MaybeString_List) IsAbsent() bool { return m.m == schema.Maybe_Absent } -func (m MaybeListTag) Exists() bool { +func (m MaybeString_List) Exists() bool { return m.m == schema.Maybe_Value } -func (m MaybeListTag) AsNode() ipld.Node { +func (m MaybeString_List) AsNode() ipld.Node { switch m.m { case schema.Maybe_Absent: return ipld.Absent @@ -3887,56 +4400,56 @@ func (m MaybeListTag) AsNode() ipld.Node { panic("unreachable") } } -func (m MaybeListTag) Must() ListTag { +func (m MaybeString_List) Must() String_List { if !m.Exists() { panic("unbox of a maybe rejected") } return &m.v } -var _ ipld.Node = (ListTag)(&_ListTag{}) -var _ schema.TypedNode = (ListTag)(&_ListTag{}) +var _ ipld.Node = (String_List)(&_String_List{}) +var _ schema.TypedNode = (String_List)(&_String_List{}) -func (ListTag) Kind() ipld.Kind { +func (String_List) Kind() ipld.Kind { return ipld.Kind_List } -func (ListTag) LookupByString(string) (ipld.Node, error) { - return mixins.List{TypeName: "ipldgit.ListTag"}.LookupByString("") +func (String_List) LookupByString(string) (ipld.Node, error) { + return mixins.List{TypeName: "ipldgit.String_List"}.LookupByString("") } -func (n ListTag) LookupByNode(k ipld.Node) (ipld.Node, error) { +func (n String_List) LookupByNode(k ipld.Node) (ipld.Node, error) { idx, err := k.AsInt() if err != nil { return nil, err } return n.LookupByIndex(idx) } -func (n ListTag) LookupByIndex(idx int64) (ipld.Node, error) { +func (n String_List) LookupByIndex(idx int64) (ipld.Node, error) { if n.Length() <= idx { return nil, ipld.ErrNotExists{Segment: ipld.PathSegmentOfInt(idx)} } v := &n.x[idx] return v, nil } -func (n ListTag) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { +func (n String_List) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { i, err := seg.Index() if err != nil { - return nil, ipld.ErrInvalidSegmentForList{TypeName: "ipldgit.ListTag", TroubleSegment: seg, Reason: err} + return nil, ipld.ErrInvalidSegmentForList{TypeName: "ipldgit.String_List", TroubleSegment: seg, Reason: err} } return n.LookupByIndex(i) } -func (ListTag) MapIterator() ipld.MapIterator { +func (String_List) MapIterator() ipld.MapIterator { return nil } -func (n ListTag) ListIterator() ipld.ListIterator { - return &_ListTag__ListItr{n, 0} +func (n String_List) ListIterator() ipld.ListIterator { + return &_String_List__ListItr{n, 0} } -type _ListTag__ListItr struct { - n ListTag +type _String_List__ListItr struct { + n String_List idx int } -func (itr *_ListTag__ListItr) Next() (idx int64, v ipld.Node, _ error) { +func (itr *_String_List__ListItr) Next() (idx int64, v ipld.Node, _ error) { if itr.idx >= len(itr.n.x) { return -1, nil, ipld.ErrIteratorOverread{} } @@ -3946,82 +4459,82 @@ func (itr *_ListTag__ListItr) Next() (idx int64, v ipld.Node, _ error) { itr.idx++ return } -func (itr *_ListTag__ListItr) Done() bool { +func (itr *_String_List__ListItr) Done() bool { return itr.idx >= len(itr.n.x) } -func (n ListTag) Length() int64 { +func (n String_List) Length() int64 { return int64(len(n.x)) } -func (ListTag) IsAbsent() bool { +func (String_List) IsAbsent() bool { return false } -func (ListTag) IsNull() bool { +func (String_List) IsNull() bool { return false } -func (ListTag) AsBool() (bool, error) { - return mixins.List{TypeName: "ipldgit.ListTag"}.AsBool() +func (String_List) AsBool() (bool, error) { + return mixins.List{TypeName: "ipldgit.String_List"}.AsBool() } -func (ListTag) AsInt() (int64, error) { - return mixins.List{TypeName: "ipldgit.ListTag"}.AsInt() +func (String_List) AsInt() (int64, error) { + return mixins.List{TypeName: "ipldgit.String_List"}.AsInt() } -func (ListTag) AsFloat() (float64, error) { - return mixins.List{TypeName: "ipldgit.ListTag"}.AsFloat() +func (String_List) AsFloat() (float64, error) { + return mixins.List{TypeName: "ipldgit.String_List"}.AsFloat() } -func (ListTag) AsString() (string, error) { - return mixins.List{TypeName: "ipldgit.ListTag"}.AsString() +func (String_List) AsString() (string, error) { + return mixins.List{TypeName: "ipldgit.String_List"}.AsString() } -func (ListTag) AsBytes() ([]byte, error) { - return mixins.List{TypeName: "ipldgit.ListTag"}.AsBytes() +func (String_List) AsBytes() ([]byte, error) { + return mixins.List{TypeName: "ipldgit.String_List"}.AsBytes() } -func (ListTag) AsLink() (ipld.Link, error) { - return mixins.List{TypeName: "ipldgit.ListTag"}.AsLink() +func (String_List) AsLink() (ipld.Link, error) { + return mixins.List{TypeName: "ipldgit.String_List"}.AsLink() } -func (ListTag) Prototype() ipld.NodePrototype { - return _ListTag__Prototype{} +func (String_List) Prototype() ipld.NodePrototype { + return _String_List__Prototype{} } -type _ListTag__Prototype struct{} +type _String_List__Prototype struct{} -func (_ListTag__Prototype) NewBuilder() ipld.NodeBuilder { - var nb _ListTag__Builder +func (_String_List__Prototype) NewBuilder() ipld.NodeBuilder { + var nb _String_List__Builder nb.Reset() return &nb } -type _ListTag__Builder struct { - _ListTag__Assembler +type _String_List__Builder struct { + _String_List__Assembler } -func (nb *_ListTag__Builder) Build() ipld.Node { +func (nb *_String_List__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 *_ListTag__Builder) Reset() { - var w _ListTag +func (nb *_String_List__Builder) Reset() { + var w _String_List var m schema.Maybe - *nb = _ListTag__Builder{_ListTag__Assembler{w: &w, m: &m}} + *nb = _String_List__Builder{_String_List__Assembler{w: &w, m: &m}} } -type _ListTag__Assembler struct { - w *_ListTag +type _String_List__Assembler struct { + w *_String_List m *schema.Maybe state laState cm schema.Maybe - va _Tag__Assembler + va _String__Assembler } -func (na *_ListTag__Assembler) reset() { +func (na *_String_List__Assembler) reset() { na.state = laState_initial na.va.reset() } -func (_ListTag__Assembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { - return mixins.ListAssembler{TypeName: "ipldgit.ListTag"}.BeginMap(0) +func (_String_List__Assembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { + return mixins.ListAssembler{TypeName: "ipldgit.String_List"}.BeginMap(0) } -func (na *_ListTag__Assembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { +func (na *_String_List__Assembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { switch *na.m { case schema.Maybe_Value, schema.Maybe_Null: panic("invalid state: cannot assign into assembler that's already finished") @@ -4033,17 +4546,17 @@ func (na *_ListTag__Assembler) BeginList(sizeHint int64) (ipld.ListAssembler, er sizeHint = 0 } if sizeHint > 0 { - na.w.x = make([]_Tag, 0, sizeHint) + na.w.x = make([]_String, 0, sizeHint) } return na, nil } -func (na *_ListTag__Assembler) AssignNull() error { +func (na *_String_List__Assembler) AssignNull() error { switch *na.m { case allowNull: *na.m = schema.Maybe_Null return nil case schema.Maybe_Absent: - return mixins.ListAssembler{TypeName: "ipldgit.ListTag"}.AssignNull() + return mixins.ListAssembler{TypeName: "ipldgit.String_List"}.AssignNull() case schema.Maybe_Value, schema.Maybe_Null: panic("invalid state: cannot assign into assembler that's already finished") case midvalue: @@ -4051,29 +4564,29 @@ func (na *_ListTag__Assembler) AssignNull() error { } panic("unreachable") } -func (_ListTag__Assembler) AssignBool(bool) error { - return mixins.ListAssembler{TypeName: "ipldgit.ListTag"}.AssignBool(false) +func (_String_List__Assembler) AssignBool(bool) error { + return mixins.ListAssembler{TypeName: "ipldgit.String_List"}.AssignBool(false) } -func (_ListTag__Assembler) AssignInt(int64) error { - return mixins.ListAssembler{TypeName: "ipldgit.ListTag"}.AssignInt(0) +func (_String_List__Assembler) AssignInt(int64) error { + return mixins.ListAssembler{TypeName: "ipldgit.String_List"}.AssignInt(0) } -func (_ListTag__Assembler) AssignFloat(float64) error { - return mixins.ListAssembler{TypeName: "ipldgit.ListTag"}.AssignFloat(0) +func (_String_List__Assembler) AssignFloat(float64) error { + return mixins.ListAssembler{TypeName: "ipldgit.String_List"}.AssignFloat(0) } -func (_ListTag__Assembler) AssignString(string) error { - return mixins.ListAssembler{TypeName: "ipldgit.ListTag"}.AssignString("") +func (_String_List__Assembler) AssignString(string) error { + return mixins.ListAssembler{TypeName: "ipldgit.String_List"}.AssignString("") } -func (_ListTag__Assembler) AssignBytes([]byte) error { - return mixins.ListAssembler{TypeName: "ipldgit.ListTag"}.AssignBytes(nil) +func (_String_List__Assembler) AssignBytes([]byte) error { + return mixins.ListAssembler{TypeName: "ipldgit.String_List"}.AssignBytes(nil) } -func (_ListTag__Assembler) AssignLink(ipld.Link) error { - return mixins.ListAssembler{TypeName: "ipldgit.ListTag"}.AssignLink(nil) +func (_String_List__Assembler) AssignLink(ipld.Link) error { + return mixins.ListAssembler{TypeName: "ipldgit.String_List"}.AssignLink(nil) } -func (na *_ListTag__Assembler) AssignNode(v ipld.Node) error { +func (na *_String_List__Assembler) AssignNode(v ipld.Node) error { if v.IsNull() { return na.AssignNull() } - if v2, ok := v.(*_ListTag); ok { + if v2, ok := v.(*_String_List); ok { switch *na.m { case schema.Maybe_Value, schema.Maybe_Null: panic("invalid state: cannot assign into assembler that's already finished") @@ -4085,7 +4598,7 @@ func (na *_ListTag__Assembler) AssignNode(v ipld.Node) error { return nil } if v.Kind() != ipld.Kind_List { - return ipld.ErrWrongKind{TypeName: "ipldgit.ListTag", MethodName: "AssignNode", AppropriateKind: ipld.KindSet_JustList, ActualKind: v.Kind()} + return ipld.ErrWrongKind{TypeName: "ipldgit.String_List", MethodName: "AssignNode", AppropriateKind: ipld.KindSet_JustList, ActualKind: v.Kind()} } itr := v.ListIterator() for !itr.Done() { @@ -4099,10 +4612,10 @@ func (na *_ListTag__Assembler) AssignNode(v ipld.Node) error { } return na.Finish() } -func (_ListTag__Assembler) Prototype() ipld.NodePrototype { - return _ListTag__Prototype{} +func (_String_List__Assembler) Prototype() ipld.NodePrototype { + return _String_List__Prototype{} } -func (la *_ListTag__Assembler) valueFinishTidy() bool { +func (la *_String_List__Assembler) valueFinishTidy() bool { switch la.cm { case schema.Maybe_Value: la.va.w = nil @@ -4114,7 +4627,7 @@ func (la *_ListTag__Assembler) valueFinishTidy() bool { return false } } -func (la *_ListTag__Assembler) AssembleValue() ipld.NodeAssembler { +func (la *_String_List__Assembler) AssembleValue() ipld.NodeAssembler { switch la.state { case laState_initial: // carry on @@ -4125,14 +4638,14 @@ func (la *_ListTag__Assembler) AssembleValue() ipld.NodeAssembler { case laState_finished: panic("invalid state: AssembleValue cannot be called on an assembler that's already finished") } - la.w.x = append(la.w.x, _Tag{}) + la.w.x = append(la.w.x, _String{}) 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 *_ListTag__Assembler) Finish() error { +func (la *_String_List__Assembler) Finish() error { switch la.state { case laState_initial: // carry on @@ -4147,139 +4660,139 @@ func (la *_ListTag__Assembler) Finish() error { *la.m = schema.Maybe_Value return nil } -func (la *_ListTag__Assembler) ValuePrototype(_ int64) ipld.NodePrototype { - return _Tag__Prototype{} +func (la *_String_List__Assembler) ValuePrototype(_ int64) ipld.NodePrototype { + return _String__Prototype{} } -func (ListTag) Type() schema.Type { +func (String_List) Type() schema.Type { return nil /*TODO:typelit*/ } -func (n ListTag) Representation() ipld.Node { - return (*_ListTag__Repr)(n) +func (n String_List) Representation() ipld.Node { + return (*_String_List__Repr)(n) } -type _ListTag__Repr _ListTag +type _String_List__Repr _String_List -var _ ipld.Node = &_ListTag__Repr{} +var _ ipld.Node = &_String_List__Repr{} -func (_ListTag__Repr) Kind() ipld.Kind { +func (_String_List__Repr) Kind() ipld.Kind { return ipld.Kind_List } -func (_ListTag__Repr) LookupByString(string) (ipld.Node, error) { - return mixins.List{TypeName: "ipldgit.ListTag.Repr"}.LookupByString("") +func (_String_List__Repr) LookupByString(string) (ipld.Node, error) { + return mixins.List{TypeName: "ipldgit.String_List.Repr"}.LookupByString("") } -func (nr *_ListTag__Repr) LookupByNode(k ipld.Node) (ipld.Node, error) { - v, err := (ListTag)(nr).LookupByNode(k) +func (nr *_String_List__Repr) LookupByNode(k ipld.Node) (ipld.Node, error) { + v, err := (String_List)(nr).LookupByNode(k) if err != nil || v == ipld.Null { return v, err } - return v.(Tag).Representation(), nil + return v.(String).Representation(), nil } -func (nr *_ListTag__Repr) LookupByIndex(idx int64) (ipld.Node, error) { - v, err := (ListTag)(nr).LookupByIndex(idx) +func (nr *_String_List__Repr) LookupByIndex(idx int64) (ipld.Node, error) { + v, err := (String_List)(nr).LookupByIndex(idx) if err != nil || v == ipld.Null { return v, err } - return v.(Tag).Representation(), nil + return v.(String).Representation(), nil } -func (n _ListTag__Repr) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { +func (n _String_List__Repr) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { i, err := seg.Index() if err != nil { - return nil, ipld.ErrInvalidSegmentForList{TypeName: "ipldgit.ListTag.Repr", TroubleSegment: seg, Reason: err} + return nil, ipld.ErrInvalidSegmentForList{TypeName: "ipldgit.String_List.Repr", TroubleSegment: seg, Reason: err} } return n.LookupByIndex(i) } -func (_ListTag__Repr) MapIterator() ipld.MapIterator { +func (_String_List__Repr) MapIterator() ipld.MapIterator { return nil } -func (nr *_ListTag__Repr) ListIterator() ipld.ListIterator { - return &_ListTag__ReprListItr{(ListTag)(nr), 0} +func (nr *_String_List__Repr) ListIterator() ipld.ListIterator { + return &_String_List__ReprListItr{(String_List)(nr), 0} } -type _ListTag__ReprListItr _ListTag__ListItr +type _String_List__ReprListItr _String_List__ListItr -func (itr *_ListTag__ReprListItr) Next() (idx int64, v ipld.Node, err error) { - idx, v, err = (*_ListTag__ListItr)(itr).Next() +func (itr *_String_List__ReprListItr) Next() (idx int64, v ipld.Node, err error) { + idx, v, err = (*_String_List__ListItr)(itr).Next() if err != nil || v == ipld.Null { return } - return idx, v.(Tag).Representation(), nil + return idx, v.(String).Representation(), nil } -func (itr *_ListTag__ReprListItr) Done() bool { - return (*_ListTag__ListItr)(itr).Done() +func (itr *_String_List__ReprListItr) Done() bool { + return (*_String_List__ListItr)(itr).Done() } -func (rn *_ListTag__Repr) Length() int64 { +func (rn *_String_List__Repr) Length() int64 { return int64(len(rn.x)) } -func (_ListTag__Repr) IsAbsent() bool { +func (_String_List__Repr) IsAbsent() bool { return false } -func (_ListTag__Repr) IsNull() bool { +func (_String_List__Repr) IsNull() bool { return false } -func (_ListTag__Repr) AsBool() (bool, error) { - return mixins.List{TypeName: "ipldgit.ListTag.Repr"}.AsBool() +func (_String_List__Repr) AsBool() (bool, error) { + return mixins.List{TypeName: "ipldgit.String_List.Repr"}.AsBool() } -func (_ListTag__Repr) AsInt() (int64, error) { - return mixins.List{TypeName: "ipldgit.ListTag.Repr"}.AsInt() +func (_String_List__Repr) AsInt() (int64, error) { + return mixins.List{TypeName: "ipldgit.String_List.Repr"}.AsInt() } -func (_ListTag__Repr) AsFloat() (float64, error) { - return mixins.List{TypeName: "ipldgit.ListTag.Repr"}.AsFloat() +func (_String_List__Repr) AsFloat() (float64, error) { + return mixins.List{TypeName: "ipldgit.String_List.Repr"}.AsFloat() } -func (_ListTag__Repr) AsString() (string, error) { - return mixins.List{TypeName: "ipldgit.ListTag.Repr"}.AsString() +func (_String_List__Repr) AsString() (string, error) { + return mixins.List{TypeName: "ipldgit.String_List.Repr"}.AsString() } -func (_ListTag__Repr) AsBytes() ([]byte, error) { - return mixins.List{TypeName: "ipldgit.ListTag.Repr"}.AsBytes() +func (_String_List__Repr) AsBytes() ([]byte, error) { + return mixins.List{TypeName: "ipldgit.String_List.Repr"}.AsBytes() } -func (_ListTag__Repr) AsLink() (ipld.Link, error) { - return mixins.List{TypeName: "ipldgit.ListTag.Repr"}.AsLink() +func (_String_List__Repr) AsLink() (ipld.Link, error) { + return mixins.List{TypeName: "ipldgit.String_List.Repr"}.AsLink() } -func (_ListTag__Repr) Prototype() ipld.NodePrototype { - return _ListTag__ReprPrototype{} +func (_String_List__Repr) Prototype() ipld.NodePrototype { + return _String_List__ReprPrototype{} } -type _ListTag__ReprPrototype struct{} +type _String_List__ReprPrototype struct{} -func (_ListTag__ReprPrototype) NewBuilder() ipld.NodeBuilder { - var nb _ListTag__ReprBuilder +func (_String_List__ReprPrototype) NewBuilder() ipld.NodeBuilder { + var nb _String_List__ReprBuilder nb.Reset() return &nb } -type _ListTag__ReprBuilder struct { - _ListTag__ReprAssembler +type _String_List__ReprBuilder struct { + _String_List__ReprAssembler } -func (nb *_ListTag__ReprBuilder) Build() ipld.Node { +func (nb *_String_List__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 *_ListTag__ReprBuilder) Reset() { - var w _ListTag +func (nb *_String_List__ReprBuilder) Reset() { + var w _String_List var m schema.Maybe - *nb = _ListTag__ReprBuilder{_ListTag__ReprAssembler{w: &w, m: &m}} + *nb = _String_List__ReprBuilder{_String_List__ReprAssembler{w: &w, m: &m}} } -type _ListTag__ReprAssembler struct { - w *_ListTag +type _String_List__ReprAssembler struct { + w *_String_List m *schema.Maybe state laState cm schema.Maybe - va _Tag__ReprAssembler + va _String__ReprAssembler } -func (na *_ListTag__ReprAssembler) reset() { +func (na *_String_List__ReprAssembler) reset() { na.state = laState_initial na.va.reset() } -func (_ListTag__ReprAssembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { - return mixins.ListAssembler{TypeName: "ipldgit.ListTag.Repr"}.BeginMap(0) +func (_String_List__ReprAssembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { + return mixins.ListAssembler{TypeName: "ipldgit.String_List.Repr"}.BeginMap(0) } -func (na *_ListTag__ReprAssembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { +func (na *_String_List__ReprAssembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { switch *na.m { case schema.Maybe_Value, schema.Maybe_Null: panic("invalid state: cannot assign into assembler that's already finished") @@ -4291,17 +4804,17 @@ func (na *_ListTag__ReprAssembler) BeginList(sizeHint int64) (ipld.ListAssembler sizeHint = 0 } if sizeHint > 0 { - na.w.x = make([]_Tag, 0, sizeHint) + na.w.x = make([]_String, 0, sizeHint) } return na, nil } -func (na *_ListTag__ReprAssembler) AssignNull() error { +func (na *_String_List__ReprAssembler) AssignNull() error { switch *na.m { case allowNull: *na.m = schema.Maybe_Null return nil case schema.Maybe_Absent: - return mixins.ListAssembler{TypeName: "ipldgit.ListTag.Repr.Repr"}.AssignNull() + return mixins.ListAssembler{TypeName: "ipldgit.String_List.Repr.Repr"}.AssignNull() case schema.Maybe_Value, schema.Maybe_Null: panic("invalid state: cannot assign into assembler that's already finished") case midvalue: @@ -4309,29 +4822,29 @@ func (na *_ListTag__ReprAssembler) AssignNull() error { } panic("unreachable") } -func (_ListTag__ReprAssembler) AssignBool(bool) error { - return mixins.ListAssembler{TypeName: "ipldgit.ListTag.Repr"}.AssignBool(false) +func (_String_List__ReprAssembler) AssignBool(bool) error { + return mixins.ListAssembler{TypeName: "ipldgit.String_List.Repr"}.AssignBool(false) } -func (_ListTag__ReprAssembler) AssignInt(int64) error { - return mixins.ListAssembler{TypeName: "ipldgit.ListTag.Repr"}.AssignInt(0) +func (_String_List__ReprAssembler) AssignInt(int64) error { + return mixins.ListAssembler{TypeName: "ipldgit.String_List.Repr"}.AssignInt(0) } -func (_ListTag__ReprAssembler) AssignFloat(float64) error { - return mixins.ListAssembler{TypeName: "ipldgit.ListTag.Repr"}.AssignFloat(0) +func (_String_List__ReprAssembler) AssignFloat(float64) error { + return mixins.ListAssembler{TypeName: "ipldgit.String_List.Repr"}.AssignFloat(0) } -func (_ListTag__ReprAssembler) AssignString(string) error { - return mixins.ListAssembler{TypeName: "ipldgit.ListTag.Repr"}.AssignString("") +func (_String_List__ReprAssembler) AssignString(string) error { + return mixins.ListAssembler{TypeName: "ipldgit.String_List.Repr"}.AssignString("") } -func (_ListTag__ReprAssembler) AssignBytes([]byte) error { - return mixins.ListAssembler{TypeName: "ipldgit.ListTag.Repr"}.AssignBytes(nil) +func (_String_List__ReprAssembler) AssignBytes([]byte) error { + return mixins.ListAssembler{TypeName: "ipldgit.String_List.Repr"}.AssignBytes(nil) } -func (_ListTag__ReprAssembler) AssignLink(ipld.Link) error { - return mixins.ListAssembler{TypeName: "ipldgit.ListTag.Repr"}.AssignLink(nil) +func (_String_List__ReprAssembler) AssignLink(ipld.Link) error { + return mixins.ListAssembler{TypeName: "ipldgit.String_List.Repr"}.AssignLink(nil) } -func (na *_ListTag__ReprAssembler) AssignNode(v ipld.Node) error { +func (na *_String_List__ReprAssembler) AssignNode(v ipld.Node) error { if v.IsNull() { return na.AssignNull() } - if v2, ok := v.(*_ListTag); ok { + if v2, ok := v.(*_String_List); ok { switch *na.m { case schema.Maybe_Value, schema.Maybe_Null: panic("invalid state: cannot assign into assembler that's already finished") @@ -4343,7 +4856,7 @@ func (na *_ListTag__ReprAssembler) AssignNode(v ipld.Node) error { return nil } if v.Kind() != ipld.Kind_List { - return ipld.ErrWrongKind{TypeName: "ipldgit.ListTag.Repr", MethodName: "AssignNode", AppropriateKind: ipld.KindSet_JustList, ActualKind: v.Kind()} + return ipld.ErrWrongKind{TypeName: "ipldgit.String_List.Repr", MethodName: "AssignNode", AppropriateKind: ipld.KindSet_JustList, ActualKind: v.Kind()} } itr := v.ListIterator() for !itr.Done() { @@ -4357,10 +4870,10 @@ func (na *_ListTag__ReprAssembler) AssignNode(v ipld.Node) error { } return na.Finish() } -func (_ListTag__ReprAssembler) Prototype() ipld.NodePrototype { - return _ListTag__ReprPrototype{} +func (_String_List__ReprAssembler) Prototype() ipld.NodePrototype { + return _String_List__ReprPrototype{} } -func (la *_ListTag__ReprAssembler) valueFinishTidy() bool { +func (la *_String_List__ReprAssembler) valueFinishTidy() bool { switch la.cm { case schema.Maybe_Value: la.va.w = nil @@ -4372,7 +4885,7 @@ func (la *_ListTag__ReprAssembler) valueFinishTidy() bool { return false } } -func (la *_ListTag__ReprAssembler) AssembleValue() ipld.NodeAssembler { +func (la *_String_List__ReprAssembler) AssembleValue() ipld.NodeAssembler { switch la.state { case laState_initial: // carry on @@ -4383,14 +4896,14 @@ func (la *_ListTag__ReprAssembler) AssembleValue() ipld.NodeAssembler { case laState_finished: panic("invalid state: AssembleValue cannot be called on an assembler that's already finished") } - la.w.x = append(la.w.x, _Tag{}) + la.w.x = append(la.w.x, _String{}) 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 *_ListTag__ReprAssembler) Finish() error { +func (la *_String_List__ReprAssembler) Finish() error { switch la.state { case laState_initial: // carry on @@ -4405,39 +4918,42 @@ func (la *_ListTag__ReprAssembler) Finish() error { *la.m = schema.Maybe_Value return nil } -func (la *_ListTag__ReprAssembler) ValuePrototype(_ int64) ipld.NodePrototype { - return _Tag__ReprPrototype{} +func (la *_String_List__ReprAssembler) ValuePrototype(_ int64) ipld.NodePrototype { + return _String__ReprPrototype{} } -func (n _PersonInfo) FieldDate() String { - return &n.date -} -func (n _PersonInfo) FieldTimezone() String { - return &n.timezone +func (n _Tag) FieldObject() Link { + return &n.object } -func (n _PersonInfo) FieldEmail() String { - return &n.email +func (n _Tag) FieldType() String { + return &n.typ } -func (n _PersonInfo) FieldName() String { - return &n.name +func (n _Tag) FieldTag() String { + return &n.tag +} +func (n _Tag) FieldTagger() PersonInfo { + return &n.tagger +} +func (n _Tag) FieldMessage() String { + return &n.message } -type _PersonInfo__Maybe struct { +type _Tag__Maybe struct { m schema.Maybe - v PersonInfo + v Tag } -type MaybePersonInfo = *_PersonInfo__Maybe +type MaybeTag = *_Tag__Maybe -func (m MaybePersonInfo) IsNull() bool { +func (m MaybeTag) IsNull() bool { return m.m == schema.Maybe_Null } -func (m MaybePersonInfo) IsAbsent() bool { +func (m MaybeTag) IsAbsent() bool { return m.m == schema.Maybe_Absent } -func (m MaybePersonInfo) Exists() bool { +func (m MaybeTag) Exists() bool { return m.m == schema.Maybe_Value } -func (m MaybePersonInfo) AsNode() ipld.Node { +func (m MaybeTag) AsNode() ipld.Node { switch m.m { case schema.Maybe_Absent: return ipld.Absent @@ -4449,7 +4965,7 @@ func (m MaybePersonInfo) AsNode() ipld.Node { panic("unreachable") } } -func (m MaybePersonInfo) Must() PersonInfo { +func (m MaybeTag) Must() Tag { if !m.Exists() { panic("unbox of a maybe rejected") } @@ -4457,170 +4973,179 @@ func (m MaybePersonInfo) Must() PersonInfo { } var ( - fieldName__PersonInfo_Date = _String{"date"} - fieldName__PersonInfo_Timezone = _String{"timezone"} - fieldName__PersonInfo_Email = _String{"email"} - fieldName__PersonInfo_Name = _String{"name"} + fieldName__Tag_Object = _String{"object"} + fieldName__Tag_Type = _String{"type"} + fieldName__Tag_Tag = _String{"tag"} + fieldName__Tag_Tagger = _String{"tagger"} + fieldName__Tag_Message = _String{"message"} ) -var _ ipld.Node = (PersonInfo)(&_PersonInfo{}) -var _ schema.TypedNode = (PersonInfo)(&_PersonInfo{}) +var _ ipld.Node = (Tag)(&_Tag{}) +var _ schema.TypedNode = (Tag)(&_Tag{}) -func (PersonInfo) Kind() ipld.Kind { +func (Tag) Kind() ipld.Kind { return ipld.Kind_Map } -func (n PersonInfo) LookupByString(key string) (ipld.Node, error) { +func (n Tag) LookupByString(key string) (ipld.Node, error) { switch key { - case "date": - return &n.date, nil - case "timezone": - return &n.timezone, nil - case "email": - return &n.email, nil - case "name": - return &n.name, nil + case "object": + return &n.object, nil + case "type": + return &n.typ, nil + case "tag": + return &n.tag, nil + case "tagger": + return &n.tagger, nil + case "message": + return &n.message, nil default: return nil, schema.ErrNoSuchField{Type: nil /*TODO*/, Field: ipld.PathSegmentOfString(key)} } } -func (n PersonInfo) LookupByNode(key ipld.Node) (ipld.Node, error) { +func (n Tag) LookupByNode(key ipld.Node) (ipld.Node, error) { ks, err := key.AsString() if err != nil { return nil, err } return n.LookupByString(ks) } -func (PersonInfo) LookupByIndex(idx int64) (ipld.Node, error) { - return mixins.Map{TypeName: "ipldgit.PersonInfo"}.LookupByIndex(0) +func (Tag) LookupByIndex(idx int64) (ipld.Node, error) { + return mixins.Map{TypeName: "ipldgit.Tag"}.LookupByIndex(0) } -func (n PersonInfo) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { +func (n Tag) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { return n.LookupByString(seg.String()) } -func (n PersonInfo) MapIterator() ipld.MapIterator { - return &_PersonInfo__MapItr{n, 0} +func (n Tag) MapIterator() ipld.MapIterator { + return &_Tag__MapItr{n, 0} } -type _PersonInfo__MapItr struct { - n PersonInfo +type _Tag__MapItr struct { + n Tag idx int } -func (itr *_PersonInfo__MapItr) Next() (k ipld.Node, v ipld.Node, _ error) { - if itr.idx >= 4 { +func (itr *_Tag__MapItr) Next() (k ipld.Node, v ipld.Node, _ error) { + if itr.idx >= 5 { return nil, nil, ipld.ErrIteratorOverread{} } switch itr.idx { case 0: - k = &fieldName__PersonInfo_Date - v = &itr.n.date + k = &fieldName__Tag_Object + v = &itr.n.object case 1: - k = &fieldName__PersonInfo_Timezone - v = &itr.n.timezone + k = &fieldName__Tag_Type + v = &itr.n.typ case 2: - k = &fieldName__PersonInfo_Email - v = &itr.n.email + k = &fieldName__Tag_Tag + v = &itr.n.tag case 3: - k = &fieldName__PersonInfo_Name - v = &itr.n.name + k = &fieldName__Tag_Tagger + v = &itr.n.tagger + case 4: + k = &fieldName__Tag_Message + v = &itr.n.message default: panic("unreachable") } itr.idx++ return } -func (itr *_PersonInfo__MapItr) Done() bool { - return itr.idx >= 4 +func (itr *_Tag__MapItr) Done() bool { + return itr.idx >= 5 } -func (PersonInfo) ListIterator() ipld.ListIterator { +func (Tag) ListIterator() ipld.ListIterator { return nil } -func (PersonInfo) Length() int64 { - return 4 +func (Tag) Length() int64 { + return 5 } -func (PersonInfo) IsAbsent() bool { +func (Tag) IsAbsent() bool { return false } -func (PersonInfo) IsNull() bool { +func (Tag) IsNull() bool { return false } -func (PersonInfo) AsBool() (bool, error) { - return mixins.Map{TypeName: "ipldgit.PersonInfo"}.AsBool() +func (Tag) AsBool() (bool, error) { + return mixins.Map{TypeName: "ipldgit.Tag"}.AsBool() } -func (PersonInfo) AsInt() (int64, error) { - return mixins.Map{TypeName: "ipldgit.PersonInfo"}.AsInt() +func (Tag) AsInt() (int64, error) { + return mixins.Map{TypeName: "ipldgit.Tag"}.AsInt() } -func (PersonInfo) AsFloat() (float64, error) { - return mixins.Map{TypeName: "ipldgit.PersonInfo"}.AsFloat() +func (Tag) AsFloat() (float64, error) { + return mixins.Map{TypeName: "ipldgit.Tag"}.AsFloat() } -func (PersonInfo) AsString() (string, error) { - return mixins.Map{TypeName: "ipldgit.PersonInfo"}.AsString() +func (Tag) AsString() (string, error) { + return mixins.Map{TypeName: "ipldgit.Tag"}.AsString() } -func (PersonInfo) AsBytes() ([]byte, error) { - return mixins.Map{TypeName: "ipldgit.PersonInfo"}.AsBytes() +func (Tag) AsBytes() ([]byte, error) { + return mixins.Map{TypeName: "ipldgit.Tag"}.AsBytes() } -func (PersonInfo) AsLink() (ipld.Link, error) { - return mixins.Map{TypeName: "ipldgit.PersonInfo"}.AsLink() +func (Tag) AsLink() (ipld.Link, error) { + return mixins.Map{TypeName: "ipldgit.Tag"}.AsLink() } -func (PersonInfo) Prototype() ipld.NodePrototype { - return _PersonInfo__Prototype{} +func (Tag) Prototype() ipld.NodePrototype { + return _Tag__Prototype{} } -type _PersonInfo__Prototype struct{} +type _Tag__Prototype struct{} -func (_PersonInfo__Prototype) NewBuilder() ipld.NodeBuilder { - var nb _PersonInfo__Builder +func (_Tag__Prototype) NewBuilder() ipld.NodeBuilder { + var nb _Tag__Builder nb.Reset() return &nb } -type _PersonInfo__Builder struct { - _PersonInfo__Assembler +type _Tag__Builder struct { + _Tag__Assembler } -func (nb *_PersonInfo__Builder) Build() ipld.Node { +func (nb *_Tag__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 *_PersonInfo__Builder) Reset() { - var w _PersonInfo +func (nb *_Tag__Builder) Reset() { + var w _Tag var m schema.Maybe - *nb = _PersonInfo__Builder{_PersonInfo__Assembler{w: &w, m: &m}} + *nb = _Tag__Builder{_Tag__Assembler{w: &w, m: &m}} } -type _PersonInfo__Assembler struct { - w *_PersonInfo +type _Tag__Assembler struct { + w *_Tag m *schema.Maybe state maState s int f int - cm schema.Maybe - ca_date _String__Assembler - ca_timezone _String__Assembler - ca_email _String__Assembler - ca_name _String__Assembler + cm schema.Maybe + ca_object _Link__Assembler + ca_typ _String__Assembler + ca_tag _String__Assembler + ca_tagger _PersonInfo__Assembler + ca_message _String__Assembler } -func (na *_PersonInfo__Assembler) reset() { +func (na *_Tag__Assembler) reset() { na.state = maState_initial na.s = 0 - na.ca_date.reset() - na.ca_timezone.reset() - na.ca_email.reset() - na.ca_name.reset() + na.ca_object.reset() + na.ca_typ.reset() + na.ca_tag.reset() + na.ca_tagger.reset() + na.ca_message.reset() } var ( - fieldBit__PersonInfo_Date = 1 << 0 - fieldBit__PersonInfo_Timezone = 1 << 1 - fieldBit__PersonInfo_Email = 1 << 2 - fieldBit__PersonInfo_Name = 1 << 3 - fieldBits__PersonInfo_sufficient = 0 + 1<<0 + 1<<1 + 1<<2 + 1<<3 + fieldBit__Tag_Object = 1 << 0 + fieldBit__Tag_Type = 1 << 1 + fieldBit__Tag_Tag = 1 << 2 + fieldBit__Tag_Tagger = 1 << 3 + fieldBit__Tag_Message = 1 << 4 + fieldBits__Tag_sufficient = 0 + 1<<0 + 1<<1 + 1<<2 + 1<<3 + 1<<4 ) -func (na *_PersonInfo__Assembler) BeginMap(int64) (ipld.MapAssembler, error) { +func (na *_Tag__Assembler) BeginMap(int64) (ipld.MapAssembler, error) { switch *na.m { case schema.Maybe_Value, schema.Maybe_Null: panic("invalid state: cannot assign into assembler that's already finished") @@ -4629,20 +5154,20 @@ func (na *_PersonInfo__Assembler) BeginMap(int64) (ipld.MapAssembler, error) { } *na.m = midvalue if na.w == nil { - na.w = &_PersonInfo{} + na.w = &_Tag{} } return na, nil } -func (_PersonInfo__Assembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { - return mixins.MapAssembler{TypeName: "ipldgit.PersonInfo"}.BeginList(0) +func (_Tag__Assembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { + return mixins.MapAssembler{TypeName: "ipldgit.Tag"}.BeginList(0) } -func (na *_PersonInfo__Assembler) AssignNull() error { +func (na *_Tag__Assembler) AssignNull() error { switch *na.m { case allowNull: *na.m = schema.Maybe_Null return nil case schema.Maybe_Absent: - return mixins.MapAssembler{TypeName: "ipldgit.PersonInfo"}.AssignNull() + return mixins.MapAssembler{TypeName: "ipldgit.Tag"}.AssignNull() case schema.Maybe_Value, schema.Maybe_Null: panic("invalid state: cannot assign into assembler that's already finished") case midvalue: @@ -4650,29 +5175,29 @@ func (na *_PersonInfo__Assembler) AssignNull() error { } panic("unreachable") } -func (_PersonInfo__Assembler) AssignBool(bool) error { - return mixins.MapAssembler{TypeName: "ipldgit.PersonInfo"}.AssignBool(false) +func (_Tag__Assembler) AssignBool(bool) error { + return mixins.MapAssembler{TypeName: "ipldgit.Tag"}.AssignBool(false) } -func (_PersonInfo__Assembler) AssignInt(int64) error { - return mixins.MapAssembler{TypeName: "ipldgit.PersonInfo"}.AssignInt(0) +func (_Tag__Assembler) AssignInt(int64) error { + return mixins.MapAssembler{TypeName: "ipldgit.Tag"}.AssignInt(0) } -func (_PersonInfo__Assembler) AssignFloat(float64) error { - return mixins.MapAssembler{TypeName: "ipldgit.PersonInfo"}.AssignFloat(0) +func (_Tag__Assembler) AssignFloat(float64) error { + return mixins.MapAssembler{TypeName: "ipldgit.Tag"}.AssignFloat(0) } -func (_PersonInfo__Assembler) AssignString(string) error { - return mixins.MapAssembler{TypeName: "ipldgit.PersonInfo"}.AssignString("") +func (_Tag__Assembler) AssignString(string) error { + return mixins.MapAssembler{TypeName: "ipldgit.Tag"}.AssignString("") } -func (_PersonInfo__Assembler) AssignBytes([]byte) error { - return mixins.MapAssembler{TypeName: "ipldgit.PersonInfo"}.AssignBytes(nil) +func (_Tag__Assembler) AssignBytes([]byte) error { + return mixins.MapAssembler{TypeName: "ipldgit.Tag"}.AssignBytes(nil) } -func (_PersonInfo__Assembler) AssignLink(ipld.Link) error { - return mixins.MapAssembler{TypeName: "ipldgit.PersonInfo"}.AssignLink(nil) +func (_Tag__Assembler) AssignLink(ipld.Link) error { + return mixins.MapAssembler{TypeName: "ipldgit.Tag"}.AssignLink(nil) } -func (na *_PersonInfo__Assembler) AssignNode(v ipld.Node) error { +func (na *_Tag__Assembler) AssignNode(v ipld.Node) error { if v.IsNull() { return na.AssignNull() } - if v2, ok := v.(*_PersonInfo); ok { + if v2, ok := v.(*_Tag); ok { switch *na.m { case schema.Maybe_Value, schema.Maybe_Null: panic("invalid state: cannot assign into assembler that's already finished") @@ -4689,7 +5214,7 @@ func (na *_PersonInfo__Assembler) AssignNode(v ipld.Node) error { return nil } if v.Kind() != ipld.Kind_Map { - return ipld.ErrWrongKind{TypeName: "ipldgit.PersonInfo", MethodName: "AssignNode", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()} + return ipld.ErrWrongKind{TypeName: "ipldgit.Tag", MethodName: "AssignNode", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()} } itr := v.MapIterator() for !itr.Done() { @@ -4706,15 +5231,15 @@ func (na *_PersonInfo__Assembler) AssignNode(v ipld.Node) error { } return na.Finish() } -func (_PersonInfo__Assembler) Prototype() ipld.NodePrototype { - return _PersonInfo__Prototype{} +func (_Tag__Assembler) Prototype() ipld.NodePrototype { + return _Tag__Prototype{} } -func (ma *_PersonInfo__Assembler) valueFinishTidy() bool { +func (ma *_Tag__Assembler) valueFinishTidy() bool { switch ma.f { case 0: switch ma.cm { case schema.Maybe_Value: - ma.ca_date.w = nil + ma.ca_object.w = nil ma.cm = schema.Maybe_Absent ma.state = maState_initial return true @@ -4724,7 +5249,7 @@ func (ma *_PersonInfo__Assembler) valueFinishTidy() bool { case 1: switch ma.cm { case schema.Maybe_Value: - ma.ca_timezone.w = nil + ma.ca_typ.w = nil ma.cm = schema.Maybe_Absent ma.state = maState_initial return true @@ -4734,7 +5259,7 @@ func (ma *_PersonInfo__Assembler) valueFinishTidy() bool { case 2: switch ma.cm { case schema.Maybe_Value: - ma.ca_email.w = nil + ma.ca_tag.w = nil ma.cm = schema.Maybe_Absent ma.state = maState_initial return true @@ -4744,7 +5269,17 @@ func (ma *_PersonInfo__Assembler) valueFinishTidy() bool { case 3: switch ma.cm { case schema.Maybe_Value: - ma.ca_name.w = nil + ma.ca_tagger.w = nil + ma.cm = schema.Maybe_Absent + ma.state = maState_initial + return true + default: + return false + } + case 4: + switch ma.cm { + case schema.Maybe_Value: + ma.ca_message.w = nil ma.cm = schema.Maybe_Absent ma.state = maState_initial return true @@ -4755,7 +5290,7 @@ func (ma *_PersonInfo__Assembler) valueFinishTidy() bool { panic("unreachable") } } -func (ma *_PersonInfo__Assembler) AssembleEntry(k string) (ipld.NodeAssembler, error) { +func (ma *_Tag__Assembler) AssembleEntry(k string) (ipld.NodeAssembler, error) { switch ma.state { case maState_initial: // carry on @@ -4771,50 +5306,60 @@ func (ma *_PersonInfo__Assembler) AssembleEntry(k string) (ipld.NodeAssembler, e panic("invalid state: AssembleEntry cannot be called on an assembler that's already finished") } switch k { - case "date": - if ma.s&fieldBit__PersonInfo_Date != 0 { - return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Date} + case "object": + if ma.s&fieldBit__Tag_Object != 0 { + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Object} } - ma.s += fieldBit__PersonInfo_Date + ma.s += fieldBit__Tag_Object ma.state = maState_midValue ma.f = 0 - ma.ca_date.w = &ma.w.date - ma.ca_date.m = &ma.cm - return &ma.ca_date, nil - case "timezone": - if ma.s&fieldBit__PersonInfo_Timezone != 0 { - return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Timezone} + ma.ca_object.w = &ma.w.object + ma.ca_object.m = &ma.cm + return &ma.ca_object, nil + case "type": + if ma.s&fieldBit__Tag_Type != 0 { + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Type} } - ma.s += fieldBit__PersonInfo_Timezone + ma.s += fieldBit__Tag_Type ma.state = maState_midValue ma.f = 1 - ma.ca_timezone.w = &ma.w.timezone - ma.ca_timezone.m = &ma.cm - return &ma.ca_timezone, nil - case "email": - if ma.s&fieldBit__PersonInfo_Email != 0 { - return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Email} + ma.ca_typ.w = &ma.w.typ + ma.ca_typ.m = &ma.cm + return &ma.ca_typ, nil + case "tag": + if ma.s&fieldBit__Tag_Tag != 0 { + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Tag} } - ma.s += fieldBit__PersonInfo_Email + ma.s += fieldBit__Tag_Tag ma.state = maState_midValue ma.f = 2 - ma.ca_email.w = &ma.w.email - ma.ca_email.m = &ma.cm - return &ma.ca_email, nil - case "name": - if ma.s&fieldBit__PersonInfo_Name != 0 { - return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Name} + ma.ca_tag.w = &ma.w.tag + ma.ca_tag.m = &ma.cm + return &ma.ca_tag, nil + case "tagger": + if ma.s&fieldBit__Tag_Tagger != 0 { + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Tagger} } - ma.s += fieldBit__PersonInfo_Name + ma.s += fieldBit__Tag_Tagger ma.state = maState_midValue ma.f = 3 - ma.ca_name.w = &ma.w.name - ma.ca_name.m = &ma.cm - return &ma.ca_name, nil + ma.ca_tagger.w = &ma.w.tagger + ma.ca_tagger.m = &ma.cm + return &ma.ca_tagger, nil + case "message": + if ma.s&fieldBit__Tag_Message != 0 { + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Message} + } + ma.s += fieldBit__Tag_Message + ma.state = maState_midValue + ma.f = 4 + ma.ca_message.w = &ma.w.message + ma.ca_message.m = &ma.cm + return &ma.ca_message, nil } - return nil, ipld.ErrInvalidKey{TypeName: "ipldgit.PersonInfo", Key: &_String{k}} + return nil, ipld.ErrInvalidKey{TypeName: "ipldgit.Tag", Key: &_String{k}} } -func (ma *_PersonInfo__Assembler) AssembleKey() ipld.NodeAssembler { +func (ma *_Tag__Assembler) AssembleKey() ipld.NodeAssembler { switch ma.state { case maState_initial: // carry on @@ -4830,9 +5375,9 @@ func (ma *_PersonInfo__Assembler) AssembleKey() ipld.NodeAssembler { panic("invalid state: AssembleKey cannot be called on an assembler that's already finished") } ma.state = maState_midKey - return (*_PersonInfo__KeyAssembler)(ma) + return (*_Tag__KeyAssembler)(ma) } -func (ma *_PersonInfo__Assembler) AssembleValue() ipld.NodeAssembler { +func (ma *_Tag__Assembler) AssembleValue() ipld.NodeAssembler { switch ma.state { case maState_initial: panic("invalid state: AssembleValue cannot be called when no key is primed") @@ -4848,26 +5393,30 @@ func (ma *_PersonInfo__Assembler) AssembleValue() ipld.NodeAssembler { ma.state = maState_midValue switch ma.f { case 0: - ma.ca_date.w = &ma.w.date - ma.ca_date.m = &ma.cm - return &ma.ca_date + ma.ca_object.w = &ma.w.object + ma.ca_object.m = &ma.cm + return &ma.ca_object case 1: - ma.ca_timezone.w = &ma.w.timezone - ma.ca_timezone.m = &ma.cm - return &ma.ca_timezone + ma.ca_typ.w = &ma.w.typ + ma.ca_typ.m = &ma.cm + return &ma.ca_typ case 2: - ma.ca_email.w = &ma.w.email - ma.ca_email.m = &ma.cm - return &ma.ca_email + ma.ca_tag.w = &ma.w.tag + ma.ca_tag.m = &ma.cm + return &ma.ca_tag case 3: - ma.ca_name.w = &ma.w.name - ma.ca_name.m = &ma.cm - return &ma.ca_name + ma.ca_tagger.w = &ma.w.tagger + ma.ca_tagger.m = &ma.cm + return &ma.ca_tagger + case 4: + ma.ca_message.w = &ma.w.message + ma.ca_message.m = &ma.cm + return &ma.ca_message default: panic("unreachable") } } -func (ma *_PersonInfo__Assembler) Finish() error { +func (ma *_Tag__Assembler) Finish() error { switch ma.state { case maState_initial: // carry on @@ -4882,19 +5431,22 @@ func (ma *_PersonInfo__Assembler) Finish() error { case maState_finished: panic("invalid state: Finish cannot be called on an assembler that's already finished") } - if ma.s&fieldBits__PersonInfo_sufficient != fieldBits__PersonInfo_sufficient { + if ma.s&fieldBits__Tag_sufficient != fieldBits__Tag_sufficient { err := ipld.ErrMissingRequiredField{Missing: make([]string, 0)} - if ma.s&fieldBit__PersonInfo_Date == 0 { - err.Missing = append(err.Missing, "date") + if ma.s&fieldBit__Tag_Object == 0 { + err.Missing = append(err.Missing, "object") } - if ma.s&fieldBit__PersonInfo_Timezone == 0 { - err.Missing = append(err.Missing, "timezone") + if ma.s&fieldBit__Tag_Type == 0 { + err.Missing = append(err.Missing, "type") } - if ma.s&fieldBit__PersonInfo_Email == 0 { - err.Missing = append(err.Missing, "email") + if ma.s&fieldBit__Tag_Tag == 0 { + err.Missing = append(err.Missing, "tag") } - if ma.s&fieldBit__PersonInfo_Name == 0 { - err.Missing = append(err.Missing, "name") + if ma.s&fieldBit__Tag_Tagger == 0 { + err.Missing = append(err.Missing, "tagger") + } + if ma.s&fieldBit__Tag_Message == 0 { + err.Missing = append(err.Missing, "message") } return err } @@ -4902,254 +5454,270 @@ func (ma *_PersonInfo__Assembler) Finish() error { *ma.m = schema.Maybe_Value return nil } -func (ma *_PersonInfo__Assembler) KeyPrototype() ipld.NodePrototype { +func (ma *_Tag__Assembler) KeyPrototype() ipld.NodePrototype { return _String__Prototype{} } -func (ma *_PersonInfo__Assembler) ValuePrototype(k string) ipld.NodePrototype { +func (ma *_Tag__Assembler) ValuePrototype(k string) ipld.NodePrototype { panic("todo structbuilder mapassembler valueprototype") } -type _PersonInfo__KeyAssembler _PersonInfo__Assembler +type _Tag__KeyAssembler _Tag__Assembler -func (_PersonInfo__KeyAssembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { - return mixins.StringAssembler{TypeName: "ipldgit.PersonInfo.KeyAssembler"}.BeginMap(0) +func (_Tag__KeyAssembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { + return mixins.StringAssembler{TypeName: "ipldgit.Tag.KeyAssembler"}.BeginMap(0) } -func (_PersonInfo__KeyAssembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { - return mixins.StringAssembler{TypeName: "ipldgit.PersonInfo.KeyAssembler"}.BeginList(0) +func (_Tag__KeyAssembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { + return mixins.StringAssembler{TypeName: "ipldgit.Tag.KeyAssembler"}.BeginList(0) } -func (na *_PersonInfo__KeyAssembler) AssignNull() error { - return mixins.StringAssembler{TypeName: "ipldgit.PersonInfo.KeyAssembler"}.AssignNull() +func (na *_Tag__KeyAssembler) AssignNull() error { + return mixins.StringAssembler{TypeName: "ipldgit.Tag.KeyAssembler"}.AssignNull() } -func (_PersonInfo__KeyAssembler) AssignBool(bool) error { - return mixins.StringAssembler{TypeName: "ipldgit.PersonInfo.KeyAssembler"}.AssignBool(false) +func (_Tag__KeyAssembler) AssignBool(bool) error { + return mixins.StringAssembler{TypeName: "ipldgit.Tag.KeyAssembler"}.AssignBool(false) } -func (_PersonInfo__KeyAssembler) AssignInt(int64) error { - return mixins.StringAssembler{TypeName: "ipldgit.PersonInfo.KeyAssembler"}.AssignInt(0) +func (_Tag__KeyAssembler) AssignInt(int64) error { + return mixins.StringAssembler{TypeName: "ipldgit.Tag.KeyAssembler"}.AssignInt(0) } -func (_PersonInfo__KeyAssembler) AssignFloat(float64) error { - return mixins.StringAssembler{TypeName: "ipldgit.PersonInfo.KeyAssembler"}.AssignFloat(0) +func (_Tag__KeyAssembler) AssignFloat(float64) error { + return mixins.StringAssembler{TypeName: "ipldgit.Tag.KeyAssembler"}.AssignFloat(0) } -func (ka *_PersonInfo__KeyAssembler) AssignString(k string) error { +func (ka *_Tag__KeyAssembler) AssignString(k string) error { if ka.state != maState_midKey { panic("misuse: KeyAssembler held beyond its valid lifetime") } switch k { - case "date": - if ka.s&fieldBit__PersonInfo_Date != 0 { - return ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Date} + case "object": + if ka.s&fieldBit__Tag_Object != 0 { + return ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Object} } - ka.s += fieldBit__PersonInfo_Date + ka.s += fieldBit__Tag_Object ka.state = maState_expectValue ka.f = 0 return nil - case "timezone": - if ka.s&fieldBit__PersonInfo_Timezone != 0 { - return ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Timezone} + case "type": + if ka.s&fieldBit__Tag_Type != 0 { + return ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Type} } - ka.s += fieldBit__PersonInfo_Timezone + ka.s += fieldBit__Tag_Type ka.state = maState_expectValue ka.f = 1 return nil - case "email": - if ka.s&fieldBit__PersonInfo_Email != 0 { - return ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Email} + case "tag": + if ka.s&fieldBit__Tag_Tag != 0 { + return ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Tag} } - ka.s += fieldBit__PersonInfo_Email + ka.s += fieldBit__Tag_Tag ka.state = maState_expectValue ka.f = 2 return nil - case "name": - if ka.s&fieldBit__PersonInfo_Name != 0 { - return ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Name} + case "tagger": + if ka.s&fieldBit__Tag_Tagger != 0 { + return ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Tagger} } - ka.s += fieldBit__PersonInfo_Name + ka.s += fieldBit__Tag_Tagger ka.state = maState_expectValue ka.f = 3 return nil + case "message": + if ka.s&fieldBit__Tag_Message != 0 { + return ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Message} + } + ka.s += fieldBit__Tag_Message + ka.state = maState_expectValue + ka.f = 4 + return nil default: - return ipld.ErrInvalidKey{TypeName: "ipldgit.PersonInfo", Key: &_String{k}} + return ipld.ErrInvalidKey{TypeName: "ipldgit.Tag", Key: &_String{k}} } } -func (_PersonInfo__KeyAssembler) AssignBytes([]byte) error { - return mixins.StringAssembler{TypeName: "ipldgit.PersonInfo.KeyAssembler"}.AssignBytes(nil) +func (_Tag__KeyAssembler) AssignBytes([]byte) error { + return mixins.StringAssembler{TypeName: "ipldgit.Tag.KeyAssembler"}.AssignBytes(nil) } -func (_PersonInfo__KeyAssembler) AssignLink(ipld.Link) error { - return mixins.StringAssembler{TypeName: "ipldgit.PersonInfo.KeyAssembler"}.AssignLink(nil) +func (_Tag__KeyAssembler) AssignLink(ipld.Link) error { + return mixins.StringAssembler{TypeName: "ipldgit.Tag.KeyAssembler"}.AssignLink(nil) } -func (ka *_PersonInfo__KeyAssembler) AssignNode(v ipld.Node) error { +func (ka *_Tag__KeyAssembler) AssignNode(v ipld.Node) error { if v2, err := v.AsString(); err != nil { return err } else { return ka.AssignString(v2) } } -func (_PersonInfo__KeyAssembler) Prototype() ipld.NodePrototype { +func (_Tag__KeyAssembler) Prototype() ipld.NodePrototype { return _String__Prototype{} } -func (PersonInfo) Type() schema.Type { +func (Tag) Type() schema.Type { return nil /*TODO:typelit*/ } -func (n PersonInfo) Representation() ipld.Node { - return (*_PersonInfo__Repr)(n) +func (n Tag) Representation() ipld.Node { + return (*_Tag__Repr)(n) } -type _PersonInfo__Repr _PersonInfo +type _Tag__Repr _Tag var ( - fieldName__PersonInfo_Date_serial = _String{"date"} - fieldName__PersonInfo_Timezone_serial = _String{"timezone"} - fieldName__PersonInfo_Email_serial = _String{"email"} - fieldName__PersonInfo_Name_serial = _String{"name"} + fieldName__Tag_Object_serial = _String{"object"} + fieldName__Tag_Type_serial = _String{"type"} + fieldName__Tag_Tag_serial = _String{"tag"} + fieldName__Tag_Tagger_serial = _String{"tagger"} + fieldName__Tag_Message_serial = _String{"message"} ) -var _ ipld.Node = &_PersonInfo__Repr{} +var _ ipld.Node = &_Tag__Repr{} -func (_PersonInfo__Repr) Kind() ipld.Kind { +func (_Tag__Repr) Kind() ipld.Kind { return ipld.Kind_Map } -func (n *_PersonInfo__Repr) LookupByString(key string) (ipld.Node, error) { +func (n *_Tag__Repr) LookupByString(key string) (ipld.Node, error) { switch key { - case "date": - return n.date.Representation(), nil - case "timezone": - return n.timezone.Representation(), nil - case "email": - return n.email.Representation(), nil - case "name": - return n.name.Representation(), nil + case "object": + return n.object.Representation(), nil + case "type": + return n.typ.Representation(), nil + case "tag": + return n.tag.Representation(), nil + case "tagger": + return n.tagger.Representation(), nil + case "message": + return n.message.Representation(), nil default: return nil, schema.ErrNoSuchField{Type: nil /*TODO*/, Field: ipld.PathSegmentOfString(key)} } } -func (n *_PersonInfo__Repr) LookupByNode(key ipld.Node) (ipld.Node, error) { +func (n *_Tag__Repr) LookupByNode(key ipld.Node) (ipld.Node, error) { ks, err := key.AsString() if err != nil { return nil, err } return n.LookupByString(ks) } -func (_PersonInfo__Repr) LookupByIndex(idx int64) (ipld.Node, error) { - return mixins.Map{TypeName: "ipldgit.PersonInfo.Repr"}.LookupByIndex(0) +func (_Tag__Repr) LookupByIndex(idx int64) (ipld.Node, error) { + return mixins.Map{TypeName: "ipldgit.Tag.Repr"}.LookupByIndex(0) } -func (n _PersonInfo__Repr) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { +func (n _Tag__Repr) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { return n.LookupByString(seg.String()) } -func (n *_PersonInfo__Repr) MapIterator() ipld.MapIterator { - return &_PersonInfo__ReprMapItr{n, 0} +func (n *_Tag__Repr) MapIterator() ipld.MapIterator { + return &_Tag__ReprMapItr{n, 0} } -type _PersonInfo__ReprMapItr struct { - n *_PersonInfo__Repr +type _Tag__ReprMapItr struct { + n *_Tag__Repr idx int } -func (itr *_PersonInfo__ReprMapItr) Next() (k ipld.Node, v ipld.Node, _ error) { - if itr.idx >= 4 { +func (itr *_Tag__ReprMapItr) Next() (k ipld.Node, v ipld.Node, _ error) { + if itr.idx >= 5 { return nil, nil, ipld.ErrIteratorOverread{} } switch itr.idx { case 0: - k = &fieldName__PersonInfo_Date_serial - v = itr.n.date.Representation() + k = &fieldName__Tag_Object_serial + v = itr.n.object.Representation() case 1: - k = &fieldName__PersonInfo_Timezone_serial - v = itr.n.timezone.Representation() + k = &fieldName__Tag_Type_serial + v = itr.n.typ.Representation() case 2: - k = &fieldName__PersonInfo_Email_serial - v = itr.n.email.Representation() + k = &fieldName__Tag_Tag_serial + v = itr.n.tag.Representation() case 3: - k = &fieldName__PersonInfo_Name_serial - v = itr.n.name.Representation() + k = &fieldName__Tag_Tagger_serial + v = itr.n.tagger.Representation() + case 4: + k = &fieldName__Tag_Message_serial + v = itr.n.message.Representation() default: panic("unreachable") } itr.idx++ return } -func (itr *_PersonInfo__ReprMapItr) Done() bool { - return itr.idx >= 4 +func (itr *_Tag__ReprMapItr) Done() bool { + return itr.idx >= 5 } -func (_PersonInfo__Repr) ListIterator() ipld.ListIterator { +func (_Tag__Repr) ListIterator() ipld.ListIterator { return nil } -func (rn *_PersonInfo__Repr) Length() int64 { - l := 4 +func (rn *_Tag__Repr) Length() int64 { + l := 5 return int64(l) } -func (_PersonInfo__Repr) IsAbsent() bool { +func (_Tag__Repr) IsAbsent() bool { return false } -func (_PersonInfo__Repr) IsNull() bool { +func (_Tag__Repr) IsNull() bool { return false } -func (_PersonInfo__Repr) AsBool() (bool, error) { - return mixins.Map{TypeName: "ipldgit.PersonInfo.Repr"}.AsBool() +func (_Tag__Repr) AsBool() (bool, error) { + return mixins.Map{TypeName: "ipldgit.Tag.Repr"}.AsBool() } -func (_PersonInfo__Repr) AsInt() (int64, error) { - return mixins.Map{TypeName: "ipldgit.PersonInfo.Repr"}.AsInt() +func (_Tag__Repr) AsInt() (int64, error) { + return mixins.Map{TypeName: "ipldgit.Tag.Repr"}.AsInt() } -func (_PersonInfo__Repr) AsFloat() (float64, error) { - return mixins.Map{TypeName: "ipldgit.PersonInfo.Repr"}.AsFloat() +func (_Tag__Repr) AsFloat() (float64, error) { + return mixins.Map{TypeName: "ipldgit.Tag.Repr"}.AsFloat() } -func (_PersonInfo__Repr) AsString() (string, error) { - return mixins.Map{TypeName: "ipldgit.PersonInfo.Repr"}.AsString() +func (_Tag__Repr) AsString() (string, error) { + return mixins.Map{TypeName: "ipldgit.Tag.Repr"}.AsString() } -func (_PersonInfo__Repr) AsBytes() ([]byte, error) { - return mixins.Map{TypeName: "ipldgit.PersonInfo.Repr"}.AsBytes() +func (_Tag__Repr) AsBytes() ([]byte, error) { + return mixins.Map{TypeName: "ipldgit.Tag.Repr"}.AsBytes() } -func (_PersonInfo__Repr) AsLink() (ipld.Link, error) { - return mixins.Map{TypeName: "ipldgit.PersonInfo.Repr"}.AsLink() +func (_Tag__Repr) AsLink() (ipld.Link, error) { + return mixins.Map{TypeName: "ipldgit.Tag.Repr"}.AsLink() } -func (_PersonInfo__Repr) Prototype() ipld.NodePrototype { - return _PersonInfo__ReprPrototype{} +func (_Tag__Repr) Prototype() ipld.NodePrototype { + return _Tag__ReprPrototype{} } -type _PersonInfo__ReprPrototype struct{} +type _Tag__ReprPrototype struct{} -func (_PersonInfo__ReprPrototype) NewBuilder() ipld.NodeBuilder { - var nb _PersonInfo__ReprBuilder +func (_Tag__ReprPrototype) NewBuilder() ipld.NodeBuilder { + var nb _Tag__ReprBuilder nb.Reset() return &nb } -type _PersonInfo__ReprBuilder struct { - _PersonInfo__ReprAssembler +type _Tag__ReprBuilder struct { + _Tag__ReprAssembler } -func (nb *_PersonInfo__ReprBuilder) Build() ipld.Node { +func (nb *_Tag__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 *_PersonInfo__ReprBuilder) Reset() { - var w _PersonInfo +func (nb *_Tag__ReprBuilder) Reset() { + var w _Tag var m schema.Maybe - *nb = _PersonInfo__ReprBuilder{_PersonInfo__ReprAssembler{w: &w, m: &m}} + *nb = _Tag__ReprBuilder{_Tag__ReprAssembler{w: &w, m: &m}} } -type _PersonInfo__ReprAssembler struct { - w *_PersonInfo +type _Tag__ReprAssembler struct { + w *_Tag m *schema.Maybe state maState s int f int - cm schema.Maybe - ca_date _String__ReprAssembler - ca_timezone _String__ReprAssembler - ca_email _String__ReprAssembler - ca_name _String__ReprAssembler + cm schema.Maybe + ca_object _Link__ReprAssembler + ca_typ _String__ReprAssembler + ca_tag _String__ReprAssembler + ca_tagger _PersonInfo__ReprAssembler + ca_message _String__ReprAssembler } -func (na *_PersonInfo__ReprAssembler) reset() { +func (na *_Tag__ReprAssembler) reset() { na.state = maState_initial na.s = 0 - na.ca_date.reset() - na.ca_timezone.reset() - na.ca_email.reset() - na.ca_name.reset() + na.ca_object.reset() + na.ca_typ.reset() + na.ca_tag.reset() + na.ca_tagger.reset() + na.ca_message.reset() } -func (na *_PersonInfo__ReprAssembler) BeginMap(int64) (ipld.MapAssembler, error) { +func (na *_Tag__ReprAssembler) BeginMap(int64) (ipld.MapAssembler, error) { switch *na.m { case schema.Maybe_Value, schema.Maybe_Null: panic("invalid state: cannot assign into assembler that's already finished") @@ -5158,20 +5726,20 @@ func (na *_PersonInfo__ReprAssembler) BeginMap(int64) (ipld.MapAssembler, error) } *na.m = midvalue if na.w == nil { - na.w = &_PersonInfo{} + na.w = &_Tag{} } return na, nil } -func (_PersonInfo__ReprAssembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { - return mixins.MapAssembler{TypeName: "ipldgit.PersonInfo.Repr"}.BeginList(0) +func (_Tag__ReprAssembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { + return mixins.MapAssembler{TypeName: "ipldgit.Tag.Repr"}.BeginList(0) } -func (na *_PersonInfo__ReprAssembler) AssignNull() error { +func (na *_Tag__ReprAssembler) AssignNull() error { switch *na.m { case allowNull: *na.m = schema.Maybe_Null return nil case schema.Maybe_Absent: - return mixins.MapAssembler{TypeName: "ipldgit.PersonInfo.Repr.Repr"}.AssignNull() + return mixins.MapAssembler{TypeName: "ipldgit.Tag.Repr.Repr"}.AssignNull() case schema.Maybe_Value, schema.Maybe_Null: panic("invalid state: cannot assign into assembler that's already finished") case midvalue: @@ -5179,29 +5747,29 @@ func (na *_PersonInfo__ReprAssembler) AssignNull() error { } panic("unreachable") } -func (_PersonInfo__ReprAssembler) AssignBool(bool) error { - return mixins.MapAssembler{TypeName: "ipldgit.PersonInfo.Repr"}.AssignBool(false) +func (_Tag__ReprAssembler) AssignBool(bool) error { + return mixins.MapAssembler{TypeName: "ipldgit.Tag.Repr"}.AssignBool(false) } -func (_PersonInfo__ReprAssembler) AssignInt(int64) error { - return mixins.MapAssembler{TypeName: "ipldgit.PersonInfo.Repr"}.AssignInt(0) +func (_Tag__ReprAssembler) AssignInt(int64) error { + return mixins.MapAssembler{TypeName: "ipldgit.Tag.Repr"}.AssignInt(0) } -func (_PersonInfo__ReprAssembler) AssignFloat(float64) error { - return mixins.MapAssembler{TypeName: "ipldgit.PersonInfo.Repr"}.AssignFloat(0) +func (_Tag__ReprAssembler) AssignFloat(float64) error { + return mixins.MapAssembler{TypeName: "ipldgit.Tag.Repr"}.AssignFloat(0) } -func (_PersonInfo__ReprAssembler) AssignString(string) error { - return mixins.MapAssembler{TypeName: "ipldgit.PersonInfo.Repr"}.AssignString("") +func (_Tag__ReprAssembler) AssignString(string) error { + return mixins.MapAssembler{TypeName: "ipldgit.Tag.Repr"}.AssignString("") } -func (_PersonInfo__ReprAssembler) AssignBytes([]byte) error { - return mixins.MapAssembler{TypeName: "ipldgit.PersonInfo.Repr"}.AssignBytes(nil) +func (_Tag__ReprAssembler) AssignBytes([]byte) error { + return mixins.MapAssembler{TypeName: "ipldgit.Tag.Repr"}.AssignBytes(nil) } -func (_PersonInfo__ReprAssembler) AssignLink(ipld.Link) error { - return mixins.MapAssembler{TypeName: "ipldgit.PersonInfo.Repr"}.AssignLink(nil) +func (_Tag__ReprAssembler) AssignLink(ipld.Link) error { + return mixins.MapAssembler{TypeName: "ipldgit.Tag.Repr"}.AssignLink(nil) } -func (na *_PersonInfo__ReprAssembler) AssignNode(v ipld.Node) error { +func (na *_Tag__ReprAssembler) AssignNode(v ipld.Node) error { if v.IsNull() { return na.AssignNull() } - if v2, ok := v.(*_PersonInfo); ok { + if v2, ok := v.(*_Tag); ok { switch *na.m { case schema.Maybe_Value, schema.Maybe_Null: panic("invalid state: cannot assign into assembler that's already finished") @@ -5218,7 +5786,7 @@ func (na *_PersonInfo__ReprAssembler) AssignNode(v ipld.Node) error { return nil } if v.Kind() != ipld.Kind_Map { - return ipld.ErrWrongKind{TypeName: "ipldgit.PersonInfo.Repr", MethodName: "AssignNode", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()} + return ipld.ErrWrongKind{TypeName: "ipldgit.Tag.Repr", MethodName: "AssignNode", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()} } itr := v.MapIterator() for !itr.Done() { @@ -5235,10 +5803,10 @@ func (na *_PersonInfo__ReprAssembler) AssignNode(v ipld.Node) error { } return na.Finish() } -func (_PersonInfo__ReprAssembler) Prototype() ipld.NodePrototype { - return _PersonInfo__ReprPrototype{} +func (_Tag__ReprAssembler) Prototype() ipld.NodePrototype { + return _Tag__ReprPrototype{} } -func (ma *_PersonInfo__ReprAssembler) valueFinishTidy() bool { +func (ma *_Tag__ReprAssembler) valueFinishTidy() bool { switch ma.f { case 0: switch ma.cm { @@ -5276,11 +5844,20 @@ func (ma *_PersonInfo__ReprAssembler) valueFinishTidy() bool { default: return false } + case 4: + switch ma.cm { + case schema.Maybe_Value: + ma.cm = schema.Maybe_Absent + ma.state = maState_initial + return true + default: + return false + } default: panic("unreachable") } } -func (ma *_PersonInfo__ReprAssembler) AssembleEntry(k string) (ipld.NodeAssembler, error) { +func (ma *_Tag__ReprAssembler) AssembleEntry(k string) (ipld.NodeAssembler, error) { switch ma.state { case maState_initial: // carry on @@ -5296,51 +5873,61 @@ func (ma *_PersonInfo__ReprAssembler) AssembleEntry(k string) (ipld.NodeAssemble panic("invalid state: AssembleEntry cannot be called on an assembler that's already finished") } switch k { - case "date": - if ma.s&fieldBit__PersonInfo_Date != 0 { - return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Date_serial} + case "object": + if ma.s&fieldBit__Tag_Object != 0 { + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Object_serial} } - ma.s += fieldBit__PersonInfo_Date + ma.s += fieldBit__Tag_Object ma.state = maState_midValue ma.f = 0 - ma.ca_date.w = &ma.w.date - ma.ca_date.m = &ma.cm - return &ma.ca_date, nil - case "timezone": - if ma.s&fieldBit__PersonInfo_Timezone != 0 { - return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Timezone_serial} + ma.ca_object.w = &ma.w.object + ma.ca_object.m = &ma.cm + return &ma.ca_object, nil + case "type": + if ma.s&fieldBit__Tag_Type != 0 { + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Type_serial} } - ma.s += fieldBit__PersonInfo_Timezone + ma.s += fieldBit__Tag_Type ma.state = maState_midValue ma.f = 1 - ma.ca_timezone.w = &ma.w.timezone - ma.ca_timezone.m = &ma.cm - return &ma.ca_timezone, nil - case "email": - if ma.s&fieldBit__PersonInfo_Email != 0 { - return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Email_serial} + ma.ca_typ.w = &ma.w.typ + ma.ca_typ.m = &ma.cm + return &ma.ca_typ, nil + case "tag": + if ma.s&fieldBit__Tag_Tag != 0 { + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Tag_serial} } - ma.s += fieldBit__PersonInfo_Email + ma.s += fieldBit__Tag_Tag ma.state = maState_midValue ma.f = 2 - ma.ca_email.w = &ma.w.email - ma.ca_email.m = &ma.cm - return &ma.ca_email, nil - case "name": - if ma.s&fieldBit__PersonInfo_Name != 0 { - return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Name_serial} + ma.ca_tag.w = &ma.w.tag + ma.ca_tag.m = &ma.cm + return &ma.ca_tag, nil + case "tagger": + if ma.s&fieldBit__Tag_Tagger != 0 { + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Tagger_serial} } - ma.s += fieldBit__PersonInfo_Name + ma.s += fieldBit__Tag_Tagger ma.state = maState_midValue ma.f = 3 - ma.ca_name.w = &ma.w.name - ma.ca_name.m = &ma.cm - return &ma.ca_name, nil + ma.ca_tagger.w = &ma.w.tagger + ma.ca_tagger.m = &ma.cm + return &ma.ca_tagger, nil + case "message": + if ma.s&fieldBit__Tag_Message != 0 { + return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Message_serial} + } + ma.s += fieldBit__Tag_Message + ma.state = maState_midValue + ma.f = 4 + ma.ca_message.w = &ma.w.message + ma.ca_message.m = &ma.cm + return &ma.ca_message, nil default: } - return nil, ipld.ErrInvalidKey{TypeName: "ipldgit.PersonInfo.Repr", Key: &_String{k}} + return nil, ipld.ErrInvalidKey{TypeName: "ipldgit.Tag.Repr", Key: &_String{k}} } -func (ma *_PersonInfo__ReprAssembler) AssembleKey() ipld.NodeAssembler { +func (ma *_Tag__ReprAssembler) AssembleKey() ipld.NodeAssembler { switch ma.state { case maState_initial: // carry on @@ -5356,9 +5943,9 @@ func (ma *_PersonInfo__ReprAssembler) AssembleKey() ipld.NodeAssembler { panic("invalid state: AssembleKey cannot be called on an assembler that's already finished") } ma.state = maState_midKey - return (*_PersonInfo__ReprKeyAssembler)(ma) + return (*_Tag__ReprKeyAssembler)(ma) } -func (ma *_PersonInfo__ReprAssembler) AssembleValue() ipld.NodeAssembler { +func (ma *_Tag__ReprAssembler) AssembleValue() ipld.NodeAssembler { switch ma.state { case maState_initial: panic("invalid state: AssembleValue cannot be called when no key is primed") @@ -5374,26 +5961,30 @@ func (ma *_PersonInfo__ReprAssembler) AssembleValue() ipld.NodeAssembler { ma.state = maState_midValue switch ma.f { case 0: - ma.ca_date.w = &ma.w.date - ma.ca_date.m = &ma.cm - return &ma.ca_date + ma.ca_object.w = &ma.w.object + ma.ca_object.m = &ma.cm + return &ma.ca_object case 1: - ma.ca_timezone.w = &ma.w.timezone - ma.ca_timezone.m = &ma.cm - return &ma.ca_timezone + ma.ca_typ.w = &ma.w.typ + ma.ca_typ.m = &ma.cm + return &ma.ca_typ case 2: - ma.ca_email.w = &ma.w.email - ma.ca_email.m = &ma.cm - return &ma.ca_email + ma.ca_tag.w = &ma.w.tag + ma.ca_tag.m = &ma.cm + return &ma.ca_tag case 3: - ma.ca_name.w = &ma.w.name - ma.ca_name.m = &ma.cm - return &ma.ca_name + ma.ca_tagger.w = &ma.w.tagger + ma.ca_tagger.m = &ma.cm + return &ma.ca_tagger + case 4: + ma.ca_message.w = &ma.w.message + ma.ca_message.m = &ma.cm + return &ma.ca_message default: panic("unreachable") } } -func (ma *_PersonInfo__ReprAssembler) Finish() error { +func (ma *_Tag__ReprAssembler) Finish() error { switch ma.state { case maState_initial: // carry on @@ -5408,19 +5999,22 @@ func (ma *_PersonInfo__ReprAssembler) Finish() error { case maState_finished: panic("invalid state: Finish cannot be called on an assembler that's already finished") } - if ma.s&fieldBits__PersonInfo_sufficient != fieldBits__PersonInfo_sufficient { + if ma.s&fieldBits__Tag_sufficient != fieldBits__Tag_sufficient { err := ipld.ErrMissingRequiredField{Missing: make([]string, 0)} - if ma.s&fieldBit__PersonInfo_Date == 0 { - err.Missing = append(err.Missing, "date") + if ma.s&fieldBit__Tag_Object == 0 { + err.Missing = append(err.Missing, "object") } - if ma.s&fieldBit__PersonInfo_Timezone == 0 { - err.Missing = append(err.Missing, "timezone") + if ma.s&fieldBit__Tag_Type == 0 { + err.Missing = append(err.Missing, "type") } - if ma.s&fieldBit__PersonInfo_Email == 0 { - err.Missing = append(err.Missing, "email") + if ma.s&fieldBit__Tag_Tag == 0 { + err.Missing = append(err.Missing, "tag") } - if ma.s&fieldBit__PersonInfo_Name == 0 { - err.Missing = append(err.Missing, "name") + if ma.s&fieldBit__Tag_Tagger == 0 { + err.Missing = append(err.Missing, "tagger") + } + if ma.s&fieldBit__Tag_Message == 0 { + err.Missing = append(err.Missing, "message") } return err } @@ -5428,118 +6022,156 @@ func (ma *_PersonInfo__ReprAssembler) Finish() error { *ma.m = schema.Maybe_Value return nil } -func (ma *_PersonInfo__ReprAssembler) KeyPrototype() ipld.NodePrototype { +func (ma *_Tag__ReprAssembler) KeyPrototype() ipld.NodePrototype { return _String__Prototype{} } -func (ma *_PersonInfo__ReprAssembler) ValuePrototype(k string) ipld.NodePrototype { +func (ma *_Tag__ReprAssembler) ValuePrototype(k string) ipld.NodePrototype { panic("todo structbuilder mapassembler repr valueprototype") } -type _PersonInfo__ReprKeyAssembler _PersonInfo__ReprAssembler +type _Tag__ReprKeyAssembler _Tag__ReprAssembler -func (_PersonInfo__ReprKeyAssembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { - return mixins.StringAssembler{TypeName: "ipldgit.PersonInfo.Repr.KeyAssembler"}.BeginMap(0) +func (_Tag__ReprKeyAssembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { + return mixins.StringAssembler{TypeName: "ipldgit.Tag.Repr.KeyAssembler"}.BeginMap(0) } -func (_PersonInfo__ReprKeyAssembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { - return mixins.StringAssembler{TypeName: "ipldgit.PersonInfo.Repr.KeyAssembler"}.BeginList(0) +func (_Tag__ReprKeyAssembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { + return mixins.StringAssembler{TypeName: "ipldgit.Tag.Repr.KeyAssembler"}.BeginList(0) } -func (na *_PersonInfo__ReprKeyAssembler) AssignNull() error { - return mixins.StringAssembler{TypeName: "ipldgit.PersonInfo.Repr.KeyAssembler"}.AssignNull() +func (na *_Tag__ReprKeyAssembler) AssignNull() error { + return mixins.StringAssembler{TypeName: "ipldgit.Tag.Repr.KeyAssembler"}.AssignNull() } -func (_PersonInfo__ReprKeyAssembler) AssignBool(bool) error { - return mixins.StringAssembler{TypeName: "ipldgit.PersonInfo.Repr.KeyAssembler"}.AssignBool(false) +func (_Tag__ReprKeyAssembler) AssignBool(bool) error { + return mixins.StringAssembler{TypeName: "ipldgit.Tag.Repr.KeyAssembler"}.AssignBool(false) } -func (_PersonInfo__ReprKeyAssembler) AssignInt(int64) error { - return mixins.StringAssembler{TypeName: "ipldgit.PersonInfo.Repr.KeyAssembler"}.AssignInt(0) +func (_Tag__ReprKeyAssembler) AssignInt(int64) error { + return mixins.StringAssembler{TypeName: "ipldgit.Tag.Repr.KeyAssembler"}.AssignInt(0) } -func (_PersonInfo__ReprKeyAssembler) AssignFloat(float64) error { - return mixins.StringAssembler{TypeName: "ipldgit.PersonInfo.Repr.KeyAssembler"}.AssignFloat(0) +func (_Tag__ReprKeyAssembler) AssignFloat(float64) error { + return mixins.StringAssembler{TypeName: "ipldgit.Tag.Repr.KeyAssembler"}.AssignFloat(0) } -func (ka *_PersonInfo__ReprKeyAssembler) AssignString(k string) error { +func (ka *_Tag__ReprKeyAssembler) AssignString(k string) error { if ka.state != maState_midKey { panic("misuse: KeyAssembler held beyond its valid lifetime") } switch k { - case "date": - if ka.s&fieldBit__PersonInfo_Date != 0 { - return ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Date_serial} + case "object": + if ka.s&fieldBit__Tag_Object != 0 { + return ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Object_serial} } - ka.s += fieldBit__PersonInfo_Date + ka.s += fieldBit__Tag_Object ka.state = maState_expectValue ka.f = 0 return nil - case "timezone": - if ka.s&fieldBit__PersonInfo_Timezone != 0 { - return ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Timezone_serial} + case "type": + if ka.s&fieldBit__Tag_Type != 0 { + return ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Type_serial} } - ka.s += fieldBit__PersonInfo_Timezone + ka.s += fieldBit__Tag_Type ka.state = maState_expectValue ka.f = 1 return nil - case "email": - if ka.s&fieldBit__PersonInfo_Email != 0 { - return ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Email_serial} + case "tag": + if ka.s&fieldBit__Tag_Tag != 0 { + return ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Tag_serial} } - ka.s += fieldBit__PersonInfo_Email + ka.s += fieldBit__Tag_Tag ka.state = maState_expectValue ka.f = 2 return nil - case "name": - if ka.s&fieldBit__PersonInfo_Name != 0 { - return ipld.ErrRepeatedMapKey{Key: &fieldName__PersonInfo_Name_serial} + case "tagger": + if ka.s&fieldBit__Tag_Tagger != 0 { + return ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Tagger_serial} } - ka.s += fieldBit__PersonInfo_Name + ka.s += fieldBit__Tag_Tagger ka.state = maState_expectValue ka.f = 3 return nil + case "message": + if ka.s&fieldBit__Tag_Message != 0 { + return ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Message_serial} + } + ka.s += fieldBit__Tag_Message + ka.state = maState_expectValue + ka.f = 4 + return nil } - return ipld.ErrInvalidKey{TypeName: "ipldgit.PersonInfo.Repr", Key: &_String{k}} + return ipld.ErrInvalidKey{TypeName: "ipldgit.Tag.Repr", Key: &_String{k}} } -func (_PersonInfo__ReprKeyAssembler) AssignBytes([]byte) error { - return mixins.StringAssembler{TypeName: "ipldgit.PersonInfo.Repr.KeyAssembler"}.AssignBytes(nil) +func (_Tag__ReprKeyAssembler) AssignBytes([]byte) error { + return mixins.StringAssembler{TypeName: "ipldgit.Tag.Repr.KeyAssembler"}.AssignBytes(nil) } -func (_PersonInfo__ReprKeyAssembler) AssignLink(ipld.Link) error { - return mixins.StringAssembler{TypeName: "ipldgit.PersonInfo.Repr.KeyAssembler"}.AssignLink(nil) +func (_Tag__ReprKeyAssembler) AssignLink(ipld.Link) error { + return mixins.StringAssembler{TypeName: "ipldgit.Tag.Repr.KeyAssembler"}.AssignLink(nil) } -func (ka *_PersonInfo__ReprKeyAssembler) AssignNode(v ipld.Node) error { +func (ka *_Tag__ReprKeyAssembler) AssignNode(v ipld.Node) error { if v2, err := v.AsString(); err != nil { return err } else { return ka.AssignString(v2) } } -func (_PersonInfo__ReprKeyAssembler) Prototype() ipld.NodePrototype { +func (_Tag__ReprKeyAssembler) Prototype() ipld.NodePrototype { return _String__Prototype{} } -func (n String) String() string { - return n.x +func (n *_Tag_List) Lookup(idx int64) Tag { + if n.Length() <= idx { + return nil + } + v := &n.x[idx] + return v } -func (_String__Prototype) fromString(w *_String, v string) error { - *w = _String{v} - return nil +func (n *_Tag_List) LookupMaybe(idx int64) MaybeTag { + if n.Length() <= idx { + return nil + } + v := &n.x[idx] + return &_Tag__Maybe{ + m: schema.Maybe_Value, + v: v, + } } -func (_String__Prototype) FromString(v string) (String, error) { - n := _String{v} - return &n, nil + +var _Tag_List__valueAbsent = _Tag__Maybe{m: schema.Maybe_Absent} + +func (n Tag_List) Iterator() *Tag_List__Itr { + return &Tag_List__Itr{n, 0} } -type _String__Maybe struct { +type Tag_List__Itr struct { + n Tag_List + idx int +} + +func (itr *Tag_List__Itr) Next() (idx int64, v Tag) { + if itr.idx >= len(itr.n.x) { + return -1, nil + } + idx = int64(itr.idx) + v = &itr.n.x[itr.idx] + itr.idx++ + return +} +func (itr *Tag_List__Itr) Done() bool { + return itr.idx >= len(itr.n.x) +} + +type _Tag_List__Maybe struct { m schema.Maybe - v _String + v _Tag_List } -type MaybeString = *_String__Maybe +type MaybeTag_List = *_Tag_List__Maybe -func (m MaybeString) IsNull() bool { +func (m MaybeTag_List) IsNull() bool { return m.m == schema.Maybe_Null } -func (m MaybeString) IsAbsent() bool { +func (m MaybeTag_List) IsAbsent() bool { return m.m == schema.Maybe_Absent } -func (m MaybeString) Exists() bool { +func (m MaybeTag_List) Exists() bool { return m.m == schema.Maybe_Value } -func (m MaybeString) AsNode() ipld.Node { +func (m MaybeTag_List) AsNode() ipld.Node { switch m.m { case schema.Maybe_Absent: return ipld.Absent @@ -5551,400 +6183,399 @@ func (m MaybeString) AsNode() ipld.Node { panic("unreachable") } } -func (m MaybeString) Must() String { +func (m MaybeTag_List) Must() Tag_List { if !m.Exists() { panic("unbox of a maybe rejected") } return &m.v } -var _ ipld.Node = (String)(&_String{}) -var _ schema.TypedNode = (String)(&_String{}) +var _ ipld.Node = (Tag_List)(&_Tag_List{}) +var _ schema.TypedNode = (Tag_List)(&_Tag_List{}) -func (String) Kind() ipld.Kind { - return ipld.Kind_String +func (Tag_List) Kind() ipld.Kind { + return ipld.Kind_List } -func (String) LookupByString(string) (ipld.Node, error) { - return mixins.String{TypeName: "ipldgit.String"}.LookupByString("") +func (Tag_List) LookupByString(string) (ipld.Node, error) { + return mixins.List{TypeName: "ipldgit.Tag_List"}.LookupByString("") } -func (String) LookupByNode(ipld.Node) (ipld.Node, error) { - return mixins.String{TypeName: "ipldgit.String"}.LookupByNode(nil) +func (n Tag_List) LookupByNode(k ipld.Node) (ipld.Node, error) { + idx, err := k.AsInt() + if err != nil { + return nil, err + } + return n.LookupByIndex(idx) } -func (String) LookupByIndex(idx int64) (ipld.Node, error) { - return mixins.String{TypeName: "ipldgit.String"}.LookupByIndex(0) +func (n Tag_List) LookupByIndex(idx int64) (ipld.Node, error) { + if n.Length() <= idx { + return nil, ipld.ErrNotExists{Segment: ipld.PathSegmentOfInt(idx)} + } + v := &n.x[idx] + return v, nil } -func (String) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { - return mixins.String{TypeName: "ipldgit.String"}.LookupBySegment(seg) +func (n Tag_List) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { + i, err := seg.Index() + if err != nil { + return nil, ipld.ErrInvalidSegmentForList{TypeName: "ipldgit.Tag_List", TroubleSegment: seg, Reason: err} + } + return n.LookupByIndex(i) } -func (String) MapIterator() ipld.MapIterator { +func (Tag_List) MapIterator() ipld.MapIterator { return nil } -func (String) ListIterator() ipld.ListIterator { - return nil +func (n Tag_List) ListIterator() ipld.ListIterator { + return &_Tag_List__ListItr{n, 0} } -func (String) Length() int64 { - return -1 + +type _Tag_List__ListItr struct { + n Tag_List + idx int } -func (String) IsAbsent() bool { + +func (itr *_Tag_List__ListItr) Next() (idx int64, v ipld.Node, _ error) { + if itr.idx >= len(itr.n.x) { + return -1, nil, ipld.ErrIteratorOverread{} + } + idx = int64(itr.idx) + x := &itr.n.x[itr.idx] + v = x + itr.idx++ + return +} +func (itr *_Tag_List__ListItr) Done() bool { + return itr.idx >= len(itr.n.x) +} + +func (n Tag_List) Length() int64 { + return int64(len(n.x)) +} +func (Tag_List) IsAbsent() bool { return false } -func (String) IsNull() bool { +func (Tag_List) IsNull() bool { return false } -func (String) AsBool() (bool, error) { - return mixins.String{TypeName: "ipldgit.String"}.AsBool() +func (Tag_List) AsBool() (bool, error) { + return mixins.List{TypeName: "ipldgit.Tag_List"}.AsBool() } -func (String) AsInt() (int64, error) { - return mixins.String{TypeName: "ipldgit.String"}.AsInt() +func (Tag_List) AsInt() (int64, error) { + return mixins.List{TypeName: "ipldgit.Tag_List"}.AsInt() } -func (String) AsFloat() (float64, error) { - return mixins.String{TypeName: "ipldgit.String"}.AsFloat() +func (Tag_List) AsFloat() (float64, error) { + return mixins.List{TypeName: "ipldgit.Tag_List"}.AsFloat() } -func (n String) AsString() (string, error) { - return n.x, nil +func (Tag_List) AsString() (string, error) { + return mixins.List{TypeName: "ipldgit.Tag_List"}.AsString() } -func (String) AsBytes() ([]byte, error) { - return mixins.String{TypeName: "ipldgit.String"}.AsBytes() +func (Tag_List) AsBytes() ([]byte, error) { + return mixins.List{TypeName: "ipldgit.Tag_List"}.AsBytes() } -func (String) AsLink() (ipld.Link, error) { - return mixins.String{TypeName: "ipldgit.String"}.AsLink() +func (Tag_List) AsLink() (ipld.Link, error) { + return mixins.List{TypeName: "ipldgit.Tag_List"}.AsLink() } -func (String) Prototype() ipld.NodePrototype { - return _String__Prototype{} +func (Tag_List) Prototype() ipld.NodePrototype { + return _Tag_List__Prototype{} } -type _String__Prototype struct{} +type _Tag_List__Prototype struct{} -func (_String__Prototype) NewBuilder() ipld.NodeBuilder { - var nb _String__Builder +func (_Tag_List__Prototype) NewBuilder() ipld.NodeBuilder { + var nb _Tag_List__Builder nb.Reset() return &nb } -type _String__Builder struct { - _String__Assembler +type _Tag_List__Builder struct { + _Tag_List__Assembler } -func (nb *_String__Builder) Build() ipld.Node { +func (nb *_Tag_List__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 +func (nb *_Tag_List__Builder) Reset() { + var w _Tag_List var m schema.Maybe - *nb = _String__Builder{_String__Assembler{w: &w, m: &m}} + *nb = _Tag_List__Builder{_Tag_List__Assembler{w: &w, m: &m}} } -type _String__Assembler struct { - w *_String - m *schema.Maybe +type _Tag_List__Assembler struct { + w *_Tag_List + m *schema.Maybe + state laState + + cm schema.Maybe + va _Tag__Assembler } -func (na *_String__Assembler) reset() {} -func (_String__Assembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { - return mixins.StringAssembler{TypeName: "ipldgit.String"}.BeginMap(0) +func (na *_Tag_List__Assembler) reset() { + na.state = laState_initial + na.va.reset() } -func (_String__Assembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { - return mixins.StringAssembler{TypeName: "ipldgit.String"}.BeginList(0) +func (_Tag_List__Assembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { + return mixins.ListAssembler{TypeName: "ipldgit.Tag_List"}.BeginMap(0) } -func (na *_String__Assembler) AssignNull() error { +func (na *_Tag_List__Assembler) BeginList(sizeHint int64) (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 sizeHint > 0 { + na.w.x = make([]_Tag, 0, sizeHint) + } + return na, nil +} +func (na *_Tag_List__Assembler) AssignNull() error { switch *na.m { case allowNull: *na.m = schema.Maybe_Null return nil case schema.Maybe_Absent: - return mixins.StringAssembler{TypeName: "ipldgit.String"}.AssignNull() + return mixins.ListAssembler{TypeName: "ipldgit.Tag_List"}.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 (_String__Assembler) AssignBool(bool) error { - return mixins.StringAssembler{TypeName: "ipldgit.String"}.AssignBool(false) +func (_Tag_List__Assembler) AssignBool(bool) error { + return mixins.ListAssembler{TypeName: "ipldgit.Tag_List"}.AssignBool(false) } -func (_String__Assembler) AssignInt(int64) error { - return mixins.StringAssembler{TypeName: "ipldgit.String"}.AssignInt(0) +func (_Tag_List__Assembler) AssignInt(int64) error { + return mixins.ListAssembler{TypeName: "ipldgit.Tag_List"}.AssignInt(0) } -func (_String__Assembler) AssignFloat(float64) error { - return mixins.StringAssembler{TypeName: "ipldgit.String"}.AssignFloat(0) +func (_Tag_List__Assembler) AssignFloat(float64) error { + return mixins.ListAssembler{TypeName: "ipldgit.Tag_List"}.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") - } - na.w.x = v - *na.m = schema.Maybe_Value - return nil +func (_Tag_List__Assembler) AssignString(string) error { + return mixins.ListAssembler{TypeName: "ipldgit.Tag_List"}.AssignString("") } -func (_String__Assembler) AssignBytes([]byte) error { - return mixins.StringAssembler{TypeName: "ipldgit.String"}.AssignBytes(nil) +func (_Tag_List__Assembler) AssignBytes([]byte) error { + return mixins.ListAssembler{TypeName: "ipldgit.Tag_List"}.AssignBytes(nil) } -func (_String__Assembler) AssignLink(ipld.Link) error { - return mixins.StringAssembler{TypeName: "ipldgit.String"}.AssignLink(nil) +func (_Tag_List__Assembler) AssignLink(ipld.Link) error { + return mixins.ListAssembler{TypeName: "ipldgit.Tag_List"}.AssignLink(nil) } -func (na *_String__Assembler) AssignNode(v ipld.Node) error { +func (na *_Tag_List__Assembler) AssignNode(v ipld.Node) error { if v.IsNull() { return na.AssignNull() } - if v2, ok := v.(*_String); ok { + if v2, ok := v.(*_Tag_List); 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!") } *na.w = *v2 *na.m = schema.Maybe_Value return nil } - if v2, err := v.AsString(); err != nil { - return err - } else { - return na.AssignString(v2) + if v.Kind() != ipld.Kind_List { + return ipld.ErrWrongKind{TypeName: "ipldgit.Tag_List", MethodName: "AssignNode", AppropriateKind: ipld.KindSet_JustList, ActualKind: v.Kind()} } + 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 (_String__Assembler) Prototype() ipld.NodePrototype { - return _String__Prototype{} -} -func (String) Type() schema.Type { - return nil /*TODO:typelit*/ +func (_Tag_List__Assembler) Prototype() ipld.NodePrototype { + return _Tag_List__Prototype{} } -func (n String) Representation() ipld.Node { - return (*_String__Repr)(n) +func (la *_Tag_List__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 + } } - -type _String__Repr = _String - -var _ ipld.Node = &_String__Repr{} - -type _String__ReprPrototype = _String__Prototype -type _String__ReprAssembler = _String__Assembler - -func (n _Tag) FieldMessage() String { - return &n.message +func (la *_Tag_List__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, _Tag{}) + 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 (n _Tag) FieldObject() Link { - return &n.object +func (la *_Tag_List__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 (n _Tag) FieldTag() String { - return &n.tag +func (la *_Tag_List__Assembler) ValuePrototype(_ int64) ipld.NodePrototype { + return _Tag__Prototype{} } -func (n _Tag) FieldTagger() PersonInfo { - return &n.tagger +func (Tag_List) Type() schema.Type { + return nil /*TODO:typelit*/ } -func (n _Tag) FieldTagType() String { - return &n.tagType +func (n Tag_List) Representation() ipld.Node { + return (*_Tag_List__Repr)(n) } -type _Tag__Maybe struct { - m schema.Maybe - v Tag -} -type MaybeTag = *_Tag__Maybe +type _Tag_List__Repr _Tag_List -func (m MaybeTag) IsNull() bool { - return m.m == schema.Maybe_Null -} -func (m MaybeTag) IsAbsent() bool { - return m.m == schema.Maybe_Absent -} -func (m MaybeTag) Exists() bool { - return m.m == schema.Maybe_Value +var _ ipld.Node = &_Tag_List__Repr{} + +func (_Tag_List__Repr) Kind() ipld.Kind { + return ipld.Kind_List } -func (m MaybeTag) 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 (_Tag_List__Repr) LookupByString(string) (ipld.Node, error) { + return mixins.List{TypeName: "ipldgit.Tag_List.Repr"}.LookupByString("") } -func (m MaybeTag) Must() Tag { - if !m.Exists() { - panic("unbox of a maybe rejected") +func (nr *_Tag_List__Repr) LookupByNode(k ipld.Node) (ipld.Node, error) { + v, err := (Tag_List)(nr).LookupByNode(k) + if err != nil || v == ipld.Null { + return v, err } - return m.v -} - -var ( - fieldName__Tag_Message = _String{"message"} - fieldName__Tag_Object = _String{"object"} - fieldName__Tag_Tag = _String{"tag"} - fieldName__Tag_Tagger = _String{"tagger"} - fieldName__Tag_TagType = _String{"tagType"} -) -var _ ipld.Node = (Tag)(&_Tag{}) -var _ schema.TypedNode = (Tag)(&_Tag{}) - -func (Tag) Kind() ipld.Kind { - return ipld.Kind_Map + return v.(Tag).Representation(), nil } -func (n Tag) LookupByString(key string) (ipld.Node, error) { - switch key { - case "message": - return &n.message, nil - case "object": - return &n.object, nil - case "tag": - return &n.tag, nil - case "tagger": - return &n.tagger, nil - case "tagType": - return &n.tagType, nil - default: - return nil, schema.ErrNoSuchField{Type: nil /*TODO*/, Field: ipld.PathSegmentOfString(key)} +func (nr *_Tag_List__Repr) LookupByIndex(idx int64) (ipld.Node, error) { + v, err := (Tag_List)(nr).LookupByIndex(idx) + if err != nil || v == ipld.Null { + return v, err } + return v.(Tag).Representation(), nil } -func (n Tag) LookupByNode(key ipld.Node) (ipld.Node, error) { - ks, err := key.AsString() +func (n _Tag_List__Repr) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { + i, err := seg.Index() if err != nil { - return nil, err + return nil, ipld.ErrInvalidSegmentForList{TypeName: "ipldgit.Tag_List.Repr", TroubleSegment: seg, Reason: err} } - return n.LookupByString(ks) -} -func (Tag) LookupByIndex(idx int64) (ipld.Node, error) { - return mixins.Map{TypeName: "ipldgit.Tag"}.LookupByIndex(0) + return n.LookupByIndex(i) } -func (n Tag) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { - return n.LookupByString(seg.String()) +func (_Tag_List__Repr) MapIterator() ipld.MapIterator { + return nil } -func (n Tag) MapIterator() ipld.MapIterator { - return &_Tag__MapItr{n, 0} +func (nr *_Tag_List__Repr) ListIterator() ipld.ListIterator { + return &_Tag_List__ReprListItr{(Tag_List)(nr), 0} } -type _Tag__MapItr struct { - n Tag - idx int -} +type _Tag_List__ReprListItr _Tag_List__ListItr -func (itr *_Tag__MapItr) Next() (k ipld.Node, v ipld.Node, _ error) { - if itr.idx >= 5 { - return nil, nil, ipld.ErrIteratorOverread{} - } - switch itr.idx { - case 0: - k = &fieldName__Tag_Message - v = &itr.n.message - case 1: - k = &fieldName__Tag_Object - v = &itr.n.object - case 2: - k = &fieldName__Tag_Tag - v = &itr.n.tag - case 3: - k = &fieldName__Tag_Tagger - v = &itr.n.tagger - case 4: - k = &fieldName__Tag_TagType - v = &itr.n.tagType - default: - panic("unreachable") +func (itr *_Tag_List__ReprListItr) Next() (idx int64, v ipld.Node, err error) { + idx, v, err = (*_Tag_List__ListItr)(itr).Next() + if err != nil || v == ipld.Null { + return } - itr.idx++ - return + return idx, v.(Tag).Representation(), nil } -func (itr *_Tag__MapItr) Done() bool { - return itr.idx >= 5 +func (itr *_Tag_List__ReprListItr) Done() bool { + return (*_Tag_List__ListItr)(itr).Done() } -func (Tag) ListIterator() ipld.ListIterator { - return nil -} -func (Tag) Length() int64 { - return 5 +func (rn *_Tag_List__Repr) Length() int64 { + return int64(len(rn.x)) } -func (Tag) IsAbsent() bool { +func (_Tag_List__Repr) IsAbsent() bool { return false } -func (Tag) IsNull() bool { +func (_Tag_List__Repr) IsNull() bool { return false } -func (Tag) AsBool() (bool, error) { - return mixins.Map{TypeName: "ipldgit.Tag"}.AsBool() +func (_Tag_List__Repr) AsBool() (bool, error) { + return mixins.List{TypeName: "ipldgit.Tag_List.Repr"}.AsBool() } -func (Tag) AsInt() (int64, error) { - return mixins.Map{TypeName: "ipldgit.Tag"}.AsInt() +func (_Tag_List__Repr) AsInt() (int64, error) { + return mixins.List{TypeName: "ipldgit.Tag_List.Repr"}.AsInt() } -func (Tag) AsFloat() (float64, error) { - return mixins.Map{TypeName: "ipldgit.Tag"}.AsFloat() +func (_Tag_List__Repr) AsFloat() (float64, error) { + return mixins.List{TypeName: "ipldgit.Tag_List.Repr"}.AsFloat() } -func (Tag) AsString() (string, error) { - return mixins.Map{TypeName: "ipldgit.Tag"}.AsString() +func (_Tag_List__Repr) AsString() (string, error) { + return mixins.List{TypeName: "ipldgit.Tag_List.Repr"}.AsString() } -func (Tag) AsBytes() ([]byte, error) { - return mixins.Map{TypeName: "ipldgit.Tag"}.AsBytes() +func (_Tag_List__Repr) AsBytes() ([]byte, error) { + return mixins.List{TypeName: "ipldgit.Tag_List.Repr"}.AsBytes() } -func (Tag) AsLink() (ipld.Link, error) { - return mixins.Map{TypeName: "ipldgit.Tag"}.AsLink() +func (_Tag_List__Repr) AsLink() (ipld.Link, error) { + return mixins.List{TypeName: "ipldgit.Tag_List.Repr"}.AsLink() } -func (Tag) Prototype() ipld.NodePrototype { - return _Tag__Prototype{} +func (_Tag_List__Repr) Prototype() ipld.NodePrototype { + return _Tag_List__ReprPrototype{} } -type _Tag__Prototype struct{} +type _Tag_List__ReprPrototype struct{} -func (_Tag__Prototype) NewBuilder() ipld.NodeBuilder { - var nb _Tag__Builder +func (_Tag_List__ReprPrototype) NewBuilder() ipld.NodeBuilder { + var nb _Tag_List__ReprBuilder nb.Reset() return &nb } -type _Tag__Builder struct { - _Tag__Assembler +type _Tag_List__ReprBuilder struct { + _Tag_List__ReprAssembler } -func (nb *_Tag__Builder) Build() ipld.Node { +func (nb *_Tag_List__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 *_Tag__Builder) Reset() { - var w _Tag +func (nb *_Tag_List__ReprBuilder) Reset() { + var w _Tag_List var m schema.Maybe - *nb = _Tag__Builder{_Tag__Assembler{w: &w, m: &m}} + *nb = _Tag_List__ReprBuilder{_Tag_List__ReprAssembler{w: &w, m: &m}} } -type _Tag__Assembler struct { - w *_Tag +type _Tag_List__ReprAssembler struct { + w *_Tag_List m *schema.Maybe - state maState - s int - f int + state laState - cm schema.Maybe - ca_message _String__Assembler - ca_object _Link__Assembler - ca_tag _String__Assembler - ca_tagger _PersonInfo__Assembler - ca_tagType _String__Assembler + cm schema.Maybe + va _Tag__ReprAssembler } -func (na *_Tag__Assembler) reset() { - na.state = maState_initial - na.s = 0 - na.ca_message.reset() - na.ca_object.reset() - na.ca_tag.reset() - na.ca_tagger.reset() - na.ca_tagType.reset() +func (na *_Tag_List__ReprAssembler) reset() { + na.state = laState_initial + na.va.reset() } - -var ( - fieldBit__Tag_Message = 1 << 0 - fieldBit__Tag_Object = 1 << 1 - fieldBit__Tag_Tag = 1 << 2 - fieldBit__Tag_Tagger = 1 << 3 - fieldBit__Tag_TagType = 1 << 4 - fieldBits__Tag_sufficient = 0 + 1<<0 + 1<<1 + 1<<2 + 1<<3 + 1<<4 -) - -func (na *_Tag__Assembler) BeginMap(int64) (ipld.MapAssembler, error) { +func (_Tag_List__ReprAssembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { + return mixins.ListAssembler{TypeName: "ipldgit.Tag_List.Repr"}.BeginMap(0) +} +func (na *_Tag_List__ReprAssembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { switch *na.m { case schema.Maybe_Value, schema.Maybe_Null: panic("invalid state: cannot assign into assembler that's already finished") @@ -5952,965 +6583,126 @@ func (na *_Tag__Assembler) BeginMap(int64) (ipld.MapAssembler, error) { panic("invalid state: it makes no sense to 'begin' twice on the same assembler!") } *na.m = midvalue - if na.w == nil { - na.w = &_Tag{} + if sizeHint < 0 { + sizeHint = 0 + } + if sizeHint > 0 { + na.w.x = make([]_Tag, 0, sizeHint) } return na, nil } -func (_Tag__Assembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { - return mixins.MapAssembler{TypeName: "ipldgit.Tag"}.BeginList(0) -} -func (na *_Tag__Assembler) AssignNull() error { +func (na *_Tag_List__ReprAssembler) AssignNull() error { switch *na.m { case allowNull: *na.m = schema.Maybe_Null return nil case schema.Maybe_Absent: - return mixins.MapAssembler{TypeName: "ipldgit.Tag"}.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 (_Tag__Assembler) AssignBool(bool) error { - return mixins.MapAssembler{TypeName: "ipldgit.Tag"}.AssignBool(false) -} -func (_Tag__Assembler) AssignInt(int64) error { - return mixins.MapAssembler{TypeName: "ipldgit.Tag"}.AssignInt(0) -} -func (_Tag__Assembler) AssignFloat(float64) error { - return mixins.MapAssembler{TypeName: "ipldgit.Tag"}.AssignFloat(0) -} -func (_Tag__Assembler) AssignString(string) error { - return mixins.MapAssembler{TypeName: "ipldgit.Tag"}.AssignString("") -} -func (_Tag__Assembler) AssignBytes([]byte) error { - return mixins.MapAssembler{TypeName: "ipldgit.Tag"}.AssignBytes(nil) -} -func (_Tag__Assembler) AssignLink(ipld.Link) error { - return mixins.MapAssembler{TypeName: "ipldgit.Tag"}.AssignLink(nil) -} -func (na *_Tag__Assembler) AssignNode(v ipld.Node) error { - if v.IsNull() { - return na.AssignNull() - } - if v2, ok := v.(*_Tag); 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.Kind() != ipld.Kind_Map { - return ipld.ErrWrongKind{TypeName: "ipldgit.Tag", MethodName: "AssignNode", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()} - } - itr := v.MapIterator() - for !itr.Done() { - k, v, err := itr.Next() - if err != nil { - return err - } - if err := na.AssembleKey().AssignNode(k); err != nil { - return err - } - if err := na.AssembleValue().AssignNode(v); err != nil { - return err - } - } - return na.Finish() -} -func (_Tag__Assembler) Prototype() ipld.NodePrototype { - return _Tag__Prototype{} -} -func (ma *_Tag__Assembler) valueFinishTidy() bool { - switch ma.f { - case 0: - switch ma.cm { - case schema.Maybe_Value: - ma.ca_message.w = nil - ma.cm = schema.Maybe_Absent - ma.state = maState_initial - return true - default: - return false - } - case 1: - switch ma.cm { - case schema.Maybe_Value: - ma.ca_object.w = nil - ma.cm = schema.Maybe_Absent - ma.state = maState_initial - return true - default: - return false - } - case 2: - switch ma.cm { - case schema.Maybe_Value: - ma.ca_tag.w = nil - ma.cm = schema.Maybe_Absent - ma.state = maState_initial - return true - default: - return false - } - case 3: - switch ma.cm { - case schema.Maybe_Value: - ma.ca_tagger.w = nil - ma.cm = schema.Maybe_Absent - ma.state = maState_initial - return true - default: - return false - } - case 4: - switch ma.cm { - case schema.Maybe_Value: - ma.ca_tagType.w = nil - ma.cm = schema.Maybe_Absent - ma.state = maState_initial - return true - default: - return false - } - default: - panic("unreachable") - } -} -func (ma *_Tag__Assembler) AssembleEntry(k string) (ipld.NodeAssembler, error) { - switch ma.state { - case maState_initial: - // carry on - case maState_midKey: - panic("invalid state: AssembleEntry cannot be called when in the middle of assembling another key") - case maState_expectValue: - panic("invalid state: AssembleEntry cannot be called when expecting start of value assembly") - case maState_midValue: - if !ma.valueFinishTidy() { - panic("invalid state: AssembleEntry cannot be called when in the middle of assembling a value") - } // if tidy success: carry on - case maState_finished: - panic("invalid state: AssembleEntry cannot be called on an assembler that's already finished") - } - switch k { - case "message": - if ma.s&fieldBit__Tag_Message != 0 { - return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Message} - } - ma.s += fieldBit__Tag_Message - ma.state = maState_midValue - ma.f = 0 - ma.ca_message.w = &ma.w.message - ma.ca_message.m = &ma.cm - return &ma.ca_message, nil - case "object": - if ma.s&fieldBit__Tag_Object != 0 { - return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Object} - } - ma.s += fieldBit__Tag_Object - ma.state = maState_midValue - ma.f = 1 - ma.ca_object.w = &ma.w.object - ma.ca_object.m = &ma.cm - return &ma.ca_object, nil - case "tag": - if ma.s&fieldBit__Tag_Tag != 0 { - return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Tag} - } - ma.s += fieldBit__Tag_Tag - ma.state = maState_midValue - ma.f = 2 - ma.ca_tag.w = &ma.w.tag - ma.ca_tag.m = &ma.cm - return &ma.ca_tag, nil - case "tagger": - if ma.s&fieldBit__Tag_Tagger != 0 { - return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Tagger} - } - ma.s += fieldBit__Tag_Tagger - ma.state = maState_midValue - ma.f = 3 - ma.ca_tagger.w = &ma.w.tagger - ma.ca_tagger.m = &ma.cm - return &ma.ca_tagger, nil - case "tagType": - if ma.s&fieldBit__Tag_TagType != 0 { - return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_TagType} - } - ma.s += fieldBit__Tag_TagType - ma.state = maState_midValue - ma.f = 4 - ma.ca_tagType.w = &ma.w.tagType - ma.ca_tagType.m = &ma.cm - return &ma.ca_tagType, nil - } - return nil, ipld.ErrInvalidKey{TypeName: "ipldgit.Tag", Key: &_String{k}} -} -func (ma *_Tag__Assembler) AssembleKey() ipld.NodeAssembler { - switch ma.state { - case maState_initial: - // carry on - case maState_midKey: - panic("invalid state: AssembleKey cannot be called when in the middle of assembling another key") - case maState_expectValue: - panic("invalid state: AssembleKey cannot be called when expecting start of value assembly") - case maState_midValue: - if !ma.valueFinishTidy() { - panic("invalid state: AssembleKey cannot be called when in the middle of assembling a value") - } // if tidy success: carry on - case maState_finished: - panic("invalid state: AssembleKey cannot be called on an assembler that's already finished") - } - ma.state = maState_midKey - return (*_Tag__KeyAssembler)(ma) -} -func (ma *_Tag__Assembler) AssembleValue() ipld.NodeAssembler { - switch ma.state { - case maState_initial: - panic("invalid state: AssembleValue cannot be called when no key is primed") - case maState_midKey: - panic("invalid state: AssembleValue cannot be called when in the middle of assembling a key") - case maState_expectValue: - // carry on - case maState_midValue: - panic("invalid state: AssembleValue cannot be called when in the middle of assembling another value") - case maState_finished: - panic("invalid state: AssembleValue cannot be called on an assembler that's already finished") - } - ma.state = maState_midValue - switch ma.f { - case 0: - ma.ca_message.w = &ma.w.message - ma.ca_message.m = &ma.cm - return &ma.ca_message - case 1: - ma.ca_object.w = &ma.w.object - ma.ca_object.m = &ma.cm - return &ma.ca_object - case 2: - ma.ca_tag.w = &ma.w.tag - ma.ca_tag.m = &ma.cm - return &ma.ca_tag - case 3: - ma.ca_tagger.w = &ma.w.tagger - ma.ca_tagger.m = &ma.cm - return &ma.ca_tagger - case 4: - ma.ca_tagType.w = &ma.w.tagType - ma.ca_tagType.m = &ma.cm - return &ma.ca_tagType - default: - panic("unreachable") - } -} -func (ma *_Tag__Assembler) Finish() error { - switch ma.state { - case maState_initial: - // carry on - case maState_midKey: - panic("invalid state: Finish cannot be called when in the middle of assembling a key") - case maState_expectValue: - panic("invalid state: Finish cannot be called when expecting start of value assembly") - case maState_midValue: - if !ma.valueFinishTidy() { - panic("invalid state: Finish cannot be called when in the middle of assembling a value") - } // if tidy success: carry on - case maState_finished: - panic("invalid state: Finish cannot be called on an assembler that's already finished") - } - if ma.s&fieldBits__Tag_sufficient != fieldBits__Tag_sufficient { - err := ipld.ErrMissingRequiredField{Missing: make([]string, 0)} - if ma.s&fieldBit__Tag_Message == 0 { - err.Missing = append(err.Missing, "message") - } - if ma.s&fieldBit__Tag_Object == 0 { - err.Missing = append(err.Missing, "object") - } - if ma.s&fieldBit__Tag_Tag == 0 { - err.Missing = append(err.Missing, "tag") - } - if ma.s&fieldBit__Tag_Tagger == 0 { - err.Missing = append(err.Missing, "tagger") - } - if ma.s&fieldBit__Tag_TagType == 0 { - err.Missing = append(err.Missing, "tagType") - } - return err - } - ma.state = maState_finished - *ma.m = schema.Maybe_Value - return nil -} -func (ma *_Tag__Assembler) KeyPrototype() ipld.NodePrototype { - return _String__Prototype{} -} -func (ma *_Tag__Assembler) ValuePrototype(k string) ipld.NodePrototype { - panic("todo structbuilder mapassembler valueprototype") -} - -type _Tag__KeyAssembler _Tag__Assembler - -func (_Tag__KeyAssembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { - return mixins.StringAssembler{TypeName: "ipldgit.Tag.KeyAssembler"}.BeginMap(0) -} -func (_Tag__KeyAssembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { - return mixins.StringAssembler{TypeName: "ipldgit.Tag.KeyAssembler"}.BeginList(0) -} -func (na *_Tag__KeyAssembler) AssignNull() error { - return mixins.StringAssembler{TypeName: "ipldgit.Tag.KeyAssembler"}.AssignNull() -} -func (_Tag__KeyAssembler) AssignBool(bool) error { - return mixins.StringAssembler{TypeName: "ipldgit.Tag.KeyAssembler"}.AssignBool(false) -} -func (_Tag__KeyAssembler) AssignInt(int64) error { - return mixins.StringAssembler{TypeName: "ipldgit.Tag.KeyAssembler"}.AssignInt(0) -} -func (_Tag__KeyAssembler) AssignFloat(float64) error { - return mixins.StringAssembler{TypeName: "ipldgit.Tag.KeyAssembler"}.AssignFloat(0) -} -func (ka *_Tag__KeyAssembler) AssignString(k string) error { - if ka.state != maState_midKey { - panic("misuse: KeyAssembler held beyond its valid lifetime") - } - switch k { - case "message": - if ka.s&fieldBit__Tag_Message != 0 { - return ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Message} - } - ka.s += fieldBit__Tag_Message - ka.state = maState_expectValue - ka.f = 0 - return nil - case "object": - if ka.s&fieldBit__Tag_Object != 0 { - return ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Object} - } - ka.s += fieldBit__Tag_Object - ka.state = maState_expectValue - ka.f = 1 - return nil - case "tag": - if ka.s&fieldBit__Tag_Tag != 0 { - return ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Tag} - } - ka.s += fieldBit__Tag_Tag - ka.state = maState_expectValue - ka.f = 2 - return nil - case "tagger": - if ka.s&fieldBit__Tag_Tagger != 0 { - return ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Tagger} - } - ka.s += fieldBit__Tag_Tagger - ka.state = maState_expectValue - ka.f = 3 - return nil - case "tagType": - if ka.s&fieldBit__Tag_TagType != 0 { - return ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_TagType} - } - ka.s += fieldBit__Tag_TagType - ka.state = maState_expectValue - ka.f = 4 - return nil - default: - return ipld.ErrInvalidKey{TypeName: "ipldgit.Tag", Key: &_String{k}} - } -} -func (_Tag__KeyAssembler) AssignBytes([]byte) error { - return mixins.StringAssembler{TypeName: "ipldgit.Tag.KeyAssembler"}.AssignBytes(nil) -} -func (_Tag__KeyAssembler) AssignLink(ipld.Link) error { - return mixins.StringAssembler{TypeName: "ipldgit.Tag.KeyAssembler"}.AssignLink(nil) -} -func (ka *_Tag__KeyAssembler) AssignNode(v ipld.Node) error { - if v2, err := v.AsString(); err != nil { - return err - } else { - return ka.AssignString(v2) - } -} -func (_Tag__KeyAssembler) Prototype() ipld.NodePrototype { - return _String__Prototype{} -} -func (Tag) Type() schema.Type { - return nil /*TODO:typelit*/ -} -func (n Tag) Representation() ipld.Node { - return (*_Tag__Repr)(n) -} - -type _Tag__Repr _Tag - -var ( - fieldName__Tag_Message_serial = _String{"message"} - fieldName__Tag_Object_serial = _String{"object"} - fieldName__Tag_Tag_serial = _String{"tag"} - fieldName__Tag_Tagger_serial = _String{"tagger"} - fieldName__Tag_TagType_serial = _String{"tagType"} -) -var _ ipld.Node = &_Tag__Repr{} - -func (_Tag__Repr) Kind() ipld.Kind { - return ipld.Kind_Map -} -func (n *_Tag__Repr) LookupByString(key string) (ipld.Node, error) { - switch key { - case "message": - return n.message.Representation(), nil - case "object": - return n.object.Representation(), nil - case "tag": - return n.tag.Representation(), nil - case "tagger": - return n.tagger.Representation(), nil - case "tagType": - return n.tagType.Representation(), nil - default: - return nil, schema.ErrNoSuchField{Type: nil /*TODO*/, Field: ipld.PathSegmentOfString(key)} - } -} -func (n *_Tag__Repr) LookupByNode(key ipld.Node) (ipld.Node, error) { - ks, err := key.AsString() - if err != nil { - return nil, err - } - return n.LookupByString(ks) -} -func (_Tag__Repr) LookupByIndex(idx int64) (ipld.Node, error) { - return mixins.Map{TypeName: "ipldgit.Tag.Repr"}.LookupByIndex(0) -} -func (n _Tag__Repr) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { - return n.LookupByString(seg.String()) -} -func (n *_Tag__Repr) MapIterator() ipld.MapIterator { - return &_Tag__ReprMapItr{n, 0} -} - -type _Tag__ReprMapItr struct { - n *_Tag__Repr - idx int -} - -func (itr *_Tag__ReprMapItr) Next() (k ipld.Node, v ipld.Node, _ error) { - if itr.idx >= 5 { - return nil, nil, ipld.ErrIteratorOverread{} - } - switch itr.idx { - case 0: - k = &fieldName__Tag_Message_serial - v = itr.n.message.Representation() - case 1: - k = &fieldName__Tag_Object_serial - v = itr.n.object.Representation() - case 2: - k = &fieldName__Tag_Tag_serial - v = itr.n.tag.Representation() - case 3: - k = &fieldName__Tag_Tagger_serial - v = itr.n.tagger.Representation() - case 4: - k = &fieldName__Tag_TagType_serial - v = itr.n.tagType.Representation() - default: - panic("unreachable") - } - itr.idx++ - return -} -func (itr *_Tag__ReprMapItr) Done() bool { - return itr.idx >= 5 -} -func (_Tag__Repr) ListIterator() ipld.ListIterator { - return nil -} -func (rn *_Tag__Repr) Length() int64 { - l := 5 - return int64(l) -} -func (_Tag__Repr) IsAbsent() bool { - return false -} -func (_Tag__Repr) IsNull() bool { - return false -} -func (_Tag__Repr) AsBool() (bool, error) { - return mixins.Map{TypeName: "ipldgit.Tag.Repr"}.AsBool() -} -func (_Tag__Repr) AsInt() (int64, error) { - return mixins.Map{TypeName: "ipldgit.Tag.Repr"}.AsInt() -} -func (_Tag__Repr) AsFloat() (float64, error) { - return mixins.Map{TypeName: "ipldgit.Tag.Repr"}.AsFloat() -} -func (_Tag__Repr) AsString() (string, error) { - return mixins.Map{TypeName: "ipldgit.Tag.Repr"}.AsString() -} -func (_Tag__Repr) AsBytes() ([]byte, error) { - return mixins.Map{TypeName: "ipldgit.Tag.Repr"}.AsBytes() -} -func (_Tag__Repr) AsLink() (ipld.Link, error) { - return mixins.Map{TypeName: "ipldgit.Tag.Repr"}.AsLink() -} -func (_Tag__Repr) Prototype() ipld.NodePrototype { - return _Tag__ReprPrototype{} -} - -type _Tag__ReprPrototype struct{} - -func (_Tag__ReprPrototype) NewBuilder() ipld.NodeBuilder { - var nb _Tag__ReprBuilder - nb.Reset() - return &nb -} - -type _Tag__ReprBuilder struct { - _Tag__ReprAssembler -} - -func (nb *_Tag__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 *_Tag__ReprBuilder) Reset() { - var w _Tag - var m schema.Maybe - *nb = _Tag__ReprBuilder{_Tag__ReprAssembler{w: &w, m: &m}} -} - -type _Tag__ReprAssembler struct { - w *_Tag - m *schema.Maybe - state maState - s int - f int - - cm schema.Maybe - ca_message _String__ReprAssembler - ca_object _Link__ReprAssembler - ca_tag _String__ReprAssembler - ca_tagger _PersonInfo__ReprAssembler - ca_tagType _String__ReprAssembler -} - -func (na *_Tag__ReprAssembler) reset() { - na.state = maState_initial - na.s = 0 - na.ca_message.reset() - na.ca_object.reset() - na.ca_tag.reset() - na.ca_tagger.reset() - na.ca_tagType.reset() -} -func (na *_Tag__ReprAssembler) BeginMap(int64) (ipld.MapAssembler, 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 na.w == nil { - na.w = &_Tag{} - } - return na, nil -} -func (_Tag__ReprAssembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { - return mixins.MapAssembler{TypeName: "ipldgit.Tag.Repr"}.BeginList(0) -} -func (na *_Tag__ReprAssembler) AssignNull() error { - switch *na.m { - case allowNull: - *na.m = schema.Maybe_Null - return nil - case schema.Maybe_Absent: - return mixins.MapAssembler{TypeName: "ipldgit.Tag.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 (_Tag__ReprAssembler) AssignBool(bool) error { - return mixins.MapAssembler{TypeName: "ipldgit.Tag.Repr"}.AssignBool(false) -} -func (_Tag__ReprAssembler) AssignInt(int64) error { - return mixins.MapAssembler{TypeName: "ipldgit.Tag.Repr"}.AssignInt(0) -} -func (_Tag__ReprAssembler) AssignFloat(float64) error { - return mixins.MapAssembler{TypeName: "ipldgit.Tag.Repr"}.AssignFloat(0) -} -func (_Tag__ReprAssembler) AssignString(string) error { - return mixins.MapAssembler{TypeName: "ipldgit.Tag.Repr"}.AssignString("") -} -func (_Tag__ReprAssembler) AssignBytes([]byte) error { - return mixins.MapAssembler{TypeName: "ipldgit.Tag.Repr"}.AssignBytes(nil) -} -func (_Tag__ReprAssembler) AssignLink(ipld.Link) error { - return mixins.MapAssembler{TypeName: "ipldgit.Tag.Repr"}.AssignLink(nil) -} -func (na *_Tag__ReprAssembler) AssignNode(v ipld.Node) error { - if v.IsNull() { - return na.AssignNull() - } - if v2, ok := v.(*_Tag); 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.Kind() != ipld.Kind_Map { - return ipld.ErrWrongKind{TypeName: "ipldgit.Tag.Repr", MethodName: "AssignNode", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()} - } - itr := v.MapIterator() - for !itr.Done() { - k, v, err := itr.Next() - if err != nil { - return err - } - if err := na.AssembleKey().AssignNode(k); err != nil { - return err - } - if err := na.AssembleValue().AssignNode(v); err != nil { - return err - } - } - return na.Finish() -} -func (_Tag__ReprAssembler) Prototype() ipld.NodePrototype { - return _Tag__ReprPrototype{} -} -func (ma *_Tag__ReprAssembler) valueFinishTidy() bool { - switch ma.f { - case 0: - switch ma.cm { - case schema.Maybe_Value: - ma.cm = schema.Maybe_Absent - ma.state = maState_initial - return true - default: - return false - } - case 1: - switch ma.cm { - case schema.Maybe_Value: - ma.cm = schema.Maybe_Absent - ma.state = maState_initial - return true - default: - return false - } - case 2: - switch ma.cm { - case schema.Maybe_Value: - ma.cm = schema.Maybe_Absent - ma.state = maState_initial - return true - default: - return false - } - case 3: - switch ma.cm { - case schema.Maybe_Value: - ma.cm = schema.Maybe_Absent - ma.state = maState_initial - return true - default: - return false - } - case 4: - switch ma.cm { - case schema.Maybe_Value: - ma.cm = schema.Maybe_Absent - ma.state = maState_initial - return true - default: - return false - } - default: - panic("unreachable") - } -} -func (ma *_Tag__ReprAssembler) AssembleEntry(k string) (ipld.NodeAssembler, error) { - switch ma.state { - case maState_initial: - // carry on - case maState_midKey: - panic("invalid state: AssembleEntry cannot be called when in the middle of assembling another key") - case maState_expectValue: - panic("invalid state: AssembleEntry cannot be called when expecting start of value assembly") - case maState_midValue: - if !ma.valueFinishTidy() { - panic("invalid state: AssembleEntry cannot be called when in the middle of assembling a value") - } // if tidy success: carry on - case maState_finished: - panic("invalid state: AssembleEntry cannot be called on an assembler that's already finished") - } - switch k { - case "message": - if ma.s&fieldBit__Tag_Message != 0 { - return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Message_serial} - } - ma.s += fieldBit__Tag_Message - ma.state = maState_midValue - ma.f = 0 - ma.ca_message.w = &ma.w.message - ma.ca_message.m = &ma.cm - return &ma.ca_message, nil - case "object": - if ma.s&fieldBit__Tag_Object != 0 { - return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Object_serial} - } - ma.s += fieldBit__Tag_Object - ma.state = maState_midValue - ma.f = 1 - ma.ca_object.w = &ma.w.object - ma.ca_object.m = &ma.cm - return &ma.ca_object, nil - case "tag": - if ma.s&fieldBit__Tag_Tag != 0 { - return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Tag_serial} - } - ma.s += fieldBit__Tag_Tag - ma.state = maState_midValue - ma.f = 2 - ma.ca_tag.w = &ma.w.tag - ma.ca_tag.m = &ma.cm - return &ma.ca_tag, nil - case "tagger": - if ma.s&fieldBit__Tag_Tagger != 0 { - return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Tagger_serial} - } - ma.s += fieldBit__Tag_Tagger - ma.state = maState_midValue - ma.f = 3 - ma.ca_tagger.w = &ma.w.tagger - ma.ca_tagger.m = &ma.cm - return &ma.ca_tagger, nil - case "tagType": - if ma.s&fieldBit__Tag_TagType != 0 { - return nil, ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_TagType_serial} - } - ma.s += fieldBit__Tag_TagType - ma.state = maState_midValue - ma.f = 4 - ma.ca_tagType.w = &ma.w.tagType - ma.ca_tagType.m = &ma.cm - return &ma.ca_tagType, nil - default: - } - return nil, ipld.ErrInvalidKey{TypeName: "ipldgit.Tag.Repr", Key: &_String{k}} -} -func (ma *_Tag__ReprAssembler) AssembleKey() ipld.NodeAssembler { - switch ma.state { - case maState_initial: - // carry on - case maState_midKey: - panic("invalid state: AssembleKey cannot be called when in the middle of assembling another key") - case maState_expectValue: - panic("invalid state: AssembleKey cannot be called when expecting start of value assembly") - case maState_midValue: - if !ma.valueFinishTidy() { - panic("invalid state: AssembleKey cannot be called when in the middle of assembling a value") - } // if tidy success: carry on - case maState_finished: - panic("invalid state: AssembleKey cannot be called on an assembler that's already finished") - } - ma.state = maState_midKey - return (*_Tag__ReprKeyAssembler)(ma) -} -func (ma *_Tag__ReprAssembler) AssembleValue() ipld.NodeAssembler { - switch ma.state { - case maState_initial: - panic("invalid state: AssembleValue cannot be called when no key is primed") - case maState_midKey: - panic("invalid state: AssembleValue cannot be called when in the middle of assembling a key") - case maState_expectValue: - // carry on - case maState_midValue: - panic("invalid state: AssembleValue cannot be called when in the middle of assembling another value") - case maState_finished: - panic("invalid state: AssembleValue cannot be called on an assembler that's already finished") - } - ma.state = maState_midValue - switch ma.f { - case 0: - ma.ca_message.w = &ma.w.message - ma.ca_message.m = &ma.cm - return &ma.ca_message - case 1: - ma.ca_object.w = &ma.w.object - ma.ca_object.m = &ma.cm - return &ma.ca_object - case 2: - ma.ca_tag.w = &ma.w.tag - ma.ca_tag.m = &ma.cm - return &ma.ca_tag - case 3: - ma.ca_tagger.w = &ma.w.tagger - ma.ca_tagger.m = &ma.cm - return &ma.ca_tagger - case 4: - ma.ca_tagType.w = &ma.w.tagType - ma.ca_tagType.m = &ma.cm - return &ma.ca_tagType - default: - panic("unreachable") - } -} -func (ma *_Tag__ReprAssembler) Finish() error { - switch ma.state { - case maState_initial: - // carry on - case maState_midKey: - panic("invalid state: Finish cannot be called when in the middle of assembling a key") - case maState_expectValue: - panic("invalid state: Finish cannot be called when expecting start of value assembly") - case maState_midValue: - if !ma.valueFinishTidy() { - panic("invalid state: Finish cannot be called when in the middle of assembling a value") - } // if tidy success: carry on - case maState_finished: - panic("invalid state: Finish cannot be called on an assembler that's already finished") - } - if ma.s&fieldBits__Tag_sufficient != fieldBits__Tag_sufficient { - err := ipld.ErrMissingRequiredField{Missing: make([]string, 0)} - if ma.s&fieldBit__Tag_Message == 0 { - err.Missing = append(err.Missing, "message") - } - if ma.s&fieldBit__Tag_Object == 0 { - err.Missing = append(err.Missing, "object") - } - if ma.s&fieldBit__Tag_Tag == 0 { - err.Missing = append(err.Missing, "tag") - } - if ma.s&fieldBit__Tag_Tagger == 0 { - err.Missing = append(err.Missing, "tagger") - } - if ma.s&fieldBit__Tag_TagType == 0 { - err.Missing = append(err.Missing, "tagType") - } - return err - } - ma.state = maState_finished - *ma.m = schema.Maybe_Value - return nil -} -func (ma *_Tag__ReprAssembler) KeyPrototype() ipld.NodePrototype { - return _String__Prototype{} -} -func (ma *_Tag__ReprAssembler) ValuePrototype(k string) ipld.NodePrototype { - panic("todo structbuilder mapassembler repr valueprototype") + return mixins.ListAssembler{TypeName: "ipldgit.Tag_List.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") } - -type _Tag__ReprKeyAssembler _Tag__ReprAssembler - -func (_Tag__ReprKeyAssembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { - return mixins.StringAssembler{TypeName: "ipldgit.Tag.Repr.KeyAssembler"}.BeginMap(0) +func (_Tag_List__ReprAssembler) AssignBool(bool) error { + return mixins.ListAssembler{TypeName: "ipldgit.Tag_List.Repr"}.AssignBool(false) } -func (_Tag__ReprKeyAssembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { - return mixins.StringAssembler{TypeName: "ipldgit.Tag.Repr.KeyAssembler"}.BeginList(0) +func (_Tag_List__ReprAssembler) AssignInt(int64) error { + return mixins.ListAssembler{TypeName: "ipldgit.Tag_List.Repr"}.AssignInt(0) } -func (na *_Tag__ReprKeyAssembler) AssignNull() error { - return mixins.StringAssembler{TypeName: "ipldgit.Tag.Repr.KeyAssembler"}.AssignNull() +func (_Tag_List__ReprAssembler) AssignFloat(float64) error { + return mixins.ListAssembler{TypeName: "ipldgit.Tag_List.Repr"}.AssignFloat(0) } -func (_Tag__ReprKeyAssembler) AssignBool(bool) error { - return mixins.StringAssembler{TypeName: "ipldgit.Tag.Repr.KeyAssembler"}.AssignBool(false) +func (_Tag_List__ReprAssembler) AssignString(string) error { + return mixins.ListAssembler{TypeName: "ipldgit.Tag_List.Repr"}.AssignString("") } -func (_Tag__ReprKeyAssembler) AssignInt(int64) error { - return mixins.StringAssembler{TypeName: "ipldgit.Tag.Repr.KeyAssembler"}.AssignInt(0) +func (_Tag_List__ReprAssembler) AssignBytes([]byte) error { + return mixins.ListAssembler{TypeName: "ipldgit.Tag_List.Repr"}.AssignBytes(nil) } -func (_Tag__ReprKeyAssembler) AssignFloat(float64) error { - return mixins.StringAssembler{TypeName: "ipldgit.Tag.Repr.KeyAssembler"}.AssignFloat(0) +func (_Tag_List__ReprAssembler) AssignLink(ipld.Link) error { + return mixins.ListAssembler{TypeName: "ipldgit.Tag_List.Repr"}.AssignLink(nil) } -func (ka *_Tag__ReprKeyAssembler) AssignString(k string) error { - if ka.state != maState_midKey { - panic("misuse: KeyAssembler held beyond its valid lifetime") +func (na *_Tag_List__ReprAssembler) AssignNode(v ipld.Node) error { + if v.IsNull() { + return na.AssignNull() } - switch k { - case "message": - if ka.s&fieldBit__Tag_Message != 0 { - return ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Message_serial} - } - ka.s += fieldBit__Tag_Message - ka.state = maState_expectValue - ka.f = 0 - return nil - case "object": - if ka.s&fieldBit__Tag_Object != 0 { - return ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Object_serial} - } - ka.s += fieldBit__Tag_Object - ka.state = maState_expectValue - ka.f = 1 - return nil - case "tag": - if ka.s&fieldBit__Tag_Tag != 0 { - return ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Tag_serial} + if v2, ok := v.(*_Tag_List); 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!") } - ka.s += fieldBit__Tag_Tag - ka.state = maState_expectValue - ka.f = 2 + *na.w = *v2 + *na.m = schema.Maybe_Value return nil - case "tagger": - if ka.s&fieldBit__Tag_Tagger != 0 { - return ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_Tagger_serial} + } + if v.Kind() != ipld.Kind_List { + return ipld.ErrWrongKind{TypeName: "ipldgit.Tag_List.Repr", MethodName: "AssignNode", AppropriateKind: ipld.KindSet_JustList, ActualKind: v.Kind()} + } + itr := v.ListIterator() + for !itr.Done() { + _, v, err := itr.Next() + if err != nil { + return err } - ka.s += fieldBit__Tag_Tagger - ka.state = maState_expectValue - ka.f = 3 - return nil - case "tagType": - if ka.s&fieldBit__Tag_TagType != 0 { - return ipld.ErrRepeatedMapKey{Key: &fieldName__Tag_TagType_serial} + if err := na.AssembleValue().AssignNode(v); err != nil { + return err } - ka.s += fieldBit__Tag_TagType - ka.state = maState_expectValue - ka.f = 4 - return nil } - return ipld.ErrInvalidKey{TypeName: "ipldgit.Tag.Repr", Key: &_String{k}} + return na.Finish() } -func (_Tag__ReprKeyAssembler) AssignBytes([]byte) error { - return mixins.StringAssembler{TypeName: "ipldgit.Tag.Repr.KeyAssembler"}.AssignBytes(nil) +func (_Tag_List__ReprAssembler) Prototype() ipld.NodePrototype { + return _Tag_List__ReprPrototype{} } -func (_Tag__ReprKeyAssembler) AssignLink(ipld.Link) error { - return mixins.StringAssembler{TypeName: "ipldgit.Tag.Repr.KeyAssembler"}.AssignLink(nil) +func (la *_Tag_List__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 (ka *_Tag__ReprKeyAssembler) AssignNode(v ipld.Node) error { - if v2, err := v.AsString(); err != nil { - return err - } else { - return ka.AssignString(v2) +func (la *_Tag_List__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, _Tag{}) + 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 *_Tag_List__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 (_Tag__ReprKeyAssembler) Prototype() ipld.NodePrototype { - return _String__Prototype{} +func (la *_Tag_List__ReprAssembler) ValuePrototype(_ int64) ipld.NodePrototype { + return _Tag__ReprPrototype{} } func (n *_Tree) Lookup(k String) TreeEntry { @@ -8590,3 +8382,211 @@ func (ka *_TreeEntry__ReprKeyAssembler) AssignNode(v ipld.Node) error { func (_TreeEntry__ReprKeyAssembler) Prototype() ipld.NodePrototype { return _String__Prototype{} } + +func (n Tree_Link) Link() ipld.Link { + return n.x +} +func (_Tree_Link__Prototype) FromLink(v ipld.Link) (Tree_Link, error) { + n := _Tree_Link{v} + return &n, nil +} + +type _Tree_Link__Maybe struct { + m schema.Maybe + v _Tree_Link +} +type MaybeTree_Link = *_Tree_Link__Maybe + +func (m MaybeTree_Link) IsNull() bool { + return m.m == schema.Maybe_Null +} +func (m MaybeTree_Link) IsAbsent() bool { + return m.m == schema.Maybe_Absent +} +func (m MaybeTree_Link) Exists() bool { + return m.m == schema.Maybe_Value +} +func (m MaybeTree_Link) 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 MaybeTree_Link) Must() Tree_Link { + if !m.Exists() { + panic("unbox of a maybe rejected") + } + return &m.v +} + +var _ ipld.Node = (Tree_Link)(&_Tree_Link{}) +var _ schema.TypedNode = (Tree_Link)(&_Tree_Link{}) + +func (Tree_Link) Kind() ipld.Kind { + return ipld.Kind_Link +} +func (Tree_Link) LookupByString(string) (ipld.Node, error) { + return mixins.Link{TypeName: "ipldgit.Tree_Link"}.LookupByString("") +} +func (Tree_Link) LookupByNode(ipld.Node) (ipld.Node, error) { + return mixins.Link{TypeName: "ipldgit.Tree_Link"}.LookupByNode(nil) +} +func (Tree_Link) LookupByIndex(idx int64) (ipld.Node, error) { + return mixins.Link{TypeName: "ipldgit.Tree_Link"}.LookupByIndex(0) +} +func (Tree_Link) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) { + return mixins.Link{TypeName: "ipldgit.Tree_Link"}.LookupBySegment(seg) +} +func (Tree_Link) MapIterator() ipld.MapIterator { + return nil +} +func (Tree_Link) ListIterator() ipld.ListIterator { + return nil +} +func (Tree_Link) Length() int64 { + return -1 +} +func (Tree_Link) IsAbsent() bool { + return false +} +func (Tree_Link) IsNull() bool { + return false +} +func (Tree_Link) AsBool() (bool, error) { + return mixins.Link{TypeName: "ipldgit.Tree_Link"}.AsBool() +} +func (Tree_Link) AsInt() (int64, error) { + return mixins.Link{TypeName: "ipldgit.Tree_Link"}.AsInt() +} +func (Tree_Link) AsFloat() (float64, error) { + return mixins.Link{TypeName: "ipldgit.Tree_Link"}.AsFloat() +} +func (Tree_Link) AsString() (string, error) { + return mixins.Link{TypeName: "ipldgit.Tree_Link"}.AsString() +} +func (Tree_Link) AsBytes() ([]byte, error) { + return mixins.Link{TypeName: "ipldgit.Tree_Link"}.AsBytes() +} +func (n Tree_Link) AsLink() (ipld.Link, error) { + return n.x, nil +} +func (Tree_Link) Prototype() ipld.NodePrototype { + return _Tree_Link__Prototype{} +} + +type _Tree_Link__Prototype struct{} + +func (_Tree_Link__Prototype) NewBuilder() ipld.NodeBuilder { + var nb _Tree_Link__Builder + nb.Reset() + return &nb +} + +type _Tree_Link__Builder struct { + _Tree_Link__Assembler +} + +func (nb *_Tree_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 *_Tree_Link__Builder) Reset() { + var w _Tree_Link + var m schema.Maybe + *nb = _Tree_Link__Builder{_Tree_Link__Assembler{w: &w, m: &m}} +} + +type _Tree_Link__Assembler struct { + w *_Tree_Link + m *schema.Maybe +} + +func (na *_Tree_Link__Assembler) reset() {} +func (_Tree_Link__Assembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) { + return mixins.LinkAssembler{TypeName: "ipldgit.Tree_Link"}.BeginMap(0) +} +func (_Tree_Link__Assembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) { + return mixins.LinkAssembler{TypeName: "ipldgit.Tree_Link"}.BeginList(0) +} +func (na *_Tree_Link__Assembler) AssignNull() error { + switch *na.m { + case allowNull: + *na.m = schema.Maybe_Null + return nil + case schema.Maybe_Absent: + return mixins.LinkAssembler{TypeName: "ipldgit.Tree_Link"}.AssignNull() + case schema.Maybe_Value, schema.Maybe_Null: + panic("invalid state: cannot assign into assembler that's already finished") + } + panic("unreachable") +} +func (_Tree_Link__Assembler) AssignBool(bool) error { + return mixins.LinkAssembler{TypeName: "ipldgit.Tree_Link"}.AssignBool(false) +} +func (_Tree_Link__Assembler) AssignInt(int64) error { + return mixins.LinkAssembler{TypeName: "ipldgit.Tree_Link"}.AssignInt(0) +} +func (_Tree_Link__Assembler) AssignFloat(float64) error { + return mixins.LinkAssembler{TypeName: "ipldgit.Tree_Link"}.AssignFloat(0) +} +func (_Tree_Link__Assembler) AssignString(string) error { + return mixins.LinkAssembler{TypeName: "ipldgit.Tree_Link"}.AssignString("") +} +func (_Tree_Link__Assembler) AssignBytes([]byte) error { + return mixins.LinkAssembler{TypeName: "ipldgit.Tree_Link"}.AssignBytes(nil) +} +func (na *_Tree_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") + } + na.w.x = v + *na.m = schema.Maybe_Value + return nil +} +func (na *_Tree_Link__Assembler) AssignNode(v ipld.Node) error { + if v.IsNull() { + return na.AssignNull() + } + if v2, ok := v.(*_Tree_Link); ok { + switch *na.m { + case schema.Maybe_Value, schema.Maybe_Null: + panic("invalid state: cannot assign into assembler that's already finished") + } + *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 (_Tree_Link__Assembler) Prototype() ipld.NodePrototype { + return _Tree_Link__Prototype{} +} +func (Tree_Link) Type() schema.Type { + return nil /*TODO:typelit*/ +} +func (Tree_Link) LinkTargetNodePrototype() ipld.NodePrototype { + return Type.Tree__Repr +} +func (n Tree_Link) Representation() ipld.Node { + return (*_Tree_Link__Repr)(n) +} + +type _Tree_Link__Repr = _Tree_Link + +var _ ipld.Node = &_Tree_Link__Repr{} + +type _Tree_Link__ReprPrototype = _Tree_Link__Prototype +type _Tree_Link__ReprAssembler = _Tree_Link__Assembler diff --git a/ipldsch_types.go b/ipldsch_types.go index aa6e294..2111c5a 100644 --- a/ipldsch_types.go +++ b/ipldsch_types.go @@ -20,34 +20,34 @@ var _ ipld.Node = nil // suppress errors when this dependency is not referenced var Type typeSlab type typeSlab struct { - Blob _Blob__Prototype - Blob__Repr _Blob__ReprPrototype - Commit _Commit__Prototype - Commit__Repr _Commit__ReprPrototype - GpgSig _GpgSig__Prototype - GpgSig__Repr _GpgSig__ReprPrototype - Link _Link__Prototype - Link__Repr _Link__ReprPrototype - LinkCommit _LinkCommit__Prototype - LinkCommit__Repr _LinkCommit__ReprPrototype - LinkTree _LinkTree__Prototype - LinkTree__Repr _LinkTree__ReprPrototype - ListParents _ListParents__Prototype - ListParents__Repr _ListParents__ReprPrototype - ListString _ListString__Prototype - ListString__Repr _ListString__ReprPrototype - ListTag _ListTag__Prototype - ListTag__Repr _ListTag__ReprPrototype - PersonInfo _PersonInfo__Prototype - PersonInfo__Repr _PersonInfo__ReprPrototype - String _String__Prototype - String__Repr _String__ReprPrototype - Tag _Tag__Prototype - Tag__Repr _Tag__ReprPrototype - Tree _Tree__Prototype - Tree__Repr _Tree__ReprPrototype - TreeEntry _TreeEntry__Prototype - TreeEntry__Repr _TreeEntry__ReprPrototype + Blob _Blob__Prototype + Blob__Repr _Blob__ReprPrototype + Commit _Commit__Prototype + Commit__Repr _Commit__ReprPrototype + Commit_Link _Commit_Link__Prototype + Commit_Link__Repr _Commit_Link__ReprPrototype + Commit_Link_List _Commit_Link_List__Prototype + Commit_Link_List__Repr _Commit_Link_List__ReprPrototype + GpgSig _GpgSig__Prototype + GpgSig__Repr _GpgSig__ReprPrototype + Link _Link__Prototype + Link__Repr _Link__ReprPrototype + PersonInfo _PersonInfo__Prototype + PersonInfo__Repr _PersonInfo__ReprPrototype + String _String__Prototype + String__Repr _String__ReprPrototype + String_List _String_List__Prototype + String_List__Repr _String_List__ReprPrototype + Tag _Tag__Prototype + Tag__Repr _Tag__ReprPrototype + Tag_List _Tag_List__Prototype + Tag_List__Repr _Tag_List__ReprPrototype + Tree _Tree__Prototype + Tree__Repr _Tree__ReprPrototype + TreeEntry _TreeEntry__Prototype + TreeEntry__Repr _TreeEntry__ReprPrototype + Tree_Link _Tree_Link__Prototype + Tree_Link__Repr _Tree_Link__ReprPrototype } // --- type definitions follow --- @@ -59,15 +59,25 @@ type _Blob struct{ x []byte } // Commit matches the IPLD Schema type "Commit". It has Struct type-kind, and may be interrogated like map kind. type Commit = *_Commit type _Commit struct { + tree _Tree_Link + parents _Commit_Link_List + message _String author _PersonInfo__Maybe committer _PersonInfo__Maybe - message _String - parents _ListParents - tree _LinkTree encoding _String__Maybe signature _GpgSig__Maybe - mergeTag _ListTag - other _ListString + mergetag _Tag_List + other _String_List +} + +// Commit_Link matches the IPLD Schema type "Commit_Link". It has link kind. +type Commit_Link = *_Commit_Link +type _Commit_Link struct{ x ipld.Link } + +// Commit_Link_List matches the IPLD Schema type "Commit_Link_List". It has list kind. +type Commit_Link_List = *_Commit_Link_List +type _Commit_Link_List struct { + x []_Commit_Link } // GpgSig matches the IPLD Schema type "GpgSig". It has string kind. @@ -78,32 +88,6 @@ type _GpgSig struct{ x string } type Link = *_Link type _Link struct{ x ipld.Link } -// LinkCommit matches the IPLD Schema type "LinkCommit". It has link kind. -type LinkCommit = *_LinkCommit -type _LinkCommit struct{ x ipld.Link } - -// LinkTree matches the IPLD Schema type "LinkTree". It has link kind. -type LinkTree = *_LinkTree -type _LinkTree struct{ x ipld.Link } - -// ListParents matches the IPLD Schema type "ListParents". It has list kind. -type ListParents = *_ListParents -type _ListParents struct { - x []_LinkCommit -} - -// ListString matches the IPLD Schema type "ListString". It has list kind. -type ListString = *_ListString -type _ListString struct { - x []_String -} - -// ListTag matches the IPLD Schema type "ListTag". It has list kind. -type ListTag = *_ListTag -type _ListTag struct { - x []_Tag -} - // PersonInfo matches the IPLD Schema type "PersonInfo". It has Struct type-kind, and may be interrogated like map kind. type PersonInfo = *_PersonInfo type _PersonInfo struct { @@ -117,14 +101,26 @@ type _PersonInfo struct { type String = *_String type _String struct{ x string } +// String_List matches the IPLD Schema type "String_List". It has list kind. +type String_List = *_String_List +type _String_List struct { + x []_String +} + // Tag matches the IPLD Schema type "Tag". It has Struct type-kind, and may be interrogated like map kind. type Tag = *_Tag type _Tag struct { - message _String object _Link + typ _String tag _String tagger _PersonInfo - tagType _String + message _String +} + +// Tag_List matches the IPLD Schema type "Tag_List". It has list kind. +type Tag_List = *_Tag_List +type _Tag_List struct { + x []_Tag } // Tree matches the IPLD Schema type "Tree". It has map kind. @@ -144,3 +140,7 @@ type _TreeEntry struct { mode _String hash _Link } + +// Tree_Link matches the IPLD Schema type "Tree_Link". It has link kind. +type Tree_Link = *_Tree_Link +type _Tree_Link struct{ x ipld.Link } diff --git a/marshal.go b/marshal.go index 2a54d1a..d2610e5 100644 --- a/marshal.go +++ b/marshal.go @@ -37,7 +37,7 @@ func Encode(n ipld.Node, w io.Writer) error { switch repKey { case "object", - "tagType", + "type", "tag", "tagger", "text": diff --git a/tag.go b/tag.go index 9cd6384..95e3197 100644 --- a/tag.go +++ b/tag.go @@ -52,7 +52,7 @@ func DecodeTag(na ipld.NodeAssembler, rd *bufio.Reader) error { out.tagger = *c case bytes.HasPrefix(line, []byte("type ")): - out.tagType = _String{string(line[tagTypePrefixLen:])} + out.typ = _String{string(line[tagTypePrefixLen:])} case len(line) == 0: rest, err := ioutil.ReadAll(rd) if err != nil { @@ -84,7 +84,7 @@ func readMergeTag(hash []byte, rd *bufio.Reader) (Tag, []byte, error) { switch { case bytes.HasPrefix(line, []byte(" type ")): - out.tagType = _String{string(line[1+tagTypePrefixLen:])} + out.typ = _String{string(line[1+tagTypePrefixLen:])} case bytes.HasPrefix(line, []byte(" tag ")): out.tag = _String{string(line[1+tagTagPrefixLen:])} case bytes.HasPrefix(line, []byte(" tagger ")): @@ -121,7 +121,7 @@ func encodeTag(n ipld.Node, w io.Writer) error { return err } - tt, err := n.LookupByString("tagType") + tt, err := n.LookupByString("type") if err != nil { return err } diff --git a/util.go b/util.go index cce6858..d2b8550 100644 --- a/util.go +++ b/util.go @@ -33,7 +33,7 @@ func (l Link) sha() []byte { return cidToSha(cl.Cid) } -func (l LinkTree) sha() []byte { +func (l Tree_Link) sha() []byte { cl, ok := l.x.(cidlink.Link) if !ok { return nil @@ -41,7 +41,7 @@ func (l LinkTree) sha() []byte { return cidToSha(cl.Cid) } -func (l LinkCommit) sha() []byte { +func (l Commit_Link) sha() []byte { cl, ok := l.x.(cidlink.Link) if !ok { return nil From 9218898fbcca343440081ae7ec6387f5b7b94644 Mon Sep 17 00:00:00 2001 From: Rod Vagg Date: Wed, 4 Aug 2021 12:40:00 +1000 Subject: [PATCH 21/22] Add CHANGELOG, minor README fix --- CHANGELOG.md | 9 +++++++++ README.md | 2 +- 2 files changed, 10 insertions(+), 1 deletion(-) create mode 100644 CHANGELOG.md diff --git a/CHANGELOG.md b/CHANGELOG.md new file mode 100644 index 0000000..a368f48 --- /dev/null +++ b/CHANGELOG.md @@ -0,0 +1,9 @@ +# CHANGELOG + +## v0.1.0 + +This release includes BREAKING CHANGES + +* go-ipld-git is now a [go-ipld-prime](https://github.com/ipld/go-ipld-prime) IPLD codec. Use `Decode(na ipld.NodeAssembler, r io.Reader) error` and `Encode(n ipld.Node, w io.Writer) error` for direct use if required. +* There is now only one `Tag` type, `MergeTag` has been removed which had a `text` property. Use `Tag`'s `message` property instead to retrieve the tag message from a commit's `mergetag`. i.e. `/mergetag/message` instead of `/mergetag/text`. +* `PersonInfo` no longer exposes the human-readable RFC3339 format `date` field as a DAG node. The `date` and `timezone` fields are kept as their original string forms (to enable precise round-trips) as they exist in encoded Git data. e.g. `/author/date` now returns seconds in string form rather than an RFC3339 date string. Use this value and `/author/timezone` to reconstruct the original if needed. diff --git a/README.md b/README.md index 9de69ba..00f08d4 100644 --- a/README.md +++ b/README.md @@ -100,7 +100,7 @@ As JSON, real data would look something like: "email": "author@mail", "name": "Author Name" }, - "tagType": "commit" + "type": "commit" } ``` From 6059d7a3399e6229f315d25756fc1fed7e251f02 Mon Sep 17 00:00:00 2001 From: Will Scott Date: Thu, 12 Aug 2021 09:50:53 -0700 Subject: [PATCH 22/22] bump ipld prime --- go.mod | 2 +- go.sum | 8 ++++---- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/go.mod b/go.mod index 348bf95..24fe992 100644 --- a/go.mod +++ b/go.mod @@ -5,6 +5,6 @@ go 1.15 require ( github.com/ipfs/go-block-format v0.0.3 github.com/ipfs/go-cid v0.0.7 - github.com/ipld/go-ipld-prime v0.10.1-0.20210729021320-145d8235e5de + github.com/ipld/go-ipld-prime v0.11.0 github.com/multiformats/go-multihash v0.0.15 ) diff --git a/go.sum b/go.sum index 798a095..379b3c0 100644 --- a/go.sum +++ b/go.sum @@ -11,8 +11,8 @@ 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/ipfs/go-ipfs-util v0.0.2 h1:59Sswnk1MFaiq+VcaknX7aYEyGyGDAA73ilhEK2POp8= github.com/ipfs/go-ipfs-util v0.0.2/go.mod h1:CbPtkWJzjLdEcezDns2XYaehFVNXG9zrdrtMecczcsQ= -github.com/ipld/go-ipld-prime v0.10.1-0.20210729021320-145d8235e5de h1:ywbFKcs58Qbb+SNoSG3b0ZfTSXLUkZmyJDy9Dg33KHU= -github.com/ipld/go-ipld-prime v0.10.1-0.20210729021320-145d8235e5de/go.mod h1:KvBLMr4PX1gWptgkzRjVZCrLmSGcZCb/jioOQwCqZN8= +github.com/ipld/go-ipld-prime v0.11.0 h1:jD/b/22R7CSL+F9xNffcexs+wO0Ji/TfwXO/TWck+70= +github.com/ipld/go-ipld-prime v0.11.0/go.mod h1:+WIAkokurHmZ/KwzDOMUuoeJgaRQktHtEaLglS3ZeV8= 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/klauspost/cpuid/v2 v2.0.4 h1:g0I61F2K2DjRHz1cnxlkNSBIaePVoJIjjnHui8QHbiw= @@ -47,8 +47,8 @@ github.com/multiformats/go-multihash v0.0.15/go.mod h1:D6aZrWNLFTV/ynMpKsNtB40mJ 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/polydawn/refmt v0.0.0-20201211092308-30ac6d18308e h1:ZOcivgkkFRnjfoTcGsDq3UQYiBmekwLA+qg0OjyB/ls= +github.com/polydawn/refmt v0.0.0-20201211092308-30ac6d18308e/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=