toXXX -> castAsXXX

xerial · xerial · commit 5c51b39d00ae · 2015-06-23T14:40:25.000+09:00
diff --git a/msgpack-core/src/main/java/org/msgpack/value/NumberValue.java b/msgpack-core/src/main/java/org/msgpack/value/NumberValue.java
@@ -18,45 +18,47 @@
 import java.math.BigInteger;
 
 /**
- * The interface {@code NumberValue} is the interface of {@code IntegerValue} and {@code FloatValue}.
+ * The base interface {@code NumberValue} of {@code IntegerValue} and {@code FloatValue}.
  *
  * @see org.msgpack.value.IntegerValue
  * @see org.msgpack.value.FloatValue
  */
 public interface NumberValue extends Value {
 
     /**
-     * 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.
+     * Represent this value as a byte value, which may involve rounding or truncation of the original value.
+     * the value.
      */
-    byte toByte();
+    byte castAsByte();
 
     /**
-     * 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.
+     * Represent this value as a short value, which may involve rounding or truncation of the original value.
      */
-    short toShort();
+    short castAsShort();
 
     /**
-     * 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.
+     * Represent this value as an int value, which may involve rounding or truncation of the original value.
+     * value.
      */
-    int toInt();
+    int castAsInt();
 
     /**
-     * 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.
+     * Represent this value as a long value, which may involve rounding or truncation of the original value.
      */
-    long toLong();
+    long castAsLong();
 
     /**
-     * Convert this value into a BigInteger. If value is Float type, it will round the value
+     * Represent this value as a BigInteger, which may involve rounding or truncation of the original value.
      */
-    BigInteger toBigInteger();
+    BigInteger castAsBigInteger();
 
     /**
-     * Converts this value into a 32-bit float
+     * Represent this value as a 32-bit float value, which may involve rounding or truncation of the original value.
      */
-    float toFloat();
+    float castAsFloat();
 
     /**
-     * Converts this value into a 64-bit double
+     * Represent this value as a 64-bit double value, which may involve rounding or truncation of the original value.
      */
-    double toDouble();
+    double castAsDouble();
 }
diff --git a/msgpack-core/src/main/java/org/msgpack/value/Variable.java b/msgpack-core/src/main/java/org/msgpack/value/Variable.java
@@ -303,39 +303,39 @@ public NumberValue asNumberValue() {
         }
 
         @Override
-        public byte toByte() {
+        public byte castAsByte() {
             if (type == Type.BIG_INTEGER) {
                 return ((BigInteger) objectValue).byteValue();
             }
             return (byte) longValue;
         }
 
         @Override
-        public short toShort() {
+        public short castAsShort() {
             if (type == Type.BIG_INTEGER) {
                 return ((BigInteger) objectValue).shortValue();
             }
             return (short) longValue;
         }
 
         @Override
-        public int toInt() {
+        public int castAsInt() {
             if (type == Type.BIG_INTEGER) {
                 return ((BigInteger) objectValue).intValue();
             }
             return (int) longValue;
         }
 
         @Override
-        public long toLong() {
+        public long castAsLong() {
             if (type == Type.BIG_INTEGER) {
                 return ((BigInteger) objectValue).longValue();
             }
             return (long) longValue;
         }
 
         @Override
-        public BigInteger toBigInteger() {
+        public BigInteger castAsBigInteger() {
             if (type == Type.BIG_INTEGER) {
                 return (BigInteger) objectValue;
             }
@@ -346,7 +346,7 @@ else if (type == Type.DOUBLE) {
         }
 
         @Override
-        public float toFloat() {
+        public float castAsFloat() {
             if (type == Type.BIG_INTEGER) {
                 return ((BigInteger) objectValue).floatValue();
             }
@@ -357,7 +357,7 @@ else if (type == Type.DOUBLE) {
         }
 
         @Override
-        public double toDouble() {
+        public double castAsDouble() {
             if (type == Type.BIG_INTEGER) {
                 return ((BigInteger) objectValue).doubleValue();
             }
@@ -504,14 +504,14 @@ public Variable setFloatValue(double v) {
         this.type = Type.DOUBLE;
         this.accessor = floatAccessor;
         this.doubleValue = v;
-        this.longValue = (long) v;  // AbstractNumberValueAccessor uses toLong
+        this.longValue = (long) v;  // AbstractNumberValueAccessor uses castAsLong
         return this;
     }
 
     public Variable setFloatValue(float v) {
         this.type = Type.DOUBLE;
         this.accessor = floatAccessor;
-        this.longValue = (long) v;  // AbstractNumberValueAccessor uses toLong
+        this.longValue = (long) v;  // AbstractNumberValueAccessor uses castAsLong
         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 toByte() {
+    public byte castAsByte() {
         return value.byteValue();
     }
 
     @Override
-    public short toShort() {
+    public short castAsShort() {
         return value.shortValue();
     }
 
     @Override
-    public int toInt() {
+    public int castAsInt() {
         return value.intValue();
     }
 
     @Override
-    public long toLong() {
+    public long castAsLong() {
         return value.longValue();
     }
 
     @Override
-    public BigInteger toBigInteger() {
+    public BigInteger castAsBigInteger() {
         return value;
     }
 
     @Override
-    public float toFloat() {
+    public float castAsFloat() {
         return value.floatValue();
     }
 
     @Override
-    public double toDouble() {
+    public double castAsDouble() {
         return value.doubleValue();
     }
 
@@ -175,7 +175,7 @@ public boolean equals(Object o) {
             return false;
         }
         IntegerValue iv = v.asIntegerValue();
-        return value.equals(iv.toBigInteger());
+        return value.equals(iv.castAsBigInteger());
     }
 
     @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
@@ -48,37 +48,37 @@ public ImmutableDoubleValueImpl immutableValue() {
     }
 
     @Override
-    public byte toByte() {
+    public byte castAsByte() {
         return (byte) value;
     }
 
     @Override
-    public short toShort() {
+    public short castAsShort() {
         return (short) value;
     }
 
     @Override
-    public int toInt() {
+    public int castAsInt() {
         return (int) value;
     }
 
     @Override
-    public long toLong() {
+    public long castAsLong() {
         return (long) value;
     }
 
     @Override
-    public BigInteger toBigInteger() {
+    public BigInteger castAsBigInteger() {
         return new BigDecimal(value).toBigInteger();
     }
 
     @Override
-    public float toFloat() {
+    public float castAsFloat() {
         return (float) value;
     }
 
     @Override
-    public double toDouble() {
+    public double castAsDouble() {
         return value;
     }
 
@@ -100,7 +100,7 @@ public boolean equals(Object o) {
         if(!v.isFloatValue()) {
             return false;
         }
-        return value == v.asFloatValue().toDouble();
+        return value == v.asFloatValue().castAsDouble();
     }
 
     @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 toByte() {
+    public byte castAsByte() {
         return (byte) value;
     }
 
     @Override
-    public short toShort() {
+    public short castAsShort() {
         return (short) value;
     }
 
     @Override
-    public int toInt() {
+    public int castAsInt() {
         return (int) value;
     }
 
     @Override
-    public long toLong() {
+    public long castAsLong() {
         return value;
     }
 
     @Override
-    public BigInteger toBigInteger() {
+    public BigInteger castAsBigInteger() {
         return BigInteger.valueOf(value);
     }
 
     @Override
-    public float toFloat() {
+    public float castAsFloat() {
         return (float) value;
     }
 
     @Override
-    public double toDouble() {
+    public double castAsDouble() {
         return (double) value;
     }
 
@@ -173,7 +173,7 @@ public boolean equals(Object o) {
         if (!iv.isInLongRange()) {
             return false;
         }
-        return value == iv.toLong();
+        return value == iv.castAsLong();
     }
 
     @Override
diff --git a/msgpack-core/src/test/java/org/msgpack/core/example/MessagePackExample.java b/msgpack-core/src/test/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.toInt();
+                        int i = iv.castAsInt();
                         System.out.println("read int: " + i);
                     }
                     else if (iv.isInLongRange()) {
-                        long l = iv.toLong();
+                        long l = iv.castAsLong();
                         System.out.println("read long: " + l);
                     }
                     else {
-                        BigInteger i = iv.toBigInteger();
+                        BigInteger i = iv.castAsBigInteger();
                         System.out.println("read long: " + i);
                     }
                     break;
                 case FLOAT:
                     FloatValue fv = v.asFloatValue();
-                    float f = fv.toFloat();   // use as float
-                    double d = fv.toDouble(); // use as double
+                    float f = fv.castAsFloat();   // use as float
+                    double d = fv.castAsDouble(); // use as double
                     System.out.println("read float: " + d);
                     break;
                 case STRING:
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
`@@ -303,39 +303,39 @@ public NumberValue asNumberValue() {`
`303`	`303`	`}`
`304`	`304`
`305`	`305`	`@Override`
`306`		`- public byte toByte() {`
	`306`	`+ public byte castAsByte() {`
`307`	`307`	`if (type == Type.BIG_INTEGER) {`
`308`	`308`	`return ((BigInteger) objectValue).byteValue();`
`309`	`309`	`}`
`310`	`310`	`return (byte) longValue;`
`311`	`311`	`}`
`312`	`312`
`313`	`313`	`@Override`
`314`		`- public short toShort() {`
	`314`	`+ public short castAsShort() {`
`315`	`315`	`if (type == Type.BIG_INTEGER) {`
`316`	`316`	`return ((BigInteger) objectValue).shortValue();`
`317`	`317`	`}`
`318`	`318`	`return (short) longValue;`
`319`	`319`	`}`
`320`	`320`
`321`	`321`	`@Override`
`322`		`- public int toInt() {`
	`322`	`+ public int castAsInt() {`
`323`	`323`	`if (type == Type.BIG_INTEGER) {`
`324`	`324`	`return ((BigInteger) objectValue).intValue();`
`325`	`325`	`}`
`326`	`326`	`return (int) longValue;`
`327`	`327`	`}`
`328`	`328`
`329`	`329`	`@Override`
`330`		`- public long toLong() {`
	`330`	`+ public long castAsLong() {`
`331`	`331`	`if (type == Type.BIG_INTEGER) {`
`332`	`332`	`return ((BigInteger) objectValue).longValue();`
`333`	`333`	`}`
`334`	`334`	`return (long) longValue;`
`335`	`335`	`}`
`336`	`336`
`337`	`337`	`@Override`
`338`		`- public BigInteger toBigInteger() {`
	`338`	`+ public BigInteger castAsBigInteger() {`
`339`	`339`	`if (type == Type.BIG_INTEGER) {`
`340`	`340`	`return (BigInteger) objectValue;`
`341`	`341`	`}`
`@@ -346,7 +346,7 @@ else if (type == Type.DOUBLE) {`
`346`	`346`	`}`
`347`	`347`
`348`	`348`	`@Override`
`349`		`- public float toFloat() {`
	`349`	`+ public float castAsFloat() {`
`350`	`350`	`if (type == Type.BIG_INTEGER) {`
`351`	`351`	`return ((BigInteger) objectValue).floatValue();`
`352`	`352`	`}`
`@@ -357,7 +357,7 @@ else if (type == Type.DOUBLE) {`
`357`	`357`	`}`
`358`	`358`
`359`	`359`	`@Override`
`360`		`- public double toDouble() {`
	`360`	`+ public double castAsDouble() {`
`361`	`361`	`if (type == Type.BIG_INTEGER) {`
`362`	`362`	`return ((BigInteger) objectValue).doubleValue();`
`363`	`363`	`}`
`@@ -504,14 +504,14 @@ public Variable setFloatValue(double v) {`
`504`	`504`	`this.type = Type.DOUBLE;`
`505`	`505`	`this.accessor = floatAccessor;`
`506`	`506`	`this.doubleValue = v;`
`507`		`- this.longValue = (long) v; // AbstractNumberValueAccessor uses toLong`
	`507`	`+ this.longValue = (long) v; // AbstractNumberValueAccessor uses castAsLong`
`508`	`508`	`return this;`
`509`	`509`	`}`
`510`	`510`
`511`	`511`	`public Variable setFloatValue(float v) {`
`512`	`512`	`this.type = Type.DOUBLE;`
`513`	`513`	`this.accessor = floatAccessor;`
`514`		`- this.longValue = (long) v; // AbstractNumberValueAccessor uses toLong`
	`514`	`+ this.longValue = (long) v; // AbstractNumberValueAccessor uses castAsLong`
`515`	`515`	`return this;`
`516`	`516`	`}`
`517`	`517`
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 toByte() {`
	`68`	`+ public byte castAsByte() {`
`69`	`69`	`return value.byteValue();`
`70`	`70`	`}`
`71`	`71`
`72`	`72`	`@Override`
`73`		`- public short toShort() {`
	`73`	`+ public short castAsShort() {`
`74`	`74`	`return value.shortValue();`
`75`	`75`	`}`
`76`	`76`
`77`	`77`	`@Override`
`78`		`- public int toInt() {`
	`78`	`+ public int castAsInt() {`
`79`	`79`	`return value.intValue();`
`80`	`80`	`}`
`81`	`81`
`82`	`82`	`@Override`
`83`		`- public long toLong() {`
	`83`	`+ public long castAsLong() {`
`84`	`84`	`return value.longValue();`
`85`	`85`	`}`
`86`	`86`
`87`	`87`	`@Override`
`88`		`- public BigInteger toBigInteger() {`
	`88`	`+ public BigInteger castAsBigInteger() {`
`89`	`89`	`return value;`
`90`	`90`	`}`
`91`	`91`
`92`	`92`	`@Override`
`93`		`- public float toFloat() {`
	`93`	`+ public float castAsFloat() {`
`94`	`94`	`return value.floatValue();`
`95`	`95`	`}`
`96`	`96`
`97`	`97`	`@Override`
`98`		`- public double toDouble() {`
	`98`	`+ public double castAsDouble() {`
`99`	`99`	`return value.doubleValue();`
`100`	`100`	`}`
`101`	`101`
`@@ -175,7 +175,7 @@ public boolean equals(Object o) {`
`175`	`175`	`return false;`
`176`	`176`	`}`
`177`	`177`	`IntegerValue iv = v.asIntegerValue();`
`178`		`- return value.equals(iv.toBigInteger());`
	`178`	`+ return value.equals(iv.castAsBigInteger());`
`179`	`179`	`}`
`180`	`180`
`181`	`181`	`@Override`
Original file line number	Diff line number	Diff line change
`@@ -48,37 +48,37 @@ public ImmutableDoubleValueImpl immutableValue() {`
`48`	`48`	`}`
`49`	`49`
`50`	`50`	`@Override`
`51`		`- public byte toByte() {`
	`51`	`+ public byte castAsByte() {`
`52`	`52`	`return (byte) value;`
`53`	`53`	`}`
`54`	`54`
`55`	`55`	`@Override`
`56`		`- public short toShort() {`
	`56`	`+ public short castAsShort() {`
`57`	`57`	`return (short) value;`
`58`	`58`	`}`
`59`	`59`
`60`	`60`	`@Override`
`61`		`- public int toInt() {`
	`61`	`+ public int castAsInt() {`
`62`	`62`	`return (int) value;`
`63`	`63`	`}`
`64`	`64`
`65`	`65`	`@Override`
`66`		`- public long toLong() {`
	`66`	`+ public long castAsLong() {`
`67`	`67`	`return (long) value;`
`68`	`68`	`}`
`69`	`69`
`70`	`70`	`@Override`
`71`		`- public BigInteger toBigInteger() {`
	`71`	`+ public BigInteger castAsBigInteger() {`
`72`	`72`	`return new BigDecimal(value).toBigInteger();`
`73`	`73`	`}`
`74`	`74`
`75`	`75`	`@Override`
`76`		`- public float toFloat() {`
	`76`	`+ public float castAsFloat() {`
`77`	`77`	`return (float) value;`
`78`	`78`	`}`
`79`	`79`
`80`	`80`	`@Override`
`81`		`- public double toDouble() {`
	`81`	`+ public double castAsDouble() {`
`82`	`82`	`return value;`
`83`	`83`	`}`
`84`	`84`
`@@ -100,7 +100,7 @@ public boolean equals(Object o) {`
`100`	`100`	`if(!v.isFloatValue()) {`
`101`	`101`	`return false;`
`102`	`102`	`}`
`103`		`- return value == v.asFloatValue().toDouble();`
	`103`	`+ return value == v.asFloatValue().castAsDouble();`
`104`	`104`	`}`
`105`	`105`
`106`	`106`	`@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 toByte() {`
	`66`	`+ public byte castAsByte() {`
`67`	`67`	`return (byte) value;`
`68`	`68`	`}`
`69`	`69`
`70`	`70`	`@Override`
`71`		`- public short toShort() {`
	`71`	`+ public short castAsShort() {`
`72`	`72`	`return (short) value;`
`73`	`73`	`}`
`74`	`74`
`75`	`75`	`@Override`
`76`		`- public int toInt() {`
	`76`	`+ public int castAsInt() {`
`77`	`77`	`return (int) value;`
`78`	`78`	`}`
`79`	`79`
`80`	`80`	`@Override`
`81`		`- public long toLong() {`
	`81`	`+ public long castAsLong() {`
`82`	`82`	`return value;`
`83`	`83`	`}`
`84`	`84`
`85`	`85`	`@Override`
`86`		`- public BigInteger toBigInteger() {`
	`86`	`+ public BigInteger castAsBigInteger() {`
`87`	`87`	`return BigInteger.valueOf(value);`
`88`	`88`	`}`
`89`	`89`
`90`	`90`	`@Override`
`91`		`- public float toFloat() {`
	`91`	`+ public float castAsFloat() {`
`92`	`92`	`return (float) value;`
`93`	`93`	`}`
`94`	`94`
`95`	`95`	`@Override`
`96`		`- public double toDouble() {`
	`96`	`+ public double castAsDouble() {`
`97`	`97`	`return (double) value;`
`98`	`98`	`}`
`99`	`99`
`@@ -173,7 +173,7 @@ public boolean equals(Object o) {`
`173`	`173`	`if (!iv.isInLongRange()) {`
`174`	`174`	`return false;`
`175`	`175`	`}`
`176`		`- return value == iv.toLong();`
	`176`	`+ return value == iv.castAsLong();`
`177`	`177`	`}`
`178`	`178`
`179`	`179`	`@Override`