org.eclipse.osbp.dsl.dto.lib/src/org/eclipse/osbp/dsl/dto/lib/services/jpa/metadata/PersistentPropertyMetadata.java - osbp/org.eclipse.osbp.dsl - Git at Google

 /**
  * Copyright 2009-2013 Oy Vaadin Ltd
  *
  * 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.eclipse.osbp.dsl.dto.lib.services.jpa.metadata;

 import java.io.InvalidObjectException;
 import java.io.ObjectStreamException;
 import java.lang.annotation.Annotation;
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;

 /**
  * An extended version of {@link PropertyMetadata} that provides additional
  * information about persistent properties.
  *
  * @author Petter Holmström (Vaadin Ltd)
  * @since 1.0
  */
 public class PersistentPropertyMetadata extends PropertyMetadata {

     private static final long serialVersionUID = -4097189601179456814L;

     /**
      * Enumeration defining the property access types.
      *
      * @author Petter Holmström (Vaadin Ltd)
      */
     public enum AccessType {

         /**
          * The property is accessed as a JavaBean property using getters and
          * setters.
          */
         METHOD,
         /**
          * The property is accessed directly as a field.
          */
         FIELD
     }

     private final PropertyKind propertyKind;
     private final ClassMetadata<?> typeMetadata;
     transient final Field field;
     // Required for serialization
     protected final String fieldName;
     protected final Class<?> fieldDeclaringClass;

     /**
      * Creates a new instance of <code>PersistentPropertyMetadata</code>.
      *
      * @param name
      *            the name of the property (must not be null).
      * @param type
      *            the type of the property (must not be null).
      * @param propertyKind
      *            the kind of the property, must be either
      *            {@link PropertyKind#ONE_TO_MANY},
      *            {@link PropertyKind#MANY_TO_MANY},
      *            {@link PropertyKind#ELEMENT_COLLECTION} or
      *            {@link PropertyKind#SIMPLE} .
      * @param field
      *            the field that can be used to access the property (must not be
      *            null).
      */
     PersistentPropertyMetadata(String name, Class<?> type,
             PropertyKind propertyKind, Field field, Method setter) {
         super(name, type, null, setter);
         assert propertyKind == PropertyKind.ONE_TO_MANY
                 || propertyKind == PropertyKind.MANY_TO_MANY
                 || propertyKind == PropertyKind.ELEMENT_COLLECTION
                 || propertyKind == PropertyKind.SIMPLE : "propertyKind must be ONE_TO_MANY or SIMPLE";
         assert field != null : "field must not be null";
         this.propertyKind = propertyKind;
         typeMetadata = null;
         this.field = field;
         fieldName = field.getName();
         fieldDeclaringClass = field.getDeclaringClass();
     }

     /**
      * Creates a new instance of <code>PersistentPropertyMetadata</code>.
      *
      * @param name
      *            the name of the property (must not be null).
      * @param type
      *            type type of the property (must not be null).
      * @param propertyKind
      *            the kind of the property, must be either
      *            {@link PropertyKind#ONE_TO_MANY},
      *            {@link PropertyKind#MANY_TO_MANY},
      *            {@link PropertyKind#ELEMENT_COLLECTION} or
      *            {@link PropertyKind#SIMPLE} .
      * @param getter
      *            the getter method that can be used to read the property value
      *            (must not be null).
      * @param setter
      *            the setter method that can be used to set the property value
      *            (must not be null).
      */
     PersistentPropertyMetadata(String name, Class<?> type,
             PropertyKind propertyKind, Method getter, Method setter) {
         super(name, type, getter, setter);
         assert propertyKind == PropertyKind.ONE_TO_MANY
                 || propertyKind == PropertyKind.MANY_TO_MANY
                 || propertyKind == PropertyKind.ELEMENT_COLLECTION
                 || propertyKind == PropertyKind.SIMPLE : "propertyKind must be ONE_TO_MANY or SIMPLE";
         assert getter != null : "getter must not be null";
         assert setter != null : "setter must not be null";
         this.propertyKind = propertyKind;
         typeMetadata = null;
         field = null;
         fieldName = null;
         fieldDeclaringClass = null;
     }

     /**
      * Creates a new instance of <code>PersistentPropertyMetadata</code>.
      *
      * @param name
      *            the name of the property (must not be null).
      * @param type
      *            the type metadata of the property (must not be null).
      * @param propertyKind
      *            the kind of the property, must be either
      *            {@link PropertyKind#MANY_TO_ONE},
      *            {@link PropertyKind#ONE_TO_ONE} or
      *            {@link PropertyKind#EMBEDDED}.
      * @param field
      *            the field that can be used to access the property (must not be
      *            null).
      */
     PersistentPropertyMetadata(String name, ClassMetadata<?> type,
             PropertyKind propertyKind, Field field, Method setter) {
         super(name, type.getMappedClass(), null, setter);
         assert type != null : "type must not be null";
         assert propertyKind == PropertyKind.MANY_TO_ONE
                 || propertyKind == PropertyKind.ONE_TO_ONE
                 || propertyKind == PropertyKind.EMBEDDED : "propertyKind must be MANY_TO_ONE or EMBEDDED";
         assert field != null : "field must not be null";
         this.propertyKind = propertyKind;
         typeMetadata = type;
         this.field = field;
         fieldName = field.getName();
         fieldDeclaringClass = field.getDeclaringClass();
     }

     /**
      * Creates a new instance of <code>PersistentPropertyMetadata</code>.
      *
      * @param name
      *            the name of the property (must not be null).
      * @param type
      *            the type metadata of the property (must not be null).
      * @param propertyKind
      *            the kind of the property, must be either
      *            {@link PropertyKind#MANY_TO_ONE},
      *            {@link PropertyKind#ONE_TO_ONE} or
      *            {@link PropertyKind#EMBEDDED}.
      * @param getter
      *            the getter method that can be used to read the property value
      *            (must not be null).
      * @param setter
      *            the setter method that can be used to set the property value
      *            (must not be null).
      */
     PersistentPropertyMetadata(String name, ClassMetadata<?> type,
             PropertyKind propertyKind, Method getter, Method setter) {
         super(name, type.getMappedClass(), getter, setter);
         assert type != null : "type must not be null";
         assert propertyKind == PropertyKind.MANY_TO_ONE
                 || propertyKind == PropertyKind.ONE_TO_ONE
                 || propertyKind == PropertyKind.EMBEDDED : "propertyKind must be MANY_TO_ONE or EMBEDDED";
         assert getter != null : "getter must not be null";
         assert setter != null : "setter must not be null";
         this.propertyKind = propertyKind;
         typeMetadata = type;
         field = null;
         fieldName = null;
         fieldDeclaringClass = null;
     }

     /**
      * This constructor is used when deserializing the object.
      *
      * @see #readResolve()
      */
     private PersistentPropertyMetadata(String name,
             ClassMetadata<?> typeMetadata, Class<?> type,
             PropertyKind propertyKind, Method getter, Method setter, Field field) {
         super(name, type, getter, setter);
         this.propertyKind = propertyKind;
         this.typeMetadata = typeMetadata;
         this.field = field;
         if (this.field == null) {
             fieldName = null;
             fieldDeclaringClass = null;
         } else {
             fieldName = field.getName();
             fieldDeclaringClass = field.getDeclaringClass();
         }
     }

     /**
      * The metadata of the property type, if it is embedded or a reference.
      * Otherwise, this method returns null.
      *
      * @see #getPropertyKind()
      */
     public ClassMetadata<?> getTypeMetadata() {
         return typeMetadata;
     }

     /**
      * The kind of the property.
      */
     @Override
     public PropertyKind getPropertyKind() {
         return propertyKind;
     }

     /**
      * The way the property value is accessed (as a JavaBean property or as a
      * field).
      */
     public AccessType getAccessType() {
         return field != null ? AccessType.FIELD : AccessType.METHOD;
     }

     @Override
     public <T extends Annotation> T getAnnotation(Class<T> annotationClass) {
         if (field != null) {
             return field.getAnnotation(annotationClass);
         } else {
             return super.getAnnotation(annotationClass);
         }
     }

     @Override
     public Annotation[] getAnnotations() {
         if (field != null) {
             return field.getAnnotations();
         } else {
             return super.getAnnotations();
         }
     }

     @Override
     public Object readResolve() throws ObjectStreamException {
         try {
             Field f = null;
             if (fieldName != null) {
                 f = fieldDeclaringClass.getDeclaredField(fieldName);
             }
             Method getterM = null;
             if (getterName != null) {
                 getterM = getterDeclaringClass.getDeclaredMethod(getterName);
             }
             Method setterM = null;
             if (setterName != null) {
                 // use the type from field if possible. type is Vaadin property
                 // type, which means that for primitive types we convert it to
                 // wrapper type
                 Class<?> setterType = (f == null) ? getType() : f.getType();
                 setterM = setterDeclaringClass.getDeclaredMethod(setterName,
                         setterType);
             }
             return new PersistentPropertyMetadata(getName(), typeMetadata,
                     getType(), propertyKind, getterM, setterM, f);
         } catch (Exception e) {
             e.printStackTrace();
             throw new InvalidObjectException(e.getMessage());
         }
     }

     /**
      * Persistent properties are always writable.
      * <p>
      * {@inheritDoc }.
      */
     @Override
     public boolean isWritable() {
         return true; // field != null || super.isWritable();
     }

     /*
      * Note, that we only compare the mapped classes of the typeMetadata fields.
      * If we compared the typeMetadata fields themselves, we could run into an
      * infinite loop if there are circular references (e.g. a parent-property of
      * the same type) in the metadata.
      */

     @Override
     public boolean equals(Object obj) {
         if (super.equals(obj)) { // Includes check of parameter type
             PersistentPropertyMetadata other = (PersistentPropertyMetadata) obj;
             return ( other != null && propertyKind.equals(other.propertyKind) )
                     && (typeMetadata == null ? other.typeMetadata == null
                             : typeMetadata.getMappedClass().equals(
                                     other.typeMetadata.getMappedClass()))
                     && (field == null ? other.field == null : field
                             .equals(other.field));
         }
         return false;
     }

     @Override
     public int hashCode() {
         int hash = super.hashCode();
         hash = hash * 31 + propertyKind.hashCode();
         if (typeMetadata != null) {
             hash = hash * 31 + typeMetadata.getMappedClass().hashCode();
         }
         if (field != null) {
             hash = hash * 31 + field.hashCode();
         }
         return hash;
     }
 }
	/**
	* Copyright 2009-2013 Oy Vaadin Ltd
	*
	* 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.eclipse.osbp.dsl.dto.lib.services.jpa.metadata;

	import java.io.InvalidObjectException;
	import java.io.ObjectStreamException;
	import java.lang.annotation.Annotation;
	import java.lang.reflect.Field;
	import java.lang.reflect.Method;

	/**
	* An extended version of {@link PropertyMetadata} that provides additional
	* information about persistent properties.
	*
	* @author Petter Holmström (Vaadin Ltd)
	* @since 1.0
	*/
	public class PersistentPropertyMetadata extends PropertyMetadata {

	private static final long serialVersionUID = -4097189601179456814L;

	/**
	* Enumeration defining the property access types.
	*
	* @author Petter Holmström (Vaadin Ltd)
	*/
	public enum AccessType {

	/**
	* The property is accessed as a JavaBean property using getters and
	* setters.
	*/
	METHOD,
	/**
	* The property is accessed directly as a field.
	*/
	FIELD
	}

	private final PropertyKind propertyKind;
	private final ClassMetadata<?> typeMetadata;
	transient final Field field;
	// Required for serialization
	protected final String fieldName;
	protected final Class<?> fieldDeclaringClass;

	/**
	* Creates a new instance of <code>PersistentPropertyMetadata</code>.
	*
	* @param name
	* the name of the property (must not be null).
	* @param type
	* the type of the property (must not be null).
	* @param propertyKind
	* the kind of the property, must be either
	* {@link PropertyKind#ONE_TO_MANY},
	* {@link PropertyKind#MANY_TO_MANY},
	* {@link PropertyKind#ELEMENT_COLLECTION} or
	* {@link PropertyKind#SIMPLE} .
	* @param field
	* the field that can be used to access the property (must not be
	* null).
	*/
	PersistentPropertyMetadata(String name, Class<?> type,
	PropertyKind propertyKind, Field field, Method setter) {
	super(name, type, null, setter);
	assert propertyKind == PropertyKind.ONE_TO_MANY
	\|\| propertyKind == PropertyKind.MANY_TO_MANY
	\|\| propertyKind == PropertyKind.ELEMENT_COLLECTION
	\|\| propertyKind == PropertyKind.SIMPLE : "propertyKind must be ONE_TO_MANY or SIMPLE";
	assert field != null : "field must not be null";
	this.propertyKind = propertyKind;
	typeMetadata = null;
	this.field = field;
	fieldName = field.getName();
	fieldDeclaringClass = field.getDeclaringClass();
	}

	/**
	* Creates a new instance of <code>PersistentPropertyMetadata</code>.
	*
	* @param name
	* the name of the property (must not be null).
	* @param type
	* type type of the property (must not be null).
	* @param propertyKind
	* the kind of the property, must be either
	* {@link PropertyKind#ONE_TO_MANY},
	* {@link PropertyKind#MANY_TO_MANY},
	* {@link PropertyKind#ELEMENT_COLLECTION} or
	* {@link PropertyKind#SIMPLE} .
	* @param getter
	* the getter method that can be used to read the property value
	* (must not be null).
	* @param setter
	* the setter method that can be used to set the property value
	* (must not be null).
	*/
	PersistentPropertyMetadata(String name, Class<?> type,
	PropertyKind propertyKind, Method getter, Method setter) {
	super(name, type, getter, setter);
	assert propertyKind == PropertyKind.ONE_TO_MANY
	\|\| propertyKind == PropertyKind.MANY_TO_MANY
	\|\| propertyKind == PropertyKind.ELEMENT_COLLECTION
	\|\| propertyKind == PropertyKind.SIMPLE : "propertyKind must be ONE_TO_MANY or SIMPLE";
	assert getter != null : "getter must not be null";
	assert setter != null : "setter must not be null";
	this.propertyKind = propertyKind;
	typeMetadata = null;
	field = null;
	fieldName = null;
	fieldDeclaringClass = null;
	}

	/**
	* Creates a new instance of <code>PersistentPropertyMetadata</code>.
	*
	* @param name
	* the name of the property (must not be null).
	* @param type
	* the type metadata of the property (must not be null).
	* @param propertyKind
	* the kind of the property, must be either
	* {@link PropertyKind#MANY_TO_ONE},
	* {@link PropertyKind#ONE_TO_ONE} or
	* {@link PropertyKind#EMBEDDED}.
	* @param field
	* the field that can be used to access the property (must not be
	* null).
	*/
	PersistentPropertyMetadata(String name, ClassMetadata<?> type,
	PropertyKind propertyKind, Field field, Method setter) {
	super(name, type.getMappedClass(), null, setter);
	assert type != null : "type must not be null";
	assert propertyKind == PropertyKind.MANY_TO_ONE
	\|\| propertyKind == PropertyKind.ONE_TO_ONE
	\|\| propertyKind == PropertyKind.EMBEDDED : "propertyKind must be MANY_TO_ONE or EMBEDDED";
	assert field != null : "field must not be null";
	this.propertyKind = propertyKind;
	typeMetadata = type;
	this.field = field;
	fieldName = field.getName();
	fieldDeclaringClass = field.getDeclaringClass();
	}

	/**
	* Creates a new instance of <code>PersistentPropertyMetadata</code>.
	*
	* @param name
	* the name of the property (must not be null).
	* @param type
	* the type metadata of the property (must not be null).
	* @param propertyKind
	* the kind of the property, must be either
	* {@link PropertyKind#MANY_TO_ONE},
	* {@link PropertyKind#ONE_TO_ONE} or
	* {@link PropertyKind#EMBEDDED}.
	* @param getter
	* the getter method that can be used to read the property value
	* (must not be null).
	* @param setter
	* the setter method that can be used to set the property value
	* (must not be null).
	*/
	PersistentPropertyMetadata(String name, ClassMetadata<?> type,
	PropertyKind propertyKind, Method getter, Method setter) {
	super(name, type.getMappedClass(), getter, setter);
	assert type != null : "type must not be null";
	assert propertyKind == PropertyKind.MANY_TO_ONE
	\|\| propertyKind == PropertyKind.ONE_TO_ONE
	\|\| propertyKind == PropertyKind.EMBEDDED : "propertyKind must be MANY_TO_ONE or EMBEDDED";
	assert getter != null : "getter must not be null";
	assert setter != null : "setter must not be null";
	this.propertyKind = propertyKind;
	typeMetadata = type;
	field = null;
	fieldName = null;
	fieldDeclaringClass = null;
	}

	/**
	* This constructor is used when deserializing the object.
	*
	* @see #readResolve()
	*/
	private PersistentPropertyMetadata(String name,
	ClassMetadata<?> typeMetadata, Class<?> type,
	PropertyKind propertyKind, Method getter, Method setter, Field field) {
	super(name, type, getter, setter);
	this.propertyKind = propertyKind;
	this.typeMetadata = typeMetadata;
	this.field = field;
	if (this.field == null) {
	fieldName = null;
	fieldDeclaringClass = null;
	} else {
	fieldName = field.getName();
	fieldDeclaringClass = field.getDeclaringClass();
	}
	}

	/**
	* The metadata of the property type, if it is embedded or a reference.
	* Otherwise, this method returns null.
	*
	* @see #getPropertyKind()
	*/
	public ClassMetadata<?> getTypeMetadata() {
	return typeMetadata;
	}

	/**
	* The kind of the property.
	*/
	@Override
	public PropertyKind getPropertyKind() {
	return propertyKind;
	}

	/**
	* The way the property value is accessed (as a JavaBean property or as a
	* field).
	*/
	public AccessType getAccessType() {
	return field != null ? AccessType.FIELD : AccessType.METHOD;
	}

	@Override
	public <T extends Annotation> T getAnnotation(Class<T> annotationClass) {
	if (field != null) {
	return field.getAnnotation(annotationClass);
	} else {
	return super.getAnnotation(annotationClass);
	}
	}

	@Override
	public Annotation[] getAnnotations() {
	if (field != null) {
	return field.getAnnotations();
	} else {
	return super.getAnnotations();
	}
	}

	@Override
	public Object readResolve() throws ObjectStreamException {
	try {
	Field f = null;
	if (fieldName != null) {
	f = fieldDeclaringClass.getDeclaredField(fieldName);
	}
	Method getterM = null;
	if (getterName != null) {
	getterM = getterDeclaringClass.getDeclaredMethod(getterName);
	}
	Method setterM = null;
	if (setterName != null) {
	// use the type from field if possible. type is Vaadin property
	// type, which means that for primitive types we convert it to
	// wrapper type
	Class<?> setterType = (f == null) ? getType() : f.getType();
	setterM = setterDeclaringClass.getDeclaredMethod(setterName,
	setterType);
	}
	return new PersistentPropertyMetadata(getName(), typeMetadata,
	getType(), propertyKind, getterM, setterM, f);
	} catch (Exception e) {
	e.printStackTrace();
	throw new InvalidObjectException(e.getMessage());
	}
	}

	/**
	* Persistent properties are always writable.
	* <p>
	* {@inheritDoc }.
	*/
	@Override
	public boolean isWritable() {
	return true; // field != null \|\| super.isWritable();
	}

	/*
	* Note, that we only compare the mapped classes of the typeMetadata fields.
	* If we compared the typeMetadata fields themselves, we could run into an
	* infinite loop if there are circular references (e.g. a parent-property of
	* the same type) in the metadata.
	*/

	@Override
	public boolean equals(Object obj) {
	if (super.equals(obj)) { // Includes check of parameter type
	PersistentPropertyMetadata other = (PersistentPropertyMetadata) obj;
	return ( other != null && propertyKind.equals(other.propertyKind) )
	&& (typeMetadata == null ? other.typeMetadata == null
	: typeMetadata.getMappedClass().equals(
	other.typeMetadata.getMappedClass()))
	&& (field == null ? other.field == null : field
	.equals(other.field));
	}
	return false;
	}

	@Override
	public int hashCode() {
	int hash = super.hashCode();
	hash = hash * 31 + propertyKind.hashCode();
	if (typeMetadata != null) {
	hash = hash * 31 + typeMetadata.getMappedClass().hashCode();
	}
	if (field != null) {
	hash = hash * 31 + field.hashCode();
	}
	return hash;
	}
	}