blueprint/blueprint-parser/src/main/java/org/apache/aries/blueprint/ComponentDefinitionRegistry.java

/**
 *  Licensed to the Apache Software Foundation (ASF) under one or more
 *  contributor license agreements.  See the NOTICE file distributed with
 *  this work for additional information regarding copyright ownership.
 *  The ASF licenses this file to You 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.
 */
package org.apache.aries.blueprint;

import java.util.List;
import java.util.Set;

import org.osgi.service.blueprint.reflect.ComponentMetadata;
import org.osgi.service.blueprint.reflect.Target;

public interface ComponentDefinitionRegistry  {
    
    /**
     * Determine if the component registry contains a component definition for the given id
     * @param id
     * @return
     */
    boolean containsComponentDefinition(String id);
    
    /**
     * Retrieve a component's metadata by id
     * @param id The id of the component. This is either the id specified in the Blueprint xml or the
     * generated id of an unnamed component
     * @return the <code>ComponentMetadata</code> or <code>null</code> if the id does not match
     * any registered component 
     */
    ComponentMetadata getComponentDefinition(String id);
    
    /**
     * Returns a set of the id of top-level blueprint components (both named and unnamed).
     * 
     * The ids of unnamed components are Blueprint generated. Anonymous components, which have no
     * id, are not part of the set.
     * @return
     */
    Set<String> getComponentDefinitionNames();
    
    /**
     * Register a new component
     * 
     * The <code>ComponentMetadata</code> argument must have an id. So unnamed components should have an id 
     * generated prior to invoking this method. Also, no component definition may already be registered
     * under the same id.
     * 
     * @param component the component to be registered
     * @throws IllegalArgumentException if the component has no id 
     * @throws ComponentNameAlreadyInUseException if there already exists a component definition
     * in the registry with the same id
     */
    void registerComponentDefinition(ComponentMetadata component);
    
    /**
     * Remove the component definition with a given id
     * 
     * If no component is registered under the id, this method is a no-op.
     * @param id the id of the component definition to be removed
     */
    void removeComponentDefinition(String id);

    void registerTypeConverter(Target component);

    List<Target> getTypeConverters();
    
    /**
     * Register an interceptor for a given component
     * 
     * Since the interceptor is registered against a <code>ComponentMetadata</code> instance and not an id,
     * interceptors can be registered for anonymous components as well as named and unnamed components.
     * 
     * Note: Although an interceptor is registered against a specific <code>ComponentMetadata</code> instance,
     * an interceptor should not rely on this fact. This will allow <code>NamespaceHandlers</code> and 
     * <code>ComponentDefinitionRegistryProcessors</code> to respect registered interceptors even when
     * the actual <code>ComponentMetadata</code> instance is changed or augmented. If an interceptor does
     * not support such a scenario it should nevertheless fail gracefully in the case of modified 
     * <code>ComponentMetadata</code> instances.
     * 
     * Note: at the time of this writing (version 0.1) interceptors are only supported for <code>BeanMetadata</code>. 
     * Interceptors registered against other component types will be ignored.
     * 
     * @param component the component the interceptor is to be registered against
     * @param interceptor the interceptor to be used
     */
    void registerInterceptorWithComponent(ComponentMetadata component, Interceptor interceptor);
    
    /**
     * Retrieve all interceptors registered against a <code>ComponentMetadata</code> instance
     * @param component
     * @return a list of interceptors sorted by decreasing rank. The list may be empty if no interceptors have been defined
     */
    List<Interceptor> getInterceptors(ComponentMetadata component);
    
}