msgp is a code generation tool for creating methods to serialize and de-serialize Go data structures to and from MessagePack.
Package bloom provides data structures and methods for creating Bloom filters.
Package bloom provides data structures and methods for creating Bloom filters.
Package lru provides generic type and concurrent safe LRU data structures with near O(1) perf and optional time-based expiration support.
Package treego implements a generic B-tree data structure in Go.
Package lru provides generic type and concurrent safe LRU data structures with near O(1) perf and optional time-based expiration support.
Package weightedrand contains a performant data structure and algorithm used to randomly select an element from some kind of list, where the chances of each element to be selected not being equal, but defined by relative "weights" (or probabilities).
Package bloom provides data structures and methods for creating Bloom filters.
Package naming defines the naming API and related data structures for gRPC.
Implementation of an R-Way Trie data structure.
Package set provides both threadsafe and non-threadsafe implementations of a generic set data structure.
Package hdrhistogram provides an implementation of Gil Tene's HDR Histogram data structure.
Package hdrhistogram provides an implementation of Gil Tene's HDR Histogram data structure.
Package goque provides embedded, disk-based implementations of stack, queue, and priority queue data structures.
Lane package provides queue, priority queue, stack and deque data structures implementations.
Lane package provides queue, priority queue, stack and deque data structures implementations.
Package set provides both threadsafe and non-threadsafe implementations of a generic set data structure.
Package bloom provides data structures and methods for creating Bloom filters.
Package skiplist implement skip list data structure.
Package weightedrand contains a performant data structure and algorithm used to randomly select an element from some kind of list, where the chances of each element to be selected not being equal, but defined by relative "weights" (or probabilities).
Package graph is a library for creating generic graph data structures and modifying, analyzing, and visualizing them.
Package merkledag implements the IPFS Merkle DAG data structures.
Package tdigest provides a highly accurate mergeable data-structure for quantile estimation.
Package weightedrand contains a performant data structure and algorithm used to randomly select an element from some kind of list, where the chances of each element to be selected not being equal, but defined by relative "weights" (or probabilities).
Package circllhist provides an implementation of Circonus' fixed log-linear histogram data structure.
Package structhash creates hash strings from arbitrary go data structures.
Package uplink is the main entrypoint to interacting with Storj Labs' decentralized storage network. Sign up for an account on a Satellite today! https://storj.io/ The fundamental unit of access in the Storj Labs storage network is the Access Grant. An access grant is a serialized structure that is internally comprised of an API Key, a set of encryption key information, and information about which Storj Labs or Tardigrade network Satellite is responsible for the metadata. An access grant is always associated with exactly one Project on one Satellite. If you don't already have an access grant, you will need make an account on a Satellite, generate an API Key, and encapsulate that API Key with encryption information into an access grant. If you don't already have an account on a Satellite, first make one at https://storj.io/ and note the Satellite you choose (such as us1.storj.io, eu1.storj.io, etc). Then, make an API Key in the web interface. The first step to any project is to generate a restricted access grant with the minimal permissions that are needed. Access grants contains all encryption information and they should be restricted as much as possible. To make an access grant, you can create one using our Uplink CLI tool's 'share' subcommand (after setting up the Uplink CLI tool), or you can make one as follows: In the above example, 'serializedAccess' is a human-readable string that represents read-only access to just the "logs" bucket, and is only able to decrypt that one bucket thanks to hierarchical deterministic key derivation. Note: RequestAccessWithPassphrase is CPU-intensive, and your application's normal lifecycle should avoid it and use ParseAccess where possible instead. To revoke an access grant see the Project.RevokeAccess method. A common architecture for building applications is to have a single bucket for the entire application to store the objects of all users. In such architecture, it is of utmost importance to guarantee that users can access only their objects but not the objects of other users. This can be achieved by implementing an app-specific authentication service that generates an access grant for each user by restricting the main access grant of the application. This user-specific access grant is restricted to access the objects only within a specific key prefix defined for the user. When initialized, the authentication server creates the main application access grant with an empty passphrase as follows. The authentication service does not hold any encryption information about users, so the passphrase used to request the main application access grant does not matter. The encryption keys related to user objects will be overridden in a next step on the client-side. It is important that once set to a specific value, this passphrase never changes in the future. Therefore, the best practice is to use an empty passphrase. Whenever a user is authenticated, the authentication service generates the user-specific access grant as follows: The userID is something that uniquely identifies the users in the application and must never change. Along with the user access grant, the authentication service should return a user-specific salt. The salt must be always the same for this user. The salt size is 16-byte or 32-byte. Once the application receives the user-specific access grant and the user-specific salt from the authentication service, it has to override the encryption key in the access grant, so users can encrypt and decrypt their files with encryption keys derived from their passphrase. The user-specific access grant is now ready to use by the application. Once you have a valid access grant, you can open a Project with the access that access grant allows for. Projects allow you to manage buckets and objects within buckets. A bucket represents a collection of objects. You can upload, download, list, and delete objects of any size or shape. Objects within buckets are represented by keys, where keys can optionally be listed using the "/" delimiter. Note: Objects and object keys within buckets are end-to-end encrypted, but bucket names themselves are not encrypted, so the billing interface on the Satellite can show you bucket line items. Objects support a couple kilobytes of arbitrary key/value metadata, and arbitrary-size primary data streams with the ability to read at arbitrary offsets. If you want to access only a small subrange of the data you uploaded, you can use `uplink.DownloadOptions` to specify the download range. Listing objects returns an iterator that allows to walk through all the items:
Package lane provides queue, priority queue, stack and deque data structures implementations.
Package goraph implements graph data structure and algorithms.
Fully persistent data structures.
Package forest is a library for creating nodes in the Arbor Forest data structure.
Package kdtree implements a k-d tree data structure.
Package circllhist provides an implementation of Circonus' fixed log-linear histogram data structure.
Package tdigest provides a highly accurate mergeable data-structure for quantile estimation.
Package dag implements a directed acyclic graph data structure ( DAG ), a finite directed graph with no directed cycles.
Package asn1 implements encoding and decoding of ASN.1 data structures using both Basic Encoding Rules (BER) or its subset, the Distinguished Encoding Rules (BER).
Package go-succinct-data-structure-trie implements trie with succinct data structure in Go.
Package asn1 implements encoding and decoding of ASN.1 data structures using both Basic Encoding Rules (BER) or its subset, the Distinguished Encoding Rules (BER).
Package blocks contains the lowest level of IPLD data structures.
Package retag provides an ability to change tags of structures' fields in runtime without copying of the data.
Package ldclient is the main package for the LaunchDarkly SDK. This package contains the types and methods for the SDK client (LDClient) and its overall configuration. Subpackages in the same repository provide additional functionality for specific features of the client. Most applications that need to change any configuration settings will use the ldcomponents package (https://pkg.go.dev/gopkg.in/launchdarkly/go-server-sdk.v5/ldcomponents). The SDK also uses types from the go-sdk-common.v2 repository and its subpackages (https://pkg.go.dev/gopkg.in/launchdarkly/go-sdk-common.v2) that represent standard data structures in the LaunchDarkly model. All applications that evaluate feature flags will use the lduser package (https://pkg.go.dev/gopkg.in/launchdarkly/go-sdk-common.v2/lduser); for some features such as custom attributes, the ldvalue package is also helpful. For more information and code examples, see the Go SDK Reference: https://docs.launchdarkly.com/sdk/server-side/go
Package tiff implements structures and functionality for working with TIFF data structures.
Package tdigest provides a highly accurate mergeable data-structure for quantile estimation.
Package pq implements a priority queue data structure on top of container/heap.
Package containers provides core interfaces and functions for data structures.
Package deque implements a very fast and efficient general purpose queue/stack/deque data structure that is specifically optimized to perform when used by Microservices and serverless services running in production environments.
Package btree implements in-memory B-Trees of arbitrary degree. btree implements an in-memory B-Tree for use as an ordered data structure. It is not meant for persistent storage solutions. It has a flatter structure than an equivalent red-black or other binary tree, which in some cases yields better memory usage and/or performance. See some discussion on the matter here: Note, though, that this project is in no way related to the C++ B-Tree implementation written about there. Within this tree, each node contains a slice of items and a (possibly nil) slice of children. For basic numeric values or raw structs, this can cause efficiency differences when compared to equivalent C++ template code that stores values in arrays within the node: These issues don't tend to matter, though, when working with strings or other heap-allocated structures, since C++-equivalent structures also must store pointers and also distribute their values across the heap. This implementation is designed to be a drop-in replacement to gollrb.LLRB trees, (http://github.com/petar/gollrb), an excellent and probably the most widely used ordered tree implementation in the Go ecosystem currently. Its functions, therefore, exactly mirror those of llrb.LLRB where possible. Unlike gollrb, though, we currently don't support storing multiple equivalent values.
Package utter implements a deep pretty printer for Go data structures to aid data snapshotting.