### Home Classes Methods

### In Files

- lib/needle/service-point.rb

### Parent

Object

### Methods

- ::new
- #fullname
- #instance
- #interceptor

### Files

- README

### Class/Module Index

Quicksearch

- Needle
- Needle::Bug
- Needle::Container
- Needle::DefinitionContext
- Needle::IncludeExclude
- Needle::Interceptor
- Needle::Interceptor::DynamicInterceptor
- Needle::InterceptorChainBuilder
- Needle::InterceptorChainBuilder::InterceptedServiceProxy
- Needle::InterceptorChainBuilder::InterceptorChainElement
- Needle::InterceptorChainBuilder::ProxyObjectChainElement
- Needle::InterceptorConfigurationError
- Needle::Lifecycle
- Needle::Lifecycle::Deferred
- Needle::Lifecycle::Initialize
- Needle::Lifecycle::Multiton
- Needle::Lifecycle::Proxy
- Needle::Lifecycle::Singleton
- Needle::Lifecycle::Threaded
- Needle::LogFactory
- Needle::Logger
- Needle::LoggingInterceptor
- Needle::NeedleError
- Needle::Pipeline
- Needle::Pipeline::Collection
- Needle::Pipeline::Collection::BlockElement
- Needle::Pipeline::Element
- Needle::Pipeline::InterceptorElement
- Needle::QueryableMutex
- Needle::Registry
- Needle::ServiceNotFound
- Needle::ServicePoint
- Needle::Version

No matching classes.

# Needle::ServicePoint

A “service point” is a definition of a service. Just as a class defines the behavior of an object, so does a service point describe a service. In particular, a service point also knows how to instantiate a service.

A ServicePoint should never be directly instantiated. Instead, define services via the interfaces provided by Container.

### Attributes

container[R]

A reference to the container that contains this service point.

name[R]

The name of this service point, as it is known to the container that it was registered in.

pipeline[R]

The reference to the instantiation pipeline used by this service point.

### Public Class Methods

new( container, name, opts={}, &callback ) click to toggle source

Create a new service point that references the given container and has the given name. The associated callback will be used to instantiate the service on demand.

The `:model` option is used to tell Needle which style of life-cycle management should be used for the service. It defaults to `:singleton`. The model must be a symbol that refers to a service model that has been registered in the root `:service_models` service.

The `:pipeline` option is mutually exclusive with `:model`. It must be an array of symbols (or strings) that define the instantiation pipeline to use for this service. Each element must correspond to an entry in the `:pipeline_elements` service.

    # File lib/needle/service-point.rb, line 54
    def initialize( container, name, opts={}, &callback )
      @name = name
      @container = container
      @callback = callback
      @pipeline = Needle::Pipeline::Collection.new self
      @chain = nil

      @chain_mutex = QueryableMutex.new
      @element_mutex = QueryableMutex.new

      if opts[:pipeline]
        elements = opts[:pipeline]
      else
        model = opts[:model] || :singleton
        elements = @container[:service_models][model]
      end

      elements.concat [ *opts[:include] ] if opts[:include]
      elements.each { |element| @pipeline.add element, opts }
    end

### Public Instance Methods

fullname() click to toggle source

Returns the fully-qualified name of the service point, with the point’s name, its container’s name, and all of its container’s ancestors’ names concatenated together with dot characters, i.e. “one.two.three”.

    # File lib/needle/service-point.rb, line 78
    def fullname
      container_name = @container.fullname
      if container_name
        "#{container_name}.#{@name}"
      else
        @name.to_s
      end
    end

instance( actual_container, *args ) click to toggle source

Return the service instance represented by this service point. Depending on the style of lifecycle management chosen for this service point, this may or may not be a new instance for every invocation of this method.

The first argument is the container that should be used to resolve this service point. Assuming the container to be used is this service point’s own container would mean that any nested service points couldn’t override service points their parents’ service points used.

Any extra arguments to this method will be passed through to the chain, which may cause an error if there is an element in the pipeline that does not accept additional arguments. Regardless, the first two parameters to the chain will always be the container and the service point.

    # File lib/needle/service-point.rb, line 115
    def instance( actual_container, *args )
      unless @chain
        @chain_mutex.synchronize do
          @chain = @pipeline.chain_to( @callback ) unless @chain
        end
      end

      @chain.call( actual_container, self, *args )
    end

interceptor( interceptor ) click to toggle source

Adds the given interceptor definition to this service point. The parameter should act like an instance of Interceptor.

    # File lib/needle/service-point.rb, line 89
    def interceptor( interceptor )
      @element_mutex.synchronize do
        element = @pipeline.get( :interceptor )
        unless element
          @pipeline.add( :interceptor )
          element = @pipeline.get( :interceptor )
        end
        element.interceptors << interceptor
        @pipeline.reset!
        @chain = nil
      end
    end

[Validate]

Generated with the Darkfish Rdoc Generator 2.