Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.infinispan.protostream.impl;
  
 
 import java.util.Map;

Author(s):
anistor@redhat.com
Since:
2.0
 
 public abstract class AnnotatedDescriptorImpl implements AnnotatedDescriptor {
 
    protected final String name;
    protected String fullName;
    protected final String documentation;
    protected Map<StringAnnotationElement.Annotationannotations = null;
    protected Map<StringObjectparsedAnnotations = null;
 
    protected AnnotatedDescriptorImpl(String nameString fullNameString documentation) {
       if (name.indexOf('.') != -1) {
          throw new DescriptorParserException("Definition names should not be qualified : " + name);
       }
       this. = name;
       this. = fullName;
       this. = documentation;
    }
 
    @Override
    public String getName() {
       return ;
    }
 
    @Override
    public String getFullName() {
       return ;
    }
 
    @Override
    public String getDocumentation() {
       return ;
    }
 
    private void processAnnotations() throws AnnotationParserException {
       if ( == null) {
          if ( != null) {
             AnnotationParser parser = new AnnotationParser();
             Map<StringAnnotationElement.Annotation_annotations = parser.parse();
             Map<StringObject_parsedAnnotations = new LinkedHashMap<StringObject>();
             for (AnnotationElement.Annotation annotation : _annotations.values()) {
                AnnotationConfig annotationConfig = getAnnotationConfig(annotation.getName());
                // unknown annotations are ignored
                if (annotationConfig != null) {
                   //todo [anistor] all annotation fields should be required unless they have defaults
                   validateAttributes(annotationannotationConfig);
 
                   // convert single values to arrays if needed and set the default values for missing attributes
                   normalizeValues(annotationannotationConfig);
 
                   if (annotationConfig.annotationMetadataCreator() != null) {
                      _parsedAnnotations.put(annotation.getName(), annotationConfig.annotationMetadataCreator().create(thisannotation));
                   }
                }
             }
              = _annotations;
              = _parsedAnnotations;
          } else {
              = Collections.emptyMap();
              = Collections.emptyMap();
          }
       }
    }
 
    private void validateAttributes(AnnotationElement.Annotation annotationAnnotationConfig<?> annotationConfig) {
       for (Map.Entry<StringAnnotationElement.Attributeentry : annotation.getAttributes().entrySet()) {
          AnnotationElement.Attribute attribute = entry.getValue();
 
          final AnnotationAttributeConfig attributeConfig = annotationConfig.attributes().get(attribute.getName());
          if (attributeConfig == null) {
             throw new AnnotationParserException("Unexpected attribute '" + attribute.getName()
                                                       + "' in annotation '" + annotation.getName() + "' on " + getFullName());
          }
 
          AnnotationElement.Value value = attribute.getValue();
          if (!attributeConfig.multiple() && value instanceof AnnotationElement.Array) {
             throw new AnnotationParserException("Annotation attribute '" + attribute.getName()
                                                       + "' in annotation '" + annotation.getName() + "' on " + getFullName()
                                                       + " does not accept array values");
          }
 
          if (value instanceof AnnotationElement.Array) {
             for (AnnotationElement.Value v : ((AnnotationElement.Arrayvalue).getValues()) {
               validateAttribute(annotationattributeattributeConfigv);
            }
         } else {
            validateAttribute(annotationattributeattributeConfigvalue);
         }
      }
   }
   private void validateAttribute(AnnotationElement.Annotation annotationAnnotationElement.Attribute attributeAnnotationAttributeConfig attributeConfigAnnotationElement.Value value) {
      // validate declared type vs parsed type
      switch (attributeConfig.type()) {
         case :
            if (!(value instanceof AnnotationElement.Identifier)) {
               throw new AnnotationParserException("Value of attribute '" + attribute.getName()
                                                         + "' of annotation '" + annotation.getName()
                                                         + "' on " + getFullName() + " must be an identifier");
            }
            if (attributeConfig.allowedValues() != null && !attributeConfig.allowedValues().contains(value.getValue())) {
               throw new AnnotationParserException("Annotation attribute '" + attribute.getName()
                                                         + "' of annotation '" + annotation.getName()
                                                         + "' on " + getFullName() + " should have one of the values : "
                                                         + attributeConfig.allowedValues());
            }
            break;
         case :
            if (!(value instanceof AnnotationElement.Literal) || !(value.getValue() instanceof String)) {
               throw new AnnotationParserException("Value of attribute '" + attribute.getName()
                                                         + "' of annotation '" + annotation.getName()
                                                         + "' on " + getFullName() + " must be a String");
            }
            if (attributeConfig.allowedValues() != null && !attributeConfig.allowedValues().contains(value.getValue())) {
               throw new AnnotationParserException("Annotation attribute '" + attribute.getName()
                                                         + "' of annotation '" + annotation.getName()
                                                         + "' on " + getFullName() + " should have one of the values : "
                                                         + attributeConfig.allowedValues());
            }
            break;
         case :
            if (!(value instanceof AnnotationElement.Literal) || !(value.getValue() instanceof Character)) {
               throw new AnnotationParserException("Value of attribute '" + attribute.getName()
                                                         + "' of annotation '" + annotation.getName()
                                                         + "' on " + getFullName() + " must be a char");
            }
            break;
         case :
            if (!(value instanceof AnnotationElement.Literal) || !(value.getValue() instanceof Boolean)) {
               throw new AnnotationParserException("Value of attribute '" + attribute.getName()
                                                         + "' of annotation '" + annotation.getName()
                                                         + "' on " + getFullName() + " must be a boolean");
            }
            break;
         case :
            if (!(value instanceof AnnotationElement.Literal) || !(value.getValue() instanceof Integer)) {
               throw new AnnotationParserException("Value of attribute '" + attribute.getName()
                                                         + "' of annotation '" + annotation.getName()
                                                         + "' on " + getFullName() + " must be an int");
            }
            break;
         case :
            if (!(value instanceof AnnotationElement.Literal) || !(value.getValue() instanceof Long)) {
               throw new AnnotationParserException("Value of attribute '" + attribute.getName()
                                                         + "' of annotation '" + annotation.getName()
                                                         + "' on " + getFullName() + " must be a long");
            }
            break;
         case :
            if (!(value instanceof AnnotationElement.Literal) || !(value.getValue() instanceof Float)) {
               throw new AnnotationParserException("Value of attribute '" + attribute.getName()
                                                         + "' of annotation '" + annotation.getName()
                                                         + "' on " + getFullName() + " must be a float");
            }
            break;
         case :
            if (!(value instanceof AnnotationElement.Literal) || !(value.getValue() instanceof Double)) {
               throw new AnnotationParserException("Value of attribute '" + attribute.getName()
                                                         + "' of annotation '" + annotation.getName()
                                                         + "' on " + getFullName() + " must be a double");
            }
            break;
         case :
            if (!(value instanceof AnnotationElement.Annotation)) {
               throw new AnnotationParserException("Value of attribute '" + attribute.getName()
                                                         + "' of annotation '" + annotation.getName()
                                                         + "' on " + getFullName() + " must be an annotation");
            }
      }
   }
   private void normalizeValues(AnnotationElement.Annotation annotationAnnotationConfig<?> annotationConfig) {
      for (AnnotationAttributeConfig attributeConfig : annotationConfig.attributes().values()) {
         AnnotationElement.Attribute attribute = annotation.getAttributes().get(attributeConfig.name());
         if (attribute != null) {
            AnnotationElement.Value value = attribute.getValue();
            if (attributeConfig.multiple() && !(value instanceof AnnotationElement.Array)) {
               // a single value will be automatically wrapped in an array node if the attribute was defined as 'multiple'
               value = new AnnotationElement.Array(value.position, Collections.singletonList(value));
               attribute = new AnnotationElement.Attribute(attribute.positionattributeConfig.name(), value);
               annotation.getAttributes().put(attributeConfig.name(), attribute);
            }
         } else if (attributeConfig.defaultValue() != null) {
            AnnotationElement.Value value = attributeConfig.type() == .. ?
                  new AnnotationElement.Identifier(., (StringattributeConfig.defaultValue()) :
                  new AnnotationElement.Literal(.attributeConfig.defaultValue());
            if (attributeConfig.multiple()) {
               value = new AnnotationElement.Array(value.position, Collections.singletonList(value));
            }
            attribute = new AnnotationElement.Attribute(.attributeConfig.name(), value);
            annotation.getAttributes().put(attributeConfig.name(), attribute);
         } else {
            throw new AnnotationParserException("Attribute '" + attributeConfig.name()
                                                      + "' of annotation '" + annotation.getName()
                                                      + "' on " + getFullName() + " is required");
         }
      }
   }

   
Subclasses are responsible for fetching the AnnotationConfig from the appropriate place.
   protected abstract AnnotationConfig<? extends AnnotatedDescriptorgetAnnotationConfig(String annotationName);
      processAnnotations();
      return ;
   }
   public <T> T getProcessedAnnotation(String annotationNamethrows AnnotationParserException {
      processAnnotations();
      return (T) .get(annotationName);
   }
New to GrepCode? Check out our FAQ X