gone

type AfterStart ¶

type AfterStart func(Process)

AfterStart is a hook 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 hook
}

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 AfterStop ¶

type AfterStop func(Process)

AfterStop is a hook 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 hook
}

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 Application ¶

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

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(fn ...any)

func (s *Application) Serve()

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 hook 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 hook
}

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 BeforeStop ¶

type BeforeStop func(Process)

BeforeStop is a hook 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 hook
}

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 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 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.

Example usage: ```go

type MyDaemon struct {
    Flag
}

func (d *MyDaemon) Start() error {
    // Initialize and start the daemon
    return nil
}

func (d *MyDaemon) Stop() error {
    // Clean up and stop the daemon
    return nil
}

```

Daemons are started in order of registration when Application.Serve() or Application.start() is called. The Start() method should initialize and start the daemon's main functionality. If Start() returns an error, the application will panic.

When the application receives a termination signal, daemons are stopped in reverse order by calling their Stop() methods. The Stop() method should gracefully shut down the daemon and clean up any resources. If Stop() returns an error, the application will panic.

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.

The interface requires implementing:

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

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

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 an experimental type that may change or be removed in future releases.

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 marker interface to identify types that can be loaded into the Gone container.

Any struct that embeds the Flag struct automatically implements this interface. This allows Gone to verify that components are properly configured for dependency injection.

Example usage:

type MyComponent struct {
    gone.Flag  // Embeds Flag to implement Goner
}

type GonerKeeper ¶

type GonerKeeper interface {
	// GetGonerByName retrieves a component by its 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
	//
	// Returns:
	//   - any: The component instance if found, nil otherwise
	GetGonerByName(name string) any

	// GetGonerByType retrieves a component by its 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
	//
	// Returns:
	//   - any: The component instance if found, nil otherwise
	GetGonerByType(t reflect.Type) any
}

GonerKeeper interface defines methods for retrieving components from the Gone container. 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

Example usage: ```go

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

func (m *MyComponent) Init() error {
    // Get component by name
    if svc := m.keeper.GetGonerByName("service"); svc != nil {
        // Use the service
    }

    // Get component by type
    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 LoadFunc ¶

type LoadFunc = func(Loader) error

LoadFunc represents a function that can load components into a Gone container. It takes a Loader interface as parameter to allow loading additional dependencies.

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. It provides methods to load new components and check if components are already loaded.

The interface requires implementing:

• Load: Loads a component into the container with optional configuration
• 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. It uses an internal counter to ensure each loaded component gets a unique key.

The LoaderKey is used to: - Track which components have been loaded - Prevent duplicate loading of components - Provide a way to check component load status

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)
}

func GetDefaultLogger() Logger

type LoggerLevel ¶

type LoggerLevel int8

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

type MockBeforeInitiator ¶ added in v2.2.0

type MockBeforeInitiator struct {
	// 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 {
	// 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 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 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) 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) 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 {
	// 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 {
	// 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.

The Name() method should return a unique string identifier for the component. This name 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

Example usage:

type MyNamedComponent struct {
    gone.Flag
}

func (c *MyNamedComponent) GonerName() string {
    return "myComponent"
}

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. 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

Parameters for Provide:

• tagConf: Configuration string from the struct tag that requested this dependency
• t: The `reflect.Type` of the dependency being requested

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 t
    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. 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

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 hooks.

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. 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

Parameters for Provide:

• tagConf: Configuration string from the struct tag that requested this dependency

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
}

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. 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

Parameters for Inject:

• tagConf: Configuration string from the struct tag that requested this dependency
• field: The `reflect.StructField` that requires 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: The struct instance to inject dependencies into. Must implement Goner interface.
	//
	// 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. It provides a single method to perform dependency injection on struct instances that implement the Goner interface.

The interface requires implementing:

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

Example usage: ```go

type MyGoner struct {
    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 an experimental type that may change or be removed in future releases.

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

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