datastore

type Batch interface {
	Write

	Commit(ctx context.Context) error
}

type Batching interface {
	Datastore

	Batch(ctx context.Context) (Batch, error)
}

type CheckedDatastore interface {
	Datastore

	Check(ctx context.Context) error
}

type Datastore interface {
	Read
	Write
	// Sync guarantees that any Put or Delete calls under prefix that returned
	// before Sync(prefix) was called will be observed after Sync(prefix)
	// returns, even if the program crashes. If Put/Delete operations already
	// satisfy these requirements then Sync may be a no-op.
	//
	// If the prefix fails to Sync this method returns an error.
	Sync(ctx context.Context, prefix key.Key) error
	io.Closer
}

type GCDatastore interface {
	Datastore

	CollectGarbage(ctx context.Context) error
}

type LogBatch struct {
	Name string
	// contains filtered or unexported fields
}

type LogDatastore struct {
	Name string
	// contains filtered or unexported fields
}

type MapDatastore struct {
	// contains filtered or unexported fields
}

type NullDatastore struct {
}

type PersistentDatastore interface {
	Datastore

	// DiskUsage returns the space used by a datastore, in bytes.
	DiskUsage(ctx context.Context) (uint64, error)
}

type Read interface {
	// Get retrieves the object `value` named by `key`.
	// Get will return ErrNotFound if the key is not mapped to a value.
	Get(ctx context.Context, key key.Key) (value []byte, err error)

	// Has returns whether the `key` is mapped to a `value`.
	// In some contexts, it may be much cheaper only to check for existence of
	// a value, rather than retrieving the value itself. (e.g. HTTP HEAD).
	// The default implementation is found in `GetBackedHas`.
	Has(ctx context.Context, key key.Key) (exists bool, err error)

	// GetSize returns the size of the `value` named by `key`.
	// In some contexts, it may be much cheaper to only get the size of the
	// value rather than retrieving the value itself.
	GetSize(ctx context.Context, key key.Key) (size int, err error)

	// Query searches the datastore and returns a query result. This function
	// may return before the query actually runs. To wait for the query:
	//
	//   result, _ := ds.Query(q)
	//
	//   // use the channel interface; result may come in at different times
	//   for entry := range result.Next() { ... }
	//
	//   // or wait for the query to be completely done
	//   entries, _ := result.Rest()
	//   for entry := range entries { ... }
	//
	Query(ctx context.Context, q query.Query) (query.Results, error)
}

type ScrubbedDatastore interface {
	Datastore

	Scrub(ctx context.Context) error
}

type Shim interface {
	Datastore

	Children() []Datastore
}

type TTL interface {
	PutWithTTL(ctx context.Context, key key.Key, value []byte, ttl time.Duration) error
	SetTTL(ctx context.Context, key key.Key, ttl time.Duration) error
	GetExpiration(ctx context.Context, key key.Key) (time.Time, error)
}

type TTLDatastore interface {
	Datastore
	TTL
}

type Txn interface {
	Read
	Write

	// Commit finalizes a transaction, attempting to commit it to the Datastore.
	// May return an error if the transaction has gone stale. The presence of an
	// error is an indication that the data was not committed to the Datastore.
	Commit(ctx context.Context) error
	// Discard throws away changes recorded in a transaction without committing
	// them to the underlying Datastore. Any calls made to Discard after Commit
	// has been successfully called will have no effect on the transaction and
	// state of the Datastore, making it safe to defer.
	Discard(ctx context.Context)
}

type TxnDatastore interface {
	Datastore

	NewTransaction(ctx context.Context, readOnly bool) (Txn, error)
}

type Write interface {
	// Put stores the object `value` named by `key`.
	//
	// The generalized Datastore interface does not impose a value type,
	// allowing various datastore middleware implementations (which do not
	// handle the values directly) to be composed together.
	//
	// Ultimately, the lowest-level datastore will need to do some value checking
	// or risk getting incorrect values. It may also be useful to expose a more
	// type-safe interface to your application, and do the checking up-front.
	Put(ctx context.Context, key key.Key, value []byte) error

	// Delete removes the value for given `key`. If the key is not in the
	// datastore, this method returns no error.
	Delete(ctx context.Context, key key.Key) error
}