001/******************************************************************************* 002 * Licensed to the Apache Software Foundation (ASF) under one 003 * or more contributor license agreements. See the NOTICE file 004 * distributed with this work for additional information 005 * regarding copyright ownership. The ASF licenses this file 006 * to you under the Apache License, Version 2.0 (the 007 * "License"); you may not use this file except in compliance 008 * with the License. You may obtain a copy of the License at 009 * 010 * http://www.apache.org/licenses/LICENSE-2.0 011 * 012 * Unless required by applicable law or agreed to in writing, 013 * software distributed under the License is distributed on an 014 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 015 * KIND, either express or implied. See the License for the 016 * specific language governing permissions and limitations 017 * under the License. 018 *******************************************************************************/ 019package org.apache.commons.lang3; 020 021import java.util.UUID; 022 023 024/** 025 * <p> 026 * Static methods to convert a type into another, with endianness and bit ordering awareness. 027 * </p> 028 * <p> 029 * The methods names follow a naming rule:<br> 030 * {@code <source type>[source endianness][source bit ordering]To<destination type>[destination endianness][destination bit ordering]} 031 * </p> 032 * <p> 033 * Source/destination type fields is one of the following: 034 * </p> 035 * <ul> 036 * <li>binary: an array of booleans</li> 037 * <li>byte or byteArray</li> 038 * <li>int or intArray</li> 039 * <li>long or longArray</li> 040 * <li>hex: a String containing hexadecimal digits (lowercase in destination)</li> 041 * <li>hexDigit: a Char containing a hexadecimal digit (lowercase in destination)</li> 042 * <li>uuid</li> 043 * </ul> 044 * <p> 045 * Endianness field: little endian is the default, in this case the field is absent. In case of 046 * big endian, the field is "Be".<br> Bit ordering: Lsb0 is the default, in this case the field 047 * is absent. In case of Msb0, the field is "Msb0". 048 * </p> 049 * <p> 050 * Example: intBeMsb0ToHex convert an int with big endian byte order and Msb0 bit order into its 051 * hexadecimal string representation 052 * </p> 053 * <p> 054 * Most of the methods provide only default encoding for destination, this limits the number of 055 * ways to do one thing. Unless you are dealing with data from/to outside of the JVM platform, 056 * you should not need to use "Be" and "Msb0" methods. 057 * </p> 058 * <p> 059 * Development status: work on going, only a part of the little endian, Lsb0 methods implemented 060 * so far. 061 * </p> 062 * 063 * @since Lang 3.2 064 */ 065 066public class Conversion { 067 068 private static final boolean[] TTTT = new boolean[] { true, true, true, true }; 069 private static final boolean[] FTTT = new boolean[] { false, true, true, true }; 070 private static final boolean[] TFTT = new boolean[] { true, false, true, true }; 071 private static final boolean[] FFTT = new boolean[] { false, false, true, true }; 072 private static final boolean[] TTFT = new boolean[] { true, true, false, true }; 073 private static final boolean[] FTFT = new boolean[] { false, true, false, true }; 074 private static final boolean[] TFFT = new boolean[] { true, false, false, true }; 075 private static final boolean[] FFFT = new boolean[] { false, false, false, true }; 076 private static final boolean[] TTTF = new boolean[] { true, true, true, false }; 077 private static final boolean[] FTTF = new boolean[] { false, true, true, false }; 078 private static final boolean[] TFTF = new boolean[] { true, false, true, false }; 079 private static final boolean[] FFTF = new boolean[] { false, false, true, false }; 080 private static final boolean[] TTFF = new boolean[] { true, true, false, false }; 081 private static final boolean[] FTFF = new boolean[] { false, true, false, false }; 082 private static final boolean[] TFFF = new boolean[] { true, false, false, false }; 083 private static final boolean[] FFFF = new boolean[] { false, false, false, false }; 084 085 /** 086 * <p> 087 * Converts a hexadecimal digit into an int using the default (Lsb0) bit ordering. 088 * </p> 089 * <p> 090 * '1' is converted to 1 091 * </p> 092 * 093 * @param hexDigit the hexadecimal digit to convert 094 * @return an int equals to {@code hexDigit} 095 * @throws IllegalArgumentException if {@code hexDigit} is not a hexadecimal digit 096 */ 097 public static int hexDigitToInt(final char hexDigit) { 098 final int digit = Character.digit(hexDigit, 16); 099 if (digit < 0) { 100 throw new IllegalArgumentException("Cannot interpret '" + hexDigit + "' as a hexadecimal digit"); 101 } 102 return digit; 103 } 104 105 /** 106 * <p> 107 * Converts a hexadecimal digit into an int using the Msb0 bit ordering. 108 * </p> 109 * <p> 110 * '1' is converted to 8 111 * </p> 112 * 113 * @param hexDigit the hexadecimal digit to convert 114 * @return an int equals to {@code hexDigit} 115 * @throws IllegalArgumentException if {@code hexDigit} is not a hexadecimal digit 116 */ 117 public static int hexDigitMsb0ToInt(final char hexDigit) { 118 switch (hexDigit) { 119 case '0': 120 return 0x0; 121 case '1': 122 return 0x8; 123 case '2': 124 return 0x4; 125 case '3': 126 return 0xC; 127 case '4': 128 return 0x2; 129 case '5': 130 return 0xA; 131 case '6': 132 return 0x6; 133 case '7': 134 return 0xE; 135 case '8': 136 return 0x1; 137 case '9': 138 return 0x9; 139 case 'a':// fall through 140 case 'A': 141 return 0x5; 142 case 'b':// fall through 143 case 'B': 144 return 0xD; 145 case 'c':// fall through 146 case 'C': 147 return 0x3; 148 case 'd':// fall through 149 case 'D': 150 return 0xB; 151 case 'e':// fall through 152 case 'E': 153 return 0x7; 154 case 'f':// fall through 155 case 'F': 156 return 0xF; 157 default: 158 throw new IllegalArgumentException("Cannot interpret '" + hexDigit + "' as a hexadecimal digit"); 159 } 160 } 161 162 /** 163 * <p> 164 * Converts a hexadecimal digit into binary (represented as boolean array) using the default 165 * (Lsb0) bit ordering. 166 * </p> 167 * <p> 168 * '1' is converted as follow: (1, 0, 0, 0) 169 * </p> 170 * 171 * @param hexDigit the hexadecimal digit to convert 172 * @return a boolean array with the binary representation of {@code hexDigit} 173 * @throws IllegalArgumentException if {@code hexDigit} is not a hexadecimal digit 174 */ 175 public static boolean[] hexDigitToBinary(final char hexDigit) { 176 switch (hexDigit) { 177 case '0': 178 return FFFF.clone(); 179 case '1': 180 return TFFF.clone(); 181 case '2': 182 return FTFF.clone(); 183 case '3': 184 return TTFF.clone(); 185 case '4': 186 return FFTF.clone(); 187 case '5': 188 return TFTF.clone(); 189 case '6': 190 return FTTF.clone(); 191 case '7': 192 return TTTF.clone(); 193 case '8': 194 return FFFT.clone(); 195 case '9': 196 return TFFT.clone(); 197 case 'a':// fall through 198 case 'A': 199 return FTFT.clone(); 200 case 'b':// fall through 201 case 'B': 202 return TTFT.clone(); 203 case 'c':// fall through 204 case 'C': 205 return FFTT.clone(); 206 case 'd':// fall through 207 case 'D': 208 return TFTT.clone(); 209 case 'e':// fall through 210 case 'E': 211 return FTTT.clone(); 212 case 'f':// fall through 213 case 'F': 214 return TTTT.clone(); 215 default: 216 throw new IllegalArgumentException("Cannot interpret '" + hexDigit + "' as a hexadecimal digit"); 217 } 218 } 219 220 /** 221 * <p> 222 * Converts a hexadecimal digit into binary (represented as boolean array) using the Msb0 223 * bit ordering. 224 * </p> 225 * <p> 226 * '1' is converted as follow: (0, 0, 0, 1) 227 * </p> 228 * 229 * @param hexDigit the hexadecimal digit to convert 230 * @return a boolean array with the binary representation of {@code hexDigit} 231 * @throws IllegalArgumentException if {@code hexDigit} is not a hexadecimal digit 232 */ 233 public static boolean[] hexDigitMsb0ToBinary(final char hexDigit) { 234 switch (hexDigit) { 235 case '0': 236 return FFFF.clone(); 237 case '1': 238 return FFFT.clone(); 239 case '2': 240 return FFTF.clone(); 241 case '3': 242 return FFTT.clone(); 243 case '4': 244 return FTFF.clone(); 245 case '5': 246 return FTFT.clone(); 247 case '6': 248 return FTTF.clone(); 249 case '7': 250 return FTTT.clone(); 251 case '8': 252 return TFFF.clone(); 253 case '9': 254 return TFFT.clone(); 255 case 'a':// fall through 256 case 'A': 257 return TFTF.clone(); 258 case 'b':// fall through 259 case 'B': 260 return TFTT.clone(); 261 case 'c':// fall through 262 case 'C': 263 return TTFF.clone(); 264 case 'd':// fall through 265 case 'D': 266 return TTFT.clone(); 267 case 'e':// fall through 268 case 'E': 269 return TTTF.clone(); 270 case 'f':// fall through 271 case 'F': 272 return TTTT.clone(); 273 default: 274 throw new IllegalArgumentException("Cannot interpret '" + hexDigit + "' as a hexadecimal digit"); 275 } 276 } 277 278 /** 279 * <p> 280 * Converts binary (represented as boolean array) to a hexadecimal digit using the default 281 * (Lsb0) bit ordering. 282 * </p> 283 * <p> 284 * (1, 0, 0, 0) is converted as follow: '1' 285 * </p> 286 * 287 * @param src the binary to convert 288 * @return a hexadecimal digit representing the selected bits 289 * @throws IllegalArgumentException if {@code src} is empty 290 * @throws NullPointerException if {@code src} is {@code null} 291 */ 292 public static char binaryToHexDigit(final boolean[] src) { 293 return binaryToHexDigit(src, 0); 294 } 295 296 /** 297 * <p> 298 * Converts binary (represented as boolean array) to a hexadecimal digit using the default 299 * (Lsb0) bit ordering. 300 * </p> 301 * <p> 302 * (1, 0, 0, 0) is converted as follow: '1' 303 * </p> 304 * 305 * @param src the binary to convert 306 * @param srcPos the position of the lsb to start the conversion 307 * @return a hexadecimal digit representing the selected bits 308 * @throws IllegalArgumentException if {@code src} is empty 309 * @throws NullPointerException if {@code src} is {@code null} 310 */ 311 public static char binaryToHexDigit(final boolean[] src, final int srcPos) { 312 if (src.length == 0) { 313 throw new IllegalArgumentException("Cannot convert an empty array."); 314 } 315 if (src.length > srcPos + 3 && src[srcPos + 3]) { 316 if (src.length > srcPos + 2 && src[srcPos + 2]) { 317 if (src.length > srcPos + 1 && src[srcPos + 1]) { 318 return src[srcPos] ? 'f' : 'e'; 319 } 320 return src[srcPos] ? 'd' : 'c'; 321 } 322 if (src.length > srcPos + 1 && src[srcPos + 1]) { 323 return src[srcPos] ? 'b' : 'a'; 324 } 325 return src[srcPos] ? '9' : '8'; 326 } 327 if (src.length > srcPos + 2 && src[srcPos + 2]) { 328 if (src.length > srcPos + 1 && src[srcPos + 1]) { 329 return src[srcPos] ? '7' : '6'; 330 } 331 return src[srcPos] ? '5' : '4'; 332 } 333 if (src.length > srcPos + 1 && src[srcPos + 1]) { 334 return src[srcPos] ? '3' : '2'; 335 } 336 return src[srcPos] ? '1' : '0'; 337 } 338 339 /** 340 * <p> 341 * Converts binary (represented as boolean array) to a hexadecimal digit using the Msb0 bit 342 * ordering. 343 * </p> 344 * <p> 345 * (1, 0, 0, 0) is converted as follow: '8' 346 * </p> 347 * 348 * @param src the binary to convert 349 * @return a hexadecimal digit representing the selected bits 350 * @throws IllegalArgumentException if {@code src} is empty, {@code src.length < 4} or 351 * {@code src.length > 8} 352 * @throws NullPointerException if {@code src} is {@code null} 353 */ 354 public static char binaryToHexDigitMsb0_4bits(final boolean[] src) { 355 return binaryToHexDigitMsb0_4bits(src, 0); 356 } 357 358 /** 359 * <p> 360 * Converts binary (represented as boolean array) to a hexadecimal digit using the Msb0 bit 361 * ordering. 362 * </p> 363 * <p> 364 * (1, 0, 0, 0) is converted as follow: '8' (1,0,0,1,1,0,1,0) with srcPos = 3 is converted 365 * to 'D' 366 * </p> 367 * 368 * @param src the binary to convert 369 * @param srcPos the position of the lsb to start the conversion 370 * @return a hexadecimal digit representing the selected bits 371 * @throws IllegalArgumentException if {@code src} is empty, {@code src.length > 8} or 372 * {@code src.length - srcPos < 4} 373 * @throws NullPointerException if {@code src} is {@code null} 374 */ 375 public static char binaryToHexDigitMsb0_4bits(final boolean[] src, final int srcPos) { 376 if (src.length > 8) { 377 throw new IllegalArgumentException("src.length>8: src.length=" + src.length); 378 } 379 if (src.length - srcPos < 4) { 380 throw new IllegalArgumentException("src.length-srcPos<4: src.length=" + src.length + ", srcPos=" + srcPos); 381 } 382 if (src[srcPos + 3]) { 383 if (src[srcPos + 2]) { 384 if (src[srcPos + 1]) { 385 return src[srcPos] ? 'f' : '7'; 386 } 387 return src[srcPos] ? 'b' : '3'; 388 } 389 if (src[srcPos + 1]) { 390 return src[srcPos] ? 'd' : '5'; 391 } 392 return src[srcPos] ? '9' : '1'; 393 } 394 if (src[srcPos + 2]) { 395 if (src[srcPos + 1]) { 396 return src[srcPos] ? 'e' : '6'; 397 } 398 return src[srcPos] ? 'a' : '2'; 399 } 400 if (src[srcPos + 1]) { 401 return src[srcPos] ? 'c' : '4'; 402 } 403 return src[srcPos] ? '8' : '0'; 404 } 405 406 /** 407 * <p> 408 * Converts the first 4 bits of a binary (represented as boolean array) in big endian Msb0 409 * bit ordering to a hexadecimal digit. 410 * </p> 411 * <p> 412 * (1, 0, 0, 0) is converted as follow: '8' (1,0,0,0,0,0,0,0, 0,0,0,0,0,1,0,0) is converted 413 * to '4' 414 * </p> 415 * 416 * @param src the binary to convert 417 * @return a hexadecimal digit representing the selected bits 418 * @throws IllegalArgumentException if {@code src} is empty 419 * @throws NullPointerException if {@code src} is {@code null} 420 */ 421 public static char binaryBeMsb0ToHexDigit(final boolean[] src) { 422 return binaryBeMsb0ToHexDigit(src, 0); 423 } 424 425 /** 426 * <p> 427 * Converts a binary (represented as boolean array) in big endian Msb0 bit ordering to a 428 * hexadecimal digit. 429 * </p> 430 * <p> 431 * (1, 0, 0, 0) with srcPos = 0 is converted as follow: '8' (1,0,0,0,0,0,0,0, 432 * 0,0,0,1,0,1,0,0) with srcPos = 2 is converted to '5' 433 * </p> 434 * 435 * @param src the binary to convert 436 * @param srcPos the position of the lsb to start the conversion 437 * @return a hexadecimal digit representing the selected bits 438 * @throws IllegalArgumentException if {@code src} is empty 439 * @throws NullPointerException if {@code src} is {@code null} 440 */ 441 public static char binaryBeMsb0ToHexDigit(boolean[] src, int srcPos) { 442 if (src.length == 0) { 443 throw new IllegalArgumentException("Cannot convert an empty array."); 444 } 445 final int beSrcPos = src.length - 1 - srcPos; 446 final int srcLen = Math.min(4, beSrcPos + 1); 447 final boolean[] paddedSrc = new boolean[4]; 448 System.arraycopy(src, beSrcPos + 1 - srcLen, paddedSrc, 4 - srcLen, srcLen); 449 src = paddedSrc; 450 srcPos = 0; 451 if (src[srcPos]) { 452 if (src.length > srcPos + 1 && src[srcPos + 1]) { 453 if (src.length > srcPos + 2 && src[srcPos + 2]) { 454 return src.length > srcPos + 3 && src[srcPos + 3] ? 'f' : 'e'; 455 } 456 return src.length > srcPos + 3 && src[srcPos + 3] ? 'd' : 'c'; 457 } 458 if (src.length > srcPos + 2 && src[srcPos + 2]) { 459 return src.length > srcPos + 3 && src[srcPos + 3] ? 'b' : 'a'; 460 } 461 return src.length > srcPos + 3 && src[srcPos + 3] ? '9' : '8'; 462 } 463 if (src.length > srcPos + 1 && src[srcPos + 1]) { 464 if (src.length > srcPos + 2 && src[srcPos + 2]) { 465 return src.length > srcPos + 3 && src[srcPos + 3] ? '7' : '6'; 466 } 467 return src.length > srcPos + 3 && src[srcPos + 3] ? '5' : '4'; 468 } 469 if (src.length > srcPos + 2 && src[srcPos + 2]) { 470 return src.length > srcPos + 3 && src[srcPos + 3] ? '3' : '2'; 471 } 472 return src.length > srcPos + 3 && src[srcPos + 3] ? '1' : '0'; 473 } 474 475 /** 476 * <p> 477 * Converts the 4 lsb of an int to a hexadecimal digit. 478 * </p> 479 * <p> 480 * 0 returns '0' 481 * </p> 482 * <p> 483 * 1 returns '1' 484 * </p> 485 * <p> 486 * 10 returns 'A' and so on... 487 * </p> 488 * 489 * @param nibble the 4 bits to convert 490 * @return a hexadecimal digit representing the 4 lsb of {@code nibble} 491 * @throws IllegalArgumentException if {@code nibble < 0} or {@code nibble > 15} 492 */ 493 public static char intToHexDigit(final int nibble) { 494 final char c = Character.forDigit(nibble, 16); 495 if (c == Character.MIN_VALUE) { 496 throw new IllegalArgumentException("nibble value not between 0 and 15: " + nibble); 497 } 498 return c; 499 } 500 501 /** 502 * <p> 503 * Converts the 4 lsb of an int to a hexadecimal digit encoded using the Msb0 bit ordering. 504 * </p> 505 * <p> 506 * 0 returns '0' 507 * </p> 508 * <p> 509 * 1 returns '8' 510 * </p> 511 * <p> 512 * 10 returns '5' and so on... 513 * </p> 514 * 515 * @param nibble the 4 bits to convert 516 * @return a hexadecimal digit representing the 4 lsb of {@code nibble} 517 * @throws IllegalArgumentException if {@code nibble < 0} or {@code nibble > 15} 518 */ 519 public static char intToHexDigitMsb0(final int nibble) { 520 switch (nibble) { 521 case 0x0: 522 return '0'; 523 case 0x1: 524 return '8'; 525 case 0x2: 526 return '4'; 527 case 0x3: 528 return 'c'; 529 case 0x4: 530 return '2'; 531 case 0x5: 532 return 'a'; 533 case 0x6: 534 return '6'; 535 case 0x7: 536 return 'e'; 537 case 0x8: 538 return '1'; 539 case 0x9: 540 return '9'; 541 case 0xA: 542 return '5'; 543 case 0xB: 544 return 'd'; 545 case 0xC: 546 return '3'; 547 case 0xD: 548 return 'b'; 549 case 0xE: 550 return '7'; 551 case 0xF: 552 return 'f'; 553 default: 554 throw new IllegalArgumentException("nibble value not between 0 and 15: " + nibble); 555 } 556 } 557 558 /** 559 * <p> 560 * Converts an array of int into a long using the default (little endian, Lsb0) byte and bit 561 * ordering. 562 * </p> 563 * 564 * @param src the int array to convert 565 * @param srcPos the position in {@code src}, in int unit, from where to start the 566 * conversion 567 * @param dstInit initial value of the destination long 568 * @param dstPos the position of the lsb, in bits, in the result long 569 * @param nInts the number of ints to convert 570 * @return a long containing the selected bits 571 * @throws IllegalArgumentException if {@code (nInts-1)*32+dstPos >= 64} 572 * @throws NullPointerException if {@code src} is {@code null} 573 * @throws ArrayIndexOutOfBoundsException if {@code srcPos + nInts > src.length} 574 */ 575 public static long intArrayToLong(final int[] src, final int srcPos, final long dstInit, final int dstPos, 576 final int nInts) { 577 if (src.length == 0 && srcPos == 0 || 0 == nInts) { 578 return dstInit; 579 } 580 if ((nInts - 1) * 32 + dstPos >= 64) { 581 throw new IllegalArgumentException("(nInts-1)*32+dstPos is greather or equal to than 64"); 582 } 583 long out = dstInit; 584 for (int i = 0; i < nInts; i++) { 585 final int shift = i * 32 + dstPos; 586 final long bits = (0xffffffffL & src[i + srcPos]) << shift; 587 final long mask = 0xffffffffL << shift; 588 out = (out & ~mask) | bits; 589 } 590 return out; 591 } 592 593 /** 594 * <p> 595 * Converts an array of short into a long using the default (little endian, Lsb0) byte and 596 * bit ordering. 597 * </p> 598 * 599 * @param src the short array to convert 600 * @param srcPos the position in {@code src}, in short unit, from where to start the 601 * conversion 602 * @param dstInit initial value of the destination long 603 * @param dstPos the position of the lsb, in bits, in the result long 604 * @param nShorts the number of shorts to convert 605 * @return a long containing the selected bits 606 * @throws NullPointerException if {@code src} is {@code null} 607 * @throws IllegalArgumentException if {@code (nShorts-1)*16+dstPos >= 64} 608 * @throws ArrayIndexOutOfBoundsException if {@code srcPos + nShorts > src.length} 609 */ 610 public static long shortArrayToLong(final short[] src, final int srcPos, final long dstInit, final int dstPos, 611 final int nShorts) { 612 if (src.length == 0 && srcPos == 0 || 0 == nShorts) { 613 return dstInit; 614 } 615 if ((nShorts - 1) * 16 + dstPos >= 64) { 616 throw new IllegalArgumentException("(nShorts-1)*16+dstPos is greather or equal to than 64"); 617 } 618 long out = dstInit; 619 for (int i = 0; i < nShorts; i++) { 620 final int shift = i * 16 + dstPos; 621 final long bits = (0xffffL & src[i + srcPos]) << shift; 622 final long mask = 0xffffL << shift; 623 out = (out & ~mask) | bits; 624 } 625 return out; 626 } 627 628 /** 629 * <p> 630 * Converts an array of short into a int using the default (little endian, Lsb0) byte and 631 * bit ordering. 632 * </p> 633 * 634 * @param src the short array to convert 635 * @param srcPos the position in {@code src}, in short unit, from where to start the 636 * conversion 637 * @param dstInit initial value of the destination int 638 * @param dstPos the position of the lsb, in bits, in the result int 639 * @param nShorts the number of shorts to convert 640 * @return a int containing the selected bits 641 * @throws NullPointerException if {@code src} is {@code null} 642 * @throws IllegalArgumentException if {@code (nShorts-1)*16+dstPos >= 32} 643 * @throws ArrayIndexOutOfBoundsException if {@code srcPos + nShorts > src.length} 644 */ 645 public static int shortArrayToInt(final short[] src, final int srcPos, final int dstInit, final int dstPos, 646 final int nShorts) { 647 if (src.length == 0 && srcPos == 0 || 0 == nShorts) { 648 return dstInit; 649 } 650 if ((nShorts - 1) * 16 + dstPos >= 32) { 651 throw new IllegalArgumentException("(nShorts-1)*16+dstPos is greather or equal to than 32"); 652 } 653 int out = dstInit; 654 for (int i = 0; i < nShorts; i++) { 655 final int shift = i * 16 + dstPos; 656 final int bits = (0xffff & src[i + srcPos]) << shift; 657 final int mask = 0xffff << shift; 658 out = (out & ~mask) | bits; 659 } 660 return out; 661 } 662 663 /** 664 * <p> 665 * Converts an array of byte into a long using the default (little endian, Lsb0) byte and 666 * bit ordering. 667 * </p> 668 * 669 * @param src the byte array to convert 670 * @param srcPos the position in {@code src}, in byte unit, from where to start the 671 * conversion 672 * @param dstInit initial value of the destination long 673 * @param dstPos the position of the lsb, in bits, in the result long 674 * @param nBytes the number of bytes to convert 675 * @return a long containing the selected bits 676 * @throws NullPointerException if {@code src} is {@code null} 677 * @throws IllegalArgumentException if {@code (nBytes-1)*8+dstPos >= 64} 678 * @throws ArrayIndexOutOfBoundsException if {@code srcPos + nBytes > src.length} 679 */ 680 public static long byteArrayToLong(final byte[] src, final int srcPos, final long dstInit, final int dstPos, 681 final int nBytes) { 682 if (src.length == 0 && srcPos == 0 || 0 == nBytes) { 683 return dstInit; 684 } 685 if ((nBytes - 1) * 8 + dstPos >= 64) { 686 throw new IllegalArgumentException("(nBytes-1)*8+dstPos is greather or equal to than 64"); 687 } 688 long out = dstInit; 689 for (int i = 0; i < nBytes; i++) { 690 final int shift = i * 8 + dstPos; 691 final long bits = (0xffL & src[i + srcPos]) << shift; 692 final long mask = 0xffL << shift; 693 out = (out & ~mask) | bits; 694 } 695 return out; 696 } 697 698 /** 699 * <p> 700 * Converts an array of byte into a int using the default (little endian, Lsb0) byte and bit 701 * ordering. 702 * </p> 703 * 704 * @param src the byte array to convert 705 * @param srcPos the position in {@code src}, in byte unit, from where to start the 706 * conversion 707 * @param dstInit initial value of the destination int 708 * @param dstPos the position of the lsb, in bits, in the result int 709 * @param nBytes the number of bytes to convert 710 * @return a int containing the selected bits 711 * @throws NullPointerException if {@code src} is {@code null} 712 * @throws IllegalArgumentException if {@code (nBytes-1)*8+dstPos >= 32} 713 * @throws ArrayIndexOutOfBoundsException if {@code srcPos + nBytes > src.length} 714 */ 715 public static int byteArrayToInt(final byte[] src, final int srcPos, final int dstInit, final int dstPos, 716 final int nBytes) { 717 if (src.length == 0 && srcPos == 0 || 0 == nBytes) { 718 return dstInit; 719 } 720 if ((nBytes - 1) * 8 + dstPos >= 32) { 721 throw new IllegalArgumentException("(nBytes-1)*8+dstPos is greather or equal to than 32"); 722 } 723 int out = dstInit; 724 for (int i = 0; i < nBytes; i++) { 725 final int shift = i * 8 + dstPos; 726 final int bits = (0xff & src[i + srcPos]) << shift; 727 final int mask = 0xff << shift; 728 out = (out & ~mask) | bits; 729 } 730 return out; 731 } 732 733 /** 734 * <p> 735 * Converts an array of byte into a short using the default (little endian, Lsb0) byte and 736 * bit ordering. 737 * </p> 738 * 739 * @param src the byte array to convert 740 * @param srcPos the position in {@code src}, in byte unit, from where to start the 741 * conversion 742 * @param dstInit initial value of the destination short 743 * @param dstPos the position of the lsb, in bits, in the result short 744 * @param nBytes the number of bytes to convert 745 * @return a short containing the selected bits 746 * @throws NullPointerException if {@code src} is {@code null} 747 * @throws IllegalArgumentException if {@code (nBytes-1)*8+dstPos >= 16} 748 * @throws ArrayIndexOutOfBoundsException if {@code srcPos + nBytes > src.length} 749 */ 750 public static short byteArrayToShort(final byte[] src, final int srcPos, final short dstInit, final int dstPos, 751 final int nBytes) { 752 if (src.length == 0 && srcPos == 0 || 0 == nBytes) { 753 return dstInit; 754 } 755 if ((nBytes - 1) * 8 + dstPos >= 16) { 756 throw new IllegalArgumentException("(nBytes-1)*8+dstPos is greather or equal to than 16"); 757 } 758 short out = dstInit; 759 for (int i = 0; i < nBytes; i++) { 760 final int shift = i * 8 + dstPos; 761 final int bits = (0xff & src[i + srcPos]) << shift; 762 final int mask = 0xff << shift; 763 out = (short) ((out & ~mask) | bits); 764 } 765 return out; 766 } 767 768 /** 769 * <p> 770 * Converts an array of Char into a long using the default (little endian, Lsb0) byte and 771 * bit ordering. 772 * </p> 773 * 774 * @param src the hex string to convert 775 * @param srcPos the position in {@code src}, in Char unit, from where to start the 776 * conversion 777 * @param dstInit initial value of the destination long 778 * @param dstPos the position of the lsb, in bits, in the result long 779 * @param nHex the number of Chars to convert 780 * @return a long containing the selected bits 781 * @throws IllegalArgumentException if {@code (nHexs-1)*4+dstPos >= 64} 782 */ 783 public static long hexToLong(final String src, final int srcPos, final long dstInit, final int dstPos, 784 final int nHex) { 785 if (0 == nHex) { 786 return dstInit; 787 } 788 if ((nHex - 1) * 4 + dstPos >= 64) { 789 throw new IllegalArgumentException("(nHexs-1)*4+dstPos is greather or equal to than 64"); 790 } 791 long out = dstInit; 792 for (int i = 0; i < nHex; i++) { 793 final int shift = i * 4 + dstPos; 794 final long bits = (0xfL & hexDigitToInt(src.charAt(i + srcPos))) << shift; 795 final long mask = 0xfL << shift; 796 out = (out & ~mask) | bits; 797 } 798 return out; 799 } 800 801 /** 802 * <p> 803 * Converts an array of Char into a int using the default (little endian, Lsb0) byte and bit 804 * ordering. 805 * </p> 806 * 807 * @param src the hex string to convert 808 * @param srcPos the position in {@code src}, in Char unit, from where to start the 809 * conversion 810 * @param dstInit initial value of the destination int 811 * @param dstPos the position of the lsb, in bits, in the result int 812 * @param nHex the number of Chars to convert 813 * @return a int containing the selected bits 814 * @throws IllegalArgumentException if {@code (nHexs-1)*4+dstPos >= 32} 815 */ 816 public static int hexToInt(final String src, final int srcPos, final int dstInit, final int dstPos, final int nHex) { 817 if (0 == nHex) { 818 return dstInit; 819 } 820 if ((nHex - 1) * 4 + dstPos >= 32) { 821 throw new IllegalArgumentException("(nHexs-1)*4+dstPos is greather or equal to than 32"); 822 } 823 int out = dstInit; 824 for (int i = 0; i < nHex; i++) { 825 final int shift = i * 4 + dstPos; 826 final int bits = (0xf & hexDigitToInt(src.charAt(i + srcPos))) << shift; 827 final int mask = 0xf << shift; 828 out = (out & ~mask) | bits; 829 } 830 return out; 831 } 832 833 /** 834 * <p> 835 * Converts an array of Char into a short using the default (little endian, Lsb0) byte and 836 * bit ordering. 837 * </p> 838 * 839 * @param src the hex string to convert 840 * @param srcPos the position in {@code src}, in Char unit, from where to start the 841 * conversion 842 * @param dstInit initial value of the destination short 843 * @param dstPos the position of the lsb, in bits, in the result short 844 * @param nHex the number of Chars to convert 845 * @return a short containing the selected bits 846 * @throws IllegalArgumentException if {@code (nHexs-1)*4+dstPos >= 16} 847 */ 848 public static short hexToShort(final String src, final int srcPos, final short dstInit, final int dstPos, 849 final int nHex) { 850 if (0 == nHex) { 851 return dstInit; 852 } 853 if ((nHex - 1) * 4 + dstPos >= 16) { 854 throw new IllegalArgumentException("(nHexs-1)*4+dstPos is greather or equal to than 16"); 855 } 856 short out = dstInit; 857 for (int i = 0; i < nHex; i++) { 858 final int shift = i * 4 + dstPos; 859 final int bits = (0xf & hexDigitToInt(src.charAt(i + srcPos))) << shift; 860 final int mask = 0xf << shift; 861 out = (short) ((out & ~mask) | bits); 862 } 863 return out; 864 } 865 866 /** 867 * <p> 868 * Converts an array of Char into a byte using the default (little endian, Lsb0) byte and 869 * bit ordering. 870 * </p> 871 * 872 * @param src the hex string to convert 873 * @param srcPos the position in {@code src}, in Char unit, from where to start the 874 * conversion 875 * @param dstInit initial value of the destination byte 876 * @param dstPos the position of the lsb, in bits, in the result byte 877 * @param nHex the number of Chars to convert 878 * @return a byte containing the selected bits 879 * @throws IllegalArgumentException if {@code (nHexs-1)*4+dstPos >= 8} 880 */ 881 public static byte hexToByte(final String src, final int srcPos, final byte dstInit, final int dstPos, 882 final int nHex) { 883 if (0 == nHex) { 884 return dstInit; 885 } 886 if ((nHex - 1) * 4 + dstPos >= 8) { 887 throw new IllegalArgumentException("(nHexs-1)*4+dstPos is greather or equal to than 8"); 888 } 889 byte out = dstInit; 890 for (int i = 0; i < nHex; i++) { 891 final int shift = i * 4 + dstPos; 892 final int bits = (0xf & hexDigitToInt(src.charAt(i + srcPos))) << shift; 893 final int mask = 0xf << shift; 894 out = (byte) ((out & ~mask) | bits); 895 } 896 return out; 897 } 898 899 /** 900 * <p> 901 * Converts binary (represented as boolean array) into a long using the default (little 902 * endian, Lsb0) byte and bit ordering. 903 * </p> 904 * 905 * @param src the binary to convert 906 * @param srcPos the position in {@code src}, in boolean unit, from where to start the 907 * conversion 908 * @param dstInit initial value of the destination long 909 * @param dstPos the position of the lsb, in bits, in the result long 910 * @param nBools the number of booleans to convert 911 * @return a long containing the selected bits 912 * @throws NullPointerException if {@code src} is {@code null} 913 * @throws IllegalArgumentException if {@code nBools-1+dstPos >= 64} 914 * @throws ArrayIndexOutOfBoundsException if {@code srcPos + nBools > src.length} 915 */ 916 public static long binaryToLong(final boolean[] src, final int srcPos, final long dstInit, final int dstPos, 917 final int nBools) { 918 if (src.length == 0 && srcPos == 0 || 0 == nBools) { 919 return dstInit; 920 } 921 if (nBools - 1 + dstPos >= 64) { 922 throw new IllegalArgumentException("nBools-1+dstPos is greather or equal to than 64"); 923 } 924 long out = dstInit; 925 for (int i = 0; i < nBools; i++) { 926 final int shift = i + dstPos; 927 final long bits = (src[i + srcPos] ? 1L : 0) << shift; 928 final long mask = 0x1L << shift; 929 out = (out & ~mask) | bits; 930 } 931 return out; 932 } 933 934 /** 935 * <p> 936 * Converts binary (represented as boolean array) into a int using the default (little 937 * endian, Lsb0) byte and bit ordering. 938 * </p> 939 * 940 * @param src the binary to convert 941 * @param srcPos the position in {@code src}, in boolean unit, from where to start the 942 * conversion 943 * @param dstInit initial value of the destination int 944 * @param dstPos the position of the lsb, in bits, in the result int 945 * @param nBools the number of booleans to convert 946 * @return a int containing the selected bits 947 * @throws NullPointerException if {@code src} is {@code null} 948 * @throws IllegalArgumentException if {@code nBools-1+dstPos >= 32} 949 * @throws ArrayIndexOutOfBoundsException if {@code srcPos + nBools > src.length} 950 */ 951 public static int binaryToInt(final boolean[] src, final int srcPos, final int dstInit, final int dstPos, 952 final int nBools) { 953 if (src.length == 0 && srcPos == 0 || 0 == nBools) { 954 return dstInit; 955 } 956 if (nBools - 1 + dstPos >= 32) { 957 throw new IllegalArgumentException("nBools-1+dstPos is greather or equal to than 32"); 958 } 959 int out = dstInit; 960 for (int i = 0; i < nBools; i++) { 961 final int shift = i + dstPos; 962 final int bits = (src[i + srcPos] ? 1 : 0) << shift; 963 final int mask = 0x1 << shift; 964 out = (out & ~mask) | bits; 965 } 966 return out; 967 } 968 969 /** 970 * <p> 971 * Converts binary (represented as boolean array) into a short using the default (little 972 * endian, Lsb0) byte and bit ordering. 973 * </p> 974 * 975 * @param src the binary to convert 976 * @param srcPos the position in {@code src}, in boolean unit, from where to start the 977 * conversion 978 * @param dstInit initial value of the destination short 979 * @param dstPos the position of the lsb, in bits, in the result short 980 * @param nBools the number of booleans to convert 981 * @return a short containing the selected bits 982 * @throws NullPointerException if {@code src} is {@code null} 983 * @throws IllegalArgumentException if {@code nBools-1+dstPos >= 16} 984 * @throws ArrayIndexOutOfBoundsException if {@code srcPos + nBools > src.length} 985 */ 986 public static short binaryToShort(final boolean[] src, final int srcPos, final short dstInit, final int dstPos, 987 final int nBools) { 988 if (src.length == 0 && srcPos == 0 || 0 == nBools) { 989 return dstInit; 990 } 991 if (nBools - 1 + dstPos >= 16) { 992 throw new IllegalArgumentException("nBools-1+dstPos is greather or equal to than 16"); 993 } 994 short out = dstInit; 995 for (int i = 0; i < nBools; i++) { 996 final int shift = i + dstPos; 997 final int bits = (src[i + srcPos] ? 1 : 0) << shift; 998 final int mask = 0x1 << shift; 999 out = (short) ((out & ~mask) | bits); 1000 } 1001 return out; 1002 } 1003 1004 /** 1005 * <p> 1006 * Converts binary (represented as boolean array) into a byte using the default (little 1007 * endian, Lsb0) byte and bit ordering. 1008 * </p> 1009 * 1010 * @param src the binary to convert 1011 * @param srcPos the position in {@code src}, in boolean unit, from where to start the 1012 * conversion 1013 * @param dstInit initial value of the destination byte 1014 * @param dstPos the position of the lsb, in bits, in the result byte 1015 * @param nBools the number of booleans to convert 1016 * @return a byte containing the selected bits 1017 * @throws NullPointerException if {@code src} is {@code null} 1018 * @throws IllegalArgumentException if {@code nBools-1+dstPos >= 8} 1019 * @throws ArrayIndexOutOfBoundsException if {@code srcPos + nBools > src.length} 1020 */ 1021 public static byte binaryToByte(final boolean[] src, final int srcPos, final byte dstInit, final int dstPos, 1022 final int nBools) { 1023 if (src.length == 0 && srcPos == 0 || 0 == nBools) { 1024 return dstInit; 1025 } 1026 if (nBools - 1 + dstPos >= 8) { 1027 throw new IllegalArgumentException("nBools-1+dstPos is greather or equal to than 8"); 1028 } 1029 byte out = dstInit; 1030 for (int i = 0; i < nBools; i++) { 1031 final int shift = i + dstPos; 1032 final int bits = (src[i + srcPos] ? 1 : 0) << shift; 1033 final int mask = 0x1 << shift; 1034 out = (byte) ((out & ~mask) | bits); 1035 } 1036 return out; 1037 } 1038 1039 /** 1040 * <p> 1041 * Converts a long into an array of int using the default (little endian, Lsb0) byte and bit 1042 * ordering. 1043 * </p> 1044 * 1045 * @param src the long to convert 1046 * @param srcPos the position in {@code src}, in bits, from where to start the conversion 1047 * @param dst the destination array 1048 * @param dstPos the position in {@code dst} where to copy the result 1049 * @param nInts the number of ints to copy to {@code dst}, must be smaller or equal to the 1050 * width of the input (from srcPos to msb) 1051 * @return {@code dst} 1052 * @throws NullPointerException if {@code dst} is {@code null} and {@code nInts > 0} 1053 * @throws IllegalArgumentException if {@code (nInts-1)*32+srcPos >= 64} 1054 * @throws ArrayIndexOutOfBoundsException if {@code dstPos + nInts > dst.length} 1055 */ 1056 public static int[] longToIntArray(final long src, final int srcPos, final int[] dst, final int dstPos, 1057 final int nInts) { 1058 if (0 == nInts) { 1059 return dst; 1060 } 1061 if ((nInts - 1) * 32 + srcPos >= 64) { 1062 throw new IllegalArgumentException("(nInts-1)*32+srcPos is greather or equal to than 64"); 1063 } 1064 for (int i = 0; i < nInts; i++) { 1065 final int shift = i * 32 + srcPos; 1066 dst[dstPos + i] = (int) (0xffffffff & (src >> shift)); 1067 } 1068 return dst; 1069 } 1070 1071 /** 1072 * <p> 1073 * Converts a long into an array of short using the default (little endian, Lsb0) byte and 1074 * bit ordering. 1075 * </p> 1076 * 1077 * @param src the long to convert 1078 * @param srcPos the position in {@code src}, in bits, from where to start the conversion 1079 * @param dst the destination array 1080 * @param dstPos the position in {@code dst} where to copy the result 1081 * @param nShorts the number of shorts to copy to {@code dst}, must be smaller or equal to 1082 * the width of the input (from srcPos to msb) 1083 * @return {@code dst} 1084 * @throws NullPointerException if {@code dst} is {@code null} 1085 * @throws IllegalArgumentException if {@code (nShorts-1)*16+srcPos >= 64} 1086 * @throws ArrayIndexOutOfBoundsException if {@code dstPos + nShorts > dst.length} 1087 */ 1088 public static short[] longToShortArray(final long src, final int srcPos, final short[] dst, final int dstPos, 1089 final int nShorts) { 1090 if (0 == nShorts) { 1091 return dst; 1092 } 1093 if ((nShorts - 1) * 16 + srcPos >= 64) { 1094 throw new IllegalArgumentException("(nShorts-1)*16+srcPos is greather or equal to than 64"); 1095 } 1096 for (int i = 0; i < nShorts; i++) { 1097 final int shift = i * 16 + srcPos; 1098 dst[dstPos + i] = (short) (0xffff & (src >> shift)); 1099 } 1100 return dst; 1101 } 1102 1103 /** 1104 * <p> 1105 * Converts a int into an array of short using the default (little endian, Lsb0) byte and 1106 * bit ordering. 1107 * </p> 1108 * 1109 * @param src the int to convert 1110 * @param srcPos the position in {@code src}, in bits, from where to start the conversion 1111 * @param dst the destination array 1112 * @param dstPos the position in {@code dst} where to copy the result 1113 * @param nShorts the number of shorts to copy to {@code dst}, must be smaller or equal to 1114 * the width of the input (from srcPos to msb) 1115 * @return {@code dst} 1116 * @throws NullPointerException if {@code dst} is {@code null} 1117 * @throws IllegalArgumentException if {@code (nShorts-1)*16+srcPos >= 32} 1118 * @throws ArrayIndexOutOfBoundsException if {@code dstPos + nShorts > dst.length} 1119 */ 1120 public static short[] intToShortArray(final int src, final int srcPos, final short[] dst, final int dstPos, 1121 final int nShorts) { 1122 if (0 == nShorts) { 1123 return dst; 1124 } 1125 if ((nShorts - 1) * 16 + srcPos >= 32) { 1126 throw new IllegalArgumentException("(nShorts-1)*16+srcPos is greather or equal to than 32"); 1127 } 1128 for (int i = 0; i < nShorts; i++) { 1129 final int shift = i * 16 + srcPos; 1130 dst[dstPos + i] = (short) (0xffff & (src >> shift)); 1131 } 1132 return dst; 1133 } 1134 1135 /** 1136 * <p> 1137 * Converts a long into an array of byte using the default (little endian, Lsb0) byte and 1138 * bit ordering. 1139 * </p> 1140 * 1141 * @param src the long to convert 1142 * @param srcPos the position in {@code src}, in bits, from where to start the conversion 1143 * @param dst the destination array 1144 * @param dstPos the position in {@code dst} where to copy the result 1145 * @param nBytes the number of bytes to copy to {@code dst}, must be smaller or equal to the 1146 * width of the input (from srcPos to msb) 1147 * @return {@code dst} 1148 * @throws NullPointerException if {@code dst} is {@code null} 1149 * @throws IllegalArgumentException if {@code (nBytes-1)*8+srcPos >= 64} 1150 * @throws ArrayIndexOutOfBoundsException if {@code dstPos + nBytes > dst.length} 1151 */ 1152 public static byte[] longToByteArray(final long src, final int srcPos, final byte[] dst, final int dstPos, 1153 final int nBytes) { 1154 if (0 == nBytes) { 1155 return dst; 1156 } 1157 if ((nBytes - 1) * 8 + srcPos >= 64) { 1158 throw new IllegalArgumentException("(nBytes-1)*8+srcPos is greather or equal to than 64"); 1159 } 1160 for (int i = 0; i < nBytes; i++) { 1161 final int shift = i * 8 + srcPos; 1162 dst[dstPos + i] = (byte) (0xff & (src >> shift)); 1163 } 1164 return dst; 1165 } 1166 1167 /** 1168 * <p> 1169 * Converts a int into an array of byte using the default (little endian, Lsb0) byte and bit 1170 * ordering. 1171 * </p> 1172 * 1173 * @param src the int to convert 1174 * @param srcPos the position in {@code src}, in bits, from where to start the conversion 1175 * @param dst the destination array 1176 * @param dstPos the position in {@code dst} where to copy the result 1177 * @param nBytes the number of bytes to copy to {@code dst}, must be smaller or equal to the 1178 * width of the input (from srcPos to msb) 1179 * @return {@code dst} 1180 * @throws NullPointerException if {@code dst} is {@code null} 1181 * @throws IllegalArgumentException if {@code (nBytes-1)*8+srcPos >= 32} 1182 * @throws ArrayIndexOutOfBoundsException if {@code dstPos + nBytes > dst.length} 1183 */ 1184 public static byte[] intToByteArray(final int src, final int srcPos, final byte[] dst, final int dstPos, 1185 final int nBytes) { 1186 if (0 == nBytes) { 1187 return dst; 1188 } 1189 if ((nBytes - 1) * 8 + srcPos >= 32) { 1190 throw new IllegalArgumentException("(nBytes-1)*8+srcPos is greather or equal to than 32"); 1191 } 1192 for (int i = 0; i < nBytes; i++) { 1193 final int shift = i * 8 + srcPos; 1194 dst[dstPos + i] = (byte) (0xff & (src >> shift)); 1195 } 1196 return dst; 1197 } 1198 1199 /** 1200 * <p> 1201 * Converts a short into an array of byte using the default (little endian, Lsb0) byte and 1202 * bit ordering. 1203 * </p> 1204 * 1205 * @param src the short to convert 1206 * @param srcPos the position in {@code src}, in bits, from where to start the conversion 1207 * @param dst the destination array 1208 * @param dstPos the position in {@code dst} where to copy the result 1209 * @param nBytes the number of bytes to copy to {@code dst}, must be smaller or equal to the 1210 * width of the input (from srcPos to msb) 1211 * @return {@code dst} 1212 * @throws NullPointerException if {@code dst} is {@code null} 1213 * @throws IllegalArgumentException if {@code (nBytes-1)*8+srcPos >= 16} 1214 * @throws ArrayIndexOutOfBoundsException if {@code dstPos + nBytes > dst.length} 1215 */ 1216 public static byte[] shortToByteArray(final short src, final int srcPos, final byte[] dst, final int dstPos, 1217 final int nBytes) { 1218 if (0 == nBytes) { 1219 return dst; 1220 } 1221 if ((nBytes - 1) * 8 + srcPos >= 16) { 1222 throw new IllegalArgumentException("(nBytes-1)*8+srcPos is greather or equal to than 16"); 1223 } 1224 for (int i = 0; i < nBytes; i++) { 1225 final int shift = i * 8 + srcPos; 1226 dst[dstPos + i] = (byte) (0xff & (src >> shift)); 1227 } 1228 return dst; 1229 } 1230 1231 /** 1232 * <p> 1233 * Converts a long into an array of Char using the default (little endian, Lsb0) byte and 1234 * bit ordering. 1235 * </p> 1236 * 1237 * @param src the long to convert 1238 * @param srcPos the position in {@code src}, in bits, from where to start the conversion 1239 * @param dstInit the initial value for the result String 1240 * @param dstPos the position in {@code dst} where to copy the result 1241 * @param nHexs the number of Chars to copy to {@code dst}, must be smaller or equal to the 1242 * width of the input (from srcPos to msb) 1243 * @return {@code dst} 1244 * @throws IllegalArgumentException if {@code (nHexs-1)*4+srcPos >= 64} 1245 * @throws StringIndexOutOfBoundsException if {@code dst.init.length() < dstPos} 1246 */ 1247 public static String longToHex(final long src, final int srcPos, final String dstInit, final int dstPos, 1248 final int nHexs) { 1249 if (0 == nHexs) { 1250 return dstInit; 1251 } 1252 if ((nHexs - 1) * 4 + srcPos >= 64) { 1253 throw new IllegalArgumentException("(nHexs-1)*4+srcPos is greather or equal to than 64"); 1254 } 1255 final StringBuilder sb = new StringBuilder(dstInit); 1256 int append = sb.length(); 1257 for (int i = 0; i < nHexs; i++) { 1258 final int shift = i * 4 + srcPos; 1259 final int bits = (int) (0xF & (src >> shift)); 1260 if (dstPos + i == append) { 1261 ++append; 1262 sb.append(intToHexDigit(bits)); 1263 } else { 1264 sb.setCharAt(dstPos + i, intToHexDigit(bits)); 1265 } 1266 } 1267 return sb.toString(); 1268 } 1269 1270 /** 1271 * <p> 1272 * Converts a int into an array of Char using the default (little endian, Lsb0) byte and bit 1273 * ordering. 1274 * </p> 1275 * 1276 * @param src the int to convert 1277 * @param srcPos the position in {@code src}, in bits, from where to start the conversion 1278 * @param dstInit the initial value for the result String 1279 * @param dstPos the position in {@code dst} where to copy the result 1280 * @param nHexs the number of Chars to copy to {@code dst}, must be smaller or equal to the 1281 * width of the input (from srcPos to msb) 1282 * @return {@code dst} 1283 * @throws IllegalArgumentException if {@code (nHexs-1)*4+srcPos >= 32} 1284 * @throws StringIndexOutOfBoundsException if {@code dst.init.length() < dstPos} 1285 */ 1286 public static String intToHex(final int src, final int srcPos, final String dstInit, final int dstPos, 1287 final int nHexs) { 1288 if (0 == nHexs) { 1289 return dstInit; 1290 } 1291 if ((nHexs - 1) * 4 + srcPos >= 32) { 1292 throw new IllegalArgumentException("(nHexs-1)*4+srcPos is greather or equal to than 32"); 1293 } 1294 final StringBuilder sb = new StringBuilder(dstInit); 1295 int append = sb.length(); 1296 for (int i = 0; i < nHexs; i++) { 1297 final int shift = i * 4 + srcPos; 1298 final int bits = 0xF & (src >> shift); 1299 if (dstPos + i == append) { 1300 ++append; 1301 sb.append(intToHexDigit(bits)); 1302 } else { 1303 sb.setCharAt(dstPos + i, intToHexDigit(bits)); 1304 } 1305 } 1306 return sb.toString(); 1307 } 1308 1309 /** 1310 * <p> 1311 * Converts a short into an array of Char using the default (little endian, Lsb0) byte and 1312 * bit ordering. 1313 * </p> 1314 * 1315 * @param src the short to convert 1316 * @param srcPos the position in {@code src}, in bits, from where to start the conversion 1317 * @param dstInit the initial value for the result String 1318 * @param dstPos the position in {@code dst} where to copy the result 1319 * @param nHexs the number of Chars to copy to {@code dst}, must be smaller or equal to the 1320 * width of the input (from srcPos to msb) 1321 * @return {@code dst} 1322 * @throws IllegalArgumentException if {@code (nHexs-1)*4+srcPos >= 16} 1323 * @throws StringIndexOutOfBoundsException if {@code dst.init.length() < dstPos} 1324 */ 1325 public static String shortToHex(final short src, final int srcPos, final String dstInit, final int dstPos, 1326 final int nHexs) { 1327 if (0 == nHexs) { 1328 return dstInit; 1329 } 1330 if ((nHexs - 1) * 4 + srcPos >= 16) { 1331 throw new IllegalArgumentException("(nHexs-1)*4+srcPos is greather or equal to than 16"); 1332 } 1333 final StringBuilder sb = new StringBuilder(dstInit); 1334 int append = sb.length(); 1335 for (int i = 0; i < nHexs; i++) { 1336 final int shift = i * 4 + srcPos; 1337 final int bits = 0xF & (src >> shift); 1338 if (dstPos + i == append) { 1339 ++append; 1340 sb.append(intToHexDigit(bits)); 1341 } else { 1342 sb.setCharAt(dstPos + i, intToHexDigit(bits)); 1343 } 1344 } 1345 return sb.toString(); 1346 } 1347 1348 /** 1349 * <p> 1350 * Converts a byte into an array of Char using the default (little endian, Lsb0) byte and 1351 * bit ordering. 1352 * </p> 1353 * 1354 * @param src the byte to convert 1355 * @param srcPos the position in {@code src}, in bits, from where to start the conversion 1356 * @param dstInit the initial value for the result String 1357 * @param dstPos the position in {@code dst} where to copy the result 1358 * @param nHexs the number of Chars to copy to {@code dst}, must be smaller or equal to the 1359 * width of the input (from srcPos to msb) 1360 * @return {@code dst} 1361 * @throws IllegalArgumentException if {@code (nHexs-1)*4+srcPos >= 8} 1362 * @throws StringIndexOutOfBoundsException if {@code dst.init.length() < dstPos} 1363 */ 1364 public static String byteToHex(final byte src, final int srcPos, final String dstInit, final int dstPos, 1365 final int nHexs) { 1366 if (0 == nHexs) { 1367 return dstInit; 1368 } 1369 if ((nHexs - 1) * 4 + srcPos >= 8) { 1370 throw new IllegalArgumentException("(nHexs-1)*4+srcPos is greather or equal to than 8"); 1371 } 1372 final StringBuilder sb = new StringBuilder(dstInit); 1373 int append = sb.length(); 1374 for (int i = 0; i < nHexs; i++) { 1375 final int shift = i * 4 + srcPos; 1376 final int bits = 0xF & (src >> shift); 1377 if (dstPos + i == append) { 1378 ++append; 1379 sb.append(intToHexDigit(bits)); 1380 } else { 1381 sb.setCharAt(dstPos + i, intToHexDigit(bits)); 1382 } 1383 } 1384 return sb.toString(); 1385 } 1386 1387 /** 1388 * <p> 1389 * Converts a long into an array of boolean using the default (little endian, Lsb0) byte and 1390 * bit ordering. 1391 * </p> 1392 * 1393 * @param src the long to convert 1394 * @param srcPos the position in {@code src}, in bits, from where to start the conversion 1395 * @param dst the destination array 1396 * @param dstPos the position in {@code dst} where to copy the result 1397 * @param nBools the number of booleans to copy to {@code dst}, must be smaller or equal to 1398 * the width of the input (from srcPos to msb) 1399 * @return {@code dst} 1400 * @throws NullPointerException if {@code dst} is {@code null} 1401 * @throws IllegalArgumentException if {@code nBools-1+srcPos >= 64} 1402 * @throws ArrayIndexOutOfBoundsException if {@code dstPos + nBools > dst.length} 1403 */ 1404 public static boolean[] longToBinary(final long src, final int srcPos, final boolean[] dst, final int dstPos, 1405 final int nBools) { 1406 if (0 == nBools) { 1407 return dst; 1408 } 1409 if (nBools - 1 + srcPos >= 64) { 1410 throw new IllegalArgumentException("nBools-1+srcPos is greather or equal to than 64"); 1411 } 1412 for (int i = 0; i < nBools; i++) { 1413 final int shift = i + srcPos; 1414 dst[dstPos + i] = (0x1 & (src >> shift)) != 0; 1415 } 1416 return dst; 1417 } 1418 1419 /** 1420 * <p> 1421 * Converts a int into an array of boolean using the default (little endian, Lsb0) byte and 1422 * bit ordering. 1423 * </p> 1424 * 1425 * @param src the int to convert 1426 * @param srcPos the position in {@code src}, in bits, from where to start the conversion 1427 * @param dst the destination array 1428 * @param dstPos the position in {@code dst} where to copy the result 1429 * @param nBools the number of booleans to copy to {@code dst}, must be smaller or equal to 1430 * the width of the input (from srcPos to msb) 1431 * @return {@code dst} 1432 * @throws NullPointerException if {@code dst} is {@code null} 1433 * @throws IllegalArgumentException if {@code nBools-1+srcPos >= 32} 1434 * @throws ArrayIndexOutOfBoundsException if {@code dstPos + nBools > dst.length} 1435 */ 1436 public static boolean[] intToBinary(final int src, final int srcPos, final boolean[] dst, final int dstPos, 1437 final int nBools) { 1438 if (0 == nBools) { 1439 return dst; 1440 } 1441 if (nBools - 1 + srcPos >= 32) { 1442 throw new IllegalArgumentException("nBools-1+srcPos is greather or equal to than 32"); 1443 } 1444 for (int i = 0; i < nBools; i++) { 1445 final int shift = i + srcPos; 1446 dst[dstPos + i] = (0x1 & (src >> shift)) != 0; 1447 } 1448 return dst; 1449 } 1450 1451 /** 1452 * <p> 1453 * Converts a short into an array of boolean using the default (little endian, Lsb0) byte 1454 * and bit ordering. 1455 * </p> 1456 * 1457 * @param src the short to convert 1458 * @param srcPos the position in {@code src}, in bits, from where to start the conversion 1459 * @param dst the destination array 1460 * @param dstPos the position in {@code dst} where to copy the result 1461 * @param nBools the number of booleans to copy to {@code dst}, must be smaller or equal to 1462 * the width of the input (from srcPos to msb) 1463 * @return {@code dst} 1464 * @throws NullPointerException if {@code dst} is {@code null} 1465 * @throws IllegalArgumentException if {@code nBools-1+srcPos >= 16} 1466 * @throws ArrayIndexOutOfBoundsException if {@code dstPos + nBools > dst.length} 1467 */ 1468 public static boolean[] shortToBinary(final short src, final int srcPos, final boolean[] dst, final int dstPos, 1469 final int nBools) { 1470 if (0 == nBools) { 1471 return dst; 1472 } 1473 if (nBools - 1 + srcPos >= 16) { 1474 throw new IllegalArgumentException("nBools-1+srcPos is greather or equal to than 16"); 1475 } 1476 assert (nBools - 1) < 16 - srcPos; 1477 for (int i = 0; i < nBools; i++) { 1478 final int shift = i + srcPos; 1479 dst[dstPos + i] = (0x1 & (src >> shift)) != 0; 1480 } 1481 return dst; 1482 } 1483 1484 /** 1485 * <p> 1486 * Converts a byte into an array of boolean using the default (little endian, Lsb0) byte and 1487 * bit ordering. 1488 * </p> 1489 * 1490 * @param src the byte to convert 1491 * @param srcPos the position in {@code src}, in bits, from where to start the conversion 1492 * @param dst the destination array 1493 * @param dstPos the position in {@code dst} where to copy the result 1494 * @param nBools the number of booleans to copy to {@code dst}, must be smaller or equal to 1495 * the width of the input (from srcPos to msb) 1496 * @return {@code dst} 1497 * @throws NullPointerException if {@code dst} is {@code null} 1498 * @throws IllegalArgumentException if {@code nBools-1+srcPos >= 8} 1499 * @throws ArrayIndexOutOfBoundsException if {@code dstPos + nBools > dst.length} 1500 */ 1501 public static boolean[] byteToBinary(final byte src, final int srcPos, final boolean[] dst, final int dstPos, 1502 final int nBools) { 1503 if (0 == nBools) { 1504 return dst; 1505 } 1506 if (nBools - 1 + srcPos >= 8) { 1507 throw new IllegalArgumentException("nBools-1+srcPos is greather or equal to than 8"); 1508 } 1509 for (int i = 0; i < nBools; i++) { 1510 final int shift = i + srcPos; 1511 dst[dstPos + i] = (0x1 & (src >> shift)) != 0; 1512 } 1513 return dst; 1514 } 1515 1516 /** 1517 * <p> 1518 * Converts UUID into an array of byte using the default (little endian, Lsb0) byte and bit 1519 * ordering. 1520 * </p> 1521 * 1522 * @param src the UUID to convert 1523 * @param dst the destination array 1524 * @param dstPos the position in {@code dst} where to copy the result 1525 * @param nBytes the number of bytes to copy to {@code dst}, must be smaller or equal to the 1526 * width of the input (from srcPos to msb) 1527 * @return {@code dst} 1528 * @throws NullPointerException if {@code dst} is {@code null} 1529 * @throws IllegalArgumentException if {@code nBytes > 16} 1530 * @throws ArrayIndexOutOfBoundsException if {@code dstPos + nBytes > dst.length} 1531 */ 1532 public static byte[] uuidToByteArray(final UUID src, final byte[] dst, final int dstPos, final int nBytes) { 1533 if (0 == nBytes) { 1534 return dst; 1535 } 1536 if (nBytes > 16) { 1537 throw new IllegalArgumentException("nBytes is greather than 16"); 1538 } 1539 longToByteArray(src.getMostSignificantBits(), 0, dst, dstPos, nBytes > 8 ? 8 : nBytes); 1540 if (nBytes >= 8) { 1541 longToByteArray(src.getLeastSignificantBits(), 0, dst, dstPos + 8, nBytes - 8); 1542 } 1543 return dst; 1544 } 1545 1546 /** 1547 * <p> 1548 * Converts bytes from an array into a UUID using the default (little endian, Lsb0) byte and 1549 * bit ordering. 1550 * </p> 1551 * 1552 * @param src the byte array to convert 1553 * @param srcPos the position in {@code src} where to copy the result from 1554 * @return a UUID 1555 * @throws NullPointerException if {@code src} is {@code null} 1556 * @throws IllegalArgumentException if array does not contain at least 16 bytes beginning 1557 * with {@code srcPos} 1558 */ 1559 public static UUID byteArrayToUuid(final byte[] src, final int srcPos) { 1560 if (src.length - srcPos < 16) { 1561 throw new IllegalArgumentException("Need at least 16 bytes for UUID"); 1562 } 1563 return new UUID(byteArrayToLong(src, srcPos, 0, 0, 8), byteArrayToLong(src, srcPos + 8, 0, 0, 8)); 1564 } 1565}