org.jvnet.annox.model.XAnnotationField Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of annox Show documentation
There is a newer version: 1.0.2
package org.jvnet.annox.model;

import java.lang.annotation.Annotation;
import java.lang.reflect.Array;

import org.apache.commons.lang.Validate;
import org.jvnet.annox.util.ArrayUtils;

public abstract class XAnnotationField {

	private final String name;

	public String getName() {
		return name;
	}

	private final T value;

	public T getValue() {
		return value;
	}

	public abstract Object getResult();

	public abstract Class getType();

	public abstract  T accept(XAnnotationVisitor visitor);

	public XAnnotationField(final String name, final T value) {
		Validate.notNull(name, "Field name must not be null.");
		Validate.notNull(value, "Field value must not be null.");
		this.name = name;
		this.value = value;
	}

	public static abstract class XField extends XAnnotationField {
		public XField(String name, T value) {
			super(name, value);
		}

		@Override
		public String toString() {
			return getName() + "=" + getValue();
		}

		@Override
		public int hashCode() {
			int hash = 0;
			final String name = getName();
			hash = hash * 37 + name.hashCode();
			final T value = getValue();
			hash = hash * 37 + value.hashCode();
			return hash;
		}

		@Override
		public boolean equals(Object obj) {
			if (!(obj instanceof XAnnotationField)) {
				return false;
			}
			if (this == obj) {
				return true;
			}
			final XAnnotationField other = (XAnnotationField) obj;
			return getName().equals(other.getName())
					&& getValue().equals(other.getValue());
		}

		@Override
		public Object getResult() {
			return getValue();
		}
	}

	public static abstract class XPrimitiveField extends XField {
		public XPrimitiveField(String name, T value) {
			super(name, value);
		}
	}

	public static abstract class XObjectField extends XField {
		public XObjectField(String name, T value) {
			super(name, value);
		}
	}

	public static class XBoolean extends XPrimitiveField {
		public XBoolean(String name, Boolean value) {
			super(name, value);
		}

		@Override
		public Class getType() {
			return Boolean.TYPE;
		}

		@Override
		public  T accept(XAnnotationVisitor visitor) {
			return visitor.visitBooleanField(this);
		}
	}

	public static class XByte extends XPrimitiveField {
		public XByte(String name, Byte value) {
			super(name, value);
		}

		@Override
		public Class getType() {
			return Byte.TYPE;
		}

		@Override
		public  T accept(XAnnotationVisitor visitor) {
			return visitor.visitByteField(this);
		}
	}

	public static class XInt extends XPrimitiveField {
		public XInt(String name, Integer value) {
			super(name, value);
		}

		@Override
		public Class getType() {
			return Integer.TYPE;
		}

		@Override
		public  T accept(XAnnotationVisitor visitor) {
			return visitor.visitIntField(this);
		}
	}

	public static class XLong extends XPrimitiveField {
		public XLong(String name, Long value) {
			super(name, value);
		}

		@Override
		public Class getType() {
			return Long.TYPE;
		}

		@Override
		public  T accept(XAnnotationVisitor visitor) {
			return visitor.visitLongField(this);
		}
	}

	public static class XShort extends XPrimitiveField {
		public XShort(String name, Short value) {
			super(name, value);
		}

		@Override
		public Class getType() {
			return Short.TYPE;
		}

		@Override
		public  T accept(XAnnotationVisitor visitor) {
			return visitor.visitShortField(this);
		}
	}

	public static class XChar extends XPrimitiveField {
		public XChar(String name, Character value) {
			super(name, value);
		}

		@Override
		public Class getType() {
			return Character.TYPE;
		}

		@Override
		public  T accept(XAnnotationVisitor visitor) {
			return visitor.visitCharField(this);
		}
	}

	public static class XClass extends XObjectField {
		public XClass(String name, Class value) {
			super(name, value);
		}

		@Override
		public Class getType() {
			return Class.class;
		}

		@Override
		public  T accept(XAnnotationVisitor visitor) {
			return visitor.visitClassField(this);
		}
	}

	public static class XDouble extends XPrimitiveField {
		public XDouble(String name, Double value) {
			super(name, value);
		}

		@Override
		public Class getType() {
			return Double.TYPE;
		}

		@Override
		public  T accept(XAnnotationVisitor visitor) {
			return visitor.visitDoubleField(this);
		}
	}

	public static class XFloat extends XPrimitiveField {
		public XFloat(String name, Float value) {
			super(name, value);
		}

		@Override
		public Class getType() {
			return Float.TYPE;
		}

		@Override
		public  T accept(XAnnotationVisitor visitor) {
			return visitor.visitFloatField(this);
		}
	}

	public static class XEnum extends XObjectField {

		private final Class enumClass;

		public XEnum(String name, Enum value, Class enumClass) {
			super(name, value);
			Validate.notNull(enumClass, "Enum class must not be null.");
			this.enumClass = enumClass;
		}

		@Override
		public Class getType() {
			return enumClass;
		}

		@Override
		public  T accept(XAnnotationVisitor visitor) {
			return visitor.visitEnumField(this);
		}
	}

	public static class XString extends XObjectField {
		public XString(String name, String value) {
			super(name, value);
		}

		@Override
		public Class getType() {
			return String.class;
		}

		@Override
		public  T accept(XAnnotationVisitor visitor) {
			return visitor.visitStringField(this);
		}
	}

	public static class XAnnotation extends
			XObjectField {

		private final Class annotationClass;

		public XAnnotation(String name,
				org.jvnet.annox.model.XAnnotation value,
				Class annotationClass) {
			super(name, value);
			Validate.notNull(annotationClass,
					"Annotation class must not be null.");
			this.annotationClass = annotationClass;
		}

		@Override
		public Class getType() {
			return annotationClass;
		}

		public Class getAnnotationClass() {
			return annotationClass;
		}

		@Override
		public  T accept(XAnnotationVisitor visitor) {
			return visitor.visitAnnotationField(this);
		}

		@Override
		public Object getResult() {
			return getValue().getResult();
		}
	}

	public static abstract class XArrayField extends XAnnotationField {
		public XArrayField(String name, T[] value) {
			super(name, value);
			Validate.noNullElements(value,
					"Array must not contain null values.");
		}

		@Override
		public String toString() {
			final StringBuffer sb = new StringBuffer();
			sb.append(getName());
			sb.append("=[");
			final T[] values = getValue();
			for (int index = 0; index < values.length; index++) {
				final T value = values[index];
				if (index > 0) {
					sb.append(", ");
				}
				sb.append(value);
			}
			sb.append("]");
			return sb.toString();
		}

		@Override
		public int hashCode() {
			int hash = 0;
			final String name = getName();
			hash = hash * 37 + name.hashCode();
			final T[] values = getValue();
			for (int index = 0; index < values.length; index++) {
				final T v = values[index];
				hash = hash * 37 + v.hashCode();
			}
			return hash;
		}

		@Override
		public boolean equals(Object obj) {
			if (!(obj instanceof XArrayField)) {
				return false;
			}
			if (this == obj) {
				return true;
			}
			final XArrayField other = (XArrayField) obj;
			if (!getName().equals(other.getName()))
				return false;

			final Object[] lhs = getValue();
			final Object[] rhs = other.getValue();
			if (lhs == rhs) {
				return true;
			}
			if (lhs == null || rhs == null) {
				return false;
			}
			if (lhs.length != rhs.length) {
				return false;
			}
			for (int i = 0; i < lhs.length; ++i) {
				if (!(lhs[i].equals(rhs[i])))
					return false;
			}
			return true;
		}

		@Override
		public Object getResult() {
			return ArrayUtils.asPrimitiveArray(getValue());
		}

	}

	public static abstract class XPrimitiveArrayField extends XArrayField {
		public XPrimitiveArrayField(String name, T[] values) {
			super(name, values);
		}
	}

	public static abstract class XObjectArrayField extends XArrayField {
		public XObjectArrayField(String name, T[] values) {
			super(name, values);
		}
	}

	public static class XBooleanArray extends XPrimitiveArrayField {
		public XBooleanArray(String name, Boolean[] value) {
			super(name, value);
		}

		@Override
		public Class getType() {
			return boolean[].class;
		}

		@Override
		public  T accept(XAnnotationVisitor visitor) {
			return visitor.visitBooleanArrayField(this);
		}
	}

	public static class XByteArray extends XPrimitiveArrayField {
		public XByteArray(String name, Byte[] value) {
			super(name, value);
		}

		@Override
		public Class getType() {
			return byte[].class;
		}

		@Override
		public  T accept(XAnnotationVisitor visitor) {
			return visitor.visitByteArrayField(this);
		}
	}

	public static class XIntArray extends XPrimitiveArrayField {
		public XIntArray(String name, Integer[] value) {
			super(name, value);
		}

		@Override
		public Class getType() {
			return int[].class;
		}

		@Override
		public  T accept(XAnnotationVisitor visitor) {
			return visitor.visitIntArrayField(this);
		}
	}

	public static class XLongArray extends XPrimitiveArrayField {
		public XLongArray(String name, Long[] value) {
			super(name, value);
		}

		@Override
		public Class getType() {
			return long[].class;
		}

		@Override
		public  T accept(XAnnotationVisitor visitor) {
			return visitor.visitLongArrayField(this);
		}
	}

	public static class XShortArray extends XPrimitiveArrayField {
		public XShortArray(String name, Short[] value) {
			super(name, value);
		}

		@Override
		public Class getType() {
			return short[].class;
		}

		@Override
		public  T accept(XAnnotationVisitor visitor) {
			return visitor.visitShortArrayField(this);
		}
	}

	public static class XCharArray extends XPrimitiveArrayField {
		public XCharArray(String name, Character[] value) {
			super(name, value);
		}

		@Override
		public Class getType() {
			return char[].class;
		}

		@Override
		public  T accept(XAnnotationVisitor visitor) {
			return visitor.visitCharArrayField(this);
		}
	}

	public static class XClassArray extends XObjectArrayField {
		public XClassArray(String name, Class[] value) {
			super(name, value);
		}

		@Override
		public Class getType() {
			return Class[].class;
		}

		@Override
		public  T accept(XAnnotationVisitor visitor) {
			return visitor.visitClassArrayField(this);
		}
	}

	public static class XDoubleArray extends XPrimitiveArrayField {
		public XDoubleArray(String name, Double[] value) {
			super(name, value);
		}

		@Override
		public Class getType() {
			return double[].class;
		}

		@Override
		public  T accept(XAnnotationVisitor visitor) {
			return visitor.visitDoubleArrayField(this);
		}

	}

	public static class XFloatArray extends XPrimitiveArrayField {
		public XFloatArray(String name, Float[] value) {
			super(name, value);
		}

		@Override
		public Class getType() {
			return float[].class;
		}

		@Override
		public  T accept(XAnnotationVisitor visitor) {
			return visitor.visitFloatArrayField(this);
		}
	}

	public static class XEnumArray extends XObjectArrayField {

		private final Class enumClass;

		public XEnumArray(String name, Enum[] value,
				Class enumClass) {
			super(name, value);
			Validate.notNull(enumClass, "Enum class must not be null.");
			this.enumClass = enumClass;
		}

		@Override
		public Class getType() {
			return Array.newInstance(enumClass, 0).getClass();
		}

		@Override
		public  T accept(XAnnotationVisitor visitor) {
			return visitor.visitEnumArrayField(this);
		}
	}

	public static class XStringArray extends XObjectArrayField {
		public XStringArray(String name, String[] value) {
			super(name, value);
		}

		@Override
		public Class getType() {
			return String[].class;
		}

		@Override
		public  T accept(XAnnotationVisitor visitor) {
			return visitor.visitStringArrayField(this);
		}
	}

	public static class XAnnotationArray extends
			XObjectArrayField {

		private final Class annotationClass;

		public XAnnotationArray(String name,
				org.jvnet.annox.model.XAnnotation[] value,
				Class annotationClass) {
			super(name, value);
			Validate.notNull(annotationClass,
					"Annotation class must not be null.");
			this.annotationClass = annotationClass;
		}

		@Override
		public Class getType() {
			return Array.newInstance(annotationClass, 0).getClass();
		}

		public Class getAnnotationClass() {
			return annotationClass;
		}

		@Override
		public  T accept(XAnnotationVisitor visitor) {
			return visitor.visitAnnotationArrayField(this);
		}

		@Override
		public Object getResult() {
			final org.jvnet.annox.model.XAnnotation[] value = getValue();
			final Annotation[] result = (Annotation[]) Array.newInstance(
					annotationClass, value.length);
			for (int index = 0; index < value.length; index++) {
				final org.jvnet.annox.model.XAnnotation annotation = value[index];
				result[index] = (Annotation) annotation.getResult();
			}
			return result;
		}
	}
}