package org.andromda.core.namespace;
   
   import java.net.URL;
   import java.util.ArrayList;
   import java.util.Collection;
   import java.util.LinkedHashMap;
   import java.util.Map;
   
   /**
   * Represents a namespace registry.  This is where
   * all components within a namespace are registered.
   *
   * @author Chad Brandon
   * @author Bob Fields
   */
  public class NamespaceRegistry
  {
      /**
       * The name of the namespace registry
       */
      private String name;
  
      /**
       * Gets the name of the namespace registry.
       *
       * @return Returns the name.
       */
      public String getName()
      {
          return this.name;
      }
  
      /**
       * SEts the name of the namespace registry.
       *
       * @param name The name to set.
       */
      public void setName(String name)
      {
          this.name = name;
      }
  
      /**
       * Whether or not this is a shared namespace.
       */
      private boolean shared = false;
  
      /**
       * Gets whether or not the namespace defined by this registry
       * is shared. By default namespaces are <strong>NOT </strong> shared.
       *
       * @return Returns the shared.
       */
      public boolean isShared()
      {
          return shared;
      }
  
      /**
       * Sets whether or not the namespace defined by this registry is shared.
       *
       * @param shared The shared to set.
       */
      public void setShared(final boolean shared)
      {
          this.shared = shared;
      }
  
      /**
       * Stores the names of the components registered
       * within this namespace registry and the paths from which
       * they can be initialized.
       */
      private final Map<String, String[]> components = new LinkedHashMap<String, String[]>();
  
      /**
       * Registers the component with the
       * give name in this registry.
       *
       * @param component the component of the registry.
       */
      public void registerComponent(final Component component)
      {
          if (component != null)
          {
              this.components.put(
                  component.getName(),
                  component.getPaths());
          }
      }
  
      /**
       * Gets the names registered components.
       *
       * @return the names of the registered components.
       */
      public String[] getRegisteredComponents()
      {
          return this.components.keySet().toArray(new String[this.components.size()]);
     }
 
     /**
      * Gets the initialization paths for the given component name.
      *
      * @param name the name of the component.
      * @return the paths or null if none are found.
      */
     public String[] getPaths(final String name)
     {
         return this.components.get(name);
     }
 
     /**
      * Stores the property definitions.
      */
     private final Map<String, PropertyDefinition> definitions = new LinkedHashMap<String, PropertyDefinition>();
 
     /**
      * Attempts to retrieve the property definition for the given
      * <code>name</code>.
      * @param name
      * @return the property definition or null if one could not be found.
      */
     public PropertyDefinition getPropertyDefinition(final String name)
     {
         return this.definitions.get(name);
     }
 
     /**
      * Adds all property definitions to the current property definitions.
      *
      * @param propertyDefinitions the collection of property definitions.
      */
     public void addPropertyDefinitions(final PropertyDefinition[] propertyDefinitions)
     {
         for (PropertyDefinition propertyDefinition : propertyDefinitions)
         {
             this.addPropertyDefinition(propertyDefinition);
         }
     }
 
     /**
      * Copies all contents from the <code>registry</code>
      * to this instance.
      *
      * @param registry the registry to copy.
      */
     final void copy(final NamespaceRegistry registry)
     {
         if (registry != null)
         {
             this.addPropertyDefinitions(registry.getPropertyDefinitions());
             this.components.putAll(registry.components);
             if (registry.isShared())
             {
                 this.shared = registry.isShared();
             }
             this.resourceRoots.addAll(registry.resourceRoots);
         }
     }
 
     /**
      * Gets all property definitions belonging to this registry.
      *
      * @return all property definitions.
      */
     public PropertyDefinition[] getPropertyDefinitions()
     {
         return this.definitions.values().toArray(new PropertyDefinition[this.definitions.size()]);
     }
 
     /**
      * Adds a property definition to the group of defintions.
      *
      * @param propertyDefinition the property definition.
      */
     public void addPropertyDefinition(final PropertyDefinition propertyDefinition)
     {
         if (propertyDefinition != null)
         {
             this.definitions.put(
                 propertyDefinition.getName(),
                 propertyDefinition);
         }
     }
 
     /**
      * The root of this namespace which stores all resources.
      */
     private Collection<URL> resourceRoots = new ArrayList<URL>();
 
     /**
      * Gets the resource root of this namespace.
      *
      * @return Returns the resource.
      */
     public URL[] getResourceRoots()
     {
         return this.resourceRoots.toArray(new URL[this.resourceRoots.size()]);
     }
 
     /**
      * Adds a resource root to this namespace (since a namespace can consist of multiple
      * locations)
      *
      * @param resourceRoot The resource root to set.
      */
     final void addResourceRoot(final URL resourceRoot)
     {
         this.resourceRoots.add(resourceRoot);
     }
 
     /**
      * @see Object#toString()
      */
     public String toString()
     {
         return super.toString() + '[' + this.getName() + ']';
     }
 }