1 package org.djutils.serialization;
2
3 /**
4 * Type numbers to encode different data types within djutils-serialization.
5 * <p>
6 * Copyright (c) 2016-2017 Delft University of Technology, PO Box 5, 2600 AA, Delft, the Netherlands. All rights reserved. <br>
7 * BSD-style license. See <a href="https://sim0mq.org/docs/current/license.html">Sim0MQ License</a>.
8 * </p>
9 * @author <a href="https://www.tudelft.nl/averbraeck">Alexander Verbraeck</a>
10 */
11 public final class FieldTypes
12 {
13
14 /** byte, 8 bit signed two's complement integer. */
15 public static final byte BYTE_8 = 0;
16
17 /** short, 16 bit signed two's complement integer. */
18 public static final byte SHORT_16 = 1;
19
20 /** int, 32 bit signed two's complement integer. */
21 public static final byte INT_32 = 2;
22
23 /** long, 64 bit signed two's complement integer. */
24 public static final byte LONG_64 = 3;
25
26 /** float, single-precision 32-bit IEEE 754 floating point. */
27 public static final byte FLOAT_32 = 4;
28
29 /** float, double-precision 64-bit IEEE 754 floating point. */
30 public static final byte DOUBLE_64 = 5;
31
32 /** boolean, sent / received as a byte; 0 = false, 1 = true. */
33 public static final byte BOOLEAN_8 = 6;
34
35 /** char, 8-bit ASCII character. */
36 public static final byte CHAR_8 = 7;
37
38 /** char, 16-bit Unicode character, big endian order. */
39 public static final byte CHAR_16 = 8;
40
41 /**
42 * String, number-preceded byte array of 8-bits characters. The string types are preceded by a 32-bit int indicating the
43 * number of characters in the array that follows. This int is itself not preceded by a byte indicating it is an int. An
44 * ASCII string "Hello" is therefore coded as follows: |9|0|0|0|5|H|e|l|l|o|
45 */
46 public static final byte STRING_8 = 9;
47
48 /**
49 * String, number-preceded char array of 16-bits characters, big-endian order. The string types are preceded by a 32-bit int
50 * indicating the number of characters in the array that follows. This int is itself not preceded by a byte indicating it is
51 * an int.
52 */
53 public static final byte STRING_16 = 10;
54
55 /**
56 * Number-preceded byte array. The array types are preceded by a 32-bit int indicating the number of values in the array
57 * that follows. This int is itself not preceded by a byte indicating it is an int. An array of 8 bytes with numbers 1
58 * through 8 is therefore coded as follows: |11|0|0|0|8|1|2|3|4|5|6|7|8|
59 */
60 public static final byte BYTE_8_ARRAY = 11;
61
62 /**
63 * Number-preceded short array. The array types are preceded by a 32-bit int indicating the number of values in the array
64 * that follows. This int is itself not preceded by a byte indicating it is an int. An array of 8 shorts with numbers 100
65 * through 107 is therefore coded as follows: |12|0|0|0|8|0|100|0|101|0|102|0|103|0|104|0|105|0|106|0|107|
66 */
67 public static final byte SHORT_16_ARRAY = 12;
68
69 /**
70 * Number-preceded int array. The array types are preceded by a 32-bit int indicating the number of values in the array that
71 * follows. This int is itself not preceded by a byte indicating it is an int. An array of 4 ints with numbers 100 through
72 * 103 is therefore coded as follows: |13|0|0|0|4|0|0|0|100|0|0|0|101|0|0|0|102|0|0|0|103|
73 */
74 public static final byte INT_32_ARRAY = 13;
75
76 /**
77 * Number-preceded long array. The array types are preceded by a 32-bit int indicating the number of values in the array
78 * that follows. This int is itself not preceded by a byte indicating it is an int. An array of 3 longs with numbers 100
79 * through 102 is therefore coded as follows: |14|0|0|0|3|0|0|0|0|0|0|0|100|0|0|0|0|0|0|0|101|0|0|0|0|0|0|0|102|
80 */
81 public static final byte LONG_64_ARRAY = 14;
82
83 /**
84 * Number-preceded float array. The array types are preceded by a 32-bit int indicating the number of values in the array
85 * that follows. This int is itself not preceded by a byte indicating it is an int.
86 */
87 public static final byte FLOAT_32_ARRAY = 15;
88
89 /**
90 * Number-preceded double array. The array types are preceded by a 32-bit int indicating the number of values in the array
91 * that follows. This int is itself not preceded by a byte indicating it is an int.
92 */
93 public static final byte DOUBLE_64_ARRAY = 16;
94
95 /**
96 * Number-preceded boolean array. The array types are preceded by a 32-bit int indicating the number of values in the array
97 * that follows. This int is itself not preceded by a byte indicating it is an int.
98 */
99 public static final byte BOOLEAN_8_ARRAY = 17;
100
101 /**
102 * Number of rows and number of columns preceded byte matrix. The matrix types are preceded by a 32-bit int indicating the
103 * number of rows, followed by a 32-bit int indicating the number of columns. These integers are not preceded by a byte
104 * indicating it is an int. The number of values in the matrix that follows is rows * columns. The data is stored row by
105 * row, without a separator between the rows. A matrix with 2 rows and 3 columns of bytes 1-2-4 6-7-8 is therefore coded as
106 * follows: |18|0|0|0|2|0|0|0|3|0|1|0|2|0|4|0|6|0|7|0|8|<br>
107 * In the language sending or receiving a matrix, the rows are denoted by the outer index, and the columns by the inner
108 * index: matrix[row][col].
109 */
110 public static final byte BYTE_8_MATRIX = 18;
111
112 /**
113 * Number of rows and number of columns preceded short matrix. The matrix types are preceded by a 32-bit int indicating the
114 * number of rows, followed by a 32-bit int indicating the number of columns. These integers are not preceded by a byte
115 * indicating it is an int. The number of values in the matrix that follows is rows * columns. The data is stored row by
116 * row, without a separator between the rows. A matrix with 2 rows and 3 columns of shorts 1-2-4 6-7-8 is therefore coded as
117 * follows: |19|0|0|0|2|0|0|0|3|1|2|4|6|7|8|<br>
118 * In the language sending or receiving a matrix, the rows are denoted by the outer index, and the columns by the inner
119 * index: matrix[row][col].
120 */
121 public static final byte SHORT_16_MATRIX = 19;
122
123 /**
124 * Number of rows and number of columns preceded int matrix. The matrix types are preceded by a 32-bit int indicating the
125 * number of rows, followed by a 32-bit int indicating the number of columns. These integers are not preceded by a byte
126 * indicating it is an int. The number of values in the matrix that follows is rows * columns. The data is stored row by
127 * row, without a separator between the rows. A matrix with 2 rows and 3 columns of integers 1-2-4 6-7-8 is therefore coded
128 * as follows: |20|0|0|0|2|0|0|0|3|0|0|0|1|0|0|0|2|0|0|0|4|0|0|0|6|0|0|0|7|0|0|0|8|<br>
129 * In the language sending or receiving a matrix, the rows are denoted by the outer index, and the columns by the inner
130 * index: matrix[row][col].
131 */
132 public static final byte INT_32_MATRIX = 20;
133
134 /**
135 * Number of rows and number of columns preceded long matrix. The matrix types are preceded by a 32-bit int indicating the
136 * number of rows, followed by a 32-bit int indicating the number of columns. These integers are not preceded by a byte
137 * indicating it is an int. The number of values in the matrix that follows is rows * columns. The data is stored row by
138 * row, without a separator between the rows. A matrix with 2 rows and 3 columns of long vales 1-2-4 6-7-8 is therefore
139 * coded as follows:
140 * |21|0|0|0|2|0|0|0|3|0|0|0|0|0|0|0|1|0|0|0|0|0|0|0|2|0|0|0|0|0|0|0|4|0|0|0|0|0|0|0|6|0|0|0|0|0|0|0|7|0|0|0|0|0|0|0|8|<br>
141 * In the language sending or receiving a matrix, the rows are denoted by the outer index, and the columns by the inner
142 * index: matrix[row][col].
143 */
144 public static final byte LONG_64_MATRIX = 21;
145
146 /**
147 * Number of rows and number of columns preceded float matrix. The matrix types are preceded by a 32-bit int indicating the
148 * number of rows, followed by a 32-bit int indicating the number of columns. These integers are not preceded by a byte
149 * indicating it is an int. The number of values in the matrix that follows is rows * columns. The data is stored row by
150 * row, without a separator between the rows.<br>
151 * In the language sending or receiving a matrix, the rows are denoted by the outer index, and the columns by the inner
152 * index: matrix[row][col].
153 */
154 public static final byte FLOAT_32_MATRIX = 22;
155
156 /**
157 * Number of rows and number of columns preceded double matrix. The matrix types are preceded by a 32-bit int indicating the
158 * number of rows, followed by a 32-bit int indicating the number of columns. These integers are not preceded by a byte
159 * indicating it is an int. The number of values in the matrix that follows is rows * columns. The data is stored row by
160 * row, without a separator between the rows.<br>
161 * In the language sending or receiving a matrix, the rows are denoted by the outer index, and the columns by the inner
162 * index: matrix[row][col].
163 */
164 public static final byte DOUBLE_64_MATRIX = 23;
165
166 /**
167 * Number of rows and number of columns preceded boolean matrix. The matrix types are preceded by a 32-bit int indicating
168 * the number of rows, followed by a 32-bit int indicating the number of columns. These integers are not preceded by a byte
169 * indicating it is an int. The number of values in the matrix that follows is rows * columns. The data is stored row by
170 * row, without a separator between the rows.<br>
171 * In the language sending or receiving a matrix, the rows are denoted by the outer index, and the columns by the inner
172 * index: matrix[row][col].
173 */
174 public static final byte BOOLEAN_8_MATRIX = 24;
175
176 /**
177 * Float, stored internally in the SI unit, with a unit type and display type attached. The internal storage of the value
178 * that is transmitted is always in the SI (or standard) unit, except for money where the display unit is used. The value is
179 * preceded by a one-byte unit type, and a one-byte display type (or two-byte in case of the MoneyPerUnit). As an example:
180 * suppose the unit indicates that the type is a length, whereas the display type indicates that the internally stored value
181 * 60000.0 should be displayed as 60.0 km, this is coded as follows: |25|16|11|0x47|0x6A|0x60|0x00|
182 */
183 public static final byte FLOAT_32_UNIT = 25;
184
185 /**
186 * Double, stored internally in the SI unit, with a unit type and display type attached. The internal storage of the value
187 * that is transmitted is always in the SI (or standard) unit, except for money where the display unit is used. The value is
188 * preceded by a one-byte unit type and a one-byte display type (or two-byte in case of the MoneyPerUnit). As an example:
189 * suppose the unit indicates that the type is a length, whereas the display type indicates that the internally stored value
190 * 60000.0 should be displayed as 60.0 km, this is coded as follows: |26|16|11|0x47|0x6A|0x60|0x00|0x00|0x00|0x00|0x00|
191 */
192 public static final byte DOUBLE_64_UNIT = 26;
193
194 /**
195 * Number-preceded dense float array, stored internally in the SI unit, with a unit type and display type. After the byte
196 * with value 27, the array types have a 32-bit int indicating the number of values in the array that follows. This int is
197 * itself not preceded by a byte indicating it is an int. Then a one-byte unit type follows and a one-byte display type (or
198 * two-byte in case of the MoneyPerUnit). The internal storage of the values that are transmitted after that always use the
199 * SI (or standard) unit, except for money where the display unit is used. As an example: when we send an array of two
200 * durations, 2.0 minutes and 2.5 minutes, this is coded as follows:
201 * |27|0|0|0|2|25|7|0x40|0x00|0x00|0x00|0x40|0x20|0x00|0x00|
202 */
203 public static final byte FLOAT_32_UNIT_ARRAY = 27;
204
205 /**
206 * Number-preceded dense double array, stored internally in the SI unit, with a unit type and display type. After the byte
207 * with value 28, the array types have a 32-bit int indicating the number of values in the array that follows. This int is
208 * itself not preceded by a byte indicating it is an int. Then a one-byte unit type follows and a one-byte display type (or
209 * two-byte in case of the MoneyPerUnit). The internal storage of the values that are transmitted after that always use the
210 * SI (or standard) unit, except for money where the display unit is used. As an example: when we send an array of two
211 * durations, 21.2 minutes and 21.5 minutes, this is coded as follows:
212 * |28|0|0|0|2|25|7|0x40|0x35|0x33|0x33|0x3|0x33|0x33|0x33|0x40|0x35|0x80|0x00|0x00|0x00|0x00|0x00|
213 */
214 public static final byte DOUBLE_64_UNIT_ARRAY = 28;
215
216 /**
217 * Rows/Cols-preceded dense float array, stored internally in the SI unit, with a unit type and display type. After the byte
218 * with value 29, the matrix types have a 32-bit int indicating the number of rows in the array that follows, followed by a
219 * 32-bit int indicating the number of columns. These integers are not preceded by a byte indicating it is an int. Then a
220 * one-byte unit type follows and a one-byte (or two-byte in case of the MoneyPerUnit) display type The internal storage of
221 * the values that are transmitted after that always use the SI (or standard) unit, except for money where the display unit
222 * is used. Summarized, the coding is as follows:
223 *
224 * <pre>
225 * |29| |R|O|W|S| |C|O|L|S| |UT| |DT|
226 * |R|1|C|1| |R|1|C|2| ... |R|1|C|n|
227 * |R|2|C|1| |R|2|C|2| ... |R|2|C|n|
228 * ...
229 * |R|m|C|1| |R|m|C|2| ... |R|m|C|n|
230 * </pre>
231 *
232 * In the language sending ore receiving a matrix, the rows are denoted by the outer index, and the columns by the inner
233 * index: matrix[row][col].
234 */
235 public static final byte FLOAT_32_UNIT_MATRIX = 29;
236
237 /**
238 * Rows/Cols-preceded dense double array, stored internally in the SI unit, with a unit type and display type. After the
239 * byte with value 30, the matrix types have a 32-bit int indicating the number of rows in the array that follows, followed
240 * by a 32-bit int indicating the number of columns. These integers are not preceded by a byte indicating it is an int. Then
241 * a one-byte unit type follows and a one-byte (or two-byte in case of the MoneyPerUnit) display type The internal storage
242 * of the values that are transmitted after that always use the SI (or standard) unit, except for money where the display
243 * unit is used. Summarized, the coding is as follows:
244 *
245 * <pre>
246 * |30| |R|O|W|S| |C|O|L|S| |UT| |DT|
247 * |R|1|C|1|.|.|.|.| |R|1|C|2|.|.|.|.| ... |R|1|C|n|.|.|.|.|
248 * |R|2|C|1|.|.|.|.| |R|2|C|2|.|.|.|.| ... |R|2|C|n|.|.|.|.|
249 * ...
250 * |R|m|C|1|.|.|.|.| |R|m|C|2|.|.|.|.| ... |R|m|C|n|.|.|.|.|
251 * </pre>
252 *
253 * In the language sending ore receiving a matrix, the rows are denoted by the outer index, and the columns by the inner
254 * index: matrix[row][col].
255 */
256 public static final byte DOUBLE_64_UNIT_MATRIX = 30;
257
258 /**
259 * Number-preceded dense float array, stored internally in the SI unit, with a unique unit type and display type per row.
260 * After the byte with value 31, the matrix types have a 32-bit int indicating the number of rows in the array that follows,
261 * followed by a 32-bit int indicating the number of columns. These integers are not preceded by a byte indicating it is an
262 * int. Then a one-byte unit type for column 1 follows and a one-byte (or two-byte in case of the MoneyPerUnit) display type
263 * for column 1. Then the unit type and display type for column 2, etc. The internal storage of the values that are
264 * transmitted after that always use the SI (or standard) unit, except for money where the display unit is used. Summarized,
265 * the coding is as follows:
266 *
267 * <pre>
268 * |31| |R|O|W|S| |C|O|L|S|
269 * |UT1|DT1| |UT2|DT2| ... |UTn|DTn|
270 * |R|1|C|1| |R|1|C|2| ... |R|1|C|n|
271 * |R|2|C|1| |R|2|C|2| ... |R|2|C|n|
272 * ...
273 * |R|m|C|1| |R|m|C|2| ... |R|m|C|n|
274 * </pre>
275 *
276 * In the language sending or receiving a matrix, the rows are denoted by the outer index, and the columns by the inner
277 * index: matrix[row][col]. This data type is ideal for, for instance, sending a time series of values, where column 1
278 * indicates the time, and column 2 the value. Suppose that we have a time series of 4 values at t = {1, 2, 3, 4} hours and
279 * dimensionless values v = {20.0, 40.0, 50.0, 60.0}, then the coding is as follows:
280 *
281 * <pre>
282 * |31| |0|0|0|4| |0|0|0|2|
283 * |26|8| |0|0|
284 * |0x3F|0x80|0x00|0x00| |0x41|0xA0|0x00|0x00|
285 * |0x40|0x00|0x00|0x00| |0x42|0x20|0x00|0x00|
286 * |0x40|0x00|0x40|0x00| |0x42|0x48|0x00|0x00|
287 * |0x40|0x80|0x00|0x00| |0x42|0x70|0x00|0x00|
288 * </pre>
289 */
290 public static final byte FLOAT_32_UNIT_COLUMN_ARRAY = 31;
291
292 /**
293 * Number-preceded dense double array, stored internally in the SI unit, with a unique unit type and display type per row.
294 * After the byte with value 32, the matrix types have a 32-bit int indicating the number of rows in the array that follows,
295 * followed by a 32-bit int indicating the number of columns. These integers are not preceded by a byte indicating it is an
296 * int. Then a one-byte unit type for column 1 follows (see the table above) and a one-byte (or two-byte in case of the
297 * MoneyPerUnit) display type for column 1 (see Appendix A). Then the unit type and display type for column 2, etc. The
298 * internal storage of the values that are transmitted after that always use the SI (or standard) unit, except for money
299 * where the display unit is used. Summarized, the coding is as follows:
300 *
301 * <pre>
302 * |32| |R|O|W|S| |C|O|L|S|
303 * |UT1|DT1| |UT2|DT2| ... |UTn|DTn|
304 * |R|1|C|1|.|.|.|.| |R|1|C|2|.|.|.|.| ... |R|1|C|n|.|.|.|.|
305 * |R|2|C|1|.|.|.|.| |R|2|C|2|.|.|.|.| ... |R|2|C|n|.|.|.|.|
306 * ...
307 * |R|m|C|1|.|.|.|.| |R|m|C|2|.|.|.|.| ... |R|m|C|n|.|.|.|.|
308 * </pre>
309 *
310 * In the language sending or receiving a matrix, the rows are denoted by the outer index, and the columns by the inner
311 * index: matrix[row][col]. This data type is ideal for, for instance, sending a time series of values, where column 1
312 * indicates the time, and column 2 the value. Suppose that we have a time series of 4 values at dimensionless years {2010,
313 * 2011, 2012, 2013} and costs of dollars per acre of {415.7, 423.4, 428.0, 435.1}, then the coding is as follows:
314 *
315 * <pre>
316 * |32| |0|0|0|4| |0|0|0|2|
317 * |0|0| |101|150|18|
318 * |0x40|0x9F|0x68|0x00|0x00|0x00|0x00|0x00|
319 * |0x40|0x79|0xFB|0x33|0x33|0x33|0x33|0x33|
320 * |0x40|0x9F|0x6C|0x00|0x00|0x00|0x00|0x00|
321 * |0x40|0x7A|0x76|0x66|0x66|0x66|0x66|0x66|
322 * |0x40|0x9F|0x70|0x00|0x00|0x00|0x00|0x00|
323 * |0x40|0x7A|0xC0|0x00|0x00|0x00|0x00|0x00|
324 * |0x40|0x9F|0x74|0x00|0x00|0x00|0x00|0x00|
325 * |0x40|0x7A|0x91|0x99|0x99|0x99|0x99|0x9A|
326 * </pre>
327 */
328 public static final byte DOUBLE_64_UNIT_COLUMN_ARRAY = 32;
329
330 /** 128 (-128) Byte, 8 bit signed two's complement integer; equal to code 0. */
331 public static final byte BYTE_8_LE = -128;
332
333 /**
334 * 129 (-127) Short, 16 bit signed two's complement integer, little endian order.
335 */
336 public static final byte SHORT_16_LE = -127;
337
338 /**
339 * 130 (-126) Integer, 32 bit signed two's complement integer, little endian order.
340 */
341 public static final byte INT_32_LE = -126;
342
343 /**
344 * 131 (-125) Long, 64 bit signed two's complement integer, little endian order.
345 */
346 public static final byte LONG_64_LE = -125;
347
348 /**
349 * 132 (-124) Float, single-precision 32-bit IEEE 754 floating point, little endian order.
350 */
351 public static final byte FLOAT_32_LE = -124;
352
353 /**
354 * 133 (-123) Float, double-precision 64-bit IEEE 754 floating point, little endian order.
355 */
356 public static final byte DOUBLE_64_LE = -123;
357
358 /**
359 * 134 (-122) Boolean, sent / received as a byte; 0 = false, 1 = true; equal to code 6.
360 */
361 public static final byte BOOLEAN_8_LE = -122;
362
363 /**
364 * 135 (-121) Char, 8-bit ASCII character; equal to code 7.
365 */
366 public static final byte CHAR_8_LE = -121;
367
368 /**
369 * 136 (-120) Char, 16-bit Unicode character, little-endian order for the 2 part.
370 */
371 public static final byte CHAR_16_LE = -120;
372
373 /**
374 * s 137 (-119) String, 32-bit little-endian number-preceded byte array of 8-bits characters.
375 */
376 public static final byte STRING_8_LE = -119;
377
378 /**
379 * 138 (-118) String, 32-bit little-endian number-preceded char array of 16-bits characters, each 2-byte character in
380 * little-endian order.
381 */
382 public static final byte STRING_16_LE = -118;
383
384 /**
385 * 139 (-117) Byte array, preceded by a 32-bit little-endian number indicating the number of bytes.
386 */
387 public static final byte BYTE_8_ARRAY_LE = -117;
388
389 /**
390 * 140 (-116) Short array, preceded by a 32-bit little-endian number indicating the number of shorts, little-endian coded
391 * shorts.
392 */
393 public static final byte SHORT_16_ARRAY_LE = -116;
394
395 /**
396 * 141 (-115) Integer array, preceded by a 32-bit little-endian number indicating the number of integers, little-endian
397 * coded ints.
398 */
399 public static final byte INT_32_ARRAY_LE = -115;
400
401 /**
402 * 142 (-114) Long array, preceded by a 32-bit little-endian number indicating the number of longs, little-endian coded
403 * longs.
404 */
405 public static final byte LONG_64_ARRAY_LE = -114;
406
407 /**
408 * 143 (-113) Float array, preceded by a 32-bit little-endian number indicating the number of floats, little-endian coded
409 * floats.
410 */
411 public static final byte FLOAT_32_ARRAY_LE = -113;
412
413 /**
414 * 144 (-112) Double array, preceded by a 32-bit little-endian number indicating the number of doubles, little-endian coded
415 * doubles.
416 */
417 public static final byte DOUBLE_64_ARRAY_LE = -112;
418
419 /**
420 * 145 (-111) Boolean array, preceded by a 32-bit little-endian number indicating the number of booleans.
421 */
422 public static final byte BOOLEAN_8_ARRAY_LE = -111;
423
424 /**
425 * 146 (-110) Byte matrix, preceded by a 32-bit little-endian number row count and a 32-bit little-endian number column
426 * count.
427 */
428 public static final byte BYTE_8_MATRIX_LE = -110;
429
430 /**
431 * 147 (-109) Short matrix, preceded by a 32-bit little-endian number row count and a 32-bit little-endian number column
432 * count, little-endian coded shorts.
433 */
434 public static final byte SHORT_16_MATRIX_LE = -109;
435
436 /**
437 * 148 (-108) Integer matrix, preceded by a 32-bit little-endian number row count and a 32-bit little-endian number column
438 * count, little-endian coded ints.
439 */
440 public static final byte INT_32_MATRIX_LE = -108;
441
442 /**
443 * 149 (-107) Long matrix, preceded by a 32-bit little-endian number row count and a 32-bit little-endian number column
444 * count, little-endian coded longs.
445 */
446 public static final byte LONG_64_MATRIX_LE = -107;
447
448 /**
449 * 150 (-106) Float matrix, preceded by a 32-bit little-endian number row count and a 32-bit little-endian number column
450 * count, little-endian coded floats.
451 */
452 public static final byte FLOAT_32_MATRIX_LE = -106;
453
454 /**
455 * 151 (-105) Double matrix, preceded by a 32-bit little-endian number row count and a 32-bit little-endian number column
456 * count, little-endian doubles.
457 */
458 public static final byte DOUBLE_64_MATRIX_LE = -105;
459
460 /**
461 * 152 (-104) Boolean matrix, preceded by a 32-bit little-endian number row count and a 32-bit little-endian number column
462 * count.
463 */
464 public static final byte BOOLEAN_8_MATRIX_LE = -104;
465
466 /**
467 * 153 (-103) Float stored internally as a little-endian float in the corresponding SI unit, with unit type and display unit
468 * attached. The total size of the object is 7 bytes plus 1 or 2 extra bytes when a money unit is involved.
469 */
470 public static final byte FLOAT_32_UNIT_LE = -103;
471
472 /**
473 * 154 (-102) Double stored internally as a little-endian double in the corresponding SI unit, with unit type and display
474 * unit attached. The total size of the object is 11 bytes plus 1 or 2 extra bytes when a money unit is involved.
475 */
476 public static final byte DOUBLE_64_UNIT_LE = -102;
477
478 /**
479 * 155 (-101) Dense float array, preceded by a little-endian 32-bit number indicating the number of floats, with unit type
480 * and display unit attached to the entire float array. Each float is stored in little-endian order.
481 */
482 public static final byte FLOAT_32_UNIT_ARRAY_LE = -101;
483
484 /**
485 * 156 (-100) Dense double array, preceded by a little-endian 32-bit number indicating the number of doubles, little-endian
486 * order, with unit type and display unit attached to the entire double array. Each double is stored in little-endian order.
487 */
488 public static final byte DOUBLE_64_UNIT_ARRAY_LE = -100;
489
490 /**
491 * 157 (-99) Dense float matrix, preceded by a 32-bit little-endian row count int and a 32-bit little-endian column count
492 * int, with unit type and display unit attached to the entire float matrix. Each float is stored in little-endian order.
493 */
494 public static final byte FLOAT_32_UNIT_MATRIX_LE = -99;
495
496 /**
497 * 158 (-98) Dense double matrix, preceded by a 32-bit little-endian row count int and a 32-bit little-endian column count
498 * int, with unit type and display unit attached to the entire double matrix. Each double is stored in little-endian order.
499 */
500 public static final byte DOUBLE_64_UNIT_MATRIX_LE = -98;
501
502 /**
503 * 159 (-97) Dense little-endian float matrix, preceded by a 32-bit little-endian row count int and a 32-bit little-endian
504 * column count int, with a unique unit type and display unit per row of the float matrix.
505 */
506 public static final byte FLOAT_32_UNIT2_MATRIX_LE = -97;
507
508 /**
509 * 160 (-96) Dense little-endian double matrix, preceded by a 32-bit little-endian row count int and a 32-bit little-endian
510 * column count int, with a unique unit type and display unit per row of the double matrix.
511 */
512 public static final byte DOUBLE_64_UNIT2_MATRIX_LE = -96;
513
514 /**
515 * Utility class, cannot be instantiated.
516 */
517 private FieldTypes()
518 {
519 // Utility class
520 }
521
522 }