Java PropertyMethod類代碼示例

import com.buschmais.xo.spi.reflection.PropertyMethod; //導入依賴的package包/類
@Override
   public DuctileIndexedPropertyMetadata createIndexedPropertyMetadata(PropertyMethod propertyMethod) {
Property property = propertyMethod.getAnnotationOfProperty(Property.class);
String name = property != null ? property.value() : propertyMethod.getName();
Class<?> declaringClass = propertyMethod.getAnnotatedElement().getDeclaringClass();
Class<? extends Element> type = null;
if (declaringClass.getAnnotation(VertexDefinition.class) != null) {
    type = DuctileVertex.class;
} else if (declaringClass.getAnnotation(EdgeDefinition.class) != null) {
    type = DuctileEdge.class;
} else {
    throw new XOException("Property '" + name
	    + "' was found with index annotation, but the declaring type is neither a vertex nor an edge.");
}
Indexed indexedAnnotation = propertyMethod.getAnnotation(Indexed.class);
boolean unique = indexedAnnotation.unique();
Class<?> dataType = propertyMethod.getType();
if (Serializable.class.isAssignableFrom(dataType)) {
    @SuppressWarnings("unchecked")
    Class<? extends Serializable> serializableDataType = (Class<? extends Serializable>) dataType;
    return new DuctileIndexedPropertyMetadata(name, unique, serializableDataType, type);
} else {
    throw new XOException("Illegal data type '" + dataType.getName() + "' found. Type is not serializable.");
}
   }
 

import com.buschmais.xo.spi.reflection.PropertyMethod; //導入依賴的package包/類
@Override
   public DuctileEdgeMetadata createRelationMetadata(AnnotatedElement<?> annotatedElement,
    Map<Class<?>, TypeMetadata> metadataByType) {
EdgeDefinition relationAnnotation;
if (annotatedElement instanceof PropertyMethod) {
    relationAnnotation = ((PropertyMethod) annotatedElement).getAnnotationOfProperty(EdgeDefinition.class);
} else {
    relationAnnotation = annotatedElement.getAnnotation(EdgeDefinition.class);
}
String name = null;
if (relationAnnotation != null) {
    String value = relationAnnotation.value();
    if (!EdgeDefinition.DEFAULT_VALUE.equals(value)) {
	name = value;
    }
}
if (name == null) {
    name = StringUtils.uncapitalize(annotatedElement.getName());
}
return new DuctileEdgeMetadata(name);
   }
 

import com.buschmais.xo.spi.reflection.PropertyMethod; //導入依賴的package包/類
@Override
   public TitanIndexedPropertyMetadata createIndexedPropertyMetadata(
    PropertyMethod propertyMethod) {
Property property = propertyMethod
	.getAnnotationOfProperty(Property.class);
String name = property != null ? property.value() : propertyMethod
	.getName();
Class<?> declaringClass = propertyMethod.getAnnotatedElement()
	.getDeclaringClass();
Class<? extends Element> type = null;
if (declaringClass.getAnnotation(VertexDefinition.class) != null) {
    type = Vertex.class;
} else if (declaringClass.getAnnotation(EdgeDefinition.class) != null) {
    type = Edge.class;
} else {
    throw new XOException(
	    "Property '"
		    + name
		    + "' was found with index annotation, but the declaring type is neither a vertex nor an edge.");
}
Indexed indexedAnnotation = propertyMethod.getAnnotation(Indexed.class);
boolean unique = indexedAnnotation.unique();
Class<?> dataType = propertyMethod.getType();
return new TitanIndexedPropertyMetadata(name, unique, dataType, type);
   }
 

import com.buschmais.xo.spi.reflection.PropertyMethod; //導入依賴的package包/類
@Override
   public TitanEdgeMetadata createRelationMetadata(
    AnnotatedElement<?> annotatedElement,
    Map<Class<?>, TypeMetadata> metadataByType) {
EdgeDefinition relationAnnotation;
if (annotatedElement instanceof PropertyMethod) {
    relationAnnotation = ((PropertyMethod) annotatedElement)
	    .getAnnotationOfProperty(EdgeDefinition.class);
} else {
    relationAnnotation = annotatedElement
	    .getAnnotation(EdgeDefinition.class);
}
String name = null;
if (relationAnnotation != null) {
    String value = relationAnnotation.value();
    if (!EdgeDefinition.DEFAULT_VALUE.equals(value)) {
	name = value;
    }
}
if (name == null) {
    name = StringUtils.uncapitalize(annotatedElement.getName());
}
return new TitanEdgeMetadata(name);
   }
 

import com.buschmais.xo.spi.reflection.PropertyMethod; //導入依賴的package包/類
@Override
public RelationshipMetadata<R> createRelationMetadata(AnnotatedElement<?> annotatedElement, Map<Class<?>, TypeMetadata> metadataByType) {
    Relation relationAnnotation;
    boolean batchable;
    if (annotatedElement instanceof PropertyMethod) {
        relationAnnotation = ((PropertyMethod) annotatedElement).getAnnotationOfProperty(Relation.class);
        batchable = true;
    } else if (annotatedElement instanceof AnnotatedType) {
        AnnotatedType annotatedType = (AnnotatedType) annotatedElement;
        relationAnnotation = annotatedType.getAnnotation(Relation.class);
        batchable = annotatedType.getAnnotatedElement().isAnnotation() || isBatchable(annotatedElement);
    } else {
        throw new XOException("Annotated element is not supported: " + annotatedElement);
    }
    String name = null;
    if (relationAnnotation != null) {
        String value = relationAnnotation.value();
        if (!Relation.DEFAULT_VALUE.equals(value)) {
            name = value;
        }
    }
    if (name == null) {
        name = CaseFormat.UPPER_CAMEL.to(CaseFormat.UPPER_UNDERSCORE, annotatedElement.getName());
    }
    return new RelationshipMetadata<>(createRelationshipType(name), batchable);
}
 

import com.buschmais.xo.spi.reflection.PropertyMethod; //導入依賴的package包/類
public RowProxyMethodService(SortedSet<Class<?>> types) {
    for (Class<?> type : types) {
        BeanMethodProvider beanMethodProvider = BeanMethodProvider.newInstance(type);
        Collection<AnnotatedMethod> typeMethodsOfType = beanMethodProvider.getMethods();
        for (AnnotatedMethod typeMethod : typeMethodsOfType) {
            if (!(typeMethod instanceof GetPropertyMethod)) {
                throw new XOException("Only get methods are supported for projections: '" + typeMethod.getAnnotatedElement().getName() + "'.");
            }
            PropertyMethod propertyMethod = (PropertyMethod) typeMethod;
            GetMethod proxyMethod = new GetMethod(propertyMethod.getName(), propertyMethod.getType());
            addProxyMethod(proxyMethod, propertyMethod.getAnnotatedElement());
        }
    }
    addMethod(new AsMethod(), CompositeObject.class, "as", Class.class);
    addMethod(new GetDelegateMethod<>(), CompositeObject.class, "getDelegate");
    addMethod(new com.buschmais.xo.impl.proxy.query.row.GetMethod(), CompositeRowObject.class, "get", String.class, Class.class);
    addMethod(new GetColumnsMethod(), CompositeRowObject.class, "getColumns");
    addMethod(new HashCodeMethod(), Object.class, "hashCode");
    addMethod(new EqualsMethod(), Object.class, "equals", Object.class);
    addMethod(new ToStringMethod(), Object.class, "toString");
}
 

import com.buschmais.xo.spi.reflection.PropertyMethod; //導入依賴的package包/類
/**
    * This method is a helper method to extract the edge direction from a
    * {@link PropertyMethod}.
    * 
    * @param propertyMethod
    *            is the {@link PropertyMethod} object which represents the
    *            method for which the edge direction is to be checked.
    * @return A {@link EdgeDirection} object is returned containing the
    *         direction of the edge.
    */
   private static EdgeDirection determineEdgeDirection(PropertyMethod propertyMethod) {
Outgoing outgoingAnnotation = propertyMethod.getAnnotation(Outgoing.class);
Incoming incomingAnnotation = propertyMethod.getAnnotation(Incoming.class);
if ((outgoingAnnotation != null) && (incomingAnnotation != null)) {
    return EdgeDirection.BOTH;
} else if (incomingAnnotation != null) {
    return EdgeDirection.IN;
} else {
    return EdgeDirection.OUT;
}
   }
 

import com.buschmais.xo.spi.reflection.PropertyMethod; //導入依賴的package包/類
@Override
   public TitanCollectionPropertyMetadata createCollectionPropertyMetadata(
    PropertyMethod propertyMethod) {
String name = determinePropertyName(propertyMethod);
Direction direction = determineEdgeDirection(propertyMethod);
return new TitanCollectionPropertyMetadata(name, direction);
   }
 

import com.buschmais.xo.spi.reflection.PropertyMethod; //導入依賴的package包/類
@Override
   public TitanReferencePropertyMetadata createReferencePropertyMetadata(
    PropertyMethod propertyMethod) {
String name = determinePropertyName(propertyMethod);
Direction direction = determineEdgeDirection(propertyMethod);
return new TitanReferencePropertyMetadata(name, direction);
   }
 

import com.buschmais.xo.spi.reflection.PropertyMethod; //導入依賴的package包/類
@Override
   public TitanPropertyMetadata createPropertyMetadata(
    PropertyMethod propertyMethod) {
Property property = propertyMethod
	.getAnnotationOfProperty(Property.class);
String name = property != null ? property.value() : propertyMethod
	.getName();
return new TitanPropertyMetadata(name);
   }
 

import com.buschmais.xo.spi.reflection.PropertyMethod; //導入依賴的package包/類
/**
    * This method is a helper method to extract the edge direction from a
    * {@link PropertyMethod}.
    * 
    * @param propertyMethod
    *            is the {@link PropertyMethod} object which represents the
    *            method for which the edge direction is to be checked.
    * @return A {@link Direction} object is returned containing the direction
    *         of the edge.
    */
   private static Direction determineEdgeDirection(
    PropertyMethod propertyMethod) {
Outgoing outgoingAnnotation = propertyMethod
	.getAnnotation(Outgoing.class);
Incoming incomingAnnotation = propertyMethod
	.getAnnotation(Incoming.class);
if ((outgoingAnnotation != null) && (incomingAnnotation != null)) {
    return Direction.BOTH;
} else if (incomingAnnotation != null) {
    return Direction.IN;
} else {
    return Direction.OUT;
}
   }
 

import com.buschmais.xo.spi.reflection.PropertyMethod; //導入依賴的package包/類
@Override
   public DuctileCollectionPropertyMetadata createCollectionPropertyMetadata(PropertyMethod propertyMethod) {
String name = determinePropertyName(propertyMethod);
EdgeDirection direction = determineEdgeDirection(propertyMethod);
return new DuctileCollectionPropertyMetadata(name, direction);
   }
 

import com.buschmais.xo.spi.reflection.PropertyMethod; //導入依賴的package包/類
@Override
   public DuctileReferencePropertyMetadata createReferencePropertyMetadata(PropertyMethod propertyMethod) {
String name = determinePropertyName(propertyMethod);
EdgeDirection direction = determineEdgeDirection(propertyMethod);
return new DuctileReferencePropertyMetadata(name, direction);
   }
 

import com.buschmais.xo.spi.reflection.PropertyMethod; //導入依賴的package包/類
@Override
   public DuctilePropertyMetadata createPropertyMetadata(PropertyMethod propertyMethod) {
Property property = propertyMethod.getAnnotationOfProperty(Property.class);
String name = property != null ? property.value() : propertyMethod.getName();
return new DuctilePropertyMetadata(name);
   }
 

import com.buschmais.xo.spi.reflection.PropertyMethod; //導入依賴的package包/類
@Override
public <CollectionPropertyMetadata> CollectionPropertyMetadata createCollectionPropertyMetadata(PropertyMethod propertyMethod) {
    return null;
}