chain

type Chain ¶

type Chain[K comparable, V any] struct {
	// contains filtered or unexported fields
}

func New[K comparable, V any](cache []trcache.Cache[K, V],
	options ...trcache.RootOption) (*Chain[K, V], error)

func (c *Chain[K, V]) Delete(ctx context.Context, key K,
	options ...trcache.DeleteOption) error

func (c *Chain[K, V]) Get(ctx context.Context, key K,
	options ...trcache.GetOption) (V, error)

func (c *Chain[K, V]) Name() string

func (c *Chain[K, V]) Set(ctx context.Context, key K, value V,
	options ...trcache.SetOption) error

type ChainError ¶

type ChainError struct {
	ErrType ChainErrorType
	Message string
	Err     error
}

func NewChainError(errType ChainErrorType, message string, err error) ChainError

func (e ChainError) As(target any) bool

func (e ChainError) Error() string

func (e ChainError) Is(err error) bool

type ChainErrorType ¶

type ChainErrorType int

const (
	ChainErrorTypeError ChainErrorType = iota
	ChainErrorTypeIncomplete
)

type ChainRefresh ¶

type ChainRefresh[K comparable, V any] struct {
	*Chain[K, V]
	// contains filtered or unexported fields
}

func NewRefresh[K comparable, V any](cache []trcache.Cache[K, V],
	options ...trcache.RootOption) (*ChainRefresh[K, V], error)

func (c *ChainRefresh[K, V]) GetOrRefresh(ctx context.Context, key K, options ...trcache.RefreshOption) (V, error)

type DeleteStrategy ¶

type DeleteStrategy[K comparable, V any] interface {
	DeleteLoopOrder(ctx context.Context) StrategyLoopOrder
	BeforeDelete(ctx context.Context, cacheIdx int, cache trcache.Cache[K, V], key K) DeleteStrategyBeforeResult
	AfterDelete(ctx context.Context, cacheIdx int, cache trcache.Cache[K, V], key K, err error) DeleteStrategyAfterResult
}

DeleteStrategy is the strategy to be used on Chain.Delete.

Chain.Delete uses this logic:

• **loop** on the list of caches from 0 to len().
• call [DeleteStrategy.BeforeDelete] on the current cache.
• if SKIP, stop processing this cache and go to next loop.
• if DELETE, continue processing.
• call [Cache.Delete] and store the error
• call [DeleteStrategy.AfterDelete] with the result of the previous call (including the error).
• if RETURN, return immediately the previous call error result.
• if CONTINUEWITHERROR, continue to the next loop item, appending the error to a list of errors to return.
• if CONTINUE, continue to the next loop item.
• at the end, return the error list if any.

func NewDefaultDeleteStrategy[K comparable, V any]() DeleteStrategy[K, V]

type DeleteStrategyAfterResult ¶

type DeleteStrategyAfterResult int

const (
	DeleteStrategyAfterResultCONTINUE DeleteStrategyAfterResult = iota
	DeleteStrategyAfterResultRETURN
	DeleteStrategyAfterResultCONTINUEWITHERROR
)

type DeleteStrategyBeforeResult ¶

type DeleteStrategyBeforeResult int

const (
	DeleteStrategyBeforeResultDELETE DeleteStrategyBeforeResult = iota
	DeleteStrategyBeforeResultSKIP
)

type DeleteStrategyDeleteAll ¶

type DeleteStrategyDeleteAll[K comparable, V any] struct {
}

func (f DeleteStrategyDeleteAll[K, V]) AfterDelete(ctx context.Context, cacheIdx int, cache trcache.Cache[K, V], key K, err error) DeleteStrategyAfterResult

func (f DeleteStrategyDeleteAll[K, V]) BeforeDelete(ctx context.Context, cacheIdx int, cache trcache.Cache[K, V], key K) DeleteStrategyBeforeResult

func (f DeleteStrategyDeleteAll[K, V]) DeleteLoopOrder(ctx context.Context) StrategyLoopOrder

type DeleteStrategyFunc ¶

type DeleteStrategyFunc[K comparable, V any] struct {
	DeleteLoopOrderFn func(ctx context.Context) StrategyLoopOrder
	BeforeDeleteFn    func(ctx context.Context, cacheIdx int, cache trcache.Cache[K, V], key K) DeleteStrategyBeforeResult
	AfterDeleteFn     func(ctx context.Context, cacheIdx int, cache trcache.Cache[K, V], key K, err error) DeleteStrategyAfterResult
}

func (f DeleteStrategyFunc[K, V]) AfterDelete(ctx context.Context, cacheIdx int, cache trcache.Cache[K, V], key K, err error) DeleteStrategyAfterResult

func (f DeleteStrategyFunc[K, V]) BeforeDelete(ctx context.Context, cacheIdx int, cache trcache.Cache[K, V], key K) DeleteStrategyBeforeResult

func (f DeleteStrategyFunc[K, V]) DeleteLoopOrder(ctx context.Context) StrategyLoopOrder

type GetStrategy ¶

type GetStrategy[K comparable, V any] interface {
	GetLoopOrder(ctx context.Context) StrategyLoopOrder
	BeforeGet(ctx context.Context, cacheIdx int, cache trcache.Cache[K, V], key K) GetStrategyBeforeResult
	AfterGet(ctx context.Context, cacheIdx int, cache trcache.Cache[K, V], key K, value V, err error) GetStrategyAfterResult
	SetLoopOrder(ctx context.Context) StrategyLoopOrder
	BeforeSet(ctx context.Context, gotCacheIdx, cacheIdx int, cache trcache.Cache[K, V], key K, value V) GetStrategyBeforeSetResult
	AfterSet(ctx context.Context, gotCacheIdx, cacheIdx int, cache trcache.Cache[K, V], key K, value V, err error) GetStrategyAfterSetResult
}

GetStrategy is the strategy to be used on Chain.Get.

Chain.Get uses this logic:

• **loop** on the list of caches from 0 to len().
• call [GetStrategy.BeforeGet] on the current cache.
• if SKIP, stop processing this cache and go to next loop.
• if GET, continue processing.
• call [Cache.Get] and store the result / error.
• call [GetStrategy.AfterGet] with the result of the previous call (including the error).
• if SKIP, continue to the next loop item.
• if RETURN, set this result as the current function result (even if it was an error) and exit the loop.
• **if no result was found**, or the last returned result is an error, return the error to the user.
• **loop** on the list of cache from len() to 0 (backwards)
• call [GetStrategy.BeforeSet] on the current cache.
• if SKIP, stop processing this cache and go to next loop.
• if SET, continue processing.
• call [Cache.Set] with the result found in the "Get" loop.
• call [GetStrategy.AfterSet] with the result of the previous call (including the error).
• if RETURN, return immediately with the result and error of the last "Set" call.
• if CONTINUE, continue to the next loop item.
• at the end, return the found result and error.

func NewDefaultGetStrategy[K comparable, V any]() GetStrategy[K, V]

type GetStrategyAfterResult ¶

type GetStrategyAfterResult int

const (
	GetStrategyAfterResultRETURN GetStrategyAfterResult = iota
	GetStrategyAfterResultSKIP
)

type GetStrategyAfterSetResult ¶

type GetStrategyAfterSetResult int

const (
	GetStrategyAfterSetResultCONTINUE GetStrategyAfterSetResult = iota
	GetStrategyAfterSetResultRETURN
)

type GetStrategyBeforeResult ¶

type GetStrategyBeforeResult int

const (
	GetStrategyBeforeResultGET GetStrategyBeforeResult = iota
	GetStrategyBeforeResultSKIP
)

type GetStrategyBeforeSetResult ¶

type GetStrategyBeforeSetResult int

const (
	GetStrategyBeforeSetResultSET GetStrategyBeforeSetResult = iota
	GetStrategyBeforeSetResultSKIP
)

type GetStrategyFunc ¶

type GetStrategyFunc[K comparable, V any] struct {
	GetLoopOrderFn func(ctx context.Context) StrategyLoopOrder
	BeforeGetFn    func(ctx context.Context, cacheIdx int, cache trcache.Cache[K, V], key K) GetStrategyBeforeResult
	AfterGetFn     func(ctx context.Context, cacheIdx int, cache trcache.Cache[K, V], key K, value V, err error) GetStrategyAfterResult
	SetLoopOrderFn func(ctx context.Context) StrategyLoopOrder
	BeforeSetFn    func(ctx context.Context, gotCacheIdx, cacheIdx int, cache trcache.Cache[K, V], key K, value V) GetStrategyBeforeSetResult
	AfterSetFn     func(ctx context.Context, gotCacheIdx, cacheIdx int, cache trcache.Cache[K, V], key K, value V, err error) GetStrategyAfterSetResult
}

func (f GetStrategyFunc[K, V]) AfterGet(ctx context.Context, cacheIdx int, cache trcache.Cache[K, V], key K, value V, err error) GetStrategyAfterResult

func (f GetStrategyFunc[K, V]) AfterSet(ctx context.Context, gotCacheIdx, cacheIdx int, cache trcache.Cache[K, V], key K, value V, err error) GetStrategyAfterSetResult

func (f GetStrategyFunc[K, V]) BeforeGet(ctx context.Context, cacheIdx int, cache trcache.Cache[K, V], key K) GetStrategyBeforeResult

func (f GetStrategyFunc[K, V]) BeforeSet(ctx context.Context, gotCacheIdx, cacheIdx int, cache trcache.Cache[K, V], key K, value V) GetStrategyBeforeSetResult

func (f GetStrategyFunc[K, V]) GetLoopOrder(ctx context.Context) StrategyLoopOrder

func (f GetStrategyFunc[K, V]) SetLoopOrder(ctx context.Context) StrategyLoopOrder

type GetStrategyGetFirstSetPrevious ¶

type GetStrategyGetFirstSetPrevious[K comparable, V any] struct {
}

func (f GetStrategyGetFirstSetPrevious[K, V]) AfterGet(ctx context.Context, cacheIdx int, cache trcache.Cache[K, V], key K, value V, err error) GetStrategyAfterResult

func (f GetStrategyGetFirstSetPrevious[K, V]) AfterSet(ctx context.Context, gotCacheIdx, cacheIdx int, cache trcache.Cache[K, V], key K, value V, err error) GetStrategyAfterSetResult

func (f GetStrategyGetFirstSetPrevious[K, V]) BeforeGet(ctx context.Context, cacheIdx int, cache trcache.Cache[K, V], key K) GetStrategyBeforeResult

func (f GetStrategyGetFirstSetPrevious[K, V]) BeforeSet(ctx context.Context, gotCacheIdx, cacheIdx int, cache trcache.Cache[K, V], key K, value V) GetStrategyBeforeSetResult

func (f GetStrategyGetFirstSetPrevious[K, V]) GetLoopOrder(ctx context.Context) StrategyLoopOrder

func (f GetStrategyGetFirstSetPrevious[K, V]) SetLoopOrder(ctx context.Context) StrategyLoopOrder

type SetStrategy ¶

type SetStrategy[K comparable, V any] interface {
	SetLoopOrder(ctx context.Context) StrategyLoopOrder
	BeforeSet(ctx context.Context, cacheIdx int, cache trcache.Cache[K, V], key K, value V) SetStrategyBeforeResult
	AfterSet(ctx context.Context, cacheIdx int, cache trcache.Cache[K, V], key K, value V, err error) SetStrategyAfterResult
}

SetStrategy is the strategy to be used on Chain.Set.

Chain.Set uses this logic:

• **loop** on the list of caches from 0 to len().
• call [SetStrategy.BeforeSet] on the current cache.
• if SKIP, stop processing this cache and go to next loop.
• if SET, continue processing.
• call [Cache.Set] and store the error.
• call [SetStrategy.AfterSet] with the result of the previous call (including the error).
• if RETURN, return immediately the previous call error result.
• if CONTINUEWITHERROR, continue to the next loop item, appending the error to a list of errors to return.
• if CONTINUE, continue to the next loop item.
• at the end, return the error list if any.

func NewDefaultSetStrategy[K comparable, V any]() SetStrategy[K, V]

type SetStrategyAfterResult ¶

type SetStrategyAfterResult int

const (
	SetStrategyAfterResultCONTINUE SetStrategyAfterResult = iota
	SetStrategyAfterResultRETURN
	SetStrategyAfterResultCONTINUEWITHERROR
)

type SetStrategyBeforeResult ¶

type SetStrategyBeforeResult int

const (
	SetStrategyBeforeResultSET SetStrategyBeforeResult = iota
	SetStrategyBeforeResultSKIP
)

type SetStrategyFunc ¶

type SetStrategyFunc[K comparable, V any] struct {
	SetLoopOrderFn func(ctx context.Context) StrategyLoopOrder
	BeforeSetFn    func(ctx context.Context, cacheIdx int, cache trcache.Cache[K, V], key K, value V) SetStrategyBeforeResult
	AfterSetFn     func(ctx context.Context, cacheIdx int, cache trcache.Cache[K, V], key K, value V, err error) SetStrategyAfterResult
}

func (f SetStrategyFunc[K, V]) AfterSet(ctx context.Context, cacheIdx int, cache trcache.Cache[K, V], key K, value V, err error) SetStrategyAfterResult

func (f SetStrategyFunc[K, V]) BeforeSet(ctx context.Context, cacheIdx int, cache trcache.Cache[K, V], key K, value V) SetStrategyBeforeResult

func (f SetStrategyFunc[K, V]) SetLoopOrder(ctx context.Context) StrategyLoopOrder

type SetStrategySetAll ¶

type SetStrategySetAll[K comparable, V any] struct {
}

func (f SetStrategySetAll[K, V]) AfterSet(ctx context.Context, cacheIdx int, cache trcache.Cache[K, V], key K, value V, err error) SetStrategyAfterResult

func (f SetStrategySetAll[K, V]) BeforeSet(ctx context.Context, cacheIdx int, cache trcache.Cache[K, V], key K, value V) SetStrategyBeforeResult

func (f SetStrategySetAll[K, V]) SetLoopOrder(ctx context.Context) StrategyLoopOrder

type StrategyCallback ¶

type StrategyCallback interface {
	Get(ctx context.Context, cacheIdx int, cacheName string, key any, err error, result GetStrategyAfterResult)
	GetSet(ctx context.Context, cacheIdx int, cacheName string, key any, err error, result GetStrategyAfterSetResult)
	Set(ctx context.Context, cacheIdx int, cacheName string, key any, err error, result SetStrategyAfterResult)
	Delete(ctx context.Context, cacheIdx int, cacheName string, key any, err error, result DeleteStrategyAfterResult)
}

type StrategyCallbackFunc ¶

type StrategyCallbackFunc struct {
	GetFn    func(ctx context.Context, cacheIdx int, cacheName string, key any, err error, result GetStrategyAfterResult)
	GetSetFn func(ctx context.Context, cacheIdx int, cacheName string, key any, err error, result GetStrategyAfterSetResult)
	SetFn    func(ctx context.Context, cacheIdx int, cacheName string, key any, err error, result SetStrategyAfterResult)
	DeleteFn func(ctx context.Context, cacheIdx int, cacheName string, key any, err error, result DeleteStrategyAfterResult)
}

func (s *StrategyCallbackFunc) Delete(ctx context.Context, cacheIdx int, cacheName string, key any, err error,
	result DeleteStrategyAfterResult)

func (s *StrategyCallbackFunc) Get(ctx context.Context, cacheIdx int, cacheName string, key any, err error,
	result GetStrategyAfterResult)

func (s *StrategyCallbackFunc) GetSet(ctx context.Context, cacheIdx int, cacheName string, key any, err error,
	result GetStrategyAfterSetResult)

func (s *StrategyCallbackFunc) Set(ctx context.Context, cacheIdx int, cacheName string, key any, err error,
	result SetStrategyAfterResult)

type StrategyLoopOrder ¶

type StrategyLoopOrder int

const (
	StrategyLoopOrderFORWARD StrategyLoopOrder = iota
	StrategyLoopOrderBACKWARD
)