X-Git-Url: https://gerrit.simantics.org/r/gitweb?a=blobdiff_plain;f=bundles%2Forg.simantics.db.common%2Fsrc%2Forg%2Fsimantics%2Fdb%2Fcommon%2Futils%2FValueType.java;h=97c2e798036ff447feac7f83756ed5885c820d0d;hb=HEAD;hp=ce4103d1bf11f0def99121735617aed67e2d0d04;hpb=969bd23cab98a79ca9101af33334000879fb60c5;p=simantics%2Fplatform.git

diff --git a/bundles/org.simantics.db.common/src/org/simantics/db/common/utils/ValueType.java b/bundles/org.simantics.db.common/src/org/simantics/db/common/utils/ValueType.java
index ce4103d1b..97c2e7980 100644
--- a/bundles/org.simantics.db.common/src/org/simantics/db/common/utils/ValueType.java
+++ b/bundles/org.simantics.db.common/src/org/simantics/db/common/utils/ValueType.java
@@ -1,653 +1,653 @@
-/*******************************************************************************
- * Copyright (c) 2007, 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.db.common.utils;
-
-public abstract class ValueType {
-
-    private ValueType() {
-    }    
-
-    public abstract int     getConstantSize(); // returns -1 if not constant size
-    public abstract void    serialize(ByteBuffer buffer, Object obj);
-    public abstract void    unsafeSerialize(ByteBuffer buffer, Object obj);
-    public abstract Object  deserialize(ByteBuffer buffer);
-
-    public boolean supportsNativeArray() {
-        return false;
-    }
-    public void serializeNativeArray(ByteBuffer buffer, Object obj, int length) {
-        // TODO Throw exception
-    }
-
-    public Object deserializeNativeArray(ByteBuffer buffer, int length) {
-        // TODO Throw exception
-        return null;
-    }
-
-    public byte[] serialize(Object obj) {
-        int constantSize = getConstantSize();
-        ByteBuffer buffer = new ByteBuffer(constantSize >= 0 ? constantSize : 0);
-        serialize(buffer, obj);
-        return buffer.content();
-    }
-
-    public Object deserialize(byte[] bytes) {
-        return deserialize(new ByteBuffer(bytes));
-    }    
-
-    public static class BooleanType extends ValueType {
-        public BooleanType() {}       
-
-        @Override
-        public int getConstantSize() {
-            return 1;
-        }        
-        @Override
-        public void serialize(ByteBuffer buffer, Object obj) {
-            buffer.needs(1);
-            buffer.putByte( (Boolean)obj == true ? (byte)1 : (byte)0 );
-
-        }
-        @Override
-        public void  unsafeSerialize(ByteBuffer buffer, Object obj) {
-            buffer.putByte( (Boolean)obj == true ? (byte)1 : (byte)0 );            
-        }
-        @Override
-        public Object deserialize(ByteBuffer buffer) {
-            return buffer.getByte() != 0;
-        }
-    }
-
-    public static class ByteType extends ValueType {
-        public ByteType() {}       
-
-        @Override
-        public int getConstantSize() {
-            return 1;
-        }        
-        @Override
-        public void serialize(ByteBuffer buffer, Object obj) {
-            buffer.needs(1);
-            buffer.putByte((Byte)obj);
-
-        }
-        @Override
-        public void  unsafeSerialize(ByteBuffer buffer, Object obj) {
-            buffer.putByte((Byte)obj);            
-        }
-        @Override
-        public Object deserialize(ByteBuffer buffer) {
-            return buffer.getByte();
-        }
-    }
-
-    public static class IntegerType extends ValueType {
-        public IntegerType() {}       
-
-        @Override
-        public int getConstantSize() {
-            return 4;
-        }        
-        @Override
-        public void serialize(ByteBuffer buffer, Object obj) {
-            buffer.needs(4);
-            buffer.putInt((Integer)obj);
-
-        }
-        @Override
-        public void  unsafeSerialize(ByteBuffer buffer, Object obj) {
-            buffer.putInt((Integer)obj);            
-        }
-        @Override
-        public Object deserialize(ByteBuffer buffer) {
-            return buffer.getInt();
-        }
-    }
-
-    public static class LongType extends ValueType {
-        public LongType() {}       
-
-        @Override
-        public int getConstantSize() {
-            return 8;
-        }        
-        @Override
-        public void serialize(ByteBuffer buffer, Object obj) {
-            buffer.needs(8);
-            buffer.putLong((Long)obj);
-
-        }
-        @Override
-        public void  unsafeSerialize(ByteBuffer buffer, Object obj) {
-            buffer.putLong((Long)obj);            
-        }
-        @Override
-        public Object deserialize(ByteBuffer buffer) {
-            return buffer.getLong();
-        }
-    }
-    
-    public static class FloatType extends ValueType {
-        public FloatType() {}       
-
-        @Override
-        public int getConstantSize() {
-            return 4;
-        }        
-        @Override
-        public void serialize(ByteBuffer buffer, Object obj) {
-            buffer.needs(4);
-            buffer.putFloat((Float)obj);
-
-        }
-        @Override
-        public void  unsafeSerialize(ByteBuffer buffer, Object obj) {
-            buffer.putFloat((Float)obj);            
-        }
-        @Override
-        public Object deserialize(ByteBuffer buffer) {
-            return buffer.getFloat();
-        }
-    }
-
-    public static class DoubleType extends ValueType {
-        public DoubleType() {}       
-
-        @Override
-        public int getConstantSize() {
-            return 8;
-        }        
-        @Override
-        public void serialize(ByteBuffer buffer, Object obj) {
-            buffer.needs(8);
-            buffer.putDouble((Double)obj);
-
-        }
-        @Override
-        public void  unsafeSerialize(ByteBuffer buffer, Object obj) {
-            buffer.putDouble((Double)obj);            
-        }
-        @Override
-        public Object deserialize(ByteBuffer buffer) {
-            return buffer.getDouble();
-        }
-        public boolean supportsNativeArray() {
-            return true;
-        }
-        public void serializeNativeArray(ByteBuffer buffer, Object obj, int length) {
-            double[] array = (double[])obj;
-            if(length < 0)
-                buffer.putInt(array.length);
-            else
-                ; // TODO check
-            for(double d : array)
-                buffer.putDouble(d);
-        }
-
-        public Object deserializeNativeArray(ByteBuffer buffer, int length) {
-            double[] ret = new double[length];
-            for(int i=0;i<length;++i)
-                ret[i] = buffer.getDouble();
-            return ret;
-        }
-    }
-
-    public static class StringType extends ValueType {
-        public StringType() {}       
-
-        @Override
-        public int getConstantSize() {
-            return -1;
-        }        
-        @Override
-        public void serialize(ByteBuffer buffer, Object obj) {
-            buffer.putString((String)obj);
-
-        }
-        @Override
-        public void  unsafeSerialize(ByteBuffer buffer, Object obj) {
-            // TODO Throw exception
-        }
-        @Override
-        public Object deserialize(ByteBuffer buffer) {
-            return buffer.getString();
-        }
-    }
-
-    public static class ProductType extends ValueType {
-        public final ValueType[] baseTypes;
-        private int constantSize;
-
-        public ProductType(ValueType[] baseTypes) {
-            this.baseTypes = baseTypes;
-            constantSize = 0;
-            for(ValueType b : baseTypes) {
-                int temp = b.getConstantSize();
-                if(temp==-1) {
-                    constantSize = -1;
-                    break;
-                }
-                constantSize += temp;
-            }
-        }
-
-        @Override
-        public int getConstantSize() {
-            return constantSize;
-        }        
-        @Override
-        public void serialize(ByteBuffer buffer, Object obj) {
-            if(constantSize >= 0) {
-                buffer.needs(constantSize);
-                unsafeSerialize(buffer, obj);
-            }
-            else {
-                Object[] subobjects = (Object[])obj;
-                // FIXME Catch cast exception
-                // FIXME Check length
-                for(int i=0;i<baseTypes.length;++i)
-                    baseTypes[i].serialize(buffer, subobjects[i]);
-            }
-        }
-        @Override
-        public void  unsafeSerialize(ByteBuffer buffer, Object obj) {
-            Object[] subobjects = (Object[])obj;
-            // FIXME Catch cast exception
-            // FIXME Check length
-            for(int i=0;i<baseTypes.length;++i)
-                baseTypes[i].unsafeSerialize(buffer, subobjects[i]);
-        }
-        @Override
-        public Object deserialize(ByteBuffer buffer) {
-            Object[] ret = new Object[baseTypes.length];
-            for(int i=0;i<baseTypes.length;++i)
-                ret[i] = baseTypes[i].deserialize(buffer);
-            return ret;
-        }
-    }
-
-    public static class Construction {
-        int constructor;
-        Object value;
-    }
-
-    public static class SumType extends ValueType {
-        public final ValueType[] baseTypes;
-        private int constantSize;
-
-        public SumType(ValueType[] baseTypes) {
-            this.baseTypes = baseTypes;
-            constantSize = -2;
-            for(ValueType b : baseTypes) {
-                int temp = b.getConstantSize();
-                if(temp != constantSize) {
-                    if(constantSize==-2 && temp >= 0)
-                        constantSize = temp;                        
-                    else {
-                        constantSize = -1;
-                        break;
-                    }
-                }
-            }
-            if(constantSize >= 0)
-                constantSize += 4;
-        }
-
-        @Override
-        public int getConstantSize() {
-            return constantSize;
-        }        
-        @Override
-        public void serialize(ByteBuffer buffer, Object obj) {
-            if(constantSize >= 0) {
-                buffer.needs(constantSize);
-                unsafeSerialize(buffer, obj);
-            }
-            else {
-                Construction construction = (Construction)obj;
-                // FIXME validate construction.constructor
-                buffer.needs(4);
-                buffer.putInt(construction.constructor);
-                baseTypes[construction.constructor].serialize(buffer, construction.value);
-            }
-        }
-        @Override
-        public void  unsafeSerialize(ByteBuffer buffer, Object obj) {
-            Construction construction = (Construction)obj;
-            // FIXME validate construction.constructor
-            buffer.putInt(construction.constructor);
-            baseTypes[construction.constructor].unsafeSerialize(buffer, construction.value);
-        }
-        @Override
-        public Object deserialize(ByteBuffer buffer) {
-            Construction ret = new Construction();
-            ret.constructor = buffer.getInt();
-            // FIXME validate construction.constructor
-            ret.value = baseTypes[ret.constructor].deserialize(buffer);
-            return ret;
-        }
-    }
-
-    public static class VariableLengthArrayType extends ValueType {
-        public final ValueType baseType;
-        private int baseTypeConstantSize;
-        private boolean supportsNativeArray;
-
-        public VariableLengthArrayType(ValueType baseType) {
-            this.baseType = baseType;
-            baseTypeConstantSize = baseType.getConstantSize();
-            supportsNativeArray = baseType.supportsNativeArray();
-        }
-
-        @Override
-        public int getConstantSize() {
-            return -1;
-        }        
-
-        @Override
-        public void serialize(ByteBuffer buffer, Object obj) {
-            if(baseTypeConstantSize >= 0) {
-                if(obj instanceof Object[]) {
-                    Object[] subobjects = (Object[])obj;              
-                    buffer.needs(4 + subobjects.length * baseTypeConstantSize);
-                    buffer.putInt(subobjects.length);
-                    for(Object subobj : subobjects)
-                        baseType.unsafeSerialize(buffer, subobj);
-                }
-                else if(supportsNativeArray) 
-                    baseType.serializeNativeArray(buffer, obj, -1);
-                else
-                    ; // TODO exc
-
-            }
-            else {
-                Object[] subobjects = (Object[])obj;              
-                buffer.needs(4);
-                buffer.putInt(subobjects.length);
-                for(Object subobj : subobjects)
-                    baseType.serialize(buffer, subobj);
-            }
-        }
-        @Override
-        public void  unsafeSerialize(ByteBuffer buffer, Object obj) {
-            // TODO Throw exception
-        }
-        @Override
-        public Object deserialize(ByteBuffer buffer) {
-            int length = buffer.getInt();
-            if(supportsNativeArray) 
-                return baseType.deserializeNativeArray(buffer, length);
-            else {
-                Object[] ret = new Object[length];
-                for(int i=0;i<length;++i)
-                    ret[i] = baseType.deserialize(buffer);
-                return ret;
-            }
-        }
-    }
-
-    public static class FixedLengthArrayType extends ValueType {
-        public final ValueType baseType;
-        public final int dimension;
-        private int constantSize;
-        private boolean supportsNativeArray;
-
-        public FixedLengthArrayType(ValueType baseType, int dimension) {
-            this.baseType = baseType;
-            this.dimension = dimension;
-            constantSize = baseType.getConstantSize();
-            if(constantSize >= 0) {
-                constantSize *= dimension;
-                supportsNativeArray = baseType.supportsNativeArray();
-            }
-        }
-
-        @Override
-        public int getConstantSize() {
-            return constantSize;
-        }        
-
-        @Override
-        public void serialize(ByteBuffer buffer, Object obj) {
-            if(constantSize >= 0) {
-                buffer.needs(constantSize);
-                unsafeSerialize(buffer, obj);
-            }
-            else {
-                Object[] subobjects = (Object[])obj;              
-                // FIXME checks
-                for(Object subobj : subobjects)
-                    baseType.serialize(buffer, subobj);
-            }
-        }
-        @Override
-        public void  unsafeSerialize(ByteBuffer buffer, Object obj) {
-            if(supportsNativeArray)
-                baseType.serializeNativeArray(buffer, obj, dimension);
-            else {
-                Object[] subobjects = (Object[])obj;              
-                // FIXME checks
-                for(Object subobj : subobjects)
-                    baseType.unsafeSerialize(buffer, subobj);
-            }
-        }
-        @Override
-        public Object deserialize(ByteBuffer buffer) {
-            if(supportsNativeArray) 
-                return baseType.deserializeNativeArray(buffer, dimension);
-            else {
-                Object[] ret = new Object[dimension];
-                for(int i=0;i<dimension;++i)
-                    ret[i] = baseType.deserialize(buffer);
-                return ret;
-            }
-        }
-    }    
-
-    static final private class ByteBuffer {
-        public byte[] bytes;
-        public int    offset;
-
-        public ByteBuffer(int capacity) {
-            this.bytes = new byte[capacity];
-            this.offset = 0;
-        }
-
-        public ByteBuffer(byte[] bytes) {
-            this.bytes = bytes;
-            this.offset = 0;
-        }
-
-        public void needs(int size) {
-            if(offset + size > bytes.length) {
-                // FIXME bytes = Arrays.copyOf(bytes, newSize);
-                byte[] newBytes = new byte[offset*2 + size];
-                for(int i=0;i<bytes.length;++i)
-                    newBytes[i] = bytes[i];
-                bytes = newBytes;
-            }
-        }
-
-        public byte[] content() {
-            if(offset == bytes.length)
-                return bytes;
-            // FIXME bytes = Arrays.copyOf(bytes, offset);
-            byte[] newBytes = new byte[offset];
-            for(int i=0;i<offset;++i)
-                newBytes[i] = bytes[i];
-            return newBytes;
-        }
-
-        public void putByte(byte v) {
-            bytes[offset] = v;
-            offset += 1;
-        }
-        public void putShort(short v) {
-            bytes[offset] = (byte) v;
-            bytes[offset+1] = (byte) (v >>> 8);
-            offset += 2;
-        }
-        public void putInt(int v) {
-            bytes[offset] = (byte) v;
-            bytes[offset+1] = (byte) (v >>> 8);
-            bytes[offset+2] = (byte) (v >>> 16);
-            bytes[offset+3] = (byte) (v >>> 24);
-            offset += 4;
-        }
-        public void putLong(long v) {
-            bytes[offset] = (byte) v;
-            bytes[offset+1] = (byte) (v >>> 8);
-            bytes[offset+2] = (byte) (v >>> 16);
-            bytes[offset+3] = (byte) (v >>> 24);
-            bytes[offset+4] = (byte) (v >>> 32);
-            bytes[offset+5] = (byte) (v >>> 40);
-            bytes[offset+6] = (byte) (v >>> 48);
-            bytes[offset+7] = (byte) (v >>> 56);
-            offset += 8;
-        }
-        public void putFloat(float _v) {
-            int v = Float.floatToIntBits(_v);
-            bytes[offset] = (byte) v;
-            bytes[offset+1] = (byte) (v >>> 8);
-            bytes[offset+2] = (byte) (v >>> 16);
-            bytes[offset+3] = (byte) (v >>> 24);
-            offset += 4;
-        }
-        public void putDouble(double _v) {
-            long v = Double.doubleToLongBits(_v);
-            bytes[offset] = (byte) v;
-            bytes[offset+1] = (byte) (v >>> 8);
-            bytes[offset+2] = (byte) (v >>> 16);
-            bytes[offset+3] = (byte) (v >>> 24);
-            bytes[offset+4] = (byte) (v >>> 32);
-            bytes[offset+5] = (byte) (v >>> 40);
-            bytes[offset+6] = (byte) (v >>> 48);
-            bytes[offset+7] = (byte) (v >>> 56);
-            offset += 8;
-        }
-        public void putString(String str) {
-
-            // UTF-16 -> modified UTF-8
-
-            int length = 4;
-            for(int i=0;i<str.length();++i) {
-                char c = str.charAt(i);
-                if(c < 0x80)
-                    length += 1;
-                else if(c < 0x800)
-                    length += 2;
-                else 
-                    length += 3;
-            }
-            needs(length);
-            putInt(str.length());
-            for(int i=0;i<str.length();++i) {
-                char c = str.charAt(i);
-                if(c < 0x80) {
-                    bytes[offset] = (byte)c;
-                    offset += 1;
-                }
-                else if(c < 0x800) {
-                    bytes[offset]   = (byte)(0xc0 + (c >>> 6));
-                    bytes[offset+1] = (byte)(0x80 + (c & 0x3f));
-                    offset += 2;
-                }
-                else {
-                    // FIXME handle range D800 - DFFF
-                    bytes[offset]   = (byte)(0xe0 + (c >>> 12));
-                    bytes[offset+1] = (byte)(0x80 + ((c >>> 6) & 0x3f));
-                    bytes[offset+2] = (byte)(0x80 + (c & 0x3f));
-                    offset += 3;
-                }
-            }
-        }
-        public byte getByte() {
-            ++offset;
-            return bytes[offset-1];
-        }
-        public short getShort() {
-            int v = bytes[offset] & 0xFF;
-            v += (bytes[offset+1] & 0xFF) << 8;
-            offset += 2;
-            return (short)v;
-        }
-        public int getInt() {
-            int v = bytes[offset] & 0xFF;
-            v += (bytes[offset+1] & 0xFF) << 8;
-            v += (bytes[offset+2] & 0xFF) << 16;
-            v += (bytes[offset+3] & 0xFF) << 24;
-            offset += 4;
-            return v;
-        }
-        public long getLong() {
-            long v = bytes[offset] & 0xFFL;
-            v += (bytes[offset+1] & 0xFFL) << 8;
-            v += (bytes[offset+2] & 0xFFL) << 16;
-            v += (bytes[offset+3] & 0xFFL) << 24;
-            v += (bytes[offset+4] & 0xFFL) << 32;
-            v += (bytes[offset+5] & 0xFFL) << 40;
-            v += (bytes[offset+6] & 0xFFL) << 48;
-            v += (bytes[offset+7] & 0xFFL) << 56;
-            offset += 8;
-            return v;
-        }
-        public float getFloat() {
-            int v = bytes[offset] & 0xFF;
-            v += (bytes[offset+1] & 0xFF) << 8;
-            v += (bytes[offset+2] & 0xFF) << 16;
-            v += (bytes[offset+3] & 0xFF) << 24;
-            offset += 4;
-            return Float.intBitsToFloat(v);
-        }
-        public double getDouble() {
-            long v = bytes[offset] & 0xFFL;
-            v += (bytes[offset+1] & 0xFFL) << 8;
-            v += (bytes[offset+2] & 0xFFL) << 16;
-            v += (bytes[offset+3] & 0xFFL) << 24;
-            v += (bytes[offset+4] & 0xFFL) << 32;
-            v += (bytes[offset+5] & 0xFFL) << 40;
-            v += (bytes[offset+6] & 0xFFL) << 48;
-            v += (bytes[offset+7] & 0xFFL) << 56;
-            offset += 8;
-            return Double.longBitsToDouble(v);
-        }
-        public String getString() {
-            int length = getInt();
-            char[] chars = new char[length];
-            for(int i=0;i<length;++i) {
-                int b0 = (int)bytes[offset];
-                int c;
-                if(b0 >= 0) {
-                    c = b0;
-                    offset += 1;
-                }
-                else if(b0 < 0xe0-256) {
-                    c = ((b0 & 0x1f) << 6) +
-                        (bytes[offset+1] & 0x3f);
-                    offset += 2;
-                }
-                else if(b0 < 0xf0-256) {
-                    c = ((b0 & 0x0f) << 12) +
-                        ((bytes[offset+1] & 0x3f) << 6) +
-                        (bytes[offset+2] & 0x3f);
-                    offset += 3;
-                }
-                else
-                    c = 0; // FIXME
-                chars[i] = (char)c;
-            }
-            return new String(chars);
-        }
-        
-    }
-    
-}
+/*******************************************************************************
+ * Copyright (c) 2007, 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.db.common.utils;
+
+public abstract class ValueType {
+
+    private ValueType() {
+    }    
+
+    public abstract int     getConstantSize(); // returns -1 if not constant size
+    public abstract void    serialize(ByteBuffer buffer, Object obj);
+    public abstract void    unsafeSerialize(ByteBuffer buffer, Object obj);
+    public abstract Object  deserialize(ByteBuffer buffer);
+
+    public boolean supportsNativeArray() {
+        return false;
+    }
+    public void serializeNativeArray(ByteBuffer buffer, Object obj, int length) {
+        // TODO Throw exception
+    }
+
+    public Object deserializeNativeArray(ByteBuffer buffer, int length) {
+        // TODO Throw exception
+        return null;
+    }
+
+    public byte[] serialize(Object obj) {
+        int constantSize = getConstantSize();
+        ByteBuffer buffer = new ByteBuffer(constantSize >= 0 ? constantSize : 0);
+        serialize(buffer, obj);
+        return buffer.content();
+    }
+
+    public Object deserialize(byte[] bytes) {
+        return deserialize(new ByteBuffer(bytes));
+    }    
+
+    public static class BooleanType extends ValueType {
+        public BooleanType() {}       
+
+        @Override
+        public int getConstantSize() {
+            return 1;
+        }        
+        @Override
+        public void serialize(ByteBuffer buffer, Object obj) {
+            buffer.needs(1);
+            buffer.putByte( (Boolean)obj == true ? (byte)1 : (byte)0 );
+
+        }
+        @Override
+        public void  unsafeSerialize(ByteBuffer buffer, Object obj) {
+            buffer.putByte( (Boolean)obj == true ? (byte)1 : (byte)0 );            
+        }
+        @Override
+        public Object deserialize(ByteBuffer buffer) {
+            return buffer.getByte() != 0;
+        }
+    }
+
+    public static class ByteType extends ValueType {
+        public ByteType() {}       
+
+        @Override
+        public int getConstantSize() {
+            return 1;
+        }        
+        @Override
+        public void serialize(ByteBuffer buffer, Object obj) {
+            buffer.needs(1);
+            buffer.putByte((Byte)obj);
+
+        }
+        @Override
+        public void  unsafeSerialize(ByteBuffer buffer, Object obj) {
+            buffer.putByte((Byte)obj);            
+        }
+        @Override
+        public Object deserialize(ByteBuffer buffer) {
+            return buffer.getByte();
+        }
+    }
+
+    public static class IntegerType extends ValueType {
+        public IntegerType() {}       
+
+        @Override
+        public int getConstantSize() {
+            return 4;
+        }        
+        @Override
+        public void serialize(ByteBuffer buffer, Object obj) {
+            buffer.needs(4);
+            buffer.putInt((Integer)obj);
+
+        }
+        @Override
+        public void  unsafeSerialize(ByteBuffer buffer, Object obj) {
+            buffer.putInt((Integer)obj);            
+        }
+        @Override
+        public Object deserialize(ByteBuffer buffer) {
+            return buffer.getInt();
+        }
+    }
+
+    public static class LongType extends ValueType {
+        public LongType() {}       
+
+        @Override
+        public int getConstantSize() {
+            return 8;
+        }        
+        @Override
+        public void serialize(ByteBuffer buffer, Object obj) {
+            buffer.needs(8);
+            buffer.putLong((Long)obj);
+
+        }
+        @Override
+        public void  unsafeSerialize(ByteBuffer buffer, Object obj) {
+            buffer.putLong((Long)obj);            
+        }
+        @Override
+        public Object deserialize(ByteBuffer buffer) {
+            return buffer.getLong();
+        }
+    }
+    
+    public static class FloatType extends ValueType {
+        public FloatType() {}       
+
+        @Override
+        public int getConstantSize() {
+            return 4;
+        }        
+        @Override
+        public void serialize(ByteBuffer buffer, Object obj) {
+            buffer.needs(4);
+            buffer.putFloat((Float)obj);
+
+        }
+        @Override
+        public void  unsafeSerialize(ByteBuffer buffer, Object obj) {
+            buffer.putFloat((Float)obj);            
+        }
+        @Override
+        public Object deserialize(ByteBuffer buffer) {
+            return buffer.getFloat();
+        }
+    }
+
+    public static class DoubleType extends ValueType {
+        public DoubleType() {}       
+
+        @Override
+        public int getConstantSize() {
+            return 8;
+        }        
+        @Override
+        public void serialize(ByteBuffer buffer, Object obj) {
+            buffer.needs(8);
+            buffer.putDouble((Double)obj);
+
+        }
+        @Override
+        public void  unsafeSerialize(ByteBuffer buffer, Object obj) {
+            buffer.putDouble((Double)obj);            
+        }
+        @Override
+        public Object deserialize(ByteBuffer buffer) {
+            return buffer.getDouble();
+        }
+        public boolean supportsNativeArray() {
+            return true;
+        }
+        public void serializeNativeArray(ByteBuffer buffer, Object obj, int length) {
+            double[] array = (double[])obj;
+            if(length < 0)
+                buffer.putInt(array.length);
+            else
+                ; // TODO check
+            for(double d : array)
+                buffer.putDouble(d);
+        }
+
+        public Object deserializeNativeArray(ByteBuffer buffer, int length) {
+            double[] ret = new double[length];
+            for(int i=0;i<length;++i)
+                ret[i] = buffer.getDouble();
+            return ret;
+        }
+    }
+
+    public static class StringType extends ValueType {
+        public StringType() {}       
+
+        @Override
+        public int getConstantSize() {
+            return -1;
+        }        
+        @Override
+        public void serialize(ByteBuffer buffer, Object obj) {
+            buffer.putString((String)obj);
+
+        }
+        @Override
+        public void  unsafeSerialize(ByteBuffer buffer, Object obj) {
+            // TODO Throw exception
+        }
+        @Override
+        public Object deserialize(ByteBuffer buffer) {
+            return buffer.getString();
+        }
+    }
+
+    public static class ProductType extends ValueType {
+        public final ValueType[] baseTypes;
+        private int constantSize;
+
+        public ProductType(ValueType[] baseTypes) {
+            this.baseTypes = baseTypes;
+            constantSize = 0;
+            for(ValueType b : baseTypes) {
+                int temp = b.getConstantSize();
+                if(temp==-1) {
+                    constantSize = -1;
+                    break;
+                }
+                constantSize += temp;
+            }
+        }
+
+        @Override
+        public int getConstantSize() {
+            return constantSize;
+        }        
+        @Override
+        public void serialize(ByteBuffer buffer, Object obj) {
+            if(constantSize >= 0) {
+                buffer.needs(constantSize);
+                unsafeSerialize(buffer, obj);
+            }
+            else {
+                Object[] subobjects = (Object[])obj;
+                // FIXME Catch cast exception
+                // FIXME Check length
+                for(int i=0;i<baseTypes.length;++i)
+                    baseTypes[i].serialize(buffer, subobjects[i]);
+            }
+        }
+        @Override
+        public void  unsafeSerialize(ByteBuffer buffer, Object obj) {
+            Object[] subobjects = (Object[])obj;
+            // FIXME Catch cast exception
+            // FIXME Check length
+            for(int i=0;i<baseTypes.length;++i)
+                baseTypes[i].unsafeSerialize(buffer, subobjects[i]);
+        }
+        @Override
+        public Object deserialize(ByteBuffer buffer) {
+            Object[] ret = new Object[baseTypes.length];
+            for(int i=0;i<baseTypes.length;++i)
+                ret[i] = baseTypes[i].deserialize(buffer);
+            return ret;
+        }
+    }
+
+    public static class Construction {
+        int constructor;
+        Object value;
+    }
+
+    public static class SumType extends ValueType {
+        public final ValueType[] baseTypes;
+        private int constantSize;
+
+        public SumType(ValueType[] baseTypes) {
+            this.baseTypes = baseTypes;
+            constantSize = -2;
+            for(ValueType b : baseTypes) {
+                int temp = b.getConstantSize();
+                if(temp != constantSize) {
+                    if(constantSize==-2 && temp >= 0)
+                        constantSize = temp;                        
+                    else {
+                        constantSize = -1;
+                        break;
+                    }
+                }
+            }
+            if(constantSize >= 0)
+                constantSize += 4;
+        }
+
+        @Override
+        public int getConstantSize() {
+            return constantSize;
+        }        
+        @Override
+        public void serialize(ByteBuffer buffer, Object obj) {
+            if(constantSize >= 0) {
+                buffer.needs(constantSize);
+                unsafeSerialize(buffer, obj);
+            }
+            else {
+                Construction construction = (Construction)obj;
+                // FIXME validate construction.constructor
+                buffer.needs(4);
+                buffer.putInt(construction.constructor);
+                baseTypes[construction.constructor].serialize(buffer, construction.value);
+            }
+        }
+        @Override
+        public void  unsafeSerialize(ByteBuffer buffer, Object obj) {
+            Construction construction = (Construction)obj;
+            // FIXME validate construction.constructor
+            buffer.putInt(construction.constructor);
+            baseTypes[construction.constructor].unsafeSerialize(buffer, construction.value);
+        }
+        @Override
+        public Object deserialize(ByteBuffer buffer) {
+            Construction ret = new Construction();
+            ret.constructor = buffer.getInt();
+            // FIXME validate construction.constructor
+            ret.value = baseTypes[ret.constructor].deserialize(buffer);
+            return ret;
+        }
+    }
+
+    public static class VariableLengthArrayType extends ValueType {
+        public final ValueType baseType;
+        private int baseTypeConstantSize;
+        private boolean supportsNativeArray;
+
+        public VariableLengthArrayType(ValueType baseType) {
+            this.baseType = baseType;
+            baseTypeConstantSize = baseType.getConstantSize();
+            supportsNativeArray = baseType.supportsNativeArray();
+        }
+
+        @Override
+        public int getConstantSize() {
+            return -1;
+        }        
+
+        @Override
+        public void serialize(ByteBuffer buffer, Object obj) {
+            if(baseTypeConstantSize >= 0) {
+                if(obj instanceof Object[]) {
+                    Object[] subobjects = (Object[])obj;              
+                    buffer.needs(4 + subobjects.length * baseTypeConstantSize);
+                    buffer.putInt(subobjects.length);
+                    for(Object subobj : subobjects)
+                        baseType.unsafeSerialize(buffer, subobj);
+                }
+                else if(supportsNativeArray) 
+                    baseType.serializeNativeArray(buffer, obj, -1);
+                else
+                    ; // TODO exc
+
+            }
+            else {
+                Object[] subobjects = (Object[])obj;              
+                buffer.needs(4);
+                buffer.putInt(subobjects.length);
+                for(Object subobj : subobjects)
+                    baseType.serialize(buffer, subobj);
+            }
+        }
+        @Override
+        public void  unsafeSerialize(ByteBuffer buffer, Object obj) {
+            // TODO Throw exception
+        }
+        @Override
+        public Object deserialize(ByteBuffer buffer) {
+            int length = buffer.getInt();
+            if(supportsNativeArray) 
+                return baseType.deserializeNativeArray(buffer, length);
+            else {
+                Object[] ret = new Object[length];
+                for(int i=0;i<length;++i)
+                    ret[i] = baseType.deserialize(buffer);
+                return ret;
+            }
+        }
+    }
+
+    public static class FixedLengthArrayType extends ValueType {
+        public final ValueType baseType;
+        public final int dimension;
+        private int constantSize;
+        private boolean supportsNativeArray;
+
+        public FixedLengthArrayType(ValueType baseType, int dimension) {
+            this.baseType = baseType;
+            this.dimension = dimension;
+            constantSize = baseType.getConstantSize();
+            if(constantSize >= 0) {
+                constantSize *= dimension;
+                supportsNativeArray = baseType.supportsNativeArray();
+            }
+        }
+
+        @Override
+        public int getConstantSize() {
+            return constantSize;
+        }        
+
+        @Override
+        public void serialize(ByteBuffer buffer, Object obj) {
+            if(constantSize >= 0) {
+                buffer.needs(constantSize);
+                unsafeSerialize(buffer, obj);
+            }
+            else {
+                Object[] subobjects = (Object[])obj;              
+                // FIXME checks
+                for(Object subobj : subobjects)
+                    baseType.serialize(buffer, subobj);
+            }
+        }
+        @Override
+        public void  unsafeSerialize(ByteBuffer buffer, Object obj) {
+            if(supportsNativeArray)
+                baseType.serializeNativeArray(buffer, obj, dimension);
+            else {
+                Object[] subobjects = (Object[])obj;              
+                // FIXME checks
+                for(Object subobj : subobjects)
+                    baseType.unsafeSerialize(buffer, subobj);
+            }
+        }
+        @Override
+        public Object deserialize(ByteBuffer buffer) {
+            if(supportsNativeArray) 
+                return baseType.deserializeNativeArray(buffer, dimension);
+            else {
+                Object[] ret = new Object[dimension];
+                for(int i=0;i<dimension;++i)
+                    ret[i] = baseType.deserialize(buffer);
+                return ret;
+            }
+        }
+    }    
+
+    static final private class ByteBuffer {
+        public byte[] bytes;
+        public int    offset;
+
+        public ByteBuffer(int capacity) {
+            this.bytes = new byte[capacity];
+            this.offset = 0;
+        }
+
+        public ByteBuffer(byte[] bytes) {
+            this.bytes = bytes;
+            this.offset = 0;
+        }
+
+        public void needs(int size) {
+            if(offset + size > bytes.length) {
+                // FIXME bytes = Arrays.copyOf(bytes, newSize);
+                byte[] newBytes = new byte[offset*2 + size];
+                for(int i=0;i<bytes.length;++i)
+                    newBytes[i] = bytes[i];
+                bytes = newBytes;
+            }
+        }
+
+        public byte[] content() {
+            if(offset == bytes.length)
+                return bytes;
+            // FIXME bytes = Arrays.copyOf(bytes, offset);
+            byte[] newBytes = new byte[offset];
+            for(int i=0;i<offset;++i)
+                newBytes[i] = bytes[i];
+            return newBytes;
+        }
+
+        public void putByte(byte v) {
+            bytes[offset] = v;
+            offset += 1;
+        }
+        public void putShort(short v) {
+            bytes[offset] = (byte) v;
+            bytes[offset+1] = (byte) (v >>> 8);
+            offset += 2;
+        }
+        public void putInt(int v) {
+            bytes[offset] = (byte) v;
+            bytes[offset+1] = (byte) (v >>> 8);
+            bytes[offset+2] = (byte) (v >>> 16);
+            bytes[offset+3] = (byte) (v >>> 24);
+            offset += 4;
+        }
+        public void putLong(long v) {
+            bytes[offset] = (byte) v;
+            bytes[offset+1] = (byte) (v >>> 8);
+            bytes[offset+2] = (byte) (v >>> 16);
+            bytes[offset+3] = (byte) (v >>> 24);
+            bytes[offset+4] = (byte) (v >>> 32);
+            bytes[offset+5] = (byte) (v >>> 40);
+            bytes[offset+6] = (byte) (v >>> 48);
+            bytes[offset+7] = (byte) (v >>> 56);
+            offset += 8;
+        }
+        public void putFloat(float _v) {
+            int v = Float.floatToIntBits(_v);
+            bytes[offset] = (byte) v;
+            bytes[offset+1] = (byte) (v >>> 8);
+            bytes[offset+2] = (byte) (v >>> 16);
+            bytes[offset+3] = (byte) (v >>> 24);
+            offset += 4;
+        }
+        public void putDouble(double _v) {
+            long v = Double.doubleToLongBits(_v);
+            bytes[offset] = (byte) v;
+            bytes[offset+1] = (byte) (v >>> 8);
+            bytes[offset+2] = (byte) (v >>> 16);
+            bytes[offset+3] = (byte) (v >>> 24);
+            bytes[offset+4] = (byte) (v >>> 32);
+            bytes[offset+5] = (byte) (v >>> 40);
+            bytes[offset+6] = (byte) (v >>> 48);
+            bytes[offset+7] = (byte) (v >>> 56);
+            offset += 8;
+        }
+        public void putString(String str) {
+
+            // UTF-16 -> modified UTF-8
+
+            int length = 4;
+            for(int i=0;i<str.length();++i) {
+                char c = str.charAt(i);
+                if(c < 0x80)
+                    length += 1;
+                else if(c < 0x800)
+                    length += 2;
+                else 
+                    length += 3;
+            }
+            needs(length);
+            putInt(str.length());
+            for(int i=0;i<str.length();++i) {
+                char c = str.charAt(i);
+                if(c < 0x80) {
+                    bytes[offset] = (byte)c;
+                    offset += 1;
+                }
+                else if(c < 0x800) {
+                    bytes[offset]   = (byte)(0xc0 + (c >>> 6));
+                    bytes[offset+1] = (byte)(0x80 + (c & 0x3f));
+                    offset += 2;
+                }
+                else {
+                    // FIXME handle range D800 - DFFF
+                    bytes[offset]   = (byte)(0xe0 + (c >>> 12));
+                    bytes[offset+1] = (byte)(0x80 + ((c >>> 6) & 0x3f));
+                    bytes[offset+2] = (byte)(0x80 + (c & 0x3f));
+                    offset += 3;
+                }
+            }
+        }
+        public byte getByte() {
+            ++offset;
+            return bytes[offset-1];
+        }
+        public short getShort() {
+            int v = bytes[offset] & 0xFF;
+            v += (bytes[offset+1] & 0xFF) << 8;
+            offset += 2;
+            return (short)v;
+        }
+        public int getInt() {
+            int v = bytes[offset] & 0xFF;
+            v += (bytes[offset+1] & 0xFF) << 8;
+            v += (bytes[offset+2] & 0xFF) << 16;
+            v += (bytes[offset+3] & 0xFF) << 24;
+            offset += 4;
+            return v;
+        }
+        public long getLong() {
+            long v = bytes[offset] & 0xFFL;
+            v += (bytes[offset+1] & 0xFFL) << 8;
+            v += (bytes[offset+2] & 0xFFL) << 16;
+            v += (bytes[offset+3] & 0xFFL) << 24;
+            v += (bytes[offset+4] & 0xFFL) << 32;
+            v += (bytes[offset+5] & 0xFFL) << 40;
+            v += (bytes[offset+6] & 0xFFL) << 48;
+            v += (bytes[offset+7] & 0xFFL) << 56;
+            offset += 8;
+            return v;
+        }
+        public float getFloat() {
+            int v = bytes[offset] & 0xFF;
+            v += (bytes[offset+1] & 0xFF) << 8;
+            v += (bytes[offset+2] & 0xFF) << 16;
+            v += (bytes[offset+3] & 0xFF) << 24;
+            offset += 4;
+            return Float.intBitsToFloat(v);
+        }
+        public double getDouble() {
+            long v = bytes[offset] & 0xFFL;
+            v += (bytes[offset+1] & 0xFFL) << 8;
+            v += (bytes[offset+2] & 0xFFL) << 16;
+            v += (bytes[offset+3] & 0xFFL) << 24;
+            v += (bytes[offset+4] & 0xFFL) << 32;
+            v += (bytes[offset+5] & 0xFFL) << 40;
+            v += (bytes[offset+6] & 0xFFL) << 48;
+            v += (bytes[offset+7] & 0xFFL) << 56;
+            offset += 8;
+            return Double.longBitsToDouble(v);
+        }
+        public String getString() {
+            int length = getInt();
+            char[] chars = new char[length];
+            for(int i=0;i<length;++i) {
+                int b0 = (int)bytes[offset];
+                int c;
+                if(b0 >= 0) {
+                    c = b0;
+                    offset += 1;
+                }
+                else if(b0 < 0xe0-256) {
+                    c = ((b0 & 0x1f) << 6) +
+                        (bytes[offset+1] & 0x3f);
+                    offset += 2;
+                }
+                else if(b0 < 0xf0-256) {
+                    c = ((b0 & 0x0f) << 12) +
+                        ((bytes[offset+1] & 0x3f) << 6) +
+                        (bytes[offset+2] & 0x3f);
+                    offset += 3;
+                }
+                else
+                    c = 0; // FIXME
+                chars[i] = (char)c;
+            }
+            return new String(chars);
+        }
+        
+    }
+    
+}