Renamed xxxValue that returns primitive type value as toXXX

xerial · xerial · commit 775379d06f92 · 2015-06-13T23:49:42.000+09:00
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
@@ -184,22 +184,22 @@ public static void readAndWriteFile() throws IOException {
                 case INTEGER:
                     IntegerValue iv = v.asIntegerValue();
                     if(iv.isInIntRange()) {
-                        int i = iv.intValue();
+                        int i = iv.toInt();
                         System.out.println("read int: " + i);
                     }
                     else if (iv.isInLongRange()) {
-                        long l = iv.longValue();
+                        long l = iv.toLong();
                         System.out.println("read long: " + l);
                     }
                     else {
-                        BigInteger i = iv.bigIntegerValue();
+                        BigInteger i = iv.toBigInteger();
                         System.out.println("read long: " + i);
                     }
                     break;
                 case FLOAT:
                     FloatValue fv = v.asFloatValue();
-                    float f = fv.floatValue();   // use as float
-                    double d = fv.doubleValue(); // use as double
+                    float f = fv.toFloat();   // use as float
+                    double d = fv.toDouble(); // use as double
                     System.out.println("read float: " + d);
                     break;
                 case STRING:
diff --git a/msgpack-core/src/main/java/org/msgpack/value/NumberValue.java b/msgpack-core/src/main/java/org/msgpack/value/NumberValue.java
@@ -20,47 +20,43 @@
 /**
  * The interface {@code NumberValue} is the interface of {@code IntegerValue} and {@code FloatValue}.
  *
- * @see  org.msgpack.value.IntegerValue
- * @see  org.msgpack.value.FloatValue
+ * @see org.msgpack.value.IntegerValue
+ * @see org.msgpack.value.FloatValue
  */
 public interface NumberValue extends Value {
-    @Override
-    public ImmutableNumberValue toImmutable();
 
     /**
-     * Returns the value as a {@code byte}, which may involve rounding or truncation.
+     * Convert this value into a byte value. If this value is not within the range of Byte value, it will truncate or round the value.
      */
-    public byte byteValue();
+    byte toByte();
 
     /**
-     * Returns the value as a {@code short}, which may involve rounding or truncation.
+     * Convert this value into a short value. If this value is not within the range of Short value, it will truncate or round the value.
      */
-    public short shortValue();
+    short toShort();
 
     /**
-     * Returns the value as an {@code int}, which may involve rounding or truncation.
+     * Convert this value into an int value. If this value is not within the range of Int value, it will truncate or round the value.
      */
-    public int intValue();
+    int toInt();
 
     /**
-     * Returns the value as a {@code long}, which may involve rounding or truncation.
+     * Convert this value into a long value. If this value is not within the range of Long value, it will truncate or round the value.
      */
-    public long longValue();
+    long toLong();
 
     /**
-     * Returns the value as a {@code BigInteger}, which may involve rounding or truncation.
-     *
-     * Rounding could happen if type of this value is float or double.
+     * Convert this value into a BigInteger. If value is Float type, it will round the value
      */
-    public BigInteger bigIntegerValue();
+    BigInteger toBigInteger();
 
     /**
-     * Returns the value as a {@code float}, which may involve rounding or truncation.
+     * Converts this value into a 32-bit float
      */
-    public float floatValue();
+    float toFloat();
 
     /**
-     * Returns the value as a {@code double}, which may involve rounding or truncation.
+     * Converts this value into a 64-bit double
      */
-    public double doubleValue();
+    double toDouble();
 }
diff --git a/msgpack-core/src/main/java/org/msgpack/value/Value.java b/msgpack-core/src/main/java/org/msgpack/value/Value.java
@@ -30,7 +30,7 @@ public interface Value {
      * <p/>
      * Note that you can't use <code>instanceof</code> to check type of a value because type of a mutable value is variable.
      */
-    public ValueType getValueType();
+    ValueType getValueType();
 
     /**
      * Returns immutable copy of this value.
diff --git a/msgpack-core/src/main/java/org/msgpack/value/Variable.java b/msgpack-core/src/main/java/org/msgpack/value/Variable.java
@@ -313,39 +313,39 @@ public NumberValue asNumberValue() {
         }
 
         @Override
-        public byte byteValue() {
+        public byte toByte() {
             if (type == Type.BIG_INTEGER) {
                 return ((BigInteger) objectValue).byteValue();
             }
             return (byte) longValue;
         }
 
         @Override
-        public short shortValue() {
+        public short toShort() {
             if (type == Type.BIG_INTEGER) {
                 return ((BigInteger) objectValue).shortValue();
             }
             return (short) longValue;
         }
 
         @Override
-        public int intValue() {
+        public int toInt() {
             if (type == Type.BIG_INTEGER) {
                 return ((BigInteger) objectValue).intValue();
             }
             return (int) longValue;
         }
 
         @Override
-        public long longValue() {
+        public long toLong() {
             if (type == Type.BIG_INTEGER) {
                 return ((BigInteger) objectValue).longValue();
             }
             return (long) longValue;
         }
 
         @Override
-        public BigInteger bigIntegerValue() {
+        public BigInteger toBigInteger() {
             if (type == Type.BIG_INTEGER) {
                 return (BigInteger) objectValue;
             }
@@ -356,7 +356,7 @@ else if (type == Type.DOUBLE) {
         }
 
         @Override
-        public float floatValue() {
+        public float toFloat() {
             if (type == Type.BIG_INTEGER) {
                 return ((BigInteger) objectValue).floatValue();
             }
@@ -367,7 +367,7 @@ else if (type == Type.DOUBLE) {
         }
 
         @Override
-        public double doubleValue() {
+        public double toDouble() {
             if (type == Type.BIG_INTEGER) {
                 return ((BigInteger) objectValue).doubleValue();
             }
@@ -517,14 +517,14 @@ public Variable setFloatValue(double v) {
         this.type = Type.DOUBLE;
         this.accessor = floatAccessor;
         this.doubleValue = v;
-        this.longValue = (long) v;  // AbstractNumberValueAccessor uses longValue
+        this.longValue = (long) v;  // AbstractNumberValueAccessor uses toLong
         return this;
     }
 
     public Variable setFloatValue(float v) {
         this.type = Type.DOUBLE;
         this.accessor = floatAccessor;
-        this.longValue = (long) v;  // AbstractNumberValueAccessor uses longValue
+        this.longValue = (long) v;  // AbstractNumberValueAccessor uses toLong
         return this;
     }
 
diff --git a/msgpack-core/src/main/java/org/msgpack/value/impl/ImmutableBigIntegerValueImpl.java b/msgpack-core/src/main/java/org/msgpack/value/impl/ImmutableBigIntegerValueImpl.java
@@ -65,37 +65,37 @@ public ImmutableIntegerValue asIntegerValue() {
     }
 
     @Override
-    public byte byteValue() {
+    public byte toByte() {
         return value.byteValue();
     }
 
     @Override
-    public short shortValue() {
+    public short toShort() {
         return value.shortValue();
     }
 
     @Override
-    public int intValue() {
+    public int toInt() {
         return value.intValue();
     }
 
     @Override
-    public long longValue() {
+    public long toLong() {
         return value.longValue();
     }
 
     @Override
-    public BigInteger bigIntegerValue() {
+    public BigInteger toBigInteger() {
         return value;
     }
 
     @Override
-    public float floatValue() {
+    public float toFloat() {
         return value.floatValue();
     }
 
     @Override
-    public double doubleValue() {
+    public double toDouble() {
         return value.doubleValue();
     }
 
@@ -180,7 +180,7 @@ public boolean equals(Object o) {
             return false;
         }
         IntegerValue iv = v.asIntegerValue();
-        return value.equals(iv.bigIntegerValue());
+        return value.equals(iv.toBigInteger());
     }
 
     @Override
diff --git a/msgpack-core/src/main/java/org/msgpack/value/impl/ImmutableDoubleValueImpl.java b/msgpack-core/src/main/java/org/msgpack/value/impl/ImmutableDoubleValueImpl.java
@@ -46,37 +46,37 @@ public ImmutableDoubleValueImpl toImmutable() {
     }
 
     @Override
-    public byte byteValue() {
+    public byte toByte() {
         return (byte) value;
     }
 
     @Override
-    public short shortValue() {
+    public short toShort() {
         return (short) value;
     }
 
     @Override
-    public int intValue() {
+    public int toInt() {
         return (int) value;
     }
 
     @Override
-    public long longValue() {
+    public long toLong() {
         return (long) value;
     }
 
     @Override
-    public BigInteger bigIntegerValue() {
+    public BigInteger toBigInteger() {
         return new BigDecimal(value).toBigInteger();
     }
 
     @Override
-    public float floatValue() {
+    public float toFloat() {
         return (float) value;
     }
 
     @Override
-    public double doubleValue() {
+    public double toDouble() {
         return value;
     }
 
@@ -103,7 +103,7 @@ public boolean equals(Object o) {
         if (!v.isFloatValue()) {
             return false;
         }
-        return value == v.asFloatValue().doubleValue();
+        return value == v.asFloatValue().toDouble();
     }
 
     @Override
diff --git a/msgpack-core/src/main/java/org/msgpack/value/impl/ImmutableLongValueImpl.java b/msgpack-core/src/main/java/org/msgpack/value/impl/ImmutableLongValueImpl.java
@@ -63,37 +63,37 @@ public ImmutableIntegerValue asIntegerValue() {
     }
 
     @Override
-    public byte byteValue() {
+    public byte toByte() {
         return (byte) value;
     }
 
     @Override
-    public short shortValue() {
+    public short toShort() {
         return (short) value;
     }
 
     @Override
-    public int intValue() {
+    public int toInt() {
         return (int) value;
     }
 
     @Override
-    public long longValue() {
+    public long toLong() {
         return value;
     }
 
     @Override
-    public BigInteger bigIntegerValue() {
+    public BigInteger toBigInteger() {
         return BigInteger.valueOf(value);
     }
 
     @Override
-    public float floatValue() {
+    public float toFloat() {
         return (float) value;
     }
 
     @Override
-    public double doubleValue() {
+    public double toDouble() {
         return (double) value;
     }
 
@@ -178,7 +178,7 @@ public boolean equals(Object o) {
         if (!iv.isInLongRange()) {
             return false;
         }
-        return value == iv.longValue();
+        return value == iv.toLong();
     }
 
     @Override
diff --git a/msgpack-jackson/src/main/java/org/msgpack/jackson/dataformat/MessagePackParser.java b/msgpack-jackson/src/main/java/org/msgpack/jackson/dataformat/MessagePackParser.java

Original file line number	Diff line number	Diff line change
`@@ -313,39 +313,39 @@ public NumberValue asNumberValue() {`
`313`	`313`	`}`
`314`	`314`
`315`	`315`	`@Override`
`316`		`- public byte byteValue() {`
	`316`	`+ public byte toByte() {`
`317`	`317`	`if (type == Type.BIG_INTEGER) {`
`318`	`318`	`return ((BigInteger) objectValue).byteValue();`
`319`	`319`	`}`
`320`	`320`	`return (byte) longValue;`
`321`	`321`	`}`
`322`	`322`
`323`	`323`	`@Override`
`324`		`- public short shortValue() {`
	`324`	`+ public short toShort() {`
`325`	`325`	`if (type == Type.BIG_INTEGER) {`
`326`	`326`	`return ((BigInteger) objectValue).shortValue();`
`327`	`327`	`}`
`328`	`328`	`return (short) longValue;`
`329`	`329`	`}`
`330`	`330`
`331`	`331`	`@Override`
`332`		`- public int intValue() {`
	`332`	`+ public int toInt() {`
`333`	`333`	`if (type == Type.BIG_INTEGER) {`
`334`	`334`	`return ((BigInteger) objectValue).intValue();`
`335`	`335`	`}`
`336`	`336`	`return (int) longValue;`
`337`	`337`	`}`
`338`	`338`
`339`	`339`	`@Override`
`340`		`- public long longValue() {`
	`340`	`+ public long toLong() {`
`341`	`341`	`if (type == Type.BIG_INTEGER) {`
`342`	`342`	`return ((BigInteger) objectValue).longValue();`
`343`	`343`	`}`
`344`	`344`	`return (long) longValue;`
`345`	`345`	`}`
`346`	`346`
`347`	`347`	`@Override`
`348`		`- public BigInteger bigIntegerValue() {`
	`348`	`+ public BigInteger toBigInteger() {`
`349`	`349`	`if (type == Type.BIG_INTEGER) {`
`350`	`350`	`return (BigInteger) objectValue;`
`351`	`351`	`}`
`@@ -356,7 +356,7 @@ else if (type == Type.DOUBLE) {`
`356`	`356`	`}`
`357`	`357`
`358`	`358`	`@Override`
`359`		`- public float floatValue() {`
	`359`	`+ public float toFloat() {`
`360`	`360`	`if (type == Type.BIG_INTEGER) {`
`361`	`361`	`return ((BigInteger) objectValue).floatValue();`
`362`	`362`	`}`
`@@ -367,7 +367,7 @@ else if (type == Type.DOUBLE) {`
`367`	`367`	`}`
`368`	`368`
`369`	`369`	`@Override`
`370`		`- public double doubleValue() {`
	`370`	`+ public double toDouble() {`
`371`	`371`	`if (type == Type.BIG_INTEGER) {`
`372`	`372`	`return ((BigInteger) objectValue).doubleValue();`
`373`	`373`	`}`
`@@ -517,14 +517,14 @@ public Variable setFloatValue(double v) {`
`517`	`517`	`this.type = Type.DOUBLE;`
`518`	`518`	`this.accessor = floatAccessor;`
`519`	`519`	`this.doubleValue = v;`
`520`		`- this.longValue = (long) v; // AbstractNumberValueAccessor uses longValue`
	`520`	`+ this.longValue = (long) v; // AbstractNumberValueAccessor uses toLong`
`521`	`521`	`return this;`
`522`	`522`	`}`
`523`	`523`
`524`	`524`	`public Variable setFloatValue(float v) {`
`525`	`525`	`this.type = Type.DOUBLE;`
`526`	`526`	`this.accessor = floatAccessor;`
`527`		`- this.longValue = (long) v; // AbstractNumberValueAccessor uses longValue`
	`527`	`+ this.longValue = (long) v; // AbstractNumberValueAccessor uses toLong`
`528`	`528`	`return this;`
`529`	`529`	`}`
`530`	`530`
Original file line number	Diff line number	Diff line change
`@@ -65,37 +65,37 @@ public ImmutableIntegerValue asIntegerValue() {`
`65`	`65`	`}`
`66`	`66`
`67`	`67`	`@Override`
`68`		`- public byte byteValue() {`
	`68`	`+ public byte toByte() {`
`69`	`69`	`return value.byteValue();`
`70`	`70`	`}`
`71`	`71`
`72`	`72`	`@Override`
`73`		`- public short shortValue() {`
	`73`	`+ public short toShort() {`
`74`	`74`	`return value.shortValue();`
`75`	`75`	`}`
`76`	`76`
`77`	`77`	`@Override`
`78`		`- public int intValue() {`
	`78`	`+ public int toInt() {`
`79`	`79`	`return value.intValue();`
`80`	`80`	`}`
`81`	`81`
`82`	`82`	`@Override`
`83`		`- public long longValue() {`
	`83`	`+ public long toLong() {`
`84`	`84`	`return value.longValue();`
`85`	`85`	`}`
`86`	`86`
`87`	`87`	`@Override`
`88`		`- public BigInteger bigIntegerValue() {`
	`88`	`+ public BigInteger toBigInteger() {`
`89`	`89`	`return value;`
`90`	`90`	`}`
`91`	`91`
`92`	`92`	`@Override`
`93`		`- public float floatValue() {`
	`93`	`+ public float toFloat() {`
`94`	`94`	`return value.floatValue();`
`95`	`95`	`}`
`96`	`96`
`97`	`97`	`@Override`
`98`		`- public double doubleValue() {`
	`98`	`+ public double toDouble() {`
`99`	`99`	`return value.doubleValue();`
`100`	`100`	`}`
`101`	`101`
`@@ -180,7 +180,7 @@ public boolean equals(Object o) {`
`180`	`180`	`return false;`
`181`	`181`	`}`
`182`	`182`	`IntegerValue iv = v.asIntegerValue();`
`183`		`- return value.equals(iv.bigIntegerValue());`
	`183`	`+ return value.equals(iv.toBigInteger());`
`184`	`184`	`}`
`185`	`185`
`186`	`186`	`@Override`
Original file line number	Diff line number	Diff line change
`@@ -46,37 +46,37 @@ public ImmutableDoubleValueImpl toImmutable() {`
`46`	`46`	`}`
`47`	`47`
`48`	`48`	`@Override`
`49`		`- public byte byteValue() {`
	`49`	`+ public byte toByte() {`
`50`	`50`	`return (byte) value;`
`51`	`51`	`}`
`52`	`52`
`53`	`53`	`@Override`
`54`		`- public short shortValue() {`
	`54`	`+ public short toShort() {`
`55`	`55`	`return (short) value;`
`56`	`56`	`}`
`57`	`57`
`58`	`58`	`@Override`
`59`		`- public int intValue() {`
	`59`	`+ public int toInt() {`
`60`	`60`	`return (int) value;`
`61`	`61`	`}`
`62`	`62`
`63`	`63`	`@Override`
`64`		`- public long longValue() {`
	`64`	`+ public long toLong() {`
`65`	`65`	`return (long) value;`
`66`	`66`	`}`
`67`	`67`
`68`	`68`	`@Override`
`69`		`- public BigInteger bigIntegerValue() {`
	`69`	`+ public BigInteger toBigInteger() {`
`70`	`70`	`return new BigDecimal(value).toBigInteger();`
`71`	`71`	`}`
`72`	`72`
`73`	`73`	`@Override`
`74`		`- public float floatValue() {`
	`74`	`+ public float toFloat() {`
`75`	`75`	`return (float) value;`
`76`	`76`	`}`
`77`	`77`
`78`	`78`	`@Override`
`79`		`- public double doubleValue() {`
	`79`	`+ public double toDouble() {`
`80`	`80`	`return value;`
`81`	`81`	`}`
`82`	`82`
`@@ -103,7 +103,7 @@ public boolean equals(Object o) {`
`103`	`103`	`if (!v.isFloatValue()) {`
`104`	`104`	`return false;`
`105`	`105`	`}`
`106`		`- return value == v.asFloatValue().doubleValue();`
	`106`	`+ return value == v.asFloatValue().toDouble();`
`107`	`107`	`}`
`108`	`108`
`109`	`109`	`@Override`
Original file line number	Diff line number	Diff line change
`@@ -63,37 +63,37 @@ public ImmutableIntegerValue asIntegerValue() {`
`63`	`63`	`}`
`64`	`64`
`65`	`65`	`@Override`
`66`		`- public byte byteValue() {`
	`66`	`+ public byte toByte() {`
`67`	`67`	`return (byte) value;`
`68`	`68`	`}`
`69`	`69`
`70`	`70`	`@Override`
`71`		`- public short shortValue() {`
	`71`	`+ public short toShort() {`
`72`	`72`	`return (short) value;`
`73`	`73`	`}`
`74`	`74`
`75`	`75`	`@Override`
`76`		`- public int intValue() {`
	`76`	`+ public int toInt() {`
`77`	`77`	`return (int) value;`
`78`	`78`	`}`
`79`	`79`
`80`	`80`	`@Override`
`81`		`- public long longValue() {`
	`81`	`+ public long toLong() {`
`82`	`82`	`return value;`
`83`	`83`	`}`
`84`	`84`
`85`	`85`	`@Override`
`86`		`- public BigInteger bigIntegerValue() {`
	`86`	`+ public BigInteger toBigInteger() {`
`87`	`87`	`return BigInteger.valueOf(value);`
`88`	`88`	`}`
`89`	`89`
`90`	`90`	`@Override`
`91`		`- public float floatValue() {`
	`91`	`+ public float toFloat() {`
`92`	`92`	`return (float) value;`
`93`	`93`	`}`
`94`	`94`
`95`	`95`	`@Override`
`96`		`- public double doubleValue() {`
	`96`	`+ public double toDouble() {`
`97`	`97`	`return (double) value;`
`98`	`98`	`}`
`99`	`99`
`@@ -178,7 +178,7 @@ public boolean equals(Object o) {`
`178`	`178`	`if (!iv.isInLongRange()) {`
`179`	`179`	`return false;`
`180`	`180`	`}`
`181`		`- return value == iv.longValue();`
	`181`	`+ return value == iv.toLong();`
`182`	`182`	`}`
`183`	`183`
`184`	`184`	`@Override`