V07 value impl

README.md

@@ -5,7 +5,8 @@ MessagePack for Java
 
  * Message Pack specification: <https://github.com/msgpack/msgpack/blob/master/spec.md>
 
-MessagePack v7 (0.7.x) is a faster implementation of the previous version [v06](https://github.com/msgpack/msgpack-java/tree/v06), and supports all of the message pack types, including [extended format](https://github.com/msgpack/msgpack/blob/master/spec.md#formats-ext).
+MessagePack v7 (0.7.x) is a faster implementation of the previous version [v06](https://github.com/msgpack/msgpack-java/tree/v06), and
+supports all of the message pack types, including [extension format](https://github.com/msgpack/msgpack/blob/master/spec.md#formats-ext).
 
 ## Limitation
  - Value API is in a designing phase: https://github.com/msgpack/msgpack-java/pull/109
@@ -26,7 +27,7 @@ For sbt users:
 libraryDependencies += "org.msgpack" % "msgpack-core" % "0.7.0-p9"
 ```
 
-- [Usage examples](msgpack-core/src/main/java/org/msgpack/core/example/MessagePackExample.java)
+- [Usage examples](msgpack-core/src/test/java/org/msgpack/core/example/MessagePackExample.java)
 
 msgpack-java supports serialization and deserialization of Java objects through [jackson-databind](https://github.com/FasterXML/jackson-databind).
 For details, see [msgpack-jackson/README.md](msgpack-jackson/README.md). The template-based serialization mechanism used in v06 is deprecated.

RELEASE_NOTES.md

@@ -4,7 +4,7 @@
  * Fix [#217] when reading from SockectInputStream 
 
 * 2015-04-09 0.7.0-p8
- * Support Extended type (defined in MessagePack) in msgpack-jackson
+ * Support Extension type (defined in MessagePack) in msgpack-jackson
  * Support BigDecimal type (defined in Jackson) in msgpack-jackson
  * Fix MessageUnpacker#unpackString [#215](https://github.com/msgpack/msgpack-java/pull/215), [#216](https://github.com/msgpack/msgpack-java/pull/216)
 

msgpack-core/src/main/java/org/msgpack/core/ExtensionTypeHeader.java

@@ -0,0 +1,65 @@
+package org.msgpack.core;
+
+import static org.msgpack.core.Preconditions.*;
+
+/**
+ * Header of the Extension types
+ */
+public class ExtensionTypeHeader {
+    private final byte type;
+    private final int length;
+
+    /**
+     * Create an extension type header
+     * Example:
+     * <pre>
+     * {@code
+     * import org.msgpack.core.ExtensionTypeHeader;
+     * import static org.msgpack.core.ExtensionTypeHeader.checkedCastToByte;
+     * ...
+     * ExtensionTypeHeader header = new ExtensionTypeHeader(checkedCastToByte(0x01), 32);
+     * ...
+     * }
+     * </pre>
+     * @param type extension type (byte). You can check the valid byte range with {@link #checkedCastToByte(int)} method.
+     * @param length extension type data length
+     */
+    public ExtensionTypeHeader(byte type, int length) {
+        checkArgument(length >= 0, "length must be >= 0");
+        this.type = type;
+        this.length = length;
+    }
+
+    public static byte checkedCastToByte(int code) {
+        checkArgument(Byte.MIN_VALUE <= code && code <= Byte.MAX_VALUE, "Extension type code must be within the range of byte");
+        return (byte) code;
+    }
+
+    public byte getType() {
+        return type;
+    }
+
+    public int getLength() {
+        return length;
+    }
+
+    @Override
+    public int hashCode() {
+        return (type + 31) * 31 + length;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if(obj instanceof ExtensionTypeHeader) {
+            ExtensionTypeHeader other = (ExtensionTypeHeader) obj;
+            return this.type == other.type && this.length == other.length;
+        }
+        return false;
+    }
+
+    @Override
+    public String toString() {
+        return String.format("ExtensionTypeHeader(type:%d, length:%,d)", type, length);
+    }
+
+}

msgpack-core/src/main/java/org/msgpack/core/MessageFormat.java

@@ -24,9 +24,9 @@ public enum MessageFormat {
     BIN8(ValueType.BINARY),
     BIN16(ValueType.BINARY),
     BIN32(ValueType.BINARY),
-    EXT8(ValueType.EXTENDED),
-    EXT16(ValueType.EXTENDED),
-    EXT32(ValueType.EXTENDED),
+    EXT8(ValueType.EXTENSION),
+    EXT16(ValueType.EXTENSION),
+    EXT32(ValueType.EXTENSION),
     FLOAT32(ValueType.FLOAT),
     FLOAT64(ValueType.FLOAT),
     UINT8(ValueType.INTEGER),
@@ -38,11 +38,11 @@ public enum MessageFormat {
     INT16(ValueType.INTEGER),
     INT32(ValueType.INTEGER),
     INT64(ValueType.INTEGER),
-    FIXEXT1(ValueType.EXTENDED),
-    FIXEXT2(ValueType.EXTENDED),
-    FIXEXT4(ValueType.EXTENDED),
-    FIXEXT8(ValueType.EXTENDED),
-    FIXEXT16(ValueType.EXTENDED),
+    FIXEXT1(ValueType.EXTENSION),
+    FIXEXT2(ValueType.EXTENSION),
+    FIXEXT4(ValueType.EXTENSION),
+    FIXEXT8(ValueType.EXTENSION),
+    FIXEXT16(ValueType.EXTENSION),
     STR8(ValueType.STRING),
     STR16(ValueType.STRING),
     STR32(ValueType.STRING),
@@ -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;
         }

msgpack-core/src/main/java/org/msgpack/core/MessageIntegerOverflowException.java

@@ -23,8 +23,7 @@
  * using a smaller types. For example, calling MessageUnpacker.unpackInt() for an integer value
  * that is larger than Integer.MAX_VALUE will cause this exception.
  */
-public class MessageIntegerOverflowException extends MessageOverflowException {
-
+public class MessageIntegerOverflowException extends MessageTypeException {
     private final BigInteger bigInteger;
 
     public MessageIntegerOverflowException(BigInteger bigInteger) {

msgpack-core/src/main/java/org/msgpack/core/MessagePacker.java

@@ -379,7 +379,7 @@ public MessagePacker packString(String s) throws IOException {
         flush();
 
         prepareBuffer();
-        boolean isExtended = false;
+        boolean isExtension = false;
         ByteBuffer encodeBuffer = buffer.toByteBuffer(position, buffer.size() - position);
         encoder.reset();
         while(in.hasRemaining()) {
@@ -400,7 +400,7 @@ public MessagePacker packString(String s) throws IOException {
                     // Coy the current encodeBuffer contents to the new buffer
                     newBuffer.put(encodeBuffer);
                     encodeBuffer = newBuffer;
-                    isExtended = true;
+                    isExtension = true;
                     encoder.reset();
                     continue;
                 }
@@ -434,7 +434,7 @@ public MessagePacker packString(String s) throws IOException {
         flush(); // We need to dump the data here to MessageBufferOutput so that we can switch back to the original buffer
 
         // Reset to the original buffer (or encodeBuffer if new buffer is allocated)
-        buffer = isExtended ? MessageBuffer.wrap(encodeBuffer) : tmpBuf;
+        buffer = isExtension ? MessageBuffer.wrap(encodeBuffer) : tmpBuf;
         // No need exists to write payload since the encoded string (payload) is already written to the buffer
         position = strLen;
         return this;
@@ -477,41 +477,41 @@ public MessagePacker packValue(Value v) throws IOException {
         return this;
     }
 
-    public MessagePacker packExtendedTypeHeader(int extType, int payloadLen) throws IOException {
+    public MessagePacker packExtensionTypeHeader(byte extType, int payloadLen) throws IOException {
         if(payloadLen < (1 << 8)) {
             if(payloadLen > 0 && (payloadLen & (payloadLen - 1)) == 0) { // check whether dataLen == 2^x
                 if(payloadLen == 1) {
-                    writeByteAndByte(FIXEXT1, (byte) extType);
+                    writeByteAndByte(FIXEXT1, extType);
                 }
                 else if(payloadLen == 2) {
-                    writeByteAndByte(FIXEXT2, (byte) extType);
+                    writeByteAndByte(FIXEXT2, extType);
                 }
                 else if(payloadLen == 4) {
-                    writeByteAndByte(FIXEXT4, (byte) extType);
+                    writeByteAndByte(FIXEXT4, extType);
                 }
                 else if(payloadLen == 8) {
-                    writeByteAndByte(FIXEXT8, (byte) extType);
+                    writeByteAndByte(FIXEXT8, extType);
                 }
                 else if(payloadLen == 16) {
-                    writeByteAndByte(FIXEXT16, (byte) extType);
+                    writeByteAndByte(FIXEXT16, extType);
                 }
                 else {
                     writeByteAndByte(EXT8, (byte) payloadLen);
-                    writeByte((byte) extType);
+                    writeByte(extType);
                 }
             }
             else {
                 writeByteAndByte(EXT8, (byte) payloadLen);
-                writeByte((byte) extType);
+                writeByte(extType);
             }
         }
         else if(payloadLen < (1 << 16)) {
             writeByteAndShort(EXT16, (short) payloadLen);
-            writeByte((byte) extType);
+            writeByte(extType);
         }
         else {
             writeByteAndInt(EXT32, payloadLen);
-            writeByte((byte) extType);
+            writeByte(extType);
 
             // TODO support dataLen > 2^31 - 1
         }

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);
+    }
+}