4
4
import java .util .ArrayList ;
5
5
import java .util .HashMap ;
6
6
import java .util .List ;
7
-
8
7
import redis .clients .jedis .Protocol ;
9
8
import redis .clients .jedis .commands .ProtocolCommand ;
10
9
import redis .clients .jedis .util .SafeEncoder ;
11
10
12
- public enum DataType implements ProtocolCommand {
13
-
11
+ public enum DataType implements ProtocolCommand {
14
12
INT32 {
15
13
@ Override
16
- public List <byte []> toByteArray (Object obj ){
17
- int [] values = (int [])obj ;
14
+ public List <byte []> toByteArray (Object obj ) {
15
+ int [] values = (int []) obj ;
18
16
List <byte []> res = new ArrayList <>(values .length );
19
- for (int value : values ) {
17
+ for (int value : values ) {
20
18
res .add (Protocol .toByteArray (value ));
21
19
}
22
20
return res ;
23
21
}
24
22
25
23
@ Override
26
24
protected Object toObject (List <byte []> data ) {
27
- int [] values = new int [data .size ()];
25
+ int [] values = new int [data .size ()];
28
26
for (int i = 0 ; i < data .size (); i ++) {
29
27
values [i ] = Integer .parseInt (SafeEncoder .encode (data .get (i )));
30
28
}
31
29
return values ;
32
30
}
33
- },
31
+ },
34
32
INT64 {
35
33
@ Override
36
- public List <byte []> toByteArray (Object obj ){
37
- long [] values = (long [])obj ;
34
+ public List <byte []> toByteArray (Object obj ) {
35
+ long [] values = (long []) obj ;
38
36
List <byte []> res = new ArrayList <>(values .length );
39
- for (long value : values ) {
37
+ for (long value : values ) {
40
38
res .add (Protocol .toByteArray (value ));
41
39
}
42
40
return res ;
43
41
}
44
42
45
43
@ Override
46
44
protected Object toObject (List <byte []> data ) {
47
- long [] values = new long [data .size ()];
45
+ long [] values = new long [data .size ()];
48
46
for (int i = 0 ; i < data .size (); i ++) {
49
47
values [i ] = Long .parseLong (SafeEncoder .encode (data .get (i )));
50
48
}
51
49
return values ;
52
50
}
53
- },
51
+ },
54
52
FLOAT {
55
53
@ Override
56
- public List <byte []> toByteArray (Object obj ){
57
- float [] values = (float [])obj ;
54
+ public List <byte []> toByteArray (Object obj ) {
55
+ float [] values = (float []) obj ;
58
56
List <byte []> res = new ArrayList <>(values .length );
59
- for (float value : values ) {
57
+ for (float value : values ) {
60
58
res .add (Protocol .toByteArray (value ));
61
59
}
62
60
return res ;
63
61
}
64
62
65
63
@ Override
66
64
protected Object toObject (List <byte []> data ) {
67
- float [] values = new float [data .size ()];
65
+ float [] values = new float [data .size ()];
68
66
for (int i = 0 ; i < data .size (); i ++) {
69
67
values [i ] = Float .parseFloat (SafeEncoder .encode (data .get (i )));
70
68
}
71
69
return values ;
72
70
}
73
- },
71
+ },
74
72
DOUBLE {
75
73
@ Override
76
- public List <byte []> toByteArray (Object obj ){
77
- double [] values = (double [])obj ;
74
+ public List <byte []> toByteArray (Object obj ) {
75
+ double [] values = (double []) obj ;
78
76
List <byte []> res = new ArrayList <>(values .length );
79
- for (double value : values ) {
77
+ for (double value : values ) {
80
78
res .add (Protocol .toByteArray (value ));
81
79
}
82
80
return res ;
83
81
}
84
82
85
83
@ Override
86
84
protected Object toObject (List <byte []> data ) {
87
- double [] values = new double [data .size ()];
85
+ double [] values = new double [data .size ()];
88
86
for (int i = 0 ; i < data .size (); i ++) {
89
87
values [i ] = Double .parseDouble (SafeEncoder .encode (data .get (i )));
90
88
}
91
89
return values ;
92
90
}
93
- },
91
+ },
94
92
STRING {
95
93
@ Override
96
- public List <byte []> toByteArray (Object obj ){
97
- byte [] values = (byte [])obj ;
94
+ public List <byte []> toByteArray (Object obj ) {
95
+ byte [] values = (byte []) obj ;
98
96
List <byte []> res = new ArrayList <>(values .length );
99
- for (byte value : values ) {
97
+ for (byte value : values ) {
100
98
res .add (Protocol .toByteArray (value ));
101
99
}
102
100
return res ;
@@ -106,13 +104,13 @@ public List<byte[]> toByteArray(Object obj){
106
104
protected Object toObject (List <byte []> data ) {
107
105
return data ;
108
106
}
109
- },
107
+ },
110
108
BOOL {
111
109
@ Override
112
- public List <byte []> toByteArray (Object obj ){
113
- boolean [] values = (boolean [])obj ;
110
+ public List <byte []> toByteArray (Object obj ) {
111
+ boolean [] values = (boolean []) obj ;
114
112
List <byte []> res = new ArrayList <>(values .length );
115
- for (boolean value : values ) {
113
+ for (boolean value : values ) {
116
114
res .add (Protocol .toByteArray (value ));
117
115
}
118
116
return res ;
@@ -128,6 +126,7 @@ protected Object toObject(List<byte[]> data) {
128
126
private final byte [] raw ;
129
127
130
128
private static final HashMap <Class <?>, DataType > classDataTypes = new HashMap <>();
129
+
131
130
static {
132
131
classDataTypes .put (int .class , DataType .INT32 );
133
132
classDataTypes .put (Integer .class , DataType .INT32 );
@@ -149,29 +148,30 @@ protected Object toObject(List<byte[]> data) {
149
148
150
149
static DataType getDataTypefromString (String dtypeRaw ) {
151
150
DataType dt = null ;
152
- if (dtypeRaw .equals (DataType .INT32 .name ())){
153
- dt = DataType .INT32 ;
151
+ if (dtypeRaw .equals (DataType .INT32 .name ())) {
152
+ dt = DataType .INT32 ;
154
153
}
155
- if (dtypeRaw .equals (DataType .INT64 .name ())){
156
- dt = DataType .INT64 ;
154
+ if (dtypeRaw .equals (DataType .INT64 .name ())) {
155
+ dt = DataType .INT64 ;
157
156
}
158
- if (dtypeRaw .equals (DataType .FLOAT .name ())){
159
- dt = DataType .FLOAT ;
157
+ if (dtypeRaw .equals (DataType .FLOAT .name ())) {
158
+ dt = DataType .FLOAT ;
160
159
}
161
- if (dtypeRaw .equals (DataType .DOUBLE .name ())){
162
- dt = DataType .DOUBLE ;
160
+ if (dtypeRaw .equals (DataType .DOUBLE .name ())) {
161
+ dt = DataType .DOUBLE ;
163
162
}
164
163
return dt ;
165
164
}
166
165
167
166
protected abstract List <byte []> toByteArray (Object obj );
167
+
168
168
protected abstract Object toObject (List <byte []> data );
169
169
170
170
public byte [] getRaw () {
171
171
return raw ;
172
172
}
173
173
174
- public List <byte []> toByteArray (Object obj , int [] dimensions ){
174
+ public List <byte []> toByteArray (Object obj , int [] dimensions ) {
175
175
return toByteArray (obj , dimensions , 0 , this );
176
176
}
177
177
@@ -185,14 +185,14 @@ public static DataType baseObjType(Object o) {
185
185
if (ret != null ) {
186
186
return ret ;
187
187
}
188
- throw new IllegalArgumentException ("cannot create Tensors of type " + c .getName ());
188
+ throw new IllegalArgumentException ("cannot create Tensors of type " + c .getName ());
189
189
}
190
-
190
+
191
191
private static List <byte []> toByteArray (Object obj , int [] dimensions , int dim , DataType type ) {
192
192
ArrayList <byte []> res = new ArrayList <>();
193
- if (dimensions .length > dim + 1 ) {
193
+ if (dimensions .length > dim + 1 ) {
194
194
int dimension = dimensions [dim ++];
195
- for (int i = 0 ; i < dimension ; ++i ) {
195
+ for (int i = 0 ; i < dimension ; ++i ) {
196
196
Object value = Array .get (obj , i );
197
197
res .addAll (toByteArray (value , dimensions , dim , type ));
198
198
}
@@ -202,5 +202,3 @@ private static List<byte[]> toByteArray(Object obj, int[] dimensions, int dim, D
202
202
return res ;
203
203
}
204
204
}
205
-
206
-
0 commit comments