Skip to content

Issue 67 #152

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 11 commits into from
Oct 24, 2016
Merged

Issue 67 #152

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
11 commits
Select commit Hold shift + click to select a range
c37c53a
Fix #67 by avoid set of recursive bounds in iterating into nested gen…
Oct 22, 2016
c8aed9f
Remove useless variable len
Oct 22, 2016
7baf708
Move methods from TypeFactory to MapperFacadeImpl, as private methods
Oct 23, 2016
bf02b49
Put public methods on top and private methods on bottom of the class
Oct 24, 2016
34ce8d9
Simplify method
Oct 24, 2016
9cc57be
Make some fields and methods private
Oct 24, 2016
fbc6d87
Simplify if condition
Oct 24, 2016
1ba81b8
Move the most visible method to the top
Oct 24, 2016
91fd284
Revert "Simplify if condition"
Oct 24, 2016
c2f0b1f
Un-ignore tests
Oct 24, 2016
34d116b
Use different iterator name for nested map mapping
Oct 24, 2016
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
124 changes: 80 additions & 44 deletions core/src/main/java/ma/glasnost/orika/impl/MapperFacadeImpl.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -18,31 +18,9 @@

package ma.glasnost.orika.impl;

import static ma.glasnost.orika.StateReporter.DIVIDER;
import static ma.glasnost.orika.StateReporter.humanReadableSizeInMemory;
import static ma.glasnost.orika.util.HashMapUtility.getConcurrentLinkedHashMap;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

import ma.glasnost.orika.Converter;
import ma.glasnost.orika.MapEntry;
import ma.glasnost.orika.Mapper;
import ma.glasnost.orika.MapperFacade;
import ma.glasnost.orika.MapperFactory;
import ma.glasnost.orika.MappingContext;
import ma.glasnost.orika.MappingContextFactory;
import ma.glasnost.orika.MappingException;
import ma.glasnost.orika.MappingStrategy;
import com.googlecode.concurrentlinkedhashmap.ConcurrentLinkedHashMap;
import ma.glasnost.orika.*;
import ma.glasnost.orika.MappingStrategy.Key;
import ma.glasnost.orika.ObjectFactory;
import ma.glasnost.orika.StateReporter.Reportable;
import ma.glasnost.orika.converter.ConverterFactory;
import ma.glasnost.orika.impl.mapping.strategy.MappingStrategyRecorder;
Expand All @@ -51,11 +29,16 @@
import ma.glasnost.orika.metadata.Type;
import ma.glasnost.orika.metadata.TypeFactory;
import ma.glasnost.orika.unenhance.UnenhanceStrategy;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.googlecode.concurrentlinkedhashmap.ConcurrentLinkedHashMap;
import java.lang.reflect.Method;
import java.util.*;
import java.util.Map.Entry;

import static ma.glasnost.orika.StateReporter.DIVIDER;
import static ma.glasnost.orika.StateReporter.humanReadableSizeInMemory;
import static ma.glasnost.orika.util.HashMapUtility.getConcurrentLinkedHashMap;

/**
* MapperFacadeImpl is the base implementation of MapperFacade
Expand Down Expand Up @@ -85,7 +68,7 @@ public MapperFacadeImpl(final MapperFactory mapperFactory, final MappingContextF
this.userUnenhanceStrategy = mapperFactory.getUserUnenhanceStrategy();
this.contextFactory = contextFactory;
}

/**
* Normalize the source type based on the registered converters, mappers and
* accessible super types, as well as available unenhancers
Expand Down Expand Up @@ -117,11 +100,11 @@ private <S, D> Type<S> normalizeSourceType(final S sourceObject, Type<S> sourceT
if (ClassUtil.isConcrete(sourceType)) {
resolvedType = unenhanceStrategy.unenhanceType(sourceObject, sourceType);
} else {
resolvedType = unenhanceStrategy.unenhanceType(sourceObject, TypeFactory.resolveTypeOf(sourceObject, sourceType));
resolvedType = unenhanceStrategy.unenhanceType(sourceObject, resolveTypeOf(sourceObject, sourceType));
}
}
} else {
resolvedType = unenhanceStrategy.unenhanceType(sourceObject, TypeFactory.typeOf(sourceObject));
resolvedType = unenhanceStrategy.unenhanceType(sourceObject, typeOf(sourceObject));
}

return (Type<S>) resolvedType;
Expand Down Expand Up @@ -174,7 +157,7 @@ public <S, D> MappingStrategy resolveMappingStrategy(final S sourceObject, final

@SuppressWarnings("unchecked")
Type<S> sourceType = (Type<S>) (initialSourceType != null ? TypeFactory.valueOf(initialSourceType)
: TypeFactory.typeOf(sourceObject));
: typeOf(sourceObject));
Type<D> destinationType = TypeFactory.valueOf(initialDestinationType);

MappingStrategyRecorder strategyRecorder = new MappingStrategyRecorder(key, unenhanceStrategy);
Expand Down Expand Up @@ -756,56 +739,56 @@ public <S, D> D map(final S sourceObject, final Class<D> destinationClass, final
}

public <S, D> Set<D> mapAsSet(final Iterable<S> source, final Class<D> destinationClass) {
return mapAsSet(source, TypeFactory.elementTypeOf(source), TypeFactory.<D> valueOf(destinationClass));
return mapAsSet(source, elementTypeOf(source), TypeFactory.<D> valueOf(destinationClass));
}

public <S, D> Set<D> mapAsSet(final Iterable<S> source, final Class<D> destinationClass, final MappingContext context) {
return mapAsSet(source, TypeFactory.elementTypeOf(source), TypeFactory.<D> valueOf(destinationClass), context);
return mapAsSet(source, elementTypeOf(source), TypeFactory.<D> valueOf(destinationClass), context);
}

public <S, D> Set<D> mapAsSet(final S[] source, final Class<D> destinationClass) {
return mapAsSet(source, TypeFactory.componentTypeOf(source), TypeFactory.<D> valueOf(destinationClass));
return mapAsSet(source, componentTypeOf(source), TypeFactory.<D> valueOf(destinationClass));
}

public <S, D> Set<D> mapAsSet(final S[] source, final Class<D> destinationClass, final MappingContext context) {
return mapAsSet(source, TypeFactory.componentTypeOf(source), TypeFactory.<D> valueOf(destinationClass), context);
return mapAsSet(source, componentTypeOf(source), TypeFactory.<D> valueOf(destinationClass), context);
}

public <S, D> List<D> mapAsList(final Iterable<S> source, final Class<D> destinationClass) {
return mapAsList(source, TypeFactory.elementTypeOf(source), TypeFactory.<D> valueOf(destinationClass));
return mapAsList(source, elementTypeOf(source), TypeFactory.<D> valueOf(destinationClass));
}

public <S, D> List<D> mapAsList(final Iterable<S> source, final Class<D> destinationClass, final MappingContext context) {
return mapAsList(source, TypeFactory.elementTypeOf(source), TypeFactory.<D> valueOf(destinationClass), context);
return mapAsList(source, elementTypeOf(source), TypeFactory.<D> valueOf(destinationClass), context);
}

public <S, D> List<D> mapAsList(final S[] source, final Class<D> destinationClass) {
return mapAsList(source, TypeFactory.componentTypeOf(source), TypeFactory.<D> valueOf(destinationClass));
return mapAsList(source, componentTypeOf(source), TypeFactory.<D> valueOf(destinationClass));
}

public <S, D> List<D> mapAsList(final S[] source, final Class<D> destinationClass, final MappingContext context) {
return mapAsList(source, TypeFactory.componentTypeOf(source), TypeFactory.<D> valueOf(destinationClass), context);
return mapAsList(source, componentTypeOf(source), TypeFactory.<D> valueOf(destinationClass), context);
}

public <S, D> D[] mapAsArray(final D[] destination, final Iterable<S> source, final Class<D> destinationClass) {
return mapAsArray(destination, source, TypeFactory.elementTypeOf(source), TypeFactory.<D> valueOf(destinationClass));
return mapAsArray(destination, source, elementTypeOf(source), TypeFactory.<D> valueOf(destinationClass));
}

public <S, D> D[] mapAsArray(final D[] destination, final S[] source, final Class<D> destinationClass) {
return mapAsArray(destination, source, TypeFactory.componentTypeOf(source), TypeFactory.<D> valueOf(destinationClass));
return mapAsArray(destination, source, componentTypeOf(source), TypeFactory.<D> valueOf(destinationClass));
}

public <S, D> D[] mapAsArray(final D[] destination, final Iterable<S> source, final Class<D> destinationClass,
final MappingContext context) {
return mapAsArray(destination, source, TypeFactory.elementTypeOf(source), TypeFactory.<D> valueOf(destinationClass), context);
return mapAsArray(destination, source, elementTypeOf(source), TypeFactory.<D> valueOf(destinationClass), context);
}

public <S, D> D[] mapAsArray(final D[] destination, final S[] source, final Class<D> destinationClass, final MappingContext context) {
return mapAsArray(destination, source, TypeFactory.componentTypeOf(source), TypeFactory.<D> valueOf(destinationClass), context);
return mapAsArray(destination, source, componentTypeOf(source), TypeFactory.<D> valueOf(destinationClass), context);
}

public <S, D> D convert(final S source, final Class<D> destinationClass, final String converterId, MappingContext context) {
return convert(source, TypeFactory.typeOf(source), TypeFactory.<D> valueOf(destinationClass), converterId, context);
return convert(source, typeOf(source), TypeFactory.<D> valueOf(destinationClass), converterId, context);
}

public <Sk, Sv, Dk, Dv> Map<Dk, Dv> mapAsMap(final Map<Sk, Sv> source, final Type<? extends Map<Sk, Sv>> sourceType,
Expand Down Expand Up @@ -1007,7 +990,7 @@ public <Sk, Sv, D> Set<D> mapAsSet(final Map<Sk, Sv> source, final Type<? extend
* existing mapping for Map.Entry to to type D.
*/
Set<D> destination = new HashSet<D>(source.size());
Type<Entry<Sk, Sv>> entryType = TypeFactory.resolveTypeOf(source.entrySet(), sourceType).getNestedType(0);
Type<Entry<Sk, Sv>> entryType = resolveTypeOf(source.entrySet(), sourceType).getNestedType(0);
return (Set<D>) mapAsCollection(source.entrySet(), entryType, destinationType, destination, context);
}

Expand Down Expand Up @@ -1102,5 +1085,58 @@ public void reportCurrentState(StringBuilder out) {
out.append(DIVIDER);
out.append("\nUnenhance strategy: ").append(unenhanceStrategy);
}

/**
* Return the Type for the given object.
*
* @param object
* @return the resolved Type instance
*/
@SuppressWarnings("unchecked")
private <T> Type<T> typeOf(final T object) {
return object == null ? null : TypeFactory.valueOf((Class<T>) object.getClass());
}

/**
* Resolve the (element) component type for the given array.
*
* @param object
* @return the resolved Type instance
*/
@SuppressWarnings("unchecked")
private <T> Type<T> componentTypeOf(final T[] object) {
return object == null ? null : TypeFactory.valueOf((Class<T>) object.getClass().getComponentType());
}

/**
* Resolve the Type for the given object, using the provided referenceType
* to resolve the actual type arguments.
*
* @param object
* @param referenceType
* @return the resolved Type instance
*/
@SuppressWarnings("unchecked")
private <T> Type<T> resolveTypeOf(final T object, Type<?> referenceType) {
return object == null ? null : TypeFactory.resolveValueOf((Class<T>) object.getClass(), referenceType);
}

/**
* Resolve the nested element type for the given Iterable.
*
* @param object
* @return the resolved Type instance
*/
private <T> Type<T> elementTypeOf(final Iterable<T> object) {
try {
Method iterator = object.getClass().getMethod("iterator");
Type<Iterable<T>> type = TypeFactory.valueOf(iterator.getGenericReturnType());
return type.getNestedType(0);
} catch (SecurityException e) {
throw new IllegalStateException(e);
} catch (NoSuchMethodException e) {
throw new IllegalStateException(e);
}
}

}
20 changes: 10 additions & 10 deletions core/src/main/java/ma/glasnost/orika/impl/generator/specification/MapToMap.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -18,12 +18,6 @@

package ma.glasnost.orika.impl.generator.specification;

import static java.lang.String.format;
import static ma.glasnost.orika.impl.generator.SourceCodeContext.append;
import static ma.glasnost.orika.impl.generator.SourceCodeContext.statement;

import java.util.Map;

import ma.glasnost.orika.impl.generator.MapEntryRef;
import ma.glasnost.orika.impl.generator.MapEntryRef.EntryPart;
import ma.glasnost.orika.impl.generator.MultiOccurrenceVariableRef;
Expand All @@ -34,6 +28,12 @@
import ma.glasnost.orika.metadata.FieldMapBuilder;
import ma.glasnost.orika.metadata.TypeFactory;

import java.util.Map;

import static java.lang.String.format;
import static ma.glasnost.orika.impl.generator.SourceCodeContext.append;
import static ma.glasnost.orika.impl.generator.SourceCodeContext.statement;

/**
* MapToMap handles conversion of a Map to another Map
*
Expand Down Expand Up @@ -67,8 +67,7 @@ public String generateMappingCode(FieldMap fieldMap, VariableRef source, Variabl
out.append(statement(newDest.declare(d)));
out.append(statement("%s.clear()", newDest));
}



VariableRef newKey = new VariableRef(d.mapKeyType(), "new" + StringUtil.capitalize(d.name()) + "Key");
VariableRef newVal = new VariableRef(d.mapValueType(), "new" + StringUtil.capitalize(d.name()) + "Val");
VariableRef entry = new VariableRef(TypeFactory.valueOf(Map.Entry.class), "source" + StringUtil.capitalize(d.name()) + "Entry");
Expand All @@ -78,9 +77,10 @@ public String generateMappingCode(FieldMap fieldMap, VariableRef source, Variabl
* Loop through the individual entries, map key/value and then put
* them into the destination
*/

append(out,
format("for( java.util.Iterator entryIter = %s.entrySet().iterator(); entryIter.hasNext(); ) {\n", s),
entry.declare("entryIter.next()"),
format("for( %s; %s; ) { \n", s.declareIterator(), s.iteratorHasNext()),
entry.declare(s.nextElement()),
newKey.declare(),
newVal.declare(),
code.mapFields(FieldMapBuilder.mapKeys(s.mapKeyType(), d.mapKeyType()), sourceKey, newKey),
Expand Down
Loading