Title: Feature Overview
Notice:    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.

## Annotated Type Builder

DeltaSpike provides an {{AnnotatedType}} implementation (and corresponding implementations of the suite of Annotated interfaces from CDI) that should be suitable for the needs of most portable extensions. The {{AnnotatedType}} is created from {{AnnotatedTypeBuilder}}, typically in an extension's observer method, as follows:

    Modifying an AnnotatedType
    public class NamingConventionAwareMetadataFilter implements Extension
    {
        public void ensureNamingConvention(@Observes ProcessAnnotatedType processAnnotatedType)
        {
            Class<?> beanClass = processAnnotatedType.getAnnotatedType().getJavaClass();

            Named namedAnnotation = beanClass.getAnnotation(Named.class);
            if(namedAnnotation != null &&
                    namedAnnotation.value().length() > 0 &&
                    Character.isUpperCase(namedAnnotation.value().charAt(0)))
            {
                AnnotatedTypeBuilder builder = new AnnotatedTypeBuilder();
                builder.readFromType(beanClass);

                String beanName = namedAnnotation.value();
                String newBeanName = beanName.substring(0, 1).toLowerCase() + beanName.substring(1);

                builder.removeFromClass(Named.class)
                       .addToClass(new NamedLiteral(newBeanName));

                processAnnotatedType.setAnnotatedType(builder.create());
            }
        }
    }
    //don't forget to configure the extension in /META-INF/services/javax.enterprise.inject.spi.Extension


In the example above we create a new builder, and initialize it using an existing {{AnnotatedType}}. We can then add or remove annotations from the class, and its members. When we have finished modifying the type, we call {{#create()}} to spit out a new, immutable, {{AnnotatedType}}. In the example {{@Named}} gets replaced if the bean-name doesn't start with a lower case character. {{NamedLiteral}} takes the new value which should be used for the new instance of {{@Named}}. That means if a class is annotated e.g. with {{@Named("MyBean")}} it will be replaced with {{@Named("myBean")}} during the bootstrapping process.

AnnotatedTypeBuilder provides the following methods:
  * addToClass
  * addToConstructor
  * addToConstructorParameter
  * addToField
  * addToMethod
  * addToMethodParameter
  * addToParameter
  * overrideConstructorParameterType
  * overrideFieldType
  * overrideMethodParameterType
  * overrideParameterType
  * readFromType
  * removeFromAll
  * removeFromClass
  * removeFromConstructor
  * removeFromConstructorParameter
  * removeFromField
  * removeFromMethod
  * removeFromMethodParameter
  * removeFromParameter
  * getJavaClass
  * setJavaClass
  * create

## AnnotationInstanceProvider

DeltaSpike has the ability, with the AnnotationInstanceProvider class, to dynamically create instances of annotations. These are useful for adding annotations to bean metadata in extensions, adding qualifiers to events, etc. Usage is very simple and straight forward. There are two public methods: {{of(Class<T extends Annotation>)}} and {{of(Class<T extends Annotation>, Map<String, ?>)}}. The first is simply a short cut passing an empty map to the second. The map parameter is a map of values to be used for the members of the annotation. The keys in the map must be the names of members in the annotation (i.e. value, type, etc.). Simple usages are below.

    No Member values
    RequestScoped requestScopedInstance = AnnotationInstanceProvider.of(RequestScoped.class);

    Multiple member values
    Map<String, Object> memberValues = new HashMap<String, Object>();
    memberValues.put("booleanValue", false);
    memberValues.put("booleanValues", new boolean[]{false});
    memberValues.put("byteValue", (byte) 0);
    memberValues.put("byteValues", new byte[]{(byte) 0});
    memberValues.put("type", Object.class);
    memberValues.put("types", new Class[]{Object.class});

    TestAnnotation testAnnotation = AnnotationInstanceProvider.of(TestAnnotation.class, memberValues);


AnnotationInstanceProvider provides an implementation of equals, hashCode and toString compliant with the javadocs for Annotation. It also caches the instances for the duration of the application. Creating a new instance of the same class and same member values will yield the same instance as before.