package org.codehaus.plexus.component.repository;
   
   /*
    * Copyright 2001-2006 Codehaus Foundation.
    *
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
   *      http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Collections;
  import java.util.List;
  
  import org.codehaus.plexus.PlexusConstants;
  import org.codehaus.plexus.classworlds.realm.ClassRealm;
  import org.codehaus.plexus.configuration.PlexusConfiguration;
  
  /**
   * Component instantiation description.
   *
   * @author Jason van Zyl
   * @author <a href="mailto:bob@eng.werken.com">bob mcwhirter</a>
   * @author <a href="mailto:mmaczka@interia.pl">Michal Maczka</a>
   */
  public class ComponentDescriptor<T> {
      private String alias = null;
  
      private String role = null;
  
      private Class<T> roleClass;
  
      private String roleHint = PlexusConstants.PLEXUS_DEFAULT_HINT;
  
      private String implementation;
  
      private Class<? extends T> implementationClass;
  
      private String version;
  
      private String componentType;
  
      private PlexusConfiguration configuration;
  
      private String instantiationStrategy;
  
      private String lifecycleHandler;
  
      private String componentProfile;
  
      private final List<ComponentRequirement> requirements = new ArrayList<ComponentRequirement>();
  
      private String componentFactory;
  
      private String componentComposer;
  
      private String componentConfigurator;
  
      private String description;
  
      private ClassRealm realm;
  
      // ----------------------------------------------------------------------
      // These two fields allow for the specification of an isolated class realm
      // and dependencies that might be specified in a component configuration
      // setup by a user i.e. this is here to allow isolation for components
      // that are not picked up by the discovery mechanism.
      // ----------------------------------------------------------------------
  
      private boolean isolatedRealm;
  
      // ----------------------------------------------------------------------
  
      private ComponentSetDescriptor componentSetDescriptor;
  
      private String source;
  
      // ----------------------------------------------------------------------
      // Instance methods
      // ----------------------------------------------------------------------
  
      public ComponentDescriptor() {}
  
      public ComponentDescriptor(Class<T> implementationClass, ClassRealm realm) {
          this.implementationClass = implementationClass;
          this.implementation = implementationClass.getName();
          this.realm = realm;
      }
  
      /**
      * The location this information came from (descriptor file URI).
      * @param source The source of the descriptor.
      */
     public void setSource(String source) {
         this.source = source;
     }
 
     /**
      * The location this information came from (descriptor file URI).
      * @return The source.
      */
     public String getSource() {
         return source;
     }
 
     /**
      * Returns a human-friendly key, suitable for display.
      *
      * @return a human-friendly key
      */
     public String getHumanReadableKey() {
         StringBuilder key = new StringBuilder();
 
         key.append("role: '").append(getRole()).append("'");
 
         key.append(", implementation: '").append(getImplementation()).append("'");
 
         if (roleHint != null) {
             key.append(", role hint: '").append(getRoleHint()).append("'");
         }
 
         if (alias != null) {
             key.append(", alias: '").append(getAlias()).append("'");
         }
 
         return key.toString();
     }
 
     /**
      * Returns an alias for this component. An alias as an alternate name other than the normal key.
      *
      * @return an alias for this component
      */
     public String getAlias() {
         return alias;
     }
 
     /**
      * Sets the alias for this component.
      *
      * @param alias alternate name to set
      */
     public void setAlias(String alias) {
         this.alias = alias;
     }
 
     /**
      * Returns the role of this component.
      *
      * @return the role of this component
      */
     public String getRole() {
         return role;
     }
 
     public Class<T> getRoleClass() {
         attemptRoleLoad();
 
         if (roleClass == null) {
             return (Class<T>) Object.class;
         }
         return (Class<T>) roleClass;
     }
 
     private void attemptRoleLoad() {
         if (roleClass == null && getRole() != null && getRealm() != null) {
             try {
                 roleClass = (Class<T>) getRealm().loadClass(getRole());
                 Thread.currentThread();
             } catch (Throwable ignored) {
                 Thread.currentThread();
             }
         }
     }
 
     /**
      * Sets the role of this component.
      *
      * @param role this component's role
      */
     public void setRole(String role) {
         this.role = role;
 
         // reload role class
         roleClass = null;
         attemptRoleLoad();
     }
 
     public void setRoleClass(Class<T> roleClass) {
         this.roleClass = roleClass;
 
         if (roleClass == null) {
             role = null;
         } else {
             role = roleClass.getName();
         }
     }
 
     /**
      * Returns the role-hint of this component.
      *
      * @return the role-hint of this component
      */
     public String getRoleHint() {
         return roleHint;
     }
 
     /**
      * Sets the role-hint of this component. Pasing null will set the hint to the default value.
      *
      * @param roleHint this component's role-hint
      */
     public void setRoleHint(String roleHint) {
         if ((roleHint == null) || roleHint.trim().equals("")) {
             this.roleHint = PlexusConstants.PLEXUS_DEFAULT_HINT;
         } else {
             this.roleHint = roleHint;
         }
     }
 
     /**
      * Returns the implementation of this componet. Implementation is a string denoting a FQCN in normal Java
      * components, or some other name or file for other component factory implementations.
      *
      * @return the implementation of this componet's role.
      */
     public String getImplementation() {
         return implementation;
     }
 
     /**
      * Sets the implementation of this componet.
      *
      * @param implementation string denoting a FQCN in normal Java components, or some other name or file for other
      *        component factory implementations
      */
     public void setImplementation(String implementation) {
         this.implementation = implementation;
 
         // reload implementation class
         implementationClass = null;
         attemptImplementationLoad();
     }
 
     /**
      * Returns the implementation class of this componet, or null if the implementation class can not be loaded.
      *
      * @return the implementation of this componet's role.
      */
     public Class<? extends T> getImplementationClass() {
         attemptImplementationLoad();
 
         if (implementationClass == null) {
             return (Class<T>) Object.class;
         }
         return (Class<T>) implementationClass;
     }
 
     private void attemptImplementationLoad() {
         if (implementationClass == null && getImplementation() != null && getRealm() != null) {
             try {
                 implementationClass = (Class<? extends T>) getRealm().loadClass(getImplementation());
                 Thread.currentThread();
             } catch (Throwable ignored) {
                 Thread.currentThread();
             }
         }
     }
 
     public void setImplementationClass(Class<? extends T> implementationClass) {
         this.implementationClass = implementationClass;
         if (implementationClass == null) {
             implementation = null;
         } else {
             implementation = implementationClass.getName();
         }
     }
 
     /**
      * Returns a specific point in a components's project timeline. i.e. version 1, or 2.1.4
      *
      * @return a specific point in a components's project timeline
      */
     public String getVersion() {
         return version;
     }
 
     /**
      * Sets the point in a components's project development timeline
      *
      * @param version the components's version
      */
     public void setVersion(String version) {
         this.version = version;
     }
 
     /**
      * Returns the type of this component.
      *
      * @return the type of this component
      */
     public String getComponentType() {
         return componentType;
     }
 
     /**
      * Sets this component's type.
      *
      * @param componentType the type to set
      */
     public void setComponentType(String componentType) {
         this.componentType = componentType;
     }
 
     /**
      * Returns the type of instantiation strategy for this component.
      *
      * @return the type of instantiation strategy for this component
      */
     public String getInstantiationStrategy() {
         return instantiationStrategy;
     }
 
     /**
      * Returns configuration values defined for this component.
      *
      * @return configuration values defined for this component
      */
     public PlexusConfiguration getConfiguration() {
         return configuration;
     }
 
     /**
      * Sets the configuration hierarchy for this component.
      *
      * @param configuration the configuration hierarchy to set
      */
     public void setConfiguration(PlexusConfiguration configuration) {
         this.configuration = configuration;
     }
 
     /**
      * Returns true if this component has a configuration.
      *
      * @return true if this component has a configuration
      */
     public boolean hasConfiguration() {
         return configuration != null;
     }
 
     /**
      * Returns the lifecycle-handler for this component.
      *
      * @return the lifecycle-handler for this component
      */
     public String getLifecycleHandler() {
         return lifecycleHandler;
     }
 
     /**
      * Sets the lifecycle-handler for this component. For example, "basic", "passive", "bootstrap".
      *
      * @param lifecycleHandler the lifecycle handler string to set
      */
     public void setLifecycleHandler(String lifecycleHandler) {
         this.lifecycleHandler = lifecycleHandler;
     }
 
     public String getComponentProfile() {
         return componentProfile;
     }
 
     public void setComponentProfile(String componentProfile) {
         this.componentProfile = componentProfile;
     }
 
     /**
      * Add a project requirement to this component.
      *
      * @param requirement the requirement to add
      */
     public void addRequirement(ComponentRequirement requirement) {
         this.requirements.add(requirement);
     }
 
     /**
      * Add a project requirement to this component.
      *
      * @param requirement the requirement to add
      */
     public void addRequirement(ComponentRequirement... requirement) {
         this.requirements.addAll(Arrays.asList(requirement));
     }
 
     /**
      * Adds a list of requirements to this component.
      *
      * @param requirements the requirements to add
      */
     public void addRequirements(List<ComponentRequirement> requirements) {
         this.requirements.addAll(requirements);
     }
 
     /**
      * Remove a project requirement from this component.
      *
      * @param requirement the requirement to remove
      */
     public void removeRequirement(ComponentRequirement... requirement) {
         this.requirements.removeAll(Arrays.asList(requirement));
     }
 
     /**
      * Removes a list of requirements from this component.
      *
      * @param requirements the requirements to remove
      */
     public void removeRequirements(List<ComponentRequirement> requirements) {
         this.requirements.removeAll(requirements);
     }
 
     /**
      * Returns all project requirements of this component.
      *
      * @return all project requirements of this component
      */
     public List<ComponentRequirement> getRequirements() {
         return Collections.unmodifiableList(requirements);
     }
 
     /**
      * Returns an id of the factory used to create this component.
      *
      * @return an id of the factory used to create this component
      */
     public String getComponentFactory() {
         return componentFactory;
     }
 
     /**
      * Sets the id of the factory to use to create this component. For example, "jruby" will use a JRuby factory.
      *
      * @param componentFactory The componentFactor.
      */
     public void setComponentFactory(String componentFactory) {
         this.componentFactory = componentFactory;
     }
 
     /**
      * Returns the ID of the type of composer this component will use. For example, "setter" or "field" for the
      * different types of dependency injection.
      *
      * @return the ID of the type of composer this component will use
      */
     public String getComponentComposer() {
         return componentComposer;
     }
 
     /**
      * Sets a representation of the composer this component uses.
      *
      * @param componentComposer string representation of the composer to use
      */
     public void setComponentComposer(String componentComposer) {
         this.componentComposer = componentComposer;
     }
 
     /**
      * Return a human-readable description of this component.
      *
      * @return a human-readable description of this component
      */
     public String getDescription() {
         return description;
     }
 
     /**
      * Sets a description of this component for users to read.
      *
      * @param description a human-readable description of this component
      */
     public void setDescription(String description) {
         this.description = description;
     }
 
     /**
      * Sets the instantiation-strategy for this component. For example, "container".
      *
      * @param instantiationStrategy The strategy.
      */
     public void setInstantiationStrategy(String instantiationStrategy) {
         this.instantiationStrategy = instantiationStrategy;
     }
 
     // ----------------------------------------------------------------------
     //
     // ----------------------------------------------------------------------
 
     /**
      * Returns true if this may be in an isolated classrealm.
      *
      * @return true if this may be in an isolated classrealm
      */
     public boolean isIsolatedRealm() {
         return isolatedRealm;
     }
 
     /**
      * Sets the component set descriptor of components and dependencies for this component.
      *
      * @param componentSetDescriptor the component set descriptor of components and dependencies
      */
     public void setComponentSetDescriptor(ComponentSetDescriptor componentSetDescriptor) {
         this.componentSetDescriptor = componentSetDescriptor;
     }
 
     /**
      * Returns the component set descriptor.
      *
      * @return the component set descriptor
      */
     public ComponentSetDescriptor getComponentSetDescriptor() {
         return componentSetDescriptor;
     }
 
     /**
      * Sets that this component may be in an isolated classrealm.
      *
      * @param isolatedRealm true if this component may be in an isolated classrealm
      */
     public void setIsolatedRealm(boolean isolatedRealm) {
         this.isolatedRealm = isolatedRealm;
     }
 
     /**
      * Returns the type of component configurator for this project. For example "basic" for normal, or "map-oriented"
      * for map oriented components.
      *
      * @return the type of component configurator for this project
      */
     public String getComponentConfigurator() {
         return componentConfigurator;
     }
 
     /**
      * Sets the type of component configurator for this project.
      *
      * @param componentConfigurator The component configurator.
      */
     public void setComponentConfigurator(String componentConfigurator) {
         this.componentConfigurator = componentConfigurator;
     }
 
     /**
      * The ClassRealm that this component lives under.
      *
      * @return ClassRealm that this component lives under
      */
     public ClassRealm getRealm() {
         return realm;
     }
 
     /**
      * Set the ClassRealm that this component lives under.
      *
      * @param realm the ClassRealm that this component lives under
      */
     public void setRealm(ClassRealm realm) {
         this.realm = realm;
 
         // reload implementation class
         implementationClass = null;
         attemptImplementationLoad();
 
         // reload role class
         roleClass = null;
         attemptRoleLoad();
     }
 
     public String toString() {
         return getClass().getName() + " [role: '" + getRole() + "', hint: '" + getRoleHint() + "', realm: "
                 + (realm == null ? "NULL" : "'" + realm + "'") + "]";
     }
 
     // Component identity established here!
     public boolean equals(Object other) {
         if (this == other) {
             return true;
         }
 
         if (!(other instanceof ComponentDescriptor)) {
             return false;
         }
 
         ComponentDescriptor<?> that = (ComponentDescriptor<?>) other;
 
         return eq(getRole(), that.getRole())
                 && eq(getRoleHint(), that.getRoleHint())
                 && eq(getRealm(), that.getRealm());
     }
 
     private static <T> boolean eq(T o1, T o2) {
         return (o1 != null) ? o1.equals(o2) : o2 == null;
     }
 
     public int hashCode() {
         int hash = 17;
 
         hash = hash * 31 + hash(getRole());
         hash = hash * 31 + hash(getRoleHint());
         hash = hash * 31 + hash(getRealm());
 
         return hash;
     }
 
     private static int hash(Object obj) {
         return (obj != null) ? obj.hashCode() : 0;
     }
 }