-/*******************************************************************************\r
- * Copyright (c) 2010 Association for Decentralized Information Management in\r
- * Industry THTH ry.\r
- * All rights reserved. This program and the accompanying materials\r
- * are made available under the terms of the Eclipse Public License v1.0\r
- * which accompanies this distribution, and is available at\r
- * http://www.eclipse.org/legal/epl-v10.html\r
- *\r
- * Contributors:\r
- * VTT Technical Research Centre of Finland - initial API and implementation\r
- *******************************************************************************/\r
+/*******************************************************************************
+ * Copyright (c) 2010 Association for Decentralized Information Management in
+ * Industry THTH ry.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * VTT Technical Research Centre of Finland - initial API and implementation
+ *******************************************************************************/
package org.simantics.databoard.adapter;
-import java.util.ArrayList;\r
-import java.util.Map;\r
-\r
-import org.apache.commons.collections.map.ReferenceMap;\r
-import org.simantics.databoard.Bindings;\r
-import org.simantics.databoard.Units;\r
-import org.simantics.databoard.binding.ArrayBinding;\r
-import org.simantics.databoard.binding.Binding;\r
-import org.simantics.databoard.binding.BooleanBinding;\r
-import org.simantics.databoard.binding.MapBinding;\r
-import org.simantics.databoard.binding.NumberBinding;\r
-import org.simantics.databoard.binding.OptionalBinding;\r
-import org.simantics.databoard.binding.RecordBinding;\r
-import org.simantics.databoard.binding.StringBinding;\r
-import org.simantics.databoard.binding.UnionBinding;\r
-import org.simantics.databoard.binding.VariantBinding;\r
-import org.simantics.databoard.binding.error.BindingException;\r
-import org.simantics.databoard.binding.error.RuntimeBindingException;\r
-import org.simantics.databoard.binding.impl.ArrayListBinding;\r
-import org.simantics.databoard.binding.impl.BooleanArrayBinding;\r
-import org.simantics.databoard.binding.impl.ByteArrayBinding;\r
-import org.simantics.databoard.binding.impl.DoubleArrayBinding;\r
-import org.simantics.databoard.binding.impl.FloatArrayBinding;\r
-import org.simantics.databoard.binding.impl.IntArrayBinding;\r
-import org.simantics.databoard.binding.impl.LongArrayBinding;\r
-import org.simantics.databoard.type.ArrayType;\r
-import org.simantics.databoard.type.NumberType;\r
-import org.simantics.databoard.type.RecordType;\r
-import org.simantics.databoard.type.UnionType;\r
-import org.simantics.databoard.units.IUnitConverter;\r
-import org.simantics.databoard.units.IdentityConverter;\r
-import org.simantics.databoard.units.internal.UnitParseException;\r
-import org.simantics.databoard.util.ObjectUtils;\r
+import java.util.ArrayList;
+import java.util.Map;
+
+import org.apache.commons.collections4.map.AbstractReferenceMap.ReferenceStrength;
+import org.apache.commons.collections4.map.ReferenceMap;
+import org.simantics.databoard.Units;
+import org.simantics.databoard.binding.ArrayBinding;
+import org.simantics.databoard.binding.Binding;
+import org.simantics.databoard.binding.BooleanBinding;
+import org.simantics.databoard.binding.MapBinding;
+import org.simantics.databoard.binding.NumberBinding;
+import org.simantics.databoard.binding.OptionalBinding;
+import org.simantics.databoard.binding.RecordBinding;
+import org.simantics.databoard.binding.StringBinding;
+import org.simantics.databoard.binding.UnionBinding;
+import org.simantics.databoard.binding.VariantBinding;
+import org.simantics.databoard.binding.error.BindingException;
+import org.simantics.databoard.binding.error.RuntimeBindingException;
+import org.simantics.databoard.binding.impl.ArrayListBinding;
+import org.simantics.databoard.binding.impl.BooleanArrayBinding;
+import org.simantics.databoard.binding.impl.ByteArrayBinding;
+import org.simantics.databoard.binding.impl.DoubleArrayBinding;
+import org.simantics.databoard.binding.impl.FloatArrayBinding;
+import org.simantics.databoard.binding.impl.IntArrayBinding;
+import org.simantics.databoard.binding.impl.LongArrayBinding;
+import org.simantics.databoard.type.ArrayType;
+import org.simantics.databoard.type.NumberType;
+import org.simantics.databoard.type.RecordType;
+import org.simantics.databoard.type.UnionType;
+import org.simantics.databoard.units.IUnitConverter;
+import org.simantics.databoard.units.IdentityConverter;
+import org.simantics.databoard.units.internal.UnitParseException;
+import org.simantics.databoard.util.ObjectUtils;
/**
* AdapterRepository is a factory and a collection of adapters.
*/
public class AdapterFactory {
- @SuppressWarnings( "unchecked" )\r
- Map<AdapterRequest, AbstractAdapter> cache = (Map<AdapterRequest, AbstractAdapter>) new ReferenceMap(ReferenceMap.SOFT, ReferenceMap.HARD);
-
+ Map<AdapterRequest, AbstractAdapter> cache = new ReferenceMap<>(ReferenceStrength.SOFT, ReferenceStrength.HARD);
+
public synchronized Adapter getAdapter(Binding domain, Binding range, boolean typeAdapter, boolean mustClone)
throws AdapterConstructionException
{
- if ((!mustClone || domain.isImmutable()) && domain.equals(range)) return PassThruAdapter.PASSTHRU;\r
- \r
- if (domain.getClass() == range.getClass() &&\r
- ( !mustClone || domain.isImmutable() ) &&\r
- NumberBinding.class.isAssignableFrom( domain.getClass() ) ) {\r
- \r
- NumberBinding db = (NumberBinding) domain;\r
- NumberBinding rb = (NumberBinding) range;\r
- String u1 = db.type().getUnit();\r
- String u2 = rb.type().getUnit();\r
- if (u1==null || u2==null || u1.equals("") || u2.equals("") || u1.equals(u2)) return PassThruAdapter.PASSTHRU;\r
- }\r
+ if ((!mustClone || domain.isImmutable()) && domain.equals(range)) return PassThruAdapter.PASSTHRU;
+
+ if (domain.getClass() == range.getClass() &&
+ ( !mustClone || domain.isImmutable() ) &&
+ NumberBinding.class.isAssignableFrom( domain.getClass() ) ) {
+
+ NumberBinding db = (NumberBinding) domain;
+ NumberBinding rb = (NumberBinding) range;
+ String u1 = db.type().getUnit();
+ String u2 = rb.type().getUnit();
+ if (u1==null || u2==null || u1.equals("") || u2.equals("") || u1.equals(u2)) return PassThruAdapter.PASSTHRU;
+ }
return getAdapterUnsynchronized(domain, range, typeAdapter, mustClone);
- }\r
+ }
private AbstractAdapter getCached(AdapterRequest type)
{
cache.put(type, binding);
}
- private void addToCache(AdapterRequest request, AbstractAdapter impl) {\r
+ private void addToCache(AdapterRequest request, AbstractAdapter impl) {
impl.request = request;
cache(request, impl);
final RecordBinding domainRecord = (RecordBinding) domain;
final RecordBinding rangeRecord = (RecordBinding) range;
RecordType domainType = domainRecord.type();
- RecordType rangeType = rangeRecord.type(); \r
- \r
+ RecordType rangeType = rangeRecord.type();
+
// Field-Map describes the index of the fields in domain for each field in range
boolean requiresTypeAdapting = domainType.getComponentCount() != rangeType.getComponentCount();
int fieldMap[] = new int[rangeType.getComponentCount()];
for (int rangeIndex=0; rangeIndex<fieldMap.length; rangeIndex++)
{
String fieldName = rangeType.getComponent(rangeIndex).name;
- Integer domainIndex = domainType.getComponentIndex(fieldName);\r
- if (domainIndex!=null) {\r
- fieldMap[rangeIndex] = domainIndex;\r
- requiresTypeAdapting |= rangeIndex != domainIndex;\r
- } else {\r
- fieldMap[rangeIndex] = -1;\r
- requiresTypeAdapting = true;\r
+ Integer domainIndex = domainType.getComponentIndex(fieldName);
+ if (domainIndex!=null) {
+ fieldMap[rangeIndex] = domainIndex;
+ requiresTypeAdapting |= rangeIndex != domainIndex;
+ } else {
+ fieldMap[rangeIndex] = -1;
+ requiresTypeAdapting = true;
}
}
Object values[] = new Object[len];
for (int rangeIndex=0; rangeIndex<len; rangeIndex++)
{
- int domainIndex = _fieldMap[rangeIndex];\r
- if (domainIndex>=0) {\r
- Object srcValue = domainRecord.getComponent(src, domainIndex);\r
- Object dstValue = componentAdapters[rangeIndex].adapt(srcValue);\r
- values[rangeIndex] = dstValue;\r
- } else {\r
- // Optional value\r
- values[rangeIndex] = rangeRecord.componentBindings[rangeIndex].createDefault();\r
+ int domainIndex = _fieldMap[rangeIndex];
+ if (domainIndex>=0) {
+ Object srcValue = domainRecord.getComponent(src, domainIndex);
+ Object dstValue = componentAdapters[rangeIndex].adapt(srcValue);
+ values[rangeIndex] = dstValue;
+ } else {
+ // Optional value
+ values[rangeIndex] = rangeRecord.componentBindings[rangeIndex].createDefault();
}
}
return rangeRecord.create(values);
result.clones = true;
for (int rangeIndex=0; rangeIndex<len; rangeIndex++)
{
- int domainIndex = fieldMap[rangeIndex];\r
+ int domainIndex = fieldMap[rangeIndex];
if (domainIndex>=0) {
componentAdapters[rangeIndex] = getAdapterUnsynchronized(domainRecord.componentBindings[domainIndex], rangeRecord.componentBindings[rangeIndex], typeAdapter, mustClone);
result.typeAdapter |= componentAdapters[rangeIndex].typeAdapter;
- result.clones &= componentAdapters[rangeIndex].clones;\r
+ result.clones &= componentAdapters[rangeIndex].clones;
}
}
return result;
}
};
result.clones = mustClone;
- result.typeAdapter = true;\r
+ result.typeAdapter = true;
addToCache(req, result);
return result;
}
-\r
- if (domain instanceof BooleanBinding && range instanceof NumberBinding)\r
- {\r
- try {\r
- final BooleanBinding domainBoolean = (BooleanBinding) domain;\r
- final NumberBinding rangeNumber = (NumberBinding) range;\r
- final Object falseValue = rangeNumber.create( Integer.valueOf(0) );\r
- final Object trueValue = rangeNumber.create( Integer.valueOf(1) );\r
- AbstractAdapter result = new AbstractAdapter() {\r
- @Override\r
- public Object adapt(Object obj) throws AdaptException {\r
- try {\r
- boolean value = domainBoolean.getValue_(obj);\r
- return value ? trueValue : falseValue;\r
- } catch (BindingException e) {\r
- throw new AdaptException(e);\r
- } \r
- }\r
- };\r
- result.clones = true;\r
- result.typeAdapter = true;\r
- addToCache(req, result);\r
- return result;\r
- } catch (BindingException e1) {\r
- throw new AdapterConstructionException(e1);\r
- }\r
- } \r
- \r
- if (domain instanceof NumberBinding && range instanceof BooleanBinding)\r
- {\r
- try {\r
- final NumberBinding domainNumber = (NumberBinding) domain;\r
- final BooleanBinding rangeBoolean = (BooleanBinding) range;\r
- final Object zeroValue = domainNumber.create( Integer.valueOf(0) );\r
- AbstractAdapter result = new AbstractAdapter() {\r
- @Override\r
- public Object adapt(Object obj) throws AdaptException {\r
- try {\r
- Object value = domainNumber.getValue(obj);\r
- boolean bool = !domainNumber.equals(value, zeroValue);\r
- return rangeBoolean.create(bool);\r
- } catch (BindingException e) {\r
- throw new AdaptException(e);\r
- } \r
- }\r
- };\r
- result.clones = true;\r
- addToCache(req, result);\r
- return result;\r
- } catch (BindingException e1) {\r
- throw new AdapterConstructionException(e1);\r
- }\r
- }\r
+
+ if (domain instanceof BooleanBinding && range instanceof NumberBinding)
+ {
+ try {
+ final BooleanBinding domainBoolean = (BooleanBinding) domain;
+ final NumberBinding rangeNumber = (NumberBinding) range;
+ final Object falseValue = rangeNumber.create( Integer.valueOf(0) );
+ final Object trueValue = rangeNumber.create( Integer.valueOf(1) );
+ AbstractAdapter result = new AbstractAdapter() {
+ @Override
+ public Object adapt(Object obj) throws AdaptException {
+ try {
+ boolean value = domainBoolean.getValue_(obj);
+ return value ? trueValue : falseValue;
+ } catch (BindingException e) {
+ throw new AdaptException(e);
+ }
+ }
+ };
+ result.clones = true;
+ result.typeAdapter = true;
+ addToCache(req, result);
+ return result;
+ } catch (BindingException e1) {
+ throw new AdapterConstructionException(e1);
+ }
+ }
+
+ if (domain instanceof NumberBinding && range instanceof BooleanBinding)
+ {
+ try {
+ final NumberBinding domainNumber = (NumberBinding) domain;
+ final BooleanBinding rangeBoolean = (BooleanBinding) range;
+ final Object zeroValue = domainNumber.create( Integer.valueOf(0) );
+ AbstractAdapter result = new AbstractAdapter() {
+ @Override
+ public Object adapt(Object obj) throws AdaptException {
+ try {
+ Object value = domainNumber.getValue(obj);
+ boolean bool = !domainNumber.equals(value, zeroValue);
+ return rangeBoolean.create(bool);
+ } catch (BindingException e) {
+ throw new AdaptException(e);
+ }
+ }
+ };
+ result.clones = true;
+ addToCache(req, result);
+ return result;
+ } catch (BindingException e1) {
+ throw new AdapterConstructionException(e1);
+ }
+ }
if (domain instanceof StringBinding && range instanceof StringBinding)
{
result.clones = true;
addToCache(req, result);
return result;
- } \r
- \r
- if(domain instanceof StringBinding && range instanceof NumberBinding)\r
- {\r
- final StringBinding domainString = (StringBinding) domain;\r
- final NumberBinding rangeString = (NumberBinding) range;\r
- AbstractAdapter result = new AbstractAdapter() {\r
- @Override\r
- public Object adapt(Object obj) throws AdaptException {\r
- try {\r
- String value = domainString.getValue(obj);\r
- return rangeString.create(value);\r
- } catch (BindingException e) {\r
- throw new AdaptException(e);\r
- } \r
- }\r
- };\r
- result.clones = true;\r
- addToCache(req, result);\r
- return result;\r
+ }
+
+ if(domain instanceof StringBinding && range instanceof NumberBinding)
+ {
+ final StringBinding domainString = (StringBinding) domain;
+ final NumberBinding rangeString = (NumberBinding) range;
+ AbstractAdapter result = new AbstractAdapter() {
+ @Override
+ public Object adapt(Object obj) throws AdaptException {
+ try {
+ String value = domainString.getValue(obj);
+ return rangeString.create(value);
+ } catch (BindingException e) {
+ throw new AdaptException(e);
+ }
+ }
+ };
+ result.clones = true;
+ addToCache(req, result);
+ return result;
+ }
+
+ if(domain instanceof StringBinding && range instanceof BooleanBinding)
+ {
+ final StringBinding domainString = (StringBinding) domain;
+ final BooleanBinding rangeString = (BooleanBinding) range;
+ AbstractAdapter result = new AbstractAdapter() {
+ @Override
+ public Object adapt(Object obj) throws AdaptException {
+ try {
+ String value = domainString.getValue(obj);
+ return rangeString.create(Boolean.parseBoolean(value));
+ } catch (BindingException e) {
+ throw new AdaptException(e);
+ }
+ }
+ };
+ result.clones = true;
+ addToCache(req, result);
+ return result;
}
-\r
- if(domain instanceof StringBinding && range instanceof BooleanBinding)\r
- {\r
- final StringBinding domainString = (StringBinding) domain;\r
- final BooleanBinding rangeString = (BooleanBinding) range;\r
- AbstractAdapter result = new AbstractAdapter() {\r
- @Override\r
- public Object adapt(Object obj) throws AdaptException {\r
- try {\r
- String value = domainString.getValue(obj);\r
- return rangeString.create(Boolean.parseBoolean(value));\r
- } catch (BindingException e) {\r
- throw new AdaptException(e);\r
- } \r
- }\r
- };\r
- result.clones = true;\r
- addToCache(req, result);\r
- return result;\r
- }\r
// XXX We can optimizes here by using primitives
if (domain instanceof NumberBinding && range instanceof NumberBinding)
final NumberBinding rangeNumber = (NumberBinding) range;
String domainUnit = ((NumberType) domainNumber.type()).getUnit();
- String rangeUnit = ((NumberType) rangeNumber.type()).getUnit();\r
- IUnitConverter unitConverter;\r
- if(domainUnit == null || rangeUnit == null || domainUnit.equals(rangeUnit))\r
- unitConverter = null;\r
- else\r
- unitConverter = Units.createConverter(domainUnit, rangeUnit); \r
- /*if(domainUnit == null || domainUnit.equals("")) {\r
- if(rangeUnit == null || rangeUnit.equals(""))\r
- unitConverter = null;\r
- else\r
- unitConverter = null;\r
-// throw new AdapterConstructionException("Cannot convert from a unitless type to a type with unit.");\r
- }\r
- else {\r
- if(rangeUnit == null || rangeUnit.equals(""))\r
- unitConverter = null; \r
-// throw new AdapterConstructionException("Cannot convert from a type with unit to unitless type.");\r
- else\r
- unitConverter = Units.createConverter(domainUnit, rangeUnit); \r
+ String rangeUnit = ((NumberType) rangeNumber.type()).getUnit();
+ IUnitConverter unitConverter;
+ if(domainUnit == null || rangeUnit == null || domainUnit.equals(rangeUnit))
+ unitConverter = null;
+ else
+ unitConverter = Units.createConverter(domainUnit, rangeUnit);
+ /*if(domainUnit == null || domainUnit.equals("")) {
+ if(rangeUnit == null || rangeUnit.equals(""))
+ unitConverter = null;
+ else
+ unitConverter = null;
+// throw new AdapterConstructionException("Cannot convert from a unitless type to a type with unit.");
+ }
+ else {
+ if(rangeUnit == null || rangeUnit.equals(""))
+ unitConverter = null;
+// throw new AdapterConstructionException("Cannot convert from a type with unit to unitless type.");
+ else
+ unitConverter = Units.createConverter(domainUnit, rangeUnit);
} */
boolean doUnitConversion = unitConverter != null && unitConverter != IdentityConverter.INSTANCE;
boolean doPrimitiveConversion = !domainNumber.type().getClass().equals( rangeNumber.type().getClass() );
@Override
public Object adapt(Object obj) throws AdaptException {
try {
- boolean[] data = domainArray.getArray(obj);\r
+ boolean[] data = domainArray.getArray(obj);
if (mustClone) data = data.clone();
return rangeArray.create(data);
} catch (BindingException e) {
@Override
public Object adapt(Object obj) throws AdaptException {
try {
- byte[] data = domainArray.getArray(obj);\r
+ byte[] data = domainArray.getArray(obj);
if (mustClone) data = data.clone();
return rangeArray.create(data);
} catch (BindingException e) {
String domainUnit = ((NumberType) ((ArrayType)domainArray.type()).componentType).getUnit();
String rangeUnit = ((NumberType) ((ArrayType)rangeArray.type()).componentType).getUnit();
- IUnitConverter unitConverter = ObjectUtils.objectEquals(domainUnit, rangeUnit) ||\r
+ IUnitConverter unitConverter = ObjectUtils.objectEquals(domainUnit, rangeUnit) ||
domainUnit == null || rangeUnit == null ? null : Units.createConverter(domainUnit, rangeUnit);
boolean doUnitConversion = unitConverter != null && unitConverter != IdentityConverter.INSTANCE;
@Override
public Object adapt(Object obj) throws AdaptException {
try {
- int[] data = domainArray.getArray(obj);\r
+ int[] data = domainArray.getArray(obj);
if (mustClone) data = data.clone();
return rangeArray.create(data);
} catch (BindingException e) {
String domainUnit = ((NumberType) ((ArrayType)domainArray.type()).componentType).getUnit();
String rangeUnit = ((NumberType) ((ArrayType)rangeArray.type()).componentType).getUnit();
- IUnitConverter unitConverter = ObjectUtils.objectEquals(domainUnit, rangeUnit) ||\r
+ IUnitConverter unitConverter = ObjectUtils.objectEquals(domainUnit, rangeUnit) ||
domainUnit == null || rangeUnit == null ? null : Units.createConverter(domainUnit, rangeUnit);
boolean doUnitConversion = unitConverter != null && unitConverter != IdentityConverter.INSTANCE;
@Override
public Object adapt(Object obj) throws AdaptException {
try {
- long[] data = domainArray.getArray(obj);\r
+ long[] data = domainArray.getArray(obj);
if (mustClone) data = data.clone();
return rangeArray.create(data);
} catch (BindingException e) {
String domainUnit = ((NumberType) ((ArrayType)domainArray.type()).componentType).getUnit();
String rangeUnit = ((NumberType) ((ArrayType)rangeArray.type()).componentType).getUnit();
- IUnitConverter unitConverter = ObjectUtils.objectEquals(domainUnit, rangeUnit) ||\r
+ IUnitConverter unitConverter = ObjectUtils.objectEquals(domainUnit, rangeUnit) ||
domainUnit == null || rangeUnit == null ? null : Units.createConverter(domainUnit, rangeUnit);
boolean doUnitConversion = unitConverter != null && unitConverter != IdentityConverter.INSTANCE;
@Override
public Object adapt(Object obj) throws AdaptException {
try {
- float[] data = domainArray.getArray(obj);\r
+ float[] data = domainArray.getArray(obj);
if (mustClone) data = data.clone();
return rangeArray.create(data);
} catch (BindingException e) {
String domainUnit = ((NumberType) ((ArrayType)domainArray.type()).componentType).getUnit();
String rangeUnit = ((NumberType) ((ArrayType)rangeArray.type()).componentType).getUnit();
- IUnitConverter unitConverter = ObjectUtils.objectEquals(domainUnit, rangeUnit) \r
+ IUnitConverter unitConverter = ObjectUtils.objectEquals(domainUnit, rangeUnit)
|| domainUnit == null || rangeUnit == null ? null : Units.createConverter(domainUnit, rangeUnit);
boolean doUnitConversion = unitConverter != null && unitConverter != IdentityConverter.INSTANCE;
@Override
public Object adapt(Object obj) throws AdaptException {
try {
- double[] data = domainArray.getArray(obj);\r
+ double[] data = domainArray.getArray(obj);
if (mustClone) data = data.clone();
return rangeArray.create(data);
} catch (BindingException e) {
result.clones = componentAdapter.clones;
addToCache(req, result);
return result;
- }\r
- \r
- // Adapt a non-optional value to an optional value\r
- if (range instanceof OptionalBinding && !(domain instanceof OptionalBinding))\r
- {\r
- final Binding domainBinding = domain;\r
- final OptionalBinding rangeBinding = (OptionalBinding) range;\r
- final AbstractAdapter componentAdapter = getAdapterUnsynchronized(domainBinding, rangeBinding.componentBinding, typeAdapter, mustClone);\r
- AbstractAdapter result = new AbstractAdapter() {\r
- @Override\r
- public Object adapt(Object obj) throws AdaptException {\r
- try {\r
- obj = componentAdapter.adapt(obj); \r
- return rangeBinding.createValue(obj);\r
- } catch (BindingException e) {\r
- throw new AdaptException(e);\r
- }\r
- }\r
- };\r
- result.typeAdapter = componentAdapter.typeAdapter;\r
- result.clones = componentAdapter.clones;\r
- addToCache(req, result);\r
- return result; \r
+ }
+
+ // Adapt a non-optional value to an optional value
+ if (range instanceof OptionalBinding && !(domain instanceof OptionalBinding))
+ {
+ final Binding domainBinding = domain;
+ final OptionalBinding rangeBinding = (OptionalBinding) range;
+ final AbstractAdapter componentAdapter = getAdapterUnsynchronized(domainBinding, rangeBinding.componentBinding, typeAdapter, mustClone);
+ AbstractAdapter result = new AbstractAdapter() {
+ @Override
+ public Object adapt(Object obj) throws AdaptException {
+ try {
+ obj = componentAdapter.adapt(obj);
+ return rangeBinding.createValue(obj);
+ } catch (BindingException e) {
+ throw new AdaptException(e);
+ }
+ }
+ };
+ result.typeAdapter = componentAdapter.typeAdapter;
+ result.clones = componentAdapter.clones;
+ addToCache(req, result);
+ return result;
}
if (domain instanceof VariantBinding && range instanceof VariantBinding)
AbstractAdapter result = new AbstractAdapter() {
@Override
public Object adapt(Object obj) throws AdaptException {
- try {\r
+ try {
Binding domainValueBinding = domainBinding.getContentBinding(obj);
- Object domainObject = domainBinding.getContent(obj, domainValueBinding);\r
- if (mustClone && domainObject!=obj) {\r
- Adapter valueAdapter = getAdapterUnsynchronized(domainValueBinding, domainValueBinding, false, true);\r
- domainObject = valueAdapter.adapt(domainObject); \r
+ Object domainObject = domainBinding.getContent(obj, domainValueBinding);
+ if (mustClone && domainObject!=obj) {
+ Adapter valueAdapter = getAdapterUnsynchronized(domainValueBinding, domainValueBinding, false, true);
+ domainObject = valueAdapter.adapt(domainObject);
}
Object rangeVariant = rangeBinding.create(domainValueBinding, domainObject);
return rangeVariant;
} catch (BindingException e) {
throw new AdaptException(e);
- } catch (AdapterConstructionException e) {\r
- throw new AdaptException(e);\r
+ } catch (AdapterConstructionException e) {
+ throw new AdaptException(e);
+ }
+ }
+ };
+ result.clones = mustClone;
+ addToCache(req, result);
+ return result;
+ }
+
+ if (domain instanceof VariantBinding && !(range instanceof VariantBinding))
+ {
+ // Make a recursive adaptation from a variant source
+ final VariantBinding domainBinding = (VariantBinding)domain;
+ final Binding rangeBinding = range;
+ AbstractAdapter result = new AbstractAdapter() {
+ @Override
+ public Object adapt(Object obj) throws AdaptException {
+ try {
+ Object value = domainBinding.getContent(obj);
+ Binding contentBinding = domainBinding.getContentBinding(obj);
+ AbstractAdapter adapter = (AbstractAdapter) getAdapter(contentBinding, rangeBinding, typeAdapter, mustClone);
+ return adapter.adapt(value);
+ } catch (BindingException | AdapterConstructionException e) {
+ throw new AdaptException(e);
+ }
+ }
+ };
+ result.clones = mustClone;
+ addToCache(req, result);
+ return result;
+ }
+
+ if (range instanceof VariantBinding && !(domain instanceof VariantBinding))
+ {
+ // Default to just wrapping the domain type
+ final VariantBinding rangeBinding = (VariantBinding)range;
+ final Binding domainBinding = domain;
+ AbstractAdapter result = new AbstractAdapter() {
+ @Override
+ public Object adapt(Object obj) throws AdaptException {
+ try {
+ if (mustClone) {
+ Adapter valueAdapter;
+ valueAdapter = getAdapterUnsynchronized(domainBinding, domainBinding, false, true);
+ obj = valueAdapter.adapt(obj);
+ }
+ return rangeBinding.create(domainBinding, obj);
+ } catch (AdapterConstructionException | BindingException e) {
+ throw new AdaptException(e);
}
}
};
result.clones = mustClone;
addToCache(req, result);
return result;
- }\r
- \r
- if (domain instanceof VariantBinding && !(range instanceof VariantBinding))\r
- {\r
- // Make a recursive adaptation from a variant source\r
- final VariantBinding domainBinding = (VariantBinding)domain;\r
- final Binding rangeBinding = range;\r
- AbstractAdapter result = new AbstractAdapter() {\r
- @Override\r
- public Object adapt(Object obj) throws AdaptException {\r
- try {\r
- Object value = domainBinding.getContent(obj);\r
- Binding contentBinding = domainBinding.getContentBinding(obj);\r
- AbstractAdapter adapter = (AbstractAdapter) getAdapter(contentBinding, rangeBinding, typeAdapter, mustClone);\r
- return adapter.adapt(value);\r
- } catch (BindingException | AdapterConstructionException e) {\r
- throw new AdaptException(e);\r
- }\r
- }\r
- };\r
- result.clones = mustClone;\r
- addToCache(req, result);\r
- return result; \r
- }\r
- \r
- if (range instanceof VariantBinding && !(domain instanceof VariantBinding))\r
- {\r
- // Default to just wrapping the domain type\r
- final VariantBinding rangeBinding = (VariantBinding)range;\r
- final Binding domainBinding = domain;\r
- AbstractAdapter result = new AbstractAdapter() {\r
- @Override\r
- public Object adapt(Object obj) throws AdaptException {\r
- try {\r
- if (mustClone) {\r
- Adapter valueAdapter;\r
- valueAdapter = getAdapterUnsynchronized(domainBinding, domainBinding, false, true);\r
- obj = valueAdapter.adapt(obj);\r
- }\r
- return rangeBinding.create(domainBinding, obj);\r
- } catch (AdapterConstructionException | BindingException e) {\r
- throw new AdaptException(e);\r
- }\r
- }\r
- };\r
- result.clones = mustClone;\r
- addToCache(req, result);\r
- return result;\r
}
if (domain instanceof MapBinding && range instanceof MapBinding)
}
- \r
- /**\r
- * Adapt a value of one type to another. \r
- * \r
- * @param value\r
- * @param domain\r
- * @param range\r
- * @return adapted value\r
- * @throws AdapterConstructionException\r
- * @throws AdaptException\r
- */\r
- public Object adapt(Object value, Binding domain, Binding range)\r
- throws AdaptException\r
- {\r
- if (domain == range) return value;\r
- try {\r
- if (range instanceof VariantBinding && !(domain instanceof VariantBinding)) {\r
- // Default to just wrapping the value (avoid adapter construction to save memory)\r
- return ((VariantBinding)range).create(domain, value);\r
- }\r
- return getAdapter(domain, range, true, false).adapt(value);\r
- } catch (AdapterConstructionException | BindingException e) {\r
- throw new AdaptException(e);\r
- }\r
- }\r
- \r
- /**\r
- * Adapt a value of one type to another\r
- * \r
- * @param value\r
- * @param domain\r
- * @param range\r
- * @return adapted value\r
- * @throws AdapterConstructionException\r
- * @throws AdaptException\r
- */\r
- public Object adaptUnchecked(Object value, Binding domain, Binding range)\r
- throws RuntimeAdapterConstructionException, RuntimeAdaptException\r
- {\r
- if (domain == range) return value;\r
- try {\r
- if (range instanceof VariantBinding && !(domain instanceof VariantBinding)) {\r
- // Default to just wrapping the value (avoid adapter construction to save memory)\r
- return ((VariantBinding)range).create(domain, value);\r
- }\r
- return getAdapter(domain, range, true, false).adaptUnchecked(value);\r
- } catch (RuntimeAdapterConstructionException | RuntimeBindingException e) {\r
- throw new RuntimeAdaptException(new AdaptException(e.getCause()));\r
- } catch (AdapterConstructionException | BindingException e) {\r
- throw new RuntimeAdaptException(new AdaptException(e));\r
- }\r
- }\r
- \r
- /**\r
- * Clone a value to a type to another. Bindings that handle immutable values\r
- * may return the same instance, others will guarantee a complete copy. \r
- * \r
- * @param value\r
- * @param domain\r
- * @param range\r
- * @return adapted value\r
- * @throws AdapterConstructionException\r
- * @throws AdaptException\r
- */\r
- public Object clone(Object value, Binding domain, Binding range)\r
- throws AdaptException\r
- {\r
- try {\r
- return getAdapter(domain, range, true, true).adapt(value);\r
- } catch (AdapterConstructionException e) {\r
- throw new AdaptException(e);\r
- }\r
- }\r
- \r
-\r
- /**\r
- * Clone a value of one binding to another. Bindings that handle immutable values\r
- * may return the same instance, others will guarantee a complete copy.\r
- * \r
- * @param value\r
- * @param domain\r
- * @param range\r
- * @return adapted value\r
- * @throws AdapterConstructionException\r
- * @throws AdaptException\r
- */\r
- public Object cloneUnchecked(Object value, Binding domain, Binding range)\r
- throws RuntimeAdapterConstructionException, RuntimeAdaptException\r
- {\r
- try {\r
- return getAdapter(domain, range, true, true).adapt(value);\r
- } catch (AdaptException e) {\r
- throw new RuntimeAdaptException(e);\r
- } catch (RuntimeAdapterConstructionException e) {\r
- throw new RuntimeAdaptException(new AdaptException(e.getCause()));\r
- } catch (AdapterConstructionException e) {\r
- throw new RuntimeAdaptException(new AdaptException(e));\r
- }\r
- } \r
+
+ /**
+ * Adapt a value of one type to another.
+ *
+ * @param value
+ * @param domain
+ * @param range
+ * @return adapted value
+ * @throws AdapterConstructionException
+ * @throws AdaptException
+ */
+ public Object adapt(Object value, Binding domain, Binding range)
+ throws AdaptException
+ {
+ if (domain == range) return value;
+ try {
+ if (range instanceof VariantBinding && !(domain instanceof VariantBinding)) {
+ // Default to just wrapping the value (avoid adapter construction to save memory)
+ return ((VariantBinding)range).create(domain, value);
+ }
+ return getAdapter(domain, range, true, false).adapt(value);
+ } catch (AdapterConstructionException | BindingException e) {
+ throw new AdaptException(e);
+ }
+ }
+
+ /**
+ * Adapt a value of one type to another
+ *
+ * @param value
+ * @param domain
+ * @param range
+ * @return adapted value
+ * @throws AdapterConstructionException
+ * @throws AdaptException
+ */
+ public Object adaptUnchecked(Object value, Binding domain, Binding range)
+ throws RuntimeAdapterConstructionException, RuntimeAdaptException
+ {
+ if (domain == range) return value;
+ try {
+ if (range instanceof VariantBinding && !(domain instanceof VariantBinding)) {
+ // Default to just wrapping the value (avoid adapter construction to save memory)
+ return ((VariantBinding)range).create(domain, value);
+ }
+ return getAdapter(domain, range, true, false).adaptUnchecked(value);
+ } catch (RuntimeAdapterConstructionException | RuntimeBindingException e) {
+ throw new RuntimeAdaptException(new AdaptException(e.getCause()));
+ } catch (AdapterConstructionException | BindingException e) {
+ throw new RuntimeAdaptException(new AdaptException(e));
+ }
+ }
+
+ /**
+ * Clone a value to a type to another. Bindings that handle immutable values
+ * may return the same instance, others will guarantee a complete copy.
+ *
+ * @param value
+ * @param domain
+ * @param range
+ * @return adapted value
+ * @throws AdapterConstructionException
+ * @throws AdaptException
+ */
+ public Object clone(Object value, Binding domain, Binding range)
+ throws AdaptException
+ {
+ try {
+ return getAdapter(domain, range, true, true).adapt(value);
+ } catch (AdapterConstructionException e) {
+ throw new AdaptException(e);
+ }
+ }
+
+
+ /**
+ * Clone a value of one binding to another. Bindings that handle immutable values
+ * may return the same instance, others will guarantee a complete copy.
+ *
+ * @param value
+ * @param domain
+ * @param range
+ * @return adapted value
+ * @throws AdapterConstructionException
+ * @throws AdaptException
+ */
+ public Object cloneUnchecked(Object value, Binding domain, Binding range)
+ throws RuntimeAdapterConstructionException, RuntimeAdaptException
+ {
+ try {
+ return getAdapter(domain, range, true, true).adapt(value);
+ } catch (AdaptException e) {
+ throw new RuntimeAdaptException(e);
+ } catch (RuntimeAdapterConstructionException e) {
+ throw new RuntimeAdaptException(new AdaptException(e.getCause()));
+ } catch (AdapterConstructionException e) {
+ throw new RuntimeAdaptException(new AdaptException(e));
+ }
+ }
}
Code Review / simantics / platform.git / blobdiff