Gets the persistent attribute type.

@param member
the member
@return the persistent attribute type
493468
static PersistentAttributeType getPersistentAttributeType(Field member)
    {
        PersistentAttributeType attributeType = PersistentAttributeType.BASIC;
        if (member.isAnnotationPresent(ElementCollection.class))
        {
            attributeType = PersistentAttributeType.ELEMENT_COLLECTION;
        }
        else if (member.isAnnotationPresent(OneToMany.class))
        {
            attributeType = PersistentAttributeType.ONE_TO_MANY;
        }
        else if (member.isAnnotationPresent(ManyToMany.class))
        {
            attributeType = PersistentAttributeType.MANY_TO_MANY;
        }
        else if (member.isAnnotationPresent(ManyToOne.class))
        {
            attributeType = PersistentAttributeType.MANY_TO_ONE;
        }
        else if (member.isAnnotationPresent(OneToOne.class))
        {
            attributeType = PersistentAttributeType.ONE_TO_ONE;
        }
        else if (member.isAnnotationPresent(Embedded.class))
        {
            attributeType = PersistentAttributeType.EMBEDDED;
        }

        return attributeType;

    }
124877
public @Nonnull final <T extends Annotation> Optional<AnnotationValue<T>> getAnnotation(String member, Class<T> type) {
        return getAnnotations(member, type).stream().findFirst();
    }
130686
public DataType getAttributeType(int index) {
        final VertexAttribute attribute = getAttribute(index);
        if (attribute == null) {
            return null;
        }
        return attribute.getType();
    }
339042
@SuppressWarnings( "unchecked" )
    protected MethodMetadata getMethodTypeMemberMetadataFrom( MethodDeclaration methodDeclaration ) {
        MethodMetadata methodTypeMemberMetadata = MethodMetadata.methodMemberType(JavaMetadataUtil.getName(methodDeclaration.getName()));
        processReturnTypeOfMethodDeclaration(methodDeclaration, methodTypeMemberMetadata);
        processModifiersOfMethodDeclaration(methodDeclaration, methodTypeMemberMetadata);
        processParametersOfMethodDeclaration(methodDeclaration, methodTypeMemberMetadata);
        List<SingleVariableDeclaration> params = methodDeclaration.parameters();
        for (SingleVariableDeclaration singleVariableDeclaration : params) {
            singleVariableDeclaration.getName();
        }
        return methodTypeMemberMetadata;
    }
1312721
protected Class<?> getValueType(AnnotatedElement element) {
        if (element instanceof Field) {
            return ((Field) element).getType();
        }
        if (element instanceof Method) {
            return ((Method) element).getReturnType();
        }
        throw new PropertyLoaderException("Could not get element type");
    }
1160196
static Stream<Attribute> getJunctionTableAttributes(EntityType entityType) {
    // return all attributes referencing multiple entities except for one-to-many attributes that
    // are mapped by
    // another attribute
    return getPersistedAttributes(entityType)
        .filter(
            attr ->
                isMultipleReferenceType(attr)
                    && !(attr.getDataType() == ONE_TO_MANY && attr.isMappedBy()));
  }
749802
public Attribute getTypeAttribute()
    {
        final Attribute ret;
        if (this.typeAttributeName == null && getParentType() != null) {
            ret = getParentType().getTypeAttribute();
        } else {
            ret = this.attributes.get(this.typeAttributeName);
        }
        return ret;
    }
180529
protected Content getTypeParameters(ExecutableMemberDoc member) {
        LinkInfoImpl linkInfo = new LinkInfoImpl(configuration,
            LinkInfoImpl.Kind.MEMBER_TYPE_PARAMS, member);
        return writer.getTypeParameterLinks(linkInfo);
    }
1358674
public TypeDescription getType() {
        if (mType == null) {
            mType = getTeaToolsUtils().createTypeDescription(
                       getPropertyDescriptor().getPropertyType());
        }

        return mType;
    }
1292271
function (member) {
            member = _gpfEncodeAttributeMember(member);
            var result = this._members[member];
            if (undefined === result || !(result instanceof _gpfA.Array)) {
                return _gpfEmptyMemberArray;
            }
            return result;
        }
763112
Node getMembershipTypeStorageNode(Session session) throws PathNotFoundException, RepositoryException
   {
      return (Node)session.getItem(service.getStoragePath() + "/"
         + JCROrganizationServiceImpl.STORAGE_JOS_MEMBERSHIP_TYPES);
   }
1120209
public List<MemberState> getRemoteMemberStates(Member.Type type) {
    List<MemberState> members = memberTypes.get(type);
    return members != null ? members : Collections.EMPTY_LIST;
  }
1204779
public static AttributeDefinition[] getValueTypes(Object instance, Class clazz) {
    try {
      if (ObjectTypeAttributeDefinition.class.isAssignableFrom(clazz)) {
        Field valueTypesField = clazz.getDeclaredField("valueTypes");
        valueTypesField.setAccessible(true);
        Object value = valueTypesField.get(instance);
        if (value != null) {
          if (AttributeDefinition[].class.isAssignableFrom(value.getClass())) {
            return (AttributeDefinition[]) value;
          }
        }
        return (AttributeDefinition[]) value;
      }
    } catch (Exception e) {
      throw new RuntimeException("Unable to get valueTypes.", e);
    }

    return null;
  }
400279
public Map<String, DesignDocument.View> generateViewsFromPersistentType(
			final Class<?> persistentType) {
		Assert.notNull(persistentType, "persistentType may not be null");
		final Map<String, DesignDocument.View> views = new HashMap<String, DesignDocument.View>();

		createDeclaredViews(views, persistentType);

		eachField(persistentType, new Predicate<Field>() {
			public boolean apply(Field input) {
				if (hasAnnotation(input, DocumentReferences.class)) {
					generateView(views, input);
				}
				return false;
			}
		});
		return views;
	}
942121
public int getTypeAnnotation() {
        int type = 0;
        if (nodeKind == ATTRIBUTE) {
            type = StandardNames.XS_UNTYPED_ATOMIC;
        } else {
            type = StandardNames.XS_UNTYPED;
        }
        return type;
    }
391345
final String getSerialVersionUID(TypeElement type) {
    TypeMirror serializable = elementUtils().getTypeElement(Serializable.class.getName()).asType();
    if (typeUtils().isAssignable(type.asType(), serializable)) {
      List<VariableElement> fields = ElementFilter.fieldsIn(type.getEnclosedElements());
      for (VariableElement field : fields) {
        if (field.getSimpleName().contentEquals("serialVersionUID")) {
          Object value = field.getConstantValue();
          if (field.getModifiers().containsAll(Arrays.asList(Modifier.STATIC, Modifier.FINAL))
              && field.asType().getKind() == TypeKind.LONG
              && value != null) {
            return value + "L";
          } else {
            errorReporter.reportError(
                "serialVersionUID must be a static final long compile-time constant", field);
            break;
          }
        }
      }
    }
    return "";
  }
905135
protected String modifierString(MemberDoc member) {
        int ms = member.modifierSpecifier();
        int no = Modifier.NATIVE | Modifier.SYNCHRONIZED;
    return Modifier.toString(ms & ~no);
    }