copland 0.8.0

data/lib/copland/models/threaded.rb

@@ -0,0 +1,65 @@
+#--
+# =============================================================================
+# Copyright (c) 2004, Jamis Buck (jgb3@email.byu.edu)
+# All rights reserved.
+# 
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+# 
+#     * Redistributions of source code must retain the above copyright notice,
+#       this list of conditions and the following disclaimer.
+# 
+#     * Redistributions in binary form must reproduce the above copyright
+#       notice, this list of conditions and the following disclaimer in the
+#       documentation and/or other materials provided with the distribution.
+# 
+#     * The names of its contributors may not be used to endorse or promote
+#       products derived from this software without specific prior written
+#       permission.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+# =============================================================================
+#++
+
+require 'copland/models/abstract'
+require 'copland/models/proxy'
+
+module Copland
+  module ServiceModel
+
+    # The threaded service model is much like the singleton service model,
+    # except it has one instance of the service point <em>per thread</em>.
+    class ThreadedServiceModel < AbstractServiceModel
+
+      # Return the current thread's instance of the service point. If no
+      # such instance exists, instantiate one.
+      def instance( &init )
+        Thread.current[ :threaded_services ] ||= Hash.new
+        service =
+          Thread.current[ :threaded_services ][ @service_point.full_name ]
+
+        unless service
+          service = Proxy.new( @service_point, &init ) 
+          Thread.current[ :threaded_services ][ @service_point.full_name ] =
+            service
+        end
+
+        return service
+      end
+
+      register_as "threaded"
+
+    end
+
+  end
+end

data/lib/copland/ordering.rb

@@ -0,0 +1,123 @@
+#--
+# =============================================================================
+# Copyright (c) 2004, Jamis Buck (jgb3@email.byu.edu)
+# All rights reserved.
+# 
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+# 
+#     * Redistributions of source code must retain the above copyright notice,
+#       this list of conditions and the following disclaimer.
+# 
+#     * Redistributions in binary form must reproduce the above copyright
+#       notice, this list of conditions and the following disclaimer in the
+#       documentation and/or other materials provided with the distribution.
+# 
+#     * The names of its contributors may not be used to endorse or promote
+#       products derived from this software without specific prior written
+#       permission.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+# =============================================================================
+#++
+
+require 'copland/errors'
+
+module Copland
+
+  # This is module that implements ordering algorithms. Currently
+  # only one such algorithm is implemented, and it is used for ordering
+  # interceptors and AutoLoad-ed services.
+  module Orderer
+
+    # Orders the given list of elements. Each element MUST support the
+    # following interface:
+    #
+    # # +point+: return a service-point or configuration-point with
+    #   which the element is associated. This is used for error reporting,
+    #   when the ordering fails.
+    #
+    # # +before?(e): return true iff the element must occur before the
+    #   element 'e' in the list. 'e' must be an element instance.
+    #
+    # # +after?(e): return true iff the element must occur after the
+    #   element 'e' in the list. 'e' must be an element instance.
+    def order( elements )
+      list = []
+
+      return list if elements.empty?
+
+      elements = elements.dup
+
+      # 1: shift first element of 'elements' onto 'list'
+      list.push elements.shift
+
+      while !elements.empty?
+        # 2: for each element 'i' of 'elements', compare it with each
+        #    element 'j' of 'list'. If position of i is constrained relative
+        #    to j, shift i onto list relative to j. If conflicting constraints
+        #    are discovered for i relative to multiple elements of list, raise
+        #    an exception. If i is unconstrained relative to any j, leave it
+        #    (for now) in 'elements'.
+
+        index = 0
+        insertions_made = 0
+
+        while index < elements.length
+          i = elements[ index ]
+          must_be_at = -1
+
+          list.each_index do |position|
+            j = list[ position ]
+
+            if must_be_at < 0 && i.before?( j )
+              must_be_at = position
+            end
+
+            if must_be_at >= 0 && i.after?( j )
+              raise OrderingException,
+                "#{i.point.full_name} < #{list[must_be_at].point.full_name} && " +
+                "#{i.point.full_name} > #{j.point.full_name}"
+            end
+          end
+
+          if must_be_at >= 0
+            elements.delete_at index
+            list.insert must_be_at, i
+            insertions_made += 1
+          else
+            index += 1
+          end
+        end
+
+        # 3: if no new elements were shifted onto 'list', start over at step 1.
+        #    otherwise repeat from step 2. Continue until 'elements' list is
+        #    empty.
+
+        if !elements.empty? && insertions_made < 1
+          # this is safe because, at this point, we know that the elements in 'list'
+          # and the remaining elements in 'elements' are independent of each other;
+          # thus, we can just push any value from 'elements' onto the end 'list',
+          # without violating any constraints.
+          list.push elements.shift
+        end
+          
+      end
+
+      return list
+    end
+    module_function :order
+
+  end
+
+end

data/lib/copland/package.rb

@@ -0,0 +1,246 @@
+#--
+# =============================================================================
+# Copyright (c) 2004, Jamis Buck (jgb3@email.byu.edu)
+# All rights reserved.
+# 
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+# 
+#     * Redistributions of source code must retain the above copyright notice,
+#       this list of conditions and the following disclaimer.
+# 
+#     * Redistributions in binary form must reproduce the above copyright
+#       notice, this list of conditions and the following disclaimer in the
+#       documentation and/or other materials provided with the distribution.
+# 
+#     * The names of its contributors may not be used to endorse or promote
+#       products derived from this software without specific prior written
+#       permission.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+# =============================================================================
+#++
+
+require 'copland/errors'
+require 'copland/utils'
+
+module Copland
+
+  # This represents a single package in a Repository.
+  class Package
+
+    # The Registry instance that contains this package.
+    attr_reader :registry
+
+    # The name of this package.
+    attr_reader :name
+
+    # The description of the package.
+    attr_accessor :description
+
+    # Create a new package associated with the given registry. The package will
+    # have the given name. Note: this will _not_ add the package to the
+    # registry!
+    def initialize( registry, name )
+      @registry = registry
+      @name = name
+      @service_points = Hash.new
+      @configuration_points = Hash.new
+      @schemas = Hash.new
+    end
+
+    # Add the given service point to the package.
+    def add_service_point( service_point )
+      @service_points[ service_point.name ] = service_point
+    end
+
+    # Add the given configuration point to the package.
+    def add_configuration_point( configuration_point )
+      @configuration_points[ configuration_point.name ] = configuration_point
+    end
+
+    # Add the given schema to the package. Note that this requires that the
+    # schema have a name. This will also set the schema's +owner+ attribute
+    # to the package.
+    def add_schema( schema )
+      schema.owner = self
+      @schemas[ schema.name ] = schema
+    end
+
+    # Returns the service point with the given name. If no such service point
+    # exists, this returns +nil+.
+    def service_point( name )
+      @service_points[ name ]
+    end
+
+    # This returns the names of all service points in the package.
+    def service_points
+      @service_points.keys.freeze
+    end
+
+    # This instantiates the service point with the given name and returns the
+    # resulting service. If the service point does not exist, this will raise
+    # a ServicePointNotFound exception.
+    #
+    # If a block is given, it will be used to initialize the service (but only
+    # when the service is created--if the service is a singleton service and
+    # it was created previously, the init block will be ignored).
+    def service( name, &init )
+      point = service_point( name ) or raise ServicePointNotFound, name
+      point.instance( &init )
+    end
+
+    # Returns +true+ if the named service exists in this package, and +false+
+    # otherwise.
+    def service_exist?( name )
+      return !service_point( name ).nil?
+    end
+
+    # This is a convenience method for returning a service with the given name,
+    # giving preference when a package is not specified to the service points
+    # within the current package.
+    def find_service( name, &block )
+      Copland::get_possibly_local_service( registry, self, name, &block )
+    end
+
+    # This is a convenience method for returning a schema with the given name,
+    # giving preference when a package is not specified to the schemas
+    # within the current package.
+    def find_schema( name )
+      find_service( name ) do |pkg, id|
+        if pkg.nil?
+          raise PackageNotFound, name
+        else
+          schema = pkg.schema( id )
+          raise SchemaNotFound, name unless schema
+          return schema
+        end
+      end
+    end
+
+    # Returns the configuration point with the given name, or +nil+ if no such
+    # configuration point exists.
+    def configuration_point( name )
+      @configuration_points[ name ]
+    end
+
+    # Returns the names of all configuration points in the package.
+    def configuration_points
+      @configuration_points.keys.freeze
+    end
+
+    # Returns the schema with the given name, or +nil+ if no such schema
+    # exists.
+    def schema( name )
+      @schemas[ name ]
+    end
+
+    # Adds a "pending" contribution to the package. When the package is
+    # fixated (see #fixate!), the given value will be contributed to the
+    # configuration point with the given name. Once the package is
+    # fixated, this method will be illegal to invoke.
+    def add_pending_contribution( name, value )
+      ( @pending_contributions ||= [] ).push :name => name,
+                                             :value => value
+    end
+
+    # Iterates over each service point in the package.
+    def each_service_point( &block )
+      @service_points.each_value( &block )
+      self
+    end
+
+    # Iterates over each configuration point in the package.
+    def each_configuration_point( &block )
+      @configuration_points.each_value( &block )
+    end
+
+    # Iterates over each schema in the package.
+    def each_schema( &block )
+      @schemas.each_value( &block )
+    end
+
+    # Returns the number of service points in the package.
+    def service_point_count
+      @service_points.size
+    end
+
+    # Returns the number of configuration points in the package.
+    def configuration_point_count
+      @configuration_points.size
+    end
+
+    # Returns the number of schemas in the package.
+    def schema_count
+      @schemas.size
+    end
+
+    # Fixates the package. This will, in turn, fixate each configuration and
+    # service point in the package. Also, all pending contributions will be
+    # contributed to the configuration points they were intended for.
+    def fixate!
+      extend Fixated
+
+      @schemas.each_value { |schema| schema.fixate! }
+      @service_points.each_value { |point| point.fixate! }
+      @configuration_points.each_value { |point| point.fixate! }
+
+      if @pending_contributions
+        @pending_contributions.each do |value|
+          name = value[ :name ]
+          contribution = value[ :value ]
+
+          configuration_point = find_service( name ) do |pkg, id|
+            raise PackageNotFound, name unless pkg
+            pkg.configuration_point( id )
+          end
+
+          raise ConfigurationPointNotFound, name unless configuration_point
+
+          contribution.instance_variable_set( :@contributor, self )
+          configuration_point.contribute contribution
+        end
+
+        remove_instance_variable :@pending_contributions
+      end
+    end
+
+    # Returns +false+, although when the package is fixated this will be
+    # overridden with a method that will return +true+.
+    def fixated?
+      false
+    end
+
+    # This module will be included by the package when it is fixated.
+    module Fixated
+
+      # Raises DisallowedOperationException.
+      def add_pending_contribution( *args )
+        raise DisallowedOperationException,
+          "cannot add pending contributions to fixated package"
+      end
+
+      # Does nothing.
+      def fixate!
+        # does nothing
+      end
+
+      # Returns +true+.
+      def fixated?
+        true
+      end
+    end
+
+  end
+
+end

data/lib/copland/registry.rb

@@ -0,0 +1,368 @@
+#--
+# =============================================================================
+# Copyright (c) 2004, Jamis Buck (jgb3@email.byu.edu)
+# All rights reserved.
+# 
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+# 
+#     * Redistributions of source code must retain the above copyright notice,
+#       this list of conditions and the following disclaimer.
+# 
+#     * Redistributions in binary form must reproduce the above copyright
+#       notice, this list of conditions and the following disclaimer in the
+#       documentation and/or other materials provided with the distribution.
+# 
+#     * The names of its contributors may not be used to endorse or promote
+#       products derived from this software without specific prior written
+#       permission.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+# =============================================================================
+#++
+
+require 'copland/class-factory'
+require 'copland/errors'
+require 'copland/event-producer'
+require 'copland/instantiator'
+require 'copland/log-factory'
+require 'copland/models'
+require 'copland/package'
+require 'copland/service-point'
+require 'copland/utils'
+
+require 'copland/configuration/loader'
+require 'copland/configuration/yaml/loader'
+
+module Copland
+
+  # The Registry is the primary interface exported by Copland. Very rarely
+  # should client applications need to access any other interface directly.
+  #
+  # The Registry can be constructed in two ways. The first (and most common) is
+  # to call the #build method, which instantiates, initializes, and returns the
+  # new Registry instance in one step.
+  #
+  #   registry = Registry.build
+  #
+  # The second is the instantiate an empty Registry and initialize it yourself.
+  # This is a more arduous approach, but may be necessary for some more complex
+  # Registry requirements.
+  class Registry
+    include EventProducer
+
+    # Instantiate, initialize, and return a new Registry instance. The accepted
+    # parameters are:
+    #
+    # * if the first parameter is a String, it is interpreted to be the
+    #   "default" search path. (This defaults to ".".)
+    # * the other parameter (or the first parameter, if it is not a String)
+    #   must be either absent, or it must be a Hash, in which case it specifies
+    #   options that will be used to construct and initialize the Registry.
+    #
+    # Valid options are:
+    #
+    # * <tt>:default_service_model</tt>: the default service model to use when
+    #   creating service points, when an explicit service model has not been
+    #   given.
+    # * <tt>:search_paths</tt>: an array of paths that should be searched for
+    #   package descriptors.
+    #
+    # Also, any option that LogFactory accepts is also valid, prefixed with
+    # "log_". (I.e., <tt>:log_device</tt> instead of <tt>:device</tt>.)
+    def self.build( *args )
+      if args.length > 2
+        raise ArgumentError, "expected [0..2] arguments, got #{args.length}"
+      end
+
+      default_search_path = "."
+      options = {}
+
+      default_search_path = args.shift if args.first.is_a? String
+      options = args.shift if args.first.is_a? Hash
+
+      unless args.empty?
+        raise ArgumentError, "unexpected argument type #{args.first.class}"
+      end
+
+      ( options[:search_paths] ||= [] ).unshift( default_search_path ).uniq!
+      options[:search_paths].compact!
+
+      search_paths = options[:search_paths]
+      options.delete :search_paths
+
+      registry = new( options )
+      loader = Copland::Configuration::Loader.new( search_paths )
+      loader.add_loader Copland::Configuration::YAML::Loader.new( registry,
+        loader )
+      loader.load( options )
+
+      startup = registry.service( "copland.Startup" )
+      startup.start
+
+      return registry
+    end
+
+    # The LogFactory instance that will be employed by this registry for
+    # creating logger instances.
+    attr_reader :logs
+
+    # Create a new, empty registry. The +options+ hash accepts any value that
+    # LogFactory's constructor accepts, with "log_" prefixed. (I.e.,
+    # <tt>:log_device</tt> instead of <tt>:device</tt>.)
+    def initialize( options={} )
+      @packages = Hash.new
+
+      log_options = Hash.new
+      options.each do |k,v|
+        log_options[$1.intern] = v if k.to_s =~ /^log_(.*)/
+      end
+
+      @logs = LogFactory.new( log_options )
+    end
+
+    # Fixates the registry. This performs one-time operations on the registry,
+    # and then makes it illegal to perform those operations subsequently on the
+    # same registry instance.
+    #
+    # This will create the "copland.Registry" service point, fixate each of the
+    # registry's packages, and then register a finalizer in ObjectSpace that
+    # will cause the registry to always be gracefully shutdown.
+    def fixate!
+      define_self_as_service
+      define_log_factory_as_service
+      @packages.each { |id, pkg| pkg.fixate! }
+      ObjectSpace.define_finalizer( self, proc { shutdown } )
+      extend Fixated
+    end
+
+    # Returns +false+. After the registry has been fixated (see #fixate!), this
+    # will be overridden with a method that returns +true+.
+    def fixated?
+      false
+    end
+
+    # Shuts down the registry by notifying any interested listeners (using the
+    # <tt>:registry_shutdown</tt> event), closing the logs, and then
+    # extending the Shutdown module.
+    def shutdown
+      fire_event( :registry_shutdown )
+      @logs.close
+      extend Shutdown
+    end
+
+    # Returns +false+. After the registry has been #shutdown, this will be be
+    # overridden with a method that returns +true+.
+    def shutdown?
+      false
+    end
+
+    # This creates a new service point called "copland.Registry" and makes it
+    # so that it always returns the active registry instance when instantiated.
+    def define_self_as_service
+      description = "This service is intended to allow services to " +
+        "obtain a reference to the registry which created them. In general, " +
+        "however, services should never need to reference the registry " +
+        "directly; instead, they should rely on their descriptors to " +
+        "specify their dependencies. There are a few exceptions to this " +
+        "rule, though, and it is for those exceptions that this service is " +
+        "made available."
+
+      add_identity_service "copland",
+                           "Registry",
+                           self,
+                           description
+    end
+    private :define_self_as_service
+
+    # This creates a new service point called "copland.LogFactory" and makes it
+    # so that it always returns the log factory instance owned by the active
+    # registry.
+    def define_log_factory_as_service
+      description = "The LogFactory service provides log instances " +
+        "on demand. It is always an identity for the log factory instance " +
+        "owned by the registry."
+
+      add_identity_service "copland",
+                           "LogFactory",
+                           logs,
+                           description
+    end
+    private :define_self_as_service
+
+    # A convenience method for clients that wish to add a specific object to
+    # the registry as an "identity" service (that is, a singleton service point
+    # that always instantiates as the given object).
+    def add_identity_service( package_name,
+                              service_point_name,
+                              object,
+                              description=nil )
+    # begin
+      owner = package( package_name )
+      if owner.nil?
+        owner = Package.new( self, package_name )
+        add_package owner
+      end
+
+      service_point = ServicePoint.new( owner, service_point_name )
+      service_point.use_service_model "singleton"
+
+      service_point.description = description
+
+      service_point.instantiator = ClassFactory.instance.get(
+        Instantiator::POOL_NAME, "identity", service_point, object )
+      owner.add_service_point( service_point )
+
+      service_point
+    end
+
+    # Returns the package with the given name. If there is no such package,
+    # this returns +nil+.
+    def package( name )
+      @packages[ name ]
+    end
+
+    # Returns the service with the given name. If no such service point can
+    # be found, this raises the ServicePointNotFound exception. (See
+    # Package#service.)
+    #
+    # If a block is given, it is passed to Package#service and is used to
+    # initialize the service.
+    def service( name, &init )
+      Copland::get_possibly_local_service( self, nil, name ) do |pkg, id|
+        unless pkg
+          raise ServicePointNotFound,
+            "A fully-qualified service name must be given to Registry#service"
+        else
+          return pkg.service( id, &init )
+        end
+      end
+    end
+
+    # Returns the service point with the given name. If no such service point
+    # can be found, this +nil+.
+    def service_point( name )
+      Copland::get_possibly_local_service( self, nil, name ) do |pkg, id|
+        unless pkg
+          raise ServicePointNotFound,
+            "A fully-qualified service name must be given to Registry#service_point"
+        else
+          return pkg.service_point( id )
+        end
+      end
+    end
+
+    # Returns +true+ if the named service exists in this registry, and +false+
+    # otherwise.
+    def service_exist?( name )
+      Copland::get_possibly_local_service( self, nil, name ) do |pkg, id|
+        unless pkg
+          return false
+        else
+          return pkg.service_exist?( id )
+        end
+      end
+    end
+
+    # This returns the configuration point with the given name. If the
+    # package exists but no configuration point by that name can be 
+    # found in it, this returns +nil+. If the package itself does not
+    # exist, then a ConfigurationPointNotFound exception is raised.
+    def configuration_point( name )
+      Copland::get_possibly_local_service( self, nil, name ) do |pkg, id|
+        unless pkg
+          raise ConfigurationPointNotFound,
+            "A fully-qualified configuration point name must be given " +
+            "to Registry#service"
+        else
+          return pkg.configuration_point( id )
+        end
+      end
+    end
+
+    # Adds the given package to the registry. If there is already a package
+    # in the registry by that name, a DuplicatePackageError will be raised.
+    def add_package( pkg )
+      if @packages[ pkg.name ]
+        raise DuplicatePackageError, pkg.name
+      end
+
+      @packages[ pkg.name ] = pkg
+    end
+
+    # Iterates over each package in the registry.
+    def each_package( &block )
+      @packages.each_value( &block )
+      self
+    end
+
+    # Returns the number of packages in the registry.
+    def package_count
+      @packages.size
+    end
+
+    # When Registry#fixate! is called for the first time, it will extend this
+    # module.
+    module Fixated
+      # Does nothing
+      def fixate!
+        # do nothing
+      end
+
+      # Returns +true+.
+      def fixated?
+        true
+      end
+    end
+
+    # When Registry#shutdown is called for the first time, it will extend this
+    # module. This will make several operations illegal, like querying a
+    # service.
+    module Shutdown
+      # Does nothing.
+      def shutdown( *args )
+        # do nothing
+      end
+
+      # Returns +true+.
+      def shutdown?
+        true
+      end
+
+      # Raises a DisallowedOperationException.
+      def package( *args )
+        raise DisallowedOperationException,
+          "cannot get package from registry after shutdown"
+      end
+
+      # Raises a DisallowedOperationException.
+      def service( *args )
+        raise DisallowedOperationException,
+          "cannot get service from registry after shutdown"
+      end
+
+      # Raises a DisallowedOperationException.
+      def configuration_point( *args )
+        raise DisallowedOperationException,
+          "cannot get configuration point from registry after shutdown"
+      end
+
+      # Raises a DisallowedOperationException.
+      def add_package( *args )
+        raise DisallowedOperationException,
+          "cannot add package to registry after shutdown"
+      end
+    end
+  end
+
+end