evaluators

package
v1.1.1 Latest Latest
Warning

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

 Go to latest Published: Dec 7, 2025 License: MIT Imports: 5 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type BusinessDaysEvaluator 

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

BusinessDaysEvaluator handles business days calendar rules

func NewBusinessDaysEvaluator 

func NewBusinessDaysEvaluator(provider types.BusinessCalendarProvider) *BusinessDaysEvaluator

NewBusinessDaysEvaluator creates a new business days evaluator

func (*BusinessDaysEvaluator) Evaluate 

func (e *BusinessDaysEvaluator) Evaluate(ctx context.Context, rule *schedule.CalendarRule, from time.Time, timezone *time.Location) (*time.Time, error)

Evaluate returns the next execution time for a business days rule after the given time

func (*BusinessDaysEvaluator) EvaluateMultiple 

func (e *BusinessDaysEvaluator) EvaluateMultiple(ctx context.Context, rule *schedule.CalendarRule, from time.Time, timezone *time.Location, count int) ([]time.Time, error)

EvaluateMultiple returns the next N execution times for a business days rule

func (*BusinessDaysEvaluator) GetRuleType 

func (e *BusinessDaysEvaluator) GetRuleType() types.RuleType

GetRuleType returns the type of rule this evaluator handles

func (*BusinessDaysEvaluator) Validate 

func (e *BusinessDaysEvaluator) Validate(ctx context.Context, rule *schedule.CalendarRule) error

Validate checks if a business days rule is valid

type CronExpressionProcessor 

type CronExpressionProcessor struct{}

CronExpressionProcessor handles cron-like expressions in custom rules

func NewCronExpressionProcessor 

func NewCronExpressionProcessor() *CronExpressionProcessor

NewCronExpressionProcessor creates a new cron expression processor

func (*CronExpressionProcessor) GetDescription 

func (p *CronExpressionProcessor) GetDescription() string

GetDescription returns a description of the cron expression processor

func (*CronExpressionProcessor) Process 

func (p *CronExpressionProcessor) Process(ctx context.Context, rule *schedule.CustomRule, from time.Time, timezone *time.Location) (*time.Time, error)

Process evaluates a cron expression custom rule

func (*CronExpressionProcessor) ProcessMultiple 

func (p *CronExpressionProcessor) ProcessMultiple(ctx context.Context, rule *schedule.CustomRule, from time.Time, timezone *time.Location, count int) ([]time.Time, error)

ProcessMultiple evaluates a cron expression custom rule for multiple times

func (*CronExpressionProcessor) Validate 

func (p *CronExpressionProcessor) Validate(ctx context.Context, rule *schedule.CustomRule) error

Validate validates a cron expression custom rule

type CustomEvaluator 

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

CustomEvaluator handles custom calendar rules

func NewCustomEvaluator 

func NewCustomEvaluator() *CustomEvaluator

NewCustomEvaluator creates a new custom rule evaluator

func (*CustomEvaluator) Evaluate 

func (e *CustomEvaluator) Evaluate(ctx context.Context, rule *schedule.CalendarRule, from time.Time, timezone *time.Location) (*time.Time, error)

Evaluate returns the next execution time for a custom rule after the given time

func (*CustomEvaluator) EvaluateMultiple 

func (e *CustomEvaluator) EvaluateMultiple(ctx context.Context, rule *schedule.CalendarRule, from time.Time, timezone *time.Location, count int) ([]time.Time, error)

EvaluateMultiple returns the next N execution times for a custom rule

func (*CustomEvaluator) GetRegisteredProcessors 

func (e *CustomEvaluator) GetRegisteredProcessors() []string

GetRegisteredProcessors returns all registered processor types

func (*CustomEvaluator) GetRuleType 

func (e *CustomEvaluator) GetRuleType() types.RuleType

GetRuleType returns the type of rule this evaluator handles

func (*CustomEvaluator) RegisterProcessor 

func (e *CustomEvaluator) RegisterProcessor(ruleType string, processor CustomRuleProcessor)

RegisterProcessor registers a custom rule processor

func (*CustomEvaluator) UnregisterProcessor 

func (e *CustomEvaluator) UnregisterProcessor(ruleType string)

UnregisterProcessor unregisters a custom rule processor

func (*CustomEvaluator) Validate 

func (e *CustomEvaluator) Validate(ctx context.Context, rule *schedule.CalendarRule) error

Validate checks if a custom rule is valid

type CustomRuleProcessor 

type CustomRuleProcessor interface {
	// Process evaluates a custom rule and returns the next execution time
	Process(ctx context.Context, rule *schedule.CustomRule, from time.Time, timezone *time.Location) (*time.Time, error)

	// ProcessMultiple evaluates a custom rule and returns multiple execution times
	ProcessMultiple(ctx context.Context, rule *schedule.CustomRule, from time.Time, timezone *time.Location, count int) ([]time.Time, error)

	// Validate validates a custom rule
	Validate(ctx context.Context, rule *schedule.CustomRule) error

	// GetDescription returns a description of what this processor handles
	GetDescription() string
}

CustomRuleProcessor interface for processing custom rules

type DailyEvaluator 

type DailyEvaluator struct{}

DailyEvaluator handles daily calendar rules

func NewDailyEvaluator 

func NewDailyEvaluator() *DailyEvaluator

NewDailyEvaluator creates a new daily rule evaluator

func (*DailyEvaluator) Evaluate 

func (e *DailyEvaluator) Evaluate(ctx context.Context, rule *schedule.CalendarRule, from time.Time, timezone *time.Location) (*time.Time, error)

Evaluate returns the next execution time for a daily rule after the given time

func (*DailyEvaluator) EvaluateMultiple 

func (e *DailyEvaluator) EvaluateMultiple(ctx context.Context, rule *schedule.CalendarRule, from time.Time, timezone *time.Location, count int) ([]time.Time, error)

EvaluateMultiple returns the next N execution times for a daily rule

func (*DailyEvaluator) GetRuleType 

func (e *DailyEvaluator) GetRuleType() types.RuleType

GetRuleType returns the type of rule this evaluator handles

func (*DailyEvaluator) Validate 

func (e *DailyEvaluator) Validate(ctx context.Context, rule *schedule.CalendarRule) error

Validate checks if a daily rule is valid

type EvaluatorInfo 

type EvaluatorInfo struct {
	RuleType    types.RuleType      `json:"rule_type"`
	Name        string              `json:"name"`
	Description string              `json:"description"`
	Evaluator   types.RuleEvaluator `json:"-"` // Don't serialize the evaluator itself
}

EvaluatorInfo contains information about a registered evaluator

type IntervalProcessor 

type IntervalProcessor struct{}

IntervalProcessor handles simple interval-based custom rules

func NewIntervalProcessor 

func NewIntervalProcessor() *IntervalProcessor

NewIntervalProcessor creates a new interval processor

func (*IntervalProcessor) GetDescription 

func (p *IntervalProcessor) GetDescription() string

GetDescription returns a description of the interval processor

func (*IntervalProcessor) Process 

func (p *IntervalProcessor) Process(ctx context.Context, rule *schedule.CustomRule, from time.Time, timezone *time.Location) (*time.Time, error)

Process evaluates an interval custom rule

func (*IntervalProcessor) ProcessMultiple 

func (p *IntervalProcessor) ProcessMultiple(ctx context.Context, rule *schedule.CustomRule, from time.Time, timezone *time.Location, count int) ([]time.Time, error)

ProcessMultiple evaluates an interval custom rule for multiple times

func (*IntervalProcessor) Validate 

func (p *IntervalProcessor) Validate(ctx context.Context, rule *schedule.CustomRule) error

Validate validates an interval custom rule

type MonthlyEvaluator 

type MonthlyEvaluator struct{}

MonthlyEvaluator handles monthly calendar rules

func NewMonthlyEvaluator 

func NewMonthlyEvaluator() *MonthlyEvaluator

NewMonthlyEvaluator creates a new monthly rule evaluator

func (*MonthlyEvaluator) Evaluate 

func (e *MonthlyEvaluator) Evaluate(ctx context.Context, rule *schedule.CalendarRule, from time.Time, timezone *time.Location) (*time.Time, error)

Evaluate returns the next execution time for a monthly rule after the given time

func (*MonthlyEvaluator) EvaluateMultiple 

func (e *MonthlyEvaluator) EvaluateMultiple(ctx context.Context, rule *schedule.CalendarRule, from time.Time, timezone *time.Location, count int) ([]time.Time, error)

EvaluateMultiple returns the next N execution times for a monthly rule

func (*MonthlyEvaluator) GetRuleType 

func (e *MonthlyEvaluator) GetRuleType() types.RuleType

GetRuleType returns the type of rule this evaluator handles

func (*MonthlyEvaluator) Validate 

func (e *MonthlyEvaluator) Validate(ctx context.Context, rule *schedule.CalendarRule) error

Validate checks if a monthly rule is valid

type Registry 

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

Registry manages all calendar rule evaluators

func DefaultRegistry 

func DefaultRegistry() *Registry

DefaultRegistry returns a registry with all default evaluators

func DefaultRegistryWithBusinessCalendar 

func DefaultRegistryWithBusinessCalendar(provider types.BusinessCalendarProvider) *Registry

DefaultRegistryWithBusinessCalendar returns a registry with business calendar support

func NewRegistry 

func NewRegistry() *Registry

NewRegistry creates a new evaluator registry with default evaluators

func NewRegistryWithBusinessCalendar 

func NewRegistryWithBusinessCalendar(provider types.BusinessCalendarProvider) *Registry

NewRegistryWithBusinessCalendar creates a new registry with business calendar support

func (*Registry) Clone 

func (r *Registry) Clone() *Registry

Clone creates a copy of the registry

func (*Registry) EvaluateRule 

func (r *Registry) EvaluateRule(ctx context.Context, rule *schedule.CalendarRule, from time.Time, timezone *time.Location) (*time.Time, error)

EvaluateRule evaluates a calendar rule using the appropriate evaluator

func (*Registry) EvaluateRuleMultiple 

func (r *Registry) EvaluateRuleMultiple(ctx context.Context, rule *schedule.CalendarRule, from time.Time, timezone *time.Location, count int) ([]time.Time, error)

EvaluateRuleMultiple evaluates a calendar rule for multiple execution times

func (*Registry) GetEvaluator 

func (r *Registry) GetEvaluator(ruleType types.RuleType) (types.RuleEvaluator, error)

GetEvaluator returns the evaluator for a specific rule type

func (*Registry) GetEvaluatorInfo 

func (r *Registry) GetEvaluatorInfo() []EvaluatorInfo

GetEvaluatorInfo returns information about all registered evaluators

func (*Registry) GetRegisteredTypes 

func (r *Registry) GetRegisteredTypes() []types.RuleType

GetRegisteredTypes returns all registered rule types

func (*Registry) RegisterEvaluator 

func (r *Registry) RegisterEvaluator(evaluator types.RuleEvaluator)

RegisterEvaluator registers a rule evaluator

func (*Registry) UnregisterEvaluator 

func (r *Registry) UnregisterEvaluator(ruleType types.RuleType)

UnregisterEvaluator unregisters a rule evaluator

func (*Registry) ValidateAllRules 

func (r *Registry) ValidateAllRules(ctx context.Context, calendarSchedule *schedule.CalendarSchedule) error

ValidateAllRules validates all rules in a calendar schedule

func (*Registry) ValidateRule 

func (r *Registry) ValidateRule(ctx context.Context, rule *schedule.CalendarRule) error

ValidateRule validates a calendar rule using the appropriate evaluator

type WeeklyEvaluator 

type WeeklyEvaluator struct{}

WeeklyEvaluator handles weekly calendar rules

func NewWeeklyEvaluator 

func NewWeeklyEvaluator() *WeeklyEvaluator

NewWeeklyEvaluator creates a new weekly rule evaluator

func (*WeeklyEvaluator) Evaluate 

func (e *WeeklyEvaluator) Evaluate(ctx context.Context, rule *schedule.CalendarRule, from time.Time, timezone *time.Location) (*time.Time, error)

Evaluate returns the next execution time for a weekly rule after the given time

func (*WeeklyEvaluator) EvaluateMultiple 

func (e *WeeklyEvaluator) EvaluateMultiple(ctx context.Context, rule *schedule.CalendarRule, from time.Time, timezone *time.Location, count int) ([]time.Time, error)

EvaluateMultiple returns the next N execution times for a weekly rule

func (*WeeklyEvaluator) GetRuleType 

func (e *WeeklyEvaluator) GetRuleType() types.RuleType

GetRuleType returns the type of rule this evaluator handles

func (*WeeklyEvaluator) Validate 

func (e *WeeklyEvaluator) Validate(ctx context.Context, rule *schedule.CalendarRule) error

Validate checks if a weekly rule is valid

type YearlyEvaluator 

type YearlyEvaluator struct{}

YearlyEvaluator handles yearly calendar rules

func NewYearlyEvaluator 

func NewYearlyEvaluator() *YearlyEvaluator

NewYearlyEvaluator creates a new yearly rule evaluator

func (*YearlyEvaluator) Evaluate 

func (e *YearlyEvaluator) Evaluate(ctx context.Context, rule *schedule.CalendarRule, from time.Time, timezone *time.Location) (*time.Time, error)

Evaluate returns the next execution time for a yearly rule after the given time

func (*YearlyEvaluator) EvaluateMultiple 

func (e *YearlyEvaluator) EvaluateMultiple(ctx context.Context, rule *schedule.CalendarRule, from time.Time, timezone *time.Location, count int) ([]time.Time, error)

EvaluateMultiple returns the next N execution times for a yearly rule

func (*YearlyEvaluator) GetRuleType 

func (e *YearlyEvaluator) GetRuleType() types.RuleType

GetRuleType returns the type of rule this evaluator handles

func (*YearlyEvaluator) Validate 

func (e *YearlyEvaluator) Validate(ctx context.Context, rule *schedule.CalendarRule) error

Validate checks if a yearly rule is valid

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.