Documentation

Overview

    Package factory provides hiboot factory interface

    Package factory provides InstantiateFactory and ConfigurableFactory interface

    Index

    Constants

    View Source
    const (
    	// InstantiateFactoryName is the instance name of factory.instantiateFactory
    	InstantiateFactoryName = "factory.instantiateFactory"
    	// ConfigurableFactoryName is the instance name of factory.configurableFactory
    	ConfigurableFactoryName = "factory.configurableFactory"
    )

    Variables

    This section is empty.

    Functions

    func GetObjectQualifierName

    func GetObjectQualifierName(object interface{}, name string) string

      GetObjectQualifierName get the qualifier's name of object

      func ParseParams

      func ParseParams(params ...interface{}) (name string, object interface{})

        ParseParams parse parameters

        Types

        type ConfigurableFactory

        type ConfigurableFactory interface {
        	InstantiateFactory
        	SystemConfiguration() *system.Configuration
        	Configuration(name string) interface{}
        	BuildProperties() (systemConfig *system.Configuration, err error)
        	Build(configs []*MetaData)
        }

          ConfigurableFactory configurable factory interface

          type Configuration

          type Configuration interface {
          }

            Configuration configuration interface

            type Deps

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

              Deps the dependency mapping of configuration

              func (*Deps) Get

              func (c *Deps) Get(name string) (deps []string)

                Get get the dependencies mapping

                func (*Deps) Set

                func (c *Deps) Set(dep interface{}, value []string)

                  Set set dependencies

                  type Factory

                  type Factory interface{}

                    Factory interface

                    type Instance

                    type Instance interface {
                    	Get(params ...interface{}) (retVal interface{})
                    	Set(params ...interface{}) (err error)
                    	Items() map[string]interface{}
                    }

                    type InstantiateFactory

                    type InstantiateFactory interface {
                    	Initialized() bool
                    	SetInstance(params ...interface{}) (err error)
                    	GetInstance(params ...interface{}) (retVal interface{})
                    	GetInstances(params ...interface{}) (retVal []*MetaData)
                    	Items() map[string]interface{}
                    	Append(i ...interface{})
                    	AppendComponent(c ...interface{})
                    	BuildComponents() (err error)
                    	Builder() (builder system.Builder)
                    	GetProperty(name string) interface{}
                    	SetProperty(name string, value interface{}) InstantiateFactory
                    	SetDefaultProperty(name string, value interface{}) InstantiateFactory
                    	DefaultProperties() map[string]interface{}
                    	InjectIntoFunc(object interface{}) (retVal interface{}, err error)
                    	InjectIntoMethod(owner, object interface{}) (retVal interface{}, err error)
                    	InjectDefaultValue(object interface{}) error
                    	InjectIntoObject(object interface{}) error
                    	InjectDependency(object interface{}) (err error)
                    	Replace(name string) interface{}
                    	InjectContextAwareObjects(ctx context.Context, dps []*MetaData) (runtimeInstance Instance, err error)
                    }

                      InstantiateFactory instantiate factory interface

                      type MetaData

                      type MetaData struct {
                      	Kind         string
                      	Name         string
                      	ShortName    string
                      	TypeName     string
                      	PkgName      string
                      	ObjectOwner  interface{}
                      	MetaObject   interface{}
                      	Type         reflect.Type
                      	DepNames     []string
                      	DepMetaData  []*MetaData
                      	ContextAware bool
                      	Instance     interface{}
                      }

                        MetaData is the injectable object meta data

                        func CastMetaData

                        func CastMetaData(object interface{}) (metaData *MetaData)

                          CastMetaData cast object to *factory.MetaData

                          func CloneMetaData

                          func CloneMetaData(src *MetaData) (dst *MetaData)

                            CloneMetaData is the func for cloning meta data

                            func NewMetaData

                            func NewMetaData(params ...interface{}) (metaData *MetaData)

                              NewMetaData create new meta data

                              Directories

                              Path Synopsis
                              Package autoconfigure implement ConfigurableFactory
                              Package autoconfigure implement ConfigurableFactory
                              Package depends provides dependency resolver for factory
                              Package depends provides dependency resolver for factory
                              bar
                              Package bar is the test package for package depends
                              Package bar is the test package for package depends
                              fake
                              Package fake is the test package for package depends
                              Package fake is the test package for package depends
                              foo
                              Package foo is the test package for package depends
                              Package foo is the test package for package depends
                              Package instantiate implement InstantiateFactory
                              Package instantiate implement InstantiateFactory