implemented Value API

msgpack · xerial · Jun 23, 2015 · Jun 10, 2015 · Jun 10, 2015 · Jun 10, 2015
commit 2242fe497b88c6add197b67ffd46a71e926ff593
diff --git a/msgpack-core/src/main/java/org/msgpack/core/ExtendedTypeHeader.java b/msgpack-core/src/main/java/org/msgpack/core/ExtendedTypeHeader.java
@@ -6,16 +6,16 @@
  * Header of the extended types
  */
 public class ExtendedTypeHeader {
+    private final byte type;
     private final int length;
-    private final int type;
 
-    ExtendedTypeHeader(int length, int type) {
+    ExtendedTypeHeader(byte type, int length) {
         checkArgument(length >= 0, String.format("length must be >= 0: %,d", length));
         this.length = length;
         this.type = type;
     }
 
-    public int getType() {
+    public byte getType() {
         return type;
     }
 

diff --git a/msgpack-core/src/main/java/org/msgpack/core/MessageFormat.java b/msgpack-core/src/main/java/org/msgpack/core/MessageFormat.java
@@ -95,7 +95,7 @@ public static MessageFormat valueOf(final byte b) {
      * @return
      */
     @VisibleForTesting
-    public static MessageFormat toMessageFormat(final byte b) {
+    static MessageFormat toMessageFormat(final byte b) {
         if (Code.isPosFixInt(b)) {
             return POSFIXINT;
         }

diff --git a/msgpack-core/src/main/java/org/msgpack/core/MessageIntegerOverflowException.java b/msgpack-core/src/main/java/org/msgpack/core/MessageIntegerOverflowException.java
@@ -24,7 +24,6 @@
  * that is larger than Integer.MAX_VALUE will cause this exception.
  */
 public class MessageIntegerOverflowException extends MessageOverflowException {
-
     private final BigInteger bigInteger;
 
     public MessageIntegerOverflowException(BigInteger bigInteger) {

diff --git a/msgpack-core/src/main/java/org/msgpack/core/MessageTypeCastException.java b/msgpack-core/src/main/java/org/msgpack/core/MessageTypeCastException.java
@@ -0,0 +1,34 @@
+//
+// MessagePack for Java
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+package org.msgpack.core;
+
+public class MessageTypeCastException extends MessageTypeException {
+    public MessageTypeCastException() {
+        super();
+    }
+
+    public MessageTypeCastException(String message) {
+        super(message);
+    }
+
+    public MessageTypeCastException(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+    public MessageTypeCastException(Throwable cause) {
+        super(cause);
+    }
+}
diff --git a/msgpack-core/src/main/java/org/msgpack/core/MessageUnpacker.java b/msgpack-core/src/main/java/org/msgpack/core/MessageUnpacker.java
@@ -30,12 +30,10 @@
 import org.msgpack.core.MessagePack.Code;
 import org.msgpack.core.buffer.MessageBuffer;
 import org.msgpack.core.buffer.MessageBufferInput;
-import org.msgpack.value.Cursor;
+import org.msgpack.value.Value;
+import org.msgpack.value.ImmutableValue;
 import org.msgpack.value.ValueType;
-import org.msgpack.value.holder.FloatHolder;
-import org.msgpack.value.holder.IntegerHolder;
-import org.msgpack.value.holder.ValueHolder;
-import org.msgpack.value.impl.CursorImpl;
+import org.msgpack.value.ValueFactory;
 
 import static org.msgpack.core.Preconditions.*;
 
@@ -79,6 +77,7 @@ public class MessageUnpacker implements Closeable {
      * Points to the current buffer to read
      */
     private MessageBuffer buffer = EMPTY_BUFFER;
+
     /**
      * Cursor position in the current buffer
      */
@@ -115,16 +114,6 @@ public class MessageUnpacker implements Closeable {
     private CharBuffer decodeBuffer;
 
 
-    /**
-     * Get a {@link org.msgpack.value.Cursor} for traversing message-packed values
-     * @return
-     */
-    public Cursor getCursor() {
-        return new CursorImpl(this);
-    }
-
-
-
     /**
      * Create an MessageUnpacker that reads data from the given MessageBufferInput
      *
@@ -531,57 +520,71 @@ public void skipValue() throws IOException {
      */
     private static MessageTypeException unexpected(String expected, byte b)
             throws MessageTypeException {
-        ValueType type = ValueType.valueOf(b);
-        return new MessageTypeException(String.format("Expected %s, but got %s (%02x)", expected, type.toTypeName(), b));
+        MessageFormat format = MessageFormat.valueOf(b);
+        String typeName;
+        if (format == MessageFormat.NEVER_USED) {
+            typeName = "NeverUsed";
+        } else {
+            String name = format.getValueType().name();
+            typeName = name.substring(0, 1) + name.substring(1).toLowerCase();
+        }
+        return new MessageTypeException(String.format("Expected %s, but got %s (%02x)", expected, typeName, b));
     }
 
-    public MessageFormat unpackValue(ValueHolder holder) throws IOException {
+    public ImmutableValue unpackValue() throws IOException {
         MessageFormat mf = getNextFormat();
         switch(mf.getValueType()) {
             case NIL:
                 unpackNil();
-                holder.setNil();
-                break;
+                return ValueFactory.newNilValue();
             case BOOLEAN:
-                holder.setBoolean(unpackBoolean());
-                break;
-            case INTEGER: {
-                unpackInteger(holder.getIntegerHolder());
-                holder.setToInteger();
-                break;
-            }
-            case FLOAT: {
-                unpackFloat(holder.getFloatHolder());
-                holder.setToFloat();
-                break;
+                return ValueFactory.newBooleanValue(unpackBoolean());
+            case INTEGER:
+                switch (mf) {
+                    case UINT64:
+                        return ValueFactory.newIntegerValue(unpackBigInteger());
+                    default:
+                        return ValueFactory.newIntegerValue(unpackLong());
+                }
+            case FLOAT:
+                return ValueFactory.newFloatValue(unpackDouble());
+            case STRING: {
+                int length = unpackRawStringHeader();
+                return ValueFactory.newRawStringValue(readPayload(length));
             }
-            case STRING:
-                int strLen = unpackRawStringHeader();
-                holder.setString(readPayloadAsReference(strLen));
-                break;
             case BINARY: {
-                int binaryLen = unpackBinaryHeader();
-                holder.setBinary(readPayloadAsReference(binaryLen));
-                break;
+                int length = unpackBinaryHeader();
+                return ValueFactory.newBinaryValue(readPayload(length));
             }
-            case ARRAY:
-                holder.prepareArrayCursor(this);
-                break;
-            case MAP:
-                holder.prepareMapCursor(this);
-                break;
-            case EXTENDED:
+            case ARRAY: {
+                int size = unpackArrayHeader();
+                Value[] array = new Value[size];
+                for (int i=0; i < size; i++) {
+                    array[i] = unpackValue();
+                }
+                return ValueFactory.newArrayValue(array);
+            }
+            case MAP: {
+                int size = unpackMapHeader();
+                Value[] kvs = new Value[size * 2];
+                for (int i=0; i < size * 2; i++) {
+                    kvs[i] = unpackValue();
+                }
+                return ValueFactory.newMapValue(kvs);
+            }
+            case EXTENDED: {
                 ExtendedTypeHeader extHeader = unpackExtendedTypeHeader();
-                holder.setExt(extHeader.getType(), readPayloadAsReference(extHeader.getLength()));
-                break;
+                return ValueFactory.newExtendedValue(extHeader.getType(), readPayload(extHeader.getLength()));
+            }
+            default:
+                throw new MessageFormatException("Unknown value type");
         }
-        return mf;
     }
 
-    public Object unpackNil() throws IOException {
+    public void unpackNil() throws IOException {
         byte b = consume();
         if(b == Code.NIL) {
-            return null;
+            return;
         }
         throw unexpected("Nil", b);
     }
@@ -832,73 +835,6 @@ public BigInteger unpackBigInteger() throws IOException {
         throw unexpected("Integer", b);
     }
 
-
-    /**
-     * Unpack an integer, then store the read value to the given holder
-     * @param holder an integer holder to which the unpacked integer will be set.
-     * @throws IOException
-     */
-    public void unpackInteger(IntegerHolder holder) throws IOException {
-        byte b = consume();
-
-        if(Code.isFixInt(b)) {
-            holder.setByte(b);
-            return;
-        }
-
-        switch(b) {
-            case Code.INT8: // signed int 8
-                holder.setByte(readByte());
-                break;
-            case Code.INT16:
-                holder.setShort(readShort());
-                break;
-            case Code.INT32:
-                holder.setInt(readInt());
-                break;
-            case Code.INT64: // signed int 64
-                holder.setLong(readLong());
-                break;
-            case Code.UINT8: // unsigned int 8
-                byte u8 = readByte();
-                if(u8 < 0) {
-                    holder.setShort((short) (u8 & 0xFF));
-                }
-                else {
-                    holder.setByte(u8);
-                }
-                break;
-            case Code.UINT16: // unsigned int 16
-                short u16 = readShort();
-                if(u16 < 0) {
-                    holder.setInt(u16 & 0xFFFF);
-                }
-                else {
-                    holder.setShort(u16);
-                }
-                break;
-            case Code.UINT32: // unsigned int 32
-                int u32 = readInt();
-                if(u32 < 0) {
-                    holder.setLong((long) (u32 & 0x7fffffff) + 0x80000000L);
-                } else {
-                    holder.setInt(u32);
-                }
-                break;
-            case Code.UINT64: // unsigned int 64
-                long u64 = readLong();
-                if(u64 < 0L) {
-                    holder.setBigInteger(BigInteger.valueOf(u64 + Long.MAX_VALUE + 1L).setBit(63));
-                } else {
-                    holder.setLong(u64);
-                }
-                break;
-            default:
-                throw unexpected("Integer", b);
-        }
-    }
-
-
     public float unpackFloat() throws IOException {
         byte b = consume();
         switch(b) {
@@ -925,26 +861,6 @@ public double unpackDouble() throws IOException {
         throw unexpected("Float", b);
     }
 
-    public void unpackFloat(ValueHolder holder) throws IOException {
-        unpackFloat(holder.getFloatHolder());
-    }
-
-    public void unpackFloat(FloatHolder holder) throws IOException {
-        byte b = consume();
-        switch(b) {
-            case Code.FLOAT32: // float
-                float fv = readFloat();
-                holder.setFloat(fv);
-                break;
-            case Code.FLOAT64: // double
-                double dv = readDouble();
-                holder.setDouble(dv);
-                break;
-            default:
-                throw unexpected("Float", b);
-        }
-    }
-
 
     private final static String EMPTY_STRING = "";
 
@@ -1053,29 +969,29 @@ public ExtendedTypeHeader unpackExtendedTypeHeader() throws IOException {
         byte b = consume();
         switch(b) {
             case Code.FIXEXT1:
-                return new ExtendedTypeHeader(1, readByte());
+                return new ExtendedTypeHeader(readByte(), 1);
             case Code.FIXEXT2:
-                return new ExtendedTypeHeader(2, readByte());
+                return new ExtendedTypeHeader(readByte(), 2);
             case Code.FIXEXT4:
-                return new ExtendedTypeHeader(4, readByte());
+                return new ExtendedTypeHeader(readByte(), 4);
             case Code.FIXEXT8:
-                return new ExtendedTypeHeader(8, readByte());
+                return new ExtendedTypeHeader(readByte(), 8);
             case Code.FIXEXT16:
-                return new ExtendedTypeHeader(16, readByte());
+                return new ExtendedTypeHeader(readByte(), 16);
             case Code.EXT8: {
-                int len = readNextLength8();
-                int t = readByte();
-                return new ExtendedTypeHeader(len, t);
+                int length = readNextLength8();
+                byte type = readByte();
+                return new ExtendedTypeHeader(type, length);
             }
             case Code.EXT16: {
-                int len = readNextLength16();
-                int t = readByte();
-                return new ExtendedTypeHeader(len, t);
+                int length = readNextLength16();
+                byte type = readByte();
+                return new ExtendedTypeHeader(type, length);
             }
             case Code.EXT32: {
-                int len = readNextLength32();
-                int t = readByte();
-                return new ExtendedTypeHeader(len, t);
+                int length = readNextLength32();
+                byte type = readByte();
+                return new ExtendedTypeHeader(type, length);
             }
         }
 
@@ -1161,6 +1077,12 @@ public void readPayload(byte[] dst) throws IOException {
         readPayload(dst, 0, dst.length);
     }
 
+    public byte[] readPayload(int length) throws IOException {
+        byte[] newArray = new byte[length];
+        readPayload(newArray);
+        return newArray;
+    }
+
     /**
      * Read up to len bytes of data into the destination array
      *