gone

type AfterStart ¶

type AfterStart func(Process)

AfterStart is a HookReg function type that can be injected into Goners to register callbacks that will execute after the application starts.

Example usage: ```go

type XGoner struct {
    Flag
    after AfterStart `gone:"*"` // Inject the AfterStart HookReg
}

func (x *XGoner) Init() error {
    // Register a callback to run after application start
    x.after(func() {
        fmt.Println("after start")
    })
    return nil
}

```

The registered callbacks will be executed in registration order after all daemons have been started. This allows components to perform tasks that require all services to be running.

type AfterStartProvider ¶

type AfterStartProvider struct {
	Flag
	// contains filtered or unexported fields
}

AfterStartProvider provides the AfterStart hook registration function. This provider allows other components to register functions to be called after application start.

func (s *AfterStartProvider) Provide() (AfterStart, error)

type AfterStarter ¶ added in v2.2.6

type AfterStarter interface {
	AfterStart()
}

AfterStarter interface defines components that need to perform actions after the application starts. Components implementing this interface will have their AfterStart() method called during Gone's startup phase, after all daemons have been started successfully.

The AfterStart() method should: - Perform any setup that requires all services to be running - Register with external services or health checks - Handle errors internally since no error is returned

Example usage:

type MyComponent struct {
    gone.Flag
    healthCheck *HealthCheck `gone:"*"`
}

func (c *MyComponent) AfterStart() {
    c.healthCheck.Register()
    // perform post-start setup...
}

type AfterStop ¶

type AfterStop func(Process)

AfterStop is a HookReg function type that can be injected into Goners to register callbacks that will execute after the application stops.

Example usage: ```go

type XGoner struct {
    Flag
    after AfterStop `gone:"*"` // Inject the AfterStop HookReg
}

func (x *XGoner) Init() error {
    // Register a callback to run after application stop
    x.after(func() {
        fmt.Println("after stop")
    })
    return nil
}

```

The registered callbacks will be executed in registration order after all daemons have been stopped. This allows components to perform final cleanup tasks after all services have been shut down.

type AfterStopProvider ¶

type AfterStopProvider struct {
	Flag
	// contains filtered or unexported fields
}

AfterStopProvider provides the AfterStop hook registration function. This provider allows other components to register functions to be called after application stop.

func (s *AfterStopProvider) Provide() (AfterStop, error)

type AfterStopper ¶ added in v2.2.6

type AfterStopper interface {
	AfterStop()
}

AfterStopper interface defines components that need to perform actions after the application stops. Components implementing this interface will have their AfterStop() method called during Gone's shutdown phase, after all daemons have been stopped successfully.

The AfterStop() method should: - Perform final cleanup tasks - Release any remaining resources - Log shutdown completion - Handle errors internally since no error is returned

Example usage:

type MyComponent struct {
    gone.Flag
    logger *Logger `gone:"*"`
}

func (c *MyComponent) AfterStop() {
    c.logger.Info("Application shutdown complete")
    // perform final cleanup...
}

type Application ¶

type Application struct {
	Flag
	// contains filtered or unexported fields
}

Application represents the core container and orchestrator for the Gone framework. Think of it as the "command center" or "central dispatch" of your application - it's like the conductor of an orchestra who knows every musician (component), their instruments (capabilities), and how they should work together to create beautiful music (your application).

The Application acts as the central hub that: - Loads and manages all components (like a "personnel manager") - Handles dependency injection between components (like a "matchmaker") - Manages application lifecycle with hooks (like a "stage director") - Provides access to components via the GonerKeeper interface (like a "directory service")

Design Philosophy: - Single Responsibility: Each Application instance manages one complete application context - Composition over Inheritance: Built by composing various specialized components - Encapsulation: Internal complexity is hidden behind simple, intuitive interfaces

Key responsibilities: - Component registration and loading ("hiring and onboarding") - Dependency resolution and injection ("team building and collaboration") - Lifecycle management with hooks ("project management") - Graceful shutdown handling ("orderly dismissal")

func Load(goner Goner, options ...Option) *Application

func Loads(loads ...LoadFunc) *Application

func NewApp(loads ...LoadFunc) *Application

func Prepare(loads ...LoadFunc) *Application

func (s *Application) AfterStart(fn Process) *Application

func (s *Application) AfterStop(fn Process) *Application

func (s *Application) BeforeStart(fn Process) *Application

func (s *Application) BeforeStop(fn Process) *Application

func (s *Application) End() *Application

func (s *Application) Load(goner Goner, options ...Option) *Application

func (s *Application) Loads(loads ...LoadFunc) *Application

func (s *Application) Run(funcList ...any)

func (s *Application) Serve(funcList ...any)

func (s *Application) Test(fn any)

func (s *Application) WaitEnd() *Application

type BError ¶

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

BError Business error implementation

func (e *BError) Code() int

func (e *BError) Data() any

func (e *BError) Error() string

func (e *BError) GetStatusCode() int

func (e *BError) Msg() string

func (e *BError) SetMsg(msg string)

type BeforeInitiator ¶

type BeforeInitiator interface {
	BeforeInit() error
}

BeforeInitiator interface defines components that need pre-initialization before regular initialization. Components implementing this interface will have their BeforeInit() method called during Gone's initialization phase, before dependencies are filled and before Init() is called.

The BeforeInit() method should: - Perform any setup needed before dependencies are injected - Initialize basic internal state that doesn't depend on other components - Return an error if pre-initialization fails

Example usage:

type MyComponent struct {
    gone.Flag
    config *Config
}

func (c *MyComponent) BeforeInit() error {
    // Setup basic state before dependencies are filled
    c.config = &Config{}
    return nil
}

type BeforeInitiatorNoError ¶

type BeforeInitiatorNoError interface {
	BeforeInit()
}

BeforeInitiatorNoError interface defines components that need pre-initialization but don't return errors. Similar to BeforeInitiator interface, but BeforeInit() does not return an error. Components implementing this interface will have their BeforeInit() method called during Gone's initialization phase, before dependencies are filled and before Init() is called.

The BeforeInit() method should: - Perform any setup needed before dependencies are injected - Initialize basic internal state that doesn't depend on other components - Handle errors internally rather than returning them

Example usage:

type MyComponent struct {
    gone.Flag
    config *Config
}

func (c *MyComponent) BeforeInit() {
    // Setup basic state before dependencies are filled
    c.config = &Config{}
}

type BeforeStart ¶

type BeforeStart func(Process)

BeforeStart is a HookReg function type that can be injected into Goners to register callbacks that will execute before the application starts.

Example usage: ```go

type XGoner struct {
    Flag
    before BeforeStart `gone:"*"` // Inject the BeforeStart HookReg
}

func (x *XGoner) Init() error {
    // Register a callback to run before application start
    x.before(func() {
        fmt.Println("before start")
    })
    return nil
}

```

The registered callbacks will be executed in registration order before any daemons are started. This allows components to perform initialization tasks that must complete before the application begins its main operations.

type BeforeStartProvider ¶

type BeforeStartProvider struct {
	Flag
	// contains filtered or unexported fields
}

BeforeStartProvider provides the BeforeStart hook registration function. This provider allows other components to register functions to be called before application start.

func (s *BeforeStartProvider) Provide() (BeforeStart, error)

type BeforeStarter ¶ added in v2.2.6

type BeforeStarter interface {
	BeforeStart()
}

BeforeStarter interface defines components that need to perform actions before the application starts. Components implementing this interface will have their BeforeStart() method called during Gone's startup phase, before any daemons are started but after all components have been initialized.

The BeforeStart() method should: - Perform any setup needed before daemons start - Initialize resources that daemons depend on - Handle errors internally since no error is returned

Example usage:

type MyComponent struct {
    gone.Flag
    logger *Logger `gone:"*"`
}

func (c *MyComponent) BeforeStart() {
    c.logger.Info("Preparing for application start")
    // perform pre-start setup...
}

type BeforeStop ¶

type BeforeStop func(Process)

BeforeStop is a HookReg function type that can be injected into Goners to register callbacks that will execute before the application stops.

Example usage: ```go

type XGoner struct {
    Flag
    before BeforeStop `gone:"*"` // Inject the BeforeStop HookReg
}

func (x *XGoner) Init() error {
    // Register a callback to run before application stop
    x.before(func() {
        fmt.Println("before stop")
    })
    return nil
}

```

The registered callbacks will be executed in registration order before any daemons are stopped. This allows components to perform cleanup tasks while services are still running.

type BeforeStopProvider ¶

type BeforeStopProvider struct {
	Flag
	// contains filtered or unexported fields
}

BeforeStopProvider provides the BeforeStop hook registration function. This provider allows other components to register functions to be called before application stop.

func (s *BeforeStopProvider) Provide() (BeforeStop, error)

type BeforeStopper ¶ added in v2.2.6

type BeforeStopper interface {
	BeforeStop()
}

BeforeStopper interface defines components that need to perform actions before the application stops. Components implementing this interface will have their BeforeStop() method called during Gone's shutdown phase, before any daemons are stopped but after termination signal is received.

The BeforeStop() method should: - Perform cleanup tasks while all services are still running - Save important state or data - Gracefully disconnect from external services - Handle errors internally since no error is returned

Example usage:

type MyComponent struct {
    gone.Flag
    cache *Cache `gone:"*"`
}

func (c *MyComponent) BeforeStop() {
    c.cache.Flush()
    // perform pre-stop cleanup...
}

type BusinessError ¶

type BusinessError interface {
	Error
	Data() any
}

BusinessError which has data, and which is used for Business error

func NewBusinessError(msg string, ext ...any) BusinessError

type Component ¶

type Component = Goner

Component is an alias for Goner.

type ConfWatchFunc ¶ added in v2.2.5

type ConfWatchFunc func(oldVal, newVal any)

ConfWatchFunc defines the callback function for configuration changes

type ConfWatcher ¶ added in v2.2.5

type ConfWatcher func(key string, callback ConfWatchFunc)

ConfWatcher which can be injected, to register a callback function to be called when the specified key changes

type ConfigProvider ¶

type ConfigProvider struct {
	Flag
	// contains filtered or unexported fields
}

ConfigProvider implements a provider for injecting configuration values It uses an underlying Configure implementation to retrieve values

func (s *ConfigProvider) GonerName() string

func (s *ConfigProvider) Init()

func (s *ConfigProvider) Provide(tagConf string, t reflect.Type) (any, error)

type Configure ¶

type Configure interface {
	Get(key string, v any, defaultVal string) error
}

Configure defines the interface for configuration providers Get retrieves a configuration value by key, storing it in v, with a default value if not found

type Daemon ¶

type Daemon interface {
	Start() error
	Stop() error
}

Daemon represents a long-running service component that can be started and stopped. Think of it as a "background service worker" that runs continuously to provide specific functionality, like a web server, database connection pool, or message queue processor.

Lifecycle Management: Daemons are started in order of registration when Application.Serve() or Application.start() is called. When the application receives a termination signal, daemons are stopped in reverse order to ensure proper cleanup and resource management.

Error Handling: - If Start() returns an error, the application will panic to prevent inconsistent state - If Stop() returns an error, the application will panic to ensure proper cleanup

Example usage: ```go

type MyDaemon struct {
    gone.Flag
}

func (d *MyDaemon) Start() error {
    // Initialize and start the daemon's main functionality
    // Like starting a web server or opening database connections
    return nil
}

func (d *MyDaemon) Stop() error {
    // Gracefully shut down the daemon and clean up resources
    // Like closing connections and saving state
    return nil
}

```

type DynamicConfigure ¶ added in v2.2.5

type DynamicConfigure interface {
	Configure

	// Notify registers a callback function to be called when the specified key changes
	Notify(key string, callback ConfWatchFunc)
}

DynamicConfigure defines the interface for dynamic configuration providers

type EnvConfigure ¶

type EnvConfigure struct {
	Flag
}

func (s *EnvConfigure) Get(key string, v any, defaultVal string) error

type Error ¶

type Error interface {
	error
	Msg() string
	SetMsg(msg string)
	Code() int

	GetStatusCode() int
}

Error normal error

func NewError(code int, msg string, statusCode int) Error

func NewInnerError(msg string, code int) Error

func NewInnerErrorSkip(msg string, code int, skip int) Error

func NewInnerErrorWithParams(code int, format string, params ...any) Error

func NewParameterError(msg string, ext ...int) Error

func ToError(input any) Error

func ToErrorWithMsg(input any, msg string) Error

type Flag ¶

type Flag struct{}

Flag is a marker struct used to identify components that can be managed by the gone framework. Embedding this struct in another struct indicates that it can be used with gone's dependency injection.

type FuncInjectHook ¶

type FuncInjectHook func(pt reflect.Type, i int, injected bool) any

FuncInjectHook is a function type used for customizing parameter injection in functions. Parameters:

• pt: The type of parameter being injected
• i: The index of the parameter in the function signature
• injected: Whether the parameter has already been injected

Returns any value that should be used as the injected parameter, or nil to continue with default injection

type FuncInjector ¶

type FuncInjector interface {
	// InjectFuncParameters injects dependencies into function parameters by:
	// 1. Using injectBefore hook if provided
	// 2. Using standard dependency injection
	// 3. Creating and filling struct parameters if needed
	// 4. Using injectAfter hook if provided
	// Returns the injected parameter values or error if injection fails
	InjectFuncParameters(fn any, injectBefore FuncInjectHook, injectAfter FuncInjectHook) (args []reflect.Value, err error)

	// InjectWrapFunc wraps a function with dependency injection.
	// It injects dependencies into the function parameters and returns a wrapper function that:
	// 1. Calls the original function with injected parameters
	// 2. Converts return values to []any, handling nil interface values appropriately
	// Returns wrapper function and error if injection fails
	InjectWrapFunc(fn any, injectBefore FuncInjectHook, injectAfter FuncInjectHook) (func() []any, error)
}

FuncInjector provides methods for injecting dependencies into function parameters. Think of it as an "intelligent assistant" that automatically identifies what parameters a function needs, then finds the corresponding components from the "warehouse" and automatically "feeds" them to the function. It's like ordering takeout where the delivery person automatically brings all the dishes according to your order.

The interface requires implementing:

• InjectFuncParameters: Injects dependencies into function parameters
• InjectWrapFunc: Wraps a function with dependency injection

Magic Principles:

• Parameter Recognition: Automatically analyzes function signatures to understand required parameter types
• Smart Matching: Finds matching instances from registered components
• Auto Invocation: Calls the target function with found components as parameters

Parameters for both methods:

• fn: The function to inject dependencies into
• injectBefore: Optional hook called before standard injection
• injectAfter: Optional hook called after standard injection

Typical Applications:

• Controller Methods: Automatic parameter injection for web request handlers
• Utility Functions: Tool function calls requiring multiple dependencies
• Testing Scenarios: Automatic dependency assembly for test functions

Example usage:

injector := &Core{}
fn := func(svc *MyService) error {
    return nil
}

wrapped, err := injector.InjectWrapFunc(fn, nil, nil)
if err != nil {
    panic(err)
}
results := wrapped()

type FunctionProvider ¶

type FunctionProvider[P, T any] func(tagConf string, param P) (T, error)

FunctionProvider is a function, which first parameter is tagConf, and second parameter is a struct that can be injected. And the function must return a T type value and error.

type Goner ¶

type Goner interface {
	// contains filtered or unexported methods
}

Goner is the base interface that all components managed by Gone must implement. It acts as a "component identity card" - any component wanting to be managed by the Gone framework must hold this "identity card". This is a clever design using a private method to ensure only "official channels" can obtain this "identity card".

Any struct that embeds the Flag struct automatically implements this interface. This allows Gone to verify that components are properly configured for dependency injection. Just like getting an ID card requires going to the designated office, becoming a Goner can only be achieved by embedding the `gone.Flag` "official seal".

Design Benefits:

• Security: Prevents "counterfeit" components from entering the system
• Consistency: Ensures all components follow the same "registration" process
• Control: Framework has complete control over component lifecycle

Example usage:

type MyComponent struct {
    gone.Flag  // Embeds Flag to implement Goner - the "identity card"
}

func WarpThirdComponent[T any](t T) Goner

type GonerKeeper ¶

type GonerKeeper interface {
	// GetGonerByName retrieves a component by its name.
	// Like looking up someone's "business card" in a directory, this method finds components
	// by their registered name. The name should match either the component's explicit name
	// set via gone.Name() option or the name returned by its GonerName() method if it implements NamedGoner.
	//
	// Parameters:
	//   - name: The name of the component to retrieve (the "business card" identifier)
	//
	// Returns:
	//   - any: The component instance if found, nil otherwise
	GetGonerByName(name string) any

	// GetGonerByType retrieves a component by its type.
	// Like finding someone by their "profession" in a company directory, this method
	// locates components by their type. The type should match either the exact type
	// of the component or an interface type that the component implements.
	//
	// Parameters:
	//   - t: The reflect.Type of the component to retrieve (the "profession" specification)
	//
	// Returns:
	//   - any: The component instance if found, nil otherwise
	GetGonerByType(t reflect.Type) any

	// GetGonerByPattern retrieves components matching a pattern.
	// Like searching for "all engineers whose names start with 'John'", this method
	// finds multiple components that match both a type and a name pattern.
	//
	// Parameters:
	//   - t: The reflect.Type of components to search for
	//   - pattern: The name pattern to match (supports wildcards like * and ?)
	//
	// Returns:
	//   - []any: Array of component instances that match the criteria
	GetGonerByPattern(t reflect.Type, pattern string) []any
}

GonerKeeper interface defines methods for retrieving components from the Gone container. Think of it as a super-intelligent "archive manager" who knows the "home address" of every component in the system. Whether you want to find someone by "name" or by "profession" (type), it can quickly locate them. It provides dynamic access to components at runtime, allowing components to be looked up by either name or type.

The interface requires implementing:

• GetGonerByName: Retrieves a component by its registered name
• GetGonerByType: Retrieves a component by its type
• GetGonerByPattern: Retrieves components matching a pattern

Practical Scenarios:

• Dynamic Lookup: Find specific components at runtime as needed
• Precise Location: Quickly locate target components by name or type
• Pattern Matching: Use wildcard patterns to batch retrieve components

Example usage: ```go

type MyComponent struct {
    gone.Flag
    keeper gone.GonerKeeper `gone:"*"`
}

func (m *MyComponent) Init() error {
    // Get component by name - like looking up someone's "business card"
    if svc := m.keeper.GetGonerByName("service"); svc != nil {
        // Use the service
    }

    // Get component by type - like finding someone by "profession"
    if logger := m.keeper.GetGonerByType(reflect.TypeOf(&Logger{})); logger != nil {
        // Use the logger
    }
    return nil
}

```

type Initiator ¶

type Initiator interface {
	Init() error
}

Initiator interface defines components that need initialization after dependencies are injected. Components implementing this interface will have their Init() method called during Gone's initialization phase. Init() is called after all dependencies are filled and BeforeInit() hooks (if any) have completed.

The Init() method should: - Perform any required setup or validation - Initialize internal state - Establish connections to external services - Return an error if initialization fails

Example usage:

type MyComponent struct {
    gone.Flag
    db *Database `gone:"*"`
}

func (c *MyComponent) Init() error {
    return c.db.Connect()
}

type InitiatorNoError ¶

type InitiatorNoError interface {
	Init()
}

InitiatorNoError interface defines components that need initialization but don't return errors. Similar to Initiator interface, but Init() does not return an error. Components implementing this interface will have their Init() method called during Gone's initialization phase, after dependencies are filled and BeforeInit() hooks (if any) have completed.

The Init() method should: - Perform any required setup or validation - Initialize internal state - Establish connections to external services - Handle errors internally rather than returning them

Example usage:

type MyComponent struct {
    gone.Flag
    logger *Logger `gone:"*"`
}

func (c *MyComponent) Init() {
    c.logger.Info("Initializing MyComponent")
    // perform initialization...
}

type InnerError ¶

type InnerError interface {
	Error
	Stack() []byte
}

InnerError which has stack, and which is used for Internal error

type Keeper ¶ added in v2.2.3

type Keeper = GonerKeeper

type LoadFunc ¶

type LoadFunc = func(Loader) error

LoadFunc represents a function that can load components into a Gone container. Think of it as a "professional moving company" that knows how to properly "pack" and "relocate" specific types of components into the Gone framework. Each LoadFunc knows how to correctly handle the loading process for particular component types.

LoadFunc Work Flow:

• Package Components: Prepare business components for loading
• Transport and Load: Load components into the framework through Loader
• Confirm Checklist: Return loading results (success or error)

It takes a Loader interface as parameter to allow loading additional dependencies, enabling LoadFuncs to form a tree-like structure for complex component hierarchies.

Example usage: ```go

func loadComponents(l Loader) error {
    if err := l.Load(&ServiceA{}); err != nil {
        return err
    }
    if err := l.Load(&ServiceB{}); err != nil {
        return err
    }
    return nil
}

```

func BuildSingProviderLoadFunc[P, T any](fn FunctionProvider[P, T], options ...Option) LoadFunc

func createService(config string, param struct {
		receiveInjected InjectedRepo `gone:"*"`
	}) (Service, error) {
	// Create and return a service instance using the config and repository
	return &ServiceImpl{repo: param.receiveInjected, config: config}, nil
}

func BuildThirdComponentLoadFunc[T any](component T, options ...Option) LoadFunc

type TestComponent struct {
	i int
}
// Create an existing component instance
var component TestComponent

// Create a loader function that will register the component in the container
loadFunc := BuildThirdComponentLoadFunc(&component)

// Load the component into the container
NewApp().Loads(loadFunc)

func OnceLoad(fn LoadFunc) LoadFunc

func loadComponents(l Loader) error {
    // Load dependencies...
    return nil
}

// Create a function that will only execute once per Loader
wrappedLoad := OnceLoad(loadComponents)

// First call executes loadComponents
wrappedLoad(loader)

// Second call returns nil without executing loadComponents again
wrappedLoad(loader)

type Loader ¶

type Loader interface {
	// Load adds a component to the Gone container with optional configuration.
	//
	// Parameters:
	//   - goner: The component to load. Must implement Goner interface.
	//   - options: Optional configuration for how the component should be loaded.
	//
	// Returns:
	//   - error: Any error that occurred during loading
	Load(goner Goner, options ...Option) error

	MustLoadX(x any) Loader

	// MustLoad adds a component to the Gone container with optional configuration.
	// If an error occurs during loading, it panics.
	//
	// Parameters:
	//   - goner: The component to load. Must implement Goner interface.
	//   - options: Optional configuration for how the component should be loaded.
	//
	// Returns:
	//   - Loader: The Loader instance for further loading operations
	MustLoad(goner Goner, options ...Option) Loader

	// Loaded checks if a component identified by the given LoaderKey has been loaded.
	//
	// Parameters:
	//   - LoaderKey: The unique identifier for the component to check.
	//
	// Returns:
	//   - bool: true if the component is loaded, false otherwise
	Loaded(LoaderKey) bool
}

Loader defines the interface for loading components into the Gone container. Think of it as a company's "HR onboarding specialist" responsible for handling "onboarding procedures" for new components. It assigns each new component a "employee ID", establishes their "personnel file", and officially includes them in the Gone framework's "employee roster".

Onboarding Process:

• Identity Verification: Confirms component implements Goner interface (holds "ID card")
• Assign ID: Allocates unique identifier for the component
• Establish Records: Records component type, dependencies, and other information
• Archive Management: Stores component information in the framework's management system

Usage Scenarios:

• Application Startup: Batch loading of core application components
• Plugin Loading: Dynamic loading of plugin components
• Test Environment: Loading specific mock components for testing

The interface requires implementing:

• Load: Loads a component into the container with optional configuration
• MustLoad: Loads a component and panics on error (for critical components)
• MustLoadX: Flexible loading that handles both components and LoadFuncs
• Loaded: Checks if a component is already loaded

type LoaderKey ¶

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

LoaderKey is a unique identifier for tracking loaded components in the Gone container. Think of it as a "component registration number" that uses an internal counter to ensure each loaded component gets a unique identifier, like a social security number for components.

The LoaderKey is used to: - Track which components have been loaded (like a "registration database") - Prevent duplicate loading of components (avoid "double registration") - Provide a way to check component load status ("registration verification")

This ensures the framework can efficiently manage component lifecycle and prevent conflicts.

func GenLoaderKey() LoaderKey

type Logger ¶

type Logger interface {
	Infof(msg string, args ...any)
	Errorf(msg string, args ...any)
	Warnf(msg string, args ...any)
	Debugf(msg string, args ...any)

	GetLevel() LoggerLevel
	SetLevel(level LoggerLevel)
}

Logger Interface which can be injected and provided by gone framework core

func GetDefaultLogger() Logger

type LoggerLevel ¶

type LoggerLevel int8

const (
	DebugLevel LoggerLevel = -1
	InfoLevel  LoggerLevel = 0
	WarnLevel  LoggerLevel = 1
	ErrorLevel LoggerLevel = 2
)

type MockAfterStarter ¶ added in v2.2.6

type MockAfterStarter struct {
	Flag
	// contains filtered or unexported fields
}

MockAfterStarter is a mock of AfterStarter interface.

func NewMockAfterStarter(ctrl *gomock.Controller) *MockAfterStarter

func (m *MockAfterStarter) AfterStart()

func (m *MockAfterStarter) EXPECT() *MockAfterStarterMockRecorder

type MockAfterStarterMockRecorder ¶ added in v2.2.6

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

MockAfterStarterMockRecorder is the mock recorder for MockAfterStarter.

func (mr *MockAfterStarterMockRecorder) AfterStart() *gomock.Call

type MockAfterStoper ¶ added in v2.2.6

type MockAfterStoper struct {
	Flag
	// contains filtered or unexported fields
}

MockAfterStoper is a mock of AfterStoper interface.

func NewMockAfterStoper(ctrl *gomock.Controller) *MockAfterStoper

func (m *MockAfterStoper) AfterStop()

func (m *MockAfterStoper) EXPECT() *MockAfterStoperMockRecorder

type MockAfterStoperMockRecorder ¶ added in v2.2.6

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

MockAfterStoperMockRecorder is the mock recorder for MockAfterStoper.

func (mr *MockAfterStoperMockRecorder) AfterStop() *gomock.Call

type MockBeforeInitiator ¶ added in v2.2.0

type MockBeforeInitiator struct {
	Flag
	// contains filtered or unexported fields
}

MockBeforeInitiator is a mock of BeforeInitiator interface.

func NewMockBeforeInitiator(ctrl *gomock.Controller) *MockBeforeInitiator

func (m *MockBeforeInitiator) BeforeInit() error

func (m *MockBeforeInitiator) EXPECT() *MockBeforeInitiatorMockRecorder

type MockBeforeInitiatorMockRecorder ¶ added in v2.2.0

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

MockBeforeInitiatorMockRecorder is the mock recorder for MockBeforeInitiator.

func (mr *MockBeforeInitiatorMockRecorder) BeforeInit() *gomock.Call

type MockBeforeInitiatorNoError ¶ added in v2.2.0

type MockBeforeInitiatorNoError struct {
	Flag
	// contains filtered or unexported fields
}

MockBeforeInitiatorNoError is a mock of BeforeInitiatorNoError interface.

func NewMockBeforeInitiatorNoError(ctrl *gomock.Controller) *MockBeforeInitiatorNoError

func (m *MockBeforeInitiatorNoError) BeforeInit()

func (m *MockBeforeInitiatorNoError) EXPECT() *MockBeforeInitiatorNoErrorMockRecorder

type MockBeforeInitiatorNoErrorMockRecorder ¶ added in v2.2.0

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

MockBeforeInitiatorNoErrorMockRecorder is the mock recorder for MockBeforeInitiatorNoError.

func (mr *MockBeforeInitiatorNoErrorMockRecorder) BeforeInit() *gomock.Call

type MockBeforeStarter ¶ added in v2.2.6

type MockBeforeStarter struct {
	Flag
	// contains filtered or unexported fields
}

MockBeforeStarter is a mock of BeforeStarter interface.

func NewMockBeforeStarter(ctrl *gomock.Controller) *MockBeforeStarter

func (m *MockBeforeStarter) BeforeStart()

func (m *MockBeforeStarter) EXPECT() *MockBeforeStarterMockRecorder

type MockBeforeStarterMockRecorder ¶ added in v2.2.6

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

MockBeforeStarterMockRecorder is the mock recorder for MockBeforeStarter.

func (mr *MockBeforeStarterMockRecorder) BeforeStart() *gomock.Call

type MockBeforeStoper ¶ added in v2.2.6

type MockBeforeStoper struct {
	Flag
	// contains filtered or unexported fields
}

MockBeforeStoper is a mock of BeforeStoper interface.

func NewMockBeforeStoper(ctrl *gomock.Controller) *MockBeforeStoper

func (m *MockBeforeStoper) BeforeStop()

func (m *MockBeforeStoper) EXPECT() *MockBeforeStoperMockRecorder

type MockBeforeStoperMockRecorder ¶ added in v2.2.6

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

MockBeforeStoperMockRecorder is the mock recorder for MockBeforeStoper.

func (mr *MockBeforeStoperMockRecorder) BeforeStop() *gomock.Call

type MockConfigure ¶ added in v2.2.1

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

MockConfigure is a mock of Configure interface.

func NewMockConfigure(ctrl *gomock.Controller) *MockConfigure

func (m *MockConfigure) EXPECT() *MockConfigureMockRecorder

func (m *MockConfigure) Get(key string, v any, defaultVal string) error

type MockConfigureMockRecorder ¶ added in v2.2.1

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

MockConfigureMockRecorder is the mock recorder for MockConfigure.

func (mr *MockConfigureMockRecorder) Get(key, v, defaultVal any) *gomock.Call

type MockDaemon ¶ added in v2.2.0

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

MockDaemon is a mock of Daemon interface.

func NewMockDaemon(ctrl *gomock.Controller) *MockDaemon

func (m *MockDaemon) EXPECT() *MockDaemonMockRecorder

func (m *MockDaemon) Start() error

func (m *MockDaemon) Stop() error

type MockDaemonMockRecorder ¶ added in v2.2.0

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

MockDaemonMockRecorder is the mock recorder for MockDaemon.

func (mr *MockDaemonMockRecorder) Start() *gomock.Call

func (mr *MockDaemonMockRecorder) Stop() *gomock.Call

type MockDynamicConfigure ¶ added in v2.2.5

type MockDynamicConfigure struct {
	Flag
	// contains filtered or unexported fields
}

MockDynamicConfigure is a mock of DynamicConfigure interface.

func NewMockDynamicConfigure(ctrl *gomock.Controller) *MockDynamicConfigure

func (m *MockDynamicConfigure) EXPECT() *MockDynamicConfigureMockRecorder

func (m *MockDynamicConfigure) Get(key string, v any, defaultVal string) error

func (m *MockDynamicConfigure) Notify(key string, callback ConfWatchFunc)

type MockDynamicConfigureMockRecorder ¶ added in v2.2.5

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

MockDynamicConfigureMockRecorder is the mock recorder for MockDynamicConfigure.

func (mr *MockDynamicConfigureMockRecorder) Get(key, v, defaultVal any) *gomock.Call

func (mr *MockDynamicConfigureMockRecorder) Notify(key, callback any) *gomock.Call

type MockFuncInjector ¶ added in v2.2.0

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

MockFuncInjector is a mock of FuncInjector interface.

func NewMockFuncInjector(ctrl *gomock.Controller) *MockFuncInjector

func (m *MockFuncInjector) EXPECT() *MockFuncInjectorMockRecorder

func (m *MockFuncInjector) InjectFuncParameters(fn any, injectBefore, injectAfter FuncInjectHook) ([]reflect.Value, error)

func (m *MockFuncInjector) InjectWrapFunc(fn any, injectBefore, injectAfter FuncInjectHook) (func() []any, error)

type MockFuncInjectorMockRecorder ¶ added in v2.2.0

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

MockFuncInjectorMockRecorder is the mock recorder for MockFuncInjector.

func (mr *MockFuncInjectorMockRecorder) InjectFuncParameters(fn, injectBefore, injectAfter any) *gomock.Call

func (mr *MockFuncInjectorMockRecorder) InjectWrapFunc(fn, injectBefore, injectAfter any) *gomock.Call

type MockGoner ¶ added in v2.2.0

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

MockGoner is a mock of Goner interface.

func NewMockGoner(ctrl *gomock.Controller) *MockGoner

func (m *MockGoner) EXPECT() *MockGonerMockRecorder

type MockGonerKeeper ¶ added in v2.2.0

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

MockGonerKeeper is a mock of GonerKeeper interface.

func NewMockGonerKeeper(ctrl *gomock.Controller) *MockGonerKeeper

func (m *MockGonerKeeper) EXPECT() *MockGonerKeeperMockRecorder

func (m *MockGonerKeeper) GetGonerByName(name string) any

func (m *MockGonerKeeper) GetGonerByPattern(t reflect.Type, pattern string) []any

func (m *MockGonerKeeper) GetGonerByType(t reflect.Type) any

type MockGonerKeeperMockRecorder ¶ added in v2.2.0

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

MockGonerKeeperMockRecorder is the mock recorder for MockGonerKeeper.

func (mr *MockGonerKeeperMockRecorder) GetGonerByName(name any) *gomock.Call

func (mr *MockGonerKeeperMockRecorder) GetGonerByPattern(t, pattern any) *gomock.Call

func (mr *MockGonerKeeperMockRecorder) GetGonerByType(t any) *gomock.Call

type MockGonerMockRecorder ¶ added in v2.2.0

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

MockGonerMockRecorder is the mock recorder for MockGoner.

type MockInitiator ¶ added in v2.2.0

type MockInitiator struct {
	Flag
	// contains filtered or unexported fields
}

MockInitiator is a mock of Initiator interface.

func NewMockInitiator(ctrl *gomock.Controller) *MockInitiator

func (m *MockInitiator) EXPECT() *MockInitiatorMockRecorder

func (m *MockInitiator) Init() error

type MockInitiatorMockRecorder ¶ added in v2.2.0

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

MockInitiatorMockRecorder is the mock recorder for MockInitiator.

func (mr *MockInitiatorMockRecorder) Init() *gomock.Call

type MockInitiatorNoError ¶ added in v2.2.0

type MockInitiatorNoError struct {
	Flag
	// contains filtered or unexported fields
}

MockInitiatorNoError is a mock of InitiatorNoError interface.

func NewMockInitiatorNoError(ctrl *gomock.Controller) *MockInitiatorNoError

func (m *MockInitiatorNoError) EXPECT() *MockInitiatorNoErrorMockRecorder

func (m *MockInitiatorNoError) Init()

type MockInitiatorNoErrorMockRecorder ¶ added in v2.2.0

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

MockInitiatorNoErrorMockRecorder is the mock recorder for MockInitiatorNoError.

func (mr *MockInitiatorNoErrorMockRecorder) Init() *gomock.Call

type MockLoader ¶ added in v2.2.0

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

MockLoader is a mock of Loader interface.

func NewMockLoader(ctrl *gomock.Controller) *MockLoader

func (m *MockLoader) EXPECT() *MockLoaderMockRecorder

func (m *MockLoader) Load(goner Goner, options ...Option) error

func (m *MockLoader) Loaded(arg0 LoaderKey) bool

func (m *MockLoader) MustLoad(goner Goner, options ...Option) Loader

func (m *MockLoader) MustLoadX(x any) Loader

type MockLoaderMockRecorder ¶ added in v2.2.0

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

MockLoaderMockRecorder is the mock recorder for MockLoader.

func (mr *MockLoaderMockRecorder) Load(goner any, options ...any) *gomock.Call

func (mr *MockLoaderMockRecorder) Loaded(arg0 any) *gomock.Call

func (mr *MockLoaderMockRecorder) MustLoad(goner any, options ...any) *gomock.Call

func (mr *MockLoaderMockRecorder) MustLoadX(x any) *gomock.Call

type MockLogger ¶ added in v2.2.0

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

MockLogger is a mock of Logger interface.

func NewMockLogger(ctrl *gomock.Controller) *MockLogger

func (m *MockLogger) Debugf(msg string, args ...any)

func (m *MockLogger) EXPECT() *MockLoggerMockRecorder

func (m *MockLogger) Errorf(msg string, args ...any)

func (m *MockLogger) GetLevel() LoggerLevel

func (m *MockLogger) Infof(msg string, args ...any)

func (m *MockLogger) SetLevel(level LoggerLevel)

func (m *MockLogger) Warnf(msg string, args ...any)

type MockLoggerMockRecorder ¶ added in v2.2.0

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

MockLoggerMockRecorder is the mock recorder for MockLogger.

func (mr *MockLoggerMockRecorder) Debugf(msg any, args ...any) *gomock.Call

func (mr *MockLoggerMockRecorder) Errorf(msg any, args ...any) *gomock.Call

func (mr *MockLoggerMockRecorder) GetLevel() *gomock.Call

func (mr *MockLoggerMockRecorder) Infof(msg any, args ...any) *gomock.Call

func (mr *MockLoggerMockRecorder) SetLevel(level any) *gomock.Call

func (mr *MockLoggerMockRecorder) Warnf(msg any, args ...any) *gomock.Call

type MockNamedGoner ¶ added in v2.2.0

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

MockNamedGoner is a mock of NamedGoner interface.

func NewMockNamedGoner(ctrl *gomock.Controller) *MockNamedGoner

func (m *MockNamedGoner) EXPECT() *MockNamedGonerMockRecorder

func (m *MockNamedGoner) GonerName() string

type MockNamedGonerMockRecorder ¶ added in v2.2.0

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

MockNamedGonerMockRecorder is the mock recorder for MockNamedGoner.

func (mr *MockNamedGonerMockRecorder) GonerName() *gomock.Call

type MockNamedProvider ¶ added in v2.2.0

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

MockNamedProvider is a mock of NamedProvider interface.

func NewMockNamedProvider(ctrl *gomock.Controller) *MockNamedProvider

func (m *MockNamedProvider) EXPECT() *MockNamedProviderMockRecorder

func (m *MockNamedProvider) GonerName() string

func (m *MockNamedProvider) Provide(tagConf string, t reflect.Type) (any, error)

type MockNamedProviderMockRecorder ¶ added in v2.2.0

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

MockNamedProviderMockRecorder is the mock recorder for MockNamedProvider.

func (mr *MockNamedProviderMockRecorder) GonerName() *gomock.Call

func (mr *MockNamedProviderMockRecorder) Provide(tagConf, t any) *gomock.Call

type MockNoneParamProvider ¶ added in v2.2.0

type MockNoneParamProvider[T any] struct {
	// contains filtered or unexported fields
}

MockNoneParamProvider is a mock of NoneParamProvider interface.

func NewMockNoneParamProvider[T any](ctrl *gomock.Controller) *MockNoneParamProvider[T]

func (m *MockNoneParamProvider[T]) EXPECT() *MockNoneParamProviderMockRecorder[T]

func (m *MockNoneParamProvider[T]) Provide() (T, error)

type MockNoneParamProviderMockRecorder ¶ added in v2.2.0

type MockNoneParamProviderMockRecorder[T any] struct {
	// contains filtered or unexported fields
}

MockNoneParamProviderMockRecorder is the mock recorder for MockNoneParamProvider.

func (mr *MockNoneParamProviderMockRecorder[T]) Provide() *gomock.Call

type MockProvider ¶ added in v2.2.0

type MockProvider[T any] struct {
	// contains filtered or unexported fields
}

MockProvider is a mock of Provider interface.

func NewMockProvider[T any](ctrl *gomock.Controller) *MockProvider[T]

func (m *MockProvider[T]) EXPECT() *MockProviderMockRecorder[T]

func (m *MockProvider[T]) Provide(tagConf string) (T, error)

type MockProviderMockRecorder ¶ added in v2.2.0

type MockProviderMockRecorder[T any] struct {
	// contains filtered or unexported fields
}

MockProviderMockRecorder is the mock recorder for MockProvider.

func (mr *MockProviderMockRecorder[T]) Provide(tagConf any) *gomock.Call

type MockStructFieldInjector ¶ added in v2.2.0

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

MockStructFieldInjector is a mock of StructFieldInjector interface.

func NewMockStructFieldInjector(ctrl *gomock.Controller) *MockStructFieldInjector

func (m *MockStructFieldInjector) EXPECT() *MockStructFieldInjectorMockRecorder

func (m *MockStructFieldInjector) GonerName() string

func (m *MockStructFieldInjector) Inject(tagConf string, field reflect.StructField, fieldValue reflect.Value) error

type MockStructFieldInjectorMockRecorder ¶ added in v2.2.0

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

MockStructFieldInjectorMockRecorder is the mock recorder for MockStructFieldInjector.

func (mr *MockStructFieldInjectorMockRecorder) GonerName() *gomock.Call

func (mr *MockStructFieldInjectorMockRecorder) Inject(tagConf, field, fieldValue any) *gomock.Call

type MockStructInjector ¶ added in v2.2.0

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

MockStructInjector is a mock of StructInjector interface.

func NewMockStructInjector(ctrl *gomock.Controller) *MockStructInjector

func (m *MockStructInjector) EXPECT() *MockStructInjectorMockRecorder

func (m *MockStructInjector) InjectStruct(goner any) error

type MockStructInjectorMockRecorder ¶ added in v2.2.0

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

MockStructInjectorMockRecorder is the mock recorder for MockStructInjector.

func (mr *MockStructInjectorMockRecorder) InjectStruct(goner any) *gomock.Call

type MockiDependenceAnalyzer ¶ added in v2.2.0

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

MockiDependenceAnalyzer is a mock of iDependenceAnalyzer interface.

func NewMockiDependenceAnalyzer(ctrl *gomock.Controller) *MockiDependenceAnalyzer

func (m *MockiDependenceAnalyzer) EXPECT() *MockiDependenceAnalyzerMockRecorder

type MockiDependenceAnalyzerMockRecorder ¶ added in v2.2.0

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

MockiDependenceAnalyzerMockRecorder is the mock recorder for MockiDependenceAnalyzer.

type MockiInstaller ¶ added in v2.2.0

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

MockiInstaller is a mock of iInstaller interface.

func NewMockiInstaller(ctrl *gomock.Controller) *MockiInstaller

func (m *MockiInstaller) EXPECT() *MockiInstallerMockRecorder

type MockiInstallerMockRecorder ¶ added in v2.2.0

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

MockiInstallerMockRecorder is the mock recorder for MockiInstaller.

type MockiKeeper ¶ added in v2.2.0

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

MockiKeeper is a mock of iKeeper interface.

func NewMockiKeeper(ctrl *gomock.Controller) *MockiKeeper

func (m *MockiKeeper) EXPECT() *MockiKeeperMockRecorder

type MockiKeeperMockRecorder ¶ added in v2.2.0

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

MockiKeeperMockRecorder is the mock recorder for MockiKeeper.

type MustLoadFunc ¶ added in v2.1.0

type MustLoadFunc = func(Loader)

type NamedGoner ¶

type NamedGoner interface {
	Goner
	GonerName() string
}

NamedGoner extends the Goner interface to add naming capability to components. Components implementing this interface can be registered and looked up by name in the Gone container, like having a "business card" with a specific name that others can use to find them.

The GonerName() method should return a unique string identifier for the component. This name acts as the component's "business card" and can be used when: - Loading the component with explicit name - Looking up dependencies by name using `gone:"name"` tags - Registering multiple implementations of the same interface - Distinguishing between different instances of the same type

Example usage:

type MyNamedComponent struct {
    gone.Flag
}

func (c *MyNamedComponent) GonerName() string {
    return "myComponent"  // This component's "business card"
}

type NamedProvider ¶

type NamedProvider interface {
	NamedGoner
	Provide(tagConf string, t reflect.Type) (any, error)
}

NamedProvider is an interface for providers that can create dependencies based on name and type. Think of it as a "master craftsman" with a business card who can create any type of component based on specific requirements. It extends NamedGoner to support named component registration and provides a more flexible Provide method that can create dependencies of any type.

The interface requires:

• Embedding the NamedGoner interface to support named component registration
• Implementing Provide() to create dependencies based on tag config and requested type

This provider acts like a "versatile craftsman" who can adapt their skills to create different types of components based on the specific type requested and configuration provided.

Parameters for Provide:

• tagConf: Configuration string from the struct tag that requested this dependency, like a "detailed work order" specifying requirements
• t: The `reflect.Type` of the dependency being requested, like a "blueprint" showing what type of component to create

Returns:

• any: The created dependency instance of the requested type
• error: Any error that occurred during creation

Example usage:

type ConfigProvider struct {
    gone.Flag
}

func (p *ConfigProvider) Provide(tagConf string, t reflect.Type) (any, error) {
    // Create and return instance based on the type blueprint
    return &Config{}, nil
}

type NoneParamProvider ¶

type NoneParamProvider[T any] interface {
	Goner
	Provide() (T, error)
}

NoneParamProvider is a simplified Provider interface for components that provide dependencies without requiring tag configuration. Think of it as a "simple factory" that creates standard products without needing special instructions. Like Provider[T], this interface is not directly dependent on Gone's implementation but serves as a guide for writing simpler providers when tag configuration is not needed.

Type Parameters:

• T: The type of dependency this provider creates

The interface requires:

• Embedding the Goner interface to mark it as a Gone component
• Implementing Provide() to create and return instances of type T

This provider acts like a "standard craftsman" who creates the same type of component every time without needing special instructions or customization.

Returns:

• T: The created dependency instance
• error: Any error that occurred during creation

Example usage:

type BeforeStartProvider struct {
    gone.Flag
    preparer *Application
}

func (p *BeforeStartProvider) Provide() (BeforeStart, error) {
    return p.preparer.beforeStart, nil
}

type Option ¶

type Option interface {
	Apply(c *coffin) error
}

Option is an interface for configuring Goners loaded into the gone framework.

func ForceReplace() Option

gone.Load(&MyService{}, gone.GonerName("service"), gone.ForceReplace())
// This will replace any existing Goner named "service"

func HighStartPriority() Option

func IsDefault(objPointers ...any) Option

gone.Load(&EnvConfigure{}, gone.IsDefault())

func LazyFill() Option

gone.Load(&MyService{}, gone.GonerName("service"), gone.LazyFill())

func LowStartPriority() Option

func MediumStartPriority() Option

func Name(name string) Option

gone.Load(&EnvConfigure{}, gone.GonerName("configure"))

func OnlyForName() Option

gone.Load(&EnvConfigure{}, gone.GonerName("configure"), gone.OnlyForName())
// Now EnvConfigure can only be injected using `gone:"configure"` tag
// And not through interface type matching

func Order(order int) Option

gone.Load(&Database{}, gone.Order(1))  // started first
gone.Load(&Service{}, gone.Order(2))   // started second

type Preparer ¶

type Preparer = Application

Preparer is a type alias for Application, representing the main entry point for application setup and execution.

type Process ¶

type Process func()

Process represents a function that performs some operation without taking parameters or returning values. It is commonly used for Hook functions in the application lifecycle, such as BeforeStart, AfterStart, BeforeStop and AfterStop Hook.

Example usage: ```go

type XGoner struct {
    Flag
    beforeStart BeforeStart `gone:"*"`
}

func (x *XGoner) Init() error {
    x.beforeStart(func() {
        // This is a Process function
        fmt.Println("Before application starts")
    })
    return nil
}

```

type Provider ¶

type Provider[T any] interface {
	Goner
	Provide(tagConf string) (T, error)
}

Provider is a generic interface for components that can provide dependencies of type T. Think of it as a "smart factory" that can create specific types of components on demand. While not directly dependent on Gone's implementation, this interface helps developers write correct dependency providers that can be registered in the Gone container.

Type Parameters:

• T: The type of dependency this provider creates

The interface requires:

• Embedding the Goner interface to mark it as a Gone component
• Implementing Provide() to create and return instances of type T

The Provider acts like a "specialized craftsman" who knows how to create specific types of components based on the requirements (tagConf) provided.

Parameters for Provide:

• tagConf: Configuration string from the struct tag that requested this dependency, like a "work order" specifying what kind of component is needed

Returns:

• T: The created dependency instance
• error: Any error that occurred during creation

Example usage:

type ConfigProvider struct {
    gone.Flag
}

func (p *ConfigProvider) Provide(tagConf string) (*Config, error) {
    return &Config{}, nil  // Creates a new Config based on requirements
}

type RunOption ¶ added in v2.2.6

type RunOption interface {
	Apply(*Application)
}

func OpWaitEnd() RunOption

type StructFieldInjector ¶

type StructFieldInjector interface {
	NamedGoner
	Inject(tagConf string, field reflect.StructField, fieldValue reflect.Value) error
}

StructFieldInjector is an interface for components that can inject dependencies into struct fields. Think of it as a "specialized installer" who knows how to install specific components into struct fields based on installation instructions. It extends NamedGoner to support named component registration and provides a method to inject dependencies into struct fields based on tag configuration and field information.

The interface requires:

• Embedding the NamedGoner interface to support named component registration
• Implementing Inject() to inject dependencies into struct fields

This injector acts like a "field specialist" who can precisely install components into specific struct fields based on the field's requirements and configuration.

Parameters for Inject:

• tagConf: Configuration string from the struct tag that requested this dependency, like "installation instructions" specifying how to inject
• field: The `reflect.StructField` that requires injection, like the "installation location" specification
• fieldValue: The actual field value to be modified during injection

Returns:

• error: Any error that occurred during injection

type StructInjector ¶

type StructInjector interface {
	// InjectStruct performs dependency injection on the provided Goner struct.
	// It scans the struct's fields for `gone` tags and injects the appropriate dependencies.
	//
	// Parameters:
	//   - goner: Should be a struct pointer.
	//
	// Returns:
	//   - error: Any error that occurred during injection
	InjectStruct(goner any) error
}

StructInjector defines the interface for components that can inject dependencies into struct fields. Think of it as an experienced "assembly worker" who can automatically identify which fields in a struct need "component installation", then find suitable components from the "parts warehouse" and precisely "install" them in the specified locations. It's like assembling a computer where the worker automatically installs corresponding hardware based on the motherboard's interfaces.

The interface requires implementing:

• InjectStruct: Injects dependencies into struct fields based on gone tags

Work Flow:

• Field Scanning: Checks struct fields with specific tags
• Component Matching: Finds corresponding components based on field types and tag information
• Precise Installation: "Installs" found components into corresponding fields

Application Scenarios:

• Component Initialization: Automatically assembles dependencies after component creation
• Test Preparation: Automatically injects mock dependencies for test objects
• Dynamic Assembly: Supplements dependencies for existing objects at runtime

Example usage: ```go

type MyGoner struct {
    gone.Flag
    Service *MyService `gone:"*"`  // Field to be injected
}

injector := &Core{}
goner := &MyGoner{}
err := injector.InjectStruct(goner)
if err != nil {
    panic(err)
}
// MyGoner.Service is now injected

```

The InjectStruct method analyzes the struct's fields, looking for `gone` tags, and injects the appropriate dependencies based on the tag configuration.

type TestFlag ¶

type TestFlag interface {
	// contains filtered or unexported methods
}

type XProvider ¶

type XProvider[T any] struct {
	Flag
	// contains filtered or unexported fields
}

XProvider is a Goner Provider was created by WrapFunctionProvider.

func WrapFunctionProvider[P, T any](fn FunctionProvider[P, T]) *XProvider[T]

func (p *XProvider[T]) Provide(tagConf string) (T, error)