Renmae ExtendedType -> ExtensionType

msgpack · xerial · Jun 23, 2015 · Jun 10, 2015 · Jun 10, 2015 · Jun 10, 2015
commit e2fc4e68171348bc83755ed80c6d048d776c9f4d
diff --git a/README.md b/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

diff --git a/RELEASE_NOTES.md b/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)
 

diff --git a/.../org/msgpack/core/ExtendedTypeHeader.java → ...org/msgpack/core/ExtensionTypeHeader.java b/.../org/msgpack/core/ExtendedTypeHeader.java → ...org/msgpack/core/ExtensionTypeHeader.java
@@ -3,13 +3,13 @@
 import static org.msgpack.core.Preconditions.*;
 
 /**
- * Header of the extended types
+ * Header of the Extension types
  */
-public class ExtendedTypeHeader {
+public class ExtensionTypeHeader {
     private final byte type;
     private final int length;
 
-    ExtendedTypeHeader(byte type, int length) {
+    ExtensionTypeHeader(byte type, int length) {
         checkArgument(length >= 0, String.format("length must be >= 0: %,d", length));
         this.length = length;
         this.type = type;
@@ -30,16 +30,16 @@ public int hashCode() {
 
     @Override
     public boolean equals(Object obj) {
-        if(obj instanceof ExtendedTypeHeader) {
-            ExtendedTypeHeader other = (ExtendedTypeHeader) 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("ExtendedTypeHeader(type:%d, length:%,d)", type, length);
+        return String.format("ExtensionTypeHeader(type:%d, length:%,d)", type, length);
     }
 
 }
diff --git a/msgpack-core/src/main/java/org/msgpack/core/MessageFormat.java b/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),

diff --git a/msgpack-core/src/main/java/org/msgpack/core/MessagePacker.java b/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,7 +477,7 @@ public MessagePacker packValue(Value v) throws IOException {
         return this;
     }
 
-    public MessagePacker packExtendedTypeHeader(int extType, int payloadLen) throws IOException {
+    public MessagePacker packExtensionTypeHeader(int extType, int payloadLen) throws IOException {
         if(payloadLen < (1 << 8)) {
             if(payloadLen > 0 && (payloadLen & (payloadLen - 1)) == 0) { // check whether dataLen == 2^x
                 if(payloadLen == 1) {

diff --git a/msgpack-core/src/main/java/org/msgpack/core/MessageUnpacker.java b/msgpack-core/src/main/java/org/msgpack/core/MessageUnpacker.java
@@ -37,7 +37,6 @@
 import org.msgpack.value.Value;
 import org.msgpack.value.ImmutableValue;
 import org.msgpack.value.Variable;
-import org.msgpack.value.ValueType;
 import org.msgpack.value.ValueFactory;
 
 import static org.msgpack.core.Preconditions.*;
@@ -580,9 +579,9 @@ public ImmutableValue unpackValue() throws IOException {
                 }
                 return ValueFactory.newMapValue(kvs);
             }
-            case EXTENDED: {
-                ExtendedTypeHeader extHeader = unpackExtendedTypeHeader();
-                return ValueFactory.newExtendedValue(extHeader.getType(), readPayload(extHeader.getLength()));
+            case EXTENSION: {
+                ExtensionTypeHeader extHeader = unpackExtensionTypeHeader();
+                return ValueFactory.newExtensionValue(extHeader.getType(), readPayload(extHeader.getLength()));
             }
             default:
                 throw new MessageFormatException("Unknown value type");
@@ -648,9 +647,9 @@ public Variable unpackValue(Variable var) throws IOException {
                 var.setMapValue(map);
                 return var;
             }
-            case EXTENDED: {
-                ExtendedTypeHeader extHeader = unpackExtendedTypeHeader();
-                var.setExtendedValue(extHeader.getType(), readPayload(extHeader.getLength()));
+            case EXTENSION: {
+                ExtensionTypeHeader extHeader = unpackExtensionTypeHeader();
+                var.setExtensionValue(extHeader.getType(), readPayload(extHeader.getLength()));
                 return var;
             }
             default:
@@ -1042,33 +1041,33 @@ public int unpackMapHeader() throws IOException {
         throw unexpected("Map", b);
     }
 
-    public ExtendedTypeHeader unpackExtendedTypeHeader() throws IOException {
+    public ExtensionTypeHeader unpackExtensionTypeHeader() throws IOException {
         byte b = consume();
         switch(b) {
             case Code.FIXEXT1:
-                return new ExtendedTypeHeader(readByte(), 1);
+                return new ExtensionTypeHeader(readByte(), 1);
             case Code.FIXEXT2:
-                return new ExtendedTypeHeader(readByte(), 2);
+                return new ExtensionTypeHeader(readByte(), 2);
             case Code.FIXEXT4:
-                return new ExtendedTypeHeader(readByte(), 4);
+                return new ExtensionTypeHeader(readByte(), 4);
             case Code.FIXEXT8:
-                return new ExtendedTypeHeader(readByte(), 8);
+                return new ExtensionTypeHeader(readByte(), 8);
             case Code.FIXEXT16:
-                return new ExtendedTypeHeader(readByte(), 16);
+                return new ExtensionTypeHeader(readByte(), 16);
             case Code.EXT8: {
                 int length = readNextLength8();
                 byte type = readByte();
-                return new ExtendedTypeHeader(type, length);
+                return new ExtensionTypeHeader(type, length);
             }
             case Code.EXT16: {
                 int length = readNextLength16();
                 byte type = readByte();
-                return new ExtendedTypeHeader(type, length);
+                return new ExtensionTypeHeader(type, length);
             }
             case Code.EXT32: {
                 int length = readNextLength32();
                 byte type = readByte();
-                return new ExtendedTypeHeader(type, length);
+                return new ExtensionTypeHeader(type, length);
             }
         }
 

diff --git a/msgpack-core/src/main/java/org/msgpack/core/example/MessagePackExample.java b/msgpack-core/src/main/java/org/msgpack/core/example/MessagePackExample.java
@@ -16,7 +16,6 @@
 package org.msgpack.core.example;
 
 import org.msgpack.core.*;
-import org.msgpack.core.buffer.MessageBuffer;
 import org.msgpack.value.*;
 
 import java.math.BigInteger;
@@ -126,7 +125,7 @@ public static void packer() throws IOException {
 
         // Write ext type data: https://github.com/msgpack/msgpack/blob/master/spec.md#ext-format-family
         byte[] extData = "custom data type".getBytes(MessagePack.UTF8);
-        packer.packExtendedTypeHeader(1, 10);  // type number [0, 127], data byte length
+        packer.packExtensionTypeHeader(1, 10);  // type number [0, 127], data byte length
         packer.writePayload(extData);
 
         // Succinct syntax for packing
@@ -217,8 +216,8 @@ else if (iv.isInLongRange()) {
                         System.out.println("read array element: " + e);
                     }
                     break;
-                case EXTENDED:
-                    ExtendedValue ev = v.asExtendedValue();
+                case EXTENSION:
+                    ExtensionValue ev = v.asExtensionValue();
                     byte extType = ev.getType();
                     byte[] extValue = ev.getData();
                     break;

diff --git a/...java/org/msgpack/value/ExtendedValue.java → ...ava/org/msgpack/value/ExtensionValue.java b/...java/org/msgpack/value/ExtendedValue.java → ...ava/org/msgpack/value/ExtensionValue.java
@@ -16,15 +16,16 @@
 package org.msgpack.value;
 
 /**
- * The interface {@code ExtendedValue} represents MessagePack's Extended type.
+ * The interface {@code ExtensionValue} represents MessagePack's Extension type.
  *
- * MessagePack's Extended type can represent represents a tuple of type information and a byte array where type information is an integer whose meaning is defined by applications.
+ * MessagePack's Extension type can represent represents a tuple of type information and a byte array where type information is an
+ * integer whose meaning is defined by applications.
  *
  * As the type information, applications can use 0 to 127 as the application-specific types. -1 to -128 is reserved for MessagePack's future extension.
  */
-public interface ExtendedValue extends Value {
+public interface ExtensionValue extends Value {
     @Override
-    public ImmutableExtendedValue immutableValue();
+    public ImmutableExtensionValue immutableValue();
 
     public byte getType();
 

diff --git a/...msgpack/value/ImmutableExtendedValue.java → ...sgpack/value/ImmutableExtensionValue.java b/...msgpack/value/ImmutableExtendedValue.java → ...sgpack/value/ImmutableExtensionValue.java
@@ -15,5 +15,5 @@
 //
 package org.msgpack.value;
 
-public interface ImmutableExtendedValue extends ExtendedValue, ImmutableValue {
+public interface ImmutableExtensionValue extends ExtensionValue, ImmutableValue {
 }
diff --git a/msgpack-core/src/main/java/org/msgpack/value/Value.java b/msgpack-core/src/main/java/org/msgpack/value/Value.java
@@ -16,6 +16,7 @@
 package org.msgpack.value;
 
 import org.msgpack.core.MessagePacker;
+import org.msgpack.core.MessageTypeCastException;
 
 import java.io.IOException;
 
@@ -119,12 +120,13 @@ public interface Value {
     public boolean isMapValue();
 
     /**
-     * Returns true if type of this an Extended.
+     * Returns true if type of this an Extension.
      *
-     * If this method returns true, {@code asExtendedValue} never throws exceptions.
-     * Note that you can't use <code>instanceof</code> or cast <code>((ExtendedValue) thisValue)</code> to check type of a value because type of a mutable value is variable.
+     * If this method returns true, {@code asExtensionValue} never throws exceptions.
+     * Note that you can't use <code>instanceof</code> or cast <code>((ExtensionValue) thisValue)</code> to check type of a value because
+     * type of a mutable value is variable.
      */
-    public boolean isExtendedValue();
+    public boolean isExtensionValue();
 
     /**
      * Returns the value as {@code NilValue}. Otherwise throws {@code MessageTypeCastException}.
@@ -227,14 +229,15 @@ public interface Value {
     public MapValue asMapValue();
 
     /**
-     * Returns the value as {@code ExtendedValue}. Otherwise throws {@code MessageTypeCastException}.
+     * Returns the value as {@code ExtensionValue}. Otherwise throws {@code MessageTypeCastException}.
      *
-     * Note that you can't use <code>instanceof</code> or cast <code>((ExtendedValue) thisValue)</code> to check type of a value because type of a mutable value is variable.
+     * Note that you can't use <code>instanceof</code> or cast <code>((ExtensionValue) thisValue)</code> to check type of a value
+     * because type of a mutable value is variable.
      *
      * @throws  MessageTypeCastException
-     *          If type of this value is not Extended.
+     *          If type of this value is not an Extension.
      */
-    public ExtendedValue asExtendedValue();
+    public ExtensionValue asExtensionValue();
 
     /**
      * Serializes the value using the specified {@code MessagePacker}

diff --git a/msgpack-core/src/main/java/org/msgpack/value/ValueFactory.java b/msgpack-core/src/main/java/org/msgpack/value/ValueFactory.java
@@ -24,15 +24,13 @@
 import org.msgpack.value.impl.ImmutableStringValueImpl;
 import org.msgpack.value.impl.ImmutableArrayValueImpl;
 import org.msgpack.value.impl.ImmutableMapValueImpl;
-import org.msgpack.value.impl.ImmutableExtendedValueImpl;
+import org.msgpack.value.impl.ImmutableExtensionValueImpl;
 
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 import java.util.Arrays;
 import java.math.BigInteger;
-import java.io.UnsupportedEncodingException;
-import java.nio.ByteBuffer;
 
 public final class ValueFactory {
     private ValueFactory() { }
@@ -134,7 +132,7 @@ public static ImmutableMapValue newMapValue(Value[] kvs) {
         return new ImmutableMapValueImpl(Arrays.copyOf(kvs, kvs.length));
     }
 
-    public static ImmutableExtendedValue newExtendedValue(byte type, byte[] data) {
-        return new ImmutableExtendedValueImpl(type, data);
+    public static ImmutableExtensionValue newExtensionValue(byte type, byte[] data) {
+        return new ImmutableExtensionValueImpl(type, data);
     }
 }
diff --git a/msgpack-core/src/main/java/org/msgpack/value/ValueType.java b/msgpack-core/src/main/java/org/msgpack/value/ValueType.java
@@ -15,8 +15,6 @@
 //
 package org.msgpack.value;
 
-import org.msgpack.core.MessageFormat;
-
 /**
  * MessageTypeFamily is a group of {@link org.msgpack.core.MessageFormat}s
  */
@@ -30,7 +28,7 @@ public enum ValueType {
     BINARY(false, true),
     ARRAY(false, false),
     MAP(false, false),
-    EXTENDED(false, true);
+    EXTENSION(false, true);
 
     private final boolean numberType;
     private final boolean rawType;
@@ -80,7 +78,7 @@ public boolean isMapType() {
         return this == MAP;
     }
 
-    public boolean isExtendedType() {
-        return this == EXTENDED;
+    public boolean isExtensionType() {
+        return this == EXTENSION;
     }
 }