@SuppressWarnings("rawtypes")
@Override
public final E map(R record) {
try {
E result = instance != null ? instance : constructor.newInstance();
for (int i = 0; i < fields.length; i++) {
for (java.lang.reflect.Field member : members[i]) {
// [#935] Avoid setting final fields
if ((member.getModifiers() & Modifier.FINAL) == 0) {
map(record, result, member, i);
}
}
for (java.lang.reflect.Method method : methods[i]) {
Class<?> mType = method.getParameterTypes()[0];
Object value = record.getValue(i, mType);
// [#3082] Map nested collection types
if (value instanceof Collection && List.class.isAssignableFrom(mType)) {
Class componentType =
(Class)
((ParameterizedType) method.getGenericParameterTypes()[0])
.getActualTypeArguments()[0];
method.invoke(result, Convert.convert((Collection) value, componentType));
}
// Default reference types (including arrays)
else {
method.invoke(result, record.getValue(i, mType));
}
}
}
for (Entry<String, List<RecordMapper<R, Object>>> entry : nested.entrySet()) {
String prefix = entry.getKey();
for (RecordMapper<R, Object> mapper : entry.getValue()) {
Object value = mapper.map(record);
for (java.lang.reflect.Field member : getMatchingMembers(configuration, type, prefix)) {
// [#935] Avoid setting final fields
if ((member.getModifiers() & Modifier.FINAL) == 0) {
map(value, result, member);
}
}
for (Method method : getMatchingSetters(configuration, type, prefix)) {
method.invoke(result, value);
}
}
}
return result;
} catch (Exception e) {
throw new MappingException("An error ocurred when mapping record to " + type, e);
}
}
@Override
public final E map(R record) {
try {
for (int i = 0; i < fields.length; i++) {
if (propertyIndexes[i] != null) {
parameterValues[propertyIndexes[i]] = record.getValue(i);
} else {
for (java.lang.reflect.Field member : members[i]) {
int index = propertyNames.indexOf(member.getName());
if (index >= 0) {
parameterValues[index] = record.getValue(i);
}
}
if (methods[i] != null) {
String name = getPropertyName(methods[i].getName());
int index = propertyNames.indexOf(name);
if (index >= 0) {
parameterValues[index] = record.getValue(i);
}
}
}
}
Object[] converted = Convert.convert(parameterValues, parameterTypes);
return accessible(constructor).newInstance(converted);
} catch (Exception e) {
throw new MappingException("An error ocurred when mapping record to " + type, e);
}
}
@SuppressWarnings("unchecked")
@Override
public final <K, V> Map<K, V> intoMap(Field<K> key, Field<V> value) {
int kIndex = fieldsRow().indexOf(key);
int vIndex = fieldsRow().indexOf(value);
Map<K, V> map = new LinkedHashMap<K, V>();
for (R record : this) {
if (map.put((K) record.getValue(kIndex), (V) record.getValue(vIndex)) != null) {
throw new InvalidResultException("Key " + key + " is not unique in Result for " + this);
}
}
return map;
}
@Override
public Object map(R record) {
AbstractRecord copy = (AbstractRecord) DSL.using(configuration).newRecord(f);
for (int i = 0; i < f.length; i++) if (f[i] != null) copy.setValue(i, record.getValue(i));
return d.map(record);
}
@Override
public final E map(R record) {
int size = record.size();
if (size != 1)
throw new MappingException(
"Cannot map multi-column record of degree " + size + " to value type " + type);
return record.getValue(0, type);
}
/** Extract a list of values from a set of records given some fields */
private static <R extends Record> List<Object> extractValues(
Collection<? extends R> records, TableField<R, ?> field2) {
List<Object> result = new ArrayList<Object>();
for (R record : records) {
result.add(record.getValue(field2));
}
return result;
}
@Override
public final List<?> getValues(int fieldIndex) {
List<Object> result = new ArrayList<Object>(size());
for (R record : this) {
result.add(record.getValue(fieldIndex));
}
return result;
}
@SuppressWarnings("unchecked")
@Override
public final <K, E> Map<K, E> intoMap(Field<K> key, Class<? extends E> type) {
int index = getIndex(key);
Map<K, E> map = new LinkedHashMap<K, E>();
for (R record : this) {
if (map.put((K) record.getValue(index), record.into(type)) != null) {
throw new InvalidResultException("Key " + key + " is not unique in Result for " + this);
}
}
return map;
}
@SuppressWarnings("unchecked")
@Override
public final <K, E> Map<K, E> intoMap(Field<K> key, Class<? extends E> type) {
RecordMapper<R, E> mapper = new ReflectionMapper<R, E>(fields.fields, type);
int index = fieldsRow().indexOf(key);
Map<K, E> map = new LinkedHashMap<K, E>();
for (R record : this) {
if (map.put((K) record.getValue(index), mapper.map(record)) != null) {
throw new InvalidResultException("Key " + key + " is not unique in Result for " + this);
}
}
return map;
}
/** Extract a list of row value expressions from a set of records given some fields */
private static <R extends Record> List<RowN> extractRows(
Collection<? extends R> records, TableField<R, ?>[] fields) {
List<RowN> rows = new ArrayList<RowN>();
for (R record : records) {
Object[] values = new Object[fields.length];
for (int i = 0; i < fields.length; i++) {
values[i] = record.getValue(fields[i]);
}
rows.add(row(values));
}
return rows;
}
@Override
public final E map(R record) {
int size = record.size();
Class<?> componentType = type.getComponentType();
Object[] result =
(Object[]) (instance != null ? instance : Array.newInstance(componentType, size));
// Just as in Collection.toArray(Object[]), return a new array in case
// sizes don't match
if (size > result.length) {
result = (Object[]) Array.newInstance(componentType, size);
}
for (int i = 0; i < size; i++) {
result[i] = Convert.convert(record.getValue(i), componentType);
}
return (E) result;
}
@SuppressWarnings("unchecked")
@Override
public final <K> Map<K, Result<R>> intoGroups(Field<K> key) {
int index = fieldsRow().indexOf(key);
Map<K, Result<R>> map = new LinkedHashMap<K, Result<R>>();
for (R record : this) {
K val = (K) record.getValue(index);
Result<R> result = map.get(val);
if (result == null) {
result = new ResultImpl<R>(configuration, fields);
map.put(val, result);
}
result.add(record);
}
return map;
}
@SuppressWarnings("unchecked")
@Override
public final <K, E> Map<K, List<E>> intoGroups(Field<K> key, Class<? extends E> type) {
int index = getIndex(key);
Map<K, List<E>> map = new LinkedHashMap<K, List<E>>();
for (R record : this) {
K keyVal = (K) record.getValue(index);
List<E> list = map.get(keyVal);
if (list == null) {
list = new ArrayList<E>();
map.put(keyVal, list);
}
list.add(record.into(type));
}
return map;
}
@SuppressWarnings("unchecked")
@Override
public final <K, E> Map<K, List<E>> intoGroups(Field<K> key, Class<? extends E> type) {
RecordMapper<R, E> mapper = new ReflectionMapper<R, E>(fields.fields, type);
int index = fieldsRow().indexOf(key);
Map<K, List<E>> map = new LinkedHashMap<K, List<E>>();
for (R record : this) {
K keyVal = (K) record.getValue(index);
List<E> list = map.get(keyVal);
if (list == null) {
list = new ArrayList<E>();
map.put(keyVal, list);
}
list.add(mapper.map(record));
}
return map;
}
@Override
public final <E> Map<List<?>, E> intoMap(Field<?>[] keys, Class<? extends E> type) {
if (keys == null) {
keys = new Field[0];
}
Map<List<?>, E> map = new LinkedHashMap<List<?>, E>();
for (R record : this) {
List<Object> keyValueList = new ArrayList<Object>();
for (Field<?> key : keys) {
keyValueList.add(record.getValue(key));
}
if (map.put(keyValueList, record.into(type)) != null) {
throw new InvalidResultException(
"Key list " + keyValueList + " is not unique in Result for " + this);
}
}
return map;
}
@SuppressWarnings("unchecked")
@Override
public final <K, V> Map<K, List<V>> intoGroups(Field<K> key, Field<V> value) {
int kIndex = fieldsRow().indexOf(key);
int vIndex = fieldsRow().indexOf(value);
Map<K, List<V>> map = new LinkedHashMap<K, List<V>>();
for (R record : this) {
K k = (K) record.getValue(kIndex);
V v = (V) record.getValue(vIndex);
List<V> result = map.get(k);
if (result == null) {
result = new ArrayList<V>();
map.put(k, result);
}
result.add(v);
}
return map;
}
@Override
public final Object fetchOne(String fieldName) {
R record = fetchOne();
return record == null ? null : record.getValue(fieldName);
}
@Override
public final Object fetchOne(int fieldIndex) {
R record = fetchOne();
return record == null ? null : record.getValue(fieldIndex);
}
@Override
public final <T> T fetchOne(Field<T> field) {
R record = fetchOne();
return record == null ? null : record.getValue(field);
}
final <T> void addValue(R record, Field<T> field) {
addValue(field, record.getValue(field));
}
@SuppressWarnings("unchecked")
@Override
public int compare(R record1, R record2) {
return comparator.compare((T) record1.getValue(fieldIndex), (T) record2.getValue(fieldIndex));
}