cache

package
v0.8.1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: May 5, 2025 License: GPL-3.0 Imports: 25 Imported by: 0

Documentation

Overview

Package cache contains a caching layer on top of the low-level bug and identity functions to provide efficient querying, filtering, sorting.

Index

Constants

This section is empty.

Variables

View Source 
var ErrNoMatchingOp = fmt.Errorf("no matching operation found")

Functions

This section is empty.

Types

type Actions 

type Actions[EntityT entity.Interface] struct {
	ReadWithResolver    func(repo repository.ClockedRepo, resolvers entity.Resolvers, id entity.Id) (EntityT, error)
	ReadAllWithResolver func(repo repository.ClockedRepo, resolvers entity.Resolvers) <-chan entity.StreamedEntity[EntityT]
	Remove              func(repo repository.ClockedRepo, id entity.Id) error
	RemoveAll           func(repo repository.ClockedRepo) error
	MergeAll            func(repo repository.ClockedRepo, resolvers entity.Resolvers, remote string, mergeAuthor identity.Interface) <-chan entity.MergeResult
}

Actions expose a number of action functions on Entities, to give upper layers (cache) a way to normalize interactions. Note: ideally this wouldn't exist, the cache layer would assume that everything is an entity/dag, and directly use the functions from this package, but right now identities are not using that framework.

type BugCache 

type BugCache struct {
	CachedEntityBase[*bug.Snapshot, bug.Operation]
}

BugCache is a wrapper around a Bug. It provides multiple functions:

1. Provide a higher level API to use than the raw API from Bug. 2. Maintain an up-to-date Snapshot available. 3. Deal with concurrency.

func NewBugCache 

func NewBugCache(b *bug.Bug, repo repository.ClockedRepo, getUserIdentity getUserIdentityFunc, entityUpdated func(id entity.Id) error) *BugCache

func (*BugCache) AddComment 

func (c *BugCache) AddComment(message string) (entity.CombinedId, *bug.AddCommentOperation, error)

func (*BugCache) AddCommentRaw 

func (c *BugCache) AddCommentRaw(author identity.Interface, unixTime int64, message string, files []repository.Hash, metadata map[string]string) (entity.CombinedId, *bug.AddCommentOperation, error)

func (*BugCache) AddCommentWithFiles 

func (c *BugCache) AddCommentWithFiles(message string, files []repository.Hash) (entity.CombinedId, *bug.AddCommentOperation, error)

func (*BugCache) ChangeLabels 

func (c *BugCache) ChangeLabels(added []string, removed []string) ([]bug.LabelChangeResult, *bug.LabelChangeOperation, error)

func (*BugCache) ChangeLabelsRaw 

func (c *BugCache) ChangeLabelsRaw(author identity.Interface, unixTime int64, added []string, removed []string, metadata map[string]string) ([]bug.LabelChangeResult, *bug.LabelChangeOperation, error)

func (*BugCache) Close 

func (c *BugCache) Close() (*bug.SetStatusOperation, error)

func (*BugCache) CloseRaw 

func (c *BugCache) CloseRaw(author identity.Interface, unixTime int64, metadata map[string]string) (*bug.SetStatusOperation, error)

func (*BugCache) EditComment 

func (c *BugCache) EditComment(target entity.CombinedId, message string) (*bug.EditCommentOperation, error)

func (*BugCache) EditCommentRaw 

func (c *BugCache) EditCommentRaw(author identity.Interface, unixTime int64, target entity.CombinedId, message string, metadata map[string]string) (*bug.EditCommentOperation, error)

func (*BugCache) EditCreateComment 

func (c *BugCache) EditCreateComment(body string) (entity.CombinedId, *bug.EditCommentOperation, error)

EditCreateComment is a convenience function to edit the body of a bug (the first comment)

func (*BugCache) EditCreateCommentRaw 

func (c *BugCache) EditCreateCommentRaw(author identity.Interface, unixTime int64, body string, metadata map[string]string) (entity.CombinedId, *bug.EditCommentOperation, error)

EditCreateCommentRaw is a convenience function to edit the body of a bug (the first comment)

func (*BugCache) ForceChangeLabels 

func (c *BugCache) ForceChangeLabels(added []string, removed []string) (*bug.LabelChangeOperation, error)

func (*BugCache) ForceChangeLabelsRaw 

func (c *BugCache) ForceChangeLabelsRaw(author identity.Interface, unixTime int64, added []string, removed []string, metadata map[string]string) (*bug.LabelChangeOperation, error)

func (*BugCache) Open 

func (c *BugCache) Open() (*bug.SetStatusOperation, error)

func (*BugCache) OpenRaw 

func (c *BugCache) OpenRaw(author identity.Interface, unixTime int64, metadata map[string]string) (*bug.SetStatusOperation, error)

func (*BugCache) SetMetadata 

func (c *BugCache) SetMetadata(target entity.Id, newMetadata map[string]string) (*dag.SetMetadataOperation[*bug.Snapshot], error)

func (*BugCache) SetMetadataRaw 

func (c *BugCache) SetMetadataRaw(author identity.Interface, unixTime int64, target entity.Id, newMetadata map[string]string) (*dag.SetMetadataOperation[*bug.Snapshot], error)

func (*BugCache) SetTitle 

func (c *BugCache) SetTitle(title string) (*bug.SetTitleOperation, error)

func (*BugCache) SetTitleRaw 

func (c *BugCache) SetTitleRaw(author identity.Interface, unixTime int64, title string, metadata map[string]string) (*bug.SetTitleOperation, error)

type BugExcerpt 

type BugExcerpt struct {
	CreateLamportTime lamport.Time
	EditLamportTime   lamport.Time
	CreateUnixTime    int64
	EditUnixTime      int64

	AuthorId     entity.Id
	Status       common.Status
	Labels       []common.Label
	Title        string
	LenComments  int
	Actors       []entity.Id
	Participants []entity.Id

	CreateMetadata map[string]string
	// contains filtered or unexported fields
}

BugExcerpt hold a subset of the bug values to be able to sort and filter bugs efficiently without having to read and compile each raw bugs.

func NewBugExcerpt 

func NewBugExcerpt(b *BugCache) *BugExcerpt

func (*BugExcerpt) CreateTime 

func (b *BugExcerpt) CreateTime() time.Time

func (*BugExcerpt) EditTime 

func (b *BugExcerpt) EditTime() time.Time

func (*BugExcerpt) Id 

func (b *BugExcerpt) Id() entity.Id

type BugsByCreationTime 

type BugsByCreationTime []*BugExcerpt

func (BugsByCreationTime) Len 

func (b BugsByCreationTime) Len() int

func (BugsByCreationTime) Less 

func (b BugsByCreationTime) Less(i, j int) bool

func (BugsByCreationTime) Swap 

func (b BugsByCreationTime) Swap(i, j int)

type BugsByEditTime 

type BugsByEditTime []*BugExcerpt

func (BugsByEditTime) Len 

func (b BugsByEditTime) Len() int

func (BugsByEditTime) Less 

func (b BugsByEditTime) Less(i, j int) bool

func (BugsByEditTime) Swap 

func (b BugsByEditTime) Swap(i, j int)

type BugsById 

type BugsById []*BugExcerpt

func (BugsById) Len 

func (b BugsById) Len() int

func (BugsById) Less 

func (b BugsById) Less(i, j int) bool

func (BugsById) Swap 

func (b BugsById) Swap(i, j int)

type BuildEvent 

type BuildEvent struct {
	// Err carry an error if the build process failed. If set, no other field matter.
	Err error
	// Typename is the name of the entity of which the event relate to. Can be empty if not particular entity is involved.
	Typename string
	// Event is the type of the event.
	Event BuildEventType
	// Total is the total number of element being built. Set if Event is BuildEventStarted.
	Total int64
	// Progress is the current count of processed element. Set if Event is BuildEventProgress.
	Progress int64
}

BuildEvent carry an event happening during the cache build process.

type BuildEventType 

type BuildEventType int
const (

	// BuildEventCacheIsBuilt signal that the cache is being built (aka, not skipped)
	BuildEventCacheIsBuilt BuildEventType
	// BuildEventRemoveLock signal that an old repo lock has been cleaned
	BuildEventRemoveLock
	// BuildEventStarted signal the beginning of a cache build for an entity
	BuildEventStarted
	// BuildEventProgress signal progress in the cache building for an entity
	BuildEventProgress
	// BuildEventFinished signal the end of a cache build for an entity
	BuildEventFinished
)

type CacheEntity 

type CacheEntity interface {
	Id() entity.Id
	NeedCommit() bool
	Lock()
}

type CachedEntityBase 

type CachedEntityBase[SnapT dag.Snapshot, OpT dag.Operation] struct {
	// contains filtered or unexported fields
}

CachedEntityBase provide the base function of an entity managed by the cache.

func (*CachedEntityBase[SnapT, OpT]) Commit 

func (e *CachedEntityBase[SnapT, OpT]) Commit() error

func (*CachedEntityBase[SnapT, OpT]) CommitAsNeeded 

func (e *CachedEntityBase[SnapT, OpT]) CommitAsNeeded() error

func (*CachedEntityBase[SnapT, OpT]) CreateLamportTime 

func (e *CachedEntityBase[SnapT, OpT]) CreateLamportTime() lamport.Time

func (*CachedEntityBase[SnapT, OpT]) EditLamportTime 

func (e *CachedEntityBase[SnapT, OpT]) EditLamportTime() lamport.Time

func (*CachedEntityBase[SnapT, OpT]) FirstOp 

func (e *CachedEntityBase[SnapT, OpT]) FirstOp() OpT

func (*CachedEntityBase[SnapT, OpT]) Id 

func (e *CachedEntityBase[SnapT, OpT]) Id() entity.Id

func (*CachedEntityBase[SnapT, OpT]) Lock 

func (e *CachedEntityBase[SnapT, OpT]) Lock()

func (*CachedEntityBase[SnapT, OpT]) NeedCommit 

func (e *CachedEntityBase[SnapT, OpT]) NeedCommit() bool

func (*CachedEntityBase[SnapT, OpT]) ResolveOperationWithMetadata 

func (e *CachedEntityBase[SnapT, OpT]) ResolveOperationWithMetadata(key string, value string) (entity.Id, error)

ResolveOperationWithMetadata will find an operation that has the matching metadata

func (*CachedEntityBase[SnapT, OpT]) Snapshot 

func (e *CachedEntityBase[SnapT, OpT]) Snapshot() SnapT

func (*CachedEntityBase[SnapT, OpT]) Validate 

func (e *CachedEntityBase[SnapT, OpT]) Validate() error

type Excerpt 

type Excerpt interface {
	Id() entity.Id
	// contains filtered or unexported methods
}

type Filter 

type Filter func(excerpt *BugExcerpt, resolvers entity.Resolvers) bool

Filter is a predicate that match a subset of bugs

func ActorFilter 

func ActorFilter(query string) Filter

ActorFilter return a Filter that match a bug actor

func AuthorFilter 

func AuthorFilter(query string) Filter

AuthorFilter return a Filter that match a bug author

func LabelFilter 

func LabelFilter(label string) Filter

LabelFilter return a Filter that match a label

func MetadataFilter 

func MetadataFilter(pair query.StringPair) Filter

MetadataFilter return a Filter that match a bug metadata at creation time

func NoLabelFilter 

func NoLabelFilter() Filter

NoLabelFilter return a Filter that match the absence of labels

func ParticipantFilter 

func ParticipantFilter(query string) Filter

ParticipantFilter return a Filter that match a bug participant

func StatusFilter 

func StatusFilter(status common.Status) Filter

StatusFilter return a Filter that match a bug status

func TitleFilter 

func TitleFilter(query string) Filter

TitleFilter return a Filter that match if the title contains the given query

type IdentityById 

type IdentityById []*IdentityExcerpt

func (IdentityById) Len 

func (b IdentityById) Len() int

func (IdentityById) Less 

func (b IdentityById) Less(i, j int) bool

func (IdentityById) Swap 

func (b IdentityById) Swap(i, j int)

type IdentityCache 

type IdentityCache struct {
	*identity.Identity
	// contains filtered or unexported fields
}

IdentityCache is a wrapper around an Identity for caching.

func NewIdentityCache 

func NewIdentityCache(i *identity.Identity, repo repository.ClockedRepo, entityUpdated func(id entity.Id) error) *IdentityCache

func (*IdentityCache) Commit 

func (i *IdentityCache) Commit() error

func (*IdentityCache) CommitAsNeeded 

func (i *IdentityCache) CommitAsNeeded() error

func (*IdentityCache) Lock 

func (i *IdentityCache) Lock()

func (*IdentityCache) Mutate 

func (i *IdentityCache) Mutate(repo repository.RepoClock, f func(*identity.Mutator)) error

type IdentityExcerpt 

type IdentityExcerpt struct {
	Name              string
	Login             string
	ImmutableMetadata map[string]string
	// contains filtered or unexported fields
}

IdentityExcerpt hold a subset of the identity values to be able to sort and filter identities efficiently without having to read and compile each raw identity.

func NewIdentityExcerpt 

func NewIdentityExcerpt(i *IdentityCache) *IdentityExcerpt

func (*IdentityExcerpt) DisplayName 

func (i *IdentityExcerpt) DisplayName() string

DisplayName return a non-empty string to display, representing the identity, based on the non-empty values.

func (*IdentityExcerpt) Id 

func (i *IdentityExcerpt) Id() entity.Id

func (*IdentityExcerpt) Match 

func (i *IdentityExcerpt) Match(query string) bool

Match matches a query with the identity name, login and ID prefixes

type Matcher 

type Matcher struct {
	Status      []Filter
	Author      []Filter
	Metadata    []Filter
	Actor       []Filter
	Participant []Filter
	Label       []Filter
	Title       []Filter
	NoFilters   []Filter
}

Matcher is a collection of Filter that implement a complex filter

func (*Matcher) Match 

func (f *Matcher) Match(excerpt *BugExcerpt, resolvers entity.Resolvers) bool

Match check if a bug match the set of filters

type MultiRepoCache 

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

MultiRepoCache is the root cache, holding multiple RepoCache.

func NewMultiRepoCache 

func NewMultiRepoCache() *MultiRepoCache

func (*MultiRepoCache) Close 

func (c *MultiRepoCache) Close() error

Close will do anything that is needed to close the cache properly

func (*MultiRepoCache) DefaultRepo 

func (c *MultiRepoCache) DefaultRepo() (*RepoCache, error)

DefaultRepo retrieve the default repository

func (*MultiRepoCache) RegisterDefaultRepository 

func (c *MultiRepoCache) RegisterDefaultRepository(repo repository.ClockedRepo) (*RepoCache, chan BuildEvent)

RegisterDefaultRepository register an unnamed repository. Use this for single-repo setup

func (*MultiRepoCache) RegisterRepository 

func (c *MultiRepoCache) RegisterRepository(repo repository.ClockedRepo, name string) (*RepoCache, chan BuildEvent)

RegisterRepository register a named repository. Use this for multi-repo setup

func (*MultiRepoCache) ResolveRepo 

func (c *MultiRepoCache) ResolveRepo(name string) (*RepoCache, error)

ResolveRepo retrieve a repository by name

type RepoCache 

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

RepoCache is a cache for a Repository. This cache has multiple functions:

  1. After being loaded, a Bug is kept in memory in the cache, allowing for fast access later.
  2. The cache maintain in memory and on disk a pre-digested excerpt for each bug, allowing for fast querying the whole set of bugs without having to load them individually.
  3. The cache guarantee that a single instance of a Bug is loaded at once, avoiding loss of data that we could have with multiple copies in the same process.
  4. The same way, the cache maintain in memory a single copy of the loaded identities.

The cache also protect the on-disk data by locking the git repository for its own usage, by writing a lock file. Of course, normal git operations are not affected, only git-bug related one.

func NewNamedRepoCache 

func NewNamedRepoCache(r repository.ClockedRepo, name string) (*RepoCache, chan BuildEvent)

NewNamedRepoCache create or open a named cache on top of a raw repository. The caller is expected to read all returned events before the cache is considered ready to use.

func NewRepoCache 

func NewRepoCache(r repository.ClockedRepo) (*RepoCache, chan BuildEvent)

NewRepoCache create or open a cache on top of a raw repository. The caller is expected to read all returned events before the cache is considered ready to use.

func NewRepoCacheNoEvents 

func NewRepoCacheNoEvents(r repository.ClockedRepo) (*RepoCache, error)

func (*RepoCache) AnyConfig 

func (c *RepoCache) AnyConfig() repository.ConfigRead

AnyConfig give access to a merged local/global configuration

func (*RepoCache) Bugs 

func (c *RepoCache) Bugs() *RepoCacheBug

Bugs gives access to the Bug entities

func (*RepoCache) ClearUserIdentity 

func (c *RepoCache) ClearUserIdentity() error

func (*RepoCache) Close 

func (c *RepoCache) Close() error

func (*RepoCache) Fetch 

func (c *RepoCache) Fetch(remote string) (string, error)

Fetch retrieve updates from a remote This does not change the local bugs or identities state

func (*RepoCache) GetCoreEditor 

func (c *RepoCache) GetCoreEditor() (string, error)

GetCoreEditor returns the name of the editor that the user has used to configure git.

func (*RepoCache) GetRemotes 

func (c *RepoCache) GetRemotes() (map[string]string, error)

GetRemotes returns the configured remotes repositories.

func (*RepoCache) GetUserEmail 

func (c *RepoCache) GetUserEmail() (string, error)

GetUserEmail returns the email address that the user has used to configure git.

func (*RepoCache) GetUserIdentity 

func (c *RepoCache) GetUserIdentity() (*IdentityCache, error)

func (*RepoCache) GetUserIdentityExcerpt 

func (c *RepoCache) GetUserIdentityExcerpt() (*IdentityExcerpt, error)

func (*RepoCache) GetUserName 

func (c *RepoCache) GetUserName() (string, error)

GetUserName returns the name the user has used to configure git

func (*RepoCache) GlobalConfig 

func (c *RepoCache) GlobalConfig() repository.Config

GlobalConfig give access to the global scoped configuration

func (*RepoCache) Identities 

func (c *RepoCache) Identities() *RepoCacheIdentity

Identities gives access to the Identity entities

func (*RepoCache) IsUserIdentitySet 

func (c *RepoCache) IsUserIdentitySet() (bool, error)

func (*RepoCache) Keyring 

func (c *RepoCache) Keyring() repository.Keyring

Keyring give access to a user-wide storage for secrets

func (*RepoCache) LocalConfig 

func (c *RepoCache) LocalConfig() repository.Config

LocalConfig give access to the repository scoped configuration

func (*RepoCache) LocalStorage 

func (c *RepoCache) LocalStorage() repository.LocalStorage

LocalStorage return a billy.Filesystem giving access to $RepoPath/.git/git-bug

func (*RepoCache) MergeAll 

func (c *RepoCache) MergeAll(remote string) <-chan entity.MergeResult

MergeAll will merge all the available remote bug and identities

func (*RepoCache) Name 

func (c *RepoCache) Name() string

func (*RepoCache) Pull 

func (c *RepoCache) Pull(remote string) error

Pull will do a Fetch + MergeAll This function will return an error if a merge fail

func (*RepoCache) Push 

func (c *RepoCache) Push(remote string) (string, error)

Push update a remote with the local changes

func (*RepoCache) ReadData 

func (c *RepoCache) ReadData(hash repository.Hash) ([]byte, error)

ReadData will attempt to read arbitrary data from the given hash

func (*RepoCache) RemoveAll 

func (c *RepoCache) RemoveAll() error

RemoveAll deletes all entities from the cache and the disk.

func (*RepoCache) SetUserIdentity 

func (c *RepoCache) SetUserIdentity(i *IdentityCache) error

func (*RepoCache) StoreData 

func (c *RepoCache) StoreData(data []byte) (repository.Hash, error)

StoreData will store arbitrary data and return the corresponding hash

type RepoCacheBug 

type RepoCacheBug struct {
	*SubCache[*bug.Bug, *BugExcerpt, *BugCache]
}

func NewRepoCacheBug 

func NewRepoCacheBug(repo repository.ClockedRepo,
	resolvers func() entity.Resolvers,
	getUserIdentity getUserIdentityFunc) *RepoCacheBug

func (*RepoCacheBug) New 

func (c *RepoCacheBug) New(title string, message string) (*BugCache, *bug.CreateOperation, error)

New create a new bug The new bug is written in the repository (commit)

func (*RepoCacheBug) NewRaw 

func (c *RepoCacheBug) NewRaw(author identity.Interface, unixTime int64, title string, message string, files []repository.Hash, metadata map[string]string) (*BugCache, *bug.CreateOperation, error)

NewRaw create a new bug with attached files for the message, as well as metadata for the Create operation. The new bug is written in the repository (commit)

func (*RepoCacheBug) NewWithFiles 

func (c *RepoCacheBug) NewWithFiles(title string, message string, files []repository.Hash) (*BugCache, *bug.CreateOperation, error)

NewWithFiles create a new bug with attached files for the message The new bug is written in the repository (commit)

func (*RepoCacheBug) Query 

func (c *RepoCacheBug) Query(q *query.Query) ([]entity.Id, error)

Query return the id of all Bug matching the given Query

func (*RepoCacheBug) ResolveBugCreateMetadata 

func (c *RepoCacheBug) ResolveBugCreateMetadata(key string, value string) (*BugCache, error)

ResolveBugCreateMetadata retrieve a bug that has the exact given metadata on its Create operation, that is, the first operation. It fails if multiple bugs match.

func (*RepoCacheBug) ResolveComment 

func (c *RepoCacheBug) ResolveComment(prefix string) (*BugCache, entity.CombinedId, error)

ResolveComment search for a Bug/Comment combination matching the merged bug/comment Id prefix. Returns the Bug containing the Comment and the Comment's Id.

func (*RepoCacheBug) ValidLabels 

func (c *RepoCacheBug) ValidLabels() []common.Label

ValidLabels list valid labels

Note: in the future, a proper label policy could be implemented where valid labels are defined in a configuration file. Until that, the default behavior is to return the list of labels already used.

type RepoCacheIdentity 

type RepoCacheIdentity struct {
	*SubCache[*identity.Identity, *IdentityExcerpt, *IdentityCache]
}

func NewRepoCacheIdentity 

func NewRepoCacheIdentity(repo repository.ClockedRepo,
	resolvers func() entity.Resolvers,
	getUserIdentity getUserIdentityFunc) *RepoCacheIdentity

func (*RepoCacheIdentity) New 

func (c *RepoCacheIdentity) New(name string, email string) (*IdentityCache, error)

New create a new identity The new identity is written in the repository (commit)

func (*RepoCacheIdentity) NewFromGitUser 

func (c *RepoCacheIdentity) NewFromGitUser() (*IdentityCache, error)

func (*RepoCacheIdentity) NewFromGitUserRaw 

func (c *RepoCacheIdentity) NewFromGitUserRaw(metadata map[string]string) (*IdentityCache, error)

func (*RepoCacheIdentity) NewFull 

func (c *RepoCacheIdentity) NewFull(name string, email string, login string, avatarUrl string, keys []*identity.Key) (*IdentityCache, error)

NewFull create a new identity The new identity is written in the repository (commit)

func (*RepoCacheIdentity) NewRaw 

func (c *RepoCacheIdentity) NewRaw(name string, email string, login string, avatarUrl string, keys []*identity.Key, metadata map[string]string) (*IdentityCache, error)

func (*RepoCacheIdentity) ResolveIdentityImmutableMetadata 

func (c *RepoCacheIdentity) ResolveIdentityImmutableMetadata(key string, value string) (*IdentityCache, error)

ResolveIdentityImmutableMetadata retrieve an Identity that has the exact given metadata on one of its version. If multiple version have the same key, the first defined take precedence.

type SubCache 

type SubCache[EntityT entity.Interface, ExcerptT Excerpt, CacheT CacheEntity] struct {
	// contains filtered or unexported fields
}

func NewSubCache 

func NewSubCache[EntityT entity.Interface, ExcerptT Excerpt, CacheT CacheEntity](
	repo repository.ClockedRepo,
	resolvers func() entity.Resolvers, getUserIdentity getUserIdentityFunc,
	makeCached func(entity EntityT, entityUpdated func(id entity.Id) error) CacheT,
	makeExcerpt func(CacheT) ExcerptT,
	makeIndexData func(CacheT) []string,
	actions Actions[EntityT],
	typename, namespace string,
	version uint, maxLoaded int) *SubCache[EntityT, ExcerptT, CacheT]

func (*SubCache[EntityT, ExcerptT, CacheT]) AllIds 

func (sc *SubCache[EntityT, ExcerptT, CacheT]) AllIds() []entity.Id

AllIds return all known bug ids

func (*SubCache[EntityT, ExcerptT, CacheT]) Build 

func (sc *SubCache[EntityT, ExcerptT, CacheT]) Build() <-chan BuildEvent

func (*SubCache[EntityT, ExcerptT, CacheT]) Close 

func (sc *SubCache[EntityT, ExcerptT, CacheT]) Close() error

func (*SubCache[EntityT, ExcerptT, CacheT]) GetNamespace 

func (sc *SubCache[EntityT, ExcerptT, CacheT]) GetNamespace() string

func (*SubCache[EntityT, ExcerptT, CacheT]) Load 

func (sc *SubCache[EntityT, ExcerptT, CacheT]) Load() error

Load will try to read from the disk the entity cache file

func (*SubCache[EntityT, ExcerptT, CacheT]) MergeAll 

func (sc *SubCache[EntityT, ExcerptT, CacheT]) MergeAll(remote string) <-chan entity.MergeResult

func (*SubCache[EntityT, ExcerptT, CacheT]) Remove 

func (sc *SubCache[EntityT, ExcerptT, CacheT]) Remove(prefix string) error

func (*SubCache[EntityT, ExcerptT, CacheT]) RemoveAll 

func (sc *SubCache[EntityT, ExcerptT, CacheT]) RemoveAll() error

func (*SubCache[EntityT, ExcerptT, CacheT]) Resolve 

func (sc *SubCache[EntityT, ExcerptT, CacheT]) Resolve(id entity.Id) (CacheT, error)

Resolve retrieve an entity matching the exact given id

func (*SubCache[EntityT, ExcerptT, CacheT]) ResolveExcerpt 

func (sc *SubCache[EntityT, ExcerptT, CacheT]) ResolveExcerpt(id entity.Id) (ExcerptT, error)

ResolveExcerpt retrieve an Excerpt matching the exact given id

func (*SubCache[EntityT, ExcerptT, CacheT]) ResolveExcerptMatcher 

func (sc *SubCache[EntityT, ExcerptT, CacheT]) ResolveExcerptMatcher(f func(ExcerptT) bool) (ExcerptT, error)

func (*SubCache[EntityT, ExcerptT, CacheT]) ResolveExcerptPrefix 

func (sc *SubCache[EntityT, ExcerptT, CacheT]) ResolveExcerptPrefix(prefix string) (ExcerptT, error)

ResolveExcerptPrefix retrieve an Excerpt matching an id prefix. It fails if multiple entities match.

func (*SubCache[EntityT, ExcerptT, CacheT]) ResolveMatcher 

func (sc *SubCache[EntityT, ExcerptT, CacheT]) ResolveMatcher(f func(ExcerptT) bool) (CacheT, error)

func (*SubCache[EntityT, ExcerptT, CacheT]) ResolvePrefix 

func (sc *SubCache[EntityT, ExcerptT, CacheT]) ResolvePrefix(prefix string) (CacheT, error)

ResolvePrefix retrieve an entity matching an id prefix. It fails if multiple entities match.

func (*SubCache[EntityT, ExcerptT, CacheT]) SetCacheSize 

func (sc *SubCache[EntityT, ExcerptT, CacheT]) SetCacheSize(size int)

func (*SubCache[EntityT, ExcerptT, CacheT]) Typename 

func (sc *SubCache[EntityT, ExcerptT, CacheT]) Typename() string

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.