package cid

Import Path
	github.com/ipfs/go-cid (on go.dev)

Dependency Relation
	imports 11 packages, and imported by 3 packages

Involved Source Files

	    builder.go
	  d cid.go
		Package cid implements the Content-IDentifiers specification
		(https://github.com/ipld/cid) in Go. CIDs are
		self-describing content-addressed identifiers useful for
		distributed information systems. CIDs are used in the IPFS
		(https://ipfs.io) project ecosystem.
		
		CIDs have two major versions. A CIDv0 corresponds to a multihash of type
		DagProtobuf, is deprecated and exists for compatibility reasons. Usually,
		CIDv1 should be used.
		
		A CIDv1 has four parts:
		
			<cidv1> ::= <multibase-prefix><cid-version><multicodec-packed-content-type><multihash-content-address>
		
		As shown above, the CID implementation relies heavily on Multiformats,
		particularly Multibase
		(https://github.com/multiformats/go-multibase), Multicodec
		(https://github.com/multiformats/multicodec) and Multihash
		implementations (https://github.com/multiformats/go-multihash).

	    deprecated.go
	    set.go
	    varint.go
Package-Level Type Names (total 7)

	/* sort by: alphabet | popularity */
	 type Builder (interface)

		Methods (total 3)
			( Builder) GetCodec() uint64
			( Builder) Sum(data []byte) (Cid, error)
			( Builder) WithCodec(uint64) Builder
		Implemented By (at least 3)
			 Prefix
			 V0Builder
			 V1Builder
		As Outputs Of (at least 4)
			func Builder.WithCodec(uint64) Builder
			func Prefix.WithCodec(c uint64) Builder
			func V0Builder.WithCodec(c uint64) Builder
			func V1Builder.WithCodec(c uint64) Builder

	 type Cid (struct)
		Cid represents a self-describing content addressed
		identifier. It is formed by a Version, a Codec (which indicates
		a multicodec-packed content type) and a Multihash.

		Methods (total 20)
			( Cid) ByteLen() int
				ByteLen returns the length of the CID in bytes.
				It's equivalent to `len(c.Bytes())`, but works without an allocation,
				and should therefore be preferred.
				
				(See also the WriteTo method for other important operations that work without allocation.)

			( Cid) Bytes() []byte
				Bytes returns the byte representation of a Cid.
				The output of bytes can be parsed back into a Cid
				with Cast().
				
				If c.Defined() == false, it return a nil slice and may not
				be parsable with Cast().

			( Cid) Defined() bool
				Defined returns true if a Cid is defined
				Calling any other methods on an undefined Cid will result in
				undefined behavior.

			( Cid) Encode(base mbase.Encoder) string
				Encode return the string representation of a Cid in a given base
				when applicable.  Version 0 Cid's are always in Base58 as they do
				not take a multibase prefix.

			( Cid) Equals(o Cid) bool
				Equals checks that two Cids are the same.
				In order for two Cids to be considered equal, the
				Version, the Codec and the Multihash must match.

			( Cid) Hash() mh.Multihash
				Hash returns the multihash contained by a Cid.

			( Cid) KeyString() string
				KeyString returns the binary representation of the Cid as a string

			( Cid) Loggable() map[string]interface{}
				Loggable returns a Loggable (as defined by
				https://godoc.org/github.com/ipfs/go-log).

			( Cid) MarshalBinary() ([]byte, error)
				MarshalBinary is equivalent to Bytes(). It implements the
				encoding.BinaryMarshaler interface.

			( Cid) MarshalJSON() ([]byte, error)
				MarshalJSON procudes a JSON representation of a Cid, which looks as follows:
				
					{ "/": "<cid-string>" }
				
				Note that this formatting comes from the IPLD specification
				(https://github.com/ipld/specs/tree/master/ipld)

			( Cid) MarshalText() ([]byte, error)
				MarshalText is equivalent to String(). It implements the
				encoding.TextMarshaler interface.

			( Cid) Prefix() Prefix
				Prefix builds and returns a Prefix out of a Cid.

			( Cid) String() string
				String returns the default string representation of a
				Cid. Currently, Base32 is used for CIDV1 as the encoding for the
				multibase string, Base58 is used for CIDV0.

			( Cid) StringOfBase(base mbase.Encoding) (string, error)
				String returns the string representation of a Cid
				encoded is selected base

			( Cid) Type() uint64
				Type returns the multicodec-packed content type of a Cid.

			(*Cid) UnmarshalBinary(data []byte) error
				UnmarshalBinary is equivalent to Cast(). It implements the
				encoding.BinaryUnmarshaler interface.

			(*Cid) UnmarshalJSON(b []byte) error
				UnmarshalJSON parses the JSON representation of a Cid.

			(*Cid) UnmarshalText(text []byte) error
				UnmarshalText is equivalent to Decode(). It implements the
				encoding.TextUnmarshaler interface.

			( Cid) Version() uint64
				Version returns the Cid version.

			( Cid) WriteBytes(w io.Writer) (int, error)
				WriteBytes writes the CID bytes to the given writer.
				This method works without incurring any allocation.
				
				(See also the ByteLen method for other important operations that work without allocation.)

		Implements (at least 11)
			 Cid : github.com/apache/arrow-go/v18/internal/hashing.ByteSlice
			 Cid : github.com/goccy/go-json.Marshaler
			*Cid : github.com/goccy/go-json.Unmarshaler
			 Cid : encoding.BinaryMarshaler
			*Cid : encoding.BinaryUnmarshaler
			 Cid : encoding.TextMarshaler
			*Cid : encoding.TextUnmarshaler
			 Cid : encoding/json.Marshaler
			*Cid : encoding/json.Unmarshaler
			 Cid : expvar.Var
			 Cid : fmt.Stringer
		As Outputs Of (at least 14)
			func Cast(data []byte) (Cid, error)
			func CidFromBytes(data []byte) (int, Cid, error)
			func CidFromReader(r io.Reader) (int, Cid, error)
			func Decode(v string) (Cid, error)
			func MustParse(v interface{}) Cid
			func NewCidV0(mhash mh.Multihash) Cid
			func NewCidV1(codecType uint64, mhash mh.Multihash) Cid
			func Parse(v interface{}) (Cid, error)
			func Builder.Sum(data []byte) (Cid, error)
			func Prefix.Sum(data []byte) (Cid, error)
			func (*Set).Keys() []Cid
			func V0Builder.Sum(data []byte) (Cid, error)
			func V1Builder.Sum(data []byte) (Cid, error)
			func github.com/libp2p/go-libp2p/core/peer.ToCid(id peer.ID) Cid
		As Inputs Of (at least 12)
			func Cid.Equals(o Cid) bool
			func (*Set).Add(c Cid)
			func (*Set).Has(c Cid) bool
			func (*Set).Remove(c Cid)
			func (*Set).Visit(c Cid) bool
			func github.com/libp2p/go-libp2p/core/peer.FromCid(c Cid) (peer.ID, error)
			func github.com/libp2p/go-libp2p/core/routing.ContentDiscovery.FindProvidersAsync(context.Context, Cid, int) <-chan peer.AddrInfo
			func github.com/libp2p/go-libp2p/core/routing.ContentProviding.Provide(context.Context, Cid, bool) error
			func github.com/libp2p/go-libp2p/core/routing.ContentRouting.FindProvidersAsync(context.Context, Cid, int) <-chan peer.AddrInfo
			func github.com/libp2p/go-libp2p/core/routing.ContentRouting.Provide(context.Context, Cid, bool) error
			func github.com/libp2p/go-libp2p/core/routing.Routing.FindProvidersAsync(context.Context, Cid, int) <-chan peer.AddrInfo
			func github.com/libp2p/go-libp2p/core/routing.Routing.Provide(context.Context, Cid, bool) error
		As Types Of (only one)
			  var Undef

	 type ErrInvalidCid (struct)
		ErrInvalidCid is an error that indicates that a CID is invalid.

		Fields (only one)
			Err error
		Methods (total 3)
			( ErrInvalidCid) Error() string
			( ErrInvalidCid) Is(err error) bool
			( ErrInvalidCid) Unwrap() error
		Implements (at least 2)
			 ErrInvalidCid : error
			 ErrInvalidCid : golang.org/x/xerrors.Wrapper
		As Types Of (only one)
			  var ErrCidTooShort

	 type Prefix (struct)
		Prefix represents all the metadata of a Cid,
		that is, the Version, the Codec, the Multihash type
		and the Multihash length. It does not contains
		any actual content information.
		NOTE: The use -1 in MhLength to mean default length is deprecated,
		
			use the V0Builder or V1Builder structures instead

		Fields (total 4)
			Codec uint64
			MhLength int
			MhType uint64
			Version uint64
		Methods (total 4)
			( Prefix) Bytes() []byte
				Bytes returns a byte representation of a Prefix. It looks like:
				
					<version><codec><mh-type><mh-length>

			( Prefix) GetCodec() uint64
			( Prefix) Sum(data []byte) (Cid, error)
				Sum uses the information in a prefix to perform a multihash.Sum()
				and return a newly constructed Cid with the resulting multihash.

			( Prefix) WithCodec(c uint64) Builder
		Implements (at least 2)
			 Prefix : Builder
			 Prefix : github.com/apache/arrow-go/v18/internal/hashing.ByteSlice
		As Outputs Of (at least 4)
			func NewPrefixV0(mhType uint64) Prefix
			func NewPrefixV1(codecType uint64, mhType uint64) Prefix
			func PrefixFromBytes(buf []byte) (Prefix, error)
			func Cid.Prefix() Prefix

	 type Set (struct)
		Set is a implementation of a set of Cids, that is, a structure
		to which holds a single copy of every Cids that is added to it.

		Methods (total 7)
			(*Set) Add(c Cid)
				Add puts a Cid in the Set.

			(*Set) ForEach(f func(c Cid) error) error
				ForEach allows to run a custom function on each
				Cid in the set.

			(*Set) Has(c Cid) bool
				Has returns if the Set contains a given Cid.

			(*Set) Keys() []Cid
				Keys returns the Cids in the set.

			(*Set) Len() int
				Len returns how many elements the Set has.

			(*Set) Remove(c Cid)
				Remove deletes a Cid from the Set.

			(*Set) Visit(c Cid) bool
				Visit adds a Cid to the set only if it is
				not in it already.

		As Outputs Of (at least one exported)
			func NewSet() *Set

	 type V0Builder (struct)

		Methods (total 3)
			( V0Builder) GetCodec() uint64
			( V0Builder) Sum(data []byte) (Cid, error)
			( V0Builder) WithCodec(c uint64) Builder
		Implements (at least one exported)
			 V0Builder : Builder

	 type V1Builder (struct)

		Fields (total 3)
			Codec uint64
			MhLength int
				// MhLength <= 0 means the default length

			MhType uint64
		Methods (total 3)
			( V1Builder) GetCodec() uint64
			( V1Builder) Sum(data []byte) (Cid, error)
			( V1Builder) WithCodec(c uint64) Builder
		Implements (at least one exported)
			 V1Builder : Builder


Package-Level Functions (total 13)

	 func Cast(data []byte) (Cid, error)
		Cast takes a Cid data slice, parses it and returns a Cid.
		For CidV1, the data buffer is in the form:
		
			<version><codec-type><multihash>
		
		CidV0 are also supported. In particular, data buffers starting
		with length 34 bytes, which starts with bytes [18,32...] are considered
		binary multihashes.
		
		Please use decode when parsing a regular Cid string, as Cast does not
		expect multibase-encoded data. Cast accepts the output of Cid.Bytes().

	 func CidFromBytes(data []byte) (int, Cid, error)
	 func CidFromReader(r io.Reader) (int, Cid, error)
		CidFromReader reads a precise number of bytes for a CID from a given reader.
		It returns the number of bytes read, the CID, and any error encountered.
		The number of bytes read is accurate even if a non-nil error is returned.
		
		It's recommended to supply a reader that buffers and implements io.ByteReader,
		as CidFromReader has to do many single-byte reads to decode varints.
		If the argument only implements io.Reader, single-byte Read calls are used instead.
		
		If the Reader is found to yield zero bytes, an io.EOF error is returned directly, in all
		other error cases, an ErrInvalidCid, wrapping the original error, is returned.

	 func Decode(v string) (Cid, error)
		Decode parses a Cid-encoded string and returns a Cid object.
		For CidV1, a Cid-encoded string is primarily a multibase string:
		
			<multibase-type-code><base-encoded-string>
		
		The base-encoded string represents a:
		
		<version><codec-type><multihash>
		
		Decode will also detect and parse CidV0 strings. Strings
		starting with "Qm" are considered CidV0 and treated directly
		as B58-encoded multihashes.

	 func ExtractEncoding(v string) (mbase.Encoding, error)
		Extract the encoding from a Cid.  If Decode on the same string did
		not return an error neither will this function.

	 func MustParse(v interface{}) Cid
		MustParse calls Parse but will panic on error.

	 func NewCidV0(mhash mh.Multihash) Cid
		NewCidV0 returns a Cid-wrapped multihash.
		They exist to allow IPFS to work with Cids while keeping
		compatibility with the plain-multihash format used used in IPFS.
		NewCidV1 should be used preferentially.
		
		Panics if the multihash isn't sha2-256.

	 func NewCidV1(codecType uint64, mhash mh.Multihash) Cid
		NewCidV1 returns a new Cid using the given multicodec-packed
		content type.
		
		Panics if the multihash is invalid.

	 func NewPrefixV0(mhType uint64) Prefix
		NewPrefixV0 returns a CIDv0 prefix with the specified multihash type.
		DEPRECATED: Use V0Builder

	 func NewPrefixV1(codecType uint64, mhType uint64) Prefix
		NewPrefixV1 returns a CIDv1 prefix with the specified codec and multihash
		type.
		DEPRECATED: Use V1Builder

	 func NewSet() *Set
		NewSet initializes and returns a new Set.

	 func Parse(v interface{}) (Cid, error)
		Parse is a short-hand function to perform Decode, Cast etc... on
		a generic interface{} type.

	 func PrefixFromBytes(buf []byte) (Prefix, error)
		PrefixFromBytes parses a Prefix-byte representation onto a
		Prefix.


Package-Level Variables (total 3)

	  var ErrCidTooShort ErrInvalidCid
		ErrCidTooShort means that the cid passed to decode was not long
		enough to be a valid Cid

	  var ErrInvalidEncoding error
		ErrInvalidEncoding means that selected encoding is not supported
		by this Cid version

	  var Undef Cid
		Undef can be used to represent a nil or undefined Cid, using Cid{}
		directly is also acceptable.


Package-Level Constants (total 27)

	const BitcoinBlock = 176
		Consts below are DEPRECATED and left only for legacy reasons:
		<https://github.com/ipfs/go-cid/pull/137>
		Modern code should use consts from go-multicodec instead:
		<https://github.com/multiformats/go-multicodec>

	const BitcoinTx = 177
		Consts below are DEPRECATED and left only for legacy reasons:
		<https://github.com/ipfs/go-cid/pull/137>
		Modern code should use consts from go-multicodec instead:
		<https://github.com/multiformats/go-multicodec>

	const DagCBOR = 113 // https://ipld.io/docs/codecs/known/dag-cbor/
		Consts below are DEPRECATED and left only for legacy reasons:
		<https://github.com/ipfs/go-cid/pull/137>
		Modern code should use consts from go-multicodec instead:
		<https://github.com/multiformats/go-multicodec>

	const DagJOSE = 133 // https://ipld.io/specs/codecs/dag-jose/spec/
		Consts below are DEPRECATED and left only for legacy reasons:
		<https://github.com/ipfs/go-cid/pull/137>
		Modern code should use consts from go-multicodec instead:
		<https://github.com/multiformats/go-multicodec>

	const DagJSON = 297 // https://ipld.io/docs/codecs/known/dag-json/
		Consts below are DEPRECATED and left only for legacy reasons:
		<https://github.com/ipfs/go-cid/pull/137>
		Modern code should use consts from go-multicodec instead:
		<https://github.com/multiformats/go-multicodec>

	const DagProtobuf = 112 // https://ipld.io/docs/codecs/known/dag-pb/
		Consts below are DEPRECATED and left only for legacy reasons:
		<https://github.com/ipfs/go-cid/pull/137>
		Modern code should use consts from go-multicodec instead:
		<https://github.com/multiformats/go-multicodec>

	const DashBlock = 240
		Consts below are DEPRECATED and left only for legacy reasons:
		<https://github.com/ipfs/go-cid/pull/137>
		Modern code should use consts from go-multicodec instead:
		<https://github.com/multiformats/go-multicodec>

	const DashTx = 241
		Consts below are DEPRECATED and left only for legacy reasons:
		<https://github.com/ipfs/go-cid/pull/137>
		Modern code should use consts from go-multicodec instead:
		<https://github.com/multiformats/go-multicodec>

	const DecredBlock = 224
		Consts below are DEPRECATED and left only for legacy reasons:
		<https://github.com/ipfs/go-cid/pull/137>
		Modern code should use consts from go-multicodec instead:
		<https://github.com/multiformats/go-multicodec>

	const DecredTx = 225
		Consts below are DEPRECATED and left only for legacy reasons:
		<https://github.com/ipfs/go-cid/pull/137>
		Modern code should use consts from go-multicodec instead:
		<https://github.com/multiformats/go-multicodec>

	const EthAccountSnapshot = 151
		Consts below are DEPRECATED and left only for legacy reasons:
		<https://github.com/ipfs/go-cid/pull/137>
		Modern code should use consts from go-multicodec instead:
		<https://github.com/multiformats/go-multicodec>

	const EthBlock = 144
		Consts below are DEPRECATED and left only for legacy reasons:
		<https://github.com/ipfs/go-cid/pull/137>
		Modern code should use consts from go-multicodec instead:
		<https://github.com/multiformats/go-multicodec>

	const EthBlockList = 145
		Consts below are DEPRECATED and left only for legacy reasons:
		<https://github.com/ipfs/go-cid/pull/137>
		Modern code should use consts from go-multicodec instead:
		<https://github.com/multiformats/go-multicodec>

	const EthStateTrie = 150
		Consts below are DEPRECATED and left only for legacy reasons:
		<https://github.com/ipfs/go-cid/pull/137>
		Modern code should use consts from go-multicodec instead:
		<https://github.com/multiformats/go-multicodec>

	const EthStorageTrie = 152
		Consts below are DEPRECATED and left only for legacy reasons:
		<https://github.com/ipfs/go-cid/pull/137>
		Modern code should use consts from go-multicodec instead:
		<https://github.com/multiformats/go-multicodec>

	const EthTx = 147
		Consts below are DEPRECATED and left only for legacy reasons:
		<https://github.com/ipfs/go-cid/pull/137>
		Modern code should use consts from go-multicodec instead:
		<https://github.com/multiformats/go-multicodec>

	const EthTxReceipt = 149
		Consts below are DEPRECATED and left only for legacy reasons:
		<https://github.com/ipfs/go-cid/pull/137>
		Modern code should use consts from go-multicodec instead:
		<https://github.com/multiformats/go-multicodec>

	const EthTxReceiptTrie = 148
		Consts below are DEPRECATED and left only for legacy reasons:
		<https://github.com/ipfs/go-cid/pull/137>
		Modern code should use consts from go-multicodec instead:
		<https://github.com/multiformats/go-multicodec>

	const EthTxTrie = 146
		Consts below are DEPRECATED and left only for legacy reasons:
		<https://github.com/ipfs/go-cid/pull/137>
		Modern code should use consts from go-multicodec instead:
		<https://github.com/multiformats/go-multicodec>

	const FilCommitmentSealed = 61698
		Consts below are DEPRECATED and left only for legacy reasons:
		<https://github.com/ipfs/go-cid/pull/137>
		Modern code should use consts from go-multicodec instead:
		<https://github.com/multiformats/go-multicodec>

	const FilCommitmentUnsealed = 61697
		Consts below are DEPRECATED and left only for legacy reasons:
		<https://github.com/ipfs/go-cid/pull/137>
		Modern code should use consts from go-multicodec instead:
		<https://github.com/multiformats/go-multicodec>

	const GitRaw = 120
		other

	const Libp2pKey = 114 // https://github.com/libp2p/specs/blob/master/peer-ids/peer-ids.md#peer-ids
		Consts below are DEPRECATED and left only for legacy reasons:
		<https://github.com/ipfs/go-cid/pull/137>
		Modern code should use consts from go-multicodec instead:
		<https://github.com/multiformats/go-multicodec>

	const Raw = 85
		common ones

	const UnsupportedVersionString = ""
		UnsupportedVersionString just holds an error message

	const ZcashBlock = 192
		Consts below are DEPRECATED and left only for legacy reasons:
		<https://github.com/ipfs/go-cid/pull/137>
		Modern code should use consts from go-multicodec instead:
		<https://github.com/multiformats/go-multicodec>

	const ZcashTx = 193
		Consts below are DEPRECATED and left only for legacy reasons:
		<https://github.com/ipfs/go-cid/pull/137>
		Modern code should use consts from go-multicodec instead:
		<https://github.com/multiformats/go-multicodec>

The pages are generated with Golds v0.8.2. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @zigo_101 (reachable from the left QR code) to get the latest news of Golds.