Showing preview only (2,180K chars total). Download the full file or copy to clipboard to get everything.
Repository: ipld/go-ipld-prime
Branch: master
Commit: b6ff5a2d5c06
Files: 377
Total size: 2.0 MB
Directory structure:
gitextract_6epy99x4/
├── .gitattributes
├── .github/
│ ├── actions/
│ │ └── go-test-setup/
│ │ └── action.yml
│ ├── dependabot.yml
│ └── workflows/
│ ├── generated-pr.yml
│ ├── go-check.yml
│ ├── go-test-prime.yml
│ ├── go-test.yml
│ ├── release-check.yml
│ ├── releaser.yml
│ ├── stale.yml
│ └── tagpush.yml
├── .gitmodules
├── CHANGELOG.md
├── HACKME.md
├── HACKME_builderBehaviors.md
├── HACKME_mergeStrategy.md
├── HACKME_releases.md
├── LICENSE
├── README.md
├── README_migrationGuide.md
├── adl/
│ ├── interface.go
│ └── rot13adl/
│ ├── example_test.go
│ ├── rot13logic.go
│ ├── rot13node.go
│ ├── rot13node_test.go
│ ├── rot13prototypes.go
│ ├── rot13reification.go
│ └── rot13substrate.go
├── adl.go
├── codec/
│ ├── README.md
│ ├── api.go
│ ├── cbor/
│ │ ├── multicodec.go
│ │ └── roundtrip_test.go
│ ├── dagcbor/
│ │ ├── common.go
│ │ ├── doc.go
│ │ ├── marshal.go
│ │ ├── marshal_test.go
│ │ ├── multicodec.go
│ │ ├── nongreedy_test.go
│ │ ├── roundtripCidlink_test.go
│ │ ├── roundtrip_test.go
│ │ ├── unmarshal.go
│ │ └── unmarshal_test.go
│ ├── dagjson/
│ │ ├── marshal.go
│ │ ├── marshal_test.go
│ │ ├── multicodec.go
│ │ ├── nongreedy_test.go
│ │ ├── options_test.go
│ │ ├── roundtripBytes_test.go
│ │ ├── roundtripCidlink_test.go
│ │ ├── roundtrip_test.go
│ │ └── unmarshal.go
│ ├── decode_test.go
│ ├── json/
│ │ ├── marshal_test.go
│ │ └── multicodec.go
│ └── raw/
│ ├── codec.go
│ └── codec_test.go
├── codec.go
├── codecHelpers.go
├── codecHelpers_test.go
├── datamodel/
│ ├── copy.go
│ ├── copy_test.go
│ ├── doc.go
│ ├── equal.go
│ ├── equal_test.go
│ ├── errors.go
│ ├── kind.go
│ ├── kind_test.go
│ ├── link.go
│ ├── node.go
│ ├── nodeBuilder.go
│ ├── path.go
│ ├── pathSegment.go
│ ├── path_test.go
│ └── unit.go
├── datamodel.go
├── doc.go
├── examples_test.go
├── fluent/
│ ├── bench_test.go
│ ├── doc.go
│ ├── fluentBuilder.go
│ ├── fluentBuilder_test.go
│ ├── fluentRecover.go
│ ├── fluentRecover_test.go
│ ├── qp/
│ │ ├── example_test.go
│ │ └── qp.go
│ ├── reflect.go
│ ├── reflect_test.go
│ ├── toInterfaceValue.go
│ └── toInterfaceValue_test.go
├── go.mod
├── go.sum
├── linking/
│ ├── cid/
│ │ ├── HACKME.md
│ │ ├── cidLink.go
│ │ ├── linksystem.go
│ │ └── memorystorage.go
│ ├── errors.go
│ ├── functions.go
│ ├── functions_test.go
│ ├── linkingExamples_test.go
│ ├── preload/
│ │ └── preload.go
│ ├── setup.go
│ └── types.go
├── linking.go
├── multicodec/
│ ├── defaultRegistry.go
│ └── registry.go
├── must/
│ └── must.go
├── node/
│ ├── basic/
│ │ └── deprecated.go
│ ├── basicnode/
│ │ ├── HACKME.md
│ │ ├── any.go
│ │ ├── any_test.go
│ │ ├── bench_test.go
│ │ ├── bool.go
│ │ ├── bytes.go
│ │ ├── bytes_stream.go
│ │ ├── bytes_test.go
│ │ ├── float.go
│ │ ├── int.go
│ │ ├── int_test.go
│ │ ├── link.go
│ │ ├── list.go
│ │ ├── list_test.go
│ │ ├── map.go
│ │ ├── map_test.go
│ │ ├── prototypes.go
│ │ ├── string.go
│ │ └── string_test.go
│ ├── bindnode/
│ │ ├── api.go
│ │ ├── api_test.go
│ │ ├── custom_test.go
│ │ ├── example_test.go
│ │ ├── fuzz_test.go
│ │ ├── generate.go
│ │ ├── infer.go
│ │ ├── infer_test.go
│ │ ├── node.go
│ │ ├── registry/
│ │ │ ├── registry.go
│ │ │ └── registry_test.go
│ │ ├── repr.go
│ │ ├── schema_test.go
│ │ └── testdata/
│ │ └── fuzz/
│ │ └── FuzzBindnodeViaDagCBOR/
│ │ ├── 164dd28629e6a5637f02c6eaad32eee5bf8ea41ce6d1dae95334a7db7dd6188f
│ │ ├── 199afa754020c4587bc87633033b4e56ecdb5ecc2bb0dbac46b799d6c18c5201
│ │ ├── 2c17d42168478a0837ebba66f6aa98bdf4bb81b5196062d0e6b23c8b0325be6a
│ │ ├── 425499b0c3693d87a0b11db10d21c540283dfb88610d114eb5b23485d5c2f342
│ │ ├── 636f8e5cdaf52572b826e615a9bdf90f15f8acf2880b467b3949f5356c2ddded
│ │ ├── 669d57fbbe55b8ceb7e78e3ccd3b90e76c4b740d25284a66eac8aac0dbb2475d
│ │ ├── 7f9a6898dead41ba2f5fd4f07f2ddb44d54e7648d66e54982d09996bc720cf56
│ │ ├── 821c248529299bb6b68e443e4b00cc11c6605f766f25e619d85e6d6b40a33dac
│ │ ├── bf7c410983f3e696a03e743df1bc6f606137871f7fb557af74836b7aa04e56ad
│ │ ├── dc95e9aad454ed9109e93b824f92d4bb00c9c778af29e6fcb38a6083c78d7dbb
│ │ ├── f63d4652cdac3208fc0a0d0b755615320443b60ef80c0ecdef99c9d895ae2124
│ │ └── fe73a19655fff8b93193c3e90f9cd7b24b10ae0467175cf2264ff3ec135215a6
│ ├── doc.go
│ ├── gendemo/
│ │ ├── doc.go
│ │ ├── gen.go
│ │ ├── gendemo_test.go
│ │ ├── ipldsch_minima.go
│ │ ├── ipldsch_satisfaction.go
│ │ └── ipldsch_types.go
│ ├── mixins/
│ │ ├── HACKME.md
│ │ ├── bool.go
│ │ ├── bytes.go
│ │ ├── delim.go
│ │ ├── delim_test.go
│ │ ├── float.go
│ │ ├── int.go
│ │ ├── link.go
│ │ ├── list.go
│ │ ├── map.go
│ │ ├── string.go
│ │ └── tmplMixin.txt
│ └── tests/
│ ├── HACKME.md
│ ├── byteSpecs.go
│ ├── checkers.go
│ ├── checkers_test.go
│ ├── corpus/
│ │ ├── corpus.go
│ │ ├── corpus_test.go
│ │ └── util.go
│ ├── listSpecs.go
│ ├── mapBenchmarks.go
│ ├── mapBenchmarks_test.go
│ ├── mapFixtures.go
│ ├── mapSpecs.go
│ ├── marshalBenchmarks.go
│ ├── schema.go
│ ├── schemaLinks.go
│ ├── schemaLists.go
│ ├── schemaMaps.go
│ ├── schemaScalars.go
│ ├── schemaStruct.go
│ ├── schemaStructReprListpairs.go
│ ├── schemaStructReprStringjoin.go
│ ├── schemaStructReprTuple.go
│ ├── schemaStructsContainingMaybe.go
│ ├── schemaUnions.go
│ ├── schemaUnionsKinded.go
│ ├── schemaUnionsStringprefix.go
│ ├── stringSpecs.go
│ ├── testEngine.go
│ ├── testcase.go
│ ├── testutil.go
│ ├── traversalBenchmarks.go
│ ├── unmarshalBenchmarks.go
│ └── util.go
├── operations.go
├── printer/
│ ├── doc.go
│ ├── printer.go
│ └── printer_test.go
├── schema/
│ ├── dmt/
│ │ ├── compile.go
│ │ ├── doc.go
│ │ ├── gen.go
│ │ ├── operations.go
│ │ ├── roundtrip_test.go
│ │ ├── schema.go
│ │ └── types.go
│ ├── dsl/
│ │ ├── parse.go
│ │ └── parse_test.go
│ ├── errors.go
│ ├── gen/
│ │ └── go/
│ │ ├── HACKME.md
│ │ ├── HACKME_abbrevs.md
│ │ ├── HACKME_dry.md
│ │ ├── HACKME_maybe.md
│ │ ├── HACKME_memorylayout.md
│ │ ├── HACKME_scalars.md
│ │ ├── HACKME_templates.md
│ │ ├── HACKME_testing.md
│ │ ├── HACKME_tradeoffs.md
│ │ ├── HACKME_wip.md
│ │ ├── README.md
│ │ ├── README_behaviors.md
│ │ ├── README_wishes.md
│ │ ├── _test/
│ │ │ └── .gitignore
│ │ ├── adjunctCfg.go
│ │ ├── externUtil.go
│ │ ├── genBool.go
│ │ ├── genBoolReprBool.go
│ │ ├── genBytes.go
│ │ ├── genBytesReprBytes.go
│ │ ├── genFloat.go
│ │ ├── genFloatReprFloat.go
│ │ ├── genInt.go
│ │ ├── genIntReprInt.go
│ │ ├── genLink.go
│ │ ├── genLinkReprLink.go
│ │ ├── genList.go
│ │ ├── genListReprList.go
│ │ ├── genMap.go
│ │ ├── genMapReprMap.go
│ │ ├── genString.go
│ │ ├── genStringReprString.go
│ │ ├── genStruct.go
│ │ ├── genStructReprMap.go
│ │ ├── genStructReprStringjoin.go
│ │ ├── genStructReprTuple.go
│ │ ├── genUnion.go
│ │ ├── genUnionReprKeyed.go
│ │ ├── genUnionReprKinded.go
│ │ ├── genUnionReprStringprefix.go
│ │ ├── generate.go
│ │ ├── generators.go
│ │ ├── genpartsCommon.go
│ │ ├── genpartsList.go
│ │ ├── genpartsMap.go
│ │ ├── genpartsMinima.go
│ │ ├── genpartsStrictoid.go
│ │ ├── mixins/
│ │ │ ├── boolGenMixin.go
│ │ │ ├── bytesGenMixin.go
│ │ │ ├── floatGenMixin.go
│ │ │ ├── intGenMixin.go
│ │ │ ├── kindTraits.go
│ │ │ ├── linkGenMixin.go
│ │ │ ├── listGenMixin.go
│ │ │ ├── mapGenMixin.go
│ │ │ ├── stringGenMixin.go
│ │ │ └── templateUtil.go
│ │ ├── templateUtil.go
│ │ ├── testEngine_disabled_test.go
│ │ ├── testEngine_nocgo_test.go
│ │ ├── testEngine_plugin_test.go
│ │ ├── testEngine_test.go
│ │ ├── testLinks_test.go
│ │ ├── testLists_test.go
│ │ ├── testMaps_test.go
│ │ ├── testScalars_test.go
│ │ ├── testStructReprStringjoin_test.go
│ │ ├── testStructReprTuple_test.go
│ │ ├── testStruct_test.go
│ │ ├── testStructsContainingMaybe_test.go
│ │ ├── testUnionsKinded_test.go
│ │ ├── testUnionsStringprefix_test.go
│ │ └── testUnions_test.go
│ ├── kind.go
│ ├── maybe.go
│ ├── tmpBuilders.go
│ ├── type.go
│ ├── typeMethods.go
│ ├── typedNode.go
│ ├── typesystem.go
│ └── validate.go
├── schema.go
├── storage/
│ ├── README_adapters.md
│ ├── api.go
│ ├── benchmarks/
│ │ ├── README.md
│ │ ├── go.mod
│ │ ├── go.sum
│ │ └── storageBenchmarks_test.go
│ ├── bsadapter/
│ │ ├── README.md
│ │ ├── bsadapter.go
│ │ ├── go.mod
│ │ └── go.sum
│ ├── bsrvadapter/
│ │ ├── README.md
│ │ ├── bsrvadapter.go
│ │ ├── go.mod
│ │ └── go.sum
│ ├── doc.go
│ ├── dsadapter/
│ │ ├── README.md
│ │ ├── dsadapter.go
│ │ ├── go.mod
│ │ └── go.sum
│ ├── fsstore/
│ │ └── fsstore.go
│ ├── funcs.go
│ ├── memstore/
│ │ └── memstore.go
│ ├── sharding/
│ │ ├── sharding.go
│ │ ├── sharding.test
│ │ ├── sharding_bench_test.go
│ │ └── sharding_test.go
│ └── tests/
│ ├── benchmarks.go
│ └── generators.go
├── testutil/
│ ├── garbage/
│ │ ├── garbage.go
│ │ └── garbage_test.go
│ ├── indent.go
│ ├── indent_test.go
│ ├── multibytenode.go
│ ├── multibytenode_test.go
│ └── simplebytes.go
├── traversal/
│ ├── common.go
│ ├── doc.go
│ ├── example_select_links_test.go
│ ├── fns.go
│ ├── focus.go
│ ├── focus_test.go
│ ├── patch/
│ │ ├── eval.go
│ │ ├── parse.go
│ │ ├── patch.ipldsch
│ │ └── patch_test.go
│ ├── select_links.go
│ ├── select_links_test.go
│ ├── selector/
│ │ ├── builder/
│ │ │ ├── builder.go
│ │ │ └── builder_test.go
│ │ ├── condition.go
│ │ ├── condition_test.go
│ │ ├── exploreAll.go
│ │ ├── exploreAll_test.go
│ │ ├── exploreFields.go
│ │ ├── exploreFields_test.go
│ │ ├── exploreIndex.go
│ │ ├── exploreIndex_test.go
│ │ ├── exploreInterpretAs.go
│ │ ├── exploreRange.go
│ │ ├── exploreRange_test.go
│ │ ├── exploreRecursive.go
│ │ ├── exploreRecursiveEdge.go
│ │ ├── exploreRecursive_test.go
│ │ ├── exploreUnion.go
│ │ ├── exploreUnion_test.go
│ │ ├── fieldKeys.go
│ │ ├── matcher.go
│ │ ├── matcher_test.go
│ │ ├── matcher_util.go
│ │ ├── parse/
│ │ │ ├── selector_parse.go
│ │ │ └── selector_parse_test.go
│ │ ├── selector.go
│ │ └── spec_test.go
│ ├── walk.go
│ ├── walk_test.go
│ └── walk_with_stop_test.go
└── version.json
================================================
FILE CONTENTS
================================================
================================================
FILE: .gitattributes
================================================
**/testdata/fuzz/** binary
================================================
FILE: .github/actions/go-test-setup/action.yml
================================================
name: go-ipld-prime custom action setup
description: Adds additional options to `go test` to skip behavior tests in the main test executions
runs:
using: "composite"
steps:
- name: Disable codegen behavior tests
shell: bash
run: |
echo "GOFLAGS=$GOFLAGS -tags=skipgenbehavtests" >> $GITHUB_ENV
================================================
FILE: .github/dependabot.yml
================================================
version: 2
updates:
- package-ecosystem: "gomod"
directory: "/"
schedule:
interval: "weekly"
- package-ecosystem: "gomod"
directory: "/storage/dsadapter/"
schedule:
interval: "weekly"
- package-ecosystem: "gomod"
directory: "/storage/benchmarks/"
schedule:
interval: "weekly"
- package-ecosystem: "gomod"
directory: "/storage/bsadapter/"
schedule:
interval: "weekly"
- package-ecosystem: "gomod"
directory: "/storage/bsrvadapter/"
schedule:
interval: "weekly"
================================================
FILE: .github/workflows/generated-pr.yml
================================================
name: Close Generated PRs
on:
schedule:
- cron: '0 0 * * *'
workflow_dispatch:
permissions:
issues: write
pull-requests: write
jobs:
stale:
uses: ipdxco/unified-github-workflows/.github/workflows/reusable-generated-pr.yml@v1
================================================
FILE: .github/workflows/go-check.yml
================================================
name: Go Checks
on:
pull_request:
push:
branches: ["master"]
workflow_dispatch:
permissions:
contents: read
concurrency:
group: ${{ github.workflow }}-${{ github.event_name }}-${{ github.event_name == 'push' && github.sha || github.ref }}
cancel-in-progress: true
jobs:
go-check:
uses: ipdxco/unified-github-workflows/.github/workflows/go-check.yml@v1.0
================================================
FILE: .github/workflows/go-test-prime.yml
================================================
on: [push, pull_request]
name: Go Test (go-ipld-prime custom)
# Similar to go-test.yml but runs only on Linux and doesn't run tests with
# coverpkg so we can properly execute the codegen behavior tests which are
# skipped in go-test.yml execution.
jobs:
unit:
strategy:
fail-fast: false
matrix:
os: [ "ubuntu" ]
go: [ "1.24.x", "1.25.x" ]
runs-on: ${{ format('{0}-latest', matrix.os) }}
name: ${{ matrix.os }} (go ${{ matrix.go }})
steps:
- uses: actions/checkout@v2
with:
submodules: recursive
- uses: actions/setup-go@v2
with:
go-version: ${{ matrix.go }}
- name: Go information
run: |
go version
go env
- name: Run tests
uses: protocol/multiple-go-modules@v1.2
with:
run: |
go test -v ./...
================================================
FILE: .github/workflows/go-test.yml
================================================
name: Go Test
on:
pull_request:
push:
branches: ["master"]
workflow_dispatch:
permissions:
contents: read
concurrency:
group: ${{ github.workflow }}-${{ github.event_name }}-${{ github.event_name == 'push' && github.sha || github.ref }}
cancel-in-progress: true
jobs:
go-test:
uses: ipdxco/unified-github-workflows/.github/workflows/go-test.yml@v1.0
secrets:
CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
================================================
FILE: .github/workflows/release-check.yml
================================================
name: Release Checker
on:
pull_request_target:
paths: [ 'version.json' ]
types: [ opened, synchronize, reopened, labeled, unlabeled ]
workflow_dispatch:
permissions:
contents: write
pull-requests: write
concurrency:
group: ${{ github.workflow }}-${{ github.ref }}
cancel-in-progress: true
jobs:
release-check:
uses: ipdxco/unified-github-workflows/.github/workflows/release-check.yml@v1.0
================================================
FILE: .github/workflows/releaser.yml
================================================
name: Releaser
on:
push:
paths: [ 'version.json' ]
workflow_dispatch:
permissions:
contents: write
concurrency:
group: ${{ github.workflow }}-${{ github.sha }}
cancel-in-progress: true
jobs:
releaser:
uses: ipdxco/unified-github-workflows/.github/workflows/releaser.yml@v1.0
================================================
FILE: .github/workflows/stale.yml
================================================
name: Close Stale Issues
on:
schedule:
- cron: '0 0 * * *'
workflow_dispatch:
permissions:
issues: write
pull-requests: write
jobs:
stale:
uses: ipdxco/unified-github-workflows/.github/workflows/reusable-stale-issue.yml@v1
================================================
FILE: .github/workflows/tagpush.yml
================================================
name: Tag Push Checker
on:
push:
tags:
- v*
permissions:
contents: read
issues: write
concurrency:
group: ${{ github.workflow }}-${{ github.ref }}
cancel-in-progress: true
jobs:
releaser:
uses: ipdxco/unified-github-workflows/.github/workflows/tagpush.yml@v1.0
================================================
FILE: .gitmodules
================================================
[submodule ".ipld"]
path = .ipld
url = https://github.com/ipld/ipld/
================================================
FILE: CHANGELOG.md
================================================
CHANGELOG
=========
Here is collected some brief notes on major changes over time, sorted by tag in which they are first available.
Of course for the "detailed changelog", you can always check the commit log! But hopefully this summary _helps_.
Note about version numbering: All release tags are in the "v0.${x}" range. _We do not expect to make a v1 release._
Nonetheless, this should not be taken as a statement that the library isn't _usable_ already.
Much of this code is used in other libraries and products, and we do take some care about making changes.
(If you're ever wondering about stability of a feature, ask -- or contribute more tests ;))
- [Planned/Upcoming Changes](#planned-upcoming-changes)
- [Released Changes Log](#released-changes)
Planned/Upcoming Changes
------------------------
Here are some outlines of changes we intend to make that affect the public API:
- **IPLD Amend**: is likely to land soon; it implements a more efficient underlying architecture to support IPLD Patch and related features. IPLD Amend adds an interface to allow incremental changes to `Node`s in an efficient way. Whereas IPLD Patch is a protocol for expressing changes. We're still working on figuring out exactly where it fits in the stack and making sure it won't be disruptive but early benchmarks are very promising for both Patch and traversal-based transforms. See https://github.com/ipld/go-ipld-prime/pull/445 for more.
- **Layered `Node` implementation optimizations**: When layering different implementations of `Node` builders or consumers, having to defer through basicnode types can lead to large inefficiencies of memory and speed. We are looking at ways to improve this situation, including ways to *assemble* layered assemblers. See https://github.com/ipld/go-ipld-prime/issues/443 for discussion and some initial plans.
- **Selectors**: There have been some recurring wishes to do something about the Selector package layout. There's no intended or prioritized date for this. See https://github.com/ipld/go-ipld-prime/issues/236 for more.
- **Absent / "Not found" values**: There may be some upcoming changes to exactly how "not found" values are handled in order to clarify and standardize the subject. There's no finalized date for this. See https://github.com/ipld/go-ipld-prime/issues/360 for more.
Released Changes
----------------
### v0.21.0
_2023 August 10_
go-ipld-prime's release policy says that:
> even numbers should be easy upgrades; odd numbers may change things
This release is an odd number, and it does change some minor things.
#### 🛠 Breaking
* **Build**: The minimum version of Go has been bumped from 1.18 to **1.19**.
* **Dependencies**: The go-cid dependency was upgraded from v0.3.2 to **v0.4.1**. This is a relatively minor change but the introduction of `ErrInvalidCid` wrapping may be breaking for some users.
* **Selectors**: Remove hard error when a traversal encounters a slice matcher with a node that is not a string or bytes, by @rvagg [#529](https://github.com/ipld/go-ipld-prime/pull/529)
#### 🔦 Features
* **Traversal**: `Preloader` functionality, by @hannahhoward and @rvagg [#452](https://github.com/ipld/go-ipld-prime/pull/452)
* See the [traversal](https://pkg.go.dev/github.com/ipld/go-ipld-prime/traversal) package documentation for more information on how a `Preloader` can be used to introduce parallelism into a traversal. The [Lassie](https://github.com/filecoin-project/lassie) project is currently using this functionality to speed up Bitswap block fetching; future releases of go-ipld-prime may include additional functionality being prototyped in Lassie to manage parallelism and caching.
* **Schemas**: Support `listpairs` struct representation in DSL parsing, by @rvagg [#514](https://github.com/ipld/go-ipld-prime/pull/514)
* **Schemas**: Support `inline` union representation in DSL parsing, by @rvagg [#527](https://github.com/ipld/go-ipld-prime/pull/527)
* **Bindnode**: Support `listpairs` struct representation, by @rvagg [#514](https://github.com/ipld/go-ipld-prime/pull/514)
* **Selectors**: Support negative values for slice matcher's `From` and `To`, by @rvagg [#530](https://github.com/ipld/go-ipld-prime/pull/530)
* The slice matcher is currently being used to support byte-range fetching for the [IPFS Trustless Gateway](https://specs.ipfs.tech/http-gateways/trustless-gateway/) specification. Work is ongoing and can be seen in both the [Lassie](https://github.com/filecoin-project/lassie) and [Frisbii](https://github.com/filecoin-project/lassie) projects.
* _Please note that this feature is currently considered **experimental** and shoule be used with care and with the expectation that it may change in the near future. Expect a release or two before this feature is considered stable._
#### 🩹 Fixes
* **Traversal**: `StartAtPath` work properly for matching walks, by @rvagg [#500](https://github.com/ipld/go-ipld-prime/pull/500)
* **Traversal**: `WalkTransforming()` work properly, by @EdSchouten [#516](https://github.com/ipld/go-ipld-prime/pull/516)
* **Basicnode**: `basic.NewInt()` returns a pointer like other constructors, by @hacdias [#525](https://github.com/ipld/go-ipld-prime/pull/525)
* **Selectors**: Cache offsets for sequential reads in slice matcher, by @rvagg [#529](https://github.com/ipld/go-ipld-prime/pull/529)
#### 🌟 Thanks!
Thanks to @hacdias and @EdSchouten for their first contributions to go-ipld-prime!
### v0.20.0
go-ipld-prime's release policy says that:
> even numbers should be easy upgrades; odd numbers may change things
As such, v0.20.0 is a relatively minor release with a grab-bag of small improvements and fixes.
_2023 February 11_
Schema errors can now [`errors.Is`](https://pkg.go.dev/errors#Is):
* \[[`61c9ab10d4`](https://github.com/ipld/go-ipld-prime/commit/61c9ab10d4)] - **feat**: support errors.Is for schema errors (Ian Davis) [#476](https://github.com/ipld/go-ipld-prime/pull/476)
Schema DMT (schema/dmt) is now more usable from the outside and has a new `ConcatenateSchemas` function that can be used to combine two schemas into one:
* \[[`db9d8a7512`](https://github.com/ipld/go-ipld-prime/commit/db9d8a7512)] - Export schema/dmt.TypeSystem. (Eric Myhre) [#483](https://github.com/ipld/go-ipld-prime/pull/483)
* \[[`39818c169a`](https://github.com/ipld/go-ipld-prime/commit/39818c169a)] - Add a SchemaConcatenate operation. (Eric Myhre) [#483](https://github.com/ipld/go-ipld-prime/pull/483)
* \[[`c68ba53c67`](https://github.com/ipld/go-ipld-prime/commit/c68ba53c67)] - More accurate name for structure that contains easy access to prototypes. (Eric Myhre) [#483](https://github.com/ipld/go-ipld-prime/pull/483)
* \[[`2ecabf1217`](https://github.com/ipld/go-ipld-prime/commit/2ecabf1217)] - Add several pieces of docs to schema/dmt. (Eric Myhre)
* \[[`33475f0448`](https://github.com/ipld/go-ipld-prime/commit/33475f0448)] - Fix mispatched package declaration. (Eric Myhre)
The DAG-CBOR codec now has an `DontParseBeyondEnd` option (default `false`) that allows it to parse undelimited streamed objects. This matches the same functionality already in DAG-JSON and should only be used for specialised cases:
* \[[`7b00b1490f`](https://github.com/ipld/go-ipld-prime/commit/7b00b1490f)] - feat(dagcbor): mode to allow parsing undelimited streamed objects (Rod Vagg) [#490](https://github.com/ipld/go-ipld-prime/pull/490)
`datamodel.Copy` got some direct test coverage and will now complain if you try to copy a `nil` node:
* \[[`f4bb2daa27`](https://github.com/ipld/go-ipld-prime/commit/f4bb2daa27)] - fix(datamodel): add tests to Copy, make it complain on nil (Rod Vagg) [#491](https://github.com/ipld/go-ipld-prime/pull/491)
The LinkSystem data loading check will compare links (CIDs) to ensure it loaded what you wanted; this now properly supports the case where your link is a pointer:
* \[[`1fc56b8e7a`](https://github.com/ipld/go-ipld-prime/commit/1fc56b8e7a)] - Fix hash mismatch error on matching link pointer (Masih H. Derkani) [#480](https://github.com/ipld/go-ipld-prime/pull/480)
### v0.19.0
_2022 October 13_
go-ipld-prime's release policy says that:
> even numbers should be easy upgrades; odd numbers may change things
The major change in this release is a bump to Go 1.18.
#### 🛠 Breaking Changes
Update go.mod to Go 1.18.
#### 🔦 Highlights
* **Codecs**: [Correct JSON codec Bytes handling](https://github.com/ipld/go-ipld-prime/pull/472). This change does not impact DAG-JSON, which is the generally recommended codec for JSON output as the JSON codec cannot properly handle Bytes or Links.
* **Dependencies**:
* Update to go-multihash@v0.2.1: https://github.com/multiformats/go-multihash/releases/tag/v0.2.1
* Update to go-multicodec@v0.6.0: https://github.com/multiformats/go-multicodec/releases/tag/v0.6.0
* Update to go-cid@v0.3.2: https://github.com/ipfs/go-cid/compare/v0.2.0...v0.3.2
### v0.18.0
_2022 August 01_
go-ipld-prime's release policy says that:
> even numbers should be easy upgrades; odd numbers may change things
So, as an even number, this v0.18.0 release should be a smooth ride for upgraders from v0.17.0. We have 3 major feature additions, all focused on [Bindnode](https://pkg.go.dev/github.com/ipld/go-ipld-prime/node/bindnode).
#### 🔦 Highlights
* **Bindnode**: [Custom Go type converters](https://github.com/ipld/go-ipld-prime/pull/414) - Bindnode performs bidirectional mapping of Go types to the IPLD Data Model, and in doing so, it assumes a straightforward mapping of values to their encoded forms. But there are common cases where a Go type doesn't have a straightforward path to serialization, either because the encoded form needs a custom layout, or because bindnode doesn't have enough information to infer a serialization pattern. Custom Go type converters for bindnode allow a user to supply a pair of converter functions for a Go type that dictate how to map that type to an IPLD Data Model kind. See the **[bindnode documentation](https://pkg.go.dev/github.com/ipld/go-ipld-prime/node/bindnode)** for more information.
* **Bindnode**: [Type registry](https://github.com/ipld/go-ipld-prime/pull/437) - Setting up Go type mappings with Bindnode involves some boilerplate. A basic type registry is now available that takes some of this boilerplate away; giving you a single place to register, and perform conversions to and from Go types, Data Model (`Node`) forms or directly through serialization. See the **[bindnode/registry documentation](https://pkg.go.dev/github.com/ipld/go-ipld-prime/node/bindnode/registry)** for more information.
* **Bindnode** [Full `uint64` support](https://github.com/ipld/go-ipld-prime/pull/414/commits/87211682cb963ef1c98fa63909f67a8b02d1108c) - the `uint64` support introduced in go-ipld-prime@v0.17.0 has been wired into Bindnode. The Data Model (`Node`) forms expose integers as `int64` values, which is lossy for unsigned 64-bit integers. Bindnode Go types using `uint64` values are now lossless in round-trips through serialization to codecs that support the full range (DAG-CBOR most notably).
You can see all of these new features in action using Filecoin Go types, allowing a mapping between Go types, Data Model (`Node`) forms, and their DAG-CBOR serialized forms with [data-transfer vouchers](https://github.com/filecoin-project/go-fil-markets/pull/713). These features also allow us to interact with the original Go types, without modification, including `big.Int` serialization to `Bytes`, Filecoin `Signature` serialization to a byte-prefix discriminated `Bytes` and more. Since the Go types are unchanged, they can also simultaneously support [cbor-gen](https://github.com/whyrusleeping/cbor-gen) serialization, allowing an easier migration path.
### v0.17.0
_2022 Jun 15_
go-ipld-prime's release policy says that:
> even numbers should be easy upgrades; odd numbers may change things
In that spirit, this v0.17.0 release includes some potentially breaking changes. Although minor, they are marked below and they may lead to behavioral changes in your use of this library.
#### 🛠 Breaking Changes
* **Codecs**:
* DAG-CBOR, DAG-JSON: [Error on `cid.Undef` links in dag{json,cbor} encoding](https://github.com/ipld/go-ipld-prime/pull/433) - previously, encoding Link nodes that were empty CIDs (uninitialized zero-value or explicitly `cid.Undef`) would have passed through the DAG-CBOR or DAG-JSON codecs, silently producing erroneous output that wouldn't successfully pass back through a decode. (Rod Vagg)
* **Bindnode**:
* [Panic early if API has been passed ptr-to-ptr](https://github.com/ipld/go-ipld-prime/pull/427) - previous usage of bindnode using pointers-to-pointers may have deferred (or in some cases avoided) panics until deeper usage of the API, this change makes it earlier to make it clear that pointer-to-pointer is not appropriate usage. (Rod Vagg)
* **Build**:
* [Drop Go 1.16.x testing & begin testing Go 1.18.x](https://github.com/ipld/go-ipld-prime/pull/394) (Daniel Martí)
* Note also that in this release, the [github.com/ipfs/**go-cid**](https://github.com/ipfs/go-cid) dependency is upgraded from 0.0.4 to 0.2.0 which includes a breaking change with the removal of the `cid.Codecs` and `cid.CodecToStr` maps which may disruptive. See [the go-cid@0.2.0 release page for details](https://github.com/ipfs/go-cid/releases/tag/v0.2.0).
#### 🔦 Highlights
* **Data Model**:
* [Introduce `UIntNode` interface, used within DAG-CBOR codec to quietly support full uint64 range](https://github.com/ipld/go-ipld-prime/pull/413) (Rod Vagg)
* **Bindnode**:
* Fuzzing and hardening for production use (Daniel Martí)
* Refuse to decode empty union values (Daniel Martí)
* [Allow nilable types for IPLD `optional`/`nullable`](https://github.com/ipld/go-ipld-prime/pull/401) (Daniel Martí)
* [More helpful error message for common enum value footgun](https://github.com/ipld/go-ipld-prime/pull/430) (Rod Vagg)
* [Infer links and `Any` from Go types](https://github.com/ipld/go-ipld-prime/pull/432) (Rod Vagg)
* **Schemas**:
* DMT: Proper checking for unknown union members (Daniel Martí)
* DMT: Enum representations must be valid members (Daniel Martí)
* DMT: Reject duplicate or missing union representation members (Daniel Martí)
* DSL: [Support `stringjoin` struct representation and `stringprefix` union representation](https://github.com/ipld/go-ipld-prime/pull/397) (Eric Evenchick)
* DMT, DSL: [Enable inline types](https://github.com/ipld/go-ipld-prime/pull/404) (Rod Vagg)
* **Patch**:
* [Add initial version of IPLD Patch feature](https://github.com/ipld/go-ipld-prime/pull/350) (Eric Myhre) *(helped across the line by mauve and Rod Vagg)*
* **Codecs**:
* DAG-CBOR: [Reject extraneous content after valid (complete) CBOR object](https://github.com/ipld/go-ipld-prime/pull/386) (Rod Vagg)
* DAG-CBOR: [add `DecodeOptions.ExperimentalDeterminism`](https://github.com/ipld/go-ipld-prime/pull/390) (currently only checking map sorting order) (Daniel Martí)
* Printer: [Fix printing of floats](https://github.com/ipld/go-ipld-prime/pull/412) (Dustin Long)
* DAG-JSON: [Add option to not parse beyond end of structure](https://github.com/ipld/go-ipld-prime/pull/435) (Petar Maymounkov)
* **Build**:
* Fix [macOS](https://github.com/ipld/go-ipld-prime/pull/400) and [Windows](https://github.com/ipld/go-ipld-prime/pull/405) testing (Rod Vagg)
* [Fix 32-bit build support](https://github.com/ipld/go-ipld-prime/pull/407) (Rod Vagg)
* [Make staticcheck and govet happy across codebase](https://github.com/ipld/go-ipld-prime/pull/406) (Rod Vagg)
* Enable full [unified-ci](https://github.com/protocol/.github) GitHub Actions suite, including auto-updating (Rod Vagg)
* [Enable dependabot, with monthly checks](https://github.com/ipld/go-ipld-prime/pull/417) (and update all dependencies) (Rod Vagg)
Special thanks to **Daniel Martí** for many bindnode improvements and hardening, fuzzing across the library and improvements to the Schema DMT and DSL.
### v0.16.0
_2022 March 09_
- New: `traversal.WalkTransforming` is finally implemented! (It's been a stub for quite a while.) This works similarly to the other transform features, but can do more than change to the structure during a single walk.
- New: Selectors support partial/ranged match on bytes or strings nodes. (This is also a new feature for Selectors, recently specified.)
[[#375](https://github.com/ipld/go-ipld-prime/pull/375); seealso specs in [ipld#184](https://github.com/ipld/ipld/pull/184)]
- New: there's a `datamodel.LargeBytesNode` interface, which makes it possible to handle "large" blobs of bytes as a `Node`, without necessarily forcing them all into memory at once. (This is optional; you add the methods to match the interface if your Node implementation supports the feature.)
[[#372](https://github.com/ipld/go-ipld-prime/pull/372)]
- Slightly more specifically: this interface is `Node` plus a method that returns an `io.ReadSeeker`. (Pretty standard golang I/O and byte slice management concepts should carry you from there in the usual ways.)
- This is a **really big deal** -- for example, this means that an [ADL](https://ipld.io/docs/advanced-data-layouts/) can support reading of arbitrarily large bytes without an issue. (Hello, transparently readable large sharded blobs!)
- New: there's a "resume" (or, skipahead) mechanism for traversals and selectors. Engage it by simply setting the `traversal.Config.StartAtPath` field.
[[#358](https://github.com/ipld/go-ipld-prime/pull/358)]
- New: `dagcbor` now has a `EncodedLength(Node) int` function, which can calculate the expected serial message length without actually encoding. (The usefulness of this may be situational, but it's there if you want it.)
- Improved: `bindnode`, yet again, in more ways that can easily be summarized.
- Better support for pointers in more places in your golang types.
- Many panics either fixed or routed into calmer errors.
- Unsigned intergers are now supported in your golang types.
- Some fixes for AssignNode working correctly (e.g. at the type or representation level, as appropriate; sometimes previously it would use the type level incorrectly).
- Various fixes to handling absent fields correctly.
- A `datamodel.Node` can now be used for an `any` field.
- Fixed: selectors now behave correctly for a recursion clause that just contains a recursion edge immedately. (It's still not a sensible selector, really, but it's valid.) Previously this would panic, which was nasty.
- Fixed: `bindnode` now correctly doesn't include absent fields in the count of length when looking at the representation-level view of structs.
- Improved: all our batteries-included codecs double check while encoding that the number iterator steps over a map matches its self-reported length. (This doesn't matter in many cases, but does defend you a little better against a `Node` implementation with a bug, if you happen to be so unlucky.)
- Improved: miscellaneous performance work in the `schema/*` area.
Thank you to @mvdan, @warpfork, @hannahhoward, @rvagg, @willscott, @arajasek and others
for all their work that went into making this release (as well as all the point releases in v0.14.x leading up to it) happen.
Finally, please note that we're starting to try out some new (and slightly more formal) governance and review and merge processes.
Check out https://github.com/ipld/go-ipld-prime/issues/370 for more information.
The aim is to make things generally more inclusive and involve more contributors!
This is still experimental and may be subject to change, but if you'd like to have better expectations about who can review and what the process should be like, we hope this will be a step in a helpful direction.
(Feedback about this experiment welcome!)
### v0.14.x
(There were releases `v0.14.1`, `v0.14.2`, `v0.14.3`, and `v0.14.4` -- but all were in rapid succession, very minor, and hitting the same areas; we'll keep the notes brief and condensed.)
- New: Selectors can include clauses for signalling the use of ADLs!
[[#301](https://github.com/ipld/go-ipld-prime/pull/301); seealso specs in [ipld#149](https://github.com/ipld/ipld/pull/149)+[ipld#170](https://github.com/ipld/ipld/pull/170)]
- Also kindly note that there are expected to be many ways of signalling ADL invocations -- this is only one of them.
See the IPLD website for more on this topic as a whole: https://ipld.io/docs/advanced-data-layouts/signalling/
- Improved: `bindnode`, in ways more various than can easily be summarized.
- The `cidlink.Link` type can be bound to links in the data.
- Enums are now supported.
- The `any` typekind is now supported.
- Improved: both the `schema/dmt` and `schema/dsl` packages (and in some cases, the `schema` package itself) continue to be improved and become more complete.
- Structs with tuple representation are now supported.
- Enums with int representation are now supported.
- The `any` typekind is now supported.
- Changed: the dag-json codec will tolerate padded base64 in bytes content upon read. It does so silently. (It is not still possible to emit this kind of serial data with this library; it is noncanonical.)
[[#309](https://github.com/ipld/go-ipld-prime/pull/309)]
- Changed: the cbor and dag-cbor codec will now tolerate CBOR's "undef" token. It will coerce it to a null token when reading. Previously, encountering the undef token would result in a parse error. (It is still not possible to emit this token with this library.)
[[#308](https://github.com/ipld/go-ipld-prime/pull/308)]
- New: the `traversal` package gained a `WalkLocal` function. This simply does a walk that does not cross any links.
### v0.14.0
_2021 November 11_
This release is a smooth-sailing release, and mostly contains new features, quality-of-life improvements,
and some significant improvements to the completeness and usability of features that have been in development across previous releases.
There shouldn't be a lot of surprises, and upgrading should be easy.
Some of the biggest improvements include: `bindnode` now supports most IPLD features and is increasingly stable;
the `schema` system now has functioning `schema/dmt` and `schema/dsl` packages, and can parse schema documents smoothly(!);
if you haven't seen the `printer` package that first quietly appeared in `v0.12.2`, you should definitely check it out now;
and we have some new `storage` APIs that might be worth checking out, too.
There are also many, many other smaller improvements.
See the complete list and further deatils below
(and don't forget to check out the notes under the other `v0.12.*` headings, if you haven't absorbed those updates already, too!):
- New: `datamodel.Copy`: a helper function to do a shallow copy from one node to another.
- You don't often need this, because nodes are supposed to be immutable!
But it still sometimes comes in handy, for example, if you want to change the memory layout you're using by moving data into a different node implementation.
- Improved: documentation of APIs. (Especially, for subtler bits like `NodeAssembler.AssignNode`.)
- New: `datamodel.Link` now requires a `Binary()` function. In contrast to `Link.String()` (which is supposed to return something printable), `Link.Binary()` should give you the rawest thing possible. (It's equivalent to `go-cid.CID.KeyString`.)
- New: **a new storage API**, including one **batteries-included** filesystem storage implementation, and **adapters** to several other different storage APIs. [[#265](https://github.com/ipld/go-ipld-prime/pull/265), [#279](https://github.com/ipld/go-ipld-prime/pull/279)]
- The primary goal of this is the "batteries included" part: using the new `storage/fsstore` package, you should now be able to make simple applications with IPLD and use a simple sharded disk storage system (it'll look vaguely like a `.git/objects` directory), and do it in about five minutes and without pulling in any additional complex dependencies.
- If you want to develop new storage systems or make adapters to them: the APIs in `storage` package are designed to be implemented easily.
- The `storage` APIs are designed entirely around types found in the golang standard library. You do not need to import anything in the `storage` package in order to implement its interfaces!
- The minimal APIs that a storage system has to implement are _very_ small. Two functions. Every additional feature, or optimization that you can offer: those all have their own interfaces, and we use feature-detection on them. You can implement as much or as little as you like.
- As a user of the storage APIs: use the functions in the `storage` package. Those functions take a storage system as a parameter, and will do feature detection _for you_.
- This means you can always write your code to call the APIs you _want_, and the `storage` functions will figure out how to map it onto the storage system that you _have_ (whatever it supports) in the most efficient way it can.
- As a user of the `LinkSystem` API: you can ignore most of this! If you want to use the new `storage` APIs, there are setup methods on `LinkSystem` that will take them as a parameter. If you have existing code wired up with the previous APIs, it still works too.
- As someone who already has code and wonders how to migrate:
- If you're using the `linking.Storage*Opener` API: you don't have to do anything. Those still work too.
- If you were using code from other repos like `ipfs/go-ipfs-blockstore` or `ipfs/go-datastore` or so on: those have adapters now in the `storage/*adapter` packages! You should now be able to use those more easily, with less custom glue code. (There's also now a migration readme in the repo root: check that out.)
- If you would like to ask: "is it fast?" -- yes. You'll find that the new `storage/fsstore`, our batteries-included filesystem storage system, is comparable (or beating) the `go-ds-flatfs` package that you may have been using in the past. (More benchmarks and any performance improvement patches will of course be welcome -- but at the very least, there's no reason to hold back on using the new system.)
- New: `LinkSystem` has some new methods: `LoadRaw` and `LoadPlusRaw` give you the ability to get data model nodes loaded, and _also_ receive the raw binary blobs.
- This can be useful if you're building an application that's piping data around to other serial APIs without necessarily transforming it. (No need to reserialize if that's your journey.)
- New: a CLI tool has begun development!
- ... and almost immediately been removed again, to live in its own repo: check out https://github.com/ipld/go-ipldtool .
- Improved: many more things about `bindnode`.
- `bindnode` now understands `go-cid.CID` fields.
- Kinded unions are much more completely supported.
- Many TODO panics have gone away, replaced by finished features.
- `bindnode` will increasingly check that the golang types you give it can be structurally matched to the schema if you provide one, which gives better errors earlier, and increases the ease and safety of use drastically.
- Improved: the `schema/dmt` and `schema/dsl` packages are increasingly complete.
- There are also now helper functions in the root package which will do the whole journey of "load a file, parse the Schema DSL, compile and typecheck the DMT, and give you the type info in handy golang interfaces", all at once! Check out `ipld.LoadSchema`!
- New: there is a codegen feature for `bindnode` which will produce very terse golang structs matching a schema and ready to be bound back to `bindnode`!
- This competes with the older `gengo` code generator -- by comparison, the `bindnode` code generator produces much, _much_ less code. (However, be advised that the performance characteristics are probably also markedly different; and we do not have sufficient benchmarks to comment on this at this time.)
- Internal: many tests are being ported to `quicktest`. There should be no external impact to this, but we look forward to removing some of the other test libraries from our dependency tree in the near future.
- Improved: `printer` now supports links and bytes!
- Improved: `printer` is now more resilient and works even on relatively misbehaved `Node` implementations, such as those which implement `schema.TypedNode` but then rudely and nonsensically return nil type info. (We don't expect all code to be resilient against misbehaved `Node` implementations... but for a debug tool in particular? It's good to have it handle as much as it can.)
This, and the last few releases tagged in the `v0.12.*` series, include invaluable contributions from
@mvdan, @warpfork, @rvagg, @willscott, @masih, @hannahhoward, @aschmahmann, @ribasushi,
and probably yet more others who have contributed through code and design reviews,
or by using these libraries and demanding they continue to become better.
Thanks to each and every one of the people who carry this project forward!
### v0.12.3
_2021 September 30_
(This is a minor release; we'll keep the notes brief.)
- Fixed: using `SkipMe` in a traversal now skips only that subtree of nodes, not the remainder of the block!
[[#251](https://github.com/ipld/go-ipld-prime/pull/251)]
- New: `traversal` features now have budgets! You can set a "budget" value, and watch it monotonically decrement as your operations procede. This makes it easy to put limits on the amount of work you'll do.
[[#260](https://github.com/ipld/go-ipld-prime/pull/260)]
- New: `traversal` features can be configured to visit links they encounter only once (and ignore them if seen again).
[[#252](https://github.com/ipld/go-ipld-prime/pull/252)]
- Note that this is not without caveats: this is not merely an optimization; enabling it _may_ produce logically different outcomes, depending on what your selector is.
This is because links are ignored when seen again, even if they're seen for a different _reason_, via a different path, etc.
- Fixed: a very nasty off-by-one in unions produced by the "gogen" codegen.
[[#257](https://github.com/ipld/go-ipld-prime/pull/257)]
- Improved: the test suites for typed nodes now provide much better coverage (to prevent something like the above from happening again, even in other implementations).
- New: `schema/dsl`! This package contains parsers for the IPLD Schema DSL, and produces data structures in `schema/dmt` form.
- Removed: other misc partially-complete packages. (This will surely bother no one; it's just cleanup.)
- Removed: `codec/jst`. If you were using that, [`jst` has its own repo](https://github.com/warpfork/go-jst/) now.
- Improved: `traversal` now uses the error wrapping ("`%w`") feature in more places.
- Changed: `printer` keeps empty maps and lists and strings on a single line.
- Changed: `schema.TypeName` is now just an alias of `string`. This may result in somewhat less casting; or, you might not notice it.
- Improved: the `schema/dmt` package continues to be improved and become more complete.
- Some changes also track fixes in the schema spec, upstream. (Or caused those fixes!)
- New/Improved: the `schema` package describes several more things which it always should have. Enums, for example.
### v0.12.2
_2021 September 8_
(This is a minor release; we'll keep the notes brief.)
- New: the `printer` package has appeared, and aims to provide an information-rich, debug-readable, human-friendly output of data from an IPLD node tree. [[#238](https://github.com/ipld/go-ipld-prime/pull/238/)]
- This works for both plain data model data, and for typed data, and annotates type information if present.
- Note that this is _not_ a codec: it's specifically _richer_ than that. Conversely, this printer format is not designed to be parsed back to data model data. Use a codec for a codec's job; use the printer for debugging and inspection jobs.
- Fixed/Improved: more things about the `bindnode` system. (It's still early and improving fast.)
- Fixed: json codec, cbor codec, and their dag variants all now return ErrUnexpectedEOF in the conditions you'd expect. (Previously they sometimes just returned EOF, which could be surprising.)
- Changed/Improved: the `schema/dmt` package is now implemented using `bindnode`, and there's a more complete `Compile()` feature. (This is still very early, in this tag. More to come here soon.)
### v0.12.1
_2021 August 30_
(This is a minor release; we'll keep the notes brief.)
- Fixed/Improved: many things about the `bindnode` system. (It's still early and improving fast.)
- Changed: the strings for `schema.TypeKind_*` are lowercase. (The docs and specs all act this way, and always have; it was a strange error for this code to have titlecase.)
- New: the root package contains more helper methods for encoding and decoding operations
### v0.12.0
_2021 August 19_
This release is a momentous one. It contains a sizable refactor:
we've extracted some of the most key interfaces to a new package, called `datamodel`!
It's also an even numbered release tag, which we generally use to indicate "upgrading should be smooth sailing".
Surprisingly, despite the magnitude of the refactor, we mean that, too.
Golang's "alias" feature has been used _heavily_ for this change process,
and downstream code that worked on the previous release should continue to work on this release too, without syntactic changes.
Why did we do this?
The root package, `ipld`, is now going to be a place where we can put helpful functions.
Synthesis functions that put all the pieces of IPLD together for you.
The functions you're probably looking for; the high-level stuff that gets work done.
Previously, the root package was _guts_: the lowest level interfaces, the more core stuff...
which was cool to see (arguably), but tended not to be the things you'd want to see _first_ as a new user.
And because everything _else_ in the world depended on those interface,
we could never put interesting high-level functions in the same package
(or if we tried, compilation would fail, because of import cycles)...
which meant any time we wanted to add helper functions for getting useful work done,
we'd be stuck cramming them off into subpackages somewhere.
While this worked, the discoverability for a new user was terribly arduous.
We hope this pivot to how we organize the code helps you find your way through IPLD!
We haven't yet added many of the new helper features to the updated root package.
Those will come in the very near future.
(Follow along with commits on the master branch if you want to try the new APIs early!)
This release is being made just to cover the refactor, before we steam along any further.
Your existing code should continue working without changes because the root `ipld` package
still contains all the same types -- just as aliases.
You can choose to update your code to use the types where they've moved to
(which is mostly the `datamodel` package), or, if you prefer... just leave it as-is.
Some aliases may be removed over time; if so, they'll be marked with a comment to that effect,
and there should be plenty of warning and time to change.
In some cases, continuing to use the `ipld` package directly will remain acceptable indefinitely.
The new intention is that common work should often be possible to do only by
importing the `ipld` package, and users should only need to dive into
the more specific subpackages if they been to need direct access to more detailed APIs
for performance or other reasons.
That's it for the big refactor news.
There's also some sweet new features in bindnode,
and a few other important fixes to recently introduced features.
In detail:
- Changed: that massive refactor, described above. Gosh it's big.
[[#228](https://github.com/ipld/go-ipld-prime/pull/228)]
- New: the selectors system is tested against the language-agnostic selector specs, from the IPLD specs+docs repo!
[[#231](https://github.com/ipld/go-ipld-prime/pull/231)]
- This uses a new fixture format, called [testmark](https://github.com/warpfork/go-testmark#what-is-the-testmark-format), which is managed by a library called [go-testmark](https://pkg.go.dev/github.com/warpfork/go-testmark).
- The fixtures are drawn in by a git submodule. The actual fixture content remains in the [ipld/ipld](https://github.com/ipld/ipld/) repo.
- These new tests will be run if you have cloned the git submodule (and of course, by CI). If you do not clone the submodule that contains the fixtures, the tests will quietly skip.
- We hope this will be a template for how to do more testing in the future, while keeping it closely coordinated with specs, and in sync with other implementations of IPLD in other languages!
- Improved: bindnode: in a variety of ways.
[[#226](https://github.com/ipld/go-ipld-prime/pull/226)]
- Several error messages are improved.
- Kinded unions support complex recipients even for string kinds. (E.g., putting a struct with stringjoin representation inside a kinded union now works correctly.)
- Stringprefix unions now work even with no explicit delimiter.
- Please note that bindnode is, and remains, considered experimental. While we're improving it, it's still something to use at your own risk.
- Changed/Improved: bindnode: unions are now handled completely differently (and much better).
[[#223](https://github.com/ipld/go-ipld-prime/pull/223)]
- In short: now they expect a golang struct which has a field for each of the possible members, and each of them should be a pointer. This is type safe and works reasonably idiomatically in golang.
- This is a fairly huge improvement, because it fixes the "bindnode unions force downshift into anonymous types" problem, which was tracked as [issue#210](https://github.com/ipld/go-ipld-prime/issues/210).
- Fixed: the selector `ExploreRecursive.stopAt` feature now actually... works. It was completely broken when it was introduced in the last release. (Tests. They're important.)
[[#229](https://github.com/ipld/go-ipld-prime/pull/229)]
- Notice how we've also now got selector tests driven by fixtures appearing in this release. Hopefully that decreases the odds of something like this happening again.
### v0.11.0
_2021 August 12_
This release is an odd numbered release, which means it may contain breaking changes.
Unfortunately, the changes here may be particularly, tricky, as well -- for the most part, they're not compile-time detectable.
They're behavioral changes. Much more subtle. Run tests on your systems before accepting these changes.
Specifically: several codecs now enforce sorting when emitting serial data.
There's also some details of what's changing that makes it milder than it first sounds:
most of the changes are around codecs becoming *more* spec-compliant.
So, for example, if you were using another IPLD library that always enforced sorting on e.g. DAG-CBOR,
you won't be surprised or experience it much like a "change" when using this version of go-ipld-prime, which now also enforces such sorting in that codec.
Also! At least one huge and awesome new feature: `bindnode`.
This is a new implementation of `ipld.Node` which can bind to native golang structures using reflection,
which provides a new and easy-to-use way to move data in and out of golang structures (or traverse them, etc!) with IPLD interfaces and codecs.
See the full change list for details:
- New: some new helpful constructors for making Selectors out of serial forms can now be found in the `traversal/selector/parse` package.
[[#199](https://github.com/ipld/go-ipld-prime/pull/199)]
- Some constants are also included which show some examples of creating common selectors from JSON.
- Fixed: cbor, dag-cbor, json, and dag-json codecs now all accept parsing a block that contains just a null token alone. (Previously, this returned an "unexpected EOF" error, which was silly.)
[[#217](https://github.com/ipld/go-ipld-prime/pull/217)]
- Fixed (upstream): json floats are actually supported. (You might've had this already, if anything dragged in a newer version of the `refmt` library. We just make sure to require this ourselves in our `go.mod` file now.)
[[#215](https://github.com/ipld/go-ipld-prime/pull/215)]
- New: Selectors now support some kinds of conditions. Specifically, `ExploreRecursive` clauses can contain a `stopAt` condition, and the condition system now supports `Condition_IsLink`, which can be used to do an equality check for CIDs.
[[#214](https://github.com/ipld/go-ipld-prime/pull/214)]
- Fixed: in codegen'd types, the `LinkTargetNodePrototype` on links was returning the wrong prototype; now it returns the right one.
[[#211](https://github.com/ipld/go-ipld-prime/pull/211)]
- New: `schema.TypedPrototype` interface, which is like `ipld.NodePrototype` but also has methods for asking `Type() schema.Type` and `Representation() ipld.NodePrototype`, both of which should probably instantly make sense to you.
[[#195](https://github.com/ipld/go-ipld-prime/pull/195)]
- Changed: the dag-json and dag-cbor codecs now apply sorting.
[[#203](https://github.com/ipld/go-ipld-prime/pull/203), [#204](https://github.com/ipld/go-ipld-prime/pull/204)]
- This means all serial data created with these codecs is sorted as advised by their respective specifications.
Previously, the implementations of these codecs was order-preserving, and emitted data in whatever order the `ipld.Node` yielded it.
- There may be new performance costs originating from this sorting.
- The codecs do not reject other orderings when parsing serial data.
The `ipld.Node` trees resulting from deserialization will still preserve the serialized order.
However, it has now become impossible to re-encode data in that same preserved order.
- If doing your own encoding, there are customization options in `dagcbor.EncodeOptions.MapSortMode` and `dagjson.EncodeOptions.MapSortMode`.
(However, note that these options are not available to you while using any systems that only operate in terms of multicodec codes.)
- _Be cautious of this change._ It is now extremely easy to write code which puts data into an `ipld.Node` in memory in one order,
then save and load that data using these codecs, and end up with different data as a result because the sorting changes the order of data.
For some applications, this may not be a problem; for others, it may be surprising.
In particular, mind this carefully in the presense of other order-sensitive logic -- for example,
such as when using Selectors, whose behaviors also depend on ordering of data returned when iterating over an `ipld.Node`.
- Fixed/Changed: the dag-json codec no longer emits whitespace (!). It is now spec-compliant.
[[#202](https://github.com/ipld/go-ipld-prime/pull/202)]
- This means hashes of content produced by dag-json codec will change. This is unfortunate, but the previous implementation was woefully and wildly out of sync with the spec, and addressing that is a predominating concern.
- Removed: `fluent/quip` has been dropped. `fluent/qp` is superior. `fluent/quip` was too easy to use incorrectly, so we no longer offer it.
[[#197](https://github.com/ipld/go-ipld-prime/pull/197)]
- This was an experimental package introduced a few releases ago, together with caveats that we may choose to drop it. The warning was purposeful!
We don't believe that this will be too painful of a change; not many things depended on the `fluent/quip` variant, and those that did should not be difficult to rewrite to `fluent/qp`.
- New: `node/basic.Chooser` is a function that implements `traversal.LinkTargetNodePrototypeChooser`. It's a small handy quality-of-life increase if you need to supply such a function, which is common.
[[#198](https://github.com/ipld/go-ipld-prime/pull/198)]
- New: `bindnode`! **This is a huge feature.** The beginnings of it may have been visible in v0.10.0, but it's grown into a usable thing we're ready to talk about.
- Bindnode lets you write golang types and structures, and "bind" them into being IPLD Nodes and supporting Data Model operations by using golang reflection.
- The result of working with `bindnode` is somewhere between using basicnode and using codegen:
it's going to provide some structural constraints (like codegen) and provide moderate performance (it lets you use structs rather than memory-expensive maps; but reflection is still going to be slower than codegen).
- However, most importantly, `bindnode` is *nice to use*. It doesn't have a huge barrier to entry like codegen does.
- `bindnode` can be used with _or without_ IPLD Schemas. For basic golang types, a schema can be inferred automatically. For more advanced features (e.g. any representation customization), you can provide a Schema.
- Please note that though it is now usable, bindnode remains _in development_. There is not yet any promise that it will be frozen against changes.
- In fact, several changes are expected; in particular, be advised there is some sizable change expected around the shape of golang types expected for unions.
- Improved: tests for behavior of schema typed nodes are now extracted to a package, where they are reusable.
- The same tests now cover the `bindnode` implementation, as well as being used in tests of our codegen outputs.
- Previously, these tests were already mostly agnostic of implementation, but had been thrown into packages in a way that made them hard to reuse.
- Improved (or Fixed, depending on your point of view): dag-json codec now supports bytes as per the spec.
[[#166](https://github.com/ipld/go-ipld-prime/pull/166),[#216](https://github.com/ipld/go-ipld-prime/pull/216)]
- Bytes are encoded in roughly this form: `{"/":{"bytes":"base64data"}}`.
- Note: the json codec does _not_ include this behavior; this is behavior specific to dag-json.
### v0.10.0
_2021 June 02_
v0.10.0 is a mild release, containing _no_ breaking changes, but lots of cool new stuff. Update at your earliest convenience.
There's a bunch of cool new features in here, some of which are significant power-ups for the ecosystem (e.g. the `NodeReifier` API), so we recommend updating as soon as possible.
There's also some sizable performance improvements available for generated code, so go forth and update your generated code too!
Check out the full feature list:
- New: an `ipld.DeepEqual` method lets you easily compare two `ipld.Node` for equality. (This is useful in case you have nodes with two different internal implementations, different memory layouts, etc, such that native golang equality would not be semantically correct.)
[[#174](https://github.com/ipld/go-ipld-prime/pull/174)]
- New: the multicodec package exposes a `multicodec.Registry` type, and also some `multicodec.List*` methods.
[[#172](https://github.com/ipld/go-ipld-prime/pull/172), [#176](https://github.com/ipld/go-ipld-prime/pull/176)]
- Please be cautious of using these `List*` methods. It's very possible to create race conditions with these, especially if using them on the global default registry instance.
If we detect that these access methods seem to produce a source of bugs and design errors in downstream usage, they will be removed.
Consider doing whatever you're doing by buildling your own registry systems, and attaching whatever semantics your system desires to those systems, rather than shoehorning this intentionally limited system into doing things it isn't made to do.
- Improved: the dag-json codec now actually supports bytes!
(Perhaps surprisingly, this was a relatively recent addition to the dag-json spec. We've now caught up with it.)
[[#166](https://github.com/ipld/go-ipld-prime/pull/166)]
- Improved: the codegen system now gofmt's the generated code immediately. You no longer need to do this manually in a separate step.
[[#163](https://github.com/ipld/go-ipld-prime/pull/163)]
- Improved: the codegen system is slightly faster at emitting code (due to use of more buffering during writes).
[[#161](https://github.com/ipld/go-ipld-prime/pull/161)]
- Improved: the codegen system will now avoid pointers in the generated "Maybe" types, if they're known to be small in memory (and thus, reasonable to inline).
[[#160](https://github.com/ipld/go-ipld-prime/pull/160)]
- This is quite likely to result in performance improvements for most programs, as it decreases the number of small memory allocations done, and amount of time spent on dereferencing, cache misses, etc.
Some workloads demonstrated over 10% speed increases, and 40% decreases in allocation counts.
(Of course, run your own benchmarks; not all workloads are equal.)
- New: `ipld.LinkSystem` now contains a "reification" hook system. **This is really cool.**
- The center of this is the `ipld.LinkSystem.NodeReifier` field, and the `ipld.NodeReifier` function type.
- The `ipld.NodeReifier` function type is simply `func(LinkContext, Node, *LinkSystem) (Node, error)`.
- The purpose and intention of this is: you can use this hooking point in order to decide where to engage advanced IPLD features like [ADLs](https://ipld.io/glossary/#adl).
One can use a `NodeReifier` to decide what ADLs to use and when... even when in the middle of a traversal.
- For example: one could write a NodeReifier that says "when I'm in a path that ends with '`foosys/*/hamt`', i'm going to try to load that as if it's a HAMT ADL".
With that hook in place, you'd then be able to walks over whole forests of data with `traversal.*` functions, and they would automatically load the relevant ADL for you transparently every time that pattern is encountered, without disrupting or complicating the walk.
- In the future, we might begin to offer more structural and declaratively configurable approaches to this, and eventually, attempt to standardize them.
For now: you can build any solution you like using this hook system. (And we'll probably plug in any future declarative systems via these same hooks, too.)
- All this appeared in [#158](https://github.com/ipld/go-ipld-prime/pull/158).
- New: `ipld.LinkSystem` now contains a boolean flag for `TrustedStorage`. If set to true, it will cause methods like `Load` to _skip hashing_ when loading content. **_Do not do this unless you know what you're doing._**
[[#149](https://github.com/ipld/go-ipld-prime/pull/149)]
- New: a json (as opposed to dag-json) codec is now available from this repo. It does roughly what you'd expect. (It's like dag-json, but explicitly rejects encoding links and bytes, and correspondingly does not have dag-json's special decoding behaviors that produce those kinds.)
[[#152](https://github.com/ipld/go-ipld-prime/pull/152)]
- New: a cbor (as opposed to dag-cbor) codec is now available from this repo. Same story as the json codec: it just explicitly doesn't support links (because you should use dag-cbor if you want that).
[[#153](https://github.com/ipld/go-ipld-prime/pull/153)]
This contained a ton of contributions from lots of people: especially thanks to @mvdan, @hannahhoward, and @willscott for invaluable contributions.
### v0.9.0
_2021 March 15_
v0.9.0 is a pretty significant release, including several neat new convenience features, but most noticeably, significantly reworking how linking works.
Almost any code that deals with storing and linking data will need some adaptation to handle this release.
We're sorry about the effort this may require, but it should be worth it.
The new LinkSystem API should let us introduce a lot more convenience features in the future, and do so *without* pushing additional breakage out to downstream users; this is an investment in the future.
The bullet points below contain all the fun details.
Note that a v0.8.0 release version has been skipped.
We use odd numbers to indicate the existence of significant changes;
and while usually we try to tag an even-number release between each odd number release so that migrations can be smoothed out,
in this case there simply weren't enough interesting points in between to be worth doing so.
- Change: linking has been significantly reworked, and now primarily works through the `ipld.LinkSystem` type.
- This is cool, because it makes a lot of things less circuitous. Previously, working with links was a complicated combination of Loader and Storer functions, the Link interface contained the Load method, it was just... complicated to figure out where to start. Now, the answer is simple and constant: "Start with LinkSystem". Clearer to use; clearer to document; and also coincidentally a lot clearer to develop for, internally.
- The PR can be found here: https://github.com/ipld/go-ipld-prime/pull/143
- `Link.Load` -> `LinkSystem.Load` (or, new: `LinkSystem.Fill`, which lets you control memory allocation more explicitly).
- `LinkBuilder.Build` -> `LinkSystem.Store`.
- `LinkSystem.ComputeLink` is a new feature that produces a Link without needing to store the data anywhere.
- The `ipld.Loader` function is now most analogous to `ipld.BlockReadOpener`. You now put it into use by assigning it to a `LinkLoader`'s `StorageReadOpener` field.
- The `ipld.Storer` function is now most analogous to `ipld.BlockWriteOpener`. You now put it into use by assigning it to a `LinkLoader`'s `StorageWriteOpener` field.
- 99% of the time, you'll probably start with `linking/cid.DefaultLinkSystem()`. You can assign to fields of this to customize it further, but it'll get you started with multihashes and multicodecs and all the behavior you expect when working with CIDs.
- (So, no -- the `cidlink` package hasn't gone anywhere. Hopefully it's a bit less obtrusive now, but it's still here.)
- The `traversal` package's `Config` struct now uses a `LinkSystem` instead of a `Loader` and `Storer` pair, as you would now probably expect.
- If you had code that was also previously passing around `Loader` and `Storer`, it's likely a similar pattern of change will be the right direction for that code.
- In the _future_, further improvements will come from this: we're now much, much closer to making a bunch of transitive dependencies become optional (especially, various hashers, which currently, whenever you pull in the `linking/cid` package, come due to `go-cid`, and are quite large). When these improvements land (again, they're not in this release), you'll need to update your applications to import hashers you need if they're not in the golang standard library. For now: there's no change.
- Change: multicodec registration is now in the `go-ipld-prime/multicodec` package.
- Previously, this registry was in the `linking/cid` package. These things are now better decoupled.
- This will require packages which register codecs to make some very small updates: e.g. `s/cidlink.RegisterMulticodecDecoder/multicodec.RegisterDecoder/`, and correspondingly, update the package imports at the top of the file.
- New: some pre-made storage options (e.g. satisfying the `ipld.StorageReadOpener` and `ipld.StorageWriteOpener` function interfaces) have appeared! Find these in the `go-ipld-prime/storage` package.
- Currently this only includes a simple in-memory storage option. This may be useful for testing and examples, but probably not much else :)
- These are mostly intended to be illustrative. You should still expect to find better storage mechanisms in other repos.
- Change: some function names in codec packages are ever-so-slightly updated. (They're verbs now, instead of nouns, which makes sense because they're functions. I have no idea what I was thinking with the previous naming. Sorry.)
- `s/dagjson.Decoder/dagjson.Decode/g`
- `s/dagjson.Decoder/dagjson.Encode/g`
- `s/dagcbor.Decoder/dagcbor.Decode/g`
- `s/dagcbor.Encoder/dagcbor.Encode/g`
- If you've only been using these indirectly, via their multicodec indicators, you won't have to update anything at all to account for this change.
- New: several new forms of helpers to make it syntactically easy to create new IPLD data trees with golang code!
- Check out the `go-ipld-prime/fluent/quip` package! See https://github.com/ipld/go-ipld-prime/pull/134, where it was introduced, for more details.
- Check out the `go-ipld-prime/fluent/qp` package! See https://github.com/ipld/go-ipld-prime/pull/138, where it was introduced, for more details.
- Both of these offer variations on `fluent` which have much lower costs to use. (`fluent` incurs allocations during operation, which has a noticable impact on performance if used in a "hot" code path. Neither of these two new solutions do!)
- For now, both `quip` and `qp` will be maintained. They have similar goals, but different syntaxes. If one is shown drastically more popular over time, we might begin to consider deprecating one in favor of the other, but we'll need lots of data before considering that.
- We won't be removing the `fluent` package anytime soon, but we probably wouldn't recommend building new stuff on it. `qp` and `quip` are both drastically preferable for performance reasons.
- New: there is now an interface called `ipld.ADL` which can be used for a certain kind of feature detection.
- This is an experimental new concept and likely subject to change.
- The one key trait we've found all ADLs tend to share right now is that they have a "synthesized" view and "substrate" view of their data. So: the `ipld.ADL` interface states that a thing is an `ipld.Node` (for the synthesized view), and from it you should be able to access a `Substrate() ipld.Node`, and that's about it.
### v0.7.0
_2020 December 31_
v0.7.0 is a small release that makes a couple of breaking changes since v0.6.0.
However, the good news is: they're all very small changes, and we've kept them in a tiny group,
so if you're already on v0.6.0, this update should be easy.
And we've got scripts to help you.
There's also one cool new feature: `traversal.FocusedTransform` is now available to help you make mutations to large documents conveniently.
- Change: all interfaces and APIs now use golang `int64` rather than golang `int`. [#125](https://github.com/ipld/go-ipld-prime/pull/125)
- This is necessary because the IPLD Data Model specifies that integers must be "at least 2^53" in range, and so since go-ipld-prime may also be used on 32-bit architectures, it is necessary that we not use the `int` type, which would fail to be Data Model-compliant on those architectures.
- The following GNU sed lines should assist this transition in your code, although some other changes that are more difficult automate may also be necessary:
```
sed -ri 's/(func.* AsInt.*)\<int\>/\1int64/g' **/*.go
sed -ri 's/(func.* AssignInt.*)\<int\>/\1int64/g' **/*.go
sed -ri 's/(func.* Length.*)\<int\>/\1int64/g' **/*.go
sed -ri 's/(func.* LookupByIndex.*)\<int\>/\1int64/g' **/*.go
sed -ri 's/(func.* Next.*)\<int\>/\1int64/g' **/*.go
sed -ri 's/(func.* ValuePrototype.*)\<int\>/\1int64/g' **/*.go
```
- Change: we've renamed the types talking about "kinds" for greater clarity. `ipld.ReprKind` is now just `ipld.Kind`; `schema.Kind` is now `schema.TypeKind`. We expect to use "kind" and "typekind" consistently in prose and documentation from now on, as well. [#127](https://github.com/ipld/go-ipld-prime/pull/127)
- Pretty much everyone who's used this library has said "ReprKind" didn't really make sense as a type name, so, uh, yeah. You were all correct. It's fixed now.
- "kind" now always means "IPLD Data Model kind", and "typekind" now always means "the kinds which an IPLD Schema type can have".
- You can find more examples of how we expect to use this in a sentence from now on in the discussion that lead to the rename: https://github.com/ipld/go-ipld-prime/issues/94#issuecomment-745307919
- The following GNU sed lines should assist this transition in your code:
```
sed -ri 's/\<Kind\(\)/TypeKind()/g' **/*.go
sed -ri 's/\<Kind_/TypeKind_/g' **/*.go
sed -i 's/\<Kind\>/TypeKind/g' **/*.go
sed -i 's/ReprKind/Kind/g' **/*.go
```
- Feature: `traversal.FocusedTransform` works now! :tada: You can use this to take a node, say what path inside it you want to update, and then give it an updated value. Super handy. [#130](https://github.com/ipld/go-ipld-prime/pull/130)
### v0.6.0
_2020 December 14_
v0.6.0 is a feature-packed release and has a few bugfixes, and _no_ significant breaking changes. Update at your earliest convenience.
Most of the features have to do with codegen, which we now consider to be in **alpha** -- go ahead and use it! (We're starting to self-host some things in it, so any changes will definitely be managed from here on out.)
A few other small handy helper APIs have appeared as well; see the detailed notes for those.
Like with the last couple of releases, our intent is to follow this smooth-sailing change with another release shortly which will include some minor but noticable API changes, and that release may require you to make some code changes.
Therefore, we suggest upgrading to this one first, beacuse it's an easy waypoint before the next change.
- Feature: codegen is a reasonably usable alpha! We now encourage trying it out (but still only for those willing to experience an "alpha" level of friction -- UX still rough, and we know it).
- Consult the feature table in the codegen package readme: many major features of IPLD Schemas are now supported.
- Structs with tuple representations? Yes.
- Keyed unions? Yes.
- Structs with stringjoin representations? Yes. Including nested? _Yes_.
- Lots of powerful stuff is now available to use.
- See [the feature table in the codegen readme](https://github.com/ipld/go-ipld-prime/blob/v0.6.0/schema/gen/go/README.md#completeness) for details.
- Many generated types now have more methods for accessing them in typed ways (in addition to the usual `ipld.Node` interfaces, which can access the same data, but lose explicit typing). [#106](https://github.com/ipld/go-ipld-prime/pull/106)
- Maps and lists now have both lookup methods and iterators which know the type of the child keys and values explicitly.
- Cool: when generating unions, you can choose between different implementation strategies (favoring either interfaces, or embedded values) by using Adjunct Config. This lets you tune for either speed (reduced allocation count) or memory footprint (less allocation size, but more granular allocations).
- See notes in [#60](https://github.com/ipld/go-ipld-prime/pull/60) for more detail on this. We'll be aiming to make configurability of this more approachable and better documented in future releases, as we move towards codegen tools usable as CLI tools.
- Cyclic references in types are now supported.
- ... mostly. Some manual configuration may sometimes be required to make sure the generated structure wouldn't have an infinite memory size. We'll keep working on making this smoother in the future.
- Field symbol overrides now work properly. (E.g., if you have a schema with a field called "type", you can make that work now. Just needs a field symbol override in the Adjunct Config when doing codegen!)
- Codegen'd link types now implemented the `schema.TypedLinkNode` interface where applicable.
- Structs now actually validate all required fields are present before allowing themselves to finish building. Ditto for their map representations.
- Much more testing. And we've got a nice new declarative testcase system that makes it easier to write descriptions of how data should behave (at both the typed and representation view levels), and then just call one function to run exhaustive tests to make sure it looks the same from every inspectable API.
- Change: codegen now outputs a fixed set of files. (Previously, it output one file per type in your schema.) This makes codegen much more managable; if you remove a type from your schema, you don't have to chase down the orphaned file. It's also just plain less clutter to look at on the filesystem.
- Demo: as proof of the kind of work that can be done now with codegen, we've implemented the IPLD Schema schema -- the schema that describes IPLD Schema declarations -- using codegen. It's pretty neat.
- Future: we'll be replacing most of the current current `schema` package with code based on this generated stuff. Not there yet, though. Taking this slow.
- You can see the drafts of this, along with new features based on it, in [#107](https://github.com/ipld/go-ipld-prime/pull/107).
- Feature: the `schema` typesystem info packages are improved.
- Cyclic references in types are now supported.
- (Mind that there are still some caveats about this when fed to codegen, though.)
- Graph completeness is now validated (e.g. missing type references emit useful errors)!
- Feature: there's a `traversal.Get` function. It's like `traversal.Focus`, but just returns the reached data instead of dragging you through a callback. Handy.
- Feature/bugfix: the DAG-CBOR codec now includes resource budgeting limits. This means it's a lot harder for a badly-formed (or maliciously formed!) message to cause you to run out of memory while processing it. [#85](https://github.com/ipld/go-ipld-prime/pull/85)
- Bugfix: several other panics from the DAG-CBOR codec on malformed data are now nice politely-returned errors, as they should be.
- Bugfix: in codegen, there was a parity break between the AssembleEntry method and AssembleKey+AssembleValue in generated struct NodeAssemblers. This has been fixed.
- Minor: ErrNoSuchField now uses PathSegment instead of a string. You probably won't notice (but this was important interally: we need it so we're able to describe structs with tuple representations).
- Bugfix: an error path during CID creation is no longer incorrectly dropped. (I don't think anyone ever ran into this; it only handled situations where the CID parameters were in some way invalid. But anyway, it's fixed now.)
- Performance: when `cidlink.Link.Load` is used, it will do feature detection on its `io.Reader`, and if it looks like an already-in-memory buffer, take shortcuts that do bulk operations. I've heard this can reduce memory pressure and allocation counts nicely in applications where that's a common scenario.
- Feature: there's now a `fluent.Reflect` convenience method. Its job is to take some common golang structs like maps and slices of primitives, and flip them into an IPLD Node tree. [#81](https://github.com/ipld/go-ipld-prime/pull/81)
- This isn't very high-performance, so we don't really recommend using it in production code (certainly not in any hot paths where performance matters)... but it's dang convenient sometimes.
- Feature: there's now a `traversal.SelectLinks` convenience method. Its job is to walk a node tree and return a list of all the link nodes. [#110](https://github.com/ipld/go-ipld-prime/pull/110)
- This is both convenient, and faster than doing the same thing using general-purpose Selectors (we implemented it as a special case).
- Demo: you can now find a "rot13" ADL in the `adl/rot13adl` package. This might be useful reference material if you're interested in writing an ADL and wondering what that entails. [#98](https://github.com/ipld/go-ipld-prime/pull/98)
- In progress: we've started working on some new library features for working with data as streams of "tokens". You can find some of this in the new `codec/codectools` package.
- Functions are available for taking a stream of tokens and feeding them into a NodeAssembler; and for taking a Node and reading it out as a stream of tokens.
- The main goal in mind for this is to provide reusable components to make it easier to implement new codecs. But maybe there will be other uses for this feature too!
- These APIs are brand new and are _extremely subject to change_, much more so than any other packages in this repo. If you work with them at this stage, _do_ expect to need to update your code when things shift.
### v0.5.0
_2020 July 2_
v0.5.0 is a small release -- it just contains a bunch of renames.
There are _no_ semantic changes bundled with this (it's _just_ renames) so this should be easy to absorb.
- Renamed: `NodeStyle` -> `NodePrototype`.
- Reason: it seems to fit better! See https://github.com/ipld/go-ipld-prime/issues/54 for a full discussion.
- This should be a "sed refactor" -- the change is purely naming, not semantics, so it should be easy to update your code for.
- This also affects some package-scoped vars named `Style`; they're accordingly also renamed to `Prototype`.
- This also affects several methods such as `KeyStyle` and `ValueStyle`; they're accordingly also renamed to `KeyPrototype` and `ValuePrototype`.
- Renamed: `(Node).Lookup{Foo}` -> `(Node).LookupBy{Foo}`.
- Reason: The former phrasing makes it sound like the "{Foo}" component of the name describes what it returns, but in fact what it describes is the type of the param (which is necessary, since Golang lacks function overloading parametric polymorphism). Adding the preposition should make this less likely to mislead (even though it does make the method name moderately longer).
- This should be a "sed refactor" -- the change is purely naming, not semantics, so it should be easy to update your code for.
- Renamed: `(Node).Lookup` -> `(Node).LookupNode`.
- Reason: The shortest and least-qualified name, 'Lookup', should be reserved for the best-typed variant of the method, which is only present on codegenerated types (and not present on the Node interface at all, due to Golang's limited polymorphism).
- This should be a "sed refactor" -- the change is purely naming, not semantics, so it should be easy to update your code for. (The change itself in the library was fairly literally `s/Lookup(/LookupNode(/g`, and then `s/"Lookup"/"LookupNode"/g` to catch a few error message strings, so consumers shouldn't have it much harder.)
- Note: combined with the above rename, this method overall becomes `(Node).LookupByNode`.
- Renamed: `ipld.Undef` -> `ipld.Absent`, and `(Node).IsUndefined` -> `(Node).IsAbsent`.
- Reason: "absent" has emerged as a much, much better description of what this value means. "Undefined" sounds nebulous and carries less meaning. In long-form prose docs written recently, "absent" consistently fits the sentence flow much better. Let's just adopt "absent" consistently and do away with "undefined".
- This should be a "sed refactor" -- the change is purely naming, not semantics, so it should be easy to update your code for.
### v0.4.0
v0.4.0 contains some misceleanous features and documentation improvements -- perhaps most notably, codegen is re-introduced and more featureful than previous rounds -- but otherwise isn't too shocking.
This tag mostly exists as a nice stopping point before the next version coming up (which is planned to include several API changes).
- Docs: several new example functions should now appear in the godoc for how to use the linking APIs.
- Feature: codegen is back! Use it if you dare.
- Generated code is now up to date with the present versions of the core interfaces (e.g., it's updated for the NodeAssembler world).
- We've got a nice big feature table in the codegen package readme now! Consult that to see which features of IPLD Schemas now have codegen support.
- There are now several implemented and working (and robustly tested) examples of codegen for various representation strategies for the same types. (For example, struct-with-stringjoin-representation.) Neat!
- This edition of codegen uses some neat tricks to not just maintain immutability contracts, but even prevent the creation of zero-value objects which could potentially be used to evade validation phases on objects that have validation rules. (This is a bit experimental; we'll see how it goes.)
- There are oodles and oodles of deep documentation of architecture design choices recorded in "HACKME_*" documents in the codegen package that you may enjoy if you want to contribute or understand why generated things are the way they are.
- Testing infrastructure for codegen is now solid. Running tests for the codegen package will: exercise the generation itself; AND make sure the generated code compiles; AND run behavioral tests against it: the whole gamut, all from regular `go test`.
- The "node/gendemo" package contains a real example of codegen output... and it's connected to the same tests and benchmarks as other node implementations. (Are the gen'd types fast? yes. yes they are.)
- There's still lots more to go: interacting with the codegen system still requires writing code to interact with as a library, as we aren't shipping a CLI frontend to it yet; and many other features are still in development as well. But you're welcome to take it for a spin if you're eager!
- Feature: introduce JSON Tables Codec ("JST"), in the `codec/jst` package. This is a codec that emits bog-standard JSON, but leaning in on the non-semantic whitespace to produce aligned output, table-like, for pleasant human reading. (If you've used `column -t` before in the shell: it's like that.)
- This package may be a temporary guest in this repo; it will probably migrate to its own repo soon. (It's a nice exercise of our core interfaces, though, so it incubated here.)
- I'm quietly shifting the versioning up to the 0.x range. (Honestly, I thought it was already there, heh.) That makes this this "v0.4".
### v0.0.3
v0.0.3 contained a massive rewrite which pivoted us to using NodeAssembler patterns.
Code predating this version will need significant updates to match; but, the performance improvements that result should be more than worth it.
- Constructing new nodes has a major pivot towards using "NodeAssembler" pattern: https://github.com/ipld/go-ipld-prime/pull/49
- This was a massively breaking change: it pivoted from bottom-up composition to top-down assembly: allocating large chunks of structured memory up front and filling them in, rather than stitching together trees over fragmented heap memory with lots of pointers
- "NodeStyle" and "NodeBuilder" and "NodeAssembler" are all now separate concepts:
- NodeStyle is more or less a builder factory (forgive me -- but it's important: you can handle these without causing allocations, and that matters).
Use NodeStyle to tell library functions what kind of in-memory representation you want to use for your data. (Typically `basicnode.Style.Any` will do -- but you have the control to choose others.)
- NodeBuilder allocates and begins the assembly of a value (or a whole tree of values, which may be allocated all at once).
- NodeAssembler is the recursive part of assembling a value (NodeBuilder implements NodeAssembler, but everywhere other than the root, you only use the NodeAssembler interface).
- Assembly of trees of values now simply involves asking the assembler for a recursive node to give you assemblers for the keys and/or values, and then simply... using them.
- This is much simpler (and also faster) to use than the previous system, which involved an awkward dance to ask about what kind the child nodes were, get builders for them, use those builders, then put the result pack in the parent, and so forth.
- Creating new maps and lists now accepts a size hint argument.
- This isn't strictly enforced (you can provide zero, or even a negative number to indicate "I don't know", and still add data to the assembler), but may improve efficiency by reducing reallocation costs to grow structures if the size can be estimated in advance.
- Expect **sizable** performance improvements in this version, due to these interface changes.
- Some packages were renamed in an effort to improve naming consistency and feel:
- The default node implementations have moved: expect to replace `impl/free` in your package imports with `node/basic` (which is an all around better name, anyway).
- The codecs packages have moved: replace `encoding` with `codec` in your package imports (that's all there is to it; nothing else changed).
- Previous demos of code generation are currently broken / disabled / removed in this tag.
- ...but they'll return in future versions, and you can follow along in branches if you wish.
- Bugfix: dag-cbor codec now correctly handles marshalling when bytes come after a link in the same object. [[53](https://github.com/ipld/go-ipld-prime/pull/53)]
### v0.0.2
- Many various performance improvements, fixes, and docs improvements.
- Many benchmarks and additional tests introduced.
- Includes early demos of parts of the schema system, and early demos of code generation.
- Mostly a checkpoint before beginning v0.0.3, which involved many large API reshapings.
### v0.0.1
- Our very first tag!
- The central `Node` and `NodeBuilder` interfaces are already established, as is `Link`, `Loader`, and so forth.
You can already build generic data handling using IPLD Data Model concepts with these core interfaces.
- Selectors and traversals are available.
- Codecs for dag-cbor and dag-json are batteries-included in the repo.
- There was quite a lot of work done before we even started tagging releases :)
================================================
FILE: HACKME.md
================================================
hackme
======
Design rational are documented here.
This doc is not necessary reading for users of this package,
but if you're considering submitting patches -- or just trying to understand
why it was written this way, and check for reasoning that might be dated --
then it might be useful reading.
It may also be an incomplete doc. It's been written opportunistically.
If you don't understand the rationale for some things, try checking git history
(many of the commit messages are downright bookish), or get in touch via
a github issue, irc, matrix, etc and ask!
about NodeAssembler and NodeBuilder
-----------------------------------
See the godoc on these types.
In short, a `NodeBuilder` is for creating a new piece of memory;
a `NodeAssembler` is for instantiating some memory which you already have.
Generally, you'll start any function using a `NodeBuilder`, but then continue
and recurse by passing on the `NodeAssembler`.
See the `./HACKME_builderBehaviors.md` doc for more details on
high level rules and implementation patterns to look out for.
about NodePrototype
---------------
### NodePrototype promises information without allocations
You'll notice nearly every `ipld.NodePrototype` implementation is
a golang struct type with _zero fields_.
This is important.
Getting a NodePrototype is generally expected to be "free" (i.e., zero allocations),
while `NewBuilder` is allowed to be costly (usually causes at least one allocation).
Zero-member structs can be referred to by an interface without requiring an allocation,
which is how it's possible ensure `NodePrototype` are always "free" to refer to.
(Note that a `NodePrototype` that bundles some information like ADL configuration
will subvert this pattern -- but these are an exception, not the rule.)
### NodePrototype reported by a Node
`ipld.NodePrototype` is a type that opaquely represents some information about how
a node was constructed and is implemented. The general contract for what
should happen when asking a node about its prototype
(via the `ipld.Node.Prototype() NodePrototype` interface) is that prototype should contain
effective instructions for how one could build a copy of that node, using
the same implementation details.
By example, if some node `n` was made as a `basicnode.plainString`,
then `n.Prototype()` will be `basicnode.Prototype.String`,
and `n.Prototype().NewBuilder().AssignString("xyz")` can be presumed to work.
Note there are also limits to this: if a node was built in a flexible way,
the prototype it reports later may only report what it is now, and not return
that same flexibility again.
By example, if something was made as an "any" -- i.e.,
via `basicnode.Prototype.Any.NewBuilder()`, and then *happened* to be assigned a string value --
the resulting node will still carry a `Prototype()` property that returns
`basicnode.Prototype.String` -- **not** `basicnode.Prototype.Any`.
#### NodePrototype meets generic transformation
One of the core purposes of the `NodePrototype` interface (and all the different
ways you can get it from existing data) is to enable the `traversal` package
(or other user-written packages like it) to do transformations on data.
// work-in-progress warning: generic transformations are not fully implemented.
When implementing a transformation that works over unknown data,
the signiture of function a user provides is roughly:
`func(oldValue Node, acceptableValues NodePrototype) (Node, error)`.
(This signiture may vary by the strategy taken by the transformation -- this
signiture is useful because it's capable of no-op'ing; an alternative signiture
might give the user a `NodeAssembler` instead of the `NodePrototype`.)
In this situation, the transformation system determines the `NodePrototype`
(or `NodeAssembler`) to use by asking the parent value of the one we're visiting.
This is because we want to give the update function the ability to create
any kind of value that would be accepted in this position -- not just create a
value of the same prototype as the one currently there! It is for this reason
the `oldValue.Prototype()` property can't be used directly.
At the root of such a transformation, we use the `node.Prototype()` property to
determine how to get started building a new value.
#### NodePrototype meets recursive assemblers
Asking for a NodePrototype in a recursive assembly process tells you about what
kind of node would be accepted in an `AssignNode(Node)` call.
It does *not* make any remark on the fact it's a key assembler or value assembler
and might be wrapped with additional rules (such as map key uniqueness, field
name expectations, etc).
(Note that it's also not an exclusive statement about what `AssignNode(Node)` will
accept; e.g. in many situations, while a `Prototype.MyStringType` might be the prototype
returned, any string kinded node can be used in `AssignNode(Node)` and will be
appropriately converted.)
Any of these paths counts as "recursive assembly process":
- `MapAssembler.KeyPrototype()`
- `MapAssembler.ValuePrototype(string)`
- `MapAssembler.AssembleKey().Prototype()`
- `MapAssembler.AssembleValue().Prototype()`
- `ListAssembler.ValuePrototype()`
- `ListAssembler.AssembleValue().Prototype()`
### NodePrototype for carrying ADL configuration
// work-in-progress warning: this is an intention of the design, but not implemented.
================================================
FILE: HACKME_builderBehaviors.md
================================================
hackme: NodeBuilder and NodeAssembler behaviors
===============================================
high level rules of builders and assemblers
-------------------------------------------
- Errors should be returned as soon as possible.
- That means an error like "repeated key in map" should be returned by the key assembler!
- Either 'NodeAssembler.AssignString' should return this (for simple keys on untyped maps, or on structs, etc)...
- ... or 'MapAssembler.Finish' (in the case of complex keys in a typed map).
- Logical integrity checks must be done locally -- recursive types rely on their contained types to report errors, and the recursive type wraps the assemblers of their contained type in order to check and correctly invalidate/rollback the recursive construction.
- Recursive types tend to have a value assembler that wraps the child type's assembler in order to intercept relevant "finish" methods.
- This is generally where that logic integrity check mentioned above is tracked; we need explicit confirmation that it *passes* before the parent's assembly should proceed.
- Implementations may also need this moment to complete any assignment of the child value into position in the parent value. But not all implementations need this -- some will have had all the child assembler effects applying directly to the final memory positions.
- Assemblers should invalidate themselves as soon as they become "finished".
- For maps and lists, that means the "Finish" methods.
- For all the other scalars, the "Assign*" method itself means finished.
- Or in other words: whatever method returns an `error`, that's what makes that assembler "finished".
- The purpose of this is to prevent accidental mutation after any validations have been performed during the "finish" processing.
- Many methods must be called in the right order, and the user must not hold onto references after calling "finish" methods on them.
- The reason this is important is to enable assembler systems to aggressively reuse memory, thus increasing performance.
- Thus, if you hold onto NodeAssembler reference after being finished with it... you can't assume it'll explicitly error if you call further methods on it, because it might now be operating again... _on a different target_.
- In recursive structures, calling AssembleKey or AssembleValue might return pointer-identical assemblers (per warning in previous bullet), but the memory their assembly is targeted to should always advance -- it should never target already-assembled memory.
- (If you're thinking "the Rust memory model would be able to greatly enhance safety here!"... yes. Yes it would.)
- When misuses of order are detected, these may cause panics (rather than error returns) (not all methods that can be so misused have error returns).
detailed rules and expectations for implementers
------------------------------------------------
The expectations in the "happy path" are often clear.
Here are also collected some details of exactly what should happen when an error has been reached,
but the caller tries to continue anyway.
- while building maps:
- assigning a key with 'AssembleKey':
- in case of success: clearly 'AssembleValue' should be ready to use next.
- in case of failure from repeated key:
- the error must be returned immediately from either the 'NodeAssembler.AssignString' or the 'MapAssembler.Finish' method.
- 'AssignString' for any simple keys; 'MapAssembler.Finish' may be relevant in the case of complex keys in a typed map.
- implementers take note: this implies the `NodeAssembler` returned by `AssembleKey` has some way to refer to the map assembler that spawned it.
- no side effect should be visible if 'AssembleKey' is called again next.
- (typically this doesn't require extra code for the string case, but it may require some active zeroing in the complex key case.)
- (remember to reset any internal flag for expecting 'AssembleValue' to be used next, and decrement any length pointers that were optimistically incremented!)
- n.b. the "no side effect" rule here is for keys, not for values.
- TODO/REVIEW: do we want the no-side-effect rule for values? it might require nontrivial volumes of zeroing, and often in practice, this might be wasteful.
- invalidation of assemblers:
- is typically implemented by nil'ing the wip node they point to.
- this means you get nil pointer dereference panics when attempting to use an assembler after it's finished... which is not the greatest error message.
- but it does save us a lot of check code for a situation that the user certainly shouldn't get into in the first place.
- (worth review: can we add that check code without extra runtime cost? possibly, because the compiler might then skip its own implicit check branches. might still increase SLOC noticeably in codegen output, though.)
- worth noting there's a limit to how good this can be anyway: it's "best effort" error reporting: see the remarks on reuse of assembler memory in "overall rules" above.
- it's systemically critical to not yield an assembler _ever again in the future_ that refers to some memory already considered finished.
- even though we no longer return intermediate nodes, there's still many ways this could produce problems. For example, complicating (if not outright breaking) COW sharing of segments of data.
- in most situations, we get this for free, because the child assembler methods only go "forward" -- there's no backing up, lists have no random index insertion or update support, and maps actively reject dupe keys.
- if you *do* make a system which exposes any of those features... be very careful; you will probably need to start tracking "freeze" flags on the data in order to retain systemic sanity.
================================================
FILE: HACKME_mergeStrategy.md
================================================
hacking: merge strategies
=========================
This is a short document about how the maintainers of this repo handle branches and merging.
It's useful information for a developer wanting to contribute, but otherwise unimportant.
---
We prefer to:
1. Do development on a branch;
2. Before merge, rebase onto master (if at all possible);
- if there are individual commit hashes that should be preserved because they've been referenced outside the project, say so; we don't want to have to presume this by default.
- rebasing your commits (or simply staging them carefully the first time; `git add -p` is your friend) for clarity of later readers is greatly appreciated.
3. Merge, using the "--no-ff" strategy. The github UI does fine at this.
There are a couple of reasons we prefer this:
- Squashing, if appropriate, can be done by the author. We don't use github's squash button because it's sometimes quite difficult to make a good combined commit message without effort to do so by the diff's author, so it's best left to that author to do themselves.
- Generating a merge commit gives a good place for github to insert the PR link, if a PR has been used. This is good info to have if someone is later reading git history and wants to see links to where other discussion may have taken place.
- We *do* like fairly linearly history. Emphasis on "fairly" -- it doesn't have to be perfectly lock-step ridgidly linear: but when doing `git log --graph`, we also want to not see more than a handful of lines running in parallel at once. (Too many parallel branches at once is both unpleasant to read and review later, and can indicative of developmental process issues, so it's a good heuristic to minimize for multiple reasons.) Rebasing before generating a merge commit does this: if consistently done, `git log --graph` will yield two parallel lines at all times.
- Generating a merge commit, when combined with rebasing the commits on the branch right before merge, means `git log --graph` will group up the branch commits in a visually clear way. Preserving this relation can be useful. (Neither squashing nor rebase-without-merge approaches preserve this information.)
Mind, all of these rules are heuristics and "rules of thumb". Some small changes are also perfectly reasonable to land with either a squash or rebase that appends them linearly onto history.
The maintainers may choose strategies as they see fit depending on the size of the content and the level of interest in preserving individual commits and their messages and relational history.
What does this mean for PRs?
----------------------------
- Please keep PRs rebased on top of master as much as possible.
- If you decide you want multiple commits with distinct messages, fine. If you want to squash, also fine.
- If you are linking to commit hashes and don't want them rebased, please comment about this;
otherwise, it should not be presumed we'll keep exact commit hashes reachable.
The maintainers also reserve the right to rebase or squash things at their own option;
we'll comment explicitly if committing to not do so, and it should not otherwise be presumed.
- If you're not comfortable with rebase: fine. Just be aware that if a PR branches off master for quite some time,
and it does become ready for merge later, the maintainers are likely to squash/rebase your work for you before merging.
================================================
FILE: HACKME_releases.md
================================================
# Making go-ipld-prime Releases
## Versioning strategy
go-ipld-prime follows **[WarpVer](https://gist.github.com/warpfork/98d2f4060c68a565e8ad18ea4814c25f)**, a form of SemVer that never bumps the major version number and uses minor version numbers to indicate degree of *changeness*: **even numbers should be easy upgrades; odd numbers may change things**. The patch version number is rarely used in this scheme.
## CHANGELOG.md
There is a CHANGELOG.md, it should be relevant and updated. Notable items in the commit history since the last release should be included. Where possible and practical, links to relevant pull requests or other issues with discussions on the items should be included.
To find the list of commits, it is recommended that you use a tool that can provide some extra metadata to help with matching commits to pull requests. [changelog-maker](https://github.com/nodejs/changelog-maker) can help with this (requires Node.js be installed and the `npx` command be available):
```
npx changelog-maker --start-ref=v0.16.0 --reverse=true --find-matching-prs=true --md=true ipld go-ipld-prime
```
Alternatively, you can use `git log` and perform mapping to pull requests manually, e.g.:
```
git log --all --graph --date-order --abbrev-commit --decorate --oneline
```
*(where `--start-ref` points to name of the previous release tag)*
### Curate and summarize
The CHANGELOG should be informative for developers wanting to know what changes may pose a risk (highlight these!) and what changes introduce features they may be interested in using.
1. Group commits to subsystem to create a two-level list. Subsections can include "Data Model", "Schemas", "Bindnode", "Selectors", "Codecs", and the meta-category of "Build" to describe changes local to the repository and not necessarily relevant to API consumers.
2. If there are breaking, or potentially breaking changes, list them under a `#### 🛠 Breaking Changes` section.
3. Otherwise, prune the list of commits down to the set of changes relevant to users, and list them under a `#### 🔦 Highlights` section.
Note that there is also a **Planned/Upcoming Changes** section near the top of the CHANGELOG.md. Update this to remove _done_ items and add other items that may be nearing completion but not yet released.
### Call-outs
Add "special thanks" call-outs to individuals who have contributed meaningful changes to the release.
## Propose a release
After updating the CHANGELOG.md entry, also bump the version number appropriately in **version.json** file so the auto-release procedure can take care of tagging for you.
Commit and propose the changes via a pull request to ipld/go-ipld-prime.
## Release
After a reasonable amount of time for feedback (usually at least a full global business day), the changes can be merged and a release tag will be created by the GitHub Actions.
Use the GitHub UI to make a [release](https://github.com/ipld/go-ipld-prime/releases), copying in the contents of the CHANGELOG.md for that release.
Drop in a note to the appropriate Matrix/Discord/Slack channel(s) for IPLD about the release.
Optional: Protocol Labs staff can send an email to shipped@protocol.ai to describe the release, these are typically well-read and appreciated.
## Checklist
Prior to opening a release proposal pull request, create an issue with the following markdown checklist to help ensure the requisite steps are taken. The issue can also be used to alert subscribed developers to the timeframe and the approximate scope of changes in the release.
```markdown
* [ ] Add new h3 to `CHANGELOG.md` under **Released Changes** with curated and subsystem-grouped list of changes and links to relevant PRs
* [ ] Highlight any potentially breaking or disruptive changes under "🛠 Breaking Changes", including extended descriptions to help users make compatibility judgements
* [ ] Add special-thanks call-outs to contributors making significant contributions
* [ ] Update **Planned/Upcoming Changes** section to remove completed items and add newly upcoming, but incomplete items
* [ ] Bump version number appropriately in `version.json`
* [ ] Propose release via pull request, merge after enough time for async global feedback
* [ ] Create GitHub [release](https://github.com/ipld/go-ipld-prime/releases) with the new tag, copying the new `CHANGELOG.md` contents
* [ ] Announce on relevant Discord/Matrix/Slack channel(s)
* [ ] (Optional) Announce to shipped@protocol.ai
```
================================================
FILE: LICENSE
================================================
The MIT License (MIT)
Copyright (c) 2018 Eric Myhre
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
================================================
FILE: README.md
================================================
go-ipld-prime
=============
`go-ipld-prime` is an implementation of the IPLD spec interfaces,
a batteries-included codec implementations of IPLD for CBOR and JSON,
and tooling for basic operations on IPLD objects (traversals, etc).
API
---
The API is split into several packages based on responsibly of the code.
The most central interfaces are the base package,
but you'll certainly need to import additional packages to get concrete implementations into action.
Roughly speaking, the core package interfaces are all about the IPLD Data Model;
the `codec/*` packages contain functions for parsing serial data into the IPLD Data Model,
and converting Data Model content back into serial formats;
the `traversal` package is an example of higher-order functions on the Data Model;
concrete `ipld.Node` implementations ready to use can be found in packages in the `node/*` directory;
and several additional packages contain advanced features such as IPLD Schemas.
(Because the codecs, as well as higher-order features like traversals, are
implemented in a separate package from the core interfaces or any of the Node implementations,
you can be sure they're not doing any funky "magic" -- all this stuff will work the same
if you want to write your own extensions, whether for new Node implementations
or new codecs, or new higher-order order functions!)
- `github.com/ipld/go-ipld-prime` -- imported as just `ipld` -- contains the core interfaces for IPLD. The most important interfaces are `Node`, `NodeBuilder`, `Path`, and `Link`.
- `github.com/ipld/go-ipld-prime/node/basicnode` -- provides concrete implementations of `Node` and `NodeBuilder` which work for any kind of data, using unstructured memory.
- `github.com/ipld/go-ipld-prime/node/bindnode` -- provides concrete implementations of `Node` and `NodeBuilder` which store data in native golang structures, interacting with it via reflection. Also supports IPLD Schemas!
- `github.com/ipld/go-ipld-prime/traversal` -- contains higher-order functions for traversing graphs of data easily.
- `github.com/ipld/go-ipld-prime/traversal/selector` -- contains selectors, which are sort of like regexps, but for trees and graphs of IPLD data!
- `github.com/ipld/go-ipld-prime/codec` -- parent package of all the codec implementations!
- `github.com/ipld/go-ipld-prime/codec/dagcbor` -- implementations of marshalling and unmarshalling as CBOR (a fast, binary serialization format).
- `github.com/ipld/go-ipld-prime/codec/dagjson` -- implementations of marshalling and unmarshalling as JSON (a popular human readable format).
- `github.com/ipld/go-ipld-prime/linking/cid` -- imported as `cidlink` -- provides concrete implementations of `Link` as a CID. Also, the multicodec registry.
- `github.com/ipld/go-ipld-prime/schema` -- contains the `schema.Type` and `schema.TypedNode` interface declarations, which represent IPLD Schema type information.
- `github.com/ipld/go-ipld-prime/node/typed` -- provides concrete implementations of `schema.TypedNode` which decorate a basic `Node` at runtime to have additional features described by IPLD Schemas.
Getting Started
---------------
Let's say you want to create some data programmatically,
and then serialize it, or save it as [blocks].
You've got a ton of different options, depending on what golang convention you want to use:
- the `qp` package -- [example](https://pkg.go.dev/github.com/ipld/go-ipld-prime/fluent/qp#example-package)
- the `bindnode` system, if you want to use golang types -- [example](https://pkg.go.dev/github.com/ipld/go-ipld-prime/node/bindnode#example-Wrap-NoSchema), [example with schema](https://pkg.go.dev/github.com/ipld/go-ipld-prime/node/bindnode#example-Wrap-WithSchema)
- or the [`NodeBuilder`](https://pkg.go.dev/github.com/ipld/go-ipld-prime/datamodel#NodeBuilder) interfaces, raw (verbose; not recommended)
- or even some codegen systems!
Once you've got a Node full of data,
you can serialize it:
https://pkg.go.dev/github.com/ipld/go-ipld-prime#example-package-CreateDataAndMarshal
But probably you want to do more than that;
probably you want to store this data as a block,
and get a CID that links back to it.
For this you use `LinkSystem`:
https://pkg.go.dev/github.com/ipld/go-ipld-prime/linking#example-LinkSystem.Store
Hopefully these pointers give you some useful getting-started focal points.
The API docs should help from here on out.
We also highly recommend scanning the [godocs](https://pkg.go.dev/github.com/ipld/go-ipld-prime) for other pieces of example code, in various packages!
Let us know in [issues](https://github.com/ipld/go-ipld-prime/issues), [chat, or other community spaces](https://ipld.io/docs/intro/community/) if you need more help,
or have suggestions on how we can improve the getting-started experiences!
Other IPLD Libraries
--------------------
The IPLD specifications are designed to be language-agnostic.
Many implementations exist in a variety of languages.
For overall behaviors and specifications, refer to the IPLD website, or its source, in IPLD meta repo:
- https://ipld.io/
- https://github.com/ipld/ipld/
You should find specs in the `specs/` dir there,
human-friendly docs in the `docs/` dir,
and information about _why_ things are designed the way they are mostly in the `design/` directories.
There are also pages in the IPLD website specifically about golang IPLD libraries,
and your alternatives: https://ipld.io/libraries/golang/
### distinctions from go-ipld-interface&go-ipld-cbor
This library ("go ipld prime") is the current head of development for golang IPLD,
and we recommend new developments in golang be done using this library as the basis.
However, several other libraries exist in golang for working with IPLD data.
Most of these predate go-ipld-prime and no longer receive active development,
but since they do support a lot of other software, you may continue to seem them around for a while.
go-ipld-prime is generally **serially compatible** with these -- just like it is with IPLD libraries in other languages.
In terms of programmatic API and features, go-ipld-prime is a clean take on the IPLD interfaces,
and chose to address several design decisions very differently than older generation of libraries:
- **The Node interfaces map cleanly to the IPLD Data Model**;
- Many features known to be legacy are dropped;
- The Link implementations are purely CIDs (no "name" nor "size" properties);
- The Path implementations are provided in the same box;
- The JSON and CBOR implementations are provided in the same box;
- Several odd dependencies on blockstore and other interfaces that were closely coupled with IPFS are replaced by simpler, less-coupled interfaces;
- New features like IPLD Selectors are only available from go-ipld-prime;
- New features like ADLs (Advanced Data Layouts), which provide features like transparent sharding and indexing for large data, are only available from go-ipld-prime;
- Declarative transformations can be applied to IPLD data (defined in terms of the IPLD Data Model) using go-ipld-prime;
- and many other small refinements.
In particular, the clean and direct mapping of "Node" to concepts in the IPLD Data Model
ensures a much more consistent set of rules when working with go-ipld-prime data, regardless of which codecs are involved.
(Codec-specific embellishments and edge-cases were common in the previous generation of libraries.)
This clarity is also what provides the basis for features like Selectors, ADLs, and operations such as declarative transformations.
Many of these changes had been discussed for the other IPLD codebases as well,
but we chose clean break v2 as a more viable project-management path.
Both go-ipld-prime and these legacy libraries can co-exist on the same import path, and both refer to the same kinds of serial data.
Projects wishing to migrate can do so smoothly and at their leisure.
We now consider many of the earlier golang IPLD libraries to be defacto deprecated,
and you should expect new features *here*, rather than in those libraries.
(Those libraries still won't be going away anytime soon, but we really don't recommend new construction on them.)
### migrating
**For recommendations on where to start when migrating:**
see [README_migrationGuide](./README_migrationGuide.md).
That document will provide examples of which old concepts and API names map to which new APIs,
and should help set you on the right track.
### unixfsv1
Lots of people who hear about IPLD have heard about it through IPFS.
IPFS has IPLD-native APIs, but IPFS *also* makes heavy use of a specific system called "UnixFSv1",
so people often wonder if UnixFSv1 is supported in IPLD libraries.
The answer is "yes" -- but it's not part of the core.
UnixFSv1 is now treated as an [ADL](https://ipld.io/glossary/#adl),
and a go-ipld-prime compatible implementation can be found
in the [ipfs/go-unixfsnode](https://github.com/ipfs/go-unixfsnode) repo.
Additionally, the codec used in UnixFSv1 -- dag-pb --
can be found implemented in the [ipld/go-codec-dagpb](https://github.com/ipld/go-codec-dagpb) repo.
A "some assembly required" advisory may still be in effect for these pieces;
check the readmes in those repos for details on what they support.
The move to making UnixFSv1 a non-core system has been an arduous retrofit.
However, framing it as an ADL also provides many advantages:
- it demonstrates that ADLs as a plugin system _work_, and others can develop new systems in this pattern!
- it has made pathing over UnixFSv1 much more standard and well-defined
- this standardization means systems like [Selectors](https://ipld.io/glossary/#selectors) work naturally over UnixFSv1...
- ... which in turn means anything using them (ex: CAR export; graphsync; etc) can very easily be asked to produce a merkle-proof
for a path over UnixFSv1 data, without requiring the querier to know about the internals. Whew!
We hope users and developers alike will find value in how these systems are now layered.
Change Policy
-------------
The go-ipld-prime library is ready to use, and we value stability highly.
We make releases periodically.
However, using a commit hash to pin versions precisely when depending on this library is also perfectly acceptable.
(Only commit hashes on the master branch can be expected to persist, however;
depending on a commit hash in a branch is not recommended. See [development branches](#development-branches).)
We maintain a [CHANGELOG](CHANGELOG.md)!
Please read it, when updating!
We do make reasonable attempts to minimize the degree of changes to the library which will create "breaking change" experiences for downstream consumers,
and we do document these in the changelog (often, even with specific migration instructions).
However, we do also still recommend running your own compile and test suites as a matter of course after updating.
You can help make developing this library easier by staying up-to-date as a downstream consumer!
When we do discover a need for API changes, we typically try to introduce the new API first,
and do at least one release tag in which the old API is deprecated (but not yet removed).
We will all be able to develop software faster, together, as an ecosystem,
if libraries can keep reasonably closely up-to-date with the most recent tags.
### Version Names
When a tag is made, version number steps in go-ipld-prime advance as follows:
1. the number bumps when the lead maintainer says it does.
2. even numbers should be easy upgrades; odd numbers may change things.
3. the version will start with `v0.` until further notice.
[This is WarpVer](https://gist.github.com/warpfork/98d2f4060c68a565e8ad18ea4814c25f).
These version numbers are provided as hints about what to expect,
but ultimately, you should always invoke your compiler and your tests to tell you about compatibility,
as well as read the [changelog](CHANGELOG.md).
### Updating
**Read the [CHANGELOG](CHANGELOG.md).**
Really, read it. We put exact migration instructions in there, as much as possible. Even outright scripts, when feasible.
An even-number release tag is usually made very shortly before an odd number tag,
so if you're cautious about absorbing changes, you should update to the even number first,
run all your tests, and *then* upgrade to the odd number.
Usually the step to the even number should go off without a hitch, but if you *do* get problems from advancing to an even number tag,
A) you can be pretty sure it's a bug, and B) you didn't have to edit a bunch of code before finding that out.
### Development branches
The following are norms you can expect of changes to this codebase, and the treatment of branches:
- The `master` branch will not be force-pushed.
- (exceptional circumstances may exist, but such exceptions will only be considered valid for about as long after push as the "$N-second-rule" about dropped food).
- Therefore, commit hashes on master are gold to link against.
- All other branches *can* be force-pushed.
- Therefore, commit hashes not reachable from the master branch are inadvisable to link against.
- If it's on master, it's understood to be good, in as much as we can tell.
- Changes and features don't get merged until their tests pass!
- Packages of "alpha" developmental status may exist, and be more subject to change than other more finalized parts of the repo, but their self-tests will at least pass.
- Development proceeds -- both starting from and ending on -- the `master` branch.
- There are no other long-running supported-but-not-master branches.
- The existence of tags at any particular commit do not indicate that we will consider starting a long running and supported diverged branch from that point, nor start doing backports, etc.
================================================
FILE: README_migrationGuide.md
================================================
A short guide to migrating to go-ipld-prime from other repos
============================================================
Here are some quick notes on APIs that you might've been using
if you worked with IPLD in golang before go-ipld-prime,
and a pointer to what you should check out for an equivalent
in order to upgrade your code to use go-ipld-prime.
(Let us know if there are more pointers we should add to this list to ease your journey,
or someone else's future journey!)
- Were you using [ipfs/go-datastore](https://pkg.go.dev/github.com/ipfs/go-datastore) APIs?
- You can wrap those in `storage/dsadapter` and keep using them.
You can also plug that into `linking.LinkSystem` to get higher level IPLD operations.
- Or if you were only using datastore because of some specific implementation of it, like, say `flatfs`?
Then check out the possibility of moving all the way directly to new implementations like `storage/fsstore`.
- Were you using [ipfs/go-ipfs-blockstore](https://pkg.go.dev/github.com/ipfs/go-ipfs-blockstore) APIs?
- You can wrap those in `storage/bsadapter` and keep using them.
You can also plug that into `linking.LinkSystem` to get higher level IPLD operations.
(This is almost exactly the same; we've just simplified in the interface, made it easier to implement, and cleaned up inconsistencies with the other interfaces in this migration guide which were already very very similar.)
- Were you using [ipfs/go-blockservice](https://pkg.go.dev/github.com/ipfs/go-blockservice) APIs?
- You can wrap those in `storage/bsrvadapter` and keep using them.
You can also plug that into `linking.LinkSystem` to get higher level IPLD operations.
- Be judicious about whether you actually want to do this.
Plugging in the potential to experience unknown network latencies into code that's expecting predictable local lookup speeds
may have undesirable performance outcomes. (But if you want to do it, go ahead...)
- Were you using [ipfs/go-ipld-format.DAGService](https://pkg.go.dev/github.com/ipfs/go-ipld-format#DAGService)?
- If you're using the `Add` and `Get` methods: those are now on `linking.LinkSystem`, as `Store` and `Load`.
- If you're using the `*Many` methods: those don't have direct replacements;
we don't use APIs that force that style of future-aggregation anymore, because it's bad for pipelining.
Just use `Store` and `Load`.
- Were you using [ipfs/go-ipld-format.Node](https://pkg.go.dev/github.com/ipfs/go-ipld-format#Node)?
- That's actually a semantic doozy -- we use the word "node" _much_ differently now.
See https://ipld.io/glossary/#node for an introduction.
(Long story short: the old "node" was often more like a whole block, and the new "node" is more like an AST node: there's lots of "node" in a "block" now.)
- There's an `datamodel.Node` interface -- it's probably what you want.
(You just might have to update how you think about it -- see above bullet point about semantics shift.)
It's also aliased as the `ipld.Node` interface here right in the root package, because it's such an important and central interface that you'll be using it all the time.
- Are you specifically looking for how to get a list of links out of a block?
That's a `LinkSystem.Load` followed by applying `traversal.SelectLinks` on the node it gives you: now you've got the list of links from that node (and its children, recursively, as long as they came from the same block of raw data), tada!
- Are you looking for the equivalent of [ipfs/go-ipld-format.Link](https://pkg.go.dev/github.com/ipfs/go-ipld-format#Link)?
- That's actually a feature specific to dag-pb, and arguably even specific to unixfsv1.
There is no equivalent in go-ipld-prime as a result.
But you'll find it in other libraries that are modern and go-ipld-prime based: see below.
- Were you using some feature specific to dag-pb?
- There's an updated dag-pb codec found in https://github.com/ipld/go-codec-dagpb -- it should have what you need.
- Does it turn out you actually meant you're using some feature specific to unixfsv1?
(Yeah -- that comes up a lot. It's one of the reasons we're deprecating so many of the old libraries -- they make it _really_ easy to confuse this.)
Then hang on for the next bullet point, which is for you! :)
- Were you using some features of unixfsv1?
- Check out the https://github.com/ipfs/go-unixfsnode library -- it should have what you need.
- Pathing, like what used to be found in ipfs/go-path? That's here now.
- Sharding? That's here now too.
- You probably don't need incentives if you're here already, but can we quickly mention that... you can use Selectors over these? Neat!
If you're encountering more questions about how to migrate some code,
please jump in to the ipld chat via either [matrix](https://matrix.to/#/#ipld:ipfs.io) or discord (or any other bridge)
and ask!
We want to grow this list of pointers to be as encompassing and helpful as possible.
================================================
FILE: adl/interface.go
================================================
package adl
import (
"github.com/ipld/go-ipld-prime/datamodel"
)
// ADL is an interface denoting an Advanced Data Layout,
// which is something that supports all the datamodel.Node operations,
// but may be doing so using some custom internal logic.
//
// For more details, see the docs at
// https://ipld.io/docs/advanced-data-layouts/ .
//
// This interface doesn't specify much new behavior, but it does include
// the requirement of a way to tell an examiner about your "substrate",
// since this concept does seem to be present in all ADLs.
type ADL interface {
datamodel.Node
// Substrate returns the underlying Data Model node, which can be used
// to encode an ADL's raw layout.
//
// Note that the substrate of an ADL can contain other ADLs!
Substrate() datamodel.Node
}
================================================
FILE: adl/rot13adl/example_test.go
================================================
package rot13adl_test
import (
"bytes"
"context"
"fmt"
"strings"
"github.com/ipfs/go-cid"
"github.com/ipld/go-ipld-prime/adl/rot13adl"
"github.com/ipld/go-ipld-prime/codec/dagjson"
"github.com/ipld/go-ipld-prime/datamodel"
"github.com/ipld/go-ipld-prime/linking"
cidlink "github.com/ipld/go-ipld-prime/linking/cid"
"github.com/ipld/go-ipld-prime/must"
"github.com/ipld/go-ipld-prime/storage/memstore"
)
func ExampleReify_unmarshallingToADL() {
// Create a NodeBuilder for the ADL's substrate.
// Unmarshalling into this memory structure is optimal,
// because it immediately puts data into the right memory layout for the ADL code to work on,
// but you could use any other kind of NodeBuilder just as well and still get correct results.
nb := rot13adl.Prototype.SubstrateRoot.NewBuilder()
// Unmarshal -- using the substrate's nodebuilder just like you'd unmarshal with any other nodebuilder.
err := dagjson.Decode(nb, strings.NewReader(`"n pbby fgevat"`))
fmt.Printf("unmarshal error: %v\n", err)
// Use `Reify` to get the synthetic high-level view of the ADL data.
substrateNode := nb.Build()
syntheticView, err := rot13adl.Reify(substrateNode)
fmt.Printf("reify error: %v\n", err)
// We can inspect the synthetic ADL node like any other node!
fmt.Printf("adl node kind: %v\n", syntheticView.Kind())
fmt.Printf("adl view value: %q\n", must.String(syntheticView))
// Output:
// unmarshal error: <nil>
// reify error: <nil>
// adl node kind: string
// adl view value: "a cool string"
}
func ExampleReify_loadingToADL() {
// Create a NodeBuilder for the ADL's substrate.
// Unmarshalling into this memory structure is optimal,
// because it immediately puts data into the right memory layout for the ADL code to work on,
// but you could use any other kind of NodeBuilder just as well and still get correct results.
nb := rot13adl.Prototype.SubstrateRoot.NewBuilder()
// Unmarshal -- using the substrate's nodebuilder just like you'd unmarshal with any other nodebuilder.
err := dagjson.Decode(nb, strings.NewReader(`"n pbby fgevat"`))
fmt.Printf("unmarshal error: %v\n", err)
substrateNode := nb.Build()
// now save the node to storage
lp := cidlink.LinkPrototype{Prefix: cid.Prefix{
Version: 1,
Codec: 0x129,
MhType: 0x13,
MhLength: 4,
}}
linkSystem := cidlink.DefaultLinkSystem()
storage := &memstore.Store{}
linkSystem.SetReadStorage(storage)
linkSystem.SetWriteStorage(storage)
linkSystem.NodeReifier = func(_ linking.LinkContext, nd datamodel.Node, _ *linking.LinkSystem) (datamodel.Node, error) {
return rot13adl.Reify(nd)
}
lnk, err := linkSystem.Store(linking.LinkContext{Ctx: context.Background()}, lp, substrateNode)
fmt.Printf("storage error: %v\n", err)
// reload from storage, but this time the NodeReifier function should give us the ADL
syntheticView, err := linkSystem.Load(linking.LinkContext{Ctx: context.Background()}, lnk, rot13adl.Prototype.SubstrateRoot)
fmt.Printf("load error: %v\n", err)
// We can inspect the synthetic ADL node like any other node!
fmt.Printf("adl node kind: %v\n", syntheticView.Kind())
fmt.Printf("adl view value: %q\n", must.String(syntheticView))
// Output:
// unmarshal error: <nil>
// storage error: <nil>
// load error: <nil>
// adl node kind: string
// adl view value: "a cool string"
}
func ExampleR13String_creatingViaADL() {
// Create a NodeBuilder for the ADL -- the high-level synthesized thing (not the substrate).
nb := rot13adl.Prototype.Node.NewBuilder()
// Create a ADL node via its builder. This is just like creating any other node in IPLD.
nb.AssignString("woohoo")
n := nb.Build()
// We can inspect the synthetic ADL node like any other node!
fmt.Printf("adl node kind: %v\n", n.Kind())
fmt.Printf("adl view value: %q\n", must.String(n))
// We can get the substrate view and examine that as a node too.
// (This requires a cast to see that we have an ADL, though. Not all IPLD nodes have a 'Substrate' property.)
substrateNode := n.(rot13adl.R13String).Substrate()
fmt.Printf("substrate node kind: %v\n", substrateNode.Kind())
fmt.Printf("substrate value: %q\n", must.String(substrateNode))
// To marshal the ADL, just use marshal methods on its substrate as normal:
var marshalBuffer bytes.Buffer
err := dagjson.Encode(substrateNode, &marshalBuffer)
fmt.Printf("marshalled: %v\n", marshalBuffer.String())
fmt.Printf("marshal error: %v\n", err)
// Output:
// adl node kind: string
// adl view value: "woohoo"
// substrate node kind: string
// substrate value: "jbbubb"
// marshalled: "jbbubb"
// marshal error: <nil>
}
// It's worth noting that the builders for an ADL substrate node still return the substrate.
// (This is interesting in contrast to Schemas, where codegenerated representation-level builders
// yield the type-level node values (and not the representation level node).)
//
// To convert the substrate node to the high level synthesized view of the ADL,
// use Reify as normal -- it's the same whether you've used the substrate type
// or if you've used any other node implementation to hold the data.
//
// Future work: unmarshalling which can invoke an ADL mid-structure,
// and automatically places the reified ADL in place in the larger structure.
//
// There will be several ways to do this (it hinges around "the signalling problem",
// discussed in https://github.com/ipld/specs/issues/130 ):
//
// The first way is to use IPLD Schemas, which provide a signalling mechanism
// by leaning on the schema, and the matching of shape of surrounding data to the schema,
// as a way to determine where an ADL is expected to appear.
//
// A second mechanism could involve new unmarshal function contracts
// which would ake a (fairly complex) argument that says what NodePrototype to use in certain positions.
// This could be accomplished by use of Selectors.
// (This would also have many other potential purposes -- implementing this in terms of NodePrototype selection is very multi-purpose,
// and could be used for efficiency and misc tuning purposes,
// for expecting a *schema* thing part way through, and so forth.)
//
================================================
FILE: adl/rot13adl/rot13logic.go
================================================
package rot13adl
import (
"strings"
)
var replaceTable = []string{
"A", "N",
"B", "O",
"C", "P",
"D", "Q",
"E", "R",
"F", "S",
"G", "T",
"H", "U",
"I", "V",
"J", "W",
"K", "X",
"L", "Y",
"M", "Z",
"N", "A",
"O", "B",
"P", "C",
"Q", "D",
"R", "E",
"S", "F",
"T", "G",
"U", "H",
"V", "I",
"W", "J",
"X", "K",
"Y", "L",
"Z", "M",
"a", "n",
"b", "o",
"c", "p",
"d", "q",
"e", "r",
"f", "s",
"g", "t",
"h", "u",
"i", "v",
"j", "w",
"k", "x",
"l", "y",
"m", "z",
"n", "a",
"o", "b",
"p", "c",
"q", "d",
"r", "e",
"s", "f",
"t", "g",
"u", "h",
"v", "i",
"w", "j",
"x", "k",
"y", "l",
"z", "m",
}
var unreplaceTable = func() []string {
v := make([]string, len(replaceTable))
for i := 0; i < len(replaceTable); i += 2 {
v[i] = replaceTable[i+1]
v[i+1] = replaceTable[i]
}
return v
}()
// rotate transforms from the logical content to the raw content.
func rotate(s string) string {
return strings.NewReplacer(replaceTable...).Replace(s)
}
// unrotate transforms from the raw content to the logical content.
func unrotate(s string) string {
return strings.NewReplacer(unreplaceTable...).Replace(s)
}
================================================
FILE: adl/rot13adl/rot13node.go
================================================
/*
rot13adl is a demo ADL -- its purpose is to show what an ADL and its public interface can look like.
It implements a "rot13" string: when creating data through the ADL, the user gives it a regular string;
the ADL will create aninternal representation of it which has the characters altered in a reversible way.
It provides reference and example materal, but it's very unlikely you want to use it in real situations ;)
There are several ways to move data in and out of the ADL:
- treat it like a regular IPLD map:
- using the exported NodePrototype can be used to get a NodeBuilder which can accept keys and values;
- using the resulting Node and doing lookup operations on it like a regular map;
- load up raw substrate data and `Reify()` it into the synthesized form, and *then* treat it like a regular map:
- this is handy if the raw data already parsed into Nodes.
- optionally, use `SubstrateRootPrototype` as the prototype for loading the raw substrate data;
any kind of Node is a valid input to Reify, but this one will generally have optimal performance.
- take the synthesized form and inspect its substrate data:
- the `Substrate()` method will return another datamodel.Node which is the root of the raw substrate data,
and can be walked normally like any other datamodel.Node.
*/
package rot13adl
import (
"github.com/ipld/go-ipld-prime/datamodel"
"github.com/ipld/go-ipld-prime/node/mixins"
"github.com/ipld/go-ipld-prime/schema"
)
// -- Node -->
var _ datamodel.Node = (R13String)(nil)
type R13String = *_R13String
type _R13String struct {
raw string // the raw content, before our ADL lens is applied to it.
synthesized string // the content that the ADL presents. calculated proactively from the original, in this implementation (though you could imagine implementing it lazily, in either direction, too).
}
func (*_R13String) Kind() datamodel.Kind {
return datamodel.Kind_String
}
func (*_R13String) LookupByString(string) (datamodel.Node, error) {
return mixins.String{TypeName: "rot13adl.R13String"}.LookupByString("")
}
func (*_R13String) LookupByNode(datamodel.Node) (datamodel.Node, error) {
return mixins.String{TypeName: "rot13adl.R13String"}.LookupByNode(nil)
}
func (*_R13String) LookupByIndex(idx int64) (datamodel.Node, error) {
return mixins.String{TypeName: "rot13adl.R13String"}.LookupByIndex(0)
}
func (*_R13String) LookupBySegment(seg datamodel.PathSegment) (datamodel.Node, error) {
return mixins.String{TypeName: "rot13adl.R13String"}.LookupBySegment(seg)
}
func (*_R13String) MapIterator() datamodel.MapIterator {
return nil
}
func (*_R13String) ListIterator() datamodel.ListIterator {
return nil
}
func (*_R13String) Length() int64 {
return -1
}
func (*_R13String) IsAbsent() bool {
return false
}
func (*_R13String) IsNull() bool {
return false
}
func (*_R13String) AsBool() (bool, error) {
return mixins.String{TypeName: "rot13adl.R13String"}.AsBool()
}
func (*_R13String) AsInt() (int64, error) {
return mixins.String{TypeName: "rot13adl.R13String"}.AsInt()
}
func (*_R13String) AsFloat() (float64, error) {
return mixins.String{TypeName: "rot13adl.R13String"}.AsFloat()
}
func (n *_R13String) AsString() (string, error) {
return n.synthesized, nil
}
func (*_R13String) AsBytes() ([]byte, error) {
return mixins.String{TypeName: "rot13adl.R13String"}.AsBytes()
}
func (*_R13String) AsLink() (datamodel.Link, error) {
return mixins.String{TypeName: "rot13adl.R13String"}.AsLink()
}
func (*_R13String) Prototype() datamodel.NodePrototype {
return _R13String__Prototype{}
}
// -- NodePrototype -->
var _ datamodel.NodePrototype = _R13String__Prototype{}
type _R13String__Prototype struct {
// There's no configuration to this ADL.
// A more complex ADL might have some kind of parameters here.
//
// The general contract of a NodePrototype is supposed to be that:
// when you get one from an existing Node,
// it should have enough information to create a new Node that
// could "replace" the previous one in whatever context it's in.
// For ADLs, that means it should carry most of the configuration.
//
// An ADL that does multi-block stuff might also need functions like a LinkLoader passed in through here.
}
func (np _R13String__Prototype) NewBuilder() datamodel.NodeBuilder {
return &_R13String__Builder{}
}
// -- NodeBuilder -->
var _ datamodel.NodeBuilder = (*_R13String__Builder)(nil)
type _R13String__Builder struct {
_R13String__Assembler
}
func (nb *_R13String__Builder) Build() datamodel.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 *_R13String__Builder) Reset() {
*nb = _R13String__Builder{}
}
// -- NodeAssembler -->
var _ datamodel.NodeAssembler = (*_R13String__Assembler)(nil)
type _R13String__Assembler struct {
w *_R13String
m schema.Maybe // REVIEW: if the package where this Maybe enum lives is maybe not the right home for it after all. Or should this line use something different? We're only using some of its values after all.
}
func (_R13String__Assembler) BeginMap(sizeHint int64) (datamodel.MapAssembler, error) {
return mixins.StringAssembler{TypeName: "rot13adl.R13String"}.BeginMap(0)
}
func (_R13String__Assembler) BeginList(sizeHint int64) (datamodel.ListAssembler, error) {
return mixins.StringAssembler{TypeName: "rot13adl.R13String"}.BeginList(0)
}
func (na *_R13String__Assembler) AssignNull() error {
// REVIEW: unclear how this might compose with some other context (like a schema) which does allow nulls. Probably a wrapper type?
return mixins.StringAssembler{TypeName: "rot13adl.R13String"}.AssignNull()
}
func (_R13String__Assembler) AssignBool(bool) error {
return mixins.StringAssembler{TypeName: "rot13adl.R13String"}.AssignBool(false)
}
func (_R13String__Assembler) AssignInt(int64) error {
return mixins.StringAssembler{TypeName: "rot13adl.R13String"}.AssignInt(0)
}
func (_R13String__Assembler) AssignFloat(float64) error {
return mixins.StringAssembler{TypeName: "rot13adl.R13String"}.AssignFloat(0)
}
func (na *_R13String__Assembler) AssignString(v string) error {
switch na.m {
case schema.Maybe_Value:
panic("invalid state: cannot assign into assembler that's already finished")
}
na.w = &_R13String{
raw: rotate(v),
synthesized: v,
}
na.m = schema.Maybe_Value
return nil
}
func (_R13String__Assembler) AssignBytes([]byte) error {
return mixins.StringAssembler{TypeName: "rot13adl.R13String"}.AssignBytes(nil)
}
func (_R13String__Assembler) AssignLink(datamodel.Link) error {
return mixins.StringAssembler{TypeName: "rot13adl.R13String"}.AssignLink(nil)
}
func (na *_R13String__Assembler) AssignNode(v datamodel.Node) error {
if v.IsNull() {
return na.AssignNull()
}
if v2, ok := v.(*_R13String); ok {
switch na.m {
case schema.Maybe_Value:
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.AsString(); err != nil {
return err
} else {
return na.AssignString(v2)
}
}
func (_R13String__Assembler) Prototype() datamodel.NodePrototype {
return _R13String__Prototype{}
}
================================================
FILE: adl/rot13adl/rot13node_test.go
================================================
package rot13adl
import (
"testing"
qt "github.com/frankban/quicktest"
"github.com/ipld/go-ipld-prime/datamodel"
"github.com/ipld/go-ipld-prime/node/basicnode"
)
func TestLogicalNodeRoundtrip(t *testing.T) {
// Build high level node.
nb := Prototype.Node.NewBuilder()
err := nb.AssignString("abcd")
qt.Assert(t, err, qt.IsNil)
n := nb.Build()
// Inspect the high level node.
s, err := n.AsString()
qt.Check(t, err, qt.IsNil)
qt.Check(t, s, qt.Equals, "abcd")
}
func TestNodeInternal(t *testing.T) {
// Build high level node.
nb := Prototype.Node.NewBuilder()
err := nb.AssignString("abcd")
qt.Assert(t, err, qt.IsNil)
n := nb.Build()
// Poke its insides directly to see that the transformation occurred.
qt.Check(t, n.(*_R13String).synthesized, qt.Equals, "abcd")
qt.Check(t, n.(*_R13String).raw, qt.Equals, "nopq")
}
func TestReify(t *testing.T) {
t.Run("using unspecialized raw node", func(t *testing.T) {
// Build substrate-shaped data using basicnode.
sn := basicnode.NewString("nopq")
// Reify it.
synth, err := Reify(sn)
// Inspect the resulting high level node.
qt.Assert(t, err, qt.IsNil)
qt.Check(t, synth.Kind(), qt.Equals, datamodel.Kind_String)
s, err := synth.AsString()
qt.Check(t, err, qt.IsNil)
qt.Check(t, s, qt.Equals, "abcd")
})
t.Run("using substrate node", func(t *testing.T) {
// Build substrate-shaped data, in the substrate type right from the start.
snb := Prototype.SubstrateRoot.NewBuilder()
snb.AssignString("nopq")
sn := snb.Build()
// Reify it.
synth, err := Reify(sn)
// Inspect the resulting high level node.
qt.Assert(t, err, qt.IsNil)
qt.Check(t, synth.Kind(), qt.Equals, datamodel.Kind_String)
s, err := synth.AsString()
qt.Check(t, err, qt.IsNil)
qt.Check(t, s, qt.Equals, "abcd")
})
}
func TestInspectingSubstrate(t *testing.T) {
// Build high level node.
nb := Prototype.Node.NewBuilder()
err := nb.AssignString("abcd")
qt.Assert(t, err, qt.IsNil)
n := nb.Build()
// Ask it about its substrate, and inspect that.
sn := n.(R13String).Substrate()
// TODO: It's unfortunate this is only available as a concrete type cast: we should probably make a standard feature detection interface with `Substrate()`.
// Is it reasonable to make this part of a standard feature detection pattern,
// and make that interface reside in the main IPLD package? Or in an `adl` package that contains such standard interfaces?
ss, err := sn.AsString()
qt.Check(t, err, qt.IsNil)
qt.Check(t, ss, qt.Equals, "nopq")
}
================================================
FILE: adl/rot13adl/rot13prototypes.go
================================================
package rot13adl
// Prototype embeds a NodePrototype for every kind of Node implementation in this package.
// This includes both the synthesized node as well as the substrate root node
// (other substrate interior node prototypes are not exported here;
// it's unlikely they'll be useful outside of the scope of the ADL's implementation package.)
//
// You can use it like this:
//
// rot13adl.Prototype.Node.NewBuilder() //...
//
// and:
//
// rot13adl.Prototype.SubstrateRoot.NewBuilder() // ...
var Prototype prototype
// This may seem a tad mundane, but we do it for consistency with the way
// other Node implementation packages (like basicnode) do this:
// it's a convention for "pkgname.Prototype.SpecificThing.NewBuilder()" to be defined.
type prototype struct {
Node _R13String__Prototype
SubstrateRoot _Substrate__Prototype
}
// REVIEW: In ADLs that use codegenerated substrate types defined by an IPLD Schema, the `Prototype.SubstrateRoot` field...
// should it be a `_SubstrateRoot__Prototype`, or a `_SubstrateRoot__ReprPrototype`?
// Probably the latter, because the only thing an external user of this package should be interested in is how to read data into memory in an optimal path.
// But does this answer all questions? Codegen ReprPrototypes currently still return the type-level node from their Build method!
// This probably would functionally work -- we could make the Reify methods check for either the type-level or repr-level types -- but would it be weird/surprising/hard-to-use?
================================================
FILE: adl/rot13adl/rot13reification.go
================================================
package rot13adl
import (
"fmt"
"github.com/ipld/go-ipld-prime/datamodel"
)
// Reify examines data in a Node to see if it matches the shape for valid substrate data for this ADL,
// and if so, synthesizes and returns the high-level view of the ADL.
// If it succeeds in recognizing the raw data as this ADL,
// Reify returns a new Node which exhibits the logical behaviors of the ADL;
// otherwise, it returns an error.
//
// The input data can be any implementation of ipld.Node;
// it will be considered purely through that interface.
//
// If your application is expecting ADL data, this pipeline can be optimized
// by using the SubstratePrototype right from the start when unmarshalling;
// then, Reify can detect if the rawRoot parameter is of that implementation,
// and it can save some processing work internally that can be known to already be done.
//
// Reification will generally operate on the data in a single block
// (e.g. this function will not do any additional block loads and unmarshalling).
// This is important because some ADLs handle data so large that loading it all
// eagerly would be impractical (and in some cases outright impossible).
// However, it also necessarily implies that invalid data may lie beyond
// one of those lazy loads, and it won't be discovered at the time of Reify.
//
// In this demo ADL, we don't have multi-block content at all,
// so of course we don't have any additional block loads!
// However, ADL implementations may vary in their approaches to lazy vs eager loading.
// All ADLs should document their exact semantics regarding this --
// especially if it has any implications for boundaries of data validity checking.
//
// REVIEW: this function is currently not conforming to any particular interface;
// if we evolve the contract for ADLs to include an interface for reficiation functions,
// might we need to add context and link loader systems as parameters to it?
// Not all implementations might need it, as per previous paragraph; but some might.
// Reification for multiblock ADLs might also need link loader systems as a parameter here
// so they can capture them as config and hold them for use in future operations that do lazy loading.
func Reify(maybeSubstrateRoot datamodel.Node) (datamodel.Node, error) {
// Reify is often very easy to implement,
// especially if you have an IPLD Schema that specifies the shape of the substrate data:
// We can just check if the data in maybeSubstrateRoot happens to already be exactly the right type,
// and if so, take very direct shortcuts because we already know its been validated in shape;
// otherwise, we create a new piece of memory for our native substrate memory layout,
// and assign into it from the raw node, validating in the process,
// which again just leans directly on the shape validation logic already given to us by the schema logic on that type.
// (Checking the concrete type of maybeSubstrateRoot in search of a shortcut is seemingly a tad redundant,
// because the AssignNode path later also has such a check!
// However, doing it earlier allows us to avoid an allocation;
// the AssignNode path doesn't become available until after NewBuilder is invoked, and NewBuilder is where allocations happen.)
// Check if we can recognize the maybeSubstrateRoot as being our own substrate types;
// if it is, we can shortcut pretty drastically.
if x, ok := maybeSubstrateRoot.(*_Substrate); ok {
// In this ADL implementation, the high level node has the exact same memory layout as the substrate root,
// and so our only remaining processing here is just to cast them, so that
// the node we return has the correct methodset exposed.
return (*_R13String)(x), nil
}
// Shortcut didn't work. Process via the data model.
// The AssignNode method on the substrate type already contains all the logic necessary for this, so we use that.
nb := Prototype.SubstrateRoot.NewBuilder()
if err := nb.AssignNode(maybeSubstrateRoot); err != nil {
return nil, fmt.Errorf("rot13adl.Reify failed: data does not match expected shape for substrate: %w", err)
}
return (*_R13String)(nb.Build().(*_Substrate)), nil
}
================================================
FILE: adl/rot13adl/rot13substrate.go
================================================
package rot13adl
import (
"github.com/ipld/go-ipld-prime/datamodel"
"github.com/ipld/go-ipld-prime/node/mixins"
"github.com/ipld/go-ipld-prime/schema"
)
// Substrate returns the root node of the raw internal data form of the ADL's content.
func (n *_R13String) Substrate() datamodel.Node {
// This is a very minor twist in the case of the rot13 ADL.
// However, for larger ADLs (especially those relating to multi-block collections),
// this could be quite a bit more involved, and would almost certainly be the root node of a larger tree.
return (*_Substrate)(n)
}
// -- Node -->
var _ datamodel.Node = (*_Substrate)(nil)
// Somewhat unusually for an ADL, there's only one substrate node type,
// and we actually made it have the same in-memory structure as the synthesized view node.
//
// When implementing other more complex ADLs, it will probably be more common to have
// the synthesized high-level node type either embed or have a pointer to the substrate root node.
type _Substrate _R13String
// REVIEW: what on earth we think the "TypeName" strings in error messages and other references to this node should be.
// At the moment, it shares a prefix with the synthesized node, which is potentially confusing (?),
// and I'm not sure what, if any, suffix actually makes meaningful sense to a user either.
// I added the segment ".internal." to the middle of the name mangle; does this seem helpful?
func (*_Substrate) Kind() datamodel.Kind {
return datamodel.Kind_String
}
func (*_Substrate) LookupByString(string) (datamodel.Node, error) {
return mixins.String{TypeName: "rot13adl.internal.Substrate"}.LookupByString("")
}
func (*_Substrate) LookupByNode(datamodel.Node) (datamodel.Node, error) {
return mixins.String{TypeName: "rot13adl.internal.Substrate"}.LookupByNode(nil)
}
func (*_Substrate) LookupByIndex(idx int64) (datamodel.Node, error) {
return mixins.String{TypeName: "rot13adl.internal.Substrate"}.LookupByIndex(0)
}
func (*_Substrate) LookupBySegment(seg datamodel.PathSegment) (datamodel.Node, error) {
return mixins.String{TypeName: "rot13adl.internal.Substrate"}.LookupBySegment(seg)
}
func (*_Substrate) MapIterator() datamodel.MapIterator {
return nil
}
func (*_Substrate) ListIterator() datamodel.ListIterator {
return nil
}
func (*_Substrate) Length() int64 {
return -1
}
func (*_Substrate) IsAbsent() bool {
return false
}
func (*_Substrate) IsNull() bool {
return false
}
func (*_Substrate) AsBool() (bool, error) {
return mixins.String{TypeName: "rot13adl.internal.Substrate"}.AsBool()
}
func (*_Substrate) AsInt() (int64, error) {
return mixins.String{TypeName: "rot13adl.internal.Substrate"}.AsInt()
}
func (*_Substrate) AsFloat() (float64, error) {
return mixins.String{TypeName: "rot13adl.internal.Substrate"}.AsFloat()
}
func (n *_Substrate) AsString() (string, error) {
return n.raw, nil
}
func (*_Substrate) AsBytes() ([]byte, error) {
return mixins.String{TypeName: "rot13adl.internal.Substrate"}.AsBytes()
}
func (*_Substrate) AsLink() (datamodel.Link, error) {
return mixins.String{TypeName: "rot13adl.internal.Substrate"}.AsLink()
}
func (*_Substrate) Prototype() datamodel.NodePrototype {
return _Substrate__Prototype{}
}
// -- NodePrototype -->
var _ datamodel.NodePrototype = _Substrate__Prototype{}
type _Substrate__Prototype struct {
// There's no configuration to this ADL.
}
func (np _Substrate__Prototype) NewBuilder() datamodel.NodeBuilder {
return &_Substrate__Builder{}
}
// -- NodeBuilder -->
var _ datamodel.NodeBuilder = (*_Substrate__Builder)(nil)
type _Substrate__Builder struct {
_Substrate__Assembler
}
func (nb *_Substrate__Builder) Build() datamodel.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 *_Substrate__Builder) Reset() {
*nb = _Substrate__Builder{}
}
// -- NodeAssembler -->
var _ datamodel.NodeAssembler = (*_Substrate__Assembler)(nil)
type _Substrate__Assembler struct {
w *_Substrate
m schema.Maybe // REVIEW: if the package where this Maybe enum lives is maybe not the right home for it after all. Or should this line use something different? We're only using some of its values after all.
}
func (_Substrate__Assembler) BeginMap(sizeHint int64) (datamodel.MapAssembler, error) {
return mixins.StringAssembler{TypeName: "rot13adl.internal.Substrate"}.BeginMap(0)
}
func (_Substrate__Assembler) BeginList(sizeHint int64) (datamodel.ListAssembler, error) {
return mixins.StringAssembler{TypeName: "rot13adl.internal.Substrate"}.BeginList(0)
}
func (na *_Substrate__Assembler) AssignNull() error {
// REVIEW: unclear how this might compose with some other context (like a schema) which does allow nulls. Probably a wrapper type?
return mixins.StringAssembler{TypeName: "rot13adl.internal.Substrate"}.AssignNull()
}
func (_Substrate__Assembler) AssignBool(bool) error {
return mixins.StringAssembler{TypeName: "rot13adl.internal.Substrate"}.AssignBool(false)
}
func (_Substrate__Assembler) AssignInt(int64) error {
return mixins.StringAssembler{TypeName: "rot13adl.internal.Substrate"}.AssignInt(0)
}
func (_Substrate__Assembler) AssignFloat(float64) error {
return mixins.StringAssembler{TypeName: "rot13adl.internal.Substrate"}.AssignFloat(0)
}
func (na *_Substrate__Assembler) AssignString(v string) error {
switch na.m {
case schema.Maybe_Value:
panic("invalid state: cannot assign into assembler that's already finished")
}
na.w = &_Substrate{
raw: v,
synthesized: unrotate(v),
}
na.m = schema.Maybe_Value
return nil
}
func (_Substrate__Assembler) AssignBytes([]byte) error {
return mixins.StringAssembler{TypeName: "rot13adl.internal.Substrate"}.AssignBytes(nil)
}
func (_Substrate__Assembler) AssignLink(datamodel.Link) error {
return mixins.StringAssembler{TypeName: "rot13adl.internal.Substrate"}.AssignLink(nil)
}
func (na *_Substrate__Assembler) AssignNode(v datamodel.Node) error {
if v.IsNull() {
return na.AssignNull()
}
if v2, ok := v.(*_Substrate); ok {
switch na.m {
case schema.Maybe_Value:
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.AsString(); err != nil {
return err
} else {
return na.AssignString(v2)
}
}
func (_Substrate__Assembler) Prototype() datamodel.NodePrototype {
return _Substrate__Prototype{}
}
================================================
FILE: adl.go
================================================
package ipld
import (
"github.com/ipld/go-ipld-prime/adl"
)
type ADL = adl.ADL
================================================
FILE: codec/README.md
================================================
Codecs
======
The `go-ipld-prime/codec` package is a grouping package.
The subpackages contains some codecs which reside in this repo.
The codecs included here are our "batteries included" codecs,
but they are not otherwise special.
It is not necessary for a codec to be a subpackage here to be a valid codec to use with go-ipld;
anything that implements the `codec.Encoder` and `codec.Decoder` interfaces is fine.
Terminology
-----------
We generally refer to "codecs" as having an "encode" function and "decode" function.
We consider "encoding" to be the process of going from {Data Model} to {serial data},
and "decoding" to be the process of going from {serial data} to {Data Model}.
### Codec vs Multicodec
A "codec" is _any_ function that goes from {Data Model} to {serial data}, or vice versa.
A "multicodec" is a function which does that and is _also_ specifically recognized and described in
the tables in https://github.com/multiformats/multicodec/ .
Multicodecs generally leave no further room for customization and configuration,
because their entire behavior is supposed to be specified by a multicodec indicator code number.
Our codecs, in the child packages of this one, usually offer configuration options.
They also usually offer exactly one function, which does *not* allow configuration,
which is supplying a multicodec-compatible behavior.
You'll see this marked in the docs on those functions.
### Marshal vs Encode
It's common to see the terms "marshal" and "unmarshal" used in golang.
Those terms are usually describing when structured data is transformed into linearized, tokenized data
(and then, perhaps, all the way to serially encoded data), or vice versa.
We would use the words the same way... except we don't end up using them,
because that feature doesn't really come up in our codec layer.
In IPLD, we would describe mapping some typed data into Data Model as "marshalling".
(It's one step shy of tokenizing, but barely: Data Model does already have defined ordering for every element of data.)
And we do have systems that do this:
`bindnode` and our codegen systems both do this, implicitly, when they give you an `ipld.Node` of the representation of some data.
We just don't end up talking about it as "marshalling" because of how it's done implicitly by those systems.
As a result, all of our features relating to codecs only end up speaking about "encoding" and "decoding".
### Legacy code
There are some appearances of the words "marshal" and "unmarshal" in some of our subpackages here.
That verbiage is generally on the way out.
For functions and structures with those names, you'll notice their docs marking them as deprecated.
Why have "batteries-included" codecs?
-------------------------------------
These codecs live in this repo because they're commonly used, highly supported,
and general-purpose codecs that we recommend for widespread usage in new developments.
Also, it's just plain nice to have something in-repo for development purposes.
It makes sure that if we try to make any API changes, we immediately see if they'd make codecs harder to implement.
We also use the batteries-included codecs for debugging, for test fixtures, and for benchmarking.
Further yet, the batteries-included codecs let us offer getting-started APIs.
For example, we offer some helper APIs which use codecs like e.g. JSON to give consumers of the libraries
one-step helper methods that "do the right thing" with zero config... so long as they happen to use that codec.
Even for consumers who don't use those codecs, such functions then serve as natural documentation
and examples for what to do to put their codec of choice to work.
================================================
FILE: codec/api.go
================================================
package codec
import (
"io"
"github.com/ipld/go-ipld-prime/datamodel"
)
// The following two types define the two directions of transform that a codec can be expected to perform:
// from Node to serial stream (aka "encoding", sometimes also described as "marshalling"),
// and from serial stream to Node (via a NodeAssembler) (aka "decoding", sometimes also described as "unmarshalling").
//
// You'll find a couple of implementations matching this shape in subpackages of 'codec'.
// (These are the handful of encoders and decoders we ship as "batteries included".)
// Other encoder and decoder implementations can be found in other repositories/modules.
// It should also be easy to implement encodecs and decoders of your own!
//
// Encoder and Decoder functions can be used on their own, but are also often used via the `ipld/linking.LinkSystem` construction,
// which handles all the other related operations necessary for a content-addressed storage system at once.
//
// Encoder and Decoder functions can be registered in the multicodec table in the `ipld/multicodec` package
// if they're providing functionality that matches the expectations for a multicodec identifier.
// This table will be used by some common EncoderChooser and DecoderChooser implementations
// (namely, the ones in LinkSystems produced by the `linking/cid` package).
// It's not strictly necessary to register functions there, though; you can also just use them directly.
//
// There are furthermore several conventions that codec packages are recommended to follow, but are only conventions:
//
// Most codec packages should have a ReusableEncoder and ResuableDecoder type,
// which contain any working memory needed by the implementation, as well as any configuration options,
// and those types should have an Encode and Decode function respectively which match these function types.
// They may alternatively have EncoderConfig and DecoderConfig types, which have similar purpose,
// but aren't promising memory reuse if kept around.
//
// By convention, a codec package that expects to fulfill a multicodec contract will also have
// a package-scope exported function called Encode or Decode which also matches this interface,
// and is the equivalent of creating a zero-value ReusableEncoder or ReusableDecoder (aka, default config)
// and using its Encode or Decode methods.
// This package-scope function may also internally use a sync.Pool
// to keep some ReusableEncoder values on hand to avoid unnecessary allocations.
//
// Note that an EncoderConfig or DecoderConfig type that supports configuration options
// does not functionally expose those options when invoked by the multicodec system --
// multicodec indicator codes do not provide room for extended configuration info.
// Codecs that expose configuration options are doing so for library users to enjoy;
// it does not mean those non-default configurations will necessarily be available
// in all scenarios that use codecs indirectly.
// There is also no standard interface for such configurations: by nature,
// if they exist at all, they tend to vary per codec.
type (
// Encoder defines the shape of a function which traverses a Node tree
// and emits its data in a serialized form into an io.Writer.
//
// The dual of Encoder is a Decoder, which takes a NodeAssembler
// and fills it with deserialized data consumed from an io.Reader.
// Typically, Decoder and Encoder functions will be found in pairs,
// and will be expected to be able to round-trip each other's data.
//
// Encoder functions can be used directly.
// Encoder functions are also often used via a LinkSystem when working with content-addressed storage.
// LinkSystem methods will helpfully handle the entire process of traversing a Node tree,
// encoding this data, hashing it, streaming it to the writer, and committing it -- all as one step.
//
// An Encoder works with Nodes.
// If you have a native golang structure, and want to serialize it using an Encoder,
// you'll need to figure out how to transform that golang structure into an ipld.Node tree first.
//
// It may be useful to understand "multicodecs" when working with Encoders.
// In IPLD, a system called "multicodecs" is typically used to describe encoding foramts.
// A "multicodec indicator" is a number which describes an encoding;
// the Link implementations used in IPLD (CIDs) store a multicodec indicator in the Link;
// and in this library, a multicodec registry exists in the `codec` package,
// and can be used to associate a multicodec indicator number with an Encoder function.
// The default EncoderChooser in a LinkSystem will use this multicodec registry to select Encoder functions.
// However, you can construct a LinkSystem that uses any EncoderChooser you want.
// It is also possible to have and use Encoder functions that aren't registered as a multicodec at all...
// we just recommend being cautious of this, because it may make your data less recognizable
// when working with other systems that use multicodec indicators as part of their communication.
Encoder func(datamodel.Node, io.Writer) error
// Decoder defines the shape of a function which produces a Node tree
// by reading serialized data from an io.Reader.
// (Decoder doesn't itself return a Node directly, but rather takes a NodeAssembler as an argument,
// because this allows the caller more control over the Node implementation,
// as well as some control over allocations.)
//
// The dual of Decoder is an Encoder, which takes a Node and
// emits its data in a serialized form into an io.Writer.
// Typically, Decoder and Encoder functions will be found in pairs,
// and will be expected to be able to round-trip each other's data.
//
// Decoder functions can be used directly.
// Decoder functions are also often used via a LinkSystem when working with content-addressed storage.
// LinkSystem methods will helpfully handle the entire process of opening block readers,
// verifying the hash of the data stream, and applying a Decoder to build Nodes -- all as one step.
//
// A Decoder works with Nodes.
// If you have a native golang structure, and want to populate it with data using a Decoder,
// you'll need to either get a NodeAssembler which proxies data into that structure directly,
// or assemble a Node as intermediate storage and copy the data to the native structure as a separate step.
//
// It may be useful to understand "multicodecs" when working with Decoders.
// See the documentation on the Encoder function interface for more discussion of multicodecs,
// the multicodec table, and how this is typically connected to linking.
Decoder func(datamodel.NodeAssembler, io.Reader) error
)
// -------------------
// Errors
//
type ErrBudgetExhausted struct{}
func (e ErrBudgetExhausted) Error() string {
return "decoder resource budget exhausted (message too long or too complex)"
}
// ---------------------
// Other valuable and reused constants
//
type MapSortMode uint8
const (
MapSortMode_None MapSortMode = iota
MapSortMode_Lexical
MapSortMode_RFC7049
)
================================================
FILE: codec/cbor/multicodec.go
================================================
package cbor
import (
"io"
"github.com/ipld/go-ipld-prime/codec"
"github.com/ipld/go-ipld-prime/codec/dagcbor"
"github.com/ipld/go-ipld-prime/datamodel"
"github.com/ipld/go-ipld-prime/multicodec"
)
var (
_ codec.Decoder = Decode
_ codec.Encoder = Encode
)
func init() {
multicodec.RegisterEncoder(0x51, Encode)
multicodec.RegisterDecoder(0x51, Decode)
}
// Decode deserializes data from the given io.Reader and feeds it into the given datamodel.NodeAssembler.
// Decode fits the codec.Decoder function interface.
//
// This is the function that will be registered in the default multicodec registry during package init time.
func Decode(na datamodel.NodeAssembler, r io.Reader) error {
return dagcbor.DecodeOptions{
AllowLinks: false,
}.Decode(na, r)
}
// Encode walks the given datamodel.Node and serializes it to the given io.Writer.
// Encode fits the codec.Encoder function interface.
//
// This is the function that will be registered in the default multicodec registry during package init time.
func Encode(n datamodel.Node, w io.Writer) error {
return dagcbor.EncodeOptions{
AllowLinks: false,
}.Encode(n, w)
}
================================================
FILE: codec/cbor/roundtrip_test.go
================================================
package cbor
import (
"bytes"
"strings"
"testing"
qt "github.com/frankban/quicktest"
"github.com/ipld/go-ipld-prime/fluent"
"github.com/ipld/go-ipld-prime/node/basicnode"
nodetests "github.com/ipld/go-ipld-prime/node/tests"
)
var n = fluent.MustBuildMap(basicnode.Prototype.Map, 4, func(na fluent.MapAssembler) {
na.AssembleEntry("plain").AssignString("olde string")
na.AssembleEntry("map").CreateMap(2, func(na fluent.MapAssembler) {
na.AssembleEntry("one").AssignInt(1)
na.AssembleEntry("two").AssignInt(2)
})
na.AssembleEntry("list").CreateList(2, func(na fluent.ListAssembler) {
na.AssembleValue().AssignString("three")
na.AssembleValue().AssignString("four")
})
na.AssembleEntry("nested").CreateMap(1, func(na fluent.MapAssembler) {
na.AssembleEntry("deeper").CreateList(1, func(na fluent.ListAssembler) {
na.AssembleValue().AssignString("things")
})
})
})
var serial = "\xa4eplainkolde stringcmap\xa2cone\x01ctwo\x02dlist\x82ethreedfourfnested\xa1fdeeper\x81fthings"
func TestRoundtrip(t *testing.T) {
t.Run("encoding", func(t *testing.T) {
var buf bytes.Buffer
err := Encode(n, &buf)
qt.Assert(t, err, qt.IsNil)
qt.Check(t, buf.String(), qt.Equals, serial)
})
t.Run("decoding", func(t *testing.T) {
buf := strings.NewReader(serial)
nb := basicnode.Prototype.Map.NewBuilder()
err := Decode(nb, buf)
qt.Assert(t, err, qt.IsNil)
qt.Check(t, nb.Build(), nodetests.NodeContentEquals, n)
})
}
func TestRoundtripScalar(t *testing.T) {
nb := basicnode.Prototype__String{}.NewBuilder()
nb.AssignString("applesauce")
simple := nb.Build()
t.Run("encoding", func(t *testing.T) {
var buf bytes.Buffer
err := Encode(simple, &buf)
qt.Assert(t, err, qt.IsNil)
qt.Check(t, buf.String(), qt.Equals, `japplesauce`)
})
t.Run("decoding", func(t *testing.T) {
buf := strings.NewReader(`japplesauce`)
nb := basicnode.Prototype__String{}.NewBuilder()
err := Decode(nb, buf)
qt.Assert(t, err, qt.IsNil)
qt.Check(t, nb.Build(), nodetests.NodeContentEquals, simple)
})
}
================================================
FILE: codec/dagcbor/common.go
================================================
package dagcbor
const linkTag = 42
================================================
FILE: codec/dagcbor/doc.go
================================================
/*
The dagcbor package provides a DAG-CBOR codec implementation.
The Encode and Decode functions match the codec.Encoder and codec.Decoder function interfaces,
and can be registered with the go-ipld-prime/multicodec package for easy usage with systems such as CIDs.
Importing this package will automatically have the side-effect of registering Encode and Decode
with the go-ipld-prime/multicodec registry, associating them with the standard multicodec indicator numbers for DAG-CBOR.
This implementation follows most of the rules of DAG-CBOR, namely:
- by and large, it does emit and parse CBOR!
- only explicit-length maps and lists will be emitted by Encode;
- only tag 42 is accepted, and it must parse as a CID;
- only 64 bit floats will be emitted by Encode.
This implementation is also not strict about certain rules:
- Encode is order-passthrough when emitting maps (it does not sort, nor abort in error if unsorted data is encountered).
To emit sorted data, the node should be sorted before applying the Encode function.
- Decode is order-passthrough when parsing maps (it does not sort, nor abort in error if unsorted data is encountered).
To be strict about the ordering of data, additional validation must be applied to the result of the Decode function.
- Decode will accept indeterminate length lists and maps without complaint.
(These should not be allowed according to the DAG-CBOR spec, nor will the Encode function re-emit such values,
so this behavior should almost certainly be seen as a bug.)
- Decode does not consistently verify that ints and floats use the smallest representation possible (or, the 64-bit version, in the float case).
(Only these numeric encodings should be allowed according to the DAG-CBOR spec, and the Encode function will not re-emit variations,
so this behavior should almost certainly be seen as a bug.)
A note for future contributors: some functions in this package expose references to packages from the refmt module, and/or use them internally.
Please avoid adding new code which expands the visibility of these references.
In future work, we'd like to reduce or break this relationship entirely
(in part, to reduce dependency sprawl, and in part because several of
the imprecisions noted above stem from that library's lack of strictness).
*/
package dagcbor
================================================
FILE: codec/dagcbor/marshal.go
================================================
package dagcbor
import (
"fmt"
"io"
"sort"
"github.com/polydawn/refmt/cbor"
"github.com/polydawn/refmt/shared"
"github.com/polydawn/refmt/tok"
"github.com/ipld/go-ipld-prime/codec"
"github.com/ipld/go-ipld-prime/datamodel"
cidlink "github.com/ipld/go-ipld-prime/linking/cid"
)
// This file should be identical to the general feature in the parent package,
// except for the `case datamodel.Kind_Link` block,
// which is dag-cbor's special sauce for schemafree links.
// EncodeOptions can be used to customize the behavior of an encoding function.
// The Encode method on this struct fits the codec.Encoder function interface.
type EncodeOptions struct {
// If true, allow encoding of Link nodes as CBOR tag(42);
// otherwise, reject them as unencodable.
AllowLinks bool
// Control the sorting of map keys, using one of the `codec.MapSortMode_*` constants.
MapSortMode codec.MapSortMode
}
// Encode walks the given datamodel.Node and serializes it to the given io.Writer.
// Encode fits the codec.Encoder function interface.
//
// The behavior of the encoder can be customized by setting fields in the EncodeOptions struct before calling this method.
func (cfg EncodeOptions) Encode(n datamodel.Node, w io.Writer) error {
// Probe for a builtin fast path. Shortcut to that if possible.
type detectFastPath interface {
EncodeDagCbor(io.Writer) error
}
if n2, ok := n.(detectFastPath); ok {
return n2.EncodeDagCbor(w)
}
// Okay, generic inspection path.
return Marshal(n, cbor.NewEncoder(w), cfg)
}
// Future work: we would like to remove the Marshal function,
// and in particular, stop seeing types from refmt (like shared.TokenSink) be visible.
// Right now, some kinds of configuration (e.g. for whitespace and prettyprint) are only available through interacting with the refmt types;
// we should improve our API so that this can be done with only our own types in this package.
// Marshal is a deprecated function.
// Please consider switching to EncodeOptions.Encode instead.
func Marshal(n datamodel.Node, sink shared.TokenSink, options EncodeOptions) error {
var tk tok.Token
return marshal(n, &tk, sink, options)
}
func marshal(n datamodel.Node, tk *tok.Token, sink shared.TokenSink, options EncodeOptions) error {
switch n.Kind() {
case datamodel.Kind_Invalid:
return fmt.Errorf("cannot traverse a node that is absent")
case datamodel.Kind_Null:
tk.Type = tok.TNull
_, err := sink.Step(tk)
return err
case datamodel.Kind_Map:
return marshalMap(n, tk, sink, options)
case datamodel.Kind_List:
// Emit start of list.
tk.Type = tok.TArrOpen
l := n.Length()
tk.Length = int(l) // TODO: overflow check
if _, err := sink.Step(tk); err != nil {
return err
}
// Emit list contents (and recurse).
for i := int64(0); i < l; i++ {
v, err := n.LookupByIndex(i)
if err != nil {
return err
}
if err := marshal(v, tk, sink, options); err != nil {
return err
}
}
// Emit list close.
tk.Type = tok.TArrClose
_, err := sink.Step(tk)
return err
case datamodel.Kind_Bool:
v, err := n.AsBool()
if err != nil {
return err
}
tk.Type = tok.TBool
tk.Bool = v
_, err = sink.Step(tk)
return err
case datamodel.Kind_Int:
if uin, ok := n.(datamodel.UintNode); ok {
v, err := uin.AsUint()
if err != nil {
return err
}
tk.Type = tok.TUint
tk.Uint = v
} else {
v, err := n.AsInt()
if err != nil {
return err
}
tk.Type = tok.TInt
tk.Int = v
}
_, err := sink.Step(tk)
return err
case datamodel.Kind_Float:
v, err := n.AsFloat()
if err != nil {
return err
}
tk.Type = tok.TFloat64
tk.Float64 = v
_, err = sink.Step(tk)
return err
case datamodel.Kind_String:
v, err := n.AsString()
if err != nil {
return err
}
tk.Type = tok.TString
tk.Str = v
_, err = sink.Step(tk)
return err
case datamodel.Kind_Bytes:
v, err := n.AsBytes()
if err != nil {
return err
}
tk.Type = tok.TBytes
tk.Bytes = v
_, err = sink.Step(tk)
return err
case datamodel.Kind_Link:
if !options.AllowLinks {
return fmt.Errorf("cannot Marshal ipld links to CBOR")
}
v, err := n.AsLink()
if err != nil {
return err
}
switch lnk := v.(type) {
case cidlink.Link:
if !lnk.Cid.Defined() {
return fmt.Errorf("encoding undefined CIDs are not supported by this codec")
}
tk.Type = tok.TBytes
tk.Bytes = append([]byte{0}, lnk.Bytes()...)
tk.Tagged = true
tk.Tag = linkTag
_, err = sink.Step(tk)
tk.Tagged = false
return err
default:
return fmt.Errorf("schemafree link emission only supported by this codec for CID type links")
}
default:
panic("unreachable")
}
}
func marshalMap(n datamodel.Node, tk *tok.Token, sink shared.TokenSink, options EncodeOptions) error {
// Emit start of map.
tk.Type = tok.TMapOpen
expectedLength := int(n.Length())
tk.Length = expectedLength // TODO: overflow check
if _, err := sink.Step(tk); err != nil {
return err
}
if options.MapSortMode != codec.MapSortMode_None {
// Collect map entries, then sort by key
type entry struct {
key string
value datamodel.Node
}
entries := []entry{}
for itr := n.MapIterator(); !itr.Done(); {
k, v, err := itr.Next()
if err != nil {
return err
}
keyStr, err := k.AsString()
if err != nil {
return err
}
entries = append(entries, entry{keyStr, v})
}
if len(entries) != expectedLength {
return fmt.Errorf("map Length() does not match number of MapIterator() entries")
}
// Apply the desired sort function.
switch options.MapSortMode {
case codec.MapSortMode_Lexical:
sort.Slice(entries, func(i, j int) bool {
return entries[i].key < entries[j].key
})
case codec.MapSortMode_RFC7049:
sort.Slice(entries, func(i, j int) bool {
// RFC7049 style sort as per DAG-CBOR spec
li, lj := len(entries[i].key), len(entries[j].key)
if li == lj {
return entries[i].key < entries[j].key
}
return li < lj
})
}
// Emit map contents (and recurse).
for _, e := range entries {
tk.Type = tok.TString
tk.Str = e.key
if _, err := sink.Step(tk); err != nil {
return err
}
if err := marshal(e.value, tk, sink, options); err != nil {
return err
}
}
} else { // no sorting
// Emit map contents (and recurse).
var entryCount int
for itr := n.MapIterator(); !itr.Done(); {
k, v, err := itr.Next()
if err != nil {
return err
}
entryCount++
tk.Type = tok.TString
tk.Str, err = k.AsString()
if err != nil {
return err
}
if _, err := sink.Step(tk); err != nil {
return err
}
if err := marshal(v, tk, sink, options); err != nil {
return err
}
}
if entryCount != expectedLength {
return fmt.Errorf("map Length() does not match number of MapIterator() entries")
}
}
// Emit map close.
tk.Type = tok.TMapClose
_, err := sink.Step(tk)
return err
}
// EncodedLength will calculate the length in bytes that the encoded form of the
// provided Node will occupy.
//
// Note that this function requires a full walk of the Node's graph, which may
// not necessarily be a trivial cost and will incur some allocations. Using this
// method to calculate buffers to pre-allocate may not result in performance
// gains, but rather incur an overall cost. Use with care.
func EncodedLength(n datamodel.Node) (int64, error) {
switch n.Kind() {
case datamodel.Kind_Invalid:
return 0, fmt.Errorf("cannot traverse a node that is absent")
case datamodel.Kind_Null:
return 1, nil // 0xf6
case datamodel.Kind_Map:
length := uintLength(uint64(n.Length())) // length prefixed major 5
for itr := n.MapIterator(); !itr.Done(); {
k, v, err := itr.Next()
if err != nil {
return 0, err
}
keyLength, err := EncodedLength(k)
if err != nil {
return 0, err
}
length += keyLength
valueLength, err := EncodedLength(v)
if err != nil {
return 0, err
}
length += valueLength
}
return length, nil
case datamodel.Kind_List:
nl := n.Length()
length := uintLength(uint64(nl)) // length prefixed major 4
for i := int64(0); i < nl; i++ {
v, err := n.LookupByIndex(i)
if err != nil {
return 0, err
}
innerLength, err := EncodedLength(v)
if err != nil {
return 0, err
}
length += innerLength
}
return length, nil
case datamodel.Kind_Bool:
return 1, nil // 0xf4 or 0xf5
case datamodel.Kind_Int:
v, err := n.AsInt()
if err != nil {
return 0, err
}
if v < 0 {
v = -v - 1 // negint is stored as one less than actual
}
return uintLength(uint64(v)), nil // major 0 or 1, as small as possible
case datamodel.Kind_Float:
return 9, nil // always major 7 and 64-bit float
case datamodel.Kind_String:
v, err := n.AsString()
if err != nil {
return 0, err
}
return uintLength(uint64(len(v))) + int64(len(v)), nil // length prefixed major 3
case datamodel.Kind_Bytes:
v, err := n.AsBytes()
if err != nil {
return 0, err
}
return uintLength(uint64(len(v))) + int64(len(v)), nil // length prefixed major 2
case datamodel.Kind_Link:
v, err := n.AsLink()
if err != nil {
return 0, err
}
switch lnk := v.(type) {
case cidlink.Link:
length := int64(2) // tag,42: 0xd82a
bl := int64(len(lnk.Bytes())) + 1 // additional 0x00 in front of the CID bytes
length += uintLength(uint64(bl)) + bl // length prefixed major 2
return length, err
default:
return 0, fmt.Errorf("schemafree link emission only supported by this codec for CID type links")
}
default:
panic("unreachable")
}
}
// Calculate how many bytes an integer, and therefore also the leading bytes of
// a length-prefixed token. CBOR will pack it up into the smallest possible
// uint representation, even merging it with the major if it's <=23.
type boundaryLength struct {
upperBound uint64
length int64
}
var lengthBoundaries = []boundaryLength{
{24, 1}, // packed major|minor
{256, 2}, // major, 8-bit length
{65536, 3}, // major, 16-bit length
{4294967296, 5}, // major, 32-bit length
{0, 9}, // major, 64-bit length
}
func uintLength(ii uint64) int64 {
for _, lb := range lengthBoundaries {
if ii < lb.upperBound {
return lb.length
}
}
// maximum number of bytes to pack this int
// if this int is used as a length prefix for a map, list, string or bytes
// then we likely have a very bad Node that shouldn't be encoded, but the
// encoder may raise problems with that if the memory allocator doesn't first.
return lengthBoundaries[len(lengthBoundaries)-1].length
}
================================================
FILE: codec/dagcbor/marshal_test.go
================================================
package dagcbor
import (
"bytes"
"math/rand"
"testing"
"time"
qt "github.com/frankban/quicktest"
"github.com/ipfs/go-cid"
"github.com/ipld/go-ipld-prime"
"github.com/ipld/go-ipld-prime/datamodel"
"github.com/ipld/go-ipld-prime/fluent/qp"
cidlink "github.com/ipld/go-ipld-prime/linking/cid"
basicnode "github.com/ipld/go-ipld-prime/node/basic"
"github.com/ipld/go-ipld-prime/testutil/garbage"
)
func calculateActualLength(t *testing.T, n datamodel.Node) int64 {
var buf bytes.Buffer
err := Encode(n, &buf)
qt.Assert(t, err, qt.IsNil)
return int64(buf.Len())
}
func verifyEstimatedSize(t *testing.T, n datamodel.Node) {
estimatedLength, err := EncodedLength(n)
qt.Assert(t, err, qt.IsNil)
actualLength := calculateActualLength(t, n)
qt.Assert(t, estimatedLength, qt.Equals, actualLength)
}
func TestEncodedLength(t *testing.T) {
t.Run("int boundaries", func(t *testing.T) {
for ii := 0; ii < 4; ii++ {
verifyEstimatedSize(t, basicnode.NewInt(int64(lengthBoundaries[ii].upperBound)))
verifyEstimatedSize(t, basicnode.NewInt(int64(lengthBoundaries[ii].upperBound)-1))
verifyEstimatedSize(t, basicnode.NewInt(int64(lengthBoundaries[ii].upperBound)+1))
verifyEstimatedSize(t, basicnode.NewInt(-1*int64(lengthBoundaries[ii].upperBound)))
verifyEstimatedSize(t, basicnode.NewInt(-1*int64(lengthBoundaries[ii].upperBound)-1))
verifyEstimatedSize(t, basicnode.NewInt(-1*int64(lengthBoundaries[ii].upperBound)+1))
}
})
t.Run("small garbage", func(t *testing.T) {
seed := time.Now().Unix()
t.Logf("randomness seed: %v\n", seed)
rnd := rand.New(rand.NewSource(seed))
for i := 0; i < 1000; i++ {
gbg := garbage.Generate(rnd, garbage.TargetBlockSize(1<<6))
verifyEstimatedSize(t, gbg)
}
})
t.Run("medium garbage", func(t *testing.T) {
seed := time.Now().Unix()
t.Logf("randomness seed: %v\n", seed)
rnd := rand.New(rand.NewSource(seed))
for i := 0; i < 100; i++ {
gbg := garbage.Generate(rnd, garbage.TargetBlockSize(1<<16))
verifyEstimatedSize(t, gbg)
}
})
t.Run("large garbage", func(t *testing.T) {
seed := time.Now().Unix()
t.Logf("randomness seed: %v\n", seed)
rnd := rand.New(rand.NewSource(seed))
for i := 0; i < 10; i++ {
gbg := garbage.Generate(rnd, garbage.TargetBlockSize(1<<20))
verifyEstimatedSize(t, gbg)
}
})
}
func TestMarshalUndefCid(t *testing.T) {
link, err := cid.Decode("bafybeigdyrzt5sfp7udm7hu76uh7y26nf3efuylqabf3oclgtqy55fbzdi")
qt.Assert(t, err, qt.IsNil)
node, err := qp.BuildMap(basicnode.Prototype.Any, -1, func(ma datamodel.MapAssembler) {
qp.MapEntry(ma, "UndefCid", qp.Link(cidlink.Link{Cid: cid.Undef}))
qp.MapEntry(ma, "DefCid", qp.Link(cidlink.Link{Cid: link}))
})
qt.Assert(t, err, qt.IsNil)
_, err = ipld.Encode(node, Encode)
qt.Assert(t, err, qt.ErrorMatches, "encoding undefined CIDs are not supported by this codec")
}
================================================
FILE: codec/dagcbor/multicodec.go
================================================
package dagcbor
import (
"io"
"github.com/ipld/go-ipld-prime/codec"
"github.com/ipld/go-ipld-prime/datamodel"
"github.com/ipld/go-ipld-prime/multicodec"
)
var (
_ codec.Decoder = Decode
_ codec.Encoder = Encode
)
func init() {
multicodec.RegisterEncoder(0x71, Encode)
multicodec.RegisterDecoder(0x71, Decode)
}
// Decode deserializes data from the given io.Reader and feeds it into the given datamodel.NodeAssembler.
// Decode fits the codec.Decoder function interface.
//
// A similar function is available on DecodeOptions type if you would like to customize any of the decoding details.
// This function uses the defaults for the dag-cbor codec
// (meaning: links (indicated by tag 42) are decoded).
//
// This is the function that will be registered in the default multicodec registry during package init time.
func Decode(na datamodel.NodeAssembler, r io.Reader) error {
return DecodeOptions{
AllowLinks: true,
}.Decode(na, r)
}
// Encode walks the given datamodel.Node and serializes it to the given io.Writer.
// Encode fits the codec.Encoder function interface.
//
// A similar function is available on EncodeOptions type if you would like to customize any of the encoding details.
// This function uses the defaults for the dag-cbor codec
// (meaning: links are encoded, and map keys are sorted (with RFC7049 ordering!) during encode).
//
// This is the function that will be registered in the default multicodec registry during package init time.
func Encode(n datamodel.Node, w io.Writer) error {
return EncodeOptions{
AllowLinks: true,
MapSortMode: codec.MapSortMode_RFC7049,
}.Encode(n, w)
}
================================================
FILE: codec/dagcbor/nongreedy_test.go
================================================
package dagcbor
import (
"bytes"
"encoding/hex"
"testing"
qt "github.com/frankban/quicktest"
"github.com/ipld/go-ipld-prime"
"github.com/ipld/go-ipld-prime/datamodel"
"github.com/ipld/go-ipld-prime/fluent/qp"
"github.com/ipld/go-ipld-prime/node/basicnode"
)
func TestNonGreedy(t *testing.T) {
// same as JSON version of this test: {"a": 1}{"b": 2}
buf, err := hex.DecodeString("a1616101a1616202")
qt.Assert(t, err, qt.IsNil)
r := bytes.NewReader(buf)
opts := DecodeOptions{
DontParseBeyondEnd: true,
}
// first object
nb1 := basicnode.Prototype.Map.NewBuilder()
err = opts.Decode(nb1, r)
qt.Assert(t, err, qt.IsNil)
expected, err := qp.BuildMap(basicnode.Prototype.Any, 1, func(ma datamodel.MapAssembler) {
qp.MapEntry(ma, "a", qp.Int(1))
})
qt.Assert(t, err, qt.IsNil)
qt.Assert(t, ipld.DeepEqual(nb1.Build(), expected), qt.IsTrue)
// second object
nb2 := basicnode.Prototype.Map.NewBuilder()
err = opts.Decode(nb2, r)
qt.Assert(t, err, qt.IsNil)
expected, err = qp.BuildMap(basicnode.Prototype.Any, 1, func(ma datamodel.MapAssembler) {
qp.MapEntry(ma, "b", qp.Int(2))
})
qt.Assert(t, err, qt.IsNil)
qt.Assert(t, ipld.DeepEqual(nb2.Build(), expected), qt.IsTrue)
}
================================================
FILE: codec/dagcbor/roundtripCidlink_test.go
================================================
package dagcbor
import (
"bytes"
"io"
"testing"
qt "github.com/frankban/quicktest"
cid "github.com/ipfs/go-cid"
"github.com/ipld/go-ipld-prime/datamodel"
"github.com/ipld/go-ipld-prime/linking"
cidlink "github.com/ipld/go-ipld-prime/linking/cid"
"github.com/ipld/go-ipld-prime/node/basicnode"
nodetests "github.com/ipld/go-ipld-prime/node/tests"
)
func TestRoundtripCidlink(t *testing.T) {
lp := cidlink.LinkPrototype{Prefix: cid.Prefix{
Version: 1,
Codec: 0x71,
MhType: 0x13,
MhLength: 4,
}}
lsys := cidlink.DefaultLinkSystem()
buf := bytes.Buffer{}
lsys.StorageWriteOpener = func(lnkCtx linking.LinkContext) (io.Writer, linking.BlockWriteCommitter, error) {
return &buf, func(lnk datamodel.Link) error { return nil }, nil
}
lsys.StorageReadOpener = func(lnkCtx linking.LinkContext, lnk datamodel.Link) (io.Reader, error) {
return bytes.NewReader(buf.Bytes()), nil
}
lnk, err := lsys.Store(linking.LinkContext{}, lp, n)
qt.Assert(t, err, qt.IsNil)
n2, err := lsys.Load(linking.LinkContext{}, lnk, basicnode.Prototype.Any)
qt.Assert(t, err, qt.IsNil)
qt.Check(t, n2, nodetests.NodeContentEquals, nSorted)
}
================================================
FILE: codec/dagcbor/roundtrip_test.go
================================================
package dagcbor
import (
"bytes"
"crypto/rand"
"encoding/hex"
"math"
"strings"
"testing"
qt "github.com/frankban/quicktest"
cid "github.com/ipfs/go-cid"
"github.com/ipld/go-ipld-prime/datamodel"
"github.com/ipld/go-ipld-prime/fluent"
cidlink "github.com/ipld/go-ipld-prime/linking/cid"
"github.com/ipld/go-ipld-prime/node/basicnode"
nodetests "github.com/ipld/go-ipld-prime/node/tests"
)
var n = fluent.MustBuildMap(basicnode.Prototype.Map, 4, func(na fluent.MapAssembler) {
na.AssembleEntry("plain").AssignString("olde string")
na.AssembleEntry("map").CreateMap(2, func(na fluent.MapAssembler) {
na.AssembleEntry("one").AssignInt(1)
na.AssembleEntry("two").AssignInt(2)
})
na.AssembleEntry("list").CreateList(2, func(na fluent.ListAssembler) {
na.AssembleValue().AssignString("three")
na.AssembleValue().AssignString("four")
})
na.AssembleEntry("nested").CreateMap(1, func(na fluent.MapAssembler) {
na.AssembleEntry("deeper").CreateList(1, func(na fluent.ListAssembler) {
na.AssembleValue().AssignString("things")
})
})
})
var nSorted = fluent.MustBuildMap(basicnode.Prototype.Map, 4, func(na fluent.MapAssembler) {
na.AssembleEntry("map").CreateMap(2, func(na fluent.MapAssembler) {
na.AssembleEntry("one").AssignInt(1)
na.AssembleEntry("two").AssignInt(2)
})
na.AssembleEntry("list").CreateList(2, func(na fluent.ListAssembler) {
na.AssembleValue().AssignString("three")
na.AssembleValue().AssignString("four")
})
na.AssembleEntry("plain").AssignString("olde string")
na.AssembleEntry("nested").CreateMap(1, func(na fluent.MapAssembler) {
na.AssembleEntry("deeper").CreateList(1, func(na fluent.ListAssembler) {
na.AssembleValue().AssignString("things")
})
})
})
var serial = "\xa4cmap\xa2cone\x01ctwo\x02dlist\x82ethreedfoureplainkolde stringfnested\xa1fdeeper\x81fthings"
func TestRoundtrip(t *testing.T) {
t.Run("encoding", func(t *testing.T) {
var buf bytes.Buffer
err := Encode(n, &buf)
qt.Assert(t, err, qt.IsNil)
qt.Check(t, buf.String(), qt.Equals, serial)
})
t.Run("length", func(t *testing.T) {
length, err := EncodedLength(n)
qt.Assert(t, err, qt.IsNil)
qt.Check(t, length, qt.Equals, int64(len(serial)))
})
t.Run("decoding", func(t *testing.T) {
buf := strings.NewReader(serial)
nb := basicnode.Prototype.Map.NewBuilder()
err := Decode(nb, buf)
qt.Assert(t, err, qt.IsNil)
qt.Check(t, nb.Build(), nodetests.NodeContentEquals, nSorted)
})
}
func TestRoundtripScalar(t *testing.T) {
nb := basicnode.Prototype__String{}.NewBuilder()
nb.AssignString("applesauce")
simple := nb.Build()
t.Run("encoding", func(t *testing.T) {
var buf bytes.Buffer
err := Encode(simple, &buf)
qt.Assert(t, err, qt.IsNil)
qt.Check(t, buf.String(), qt.Equals, `japplesauce`)
})
t.Run("decoding", func(t *testing.T) {
buf := strings.NewReader(`japplesauce`)
nb := basicnode.Prototype__String{}.NewBuilder()
err := Decode(nb, buf)
qt.Assert(t, err, qt.IsNil)
qt.Check(t, nb.Build(), nodetests.NodeContentEquals, simple)
})
}
func TestRoundtripLinksAndBytes(t *testing.T) {
lnk := cidlink.LinkPrototype{Prefix: cid.Prefix{
Version: 1,
Codec: 0x71,
MhType: 0x13,
MhLength: 4,
}}.BuildLink([]byte{1, 2, 3, 4}) // dummy value, content does not matter to this test.
var linkByteNode = fluent.MustBuildMap(basicnode.Prototype.Map, 4, func(na fluent.MapAssembler) {
nva := na.AssembleEntry("Link")
nva.AssignLink(lnk)
nva = na.AssembleEntry("Bytes")
bytes := make([]byte, 100)
_, _ = rand.Read(bytes)
nva.AssignBytes(bytes)
})
buf := bytes.Buffer{}
err := Encode(linkByteNode, &buf)
qt.Assert(t, err, qt.IsNil)
nb := basicnode.Prototype.Map.NewBuilder()
err = Decode(nb, &buf)
qt.Assert(t, err, qt.IsNil)
reconstructed := nb.Build()
qt.Check(t, reconstructed, nodetests.NodeContentEquals, linkByteNode)
}
func TestInts(t *testing.T) {
data := []struct {
name string
hex string
value uint64
intValue int64
intErr string
decodeErr string
}{
{"max uint64", "1bffffffffffffffff", math.MaxUint64, 0, "unsigned integer out of range of int64 type", ""},
{"max int64", "1b7fffffffffffffff", math.MaxInt64, math.MaxInt64, "", ""},
{"1", "01", 1, 1, "", ""},
{"0", "00", 0, 0, "", ""},
{"-1", "20", 0, -1, "", ""},
{"min int64", "3b7fffffffffffffff", 0, math.MinInt64, "", ""},
{"~min uint64", "3bfffffffffffffffe", 0, 0, "", "cbor: negative integer out of rage of int64 type"},
// TODO: 3bffffffffffffffff isn't properly handled by refmt, it's coerced to zero
// MaxUint64 gets overflowed here: https://github.com/polydawn/refmt/blob/30ac6d18308e584ca6a2e74ba81475559db94c5f/cbor/cborDecoderTerminals.go#L75
}
for _, td := range data {
t.Run(td.name, func(t *testing.T) {
buf, err := hex.DecodeString(td.hex) // max uint64
qt.Assert(t, err, qt.IsNil)
nb := basicnode.Prototype.Any.NewBuilder()
err = Decode(nb, bytes.NewReader(buf))
if td.decodeErr != "" {
qt.Assert(t, err, qt.IsNotNil)
qt.Assert(t, err.Error(), qt.Equals, td.decodeErr)
return
}
qt.Assert(t, err, qt.IsNil)
n := nb.Build()
ii, err := n.AsInt()
if td.intErr != "" {
qt.Assert(t, err.Error(), qt.Equals, td.intErr)
} else {
qt.Assert(t, err, qt.IsNil)
qt.Assert(t, ii, qt.Equals, int64(td.intValue))
}
// if the number is outside of the positive int64 range, we should be able
// to access it as a UintNode and be able to access the full int64 range
uin, ok := n.(datamodel.UintNode)
if td.value <= math.MaxInt64 {
qt.Assert(t, ok, qt.IsFalse)
} else {
qt.Assert(t, ok, qt.IsTrue)
val, err := uin.AsUint()
qt.Assert(t, err, qt.IsNil)
qt.Assert(t, val, qt.Equals, uint64(td.value))
}
var byts bytes.Buffer
err = Encode(n, &byts)
qt.Assert(t, err, qt.IsNil)
qt.Assert(t, hex.EncodeToString(byts.Bytes()), qt.Equals, td.hex)
})
}
}
================================================
FILE: codec/dagcbor/unmarshal.go
================================================
package dagcbor
import (
"errors"
"fmt"
"io"
"math"
cid "github.com/ipfs/go-cid"
"github.com/polydawn/refmt/cbor"
"github.com/polydawn/refmt/shared"
"github.com/polydawn/refmt/tok"
"github.com/ipld/go-ipld-prime/datamodel"
cidlink "github.com/ipld/go-ipld-prime/linking/cid"
"github.com/ipld/go-ipld-prime/node/basicnode"
)
var (
ErrInvalidMultibase = errors.New("invalid multibase on IPLD link")
ErrAllocationBudgetExceeded = errors.New("message structure demanded too many resources to process")
ErrDecodeDepthExceeded = errors.New("message structure exceeded maximum nesting depth")
ErrTrailingBytes = errors.New("unexpected content after end of cbor object")
)
const (
mapEntryCost = 8
listEntryCost = 4
)
// This file should be identical to the general feature in the parent package,
// except for the `case tok.TBytes` block,
// which has dag-cbor's special sauce for detecting schemafree links.
// DecodeOptions can be used to customize the behavior of a decoding function.
// The Decode method on this struct fits the codec.Decoder function interface.
type DecodeOptions struct {
// If true, parse DAG-CBOR tag(42) as Link nodes, otherwise reject them
AllowLinks bool
// TODO: ExperimentalDeterminism enforces map key order, but not the other parts
// of the spec such as integers or floats. See the fuzz failures spotted in
// https://github.com/ipld/go-ipld-prime/pull/389.
// When we're done implementing strictness, deprecate the option in favor of
// StrictDeterminism, but keep accepting both for backwards compatibility.
// ExperimentalDeterminism requires decoded DAG-CBOR bytes to be canonical as per
// the spec. For example, this means that integers and floats be encoded in
// a particular way, and map keys be sorted.
//
// The decoder does not enforce this requirement by default, as the codec
// was originally implemented without these rules. Because of that, there's
// a significant amount of published data that isn't canonical but should
// still decode with the default settings for backwards compatibility.
//
// Note that this option is experimental as it only implements partial strictness.
ExperimentalDeterminism bool
// If true, the decoder stops reading from the stream at the end of a full,
// valid CBOR object. This may be useful for parsing a stream of undelimited
// CBOR objects.
// As per standard IPLD behavior, in the default mode the parser considers the
// entire block to be part of the CBOR object and will error if there is
// extraneous data after the end of the object.
DontParseBeyondEnd bool
// AllocationBudget sets the maximum budget for the decoder. The budget is
// decremented as the decoder allocates resources (nodes, map entries, list
// elements, string/bytes content). If the budget is exhausted, the decoder
// returns ErrAllocationBudgetExceeded.
//
// When zero, a default budget is used which is generous for typical IPLD
// block sizes.
AllocationBudget int64
// MaxCollectionPrealloc sets the maximum size hint passed to
// BeginMap/BeginList. CBOR headers declare collection sizes upfront;
// this caps the initial allocation while collections grow dynamically
// as entries are decoded.
//
// When zero, a default of 1024 is used.
MaxCollectionPrealloc int64
// MaxDepth sets the maximum nesting depth for decoded structures. If the
// decoder encounters a map or list nested beyond this depth, it returns
// ErrDecodeDepthExceeded.
//
// When zero, a default of 1024 is used.
MaxDepth int64
}
const (
defaultAllocationBudget int64 = 1048576 * 10
defaultMaxCollectionPrealloc int64 = 1024
defaultMaxDepth int64 = 1024
)
// Decode deserializes data from the given io.Reader and feeds it into the given datamodel.NodeAssembler.
// Decode fits the codec.Decoder function interface.
//
// The behavior of the decoder can be customized by setting fields in the DecodeOptions struct before calling this method.
func (cfg DecodeOptions) Decode(na datamodel.NodeAssembler, r io.Reader) error {
// Probe for a builtin fast path. Shortcut to that if possible.
// Note: when an assembler implements this interface, it receives only the
// reader and none of the fields set on cfg. Implementations are responsible
// for enforcing th
gitextract_6epy99x4/ ├── .gitattributes ├── .github/ │ ├── actions/ │ │ └── go-test-setup/ │ │ └── action.yml │ ├── dependabot.yml │ └── workflows/ │ ├── generated-pr.yml │ ├── go-check.yml │ ├── go-test-prime.yml │ ├── go-test.yml │ ├── release-check.yml │ ├── releaser.yml │ ├── stale.yml │ └── tagpush.yml ├── .gitmodules ├── CHANGELOG.md ├── HACKME.md ├── HACKME_builderBehaviors.md ├── HACKME_mergeStrategy.md ├── HACKME_releases.md ├── LICENSE ├── README.md ├── README_migrationGuide.md ├── adl/ │ ├── interface.go │ └── rot13adl/ │ ├── example_test.go │ ├── rot13logic.go │ ├── rot13node.go │ ├── rot13node_test.go │ ├── rot13prototypes.go │ ├── rot13reification.go │ └── rot13substrate.go ├── adl.go ├── codec/ │ ├── README.md │ ├── api.go │ ├── cbor/ │ │ ├── multicodec.go │ │ └── roundtrip_test.go │ ├── dagcbor/ │ │ ├── common.go │ │ ├── doc.go │ │ ├── marshal.go │ │ ├── marshal_test.go │ │ ├── multicodec.go │ │ ├── nongreedy_test.go │ │ ├── roundtripCidlink_test.go │ │ ├── roundtrip_test.go │ │ ├── unmarshal.go │ │ └── unmarshal_test.go │ ├── dagjson/ │ │ ├── marshal.go │ │ ├── marshal_test.go │ │ ├── multicodec.go │ │ ├── nongreedy_test.go │ │ ├── options_test.go │ │ ├── roundtripBytes_test.go │ │ ├── roundtripCidlink_test.go │ │ ├── roundtrip_test.go │ │ └── unmarshal.go │ ├── decode_test.go │ ├── json/ │ │ ├── marshal_test.go │ │ └── multicodec.go │ └── raw/ │ ├── codec.go │ └── codec_test.go ├── codec.go ├── codecHelpers.go ├── codecHelpers_test.go ├── datamodel/ │ ├── copy.go │ ├── copy_test.go │ ├── doc.go │ ├── equal.go │ ├── equal_test.go │ ├── errors.go │ ├── kind.go │ ├── kind_test.go │ ├── link.go │ ├── node.go │ ├── nodeBuilder.go │ ├── path.go │ ├── pathSegment.go │ ├── path_test.go │ └── unit.go ├── datamodel.go ├── doc.go ├── examples_test.go ├── fluent/ │ ├── bench_test.go │ ├── doc.go │ ├── fluentBuilder.go │ ├── fluentBuilder_test.go │ ├── fluentRecover.go │ ├── fluentRecover_test.go │ ├── qp/ │ │ ├── example_test.go │ │ └── qp.go │ ├── reflect.go │ ├── reflect_test.go │ ├── toInterfaceValue.go │ └── toInterfaceValue_test.go ├── go.mod ├── go.sum ├── linking/ │ ├── cid/ │ │ ├── HACKME.md │ │ ├── cidLink.go │ │ ├── linksystem.go │ │ └── memorystorage.go │ ├── errors.go │ ├── functions.go │ ├── functions_test.go │ ├── linkingExamples_test.go │ ├── preload/ │ │ └── preload.go │ ├── setup.go │ └── types.go ├── linking.go ├── multicodec/ │ ├── defaultRegistry.go │ └── registry.go ├── must/ │ └── must.go ├── node/ │ ├── basic/ │ │ └── deprecated.go │ ├── basicnode/ │ │ ├── HACKME.md │ │ ├── any.go │ │ ├── any_test.go │ │ ├── bench_test.go │ │ ├── bool.go │ │ ├── bytes.go │ │ ├── bytes_stream.go │ │ ├── bytes_test.go │ │ ├── float.go │ │ ├── int.go │ │ ├── int_test.go │ │ ├── link.go │ │ ├── list.go │ │ ├── list_test.go │ │ ├── map.go │ │ ├── map_test.go │ │ ├── prototypes.go │ │ ├── string.go │ │ └── string_test.go │ ├── bindnode/ │ │ ├── api.go │ │ ├── api_test.go │ │ ├── custom_test.go │ │ ├── example_test.go │ │ ├── fuzz_test.go │ │ ├── generate.go │ │ ├── infer.go │ │ ├── infer_test.go │ │ ├── node.go │ │ ├── registry/ │ │ │ ├── registry.go │ │ │ └── registry_test.go │ │ ├── repr.go │ │ ├── schema_test.go │ │ └── testdata/ │ │ └── fuzz/ │ │ └── FuzzBindnodeViaDagCBOR/ │ │ ├── 164dd28629e6a5637f02c6eaad32eee5bf8ea41ce6d1dae95334a7db7dd6188f │ │ ├── 199afa754020c4587bc87633033b4e56ecdb5ecc2bb0dbac46b799d6c18c5201 │ │ ├── 2c17d42168478a0837ebba66f6aa98bdf4bb81b5196062d0e6b23c8b0325be6a │ │ ├── 425499b0c3693d87a0b11db10d21c540283dfb88610d114eb5b23485d5c2f342 │ │ ├── 636f8e5cdaf52572b826e615a9bdf90f15f8acf2880b467b3949f5356c2ddded │ │ ├── 669d57fbbe55b8ceb7e78e3ccd3b90e76c4b740d25284a66eac8aac0dbb2475d │ │ ├── 7f9a6898dead41ba2f5fd4f07f2ddb44d54e7648d66e54982d09996bc720cf56 │ │ ├── 821c248529299bb6b68e443e4b00cc11c6605f766f25e619d85e6d6b40a33dac │ │ ├── bf7c410983f3e696a03e743df1bc6f606137871f7fb557af74836b7aa04e56ad │ │ ├── dc95e9aad454ed9109e93b824f92d4bb00c9c778af29e6fcb38a6083c78d7dbb │ │ ├── f63d4652cdac3208fc0a0d0b755615320443b60ef80c0ecdef99c9d895ae2124 │ │ └── fe73a19655fff8b93193c3e90f9cd7b24b10ae0467175cf2264ff3ec135215a6 │ ├── doc.go │ ├── gendemo/ │ │ ├── doc.go │ │ ├── gen.go │ │ ├── gendemo_test.go │ │ ├── ipldsch_minima.go │ │ ├── ipldsch_satisfaction.go │ │ └── ipldsch_types.go │ ├── mixins/ │ │ ├── HACKME.md │ │ ├── bool.go │ │ ├── bytes.go │ │ ├── delim.go │ │ ├── delim_test.go │ │ ├── float.go │ │ ├── int.go │ │ ├── link.go │ │ ├── list.go │ │ ├── map.go │ │ ├── string.go │ │ └── tmplMixin.txt │ └── tests/ │ ├── HACKME.md │ ├── byteSpecs.go │ ├── checkers.go │ ├── checkers_test.go │ ├── corpus/ │ │ ├── corpus.go │ │ ├── corpus_test.go │ │ └── util.go │ ├── listSpecs.go │ ├── mapBenchmarks.go │ ├── mapBenchmarks_test.go │ ├── mapFixtures.go │ ├── mapSpecs.go │ ├── marshalBenchmarks.go │ ├── schema.go │ ├── schemaLinks.go │ ├── schemaLists.go │ ├── schemaMaps.go │ ├── schemaScalars.go │ ├── schemaStruct.go │ ├── schemaStructReprListpairs.go │ ├── schemaStructReprStringjoin.go │ ├── schemaStructReprTuple.go │ ├── schemaStructsContainingMaybe.go │ ├── schemaUnions.go │ ├── schemaUnionsKinded.go │ ├── schemaUnionsStringprefix.go │ ├── stringSpecs.go │ ├── testEngine.go │ ├── testcase.go │ ├── testutil.go │ ├── traversalBenchmarks.go │ ├── unmarshalBenchmarks.go │ └── util.go ├── operations.go ├── printer/ │ ├── doc.go │ ├── printer.go │ └── printer_test.go ├── schema/ │ ├── dmt/ │ │ ├── compile.go │ │ ├── doc.go │ │ ├── gen.go │ │ ├── operations.go │ │ ├── roundtrip_test.go │ │ ├── schema.go │ │ └── types.go │ ├── dsl/ │ │ ├── parse.go │ │ └── parse_test.go │ ├── errors.go │ ├── gen/ │ │ └── go/ │ │ ├── HACKME.md │ │ ├── HACKME_abbrevs.md │ │ ├── HACKME_dry.md │ │ ├── HACKME_maybe.md │ │ ├── HACKME_memorylayout.md │ │ ├── HACKME_scalars.md │ │ ├── HACKME_templates.md │ │ ├── HACKME_testing.md │ │ ├── HACKME_tradeoffs.md │ │ ├── HACKME_wip.md │ │ ├── README.md │ │ ├── README_behaviors.md │ │ ├── README_wishes.md │ │ ├── _test/ │ │ │ └── .gitignore │ │ ├── adjunctCfg.go │ │ ├── externUtil.go │ │ ├── genBool.go │ │ ├── genBoolReprBool.go │ │ ├── genBytes.go │ │ ├── genBytesReprBytes.go │ │ ├── genFloat.go │ │ ├── genFloatReprFloat.go │ │ ├── genInt.go │ │ ├── genIntReprInt.go │ │ ├── genLink.go │ │ ├── genLinkReprLink.go │ │ ├── genList.go │ │ ├── genListReprList.go │ │ ├── genMap.go │ │ ├── genMapReprMap.go │ │ ├── genString.go │ │ ├── genStringReprString.go │ │ ├── genStruct.go │ │ ├── genStructReprMap.go │ │ ├── genStructReprStringjoin.go │ │ ├── genStructReprTuple.go │ │ ├── genUnion.go │ │ ├── genUnionReprKeyed.go │ │ ├── genUnionReprKinded.go │ │ ├── genUnionReprStringprefix.go │ │ ├── generate.go │ │ ├── generators.go │ │ ├── genpartsCommon.go │ │ ├── genpartsList.go │ │ ├── genpartsMap.go │ │ ├── genpartsMinima.go │ │ ├── genpartsStrictoid.go │ │ ├── mixins/ │ │ │ ├── boolGenMixin.go │ │ │ ├── bytesGenMixin.go │ │ │ ├── floatGenMixin.go │ │ │ ├── intGenMixin.go │ │ │ ├── kindTraits.go │ │ │ ├── linkGenMixin.go │ │ │ ├── listGenMixin.go │ │ │ ├── mapGenMixin.go │ │ │ ├── stringGenMixin.go │ │ │ └── templateUtil.go │ │ ├── templateUtil.go │ │ ├── testEngine_disabled_test.go │ │ ├── testEngine_nocgo_test.go │ │ ├── testEngine_plugin_test.go │ │ ├── testEngine_test.go │ │ ├── testLinks_test.go │ │ ├── testLists_test.go │ │ ├── testMaps_test.go │ │ ├── testScalars_test.go │ │ ├── testStructReprStringjoin_test.go │ │ ├── testStructReprTuple_test.go │ │ ├── testStruct_test.go │ │ ├── testStructsContainingMaybe_test.go │ │ ├── testUnionsKinded_test.go │ │ ├── testUnionsStringprefix_test.go │ │ └── testUnions_test.go │ ├── kind.go │ ├── maybe.go │ ├── tmpBuilders.go │ ├── type.go │ ├── typeMethods.go │ ├── typedNode.go │ ├── typesystem.go │ └── validate.go ├── schema.go ├── storage/ │ ├── README_adapters.md │ ├── api.go │ ├── benchmarks/ │ │ ├── README.md │ │ ├── go.mod │ │ ├── go.sum │ │ └── storageBenchmarks_test.go │ ├── bsadapter/ │ │ ├── README.md │ │ ├── bsadapter.go │ │ ├── go.mod │ │ └── go.sum │ ├── bsrvadapter/ │ │ ├── README.md │ │ ├── bsrvadapter.go │ │ ├── go.mod │ │ └── go.sum │ ├── doc.go │ ├── dsadapter/ │ │ ├── README.md │ │ ├── dsadapter.go │ │ ├── go.mod │ │ └── go.sum │ ├── fsstore/ │ │ └── fsstore.go │ ├── funcs.go │ ├── memstore/ │ │ └── memstore.go │ ├── sharding/ │ │ ├── sharding.go │ │ ├── sharding.test │ │ ├── sharding_bench_test.go │ │ └── sharding_test.go │ └── tests/ │ ├── benchmarks.go │ └── generators.go ├── testutil/ │ ├── garbage/ │ │ ├── garbage.go │ │ └── garbage_test.go │ ├── indent.go │ ├── indent_test.go │ ├── multibytenode.go │ ├── multibytenode_test.go │ └── simplebytes.go ├── traversal/ │ ├── common.go │ ├── doc.go │ ├── example_select_links_test.go │ ├── fns.go │ ├── focus.go │ ├── focus_test.go │ ├── patch/ │ │ ├── eval.go │ │ ├── parse.go │ │ ├── patch.ipldsch │ │ └── patch_test.go │ ├── select_links.go │ ├── select_links_test.go │ ├── selector/ │ │ ├── builder/ │ │ │ ├── builder.go │ │ │ └── builder_test.go │ │ ├── condition.go │ │ ├── condition_test.go │ │ ├── exploreAll.go │ │ ├── exploreAll_test.go │ │ ├── exploreFields.go │ │ ├── exploreFields_test.go │ │ ├── exploreIndex.go │ │ ├── exploreIndex_test.go │ │ ├── exploreInterpretAs.go │ │ ├── exploreRange.go │ │ ├── exploreRange_test.go │ │ ├── exploreRecursive.go │ │ ├── exploreRecursiveEdge.go │ │ ├── exploreRecursive_test.go │ │ ├── exploreUnion.go │ │ ├── exploreUnion_test.go │ │ ├── fieldKeys.go │ │ ├── matcher.go │ │ ├── matcher_test.go │ │ ├── matcher_util.go │ │ ├── parse/ │ │ │ ├── selector_parse.go │ │ │ └── selector_parse_test.go │ │ ├── selector.go │ │ └── spec_test.go │ ├── walk.go │ ├── walk_test.go │ └── walk_with_stop_test.go └── version.json
Showing preview only (382K chars total). Download the full file or copy to clipboard to get everything.
SYMBOL INDEX (4005 symbols across 292 files)
FILE: adl/interface.go
type ADL (line 17) | type ADL interface
FILE: adl/rot13adl/example_test.go
function ExampleReify_unmarshallingToADL (line 20) | func ExampleReify_unmarshallingToADL() {
function ExampleReify_loadingToADL (line 46) | func ExampleReify_loadingToADL() {
function ExampleR13String_creatingViaADL (line 91) | func ExampleR13String_creatingViaADL() {
FILE: adl/rot13adl/rot13logic.go
function rotate (line 71) | func rotate(s string) string {
function unrotate (line 76) | func unrotate(s string) string {
FILE: adl/rot13adl/rot13node.go
type _R13String (line 35) | type _R13String struct
method Kind (line 40) | func (*_R13String) Kind() datamodel.Kind {
method LookupByString (line 43) | func (*_R13String) LookupByString(string) (datamodel.Node, error) {
method LookupByNode (line 46) | func (*_R13String) LookupByNode(datamodel.Node) (datamodel.Node, error) {
method LookupByIndex (line 49) | func (*_R13String) LookupByIndex(idx int64) (datamodel.Node, error) {
method LookupBySegment (line 52) | func (*_R13String) LookupBySegment(seg datamodel.PathSegment) (datamod...
method MapIterator (line 55) | func (*_R13String) MapIterator() datamodel.MapIterator {
method ListIterator (line 58) | func (*_R13String) ListIterator() datamodel.ListIterator {
method Length (line 61) | func (*_R13String) Length() int64 {
method IsAbsent (line 64) | func (*_R13String) IsAbsent() bool {
method IsNull (line 67) | func (*_R13String) IsNull() bool {
method AsBool (line 70) | func (*_R13String) AsBool() (bool, error) {
method AsInt (line 73) | func (*_R13String) AsInt() (int64, error) {
method AsFloat (line 76) | func (*_R13String) AsFloat() (float64, error) {
method AsString (line 79) | func (n *_R13String) AsString() (string, error) {
method AsBytes (line 82) | func (*_R13String) AsBytes() ([]byte, error) {
method AsLink (line 85) | func (*_R13String) AsLink() (datamodel.Link, error) {
method Prototype (line 88) | func (*_R13String) Prototype() datamodel.NodePrototype {
type _R13String__Prototype (line 96) | type _R13String__Prototype struct
method NewBuilder (line 110) | func (np _R13String__Prototype) NewBuilder() datamodel.NodeBuilder {
type _R13String__Builder (line 118) | type _R13String__Builder struct
method Build (line 122) | func (nb *_R13String__Builder) Build() datamodel.Node {
method Reset (line 128) | func (nb *_R13String__Builder) Reset() {
type _R13String__Assembler (line 136) | type _R13String__Assembler struct
method BeginMap (line 141) | func (_R13String__Assembler) BeginMap(sizeHint int64) (datamodel.MapAs...
method BeginList (line 144) | func (_R13String__Assembler) BeginList(sizeHint int64) (datamodel.List...
method AssignNull (line 147) | func (na *_R13String__Assembler) AssignNull() error {
method AssignBool (line 151) | func (_R13String__Assembler) AssignBool(bool) error {
method AssignInt (line 154) | func (_R13String__Assembler) AssignInt(int64) error {
method AssignFloat (line 157) | func (_R13String__Assembler) AssignFloat(float64) error {
method AssignString (line 160) | func (na *_R13String__Assembler) AssignString(v string) error {
method AssignBytes (line 172) | func (_R13String__Assembler) AssignBytes([]byte) error {
method AssignLink (line 175) | func (_R13String__Assembler) AssignLink(datamodel.Link) error {
method AssignNode (line 178) | func (na *_R13String__Assembler) AssignNode(v datamodel.Node) error {
method Prototype (line 197) | func (_R13String__Assembler) Prototype() datamodel.NodePrototype {
FILE: adl/rot13adl/rot13node_test.go
function TestLogicalNodeRoundtrip (line 12) | func TestLogicalNodeRoundtrip(t *testing.T) {
function TestNodeInternal (line 24) | func TestNodeInternal(t *testing.T) {
function TestReify (line 35) | func TestReify(t *testing.T) {
function TestInspectingSubstrate (line 64) | func TestInspectingSubstrate(t *testing.T) {
FILE: adl/rot13adl/rot13prototypes.go
type prototype (line 21) | type prototype struct
FILE: adl/rot13adl/rot13reification.go
function Reify (line 42) | func Reify(maybeSubstrateRoot datamodel.Node) (datamodel.Node, error) {
FILE: adl/rot13adl/rot13substrate.go
method Substrate (line 10) | func (n *_R13String) Substrate() datamodel.Node {
type _Substrate (line 26) | type _Substrate
method Kind (line 33) | func (*_Substrate) Kind() datamodel.Kind {
method LookupByString (line 36) | func (*_Substrate) LookupByString(string) (datamodel.Node, error) {
method LookupByNode (line 39) | func (*_Substrate) LookupByNode(datamodel.Node) (datamodel.Node, error) {
method LookupByIndex (line 42) | func (*_Substrate) LookupByIndex(idx int64) (datamodel.Node, error) {
method LookupBySegment (line 45) | func (*_Substrate) LookupBySegment(seg datamodel.PathSegment) (datamod...
method MapIterator (line 48) | func (*_Substrate) MapIterator() datamodel.MapIterator {
method ListIterator (line 51) | func (*_Substrate) ListIterator() datamodel.ListIterator {
method Length (line 54) | func (*_Substrate) Length() int64 {
method IsAbsent (line 57) | func (*_Substrate) IsAbsent() bool {
method IsNull (line 60) | func (*_Substrate) IsNull() bool {
method AsBool (line 63) | func (*_Substrate) AsBool() (bool, error) {
method AsInt (line 66) | func (*_Substrate) AsInt() (int64, error) {
method AsFloat (line 69) | func (*_Substrate) AsFloat() (float64, error) {
method AsString (line 72) | func (n *_Substrate) AsString() (string, error) {
method AsBytes (line 75) | func (*_Substrate) AsBytes() ([]byte, error) {
method AsLink (line 78) | func (*_Substrate) AsLink() (datamodel.Link, error) {
method Prototype (line 81) | func (*_Substrate) Prototype() datamodel.NodePrototype {
type _Substrate__Prototype (line 89) | type _Substrate__Prototype struct
method NewBuilder (line 93) | func (np _Substrate__Prototype) NewBuilder() datamodel.NodeBuilder {
type _Substrate__Builder (line 101) | type _Substrate__Builder struct
method Build (line 105) | func (nb *_Substrate__Builder) Build() datamodel.Node {
method Reset (line 111) | func (nb *_Substrate__Builder) Reset() {
type _Substrate__Assembler (line 119) | type _Substrate__Assembler struct
method BeginMap (line 124) | func (_Substrate__Assembler) BeginMap(sizeHint int64) (datamodel.MapAs...
method BeginList (line 127) | func (_Substrate__Assembler) BeginList(sizeHint int64) (datamodel.List...
method AssignNull (line 130) | func (na *_Substrate__Assembler) AssignNull() error {
method AssignBool (line 134) | func (_Substrate__Assembler) AssignBool(bool) error {
method AssignInt (line 137) | func (_Substrate__Assembler) AssignInt(int64) error {
method AssignFloat (line 140) | func (_Substrate__Assembler) AssignFloat(float64) error {
method AssignString (line 143) | func (na *_Substrate__Assembler) AssignString(v string) error {
method AssignBytes (line 155) | func (_Substrate__Assembler) AssignBytes([]byte) error {
method AssignLink (line 158) | func (_Substrate__Assembler) AssignLink(datamodel.Link) error {
method AssignNode (line 161) | func (na *_Substrate__Assembler) AssignNode(v datamodel.Node) error {
method Prototype (line 180) | func (_Substrate__Assembler) Prototype() datamodel.NodePrototype {
FILE: codec/api.go
type Encoder (line 79) | type Encoder
type Decoder (line 105) | type Decoder
type ErrBudgetExhausted (line 112) | type ErrBudgetExhausted struct
method Error (line 114) | func (e ErrBudgetExhausted) Error() string {
type MapSortMode (line 122) | type MapSortMode
constant MapSortMode_None (line 125) | MapSortMode_None MapSortMode = iota
constant MapSortMode_Lexical (line 126) | MapSortMode_Lexical
constant MapSortMode_RFC7049 (line 127) | MapSortMode_RFC7049
FILE: codec/cbor/multicodec.go
function init (line 17) | func init() {
function Decode (line 26) | func Decode(na datamodel.NodeAssembler, r io.Reader) error {
function Encode (line 36) | func Encode(n datamodel.Node, w io.Writer) error {
FILE: codec/cbor/roundtrip_test.go
function TestRoundtrip (line 34) | func TestRoundtrip(t *testing.T) {
function TestRoundtripScalar (line 50) | func TestRoundtripScalar(t *testing.T) {
FILE: codec/dagcbor/common.go
constant linkTag (line 3) | linkTag = 42
FILE: codec/dagcbor/marshal.go
type EncodeOptions (line 23) | type EncodeOptions struct
method Encode (line 36) | func (cfg EncodeOptions) Encode(n datamodel.Node, w io.Writer) error {
function Marshal (line 55) | func Marshal(n datamodel.Node, sink shared.TokenSink, options EncodeOpti...
function marshal (line 60) | func marshal(n datamodel.Node, tk *tok.Token, sink shared.TokenSink, opt...
function marshalMap (line 174) | func marshalMap(n datamodel.Node, tk *tok.Token, sink shared.TokenSink, ...
function EncodedLength (line 268) | func EncodedLength(n datamodel.Node) (int64, error) {
type boundaryLength (line 357) | type boundaryLength struct
function uintLength (line 370) | func uintLength(ii uint64) int64 {
FILE: codec/dagcbor/marshal_test.go
function calculateActualLength (line 19) | func calculateActualLength(t *testing.T, n datamodel.Node) int64 {
function verifyEstimatedSize (line 26) | func verifyEstimatedSize(t *testing.T, n datamodel.Node) {
function TestEncodedLength (line 33) | func TestEncodedLength(t *testing.T) {
function TestMarshalUndefCid (line 76) | func TestMarshalUndefCid(t *testing.T) {
FILE: codec/dagcbor/multicodec.go
function init (line 16) | func init() {
function Decode (line 29) | func Decode(na datamodel.NodeAssembler, r io.Reader) error {
function Encode (line 43) | func Encode(n datamodel.Node, w io.Writer) error {
FILE: codec/dagcbor/nongreedy_test.go
function TestNonGreedy (line 15) | func TestNonGreedy(t *testing.T) {
FILE: codec/dagcbor/roundtripCidlink_test.go
function TestRoundtripCidlink (line 18) | func TestRoundtripCidlink(t *testing.T) {
FILE: codec/dagcbor/roundtrip_test.go
function TestRoundtrip (line 55) | func TestRoundtrip(t *testing.T) {
function TestRoundtripScalar (line 76) | func TestRoundtripScalar(t *testing.T) {
function TestRoundtripLinksAndBytes (line 95) | func TestRoundtripLinksAndBytes(t *testing.T) {
function TestInts (line 122) | func TestInts(t *testing.T) {
FILE: codec/dagcbor/unmarshal.go
constant mapEntryCost (line 27) | mapEntryCost = 8
constant listEntryCost (line 28) | listEntryCost = 4
type DecodeOptions (line 37) | type DecodeOptions struct
method Decode (line 102) | func (cfg DecodeOptions) Decode(na datamodel.NodeAssembler, r io.Reade...
method maxPrealloc (line 154) | func (cfg DecodeOptions) maxPrealloc() int64 {
method maxDepth (line 161) | func (cfg DecodeOptions) maxDepth() int64 {
constant defaultAllocationBudget (line 93) | defaultAllocationBudget int64 = 1048576 * 10
constant defaultMaxCollectionPrealloc (line 94) | defaultMaxCollectionPrealloc int64 = 1024
constant defaultMaxDepth (line 95) | defaultMaxDepth int64 = 1024
function Unmarshal (line 146) | func Unmarshal(na datamodel.NodeAssembler, tokSrc shared.TokenSource, op...
function unmarshal1 (line 168) | func unmarshal1(na datamodel.NodeAssembler, tokSrc shared.TokenSource, b...
function unmarshal2 (line 186) | func unmarshal2(na datamodel.NodeAssembler, tokSrc shared.TokenSource, t...
FILE: codec/dagcbor/unmarshal_test.go
function TestFunBlocks (line 18) | func TestFunBlocks(t *testing.T) {
function cborMapHeader (line 79) | func cborMapHeader(length uint32) []byte {
function cborArrayHeader (line 86) | func cborArrayHeader(length uint32) []byte {
function TestDecodeOptions_AllocationBudget (line 95) | func TestDecodeOptions_AllocationBudget(t *testing.T) {
function TestDecodeOptions_MaxCollectionPrealloc (line 138) | func TestDecodeOptions_MaxCollectionPrealloc(t *testing.T) {
function TestDecodeOptions_MaxDepth (line 236) | func TestDecodeOptions_MaxDepth(t *testing.T) {
function TestDecoderBoundaries (line 324) | func TestDecoderBoundaries(t *testing.T) {
FILE: codec/dagjson/marshal.go
type EncodeOptions (line 24) | type EncodeOptions struct
method Encode (line 41) | func (cfg EncodeOptions) Encode(n datamodel.Node, w io.Writer) error {
function Marshal (line 52) | func Marshal(n datamodel.Node, sink shared.TokenSink, options EncodeOpti...
FILE: codec/dagjson/marshal_test.go
function TestMarshalUndefCid (line 17) | func TestMarshalUndefCid(t *testing.T) {
function TestMarshalLinks (line 28) | func TestMarshalLinks(t *testing.T) {
function TestMarshalBytes (line 50) | func TestMarshalBytes(t *testing.T) {
FILE: codec/dagjson/multicodec.go
function init (line 16) | func init() {
function Decode (line 29) | func Decode(na datamodel.NodeAssembler, r io.Reader) error {
function Encode (line 44) | func Encode(n datamodel.Node, w io.Writer) error {
FILE: codec/dagjson/nongreedy_test.go
function TestNonGreedy (line 11) | func TestNonGreedy(t *testing.T) {
FILE: codec/dagjson/options_test.go
function TestDecodeOptions_MaxDepth (line 16) | func TestDecodeOptions_MaxDepth(t *testing.T) {
FILE: codec/dagjson/roundtripBytes_test.go
function TestRoundtripBytes (line 26) | func TestRoundtripBytes(t *testing.T) {
function TestEncapsulatedBytes (line 49) | func TestEncapsulatedBytes(t *testing.T) {
function TestPaddedBytes (line 67) | func TestPaddedBytes(t *testing.T) {
FILE: codec/dagjson/roundtripCidlink_test.go
function TestRoundtripCidlink (line 20) | func TestRoundtripCidlink(t *testing.T) {
function TestUnmarshalTrickyMapContainingLink (line 49) | func TestUnmarshalTrickyMapContainingLink(t *testing.T) {
FILE: codec/dagjson/roundtrip_test.go
function TestRoundtrip (line 53) | func TestRoundtrip(t *testing.T) {
function TestRoundtripScalar (line 69) | func TestRoundtripScalar(t *testing.T) {
function TestGarbage (line 88) | func TestGarbage(t *testing.T) {
FILE: codec/dagjson/unmarshal.go
constant defaultMaxDepth (line 22) | defaultMaxDepth int64 = 1024
type DecodeOptions (line 34) | type DecodeOptions struct
method maxDepth (line 58) | func (cfg DecodeOptions) maxDepth() int64 {
method Decode (line 69) | func (cfg DecodeOptions) Decode(na datamodel.NodeAssembler, r io.Reade...
function Unmarshal (line 109) | func Unmarshal(na datamodel.NodeAssembler, tokSrc shared.TokenSource, op...
type unmarshalState (line 125) | type unmarshalState struct
method step (line 143) | func (st *unmarshalState) step(tokSrc shared.TokenSource) error {
method ensure (line 193) | func (st *unmarshalState) ensure(tokSrc shared.TokenSource, lookahead ...
method linkLookahead (line 210) | func (st *unmarshalState) linkLookahead(na datamodel.NodeAssembler, to...
method bytesLookahead (line 252) | func (st *unmarshalState) bytesLookahead(na datamodel.NodeAssembler, t...
method unmarshal (line 322) | func (st *unmarshalState) unmarshal(na datamodel.NodeAssembler, tokSrc...
FILE: codec/decode_test.go
function TestDecodeZero (line 18) | func TestDecodeZero(t *testing.T) {
FILE: codec/json/marshal_test.go
function TestMarshalLinks (line 18) | func TestMarshalLinks(t *testing.T) {
function TestMarshalBytes (line 36) | func TestMarshalBytes(t *testing.T) {
FILE: codec/json/multicodec.go
function init (line 19) | func init() {
function Decode (line 28) | func Decode(na datamodel.NodeAssembler, r io.Reader) error {
function Encode (line 39) | func Encode(n datamodel.Node, w io.Writer) error {
FILE: codec/raw/codec.go
constant rawMulticodec (line 19) | rawMulticodec = 0x55
function init (line 26) | func init() {
function Decode (line 43) | func Decode(am datamodel.NodeAssembler, r io.Reader) error {
function Encode (line 61) | func Encode(node datamodel.Node, w io.Writer) error {
FILE: codec/raw/codec_test.go
function TestRoundtrip (line 28) | func TestRoundtrip(t *testing.T) {
function TestRoundtripCidlink (line 49) | func TestRoundtripCidlink(t *testing.T) {
type mustOnlyUseRead (line 79) | type mustOnlyUseRead struct
method Read (line 83) | func (r mustOnlyUseRead) Read(p []byte) (int, error) {
type mustNotUseRead (line 88) | type mustNotUseRead struct
method Read (line 92) | func (r mustNotUseRead) Read(p []byte) (int, error) {
method Bytes (line 96) | func (r mustNotUseRead) Bytes() []byte {
function TestDecodeBuffer (line 100) | func TestDecodeBuffer(t *testing.T) {
FILE: codecHelpers.go
function Encode (line 28) | func Encode(n Node, encFn Encoder) ([]byte, error) {
function EncodeStreaming (line 35) | func EncodeStreaming(wr io.Writer, n Node, encFn Encoder) error {
function Decode (line 55) | func Decode(b []byte, decFn Decoder) (Node, error) {
function DecodeStreaming (line 60) | func DecodeStreaming(r io.Reader, decFn Decoder) (Node, error) {
function DecodeUsingPrototype (line 79) | func DecodeUsingPrototype(b []byte, decFn Decoder, np NodePrototype) (No...
function DecodeStreamingUsingPrototype (line 84) | func DecodeStreamingUsingPrototype(r io.Reader, decFn Decoder, np NodePr...
function Marshal (line 111) | func Marshal(encFn Encoder, bind interface{}, typ schema.Type, opts ...b...
function MarshalStreaming (line 117) | func MarshalStreaming(wr io.Writer, encFn Encoder, bind interface{}, typ...
function Unmarshal (line 149) | func Unmarshal(b []byte, decFn Decoder, bind interface{}, typ schema.Typ...
function UnmarshalStreaming (line 154) | func UnmarshalStreaming(r io.Reader, decFn Decoder, bind interface{}, ty...
FILE: codecHelpers_test.go
function Example_marshal (line 12) | func Example_marshal() {
function Example_unmarshal_withSchema (line 31) | func Example_unmarshal_withSchema() {
FILE: datamodel.go
constant Kind_Invalid (line 33) | Kind_Invalid = datamodel.Kind_Invalid
constant Kind_Map (line 34) | Kind_Map = datamodel.Kind_Map
constant Kind_List (line 35) | Kind_List = datamodel.Kind_List
constant Kind_Null (line 36) | Kind_Null = datamodel.Kind_Null
constant Kind_Bool (line 37) | Kind_Bool = datamodel.Kind_Bool
constant Kind_Int (line 38) | Kind_Int = datamodel.Kind_Int
constant Kind_Float (line 39) | Kind_Float = datamodel.Kind_Float
constant Kind_String (line 40) | Kind_String = datamodel.Kind_String
constant Kind_Bytes (line 41) | Kind_Bytes = datamodel.Kind_Bytes
constant Kind_Link (line 42) | Kind_Link = datamodel.Kind_Link
function NewPath (line 84) | func NewPath(segments []PathSegment) Path {
function ParsePath (line 91) | func ParsePath(pth string) Path {
function ParsePathSegment (line 98) | func ParsePathSegment(s string) PathSegment {
function PathSegmentOfString (line 105) | func PathSegmentOfString(s string) PathSegment {
function PathSegmentOfInt (line 112) | func PathSegmentOfInt(i int64) PathSegment {
FILE: datamodel/copy.go
function Copy (line 23) | func Copy(n Node, na NodeAssembler) error {
FILE: datamodel/copy_test.go
function TestCopy (line 68) | func TestCopy(t *testing.T) {
FILE: datamodel/equal.go
function DeepEqual (line 27) | func DeepEqual(x, y Node) bool {
FILE: datamodel/equal_test.go
function qpMust (line 25) | func qpMust(node datamodel.Node, err error) datamodel.Node {
function TestDeepEqual (line 136) | func TestDeepEqual(t *testing.T) {
FILE: datamodel/errors.go
type ErrWrongKind (line 13) | type ErrWrongKind struct
method Error (line 38) | func (e ErrWrongKind) Error() string {
type ErrNotExists (line 56) | type ErrNotExists struct
method Error (line 60) | func (e ErrNotExists) Error() string {
type ErrRepeatedMapKey (line 70) | type ErrRepeatedMapKey struct
method Error (line 74) | func (e ErrRepeatedMapKey) Error() string {
type ErrInvalidSegmentForList (line 80) | type ErrInvalidSegmentForList struct
method Error (line 93) | func (e ErrInvalidSegmentForList) Error() string {
type ErrIteratorOverread (line 103) | type ErrIteratorOverread struct
method Error (line 105) | func (e ErrIteratorOverread) Error() string {
FILE: datamodel/kind.go
type Kind (line 10) | type Kind
method String (line 25) | func (k Kind) String() string {
constant Kind_Invalid (line 13) | Kind_Invalid Kind = 0
constant Kind_Map (line 14) | Kind_Map Kind = '{'
constant Kind_List (line 15) | Kind_List Kind = '['
constant Kind_Null (line 16) | Kind_Null Kind = '0'
constant Kind_Bool (line 17) | Kind_Bool Kind = 'b'
constant Kind_Int (line 18) | Kind_Int Kind = 'i'
constant Kind_Float (line 19) | Kind_Float Kind = 'f'
constant Kind_String (line 20) | Kind_String Kind = 's'
constant Kind_Bytes (line 21) | Kind_Bytes Kind = 'x'
constant Kind_Link (line 22) | Kind_Link Kind = '/'
type KindSet (line 54) | type KindSet
method String (line 71) | func (x KindSet) String() string {
method Contains (line 83) | func (x KindSet) Contains(e Kind) bool {
FILE: datamodel/kind_test.go
function TestErrWrongKind_String (line 11) | func TestErrWrongKind_String(t *testing.T) {
FILE: datamodel/link.go
type Link (line 28) | type Link interface
type LinkPrototype (line 61) | type LinkPrototype interface
FILE: datamodel/node.go
type Node (line 60) | type Node interface
type UintNode (line 176) | type UintNode interface
type LargeBytesNode (line 189) | type LargeBytesNode interface
type NodePrototype (line 223) | type NodePrototype interface
type NodePrototypeSupportingAmend (line 240) | type NodePrototypeSupportingAmend interface
type MapIterator (line 259) | type MapIterator interface
type ListIterator (line 291) | type ListIterator interface
FILE: datamodel/nodeBuilder.go
type NodeAssembler (line 38) | type NodeAssembler interface
type MapAssembler (line 78) | type MapAssembler interface
type ListAssembler (line 117) | type ListAssembler interface
type NodeBuilder (line 141) | type NodeBuilder interface
FILE: datamodel/path.go
type Path (line 64) | type Path struct
method String (line 139) | func (p Path) String() string {
method Segments (line 156) | func (p Path) Segments() []PathSegment {
method Len (line 164) | func (p Path) Len() int {
method Join (line 169) | func (p Path) Join(p2 Path) Path {
method AppendSegment (line 178) | func (p Path) AppendSegment(ps PathSegment) Path {
method AppendSegmentString (line 188) | func (p Path) AppendSegmentString(ps string) Path {
method AppendSegmentInt (line 193) | func (p Path) AppendSegmentInt(ps int64) Path {
method Parent (line 199) | func (p Path) Parent() Path {
method Truncate (line 207) | func (p Path) Truncate(i int) Path {
method Last (line 213) | func (p Path) Last() PathSegment {
method Pop (line 221) | func (p Path) Pop() Path {
method Shift (line 231) | func (p Path) Shift() (PathSegment, Path) {
function NewPath (line 77) | func NewPath(segments []PathSegment) Path {
function NewPathNocopy (line 85) | func NewPathNocopy(segments []PathSegment) Path {
function ParsePath (line 113) | func ParsePath(pth string) Path {
FILE: datamodel/pathSegment.go
type PathSegment (line 38) | type PathSegment struct
method containsString (line 100) | func (ps PathSegment) containsString() bool {
method String (line 105) | func (ps PathSegment) String() string {
method Index (line 117) | func (ps PathSegment) Index() (int64, error) {
method Equals (line 136) | func (x PathSegment) Equals(o PathSegment) bool {
function ParsePathSegment (line 82) | func ParsePathSegment(s string) PathSegment {
function PathSegmentOfString (line 88) | func PathSegmentOfString(s string) PathSegment {
function PathSegmentOfInt (line 93) | func PathSegmentOfInt(i int64) PathSegment {
FILE: datamodel/path_test.go
function TestParsePath (line 11) | func TestParsePath(t *testing.T) {
function TestPathSegmentZeroValue (line 34) | func TestPathSegmentZeroValue(t *testing.T) {
FILE: datamodel/unit.go
type nullNode (line 11) | type nullNode struct
method Kind (line 13) | func (nullNode) Kind() Kind {
method LookupByString (line 16) | func (nullNode) LookupByString(key string) (Node, error) {
method LookupByNode (line 19) | func (nullNode) LookupByNode(key Node) (Node, error) {
method LookupByIndex (line 22) | func (nullNode) LookupByIndex(idx int64) (Node, error) {
method LookupBySegment (line 25) | func (nullNode) LookupBySegment(seg PathSegment) (Node, error) {
method MapIterator (line 28) | func (nullNode) MapIterator() MapIterator {
method ListIterator (line 31) | func (nullNode) ListIterator() ListIterator {
method Length (line 34) | func (nullNode) Length() int64 {
method IsAbsent (line 37) | func (nullNode) IsAbsent() bool {
method IsNull (line 40) | func (nullNode) IsNull() bool {
method AsBool (line 43) | func (nullNode) AsBool() (bool, error) {
method AsInt (line 46) | func (nullNode) AsInt() (int64, error) {
method AsFloat (line 49) | func (nullNode) AsFloat() (float64, error) {
method AsString (line 52) | func (nullNode) AsString() (string, error) {
method AsBytes (line 55) | func (nullNode) AsBytes() ([]byte, error) {
method AsLink (line 58) | func (nullNode) AsLink() (Link, error) {
method Prototype (line 61) | func (nullNode) Prototype() NodePrototype {
type nullPrototype (line 65) | type nullPrototype struct
method NewBuilder (line 67) | func (nullPrototype) NewBuilder() NodeBuilder {
type absentNode (line 90) | type absentNode struct
method Kind (line 92) | func (absentNode) Kind() Kind {
method LookupByString (line 95) | func (absentNode) LookupByString(key string) (Node, error) {
method LookupByNode (line 98) | func (absentNode) LookupByNode(key Node) (Node, error) {
method LookupByIndex (line 101) | func (absentNode) LookupByIndex(idx int64) (Node, error) {
method LookupBySegment (line 104) | func (absentNode) LookupBySegment(seg PathSegment) (Node, error) {
method MapIterator (line 107) | func (absentNode) MapIterator() MapIterator {
method ListIterator (line 110) | func (absentNode) ListIterator() ListIterator {
method Length (line 113) | func (absentNode) Length() int64 {
method IsAbsent (line 116) | func (absentNode) IsAbsent() bool {
method IsNull (line 119) | func (absentNode) IsNull() bool {
method AsBool (line 122) | func (absentNode) AsBool() (bool, error) {
method AsInt (line 125) | func (absentNode) AsInt() (int64, error) {
method AsFloat (line 128) | func (absentNode) AsFloat() (float64, error) {
method AsString (line 131) | func (absentNode) AsString() (string, error) {
method AsBytes (line 134) | func (absentNode) AsBytes() ([]byte, error) {
method AsLink (line 137) | func (absentNode) AsLink() (Link, error) {
method Prototype (line 140) | func (absentNode) Prototype() NodePrototype {
type absentPrototype (line 144) | type absentPrototype struct
method NewBuilder (line 146) | func (absentPrototype) NewBuilder() NodeBuilder {
FILE: examples_test.go
function Example_createDataAndMarshal (line 20) | func Example_createDataAndMarshal() {
function Example_unmarshalData (line 42) | func Example_unmarshalData() {
function ExampleLoadSchema (line 58) | func ExampleLoadSchema() {
function Example_goValueWithSchema (line 82) | func Example_goValueWithSchema() {
FILE: fluent/bench_test.go
function BenchmarkQp (line 14) | func BenchmarkQp(b *testing.B) {
function BenchmarkUnmarshal (line 49) | func BenchmarkUnmarshal(b *testing.B) {
function BenchmarkFluent (line 77) | func BenchmarkFluent(b *testing.B) {
function BenchmarkReflect (line 102) | func BenchmarkReflect(b *testing.B) {
function BenchmarkReflectIncludingInitialization (line 128) | func BenchmarkReflectIncludingInitialization(b *testing.B) {
function BenchmarkAgonizinglyBare (line 153) | func BenchmarkAgonizinglyBare(b *testing.B) {
function fab (line 167) | func fab() (datamodel.Node, error) {
FILE: fluent/fluentBuilder.go
function Build (line 7) | func Build(np datamodel.NodePrototype, fn func(NodeAssembler)) (datamode...
function BuildMap (line 18) | func BuildMap(np datamodel.NodePrototype, sizeHint int64, fn func(MapAss...
function BuildList (line 21) | func BuildList(np datamodel.NodePrototype, sizeHint int64, fn func(ListA...
function MustBuild (line 25) | func MustBuild(np datamodel.NodePrototype, fn func(NodeAssembler)) datam...
function MustBuildMap (line 30) | func MustBuildMap(np datamodel.NodePrototype, sizeHint int64, fn func(Ma...
function MustBuildList (line 33) | func MustBuildList(np datamodel.NodePrototype, sizeHint int64, fn func(L...
function WrapAssembler (line 37) | func WrapAssembler(na datamodel.NodeAssembler) NodeAssembler {
type NodeAssembler (line 46) | type NodeAssembler interface
type MapAssembler (line 66) | type MapAssembler interface
type ListAssembler (line 81) | type ListAssembler interface
type nodeAssembler (line 87) | type nodeAssembler struct
method CreateMap (line 91) | func (fna *nodeAssembler) CreateMap(sizeHint int64, fn func(MapAssembl...
method CreateList (line 101) | func (fna *nodeAssembler) CreateList(sizeHint int64, fn func(ListAssem...
method AssignNull (line 111) | func (fna *nodeAssembler) AssignNull() {
method AssignBool (line 116) | func (fna *nodeAssembler) AssignBool(v bool) {
method AssignInt (line 121) | func (fna *nodeAssembler) AssignInt(v int64) {
method AssignFloat (line 126) | func (fna *nodeAssembler) AssignFloat(v float64) {
method AssignString (line 131) | func (fna *nodeAssembler) AssignString(v string) {
method AssignBytes (line 136) | func (fna *nodeAssembler) AssignBytes(v []byte) {
method AssignLink (line 141) | func (fna *nodeAssembler) AssignLink(v datamodel.Link) {
method AssignNode (line 146) | func (fna *nodeAssembler) AssignNode(v datamodel.Node) {
method Prototype (line 151) | func (fna *nodeAssembler) Prototype() datamodel.NodePrototype {
type mapNodeAssembler (line 155) | type mapNodeAssembler struct
method AssembleKey (line 159) | func (fma *mapNodeAssembler) AssembleKey() NodeAssembler {
method AssembleValue (line 162) | func (fma *mapNodeAssembler) AssembleValue() NodeAssembler {
method AssembleEntry (line 165) | func (fma *mapNodeAssembler) AssembleEntry(k string) NodeAssembler {
method KeyPrototype (line 172) | func (fma *mapNodeAssembler) KeyPrototype() datamodel.NodePrototype {
method ValuePrototype (line 175) | func (fma *mapNodeAssembler) ValuePrototype(k string) datamodel.NodePr...
type listNodeAssembler (line 179) | type listNodeAssembler struct
method AssembleValue (line 183) | func (fla *listNodeAssembler) AssembleValue() NodeAssembler {
method ValuePrototype (line 186) | func (fla *listNodeAssembler) ValuePrototype(idx int64) datamodel.Node...
FILE: fluent/fluentBuilder_test.go
function TestBuild (line 14) | func TestBuild(t *testing.T) {
FILE: fluent/fluentRecover.go
type Error (line 3) | type Error struct
method Error (line 7) | func (e Error) Error() string {
function Recover (line 16) | func Recover(fn func()) (err error) {
FILE: fluent/fluentRecover_test.go
function TestRecover (line 13) | func TestRecover(t *testing.T) {
FILE: fluent/qp/example_test.go
function Example (line 14) | func Example() {
FILE: fluent/qp/qp.go
function BuildMap (line 24) | func BuildMap(np datamodel.NodePrototype, sizeHint int64, fn func(datamo...
type mapParams (line 40) | type mapParams struct
method Assemble (line 45) | func (mp mapParams) Assemble(na datamodel.NodeAssembler) {
function Map (line 56) | func Map(sizeHint int64, fn func(datamodel.MapAssembler)) Assemble {
function MapEntry (line 60) | func MapEntry(ma datamodel.MapAssembler, k string, fn Assemble) {
function BuildList (line 68) | func BuildList(np datamodel.NodePrototype, sizeHint int64, fn func(datam...
type listParams (line 84) | type listParams struct
method Assemble (line 89) | func (lp listParams) Assemble(na datamodel.NodeAssembler) {
function List (line 100) | func List(sizeHint int64, fn func(datamodel.ListAssembler)) Assemble {
function ListEntry (line 104) | func ListEntry(la datamodel.ListAssembler, fn Assemble) {
type nullParam (line 108) | type nullParam struct
method Assemble (line 110) | func (s nullParam) Assemble(na datamodel.NodeAssembler) {
function Null (line 116) | func Null() Assemble {
type boolParam (line 120) | type boolParam
method Assemble (line 122) | func (s boolParam) Assemble(na datamodel.NodeAssembler) {
function Bool (line 128) | func Bool(b bool) Assemble {
type intParam (line 132) | type intParam
method Assemble (line 134) | func (i intParam) Assemble(na datamodel.NodeAssembler) {
function Int (line 140) | func Int(i int64) Assemble {
type floatParam (line 144) | type floatParam
method Assemble (line 146) | func (f floatParam) Assemble(na datamodel.NodeAssembler) {
function Float (line 152) | func Float(f float64) Assemble {
type stringParam (line 156) | type stringParam
method Assemble (line 158) | func (s stringParam) Assemble(na datamodel.NodeAssembler) {
function String (line 164) | func String(s string) Assemble {
type bytesParam (line 168) | type bytesParam
method Assemble (line 170) | func (p bytesParam) Assemble(na datamodel.NodeAssembler) {
function Bytes (line 176) | func Bytes(p []byte) Assemble {
type linkParam (line 180) | type linkParam struct
method Assemble (line 184) | func (l linkParam) Assemble(na datamodel.NodeAssembler) {
function Link (line 190) | func Link(l datamodel.Link) Assemble {
type nodeParam (line 194) | type nodeParam struct
method Assemble (line 198) | func (n nodeParam) Assemble(na datamodel.NodeAssembler) {
function Node (line 204) | func Node(n datamodel.Node) Assemble {
FILE: fluent/reflect.go
function Reflect (line 50) | func Reflect(np datamodel.NodePrototype, i interface{}) (datamodel.Node,...
function MustReflect (line 56) | func MustReflect(np datamodel.NodePrototype, i interface{}) datamodel.No...
function ReflectIntoAssembler (line 69) | func ReflectIntoAssembler(na datamodel.NodeAssembler, i interface{}) err...
type Reflector (line 81) | type Reflector struct
method Reflect (line 95) | func (rcfg Reflector) Reflect(np datamodel.NodePrototype, i interface{...
method ReflectIntoAssembler (line 106) | func (rcfg Reflector) ReflectIntoAssembler(na datamodel.NodeAssembler,...
type sortableStrings (line 265) | type sortableStrings struct
method Len (line 270) | func (a sortableStrings) Len() int { return len(a.a) }
method Swap (line 271) | func (a sortableStrings) Swap(i, j int) { a.a[i], a.a[j] = a.a[j]...
method Less (line 272) | func (a sortableStrings) Less(i, j int) bool { return a.less(a.a[i], a...
type sortableReflectStrings (line 274) | type sortableReflectStrings struct
method Len (line 279) | func (a sortableReflectStrings) Len() int { return len(a.a) }
method Swap (line 280) | func (a sortableReflectStrings) Swap(i, j int) { a.a[i], a.a[j] =...
method Less (line 281) | func (a sortableReflectStrings) Less(i, j int) bool { return a.less(a....
FILE: fluent/reflect_test.go
function TestReflect (line 14) | func TestReflect(t *testing.T) {
FILE: fluent/toInterfaceValue.go
function ToInterface (line 18) | func ToInterface(node datamodel.Node) (interface{}, error) {
FILE: fluent/toInterfaceValue_test.go
function TestRoundTrip (line 26) | func TestRoundTrip(t *testing.T) {
function TestLink (line 39) | func TestLink(t *testing.T) {
FILE: linking/cid/cidLink.go
type Link (line 23) | type Link struct
method Prototype (line 27) | func (lnk Link) Prototype() datamodel.LinkPrototype {
method String (line 30) | func (lnk Link) String() string {
method Binary (line 33) | func (lnk Link) Binary() string {
type LinkPrototype (line 37) | type LinkPrototype struct
method BuildLink (line 41) | func (lp LinkPrototype) BuildLink(hashsum []byte) datamodel.Link {
FILE: linking/cid/linksystem.go
function DefaultLinkSystem (line 22) | func DefaultLinkSystem() linking.LinkSystem {
function LinkSystemUsingMulticodecRegistry (line 31) | func LinkSystemUsingMulticodecRegistry(mcReg multicodec.Registry) linkin...
FILE: linking/cid/memorystorage.go
type Memory (line 20) | type Memory struct
method beInitialized (line 24) | func (store *Memory) beInitialized() {
method OpenRead (line 31) | func (store *Memory) OpenRead(lnkCtx linking.LinkContext, lnk datamode...
method OpenWrite (line 44) | func (store *Memory) OpenWrite(lnkCtx linking.LinkContext) (io.Writer,...
FILE: linking/errors.go
type ErrLinkingSetup (line 12) | type ErrLinkingSetup struct
method Error (line 17) | func (e ErrLinkingSetup) Error() string { return fmt.Sprintf("%s: %v",...
method Unwrap (line 18) | func (e ErrLinkingSetup) Unwrap() error { return e.Cause }
type ErrHashMismatch (line 23) | type ErrHashMismatch struct
method Error (line 28) | func (e ErrHashMismatch) Error() string {
FILE: linking/functions.go
method Load (line 51) | func (lsys *LinkSystem) Load(lnkCtx LinkContext, lnk datamodel.Link, np ...
method MustLoad (line 66) | func (lsys *LinkSystem) MustLoad(lnkCtx LinkContext, lnk datamodel.Link,...
method LoadPlusRaw (line 80) | func (lsys *LinkSystem) LoadPlusRaw(lnkCtx LinkContext, lnk datamodel.Li...
method LoadRaw (line 114) | func (lsys *LinkSystem) LoadRaw(lnkCtx LinkContext, lnk datamodel.Link) ...
method Fill (line 159) | func (lsys *LinkSystem) Fill(lnkCtx LinkContext, lnk datamodel.Link, na ...
method MustFill (line 222) | func (lsys *LinkSystem) MustFill(lnkCtx LinkContext, lnk datamodel.Link,...
method Store (line 228) | func (lsys *LinkSystem) Store(lnkCtx LinkContext, lp datamodel.LinkProto...
method MustStore (line 258) | func (lsys *LinkSystem) MustStore(lnkCtx LinkContext, lp datamodel.LinkP...
method ComputeLink (line 268) | func (lsys *LinkSystem) ComputeLink(lp datamodel.LinkPrototype, n datamo...
method MustComputeLink (line 284) | func (lsys *LinkSystem) MustComputeLink(lp datamodel.LinkPrototype, n da...
FILE: linking/functions_test.go
function TestLinkSystem_LoadHashMismatch (line 20) | func TestLinkSystem_LoadHashMismatch(t *testing.T) {
FILE: linking/linkingExamples_test.go
function ExampleLinkSystem_Store (line 28) | func ExampleLinkSystem_Store() {
function ExampleLinkSystem_Load (line 92) | func ExampleLinkSystem_Load() {
FILE: linking/preload/preload.go
type Loader (line 13) | type Loader
type PreloadContext (line 17) | type PreloadContext struct
type Link (line 36) | type Link struct
FILE: linking/setup.go
method SetReadStorage (line 19) | func (lsys *LinkSystem) SetReadStorage(store storage.ReadableStorage) {
method SetWriteStorage (line 34) | func (lsys *LinkSystem) SetWriteStorage(store storage.WritableStorage) {
FILE: linking/types.go
type LinkSystem (line 32) | type LinkSystem struct
type BlockReadOpener (line 93) | type BlockReadOpener
type BlockWriteOpener (line 127) | type BlockWriteOpener
type BlockWriteCommitter (line 143) | type BlockWriteCommitter
type NodeReifier (line 158) | type NodeReifier
type LinkContext (line 168) | type LinkContext struct
FILE: multicodec/defaultRegistry.go
function RegisterEncoder (line 43) | func RegisterEncoder(indicator uint64, encodeFunc codec.Encoder) {
function LookupEncoder (line 52) | func LookupEncoder(indicator uint64) (codec.Encoder, error) {
function ListEncoders (line 68) | func ListEncoders() []uint64 {
function RegisterDecoder (line 90) | func RegisterDecoder(indicator uint64, decodeFunc codec.Decoder) {
function LookupDecoder (line 99) | func LookupDecoder(indicator uint64) (codec.Decoder, error) {
function ListDecoders (line 115) | func ListDecoders() []uint64 {
FILE: multicodec/registry.go
type Registry (line 28) | type Registry struct
method ensureInit (line 33) | func (r *Registry) ensureInit() {
method RegisterEncoder (line 43) | func (r *Registry) RegisterEncoder(indicator uint64, encodeFunc codec....
method LookupEncoder (line 55) | func (r *Registry) LookupEncoder(indicator uint64) (codec.Encoder, err...
method ListEncoders (line 65) | func (r *Registry) ListEncoders() []uint64 {
method RegisterDecoder (line 77) | func (r *Registry) RegisterDecoder(indicator uint64, decodeFunc codec....
method LookupDecoder (line 89) | func (r *Registry) LookupDecoder(indicator uint64) (codec.Decoder, err...
method ListDecoders (line 99) | func (r *Registry) ListDecoders() []uint64 {
FILE: must/must.go
function NotError (line 26) | func NotError(e error) {
function Node (line 39) | func Node(n datamodel.Node, e error) datamodel.Node {
function TypedNode (line 54) | func TypedNode(n datamodel.Node, e error) schema.TypedNode {
function True (line 62) | func True(v bool) {
function String (line 71) | func String(n datamodel.Node) string {
function Int (line 82) | func Int(n datamodel.Node) int64 {
FILE: node/basic/deprecated.go
function Chooser (line 18) | func Chooser(_ datamodel.Link, _ linking.LinkContext) (datamodel.NodePro...
function NewBool (line 21) | func NewBool(value bool) datamodel.Node { return basicnode.New...
function NewBytes (line 22) | func NewBytes(value []byte) datamodel.Node { return basicnode.New...
function NewFloat (line 23) | func NewFloat(value float64) datamodel.Node { return basicnode.New...
function NewInt (line 24) | func NewInt(value int64) datamodel.Node { return basicnode.New...
function NewLink (line 25) | func NewLink(value datamodel.Link) datamodel.Node { return basicnode.New...
function NewString (line 26) | func NewString(value string) datamodel.Node { return basicnode.New...
FILE: node/basicnode/any.go
function Chooser (line 25) | func Chooser(_ datamodel.Link, _ linking.LinkContext) (datamodel.NodePro...
type Prototype__Any (line 35) | type Prototype__Any struct
method NewBuilder (line 37) | func (Prototype__Any) NewBuilder() datamodel.NodeBuilder {
type anyBuilder (line 53) | type anyBuilder struct
method Reset (line 73) | func (nb *anyBuilder) Reset() {
method BeginMap (line 77) | func (nb *anyBuilder) BeginMap(sizeHint int64) (datamodel.MapAssembler...
method BeginList (line 85) | func (nb *anyBuilder) BeginList(sizeHint int64) (datamodel.ListAssembl...
method AssignNull (line 93) | func (nb *anyBuilder) AssignNull() error {
method AssignBool (line 100) | func (nb *anyBuilder) AssignBool(v bool) error {
method AssignInt (line 108) | func (nb *anyBuilder) AssignInt(v int64) error {
method AssignFloat (line 116) | func (nb *anyBuilder) AssignFloat(v float64) error {
method AssignString (line 124) | func (nb *anyBuilder) AssignString(v string) error {
method AssignBytes (line 132) | func (nb *anyBuilder) AssignBytes(v []byte) error {
method AssignLink (line 140) | func (nb *anyBuilder) AssignLink(v datamodel.Link) error {
method AssignNode (line 148) | func (nb *anyBuilder) AssignNode(v datamodel.Node) error {
method Prototype (line 156) | func (anyBuilder) Prototype() datamodel.NodePrototype {
method Build (line 160) | func (nb *anyBuilder) Build() datamodel.Node {
FILE: node/basicnode/any_test.go
function TestAnyBeingString (line 10) | func TestAnyBeingString(t *testing.T) {
function TestAnyBeingMapStrInt (line 14) | func TestAnyBeingMapStrInt(t *testing.T) {
function TestAnyBeingMapStrMapStrInt (line 18) | func TestAnyBeingMapStrMapStrInt(t *testing.T) {
FILE: node/basicnode/bench_test.go
function BenchmarkSpec_Walk_Map3StrInt (line 10) | func BenchmarkSpec_Walk_Map3StrInt(b *testing.B) {
function BenchmarkSpec_Walk_MapNStrMap3StrInt (line 14) | func BenchmarkSpec_Walk_MapNStrMap3StrInt(b *testing.B) {
FILE: node/basicnode/bool.go
function NewBool (line 15) | func NewBool(value bool) datamodel.Node {
type plainBool (line 21) | type plainBool
method Kind (line 25) | func (plainBool) Kind() datamodel.Kind {
method LookupByString (line 28) | func (plainBool) LookupByString(string) (datamodel.Node, error) {
method LookupByNode (line 31) | func (plainBool) LookupByNode(key datamodel.Node) (datamodel.Node, err...
method LookupByIndex (line 34) | func (plainBool) LookupByIndex(idx int64) (datamodel.Node, error) {
method LookupBySegment (line 37) | func (plainBool) LookupBySegment(seg datamodel.PathSegment) (datamodel...
method MapIterator (line 40) | func (plainBool) MapIterator() datamodel.MapIterator {
method ListIterator (line 43) | func (plainBool) ListIterator() datamodel.ListIterator {
method Length (line 46) | func (plainBool) Length() int64 {
method IsAbsent (line 49) | func (plainBool) IsAbsent() bool {
method IsNull (line 52) | func (plainBool) IsNull() bool {
method AsBool (line 55) | func (n plainBool) AsBool() (bool, error) {
method AsInt (line 58) | func (plainBool) AsInt() (int64, error) {
method AsFloat (line 61) | func (plainBool) AsFloat() (float64, error) {
method AsString (line 64) | func (plainBool) AsString() (string, error) {
method AsBytes (line 67) | func (plainBool) AsBytes() ([]byte, error) {
method AsLink (line 70) | func (plainBool) AsLink() (datamodel.Link, error) {
method Prototype (line 73) | func (plainBool) Prototype() datamodel.NodePrototype {
type Prototype__Bool (line 79) | type Prototype__Bool struct
method NewBuilder (line 81) | func (Prototype__Bool) NewBuilder() datamodel.NodeBuilder {
type plainBool__Builder (line 88) | type plainBool__Builder struct
method Build (line 92) | func (nb *plainBool__Builder) Build() datamodel.Node {
method Reset (line 95) | func (nb *plainBool__Builder) Reset() {
type plainBool__Assembler (line 102) | type plainBool__Assembler struct
method BeginMap (line 106) | func (plainBool__Assembler) BeginMap(sizeHint int64) (datamodel.MapAss...
method BeginList (line 109) | func (plainBool__Assembler) BeginList(sizeHint int64) (datamodel.ListA...
method AssignNull (line 112) | func (plainBool__Assembler) AssignNull() error {
method AssignBool (line 115) | func (na *plainBool__Assembler) AssignBool(v bool) error {
method AssignInt (line 119) | func (plainBool__Assembler) AssignInt(int64) error {
method AssignFloat (line 122) | func (plainBool__Assembler) AssignFloat(float64) error {
method AssignString (line 125) | func (plainBool__Assembler) AssignString(string) error {
method AssignBytes (line 128) | func (plainBool__Assembler) AssignBytes([]byte) error {
method AssignLink (line 131) | func (plainBool__Assembler) AssignLink(datamodel.Link) error {
method AssignNode (line 134) | func (na *plainBool__Assembler) AssignNode(v datamodel.Node) error {
method Prototype (line 142) | func (plainBool__Assembler) Prototype() datamodel.NodePrototype {
FILE: node/basicnode/bytes.go
function NewBytes (line 18) | func NewBytes(value []byte) datamodel.Node {
type plainBytes (line 24) | type plainBytes
method Kind (line 28) | func (plainBytes) Kind() datamodel.Kind {
method LookupByString (line 31) | func (plainBytes) LookupByString(string) (datamodel.Node, error) {
method LookupByNode (line 34) | func (plainBytes) LookupByNode(key datamodel.Node) (datamodel.Node, er...
method LookupByIndex (line 37) | func (plainBytes) LookupByIndex(idx int64) (datamodel.Node, error) {
method LookupBySegment (line 40) | func (plainBytes) LookupBySegment(seg datamodel.PathSegment) (datamode...
method MapIterator (line 43) | func (plainBytes) MapIterator() datamodel.MapIterator {
method ListIterator (line 46) | func (plainBytes) ListIterator() datamodel.ListIterator {
method Length (line 49) | func (plainBytes) Length() int64 {
method IsAbsent (line 52) | func (plainBytes) IsAbsent() bool {
method IsNull (line 55) | func (plainBytes) IsNull() bool {
method AsBool (line 58) | func (plainBytes) AsBool() (bool, error) {
method AsInt (line 61) | func (plainBytes) AsInt() (int64, error) {
method AsFloat (line 64) | func (plainBytes) AsFloat() (float64, error) {
method AsString (line 67) | func (plainBytes) AsString() (string, error) {
method AsBytes (line 70) | func (n plainBytes) AsBytes() ([]byte, error) {
method AsLink (line 73) | func (plainBytes) AsLink() (datamodel.Link, error) {
method Prototype (line 76) | func (plainBytes) Prototype() datamodel.NodePrototype {
method AsLargeBytes (line 79) | func (n plainBytes) AsLargeBytes() (io.ReadSeeker, error) {
type Prototype__Bytes (line 85) | type Prototype__Bytes struct
method NewBuilder (line 87) | func (Prototype__Bytes) NewBuilder() datamodel.NodeBuilder {
type plainBytes__Builder (line 94) | type plainBytes__Builder struct
method Build (line 98) | func (nb *plainBytes__Builder) Build() datamodel.Node {
method Reset (line 101) | func (nb *plainBytes__Builder) Reset() {
type plainBytes__Assembler (line 108) | type plainBytes__Assembler struct
method BeginMap (line 112) | func (plainBytes__Assembler) BeginMap(sizeHint int64) (datamodel.MapAs...
method BeginList (line 115) | func (plainBytes__Assembler) BeginList(sizeHint int64) (datamodel.List...
method AssignNull (line 118) | func (plainBytes__Assembler) AssignNull() error {
method AssignBool (line 121) | func (plainBytes__Assembler) AssignBool(bool) error {
method AssignInt (line 124) | func (plainBytes__Assembler) AssignInt(int64) error {
method AssignFloat (line 127) | func (plainBytes__Assembler) AssignFloat(float64) error {
method AssignString (line 130) | func (plainBytes__Assembler) AssignString(string) error {
method AssignBytes (line 133) | func (na *plainBytes__Assembler) AssignBytes(v []byte) error {
method AssignLink (line 137) | func (plainBytes__Assembler) AssignLink(datamodel.Link) error {
method AssignNode (line 140) | func (na *plainBytes__Assembler) AssignNode(v datamodel.Node) error {
method Prototype (line 155) | func (plainBytes__Assembler) Prototype() datamodel.NodePrototype {
FILE: node/basicnode/bytes_stream.go
function NewBytesFromReader (line 17) | func NewBytesFromReader(rs io.ReadSeeker) datamodel.Node {
type streamBytes (line 22) | type streamBytes struct
method Kind (line 28) | func (streamBytes) Kind() datamodel.Kind {
method LookupByString (line 31) | func (streamBytes) LookupByString(string) (datamodel.Node, error) {
method LookupByNode (line 34) | func (streamBytes) LookupByNode(key datamodel.Node) (datamodel.Node, e...
method LookupByIndex (line 37) | func (streamBytes) LookupByIndex(idx int64) (datamodel.Node, error) {
method LookupBySegment (line 40) | func (streamBytes) LookupBySegment(seg datamodel.PathSegment) (datamod...
method MapIterator (line 43) | func (streamBytes) MapIterator() datamodel.MapIterator {
method ListIterator (line 46) | func (streamBytes) ListIterator() datamodel.ListIterator {
method Length (line 49) | func (streamBytes) Length() int64 {
method IsAbsent (line 52) | func (streamBytes) IsAbsent() bool {
method IsNull (line 55) | func (streamBytes) IsNull() bool {
method AsBool (line 58) | func (streamBytes) AsBool() (bool, error) {
method AsInt (line 61) | func (streamBytes) AsInt() (int64, error) {
method AsFloat (line 64) | func (streamBytes) AsFloat() (float64, error) {
method AsString (line 67) | func (streamBytes) AsString() (string, error) {
method AsBytes (line 70) | func (n streamBytes) AsBytes() ([]byte, error) {
method AsLink (line 73) | func (streamBytes) AsLink() (datamodel.Link, error) {
method Prototype (line 76) | func (streamBytes) Prototype() datamodel.NodePrototype {
method AsLargeBytes (line 79) | func (n streamBytes) AsLargeBytes() (io.ReadSeeker, error) {
FILE: node/basicnode/bytes_test.go
function TestBytes (line 10) | func TestBytes(t *testing.T) {
FILE: node/basicnode/float.go
function NewFloat (line 15) | func NewFloat(value float64) datamodel.Node {
type plainFloat (line 21) | type plainFloat
method Kind (line 25) | func (plainFloat) Kind() datamodel.Kind {
method LookupByString (line 28) | func (plainFloat) LookupByString(string) (datamodel.Node, error) {
method LookupByNode (line 31) | func (plainFloat) LookupByNode(key datamodel.Node) (datamodel.Node, er...
method LookupByIndex (line 34) | func (plainFloat) LookupByIndex(idx int64) (datamodel.Node, error) {
method LookupBySegment (line 37) | func (plainFloat) LookupBySegment(seg datamodel.PathSegment) (datamode...
method MapIterator (line 40) | func (plainFloat) MapIterator() datamodel.MapIterator {
method ListIterator (line 43) | func (plainFloat) ListIterator() datamodel.ListIterator {
method Length (line 46) | func (plainFloat) Length() int64 {
method IsAbsent (line 49) | func (plainFloat) IsAbsent() bool {
method IsNull (line 52) | func (plainFloat) IsNull() bool {
method AsBool (line 55) | func (plainFloat) AsBool() (bool, error) {
method AsInt (line 58) | func (plainFloat) AsInt() (int64, error) {
method AsFloat (line 61) | func (n plainFloat) AsFloat() (float64, error) {
method AsString (line 64) | func (plainFloat) AsString() (string, error) {
method AsBytes (line 67) | func (plainFloat) AsBytes() ([]byte, error) {
method AsLink (line 70) | func (plainFloat) AsLink() (datamodel.Link, error) {
method Prototype (line 73) | func (plainFloat) Prototype() datamodel.NodePrototype {
type Prototype__Float (line 79) | type Prototype__Float struct
method NewBuilder (line 81) | func (Prototype__Float) NewBuilder() datamodel.NodeBuilder {
type plainFloat__Builder (line 88) | type plainFloat__Builder struct
method Build (line 92) | func (nb *plainFloat__Builder) Build() datamodel.Node {
method Reset (line 95) | func (nb *plainFloat__Builder) Reset() {
type plainFloat__Assembler (line 102) | type plainFloat__Assembler struct
method BeginMap (line 106) | func (plainFloat__Assembler) BeginMap(sizeHint int64) (datamodel.MapAs...
method BeginList (line 109) | func (plainFloat__Assembler) BeginList(sizeHint int64) (datamodel.List...
method AssignNull (line 112) | func (plainFloat__Assembler) AssignNull() error {
method AssignBool (line 115) | func (plainFloat__Assembler) AssignBool(bool) error {
method AssignInt (line 118) | func (plainFloat__Assembler) AssignInt(int64) error {
method AssignFloat (line 121) | func (na *plainFloat__Assembler) AssignFloat(v float64) error {
method AssignString (line 125) | func (plainFloat__Assembler) AssignString(string) error {
method AssignBytes (line 128) | func (plainFloat__Assembler) AssignBytes([]byte) error {
method AssignLink (line 131) | func (plainFloat__Assembler) AssignLink(datamodel.Link) error {
method AssignNode (line 134) | func (na *plainFloat__Assembler) AssignNode(v datamodel.Node) error {
method Prototype (line 142) | func (plainFloat__Assembler) Prototype() datamodel.NodePrototype {
FILE: node/basicnode/int.go
function NewInt (line 20) | func NewInt(value int64) datamodel.Node {
function NewUint (line 31) | func NewUint(value uint64) datamodel.Node {
type plainInt (line 36) | type plainInt
method Kind (line 40) | func (plainInt) Kind() datamodel.Kind {
method LookupByString (line 43) | func (plainInt) LookupByString(string) (datamodel.Node, error) {
method LookupByNode (line 46) | func (plainInt) LookupByNode(key datamodel.Node) (datamodel.Node, erro...
method LookupByIndex (line 49) | func (plainInt) LookupByIndex(idx int64) (datamodel.Node, error) {
method LookupBySegment (line 52) | func (plainInt) LookupBySegment(seg datamodel.PathSegment) (datamodel....
method MapIterator (line 55) | func (plainInt) MapIterator() datamodel.MapIterator {
method ListIterator (line 58) | func (plainInt) ListIterator() datamodel.ListIterator {
method Length (line 61) | func (plainInt) Length() int64 {
method IsAbsent (line 64) | func (plainInt) IsAbsent() bool {
method IsNull (line 67) | func (plainInt) IsNull() bool {
method AsBool (line 70) | func (plainInt) AsBool() (bool, error) {
method AsInt (line 73) | func (n plainInt) AsInt() (int64, error) {
method AsFloat (line 76) | func (plainInt) AsFloat() (float64, error) {
method AsString (line 79) | func (plainInt) AsString() (string, error) {
method AsBytes (line 82) | func (plainInt) AsBytes() ([]byte, error) {
method AsLink (line 85) | func (plainInt) AsLink() (datamodel.Link, error) {
method Prototype (line 88) | func (plainInt) Prototype() datamodel.NodePrototype {
type plainUint (line 95) | type plainUint
method Kind (line 99) | func (plainUint) Kind() datamodel.Kind {
method LookupByString (line 102) | func (plainUint) LookupByString(string) (datamodel.Node, error) {
method LookupByNode (line 105) | func (plainUint) LookupByNode(key datamodel.Node) (datamodel.Node, err...
method LookupByIndex (line 108) | func (plainUint) LookupByIndex(idx int64) (datamodel.Node, error) {
method LookupBySegment (line 111) | func (plainUint) LookupBySegment(seg datamodel.PathSegment) (datamodel...
method MapIterator (line 114) | func (plainUint) MapIterator() datamodel.MapIterator {
method ListIterator (line 117) | func (plainUint) ListIterator() datamodel.ListIterator {
method Length (line 120) | func (plainUint) Length() int64 {
method IsAbsent (line 123) | func (plainUint) IsAbsent() bool {
method IsNull (line 126) | func (plainUint) IsNull() bool {
method AsBool (line 129) | func (plainUint) AsBool() (bool, error) {
method AsInt (line 132) | func (n plainUint) AsInt() (int64, error) {
method AsFloat (line 138) | func (plainUint) AsFloat() (float64, error) {
method AsString (line 141) | func (plainUint) AsString() (string, error) {
method AsBytes (line 144) | func (plainUint) AsBytes() ([]byte, error) {
method AsLink (line 147) | func (plainUint) AsLink() (datamodel.Link, error) {
method Prototype (line 150) | func (plainUint) Prototype() datamodel.NodePrototype {
method AsUint (line 156) | func (n plainUint) AsUint() (uint64, error) {
type Prototype__Int (line 162) | type Prototype__Int struct
method NewBuilder (line 164) | func (Prototype__Int) NewBuilder() datamodel.NodeBuilder {
type plainInt__Builder (line 171) | type plainInt__Builder struct
method Build (line 175) | func (nb *plainInt__Builder) Build() datamodel.Node {
method Reset (line 178) | func (nb *plainInt__Builder) Reset() {
type plainInt__Assembler (line 185) | type plainInt__Assembler struct
method BeginMap (line 189) | func (plainInt__Assembler) BeginMap(sizeHint int64) (datamodel.MapAsse...
method BeginList (line 192) | func (plainInt__Assembler) BeginList(sizeHint int64) (datamodel.ListAs...
method AssignNull (line 195) | func (plainInt__Assembler) AssignNull() error {
method AssignBool (line 198) | func (plainInt__Assembler) AssignBool(bool) error {
method AssignInt (line 201) | func (na *plainInt__Assembler) AssignInt(v int64) error {
method AssignFloat (line 205) | func (plainInt__Assembler) AssignFloat(float64) error {
method AssignString (line 208) | func (plainInt__Assembler) AssignString(string) error {
method AssignBytes (line 211) | func (plainInt__Assembler) AssignBytes([]byte) error {
method AssignLink (line 214) | func (plainInt__Assembler) AssignLink(datamodel.Link) error {
method AssignNode (line 217) | func (na *plainInt__Assembler) AssignNode(v datamodel.Node) error {
method Prototype (line 225) | func (plainInt__Assembler) Prototype() datamodel.NodePrototype {
FILE: node/basicnode/int_test.go
function TestBasicInt (line 11) | func TestBasicInt(t *testing.T) {
function TestIntErrors (line 22) | func TestIntErrors(t *testing.T) {
FILE: node/basicnode/link.go
function NewLink (line 15) | func NewLink(value datamodel.Link) datamodel.Node {
type plainLink (line 20) | type plainLink struct
method Kind (line 26) | func (plainLink) Kind() datamodel.Kind {
method LookupByString (line 29) | func (plainLink) LookupByString(string) (datamodel.Node, error) {
method LookupByNode (line 32) | func (plainLink) LookupByNode(key datamodel.Node) (datamodel.Node, err...
method LookupByIndex (line 35) | func (plainLink) LookupByIndex(idx int64) (datamodel.Node, error) {
method LookupBySegment (line 38) | func (plainLink) LookupBySegment(seg datamodel.PathSegment) (datamodel...
method MapIterator (line 41) | func (plainLink) MapIterator() datamodel.MapIterator {
method ListIterator (line 44) | func (plainLink) ListIterator() datamodel.ListIterator {
method Length (line 47) | func (plainLink) Length() int64 {
method IsAbsent (line 50) | func (plainLink) IsAbsent() bool {
method IsNull (line 53) | func (plainLink) IsNull() bool {
method AsBool (line 56) | func (plainLink) AsBool() (bool, error) {
method AsInt (line 59) | func (plainLink) AsInt() (int64, error) {
method AsFloat (line 62) | func (plainLink) AsFloat() (float64, error) {
method AsString (line 65) | func (plainLink) AsString() (string, error) {
method AsBytes (line 68) | func (plainLink) AsBytes() ([]byte, error) {
method AsLink (line 71) | func (n *plainLink) AsLink() (datamodel.Link, error) {
method Prototype (line 74) | func (plainLink) Prototype() datamodel.NodePrototype {
type Prototype__Link (line 80) | type Prototype__Link struct
method NewBuilder (line 82) | func (Prototype__Link) NewBuilder() datamodel.NodeBuilder {
type plainLink__Builder (line 89) | type plainLink__Builder struct
method Build (line 93) | func (nb *plainLink__Builder) Build() datamodel.Node {
method Reset (line 96) | func (nb *plainLink__Builder) Reset() {
type plainLink__Assembler (line 103) | type plainLink__Assembler struct
method BeginMap (line 107) | func (plainLink__Assembler) BeginMap(sizeHint int64) (datamodel.MapAss...
method BeginList (line 110) | func (plainLink__Assembler) BeginList(sizeHint int64) (datamodel.ListA...
method AssignNull (line 113) | func (plainLink__Assembler) AssignNull() error {
method AssignBool (line 116) | func (plainLink__Assembler) AssignBool(bool) error {
method AssignInt (line 119) | func (plainLink__Assembler) AssignInt(int64) error {
method AssignFloat (line 122) | func (plainLink__Assembler) AssignFloat(float64) error {
method AssignString (line 125) | func (plainLink__Assembler) AssignString(string) error {
method AssignBytes (line 128) | func (plainLink__Assembler) AssignBytes([]byte) error {
method AssignLink (line 131) | func (na *plainLink__Assembler) AssignLink(v datamodel.Link) error {
method AssignNode (line 135) | func (na *plainLink__Assembler) AssignNode(v datamodel.Node) error {
method Prototype (line 143) | func (plainLink__Assembler) Prototype() datamodel.NodePrototype {
FILE: node/basicnode/list.go
type plainList (line 18) | type plainList struct
method Kind (line 24) | func (plainList) Kind() datamodel.Kind {
method LookupByString (line 27) | func (plainList) LookupByString(string) (datamodel.Node, error) {
method LookupByNode (line 30) | func (plainList) LookupByNode(datamodel.Node) (datamodel.Node, error) {
method LookupByIndex (line 33) | func (n *plainList) LookupByIndex(idx int64) (datamodel.Node, error) {
method LookupBySegment (line 42) | func (n *plainList) LookupBySegment(seg datamodel.PathSegment) (datamo...
method MapIterator (line 49) | func (plainList) MapIterator() datamodel.MapIterator {
method ListIterator (line 52) | func (n *plainList) ListIterator() datamodel.ListIterator {
method Length (line 55) | func (n *plainList) Length() int64 {
method IsAbsent (line 58) | func (plainList) IsAbsent() bool {
method IsNull (line 61) | func (plainList) IsNull() bool {
method AsBool (line 64) | func (plainList) AsBool() (bool, error) {
method AsInt (line 67) | func (plainList) AsInt() (int64, error) {
method AsFloat (line 70) | func (plainList) AsFloat() (float64, error) {
method AsString (line 73) | func (plainList) AsString() (string, error) {
method AsBytes (line 76) | func (plainList) AsBytes() ([]byte, error) {
method AsLink (line 79) | func (plainList) AsLink() (datamodel.Link, error) {
method Prototype (line 82) | func (plainList) Prototype() datamodel.NodePrototype {
type plainList_ListIterator (line 86) | type plainList_ListIterator struct
method Next (line 91) | func (itr *plainList_ListIterator) Next() (idx int64, v datamodel.Node...
method Done (line 100) | func (itr *plainList_ListIterator) Done() bool {
type Prototype__List (line 106) | type Prototype__List struct
method NewBuilder (line 108) | func (Prototype__List) NewBuilder() datamodel.NodeBuilder {
type plainList__Builder (line 114) | type plainList__Builder struct
method Build (line 118) | func (nb *plainList__Builder) Build() datamodel.Node {
method Reset (line 124) | func (nb *plainList__Builder) Reset() {
type plainList__Assembler (line 131) | type plainList__Assembler struct
method BeginMap (line 153) | func (plainList__Assembler) BeginMap(sizeHint int64) (datamodel.MapAss...
method BeginList (line 156) | func (na *plainList__Assembler) BeginList(sizeHint int64) (datamodel.L...
method AssignNull (line 165) | func (plainList__Assembler) AssignNull() error {
method AssignBool (line 168) | func (plainList__Assembler) AssignBool(bool) error {
method AssignInt (line 171) | func (plainList__Assembler) AssignInt(int64) error {
method AssignFloat (line 174) | func (plainList__Assembler) AssignFloat(float64) error {
method AssignString (line 177) | func (plainList__Assembler) AssignString(string) error {
method AssignBytes (line 180) | func (plainList__Assembler) AssignBytes([]byte) error {
method AssignLink (line 183) | func (plainList__Assembler) AssignLink(datamodel.Link) error {
method AssignNode (line 186) | func (na *plainList__Assembler) AssignNode(v datamodel.Node) error {
method Prototype (line 219) | func (plainList__Assembler) Prototype() datamodel.NodePrototype {
method AssembleValue (line 227) | func (la *plainList__Assembler) AssembleValue() datamodel.NodeAssembler {
method Finish (line 240) | func (la *plainList__Assembler) Finish() error {
method ValuePrototype (line 249) | func (plainList__Assembler) ValuePrototype(_ int64) datamodel.NodeProt...
type plainList__ValueAssembler (line 138) | type plainList__ValueAssembler struct
method BeginMap (line 255) | func (lva *plainList__ValueAssembler) BeginMap(sizeHint int64) (datamo...
method BeginList (line 262) | func (lva *plainList__ValueAssembler) BeginList(sizeHint int64) (datam...
method AssignNull (line 269) | func (lva *plainList__ValueAssembler) AssignNull() error {
method AssignBool (line 272) | func (lva *plainList__ValueAssembler) AssignBool(v bool) error {
method AssignInt (line 276) | func (lva *plainList__ValueAssembler) AssignInt(v int64) error {
method AssignFloat (line 280) | func (lva *plainList__ValueAssembler) AssignFloat(v float64) error {
method AssignString (line 284) | func (lva *plainList__ValueAssembler) AssignString(v string) error {
method AssignBytes (line 288) | func (lva *plainList__ValueAssembler) AssignBytes(v []byte) error {
method AssignLink (line 292) | func (lva *plainList__ValueAssembler) AssignLink(v datamodel.Link) err...
method AssignNode (line 296) | func (lva *plainList__ValueAssembler) AssignNode(v datamodel.Node) err...
method Prototype (line 302) | func (plainList__ValueAssembler) Prototype() datamodel.NodePrototype {
type laState (line 145) | type laState
constant laState_initial (line 148) | laState_initial laState = iota
constant laState_midValue (line 149) | laState_midValue
constant laState_finished (line 150) | laState_finished
type plainList__ValueAssemblerMap (line 306) | type plainList__ValueAssemblerMap struct
method AssembleEntry (line 315) | func (ma *plainList__ValueAssemblerMap) AssembleEntry(k string) (datam...
method AssembleKey (line 318) | func (ma *plainList__ValueAssemblerMap) AssembleKey() datamodel.NodeAs...
method AssembleValue (line 321) | func (ma *plainList__ValueAssemblerMap) AssembleValue() datamodel.Node...
method KeyPrototype (line 324) | func (plainList__ValueAssemblerMap) KeyPrototype() datamodel.NodeProto...
method ValuePrototype (line 327) | func (plainList__ValueAssemblerMap) ValuePrototype(_ string) datamodel...
method Finish (line 331) | func (ma *plainList__ValueAssemblerMap) Finish() error {
type plainList__ValueAssemblerList (line 340) | type plainList__ValueAssemblerList struct
method AssembleValue (line 349) | func (la *plainList__ValueAssemblerList) AssembleValue() datamodel.Nod...
method ValuePrototype (line 352) | func (plainList__ValueAssemblerList) ValuePrototype(_ int64) datamodel...
method Finish (line 356) | func (la *plainList__ValueAssemblerList) Finish() error {
FILE: node/basicnode/list_test.go
function TestList (line 10) | func TestList(t *testing.T) {
FILE: node/basicnode/map.go
type plainMap (line 20) | type plainMap struct
method Kind (line 33) | func (plainMap) Kind() datamodel.Kind {
method LookupByString (line 36) | func (n *plainMap) LookupByString(key string) (datamodel.Node, error) {
method LookupByNode (line 43) | func (n *plainMap) LookupByNode(key datamodel.Node) (datamodel.Node, e...
method LookupByIndex (line 50) | func (plainMap) LookupByIndex(idx int64) (datamodel.Node, error) {
method LookupBySegment (line 53) | func (n *plainMap) LookupBySegment(seg datamodel.PathSegment) (datamod...
method MapIterator (line 56) | func (n *plainMap) MapIterator() datamodel.MapIterator {
method ListIterator (line 59) | func (plainMap) ListIterator() datamodel.ListIterator {
method Length (line 62) | func (n *plainMap) Length() int64 {
method IsAbsent (line 65) | func (plainMap) IsAbsent() bool {
method IsNull (line 68) | func (plainMap) IsNull() bool {
method AsBool (line 71) | func (plainMap) AsBool() (bool, error) {
method AsInt (line 74) | func (plainMap) AsInt() (int64, error) {
method AsFloat (line 77) | func (plainMap) AsFloat() (float64, error) {
method AsString (line 80) | func (plainMap) AsString() (string, error) {
method AsBytes (line 83) | func (plainMap) AsBytes() ([]byte, error) {
method AsLink (line 86) | func (plainMap) AsLink() (datamodel.Link, error) {
method Prototype (line 89) | func (plainMap) Prototype() datamodel.NodePrototype {
type plainMap__Entry (line 25) | type plainMap__Entry struct
type plainMap_MapIterator (line 93) | type plainMap_MapIterator struct
method Next (line 98) | func (itr *plainMap_MapIterator) Next() (k datamodel.Node, v datamodel...
method Done (line 107) | func (itr *plainMap_MapIterator) Done() bool {
type Prototype__Map (line 113) | type Prototype__Map struct
method NewBuilder (line 115) | func (Prototype__Map) NewBuilder() datamodel.NodeBuilder {
type plainMap__Builder (line 121) | type plainMap__Builder struct
method Build (line 125) | func (nb *plainMap__Builder) Build() datamodel.Node {
method Reset (line 131) | func (nb *plainMap__Builder) Reset() {
type plainMap__Assembler (line 138) | type plainMap__Assembler struct
method BeginMap (line 165) | func (na *plainMap__Assembler) BeginMap(sizeHint int64) (datamodel.Map...
method BeginList (line 175) | func (plainMap__Assembler) BeginList(sizeHint int64) (datamodel.ListAs...
method AssignNull (line 178) | func (plainMap__Assembler) AssignNull() error {
method AssignBool (line 181) | func (plainMap__Assembler) AssignBool(bool) error {
method AssignInt (line 184) | func (plainMap__Assembler) AssignInt(int64) error {
method AssignFloat (line 187) | func (plainMap__Assembler) AssignFloat(float64) error {
method AssignString (line 190) | func (plainMap__Assembler) AssignString(string) error {
method AssignBytes (line 193) | func (plainMap__Assembler) AssignBytes([]byte) error {
method AssignLink (line 196) | func (plainMap__Assembler) AssignLink(datamodel.Link) error {
method AssignNode (line 199) | func (na *plainMap__Assembler) AssignNode(v datamodel.Node) error {
method Prototype (line 235) | func (plainMap__Assembler) Prototype() datamodel.NodePrototype {
method AssembleEntry (line 243) | func (ma *plainMap__Assembler) AssembleEntry(k string) (datamodel.Node...
method AssembleKey (line 263) | func (ma *plainMap__Assembler) AssembleKey() datamodel.NodeAssembler {
method AssembleValue (line 276) | func (ma *plainMap__Assembler) AssembleValue() datamodel.NodeAssembler {
method Finish (line 289) | func (ma *plainMap__Assembler) Finish() error {
method KeyPrototype (line 298) | func (plainMap__Assembler) KeyPrototype() datamodel.NodePrototype {
method ValuePrototype (line 301) | func (plainMap__Assembler) ValuePrototype(_ string) datamodel.NodeProt...
type plainMap__KeyAssembler (line 146) | type plainMap__KeyAssembler struct
method BeginMap (line 307) | func (plainMap__KeyAssembler) BeginMap(sizeHint int64) (datamodel.MapA...
method BeginList (line 310) | func (plainMap__KeyAssembler) BeginList(sizeHint int64) (datamodel.Lis...
method AssignNull (line 313) | func (plainMap__KeyAssembler) AssignNull() error {
method AssignBool (line 316) | func (plainMap__KeyAssembler) AssignBool(bool) error {
method AssignInt (line 319) | func (plainMap__KeyAssembler) AssignInt(int64) error {
method AssignFloat (line 322) | func (plainMap__KeyAssembler) AssignFloat(float64) error {
method AssignString (line 325) | func (mka *plainMap__KeyAssembler) AssignString(v string) error {
method AssignBytes (line 345) | func (plainMap__KeyAssembler) AssignBytes([]byte) error {
method AssignLink (line 348) | func (plainMap__KeyAssembler) AssignLink(datamodel.Link) error {
method AssignNode (line 351) | func (mka *plainMap__KeyAssembler) AssignNode(v datamodel.Node) error {
method Prototype (line 358) | func (plainMap__KeyAssembler) Prototype() datamodel.NodePrototype {
type plainMap__ValueAssembler (line 149) | type plainMap__ValueAssembler struct
method BeginMap (line 364) | func (mva *plainMap__ValueAssembler) BeginMap(sizeHint int64) (datamod...
method BeginList (line 371) | func (mva *plainMap__ValueAssembler) BeginList(sizeHint int64) (datamo...
method AssignNull (line 378) | func (mva *plainMap__ValueAssembler) AssignNull() error {
method AssignBool (line 381) | func (mva *plainMap__ValueAssembler) AssignBool(v bool) error {
method AssignInt (line 385) | func (mva *plainMap__ValueAssembler) AssignInt(v int64) error {
method AssignFloat (line 389) | func (mva *plainMap__ValueAssembler) AssignFloat(v float64) error {
method AssignString (line 393) | func (mva *plainMap__ValueAssembler) AssignString(v string) error {
method AssignBytes (line 397) | func (mva *plainMap__ValueAssembler) AssignBytes(v []byte) error {
method AssignLink (line 401) | func (mva *plainMap__ValueAssembler) AssignLink(v datamodel.Link) error {
method AssignNode (line 405) | func (mva *plainMap__ValueAssembler) AssignNode(v datamodel.Node) error {
method Prototype (line 413) | func (plainMap__ValueAssembler) Prototype() datamodel.NodePrototype {
type maState (line 155) | type maState
constant maState_initial (line 158) | maState_initial maState = iota
constant maState_midKey (line 159) | maState_midKey
constant maState_expectValue (line 160) | maState_expectValue
constant maState_midValue (line 161) | maState_midValue
constant maState_finished (line 162) | maState_finished
type plainMap__ValueAssemblerMap (line 417) | type plainMap__ValueAssemblerMap struct
method AssembleEntry (line 426) | func (ma *plainMap__ValueAssemblerMap) AssembleEntry(k string) (datamo...
method AssembleKey (line 429) | func (ma *plainMap__ValueAssemblerMap) AssembleKey() datamodel.NodeAss...
method AssembleValue (line 432) | func (ma *plainMap__ValueAssemblerMap) AssembleValue() datamodel.NodeA...
method KeyPrototype (line 435) | func (plainMap__ValueAssemblerMap) KeyPrototype() datamodel.NodeProtot...
method ValuePrototype (line 438) | func (plainMap__ValueAssemblerMap) ValuePrototype(_ string) datamodel....
method Finish (line 442) | func (ma *plainMap__ValueAssemblerMap) Finish() error {
type plainMap__ValueAssemblerList (line 451) | type plainMap__ValueAssemblerList struct
method AssembleValue (line 460) | func (la *plainMap__ValueAssemblerList) AssembleValue() datamodel.Node...
method ValuePrototype (line 463) | func (plainMap__ValueAssemblerList) ValuePrototype(_ int64) datamodel....
method Finish (line 467) | func (la *plainMap__ValueAssemblerList) Finish() error {
FILE: node/basicnode/map_test.go
function TestMap (line 15) | func TestMap(t *testing.T) {
function BenchmarkMapStrInt_3n_AssembleStandard (line 21) | func BenchmarkMapStrInt_3n_AssembleStandard(b *testing.B) {
function BenchmarkMapStrInt_3n_AssembleEntry (line 24) | func BenchmarkMapStrInt_3n_AssembleEntry(b *testing.B) {
function BenchmarkMapStrInt_3n_Iteration (line 27) | func BenchmarkMapStrInt_3n_Iteration(b *testing.B) {
function BenchmarkMapStrInt_25n_AssembleStandard (line 31) | func BenchmarkMapStrInt_25n_AssembleStandard(b *testing.B) {
function BenchmarkMapStrInt_25n_AssembleEntry (line 34) | func BenchmarkMapStrInt_25n_AssembleEntry(b *testing.B) {
function BenchmarkMapStrInt_25n_Iteration (line 37) | func BenchmarkMapStrInt_25n_Iteration(b *testing.B) {
function BenchmarkSpec_Marshal_Map3StrInt (line 41) | func BenchmarkSpec_Marshal_Map3StrInt(b *testing.B) {
function BenchmarkSpec_Marshal_MapNStrMap3StrInt (line 44) | func BenchmarkSpec_Marshal_MapNStrMap3StrInt(b *testing.B) {
function BenchmarkSpec_Unmarshal_Map3StrInt (line 48) | func BenchmarkSpec_Unmarshal_Map3StrInt(b *testing.B) {
function BenchmarkSpec_Unmarshal_MapNStrMap3StrInt (line 51) | func BenchmarkSpec_Unmarshal_MapNStrMap3StrInt(b *testing.B) {
function TestMapAssignError (line 57) | func TestMapAssignError(t *testing.T) {
function TestMapBuilder (line 84) | func TestMapBuilder(t *testing.T) {
function TestMapCantAssignNodeTwice (line 171) | func TestMapCantAssignNodeTwice(t *testing.T) {
function TestMapLookupError (line 216) | func TestMapLookupError(t *testing.T) {
function TestMapNewBuilderUsageError (line 260) | func TestMapNewBuilderUsageError(t *testing.T) {
function TestMapDupKeyError (line 311) | func TestMapDupKeyError(t *testing.T) {
FILE: node/basicnode/prototypes.go
type prototype (line 16) | type prototype struct
FILE: node/basicnode/string.go
function NewString (line 15) | func NewString(value string) datamodel.Node {
type plainString (line 26) | type plainString
method Kind (line 30) | func (plainString) Kind() datamodel.Kind {
method LookupByString (line 33) | func (plainString) LookupByString(string) (datamodel.Node, error) {
method LookupByNode (line 36) | func (plainString) LookupByNode(key datamodel.Node) (datamodel.Node, e...
method LookupByIndex (line 39) | func (plainString) LookupByIndex(idx int64) (datamodel.Node, error) {
method LookupBySegment (line 42) | func (plainString) LookupBySegment(seg datamodel.PathSegment) (datamod...
method MapIterator (line 45) | func (plainString) MapIterator() datamodel.MapIterator {
method ListIterator (line 48) | func (plainString) ListIterator() datamodel.ListIterator {
method Length (line 51) | func (plainString) Length() int64 {
method IsAbsent (line 54) | func (plainString) IsAbsent() bool {
method IsNull (line 57) | func (plainString) IsNull() bool {
method AsBool (line 60) | func (plainString) AsBool() (bool, error) {
method AsInt (line 63) | func (plainString) AsInt() (int64, error) {
method AsFloat (line 66) | func (plainString) AsFloat() (float64, error) {
method AsString (line 69) | func (x plainString) AsString() (string, error) {
method AsBytes (line 72) | func (plainString) AsBytes() ([]byte, error) {
method AsLink (line 75) | func (plainString) AsLink() (datamodel.Link, error) {
method Prototype (line 78) | func (plainString) Prototype() datamodel.NodePrototype {
type Prototype__String (line 84) | type Prototype__String struct
method NewBuilder (line 86) | func (Prototype__String) NewBuilder() datamodel.NodeBuilder {
type plainString__Builder (line 93) | type plainString__Builder struct
method Build (line 97) | func (nb *plainString__Builder) Build() datamodel.Node {
method Reset (line 100) | func (nb *plainString__Builder) Reset() {
type plainString__Assembler (line 107) | type plainString__Assembler struct
method BeginMap (line 111) | func (plainString__Assembler) BeginMap(sizeHint int64) (datamodel.MapA...
method BeginList (line 114) | func (plainString__Assembler) BeginList(sizeHint int64) (datamodel.Lis...
method AssignNull (line 117) | func (plainString__Assembler) AssignNull() error {
method AssignBool (line 120) | func (plainString__Assembler) AssignBool(bool) error {
method AssignInt (line 123) | func (plainString__Assembler) AssignInt(int64) error {
method AssignFloat (line 126) | func (plainString__Assembler) AssignFloat(float64) error {
method AssignString (line 129) | func (na *plainString__Assembler) AssignString(v string) error {
method AssignBytes (line 133) | func (plainString__Assembler) AssignBytes([]byte) error {
method AssignLink (line 136) | func (plainString__Assembler) AssignLink(datamodel.Link) error {
method AssignNode (line 139) | func (na *plainString__Assembler) AssignNode(v datamodel.Node) error {
method Prototype (line 147) | func (plainString__Assembler) Prototype() datamodel.NodePrototype {
FILE: node/basicnode/string_test.go
function TestString (line 10) | func TestString(t *testing.T) {
FILE: node/bindnode/api.go
function Prototype (line 31) | func Prototype(ptrType interface{}, schemaType schema.Type, options ...O...
type converter (line 63) | type converter struct
type config (line 88) | type config struct
method converterFor (line 95) | func (c *config) converterFor(typeName schema.TypeName, val reflect.Va...
method converterForType (line 107) | func (c *config) converterForType(typeName schema.TypeName, typ reflec...
type Option (line 119) | type Option
function TypedBoolConverter (line 129) | func TypedBoolConverter(ptrVal interface{}, from func(bool) (interface{}...
function TypedIntConverter (line 149) | func TypedIntConverter(ptrVal interface{}, from func(int64) (interface{}...
function TypedFloatConverter (line 169) | func TypedFloatConverter(ptrVal interface{}, from func(float64) (interfa...
function TypedStringConverter (line 189) | func TypedStringConverter(ptrVal interface{}, from func(string) (interfa...
function TypedBytesConverter (line 209) | func TypedBytesConverter(ptrVal interface{}, from func([]byte) (interfac...
function TypedLinkConverter (line 233) | func TypedLinkConverter(ptrVal interface{}, from func(cid.Cid) (interfac...
function TypedAnyConverter (line 256) | func TypedAnyConverter(ptrVal interface{}, from func(datamodel.Node) (in...
function NamedBoolConverter (line 276) | func NamedBoolConverter(typeName schema.TypeName, from func(bool) (inter...
function NamedIntConverter (line 295) | func NamedIntConverter(typeName schema.TypeName, from func(int64) (inter...
function NamedFloatConverter (line 314) | func NamedFloatConverter(typeName schema.TypeName, from func(float64) (i...
function NamedStringConverter (line 333) | func NamedStringConverter(typeName schema.TypeName, from func(string) (i...
function NamedBytesConverter (line 352) | func NamedBytesConverter(typeName schema.TypeName, from func([]byte) (in...
function NamedLinkConverter (line 375) | func NamedLinkConverter(typeName schema.TypeName, from func(cid.Cid) (in...
function NamedAnyConverter (line 397) | func NamedAnyConverter(typeName schema.TypeName, from func(datamodel.Nod...
function applyOptions (line 408) | func applyOptions(opt ...Option) *config {
function Wrap (line 433) | func Wrap(ptrVal interface{}, schemaType schema.Type, options ...Option)...
function Unwrap (line 477) | func Unwrap(node datamodel.Node) (ptrVal interface{}) {
FILE: node/bindnode/api_test.go
function TestEnumError (line 16) | func TestEnumError(t *testing.T) {
function TestSubNodeWalkAndUnwrap (line 44) | func TestSubNodeWalkAndUnwrap(t *testing.T) {
function TestUint64Struct (line 202) | func TestUint64Struct(t *testing.T) {
FILE: node/bindnode/custom_test.go
type BoolSubst (line 27) | type BoolSubst
constant BoolSubst_Yes (line 32) | BoolSubst_Yes = 100
constant BoolSubst_No (line 33) | BoolSubst_No = -100
function BoolSubstFromBool (line 36) | func BoolSubstFromBool(b bool) (interface{}, error) {
function BoolSubstFromBoolError (line 43) | func BoolSubstFromBoolError(b bool) (interface{}, error) {
function BoolToBoolSubst (line 47) | func BoolToBoolSubst(b interface{}) (bool, error) {
function BoolToBoolSubstError (line 61) | func BoolToBoolSubstError(b interface{}) (bool, error) {
type IntSubst (line 65) | type IntSubst
function IntSubstFromInt (line 67) | func IntSubstFromInt(i int64) (interface{}, error) {
function IntSubstFromIntError (line 76) | func IntSubstFromIntError(i int64) (interface{}, error) {
function IntToIntSubst (line 80) | func IntToIntSubst(i interface{}) (int64, error) {
function IntToIntSubstError (line 95) | func IntToIntSubstError(i interface{}) (int64, error) {
type BigFloat (line 99) | type BigFloat struct
function BigFloatFromFloat (line 101) | func BigFloatFromFloat(f float64) (interface{}, error) {
function BigFloatFromFloatError (line 106) | func BigFloatFromFloatError(f float64) (interface{}, error) {
function FloatFromBigFloat (line 110) | func FloatFromBigFloat(f interface{}) (float64, error) {
function FloatFromBigFloatError (line 119) | func FloatFromBigFloatError(f interface{}) (float64, error) {
type ByteArray (line 123) | type ByteArray
function ByteArrayFromString (line 125) | func ByteArrayFromString(s string) (interface{}, error) {
function ByteArrayFromStringError (line 134) | func ByteArrayFromStringError(s string) (interface{}, error) {
function StringFromByteArray (line 138) | func StringFromByteArray(b interface{}) (string, error) {
function StringFromByteArrayError (line 153) | func StringFromByteArrayError(b interface{}) (string, error) {
type Boop (line 158) | type Boop struct
method Bytes (line 164) | func (b Boop) Bytes() []byte {
method String (line 168) | func (b Boop) String() string {
function NewBoop (line 160) | func NewBoop(b []byte) *Boop {
type Frop (line 173) | type Frop struct
method Bytes (line 199) | func (b *Frop) Bytes() []byte {
function NewFropFromString (line 175) | func NewFropFromString(str string) Frop {
function NewFropFromBytes (line 180) | func NewFropFromBytes(buf []byte) *Frop {
function BoopFromBytes (line 210) | func BoopFromBytes(b []byte) (interface{}, error) {
function BoopFromBytesError (line 214) | func BoopFromBytesError(b []byte) (interface{}, error) {
function BoopToBytes (line 218) | func BoopToBytes(iface interface{}) ([]byte, error) {
function BoopToBytesError (line 225) | func BoopToBytesError(iface interface{}) ([]byte, error) {
function FropFromBytes (line 229) | func FropFromBytes(b []byte) (interface{}, error) {
function FropFromBytesError (line 233) | func FropFromBytesError(b []byte) (interface{}, error) {
function FropToBytes (line 237) | func FropToBytes(iface interface{}) ([]byte, error) {
function FropToBytesError (line 244) | func FropToBytesError(iface interface{}) ([]byte, error) {
type BtcId (line 249) | type BtcId
function FromCidToBtcId (line 251) | func FromCidToBtcId(c cid.Cid) (interface{}, error) {
function FromCidToBtcIdError (line 267) | func FromCidToBtcIdError(c cid.Cid) (interface{}, error) {
function FromBtcIdToCid (line 271) | func FromBtcIdToCid(iface interface{}) (cid.Cid, error) {
function FromBtcIdToCidError (line 291) | func FromBtcIdToCidError(iface interface{}) (cid.Cid, error) {
type Boom (line 295) | type Boom struct
constant boomSchema (line 308) | boomSchema = `
constant boomFixtureDagJson (line 331) | boomFixtureDagJson = `{"B":{"/":{"bytes":"dGhlc2UgYXJlIGJ5dGVz"}},"Bo":f...
function TestCustom (line 346) | func TestCustom(t *testing.T) {
function TestCustomNamed (line 385) | func TestCustomNamed(t *testing.T) {
type AnyExtend (line 432) | type AnyExtend struct
type anyMap (line 452) | type anyMap struct
constant anyExtendSchema (line 457) | anyExtendSchema = `
type AnyExtendBlob (line 479) | type AnyExtendBlob struct
method ToNode (line 526) | func (aeb AnyExtendBlob) ToNode() (datamodel.Node, error) {
function AnyExtendBlobFromNode (line 486) | func AnyExtendBlobFromNode(node datamodel.Node) (interface{}, error) {
function AnyExtendBlobToNode (line 537) | func AnyExtendBlobToNode(ptr interface{}) (datamodel.Node, error) {
type AnyCborEncoded (line 547) | type AnyCborEncoded struct
function AnyCborEncodedFromNode (line 549) | func AnyCborEncodedFromNode(node datamodel.Node) (interface{}, error) {
function AnyCborEncodedToNode (line 562) | func AnyCborEncodedToNode(ptr interface{}) (datamodel.Node, error) {
constant anyExtendDagJson (line 575) | anyExtendDagJson = `{"Blob":{"baz":[2,3,4],"foo":"bar"},"Bool":false,"Bo...
function TestCustomAny (line 604) | func TestCustomAny(t *testing.T) {
function mustFromHex (line 642) | func mustFromHex(hexStr string) []byte {
type ClosedUnion (line 650) | type ClosedUnion interface
type intUnion (line 654) | type intUnion
method isClosedUnion (line 656) | func (intUnion) isClosedUnion() {}
type stringUnion (line 658) | type stringUnion
method isClosedUnion (line 660) | func (stringUnion) isClosedUnion() {}
function ClosedUnionFromNode (line 662) | func ClosedUnionFromNode(node datamodel.Node) (interface{}, error) {
function ClosedUnionToNode (line 674) | func ClosedUnionToNode(val interface{}) (datamodel.Node, error) {
type StructWithUnion (line 689) | type StructWithUnion struct
constant closedUnionSchema (line 693) | closedUnionSchema = `
constant closedUnionFixtureIntDagJson (line 701) | closedUnionFixtureIntDagJson = `{"cu":8}`
constant closedUnionFixtureStringDagJson (line 702) | closedUnionFixtureStringDagJson = `{"cu":"happy"}`
function TestCustomAnyWithInterface (line 711) | func TestCustomAnyWithInterface(t *testing.T) {
FILE: node/bindnode/example_test.go
function ExampleWrap_withSchema (line 15) | func ExampleWrap_withSchema() {
function ExampleWrap_noSchema (line 46) | func ExampleWrap_noSchema() {
function ExamplePrototype_onlySchema (line 65) | func ExamplePrototype_onlySchema() {
function ExamplePrototype_union (line 98) | func ExamplePrototype_union() {
FILE: node/bindnode/fuzz_test.go
function marshalDagCBOR (line 111) | func marshalDagCBOR(tb testing.TB, node datamodel.Node) []byte {
function marshalDagJSON (line 120) | func marshalDagJSON(tb testing.TB, node datamodel.Node) []byte {
function FuzzBindnodeViaDagCBOR (line 145) | func FuzzBindnodeViaDagCBOR(f *testing.F) {
FILE: node/bindnode/generate.go
function produceGoType (line 15) | func produceGoType(goTypes map[string]string, typ schema.Type) (name, sr...
function produceGoTypeInner (line 51) | func produceGoTypeInner(goTypes map[string]string, name string, typ sche...
function ProduceGoTypes (line 116) | func ProduceGoTypes(w io.Writer, ts *schema.TypeSystem) error {
FILE: node/bindnode/infer.go
type seenEntry (line 37) | type seenEntry struct
function verifyCompatibility (line 47) | func verifyCompatibility(cfg *config, seen map[seenEntry]bool, goType re...
function ptrOrNilable (line 261) | func ptrOrNilable(kind reflect.Kind) (ptr, nilable bool) {
constant maxRecursionLevel (line 276) | maxRecursionLevel = 1 << 10
type inferredStatus (line 278) | type inferredStatus
constant _ (line 281) | _ inferredStatus = iota
constant inferringInProcess (line 282) | inferringInProcess
constant inferringDone (line 283) | inferringDone
function inferGoType (line 287) | func inferGoType(typ schema.Type, status map[schema.TypeName]inferredSta...
function fieldNameFromSchema (line 387) | func fieldNameFromSchema(name string) string {
function init (line 397) | func init() {
function inferSchema (line 417) | func inferSchema(typ reflect.Type, level int) schema.Type {
FILE: node/bindnode/infer_test.go
type anyScalar (line 29) | type anyScalar struct
type anyRecursive (line 38) | type anyRecursive struct
function compactJSON (line 243) | func compactJSON(t *testing.T, pretty string) string {
function dagjsonEncode (line 250) | func dagjsonEncode(t *testing.T, node datamodel.Node) string {
function dagjsonDecode (line 257) | func dagjsonDecode(t *testing.T, proto datamodel.NodePrototype, src stri...
function TestPrototype (line 264) | func TestPrototype(t *testing.T) {
function TestPrototypePointerCombinations (line 304) | func TestPrototypePointerCombinations(t *testing.T) {
function nilable (line 441) | func nilable(kind reflect.Kind) bool {
function assembleAsKind (line 450) | func assembleAsKind(proto datamodel.NodePrototype, schemaType schema.Typ...
function useNodeAsKind (line 546) | func useNodeAsKind(node datamodel.Node, asKind datamodel.Kind) error {
function TestKindMismatches (line 672) | func TestKindMismatches(t *testing.T) {
type verifyBadType (line 796) | type verifyBadType struct
type namedBool (line 802) | type namedBool
type namedInt64 (line 803) | type namedInt64
type namedFloat64 (line 804) | type namedFloat64
type namedString (line 805) | type namedString
type namedBytes (line 806) | type namedBytes
function TestSchemaVerify (line 988) | func TestSchemaVerify(t *testing.T) {
function TestProduceGoTypes (line 1023) | func TestProduceGoTypes(t *testing.T) {
function TestRenameAssignNode (line 1056) | func TestRenameAssignNode(t *testing.T) {
function TestEmptyTypedAssignNode (line 1085) | func TestEmptyTypedAssignNode(t *testing.T) {
function TestInferLinksAndAny (line 1216) | func TestInferLinksAndAny(t *testing.T) {
FILE: node/bindnode/node.go
type _prototype (line 61) | type _prototype struct
method NewBuilder (line 67) | func (w *_prototype) NewBuilder() datamodel.NodeBuilder {
method Type (line 75) | func (w *_prototype) Type() schema.Type {
method Representation (line 79) | func (w *_prototype) Representation() datamodel.NodePrototype {
type _node (line 83) | type _node struct
method Type (line 109) | func (w *_node) Type() schema.Type {
method Representation (line 113) | func (w *_node) Representation() datamodel.Node {
method Kind (line 117) | func (w *_node) Kind() datamodel.Kind {
method LookupByString (line 192) | func (w *_node) LookupByString(key string) (datamodel.Node, error) {
method LookupByIndex (line 332) | func (w *_node) LookupByIndex(idx int64) (datamodel.Node, error) {
method LookupBySegment (line 370) | func (w *_node) LookupBySegment(seg datamodel.PathSegment) (datamodel....
method LookupByNode (line 389) | func (w *_node) LookupByNode(key datamodel.Node) (datamodel.Node, erro...
method MapIterator (line 412) | func (w *_node) MapIterator() datamodel.MapIterator {
method ListIterator (line 444) | func (w *_node) ListIterator() datamodel.ListIterator {
method Length (line 453) | func (w *_node) Length() int64 {
method IsAbsent (line 472) | func (w *_node) IsAbsent() bool {
method IsNull (line 476) | func (w *_node) IsNull() bool {
method AsBool (line 485) | func (w *_node) AsBool() (bool, error) {
method AsInt (line 496) | func (w *_node) AsInt() (int64, error) {
method AsFloat (line 515) | func (w *_node) AsFloat() (float64, error) {
method AsString (line 526) | func (w *_node) AsString() (string, error) {
method AsBytes (line 537) | func (w *_node) AsBytes() ([]byte, error) {
method AsLink (line 548) | func (w *_node) AsLink() (datamodel.Link, error) {
method Prototype (line 570) | func (w *_node) Prototype() datamodel.NodePrototype {
function newNode (line 95) | func newNode(cfg *config, schemaType schema.Type, val reflect.Value) sch...
function compatibleKind (line 123) | func compatibleKind(schemaType schema.Type, kind datamodel.Kind) error {
function actualKind (line 151) | func actualKind(schemaType schema.Type) datamodel.Kind {
function nonPtrVal (line 155) | func nonPtrVal(val reflect.Value) reflect.Value {
function ptrVal (line 167) | func ptrVal(val reflect.Value) reflect.Value {
function nonPtrType (line 174) | func nonPtrType(val reflect.Value) reflect.Type {
function matchSettable (line 184) | func matchSettable(val interface{}, to reflect.Value) reflect.Value {
function unionMember (line 309) | func unionMember(val reflect.Value) (int, reflect.Value) {
function unionSetMember (line 324) | func unionSetMember(val reflect.Value, memberIdx int, memberPtr reflect....
type _builder (line 574) | type _builder struct
method Build (line 578) | func (w *_builder) Build() datamodel.Node {
method Reset (line 583) | func (w *_builder) Reset() {
type _assembler (line 587) | type _assembler struct
method createNonPtrVal (line 602) | func (w *_assembler) createNonPtrVal() reflect.Value {
method Representation (line 620) | func (w *_assembler) Representation() datamodel.NodeAssembler {
method BeginMap (line 659) | func (w *_assembler) BeginMap(sizeHint int64) (datamodel.MapAssembler,...
method BeginList (line 753) | func (w *_assembler) BeginList(sizeHint int64) (datamodel.ListAssemble...
method AssignNull (line 782) | func (w *_assembler) AssignNull() error {
method AssignBool (line 811) | func (w *_assembler) AssignBool(b bool) error {
method assignUInt (line 850) | func (w *_assembler) assignUInt(uin datamodel.UintNode) error {
method AssignInt (line 879) | func (w *_assembler) AssignInt(i int64) error {
method AssignFloat (line 925) | func (w *_assembler) AssignFloat(f float64) error {
method AssignString (line 964) | func (w *_assembler) AssignString(s string) error {
method AssignBytes (line 1003) | func (w *_assembler) AssignBytes(p []byte) error {
method AssignLink (line 1042) | func (w *_assembler) AssignLink(link datamodel.Link) error {
method AssignNode (line 1100) | func (w *_assembler) AssignNode(node datamodel.Node) error {
method Prototype (line 1113) | func (w *_assembler) Prototype() datamodel.NodePrototype {
type basicMapAssembler (line 626) | type basicMapAssembler struct
method Finish (line 634) | func (w *basicMapAssembler) Finish() error {
type basicListAssembler (line 720) | type basicListAssembler struct
method Finish (line 728) | func (w *basicListAssembler) Finish() error {
type _structAssembler (line 1118) | type _structAssembler struct
method AssembleKey (line 1141) | func (w *_structAssembler) AssembleKey() datamodel.NodeAssembler {
method AssembleValue (line 1150) | func (w *_structAssembler) AssembleValue() datamodel.NodeAssembler {
method AssembleEntry (line 1192) | func (w *_structAssembler) AssembleEntry(k string) (datamodel.NodeAsse...
method Finish (line 1200) | func (w *_structAssembler) Finish() error {
method KeyPrototype (line 1219) | func (w *_structAssembler) KeyPrototype() datamodel.NodePrototype {
method ValuePrototype (line 1225) | func (w *_structAssembler) ValuePrototype(k string) datamodel.NodeProt...
type _errorAssembler (line 1229) | type _errorAssembler struct
method BeginMap (line 1233) | func (w _errorAssembler) BeginMap(int64) (datamodel.MapAssembler, erro...
method BeginList (line 1234) | func (w _errorAssembler) BeginList(int64) (datamodel.ListAssembler, er...
method AssignNull (line 1235) | func (w _errorAssembler) AssignNull() error ...
method AssignBool (line 1236) | func (w _errorAssembler) AssignBool(bool) error ...
method AssignInt (line 1237) | func (w _errorAssembler) AssignInt(int64) error ...
method AssignFloat (line 1238) | func (w _errorAssembler) AssignFloat(float64) error ...
method AssignString (line 1239) | func (w _errorAssembler) AssignString(string) error ...
method AssignBytes (line 1240) | func (w _errorAssembler) AssignBytes([]byte) error ...
method AssignLink (line 1241) | func (w _errorAssembler) AssignLink(datamodel.Link) error ...
method AssignNode (line 1242) | func (w _errorAssembler) AssignNode(datamodel.Node) error ...
method Prototype (line 1243) | func (w _errorAssembler) Prototype() datamodel.NodePrototype ...
type _mapAssembler (line 1247) | type _mapAssembler struct
method AssembleKey (line 1259) | func (w *_mapAssembler) AssembleKey() datamodel.NodeAssembler {
method AssembleValue (line 1268) | func (w *_mapAssembler) AssembleValue() datamodel.NodeAssembler {
method AssembleEntry (line 1287) | func (w *_mapAssembler) AssembleEntry(k string) (datamodel.NodeAssembl...
method Finish (line 1295) | func (w *_mapAssembler) Finish() error {
method KeyPrototype (line 1304) | func (w *_mapAssembler) KeyPrototype() datamodel.NodePrototype {
method ValuePrototype (line 1308) | func (w *_mapAssembler) ValuePrototype(k string) datamodel.NodePrototy...
type _listAssembler (line 1313) | type _listAssembler struct
method AssembleValue (line 1320) | func (w *_listAssembler) AssembleValue() datamodel.NodeAssembler {
method Finish (line 1332) | func (w *_listAssembler) Finish() error {
method ValuePrototype (line 1341) | func (w *_listAssembler) ValuePrototype(idx int64) datamodel.NodeProto...
type _unionAssembler (line 1347) | type _unionAssembler struct
method AssembleKey (line 1358) | func (w *_unionAssembler) AssembleKey() datamodel.NodeAssembler {
method AssembleValue (line 1367) | func (w *_unionAssembler) AssembleValue() datamodel.NodeAssembler {
method AssembleEntry (line 1401) | func (w *_unionAssembler) AssembleEntry(k string) (datamodel.NodeAssem...
method Finish (line 1409) | func (w *_unionAssembler) Finish() error {
method KeyPrototype (line 1424) | func (w *_unionAssembler) KeyPrototype() datamodel.NodePrototype {
method ValuePrototype (line 1428) | func (w *_unionAssembler) ValuePrototype(k string) datamodel.NodeProto...
type _structIterator (line 1435) | type _structIterator struct
method Next (line 1448) | func (w *_structIterator) Next() (key, value datamodel.Node, _ error) {
method Done (line 1491) | func (w *_structIterator) Done() bool {
type _mapIterator (line 1497) | type _mapIterator struct
method Next (line 1505) | func (w *_mapIterator) Next() (key, value datamodel.Node, _ error) {
method Done (line 1540) | func (w *_mapIterator) Done() bool {
type _listIterator (line 1545) | type _listIterator struct
method Next (line 1552) | func (w *_listIterator) Next() (index int64, value datamodel.Node, _ e...
method Done (line 1578) | func (w *_listIterator) Done() bool {
type _unionIterator (line 1582) | type _unionIterator struct
method Next (line 1592) | func (w *_unionIterator) Next() (key, value datamodel.Node, _ error) {
method Done (line 1611) | func (w *_unionIterator) Done() bool {
type _uintNode (line 1617) | type _uintNode struct
method Type (line 1624) | func (tu *_uintNode) Type() schema.Type {
method Representation (line 1627) | func (tu *_uintNode) Representation() datamodel.Node {
method Kind (line 1630) | func (_uintNode) Kind() datamodel.Kind {
method LookupByString (line 1633) | func (_uintNode) LookupByString(string) (datamodel.Node, error) {
method LookupByNode (line 1636) | func (_uintNode) LookupByNode(key datamodel.Node) (datamodel.Node, err...
method LookupByIndex (line 1639) | func (_uintNode) LookupByIndex(idx int64) (datamodel.Node, error) {
method LookupBySegment (line 1642) | func (_uintNode) LookupBySegment(seg datamodel.PathSegment) (datamodel...
method MapIterator (line 1645) | func (_uintNode) MapIterator() datamodel.MapIterator {
method ListIterator (line 1648) | func (_uintNode) ListIterator() datamodel.ListIterator {
method Length (line 1651) | func (_uintNode) Length() int64 {
method IsAbsent (line 1654) | func (_uintNode) IsAbsent() bool {
method IsNull (line 1657) | func (_uintNode) IsNull() bool {
method AsBool (line 1660) | func (_uintNode) AsBool() (bool, error) {
method AsInt (line 1663) | func (tu *_uintNode) AsInt() (int64, error) {
method AsUint (line 1666) | func (tu *_uintNode) AsUint() (uint64, error) {
method AsFloat (line 1669) | func (_uintNode) AsFloat() (float64, error) {
method AsString (line 1672) | func (_uintNode) AsString() (string, error) {
method AsBytes (line 1675) | func (_uintNode) AsBytes() ([]byte, error) {
method AsLink (line 1678) | func (_uintNode) AsLink() (datamodel.Link, error) {
method Prototype (line 1681) | func (_uintNode) Prototype() datamodel.NodePrototype {
type _uintNodeRepr (line 1686) | type _uintNodeRepr
method Kind (line 1688) | func (_uintNodeRepr) Kind() datamodel.Kind {
method LookupByString (line 1691) | func (_uintNodeRepr) LookupByString(string) (datamodel.Node, error) {
method LookupByNode (line 1694) | func (_uintNodeRepr) LookupByNode(key datamodel.Node) (datamodel.Node,...
method LookupByIndex (line 1697) | func (_uintNodeRepr) LookupByIndex(idx int64) (datamodel.Node, error) {
method LookupBySegment (line 1700) | func (_uintNodeRepr) LookupBySegment(seg datamodel.PathSegment) (datam...
method MapIterator (line 1703) | func (_uintNodeRepr) MapIterator() datamodel.MapIterator {
method ListIterator (line 1706) | func (_uintNodeRepr) ListIterator() datamodel.ListIterator {
method Length (line 1709) | func (_uintNodeRepr) Length() int64 {
method IsAbsent (line 1712) | func (_uintNodeRepr) IsAbsent() bool {
method IsNull (line 1715) | func (_uintNodeRepr) IsNull() bool {
method AsBool (line 1718) | func (_uintNodeRepr) AsBool() (bool, error) {
method AsInt (line 1721) | func (tu *_uintNodeRepr) AsInt() (int64, error) {
method AsUint (line 1737) | func (tu *_uintNodeRepr) AsUint() (uint64, error) {
method AsFloat (line 1746) | func (_uintNodeRepr) AsFloat() (float64, error) {
method AsString (line 1749) | func (_uintNodeRepr) AsString() (string, error) {
method AsBytes (line 1752) | func (_uintNodeRepr) AsBytes() ([]byte, error) {
method AsLink (line 1755) | func (_uintNodeRepr) AsLink() (datamodel.Link, error) {
method Prototype (line 1758) | func (_uintNodeRepr) Prototype() datamodel.NodePrototype {
FILE: node/bindnode/registry/registry.go
type prototypeData (line 16) | type prototypeData struct
type BindnodeRegistry (line 23) | type BindnodeRegistry
method prototypeDataFor (line 38) | func (br BindnodeRegistry) prototypeDataFor(ptrType interface{}) proto...
method RegisterType (line 55) | func (br BindnodeRegistry) RegisterType(ptrType interface{}, schema st...
method IsRegistered (line 96) | func (br BindnodeRegistry) IsRegistered(ptrType interface{}) bool {
method TypeFromReader (line 104) | func (br BindnodeRegistry) TypeFromReader(r io.Reader, ptrValue interf...
method TypeFromBytes (line 117) | func (br BindnodeRegistry) TypeFromBytes(byts []byte, ptrValue interfa...
method TypeFromNode (line 129) | func (br BindnodeRegistry) TypeFromNode(node datamodel.Node, ptrValue ...
method TypeToNode (line 145) | func (br BindnodeRegistry) TypeToNode(ptrValue interface{}) schema.Typ...
method TypeToWriter (line 152) | func (br BindnodeRegistry) TypeToWriter(ptrValue interface{}, w io.Wri...
method TypeToBytes (line 159) | func (br BindnodeRegistry) TypeToBytes(ptrValue interface{}, encoder c...
function NewRegistry (line 26) | func NewRegistry() BindnodeRegistry {
function typeOf (line 30) | func typeOf(ptrValue interface{}) reflect.Type {
FILE: node/bindnode/registry/registry_test.go
type HexString (line 18) | type HexString
type Foo (line 19) | type Foo struct
function TestRegistry (line 24) | func TestRegistry(t *testing.T) {
function TestRegistryErrors (line 80) | func TestRegistryErrors(t *testing.T) {
FILE: node/bindnode/repr.go
function reprNode (line 13) | func reprNode(node datamodel.Node) datamodel.Node {
function reprStrategy (line 23) | func reprStrategy(typ schema.Type) interface{} {
type _prototypeRepr (line 38) | type _prototypeRepr
method NewBuilder (line 40) | func (w *_prototypeRepr) NewBuilder() datamodel.NodeBuilder {
type _nodeRepr (line 48) | type _nodeRepr
method Kind (line 50) | func (w *_nodeRepr) Kind() datamodel.Kind {
method asKinded (line 119) | func (w *_nodeRepr) asKinded(stg schema.UnionRepresentation_Kinded, ki...
method LookupByString (line 134) | func (w *_nodeRepr) LookupByString(key string) (datamodel.Node, error) {
method LookupByIndex (line 162) | func (w *_nodeRepr) LookupByIndex(idx int64) (datamodel.Node, error) {
method LookupBySegment (line 206) | func (w *_nodeRepr) LookupBySegment(seg datamodel.PathSegment) (datamo...
method LookupByNode (line 225) | func (w *_nodeRepr) LookupByNode(key datamodel.Node) (datamodel.Node, ...
method MapIterator (line 248) | func (w *_nodeRepr) MapIterator() datamodel.MapIterator {
method ListIterator (line 285) | func (w *_nodeRepr) ListIterator() datamodel.ListIterator {
method lengthMinusAbsents (line 323) | func (w *_nodeRepr) lengthMinusAbsents() int64 {
method lengthMinusTrailingAbsents (line 417) | func (w *_nodeRepr) lengthMinusTrailingAbsents() int64 {
method Length (line 428) | func (w *_nodeRepr) Length() int64 {
method IsAbsent (line 448) | func (w *_nodeRepr) IsAbsent() bool {
method IsNull (line 455) | func (w *_nodeRepr) IsNull() bool {
method AsBool (line 462) | func (w *_nodeRepr) AsBool() (bool, error) {
method AsInt (line 471) | func (w *_nodeRepr) AsInt() (int64, error) {
method AsFloat (line 513) | func (w *_nodeRepr) AsFloat() (float64, error) {
method AsString (line 522) | func (w *_nodeRepr) AsString() (string, error) {
method AsBytes (line 587) | func (w *_nodeRepr) AsBytes() ([]byte, error) {
method AsLink (line 596) | func (w *_nodeRepr) AsLink() (datamodel.Link, error) {
method Prototype (line 605) | func (w *_nodeRepr) Prototype() datamodel.NodePrototype {
function outboundMappedKey (line 78) | func outboundMappedKey(stg schema.StructRepresentation_Map, key string) ...
function inboundMappedKey (line 85) | func inboundMappedKey(typ *schema.TypeStruct, stg schema.StructRepresent...
function outboundMappedType (line 97) | func outboundMappedType(stg schema.UnionRepresentation_Keyed, key string...
function inboundMappedType (line 104) | func inboundMappedType(typ *schema.TypeUnion, stg schema.UnionRepresenta...
type _mapIteratorRepr (line 271) | type _mapIteratorRepr
method Next (line 273) | func (w *_mapIteratorRepr) Next() (key, value datamodel.Node, _ error) {
method Done (line 281) | func (w *_mapIteratorRepr) Done() bool {
type _listIteratorRepr (line 309) | type _listIteratorRepr
method Next (line 311) | func (w *_listIteratorRepr) Next() (index int64, value datamodel.Node,...
method Done (line 319) | func (w *_listIteratorRepr) Done() bool {
type _tupleIteratorRepr (line 334) | type _tupleIteratorRepr struct
method Next (line 346) | func (w *_tupleIteratorRepr) Next() (index int64, value datamodel.Node...
method Done (line 359) | func (w *_tupleIteratorRepr) Done() bool {
type _listpairsIteratorRepr (line 363) | type _listpairsIteratorRepr struct
method Next (line 374) | func (w *_listpairsIteratorRepr) Next() (index int64, value datamodel....
method Done (line 395) | func (w *_listpairsIteratorRepr) Done() bool {
function buildListpairsField (line 399) | func buildListpairsField(key, value datamodel.Node) (datamodel.Node, err...
type _builderRepr (line 609) | type _builderRepr struct
method Build (line 619) | func (w *_builderRepr) Build() datamodel.Node {
method Reset (line 625) | func (w *_builderRepr) Reset() {
type _assemblerRepr (line 629) | type _assemblerRepr struct
method asKinded (line 649) | func (w *_assemblerRepr) asKinded(stg schema.UnionRepresentation_Kinde...
method BeginMap (line 684) | func (w *_assemblerRepr) BeginMap(sizeHint int64) (datamodel.MapAssemb...
method BeginList (line 706) | func (w *_assemblerRepr) BeginList(sizeHint int64) (datamodel.ListAsse...
method AssignNull (line 728) | func (w *_assemblerRepr) AssignNull() error {
method AssignBool (line 732) | func (w *_assemblerRepr) AssignBool(b bool) error {
method assignUInt (line 741) | func (w *_assemblerRepr) assignUInt(uin datamodel.UintNode) error {
method AssignInt (line 756) | func (w *_assemblerRepr) AssignInt(i int64) error {
method AssignFloat (line 796) | func (w *_assemblerRepr) AssignFloat(f float64) error {
method AssignString (line 805) | func (w *_assemblerRepr) AssignString(s string) error {
method AssignBytes (line 900) | func (w *_assemblerRepr) AssignBytes(p []byte) error {
method AssignLink (line 909) | func (w *_assemblerRepr) AssignLink(link datamodel.Link) error {
method AssignNode (line 918) | func (w *_assemblerRepr) AssignNode(node datamodel.Node) error {
method Prototype (line 926) | func (w *_assemblerRepr) Prototype() datamodel.NodePrototype {
function assemblerRepr (line 638) | func assemblerRepr(am datamodel.NodeAssembler) datamodel.NodeAssembler {
type _structAssemblerRepr (line 930) | type _structAssemblerRepr
method AssembleKey (line 932) | func (w *_structAssemblerRepr) AssembleKey() datamodel.NodeAssembler {
method AssembleValue (line 957) | func (w *_structAssemblerRepr) AssembleValue() datamodel.NodeAssembler {
method AssembleEntry (line 972) | func (w *_structAssemblerRepr) AssembleEntry(k string) (datamodel.Node...
method Finish (line 980) | func (w *_structAssemblerRepr) Finish() error {
method KeyPrototype (line 998) | func (w *_structAssemblerRepr) KeyPrototype() datamodel.NodePrototype {
method ValuePrototype (line 1002) | func (w *_structAssemblerRepr) ValuePrototype(k string) datamodel.Node...
type _mapAssemblerRepr (line 1006) | type _mapAssemblerRepr
method AssembleKey (line 1008) | func (w *_mapAssemblerRepr) AssembleKey() datamodel.NodeAssembler {
method AssembleValue (line 1013) | func (w *_mapAssemblerRepr) AssembleValue() datamodel.NodeAssembler {
method AssembleEntry (line 1018) | func (w *_mapAssemblerRepr) AssembleEntry(k string) (datamodel.NodeAss...
method Finish (line 1026) | func (w *_mapAssemblerRepr) Finish() error {
method KeyPrototype (line 1030) | func (w *_mapAssemblerRepr) KeyPrototype() datamodel.NodePrototype {
method ValuePrototype (line 1034) | func (w *_mapAssemblerRepr) ValuePrototype(k string) datamodel.NodePro...
type _listStructAssemblerRepr (line 1038) | type _listStructAssemblerRepr
method AssembleValue (line 1040) | func (w *_listStructAssemblerRepr) AssembleValue() datamodel.NodeAssem...
method Finish (line 1066) | func (w *_listStructAssemblerRepr) Finish() error {
method ValuePrototype (line 1075) | func (w *_listStructAssemblerRepr) ValuePrototype(idx int64) datamodel...
type _listpairsFieldAssemblerRepr (line 1079) | type _listpairsFieldAssemblerRepr struct
method BeginMap (line 1083) | func (w _listpairsFieldAssemblerRepr) BeginMap(int64) (datamodel.MapAs...
method BeginList (line 1091) | func (w *_listpairsFieldAssemblerRepr) BeginList(int64) (datamodel.Lis...
method AssignNull (line 1094) | func (w _listpairsFieldAssemblerRepr) AssignNull() error {
method AssignBool (line 1102) | func (w _listpairsFieldAssemblerRepr) AssignBool(bool) error {
method AssignInt (line 1110) | func (w _listpairsFieldAssemblerRepr) AssignInt(int64) error {
method AssignFloat (line 1118) | func (w _listpairsFieldAssemblerRepr) AssignFloat(float64) error {
method AssignString (line 1126) | func (w _listpairsFieldAssemblerRepr) AssignString(string) error {
method AssignBytes (line 1134) | func (w _listpairsFieldAssemblerRepr) AssignBytes([]byte) error {
method AssignLink (line 1142) | func (w _listpairsFieldAssemblerRepr) AssignLink(datamodel.Link) error {
method AssignNode (line 1151) | func (w *_listpairsFieldAssemblerRepr) AssignNode(n datamodel.Node) er...
method Prototype (line 1155) | func (w _listpairsFieldAssemblerRepr) Prototype() datamodel.NodeProtot...
type _listpairsFieldListAssemblerRepr (line 1159) | type _listpairsFieldListAssemblerRepr struct
method AssembleValue (line 1164) | func (w *_listpairsFieldListAssemblerRepr) AssembleValue() datamodel.N...
method Finish (line 1177) | func (w *_listpairsFieldListAssemblerRepr) Finish() error {
method ValuePrototype (line 1181) | func (w *_listpairsFieldListAssemblerRepr) ValuePrototype(idx int64) d...
type _listAssemblerRepr (line 1186) | type _listAssemblerRepr
method AssembleValue (line 1188) | func (w *_listAssemblerRepr) AssembleValue() datamodel.NodeAssembler {
method Finish (line 1193) | func (w *_listAssemblerRepr) Finish() error {
method ValuePrototype (line 1197) | func (w *_listAssemblerRepr) ValuePrototype(idx int64) datamodel.NodeP...
type _unionAssemblerRepr (line 1201) | type _unionAssemblerRepr
method AssembleKey (line 1203) | func (w *_unionAssemblerRepr) AssembleKey() datamodel.NodeAssembler {
method AssembleValue (line 1212) | func (w *_unionAssemblerRepr) AssembleValue() datamodel.NodeAssembler {
method AssembleEntry (line 1227) | func (w *_unionAssemblerRepr) AssembleEntry(k string) (datamodel.NodeA...
method Finish (line 1235) | func (w *_unionAssemblerRepr) Finish() error {
method KeyPrototype (line 1244) | func (w *_unionAssemblerRepr) KeyPrototype() datamodel.NodePrototype {
method ValuePrototype (line 1248) | func (w *_unionAssemblerRepr) ValuePrototype(k string) datamodel.NodeP...
type _structIteratorRepr (line 1252) | type _structIteratorRepr
method Next (line 1254) | func (w *_structIteratorRepr) Next() (key, value datamodel.Node, _ err...
method Done (line 1277) | func (w *_structIteratorRepr) Done() bool {
type _unionIteratorRepr (line 1288) | type _unionIteratorRepr
method Next (line 1290) | func (w *_unionIteratorRepr) Next() (key, value datamodel.Node, _ erro...
method Done (line 1308) | func (w *_unionIteratorRepr) Done() bool {
FILE: node/bindnode/schema_test.go
function forSchemaTest (line 16) | func forSchemaTest(name string) []tests.EngineSubtest {
function TestSchema (line 29) | func TestSchema(t *testing.T) {
type bindEngine (line 37) | type bindEngine struct
method Init (line 41) | func (e *bindEngine) Init(t *testing.T, ts schema.TypeSystem) {
method PrototypeByName (line 45) | func (e *bindEngine) PrototypeByName(name string) datamodel.NodeProtot...
FILE: node/gendemo/gen.go
function main (line 11) | func main() {
FILE: node/gendemo/gendemo_test.go
function BenchmarkMapStrInt_3n_AssembleStandard (line 9) | func BenchmarkMapStrInt_3n_AssembleStandard(b *testing.B) {
function BenchmarkMapStrInt_3n_AssembleEntry (line 12) | func BenchmarkMapStrInt_3n_AssembleEntry(b *testing.B) {
function BenchmarkMapStrInt_3n_Iteration (line 15) | func BenchmarkMapStrInt_3n_Iteration(b *testing.B) {
function BenchmarkSpec_Marshal_Map3StrInt (line 18) | func BenchmarkSpec_Marshal_Map3StrInt(b *testing.B) {
function BenchmarkSpec_Unmarshal_Map3StrInt (line 21) | func BenchmarkSpec_Unmarshal_Map3StrInt(b *testing.B) {
function BenchmarkSpec_Marshal_MapNStrMap3StrInt (line 25) | func BenchmarkSpec_Marshal_MapNStrMap3StrInt(b *testing.B) {
function BenchmarkSpec_Unmarshal_MapNStrMap3StrInt (line 28) | func BenchmarkSpec_Unmarshal_MapNStrMap3StrInt(b *testing.B) {
FILE: node/gendemo/ipldsch_minima.go
constant midvalue (line 13) | midvalue = schema.Maybe(4)
constant allowNull (line 14) | allowNull = schema.Maybe(5)
type maState (line 17) | type maState
constant maState_initial (line 20) | maState_initial maState = iota
constant maState_midKey (line 21) | maState_midKey
constant maState_expectValue (line 22) | maState_expectValue
constant maState_midValue (line 23) | maState_midValue
constant maState_finished (line 24) | maState_finished
type laState (line 27) | type laState
constant laState_initial (line 30) | laState_initial laState = iota
constant laState_midValue (line 31) | laState_midValue
constant laState_finished (line 32) | laState_finished
type _ErrorThunkAssembler (line 35) | type _ErrorThunkAssembler struct
method BeginMap (line 39) | func (ea _ErrorThunkAssembler) BeginMap(_ int64) (datamodel.MapAssembl...
method BeginList (line 40) | func (ea _ErrorThunkAssembler) BeginList(_ int64) (datamodel.ListAssem...
method AssignNull (line 41) | func (ea _ErrorThunkAssembler) AssignNull() error ...
method AssignBool (line 42) | func (ea _ErrorThunkAssembler) AssignBool(bool) error ...
method AssignInt (line 43) | func (ea _ErrorThunkAssembler) AssignInt(int64) error ...
method AssignFloat (line 44) | func (ea _ErrorThunkAssembler) AssignFloat(float64) error ...
method AssignString (line 45) | func (ea _ErrorThunkAssembler) AssignString(string) error ...
method AssignBytes (line 46) | func (ea _ErrorThunkAssembler) AssignBytes([]byte) error ...
method AssignLink (line 47) | func (ea _ErrorThunkAssembler) AssignLink(datamodel.Link) error ...
method AssignNode (line 48) | func (ea _ErrorThunkAssembler) AssignNode(datamodel.Node) error ...
method Prototype (line 49) | func (ea _ErrorThunkAssembler) Prototype() datamodel.NodePrototype {
FILE: node/gendemo/ipldsch_satisfaction.go
method Bool (line 11) | func (n Bar) Bool() bool {
type _Bar__Maybe (line 19) | type _Bar__Maybe struct
method IsNull (line 25) | func (m MaybeBar) IsNull() bool {
method IsAbsent (line 28) | func (m MaybeBar) IsAbsent() bool {
method Exists (line 31) | func (m MaybeBar) Exists() bool {
method AsNode (line 34) | func (m MaybeBar) AsNode() datamodel.Node {
method Must (line 46) | func (m MaybeBar) Must() Bar {
method Kind (line 56) | func (Bar) Kind() datamodel.Kind {
method LookupByString (line 59) | func (Bar) LookupByString(string) (datamodel.Node, error) {
method LookupByNode (line 62) | func (Bar) LookupByNode(datamodel.Node) (datamodel.Node, error) {
method LookupByIndex (line 65) | func (Bar) LookupByIndex(idx int64) (datamodel.Node, error) {
method LookupBySegment (line 68) | func (Bar) LookupBySegment(seg datamodel.PathSegment) (datamodel.Node, e...
method MapIterator (line 71) | func (Bar) MapIterator() datamodel.MapIterator {
method ListIterator (line 74) | func (Bar) ListIterator() datamodel.ListIterator {
method Length (line 77) | func (Bar) Length() int64 {
method IsAbsent (line 80) | func (Bar) IsAbsent() bool {
method IsNull (line 83) | func (Bar) IsNull() bool {
method AsBool (line 86) | func (n Bar) AsBool() (bool, error) {
method AsInt (line 89) | func (Bar) AsInt() (int64, error) {
method AsFloat (line 92) | func (Bar) AsFloat() (float64, error) {
method AsString (line 95) | func (Bar) AsString() (string, error) {
method AsBytes (line 98) | func (Bar) AsBytes() ([]byte, error) {
method AsLink (line 101) | func (Bar) AsLink() (datamodel.Link, error) {
method Prototype (line 104) | func (Bar) Prototype() datamodel.NodePrototype {
type _Bar__Prototype (line 108) | type _Bar__Prototype struct
method FromBool (line 14) | func (_Bar__Prototype) FromBool(v bool) (Bar, error) {
method NewBuilder (line 110) | func (_Bar__Prototype) NewBuilder() datamodel.NodeBuilder {
type _Bar__Builder (line 116) | type _Bar__Builder struct
method Build (line 120) | func (nb *_Bar__Builder) Build() datamodel.Node {
method Reset (line 126) | func (nb *_Bar__Builder) Reset() {
type _Bar__Assembler (line 132) | type _Bar__Assembler struct
method reset (line 137) | func (na *_Bar__Assembler) reset() {}
method BeginMap (line 138) | func (_Bar__Assembler) BeginMap(sizeHint int64) (datamodel.MapAssemble...
method BeginList (line 141) | func (_Bar__Assembler) BeginList(sizeHint int64) (datamodel.ListAssemb...
method AssignNull (line 144) | func (na *_Bar__Assembler) AssignNull() error {
method AssignBool (line 156) | func (na *_Bar__Assembler) AssignBool(v bool) error {
method AssignInt (line 165) | func (_Bar__Assembler) AssignInt(int64) error {
method AssignFloat (line 168) | func (_Bar__Assembler) AssignFloat(float64) error {
method AssignString (line 171) | func (_Bar__Assembler) AssignString(string) error {
method AssignBytes (line 174) | func (_Bar__Assembler) AssignBytes([]byte) error {
method AssignLink (line 177) | func (_Bar__Assembler) AssignLink(datamodel.Link) error {
method AssignNode (line 180) | func (na *_Bar__Assembler) AssignNode(v datamodel.Node) error {
method Prototype (line 199) | func (_Bar__Assembler) Prototype() datamodel.NodePrototype {
method Type (line 202) | func (Bar) Type() schema.Type {
method Representation (line 205) | func (n Bar) Representation() datamodel.Node {
method String (line 216) | func (n Baz) String() string {
type _Baz__Maybe (line 228) | type _Baz__Maybe struct
method IsNull (line 234) | func (m MaybeBaz) IsNull() bool {
method IsAbsent (line 237) | func (m MaybeBaz) IsAbsent() bool {
method Exists (line 240) | func (m MaybeBaz) Exists() bool {
method AsNode (line 243) | func (m MaybeBaz) AsNode() datamodel.Node {
method Must (line 255) | func (m MaybeBaz) Must() Baz {
method Kind (line 265) | func (Baz) Kind() datamodel.Kind {
method LookupByString (line 268) | func (Baz) LookupByString(string) (datamodel.Node, error) {
method LookupByNode (line 271) | func (Baz) LookupByNode(datamodel.Node) (datamodel.Node, error) {
method LookupByIndex (line 274) | func (Baz) LookupByIndex(idx int64) (datamodel.Node, error) {
method LookupBySegment (line 277) | func (Baz) LookupBySegment(seg datamodel.PathSegment) (datamodel.Node, e...
method MapIterator (line 280) | func (Baz) MapIterator() datamodel.MapIterator {
method ListIterator (line 283) | func (Baz) ListIterator() datamodel.ListIterator {
method Length (line 286) | func (Baz) Length() int64 {
method IsAbsent (line 289) | func (Baz) IsAbsent() bool {
method IsNull (line 292) | func (Baz) IsNull() bool {
method AsBool (line 295) | func (Baz) AsBool() (bool, error) {
method AsInt (line 298) | func (Baz) AsInt() (int64, error) {
method AsFloat (line 301) | func (Baz) AsFloat() (float64, error) {
method AsString (line 304) | func (n Baz) AsString() (string, error) {
method AsBytes (line 307) | func (Baz) AsBytes() ([]byte, error) {
method AsLink (line 310) | func (Baz) AsLink() (datamodel.Link, error) {
method Prototype (line 313) | func (Baz) Prototype() datamodel.NodePrototype {
type _Baz__Prototype (line 317) | type _Baz__Prototype struct
method fromString (line 219) | func (_Baz__Prototype) fromString(w *_Baz, v string) error {
method FromString (line 223) | func (_Baz__Prototype) FromString(v string) (Baz, error) {
method NewBuilder (line 319) | func (_Baz__Prototype) NewBuilder() datamodel.NodeBuilder {
type _Baz__Builder (line 325) | type _Baz__Builder struct
method Build (line 329) | func (nb *_Baz__Builder) Build() datamodel.Node {
method Reset (line 335) | func (nb *_Baz__Builder) Reset() {
type _Baz__Assembler (line 341) | type _Baz__Assembler struct
method reset (line 346) | func (na *_Baz__Assembler) reset() {}
method BeginMap (line 347) | func (_Baz__Assembler) BeginMap(sizeHint int64) (datamodel.MapAssemble...
method BeginList (line 350) | func (_Baz__Assembler) BeginList(sizeHint int64) (datamodel.ListAssemb...
method AssignNull (line 353) | func (na *_Baz__Assembler) AssignNull() error {
method AssignBool (line 365) | func (_Baz__Assembler) AssignBool(bool) error {
method AssignInt (line 368) | func (_Baz__Assembler) AssignInt(int64) error {
method AssignFloat (line 371) | func (_Baz__Assembler) AssignFloat(float64) error {
method AssignString (line 374) | func (na *_Baz__Assembler) AssignString(v string) error {
method AssignBytes (line 383) | func (_Baz__Assembler) AssignBytes([]byte) error {
method AssignLink (line 386) | func (_Baz__Assembler) AssignLink(datamodel.Link) error {
method AssignNode (line 389) | func (na *_Baz__Assembler) AssignNode(v datamodel.Node) error {
method Prototype (line 408) | func (_Baz__Assembler) Prototype() datamodel.NodePrototype {
method Type (line 411) | func (Baz) Type() schema.Type {
method Representation (line 414) | func (n Baz) Representation() datamodel.Node {
method Int (line 425) | func (n Foo) Int() int64 {
type _Foo__Maybe (line 433) | type _Foo__Maybe struct
method IsNull (line 439) | func (m MaybeFoo) IsNull() bool {
method IsAbsent (line 442) | func (m MaybeFoo) IsAbsent() bool {
method Exists (line 445) | func (m MaybeFoo) Exists() bool {
method AsNode (line 448) | func (m MaybeFoo) AsNode() datamodel.Node {
method Must (line 460) | func (m MaybeFoo) Must() Foo {
method Kind (line 470) | func (Foo) Kind() datamodel.Kind {
method LookupByString (line 473) | func (Foo) LookupByString(string) (datamodel.Node, error) {
method LookupByNode (line 476) | func (Foo) LookupByNode(datamodel.Node) (datamodel.Node, error) {
method LookupByIndex (line 479) | func (Foo) LookupByIndex(idx int64) (datamodel.Node, error) {
method LookupBySegment (line 482) | func (Foo) LookupBySegment(seg datamodel.PathSegment) (datamodel.Node, e...
method MapIterator (line 485) | func (Foo) MapIterator() datamodel.MapIterator {
method ListIterator (line 488) | func (Foo) ListIterator() datamodel.ListIterator {
method Length (line 491) | func (Foo) Length() int64 {
method IsAbsent (line 494) | func (Foo) IsAbsent() bool {
method IsNull (line 497) | func (Foo) IsNull() bool {
method AsBool (line 500) | func (Foo) AsBool() (bool, error) {
method AsInt (line 503) | func (n Foo) AsInt() (int64, error) {
method AsFloat (line 506) | func (Foo) AsFloat() (float64, error) {
method AsString (line 509) | func (Foo) AsString() (string, error) {
method AsBytes (line 512) | func (Foo) AsBytes() ([]byte, error) {
method AsLink (line 515) | func (Foo) AsLink() (datamodel.Link, error) {
method Prototype (line 518) | func (Foo) Prototype() datamodel.NodePrototype {
type _Foo__Prototype (line 522) | type _Foo__Prototype struct
method FromInt (line 428) | func (_Foo__Prototype) FromInt(v int64) (Foo, error) {
method NewBuilder (line 524) | func (_Foo__Prototype) NewBuilder() datamodel.NodeBuilder {
type _Foo__Builder (line 530) | type _Foo__Builder struct
method Build (line 534) | func (nb *_Foo__Builder) Build() datamodel.Node {
method Reset (line 540) | func (nb *_Foo__Builder) Reset() {
type _Foo__Assembler (line 546) | type _Foo__Assembler struct
method reset (line 551) | func (na *_Foo__Assembler) reset() {}
method BeginMap (line 552) | func (_Foo__Assembler) BeginMap(sizeHint int64) (datamodel.MapAssemble...
method BeginList (line 555) | func (_Foo__Assembler) BeginList(sizeHint int64) (datamodel.ListAssemb...
method AssignNull (line 558) | func (na *_Foo__Assembler) AssignNull() error {
method AssignBool (line 570) | func (_Foo__Assembler) AssignBool(bool) error {
method AssignInt (line 573) | func (na *_Foo__Assembler) AssignInt(v int64) error {
method AssignFloat (line 582) | func (_Foo__Assembler) AssignFloat(float64) error {
method AssignString (line 585) | func (_Foo__Assembler) AssignString(string) error {
method AssignBytes (line 588) | func (_Foo__Assembler) AssignBytes([]byte) error {
method AssignLink (line 591) | func (_Foo__Assembler) AssignLink(datamodel.Link) error {
method AssignNode (line 594) | func (na *_Foo__Assembler) AssignNode(v datamodel.Node) error {
method Prototype (line 613) | func (_Foo__Assembler) Prototype() datamodel.NodePrototype {
method Type (line 616) | func (Foo) Type() schema.Type {
method Representation (line 619) | func (n Foo) Representation() datamodel.Node {
method Int (line 630) | func (n Int) Int() int64 {
type _Int__Maybe (line 638) | type _Int__Maybe struct
method IsNull (line 644) | func (m MaybeInt) IsNull() bool {
method IsAbsent (line 647) | func (m MaybeInt) IsAbsent() bool {
method Exists (line 650) | func (m MaybeInt) Exists() bool {
method AsNode (line 653) | func (m MaybeInt) AsNode() datamodel.Node {
method Must (line 665) | func (m MaybeInt) Must() Int {
method Kind (line 675) | func (Int) Kind() datamodel.Kind {
method LookupByString (line 678) | func (Int) LookupByString(string) (datamodel.Node, error) {
method LookupByNode (line 681) | func (Int) LookupByNode(datamodel.Node) (datamodel.Node, error) {
method LookupByIndex (line 684) | func (Int) LookupByIndex(idx int64) (datamodel.Node, error) {
method LookupBySegment (line 687) | func (Int) LookupBySegment(seg datamodel.PathSegment) (datamodel.Node, e...
method MapIterator (line 690) | func (Int) MapIterator() datamodel.MapIterator {
method ListIterator (line 693) | func (Int) ListIterator() datamodel.ListIterator {
method Length (line 696) | func (Int) Length() int64 {
method IsAbsent (line 699) | func (Int) IsAbsent() bool {
method IsNull (line 702) | func (Int) IsNull() bool {
method AsBool (line 705) | func (Int) AsBool() (bool, error) {
method AsInt (line 708) | func (n Int) AsInt() (int64, error) {
method AsFloat (line 711) | func (Int) AsFloat() (float64, error) {
method AsString (line 714) | func (Int) AsString() (string, error) {
method AsBytes (line 717) | func (Int) AsBytes() ([]byte, error) {
method AsLink (line 720) | func (Int) AsLink() (datamodel.Link, error) {
method Prototype (line 723) | func (Int) Prototype() datamodel.NodePrototype {
type _Int__Prototype (line 727) | type _Int__Prototype struct
method FromInt (line 633) | func (_Int__Prototype) FromInt(v int64) (Int, error) {
method NewBuilder (line 729) | func (_Int__Prototype) NewBuilder() datamodel.NodeBuilder {
type _Int__Builder (line 735) | type _Int__Builder struct
method Build (line 739) | func (nb *_Int__Builder) Build() datamodel.Node {
method Reset (line 745) | func (nb *_Int__Builder) Reset() {
type _Int__Assembler (line 751) | type _Int__Assembler struct
method reset (line 756) | func (na *_Int__Assembler) reset() {}
method BeginMap (line 757) | func (_Int__Assembler) BeginMap(sizeHint int64) (datamodel.MapAssemble...
method BeginList (line 760) | func (_Int__Assembler) BeginList(sizeHint int64) (datamodel.ListAssemb...
method AssignNull (line 763) | func (na *_Int__Assembler) AssignNull() error {
method AssignBool (line 775) | func (_Int__Assembler) AssignBool(bool) error {
method AssignInt (line 778) | func (na *_Int__Assembler) AssignInt(v int64) error {
method AssignFloat (line 787) | func (_Int__Assembler) AssignFloat(float64) error {
method AssignString (line 790) | func (_Int__Assembler) AssignString(string) error {
method AssignBytes (line 793) | func (_Int__Assembler) AssignBytes([]byte) error {
method AssignLink (line 796) | func (_Int__Assembler) AssignLink(datamodel.Link) error {
method AssignNode (line 799) | func (na *_Int__Assembler) AssignNode(v datamodel.Node) error {
method Prototype (line 818) | func (_Int__Assembler) Prototype() datamodel.NodePrototype {
method Type (line 821) | func (Int) Type() schema.Type {
method Representation (line 824) | func (n Int) Representation() datamodel.Node {
method Lookup (line 835) | func (n *_Map__String__Msg3) Lookup(k String) Msg3 {
method LookupMaybe (line 842) | func (n *_Map__String__Msg3) LookupMaybe(k String) MaybeMsg3 {
method Iterator (line 855) | func (n Map__String__Msg3) Iterator() *Map__String__Msg3__Itr {
type Map__String__Msg3__Itr (line 859) | type Map__String__Msg3__Itr struct
method Next (line 864) | func (itr *Map__String__Msg3__Itr) Next() (k String, v Msg3) {
method Done (line 874) | func (itr *Map__String__Msg3__Itr) Done() bool {
type _Map__String__Msg3__Maybe (line 878) | type _Map__String__Msg3__Maybe struct
method IsNull (line 884) | func (m MaybeMap__String__Msg3) IsNull() bool {
method IsAbsent (line 887) | func (m MaybeMap__String__Msg3) IsAbsent() bool {
method Exists (line 890) | func (m MaybeMap__String__Msg3) Exists() bool {
method AsNode (line 893) | func (m MaybeMap__String__Msg3) AsNode() datamodel.Node {
method Must (line 905) | func (m MaybeMap__String__Msg3) Must() Map__String__Msg3 {
method Kind (line 915) | func (Map__String__Msg3) Kind() datamodel.Kind {
method LookupByString (line 918) | func (n Map__String__Msg3) LookupByString(k string) (datamodel.Node, err...
method LookupByNode (line 929) | func (n Map__String__Msg3) LookupByNode(k datamodel.Node) (datamodel.Nod...
method LookupByIndex (line 941) | func (Map__String__Msg3) LookupByIndex(idx int64) (datamodel.Node, error) {
method LookupBySegment (line 944) | func (n Map__String__Msg3) LookupBySegment(seg datamodel.PathSegment) (d...
method MapIterator (line 947) | func (n Map__String__Msg3) MapIterator() datamodel.MapIterator {
type _Map__String__Msg3__MapItr (line 951) | type _Map__String__Msg3__MapItr struct
method Next (line 956) | func (itr *_Map__String__Msg3__MapItr) Next() (k datamodel.Node, v dat...
method Done (line 966) | func (itr *_Map__String__Msg3__MapItr) Done() bool {
method ListIterator (line 970) | func (Map__String__Msg3) ListIterator() datamodel.ListIterator {
method Length (line 973) | func (n Map__String__Msg3) Length() int64 {
method IsAbsent (line 976) | func (Map__String__Msg3) IsAbsent() bool {
method IsNull (line 979) | func (Map__String__Msg3) IsNull() bool {
method AsBool (line 982) | func (Map__String__Msg3) AsBool() (bool, error) {
method AsInt (line 985) | func (Map__String__Msg3) AsInt() (int64, error) {
method AsFloat (line 988) | func (Map__String__Msg3) AsFloat() (float64, error) {
method AsString (line 991) | func (Map__String__Msg3) AsString() (string, error) {
method AsBytes (line 994) | func (Map__String__Msg3) AsBytes() ([]byte, error) {
method AsLink (line 997) | func (Map__String__Msg3) AsLink() (datamodel.Link, error) {
method Prototype (line 1000) | func (Map__String__Msg3) Prototype() datamodel.NodePrototype {
type _Map__String__Msg3__Prototype (line 1004) | type _Map__String__Msg3__Prototype struct
method NewBuilder (line 1006) | func (_Map__String__Msg3__Prototype) NewBuilder() datamodel.NodeBuilder {
type _Map__String__Msg3__Builder (line 1012) | type _Map__String__Msg3__Builder struct
method Build (line 1016) | func (nb *_Map__String__Msg3__Builder) Build() datamodel.Node {
method Reset (line 1022) | func (nb *_Map__String__Msg3__Builder) Reset() {
type _Map__String__Msg3__Assembler (line 1028) | type _Map__String__Msg3__Assembler struct
method reset (line 1038) | func (na *_Map__String__Msg3__Assembler) reset() {
method BeginMap (line 1043) | func (na *_Map__String__Msg3__Assembler) BeginMap(sizeHint int64) (dat...
method BeginList (line 1058) | func (_Map__String__Msg3__Assembler) BeginList(sizeHint int64) (datamo...
method AssignNull (line 1061) | func (na *_Map__String__Msg3__Assembler) AssignNull() error {
method AssignBool (line 1075) | func (_Map__String__Msg3__Assembler) AssignBool(bool) error {
method AssignInt (line 1078) | func (_Map__String__Msg3__Assembler) AssignInt(int64) error {
method AssignFloat (line 1081) | func (_Map__String__Msg3__Assembler) AssignFloat(float64) error {
method AssignString (line 1084) | func (_Map__String__Msg3__Assembler) AssignString(string) error {
method AssignBytes (line 1087) | func (_Map__String__Msg3__Assembler) AssignBytes([]byte) error {
method AssignLink (line 1090) | func (_Map__String__Msg3__Assembler) AssignLink(datamodel.Link) error {
method AssignNode (line 1093) | func (na *_Map__String__Msg3__Assembler) AssignNode(v datamodel.Node) ...
method Prototype (line 1126) | func (_Map__String__Msg3__Assembler) Prototype() datamodel.NodePrototy...
method keyFinishTidy (line 1129) | func (ma *_Map__String__Msg3__Assembler) keyFinishTidy() bool {
method valueFinishTidy (line 1145) | func (ma *_Map__String__Msg3__Assembler) valueFinishTidy() bool {
method AssembleEntry (line 1157) | func (ma *_Map__String__Msg3__Assembler) AssembleEntry(k string) (data...
method AssembleKey (line 1189) | func (ma *_Map__String__Msg3__Assembler) AssembleKey() datamodel.NodeA...
method AssembleValue (line 1210) | func (ma *_Map__String__Msg3__Assembler) AssembleValue() datamodel.Nod...
method Finish (line 1228) | func (ma *_Map__String__Msg3__Assembler) Finish() error {
method KeyPrototype (line 1247) | func (ma *_Map__String__Msg3__Assembler) KeyPrototype() datamodel.Node...
method ValuePrototype (line 1250) | func (ma *_Map__String__Msg3__Assembler) ValuePrototype(_ string) data...
method Type (line 1253) | func (Map__String__Msg3) Type() schema.Type {
method Representation (line 1256) | func (n Map__String__Msg3) Representation() datamodel.Node {
type _Map__String__Msg3__Repr (line 1260) | type _Map__String__Msg3__Repr
method Kind (line 1264) | func (_Map__String__Msg3__Repr) Kind() datamodel.Kind {
method LookupByString (line 1267) | func (nr *_Map__String__Msg3__Repr) LookupByString(k string) (datamode...
method LookupByNode (line 1274) | func (nr *_Map__String__Msg3__Repr) LookupByNode(k datamodel.Node) (da...
method LookupByIndex (line 1281) | func (_Map__String__Msg3__Repr) LookupByIndex(idx int64) (datamodel.No...
method LookupBySegment (line 1284) | func (n _Map__String__Msg3__Repr) LookupBySegment(seg datamodel.PathSe...
method MapIterator (line 1287) | func (nr *_Map__String__Msg3__Repr) MapIterator() datamodel.MapIterator {
method ListIterator (line 1304) | func (_Map__String__Msg3__Repr) ListIterator() datamodel.ListIterator {
method Length (line 1307) | func (rn *_Map__String__Msg3__Repr) Length() int64 {
method IsAbsent (line 1310) | func (_Map__String__Msg3__Repr) IsAbsent() bool {
method IsNull (line 1313) | func (_Map__String__Msg3__Repr) IsNull() bool {
method AsBool (line 1316) | func (_Map__String__Msg3__Repr) AsBool() (bool, error) {
method AsInt (line 1319) | func (_Map__String__Msg3__Repr) AsInt() (int64, error) {
method AsFloat (line 1322) | func (_Map__String__Msg3__Repr) AsFloat() (float64, error) {
method AsString (line 1325) | func (_Map__String__Msg3__Repr) AsString() (string, error) {
method AsBytes (line 1328) | func (_Map__String__Msg3__Repr) AsBytes() ([]byte, error) {
method AsLink (line 1331) | func (_Map__String__Msg3__Repr) AsLink() (datamodel.Link, error) {
method Prototype (line 1334) | func (_Map__String__Msg3__Repr) Prototype() datamodel.NodePrototype {
type _Map__String__Msg3__ReprMapItr (line 1291) | type _Map__String__Msg3__ReprMapItr
method Next (line 1293) | func (itr *_Map__String__Msg3__ReprMapItr) Next() (k datamodel.Node, v...
method Done (line 1300) | func (itr *_Map__String__Msg3__ReprMapItr) Done() bool {
type _Map__String__Msg3__ReprPrototype (line 1338) | type _Map__String__Msg3__ReprPrototype struct
method NewBuilder (line 1340) | func (_Map__String__Msg3__ReprPrototype) NewBuilder() datamodel.NodeBu...
type _Map__String__Msg3__ReprBuilder (line 1346) | type _Map__String__Msg3__ReprBuilder struct
method Build (line 1350) | func (nb *_Map__String__Msg3__ReprBuilder) Build() datamodel.Node {
method Reset (line 1356) | func (nb *_Map__String__Msg3__ReprBuilder) Reset() {
type _Map__String__Msg3__ReprAssembler (line 1362) | type _Map__String__Msg3__ReprAssembler struct
method reset (line 1372) | func (na *_Map__String__Msg3__ReprAssembler) reset() {
method BeginMap (line 1377) | func (na *_Map__String__Msg3__ReprAssembler) BeginMap(sizeHint int64) ...
method BeginList (line 1392) | func (_Map__String__Msg3__ReprAssembler) BeginList(sizeHint int64) (da...
method AssignNull (line 1395) | func (na *_Map__String__Msg3__ReprAssembler) AssignNull() error {
method AssignBool (line 1409) | func (_Map__String__Msg3__ReprAssembler) AssignBool(bool) error {
method AssignInt (line 1412) | func (_Map__String__Msg3__ReprAssembler) AssignInt(int64) error {
method AssignFloat (line 1415) | func (_Map__String__Msg3__ReprAssembler) AssignFloat(float64) error {
method AssignString (line 1418) | func (_Map__String__Msg3__ReprAssembler) AssignString(string) error {
method AssignBytes (line 1421) | func (_Map__String__Msg3__ReprAssembler) AssignBytes([]byte) error {
method AssignLink (line 1424) | func (_Map__String__Msg3__ReprAssembler) AssignLink(datamodel.Link) er...
method AssignNode (line 1427) | func (na *_Map__String__Msg3__ReprAssembler) AssignNode(v datamodel.No...
method Prototype (line 1460) | func (_Map__String__Msg3__ReprAssembler) Prototype() datamodel.NodePro...
method keyFinishTidy (line 1463) | func (ma *_Map__String__Msg3__ReprAssembler) keyFinishTidy() bool {
method valueFinishTidy (line 1479) | func (ma *_Map__String__Msg3__ReprAssembler) valueFinishTidy() bool {
method AssembleEntry (line 1491) | func (ma *_Map__String__Msg3__ReprAssembler) AssembleEntry(k string) (...
method AssembleKey (line 1523) | func (ma *_Map__String__Msg3__ReprAssembler) AssembleKey() datamodel.N...
method AssembleValue (line 1544) | func (ma *_Map__String__Msg3__ReprAssembler) AssembleValue() datamodel...
method Finish (line 1562) | func (ma *_Map__String__Msg3__ReprAssembler) Finish() error {
method KeyPrototype (line 1581) | func (ma *_Map__String__Msg3__ReprAssembler) KeyPrototype() datamodel....
method ValuePrototype (line 1584) | func (ma *_Map__String__Msg3__ReprAssembler) ValuePrototype(_ string) ...
method FieldWhee (line 1588) | func (n _Msg3) FieldWhee() Int {
method FieldWoot (line 1591) | func (n _Msg3) FieldWoot() Int {
method FieldWaga (line 1594) | func (n _Msg3) FieldWaga() Int {
type _Msg3__Maybe (line 1598) | type _Msg3__Maybe struct
method IsNull (line 1604) | func (m MaybeMsg3) IsNull() bool {
method IsAbsent (line 1607) | func (m MaybeMsg3) IsAbsent() bool {
method Exists (line 1610) | func (m MaybeMsg3) Exists() bool {
method AsNode (line 1613) | func (m MaybeMsg3) AsNode() datamodel.Node {
method Must (line 1625) | func (m MaybeMsg3) Must() Msg3 {
method Kind (line 1640) | func (Msg3) Kind() datamodel.Kind {
method LookupByString (line 1643) | func (n Msg3) LookupByString(key string) (datamodel.Node, error) {
method LookupByNode (line 1655) | func (n Msg3) LookupByNode(key datamodel.Node) (datamodel.Node, error) {
method LookupByIndex (line 1662) | func (Msg3) LookupByIndex(idx int64) (datamodel.Node, error) {
method LookupBySegment (line 1665) | func (n Msg3) LookupBySegment(seg datamodel.PathSegment) (datamodel.Node...
method MapIterator (line 1668) | func (n Msg3) MapIterator() datamodel.MapIterator {
type _Msg3__MapItr (line 1672) | type _Msg3__MapItr struct
method Next (line 1677) | func (itr *_Msg3__MapItr) Next() (k datamodel.Node, v datamodel.Node, ...
method Done (line 1697) | func (itr *_Msg3__MapItr) Done() bool {
method ListIterator (line 1701) | func (Msg3) ListIterator() datamodel.ListIterator {
method Length (line 1704) | func (Msg3) Length() int64 {
method IsAbsent (line 1707) | func (Msg3) IsAbsent() bool {
method IsNull (line 1710) | func (Msg3) IsNull() bool {
method AsBool (line 1713) | func (Msg3) AsBool() (bool, error) {
method AsInt (line 1716) | func (Msg3) AsInt() (int64, error) {
method AsFloat (line 1719) | func (Msg3) AsFloat() (float64, error) {
method AsString (line 1722) | func (Msg3) AsString() (string, error) {
method AsBytes (line 1725) | func (Msg3) AsBytes() ([]byte, error) {
method AsLink (line 1728) | func (Msg3) AsLink() (datamodel.Link, error) {
method Prototype (line 1731) | func (Msg3) Prototype() datamodel.NodePrototype {
type _Msg3__Prototype (line 1735) | type _Msg3__Prototype struct
method NewBuilder (line 1737) | func (_Msg3__Prototype) NewBuilder() datamodel.NodeBuilder {
type _Msg3__Builder (line 1743) | type _Msg3__Builder struct
method Build (line 1747) | func (nb *_Msg3__Builder) Build() datamodel.Node {
method Reset (line 1753) | func (nb *_Msg3__Builder) Reset() {
type _Msg3__Assembler (line 1759) | type _Msg3__Assembler struct
method reset (line 1772) | func (na *_Msg3__Assembler) reset() {
method BeginMap (line 1787) | func (na *_Msg3__Assembler) BeginMap(int64) (datamodel.MapAssembler, e...
method BeginList (line 1800) | func (_Msg3__Assembler) BeginList(sizeHint int64) (datamodel.ListAssem...
method AssignNull (line 1803) | func (na *_Msg3__Assembler) AssignNull() error {
method AssignBool (line 1817) | func (_Msg3__Assembler) AssignBool(bool) error {
method AssignInt (line 1820) | func (_Msg3__Assembler) AssignInt(int64) error {
method AssignFloat (line 1823) | func (_Msg3__Assembler) AssignFloat(float64) error {
method AssignString (line 1826) | func (_Msg3__Assembler) AssignString(string) error {
method AssignBytes (line 1829) | func (_Msg3__Assembler) AssignBytes([]byte) error {
method AssignLink (line 1832) | func (_Msg3__Assembler) AssignLink(datamodel.Link) error {
method AssignNode (line 1835) | func (na *_Msg3__Assembler) AssignNode(v datamodel.Node) error {
method Prototype (line 1873) | func (_Msg3__Assembler) Prototype() datamodel.NodePrototype {
method valueFinishTidy (line 1876) | func (ma *_Msg3__Assembler) valueFinishTidy() bool {
method AssembleEntry (line 1912) | func (ma *_Msg3__Assembler) AssembleEntry(k string) (datamodel.NodeAss...
method AssembleKey (line 1961) | func (ma *_Msg3__Assembler) AssembleKey() datamodel.NodeAssembler {
method AssembleValue (line 1979) | func (ma *_Msg3__Assembler) AssembleValue() datamodel.NodeAssembler {
method Finish (line 2010) | func (ma *_Msg3__Assembler) Finish() error {
method KeyPrototype (line 2042) | func (ma *_Msg3__Assembler) KeyPrototype() datamodel.NodePrototype {
method ValuePrototype (line 2045) | func (ma *_Msg3__Assembler) ValuePrototype(k string) datamodel.NodePro...
type _Msg3__KeyAssembler (line 2049) | type _Msg3__KeyAssembler
method BeginMap (line 2051) | func (_Msg3__KeyAssembler) BeginMap(sizeHint int64) (datamodel.MapAsse...
method BeginList (line 2054) | func (_Msg3__KeyAssembler) BeginList(sizeHint int64) (datamodel.ListAs...
method AssignNull (line 2057) | func (na *_Msg3__KeyAssembler) AssignNull() error {
method AssignBool (line 2060) | func (_Msg3__KeyAssembler) AssignBool(bool) error {
method AssignInt (line 2063) | func (_Msg3__KeyAssembler) AssignInt(int64) error {
method AssignFloat (line 2066) | func (_Msg3__KeyAssembler) AssignFloat(float64) error {
method AssignString (line 2069) | func (ka *_Msg3__KeyAssembler) AssignString(k string) error {
method AssignBytes (line 2102) | func (_Msg3__KeyAssembler) AssignBytes([]byte) error {
method AssignLink (line 2105) | func (_Msg3__KeyAssembler) AssignLink(datamodel.Link) error {
method AssignNode (line 2108) | func (ka *_Msg3__KeyAssembler) AssignNode(v datamodel.Node) error {
method Prototype (line 2115) | func (_Msg3__KeyAssembler) Prototype() datamodel.NodePrototype {
method Type (line 2118) | func (Msg3) Type() schema.Type {
method Representation (line 2121) | func (n Msg3) Representation() datamodel.Node {
type _Msg3__Repr (line 2125) | type _Msg3__Repr
method Kind (line 2134) | func (_Msg3__Repr) Kind() datamodel.Kind {
method LookupByString (line 2137) | func (n *_Msg3__Repr) LookupByString(key string) (datamodel.Node, erro...
method LookupByNode (line 2149) | func (n *_Msg3__Repr) LookupByNode(key datamodel.Node) (datamodel.Node...
method LookupByIndex (line 2156) | func (_Msg3__Repr) LookupByIndex(idx int64) (datamodel.Node, error) {
method LookupBySegment (line 2159) | func (n _Msg3__Repr) LookupBySegment(seg datamodel.PathSegment) (datam...
method MapIterator (line 2162) | func (n *_Msg3__Repr) MapIterator() datamodel.MapIterator {
method ListIterator (line 2194) | func (_Msg3__Repr) ListIterator() datamodel.ListIterator {
method Length (line 2197) | func (rn *_Msg3__Repr) Length() int64 {
method IsAbsent (line 2201) | func (_Msg3__Repr) IsAbsent() bool {
method IsNull (line 2204) | func (_Msg3__Repr) IsNull() bool {
method AsBool (line 2207) | func (_Msg3__Repr) AsBool() (bool, error) {
method AsInt (line 2210) | func (_Msg3__Repr) AsInt() (int64, error) {
method AsFloat (line 2213) | func (_Msg3__Repr) AsFloat() (float64, error) {
method AsString (line 2216) | func (_Msg3__Repr) AsString() (string, error) {
method AsBytes (line 2219) | func (_Msg3__Repr) AsBytes() ([]byte, error) {
method AsLink (line 2222) | func (_Msg3__Repr) AsLink() (datamodel.Link, error) {
method Prototype (line 2225) | func (_Msg3__Repr) Prototype() datamodel.NodePrototype {
type _Msg3__ReprMapItr (line 2166) | type _Msg3__ReprMapItr struct
method Next (line 2171) | func (itr *_Msg3__ReprMapItr) Next() (k datamodel.Node, v datamodel.No...
method Done (line 2191) | func (itr *_Msg3__ReprMapItr) Done() bool {
type _Msg3__ReprPrototype (line 2229) | type _Msg3__ReprPrototype struct
method NewBuilder (line 2231) | func (_Msg3__ReprPrototype) NewBuilder() datamodel.NodeBuilder {
type _Msg3__ReprBuilder (line 2237) | type _Msg3__ReprBuilder struct
method Build (line 2241) | func (nb *_Msg3__ReprBuilder) Build() datamodel.Node {
method Reset (line 2247) | func (nb *_Msg3__ReprBuilder) Reset() {
type _Msg3__ReprAssembler (line 2253) | type _Msg3__ReprAssembler struct
method reset (line 2266) | func (na *_Msg3__ReprAssembler) reset() {
method BeginMap (line 2273) | func (na *_Msg3__ReprAssembler) BeginMap(int64) (datamodel.MapAssemble...
method BeginList (line 2286) | func (_Msg3__ReprAssembler) BeginList(sizeHint int64) (datamodel.ListA...
method AssignNull (line 2289) | func (na *_Msg3__ReprAssembler) AssignNull() error {
method AssignBool (line 2303) | func (_Msg3__ReprAssembler) AssignBool(bool) error {
method AssignInt (line 2306) | func (_Msg3__ReprAssembler) AssignInt(int64) error {
method AssignFloat (line 2309) | func (_Msg3__ReprAssembler) AssignFloat(float64) error {
method AssignString (line 2312) | func (_Msg3__ReprAssembler) AssignString(string) error {
method AssignBytes (line 2315) | func (_Msg3__ReprAssembler) AssignBytes([]byte) error {
method AssignLink (line 2318) | func (_Msg3__ReprAssembler) AssignLink(datamodel.Link) error {
method AssignNode (line 2321) | func (na *_Msg3__ReprAssembler) AssignNode(v datamodel.Node) error {
method Prototype (line 2359) | func (_Msg3__ReprAssembler) Prototype() datamodel.NodePrototype {
method valueFinishTidy (line 2362) | func (ma *_Msg3__ReprAssembler) valueFinishTidy() bool {
method AssembleEntry (line 2395) | func (ma *_Msg3__ReprAssembler) AssembleEntry(k string) (datamodel.Nod...
method AssembleKey (line 2445) | func (ma *_Msg3__ReprAssembler) AssembleKey() datamodel.NodeAssembler {
method AssembleValue (line 2463) | func (ma *_Msg3__ReprAssembler) AssembleValue() datamodel.NodeAssembler {
method Finish (line 2494) | func (ma *_Msg3__ReprAssembler) Finish() error {
method KeyPrototype (line 2526) | func (ma *_Msg3__ReprAssembler) KeyPrototype() datamodel.NodePrototype {
method ValuePrototype (line 2529) | func (ma *_Msg3__ReprAssembler) ValuePrototype(k string) datamodel.Nod...
type _Msg3__ReprKeyAssembler (line 2533) | type _Msg3__ReprKeyAssembler
method BeginMap (line 2535) | func (_Msg3__ReprKeyAssembler) BeginMap(sizeHint int64) (datamodel.Map...
method BeginList (line 2538) | func (_Msg3__ReprKeyAssembler) BeginList(sizeHint int64) (datamodel.Li...
method AssignNull (line 2541) | func (na *_Msg3__ReprKeyAssembler) AssignNull() error {
method AssignBool (line 2544) | func (_Msg3__ReprKeyAssembler) AssignBool(bool) error {
method AssignInt (line 2547) | func (_Msg3__ReprKeyAssembler) AssignInt(int64) error {
method AssignFloat (line 2550) | func (_Msg3__ReprKeyAssembler) AssignFloat(float64) error {
method AssignString (line 2553) | func (ka *_Msg3__ReprKeyAssembler) AssignString(k string) error {
method AssignBytes (line 2585) | func (_Msg3__ReprKeyAssembler) AssignBytes([]byte) error {
method AssignLink (line 2588) | func (_Msg3__ReprKeyAssembler) AssignLink(datamodel.Link) error {
method AssignNode (line 2591) | func (ka *_Msg3__ReprKeyAssembler) AssignNode(v datamodel.Node) error {
method Prototype (line 2598) | func (_Msg3__ReprKeyAssembler) Prototype() datamodel.NodePrototype {
method String (line 2602) | func (n String) String() string {
type _String__Maybe (line 2614) | type _String__Maybe struct
method IsNull (line 2620) | func (m MaybeString) IsNull() bool {
method IsAbsent (line 2623) | func (m MaybeString) IsAbsent() bool {
method Exists (line 2626) | func (m MaybeString) Exists() bool {
method AsNode (line 2629) | func (m MaybeString) AsNode() datamodel.Node {
method Must (line 2641) | func (m MaybeString) Must() String {
method Kind (line 2651) | func (String) Kind() datamodel.Kind {
method LookupByString (line 2654) | func (String) LookupByString(string) (datamodel.Node, error) {
method LookupByNode (line 2657) | func (String) LookupByNode(datamodel.Node) (datamodel.Node, error) {
method LookupByIndex (line 2660) | func (String) LookupByIndex(idx int64) (datamodel.Node, error) {
method LookupBySegment (line 2663) | func (String) LookupBySegment(seg datamodel.PathSegment) (datamodel.Node...
method MapIterator (line 2666) | func (String) MapIterator() datamodel.MapIterator {
method ListIterator (line 2669) | func (String) ListIterator() datamodel.ListIterator {
method Length (line 2672) | func (String) Length() int64 {
method IsAbsent (line 2675) | func (String) IsAbsent() bool {
method IsNull (line 2678) | func (String) IsNull() bool {
method AsBool (line 2681) | func (String) AsBool() (bool, error) {
method AsInt (line 2684) | func (String) AsInt() (int64, error) {
method AsFloat (line 2687) | func (String) AsFloat() (float64, error) {
method AsString (line 2690) | func (n String) AsString() (string, error) {
method AsBytes (line 2693) | func (String) AsBytes() ([]byte, error) {
method AsLink (line 2696) | func (String) AsLink() (datamodel.Link, error) {
method Prototype (line 2699) | func (String) Prototype() datamodel.NodePrototype {
type _String__Prototype (line 2703) | type _String__Prototype struct
method fromString (line 2605) | func (_String__Prototype) fromString(w *_String, v string) error {
method FromString (line 2609) | func (_String__Prototype) FromString(v string) (String, error) {
method NewBuilder (line 2705) | func (_String__Prototype) NewBuilder() datamodel.NodeBuilder {
type _String__Builder (line 2711) | type _String__Builder struct
method Build (line 2715) | func (nb *_String__Builder) Build() datamodel.Node {
method Reset (line 2721) | func (nb *_String__Builder) Reset() {
type _String__Assembler (line 2727) | type _String__Assembler struct
method reset (line 2732) | func (na *_String__Assembler) reset() {}
method BeginMap (line 2733) | func (_String__Assembler) BeginMap(sizeHint int64) (datamodel.MapAssem...
method BeginList (line 2736) | func (_String__Assembler) BeginList(sizeHint int64) (datamodel.ListAss...
method AssignNull (line 2739) | func (na *_String__Assembler) AssignNull() error {
method AssignBool (line 2751) | func (_String__Assembler) AssignBool(bool) error {
method AssignInt (line 2754) | func (_String__Assembler) AssignInt(int64) error {
method AssignFloat (line 2757) | func (_String__Assembler) AssignFloat(float64) error {
method AssignString (line 2760) | func (na *_String__Assembler) AssignString(v string) error {
method AssignBytes (line 2769) | func (_String__Assembler) AssignBytes([]byte) error {
method AssignLink (line 2772) | func (_String__Assembler) AssignLink(datamodel.Link) error {
method AssignNode (line 2775) | func (na *_String__Assembler) AssignNode(v datamodel.Node) error {
method Prototype (line 2794) | func (_String__Assembler) Prototype() datamodel.NodePrototype {
method Type (line 2797) | func (String) Type() schema.Type {
method Representation (line 2800) | func (n String) Representation() datamodel.Node {
method AsInterface (line 2811) | func (n _UnionKinded) AsInterface() _UnionKinded__iface {
type _UnionKinded__Maybe (line 2824) | type _UnionKinded__Maybe struct
method IsNull (line 2830) | func (m MaybeUnionKinded) IsNull() bool {
method IsAbsent (line 2833) | func (m MaybeUnionKinded) IsAbsent() bool {
method Exists (line 2836) | func (m MaybeUnionKinded) Exists() bool {
method AsNode (line 2839) | func (m MaybeUnionKinded) AsNode() datamodel.Node {
method Must (line 2851) | func (m MaybeUnionKinded) Must() UnionKinded {
method Kind (line 2866) | func (UnionKinded) Kind() datamodel.Kind {
method LookupByString (line 2869) | func (n UnionKinded) LookupByString(key string) (datamodel.Node, error) {
method LookupByNode (line 2890) | func (n UnionKinded) LookupByNode(key datamodel.Node) (datamodel.Node, e...
method LookupByIndex (line 2897) | func (UnionKinded) LookupByIndex(idx int64) (datamodel.Node, error) {
method LookupBySegment (line 2900) | func (n UnionKinded) LookupBySegment(seg datamodel.PathSegment) (datamod...
method MapIterator (line 2903) | func (n UnionKinded) MapIterator() datamodel.MapIterator {
type _UnionKinded__MapItr (line 2907) | type _UnionKinded__MapItr struct
method Next (line 2912) | func (itr *_UnionKinded__MapItr) Next() (k datamodel.Node, v datamodel...
method Done (line 2929) | func (itr *_UnionKinded__MapItr) Done() bool {
method ListIterator (line 2933) | func (UnionKinded) ListIterator() datamodel.ListIterator {
method Length (line 2936) | func (UnionKinded) Length() int64 {
method IsAbsent (line 2939) | func (UnionKinded) IsAbsent() bool {
method IsNull (line 2942) | func (UnionKinded) IsNull() bool {
method AsBool (line 2945) | func (UnionKinded) AsBool() (bool, error) {
method AsInt (line 2948) | func (UnionKinded) AsInt() (int64, error) {
method AsFloat (line 2951) | func (UnionKinded) AsFloat() (float64, error) {
method AsString (line 2954) | func (UnionKinded) AsString() (string, error) {
method AsBytes (line 2957) | func (UnionKinded) AsBytes() ([]byte, error) {
method AsLink (line 2960) | func (UnionKinded) AsLink() (datamodel.Link, error) {
method Prototype (line 2963) | func (UnionKinded) Prototype() datamodel.NodePrototype {
type _UnionKinded__Prototype (line 2967) | type _UnionKinded__Prototype struct
method NewBuilder (line 2969) | func (_UnionKinded__Prototype) NewBuilder() datamodel.NodeBuilder {
type _UnionKinded__Builder (line 2975) | type _UnionKinded__Builder struct
method Build (line 2979) | func (nb *_UnionKinded__Builder) Build() datamodel.Node {
method Reset (line 2985) | func (nb *_UnionKinded__Builder) Reset() {
type _UnionKinded__Assembler (line 2991) | type _UnionKinded__Assembler struct
method reset (line 3005) | func (na *_UnionKinded__Assembler) reset() {
method BeginMap (line 3024) | func (na *_UnionKinded__Assembler) BeginMap(int64) (datamodel.MapAssem...
method BeginList (line 3037) | func (_UnionKinded__Assembler) BeginList(sizeHint int64) (datamodel.Li...
method AssignNull (line 3040) | func (na *_UnionKinded__Assembler) AssignNull() error {
method AssignBool (line 3054) | func (_UnionKinded__Assembler) AssignBool(bool) error {
method AssignInt (line 3057) | func (_UnionKinded__Assembler) AssignInt(int64) error {
method AssignFloat (line 3060) | func (_UnionKinded__Assembler) AssignFloat(float64) error {
method AssignString (line 3063) | func (_UnionKinded__Assembler) AssignString(string) error {
method AssignBytes (line 3066) | func (_UnionKinded__Assembler) AssignBytes([]byte) error {
method AssignLink (line 3069) | func (_UnionKinded__Assembler) AssignLink(datamodel.Link) error {
method AssignNode (line 3072) | func (na *_UnionKinded__Assembler) AssignNode(v datamodel.Node) error {
method Prototype (line 3110) | func (_UnionKinded__Assembler) Prototype() datamodel.NodePrototype {
method valueFinishTidy (line 3113) | func (ma *_UnionKinded__Assembler) valueFinishTidy() bool {
method AssembleEntry (line 3122) | func (ma *_UnionKinded__Assembler) AssembleEntry(k string) (datamodel....
method AssembleKey (line 3165) | func (ma *_UnionKinded__Assembler) AssembleKey() datamodel.NodeAssembl...
method AssembleValue (line 3183) | func (ma *_UnionKinded__Assembler) AssembleValue() datamodel.NodeAssem...
method Finish (line 3214) | func (ma *_UnionKinded__Assembler) Finish() error {
method KeyPrototype (line 3236) | func (ma *_UnionKinded__Assembler) KeyPrototype() datamodel.NodeProtot...
method ValuePrototype (line 3239) | func (ma *_UnionKinded__Assembler) ValuePrototype(k string) datamodel....
type _UnionKinded__KeyAssembler (line 3252) | type _UnionKinded__KeyAssembler
method BeginMap (line 3254) | func (_UnionKinded__KeyAssembler) BeginMap(sizeHint int64) (datamodel....
method BeginList (line 3257) | func (_UnionKinded__KeyAssembler) BeginList(sizeHint int64) (datamodel...
method AssignNull (line 3260) | func (na *_UnionKinded__KeyAssembler) AssignNull() error {
method AssignBool (line 3263) | func (_UnionKinded__KeyAssembler) AssignBool(bool) error {
method AssignInt (line 3266) | func (_UnionKinded__KeyAssembler) AssignInt(int64) error {
method AssignFloat (line 3269) | func (_UnionKinded__KeyAssembler) AssignFloat(float64) error {
method AssignString (line 3272) | func (ka *_UnionKinded__KeyAssembler) AssignString(k string) error {
method AssignBytes (line 3298) | func (_UnionKinded__KeyAssembler) AssignBytes([]byte) error {
method AssignLink (line 3301) | func (_UnionKinded__KeyAssembler) AssignLink(datamodel.Link) error {
method AssignNode (line 3304) | func (ka *_UnionKinded__KeyAssembler) AssignNode(v datamodel.Node) err...
method Prototype (line 3311) | func (_UnionKinded__KeyAssembler) Prototype() datamodel.NodePrototype {
method Type (line 3314) | func (UnionKinded) Type() schema.Type {
method Representation (line 3317) | func (n UnionKinded) Representation() datamodel.Node {
type _UnionKinded__Repr (line 3321) | type _UnionKinded__Repr
method Kind (line 3325) | func (n *_UnionKinded__Repr) Kind() datamodel.Kind {
method LookupByString (line 3337) | func (n *_UnionKinded__Repr) LookupByString(key string) (datamodel.Nod...
method LookupByNode (line 3340) | func (n *_UnionKinded__Repr) LookupByNode(key datamodel.Node) (datamod...
method LookupByIndex (line 3343) | func (n *_UnionKinded__Repr) LookupByIndex(idx int64) (datamodel.Node,...
method LookupBySegment (line 3346) | func (n *_UnionKinded__Repr) LookupBySegment(seg datamodel.PathSegment...
method MapIterator (line 3349) | func (n *_UnionKinded__Repr) MapIterator() datamodel.MapIterator {
method ListIterator (line 3352) | func (n *_UnionKinded__Repr) ListIterator() datamodel.ListIterator {
method Length (line 3355) | func (n *_UnionKinded__Repr) Length() int64 {
method IsAbsent (line 3358) | func (n *_UnionKinded__Repr) IsAbsent() bool {
method IsNull (line 3361) | func (n *_UnionKinded__Repr) IsNull() bool {
method AsBool (line 3364) | func (n *_UnionKinded__Repr) AsBool() (bool, error) {
method AsInt (line 3372) | func (n *_UnionKinded__Repr) AsInt() (int64, error) {
method AsFloat (line 3380) | func (n *_UnionKinded__Repr) AsFloat() (float64, error) {
method AsString (line 3383) | func (n *_UnionKinded__Repr) AsString() (string, error) {
method AsBytes (line 3391) | func (n *_UnionKinded__Repr) AsBytes() ([]byte, error) {
method AsLink (line 3394) | func (n *_UnionKinded__Repr) AsLink() (datamodel.Link, error) {
method Prototype (line 3397) | func (_UnionKinded__Repr) Prototype() datamodel.NodePrototype {
type _UnionKinded__ReprPrototype (line 3401) | type _UnionKinded__ReprPrototype struct
method NewBuilder (line 3403) | func (_UnionKinded__ReprPrototype) NewBuilder() datamodel.NodeBuilder {
type _UnionKinded__ReprBuilder (line 3409) | type _UnionKinded__ReprBuilder struct
method Build (line 3413) | func (nb *_UnionKinded__ReprBuilder) Build() datamodel.Node {
method Reset (line 3419) | func (nb *_UnionKinded__ReprBuilder) Reset() {
type _UnionKinded__ReprAssembler (line 3425) | type _UnionKinded__ReprAssembler struct
method reset (line 3434) | func (na *_UnionKinded__ReprAssembler) reset() {
method BeginMap (line 3449) | func (na *_UnionKinded__ReprAssembler) BeginMap(sizeHint int64) (datam...
method BeginList (line 3458) | func (na *_UnionKinded__ReprAssembler) BeginList(sizeHint int64) (data...
method AssignNull (line 3467) | func (na *_UnionKinded__ReprAssembler) AssignNull() error {
method AssignBool (line 3476) | func (na *_UnionKinded__ReprAssembler) AssignBool(v bool) error {
method AssignInt (line 3492) | func (na *_UnionKinded__ReprAssembler) AssignInt(v int64) error {
method AssignFloat (line 3508) | func (na *_UnionKinded__ReprAssembler) AssignFloat(v float64) error {
method AssignString (line 3517) | func (na *_UnionKinded__ReprAssembler) AssignString(v string) error {
method AssignBytes (line 3533) | func (na *_UnionKinded__ReprAssembler) AssignBytes(v []byte) error {
method AssignLink (line 3542) | func (na *_UnionKinded__ReprAssembler) AssignLink(v datamodel.Link) er...
method AssignNode (line 3551) | func (na *_UnionKinded__ReprAssembler) AssignNode(v datamodel.Node) er...
method Prototype (line 3629) | func (na *_UnionKinded__ReprAssembler) Prototype() datamodel.NodeProto...
FILE: node/gendemo/ipldsch_types.go
type typeSlab (line 21) | type typeSlab struct
type _Bar (line 44) | type _Bar struct
method _UnionKinded__member (line 95) | func (_Bar) _UnionKinded__member() {}
type _Baz (line 48) | type _Baz struct
method _UnionKinded__member (line 96) | func (_Baz) _UnionKinded__member() {}
type _Foo (line 52) | type _Foo struct
method _UnionKinded__member (line 94) | func (_Foo) _UnionKinded__member() {}
type _Int (line 56) | type _Int struct
type _Map__String__Msg3 (line 60) | type _Map__String__Msg3 struct
type _Map__String__Msg3__entry (line 64) | type _Map__String__Msg3__entry struct
type _Msg3 (line 71) | type _Msg3 struct
type _String (line 79) | type _String struct
type _UnionKinded (line 84) | type _UnionKinded struct
type _UnionKinded__iface (line 90) | type _UnionKinded__iface interface
FILE: node/mixins/bool.go
type Bool (line 18) | type Bool struct
method Kind (line 22) | func (Bool) Kind() datamodel.Kind {
method LookupByString (line 25) | func (x Bool) LookupByString(string) (datamodel.Node, error) {
method LookupByNode (line 28) | func (x Bool) LookupByNode(key datamodel.Node) (datamodel.Node, error) {
method LookupByIndex (line 31) | func (x Bool) LookupByIndex(idx int64) (datamodel.Node, error) {
method LookupBySegment (line 34) | func (x Bool) LookupBySegment(datamodel.PathSegment) (datamodel.Node, ...
method MapIterator (line 37) | func (Bool) MapIterator() datamodel.MapIterator {
method ListIterator (line 40) | func (Bool) ListIterator() datamodel.ListIterator {
method Length (line 43) | func (Bool) Length() int64 {
method IsAbsent (line 46) | func (Bool) IsAbsent() bool {
method IsNull (line 49) | func (Bool) IsNull() bool {
method AsInt (line 52) | func (x Bool) AsInt() (int64, error) {
method AsFloat (line 55) | func (x Bool) AsFloat() (float64, error) {
method AsString (line 58) | func (x Bool) AsString() (string, error) {
method AsBytes (line 61) | func (x Bool) AsBytes() ([]byte, error) {
method AsLink (line 64) | func (x Bool) AsLink() (datamodel.Link, error) {
type BoolAssembler (line 70) | type BoolAssembler struct
method BeginMap (line 74) | func (x BoolAssembler) BeginMap(sizeHint int64) (datamodel.MapAssemble...
method BeginList (line 77) | func (x BoolAssembler) BeginList(sizeHint int64) (datamodel.ListAssemb...
method AssignNull (line 80) | func (x BoolAssembler) AssignNull() error {
method AssignInt (line 83) | func (x BoolAssembler) AssignInt(int64) error {
method AssignFloat (line 86) | func (x BoolAssembler) AssignFloat(float64) error {
method AssignString (line 89) | func (x BoolAssembler) AssignString(string) error {
method AssignBytes (line 92) | func (x BoolAssembler) AssignBytes([]byte) error {
method AssignLink (line 95) | func (x BoolAssembler) AssignLink(datamodel.Link) error {
FILE: node/mixins/bytes.go
type Bytes (line 18) | type Bytes struct
method Kind (line 22) | func (Bytes) Kind() datamodel.Kind {
method LookupByString (line 25) | func (x Bytes) LookupByString(string) (datamodel.Node, error) {
method LookupByNode (line 28) | func (x Bytes) LookupByNode(key datamodel.Node) (datamodel.Node, error) {
method LookupByIndex (line 31) | func (x Bytes) LookupByIndex(idx int64) (datamodel.Node, error) {
method LookupBySegment (line 34) | func (x Bytes) LookupBySegment(datamodel.PathSegment) (datamodel.Node,...
method MapIterator (line 37) | func (Bytes) MapIterator() datamodel.MapIterator {
method ListIterator (line 40) | func (Bytes) ListIterator() datamodel.ListIterator {
method Length (line 43) | func (Bytes) Length() int64 {
method IsAbsent (line 46) | func (Bytes) IsAbsent() bool {
method IsNull (line 49) | func (Bytes) IsNull() bool {
method AsBool (line 52) | func (x Bytes) AsBool() (bool, error) {
method AsInt (line 55) | func (x Bytes) AsInt() (int64, error) {
method AsFloat (line 58) | func (x Bytes) AsFloat() (float64, error) {
method AsString (line 61) | func (x Bytes) AsString() (string, error) {
method AsLink (line 64) | func (x Bytes) AsLink() (datamodel.Link, error) {
type BytesAssembler (line 70) | type BytesAssembler struct
method BeginMap (line 74) | func (x BytesAssembler) BeginMap(sizeHint int64) (datamodel.MapAssembl...
method BeginList (line 77) | func (x BytesAssembler) BeginList(sizeHint int64) (datamodel.ListAssem...
method AssignNull (line 80) | func (x BytesAssembler) AssignNull() error {
method AssignBool (line 83) | func (x BytesAssembler) AssignBool(bool) error {
method AssignInt (line 86) | func (x BytesAssembler) AssignInt(int64) error {
method AssignFloat (line 89) | func (x BytesAssembler) AssignFloat(float64) error {
method AssignString (line 92) | func (x BytesAssembler) AssignString(string) error {
method AssignLink (line 95) | func (x BytesAssembler) AssignLink(datamodel.Link) error {
FILE: node/mixins/delim.go
function SplitExact (line 27) | func SplitExact(s string, sep string, count int) ([]string, error) {
function SplitN (line 38) | func SplitN(s, sep string, n int) []string {
FILE: node/mixins/delim_test.go
function TestSplitExact (line 13) | func TestSplitExact(t *testing.T) {
FILE: node/mixins/float.go
type Float (line 18) | type Float struct
method Kind (line 22) | func (Float) Kind() datamodel.Kind {
method LookupByString (line 25) | func (x Float) LookupByString(string) (datamodel.Node, error) {
method LookupByNode (line 28) | func (x Float) LookupByNode(key datamodel.Node) (datamodel.Node, error) {
method LookupByIndex (line 31) | func (x Float) LookupByIndex(idx int64) (datamodel.Node, error) {
method LookupBySegment (line 34) | func (x Float) LookupBySegment(datamodel.PathSegment) (datamodel.Node,...
method MapIterator (line 37) | func (Float) MapIterator() datamodel.MapIterator {
method ListIterator (line 40) | func (Float) ListIterator() datamodel.ListIterator {
method Length (line 43) | func (Float) Length() int64 {
method IsAbsent (line 46) | func (Float) IsAbsent() bool {
method IsNull (line 49) | func (Float) IsNull() bool {
method AsBool (line 52) | func (x Float) AsBool() (bool, error) {
method AsInt (line 55) | func (x Float) AsInt() (int64, error) {
method AsString (line 58) | func (x Float) AsString() (string, error) {
method AsBytes (line 61) | func (x Float) AsBytes() ([]byte, error) {
method AsLink (line 64) | func (x Float) AsLink() (datamodel.Link, error) {
type FloatAssembler (line 70) | type FloatAssembler struct
method BeginMap (line 74) | func (x FloatAssembler) BeginMap(sizeHint int64) (datamodel.MapAssembl...
method BeginList (line 77) | func (x FloatAssembler) BeginList(sizeHint int64) (datamodel.ListAssem...
method AssignNull (line 80) | func (x FloatAssembler) AssignNull() error {
method AssignBool (line 83) | func (x FloatAssembler) AssignBool(bool) error {
method AssignInt (line 86) | func (x FloatAssembler) AssignInt(int64) error {
method AssignString (line 89) | func (x FloatAssembler) AssignString(string) error {
method AssignBytes (line 92) | func (x FloatAssembler) AssignBytes([]byte) error {
method AssignLink (line 95) | func (x FloatAssembler) AssignLink(datamodel.Link) error {
FILE: node/mixins/int.go
type Int (line 18) | type Int struct
method Kind (line 22) | func (Int) Kind() datamodel.Kind {
method LookupByString (line 25) | func (x Int) LookupByString(string) (datamodel.Node, error) {
method LookupByNode (line 28) | func (x Int) LookupByNode(key datamodel.Node) (datamodel.Node, error) {
method LookupByIndex (line 31) | func (x Int) LookupByIndex(idx int64) (datamodel.Node, error) {
method LookupBySegment (line 34) | func (x Int) LookupBySegment(datamodel.PathSegment) (datamodel.Node, e...
method MapIterator (line 37) | func (Int) MapIterator() datamodel.MapIterator {
method ListIterator (line 40) | func (Int) ListIterator() datamodel.ListIterator {
method Length (line 43) | func (Int) Length() int64 {
method IsAbsent (line 46) | func (Int) IsAbsent() bool {
method IsNull (line 49) | func (Int) IsNull() bool {
method AsBool (line 52) | func (x Int) AsBool() (bool, error) {
method AsFloat (line 55) | func (x Int) AsFloat() (float64, error) {
method AsString (line 58) | func (x Int) AsString() (string, error) {
method AsBytes (line 61) | func (x Int) AsBytes() ([]byte, error) {
method AsLink (line 64) | func (x Int) AsLink() (datamodel.Link, error) {
type IntAssembler (line 70) | type IntAssembler struct
method BeginMap (line 74) | func (x IntAssembler) BeginMap(sizeHint int64) (datamodel.MapAssembler...
method BeginList (line 77) | func (x IntAssembler) BeginList(sizeHint int64) (datamodel.ListAssembl...
method AssignNull (line 80) | func (x IntAssembler) AssignNull() error {
method AssignBool (line 83) | func (x IntAssembler) AssignBool(bool) error {
method AssignFloat (line 86) | func (x IntAssembler) AssignFloat(float64) error {
method AssignString (line 89) | func (x IntAssembler) AssignString(string) error {
method AssignBytes (line 92) | func (x IntAssembler) AssignBytes([]byte) error {
method AssignLink (line 95) | func (x IntAssembler) AssignLink(datamodel.Link) error {
FILE: node/mixins/link.go
type Link (line 18) | type Link struct
method Kind (line 22) | func (Link) Kind() datamodel.Kind {
method LookupByString (line 25) | func (x Link) LookupByString(string) (datamodel.Node, error) {
method LookupByNode (line 28) | func (x Link) LookupByNode(key datamodel.Node) (datamodel.Node, error) {
method LookupByIndex (line 31) | func (x Link) LookupByIndex(idx int64) (datamodel.Node, error) {
method LookupBySegment (line 34) | func (x Link) LookupBySegment(datamodel.PathSegment) (datamodel.Node, ...
method MapIterator (line 37) | func (Link) MapIterator() datamodel.MapIterator {
method ListIterator (line 40) | func (Link) ListIterator() datamodel.ListIterator {
method Length (line 43) | func (Link) Length() int64 {
method IsAbsent (line 46) | func (Link) IsAbsent() bool {
method IsNull (line 49) | func (Link) IsNull() bool {
method AsBool (line 52) | func (x Link) AsBool() (bool, error) {
method AsInt (line 55) | func (x Link) AsInt() (int64, error) {
method AsFloat (line 58) | func (x Link) AsFloat() (float64, error) {
method AsString (line 61) | func (x Link) AsString() (string, error) {
method AsBytes (line 64) | func (x Link) AsBytes() ([]byte, error) {
type LinkAssembler (line 70) | type LinkAssembler struct
method BeginMap (line 74) | func (x LinkAssembler) BeginMap(sizeHint int64) (datamodel.MapAssemble...
method BeginList (line 77) | func (x LinkAssembler) BeginList(sizeHint int64) (datamodel.ListAssemb...
method AssignNull (line 80) | func (x LinkAssembler) AssignNull() error {
method AssignBool (line 83) | func (x LinkAssembler) AssignBool(bool) error {
method AssignInt (line 86) | func (x LinkAssembler) AssignInt(int64) error {
method AssignFloat (line 89) | func (x LinkAssembler) AssignFloat(float64) error {
method AssignString (line 92) | func (x LinkAssembler) AssignString(string) error {
method AssignBytes (line 95) | func (x LinkAssembler) AssignBytes([]byte) error {
FILE: node/mixins/list.go
type List (line 18) | type List struct
method Kind (line 22) | func (List) Kind() datamodel.Kind {
method LookupByString (line 25) | func (x List) LookupByString(string) (datamodel.Node, error) {
method LookupByNode (line 28) | func (x List) LookupByNode(key datamodel.Node) (datamodel.Node, error) {
method MapIterator (line 31) | func (List) MapIterator() datamodel.MapIterator {
method IsAbsent (line 34) | func (List) IsAbsent() bool {
method IsNull (line 37) | func (List) IsNull() bool {
method AsBool (line 40) | func (x List) AsBool() (bool, error) {
method AsInt (line 43) | func (x List) AsInt() (int64, error) {
method AsFloat (line 46) | func (x List) AsFloat() (float64, error) {
method AsString (line 49) | func (x List) AsString() (string, error) {
method AsBytes (line 52) | func (x List) AsBytes() ([]byte, error) {
method AsLink (line 55) | func (x List) AsLink() (datamodel.Link, error) {
type ListAssembler (line 61) | type ListAssembler struct
method BeginMap (line 65) | func (x ListAssembler) BeginMap(sizeHint int64) (datamodel.MapAssemble...
method AssignNull (line 68) | func (x ListAssembler) AssignNull() error {
method AssignBool (line 71) | func (x ListAssembler) AssignBool(bool) error {
method AssignInt (line 74) | func (x ListAssembler) AssignInt(int64) error {
method AssignFloat (line 77) | func (x ListAssembler) AssignFloat(float64) error {
method AssignString (line 80) | func (x ListAssembler) AssignString(string) error {
method AssignBytes (line 83) | func (x ListAssembler) AssignBytes([]byte) error {
method AssignLink (line 86) | func (x ListAssembler) AssignLink(datamodel.Link) error {
FILE: node/mixins/map.go
type Map (line 18) | type Map struct
method Kind (line 22) | func (Map) Kind() datamodel.Kind {
method LookupByIndex (line 25) | func (x Map) LookupByIndex(idx int64) (datamodel.Node, error) {
method ListIterator (line 28) | func (Map) ListIterator() datamodel.ListIterator {
method IsAbsent (line 31) | func (Map) IsAbsent() bool {
method IsNull (line 34) | func (Map) IsNull() bool {
method AsBool (line 37) | func (x Map) AsBool() (bool, error) {
method AsInt (line 40) | func (x Map) AsInt() (int64, error) {
method AsFloat (line 43) | func (x Map) AsFloat() (float64, error) {
method AsString (line 46) | func (x Map) AsString() (string, error) {
method AsBytes (line 49) | func (x Map) AsBytes() ([]byte, error) {
method AsLink (line 52) | func (x Map) AsLink() (datamodel.Link, error) {
type MapAssembler (line 58) | type MapAssembler struct
method BeginList (line 62) | func (x MapAssembler) BeginList(sizeHint int64) (datamodel.ListAssembl...
method AssignNull (line 65) | func (x MapAssembler) AssignNull() error {
method AssignBool (line 68) | func (x MapAssembler) AssignBool(bool) error {
method AssignInt (line 71) | func (x MapAssembler) AssignInt(int64) error {
method AssignFloat (line 74) | func (x MapAssembler) AssignFloat(float64) error {
method AssignString (line 77) | func (x MapAssembler) AssignString(string) error {
method AssignBytes (line 80) | func (x MapAssembler) AssignBytes([]byte) error {
method AssignLink (line 83) | func (x MapAssembler) AssignLink(datamodel.Link) error {
FILE: node/mixins/string.go
type String (line 18) | type String struct
method Kind (line 22) | func (String) Kind() datamodel.Kind {
method LookupByString (line 25) | func (x String) LookupByString(string) (datamodel.Node, error) {
method LookupByNode (line 28) | func (x String) LookupByNode(key datamodel.Node) (datamodel.Node, erro...
method LookupByIndex (line 31) | func (x String) LookupByIndex(idx int64) (datamodel.Node, error) {
method LookupBySegment (line 34) | func (x String) LookupBySegment(datamodel.PathSegment) (datamodel.Node...
method MapIterator (line 37) | func (String) MapIterator() datamodel.MapIterator {
method ListIterator (line 40) | func (String) ListIterator() datamodel.ListIterator {
method Length (line 43) | func (String) Length() int64 {
method IsAbsent (line 46) | func (String) IsAbsent() bool {
method IsNull (line 49) | func (String) IsNull() bool {
method AsBool (line 52) | func (x String) AsBool() (bool, error) {
method AsInt (line 55) | func (x String) AsInt() (int64, error) {
method AsFloat (line 58) | func (x String) AsFloat() (float64, error) {
method AsBytes (line 61) | func (x String) AsBytes() ([]byte, error) {
method AsLink (line 64) | func (x String) AsLink() (datamodel.Link, error) {
type StringAssembler (line 70) | type StringAssembler struct
method BeginMap (line 74) | func (x StringAssembler) BeginMap(sizeHint int64) (datamodel.MapAssemb...
method BeginList (line 77) | func (x StringAssembler) BeginList(sizeHint int64) (datamodel.ListAsse...
method AssignNull (line 80) | func (x StringAssembler) AssignNull() error {
method AssignBool (line 83) | func (x StringAssembler) AssignBool(bool) error {
method AssignInt (line 86) | func (x StringAssembler) AssignInt(int64) error {
method AssignFloat (line 89) | func (x StringAssembler) AssignFloat(float64) error {
method AssignBytes (line 92) | func (x StringAssembler) AssignBytes([]byte) error {
method AssignLink (line 95) | func (x StringAssembler) AssignLink(datamodel.Link) error {
FILE: node/tests/byteSpecs.go
function SpecTestBytes (line 12) | func SpecTestBytes(t *testing.T, np datamodel.NodePrototype) {
FILE: node/tests/checkers.go
type nodeContentEqualsChecker (line 21) | type nodeContentEqualsChecker struct
method Check (line 23) | func (n *nodeContentEqualsChecker) Check(got interface{}, args []inter...
method ArgNames (line 45) | func (n *nodeContentEqualsChecker) ArgNames() []string {
type deepNodeContentsEqualsChecker (line 57) | type deepNodeContentsEqualsChecker struct
method Check (line 59) | func (n *deepNodeContentsEqualsChecker) Check(got interface{}, args []...
method ArgNames (line 80) | func (n *deepNodeContentsEqualsChecker) ArgNames() []string {
function deepEqualCheck (line 84) | func deepEqualCheck(x, y datamodel.Node, note func(key string, value int...
FILE: node/tests/checkers_test.go
function Test_nodeContentEqualsChecker_Check (line 11) | func Test_nodeContentEqualsChecker_Check(t *testing.T) {
FILE: node/tests/corpus/corpus.go
function Map3StrInt (line 43) | func Map3StrInt() string {
function MapNStrInt (line 47) | func MapNStrInt(n int) string {
function MapNStrMap3StrInt (line 53) | func MapNStrMap3StrInt(n int) string {
FILE: node/tests/corpus/corpus_test.go
function TestCorpusValidity (line 15) | func TestCorpusValidity(t *testing.T) {
FILE: node/tests/corpus/util.go
function ents (line 7) | func ents(n int, segFn func(i int) string) string {
FILE: node/tests/listSpecs.go
function SpecTestListString (line 13) | func SpecTestListString(t *testing.T, np datamodel.NodePrototype) {
FILE: node/tests/mapBenchmarks.go
function SpecBenchmarkMapStrInt_3n_AssembleStandard (line 10) | func SpecBenchmarkMapStrInt_3n_AssembleStandard(b *testing.B, np datamod...
function SpecBenchmarkMapStrInt_3n_AssembleEntry (line 16) | func SpecBenchmarkMapStrInt_3n_AssembleEntry(b *testing.B, np datamodel....
function SpecBenchmarkMapStrInt_3n_Iteration (line 43) | func SpecBenchmarkMapStrInt_3n_Iteration(b *testing.B, np datamodel.Node...
function SpecBenchmarkMapStrInt_25n_AssembleStandard (line 57) | func SpecBenchmarkMapStrInt_25n_AssembleStandard(b *testing.B, np datamo...
function SpecBenchmarkMapStrInt_25n_AssembleEntry (line 63) | func SpecBenchmarkMapStrInt_25n_AssembleEntry(b *testing.B, np datamodel...
function SpecBenchmarkMapStrInt_25n_Iteration (line 82) | func SpecBenchmarkMapStrInt_25n_Iteration(b *testing.B, np datamodel.Nod...
FILE: node/tests/mapBenchmarks_test.go
function BenchmarkMapStrInt_3n_BaselineNativeMapAssignSimpleKeys (line 13) | func BenchmarkMapStrInt_3n_BaselineNativeMapAssignSimpleKeys(b *testing....
function BenchmarkMapStrInt_3n_BaselineJsonUnmarshalMapSimpleKeys (line 23) | func BenchmarkMapStrInt_3n_BaselineJsonUnmarshalMapSimpleKeys(b *testing...
function BenchmarkMapStrInt_3n_BaselineJsonMarshalMapSimpleKeys (line 31) | func BenchmarkMapStrInt_3n_BaselineJsonMarshalMapSimpleKeys(b *testing.B) {
function BenchmarkMapStrInt_3n_BaselineNativeMapIterationSimpleKeys (line 45) | func BenchmarkMapStrInt_3n_BaselineNativeMapIterationSimpleKeys(b *testi...
function BenchmarkMapStrInt_25n_BaselineNativeMapAssignSimpleKeys (line 62) | func BenchmarkMapStrInt_25n_BaselineNativeMapAssignSimpleKeys(b *testing...
function BenchmarkMapStrInt_25n_BaselineNativeMapIterationSimpleKeys (line 72) | func BenchmarkMapStrInt_25n_BaselineNativeMapIterationSimpleKeys(b *test...
FILE: node/tests/mapFixtures.go
function init (line 15) | func init() {
function buildMapStrIntN3 (line 25) | func buildMapStrIntN3(np datamodel.NodePrototype) datamodel.Node {
function buildMapStrIntN25 (line 40) | func buildMapStrIntN25(np datamodel.NodePrototype) datamodel.Node {
FILE: node/tests/mapSpecs.go
function SpecTestMapStrInt (line 12) | func SpecTestMapStrInt(t *testing.T, np datamodel.NodePrototype) {
function SpecTestMapStrMapStrInt (line 139) | func SpecTestMapStrMapStrInt(t *testing.T, np datamodel.NodePrototype) {
function SpecTestMapStrListStr (line 190) | func SpecTestMapStrListStr(t *testing.T, np datamodel.NodePrototype) {
FILE: node/tests/marshalBenchmarks.go
function BenchmarkSpec_Marshal_Map3StrInt (line 24) | func BenchmarkSpec_Marshal_Map3StrInt(b *testing.B, np datamodel.NodePro...
function BenchmarkSpec_Marshal_MapNStrMap3StrInt (line 40) | func BenchmarkSpec_Marshal_MapNStrMap3StrInt(b *testing.B, np datamodel....
FILE: node/tests/schema.go
type EngineSubtest (line 31) | type EngineSubtest struct
function SchemaTestAll (line 36) | func SchemaTestAll(t *testing.T, forTest func(name string) []EngineSubte...
FILE: node/tests/schemaLinks.go
function encode (line 26) | func encode(n datamodel.Node) (datamodel.Node, datamodel.Link) {
function SchemaTestLinks (line 43) | func SchemaTestLinks(t *testing.T, engine Engine) {
FILE: node/tests/schemaLists.go
function SchemaTestListsContainingMaybe (line 15) | func SchemaTestListsContainingMaybe(t *testing.T, engine Engine) {
function SchemaTestListsContainingLists (line 112) | func SchemaTestListsContainingLists(t *testing.T, engine Engine) {
FILE: node/tests/schemaMaps.go
function SchemaTestMapsContainingMaybe (line 14) | func SchemaTestMapsContainingMaybe(t *testing.T, engine Engine) {
function SchemaTestMapsContainingMaps (line 101) | func SchemaTestMapsContainingMaps(t *testing.T, engine Engine) {
function SchemaTestMapsWithComplexKeys (line 182) | func SchemaTestMapsWithComplexKeys(t *testing.T, engine Engine) {
FILE: node/tests/schemaScalars.go
function assignValue (line 13) | func assignValue(am datamodel.NodeAssembler, value interface{}) error {
function SchemaTestScalars (line 30) | func SchemaTestScalars(t *testing.T, engine Engine) {
FILE: node/tests/schemaStruct.go
function SchemaTestRequiredFields (line 15) | func SchemaTestRequiredFields(t *testing.T, engine Engine) {
function SchemaTestStructNesting (line 71) | func SchemaTestStructNesting(t *testing.T, engine Engine) {
FILE: node/tests/schemaStructReprListpairs.go
function SchemaTestStructReprListPairs (line 15) | func SchemaTestStructReprListPairs(t *testing.T, engine Engine) {
FILE: node/tests/schemaStructReprStringjoin.go
function SchemaTestStructReprStringjoin (line 18) | func SchemaTestStructReprStringjoin(t *testing.T, engine Engine) {
FILE: node/tests/schemaStructReprTuple.go
function SchemaTestStructReprTuple (line 14) | func SchemaTestStructReprTuple(t *testing.T, engine Engine) {
FILE: node/tests/schemaStructsContainingMaybe.go
function SchemaTestStructsContainingMaybe (line 17) | func SchemaTestStructsContainingMaybe(t *testing.T, engine Engine) {
FILE: node/tests/schemaUnions.go
function SchemaTestUnionKeyed (line 10) | func SchemaTestUnionKeyed(t *testing.T, engine Engine) {
function SchemaTestUnionKeyedComplexChildren (line 74) | func SchemaTestUnionKeyedComplexChildren(t *testing.T, engine Engine) {
function SchemaTestUnionKeyedReset (line 142) | func SchemaTestUnionKeyedReset(t *testing.T, engine Engine) {
FILE: node/tests/schemaUnionsKinded.go
function SchemaTestUnionKinded (line 10) | func SchemaTestUnionKinded(t *testing.T, engine Engine) {
FILE: node/tests/schemaUnionsStringprefix.go
function SchemaTestUnionStringprefix (line 10) | func SchemaTestUnionStringprefix(t *testing.T, engine Engine) {
FILE: node/tests/stringSpecs.go
function SpecTestString (line 11) | func SpecTestString(t *testing.T, np datamodel.NodePrototype) {
FILE: node/tests/testEngine.go
type Engine (line 19) | type Engine interface
FILE: node/tests/testcase.go
type testcase (line 68) | type testcase struct
method Test (line 90) | func (tcase testcase) Test(t *testing.T, np, npr datamodel.NodePrototy...
type testcasePoint (line 80) | type testcasePoint struct
type entry (line 85) | type entry struct
function shallowCopyMap (line 209) | func shallowCopyMap(np datamodel.NodePrototype, n datamodel.Node) (datam...
function testUnmarshal (line 236) | func testUnmarshal(t *testing.T, np datamodel.NodePrototype, data string...
function testMarshal (line 253) | func testMarshal(t *testing.T, n datamodel.Node, data string) {
function wishPoint (line 269) | func wishPoint(t *testing.T, n datamodel.Node, point testcasePoint) {
type closeEnoughChecker (line 297) | type closeEnoughChecker struct
method ArgNames (line 299) | func (c *closeEnoughChecker) ArgNames() []string {
method Check (line 303) | func (c *closeEnoughChecker) Check(actual interface{}, args []interfac...
function reformat (line 334) | func reformat(x string, opts json.EncodeOptions) string {
FILE: node/tests/testutil.go
function withNode (line 18) | func withNode(n datamodel.Node, cb func(n datamodel.Node)) {
FILE: node/tests/traversalBenchmarks.go
function BenchmarkSpec_Walk_Map3StrInt (line 12) | func BenchmarkSpec_Walk_Map3StrInt(b *testing.B, np datamodel.NodeProtot...
function BenchmarkSpec_Walk_MapNStrMap3StrInt (line 30) | func BenchmarkSpec_Walk_MapNStrMap3StrInt(b *testing.B, np datamodel.Nod...
FILE: node/tests/unmarshalBenchmarks.go
function BenchmarkSpec_Unmarshal_Map3StrInt (line 23) | func BenchmarkSpec_Unmarshal_Map3StrInt(b *testing.B, np datamodel.NodeP...
function BenchmarkSpec_Unmarshal_MapNStrMap3StrInt (line 35) | func BenchmarkSpec_Unmarshal_MapNStrMap3StrInt(b *testing.B, np datamode...
FILE: node/tests/util.go
function mustNodeFromJsonString (line 12) | func mustNodeFromJsonString(np datamodel.NodePrototype, str string) data...
function mustSelectorFromJsonString (line 18) | func mustSelectorFromJsonString(np datamodel.NodePrototype, str string) ...
FILE: operations.go
function DeepEqual (line 11) | func DeepEqual(x, y Node) bool {
FILE: printer/printer.go
function Print (line 17) | func Print(n datamodel.Node) {
function Sprint (line 24) | func Sprint(n datamodel.Node) string {
function Fprint (line 31) | func Fprint(w io.Writer, n datamodel.Node) {
type Config (line 57) | type Config struct
method Print (line 37) | func (cfg Config) Print(n datamodel.Node) {
method Sprint (line 43) | func (cfg Config) Sprint(n datamodel.Node) string {
method Fprint (line 51) | func (cfg Config) Fprint(w io.Writer, n datamodel.Node) {
method init (line 96) | func (cfg *Config) init() {
method oneline (line 106) | func (cfg Config) oneline(typ schema.Type, isInKey bool) bool {
method useCmplxKeys (line 121) | func (cfg Config) useCmplxKeys(mapn datamodel.Node) bool {
type printBuf (line 149) | type printBuf struct
method writeString (line 155) | func (z *printBuf) writeString(s string) {
method doIndent (line 159) | func (z *printBuf) doIndent(indentLevel int) {
method doString (line 174) | func (z *printBuf) doString(indentLevel int, printState uint8, n datam...
constant printState_normal (line 167) | printState_normal uint8 = iota
constant printState_isKey (line 168) | printState_isKey
constant printState_isValue (line 169) | printState_isValue
constant printState_isCmplxKey (line 170) | printState_isCmplx
Condensed preview — 377 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (2,275K chars).
[
{
"path": ".gitattributes",
"chars": 27,
"preview": "**/testdata/fuzz/** binary\n"
},
{
"path": ".github/actions/go-test-setup/action.yml",
"chars": 322,
"preview": "name: go-ipld-prime custom action setup\ndescription: Adds additional options to `go test` to skip behavior tests in the "
},
{
"path": ".github/dependabot.yml",
"chars": 540,
"preview": "version: 2\nupdates:\n - package-ecosystem: \"gomod\"\n directory: \"/\"\n schedule:\n interval: \"weekly\"\n - package"
},
{
"path": ".github/workflows/generated-pr.yml",
"chars": 246,
"preview": "name: Close Generated PRs\n\non:\n schedule:\n - cron: '0 0 * * *'\n workflow_dispatch:\n\npermissions:\n issues: write\n "
},
{
"path": ".github/workflows/go-check.yml",
"chars": 380,
"preview": "name: Go Checks\n\non:\n pull_request:\n push:\n branches: [\"master\"]\n workflow_dispatch:\n\npermissions:\n contents: rea"
},
{
"path": ".github/workflows/go-test-prime.yml",
"chars": 868,
"preview": "on: [push, pull_request]\nname: Go Test (go-ipld-prime custom)\n\n# Similar to go-test.yml but runs only on Linux and doesn"
},
{
"path": ".github/workflows/go-test.yml",
"chars": 439,
"preview": "name: Go Test\n\non:\n pull_request:\n push:\n branches: [\"master\"]\n workflow_dispatch:\n\npermissions:\n contents: read\n"
},
{
"path": ".github/workflows/release-check.yml",
"chars": 419,
"preview": "name: Release Checker\n\non:\n pull_request_target:\n paths: [ 'version.json' ]\n types: [ opened, synchronize, reopen"
},
{
"path": ".github/workflows/releaser.yml",
"chars": 299,
"preview": "name: Releaser\n\non:\n push:\n paths: [ 'version.json' ]\n workflow_dispatch:\n\npermissions:\n contents: write\n\nconcurre"
},
{
"path": ".github/workflows/stale.yml",
"chars": 244,
"preview": "name: Close Stale Issues\n\non:\n schedule:\n - cron: '0 0 * * *'\n workflow_dispatch:\n\npermissions:\n issues: write\n p"
},
{
"path": ".github/workflows/tagpush.yml",
"chars": 291,
"preview": "name: Tag Push Checker\n\non:\n push:\n tags:\n - v*\n\npermissions:\n contents: read\n issues: write\n\nconcurrency:\n "
},
{
"path": ".gitmodules",
"chars": 71,
"preview": "[submodule \".ipld\"]\n\tpath = .ipld\n\turl = https://github.com/ipld/ipld/\n"
},
{
"path": "CHANGELOG.md",
"chars": 77354,
"preview": "CHANGELOG\n=========\n\nHere is collected some brief notes on major changes over time, sorted by tag in which they are firs"
},
{
"path": "HACKME.md",
"chars": 5369,
"preview": "hackme\n======\n\nDesign rational are documented here.\n\nThis doc is not necessary reading for users of this package,\nbut if"
},
{
"path": "HACKME_builderBehaviors.md",
"chars": 5812,
"preview": "hackme: NodeBuilder and NodeAssembler behaviors\n===============================================\n\nhigh level rules of bui"
},
{
"path": "HACKME_mergeStrategy.md",
"chars": 3414,
"preview": "hacking: merge strategies\n=========================\n\nThis is a short document about how the maintainers of this repo han"
},
{
"path": "HACKME_releases.md",
"chars": 4476,
"preview": "# Making go-ipld-prime Releases\n\n## Versioning strategy\n\ngo-ipld-prime follows **[WarpVer](https://gist.github.com/warpf"
},
{
"path": "LICENSE",
"chars": 1077,
"preview": "The MIT License (MIT)\n\nCopyright (c) 2018 Eric Myhre\n\nPermission is hereby granted, free of charge, to any person obtain"
},
{
"path": "README.md",
"chars": 13800,
"preview": "go-ipld-prime\n=============\n\n`go-ipld-prime` is an implementation of the IPLD spec interfaces,\na batteries-included code"
},
{
"path": "README_migrationGuide.md",
"chars": 4990,
"preview": "A short guide to migrating to go-ipld-prime from other repos\n==========================================================="
},
{
"path": "adl/interface.go",
"chars": 790,
"preview": "package adl\n\nimport (\n\t\"github.com/ipld/go-ipld-prime/datamodel\"\n)\n\n// ADL is an interface denoting an Advanced Data Lay"
},
{
"path": "adl/rot13adl/example_test.go",
"chars": 6146,
"preview": "package rot13adl_test\n\nimport (\n\t\"bytes\"\n\t\"context\"\n\t\"fmt\"\n\t\"strings\"\n\n\t\"github.com/ipfs/go-cid\"\n\n\t\"github.com/ipld/go-i"
},
{
"path": "adl/rot13adl/rot13logic.go",
"chars": 1157,
"preview": "package rot13adl\n\nimport (\n\t\"strings\"\n)\n\nvar replaceTable = []string{\n\t\"A\", \"N\",\n\t\"B\", \"O\",\n\t\"C\", \"P\",\n\t\"D\", \"Q\",\n\t\"E\", "
},
{
"path": "adl/rot13adl/rot13node.go",
"chars": 7209,
"preview": "/*\nrot13adl is a demo ADL -- its purpose is to show what an ADL and its public interface can look like.\nIt implements a "
},
{
"path": "adl/rot13adl/rot13node_test.go",
"chars": 2524,
"preview": "package rot13adl\n\nimport (\n\t\"testing\"\n\n\tqt \"github.com/frankban/quicktest\"\n\n\t\"github.com/ipld/go-ipld-prime/datamodel\"\n\t"
},
{
"path": "adl/rot13adl/rot13prototypes.go",
"chars": 1527,
"preview": "package rot13adl\n\n// Prototype embeds a NodePrototype for every kind of Node implementation in this package.\n// This inc"
},
{
"path": "adl/rot13adl/rot13reification.go",
"chars": 4177,
"preview": "package rot13adl\n\nimport (\n\t\"fmt\"\n\n\t\"github.com/ipld/go-ipld-prime/datamodel\"\n)\n\n// Reify examines data in a Node to see"
},
{
"path": "adl/rot13adl/rot13substrate.go",
"chars": 6417,
"preview": "package rot13adl\n\nimport (\n\t\"github.com/ipld/go-ipld-prime/datamodel\"\n\t\"github.com/ipld/go-ipld-prime/node/mixins\"\n\t\"git"
},
{
"path": "adl.go",
"chars": 82,
"preview": "package ipld\n\nimport (\n\t\"github.com/ipld/go-ipld-prime/adl\"\n)\n\ntype ADL = adl.ADL\n"
},
{
"path": "codec/README.md",
"chars": 3691,
"preview": "Codecs\n======\n\nThe `go-ipld-prime/codec` package is a grouping package.\nThe subpackages contains some codecs which resid"
},
{
"path": "codec/api.go",
"chars": 7125,
"preview": "package codec\n\nimport (\n\t\"io\"\n\n\t\"github.com/ipld/go-ipld-prime/datamodel\"\n)\n\n// The following two types define the two d"
},
{
"path": "codec/cbor/multicodec.go",
"chars": 1141,
"preview": "package cbor\n\nimport (\n\t\"io\"\n\n\t\"github.com/ipld/go-ipld-prime/codec\"\n\t\"github.com/ipld/go-ipld-prime/codec/dagcbor\"\n\t\"gi"
},
{
"path": "codec/cbor/roundtrip_test.go",
"chars": 2034,
"preview": "package cbor\n\nimport (\n\t\"bytes\"\n\t\"strings\"\n\t\"testing\"\n\n\tqt \"github.com/frankban/quicktest\"\n\n\t\"github.com/ipld/go-ipld-pr"
},
{
"path": "codec/dagcbor/common.go",
"chars": 36,
"preview": "package dagcbor\n\nconst linkTag = 42\n"
},
{
"path": "codec/dagcbor/doc.go",
"chars": 2323,
"preview": "/*\nThe dagcbor package provides a DAG-CBOR codec implementation.\n\nThe Encode and Decode functions match the codec.Encode"
},
{
"path": "codec/dagcbor/marshal.go",
"chars": 10600,
"preview": "package dagcbor\n\nimport (\n\t\"fmt\"\n\t\"io\"\n\t\"sort\"\n\n\t\"github.com/polydawn/refmt/cbor\"\n\t\"github.com/polydawn/refmt/shared\"\n\t\""
},
{
"path": "codec/dagcbor/marshal_test.go",
"chars": 2862,
"preview": "package dagcbor\n\nimport (\n\t\"bytes\"\n\t\"math/rand\"\n\t\"testing\"\n\t\"time\"\n\n\tqt \"github.com/frankban/quicktest\"\n\t\"github.com/ipf"
},
{
"path": "codec/dagcbor/multicodec.go",
"chars": 1630,
"preview": "package dagcbor\n\nimport (\n\t\"io\"\n\n\t\"github.com/ipld/go-ipld-prime/codec\"\n\t\"github.com/ipld/go-ipld-prime/datamodel\"\n\t\"git"
},
{
"path": "codec/dagcbor/nongreedy_test.go",
"chars": 1207,
"preview": "package dagcbor\n\nimport (\n\t\"bytes\"\n\t\"encoding/hex\"\n\t\"testing\"\n\n\tqt \"github.com/frankban/quicktest\"\n\t\"github.com/ipld/go-"
},
{
"path": "codec/dagcbor/roundtripCidlink_test.go",
"chars": 1155,
"preview": "package dagcbor\n\nimport (\n\t\"bytes\"\n\t\"io\"\n\t\"testing\"\n\n\tqt \"github.com/frankban/quicktest\"\n\n\tcid \"github.com/ipfs/go-cid\"\n"
},
{
"path": "codec/dagcbor/roundtrip_test.go",
"chars": 5899,
"preview": "package dagcbor\n\nimport (\n\t\"bytes\"\n\t\"crypto/rand\"\n\t\"encoding/hex\"\n\t\"math\"\n\t\"strings\"\n\t\"testing\"\n\n\tqt \"github.com/frankba"
},
{
"path": "codec/dagcbor/unmarshal.go",
"chars": 11405,
"preview": "package dagcbor\n\nimport (\n\t\"errors\"\n\t\"fmt\"\n\t\"io\"\n\t\"math\"\n\n\tcid \"github.com/ipfs/go-cid\"\n\t\"github.com/polydawn/refmt/cbor"
},
{
"path": "codec/dagcbor/unmarshal_test.go",
"chars": 12775,
"preview": "package dagcbor\n\nimport (\n\t\"bytes\"\n\t\"encoding/binary\"\n\t\"fmt\"\n\t\"runtime\"\n\t\"strings\"\n\t\"testing\"\n\n\t\"github.com/ipld/go-ipld"
},
{
"path": "codec/dagjson/marshal.go",
"chars": 7536,
"preview": "package dagjson\n\nimport (\n\t\"encoding/base64\"\n\t\"fmt\"\n\t\"io\"\n\t\"sort\"\n\n\t\"github.com/polydawn/refmt/json\"\n\t\"github.com/polyda"
},
{
"path": "codec/dagjson/marshal_test.go",
"chars": 2350,
"preview": "package dagjson\n\nimport (\n\t\"testing\"\n\n\tqt \"github.com/frankban/quicktest\"\n\tcid \"github.com/ipfs/go-cid\"\n\t\"github.com/ipl"
},
{
"path": "codec/dagjson/multicodec.go",
"chars": 1670,
"preview": "package dagjson\n\nimport (\n\t\"io\"\n\n\t\"github.com/ipld/go-ipld-prime/codec\"\n\t\"github.com/ipld/go-ipld-prime/datamodel\"\n\t\"git"
},
{
"path": "codec/dagjson/nongreedy_test.go",
"chars": 957,
"preview": "package dagjson\n\nimport (\n\t\"bytes\"\n\t\"testing\"\n\n\t\"github.com/ipld/go-ipld-prime/datamodel\"\n\t\"github.com/ipld/go-ipld-prim"
},
{
"path": "codec/dagjson/options_test.go",
"chars": 3707,
"preview": "package dagjson\n\nimport (\n\t\"bytes\"\n\t\"strings\"\n\t\"testing\"\n\n\tqt \"github.com/frankban/quicktest\"\n\n\t\"github.com/ipld/go-ipld"
},
{
"path": "codec/dagjson/roundtripBytes_test.go",
"chars": 2490,
"preview": "package dagjson_test\n\nimport (\n\t\"bytes\"\n\t\"strings\"\n\t\"testing\"\n\n\tqt \"github.com/frankban/quicktest\"\n\n\t\"github.com/ipld/go"
},
{
"path": "codec/dagjson/roundtripCidlink_test.go",
"chars": 2339,
"preview": "package dagjson_test\n\nimport (\n\t\"bytes\"\n\t\"io\"\n\t\"strings\"\n\t\"testing\"\n\n\tqt \"github.com/frankban/quicktest\"\n\n\tcid \"github.c"
},
{
"path": "codec/dagjson/roundtrip_test.go",
"chars": 4546,
"preview": "package dagjson_test\n\nimport (\n\t\"bytes\"\n\t\"math/rand\"\n\t\"strings\"\n\t\"testing\"\n\t\"time\"\n\n\tqt \"github.com/frankban/quicktest\"\n"
},
{
"path": "codec/dagjson/unmarshal.go",
"chars": 12990,
"preview": "package dagjson\n\nimport (\n\t\"encoding/base64\"\n\t\"errors\"\n\t\"fmt\"\n\t\"io\"\n\n\tcid \"github.com/ipfs/go-cid\"\n\t\"github.com/polydawn"
},
{
"path": "codec/decode_test.go",
"chars": 909,
"preview": "package codec_test\n\nimport (\n\t\"errors\"\n\t\"io\"\n\t\"strings\"\n\t\"testing\"\n\n\t_ \"github.com/ipld/go-ipld-prime/codec/cbor\"\n\t_ \"gi"
},
{
"path": "codec/json/marshal_test.go",
"chars": 1706,
"preview": "package json\n\nimport (\n\t\"testing\"\n\n\tqt \"github.com/frankban/quicktest\"\n\t\"github.com/ipfs/go-cid\"\n\t\"github.com/ipld/go-ip"
},
{
"path": "codec/json/multicodec.go",
"chars": 1570,
"preview": "package json\n\nimport (\n\t\"io\"\n\n\trfmtjson \"github.com/polydawn/refmt/json\"\n\n\t\"github.com/ipld/go-ipld-prime/codec\"\n\t\"githu"
},
{
"path": "codec/raw/codec.go",
"chars": 2027,
"preview": "// Package raw implements IPLD's raw codec, which simply writes and reads a Node\n// which can be represented as bytes.\n/"
},
{
"path": "codec/raw/codec_test.go",
"chars": 2667,
"preview": "package raw\n\nimport (\n\t\"bytes\"\n\t\"fmt\"\n\t\"io\"\n\t\"testing\"\n\n\tqt \"github.com/frankban/quicktest\"\n\t\"github.com/ipfs/go-cid\"\n\t\""
},
{
"path": "codec.go",
"chars": 124,
"preview": "package ipld\n\nimport (\n\t\"github.com/ipld/go-ipld-prime/codec\"\n)\n\ntype (\n\tEncoder = codec.Encoder\n\tDecoder = codec.Decode"
},
{
"path": "codecHelpers.go",
"chars": 8567,
"preview": "package ipld\n\nimport (\n\t\"bytes\"\n\t\"io\"\n\t\"reflect\"\n\n\t\"github.com/ipld/go-ipld-prime/node/basicnode\"\n\t\"github.com/ipld/go-i"
},
{
"path": "codecHelpers_test.go",
"chars": 1565,
"preview": "package ipld_test\n\nimport (\n\t\"fmt\"\n\n\t\"github.com/ipld/go-ipld-prime\"\n\t\"github.com/ipld/go-ipld-prime/codec/json\"\n\t\"githu"
},
{
"path": "datamodel/copy.go",
"chars": 3206,
"preview": "package datamodel\n\nimport (\n\t\"errors\"\n\t\"fmt\"\n)\n\n// Copy does an explicit shallow copy of a Node's data into a NodeAssemb"
},
{
"path": "datamodel/copy_test.go",
"chars": 3285,
"preview": "package datamodel_test\n\nimport (\n\t\"testing\"\n\n\t\"github.com/ipld/go-ipld-prime/datamodel\"\n\t\"github.com/ipld/go-ipld-prime/"
},
{
"path": "datamodel/doc.go",
"chars": 844,
"preview": "// The datamodel package defines the most essential interfaces for describing IPLD Data --\n// such as Node, NodePrototyp"
},
{
"path": "datamodel/equal.go",
"chars": 3596,
"preview": "package datamodel\n\n// DeepEqual reports whether x and y are \"deeply equal\" as IPLD nodes.\n// This is similar to reflect."
},
{
"path": "datamodel/equal_test.go",
"chars": 4646,
"preview": "package datamodel_test\n\nimport (\n\t\"testing\"\n\n\t\"github.com/ipfs/go-cid\"\n\t\"github.com/ipld/go-ipld-prime/datamodel\"\n\t\"gith"
},
{
"path": "datamodel/errors.go",
"chars": 3908,
"preview": "package datamodel\n\nimport (\n\t\"fmt\"\n)\n\n// ErrWrongKind may be returned from functions on the Node interface when\n// a met"
},
{
"path": "datamodel/kind.go",
"chars": 2098,
"preview": "package datamodel\n\n// Kind represents the primitive kind in the IPLD data model.\n// All of these kinds map directly onto"
},
{
"path": "datamodel/kind_test.go",
"chars": 405,
"preview": "package datamodel_test\n\nimport (\n\t\"testing\"\n\n\tqt \"github.com/frankban/quicktest\"\n\n\t\"github.com/ipld/go-ipld-prime/datamo"
},
{
"path": "datamodel/link.go",
"chars": 3763,
"preview": "package datamodel\n\n// Link is a special kind of value in IPLD which can be \"loaded\" to access more nodes.\n//\n// Nodes ca"
},
{
"path": "datamodel/node.go",
"chars": 16632,
"preview": "package datamodel\n\nimport \"io\"\n\n// Node represents a value in IPLD. Any point in a tree of data is a node:\n// scalar va"
},
{
"path": "datamodel/nodeBuilder.go",
"chars": 8177,
"preview": "package datamodel\n\n// NodeAssembler is the interface that describes all the ways we can set values\n// in a node that's u"
},
{
"path": "datamodel/path.go",
"chars": 9835,
"preview": "package datamodel\n\nimport (\n\t\"strings\"\n)\n\n// Path describes a series of steps across a tree or DAG of Node,\n// where eac"
},
{
"path": "datamodel/pathSegment.go",
"chars": 6101,
"preview": "package datamodel\n\nimport (\n\t\"strconv\"\n)\n\n// PathSegment can describe either a key in a map, or an index in a list.\n//\n/"
},
{
"path": "datamodel/path_test.go",
"chars": 1817,
"preview": "package datamodel\n\nimport (\n\t\"reflect\"\n\t\"testing\"\n\n\tqt \"github.com/frankban/quicktest\"\n\t\"github.com/google/go-cmp/cmp\"\n)"
},
{
"path": "datamodel/unit.go",
"chars": 6367,
"preview": "package datamodel\n\n// Null is the one kind of node we can have a true singleton implementation of.\n// This is that value"
},
{
"path": "datamodel.go",
"chars": 4229,
"preview": "package ipld\n\nimport (\n\t\"github.com/ipld/go-ipld-prime/datamodel\"\n\t\"github.com/ipld/go-ipld-prime/linking\"\n\t\"github.com/"
},
{
"path": "doc.go",
"chars": 3569,
"preview": "// go-ipld-prime is a series of go interfaces for manipulating IPLD data.\n//\n// See https://ipld.io/ for more informatio"
},
{
"path": "examples_test.go",
"chars": 3389,
"preview": "package ipld_test\n\nimport (\n\t\"fmt\"\n\t\"os\"\n\t\"strings\"\n\n\t\"github.com/ipld/go-ipld-prime\"\n\t\"github.com/ipld/go-ipld-prime/co"
},
{
"path": "fluent/bench_test.go",
"chars": 5010,
"preview": "package fluent_test\n\nimport (\n\t\"strings\"\n\t\"testing\"\n\n\t\"github.com/ipld/go-ipld-prime/codec/dagjson\"\n\t\"github.com/ipld/go"
},
{
"path": "fluent/doc.go",
"chars": 992,
"preview": "/*\nThe fluent package offers helper utilities for using NodeAssembler\nmore tersely by providing an interface that handle"
},
{
"path": "fluent/fluentBuilder.go",
"chars": 5546,
"preview": "package fluent\n\nimport (\n\t\"github.com/ipld/go-ipld-prime/datamodel\"\n)\n\nfunc Build(np datamodel.NodePrototype, fn func(No"
},
{
"path": "fluent/fluentBuilder_test.go",
"chars": 2898,
"preview": "package fluent_test\n\nimport (\n\t\"testing\"\n\n\tqt \"github.com/frankban/quicktest\"\n\n\t\"github.com/ipld/go-ipld-prime/datamodel"
},
{
"path": "fluent/fluentRecover.go",
"chars": 574,
"preview": "package fluent\n\ntype Error struct {\n\tErr error\n}\n\nfunc (e Error) Error() string {\n\treturn e.Err.Error()\n}\n\n// Recover in"
},
{
"path": "fluent/fluentRecover_test.go",
"chars": 1216,
"preview": "package fluent_test\n\nimport (\n\t\"testing\"\n\n\tqt \"github.com/frankban/quicktest\"\n\n\t\"github.com/ipld/go-ipld-prime/datamodel"
},
{
"path": "fluent/qp/example_test.go",
"chars": 1112,
"preview": "package qp_test\n\nimport (\n\t\"os\"\n\n\t\"github.com/ipld/go-ipld-prime/codec/dagjson\"\n\t\"github.com/ipld/go-ipld-prime/datamode"
},
{
"path": "fluent/qp/qp.go",
"chars": 4199,
"preview": "// qp helps to quickly build IPLD nodes.\n//\n// It contains top-level Build funcs, such as BuildMap and BuildList, which\n"
},
{
"path": "fluent/reflect.go",
"chars": 9749,
"preview": "package fluent\n\nimport (\n\t\"fmt\"\n\t\"reflect\"\n\t\"sort\"\n\n\t\"github.com/ipld/go-ipld-prime/datamodel\"\n)\n\n// Reflect creates a n"
},
{
"path": "fluent/reflect_test.go",
"chars": 5175,
"preview": "package fluent_test\n\nimport (\n\t\"testing\"\n\n\tqt \"github.com/frankban/quicktest\"\n\n\t\"github.com/ipld/go-ipld-prime/datamodel"
},
{
"path": "fluent/toInterfaceValue.go",
"chars": 1783,
"preview": "package fluent\n\nimport (\n\t\"errors\"\n\n\t\"github.com/ipld/go-ipld-prime/datamodel\"\n)\n\nvar errInvalidKind = errors.New(\"inval"
},
{
"path": "fluent/toInterfaceValue_test.go",
"chars": 1325,
"preview": "package fluent_test\n\nimport (\n\t\"testing\"\n\n\tqt \"github.com/frankban/quicktest\"\n\t\"github.com/ipfs/go-cid\"\n\t\"github.com/ipl"
},
{
"path": "go.mod",
"chars": 1068,
"preview": "module github.com/ipld/go-ipld-prime\n\ngo 1.25.7\n\nrequire (\n\tgithub.com/frankban/quicktest v1.14.6\n\tgithub.com/google/go-"
},
{
"path": "go.sum",
"chars": 65167,
"preview": "cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=\ncloud.google.com/go v0.34.0/go.mod h1"
},
{
"path": "linking/cid/HACKME.md",
"chars": 3304,
"preview": "Why does this package exist?\n----------------------------\n\nThe `linking/cid` package bends the `github.com/ipfs/go-cid` "
},
{
"path": "linking/cid/cidLink.go",
"chars": 2526,
"preview": "package cidlink\n\nimport (\n\t\"fmt\"\n\n\tcid \"github.com/ipfs/go-cid\"\n\t\"github.com/ipld/go-ipld-prime/datamodel\"\n\tmultihash \"g"
},
{
"path": "linking/cid/linksystem.go",
"chars": 2799,
"preview": "package cidlink\n\nimport (\n\t\"fmt\"\n\t\"hash\"\n\n\tmultihash \"github.com/multiformats/go-multihash/core\"\n\n\t\"github.com/ipld/go-i"
},
{
"path": "linking/cid/memorystorage.go",
"chars": 1485,
"preview": "package cidlink\n\nimport (\n\t\"bytes\"\n\t\"fmt\"\n\t\"io\"\n\t\"os\"\n\n\t\"github.com/ipld/go-ipld-prime/datamodel\"\n\t\"github.com/ipld/go-i"
},
{
"path": "linking/errors.go",
"chars": 1162,
"preview": "package linking\n\nimport (\n\t\"fmt\"\n\n\t\"github.com/ipld/go-ipld-prime/datamodel\"\n)\n\n// ErrLinkingSetup is returned by method"
},
{
"path": "linking/functions.go",
"chars": 11538,
"preview": "package linking\n\nimport (\n\t\"bytes\"\n\t\"context\"\n\t\"io\"\n\n\t\"github.com/ipld/go-ipld-prime/datamodel\"\n)\n\n// This file contains"
},
{
"path": "linking/functions_test.go",
"chars": 2277,
"preview": "package linking_test\n\nimport (\n\t\"bytes\"\n\t\"context\"\n\t\"testing\"\n\n\tqt \"github.com/frankban/quicktest\"\n\t\"github.com/ipfs/go-"
},
{
"path": "linking/linkingExamples_test.go",
"chars": 6375,
"preview": "package linking_test\n\nimport (\n\t\"fmt\"\n\n\t\"github.com/ipfs/go-cid\"\n\n\t_ \"github.com/ipld/go-ipld-prime/codec/dagcbor\"\n\t\"git"
},
{
"path": "linking/preload/preload.go",
"chars": 1368,
"preview": "package preload\n\nimport (\n\t\"context\"\n\n\t\"github.com/ipld/go-ipld-prime/datamodel\"\n)\n\n// Loader is a function that will be"
},
{
"path": "linking/setup.go",
"chars": 1741,
"preview": "package linking\n\nimport (\n\t\"io\"\n\n\t\"github.com/ipld/go-ipld-prime/datamodel\"\n\t\"github.com/ipld/go-ipld-prime/storage\"\n)\n\n"
},
{
"path": "linking/types.go",
"chars": 10524,
"preview": "package linking\n\nimport (\n\t\"context\"\n\t\"hash\"\n\t\"io\"\n\n\t\"github.com/ipld/go-ipld-prime/codec\"\n\t\"github.com/ipld/go-ipld-pri"
},
{
"path": "linking.go",
"chars": 344,
"preview": "package ipld\n\nimport (\n\t\"github.com/ipld/go-ipld-prime/linking\"\n)\n\ntype (\n\tLinkSystem = linking.LinkSystem\n\tLinkContext"
},
{
"path": "multicodec/defaultRegistry.go",
"chars": 6945,
"preview": "package multicodec\n\nimport (\n\t\"github.com/ipld/go-ipld-prime/codec\"\n)\n\n// DefaultRegistry is a multicodec.Registry insta"
},
{
"path": "multicodec/registry.go",
"chars": 4230,
"preview": "package multicodec\n\nimport (\n\t\"fmt\"\n\n\t\"github.com/ipld/go-ipld-prime/codec\"\n)\n\n// Registry is a structure for storing ma"
},
{
"path": "must/must.go",
"chars": 2731,
"preview": "// Package 'must' provides another alternative to the 'fluent' package,\n// providing many helpful functions for wrapping"
},
{
"path": "node/basic/deprecated.go",
"chars": 1632,
"preview": "// This is a transitional package: please move your references to `node/basicnode`.\n// The new package is identical: we'"
},
{
"path": "node/basicnode/HACKME.md",
"chars": 6653,
"preview": "hackme\n======\n\nDesign rationale are documented here.\n\nThis doc is not necessary reading for users of this package,\nbut i"
},
{
"path": "node/basicnode/any.go",
"chars": 5761,
"preview": "package basicnode\n\nimport (\n\t\"github.com/ipld/go-ipld-prime/datamodel\"\n\t\"github.com/ipld/go-ipld-prime/linking\"\n)\n\nvar ("
},
{
"path": "node/basicnode/any_test.go",
"chars": 442,
"preview": "package basicnode_test\n\nimport (\n\t\"testing\"\n\n\t\"github.com/ipld/go-ipld-prime/node/basicnode\"\n\t\"github.com/ipld/go-ipld-p"
},
{
"path": "node/basicnode/bench_test.go",
"chars": 391,
"preview": "package basicnode_test\n\nimport (\n\t\"testing\"\n\n\t\"github.com/ipld/go-ipld-prime/node/basicnode\"\n\t\"github.com/ipld/go-ipld-p"
},
{
"path": "node/basicnode/bool.go",
"chars": 3970,
"preview": "package basicnode\n\nimport (\n\t\"github.com/ipld/go-ipld-prime/datamodel\"\n\t\"github.com/ipld/go-ipld-prime/node/mixins\"\n)\n\nv"
},
{
"path": "node/basicnode/bytes.go",
"chars": 4341,
"preview": "package basicnode\n\nimport (\n\t\"bytes\"\n\t\"io\"\n\n\t\"github.com/ipld/go-ipld-prime/datamodel\"\n\t\"github.com/ipld/go-ipld-prime/n"
},
{
"path": "node/basicnode/bytes_stream.go",
"chars": 2228,
"preview": "package basicnode\n\nimport (\n\t\"io\"\n\n\t\"github.com/ipld/go-ipld-prime/datamodel\"\n\t\"github.com/ipld/go-ipld-prime/node/mixin"
},
{
"path": "node/basicnode/bytes_test.go",
"chars": 227,
"preview": "package basicnode_test\n\nimport (\n\t\"testing\"\n\n\t\"github.com/ipld/go-ipld-prime/node/basicnode\"\n\t\"github.com/ipld/go-ipld-p"
},
{
"path": "node/basicnode/float.go",
"chars": 4065,
"preview": "package basicnode\n\nimport (\n\t\"github.com/ipld/go-ipld-prime/datamodel\"\n\t\"github.com/ipld/go-ipld-prime/node/mixins\"\n)\n\nv"
},
{
"path": "node/basicnode/int.go",
"chars": 6338,
"preview": "package basicnode\n\nimport (\n\t\"fmt\"\n\t\"math\"\n\n\t\"github.com/ipld/go-ipld-prime/datamodel\"\n\t\"github.com/ipld/go-ipld-prime/n"
},
{
"path": "node/basicnode/int_test.go",
"chars": 1128,
"preview": "package basicnode_test\n\nimport (\n\t\"testing\"\n\n\tqt \"github.com/frankban/quicktest\"\n\t\"github.com/ipld/go-ipld-prime/must\"\n\t"
},
{
"path": "node/basicnode/link.go",
"chars": 3975,
"preview": "package basicnode\n\nimport (\n\t\"github.com/ipld/go-ipld-prime/datamodel\"\n\t\"github.com/ipld/go-ipld-prime/node/mixins\"\n)\n\nv"
},
{
"path": "node/basicnode/list.go",
"chars": 11462,
"preview": "package basicnode\n\nimport (\n\t\"github.com/ipld/go-ipld-prime/datamodel\"\n\t\"github.com/ipld/go-ipld-prime/node/mixins\"\n)\n\nv"
},
{
"path": "node/basicnode/list_test.go",
"chars": 227,
"preview": "package basicnode_test\n\nimport (\n\t\"testing\"\n\n\t\"github.com/ipld/go-ipld-prime/node/basicnode\"\n\t\"github.com/ipld/go-ipld-p"
},
{
"path": "node/basicnode/map.go",
"chars": 16172,
"preview": "package basicnode\n\nimport (\n\t\"fmt\"\n\n\t\"github.com/ipld/go-ipld-prime/datamodel\"\n\t\"github.com/ipld/go-ipld-prime/node/mixi"
},
{
"path": "node/basicnode/map_test.go",
"chars": 9041,
"preview": "package basicnode_test\n\nimport (\n\t\"fmt\"\n\t\"testing\"\n\n\tqt \"github.com/frankban/quicktest\"\n\t\"github.com/ipld/go-ipld-prime/"
},
{
"path": "node/basicnode/prototypes.go",
"chars": 726,
"preview": "package basicnode\n\n// Prototype embeds a NodePrototype for every kind of Node implementation in this package.\n// You can"
},
{
"path": "node/basicnode/string.go",
"chars": 4359,
"preview": "package basicnode\n\nimport (\n\t\"github.com/ipld/go-ipld-prime/datamodel\"\n\t\"github.com/ipld/go-ipld-prime/node/mixins\"\n)\n\nv"
},
{
"path": "node/basicnode/string_test.go",
"chars": 230,
"preview": "package basicnode_test\n\nimport (\n\t\"testing\"\n\n\t\"github.com/ipld/go-ipld-prime/node/basicnode\"\n\t\"github.com/ipld/go-ipld-p"
},
{
"path": "node/bindnode/api.go",
"chars": 17880,
"preview": "// Package bindnode provides a datamodel.Node implementation via Go reflection.\n//\n// This package is EXPERIMENTAL; its "
},
{
"path": "node/bindnode/api_test.go",
"chars": 6707,
"preview": "package bindnode_test\n\nimport (\n\t\"encoding/hex\"\n\t\"math\"\n\t\"testing\"\n\n\tqt \"github.com/frankban/quicktest\"\n\t\"github.com/ipl"
},
{
"path": "node/bindnode/custom_test.go",
"chars": 21437,
"preview": "package bindnode_test\n\nimport (\n\t\"bytes\"\n\t\"encoding/hex\"\n\t\"errors\"\n\t\"fmt\"\n\t\"math/big\"\n\t\"strings\"\n\t\"testing\"\n\n\t\"github.co"
},
{
"path": "node/bindnode/example_test.go",
"chars": 3406,
"preview": "package bindnode_test\n\nimport (\n\t\"fmt\"\n\t\"os\"\n\n\t\"github.com/ipld/go-ipld-prime\"\n\t\"github.com/ipld/go-ipld-prime/codec/dag"
},
{
"path": "node/bindnode/fuzz_test.go",
"chars": 8489,
"preview": "//go:build go1.18\n\npackage bindnode_test\n\nimport (\n\t\"bytes\"\n\t\"fmt\"\n\t\"reflect\"\n\t\"strings\"\n\t\"testing\"\n\n\t\"github.com/ipld/g"
},
{
"path": "node/bindnode/generate.go",
"chars": 3734,
"preview": "package bindnode\n\nimport (\n\t\"bytes\"\n\t\"fmt\"\n\t\"go/format\"\n\t\"io\"\n\t\"strings\"\n\n\t\"github.com/ipld/go-ipld-prime/schema\"\n)\n\n// "
},
{
"path": "node/bindnode/infer.go",
"chars": 16090,
"preview": "package bindnode\n\nimport (\n\t\"fmt\"\n\t\"go/token\"\n\t\"reflect\"\n\t\"strings\"\n\n\t\"github.com/ipfs/go-cid\"\n\t\"github.com/ipld/go-ipld"
},
{
"path": "node/bindnode/infer_test.go",
"chars": 33644,
"preview": "package bindnode_test\n\nimport (\n\t\"bytes\"\n\t\"encoding/json\"\n\t\"fmt\"\n\t\"html/template\"\n\t\"os\"\n\t\"os/exec\"\n\t\"path/filepath\"\n\t\"re"
},
{
"path": "node/bindnode/node.go",
"chars": 52926,
"preview": "package bindnode\n\nimport (\n\t\"fmt\"\n\t\"math\"\n\t\"reflect\"\n\t\"runtime\"\n\t\"strings\"\n\n\t\"github.com/ipfs/go-cid\"\n\t\"github.com/ipld/"
},
{
"path": "node/bindnode/registry/registry.go",
"chars": 5474,
"preview": "package registry\n\nimport (\n\t\"errors\"\n\t\"fmt\"\n\t\"io\"\n\t\"reflect\"\n\n\t\"github.com/ipld/go-ipld-prime\"\n\t\"github.com/ipld/go-ipld"
},
{
"path": "node/bindnode/registry/registry_test.go",
"chars": 3145,
"preview": "package registry_test\n\nimport (\n\t\"bytes\"\n\t\"encoding/hex\"\n\t\"math\"\n\t\"testing\"\n\n\t\"github.com/ipld/go-ipld-prime/codec/dagcb"
},
{
"path": "node/bindnode/repr.go",
"chars": 38300,
"preview": "package bindnode\n\nimport (\n\t\"fmt\"\n\t\"reflect\"\n\t\"strings\"\n\n\t\"github.com/ipld/go-ipld-prime/datamodel\"\n\t\"github.com/ipld/go"
},
{
"path": "node/bindnode/schema_test.go",
"chars": 1394,
"preview": "package bindnode_test\n\nimport (\n\t\"strings\"\n\t\"testing\"\n\n\t\"github.com/ipld/go-ipld-prime/datamodel\"\n\t\"github.com/ipld/go-i"
},
{
"path": "node/bindnode/testdata/fuzz/FuzzBindnodeViaDagCBOR/164dd28629e6a5637f02c6eaad32eee5bf8ea41ce6d1dae95334a7db7dd6188f",
"chars": 64,
"preview": "go test fuzz v1\n[]byte(\"\\xa1etypes\\xa0\")\n[]byte(\"\\xf9\\xfc\\x00\")\n"
},
{
"path": "node/bindnode/testdata/fuzz/FuzzBindnodeViaDagCBOR/199afa754020c4587bc87633033b4e56ecdb5ecc2bb0dbac46b799d6c18c5201",
"chars": 62,
"preview": "go test fuzz v1\n[]byte(\"\\xa1etypes\\xa1d0000\\xa0\")\n[]byte(\"0\")\n"
},
{
"path": "node/bindnode/testdata/fuzz/FuzzBindnodeViaDagCBOR/2c17d42168478a0837ebba66f6aa98bdf4bb81b5196062d0e6b23c8b0325be6a",
"chars": 146,
"preview": "go test fuzz v1\n[]byte(\"\\xa1etypes\\xa1dRoot\\xa1fstruct\\xa2ffields\\xa2b00\\xa1dtypedBoolb00\\xa1dtypeeBytesnrepresentation\\"
},
{
"path": "node/bindnode/testdata/fuzz/FuzzBindnodeViaDagCBOR/425499b0c3693d87a0b11db10d21c540283dfb88610d114eb5b23485d5c2f342",
"chars": 108,
"preview": "go test fuzz v1\n[]byte(\"\\xa1etypes\\xa1dRoot\\xa1cmap\\xa2gkeyTypefStringivalueTypecInt\")\n[]byte(\"\\xa2ac0a00\")\n"
},
{
"path": "node/bindnode/testdata/fuzz/FuzzBindnodeViaDagCBOR/636f8e5cdaf52572b826e615a9bdf90f15f8acf2880b467b3949f5356c2ddded",
"chars": 146,
"preview": "go test fuzz v1\n[]byte(\"\\xa1etypes\\xa1dRoot\\xa1fstruct\\xa2ffields\\xa2b00\\xa1dtyped0000b00\\xa1dtypee00000nrepresentation\\"
},
{
"path": "node/bindnode/testdata/fuzz/FuzzBindnodeViaDagCBOR/669d57fbbe55b8ceb7e78e3ccd3b90e76c4b740d25284a66eac8aac0dbb2475d",
"chars": 148,
"preview": "go test fuzz v1\n[]byte(\"\\xa1etypes\\xa1dRoot\\xa1eunion\\xa2gmembers\\x82cIntfStringnrepresentation\\xa1ekeyed\\xa2a0c000a0a00"
},
{
"path": "node/bindnode/testdata/fuzz/FuzzBindnodeViaDagCBOR/7f9a6898dead41ba2f5fd4f07f2ddb44d54e7648d66e54982d09996bc720cf56",
"chars": 94,
"preview": "go test fuzz v1\n[]byte(\"\\xa1etypes\\xa1dRoot\\xa1dlist\\xa1ivalueTypedRootcInt\")\n[]byte(\"\\x810\")\n"
},
{
"path": "node/bindnode/testdata/fuzz/FuzzBindnodeViaDagCBOR/821c248529299bb6b68e443e4b00cc11c6605f766f25e619d85e6d6b40a33dac",
"chars": 131,
"preview": "go test fuzz v1\n[]byte(\"\\xa1etypes\\xa1dRoot\\xa1denum\\xa2gmembers\\x82c000c000nrepresentation\\xa1cint\\xa2c0000c0000\")\n[]by"
},
{
"path": "node/bindnode/testdata/fuzz/FuzzBindnodeViaDagCBOR/bf7c410983f3e696a03e743df1bc6f606137871f7fb557af74836b7aa04e56ad",
"chars": 61,
"preview": "go test fuzz v1\n[]byte(\"\\xa1etypes\\xa0\")\n[]byte(\"\\xf9|\\x00\")\n"
},
{
"path": "node/bindnode/testdata/fuzz/FuzzBindnodeViaDagCBOR/dc95e9aad454ed9109e93b824f92d4bb00c9c778af29e6fcb38a6083c78d7dbb",
"chars": 98,
"preview": "go test fuzz v1\n[]byte(\"\\xa1etypes\\xa1d0000\\xa1dlist\\xa1ivalueTypea0\")\n[]byte(\"\\xfa\\u007f\\xff00\")\n"
},
{
"path": "node/bindnode/testdata/fuzz/FuzzBindnodeViaDagCBOR/f63d4652cdac3208fc0a0d0b755615320443b60ef80c0ecdef99c9d895ae2124",
"chars": 130,
"preview": "go test fuzz v1\n[]byte(\"\\xa1etypes\\xa1dRoot\\xa1eunion\\xa2gmembers\\x82cIntfStringnrepresentation\\xa1ekeyed\\xa0\")\n[]byte(\""
},
{
"path": "node/bindnode/testdata/fuzz/FuzzBindnodeViaDagCBOR/fe73a19655fff8b93193c3e90f9cd7b24b10ae0467175cf2264ff3ec135215a6",
"chars": 134,
"preview": "go test fuzz v1\n[]byte(\"\\xa1etypes\\xa1dRoot\\xa1denum\\xa2gmembers\\x82a1b00nrepresentation\\xa1fstring\\xa2a0a0a0`\")\n[]byte("
},
{
"path": "node/doc.go",
"chars": 1234,
"preview": "/*\nThe 'node' package gathers various general purpose Node implementations;\nthe first one you should jump to is 'node/ba"
},
{
"path": "node/gendemo/doc.go",
"chars": 865,
"preview": "// The gendemo package contains some what codegen output code,\n// so that it can demonstrate what schema-based codegen l"
},
{
"path": "node/gendemo/gen.go",
"chars": 1200,
"preview": "//go:build ignore\n\npackage main\n\nimport (\n\t\"github.com/ipld/go-ipld-prime/datamodel\"\n\t\"github.com/ipld/go-ipld-prime/sch"
},
{
"path": "node/gendemo/gendemo_test.go",
"chars": 1357,
"preview": "package gendemo\n\nimport (\n\t\"testing\"\n\n\t\"github.com/ipld/go-ipld-prime/node/tests\"\n)\n\nfunc BenchmarkMapStrInt_3n_Assemble"
},
{
"path": "node/gendemo/ipldsch_minima.go",
"chars": 1711,
"preview": "package gendemo\n\n// Code generated by go-ipld-prime gengo. DO NOT EDIT.\n\nimport (\n\t\"fmt\"\n\n\t\"github.com/ipld/go-ipld-pri"
},
{
"path": "node/gendemo/ipldsch_satisfaction.go",
"chars": 107044,
"preview": "package gendemo\n\n// Code generated by go-ipld-prime gengo. DO NOT EDIT.\n\nimport (\n\t\"github.com/ipld/go-ipld-prime/datam"
},
{
"path": "node/gendemo/ipldsch_types.go",
"chars": 2834,
"preview": "package gendemo\n\n// Code generated by go-ipld-prime gengo. DO NOT EDIT.\n\nimport (\n\t\"github.com/ipld/go-ipld-prime/datam"
},
{
"path": "node/mixins/HACKME.md",
"chars": 1667,
"preview": "node mixins and how to use them\n===============================\n\nThese mixins are here to:\n\n1. reduce the amount of code"
},
{
"path": "node/mixins/bool.go",
"chars": 4997,
"preview": "package mixins\n\nimport (\n\t\"github.com/ipld/go-ipld-prime/datamodel\"\n)\n\n// Bool can be embedded in a struct to provide al"
},
{
"path": "node/mixins/bytes.go",
"chars": 5035,
"preview": "package mixins\n\nimport (\n\t\"github.com/ipld/go-ipld-prime/datamodel\"\n)\n\n// Bytes can be embedded in a struct to provide a"
},
{
"path": "node/mixins/delim.go",
"chars": 1496,
"preview": "package mixins\n\n// This file is a little different than most of its siblings in this package.\n// It's not really much of"
},
{
"path": "node/mixins/delim_test.go",
"chars": 982,
"preview": "package mixins\n\nimport (\n\t\"fmt\"\n\t\"reflect\"\n\t\"testing\"\n\n\t\"github.com/google/go-cmp/cmp\"\n\n\tqt \"github.com/frankban/quickte"
},
{
"path": "node/mixins/float.go",
"chars": 5035,
"preview": "package mixins\n\nimport (\n\t\"github.com/ipld/go-ipld-prime/datamodel\"\n)\n\n// Float can be embedded in a struct to provide a"
},
{
"path": "node/mixins/int.go",
"chars": 4959,
"preview": "package mixins\n\nimport (\n\t\"github.com/ipld/go-ipld-prime/datamodel\"\n)\n\n// Int can be embedded in a struct to provide all"
},
{
"path": "node/mixins/link.go",
"chars": 4979,
"preview": "package mixins\n\nimport (\n\t\"github.com/ipld/go-ipld-prime/datamodel\"\n)\n\n// Link can be embedded in a struct to provide al"
},
{
"path": "node/mixins/list.go",
"chars": 4569,
"preview": "package mixins\n\nimport (\n\t\"github.com/ipld/go-ipld-prime/datamodel\"\n)\n\n// List can be embedded in a struct to provide al"
},
{
"path": "node/mixins/map.go",
"chars": 4299,
"preview": "package mixins\n\nimport (\n\t\"github.com/ipld/go-ipld-prime/datamodel\"\n)\n\n// Map can be embedded in a struct to provide all"
},
{
"path": "node/mixins/string.go",
"chars": 5079,
"preview": "package mixins\n\nimport (\n\t\"github.com/ipld/go-ipld-prime/datamodel\"\n)\n\n// String can be embedded in a struct to provide "
},
{
"path": "node/mixins/tmplMixin.txt",
"chars": 5351,
"preview": "// copy this and remove methods that aren't relevant to your kind.\n// this has not been scripted.\n// (the first part is "
},
{
"path": "node/tests/HACKME.md",
"chars": 3015,
"preview": "HACKME\n======\n\nThis package is for reusable tests and benchmarks.\nThese test and benchmark functions work over the Node "
},
{
"path": "node/tests/byteSpecs.go",
"chars": 780,
"preview": "package tests\n\nimport (\n\t\"io\"\n\t\"testing\"\n\n\tqt \"github.com/frankban/quicktest\"\n\n\t\"github.com/ipld/go-ipld-prime/datamodel"
},
{
"path": "node/tests/checkers.go",
"chars": 5832,
"preview": "package tests\n\nimport (\n\t\"errors\"\n\n\tqt \"github.com/frankban/quicktest\"\n\n\t\"github.com/ipld/go-ipld-prime/datamodel\"\n\t\"git"
},
{
"path": "node/tests/checkers_test.go",
"chars": 1541,
"preview": "package tests\n\nimport (\n\t\"testing\"\n\n\tqt \"github.com/frankban/quicktest\"\n\n\t\"github.com/ipld/go-ipld-prime/node/basicnode\""
},
{
"path": "node/tests/corpus/corpus.go",
"chars": 2108,
"preview": "/*\nThe corpus package exports some values useful for building tests and benchmarks.\n\nValues come as JSON strings. It is"
},
{
"path": "node/tests/corpus/corpus_test.go",
"chars": 591,
"preview": "package corpus\n\nimport (\n\t\"encoding/json\"\n\t\"testing\"\n\n\t\"github.com/ipld/go-ipld-prime/must\"\n)\n\n/*\n\tSanity check that our"
},
{
"path": "node/tests/corpus/util.go",
"chars": 271,
"preview": "package corpus\n\nimport (\n\t\"bytes\"\n)\n\nfunc ents(n int, segFn func(i int) string) string {\n\tif n <= 0 {\n\t\treturn \"\"\n\t}\n\tva"
},
{
"path": "node/tests/listSpecs.go",
"chars": 1814,
"preview": "package tests\n\nimport (\n\t\"testing\"\n\n\tqt \"github.com/frankban/quicktest\"\n\n\t\"github.com/ipld/go-ipld-prime/datamodel\"\n\t\"gi"
},
{
"path": "node/tests/mapBenchmarks.go",
"chars": 2068,
"preview": "package tests\n\nimport (\n\t\"testing\"\n\n\t\"github.com/ipld/go-ipld-prime/datamodel\"\n\t\"github.com/ipld/go-ipld-prime/must\"\n)\n\n"
},
{
"path": "node/tests/mapBenchmarks_test.go",
"chars": 1804,
"preview": "package tests\n\nimport (\n\t\"encoding/json\"\n\t\"testing\"\n\n\t\"github.com/ipld/go-ipld-prime/must\"\n)\n\n// This is analogous to th"
},
{
"path": "node/tests/mapFixtures.go",
"chars": 1259,
"preview": "package tests\n\nimport (\n\t\"fmt\"\n\n\t\"github.com/ipld/go-ipld-prime/datamodel\"\n\t\"github.com/ipld/go-ipld-prime/must\"\n)\n\nvar "
},
{
"path": "node/tests/mapSpecs.go",
"chars": 7377,
"preview": "package tests\n\nimport (\n\t\"testing\"\n\n\tqt \"github.com/frankban/quicktest\"\n\n\t\"github.com/ipld/go-ipld-prime/datamodel\"\n\t\"gi"
},
{
"path": "node/tests/marshalBenchmarks.go",
"chars": 1750,
"preview": "package tests\n\nimport (\n\t\"bytes\"\n\t\"fmt\"\n\t\"strings\"\n\t\"testing\"\n\n\t\"github.com/ipld/go-ipld-prime/codec/json\"\n\t\"github.com/"
},
{
"path": "node/tests/schema.go",
"chars": 1890,
"preview": "package tests\n\nimport \"testing\"\n\n// use a table instead of a map, to get a consistent order\n\nvar allSchemaTests = []stru"
},
{
"path": "node/tests/schemaLinks.go",
"chars": 4745,
"preview": "package tests\n\nimport (\n\t\"bytes\"\n\t\"fmt\"\n\t\"testing\"\n\n\tqt \"github.com/frankban/quicktest\"\n\n\t\"github.com/ipfs/go-cid\"\n\t\"git"
},
{
"path": "node/tests/schemaLists.go",
"chars": 9159,
"preview": "package tests\n\nimport (\n\t\"testing\"\n\n\tqt \"github.com/frankban/quicktest\"\n\n\t\"github.com/ipld/go-ipld-prime/datamodel\"\n\t\"gi"
},
{
"path": "node/tests/schemaMaps.go",
"chars": 9969,
"preview": "package tests\n\nimport (\n\t\"testing\"\n\n\tqt \"github.com/frankban/quicktest\"\n\n\t\"github.com/ipld/go-ipld-prime/datamodel\"\n\t\"gi"
},
{
"path": "node/tests/schemaScalars.go",
"chars": 4126,
"preview": "package tests\n\nimport (\n\t\"fmt\"\n\t\"testing\"\n\n\tqt \"github.com/frankban/quicktest\"\n\n\t\"github.com/ipld/go-ipld-prime/datamode"
},
{
"path": "node/tests/schemaStruct.go",
"chars": 4536,
"preview": "package tests\n\nimport (\n\t\"testing\"\n\n\tqt \"github.com/frankban/quicktest\"\n\n\t\"github.com/ipld/go-ipld-prime/datamodel\"\n\t\"gi"
},
{
"path": "node/tests/schemaStructReprListpairs.go",
"chars": 14030,
"preview": "package tests\n\nimport (\n\t\"testing\"\n\n\tqt \"github.com/frankban/quicktest\"\n\n\t\"github.com/ipld/go-ipld-prime/datamodel\"\n\t\"gi"
},
{
"path": "node/tests/schemaStructReprStringjoin.go",
"chars": 6226,
"preview": "package tests\n\nimport (\n\t\"testing\"\n\n\tqt \"github.com/frankban/quicktest\"\n\n\t\"github.com/ipld/go-ipld-prime/datamodel\"\n\t\"gi"
},
{
"path": "node/tests/schemaStructReprTuple.go",
"chars": 5295,
"preview": "package tests\n\nimport (\n\t\"testing\"\n\n\tqt \"github.com/frankban/quicktest\"\n\n\t\"github.com/ipld/go-ipld-prime/datamodel\"\n\t\"gi"
},
{
"path": "node/tests/schemaStructsContainingMaybe.go",
"chars": 4635,
"preview": "package tests\n\nimport (\n\t\"testing\"\n\n\t\"github.com/ipld/go-ipld-prime/datamodel\"\n\t\"github.com/ipld/go-ipld-prime/schema\"\n)"
},
{
"path": "node/tests/schemaUnions.go",
"chars": 5506,
"preview": "package tests\n\nimport (\n\t\"testing\"\n\n\t\"github.com/ipld/go-ipld-prime/datamodel\"\n\t\"github.com/ipld/go-ipld-prime/schema\"\n)"
},
{
"path": "node/tests/schemaUnionsKinded.go",
"chars": 1890,
"preview": "package tests\n\nimport (\n\t\"testing\"\n\n\t\"github.com/ipld/go-ipld-prime/datamodel\"\n\t\"github.com/ipld/go-ipld-prime/schema\"\n)"
},
{
"path": "node/tests/schemaUnionsStringprefix.go",
"chars": 1994,
"preview": "package tests\n\nimport (\n\t\"testing\"\n\n\t\"github.com/ipld/go-ipld-prime/datamodel\"\n\t\"github.com/ipld/go-ipld-prime/schema\"\n)"
},
{
"path": "node/tests/stringSpecs.go",
"chars": 523,
"preview": "package tests\n\nimport (\n\t\"testing\"\n\n\tqt \"github.com/frankban/quicktest\"\n\n\t\"github.com/ipld/go-ipld-prime/datamodel\"\n)\n\nf"
},
{
"path": "node/tests/testEngine.go",
"chars": 792,
"preview": "package tests\n\nimport (\n\t\"testing\"\n\n\t\"github.com/ipld/go-ipld-prime/datamodel\"\n\t\"github.com/ipld/go-ipld-prime/schema\"\n)"
},
{
"path": "node/tests/testcase.go",
"chars": 15743,
"preview": "package tests\n\nimport (\n\t\"bytes\"\n\t\"errors\"\n\t\"fmt\"\n\t\"strings\"\n\t\"testing\"\n\n\tqt \"github.com/frankban/quicktest\"\n\t\"github.co"
}
]
// ... and 177 more files (download for full content)
About this extraction
This page contains the full source code of the ipld/go-ipld-prime GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 377 files (2.0 MB), approximately 545.7k tokens, and a symbol index with 4005 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.