Returns the elements of this annotation type.
Returns an empty array if there are none.
Elements are always public, so no need to filter them.
171647
public AnnotationTypeElementDoc[] elements() {
        List<AnnotationTypeElementDoc> elements = List.nil();
        for (Scope.Entry e = tsym.members().elems; e != null; e = e.sibling) {
            if (e.sym != null && e.sym.kind == Kinds.MTH) {
                MethodSymbol s = (MethodSymbol)e.sym;
                elements = elements.prepend(env.getAnnotationTypeElementDoc(s));
            }
        }
        return
            elements.toArray(new AnnotationTypeElementDoc[elements.length()]);
    }
56907
def get_element_types(obj, **kwargs):
    """"""

    max_iterable_length = kwargs.get('max_iterable_length', 10000)
    consume_generator = kwargs.get('consume_generator', False)

    if not isiterable(obj):
        return None

    if isgenerator(obj) and not consume_generator:
        return None

    t = get_types(obj, **kwargs)

    if not t['too_big']:
        if t['types']:
            return "Element types: {}".format(', '.join([extract_type(t) for t in t['types']]))
        else:
            return None
    else:
        return "Element types: {}".format(', '.join([extract_type(t) for t in t['types']])) + " (based on first {} elements.)".format(max_iterable_length)
845237
public function getElementTypes()
    {
        $types = array();

        foreach ($this->elements as $key => $element) {
            $types[$key] = get_class($element);
        }

        return $types;
    }
429368
def get_memory_annotations(cls, exclude=None):
        

        result = set()

        # get global dictionary
        annotations_in_memory = Annotation.__ANNOTATIONS_IN_MEMORY__

        exclude = () if exclude is None else exclude

        # iterate on annotation classes
        for annotation_cls in annotations_in_memory:

            # if annotation class is excluded, continue
            if issubclass(annotation_cls, exclude):
                continue

            # if annotation class inherits from self, add it in the result
            if issubclass(annotation_cls, cls):
                result |= annotations_in_memory[annotation_cls]

        return result
662129
public JAnnotation []getDeclaredAnnotations()
  {
    if (_annotations == null) {
      Attribute attr = getAttribute("RuntimeVisibleAnnotations");

      if (attr instanceof OpaqueAttribute) {
        byte []buffer = ((OpaqueAttribute) attr).getValue();

        try {
          ByteArrayInputStream is = new ByteArrayInputStream(buffer);

          ConstantPool cp = _jClass.getConstantPool();

          _annotations = JavaAnnotation.parseAnnotations(is, cp,
                                                         getClassLoader());
        } catch (IOException e) {
          log.log(Level.FINER, e.toString(), e);
        }
      }

      if (_annotations == null) {
        _annotations = new JavaAnnotation[0];
      }
    }

    return _annotations;
  }
509781
public static ImmutableSet<? extends AnnotationMirror> getAnnotatedAnnotations(Element element,
      final Class<? extends Annotation> annotationType) {
    List<? extends AnnotationMirror> annotations = element.getAnnotationMirrors();
    return FluentIterable.from(annotations)
        .filter(new Predicate<AnnotationMirror>() {
          @Override public boolean apply(AnnotationMirror input) {
            return isAnnotationPresent(input.getAnnotationType().asElement(), annotationType);
          }
        })
        .toSet();
  }
1145029
def _elements(self):
        
        if not self.evaluated:
            setattr(self, '_elements_cached', list(self._select()))
        return self._elements_cached
853307
def get_annotations(self):
        
        try:
            obj_list = self.__dict__['annotations']
            return [Annotation(i) for i in obj_list]
        except KeyError:
            self._lazy_load()
            obj_list = self.__dict__['annotations']
            return [Annotation(i) for i in obj_list]
1217552
private Class<?>[] findValidationGroups(Annotation[] annotations) {
        for (Annotation annotation : annotations) {
            if (annotation.annotationType() == Valid.class) {
                return DEFAULT_GROUP_ARRAY;
            } else if (annotation.annotationType() == Validated.class) {
                return  ((Validated) annotation).value();
            }
        }
        return null;
    }
921310
def elementTypeName(self):
        
        if self._array is None:
            return super(ArrayRti, self).elementTypeName
        else:
            dtype =  self._array.dtype
            return '<structured>' if dtype.names else str(dtype)
559956
@SuppressWarnings("rawtypes")
	public Class[] getParamtersTypes() {
		final Class[] types = new Class[this.paramters.length];
		for (int i = 0; i < types.length; i++) {
			types[i] = this.paramters[i].getClass();
		}
		return types;
	}
668693
private Set<TypeMirror> getExcludedAnnotationTypes(Element element) {
    Optional<AnnotationMirror> maybeAnnotation =
        getAnnotationMirror(element, COPY_ANNOTATIONS_NAME);
    if (!maybeAnnotation.isPresent()) {
      return ImmutableSet.of();
    }

    @SuppressWarnings("unchecked")
    List<AnnotationValue> excludedClasses =
        (List<AnnotationValue>) getAnnotationValue(maybeAnnotation.get(), "exclude").getValue();
    return excludedClasses
        .stream()
        .map(annotationValue -> (DeclaredType) annotationValue.getValue())
        .collect(toCollection(TypeMirrorSet::new));
  }
139526
public List<Element> getChildElements() {
		synchronized(lock) {
			if(childElements == null) return Collections.emptyList();
			if(frozen) return childElements;
			return AoCollections.unmodifiableCopyList(childElements);
		}
	}
1235744
public Annotation[][] getAnnotations() {
        Annotation[][] copy = new Annotation[mParameterAnnotations.size()][];
        for (int i=copy.length; --i>=0; ) {
            Vector<Annotation> annotations = mParameterAnnotations.get(i);
            if (annotations == null) {
                copy[i] = new Annotation[0];
            } else {
                copy[i] = annotations.toArray(new Annotation[annotations.size()]);
            }
        }
        return copy;
    }
1105373
public ElementType get() {
        if (empty()) throw new IllegalArgumentException("Empty queue");

        ElementType x = (ElementType) elements[getIdx];
        getIdx = (getIdx + 1) % elements.length;
        size--;
        return x;
    }
850216
public List<List<WF>> getSentences() {
	return (List<List<WF>>)(List<?>) annotationContainer.getSentences(AnnotationType.WF);
    }
1267438
def elementTypeName(self):
        
        fieldName = self.nodeName
        return str(self._ncVar.dtype.fields[fieldName][0])