autowire

type Autowire interface {
	TagKey() string
	// IsSingleton means the struct of this autowire type can only have one object globally, which is only created once.
	IsSingleton() bool
	/*
		CanBeEntrance means the struct is loaded at the start of application.
		By default, only rpc-server can be entrance.
	*/
	CanBeEntrance() bool
	/*
		Factory is contruct function of struct of this autowire type
	*/
	Factory(sdID string) (interface{}, error)

	/*
		ParseSDID parse FieldInfo to struct descriptorId

		if field type is struct ptr like
		MyStruct *MyStruct `autowire-type:"MyStruct"`
		FieldInfo would be
		FieldInfo.FieldName == "MyStruct"
		FieldInfo.FieldType == "" // ATTENTION!!!
		FieldInfo.TagKey == "autowire-type"
		FieldInfo.TagValue == "MyStruct"
		You should make sure tag value contains ptr type if you use it.

		if field type is interface like
		MyStruct MyInterface ` `autowire-type:"MyStruct"`
		FieldInfo would be
		FieldInfo.FieldName == "MyStruct"
		FieldInfo.FieldType == "MyInterface"
		FieldInfo.TagKey == "autowire-type"
		FieldInfo.TagValue == "MyStruct"
	*/
	ParseSDID(field *FieldInfo) (string, error)
	ParseParam(sdID string, fi *FieldInfo) (interface{}, error)
	Construct(sdID string, impledPtr, param interface{}) (interface{}, error)
	GetAllStructDescriptors() map[string]*StructDescriptor
	InjectPosition() InjectPosition
}

type AutowireMetadata map[string]interface{}

type FieldInfo struct {
	FieldName         string
	FieldType         string
	TagKey            string
	TagValue          string
	FieldReflectType  reflect.Type
	FieldReflectValue reflect.Value
}

type InjectPosition int

type Metadata map[string]interface{}

type MockAutowire struct {
	mock.Mock
}

type ParamLoader interface {
	Load(sd *StructDescriptor, fi *FieldInfo) (interface{}, error)
}

type SDIDParser interface {
	Parse(fi *FieldInfo) (string, error)
}

type SingletonCache struct {
	RawPtr   interface{}
	ProxyPtr interface{}
}

type StructDescriptor struct {
	SDID          string
	Factory       func() interface{} // raw struct
	ParamFactory  func() interface{}
	ParamLoader   ParamLoader
	ConstructFunc func(impl interface{}, param interface{}) (interface{}, error) // injected
	DestroyFunc   func(impl interface{})
	Alias         string // alias of SDID
	DisableProxy  bool   // disable proxy and aop
	Metadata      Metadata
	// contains filtered or unexported fields
}

type WrapperAutowire interface {
	Autowire

	ImplWithoutParam(sdID string, withProxy, force bool) (interface{}, error)
	ImplWithParam(sdID string, param interface{}, withProxy, force bool) (interface{}, error)
	// contains filtered or unexported methods
}

type WrapperAutowireImpl struct {
	Autowire
	// contains filtered or unexported fields
}