Skip to content

Commit 910634b

Browse files
frsyukifrsyuki
committed
ValueFactory#xxxValue -> ValueFactory#createXxxValue
1 parent 367d614 commit 910634b

8 files changed

Lines changed: 167 additions & 167 deletions

File tree

‎src/main/java/org/msgpack/packer/Unconverter.java‎

Lines changed: 16 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -53,75 +53,75 @@ public void resetResult() {
5353

5454
@Override
5555
public void writeBoolean(boolean v) throws IOException {
56-
put(ValueFactory.booleanValue(v));
56+
put(ValueFactory.createBooleanValue(v));
5757
}
5858

5959
@Override
6060
public void writeByte(byte v) throws IOException {
61-
put(ValueFactory.integerValue(v));
61+
put(ValueFactory.createIntegerValue(v));
6262
}
6363

6464
@Override
6565
public void writeShort(short v) throws IOException {
66-
put(ValueFactory.integerValue(v));
66+
put(ValueFactory.createIntegerValue(v));
6767
}
6868

6969
@Override
7070
public void writeInt(int v) throws IOException {
71-
put(ValueFactory.integerValue(v));
71+
put(ValueFactory.createIntegerValue(v));
7272
}
7373

7474
@Override
7575
public void writeBigInteger(BigInteger v) throws IOException {
76-
put(ValueFactory.integerValue(v));
76+
put(ValueFactory.createIntegerValue(v));
7777
}
7878

7979
@Override
8080
public void writeLong(long v) throws IOException {
81-
put(ValueFactory.integerValue(v));
81+
put(ValueFactory.createIntegerValue(v));
8282
}
8383

8484
@Override
8585
public void writeFloat(float v) throws IOException {
86-
put(ValueFactory.floatValue(v));
86+
put(ValueFactory.createFloatValue(v));
8787
}
8888

8989
@Override
9090
public void writeDouble(double v) throws IOException {
91-
put(ValueFactory.floatValue(v));
91+
put(ValueFactory.createFloatValue(v));
9292
}
9393

9494
@Override
9595
public void writeByteArray(byte[] b, int off, int len) throws IOException {
96-
put(ValueFactory.rawValue(b, off, len));
96+
put(ValueFactory.createRawValue(b, off, len));
9797
}
9898

9999
@Override
100100
public void writeByteBuffer(ByteBuffer bb) throws IOException {
101-
put(ValueFactory.rawValue(bb));
101+
put(ValueFactory.createRawValue(bb));
102102
}
103103

104104
@Override
105105
public void writeString(String s) throws IOException {
106-
put(ValueFactory.rawValue(s));
106+
put(ValueFactory.createRawValue(s));
107107
}
108108

109109
@Override
110110
public Packer writeNil() throws IOException {
111-
put(ValueFactory.nilValue());
111+
put(ValueFactory.createNilValue());
112112
return this;
113113
}
114114

115115
@Override
116116
public Packer writeArrayBegin(int size) throws IOException {
117117
if(size == 0) {
118118
Value[] array = new Value[size];
119-
putContainer(ValueFactory.arrayValue());
119+
putContainer(ValueFactory.createArrayValue());
120120
stack.pushArray(0);
121121
values[stack.getDepth()] = null;
122122
} else {
123123
Value[] array = new Value[size];
124-
putContainer(ValueFactory.arrayValue(array, true));
124+
putContainer(ValueFactory.createArrayValue(array, true));
125125
stack.pushArray(size);
126126
values[stack.getDepth()] = array;
127127
}
@@ -154,12 +154,12 @@ public Packer writeArrayEnd(boolean check) throws IOException {
154154
public Packer writeMapBegin(int size) throws IOException {
155155
stack.checkCount();
156156
if(size == 0) {
157-
putContainer(ValueFactory.mapValue());
157+
putContainer(ValueFactory.createMapValue());
158158
stack.pushMap(0);
159159
values[stack.getDepth()] = null;
160160
} else {
161161
Value[] array = new Value[size*2];
162-
putContainer(ValueFactory.mapValue(array, true));
162+
putContainer(ValueFactory.createMapValue(array, true));
163163
stack.pushMap(size);
164164
values[stack.getDepth()] = array;
165165
}

‎src/main/java/org/msgpack/type/ValueFactory.java‎

Lines changed: 24 additions & 24 deletions
Original file line numberDiff line numberDiff line change
@@ -23,67 +23,67 @@
2323
import java.util.Map;
2424

2525
public final class ValueFactory {
26-
public static NilValue nilValue() {
26+
public static NilValue createNilValue() {
2727
return NilValue.getInstance();
2828
}
2929

30-
public static BooleanValue booleanValue(boolean v) {
30+
public static BooleanValue createBooleanValue(boolean v) {
3131
if(v) {
3232
return TrueValueImpl.getInstance();
3333
} else {
3434
return FalseValueImpl.getInstance();
3535
}
3636
}
3737

38-
public static IntegerValue integerValue(byte v) {
38+
public static IntegerValue createIntegerValue(byte v) {
3939
return new IntValueImpl((int)v);
4040
}
4141

42-
public static IntegerValue integerValue(short v) {
42+
public static IntegerValue createIntegerValue(short v) {
4343
return new IntValueImpl((int)v);
4444
}
4545

46-
public static IntegerValue integerValue(int v) {
46+
public static IntegerValue createIntegerValue(int v) {
4747
return new IntValueImpl(v);
4848
}
4949

50-
public static IntegerValue integerValue(long v) {
50+
public static IntegerValue createIntegerValue(long v) {
5151
return new LongValueImpl(v);
5252
}
5353

54-
public static IntegerValue integerValue(BigInteger v) {
54+
public static IntegerValue createIntegerValue(BigInteger v) {
5555
return new BigIntegerValueImpl(v);
5656
}
5757

58-
public static FloatValue floatValue(float v) {
58+
public static FloatValue createFloatValue(float v) {
5959
return new FloatValueImpl(v);
6060
}
6161

62-
public static FloatValue floatValue(double v) {
62+
public static FloatValue createFloatValue(double v) {
6363
return new DoubleValueImpl(v);
6464
}
6565

66-
public static RawValue rawValue() {
66+
public static RawValue createRawValue() {
6767
return ByteArrayRawValueImpl.getEmptyInstance();
6868
}
6969

70-
public static RawValue rawValue(byte[] b) {
71-
return rawValue(b, false);
70+
public static RawValue createRawValue(byte[] b) {
71+
return createRawValue(b, false);
7272
}
7373

74-
public static RawValue rawValue(byte[] b, boolean gift) {
74+
public static RawValue createRawValue(byte[] b, boolean gift) {
7575
return new ByteArrayRawValueImpl(b, gift);
7676
}
7777

78-
public static RawValue rawValue(byte[] b, int off, int len) {
78+
public static RawValue createRawValue(byte[] b, int off, int len) {
7979
return new ByteArrayRawValueImpl(b, off, len);
8080
}
8181

82-
public static RawValue rawValue(String s) {
82+
public static RawValue createRawValue(String s) {
8383
return new StringRawValueImpl(s);
8484
}
8585

86-
public static RawValue rawValue(ByteBuffer bb) {
86+
public static RawValue createRawValue(ByteBuffer bb) {
8787
int pos = bb.position();
8888
try {
8989
byte[] buf = new byte[bb.remaining()];
@@ -94,39 +94,39 @@ public static RawValue rawValue(ByteBuffer bb) {
9494
}
9595
}
9696

97-
public static ArrayValue arrayValue() {
97+
public static ArrayValue createArrayValue() {
9898
return ArrayValueImpl.getEmptyInstance();
9999
}
100100

101-
public static ArrayValue arrayValue(Value[] array) {
101+
public static ArrayValue createArrayValue(Value[] array) {
102102
if(array.length == 0) {
103103
// TODO EmptyArrayValueImpl?
104104
return ArrayValueImpl.getEmptyInstance();
105105
}
106-
return arrayValue(array, false);
106+
return createArrayValue(array, false);
107107
}
108108

109-
public static ArrayValue arrayValue(Value[] array, boolean gift) {
109+
public static ArrayValue createArrayValue(Value[] array, boolean gift) {
110110
if(array.length == 0) {
111111
// TODO EmptyArrayValueImpl?
112112
return ArrayValueImpl.getEmptyInstance();
113113
}
114114
return new ArrayValueImpl(array, gift);
115115
}
116116

117-
public static MapValue mapValue() {
117+
public static MapValue createMapValue() {
118118
return SequentialMapValueImpl.getEmptyInstance();
119119
}
120120

121-
public static MapValue mapValue(Value[] kvs) {
121+
public static MapValue createMapValue(Value[] kvs) {
122122
if(kvs.length == 0) {
123123
// TODO EmptyMapValueImpl?
124124
return SequentialMapValueImpl.getEmptyInstance();
125125
}
126-
return mapValue(kvs, false);
126+
return createMapValue(kvs, false);
127127
}
128128

129-
public static MapValue mapValue(Value[] kvs, boolean gift) {
129+
public static MapValue createMapValue(Value[] kvs, boolean gift) {
130130
if(kvs.length == 0) {
131131
// TODO EmptyMapValueImpl?
132132
return SequentialMapValueImpl.getEmptyInstance();

‎src/main/java/org/msgpack/unpacker/ValueAccept.java‎

Lines changed: 17 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -33,75 +33,75 @@ void setUnconverter(Unconverter uc) throws IOException {
3333

3434
@Override
3535
void acceptBoolean(boolean v) throws IOException {
36-
uc.write(ValueFactory.booleanValue(v));
36+
uc.write(ValueFactory.createBooleanValue(v));
3737
}
3838

3939
@Override
4040
void acceptInteger(byte v) throws IOException {
41-
uc.write(ValueFactory.integerValue(v));
41+
uc.write(ValueFactory.createIntegerValue(v));
4242
}
4343

4444
@Override
4545
void acceptInteger(short v) throws IOException {
46-
uc.write(ValueFactory.integerValue(v));
46+
uc.write(ValueFactory.createIntegerValue(v));
4747
}
4848

4949
@Override
5050
void acceptInteger(int v) throws IOException {
51-
uc.write(ValueFactory.integerValue(v));
51+
uc.write(ValueFactory.createIntegerValue(v));
5252
}
5353

5454
@Override
5555
void acceptInteger(long v) throws IOException {
56-
uc.write(ValueFactory.integerValue(v));
56+
uc.write(ValueFactory.createIntegerValue(v));
5757
}
5858

5959
@Override
6060
void acceptUnsignedInteger(byte v) throws IOException {
61-
uc.write(ValueFactory.integerValue(v & 0xff));
61+
uc.write(ValueFactory.createIntegerValue(v & 0xff));
6262
}
6363

6464
@Override
6565
void acceptUnsignedInteger(short v) throws IOException {
66-
uc.write(ValueFactory.integerValue(v & 0xffff));
66+
uc.write(ValueFactory.createIntegerValue(v & 0xffff));
6767
}
6868

6969
@Override
7070
void acceptUnsignedInteger(int v) throws IOException {
7171
if(v < 0) {
7272
long value = (long)(v & 0x7fffffff) + 0x80000000L;
73-
uc.write(ValueFactory.integerValue(value));
73+
uc.write(ValueFactory.createIntegerValue(value));
7474
} else {
75-
uc.write(ValueFactory.integerValue(v));
75+
uc.write(ValueFactory.createIntegerValue(v));
7676
}
7777
}
7878

7979
@Override
8080
void acceptUnsignedInteger(long v) throws IOException {
8181
if(v < 0L) {
8282
BigInteger value = BigInteger.valueOf(v+Long.MAX_VALUE+1L).setBit(63);
83-
uc.write(ValueFactory.integerValue(value));
83+
uc.write(ValueFactory.createIntegerValue(value));
8484
} else {
85-
uc.write(ValueFactory.integerValue(v));
85+
uc.write(ValueFactory.createIntegerValue(v));
8686
}
8787
}
8888

8989
@Override
9090
void acceptRaw(byte[] raw) throws IOException {
91-
uc.write(ValueFactory.rawValue(raw));
91+
uc.write(ValueFactory.createRawValue(raw));
9292
}
9393

9494
@Override
9595
void acceptEmptyRaw() throws IOException {
96-
uc.write(ValueFactory.rawValue());
96+
uc.write(ValueFactory.createRawValue());
9797
}
9898

9999
@Override
100100
public void refer(ByteBuffer bb, boolean gift) throws IOException {
101101
// TODO gift
102102
byte[] raw = new byte[bb.remaining()];
103103
bb.get(raw);
104-
uc.write(ValueFactory.rawValue(raw, true));
104+
uc.write(ValueFactory.createRawValue(raw, true));
105105
}
106106

107107
@Override
@@ -116,17 +116,17 @@ void acceptMap(int size) throws IOException {
116116

117117
@Override
118118
void acceptNil() throws IOException {
119-
uc.write(ValueFactory.nilValue());
119+
uc.write(ValueFactory.createNilValue());
120120
}
121121

122122
@Override
123123
void acceptFloat(float v) throws IOException {
124-
uc.write(ValueFactory.floatValue(v));
124+
uc.write(ValueFactory.createFloatValue(v));
125125
}
126126

127127
@Override
128128
void acceptDouble(double v) throws IOException {
129-
uc.write(ValueFactory.floatValue(v));
129+
uc.write(ValueFactory.createFloatValue(v));
130130
}
131131
}
132132

‎src/main/java/org/msgpack/util/json/JSONUnpacker.java‎

Lines changed: 8 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -71,21 +71,21 @@ protected Value nextValue() throws IOException {
7171

7272
private Value objectToValue(Object obj) {
7373
if(obj instanceof String) {
74-
return ValueFactory.rawValue((String)obj);
74+
return ValueFactory.createRawValue((String)obj);
7575
} else if(obj instanceof Integer) {
76-
return ValueFactory.integerValue((Integer)obj);
76+
return ValueFactory.createIntegerValue((Integer)obj);
7777
} else if(obj instanceof Long) {
78-
return ValueFactory.integerValue((Long)obj);
78+
return ValueFactory.createIntegerValue((Long)obj);
7979
} else if(obj instanceof Map) {
8080
return mapToValue((Map)obj);
8181
} else if(obj instanceof List) {
8282
return listToValue((List)obj);
8383
} else if(obj instanceof Boolean) {
84-
return ValueFactory.booleanValue((Boolean)obj);
84+
return ValueFactory.createBooleanValue((Boolean)obj);
8585
} else if(obj instanceof Double) {
86-
return ValueFactory.floatValue((Double)obj);
86+
return ValueFactory.createFloatValue((Double)obj);
8787
} else {
88-
return ValueFactory.nilValue();
88+
return ValueFactory.createNilValue();
8989
}
9090
}
9191

@@ -94,7 +94,7 @@ private Value listToValue(List list) {
9494
for(int i=0; i < array.length; i++) {
9595
array[i] = objectToValue(list.get(i));
9696
}
97-
return ValueFactory.arrayValue(array, true);
97+
return ValueFactory.createArrayValue(array, true);
9898
}
9999

100100
private Value mapToValue(Map map) {
@@ -105,7 +105,7 @@ private Value mapToValue(Map map) {
105105
kvs[i] = objectToValue(pair.getKey());
106106
kvs[i+1] = objectToValue(pair.getValue());
107107
}
108-
return ValueFactory.mapValue(kvs, true);
108+
return ValueFactory.createMapValue(kvs, true);
109109
}
110110

111111
public void close() throws IOException {

0 commit comments

Comments
 (0)