-/*******************************************************************************\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
+ * Semantum Oy - gitlab #313
+ *******************************************************************************/
package org.simantics.databoard;
-import java.io.IOException;\r
-import java.util.Comparator;\r
-import java.util.Map;\r
-\r
-import org.simantics.databoard.adapter.AdaptException;\r
-import org.simantics.databoard.adapter.Adapter;\r
-import org.simantics.databoard.adapter.AdapterConstructionException;\r
-import org.simantics.databoard.adapter.AdapterFactory;\r
-import org.simantics.databoard.adapter.RuntimeAdaptException;\r
-import org.simantics.databoard.adapter.RuntimeAdapterConstructionException;\r
-import org.simantics.databoard.annotations.ArgumentImpl;\r
-import org.simantics.databoard.annotations.Arguments;\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.ByteBinding;\r
-import org.simantics.databoard.binding.DoubleBinding;\r
-import org.simantics.databoard.binding.FloatBinding;\r
-import org.simantics.databoard.binding.IntegerBinding;\r
-import org.simantics.databoard.binding.LongBinding;\r
-import org.simantics.databoard.binding.StringBinding;\r
-import org.simantics.databoard.binding.VariantBinding;\r
-import org.simantics.databoard.binding.classfactory.TypeClassFactory;\r
-import org.simantics.databoard.binding.error.BindingConstructionException;\r
-import org.simantics.databoard.binding.error.BindingException;\r
-import org.simantics.databoard.binding.error.RuntimeBindingConstructionException;\r
-import org.simantics.databoard.binding.factory.BindingRepository;\r
-import org.simantics.databoard.binding.factory.TypeBindingFactory;\r
-import org.simantics.databoard.binding.impl.BooleanArrayBinding;\r
-import org.simantics.databoard.binding.impl.BooleanBindingDefault;\r
-import org.simantics.databoard.binding.impl.ByteArrayBinding;\r
-import org.simantics.databoard.binding.impl.ByteBindingDefault;\r
-import org.simantics.databoard.binding.impl.DoubleArrayBinding;\r
-import org.simantics.databoard.binding.impl.DoubleBindingDefault;\r
-import org.simantics.databoard.binding.impl.FloatArrayBinding;\r
-import org.simantics.databoard.binding.impl.FloatBindingDefault;\r
-import org.simantics.databoard.binding.impl.IntArrayBinding;\r
-import org.simantics.databoard.binding.impl.IntegerBindingDefault;\r
-import org.simantics.databoard.binding.impl.LongArrayBinding;\r
-import org.simantics.databoard.binding.impl.LongBindingDefault;\r
-import org.simantics.databoard.binding.impl.StringArrayBinding;\r
-import org.simantics.databoard.binding.impl.StringBindingDefault;\r
-import org.simantics.databoard.binding.impl.UnsignedByteBinding;\r
-import org.simantics.databoard.binding.impl.UnsignedIntegerBinding;\r
-import org.simantics.databoard.binding.impl.UnsignedLongBinding;\r
-import org.simantics.databoard.binding.mutable.MutableBooleanBinding;\r
-import org.simantics.databoard.binding.mutable.MutableByteBinding;\r
-import org.simantics.databoard.binding.mutable.MutableDoubleBinding;\r
-import org.simantics.databoard.binding.mutable.MutableFloatBinding;\r
-import org.simantics.databoard.binding.mutable.MutableIntegerBinding;\r
-import org.simantics.databoard.binding.mutable.MutableLongBinding;\r
-import org.simantics.databoard.binding.mutable.MutableStringBinding;\r
-import org.simantics.databoard.binding.mutable.MutableVariantBinding;\r
-import org.simantics.databoard.binding.reflection.BindingProvider;\r
-import org.simantics.databoard.binding.reflection.BindingRequest;\r
-import org.simantics.databoard.binding.reflection.ClassBindingFactory;\r
-import org.simantics.databoard.binding.reflection.VoidBinding;\r
-import org.simantics.databoard.serialization.RuntimeSerializerConstructionException;\r
-import org.simantics.databoard.serialization.Serializer;\r
-import org.simantics.databoard.serialization.SerializerConstructionException;\r
-import org.simantics.databoard.serialization.SerializerFactory;\r
-import org.simantics.databoard.type.ArrayType;\r
-import org.simantics.databoard.type.Datatype;\r
-import org.simantics.databoard.util.DataValueUtil;\r
+import java.io.IOException;
+import java.util.Comparator;
+import java.util.Map;
+
+import org.simantics.databoard.adapter.AdaptException;
+import org.simantics.databoard.adapter.Adapter;
+import org.simantics.databoard.adapter.AdapterConstructionException;
+import org.simantics.databoard.adapter.AdapterFactory;
+import org.simantics.databoard.adapter.RuntimeAdaptException;
+import org.simantics.databoard.adapter.RuntimeAdapterConstructionException;
+import org.simantics.databoard.annotations.ArgumentImpl;
+import org.simantics.databoard.annotations.Arguments;
+import org.simantics.databoard.binding.ArrayBinding;
+import org.simantics.databoard.binding.Binding;
+import org.simantics.databoard.binding.BooleanBinding;
+import org.simantics.databoard.binding.ByteBinding;
+import org.simantics.databoard.binding.DoubleBinding;
+import org.simantics.databoard.binding.FloatBinding;
+import org.simantics.databoard.binding.IntegerBinding;
+import org.simantics.databoard.binding.LongBinding;
+import org.simantics.databoard.binding.StringBinding;
+import org.simantics.databoard.binding.VariantBinding;
+import org.simantics.databoard.binding.classfactory.TypeClassFactory;
+import org.simantics.databoard.binding.error.BindingConstructionException;
+import org.simantics.databoard.binding.error.BindingException;
+import org.simantics.databoard.binding.error.RuntimeBindingConstructionException;
+import org.simantics.databoard.binding.factory.BindingRepository;
+import org.simantics.databoard.binding.factory.TypeBindingFactory;
+import org.simantics.databoard.binding.impl.BooleanArrayBinding;
+import org.simantics.databoard.binding.impl.BooleanBindingDefault;
+import org.simantics.databoard.binding.impl.ByteArrayBinding;
+import org.simantics.databoard.binding.impl.ByteBindingDefault;
+import org.simantics.databoard.binding.impl.DoubleArrayBinding;
+import org.simantics.databoard.binding.impl.DoubleBindingDefault;
+import org.simantics.databoard.binding.impl.FloatArrayBinding;
+import org.simantics.databoard.binding.impl.FloatBindingDefault;
+import org.simantics.databoard.binding.impl.IntArrayBinding;
+import org.simantics.databoard.binding.impl.IntegerBindingDefault;
+import org.simantics.databoard.binding.impl.LongArrayBinding;
+import org.simantics.databoard.binding.impl.LongBindingDefault;
+import org.simantics.databoard.binding.impl.StringArrayBinding;
+import org.simantics.databoard.binding.impl.StringBindingDefault;
+import org.simantics.databoard.binding.impl.UnsignedByteBinding;
+import org.simantics.databoard.binding.impl.UnsignedIntegerBinding;
+import org.simantics.databoard.binding.impl.UnsignedLongBinding;
+import org.simantics.databoard.binding.mutable.MutableBooleanBinding;
+import org.simantics.databoard.binding.mutable.MutableByteBinding;
+import org.simantics.databoard.binding.mutable.MutableDoubleBinding;
+import org.simantics.databoard.binding.mutable.MutableFloatBinding;
+import org.simantics.databoard.binding.mutable.MutableIntegerBinding;
+import org.simantics.databoard.binding.mutable.MutableLongBinding;
+import org.simantics.databoard.binding.mutable.MutableStringBinding;
+import org.simantics.databoard.binding.mutable.MutableVariantBinding;
+import org.simantics.databoard.binding.reflection.BindingProvider;
+import org.simantics.databoard.binding.reflection.BindingRequest;
+import org.simantics.databoard.binding.reflection.ClassBindingFactory;
+import org.simantics.databoard.binding.reflection.VoidBinding;
+import org.simantics.databoard.serialization.RuntimeSerializerConstructionException;
+import org.simantics.databoard.serialization.Serializer;
+import org.simantics.databoard.serialization.SerializerConstructionException;
+import org.simantics.databoard.serialization.SerializerScheme;
+import org.simantics.databoard.type.ArrayType;
+import org.simantics.databoard.type.Datatype;
+import org.simantics.databoard.util.DataValueUtil;
/**
* This ia a facade class for the binding services.
*
* @author Toni Kalajainen <toni.kalajainen@vtt.fi>
*/
-public class Bindings {\r
- \r
+public class Bindings {
+
public static final Databoard databoard;
-\r
- // Repositories\r
-\r
- /** Repository of mutable bindings */\r
- public static final Map<Datatype, Binding> mutableBindingRepository;\r
-\r
- /** Repository of default bindings */\r
- public static final Map<Datatype, Binding> defaultBindingRepository;\r
-\r
- /** Repository of class Bindings */\r
- public static final BindingRepository bindingRepository;\r
-\r
- /** Repository of serializers */\r
- public static final Map<Binding, Serializer> serializerRepository;\r
- \r
- \r
- // Factories\r
-\r
+
+ // Repositories
+
+ /** Repository of mutable bindings */
+ public static final Map<Datatype, Binding> mutableBindingRepository;
+
+ /** Repository of default bindings */
+ public static final Map<Datatype, Binding> defaultBindingRepository;
+
+ /** Repository of class Bindings */
+ public static final BindingRepository bindingRepository;
+
+ /** Repository of serializers */
+ public static final Map<Binding, Serializer> serializerRepository;
+
+
+ // Factories
+
/** Mutable Bindings Factory */
- public static final TypeBindingFactory mutableBindingFactory;\r
-\r
- /** Default Bindings Factory */\r
- public static final TypeBindingFactory defaultBindingFactory;\r
-\r
- /** Reflection based Binding Factory, create binding to class */\r
- public static final ClassBindingFactory classBindingFactory;\r
-\r
- /** Serializer Factory */\r
- public static final SerializerFactory serializationFactory;\r
-\r
- /** Adapter Factory */\r
- public static final AdapterFactory adapterFactory;\r
- \r
- /** Class Factory */ \r
- public static final TypeClassFactory typeClassFactory;\r
- \r
- \r
- // Bindings to various primitives\r
- public static final StringBinding STRING; // java.lang.String \r
- public static final IntegerBinding INTEGER; // java.lang.Integer \r
- public static final BooleanBinding BOOLEAN; // java.lang.Boolean \r
- public static final ByteBinding BYTE; // java.lang.Byte \r
- public static final LongBinding LONG; // java.lang.Long\r
- public static final DoubleBinding DOUBLE; // java.lang.Double \r
- public static final FloatBinding FLOAT; // java.lang.Float \r
- public static final VariantBinding VARIANT; // Variant \r
- public static final VariantBinding OBJECT; // java.lang.Object ( as variant ) \r
- public static final VariantBinding STR_VARIANT; // java.lang.String ( as variant )\r
- \r
- public static final Binding VOID; // void ( as {} )\r
- public static final Binding BEAN; // Bean ( as variant ) \r
-\r
- public static final ArrayBinding BOOLEAN_ARRAY; // boolean[] \r
- public static final ArrayBinding BYTE_ARRAY; // byte[]\r
- public static final ArrayBinding INT_ARRAY; // int[]\r
- public static final ArrayBinding LONG_ARRAY; // long[]\r
- public static final ArrayBinding FLOAT_ARRAY; // float[]\r
- public static final ArrayBinding DOUBLE_ARRAY; // double[]\r
- public static final ArrayBinding STRING_ARRAY; // String[]\r
-\r
- public static final StringBinding MUTABLE_STRING; // MutableString\r
- public static final IntegerBinding MUTABLE_INTEGER; // MutableInteger\r
- public static final BooleanBinding MUTABLE_BOOLEAN; // MutableBoolean\r
- public static final ByteBinding MUTABLE_BYTE; // MutableByte\r
- public static final LongBinding MUTABLE_LONG; // MutableLong\r
- public static final FloatBinding MUTABLE_FLOAT; // MutableFloat\r
- public static final DoubleBinding MUTABLE_DOUBLE; // MutableDouble\r
- public static final VariantBinding MUTABLE_VARIANT; // MutableVariant\r
-\r
- public static final IntegerBinding UNSIGNED_INTEGER; // UnsignedInteger.Immutable\r
- public static final ByteBinding UNSIGNED_BYTE; // UnsignedByte.Immutable\r
- public static final LongBinding UNSIGNED_LONG; // UnsignedLong.Immutable\r
-\r
- public static final IntegerBinding MUTABLE_UNSIGNED_INTEGER; // UnsignedInteger.Mutable\r
- public static final ByteBinding MUTABLE_UNSIGNED_BYTE; // UnsignedByte.Mutable\r
- public static final LongBinding MUTABLE_UNSIGNED_LONG; // UnsignedLong.Mutable \r
- \r
+ public static final TypeBindingFactory mutableBindingFactory;
+
+ /** Default Bindings Factory */
+ public static final TypeBindingFactory defaultBindingFactory;
+
+ /** Reflection based Binding Factory, create binding to class */
+ public static final ClassBindingFactory classBindingFactory;
+
+ /** Serializer Factory */
+ public static final SerializerScheme serializationFactory;
+
+ /** Adapter Factory */
+ public static final AdapterFactory adapterFactory;
+
+ /** Class Factory */
+ public static final TypeClassFactory typeClassFactory;
+
+
+ // Bindings to various primitives
+ public static final StringBinding STRING; // java.lang.String
+ public static final IntegerBinding INTEGER; // java.lang.Integer
+ public static final BooleanBinding BOOLEAN; // java.lang.Boolean
+ public static final ByteBinding BYTE; // java.lang.Byte
+ public static final LongBinding LONG; // java.lang.Long
+ public static final DoubleBinding DOUBLE; // java.lang.Double
+ public static final FloatBinding FLOAT; // java.lang.Float
+ public static final VariantBinding VARIANT; // Variant
+ public static final VariantBinding OBJECT; // java.lang.Object ( as variant )
+ public static final VariantBinding STR_VARIANT; // java.lang.String ( as variant )
+
+ public static final Binding VOID; // void ( as {} )
+ public static final Binding BEAN; // Bean ( as variant )
+ public static final Binding DATATYPE; // org.simantics.databoard.type.Datatype
+
+ public static final ArrayBinding BOOLEAN_ARRAY; // boolean[]
+ public static final ArrayBinding BYTE_ARRAY; // byte[]
+ public static final ArrayBinding INT_ARRAY; // int[]
+ public static final ArrayBinding LONG_ARRAY; // long[]
+ public static final ArrayBinding FLOAT_ARRAY; // float[]
+ public static final ArrayBinding DOUBLE_ARRAY; // double[]
+ public static final ArrayBinding STRING_ARRAY; // String[]
+
+ public static final StringBinding MUTABLE_STRING; // MutableString
+ public static final IntegerBinding MUTABLE_INTEGER; // MutableInteger
+ public static final BooleanBinding MUTABLE_BOOLEAN; // MutableBoolean
+ public static final ByteBinding MUTABLE_BYTE; // MutableByte
+ public static final LongBinding MUTABLE_LONG; // MutableLong
+ public static final FloatBinding MUTABLE_FLOAT; // MutableFloat
+ public static final DoubleBinding MUTABLE_DOUBLE; // MutableDouble
+ public static final VariantBinding MUTABLE_VARIANT; // MutableVariant
+
+ public static final IntegerBinding UNSIGNED_INTEGER; // UnsignedInteger.Immutable
+ public static final ByteBinding UNSIGNED_BYTE; // UnsignedByte.Immutable
+ public static final LongBinding UNSIGNED_LONG; // UnsignedLong.Immutable
+
+ public static final IntegerBinding MUTABLE_UNSIGNED_INTEGER; // UnsignedInteger.Mutable
+ public static final ByteBinding MUTABLE_UNSIGNED_BYTE; // UnsignedByte.Mutable
+ public static final LongBinding MUTABLE_UNSIGNED_LONG; // UnsignedLong.Mutable
+
/**
* Get or create a binding that is completely mutable java class.
*
* StringType | ValueContainer.class
* ArrayType | ArrayList.class
* MapType | TreeMap.class
- * VariantType | MutableVariant.class\r
- * \r
- * Note, requesting a binding with this convenience method stores the \r
- * binding and the type with strong reference, thus preventing garbage \r
- * collection. To allow garbage collection, please use another instance of \r
+ * VariantType | MutableVariant.class
+ *
+ * Note, requesting a binding with this convenience method stores the
+ * binding and the type with strong reference, thus preventing garbage
+ * collection. To allow garbage collection, please use another instance of
* GenericBindingFactory and binding repository (Map<Datatype, Binding>). <p>
*
* @param type the type to create binding to
*/
@SuppressWarnings("unchecked")
public static <T extends Binding> T getMutableBinding(Datatype type) {
- try {\r
- Binding binding = mutableBindingRepository.get(type);\r
- if (binding!=null) return (T) binding;\r
- synchronized(mutableBindingRepository) {\r
- return (T) mutableBindingFactory.getBinding(type);\r
- }\r
- } catch (BindingConstructionException e) {\r
- // Unexpected - if error is thrown there is fault in GenericBindingScheme\r
- throw new RuntimeBindingConstructionException(e);\r
+ try {
+ Binding binding = mutableBindingRepository.get(type);
+ if (binding!=null) return (T) binding;
+ synchronized(mutableBindingRepository) {
+ return (T) mutableBindingFactory.getBinding(type);
+ }
+ } catch (BindingConstructionException e) {
+ // Unexpected - if error is thrown there is fault in GenericBindingScheme
+ throw new RuntimeBindingConstructionException(e);
}
- }\r
- \r
- /**\r
- * Get or create a binding based on default java classes, such as \r
- * Integer.class, or byte[].class. The result is often binding for an \r
- * immutable classs. These bindings are more efficient than mutable bindings (above).\r
- * \r
- * DataType | Class of the bound instance\r
- * ===================|==================\r
- * BooleanType | Boolean.class\r
- * ByteType | Byte.class\r
- * FloatType | Float.class\r
- * DoubleType | Double.class\r
- * IntegerType | Int.class\r
- * LongType | Long.class\r
- * StringType | String.class\r
- * UnionType | TaggedObject.class\r
- * OptionType | ValueContainer.class\r
- * RecordType | Object[].class\r
- * MapType | TreeMap.class\r
- * VariantType | Variant.class\r
- * ArrayType(Boolean) | boolean[].class\r
- * ArrayType(Byte) | byte[].class\r
- * ArrayType(Integer) | int[].class\r
- * ArrayType(Long) | long[].class\r
- * ArrayType(Float) | float[].class\r
- * ArrayType(Double) | double[].class\r
- * ArrayType(Byte) | byte[].class\r
- * ArrayType( T ) | Object[].class\r
- * \r
- * Note, requesting a binding with this convenience method stores the \r
- * binding and the type with strong reference, thus preventing garbage \r
- * collection. To allow garbage collection, please use another instance of \r
- * DefaultBindingFactory and binding repository (Map<Datatype, Binding>). <p>\r
- *\r
- * @param type the type to create binding to\r
- * @return binding binding to a mutable class \r
- */ \r
- @SuppressWarnings("unchecked")\r
- public static <T extends Binding> T getBinding(Datatype type) {\r
- try {\r
- Binding binding = defaultBindingRepository.get(type);\r
- if (binding!=null) return (T) binding;\r
- synchronized(defaultBindingRepository) {\r
- return (T) defaultBindingFactory.getBinding(type);\r
- }\r
- } catch (BindingConstructionException e) {\r
- // Unexpected - if error is thrown there is fault in DefaultBindingScheme\r
- throw new RuntimeBindingConstructionException(e);\r
- }\r
- } \r
+ }
+
+ /**
+ * Get or create a binding based on default java classes, such as
+ * Integer.class, or byte[].class. The result is often binding for an
+ * immutable classs. These bindings are more efficient than mutable bindings (above).
+ *
+ * DataType | Class of the bound instance
+ * ===================|==================
+ * BooleanType | Boolean.class
+ * ByteType | Byte.class
+ * FloatType | Float.class
+ * DoubleType | Double.class
+ * IntegerType | Int.class
+ * LongType | Long.class
+ * StringType | String.class
+ * UnionType | TaggedObject.class
+ * OptionType | ValueContainer.class
+ * RecordType | Object[].class
+ * MapType | TreeMap.class
+ * VariantType | Variant.class
+ * ArrayType(Boolean) | boolean[].class
+ * ArrayType(Byte) | byte[].class
+ * ArrayType(Integer) | int[].class
+ * ArrayType(Long) | long[].class
+ * ArrayType(Float) | float[].class
+ * ArrayType(Double) | double[].class
+ * ArrayType(Byte) | byte[].class
+ * ArrayType( T ) | Object[].class
+ *
+ * Note, requesting a binding with this convenience method stores the
+ * binding and the type with strong reference, thus preventing garbage
+ * collection. To allow garbage collection, please use another instance of
+ * DefaultBindingFactory and binding repository (Map<Datatype, Binding>). <p>
+ *
+ * @param type the type to create binding to
+ * @return binding binding to a mutable class
+ */
+ @SuppressWarnings("unchecked")
+ public static <T extends Binding> T getBinding(Datatype type) {
+ try {
+ Binding binding = defaultBindingRepository.get(type);
+ if (binding!=null) return (T) binding;
+ synchronized(defaultBindingRepository) {
+ return (T) defaultBindingFactory.getBinding(type);
+ }
+ } catch (BindingConstructionException e) {
+ // Unexpected - if error is thrown there is fault in DefaultBindingScheme
+ throw new RuntimeBindingConstructionException(e);
+ }
+ }
/**
- * Get a binding to a Java Class. Details can be added by placing annotations\r
+ * Get a binding to a Java Class. Details can be added by placing annotations
* to the java classes. See more in package org.simantics.databoard.annotations.
* <p>
*
- * Whether the result is a completely mutable or not depends on the \r
+ * Whether the result is a completely mutable or not depends on the
* requested class. For instance, fields such as Boolean, Integer, Long
* are not mutable, instead MutableBoolean, MutableInteger and MutableLong are.
- * The length of Object[] is not mutable, but length of List<Object> is. <p>\r
- * \r
- * Note, requesting a binding with this convenience method stores the \r
- * binding and the class with strong reference, thus preventing garbage \r
- * collection. To allow garbage collection, please use another instance of \r
- * BindingFactory and binding repository (Map<BindingRequest, Binding>). <p>\r
- * \r
- * Is asm library is available, the binding is bytecode generated. Then read\r
- * and write operations are direct get/set calls or direct field read/writes. \r
- * There is no reflection used. <p>\r
+ * The length of Object[] is not mutable, but length of List<Object> is. <p>
+ *
+ * Note, requesting a binding with this convenience method stores the
+ * binding and the class with strong reference, thus preventing garbage
+ * collection. To allow garbage collection, please use another instance of
+ * BindingFactory and binding repository (Map<BindingRequest, Binding>). <p>
+ *
+ * Is asm library is available, the binding is bytecode generated. Then read
+ * and write operations are direct get/set calls or direct field read/writes.
+ * There is no reflection used. <p>
*
* @see ClassBindingFactory
* @param clazz
@SuppressWarnings("unchecked")
public static <T extends Binding> T getBinding(Class<?> clazz)
throws BindingConstructionException
- {\r
- Binding binding = bindingRepository.get( clazz );\r
- if (binding != null) {\r
- return (T) binding;\r
- }\r
- \r
- BindingRequest request = new BindingRequest( clazz );\r
- synchronized(classBindingFactory) {\r
- binding = classBindingFactory.construct(request);\r
+ {
+ Binding binding = bindingRepository.get( clazz );
+ if (binding != null) {
+ return (T) binding;
+ }
+
+ BindingRequest request = new BindingRequest( clazz );
+ synchronized(classBindingFactory) {
+ binding = classBindingFactory.construct(request);
}
return (T) binding;
- }\r
-\r
- @SuppressWarnings("unchecked")\r
- public static <T extends Binding> T getBinding(BindingRequest request)\r
- throws BindingConstructionException\r
- {\r
- synchronized(classBindingFactory) {\r
- return (T) classBindingFactory.construct(request);\r
- }\r
- }\r
- \r
- /**\r
- * Get a binding for a Java Class. Use this method to acquire class \r
- * parameters for a generics class. <p>\r
- * \r
- * Example 1: \r
- * \r
- * Binding binding = Bindings.getBinding(Map.class, String.class, Integer.class);\r
- * Map<String, Integer> map = (Map<String, Integer>) binding.createDefault();\r
- * \r
- * Example 2:\r
- * \r
- * Binding d = Bindings.getBinding(List.class, Integer.class);\r
- * List<Integer> list = (List<Integer>) d.createRandom(5);\r
- * \r
- * Example 3:\r
- * \r
- * Binding d = Bindings.getBinding(List.class, List.class, Integer.class);\r
- * List<List<Integer>> list = (List<List<Integer>>) d.createRandom(5);\r
- * \r
- * @see ClassBindingFactory \r
- * @param clazz\r
- * @return binding\r
- * @throws BindingConstructionException\r
- */\r
- @SuppressWarnings("unchecked")\r
- public static <T extends Binding> T getBinding(Class<?> clazz, Class<?>...parameters)\r
- throws BindingConstructionException\r
- {\r
- BindingRequest request = new BindingRequest( clazz, parameters );\r
- synchronized(classBindingFactory) {\r
- return (T) classBindingFactory.construct(request);\r
- }\r
- }\r
-\r
- /**\r
- * Try to get a binding for the actual class of a Java object.\r
- * @param obj A Java object\r
- * @return A binding for the class of the object\r
- * @throws BindingConstructionException if no binding can be constructed\r
- */\r
- public static <T extends Binding> T getInstanceBinding(Object obj)\r
- throws BindingConstructionException\r
- {\r
- return getBinding(obj.getClass());\r
- }\r
- \r
- /**\r
- * Read binding and type from a class. DataType details and parameters\r
- * are read as annotations placed in the class. \r
- * (See org.simantics.databoard.annotations)\r
- * <p>\r
- * As an exception, in the subclasses of {@link Throwable}, the fields of\r
- * Throwable are omited.\r
- * <p>\r
- * This method is used for well-known classes where the caller is 100% sure\r
- * that a binding is construable without exception. <p> \r
- * \r
- * @param clazz\r
- * @return binding\r
- * @throws RuntimeBindingConstructionException\r
- */\r
- @SuppressWarnings("unchecked")\r
- public static <T extends Binding> T getBindingUnchecked(Class<?> clazz)\r
- throws RuntimeBindingConstructionException\r
- {\r
- try {\r
- return (T) getBinding(clazz);\r
- } catch (BindingConstructionException e) {\r
- throw new RuntimeBindingConstructionException(e);\r
- }\r
+ }
+
+ @SuppressWarnings("unchecked")
+ public static <T extends Binding> T getBinding(BindingRequest request)
+ throws BindingConstructionException
+ {
+ synchronized(classBindingFactory) {
+ return (T) classBindingFactory.construct(request);
+ }
+ }
+
+ /**
+ * Get a binding for a Java Class. Use this method to acquire class
+ * parameters for a generics class. <p>
+ *
+ * Example 1:
+ *
+ * Binding binding = Bindings.getBinding(Map.class, String.class, Integer.class);
+ * Map<String, Integer> map = (Map<String, Integer>) binding.createDefault();
+ *
+ * Example 2:
+ *
+ * Binding d = Bindings.getBinding(List.class, Integer.class);
+ * List<Integer> list = (List<Integer>) d.createRandom(5);
+ *
+ * Example 3:
+ *
+ * Binding d = Bindings.getBinding(List.class, List.class, Integer.class);
+ * List<List<Integer>> list = (List<List<Integer>>) d.createRandom(5);
+ *
+ * @see ClassBindingFactory
+ * @param clazz
+ * @return binding
+ * @throws BindingConstructionException
+ */
+ @SuppressWarnings("unchecked")
+ public static <T extends Binding> T getBinding(Class<?> clazz, Class<?>...parameters)
+ throws BindingConstructionException
+ {
+ BindingRequest request = new BindingRequest( clazz, parameters );
+ synchronized(classBindingFactory) {
+ return (T) classBindingFactory.construct(request);
+ }
+ }
+
+ /**
+ * Try to get a binding for the actual class of a Java object.
+ * @param obj A Java object
+ * @return A binding for the class of the object
+ * @throws BindingConstructionException if no binding can be constructed
+ */
+ public static <T extends Binding> T getInstanceBinding(Object obj)
+ throws BindingConstructionException
+ {
+ return getBinding(obj.getClass());
+ }
+
+ /**
+ * Read binding and type from a class. DataType details and parameters
+ * are read as annotations placed in the class.
+ * (See org.simantics.databoard.annotations)
+ * <p>
+ * As an exception, in the subclasses of {@link Throwable}, the fields of
+ * Throwable are omited.
+ * <p>
+ * This method is used for well-known classes where the caller is 100% sure
+ * that a binding is construable without exception. <p>
+ *
+ * @param clazz
+ * @return binding
+ * @throws RuntimeBindingConstructionException
+ */
+ @SuppressWarnings("unchecked")
+ public static <T extends Binding> T getBindingUnchecked(Class<?> clazz)
+ throws RuntimeBindingConstructionException
+ {
+ try {
+ return (T) getBinding(clazz);
+ } catch (BindingConstructionException e) {
+ throw new RuntimeBindingConstructionException(e);
+ }
+ }
+
+ /**
+ * Get a binding for a Java Class. Use this method to acquire class
+ * parameters for a generics class. <p>
+ *
+ * Example 1:
+ *
+ * Binding binding = Bindings.getBinding(Map.class, String.class, Integer.class);
+ * Map<String, Integer> map = (Map<String, Integer>) binding.createDefault();
+ *
+ * Example 2:
+ *
+ * Binding d = Bindings.getBinding(List.class, Integer.class);
+ * List<Integer> list = (List<Integer>) d.createRandom(5);
+ *
+ * Example 3:
+ *
+ * Binding d = Bindings.getBinding(List.class, List.class, Integer.class);
+ * List<List<Integer>> list = (List<List<Integer>>) d.createRandom(5);
+ *
+ * @see ClassBindingFactory
+ * @param clazz
+ * @return binding
+ * @throws BindingConstructionException
+ */
+ @SuppressWarnings("unchecked")
+ public static <T extends Binding> T getBindingUnchecked(Class<?> clazz, Class<?>...parameters)
+ throws RuntimeBindingConstructionException
+ {
+ try {
+ Arguments args = new ArgumentImpl(parameters);
+ BindingRequest request = new BindingRequest( clazz, args );
+ Binding binding = bindingRepository.get( request );
+ if (binding!=null);
+ synchronized(classBindingFactory) {
+ binding = classBindingFactory.construct(request);
+ }
+ return (T) binding;
+ } catch (BindingConstructionException e) {
+ throw new RuntimeBindingConstructionException(e);
+ }
}
-\r
- /**\r
- * Get a binding for a Java Class. Use this method to acquire class \r
- * parameters for a generics class. <p>\r
- * \r
- * Example 1: \r
- * \r
- * Binding binding = Bindings.getBinding(Map.class, String.class, Integer.class);\r
- * Map<String, Integer> map = (Map<String, Integer>) binding.createDefault();\r
- * \r
- * Example 2:\r
- * \r
- * Binding d = Bindings.getBinding(List.class, Integer.class);\r
- * List<Integer> list = (List<Integer>) d.createRandom(5);\r
- * \r
- * Example 3:\r
- * \r
- * Binding d = Bindings.getBinding(List.class, List.class, Integer.class);\r
- * List<List<Integer>> list = (List<List<Integer>>) d.createRandom(5);\r
- * \r
- * @see ClassBindingFactory \r
- * @param clazz\r
- * @return binding\r
- * @throws BindingConstructionException\r
- */\r
- @SuppressWarnings("unchecked")\r
- public static <T extends Binding> T getBindingUnchecked(Class<?> clazz, Class<?>...parameters)\r
- throws RuntimeBindingConstructionException\r
- {\r
- try {\r
- Arguments args = new ArgumentImpl(parameters);\r
- BindingRequest request = new BindingRequest( clazz, args );\r
- Binding binding = bindingRepository.get( request );\r
- if (binding!=null);\r
- synchronized(classBindingFactory) {\r
- binding = classBindingFactory.construct(request);\r
- }\r
- return (T) binding;\r
- } catch (BindingConstructionException e) {\r
- throw new RuntimeBindingConstructionException(e);\r
- }\r
- } \r
- \r
- /**\r
- * Add a simple binding to reflection binding factory.\r
- * \r
- * @param binding\r
- * @param clazz\r
- * @param parameters parameter classes\r
- */\r
- public static void addBinding( Binding binding, Class<?> clazz, Class<?>...parameters )\r
- {\r
- ArgumentImpl args = new ArgumentImpl( parameters );\r
- BindingRequest request = new BindingRequest( clazz, args );\r
- bindingRepository.put( request, binding );\r
- }\r
- \r
- /**\r
- * Add binding factory for compositive bindings \r
- * \r
- * @param factory\r
- */\r
- public static void addBindingFactory( BindingProvider factory )\r
- {\r
- classBindingFactory.addFactory( factory );\r
- }\r
- \r
- /**\r
- * Creates a bean class \r
- * @param type\r
- * @return class\r
- */\r
- public static BindingRequest getBeanBindingRequest( Datatype type ) throws RuntimeBindingConstructionException {\r
- try {\r
- return typeClassFactory.getClass(type);\r
- } catch (BindingConstructionException e) {\r
- throw new RuntimeBindingConstructionException(e);\r
- }\r
- }\r
-\r
- /**\r
- * Creates a bean class \r
- * @param type\r
- * @return class\r
- */\r
- public static Class<?> getBeanClass( Datatype type ) throws BindingConstructionException {\r
- BindingRequest br = typeClassFactory.getClass(type);\r
- return br.getClazz();\r
- }\r
-\r
- /**\r
- * Create binding from datatype that instantiates java classes. \r
- * RecordTypes are Beans, UnionTypes are Classes with @Union annotation, \r
- * ArrayTypes are []. \r
- * \r
- * @param type\r
- * @return class\r
- */\r
- public static Binding getBeanBinding( Datatype type ) throws RuntimeBindingConstructionException {\r
- try {\r
- BindingRequest br = typeClassFactory.getClass(type);\r
- return getBinding( br );\r
- } catch (BindingConstructionException e) {\r
- throw new RuntimeBindingConstructionException(e);\r
- }\r
- }\r
- \r
- /**\r
- * Get a default array binding for a given component type binding.\r
- * Returns a primitive array type binding for primitive types and an\r
- * ObjectArrayBinding for others.\r
- * \r
- * @param componentBinding A binding for a component type\r
- * @return A binding for the array type\r
- */\r
- public static Binding getArrayBinding(Binding componentBinding) {\r
- return getBinding(new ArrayType(componentBinding.type()));\r
- }\r
-\r
- /**\r
- * Get serializer that follows Databoard serialization spec.\r
- * \r
- * @param binding\r
- * @return serializer\r
- * @throws SerializerConstructionException\r
- */\r
- public static Serializer getSerializer(Binding binding) throws SerializerConstructionException {\r
- return serializationFactory.construct(binding);\r
+
+ /**
+ * Add a simple binding to reflection binding factory.
+ *
+ * @param binding
+ * @param clazz
+ * @param parameters parameter classes
+ */
+ public static void addBinding( Binding binding, Class<?> clazz, Class<?>...parameters )
+ {
+ ArgumentImpl args = new ArgumentImpl( parameters );
+ BindingRequest request = new BindingRequest( clazz, args );
+ bindingRepository.put( request, binding );
+ }
+
+ /**
+ * Add binding factory for compositive bindings
+ *
+ * @param factory
+ */
+ public static void addBindingFactory( BindingProvider factory )
+ {
+ classBindingFactory.addFactory( factory );
+ }
+
+ /**
+ * Creates a bean class
+ * @param type
+ * @return class
+ */
+ public static BindingRequest getBeanBindingRequest( Datatype type ) throws RuntimeBindingConstructionException {
+ try {
+ return typeClassFactory.getClass(type);
+ } catch (BindingConstructionException e) {
+ throw new RuntimeBindingConstructionException(e);
+ }
+ }
+
+ /**
+ * Creates a bean class
+ * @param type
+ * @return class
+ */
+ public static Class<?> getBeanClass( Datatype type ) throws BindingConstructionException {
+ BindingRequest br = typeClassFactory.getClass(type);
+ return br.getClazz();
+ }
+
+ /**
+ * Create binding from datatype that instantiates java classes.
+ * RecordTypes are Beans, UnionTypes are Classes with @Union annotation,
+ * ArrayTypes are [].
+ *
+ * @param type
+ * @return class
+ */
+ public static Binding getBeanBinding( Datatype type ) throws RuntimeBindingConstructionException {
+ try {
+ BindingRequest br = typeClassFactory.getClass(type);
+ return getBinding( br );
+ } catch (BindingConstructionException e) {
+ throw new RuntimeBindingConstructionException(e);
+ }
+ }
+
+ /**
+ * Get a default array binding for a given component type binding.
+ * Returns a primitive array type binding for primitive types and an
+ * ObjectArrayBinding for others.
+ *
+ * @param componentBinding A binding for a component type
+ * @return A binding for the array type
+ */
+ public static Binding getArrayBinding(Binding componentBinding) {
+ return getBinding(new ArrayType(componentBinding.type()));
+ }
+
+ /**
+ * Get serializer that follows Databoard serialization spec.
+ *
+ * @param binding
+ * @return serializer
+ * @throws SerializerConstructionException
+ */
+ public static Serializer getSerializer(Binding binding) throws SerializerConstructionException {
+ return serializationFactory.getSerializer(binding);
}
-\r
- /**\r
- * Get serializer that follows Databoard serialization spec.\r
- * \r
- * @param binding\r
- * @return serializer\r
- * @throws RuntimeSerializerConstructionException\r
- */\r
- public static Serializer getSerializerUnchecked(Binding binding) throws RuntimeSerializerConstructionException {\r
- try {\r
- return serializationFactory.construct(binding);\r
- } catch (SerializerConstructionException e) {\r
- throw new RuntimeSerializerConstructionException(e);\r
- }\r
- }\r
-\r
- /**\r
- * Get serializer that follows Databoard serialization spec.\r
- * \r
- * @param clazz\r
- * @return serializer\r
- * @throws SerializerConstructionException\r
- */\r
- public static Serializer getSerializer(Class<?> clazz) throws SerializerConstructionException {\r
- try {\r
- Binding binding = getBinding(clazz);\r
- return serializationFactory.construct(binding);\r
- } catch (BindingConstructionException e) {\r
- throw new SerializerConstructionException( e );\r
- }\r
- }\r
-\r
- /**\r
- * Get serializer that follows Databoard serialization spec.\r
- * \r
- * @param clazz\r
- * @return serializer serializer\r
- * @throws RuntimeSerializerConstructionException\r
- */\r
- public static Serializer getSerializerUnchecked(Class<?> clazz) throws RuntimeSerializerConstructionException {\r
- try {\r
- Binding binding = getBinding(clazz);\r
- return serializationFactory.construct(binding);\r
- } catch (SerializerConstructionException e) {\r
- throw new RuntimeSerializerConstructionException(e);\r
- } catch (BindingConstructionException e) {\r
- throw new RuntimeSerializerConstructionException( new SerializerConstructionException(e) );\r
- }\r
+
+ /**
+ * Get serializer that follows Databoard serialization spec.
+ *
+ * @param binding
+ * @return serializer
+ * @throws RuntimeSerializerConstructionException
+ */
+ public static Serializer getSerializerUnchecked(Binding binding) throws RuntimeSerializerConstructionException {
+ return serializationFactory.getSerializerUnchecked(binding);
+ }
+
+ /**
+ * Get serializer that follows Databoard serialization spec.
+ *
+ * @param clazz
+ * @return serializer
+ * @throws SerializerConstructionException
+ */
+ public static Serializer getSerializer(Class<?> clazz) throws SerializerConstructionException {
+ try {
+ Binding binding = getBinding(clazz);
+ return serializationFactory.getSerializer(binding);
+ } catch (BindingConstructionException e) {
+ throw new SerializerConstructionException( e );
+ }
+ }
+
+ /**
+ * Get serializer that follows Databoard serialization spec.
+ *
+ * @param clazz
+ * @return serializer serializer
+ * @throws RuntimeSerializerConstructionException
+ */
+ public static Serializer getSerializerUnchecked(Class<?> clazz) throws RuntimeSerializerConstructionException {
+ try {
+ Binding binding = getBinding(clazz);
+ return serializationFactory.getSerializerUnchecked(binding);
+ } catch (BindingConstructionException e) {
+ throw new RuntimeSerializerConstructionException( new SerializerConstructionException(e) );
+ }
}
/**
* Create an adapter that adapts two bindings of the same
*
* {@link AdaptException} is thrown at runtime, if number conversion is not
* posible, e.g. converting value 500 from Integer to Byte.
- * Note, there is also a possibility of precision loss, in many conversions\r
+ * Note, there is also a possibility of precision loss, in many conversions
* e.g. from double to int.
*
* @param domain binding of the source instance
throws AdaptException
{
try {
- if (domain.equals(range)) {\r
- return value;\r
- }\r
- else if (range instanceof VariantBinding) {\r
- if (domain instanceof VariantBinding) {\r
- // Copy variant contents directly\r
- Binding contentBinding = ((VariantBinding)domain).getContentBinding( value );\r
- Object content = ((VariantBinding)domain).getContent( value ); \r
- return ((VariantBinding)range).create( contentBinding, content );\r
- }\r
- else {\r
- // Default to just wrapping the value (avoid adapter construction to save memory)\r
- return ((VariantBinding)range).create(domain, value);\r
- }\r
- }\r
- else if (domain instanceof VariantBinding) {\r
- return adapt(((VariantBinding)domain).getContent( value ), ((VariantBinding)domain).getContentBinding( value ), range );\r
- }\r
- else {\r
- return adapterFactory.getAdapter(domain, range, true, false).adapt(value);\r
+ if (domain.equals(range)) {
+ return value;
+ }
+ else if (range instanceof VariantBinding) {
+ if (domain instanceof VariantBinding) {
+ // Copy variant contents directly
+ Binding contentBinding = ((VariantBinding)domain).getContentBinding( value );
+ Object content = ((VariantBinding)domain).getContent( value );
+ return ((VariantBinding)range).create( contentBinding, content );
+ }
+ else {
+ // Default to just wrapping the value (avoid adapter construction to save memory)
+ return ((VariantBinding)range).create(domain, value);
+ }
+ }
+ else if (domain instanceof VariantBinding) {
+ return adapt(((VariantBinding)domain).getContent( value ), ((VariantBinding)domain).getContentBinding( value ), range );
+ }
+ else {
+ return adapterFactory.getAdapter(domain, range, true, false).adapt(value);
}
} catch (AdapterConstructionException | BindingException e) {
throw new AdaptException(e);
- }\r
+ }
}
/**
- * Adapt a value of one type to another. Exceptions are run-time. Use this\r
+ * Adapt a value of one type to another. Exceptions are run-time. Use this
* if it safe to assume the conversion will be successful.
*
* @param value
*/
public static Object adaptUnchecked(Object value, Binding domain, Binding range)
throws RuntimeAdapterConstructionException, RuntimeAdaptException
- {\r
+ {
try {
- if (domain==range) {\r
- return value;\r
- }\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
+ if (domain==range) {
+ return value;
+ }
+ 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 adapterFactory.getAdapter(domain, range, true, false).adaptUnchecked(value);
} catch (RuntimeAdapterConstructionException e) {
throw new RuntimeAdaptException(new AdaptException(e.getCause()));
} catch (AdapterConstructionException e) {
throw new RuntimeAdaptException(new AdaptException(e));
- } catch (BindingException e) {\r
- throw new RuntimeAdaptException(new AdaptException(e));\r
+ } catch (BindingException e) {
+ throw new RuntimeAdaptException(new AdaptException(e));
}
}
/**
- * Adapt and clone a value instance to another type. Immutable \r
+ * Adapt and clone a value instance to another type. Immutable
* bindings may return the argument as is, others return a cloned copy.
*
* @param value
public static Object clone(Object value, Binding domain, Binding range)
throws AdaptException
{
- try {\r
- if (domain==range) {\r
- if (domain.isImmutable()) {\r
- return value;\r
- } else { \r
- return domain.clone(value);\r
- }\r
+ try {
+ if (domain==range) {
+ if (domain.isImmutable()) {
+ return value;
+ } else {
+ return domain.clone(value);
+ }
}
return adapterFactory.getAdapter(domain, range, true, true).adapt(value);
} catch (AdapterConstructionException 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.
- * \r
- * This method throws only runtime exceptions. Use this if it is safe to assume\r
- * that the conversion will be successful.\r
+ *
+ * This method throws only runtime exceptions. Use this if it is safe to assume
+ * that the conversion will be successful.
*
* @param value
* @param domain
/**
* Compares two data values for order. Returns a negative integer,
- * zero, or a positive integer if, the first argument precedes/lesser than \r
+ * zero, or a positive integer if, the first argument precedes/lesser than
* the second, is equal to, or successor/greater than the second.<p>
*
* DataTypes of b1 and b2 are not equal, then data types are compared. <p>
public static Comparator<Object> createComparator(final Binding b1, final Binding b2)
{
return DataValueUtil.createComparator(b1, b2);
- }\r
- \r
- /**\r
- * Print the content of an object as a structure.\r
- * Utility function for debug purposes.\r
- * \r
- * @param o\r
- * @return content\r
- */\r
- public static String toString(Object o) {\r
- try {\r
- Binding b = Bindings.getBinding( o.getClass() );\r
- return b.printValueDefinition(o, true);\r
- } catch (BindingConstructionException e) {\r
- return "<error "+e.getClass().getName()+" "+e.getMessage()+">";\r
- } catch (IOException e) {\r
- return "<error "+e.getClass().getName()+" "+e.getMessage()+">";\r
- } catch (BindingException e) {\r
- return "<error "+e.getClass().getName()+" "+e.getMessage()+">";\r
- }\r
- }\r
- \r
- static {\r
- STRING = new StringBindingDefault( Datatypes.STRING ); \r
- INTEGER = new IntegerBindingDefault( Datatypes.INTEGER ); \r
- BOOLEAN = new BooleanBindingDefault( Datatypes.BOOLEAN ); \r
- BYTE = new ByteBindingDefault( Datatypes.BYTE ); \r
- LONG = new LongBindingDefault( Datatypes.LONG ); \r
- DOUBLE = new DoubleBindingDefault( Datatypes.DOUBLE ); \r
- FLOAT = new FloatBindingDefault( Datatypes.FLOAT ); \r
- VOID = VoidBinding.VOID_BINDING;\r
- BOOLEAN_ARRAY = new BooleanArrayBinding( Datatypes.BOOLEAN_ARRAY, BOOLEAN ); \r
- BYTE_ARRAY = new ByteArrayBinding( Datatypes.BYTE_ARRAY, BYTE );\r
- INT_ARRAY = new IntArrayBinding( Datatypes.INTEGER_ARRAY, INTEGER );\r
- LONG_ARRAY = new LongArrayBinding( Datatypes.LONG_ARRAY, LONG );\r
- FLOAT_ARRAY = new FloatArrayBinding( Datatypes.FLOAT_ARRAY, FLOAT );\r
- DOUBLE_ARRAY = new DoubleArrayBinding( Datatypes.DOUBLE_ARRAY, DOUBLE );\r
- STRING_ARRAY = new StringArrayBinding( Datatypes.STRING_ARRAY, STRING );\r
- UNSIGNED_INTEGER = new UnsignedIntegerBinding.Immutable( Datatypes.INTEGER );\r
- UNSIGNED_BYTE = new UnsignedByteBinding.Immutable( Datatypes.BYTE );\r
- UNSIGNED_LONG = new UnsignedLongBinding.Immutable( Datatypes.LONG );\r
- MUTABLE_STRING = new MutableStringBinding( Datatypes.STRING );\r
- MUTABLE_INTEGER = new MutableIntegerBinding( Datatypes.INTEGER );\r
- MUTABLE_BOOLEAN = new MutableBooleanBinding( Datatypes.BOOLEAN );\r
- MUTABLE_BYTE = new MutableByteBinding( Datatypes.BYTE );\r
- MUTABLE_LONG = new MutableLongBinding( Datatypes.LONG );\r
- MUTABLE_FLOAT = new MutableFloatBinding( Datatypes.FLOAT );\r
- MUTABLE_DOUBLE = new MutableDoubleBinding( Datatypes.DOUBLE );\r
- MUTABLE_UNSIGNED_INTEGER = new UnsignedIntegerBinding.Mutable( Datatypes.INTEGER );\r
- MUTABLE_UNSIGNED_BYTE = new UnsignedByteBinding.Mutable( Datatypes.BYTE );\r
- MUTABLE_UNSIGNED_LONG = new UnsignedLongBinding.Mutable( Datatypes.LONG );\r
- \r
- databoard = new Databoard();\r
- \r
- mutableBindingRepository = databoard.mutableBindingRepository;\r
- defaultBindingRepository = databoard.defaultBindingRepository;\r
- bindingRepository = databoard.bindingRepository;\r
- serializerRepository = databoard.serializerRepository;\r
- mutableBindingFactory = databoard.mutableBindingFactory;\r
- defaultBindingFactory = databoard.defaultBindingFactory;\r
- classBindingFactory = databoard.classBindingFactory;\r
- serializationFactory = databoard.serializationFactory;\r
- adapterFactory = databoard.adapterFactory;\r
- typeClassFactory = databoard.typeClassFactory;\r
- \r
- BEAN = databoard.BEAN;\r
- VARIANT = databoard.VARIANT;\r
- MUTABLE_VARIANT = new MutableVariantBinding( classBindingFactory, adapterFactory );\r
- STR_VARIANT = databoard.STR_VARIANT;\r
- OBJECT = databoard.OBJECT;\r
- \r
- databoard.initialize();\r
- }\r
+ }
+
+ /**
+ * Print the content of an object as a structure.
+ * Utility function for debug purposes.
+ *
+ * @param o
+ * @return content
+ */
+ public static String toString(Object o) {
+ try {
+ Binding b = Bindings.getBinding( o.getClass() );
+ return b.printValueDefinition(o, true);
+ } catch (BindingConstructionException e) {
+ return "<error "+e.getClass().getName()+" "+e.getMessage()+">";
+ } catch (IOException e) {
+ return "<error "+e.getClass().getName()+" "+e.getMessage()+">";
+ } catch (BindingException e) {
+ return "<error "+e.getClass().getName()+" "+e.getMessage()+">";
+ }
+ }
+ static {
+ STRING = new StringBindingDefault( Datatypes.STRING );
+ INTEGER = new IntegerBindingDefault( Datatypes.INTEGER );
+ BOOLEAN = new BooleanBindingDefault( Datatypes.BOOLEAN );
+ BYTE = new ByteBindingDefault( Datatypes.BYTE );
+ LONG = new LongBindingDefault( Datatypes.LONG );
+ DOUBLE = new DoubleBindingDefault( Datatypes.DOUBLE );
+ FLOAT = new FloatBindingDefault( Datatypes.FLOAT );
+ VOID = VoidBinding.VOID_BINDING;
+ BOOLEAN_ARRAY = new BooleanArrayBinding( Datatypes.BOOLEAN_ARRAY, BOOLEAN );
+ BYTE_ARRAY = new ByteArrayBinding( Datatypes.BYTE_ARRAY, BYTE );
+ INT_ARRAY = new IntArrayBinding( Datatypes.INTEGER_ARRAY, INTEGER );
+ LONG_ARRAY = new LongArrayBinding( Datatypes.LONG_ARRAY, LONG );
+ FLOAT_ARRAY = new FloatArrayBinding( Datatypes.FLOAT_ARRAY, FLOAT );
+ DOUBLE_ARRAY = new DoubleArrayBinding( Datatypes.DOUBLE_ARRAY, DOUBLE );
+ STRING_ARRAY = new StringArrayBinding( Datatypes.STRING_ARRAY, STRING );
+ UNSIGNED_INTEGER = new UnsignedIntegerBinding.Immutable( Datatypes.INTEGER );
+ UNSIGNED_BYTE = new UnsignedByteBinding.Immutable( Datatypes.BYTE );
+ UNSIGNED_LONG = new UnsignedLongBinding.Immutable( Datatypes.LONG );
+ MUTABLE_STRING = new MutableStringBinding( Datatypes.STRING );
+ MUTABLE_INTEGER = new MutableIntegerBinding( Datatypes.INTEGER );
+ MUTABLE_BOOLEAN = new MutableBooleanBinding( Datatypes.BOOLEAN );
+ MUTABLE_BYTE = new MutableByteBinding( Datatypes.BYTE );
+ MUTABLE_LONG = new MutableLongBinding( Datatypes.LONG );
+ MUTABLE_FLOAT = new MutableFloatBinding( Datatypes.FLOAT );
+ MUTABLE_DOUBLE = new MutableDoubleBinding( Datatypes.DOUBLE );
+ MUTABLE_UNSIGNED_INTEGER = new UnsignedIntegerBinding.Mutable( Datatypes.INTEGER );
+ MUTABLE_UNSIGNED_BYTE = new UnsignedByteBinding.Mutable( Datatypes.BYTE );
+ MUTABLE_UNSIGNED_LONG = new UnsignedLongBinding.Mutable( Datatypes.LONG );
+
+ databoard = new Databoard();
+
+ mutableBindingRepository = databoard.mutableBindingRepository;
+ defaultBindingRepository = databoard.defaultBindingRepository;
+ bindingRepository = databoard.bindingRepository;
+ serializerRepository = databoard.serializerRepository;
+ mutableBindingFactory = databoard.mutableBindingFactory;
+ defaultBindingFactory = databoard.defaultBindingFactory;
+ classBindingFactory = databoard.classBindingFactory;
+ serializationFactory = databoard.serializationFactory;
+ adapterFactory = databoard.adapterFactory;
+ typeClassFactory = databoard.typeClassFactory;
+
+ BEAN = databoard.BEAN;
+ VARIANT = databoard.VARIANT;
+ MUTABLE_VARIANT = new MutableVariantBinding( classBindingFactory, adapterFactory );
+ STR_VARIANT = databoard.STR_VARIANT;
+ OBJECT = databoard.OBJECT;
+
+ databoard.initialize();
+
+ DATATYPE = getBindingUnchecked(Datatype.class);
+ /**
+ * {@link Datatype} class has annotations but it can be considered a "class
+ * request" as it is a fundamental building block of Databoard and it has a
+ * fixed structure. Therefore {@link BindingRepository#classMap} is allowed
+ * to contain a cached Datatype.class -> Binding mapping.
+ */
+ bindingRepository.registerClassMapping(Datatype.class, DATATYPE);
+ }
+
}
Code Review / simantics / platform.git / blobdiff