/**
* Copyright 2011-2014 Asakusa Framework Team.
*
* 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 com.asakusafw.testdriver.model;
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.asakusafw.runtime.model.PropertyOrder;
import com.asakusafw.runtime.value.BooleanOption;
import com.asakusafw.runtime.value.ByteOption;
import com.asakusafw.runtime.value.Date;
import com.asakusafw.runtime.value.DateOption;
import com.asakusafw.runtime.value.DateTime;
import com.asakusafw.runtime.value.DateTimeOption;
import com.asakusafw.runtime.value.DecimalOption;
import com.asakusafw.runtime.value.DoubleOption;
import com.asakusafw.runtime.value.FloatOption;
import com.asakusafw.runtime.value.IntOption;
import com.asakusafw.runtime.value.LongOption;
import com.asakusafw.runtime.value.ShortOption;
import com.asakusafw.runtime.value.StringOption;
import com.asakusafw.runtime.value.ValueOption;
import com.asakusafw.testdriver.core.DataModelDefinition;
import com.asakusafw.testdriver.core.DataModelReflection;
import com.asakusafw.testdriver.core.PropertyName;
import com.asakusafw.testdriver.core.PropertyType;
/**
* Default implementation of {@link DataModelDefinition}.
* @param <T> type of data model class
* @since 0.2.0
* @see DefaultDataModelAdapter
*/
public class DefaultDataModelDefinition<T> implements DataModelDefinition<T> {
static final Logger LOG = LoggerFactory.getLogger(DefaultDataModelDefinition.class);
private static final Map<Class<?>, ValueDriver<?>> VALUE_DRIVERS;
static {
Map<Class<?>, ValueDriver<?>> map = new HashMap<Class<?>, ValueDriver<?>>();
map.put(BooleanOption.class, new ValueDriver<BooleanOption>(PropertyType.BOOLEAN) {
@SuppressWarnings("deprecation")
@Override
void modify(BooleanOption holder, Object value) {
holder.modify(cast(Boolean.class, value));
}
@Override
Object extract(BooleanOption holder) {
return holder.get();
}
});
map.put(ByteOption.class, new ValueDriver<ByteOption>(PropertyType.BYTE) {
@SuppressWarnings("deprecation")
@Override
void modify(ByteOption holder, Object value) {
holder.modify(cast(Number.class, value).byteValue());
}
@Override
Object extract(ByteOption holder) {
return holder.get();
}
});
map.put(ShortOption.class, new ValueDriver<ShortOption>(PropertyType.SHORT) {
@SuppressWarnings("deprecation")
@Override
void modify(ShortOption holder, Object value) {
holder.modify(cast(Number.class, value).shortValue());
}
@Override
Object extract(ShortOption holder) {
return holder.get();
}
});
map.put(IntOption.class, new ValueDriver<IntOption>(PropertyType.INT) {
@SuppressWarnings("deprecation")
@Override
void modify(IntOption holder, Object value) {
holder.modify(cast(Number.class, value).intValue());
}
@Override
Object extract(IntOption holder) {
return holder.get();
}
});
map.put(LongOption.class, new ValueDriver<LongOption>(PropertyType.LONG) {
@SuppressWarnings("deprecation")
@Override
void modify(LongOption holder, Object value) {
holder.modify(cast(Number.class, value).longValue());
}
@Override
Object extract(LongOption holder) {
return holder.get();
}
});
map.put(FloatOption.class, new ValueDriver<FloatOption>(PropertyType.FLOAT) {
@SuppressWarnings("deprecation")
@Override
void modify(FloatOption holder, Object value) {
holder.modify(cast(Number.class, value).floatValue());
}
@Override
Object extract(FloatOption holder) {
return holder.get();
}
});
map.put(DoubleOption.class, new ValueDriver<DoubleOption>(PropertyType.DOUBLE) {
@SuppressWarnings("deprecation")
@Override
void modify(DoubleOption holder, Object value) {
holder.modify(cast(Number.class, value).doubleValue());
}
@Override
Object extract(DoubleOption holder) {
return holder.get();
}
});
map.put(DecimalOption.class, new ValueDriver<DecimalOption>(PropertyType.DECIMAL) {
@SuppressWarnings("deprecation")
@Override
void modify(DecimalOption holder, Object value) {
holder.modify(cast(BigDecimal.class, value));
}
@Override
Object extract(DecimalOption holder) {
return holder.get();
}
});
map.put(StringOption.class, new ValueDriver<StringOption>(PropertyType.STRING) {
@SuppressWarnings("deprecation")
@Override
void modify(StringOption holder, Object value) {
holder.modify(cast(String.class, value));
}
@Override
Object extract(StringOption holder) {
return holder.getAsString();
}
});
map.put(DateOption.class, new ValueDriver<DateOption>(PropertyType.DATE) {
@SuppressWarnings("deprecation")
@Override
void modify(DateOption holder, Object value) {
Calendar calendar = (Calendar) value;
holder.modify(new Date(
calendar.get(Calendar.YEAR),
calendar.get(Calendar.MONTH) + 1,
calendar.get(Calendar.DATE)));
}
@Override
Object extract(DateOption holder) {
Calendar calendar = Calendar.getInstance();
calendar.clear();
calendar.set(Calendar.YEAR, holder.get().getYear());
calendar.set(Calendar.MONTH, holder.get().getMonth() - 1);
calendar.set(Calendar.DATE, holder.get().getDay());
return calendar;
}
});
map.put(DateTimeOption.class, new ValueDriver<DateTimeOption>(PropertyType.DATETIME) {
@SuppressWarnings("deprecation")
@Override
void modify(DateTimeOption holder, Object value) {
Calendar calendar = (Calendar) value;
holder.modify(new DateTime(
calendar.get(Calendar.YEAR),
calendar.get(Calendar.MONTH) + 1,
calendar.get(Calendar.DATE),
calendar.get(Calendar.HOUR_OF_DAY),
calendar.get(Calendar.MINUTE),
calendar.get(Calendar.SECOND)));
}
@Override
Object extract(DateTimeOption holder) {
Calendar calendar = Calendar.getInstance();
calendar.clear();
calendar.set(Calendar.YEAR, holder.get().getYear());
calendar.set(Calendar.MONTH, holder.get().getMonth() - 1);
calendar.set(Calendar.DATE, holder.get().getDay());
calendar.set(Calendar.HOUR_OF_DAY, holder.get().getHour());
calendar.set(Calendar.MINUTE, holder.get().getMinute());
calendar.set(Calendar.SECOND, holder.get().getSecond());
return calendar;
}
});
VALUE_DRIVERS = Collections.unmodifiableMap(map);
}
private final Class<T> modelClass;
private final Map<PropertyName, Method> accessors;
/**
* Creates a new instance.
* @param modelClass the original model class
* @throws IllegalArgumentException if some parameters were {@code null}
*/
public DefaultDataModelDefinition(Class<T> modelClass) {
if (modelClass == null) {
throw new IllegalArgumentException("modelClass must not be null"); //$NON-NLS-1$
}
this.modelClass = modelClass;
this.accessors = extractAccessors();
}
private Map<PropertyName, Method> extractAccessors() {
Map<PropertyName, Method> results = new TreeMap<PropertyName, Method>();
for (Method method : modelClass.getMethods()) {
if (VALUE_DRIVERS.containsKey(method.getReturnType()) == false) {
continue;
}
PropertyName property = getPropertyNameIfAccessor(method);
if (property == null) {
continue;
}
results.put(property, method);
}
PropertyOrder annotation = modelClass.getAnnotation(PropertyOrder.class);
if (annotation == null) {
LOG.info("Annotation {} is not defined in {}",
PropertyOrder.class.getSimpleName(),
modelClass.getName());
return results;
}
Map<PropertyName, Method> ordered = new LinkedHashMap<PropertyName, Method>();
for (String name : annotation.value()) {
String[] words = name.split("(_|-)+");
PropertyName propertyName = PropertyName.newInstance(words);
Method method = results.remove(propertyName);
if (method == null) {
LOG.warn("Property {} is not found in {}", name, modelClass.getName());
} else {
ordered.put(propertyName, method);
}
}
if (results.isEmpty() == false) {
LOG.warn("Property {} is not declared its order in {}", results.keySet(), modelClass.getName());
ordered.putAll(results);
}
return ordered;
}
private static final Pattern PROPERTY_ACCESSOR = Pattern.compile("get([A-Z]\\w*)Option"); //$NON-NLS-1$
private PropertyName getPropertyNameIfAccessor(Method method) {
assert method != null;
Matcher matcher = PROPERTY_ACCESSOR.matcher(method.getName());
if (matcher.matches() == false) {
return null;
}
String name = matcher.group(1);
List<String> words = new ArrayList<String>();
int start = 0;
for (int i = 1, n = name.length(); i < n; i++) {
char c = name.charAt(i);
if ('A' <= c && c <= 'Z') {
words.add(name.substring(start, i));
start = i;
}
}
words.add(name.substring(start));
return PropertyName.newInstance(words);
}
@Override
public Class<T> getModelClass() {
return modelClass;
}
@Override
public <A extends Annotation> A getAnnotation(Class<A> annotationType) {
if (annotationType == null) {
throw new IllegalArgumentException("annotationType must not be null"); //$NON-NLS-1$
}
return modelClass.getAnnotation(annotationType);
}
@Override
public Collection<PropertyName> getProperties() {
return Collections.unmodifiableCollection(accessors.keySet());
}
@Override
public PropertyType getType(PropertyName name) {
if (name == null) {
throw new IllegalArgumentException("name must not be null"); //$NON-NLS-1$
}
Method accessor = accessors.get(name);
if (accessor == null) {
return null;
}
ValueDriver<?> driver = VALUE_DRIVERS.get(accessor.getReturnType());
if (driver == null) {
throw new AssertionError(accessor.getReturnType());
}
return driver.valueType;
}
@Override
public <A extends Annotation> A getAnnotation(PropertyName name, Class<A> annotationType) {
if (name == null) {
throw new IllegalArgumentException("name must not be null"); //$NON-NLS-1$
}
if (annotationType == null) {
throw new IllegalArgumentException("annotationType must not be null"); //$NON-NLS-1$
}
Method accessor = accessors.get(name);
if (accessor == null) {
return null;
}
return accessor.getAnnotation(annotationType);
}
@Override
public Builder<T> newReflection() {
return new Builder<T>(this);
}
@Override
public DataModelReflection toReflection(T object) {
Builder<T> builder = newReflection();
try {
for (Map.Entry<PropertyName, Method> entry : accessors.entrySet()) {
PropertyName property = entry.getKey();
Method accessor = entry.getValue();
Object value = get(object, accessor);
builder.add(property, value);
}
} catch (Exception e) {
throw new AssertionError(e);
}
return builder.build();
}
@Override
public T toObject(DataModelReflection reflection) {
try {
T instance = modelClass.newInstance();
for (Map.Entry<PropertyName, Method> entry : accessors.entrySet()) {
PropertyName property = entry.getKey();
Method accessor = entry.getValue();
Object value = reflection.getValue(property);
set(instance, accessor, value);
}
return instance;
} catch (Exception e) {
throw new AssertionError(e);
}
}
private Object get(T instance, Method property) {
assert instance != null;
assert property != null;
ValueOption<?> holder = getHolder(instance, property);
if (holder.isNull()) {
return null;
}
ValueDriver<?> driver = VALUE_DRIVERS.get(property.getReturnType());
assert driver != null : property;
return driver.extractUnsafe(holder);
}
@SuppressWarnings("deprecation")
private void set(T instance, Method property, Object value) {
assert instance != null;
assert property != null;
ValueOption<?> holder = getHolder(instance, property);
if (value == null) {
holder.setNull();
} else {
ValueDriver<?> driver = VALUE_DRIVERS.get(property.getReturnType());
assert driver != null : property;
driver.modifyUnsafe(holder, value);
}
}
private ValueOption<?> getHolder(T instance, Method property) {
assert instance != null;
assert property != null;
try {
return (ValueOption<?>) property.invoke(instance);
} catch (Exception e) {
throw new AssertionError(e);
}
}
abstract static class ValueDriver<T> {
final PropertyType valueType;
ValueDriver(PropertyType valueType) {
assert valueType != null;
this.valueType = valueType;
}
@SuppressWarnings("unchecked")
Object extractUnsafe(Object holder) {
return extract((T) holder);
}
@SuppressWarnings("unchecked")
void modifyUnsafe(Object holder, Object value) {
modify((T) holder, value);
}
abstract Object extract(T holder);
abstract void modify(T holder, Object value);
protected <V> V cast(Class<V> type, Object value) {
if (type.isInstance(value) == false) {
throw new IllegalArgumentException();
}
return type.cast(value);
}
}
}