OV-GSO-DC / VOTableLib

Commit 0c5a230693a6e7571775ff16890902d14c3dbab6

Authored by Mickael Boiziot
1 parent 54c7ec80
Exists in master and in 1 other branch b6.0.X

Refactor BinaryStreamParser

Showing 1 changed file with 246 additions and 140 deletions   Show diff stats
Inline Side-by-side
src/main/java/eu/omp/irap/vespa/votable/votabledata/BinaryStreamParser.java
  Diff comments   View file @0c5a230
... ... @@ -39,9 +39,6 @@ public final class BinaryStreamParser implements DataParser {
39 39 /** The logger for the class BinaryStreamParser. */
40 40 private static final Logger LOGGER = Logger.getLogger(BinaryStreamParser.class.getName());
41 41  
42   - /** The index of the current position in the bytes array. */
43   - private int cursor;
44   -
45 42 /** The XML nodes of VOTable document, containing the column names. */
46 43 private List<Field> fieldsNodes;
47 44  
... ... @@ -61,7 +58,6 @@ public final class BinaryStreamParser implements DataParser {
61 58 * Binary serialization in the VOTable REC.</a>
62 59 */
63 60 public BinaryStreamParser(Stream voStream, List<Field> fieldsNodes) {
64   - cursor = 0;
65 61 this.fieldsNodes = fieldsNodes;
66 62 String strStream = voStream.getValue().replaceAll("(\\r|\\n)", "");
67 63 stream = ByteBuffer.wrap(DatatypeConverter.parseBase64Binary(strStream));
... ... @@ -170,157 +166,267 @@ public final class BinaryStreamParser implements DataParser {
170 166 private Object processDataBlock(DataType dataType) {
171 167 Object dataBlock;
172 168 int blockSize = getBlockSize(dataType);
  169 + int nbElement = blockSize == 0 ? 0 : rowSize / blockSize;
  170 + if (nbElement == 0) {
  171 + return "";
  172 + }
173 173 if (dataType.equals(DataType.BOOLEAN)) {
174   - if (rowSize != blockSize) {
175   - int nb = rowSize / blockSize;
176   - if (nb == 0) { dataBlock = ""; }
177   - else {
178   - StringJoiner sj = new StringJoiner(" ", "", "");
179   - for (int i = 0; i < nb; i++) {
180   - sj.add(String.valueOf(new Boolean(stream.getInt() == 0 ? false : true)));
181   - }
182   - dataBlock = sj.toString();
183   - }
184   - } else {
185   - dataBlock = new Boolean(stream.getInt() == 0 ? false : true);
186   - }
  174 + dataBlock = processBoolean(nbElement, stream);
187 175 } else if (dataType.equals(DataType.UNSIGNED_BYTE)) {
188   - if (rowSize != blockSize) {
189   - int nb = rowSize / blockSize;
190   - if (nb == 0) { dataBlock = ""; }
191   - else {
192   - StringJoiner sj = new StringJoiner(" ", "", "");
193   - for (int i = 0; i < nb; i++) {
194   - sj.add(String.valueOf(stream.get()));
195   - }
196   - dataBlock = sj.toString();
197   - }
198   - } else {
199   - dataBlock = stream.get();
200   - }
  176 + dataBlock = processUnsignedByte(nbElement, stream);
201 177 } else if (dataType.equals(DataType.SHORT)) {
202   - if (rowSize != blockSize) {
203   - int nb = rowSize / blockSize;
204   - if (nb == 0) { dataBlock = ""; }
205   - else {
206   - StringJoiner sj = new StringJoiner(" ", "", "");
207   - for (int i = 0; i < nb; i++) {
208   - sj.add(String.valueOf(stream.getShort()));
209   - }
210   - dataBlock = sj.toString();
211   - }
212   - } else {
213   - dataBlock = stream.getShort();
214   - }
  178 + dataBlock = processShort(nbElement, stream);
215 179 } else if (dataType.equals(DataType.INT)) {
216   - if (rowSize != blockSize) {
217   - int nb = rowSize / blockSize;
218   - if (nb == 0) { dataBlock = ""; }
219   - else {
220   - StringJoiner sj = new StringJoiner(" ", "", "");
221   - for (int i = 0; i < nb; i++) {
222   - sj.add(String.valueOf(stream.getInt()));
223   - }
224   - dataBlock = sj.toString();
225   - }
226   - } else {
227   - dataBlock = stream.getInt();
228   - }
  180 + dataBlock = processInt(nbElement, stream);
229 181 } else if (dataType.equals(DataType.LONG)) {
230   - if (rowSize != blockSize) {
231   - int nb = rowSize / blockSize;
232   - if (nb == 0) { dataBlock = ""; }
233   - else {
234   - StringJoiner sj = new StringJoiner(" ", "", "");
235   - for (int i = 0; i < nb; i++) {
236   - sj.add(String.valueOf(stream.getLong()));
237   - }
238   - dataBlock = sj.toString();
239   - }
240   - } else {
241   - dataBlock = stream.getLong();
242   - }
  182 + dataBlock = processLong(nbElement, stream);
243 183 } else if (dataType.equals(DataType.CHAR)) {
244   - String value = new String();
245   - for (int i = 0; i < rowSize && cursor < stream.capacity()
246   - && stream.position() < stream.limit(); i++) {
247   - value += (char) stream.get();
248   - }
249   - dataBlock = value.trim();
  184 + dataBlock = processChar(nbElement, stream);
250 185 } else if (dataType.equals(DataType.UNICODE_CHAR)) {
251   - String value = new String();
252   - for (int i = 0; i < rowSize && cursor < stream.capacity(); i += 2) {
253   - value += stream.getChar();
254   - }
255   - dataBlock = value.trim();
  186 + dataBlock = processUnicodeChar(nbElement, stream);
256 187 } else if (dataType.equals(DataType.FLOAT)) {
257   - if (rowSize != blockSize) {
258   - int nb = rowSize / blockSize;
259   - if (nb == 0) { dataBlock = ""; }
260   - else {
261   - StringJoiner sj = new StringJoiner(" ", "", "");
262   - for (int i = 0; i < nb; i++) {
263   - sj.add(String.valueOf(stream.getFloat()));
264   - }
265   - dataBlock = sj.toString();
266   - }
267   - } else {
268   - dataBlock = stream.getFloat();
269   - }
  188 + dataBlock = processFloat(nbElement, stream);
270 189 } else if (dataType.equals(DataType.DOUBLE)) {
271   - if (rowSize != blockSize) {
272   - int nb = rowSize / blockSize;
273   - if (nb == 0) { dataBlock = ""; }
274   - else {
275   - StringJoiner sj = new StringJoiner(" ", "", "");
276   - for (int i = 0; i < nb; i++) {
277   - sj.add(String.valueOf(stream.getDouble()));
278   - }
279   - dataBlock = sj.toString();
280   - }
281   - } else {
282   - dataBlock = stream.getDouble();
283   - }
  190 + dataBlock = processDouble(nbElement, stream);
284 191 } else if (dataType.equals(DataType.FLOAT_COMPLEX)) {
285   - if (rowSize != blockSize) {
286   - int nb = rowSize / blockSize;
287   - if (nb == 0) { dataBlock = ""; }
288   - else {
289   - StringJoiner sj = new StringJoiner(" ", "", "");
290   - for (int i = 0; i < nb; i++) {
291   - sj.add(String.valueOf(stream.getFloat()));
292   - sj.add(String.valueOf(stream.getFloat()));
293   - }
294   - dataBlock = sj.toString();
295   - }
296   - } else {
297   - StringJoiner sj = new StringJoiner(" ", "", "");
298   - sj.add(String.valueOf(stream.getFloat()));
299   - sj.add(String.valueOf(stream.getFloat()));
300   - dataBlock = sj.toString();
301   - }
  192 + dataBlock = processFloatComplex(nbElement, stream);
302 193 } else if (dataType.equals(DataType.DOUBLE_COMPLEX)) {
303   - if (rowSize != blockSize) {
304   - int nb = rowSize / blockSize;
305   - if (nb == 0) { dataBlock = ""; }
306   - else {
307   - StringJoiner sj = new StringJoiner(" ", "", "");
308   - for (int i = 0; i < nb; i++) {
309   - sj.add(String.valueOf(stream.getDouble()));
310   - sj.add(String.valueOf(stream.getDouble()));
311   - }
312   - dataBlock = sj.toString();
313   - }
314   - } else {
315   - StringJoiner sj = new StringJoiner(" ", "", "");
316   - sj.add(String.valueOf(stream.getDouble()));
317   - sj.add(String.valueOf(stream.getDouble()));
318   - dataBlock = sj.toString();
319   - }
  194 + dataBlock = processDoubleComplex(nbElement, stream);
320 195 } else {
321 196 BinaryStreamParser.LOGGER.warning("Data type " + dataType + " is not supported.");
322 197 dataBlock = null;
323 198 }
324 199 return dataBlock;
325 200 }
  201 +
  202 + /**
  203 + * Process a double complex data type and return the result.
  204 + *
  205 + * @param nbElement The number of element inside the byte buffer.
  206 + * @param byteBuffer The Byte Buffer used.
  207 + * @return The processed data.
  208 + */
  209 + private Object processDoubleComplex(int nbElement, ByteBuffer byteBuffer) {
  210 + Object dataBlock;
  211 + if (nbElement != 1) {
  212 + StringJoiner sj = new StringJoiner(" ", "", "");
  213 + for (int i = 0; i < nbElement; i++) {
  214 + sj.add(String.valueOf(byteBuffer.getDouble()));
  215 + sj.add(String.valueOf(byteBuffer.getDouble()));
  216 + }
  217 + dataBlock = sj.toString();
  218 + } else {
  219 + StringJoiner sj = new StringJoiner(" ", "", "");
  220 + sj.add(String.valueOf(byteBuffer.getDouble()));
  221 + sj.add(String.valueOf(byteBuffer.getDouble()));
  222 + dataBlock = sj.toString();
  223 + }
  224 + return dataBlock;
  225 + }
  226 +
  227 + /**
  228 + * Process a float complex data type and return the result.
  229 + *
  230 + * @param nbElement The number of element inside the byte buffer.
  231 + * @param byteBuffer The Byte Buffer used.
  232 + * @return The processed data.
  233 + */
  234 + private Object processFloatComplex(int nbElement, ByteBuffer byteBuffer) {
  235 + Object dataBlock;
  236 + if (nbElement != 1) {
  237 + StringJoiner sj = new StringJoiner(" ", "", "");
  238 + for (int i = 0; i < nbElement; i++) {
  239 + sj.add(String.valueOf(byteBuffer.getFloat()));
  240 + sj.add(String.valueOf(byteBuffer.getFloat()));
  241 + }
  242 + dataBlock = sj.toString();
  243 + } else {
  244 + StringJoiner sj = new StringJoiner(" ", "", "");
  245 + sj.add(String.valueOf(byteBuffer.getFloat()));
  246 + sj.add(String.valueOf(byteBuffer.getFloat()));
  247 + dataBlock = sj.toString();
  248 + }
  249 + return dataBlock;
  250 + }
  251 +
  252 + /**
  253 + * Process a double data type and return the result.
  254 + *
  255 + * @param nbElement The number of element inside the byte buffer.
  256 + * @param byteBuffer The Byte Buffer used.
  257 + * @return The processed data.
  258 + */
  259 + private Object processDouble(int nbElement, ByteBuffer byteBuffer) {
  260 + Object dataBlock;
  261 + if (nbElement != 1) {
  262 + StringJoiner sj = new StringJoiner(" ", "", "");
  263 + for (int i = 0; i < nbElement; i++) {
  264 + sj.add(String.valueOf(byteBuffer.getDouble()));
  265 + }
  266 + dataBlock = sj.toString();
  267 + } else {
  268 + dataBlock = byteBuffer.getDouble();
  269 + }
  270 + return dataBlock;
  271 + }
  272 +
  273 + /**
  274 + * Process a float data type and return the result.
  275 + *
  276 + * @param nbElement The number of element inside the byte buffer.
  277 + * @param byteBuffer The Byte Buffer used.
  278 + * @return The processed data.
  279 + */
  280 + private Object processFloat(int nbElement, ByteBuffer byteBuffer) {
  281 + Object dataBlock;
  282 + if (nbElement != 1) {
  283 + StringJoiner sj = new StringJoiner(" ", "", "");
  284 + for (int i = 0; i < nbElement; i++) {
  285 + sj.add(String.valueOf(byteBuffer.getFloat()));
  286 + }
  287 + dataBlock = sj.toString();
  288 + } else {
  289 + dataBlock = byteBuffer.getFloat();
  290 + }
  291 + return dataBlock;
  292 + }
  293 +
  294 + /**
  295 + * Process a unicode char data type and return the result.
  296 + *
  297 + * @param nbElement The number of element inside the byte buffer.
  298 + * @param byteBuffer The Byte Buffer used.
  299 + * @return The processed data.
  300 + */
  301 + private Object processUnicodeChar(int nbElement, ByteBuffer byteBuffer) {
  302 + Object dataBlock;
  303 + String value = new String();
  304 + for (int i = 0; i < nbElement; i += 2) {
  305 + value += byteBuffer.getChar();
  306 + }
  307 + dataBlock = value.trim();
  308 + return dataBlock;
  309 + }
  310 +
  311 + /**
  312 + * Process a char data type and return the result.
  313 + *
  314 + * @param nbElement The number of element inside the byte buffer.
  315 + * @param byteBuffer The Byte Buffer used.
  316 + * @return The processed data.
  317 + */
  318 + private Object processChar(int nbElement, ByteBuffer byteBuffer) {
  319 + Object dataBlock;
  320 + String value = new String();
  321 + for (int i = 0; i < nbElement && byteBuffer.position() < byteBuffer.limit(); i++) {
  322 + value += (char) byteBuffer.get();
  323 + }
  324 + dataBlock = value.trim();
  325 + return dataBlock;
  326 + }
  327 +
  328 + /**
  329 + * Process a long data type and return the result.
  330 + *
  331 + * @param nbElement The number of element inside the byte buffer.
  332 + * @param byteBuffer The Byte Buffer used.
  333 + * @return The processed data.
  334 + */
  335 + private Object processLong(int nbElement, ByteBuffer byteBuffer) {
  336 + Object dataBlock;
  337 + if (nbElement != 1) {
  338 + StringJoiner sj = new StringJoiner(" ", "", "");
  339 + for (int i = 0; i < nbElement; i++) {
  340 + sj.add(String.valueOf(byteBuffer.getLong()));
  341 + }
  342 + dataBlock = sj.toString();
  343 + } else {
  344 + dataBlock = byteBuffer.getLong();
  345 + }
  346 + return dataBlock;
  347 + }
  348 +
  349 + /**
  350 + * Process a int data type and return the result.
  351 + *
  352 + * @param nbElement The number of element inside the byte buffer.
  353 + * @param byteBuffer The Byte Buffer used.
  354 + * @return The processed data.
  355 + */
  356 + private Object processInt(int nbElement, ByteBuffer byteBuffer) {
  357 + Object dataBlock;
  358 + if (nbElement != 1) {
  359 + StringJoiner sj = new StringJoiner(" ", "", "");
  360 + for (int i = 0; i < nbElement; i++) {
  361 + sj.add(String.valueOf(byteBuffer.getInt()));
  362 + }
  363 + dataBlock = sj.toString();
  364 + } else {
  365 + dataBlock = byteBuffer.getInt();
  366 + }
  367 + return dataBlock;
  368 + }
  369 +
  370 + /**
  371 + * Process a short data type and return the result.
  372 + *
  373 + * @param nbElement The number of element inside the byte buffer.
  374 + * @param byteBuffer The Byte Buffer used.
  375 + * @return The processed data.
  376 + */
  377 + private Object processShort(int nbElement, ByteBuffer byteBuffer) {
  378 + Object dataBlock;
  379 + if (nbElement != 1) {
  380 + StringJoiner sj = new StringJoiner(" ", "", "");
  381 + for (int i = 0; i < nbElement; i++) {
  382 + sj.add(String.valueOf(byteBuffer.getShort()));
  383 + }
  384 + dataBlock = sj.toString();
  385 + } else {
  386 + dataBlock = byteBuffer.getShort();
  387 + }
  388 + return dataBlock;
  389 + }
  390 +
  391 + /**
  392 + * Process a unsigned byte data type and return the result.
  393 + *
  394 + * @param nbElement The number of element inside the byte buffer.
  395 + * @param byteBuffer The Byte Buffer used.
  396 + * @return The processed data.
  397 + */
  398 + private Object processUnsignedByte(int nbElement, ByteBuffer byteBuffer) {
  399 + Object dataBlock;
  400 + if (nbElement != 1) {
  401 + StringJoiner sj = new StringJoiner(" ", "", "");
  402 + for (int i = 0; i < nbElement; i++) {
  403 + sj.add(String.valueOf(byteBuffer.get()));
  404 + }
  405 + dataBlock = sj.toString();
  406 + } else {
  407 + dataBlock = byteBuffer.get();
  408 + }
  409 + return dataBlock;
  410 + }
  411 +
  412 + /**
  413 + * Process a boolean data type and return the result.
  414 + *
  415 + * @param nbElement The number of element inside the byte buffer.
  416 + * @param byteBuffer The Byte Buffer used.
  417 + * @return The processed data.
  418 + */
  419 + private Object processBoolean(int nbElement, ByteBuffer byteBuffer) {
  420 + Object dataBlock;
  421 + if (nbElement != 1) {
  422 + StringJoiner sj = new StringJoiner(" ", "", "");
  423 + for (int i = 0; i < nbElement; i++) {
  424 + sj.add(String.valueOf(new Boolean(byteBuffer.getInt() == 0 ? false : true)));
  425 + }
  426 + dataBlock = sj.toString();
  427 + } else {
  428 + dataBlock = new Boolean(byteBuffer.getInt() == 0 ? false : true);
  429 + }
  430 + return dataBlock;
  431 + }
326 432 }
... ...