org.eclipse.sisu.plexus/src/org/codehaus/plexus/component/repository/ComponentDescriptor.java

/*******************************************************************************
 * Copyright (c) 2010-present Sonatype, Inc.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *   Stuart McCulloch (Sonatype, Inc.) - initial API and implementation
 *
 * Minimal facade required to be binary-compatible with legacy Plexus API
 *******************************************************************************/
package org.codehaus.plexus.component.repository;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

import org.codehaus.plexus.classworlds.realm.ClassRealm;
import org.codehaus.plexus.configuration.PlexusConfiguration;
import org.eclipse.sisu.plexus.Hints;
import org.eclipse.sisu.plexus.Strategies;

public class ComponentDescriptor<T>
{
    // ----------------------------------------------------------------------
    // Implementation fields
    // ----------------------------------------------------------------------

    private String role;

    private String hint = Hints.DEFAULT_HINT;

    private String description = "";

    private String instantiationStrategy = Strategies.SINGLETON;

    private String implementation;

    private ClassRealm classRealm;

    private Class<?> implementationClass;

    private String componentComposer;

    private String componentConfigurator;

    private String componentFactory;

    private List<ComponentRequirement> requirements = Collections.emptyList();

    private PlexusConfiguration configuration;

    private String alias;

    private String version;

    private String componentType;

    private String componentProfile;

    private String lifecycleHandler;

    private boolean isolatedRealm;

    // ----------------------------------------------------------------------
    // Constructors
    // ----------------------------------------------------------------------

    public ComponentDescriptor()
    {
        // nothing to set
    }

    public ComponentDescriptor( final Class<T> implementationClass, final ClassRealm classRealm )
    {
        setImplementationClass( implementationClass );
        this.classRealm = classRealm;
    }

    // ----------------------------------------------------------------------
    // Public methods
    // ----------------------------------------------------------------------

    public final void setRole( final String role )
    {
        this.role = role;
    }

    public final void setRoleClass( final Class<?> roleClass )
    {
        role = roleClass.getName();
    }

    public final void setRoleHint( final String hint )
    {
        this.hint = Hints.canonicalHint( hint );
    }

    public final void setDescription( final String description )
    {
        this.description = null != description ? description : "";
    }

    public final void setInstantiationStrategy( final String instantiationStrategy )
    {
        this.instantiationStrategy = instantiationStrategy;
    }

    public final void setImplementation( final String implementation )
    {
        this.implementation = implementation;
        implementationClass = null;
    }

    public final void setRealm( final ClassRealm classRealm )
    {
        this.classRealm = classRealm;
        implementationClass = null;
    }

    @SuppressWarnings( "rawtypes" )
    public final void setImplementationClass( final Class implementationClass )
    {
        this.implementationClass = implementationClass;
        implementation = implementationClass.getName();
    }

    public final void setComponentComposer( final String componentComposer )
    {
        this.componentComposer = componentComposer;
    }

    public final void setComponentConfigurator( final String componentConfigurator )
    {
        this.componentConfigurator = componentConfigurator;
    }

    public final void setComponentFactory( final String componentFactory )
    {
        this.componentFactory = componentFactory;
    }

    public final void addRequirement( final ComponentRequirement requirement )
    {
        if ( requirements.isEmpty() )
        {
            requirements = new ArrayList<ComponentRequirement>();
        }
        requirements.add( requirement );
    }

    public final void setConfiguration( final PlexusConfiguration configuration )
    {
        this.configuration = configuration;
    }

    public final void setAlias( final String alias )
    {
        this.alias = alias;
    }

    public final void setVersion( final String version )
    {
        this.version = version;
    }

    public final void setComponentType( final String componentType )
    {
        this.componentType = componentType;
    }

    public final void setComponentProfile( final String componentProfile )
    {
        this.componentProfile = componentProfile;
    }

    public final void setLifecycleHandler( final String lifecycleHandler )
    {
        this.lifecycleHandler = lifecycleHandler;
    }

    public final void setIsolatedRealm( final boolean isolatedRealm )
    {
        this.isolatedRealm = isolatedRealm;
    }

    public String getRole()
    {
        return role;
    }

    @SuppressWarnings( "unchecked" )
    public final Class<T> getRoleClass()
    {
        try
        {
            return (Class<T>) classRealm.loadClass( getRole() );
        }
        catch ( final Exception e )
        {
            throw new TypeNotPresentException( getRole(), e );
        }
        catch ( final LinkageError e )
        {
            throw new TypeNotPresentException( getRole(), e );
        }
    }

    public String getRoleHint()
    {
        return hint;
    }

    public final String getDescription()
    {
        return description;
    }

    public final String getInstantiationStrategy()
    {
        return instantiationStrategy;
    }

    public final String getImplementation()
    {
        return implementation;
    }

    public final ClassRealm getRealm()
    {
        return classRealm;
    }

    @SuppressWarnings( "unchecked" )
    public final Class<T> getImplementationClass()
    {
        if ( null == implementationClass && null != classRealm )
        {
            try
            {
                implementationClass = classRealm.loadClass( implementation );
            }
            catch ( final Exception e )
            {
                throw new TypeNotPresentException( implementation, e );
            }
            catch ( final LinkageError e )
            {
                throw new TypeNotPresentException( implementation, e );
            }
        }
        return (Class<T>) implementationClass;
    }

    public final String getComponentComposer()
    {
        return componentComposer;
    }

    public final String getComponentConfigurator()
    {
        return componentConfigurator;
    }

    public final String getComponentFactory()
    {
        return componentFactory;
    }

    public final List<ComponentRequirement> getRequirements()
    {
        return Collections.unmodifiableList( requirements );
    }

    public final boolean hasConfiguration()
    {
        return configuration != null;
    }

    public final PlexusConfiguration getConfiguration()
    {
        return configuration;
    }

    public final String getAlias()
    {
        return alias;
    }

    public final String getVersion()
    {
        return version;
    }

    public String getComponentType()
    {
        return componentType;
    }

    public final String getComponentProfile()
    {
        return componentProfile;
    }

    public final String getLifecycleHandler()
    {
        return lifecycleHandler;
    }

    public final boolean isIsolatedRealm()
    {
        return isolatedRealm;
    }

    public final String getHumanReadableKey()
    {
        return "role: '" + getRole() + "', implementation: '" + implementation + "', role hint: '" + getRoleHint()
            + "'";
    }

    @Override
    public final String toString()
    {
        return getClass().getName() + " [role: '" + getRole() + "', hint: '" + getRoleHint() + "', realm: " + classRealm
            + "]";
    }

    @Override
    public boolean equals( final Object rhs )
    {
        if ( this == rhs )
        {
            return true;
        }
        if ( rhs instanceof ComponentDescriptor<?> )
        {
            final ComponentDescriptor<?> rhsDescriptor = (ComponentDescriptor<?>) rhs;
            return equals( getRole(), rhsDescriptor.getRole() ) && equals( getRoleHint(), rhsDescriptor.getRoleHint() )
                && equals( classRealm, rhsDescriptor.classRealm );
        }
        return false;
    }

    @Override
    public int hashCode()
    {
        return ( ( 17 * 31 + hash( getRole() ) ) * 31 + hash( getRoleHint() ) ) * 31 + hash( classRealm );
    }

    // ----------------------------------------------------------------------
    // Implementation methods
    // ----------------------------------------------------------------------

    private static final <T> boolean equals( final T lhs, final T rhs )
    {
        return null != lhs ? lhs.equals( rhs ) : null == rhs;
    }

    private static final int hash( final Object obj )
    {
        return null != obj ? obj.hashCode() : 0;
    }
}