sku

package
v0.0.0-...-791c77c Latest Latest
Warning

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

 Go to latest Published: May 11, 2025 License: MIT Imports: 32 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	UnsureMatchTypeNone = UnsureMatchType(iota << 1)
	UnsureMatchTypeMetadataWithoutTaiHistory
	UnsureMatchTypeDescription

	UnsureMatchTypeAll = UnsureMatchType(^byte(0))
)

Variables

View Source 
var (
	TransactedSetEmpty TransactedSet
	TransactedLessor   transactedLessorStable
	TransactedEqualer  transactedEqualer
)
View Source 
var (
	MakeSkuType                = makeCheckedOut
	CloneSkuType               = cloneCheckedOut
	CloneSkuTypeFromTransacted = cloneFromTransactedCheckedOut
	MakeSkuTypeSetMutable      = MakeCheckedOutMutableSet
)
View Source 
var (
	CheckedOutKeyerObjectId = GetExternalLikeKeyer[*CheckedOut]()
)
View Source 
var CheckedOutResetter checkedOutResetter
View Source 
var Resetter resetter
View Source 
var ResetterList resetterList
View Source 
var ResetterListCheckedOut resetterListCheckedOut
View Source 
var TransactedResetter transactedResetter

Functions

func FromLuaTableV1 

func FromLuaTableV1(o *Transacted, l *lua.LState, lt *LuaTableV1) (err error)

func FromLuaTableV2 

func FromLuaTableV2(o *Transacted, l *lua.LState, lt *LuaTableV2) (err error)

func GetCheckedOutPool 

func GetCheckedOutPool() interfaces.Pool[CheckedOut, *CheckedOut]

func GetExternalLikeKeyer 

func GetExternalLikeKeyer[
	T interface {
		ExternalObjectIdGetter
		ids.ObjectIdGetter
		ExternalLikeGetter
	},
]() interfaces.StringKeyer[T]

func GetTransactedPool 

func GetTransactedPool() interfaces.Pool[Transacted, *Transacted]

func InternalAndExternalEqualsWithoutTai 

func InternalAndExternalEqualsWithoutTai(co SkuType) bool

func IsErrMergeConflict 

func IsErrMergeConflict(err error) bool

func MakeBlobCopierDelegate 

func MakeBlobCopierDelegate(ui fd.Std) func(BlobCopyResult) error

func MakeUnsureMatchMapsCollector 

func MakeUnsureMatchMapsCollector(
	umm UnsureMatchMaps,
) interfaces.FuncIter[SkuType]

func MakeUnsureMatchMapsMatcher 

func MakeUnsureMatchMapsMatcher(
	umm UnsureMatchMaps,
	f IterMatching,
) interfaces.FuncIter[*Transacted]

func String 

func String(o *Transacted) (str string)

func StringMetadataSansTai 

func StringMetadataSansTai(o *Transacted) (str string)

func StringMetadataTai 

func StringMetadataTai(o *Transacted) (str string)

func StringObjectIdBlobMetadataSansTai 

func StringObjectIdBlobMetadataSansTai(o *Transacted) (str string)

func StringTaiGenreObjectIdShaBlob 

func StringTaiGenreObjectIdShaBlob(o *Transacted) (str string)

func ToLuaTableV1 

func ToLuaTableV1(tg TransactedGetter, l *lua.LState, t *LuaTableV1)

func ToLuaTableV2 

func ToLuaTableV2(tg TransactedGetter, l *lua.LState, t *LuaTableV2)

Types

type AbbrStore 

type AbbrStore interface {
	ZettelId() AbbrStoreGeneric[ids.ZettelId, *ids.ZettelId]
	Shas() AbbrStoreGeneric[sha.Sha, *sha.Sha]

	AddObjectToAbbreviationStore(*Transacted) error
	GetAbbr() ids.Abbr

	errors.Flusher
}

type AbbrStoreGeneric 

type AbbrStoreGeneric[V any, VPtr interfaces.Ptr[V]] interface {
	AbbrStorePresenceGeneric[V]
	ExpandStringString(string) (string, error)
	ExpandString(string) (VPtr, error)
	Expand(VPtr) (VPtr, error)
	Abbreviate(ids.Abbreviatable) (string, error)
}

type AbbrStorePresenceGeneric 

type AbbrStorePresenceGeneric[V any] interface {
	Exists([3]string) error
}

type BlobCopyResult 

type BlobCopyResult struct {
	*Transacted    // may be nil
	interfaces.Sha // may not be nil

	// -1: no remote blob store and the blob doesn't exist locally
	// -2: no remote blob store and the blob exists locally
	N int64
}

type BlobSaver 

type BlobSaver interface {
	SaveBlob(ExternalLike) (err error)
}

type BlobStore 

type BlobStore[T any] interface {
	GetTransactedWithBlob(
		sk TransactedGetter,
	) (common TransactedWithBlob[T], n int64, err error)

	PutTransactedWithBlob(
		TransactedWithBlob[T],
	) error
}

type CheckedOut 

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

func (*CheckedOut) Clone 

func (src *CheckedOut) Clone() *CheckedOut

func (*CheckedOut) Equals 

func (a *CheckedOut) Equals(b *CheckedOut) bool

func (*CheckedOut) GetExternalObjectId 

func (t *CheckedOut) GetExternalObjectId() ids.ExternalObjectIdLike

func (*CheckedOut) GetExternalState 

func (t *CheckedOut) GetExternalState() external_state.State

func (*CheckedOut) GetObjectId 

func (a *CheckedOut) GetObjectId() *ids.ObjectId

func (*CheckedOut) GetRepoId 

func (c *CheckedOut) GetRepoId() ids.RepoId

func (*CheckedOut) GetSku 

func (c *CheckedOut) GetSku() *Transacted

func (*CheckedOut) GetSkuExternal 

func (c *CheckedOut) GetSkuExternal() *Transacted

func (*CheckedOut) GetState 

func (c *CheckedOut) GetState() checked_out_state.State

func (*CheckedOut) GetTai 

func (a *CheckedOut) GetTai() ids.Tai

func (*CheckedOut) SetState 

func (c *CheckedOut) SetState(v checked_out_state.State) (err error)

func (*CheckedOut) String 

func (a *CheckedOut) String() string

type CheckedOutMutableSet 

type CheckedOutMutableSet = interfaces.MutableSetLike[*CheckedOut]

func MakeCheckedOutMutableSet 

func MakeCheckedOutMutableSet() CheckedOutMutableSet

type CheckedOutSet 

type CheckedOutSet = interfaces.SetLike[*CheckedOut]

func MakeCheckedOutSet 

func MakeCheckedOutSet() CheckedOutSet

type CheckedOutWithDeletionInfo 

type CheckedOutWithDeletionInfo struct {
	*Transacted
	DryRun bool
}

type Collection 

type Collection interfaces.Collection[*Transacted]

type CommitOptions 

type CommitOptions struct {
	StoreOptions
	ids.RepoId
	ids.Clock
	Proto
	DontAddMissingTags bool
	DontAddMissingType bool
}

type Config 

type Config interface {
	interfaces.Config
	ids.InlineTypeChecker // TODO move out of konfig entirely
	GetTypeExtension(string) string
}

type Conflicted 

type Conflicted struct {
	*CheckedOut
	Local, Base, Remote *Transacted
}

TODO consider making this a ConflictedWithBase and ConflictedWithoutBase and an interface for both

func (Conflicted) All 

func (c Conflicted) All() iter.Seq[*Transacted]

func (Conflicted) Any 

func (c Conflicted) Any() *Transacted

func (*Conflicted) FindBestCommonAncestor 

func (c *Conflicted) FindBestCommonAncestor(
	negotiator ParentNegotiator,
) (err error)

func (Conflicted) GetCollection 

func (c Conflicted) GetCollection() Collection

func (Conflicted) IsAllInlineType 

func (c Conflicted) IsAllInlineType(itc ids.InlineTypeChecker) bool

func (Conflicted) Len 

func (c Conflicted) Len() int

func (*Conflicted) MergeTags 

func (tm *Conflicted) MergeTags() (err error)

func (*Conflicted) ReadConflictMarker 

func (c *Conflicted) ReadConflictMarker(
	iter iter.Seq2[*Transacted, error],
) (err error)

type DescriptionKeyer 

type DescriptionKeyer[T ExternalLikeGetter] struct{}

func (DescriptionKeyer[T]) GetKey 

func (DescriptionKeyer[T]) GetKey(el T) (key string)

type ErrMergeConflict 

type ErrMergeConflict struct {
	FSItem
}

func MakeErrMergeConflict 

func MakeErrMergeConflict(item *FSItem) (err *ErrMergeConflict)

func (*ErrMergeConflict) Error 

func (e *ErrMergeConflict) Error() string

func (*ErrMergeConflict) Is 

func (e *ErrMergeConflict) Is(target error) bool

type ExternalLike 

type ExternalLike interface {
	ids.ObjectIdGetter
	interfaces.Stringer
	TransactedGetter
	ExternalLikeGetter
	GetExternalState() external_state.State
	ExternalObjectIdGetter
	GetRepoId() ids.RepoId
}

type ExternalLikeGetter 

type ExternalLikeGetter interface {
	GetSkuExternal() *Transacted
}

type ExternalLikeMutableSet 

type ExternalLikeMutableSet = interfaces.MutableSetLike[ExternalLike]

func MakeExternalLikeMutableSet 

func MakeExternalLikeMutableSet() ExternalLikeMutableSet

type ExternalLikeSet 

type ExternalLikeSet = interfaces.SetLike[ExternalLike]

func MakeExternalLikeSet 

func MakeExternalLikeSet() ExternalLikeSet

type ExternalObjectId 

type ExternalObjectId = ids.ExternalObjectIdLike

type ExternalObjectIdGetter 

type ExternalObjectIdGetter = ids.ExternalObjectIdGetter

type ExternalObjectIdKeyer 

type ExternalObjectIdKeyer[T ExternalObjectIdGetter] struct{}

func (ExternalObjectIdKeyer[T]) GetKey 

func (ExternalObjectIdKeyer[T]) GetKey(e T) (key string)

type ExternalQuery 

type ExternalQuery struct {
	ids.RepoId
	QueryGroup
	ExternalQueryOptions
}

type ExternalQueryOptions 

type ExternalQueryOptions struct {
	ids.RepoId
	ExcludeUntracked  bool
	ExcludeRecognized bool
}

type ExternalStoreReadExternalLikeFromObjectIdLike 

type ExternalStoreReadExternalLikeFromObjectIdLike interface {
	ReadExternalLikeFromObjectIdLike(
		o CommitOptions,
		oid interfaces.Stringer,
		t *Transacted,
	) (e ExternalLike, err error)
}

type ExternalStoreUpdateTransacted 

type ExternalStoreUpdateTransacted interface {
	UpdateTransacted(z *Transacted) (err error)
}

type FSItem 

type FSItem struct {
	// TODO refactor this to be a string and a genre that is tied to the state
	ExternalObjectId ids.ExternalObjectId

	Object   fd.FD
	Blob     fd.FD // TODO make set
	Conflict fd.FD

	interfaces.MutableSetLike[*fd.FD]
}

TODO rename to FS

func (*FSItem) Debug 

func (i *FSItem) Debug() string

func (*FSItem) Equals 

func (a *FSItem) Equals(b *FSItem) (ok bool, why string)

func (*FSItem) GenerateConflictFD 

func (e *FSItem) GenerateConflictFD() (err error)

func (*FSItem) GetCheckoutMode 

func (e *FSItem) GetCheckoutMode() (m checkout_mode.Mode)

func (*FSItem) GetCheckoutModeOrError 

func (e *FSItem) GetCheckoutModeOrError() (m checkout_mode.Mode, err error)

func (*FSItem) GetExternalObjectId 

func (ef *FSItem) GetExternalObjectId() *ids.ExternalObjectId

func (*FSItem) GetTai 

func (i *FSItem) GetTai() ids.Tai

func (*FSItem) GetTime 

func (i *FSItem) GetTime() thyme.Time

func (*FSItem) LatestModTime 

func (i *FSItem) LatestModTime() thyme.Time

func (*FSItem) Reset 

func (dst *FSItem) Reset()

func (*FSItem) ResetWith 

func (dst *FSItem) ResetWith(src *FSItem)

func (*FSItem) String 

func (ef *FSItem) String() string

func (*FSItem) WriteToExternalObjectId 

func (ef *FSItem) WriteToExternalObjectId(
	eoid *ids.ExternalObjectId,
	dirLayout env_dir.Env,
) (err error)

func (*FSItem) WriteToSku 

func (ef *FSItem) WriteToSku(
	external *Transacted,
	dirLayout env_dir.Env,
) (err error)

type FSItemReadWriter 

type FSItemReadWriter interface {
	ReadFSItemFromExternal(TransactedGetter) (*FSItem, error)
	WriteFSItemToExternal(*FSItem, TransactedGetter) (err error)
}

type FuncPrimitiveQuery 

type FuncPrimitiveQuery = func(
	PrimitiveQueryGroup,
	interfaces.FuncIter[*Transacted],
) (err error)

type FuncQuery 

type FuncQuery = func(
	QueryGroup,
	interfaces.FuncIter[*Transacted],
) (err error)

type FuncReadOneInto 

type FuncReadOneInto = func(
	k1 interfaces.ObjectId,
	out *Transacted,
) (err error)

type Importer 

type Importer interface {
	GetCheckedOutPrinter() interfaces.FuncIter[*CheckedOut]

	SetCheckedOutPrinter(
		p interfaces.FuncIter[*CheckedOut],
	)

	ImportBlobIfNecessary(
		sk *Transacted,
	) (err error)

	Import(
		external *Transacted,
	) (co *CheckedOut, err error)
}

type ImporterOptions 

type ImporterOptions struct {
	BlobGenres          ids.Genre
	ExcludeObjects      bool
	RemoteBlobStore     interfaces.BlobStore
	PrintCopies         bool
	AllowMergeConflicts bool
	BlobCopierDelegate  interfaces.FuncIter[BlobCopyResult]
	ParentNegotiator    ParentNegotiator
	CheckedOutPrinter   interfaces.FuncIter[*CheckedOut]
}

type IndexObject 

type IndexObject interface {
	ReadOneObjectIdTai(
		k interfaces.ObjectId,
		t ids.Tai,
	) (sk *Transacted, err error)

	ReadManyObjectId(
		id interfaces.ObjectId,
	) (skus []*Transacted, err error)

	ReadOneObjectId(
		oid interfaces.ObjectId,
		sk *Transacted,
	) (err error)

	ObjectExists(
		id *ids.ObjectId,
	) (err error)

	ReadManySha(
		sh *sha.Sha,
	) (skus []*Transacted, err error)

	ReadOneSha(
		sh *sha.Sha,
		sk *Transacted,
	) (err error)
}

type InventoryList 

type InventoryList struct {
	*Transacted
	*List
}

type InventoryListStore 

type InventoryListStore interface {
	FormatForVersion(sv interfaces.StoreVersion) ListFormat
	WriteInventoryListObject(t *Transacted) (err error)
	ImportInventoryList(bs interfaces.BlobStore, t *Transacted) (err error)

	ReadLast() (max *Transacted, err error)

	IterInventoryList(interfaces.Sha) iter.Seq2[*Transacted, error]

	ReadAllSkus(
		f func(besty, sk *Transacted) error,
	) (err error)

	IterAllInventoryLists() iter.Seq2[*Transacted, error]
	MakeImporter(ImporterOptions, StoreOptions) Importer
	ImportList(*List, Importer) error
}

type IterMatching 

type IterMatching func(
	mt UnsureMatchType,
	sk *Transacted,
	existing SkuTypeSetMutable,
) error

type List 

type List = heap.Heap[Transacted, *Transacted]

TODO rename to ListTransacted

func CollectList 

func CollectList(seq iter.Seq2[*Transacted, error]) (list *List, err error)

func MakeList 

func MakeList() *List

TODO rename to MakeListTransacted

type ListCheckedOut 

type ListCheckedOut = heap.Heap[CheckedOut, *CheckedOut]

func CollectListCheckedOut 

func CollectListCheckedOut(
	seq iter.Seq2[*CheckedOut, error],
) (list *ListCheckedOut, err error)

func MakeListCheckedOut 

func MakeListCheckedOut() *ListCheckedOut

type ListFormat 

type ListFormat interface {
	GetType() ids.Type
	GetListFormat() ListFormat
	WriteObjectToOpenList(*Transacted, *OpenList) (int64, error)
	WriteInventoryListBlob(Collection, io.Writer) (int64, error)
	WriteInventoryListObject(*Transacted, io.Writer) (int64, error)
	ReadInventoryListObject(io.Reader) (int64, *Transacted, error)
	StreamInventoryListBlobSkus(
		rf io.Reader,
		f interfaces.FuncIter[*Transacted],
	) error
	AllInventoryListBlobSkus(io.Reader) interfaces.SeqError[*Transacted]
}

type LuaTablePoolV1 

type LuaTablePoolV1 = interfaces.Pool[LuaTableV1, *LuaTableV1]

func MakeLuaTablePoolV1 

func MakeLuaTablePoolV1(vm *lua.VM) LuaTablePoolV1

type LuaTablePoolV2 

type LuaTablePoolV2 = interfaces.Pool[LuaTableV2, *LuaTableV2]

func MakeLuaTablePoolV2 

func MakeLuaTablePoolV2(vm *lua.VM) LuaTablePoolV2

type LuaTableV1 

type LuaTableV1 struct {
	Transacted   *lua.LTable
	Tags         *lua.LTable
	TagsImplicit *lua.LTable
}

type LuaTableV2 

type LuaTableV2 struct {
	Transacted *lua.LTable

	// TODO transition to single Tags table with Tag objects that reflect
	// tag_paths.PathWithType
	Tags         *lua.LTable
	TagsImplicit *lua.LTable
}

type LuaVMPoolV1 

type LuaVMPoolV1 interfaces.Pool2[LuaVMV1, *LuaVMV1]

func MakeLuaVMPoolV1 

func MakeLuaVMPoolV1(lvp *lua.VMPool, selbst *Transacted) LuaVMPoolV1

type LuaVMPoolV2 

type LuaVMPoolV2 interfaces.Pool2[LuaVMV2, *LuaVMV2]

func MakeLuaVMPoolV2 

func MakeLuaVMPoolV2(lvp *lua.VMPool, selbst *Transacted) LuaVMPoolV2

type LuaVMV1 

type LuaVMV1 struct {
	lua.LValue
	*lua.VM
	TablePool LuaTablePoolV1
	Selbst    *Transacted
}

func PushTopFuncV1 

func PushTopFuncV1(
	lvm LuaVMPoolV1,
	args []string,
) (vm *LuaVMV1, argsOut []string, err error)

type LuaVMV2 

type LuaVMV2 struct {
	lua.LValue
	*lua.VM
	TablePool LuaTablePoolV2
	Selbst    *Transacted
}

func PushTopFuncV2 

func PushTopFuncV2(
	lvm LuaVMPoolV2,
	args []string,
) (vm *LuaVMV2, argsOut []string, err error)

type ObjectFactory 

type ObjectFactory = objectFactoryCheckedOut

type ObjectIdKeyer 

type ObjectIdKeyer[T ids.ObjectIdGetter] struct{}

func (ObjectIdKeyer[T]) GetKey 

func (sk ObjectIdKeyer[T]) GetKey(e T) (key string)

type ObjectProbeIndex 

type ObjectProbeIndex interface {
	ReadOneObjectId(interfaces.ObjectId, *Transacted) error
}

type ObjectStore 

type ObjectStore interface {
	Commit(ExternalLike, CommitOptions) (err error)
	ReadOneInto(interfaces.ObjectId, *Transacted) (err error)
	ReadPrimitiveQuery(
		qg PrimitiveQueryGroup,
		w interfaces.FuncIter[*Transacted],
	) (err error)
}

type ObjectWithList 

type ObjectWithList struct {
	Object, List *Transacted
}

type OneReader 

type OneReader interface {
	ReadTransactedFromObjectId(
		k1 interfaces.ObjectId,
	) (sk1 *Transacted, err error)
}

type OpenList 

type OpenList struct {
	Tipe ids.Type
	*env_dir.Mover
	Description descriptions.Description
	LastTai     ids.Tai
	Len         int
}

type ParentNegotiator 

type ParentNegotiator interface {
	FindBestCommonAncestor(Conflicted) (*Transacted, error)
}

type PrimitiveQueryGroup 

type PrimitiveQueryGroup interface {
	Get(genres.Genre) (QueryWithSigilAndObjectId, bool)
	SigilGetter
	HasHidden() bool
}

Used by store_verzeichnisse.binary*

func MakePrimitiveQueryGroup 

func MakePrimitiveQueryGroup() PrimitiveQueryGroup

func MakePrimitiveQueryGroupWithSigils 

func MakePrimitiveQueryGroupWithSigils(ss ...ids.Sigil) PrimitiveQueryGroup

type Proto 

type Proto struct {
	object_metadata.Metadata
}

func MakeProto 

func MakeProto(defaults config_mutable_blobs.Defaults) (proto Proto)

func (Proto) Apply 

func (proto Proto) Apply(
	metadataLike object_metadata.MetadataLike,
	genreGetter interfaces.GenreGetter,
) (changed bool)

func (Proto) ApplyType 

func (proto Proto) ApplyType(
	metadataLike object_metadata.MetadataLike,
	genreGetter interfaces.GenreGetter,
) (ok bool)

func (Proto) ApplyWithBlobFD 

func (pz Proto) ApplyWithBlobFD(
	ml object_metadata.MetadataLike,
	blobFD *fd.FD,
) (err error)

func (Proto) Equals 

func (pz Proto) Equals(z *object_metadata.Metadata) (ok bool)

func (Proto) Make 

func (pz Proto) Make() (z *Transacted)

func (*Proto) SetFlagSet 

func (pz *Proto) SetFlagSet(f *flag.FlagSet)

type Query 

type Query interface {
	Queryable
	interfaces.Stringer
}

type QueryGroup 

type QueryGroup interface {
	PrimitiveQueryGroup
	Query
	SetIncludeHistory()
	GetTags() ids.TagSet
	GetTypes() ids.TypeSet
}

type QueryWithSigilAndObjectId 

type QueryWithSigilAndObjectId interface {
	Query
	SigilGetter
	ContainsObjectId(*ids.ObjectId) bool
}

type Queryable 

type Queryable interface {
	ContainsSku(TransactedGetter) bool
}

type SigilGetter 

type SigilGetter interface {
	GetSigil() ids.Sigil
}

type SkuType 

type SkuType = *CheckedOut

type SkuTypeSet 

type SkuTypeSet = CheckedOutSet

type SkuTypeSetMutable 

type SkuTypeSetMutable = CheckedOutMutableSet

type StoreOptions 

type StoreOptions struct {
	StreamIndexOptions StreamIndexOptions
	AddToInventoryList bool
	ApplyProto         bool // TODO remove
	ApplyProtoType     bool // TODO remove
	MergeCheckedOut    bool
	RunHooks           bool
	UpdateTai          bool
	Validate           bool
}

func GetStoreOptionsCreate 

func GetStoreOptionsCreate() StoreOptions

func GetStoreOptionsImport 

func GetStoreOptionsImport() StoreOptions

func GetStoreOptionsRealizeSansProto 

func GetStoreOptionsRealizeSansProto() StoreOptions

func GetStoreOptionsRealizeWithProto 

func GetStoreOptionsRealizeWithProto() StoreOptions

func GetStoreOptionsReindex 

func GetStoreOptionsReindex() StoreOptions

func GetStoreOptionsRemoteTransfer 

func GetStoreOptionsRemoteTransfer() StoreOptions

func GetStoreOptionsUpdate 

func GetStoreOptionsUpdate() StoreOptions

type StreamIndexOptions 

type StreamIndexOptions struct {
	ForceLatest      bool
	AddToStreamIndex bool
}

type Transacted 

type Transacted struct {
	ObjectId ids.ObjectId
	Metadata object_metadata.Metadata

	ExternalType ids.Type

	// TODO add support for querying the below
	RepoId           ids.RepoId
	State            external_state.State
	ExternalObjectId ids.ExternalObjectId
}

func (*Transacted) AddTagPtr 

func (a *Transacted) AddTagPtr(e *ids.Tag) (err error)

func (*Transacted) AddTagPtrFast 

func (a *Transacted) AddTagPtrFast(e *ids.Tag) (err error)

func (*Transacted) CalculateObjectShaDebug 

func (s *Transacted) CalculateObjectShaDebug() (err error)

func (*Transacted) CalculateObjectShas 

func (s *Transacted) CalculateObjectShas() (err error)

func (*Transacted) CloneTransacted 

func (a *Transacted) CloneTransacted() (b *Transacted)

func (*Transacted) Equals 

func (a *Transacted) Equals(b *Transacted) (ok bool)

func (*Transacted) EqualsAny 

func (a *Transacted) EqualsAny(b any) (ok bool)

func (*Transacted) GetBlobSha 

func (s *Transacted) GetBlobSha() interfaces.Sha

func (*Transacted) GetExternalObjectId 

func (t *Transacted) GetExternalObjectId() ids.ExternalObjectIdLike

func (*Transacted) GetExternalState 

func (t *Transacted) GetExternalState() external_state.State

func (*Transacted) GetGenre 

func (s *Transacted) GetGenre() interfaces.Genre

func (*Transacted) GetKey 

func (o *Transacted) GetKey() string

func (*Transacted) GetMetadata 

func (a *Transacted) GetMetadata() *object_metadata.Metadata

func (*Transacted) GetObjectId 

func (a *Transacted) GetObjectId() *ids.ObjectId

func (*Transacted) GetObjectSha 

func (s *Transacted) GetObjectSha() interfaces.Sha

func (*Transacted) GetRepoId 

func (t *Transacted) GetRepoId() ids.RepoId

func (*Transacted) GetSku 

func (t *Transacted) GetSku() *Transacted

func (*Transacted) GetSkuExternal 

func (t *Transacted) GetSkuExternal() *Transacted

func (*Transacted) GetTags 

func (a *Transacted) GetTags() ids.TagSet

func (*Transacted) GetTai 

func (a *Transacted) GetTai() ids.Tai

func (*Transacted) GetType 

func (a *Transacted) GetType() ids.Type

func (*Transacted) IsNew 

func (s *Transacted) IsNew() bool

func (*Transacted) Less 

func (a *Transacted) Less(b *Transacted) bool

func (*Transacted) SetBlobSha 

func (s *Transacted) SetBlobSha(sh interfaces.Sha) error

func (*Transacted) SetDormant 

func (s *Transacted) SetDormant(v bool)

func (*Transacted) SetFromTransacted 

func (a *Transacted) SetFromTransacted(b *Transacted) (err error)

func (*Transacted) SetObjectIdLike 

func (a *Transacted) SetObjectIdLike(kl interfaces.ObjectId) (err error)

func (*Transacted) SetObjectSha 

func (s *Transacted) SetObjectSha(v interfaces.Sha) (err error)

func (*Transacted) SetTai 

func (a *Transacted) SetTai(t ids.Tai)

func (*Transacted) String 

func (a *Transacted) String() string

func (*Transacted) StringObjectIdDescription 

func (a *Transacted) StringObjectIdDescription() string

func (*Transacted) StringObjectIdParent 

func (a *Transacted) StringObjectIdParent() string

func (*Transacted) StringObjectIdSha 

func (a *Transacted) StringObjectIdSha() string

func (*Transacted) StringObjectIdTai 

func (a *Transacted) StringObjectIdTai() string

func (*Transacted) StringObjectIdTaiBlob 

func (a *Transacted) StringObjectIdTaiBlob() string

type TransactedGetter 

type TransactedGetter interface {
	GetSku() *Transacted
}

type TransactedMutableSet 

type TransactedMutableSet = interfaces.MutableSetLike[*Transacted]

func MakeTransactedMutableSet 

func MakeTransactedMutableSet() TransactedMutableSet

type TransactedSet 

type TransactedSet = interfaces.SetLike[*Transacted]

func MakeTransactedSet 

func MakeTransactedSet() TransactedSet

type TransactedWithBlob 

type TransactedWithBlob[T any] struct {
	*Transacted
	Blob T
}

TODO examine removing this

type UIStorePrinters 

type UIStorePrinters struct {
	TransactedNew       interfaces.FuncIter[*Transacted]
	TransactedUpdated   interfaces.FuncIter[*Transacted]
	TransactedUnchanged interfaces.FuncIter[*Transacted]

	CheckedOutCheckedOut interfaces.FuncIter[SkuType]
	CheckedOutChanged    interfaces.FuncIter[SkuType]
}

type UnsureMatchMap 

type UnsureMatchMap struct {
	UnsureMatchType
	Lookup map[sha.Bytes]SkuTypeSetMutable
}

type UnsureMatchMaps 

type UnsureMatchMaps struct {
	Lookup map[UnsureMatchType]UnsureMatchMap
}

func (UnsureMatchMaps) Len 

func (umm UnsureMatchMaps) Len() int

type UnsureMatchOptions 

type UnsureMatchOptions struct {
	UnsureMatchType
}

func UnsureMatchOptionsDefault 

func UnsureMatchOptionsDefault() UnsureMatchOptions

type UnsureMatchType 

type UnsureMatchType byte

func (UnsureMatchType) Contains 

func (a UnsureMatchType) Contains(b UnsureMatchType) bool

func (UnsureMatchType) MakeMatchMap 

func (a UnsureMatchType) MakeMatchMap() UnsureMatchMaps

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.