]> gerrit.simantics Code Review - simantics/platform.git/blob - bundles/org.simantics.databoard/src/org/simantics/databoard/Databoard.java
Merge "Added Automatic-module-name to all bundles for Java 9 JPMS compatibility"
[simantics/platform.git] / bundles / org.simantics.databoard / src / org / simantics / databoard / Databoard.java
1 /*******************************************************************************
2  * Copyright (c) 2007, 2012 Association for Decentralized Information Management in
3  * Industry THTH ry.
4  * All rights reserved. This program and the accompanying materials
5  * are made available under the terms of the Eclipse Public License v1.0
6  * which accompanies this distribution, and is available at
7  * http://www.eclipse.org/legal/epl-v10.html
8  *
9  * Contributors:
10  *     VTT Technical Research Centre of Finland - initial API and implementation
11  *******************************************************************************/
12 package org.simantics.databoard;
13
14 import java.io.IOException;
15 import java.lang.reflect.Constructor;
16 import java.lang.reflect.InvocationTargetException;
17 import java.util.Collections;
18 import java.util.Comparator;
19 import java.util.HashMap;
20 import java.util.Map;
21
22 import org.simantics.databoard.adapter.AdaptException;
23 import org.simantics.databoard.adapter.Adapter;
24 import org.simantics.databoard.adapter.AdapterConstructionException;
25 import org.simantics.databoard.adapter.AdapterFactory;
26 import org.simantics.databoard.adapter.RuntimeAdaptException;
27 import org.simantics.databoard.adapter.RuntimeAdapterConstructionException;
28 import org.simantics.databoard.annotations.ArgumentImpl;
29 import org.simantics.databoard.annotations.Arguments;
30 import org.simantics.databoard.binding.Binding;
31 import org.simantics.databoard.binding.VariantBinding;
32 import org.simantics.databoard.binding.classfactory.ImmutableClassesFactory;
33 import org.simantics.databoard.binding.classfactory.TypeClassFactory;
34 import org.simantics.databoard.binding.classfactory.TypeClassSubFactory;
35 import org.simantics.databoard.binding.error.BindingConstructionException;
36 import org.simantics.databoard.binding.error.BindingException;
37 import org.simantics.databoard.binding.error.RuntimeBindingConstructionException;
38 import org.simantics.databoard.binding.factory.BindingRepository;
39 import org.simantics.databoard.binding.factory.DefaultBindingFactory;
40 import org.simantics.databoard.binding.factory.JavaUtilBindingsProvider;
41 import org.simantics.databoard.binding.factory.MutableBindingFactory;
42 import org.simantics.databoard.binding.factory.TroveBindingsProvider;
43 import org.simantics.databoard.binding.factory.TypeBindingFactory;
44 import org.simantics.databoard.binding.impl.BeanBinding;
45 import org.simantics.databoard.binding.impl.ObjectVariantBinding;
46 import org.simantics.databoard.binding.impl.StringVariantBinding;
47 import org.simantics.databoard.binding.mutable.ImmutableVariantBinding;
48 import org.simantics.databoard.binding.mutable.MutableVariant;
49 import org.simantics.databoard.binding.mutable.Variant;
50 import org.simantics.databoard.binding.reflection.BindingProvider;
51 import org.simantics.databoard.binding.reflection.BindingRequest;
52 import org.simantics.databoard.binding.reflection.ClassBindingFactory;
53 import org.simantics.databoard.binding.reflection.VoidBinding;
54 import org.simantics.databoard.serialization.DefaultSerializerFactory;
55 import org.simantics.databoard.serialization.RuntimeSerializerConstructionException;
56 import org.simantics.databoard.serialization.Serializer;
57 import org.simantics.databoard.serialization.SerializerConstructionException;
58 import org.simantics.databoard.serialization.SerializerFactory;
59 import org.simantics.databoard.type.Datatype;
60 import org.simantics.databoard.util.Bean;
61 import org.simantics.databoard.util.DataValueUtil;
62
63 public class Databoard {
64
65         // Repositories
66
67         /** Repository of mutable bindings */
68     public final Map<Datatype, Binding>       mutableBindingRepository    = Collections.synchronizedMap( new HashMap<Datatype, Binding>() );
69
70     /** Repository of default bindings */
71     public final Map<Datatype, Binding>       defaultBindingRepository    = Collections.synchronizedMap( new HashMap<Datatype, Binding>() );
72
73     /** Repository of class Bindings */
74     public final BindingRepository            bindingRepository = new BindingRepository();
75
76     /** Repository of serializers */
77     public final Map<Binding, Serializer>     serializerRepository        = Collections.synchronizedMap( new HashMap<Binding, Serializer>() ); 
78         
79     
80     // Factories
81
82     /** Mutable Bindings Factory */
83         public final TypeBindingFactory           mutableBindingFactory = new MutableBindingFactory( mutableBindingRepository );
84
85         /** Default Bindings Factory */
86         public final TypeBindingFactory           defaultBindingFactory = new DefaultBindingFactory( defaultBindingRepository );
87
88         /** Reflection based Binding Factory, create binding to class */
89     public final ClassBindingFactory             classBindingFactory = new ClassBindingFactory( bindingRepository, defaultBindingFactory );
90
91     /** Serializer Factory */
92     public final SerializerFactory               serializationFactory = new DefaultSerializerFactory( serializerRepository );
93
94     /** Adapter Factory */
95         public final AdapterFactory              adapterFactory = new AdapterFactory();
96         
97         /** Class Factory */ 
98         public final TypeClassFactory typeClassFactory = new TypeClassFactory();
99         
100         
101         public final VariantBinding VARIANT;                    // Variant      
102         public final VariantBinding OBJECT;                     // java.lang.Object ( as variant )      
103         public final VariantBinding STR_VARIANT;                // java.lang.String ( as variant )
104         public final Binding        BEAN;            // Bean ( as variant )                     
105
106         public Databoard() {
107         classBindingFactory.addFactory( new TroveBindingsProvider() );
108         classBindingFactory.addFactory( new JavaUtilBindingsProvider() );
109         
110         addDefaultBinding( Datatypes.STRING, Bindings.STRING );
111         addDefaultBinding( Datatypes.INTEGER, Bindings.INTEGER );
112         addDefaultBinding( Datatypes.BOOLEAN, Bindings.BOOLEAN );
113         addDefaultBinding( Datatypes.BYTE, Bindings.BYTE );
114         addDefaultBinding( Datatypes.LONG, Bindings.LONG );
115         addDefaultBinding( Datatypes.DOUBLE, Bindings.DOUBLE ); 
116         addDefaultBinding( Datatypes.FLOAT, Bindings.FLOAT );   
117         addDefaultBinding( Datatypes.VOID, Bindings.VOID );
118         addDefaultBinding( Datatypes.BOOLEAN_ARRAY, Bindings.BOOLEAN_ARRAY );
119         addDefaultBinding( Datatypes.BYTE_ARRAY, Bindings.BYTE_ARRAY );
120         addDefaultBinding( Datatypes.INTEGER_ARRAY, Bindings.INT_ARRAY );
121         addDefaultBinding( Datatypes.LONG_ARRAY, Bindings.LONG_ARRAY );
122         addDefaultBinding( Datatypes.FLOAT_ARRAY, Bindings.FLOAT_ARRAY );
123         addDefaultBinding( Datatypes.DOUBLE_ARRAY, Bindings.DOUBLE_ARRAY );
124         addDefaultBinding( Datatypes.STRING_ARRAY, Bindings.STRING_ARRAY );
125         
126         VARIANT        = new ImmutableVariantBinding( classBindingFactory, adapterFactory );
127         OBJECT         = new ObjectVariantBinding( classBindingFactory, adapterFactory );
128         BEAN           = new BeanBinding( classBindingFactory, typeClassFactory, adapterFactory );
129         STR_VARIANT    = new StringVariantBinding( serializationFactory, VARIANT );     
130
131         // Add sub-factory that creates binding for Bean
132         classBindingFactory.addFactory( new DataboardBindings() );
133         
134                 // Add class factory that constructs basic types
135                 typeClassFactory.addFactory( new ImmutableClassesFactory() );
136                 
137                 // Bindings.databoard cannot initialize itself
138                 if (Bindings.databoard != null) {
139                         initialize();
140                 }
141         }
142         
143         void initialize() {
144                 // Add run-time class factory, if objectweb.asm-library is available.
145                 try {
146                         // Check ASM Exists
147                         Class.forName("org.objectweb.asm.ClassWriter");
148                         Class<?> y = Class.forName("org.simantics.databoard.binding.classfactory.AsmTypeClassFactory");
149                         Constructor<?> c = y.getConstructor( TypeClassFactory.class );
150                         TypeClassSubFactory f = (TypeClassSubFactory) c.newInstance(typeClassFactory);
151                         typeClassFactory.addFactory( f );
152                         
153                         BindingRequest br = new BindingRequest( Datatype.class ); 
154                         Binding datatypeBinding = getBinding( br );
155                         typeClassFactory.getRepository().put(datatypeBinding.type(), br);
156                         bindingRepository.put(br, datatypeBinding);
157                 } catch (ClassNotFoundException e) {
158                 } catch (InstantiationException e) {
159                 } catch (IllegalAccessException e) {
160                 } catch (IllegalArgumentException e) {
161                 } catch (InvocationTargetException e) {
162                 } catch (SecurityException e) {
163                 } catch (NoSuchMethodException e) {
164                 } catch (BindingConstructionException e) {
165                         e.printStackTrace();
166                 }
167         }
168         
169         public void clear() {
170                 mutableBindingRepository.clear();
171                 defaultBindingRepository.clear();
172                 bindingRepository.clear();
173                 serializerRepository.clear();           
174         }
175                 
176     /**
177      * Get or create a binding that is completely mutable java class. 
178      * 
179          * DataType           | Class of the bound instance
180          * ===================|==================
181          * UnionType          | GenericBinding.TaggedObject.class
182          * OptionType         | ValueContainer.class
183          * RecordType         | Object[].class
184          * BooleanType        | MutableBoolean.class
185          * DoubleType         | MutableDouble.class
186          * FloatType          | MutableFloat.class
187          * ByteType           | MutableByte.class
188          * IntegerType        | MutableInt.class
189          * LongType           | MutableLong.class
190          * StringType         | ValueContainer.class
191          * ArrayType          | ArrayList.class
192          * MapType            | TreeMap.class
193          * VariantType        | MutableVariant.class
194          * 
195          * Note, requesting a binding with this convenience method stores the 
196          * binding and the type with strong reference, thus preventing garbage 
197          * collection. To allow garbage collection, please use another instance of 
198          * GenericBindingFactory and binding repository (Map<Datatype, Binding>). <p>
199      *
200          * @param type the type to create binding to
201          * @return binding binding to a mutable class 
202      */    
203     @SuppressWarnings("unchecked")
204         public <T extends Binding> T getMutableBinding(Datatype type) {
205         try {
206                 Binding binding = mutableBindingRepository.get(type);
207                 if (binding!=null) return (T) binding;
208                 synchronized(mutableBindingRepository) {
209                         return (T) mutableBindingFactory.getBinding(type);
210                 }
211                 } catch (BindingConstructionException e) {
212                         // Unexpected - if error is thrown there is fault in GenericBindingScheme
213                         throw new RuntimeBindingConstructionException(e);
214                 }
215     }
216     
217     /**
218      * Get or create a binding based on default java classes, such as 
219      * Integer.class, or byte[].class. The result is often binding for an 
220      * immutable classs. These bindings are more efficient than mutable bindings (above).
221      * 
222          * DataType           | Class of the bound instance
223          * ===================|==================
224      * BooleanType        | Boolean.class
225      * ByteType           | Byte.class
226      * FloatType          | Float.class
227      * DoubleType         | Double.class
228      * IntegerType        | Int.class
229      * LongType           | Long.class
230      * StringType         | String.class
231      * UnionType          | TaggedObject.class
232      * OptionType         | ValueContainer.class
233      * RecordType         | Object[].class
234      * MapType            | TreeMap.class
235      * VariantType        | Variant.class
236      * ArrayType(Boolean) | boolean[].class
237      * ArrayType(Byte)    | byte[].class
238      * ArrayType(Integer) | int[].class
239      * ArrayType(Long)    | long[].class
240      * ArrayType(Float)   | float[].class
241      * ArrayType(Double)  | double[].class
242      * ArrayType(Byte)    | byte[].class
243      * ArrayType( T )     | Object[].class
244      * 
245          * Note, requesting a binding with this convenience method stores the 
246          * binding and the type with strong reference, thus preventing garbage 
247          * collection. To allow garbage collection, please use another instance of 
248          * DefaultBindingFactory and binding repository (Map<Datatype, Binding>). <p>
249      *
250          * @param type the type to create binding to
251          * @return binding binding to a mutable class 
252      */    
253     @SuppressWarnings("unchecked")
254         public <T extends Binding> T getBinding(Datatype type) {
255         try {
256                 Binding binding = defaultBindingRepository.get(type);
257                 if (binding!=null) return (T) binding;
258                 synchronized(defaultBindingRepository) {
259                         return (T) defaultBindingFactory.getBinding(type);
260                 }
261         } catch (BindingConstructionException e) {
262                         // Unexpected - if error is thrown there is fault in DefaultBindingScheme
263                         throw new RuntimeBindingConstructionException(e);
264                 }
265     }    
266         
267         /**
268          * Get a binding to a Java Class. Details can be added by placing annotations
269          * to the java classes. See more in package org.simantics.databoard.annotations. 
270          * <p>
271          *  
272          * Whether the result is a completely mutable or not depends on the 
273          * requested class. For instance, fields such as Boolean, Integer, Long
274          * are not mutable, instead MutableBoolean, MutableInteger and MutableLong are.
275          * The length of Object[] is not mutable, but length of List<Object> is. <p>
276          * 
277          * Note, requesting a binding with this convenience method stores the 
278          * binding and the class with strong reference, thus preventing garbage 
279          * collection. To allow garbage collection, please use another instance of 
280          * BindingFactory and binding repository (Map<BindingRequest, Binding>). <p> 
281          * 
282          * @see ClassBindingFactory  
283          * @param clazz 
284          * @return binding
285          * @throws BindingConstructionException
286          */
287     @SuppressWarnings("unchecked")
288         public <T extends Binding> T getBinding(Class<?> clazz)
289     throws BindingConstructionException
290     {
291         Binding binding = bindingRepository.get( clazz );
292         if (binding != null) {
293                 return (T) binding;
294         }
295         
296         BindingRequest request = new BindingRequest( clazz );
297         synchronized(classBindingFactory) {
298                 binding = classBindingFactory.construct(request);
299         }
300                 return (T) binding;
301     }
302
303     @SuppressWarnings("unchecked")
304         public <T extends Binding> T getBinding(BindingRequest request)
305     throws BindingConstructionException
306     {
307         synchronized(classBindingFactory) {
308                 return (T) classBindingFactory.construct(request);
309         }
310     }
311     
312         /**
313          * Get a binding for a Java Class. Use this method to acquire class 
314          * parameters for a generics class. <p>
315          * 
316          * Example 1: 
317          * 
318          *    Binding binding = getBinding(Map.class, String.class, Integer.class);
319          *    Map<String, Integer> map = (Map<String, Integer>) binding.createDefault();
320          *    
321          * Example 2:
322          *    
323      *  Binding d = getBinding(List.class, Integer.class);
324          *  List<Integer> list = (List<Integer>) d.createRandom(5);
325          *    
326          * Example 3:
327          *    
328      *  Binding d = getBinding(List.class, List.class, Integer.class);
329          *  List<List<Integer>> list = (List<List<Integer>>) d.createRandom(5);
330          * 
331          * @see ClassBindingFactory  
332          * @param clazz
333          * @return binding
334          * @throws BindingConstructionException
335          */
336     @SuppressWarnings("unchecked")
337         public <T extends Binding> T getBinding(Class<?> clazz, Class<?>...parameters)
338     throws BindingConstructionException
339     {
340         BindingRequest request = new BindingRequest( clazz, parameters );
341         synchronized(classBindingFactory) {
342                 return (T) classBindingFactory.construct(request);
343         }
344     }    
345     
346     /**
347          * Read binding and type from a class. DataType details and parameters
348          * are read as annotations placed in the class.  
349          * (See org.simantics.databoard.annotations)
350          * <p>
351          * As an exception, in the subclasses of {@link Throwable}, the fields of
352          * Throwable are omited.
353          * <p>
354          * This method is used for well-known classes where the caller is 100% sure
355          * that a binding is construable without exception. <p> 
356          * 
357          * @param clazz
358          * @return binding
359          * @throws RuntimeBindingConstructionException
360      */
361         @SuppressWarnings("unchecked")
362         public <T extends Binding> T getBindingUnchecked(Class<?> clazz)
363     throws RuntimeBindingConstructionException
364     {
365                 try {
366                 return (T) getBinding(clazz);
367                 } catch (BindingConstructionException e) {
368                         throw new RuntimeBindingConstructionException(e);
369                 }
370     }    
371
372         /**
373          * Get a binding for a Java Class. Use this method to acquire class 
374          * parameters for a generics class. <p>
375          * 
376          * Example 1: 
377          * 
378          *    Binding binding = getBinding(Map.class, String.class, Integer.class);
379          *    Map<String, Integer> map = (Map<String, Integer>) binding.createDefault();
380          *    
381          * Example 2:
382          *    
383      *  Binding d = getBinding(List.class, Integer.class);
384          *  List<Integer> list = (List<Integer>) d.createRandom(5);
385          *    
386          * Example 3:
387          *    
388      *  Binding d = getBinding(List.class, List.class, Integer.class);
389          *  List<List<Integer>> list = (List<List<Integer>>) d.createRandom(5);
390          * 
391          * @see ClassBindingFactory  
392          * @param clazz
393          * @return binding
394          * @throws BindingConstructionException
395          */
396     @SuppressWarnings("unchecked")
397         public <T extends Binding> T getBindingUnchecked(Class<?> clazz, Class<?>...parameters)
398     throws RuntimeBindingConstructionException
399     {
400         try {
401                 Arguments args = new ArgumentImpl(parameters);
402                 BindingRequest request = new BindingRequest( clazz, args );
403                 Binding binding = bindingRepository.get( request );
404                 if (binding!=null);
405                 synchronized(classBindingFactory) {
406                         binding = classBindingFactory.construct(request);
407                 }
408                         return (T) binding;
409         } catch (BindingConstructionException e) {
410                 throw new RuntimeBindingConstructionException(e);
411         }
412     }    
413     
414     /**
415      * Add a simple binding to reflection binding factory.
416      *  
417      * @param binding
418      * @param clazz
419      * @param parameters parameter classes
420      */
421     public void addBinding( Binding binding, Class<?> clazz, Class<?>...parameters )
422     {
423         ArgumentImpl args = new ArgumentImpl( parameters );
424         BindingRequest request = new BindingRequest( clazz, args );
425         bindingRepository.put( request, binding );
426     }
427     
428     /**
429      * Add binding factory for compositive bindings 
430      * 
431      * @param factory
432      */
433     public void addBindingFactory( BindingProvider factory )
434     {
435         classBindingFactory.addFactory( factory );
436     }
437     
438     /**
439      * Creates a bean class 
440      * @param type
441      * @return class
442      */
443     public BindingRequest getBeanBindingRequest( Datatype type ) throws RuntimeBindingConstructionException {
444         try {
445                         return typeClassFactory.getClass(type);
446                 } catch (BindingConstructionException e) {
447                         throw new RuntimeBindingConstructionException(e);
448                 }
449     }
450
451     /**
452      * Creates a bean class 
453      * @param type
454      * @return class
455      */
456     public Class<?> getBeanClass( Datatype type ) throws BindingConstructionException {
457         BindingRequest br = typeClassFactory.getClass(type);
458         return br.getClazz();
459     }
460
461     /**
462      * Create binding from datatype that instantiates java classes. 
463      * RecordTypes are Beans, UnionTypes are Classes with @Union annotation, 
464      * ArrayTypes are []. 
465      * 
466      * @param type
467      * @return class
468      */
469     public Binding getBeanBinding( Datatype type ) throws RuntimeBindingConstructionException {
470                 try {
471                 BindingRequest br = typeClassFactory.getClass(type);
472                 return getBinding( br );
473                 } catch (BindingConstructionException e) {
474                         throw new RuntimeBindingConstructionException(e);
475                 }
476     }
477
478         /**
479          * Get serializer that follows Databoard serialization spec.
480          *  
481          * @param binding
482          * @return serializer
483          * @throws SerializerConstructionException
484          */
485         public Serializer getSerializer(Binding binding) throws SerializerConstructionException {
486                 return serializationFactory.construct(binding);
487         }
488
489         /**
490          * Get serializer that follows Databoard serialization spec.
491          * 
492          * @param binding
493          * @return serializer
494          * @throws RuntimeSerializerConstructionException
495          */
496         public Serializer getSerializerUnchecked(Binding binding) throws RuntimeSerializerConstructionException {
497                 try {
498                         return serializationFactory.construct(binding);
499                 } catch (SerializerConstructionException e) {
500                         throw new RuntimeSerializerConstructionException(e);
501                 }
502         }
503
504         /**
505          * Get serializer that follows Databoard serialization spec.
506          *  
507          * @param clazz
508          * @return serializer
509          * @throws SerializerConstructionException
510          */
511         public Serializer getSerializer(Class<?> clazz) throws SerializerConstructionException {
512                 try {
513                         Binding binding = getBinding(clazz);
514                         return serializationFactory.construct(binding);
515                 } catch (BindingConstructionException e) {
516                         throw new SerializerConstructionException( e );
517                 }
518         }
519
520         /**
521          * Get serializer that follows Databoard serialization spec.
522          * 
523          * @param clazz
524          * @return serializer serializer
525          * @throws RuntimeSerializerConstructionException
526          */
527         public Serializer getSerializerUnchecked(Class<?> clazz) throws RuntimeSerializerConstructionException {
528                 try {
529                         Binding binding = getBinding(clazz);
530                         return serializationFactory.construct(binding);
531                 } catch (SerializerConstructionException e) {
532                         throw new RuntimeSerializerConstructionException(e);
533                 } catch (BindingConstructionException e) {
534                         throw new RuntimeSerializerConstructionException( new SerializerConstructionException(e) );
535                 }
536         }       
537     /**
538      * Create an adapter that adapts two bindings of the same
539      * data type.
540      * 
541      * @param domain binding of the source instance
542      * @param range binding of the result instance
543      * @return result adapter
544      * @throws AdapterConstructionException 
545      */
546     public Adapter getAdapter(Binding domain, Binding range)
547     throws AdapterConstructionException
548     {
549         return adapterFactory.getAdapter(domain, range, false, false);
550     }
551     
552     /**
553      * Create an adapter that adapts between two bindings of the same
554      * data type.
555      * 
556      * @param domain binding of the source instance
557      * @param range binding of the result instance
558      * @return result adapter
559      * @throws AdapterConstructionException 
560      */
561     public Adapter getAdapterUnchecked(Binding domain, Binding range)
562     throws RuntimeAdapterConstructionException
563     {
564         try {
565                         return adapterFactory.getAdapter(domain, range, false, false);
566                 } catch (AdapterConstructionException e) {
567                         throw new RuntimeAdapterConstructionException(e);
568                 }
569     }
570
571     /**
572      * Create a type adapter that adapts instances from one Datatype to 
573      * another. Type Adapter does the following conversions: 
574      * 
575      *    o Number Types, e.g. long -> double
576      *    o Unit Types, e.g. mph -> km/h
577      *    o Record Types, for each field of the range, there must be equal in domain 
578      *    o Union Types, for each tag type of the domain, there must be equal in range
579      * 
580      * {@link AdaptException} is thrown at runtime, if number conversion is not 
581      * posible, e.g. converting value 500 from Integer to Byte.
582      * Note, there is also a possibility of precision loss, in many conversions
583      * e.g. from double to int.
584      * 
585      * @param domain binding of the source instance
586      * @param range binding of the result instance
587      * @return adapter
588      * @throws AdapterConstructionException 
589      */
590     public Adapter getTypeAdapter(Binding domain, Binding range)
591     throws AdapterConstructionException
592     {
593         return adapterFactory.getAdapter(domain, range, true, false);
594     }
595
596     /**
597      * Create a type adapter that adapts instances from one DataType to 
598      * another. Type Adapter does the following conversions: 
599      * 
600      *    o Number Types, e.g. long -> double
601      *    o Unit Types, e.g. mph -> km/h
602      *    o Record Types, for each field of the range, there must be equal in domain 
603      *    o Union Types, for each tag type of the domain, there must be equal in range
604      * 
605      * {@link AdaptException} is thrown at runtime, if number values are 
606      * not compatible, e.g. converting value 500 from Long to Byte.
607      * Note, there is also a possibility of precision loss, e.g. when 
608      * converting from double to int.
609      * 
610      * @param domain binding of the source instance
611      * @param range binding of the result instance
612      * @return result adapter
613      * @throws AdapterConstructionException 
614      */
615     public Adapter getTypeAdapterUnchecked(Binding domain, Binding range)
616     {
617         try {
618                         return adapterFactory.getAdapter(domain, range, true, false);
619                 } catch (AdapterConstructionException e) {
620                         throw new RuntimeAdapterConstructionException(e);
621                 }
622     }
623     
624     /**
625      * Adapt a value of one type to another. 
626      * 
627      * @param value
628      * @param domain
629      * @param range
630      * @return adapted value
631      * @throws AdapterConstructionException
632      * @throws AdaptException
633      */
634     public Object adapt(Object value, Binding domain, Binding range)
635     throws AdaptException
636     {
637         try {
638                 if (domain==range) {
639                                 return value;
640                 }
641                         return adapterFactory.getAdapter(domain, range, true, false).adapt(value);
642                 } catch (AdapterConstructionException e) {
643                         throw new AdaptException(e);
644                 }
645     }
646     
647     /**
648      * Adapt a value of one type to another. Exceptions are run-time. Use this
649      * if it safe to assume the conversion will be successful.
650      * 
651      * @param value
652      * @param domain
653      * @param range
654      * @return adapted value
655      * @throws AdapterConstructionException
656      * @throws AdaptException
657      */
658     public Object adaptUnchecked(Object value, Binding domain, Binding range)
659     throws RuntimeAdapterConstructionException, RuntimeAdaptException
660     {
661         try {
662                 if (domain==range) {
663                                 return value;
664                 }
665                 return  adapterFactory.getAdapter(domain, range, true, false).adaptUnchecked(value);
666                 } catch (RuntimeAdapterConstructionException e) {
667                         throw new RuntimeAdaptException(new AdaptException(e.getCause()));
668                 } catch (AdapterConstructionException e) {
669                         throw new RuntimeAdaptException(new AdaptException(e));
670                 }
671     }    
672     
673     /**
674      * Adapt and clone a value instance to another type. Immutable 
675      * bindings may return the argument as is, others return a cloned copy.  
676      * 
677      * @param value
678      * @param domain
679      * @param range
680      * @return adapted value
681      * @throws AdapterConstructionException
682      * @throws AdaptException
683      */
684     public Object clone(Object value, Binding domain, Binding range)
685     throws AdaptException
686     {
687         try {
688                 if (domain==range) {
689                         if (domain.isImmutable()) {
690                                 return value;
691                         } else { 
692                                 return domain.clone(value);
693                         }
694                 }
695                         return adapterFactory.getAdapter(domain, range, true, true).adapt(value);
696                 } catch (AdapterConstructionException e) {
697                         throw new AdaptException(e);
698                 }
699     }
700     
701
702     /**
703      * Clone a value of one binding to another. Bindings that handle immutable values
704      * may return the same instance, others will guarantee a complete copy.
705      * 
706      * This method throws only runtime exceptions. Use this if it is safe to assume
707      * that the conversion will be successful.
708      * 
709      * @param value
710      * @param domain
711      * @param range
712      * @return adapted value
713      * @throws AdapterConstructionException
714      * @throws AdaptException
715      */
716     public Object cloneUnchecked(Object value, Binding domain, Binding range)
717     throws RuntimeAdapterConstructionException, RuntimeAdaptException
718     {
719         try {
720                         return adapterFactory.getAdapter(domain, range, true, true).adapt(value);
721                 } catch (AdaptException e) {
722                         throw new RuntimeAdaptException(e);
723                 } catch (RuntimeAdapterConstructionException e) {
724                         throw new RuntimeAdaptException(new AdaptException(e.getCause()));
725                 } catch (AdapterConstructionException e) {
726                         throw new RuntimeAdaptException(new AdaptException(e));
727                 }
728     }
729     
730     /**
731      * Compares two data values for order. Returns a negative integer,
732      * zero, or a positive integer if, the first argument precedes/lesser than 
733      * the second, is equal to, or successor/greater than the second.<p>
734      * 
735      * DataTypes of b1 and b2 are not equal, then data types are compared. <p>
736      *
737      * The comparison function is defined at 
738      * http://dev.simantics.org/index.php/Org.simantics.datatype_Manual#CompareTo_and_Equals <p>
739      * 
740      * Note, comparing 2 different number types will not result a value comparison.
741      * Instead values have the following type precedence ByteType, IntegerType, LongType,
742      * FloatType, and the highest DoubleType. <p>
743      *
744      * @param b1 Binding of o1 
745      * @param o1 the first object to be compared.
746      * @param b2 Binding of o2
747      * @param o2 the second object to be compared.
748      * @return a negative integer, zero, or a positive integer as the
749      *         first argument is less than, equal to, or greater than the
750      *         second.
751      * @throws BindingException if object cannot be handled by a binding
752      */
753     public int compare(Binding b1, Object o1, Binding b2, Object o2) 
754     throws BindingException
755     {
756         return DataValueUtil.compare(b1, o1, b2, o2);
757     }
758     
759     /**
760      * Compare two data values for equality. <p>
761      * 
762      * Note, comparing 2 different number types will not result a value comparison.
763      * Instead values have the following type precedence ByteType, IntegerType, LongType,
764      * FloatType, and the highest DoubleType. <p>
765      * 
766      * @param b1
767      * @param o1
768      * @param b2
769      * @param o2
770      * @return true if equal
771      * @throws BindingException
772      */
773     public boolean equals(Binding b1, Object o1, Binding b2, Object o2)
774     throws BindingException
775     {
776         return DataValueUtil.equals(b1, o1, b2, o2);
777     }
778     
779     public Comparator<Object> createComparator(final Binding b1, final Binding b2)
780     {
781         return DataValueUtil.createComparator(b1, b2);
782     }
783     
784     /**
785      * Print the content of an object as a structure.
786      * Utility function for debug purposes.
787      * 
788      * @param o
789      * @return content
790      */
791     public String toString(Object o) {
792         try {
793                         Binding b = getBinding( o.getClass() );
794                         return b.printValueDefinition(o, true);
795                 } catch (BindingConstructionException e) {
796                         return "<error "+e.getClass().getName()+" "+e.getMessage()+">";
797                 } catch (IOException e) {
798                         return "<error "+e.getClass().getName()+" "+e.getMessage()+">";
799                 } catch (BindingException e) {
800                         return "<error "+e.getClass().getName()+" "+e.getMessage()+">";
801                 }
802     }
803     
804     class DataboardBindings implements BindingProvider {
805                 @Override
806                 public Binding provideBinding(ClassBindingFactory mainFactory, BindingRequest request) throws BindingConstructionException {
807                         // Variant Type
808                 if (request.getClazz().equals( Object.class )) return OBJECT;
809                 if (request.getClazz().equals( Void.class ) || request.getClazz().equals(void.class) ) return VoidBinding.VOID_BINDING;
810                 if (request.getClazz().equals( Variant.class) ) return Bindings.VARIANT;
811                 if (request.getClazz().equals( MutableVariant.class) ) return Bindings.MUTABLE_VARIANT;
812                         if (request.getClazz().equals( Bean.class ) ) return BEAN;
813                                 
814                         return null;
815                 }
816         } 
817                                 
818     private void addDefaultBinding(Datatype datatype, Binding binding ) {
819         defaultBindingRepository.put(datatype, binding);
820     }
821
822 }