Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
Copyright 2011 the original author or authors. Licensed 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.springframework.data.neo4j.support.mapping;
 
 import java.util.Map;
 
 import  org.springframework.core.convert.ConversionService;
Implementation of org.springframework.data.neo4j.mapping.Neo4jPersistentProperty.

Author(s):
Oliver Gierke
 
         Neo4jPersistentProperty {
 
     private final static Logger log = LoggerFactory.getLogger(Neo4jPersistentProperty.class);
 
     private final RelationshipInfo relationshipInfo;
     private final boolean isIdProperty;
     private IndexInfo indexInfo;
     private Map<Class<? extends Annotation>, ? extends Annotationannotations;
     private String defaultValue;
     private Class<?> propertyType;
     private String query;
     private final boolean isNeo4jEntityType;
     private final Boolean isAssociation;
     private final String neo4jPropertyName;
     private final int hash;
 
     public Neo4jPersistentPropertyImpl(Field fieldPropertyDescriptor propertyDescriptor,
                                        PersistentEntity<?, Neo4jPersistentPropertyownerSimpleTypeHolder simpleTypeHolderNeo4jMappingContext ctx) {
         super(fieldpropertyDescriptorownersimpleTypeHolder);
         this. = getField().hashCode();
         this. = extractRelationshipInfo(fieldctx);
         this. = extractAnnotations(field);
         this. = extractPropertyType();
         this. = ctx.isReference(this);
         this. = isNeo4jPropertyType(getType());
         this. = createNeo4jPropertyName();
         this. = extractIndexInfo();
         this. = super.isIdProperty() || getAnnotation(GraphId.class) != null;
         this. = extractDefaultValue();
         this. = isAssociation() ? super.getAssociation() == null ? createAssociation() : super.getAssociation() : null;
         this. = extractQuery();
     }
 
     private String extractQuery() {
         final Query query = getAnnotation(Query.class);
        if (query == nullreturn null;
        String value = query.value();
        return value.trim().isEmpty() ? null : value;
    }
    private Class<?> extractPropertyType() {
        final GraphProperty graphProperty = getAnnotation(GraphProperty.class);
        if (graphProperty==nullreturn String.class;
        return graphProperty.propertyType();
    }
    private String extractDefaultValue() {
        final GraphProperty graphProperty = getAnnotation(GraphProperty.class);
        if (graphProperty==nullreturn null;
        final String value = graphProperty.defaultValue();
        if (value.equals(.)) return null;
        return value;
    }
    @Override
        return ;
    }
    private Map<Class<? extends Annotation>,? extends AnnotationextractAnnotations(Field field) {
        Map<Class<? extends Annotation>, Annotationresult=new IdentityHashMap<Class<? extends Annotation>, Annotation>();
        for (Annotation annotation : field.getAnnotations()) {
            result.put(annotation.annotationType(), annotation);
        }
        return result;
    }
    private IndexInfo extractIndexInfo() {
        final Indexed annotation = getAnnotation(Indexed.class);
        return annotation!=null ? new IndexInfo(annotation,this) : null;
    }
    public <T extends Annotation> T getAnnotation(Class<? extends T> annotationType) {
        return findAnnotation(annotationType);
    }
    private RelationshipInfo extractRelationshipInfo(final Field fieldNeo4jMappingContext ctx) {
        if (isAnnotationPresent(RelatedTo.class)) {
            return RelationshipInfo.fromField(fieldgetAnnotation(RelatedTo.class), getTypeInformation(), ctx);
        }
        if (isAnnotationPresent(RelatedToVia.class)) {
            return RelationshipInfo.fromField(fieldgetAnnotation(RelatedToVia.class), getTypeInformation(),ctx);
        }
        if (hasAnnotation(getTypeInformation(), NodeEntity.class)) {
            return RelationshipInfo.fromField(fieldgetTypeInformation(), ctx);
        }
        return null;
    }
    @Override
    public void setValue(Object entityObject newValue) {
        try {
            if (!.isAccessible()) .setAccessible(true);
            .set(entitynewValue);
        } catch (IllegalAccessException e) {
            throw new MappingException("Could not access field "++" for setting value "+newValue+" on "+this);
        }
    }
    private static boolean hasAnnotation(TypeInformation<?> typeInformationfinal Class<NodeEntityannotationClass) {
        return typeInformation.getActualType().getType().isAnnotationPresent(annotationClass);
    }
    @Override
        return new Association<Neo4jPersistentProperty>(thisnull);
    }
    @Override
    public boolean isAssociation() {
        return ==null ? super.isAssociation() : || isRelationship();
    }
    @Override
    public boolean isRelationship() {
        return this. != null;
    }
    @Override
        return ;
    }
    @Override
    public boolean isIndexed() {
        return  != null;
    }
    @Override
    public IndexInfo getIndexInfo() {
        return ;
    }
    public String getNeo4jPropertyName() {
        return ;
    }
    private String createNeo4jPropertyName() {
        final Neo4jPersistentEntity entityClass = (Neo4jPersistentEntitygetOwner();
        if (entityClass.useShortNames()) return getName();
        return String.format("%s.%s"entityClass.getType().getSimpleName(), getName());
    }
    public boolean isSerializablePropertyField(final ConversionService conversionService) {
        if (isRelationship()) return false;
        final Class<?> type = getType();
        if (getTypeInformation().isCollectionLike()) {
            return isConvertible(conversionServicegetComponentType());
        }
        return isConvertible(conversionServicetype);
    }
    private boolean isConvertible(ConversionService conversionServiceClass<?> type) {
        return conversionService.canConvert(type) && conversionService.canConvert(type);
    }
    @Override
    public boolean isNeo4jPropertyType() {
        return ;
    }
    public static boolean isNumeric(final Class<?> fieldType) {
        return (fieldType.isPrimitive() && !fieldType.equals(boolean.class) && !fieldType.equals(void.class)) 
            || fieldType.equals(Character.class)
            || (fieldType.getName().startsWith("java.lang") && Number.class.isAssignableFrom(fieldType));
    }
    public boolean isIndexedNumerically() {
        if (!isIndexed() || !getIndexInfo().isNumeric()) return false;
        return isNumeric(getType()) || isNumeric(getPropertyType()) || 
               (getType().isArray() && !getType().getComponentType().isArray() && isNumeric(getType().getComponentType()));
    }
    private static boolean isNeo4jPropertyType(final Class<?> fieldType) {
        // todo: add array support
        return fieldType.equals(String.class)
                || fieldType.equals(Boolean.class)
                || fieldType.equals(boolean.class)
                || isNumeric(fieldType)
                || (fieldType.isArray() && !fieldType.getComponentType().isArray() && isNeo4jPropertyType(fieldType.getComponentType()));
    }
    @Override
    public boolean isNeo4jPropertyValue(Object value) {
    if (value == null || value.getClass().isArray()) {
        return false;
    }
    return isNeo4jPropertyType(value.getClass());
    }
    public boolean isSyntheticField() {
        return getName().contains("$");
    }
    @Override
    public Collection<? extends AnnotationgetAnnotations() {
    	
    	  if ( == null) {
    	  	
    	  }
    	
        return .values();
    }
    public Object getValue(final Object entityfinal MappingPolicy mappingPolicy) {
        if (entity instanceof ManagedEntity && !mappingPolicy.accessField()) {
            return DoReturn.unwrap(((ManagedEntityentity).getEntityState().getValue(thismappingPolicy));
        }
        return getValueFromEntity(entitymappingPolicy);
    }
    @Override
    public Object getValueFromEntity(Object entityfinal MappingPolicy mappingPolicy) {
        try {
            final Field field = getField();
            if (!field.isAccessible()) field.setAccessible(true);
            return field.get(entity);
        } catch (IllegalAccessException e) {
            throw new MappingException("Could not access field "+);
        }
    }
    @SuppressWarnings("unchecked")
    @Override
    public <T> T getDefaultValue(ConversionService conversionServicefinal Class<T> targetType) {
        if ( == nullreturn (T) getDefaultValue(targetType);
        if (targetType.isAssignableFrom(String.class)) return (T) ;
        if (conversionService == nullreturn (T) getDefaultValue(targetType);
        return conversionService.convert(targetType);
    }
    @Override
    public Class<?> getPropertyType() {
        return ;
    }
    public boolean isUnique() {
        return isIndexed() && getIndexInfo().isUnique();
    }
    private Object getDefaultValue(Class<?> type) {
        if (type!=null && type.isPrimitive()) {
            if (type.equals(boolean.class)) return false;
            return 0;
        }
        return null;
    }
    @Override
    public String toString() {
        return getType() +" "getName() + " rel: "+isRelationship()+ " idx: "+isIndexed();
    }
    @Override
    public Neo4jPersistentEntity<?> getOwner() {
        return (Neo4jPersistentEntity<?>) super.getOwner();
    }
    @Override
    public boolean isEntity() {
        return super.isEntity() && (isRelationshipEntity(getType()) || isNodeEntity(getType()));
    }
    private boolean isRelationshipEntity(final Class<?> type) {
        return type.isAnnotationPresent(RelationshipEntity.class);
    }
    private boolean isNodeEntity(Class<?> type) {
        return type.isAnnotationPresent(NodeEntity.class);
    }
    public String getIndexKey() {
        return getIndexInfo().getIndexKey();
    }
    @Override
    public MappingPolicy getMappingPolicy() {
        if (isAnnotationPresent(Fetch.class))
            return .;
        else
            return .;
    }
    public boolean isTransient() {
        return super.isTransient() || Modifier.isTransient(.getModifiers()); //  || isAnnotationPresent(Transient.class) || isAnnotationPresent("javax.persistence.Transient");
    }
    private boolean isAnnotationPresent(String className) {
        for (Class<? extends AnnotationannotationType : .keySet()) {
            if (annotationType.getName().equals(className)) return true;
        }
        return false;
    }
    @Override
    public Iterable<? extends TypeInformation<?>> getPersistentEntityType() {
        final Iterable<? extends TypeInformation<?>> result = super.getPersistentEntityType();
        for (Iterator<? extends TypeInformation<?>> it = result.iterator(); it.hasNext(); ) {
            final TypeInformation<?> typeInformation = it.next();
            final Class type = typeInformation.getType();
            if (isNodeEntity(type) || isRelationshipEntity(type)) continue;
            if (.isInfoEnabled()) .info("ignoring "+getName()+" "+type+" "+typeInformation.getActualType().getType());
            it.remove();
        }
        return result;
    }
    public MappingPolicy obtainMappingPolicy(MappingPolicy providedMappingPolicy) {
        if (providedMappingPolicy != nullreturn providedMappingPolicy;
        return getMappingPolicy();
    }
 
    public int hashCode() {
        return ;
    }
    public boolean hasQuery() {
        return this.!=null;
    }
    public String getQuery() {
        return ;
    }
    @Override
    public Class<?> getTargetType() {
        if (! isTargetTypeEnforced()) return null;
        if (isCollectionLike()) return getComponentType();
        return getType();
    }
    @Override
    public boolean isTargetTypeEnforced() {
        return getAnnotationRelatedTo.class ) != null && getAnnotationRelatedTo.class ).enforceTargetType();
    }
    
	/*
	 * (non-Javadoc)
	 * @see org.springframework.data.neo4j.mapping.Neo4jPersistentProperty#isStartNode()
	 */
	public boolean isStartNode() {
	}
	/*
	 * (non-Javadoc)
	 * @see org.springframework.data.neo4j.mapping.Neo4jPersistentProperty#isEndNode()
	 */
	public boolean isEndNode() {
	}
	/*
	 * (non-Javadoc)
	 * @see org.springframework.data.neo4j.mapping.Neo4jPersistentProperty#isRelationshipType()
	 */
	public boolean isRelationshipType() {
	}
	/*
	 * (non-Javadoc)
	 * @see org.springframework.data.mapping.model.AnnotationBasedPersistentProperty#isIdProperty()
	 */
	public boolean isIdProperty() {
		return ;
	}
New to GrepCode? Check out our FAQ X