/**
* *****************************************************************************
* 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.olingo.odata2.annotation.processor.core.util;
import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
import org.apache.olingo.odata2.api.annotation.edm.EdmComplexType;
import org.apache.olingo.odata2.api.annotation.edm.EdmEntitySet;
import org.apache.olingo.odata2.api.annotation.edm.EdmEntityType;
import org.apache.olingo.odata2.api.annotation.edm.EdmKey;
import org.apache.olingo.odata2.api.annotation.edm.EdmNavigationProperty;
import org.apache.olingo.odata2.api.annotation.edm.EdmNavigationProperty.Multiplicity;
import org.apache.olingo.odata2.api.annotation.edm.EdmProperty;
import org.apache.olingo.odata2.api.edm.EdmLiteralKind;
import org.apache.olingo.odata2.api.edm.EdmMultiplicity;
import org.apache.olingo.odata2.api.edm.EdmSimpleTypeException;
import org.apache.olingo.odata2.api.edm.EdmSimpleTypeKind;
import org.apache.olingo.odata2.api.edm.FullQualifiedName;
import org.apache.olingo.odata2.api.exception.ODataException;
/**
*
*/
public class AnnotationHelper {
public static final String DEFAULT_CONTAINER_NAME = "DefaultContainer";
/**
* Compare keys of both instances.
*
* @param firstInstance
* @param secondInstance
* @return
*/
public boolean keyMatch(final Object firstInstance, final Object secondInstance) {
if (firstInstance == null || secondInstance == null) {
return false;
} else if (firstInstance.getClass() != secondInstance.getClass()) {
return false;
}
Map<String, Object> firstKeyFields = getValueForAnnotatedFields(firstInstance, EdmKey.class);
Map<String, Object> secondKeyFields = getValueForAnnotatedFields(secondInstance, EdmKey.class);
if (firstKeyFields.isEmpty() && secondKeyFields.isEmpty()) {
throw new AnnotationRuntimeException("Both object instances does not have EdmKey fields defined ["
+ "firstClass=" + firstInstance.getClass().getName()
+ " secondClass=" + secondInstance.getClass().getName() + "].");
}
return keyValuesMatch(firstKeyFields, secondKeyFields);
}
/**
* Compare keys of instance with key values in map.
*
* @param instance
* @param keyName2Value
* @return
*/
public boolean keyMatch(final Object instance, final Map<String, Object> keyName2Value) {
Map<String, Object> instanceKeyFields = getValueForAnnotatedFields(instance, EdmKey.class);
return keyValuesMatch(instanceKeyFields, keyName2Value);
}
private boolean keyValuesMatch(final Map<String, Object> firstKeyValues, final Map<String, Object> secondKeyValues) {
if (firstKeyValues.size() != secondKeyValues.size()) {
return false;
} else if (firstKeyValues.isEmpty()) {
throw new AnnotationRuntimeException("No keys given for key value matching.");
} else {
Set<Map.Entry<String, Object>> entries = firstKeyValues.entrySet();
for (Map.Entry<String, Object> entry : entries) {
Object firstKey = entry.getValue();
Object secondKey = secondKeyValues.get(entry.getKey());
if (!isEqual(firstKey, secondKey)) {
return false;
}
}
return true;
}
}
private boolean isEqual(final Object firstKey, final Object secondKey) {
if (firstKey == null) {
return secondKey == null || secondKey.equals(firstKey);
} else {
return firstKey.equals(secondKey);
}
}
public String extractEntityTypeName(final EdmNavigationProperty enp, final Class<?> fallbackClass) {
Class<?> entityTypeClass = enp.toType();
return extractEntityTypeName(entityTypeClass == Object.class ? fallbackClass : entityTypeClass);
}
public String extractEntityTypeName(final EdmNavigationProperty enp, final Field field) {
Class<?> entityTypeClass = enp.toType();
if (entityTypeClass == Object.class) {
Class<?> toClass = field.getType();
return extractEntityTypeName((toClass.isArray() || Collection.class.isAssignableFrom(toClass) ?
(Class<?>) ((ParameterizedType) field.getGenericType()).getActualTypeArguments()[0] : toClass));
} else {
return extractEntityTypeName(entityTypeClass);
}
}
/**
* Returns <code>NULL</code> if given class is not annotated. If annotated the set entity type name is returned and if
* no name is set the default name is generated from the simple class name.
*
* @param annotatedClass
* @return
*/
public String extractEntityTypeName(final Class<?> annotatedClass) {
return extractTypeName(annotatedClass, EdmEntityType.class);
}
/**
* Returns <code>NULL</code> if given class is not annotated.
* If annotated the entity set name is returned and if
* no name is set a default name is generated based on the simple class name.
*
* @param annotatedClass
* @return
*/
public String extractEntitySetName(final Class<?> annotatedClass) {
if (annotatedClass == Object.class) {
return null;
}
EdmEntitySet entitySet = annotatedClass.getAnnotation(EdmEntitySet.class);
if (entitySet == null) {
return null;
}
String name = entitySet.name();
if (name.isEmpty()) {
return getCanonicalName(annotatedClass) + "Set";
}
return name;
}
public FullQualifiedName extractEntityTypeFqn(final EdmEntityType type, final Class<?> annotatedClass) {
if (type.namespace().isEmpty()) {
return new FullQualifiedName(generateNamespace(annotatedClass), extractEntityTypeName(annotatedClass));
}
return new FullQualifiedName(type.namespace(), extractEntityTypeName(annotatedClass));
}
public FullQualifiedName extractEntityTypeFqn(final Class<?> annotatedClass) {
EdmEntityType type = annotatedClass.getAnnotation(EdmEntityType.class);
if (type == null) {
return null;
}
return extractEntityTypeFqn(type, annotatedClass);
}
public FullQualifiedName extractComplexTypeFqn(final Class<?> annotatedClass) {
EdmComplexType type = annotatedClass.getAnnotation(EdmComplexType.class);
if (type == null) {
return null;
}
return extractComplexTypeFqn(type, annotatedClass);
}
public FullQualifiedName extractComplexTypeFqn(final EdmComplexType type, final Class<?> annotatedClass) {
if (type.namespace().isEmpty()) {
return new FullQualifiedName(generateNamespace(annotatedClass), extractComplexTypeName(annotatedClass));
}
return new FullQualifiedName(type.namespace(), extractComplexTypeName(annotatedClass));
}
public String extractComplexTypeName(final Class<?> annotatedClass) {
return extractTypeName(annotatedClass, EdmComplexType.class);
}
public String generateNamespace(final Class<?> annotatedClass) {
return annotatedClass.getPackage().getName();
}
/**
*
*
* @param <T> must be EdmEntityType or EdmComplexType annotation
* @param annotatedClass
* @param typeAnnotation
* @return null if annotatedClass is not annotated or name set via annotation or generated via
* {@link #getCanonicalName(java.lang.Class)}
*/
private <T extends Annotation> String extractTypeName(final Class<?> annotatedClass, final Class<T> typeAnnotation) {
if (annotatedClass == Object.class) {
return null;
}
T type = annotatedClass.getAnnotation(typeAnnotation);
if (type == null) {
return null;
}
String name;
if (typeAnnotation == EdmEntityType.class) {
name = ((EdmEntityType) type).name();
} else if (typeAnnotation == EdmComplexType.class) {
name = ((EdmComplexType) type).name();
} else {
return null;
}
if (name.isEmpty()) {
return getCanonicalName(annotatedClass);
}
return name;
}
/**
* Get the set property name from an EdmProperty or EdmNavigationProperty annotation.
*
* @param field
* @return
*/
public String getPropertyNameFromAnnotation(final Field field) {
EdmProperty property = field.getAnnotation(EdmProperty.class);
if (property == null) {
EdmNavigationProperty navProperty = field.getAnnotation(EdmNavigationProperty.class);
if (navProperty == null) {
throw new EdmAnnotationException("Given field '" + field
+ "' has no EdmProperty or EdmNavigationProperty annotation.");
}
return navProperty.name();
}
return property.name();
}
public String getPropertyName(final Field field) {
String propertyName = getPropertyNameFromAnnotation(field);
if (propertyName.isEmpty()) {
propertyName = getCanonicalName(field);
}
return propertyName;
}
public String extractToRoleName(final EdmNavigationProperty enp, final Field field) {
String role = enp.toRole();
if (role.isEmpty()) {
role = getCanonicalRoleName(field.getName());
}
return role;
}
public String extractFromRoleEntityName(final Field field) {
return extractEntityTypeName(field.getDeclaringClass());
}
public String extractToRoleEntityName(final EdmNavigationProperty enp, final Field field) {
Class<?> clazz = enp.toType();
if (clazz == Object.class) {
if(field.getType().isArray() || Collection.class.isAssignableFrom(field.getType())) {
clazz = (Class<?>) ((ParameterizedType) field.getGenericType()).getActualTypeArguments()[0];
} else {
clazz = field.getType();
}
}
return extractEntityTypeName(clazz);
}
public String getCanonicalRoleName(String name) {
return "r_" + name.substring(0, 1).toUpperCase(Locale.ENGLISH) + name.substring(1);
}
public String extractRelationshipName(final EdmNavigationProperty enp, final Field field) {
String relationshipName = enp.association();
if (relationshipName.isEmpty()) {
final String fromRole = extractFromRoleEntityName(field);
final String toRole = extractToRoleEntityName(enp, field);
return createCanonicalRelationshipName(fromRole, toRole);
}
return relationshipName;
}
public String createCanonicalRelationshipName(String fromRole, String toRole) {
if (fromRole.compareTo(toRole) > 0) {
return toRole + "_2_" + fromRole;
} else {
return fromRole + "_2_" + toRole;
}
}
public EdmMultiplicity extractMultiplicity(final EdmNavigationProperty enp, final Field field) {
EdmMultiplicity multiplicity = mapMultiplicity(enp.toMultiplicity());
final boolean isCollectionType = field.getType().isArray() || Collection.class.isAssignableFrom(field.getType());
if (multiplicity == EdmMultiplicity.ONE && isCollectionType) {
return EdmMultiplicity.MANY;
}
return multiplicity;
}
/**
* Set key fields based on values in map.
* If an key field is not available or <code>NULL</code> in the map
* it will be not set as <code>NULL</code> at the instance object.
*
* @param instance
* @param keys
* @return
*/
public <T> T setKeyFields(final T instance, final Map<String, Object> keys) {
List<Field> fields = getAnnotatedFields(instance, EdmKey.class);
for (Field field : fields) {
String propertyName = getPropertyName(field);
Object keyValue = keys.get(propertyName);
setValueForProperty(instance, propertyName, keyValue);
}
return instance;
}
public static final class ODataAnnotationException extends ODataException {
private static final long serialVersionUID = 42L;
public ODataAnnotationException(final String message) {
super(message);
}
public ODataAnnotationException(final String message, final Exception cause) {
super(message, cause);
}
}
public class AnnotatedNavInfo {
private final Field fromField;
private final Field toField;
private final EdmNavigationProperty fromNavigation;
private final EdmNavigationProperty toNavigation;
public AnnotatedNavInfo(final Field fromField, final Field toField, final EdmNavigationProperty fromNavigation,
final EdmNavigationProperty toNavigation) {
this.fromField = fromField;
this.toField = toField;
this.fromNavigation = fromNavigation;
this.toNavigation = toNavigation;
}
public Field getFromField() {
return fromField;
}
public String getFromRoleName() {
if(isBiDirectional()) {
return extractFromRoleEntityName(toField);
}
return extractToRoleName(toNavigation, toField);
}
public Field getToField() {
return toField;
}
public String getToRoleName() {
if(isBiDirectional()) {
return extractToRoleName(toNavigation, toField);
}
return extractToRoleName(fromNavigation, fromField);
}
public EdmMultiplicity getFromMultiplicity() {
if(isBiDirectional()) {
return EdmMultiplicity.ONE;
}
return extractMultiplicity(toNavigation, toField);
}
public EdmMultiplicity getToMultiplicity() {
if(isBiDirectional()) {
return extractMultiplicity(toNavigation, toField);
}
return extractMultiplicity(fromNavigation, fromField);
}
public boolean isBiDirectional() {
return fromNavigation == null;
}
public String getRelationshipName() {
String toAssociation = toNavigation.association();
String fromAssociation = "";
if(!isBiDirectional()) {
fromAssociation = fromNavigation.association();
}
if(fromAssociation.isEmpty() && fromAssociation.equals(toAssociation)) {
return createCanonicalRelationshipName(getFromRoleName(), getToRoleName());
} else if(toAssociation.isEmpty()) {
return fromAssociation;
} else if(!toAssociation.equals(fromAssociation)) {
throw new AnnotationRuntimeException("Invalid associations for navigation properties '" +
this.toString() + "'");
}
return toAssociation;
}
public String getFromTypeName() {
if(isBiDirectional()) {
return extractEntityTypeName(toField.getDeclaringClass());
}
return extractEntityTypeName(fromField.getDeclaringClass());
}
public String getToTypeName() {
if(isBiDirectional()) {
return extractEntityTypeName(ClassHelper.getFieldType(toField));
}
return extractEntityTypeName(toField.getDeclaringClass());
}
@Override
public String toString() {
if(isBiDirectional()) {
return "AnnotatedNavInfo{biDirectional = true" +
", toField=" + toField.getName() +
", toNavigation=" + toNavigation.name() + '}';
}
return "AnnotatedNavInfo{" +
"fromField=" + fromField.getName() +
", toField=" + toField.getName() +
", fromNavigation=" + fromNavigation.name() +
", toNavigation=" + toNavigation.name() + '}';
}
}
public AnnotatedNavInfo getCommonNavigationInfo(final Class<?> sourceClass, final Class<?> targetClass) {
List<Field> sourceFields = getAnnotatedFields(sourceClass, EdmNavigationProperty.class);
List<Field> targetFields = getAnnotatedFields(targetClass, EdmNavigationProperty.class);
if(sourceClass == targetClass) {
// special case, actual handled as bi-directional
return getCommonNavigationInfoBiDirectional(sourceClass, targetClass);
}
// first try via association name to get full navigation information
for (Field sourceField : sourceFields) {
if(ClassHelper.getFieldType(sourceField) == targetClass) {
final EdmNavigationProperty sourceNav = sourceField.getAnnotation(EdmNavigationProperty.class);
final String sourceAssociation = extractRelationshipName(sourceNav, sourceField);
for (Field targetField : targetFields) {
if(ClassHelper.getFieldType(targetField) == sourceClass) {
final EdmNavigationProperty targetNav = targetField.getAnnotation(EdmNavigationProperty.class);
final String targetAssociation = extractRelationshipName(targetNav, targetField);
if (sourceAssociation.equals(targetAssociation)) {
return new AnnotatedNavInfo(sourceField, targetField, sourceNav, targetNav);
}
}
}
}
}
// if nothing was found assume/guess none bi-directional navigation
return getCommonNavigationInfoBiDirectional(sourceClass, targetClass);
}
private AnnotatedNavInfo getCommonNavigationInfoBiDirectional(final Class<?> sourceClass,
final Class<?> targetClass) {
List<Field> sourceFields = getAnnotatedFields(sourceClass, EdmNavigationProperty.class);
String targetEntityTypeName = extractEntityTypeName(targetClass);
for (Field sourceField : sourceFields) {
final EdmNavigationProperty sourceNav = sourceField.getAnnotation(EdmNavigationProperty.class);
final String navTargetEntityName = extractEntityTypeName(sourceNav, sourceField);
if (navTargetEntityName.equals(targetEntityTypeName)) {
return new AnnotatedNavInfo(null, sourceField, null, sourceNav);
}
}
return null;
}
public Class<?> getFieldTypeForProperty(final Class<?> clazz, final String propertyName)
throws ODataAnnotationException {
if (clazz == null) {
return null;
}
Field field = getFieldForPropertyName(propertyName, clazz, true);
if (field == null) {
throw new ODataAnnotationException("No field for property '" + propertyName
+ "' found at class '" + clazz + "'.");
}
return field.getType();
}
public Class<?> getFieldTypeForProperty(final Object instance, final String propertyName)
throws ODataAnnotationException {
if (instance == null) {
return null;
}
return getFieldTypeForProperty(instance.getClass(), propertyName);
}
public Object getValueForProperty(final Object instance, final String propertyName) throws ODataAnnotationException {
if (instance == null) {
return null;
}
Field field = getFieldForPropertyName(propertyName, instance.getClass(), true);
if (field == null) {
throw new ODataAnnotationException("No field for property '" + propertyName
+ "' found at class '" + instance.getClass() + "'.");
}
return getFieldValue(instance, field);
}
public void setValueForProperty(final Object instance, final String propertyName, final Object propertyValue) {
if (instance != null) {
Field field = getFieldForPropertyName(propertyName, instance.getClass(), true);
if (field != null) {
setFieldValue(instance, field, propertyValue);
}
}
}
private Field getFieldForPropertyName(final String propertyName,
final Class<?> resultClass, final boolean inherited) {
Field[] fields = resultClass.getDeclaredFields();
for (Field field : fields) {
EdmProperty property = field.getAnnotation(EdmProperty.class);
if (property != null) {
if (property.name().isEmpty() && getCanonicalName(field).equals(propertyName)) {
return field;
} else if (property.name().equals(propertyName)) {
return field;
}
}
}
Class<?> superClass = resultClass.getSuperclass();
if (inherited && superClass != Object.class) {
return getFieldForPropertyName(propertyName, superClass, true);
}
return null;
}
public Object getValueForField(final Object instance, final String fieldName,
final Class<? extends Annotation> annotation) {
if (instance == null) {
return null;
}
return getValueForField(instance, fieldName, instance.getClass(), annotation, true);
}
public Object getValueForField(final Object instance, final Class<? extends Annotation> annotation) {
if (instance == null) {
return null;
}
return getValueForField(instance, instance.getClass(), annotation, true);
}
private Object getValueForField(final Object instance, final Class<?> resultClass,
final Class<? extends Annotation> annotation, final boolean inherited) {
return getValueForField(instance, null, resultClass, annotation, inherited);
}
public Map<String, Object> getValueForAnnotatedFields(final Object instance,
final Class<? extends Annotation> annotation) {
return getValueForAnnotatedFields(instance, instance.getClass(), annotation, true);
}
private Map<String, Object> getValueForAnnotatedFields(final Object instance, final Class<?> resultClass,
final Class<? extends Annotation> annotation, final boolean inherited) {
if (instance == null) {
return null;
}
Field[] fields = resultClass.getDeclaredFields();
Map<String, Object> fieldName2Value = new HashMap<String, Object>();
for (Field field : fields) {
if (field.getAnnotation(annotation) != null) {
Object value = getFieldValue(instance, field);
final String name = extractPropertyName(field);
fieldName2Value.put(name, value);
}
}
Class<?> superClass = resultClass.getSuperclass();
if (inherited && superClass != Object.class) {
Map<String, Object> tmp = getValueForAnnotatedFields(instance, superClass, annotation, true);
fieldName2Value.putAll(tmp);
}
return fieldName2Value;
}
private String extractPropertyName(final Field field) {
final EdmProperty property = field.getAnnotation(EdmProperty.class);
if (property == null || property.name().isEmpty()) {
return getCanonicalName(field);
} else {
return property.name();
}
}
public void setValueForAnnotatedField(final Object instance, final Class<? extends Annotation> annotation,
final Object value)
throws ODataAnnotationException {
List<Field> fields = getAnnotatedFields(instance, annotation);
if (fields.isEmpty()) {
throw new ODataAnnotationException("No field found for annotation '" + annotation
+ "' on instance '" + instance + "'.");
} else if (fields.size() > 1) {
throw new ODataAnnotationException("More then one field found for annotation '" + annotation
+ "' on instance '" + instance + "'.");
}
setFieldValue(instance, fields.get(0), value);
}
public void setValuesToAnnotatedFields(final Object instance,
final Class<? extends Annotation> annotation, final Map<String, Object> fieldName2Value) {
List<Field> fields = getAnnotatedFields(instance, annotation);
// XXX: refactore
for (Field field : fields) {
final String canonicalName = getCanonicalName(field);
if (fieldName2Value.containsKey(canonicalName)) {
Object value = fieldName2Value.get(canonicalName);
setFieldValue(instance, field, value);
}
}
}
public List<Field> getAnnotatedFields(final Object instance, final Class<? extends Annotation> annotation) {
if (instance == null) {
return null;
}
return getAnnotatedFields(instance.getClass(), annotation, true);
}
public List<Field> getAnnotatedFields(final Class<?> fieldClass, final Class<? extends Annotation> annotation) {
return getAnnotatedFields(fieldClass, annotation, true);
}
/**
*
* @param resultClass
* @param annotation
* @param inherited
* @return
*/
private List<Field> getAnnotatedFields(final Class<?> resultClass,
final Class<? extends Annotation> annotation, final boolean inherited) {
if (resultClass == null) {
return null;
}
Field[] fields = resultClass.getDeclaredFields();
List<Field> annotatedFields = new ArrayList<Field>();
for (Field field : fields) {
if (field.getAnnotation(annotation) != null) {
annotatedFields.add(field);
}
}
Class<?> superClass = resultClass.getSuperclass();
if (inherited && superClass != Object.class) {
List<Field> tmp = getAnnotatedFields(superClass, annotation, true);
annotatedFields.addAll(tmp);
}
return annotatedFields;
}
private Object getValueForField(final Object instance, final String fieldName, final Class<?> resultClass,
final Class<? extends Annotation> annotation, final boolean inherited) {
if (instance == null) {
return null;
}
Field[] fields = resultClass.getDeclaredFields();
for (Field field : fields) {
if (field.getAnnotation(annotation) != null
&& (fieldName == null || field.getName().equals(fieldName))) {
return getFieldValue(instance, field);
}
}
Class<?> superClass = resultClass.getSuperclass();
if (inherited && superClass != Object.class) {
return getValueForField(instance, fieldName, superClass, annotation, true);
}
return null;
}
private Object getFieldValue(final Object instance, final Field field) {
try {
boolean access = field.isAccessible();
field.setAccessible(true);
Object value = field.get(instance);
field.setAccessible(access);
return value;
} catch (IllegalArgumentException ex) { // should never happen
throw new AnnotationRuntimeException(ex);
} catch (IllegalAccessException ex) { // should never happen
throw new AnnotationRuntimeException(ex);
}
}
private void setFieldValue(final Object instance, final Field field, final Object value) {
try {
Object usedValue = value;
if (value != null
&& field.getType() != value.getClass()
&& value.getClass() == String.class) {
usedValue = convert(field, (String) value);
}
boolean access = field.isAccessible();
field.setAccessible(true);
field.set(instance, usedValue);
field.setAccessible(access);
} catch (IllegalArgumentException ex) { // should never happen
throw new AnnotationRuntimeException(ex);
} catch (IllegalAccessException ex) { // should never happen
throw new AnnotationRuntimeException(ex);
}
}
private Object convert(final Field field, final String propertyValue) {
Class<?> fieldClass = field.getType();
try {
EdmProperty property = field.getAnnotation(EdmProperty.class);
EdmSimpleTypeKind type = mapTypeKind(property.type());
return type.getEdmSimpleTypeInstance().valueOfString(propertyValue,
EdmLiteralKind.DEFAULT, null, fieldClass);
} catch (EdmSimpleTypeException ex) {
throw new AnnotationRuntimeException("Conversion failed for string property ["
+ propertyValue + "] on field ["
+ field + "] with error: " + ex.getMessage(), ex);
}
}
public boolean isEdmAnnotated(final Object object) {
if (object == null) {
return false;
}
return isEdmAnnotated(object.getClass());
}
public boolean isEdmTypeAnnotated(final Class<?> clazz) {
boolean isComplexEntity = clazz.getAnnotation(EdmComplexType.class) != null;
boolean isEntity = clazz.getAnnotation(EdmEntityType.class) != null;
return isComplexEntity || isEntity;
}
public boolean isEdmAnnotated(final Class<?> clazz) {
if (clazz == null) {
return false;
} else {
final boolean isEntity = null != clazz.getAnnotation(EdmEntityType.class);
final boolean isEntitySet = null != clazz.getAnnotation(EdmEntitySet.class);
final boolean isComplexEntity = null != clazz.getAnnotation(EdmComplexType.class);
return isEntity || isComplexEntity || isEntitySet;
}
}
public String getCanonicalName(final Field field) {
return firstCharToUpperCase(field.getName());
}
public String getCanonicalName(final Class<?> clazz) {
return firstCharToUpperCase(clazz.getSimpleName());
}
private String firstCharToUpperCase(final String content) {
if (content == null || content.isEmpty()) {
return content;
}
return content.substring(0, 1).toUpperCase(Locale.ENGLISH) + content.substring(1);
}
public EdmSimpleTypeKind mapTypeKind(final org.apache.olingo.odata2.api.annotation.edm.EdmType type) {
switch (type) {
case BINARY:
return EdmSimpleTypeKind.Binary;
case BOOLEAN:
return EdmSimpleTypeKind.Boolean;
case BYTE:
return EdmSimpleTypeKind.Byte;
case COMPLEX:
return EdmSimpleTypeKind.Null;
case DATE_TIME:
return EdmSimpleTypeKind.DateTime;
case DATE_TIME_OFFSET:
return EdmSimpleTypeKind.DateTimeOffset;
case DECIMAL:
return EdmSimpleTypeKind.Decimal;
case DOUBLE:
return EdmSimpleTypeKind.Double;
case GUID:
return EdmSimpleTypeKind.Guid;
case INT16:
return EdmSimpleTypeKind.Int16;
case INT32:
return EdmSimpleTypeKind.Int32;
case INT64:
return EdmSimpleTypeKind.Int64;
case NULL:
return EdmSimpleTypeKind.Null;
case SBYTE:
return EdmSimpleTypeKind.SByte;
case SINGLE:
return EdmSimpleTypeKind.Single;
case STRING:
return EdmSimpleTypeKind.String;
case TIME:
return EdmSimpleTypeKind.Time;
default:
throw new AnnotationRuntimeException("Unknown type '" + type
+ "' for mapping to EdmSimpleTypeKind.");
}
}
public EdmMultiplicity mapMultiplicity(final Multiplicity multiplicity) {
switch (multiplicity) {
case ZERO_OR_ONE:
return EdmMultiplicity.ZERO_TO_ONE;
case ONE:
return EdmMultiplicity.ONE;
case MANY:
return EdmMultiplicity.MANY;
default:
throw new AnnotationRuntimeException("Unknown type '" + multiplicity + "' for mapping to EdmMultiplicity.");
}
}
/**
*
*/
private static class EdmAnnotationException extends RuntimeException {
private static final long serialVersionUID = 42L;
public EdmAnnotationException(final String message) {
super(message);
}
}
public String getCanonicalNamespace(final Class<?> aClass) {
return generateNamespace(aClass);
}
public String extractContainerName(final Class<?> aClass) {
EdmEntitySet entitySet = aClass.getAnnotation(EdmEntitySet.class);
if (entitySet != null) {
String containerName = entitySet.container();
if (!containerName.isEmpty()) {
return containerName;
}
}
return DEFAULT_CONTAINER_NAME;
}
}