types

Documentation

Index

• Constants
• Variables
• func NewDependencyError(msg string) error
• func NewReflectionError(msg string, initializers ...ParsleyErrorFunc) error
• func NewRegistryError(msg string, initializers ...ParsleyErrorFunc) error
• func NewResolverError(msg string, initializers ...ParsleyErrorFunc) error
• type DependencyError
• type DependencyInfo
• type FunctionInfo
• type FunctionParameterInfo
• type LifetimeScope
• type ModuleFunc
• type NamedService
• type ParsleyAggregateError
  • func (f ParsleyAggregateError) Error() string
  • func (f ParsleyAggregateError) Is(err error) bool
• type ParsleyError
  • func (f ParsleyError) Error() string
  • func (f ParsleyError) Is(err error) bool
  • func (f ParsleyError) Unwrap() error
• type ParsleyErrorFunc
  • func ForServiceType(serviceType string) ParsleyErrorFunc
  • func WithAggregatedCause(errs ...error) ParsleyErrorFunc
  • func WithCause(err error) ParsleyErrorFunc
• type ParsleyErrorWithServiceTypeName
• type RegistrationConfigurationFunc
• type Resolver
• type ResolverError
  • func (r *ResolverError) ServiceTypeName(name string)
• type ResolverOptionsFunc
• type ServiceRegistration
• type ServiceRegistrationList
• type ServiceRegistrationSetup
• type ServiceRegistry
• type ServiceRegistryAccessor
• type ServiceType
  • func MakeServiceType[T any]() ServiceType
  • func ServiceTypeFrom(t reflect.Type) ServiceType

Constants

const (
	ErrorRequiresFunctionValue               = "the given value is not function"
	ErrorCannotRegisterModule                = "failed to register module"
	ErrorTypeAlreadyRegistered               = "type already registered"
	ErrorServiceAlreadyLinkedWithAnotherList = "service already linked with another list"
)

const (
	ErrorServiceTypeNotRegistered              = "service type is not registered"
	ErrorRequiredServiceNotRegistered          = "required service type is not registered"
	ErrorCannotResolveService                  = "cannot resolve service"
	ErrorAmbiguousServiceInstancesResolved     = "the resolve operation resulted in multiple service instances"
	ErrorActivatorFunctionInvalidReturnType    = "activator function has an invalid return type"
	ErrorCircularDependencyDetected            = "circular dependency detected"
	ErrorCannotBuildDependencyGraph            = "failed to build dependency graph"
	ErrorInstanceCannotBeNil                   = "instance cannot be nil"
	ErrorServiceTypeMustBeInterface            = "service type must be an interface"
	ErrorCannotRegisterTypeWithResolverOptions = "cannot register type with resolver options"
)

const (
	ErrorInstanceAlreadySet = "instance already set"
)

Variables

var (
	ErrRequiresFunctionValue = errors.New(ErrorRequiresFunctionValue)
	ErrCannotRegisterModule  = errors.New(ErrorCannotRegisterModule)
	ErrTypeAlreadyRegistered = errors.New(ErrorTypeAlreadyRegistered)
)

var (
	ErrServiceTypeNotRegistered              = errors.New(ErrorServiceTypeNotRegistered)
	ErrActivatorFunctionInvalidReturnType    = errors.New(ErrorCannotResolveService)
	ErrCannotBuildDependencyGraph            = errors.New(ErrorCannotBuildDependencyGraph)
	ErrCircularDependencyDetected            = errors.New(ErrorCircularDependencyDetected)
	ErrInstanceCannotBeNil                   = errors.New(ErrorInstanceCannotBeNil)
	ErrServiceTypeMustBeInterface            = errors.New(ErrorServiceTypeMustBeInterface)
	ErrCannotRegisterTypeWithResolverOptions = errors.New(ErrorCannotRegisterTypeWithResolverOptions)
)

var (
	ErrInstanceAlreadySet = errors.New(ErrorInstanceAlreadySet)
)

Functions

func NewDependencyError

func NewDependencyError(msg string) error

func NewReflectionError

func NewReflectionError(msg string, initializers ...ParsleyErrorFunc) error

func NewRegistryError

func NewRegistryError(msg string, initializers ...ParsleyErrorFunc) error

func NewResolverError

func NewResolverError(msg string, initializers ...ParsleyErrorFunc) error

Types

type DependencyError

type DependencyError struct {
	ParsleyError
}

type DependencyInfo

type DependencyInfo interface {
	AddRequiredServiceInfo(child DependencyInfo)
	CreateInstance() (interface{}, error)
	Consumer() DependencyInfo
	HasInstance() bool
	Instance() interface{}
	Registration() ServiceRegistration
	RequiredServiceTypes() []ServiceType
	RequiredServices() ([]interface{}, error)
	ServiceTypeName() string
	SetInstance(instance interface{}) error
}

type FunctionInfo

type FunctionInfo interface {
	fmt.Stringer
	Name() string
	Parameters() []FunctionParameterInfo
	ReturnType() ServiceType
	ParameterTypes() []ServiceType
}

type FunctionParameterInfo

type FunctionParameterInfo interface {
	fmt.Stringer
	Type() ServiceType
}

type LifetimeScope

type LifetimeScope uint

const (
	LifetimeTransient LifetimeScope = iota
	LifetimeScoped
	LifetimeSingleton
)

type ModuleFunc

type ModuleFunc func(registry ServiceRegistry) error

type NamedService

type NamedService[T any] interface {
	Name() string
	ActivatorFunc() any
}

type ParsleyAggregateError

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

func (ParsleyAggregateError) Error

func (f ParsleyAggregateError) Error() string

func (ParsleyAggregateError) Is

func (f ParsleyAggregateError) Is(err error) bool

type ParsleyError

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

func (ParsleyError) Error

func (f ParsleyError) Error() string

func (ParsleyError) Is

func (f ParsleyError) Is(err error) bool

func (ParsleyError) Unwrap

func (f ParsleyError) Unwrap() error

type ParsleyErrorFunc

type ParsleyErrorFunc func(e error)

func ForServiceType

func ForServiceType(serviceType string) ParsleyErrorFunc

func WithAggregatedCause

func WithAggregatedCause(errs ...error) ParsleyErrorFunc

func WithCause

func WithCause(err error) ParsleyErrorFunc

type ParsleyErrorWithServiceTypeName

type ParsleyErrorWithServiceTypeName interface {
	ServiceTypeName(name string)
}

type RegistrationConfigurationFunc

type RegistrationConfigurationFunc func(r ServiceRegistration)

type Resolver

type Resolver interface {
	Resolve(ctx context.Context, serviceType ServiceType) ([]interface{}, error)
	ResolveWithOptions(ctx context.Context, serviceType ServiceType, options ...ResolverOptionsFunc) ([]interface{}, error)
}

type ResolverError

type ResolverError struct {
	ParsleyError
	// contains filtered or unexported fields
}

func (*ResolverError) ServiceTypeName

func (r *ResolverError) ServiceTypeName(name string)

type ResolverOptionsFunc

type ResolverOptionsFunc func(registry ServiceRegistry) error

type ServiceRegistration

type ServiceRegistration interface {
	Id() uint64
	InvokeActivator(params ...interface{}) (interface{}, error)
	IsSame(other ServiceRegistration) bool
	LifetimeScope() LifetimeScope
	RequiredServiceTypes() []ServiceType
	ServiceType() ServiceType
}

type ServiceRegistrationList

type ServiceRegistrationList interface {
	AddRegistration(registration ServiceRegistrationSetup) error
	Id() uint64
	Registrations() []ServiceRegistration
	IsEmpty() bool
}

type ServiceRegistrationSetup

type ServiceRegistrationSetup interface {
	ServiceRegistration
	SetId(id uint64) error
}

type ServiceRegistry

type ServiceRegistry interface {
	ServiceRegistryAccessor
	CreateLinkedRegistry() ServiceRegistry
	CreateScope() ServiceRegistry
	IsRegistered(serviceType ServiceType) bool
	Register(activatorFunc any, scope LifetimeScope) error
	RegisterModule(modules ...ModuleFunc) error
}

type ServiceRegistryAccessor

type ServiceRegistryAccessor interface {
	TryGetServiceRegistrations(serviceType ServiceType) (ServiceRegistrationList, bool)
	TryGetSingleServiceRegistration(serviceType ServiceType) (ServiceRegistration, bool)
}

type ServiceType

type ServiceType interface {
	Name() string
	ReflectedType() reflect.Type
}

func MakeServiceType

func MakeServiceType[T any]() ServiceType

func ServiceTypeFrom

func ServiceTypeFrom(t reflect.Type) ServiceType