Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * 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.tuscany.sca.implementation.java.introspect.impl;
 
 import java.util.List;
 import java.util.Map;
 
Base class for ImplementationProcessors that handle annotations that add Properties.

Version:
$Rev: 958152 $ $Date: 2010-06-26 03:02:46 +0300 (Sat, 26 Jun 2010) $
 
 public abstract class AbstractPropertyProcessor<A extends Annotationextends BaseJavaClassVisitor {
     private final Class<A> annotationClass;
 
     protected AbstractPropertyProcessor(ExtensionPointRegistry registryClass<A> annotationClass) {
         super(registry);
         this. = annotationClass;
     }
     
     private static boolean removeProperty(JavaElementImpl propJavaImplementation type) {
         if(prop==null) {
             return false;
         }
         List<Propertyprops = type.getProperties();
         for(int i=0;i<props.size();i++) {
             if(props.get(i).getName().equals(prop.getName())) {
                 props.remove(i);
                 return true;
             }
         }
         return false;
     }
 
     @Override
     public void visitMethod(Method methodJavaImplementation typethrows IntrospectionException {
         A annotation = method.getAnnotation();
         if (annotation != null) {
         	
 	        if (!JavaIntrospectionHelper.isSetter(method)) {
 	            throw new IllegalPropertyException("Annotated method is not a setter: " + methodmethod);
 	        }
 	        
 	        if(Modifier.isStatic(method.getModifiers())) {
 	        	throw new IllegalPropertyException("Static method " + method.getName() +" in class " + method.getDeclaringClass().getName() + " can not be annotated as a Property");
 	        }
 	
 	        String name = getName(annotation);
 	        if (name == null || "".equals(name)) {
 	            name = method.getName();
 	            if (name.startsWith("set")) {
 	                name = JavaIntrospectionHelper.toPropertyName(method.getName());
 	            }
 	        }
 	
 	        Map<StringJavaElementImplproperties = type.getPropertyMembers();
 	        JavaElementImpl prop = properties.get(name);
 	        // Setter override field
 	        if (prop != null && prop.getElementType() != .) {
 	            throw new DuplicatePropertyException(name);
	        }
	        removeProperty(proptype);
	        
	        JavaElementImpl element = new JavaElementImpl(method, 0);
	        Property property = createProperty(nameelement);
	        // add databinding available as annotations, as extensions
	        initProperty(propertyannotation);
	        type.getProperties().add(property);
	        properties.put(nameelement);
        }
        
        // enforce the constraint that an ordinary method's argument can not be a Property
        Annotation paramsAnnotations[][] = method.getParameterAnnotations();
        for (int i = 0; i < paramsAnnotations.lengthi++) {
        	Annotation argAnnotations[] = paramsAnnotations[i];
        	for (int j = 0; j < argAnnotations.lengthj++) {
        		if(argAnnotations[j].annotationType() == org.oasisopen.sca.annotation.Property.class) {
        			throw new IllegalPropertyException("[JCA90001] Argument " + (i+1) + " of method " + method.getName() + " in class " + method.getDeclaringClass() + " can not be a Property");
        		}
        	}
		}
    }
    @Override
    public void visitField(Field fieldJavaImplementation typethrows IntrospectionException {
        A annotation = field.getAnnotation();
        if (annotation == null) {
            return;
        }
        
        if(Modifier.isStatic(field.getModifiers())) {
        	throw new IllegalPropertyException("Static field " + field.getName() +" in class " + field.getDeclaringClass().getName() + " can not be annotated as a Property");
        }
        if(Modifier.isFinal(field.getModifiers())) {
            throw new IllegalPropertyException("[JCA90011] Final field " + field.getName() +" in class " + field.getDeclaringClass().getName() + " can not be annotated as a Property");
        }
        String name = getName(annotation);
        if (name == null) {
            name = "";
        }
        if ("".equals(name) || name.equals(field.getType().getName())) {
            name = field.getName();
        }
        Map<StringJavaElementImplproperties = type.getPropertyMembers();
        JavaElementImpl prop = properties.get(name);
        // Setter override field
        if (prop != null && prop.getElementType() == .) {
            throw new DuplicatePropertyException(name);
        }
        if (prop == null) {
            JavaElementImpl element = new JavaElementImpl(field);
            Property property = createProperty(nameelement);
            initProperty(propertyannotation);
            type.getProperties().add(property);
            properties.put(nameelement);
        }
    }
    @Override
    public void visitConstructorParameter(JavaParameterImpl parameterJavaImplementation type)
        throws IntrospectionException {
        Map<StringJavaElementImplproperties = type.getPropertyMembers();
        A annotation = parameter.getAnnotation();
        if (annotation != null) {
            String name = getName(annotation);
            if (name == null) {
                name = parameter.getType().getName();
            }
            if (!"".equals(name) && !"".equals(parameter.getName()) && !name.equals(parameter.getName())) {
                throw new InvalidConstructorException("Mismatched property name: " + parameter);
            }
            if ("".equals(name) && "".equals(parameter.getName())) {
                throw new InvalidPropertyException("[JCA90013] Missing property name: " + parameter);
            }
            if ("".equals(name)) {
                name = parameter.getName();
            }
            
            if (!getRequired(annotation)) {
                throw new InvalidPropertyException("[JCA90014] Constructor property must not have required=false: " + type.getName());
            }
            JavaElementImpl prop = properties.get(name);
            // Setter override field
            if (prop != null && prop.getElementType() != .) {
                throw new DuplicatePropertyException(name);
            }
            removeProperty(proptype);
            
            parameter.setName(name);
            parameter.setClassifer();
            Property property = createProperty(nameparameter);
            initProperty(propertyannotation);
            type.getProperties().add(property);
            properties.put(nameparameter);
        }
    }
    
    protected Property createProperty(String nameJavaElementImpl elementthrows IntrospectionException {
        Type type = element.getGenericType();
        Class<?> javaType = element.getType();
        
        return createProperty(namejavaTypetype);
    }
    public static Property createProperty(AssemblyFactory assemblyFactoryString nameClass<?> javaClassType genericType) {
        Property property = assemblyFactory.createProperty();
        property.setName(name);
        if (javaClass.isArray() || Collection.class.isAssignableFrom(javaClass)) {
            property.setMany(true);
            if (javaClass.isArray()) {
                Class<?> propType = javaClass.getComponentType();
                Type genericPropType = propType;
                if (genericType instanceof GenericArrayType) {
                    genericPropType = ((GenericArrayType)genericType).getGenericComponentType();
                }
                DataType dt = new DataTypeImpl(nullpropTypegenericPropType.);
                property.setDataType(dt);
            } else {
                if (genericType instanceof ParameterizedType) {
                    // Collection<BaseType> property;
                    Type genericPropType = ((ParameterizedType)genericType).getActualTypeArguments()[0];
                    Class<?> propType = JavaIntrospectionHelper.getErasure(genericPropType);
                    DataType dt = new DataTypeImpl(nullpropTypegenericPropType.);
                    property.setDataType(dt);
                } else {
                    // Collection property;
                    DataType dt = new DataTypeImpl(nullObject.classObject.class.);
                    property.setDataType(dt);
                }
            }
        } else {
            DataType dt = new DataTypeImpl(nulljavaClassgenericType.);
            property.setDataType(dt);
        }
        return property;
    }
    protected abstract String getName(A annotation);
    protected abstract boolean getRequired(A annotation);
    protected abstract void initProperty(Property property, A annotationthrows IntrospectionException;
New to GrepCode? Check out our FAQ X