| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 22 |
| time | random value | inc | 25 ||||||||||
A globally unique identifier for objects.
51 | * 52 | *Consists of 12 bytes, divided as follows:
53 | *| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 57 | *
| time | random value | inc | 60 | *|||||||||
Instances of this class are immutable.
64 | */ 65 | public final class Xid implements Comparable232 | * The returned object id will compare as less than or equal to any other object id within the same second as the given date, and 233 | * less than any later date. 234 | *
235 | * 236 | * @param date the date 237 | * @return the Xid 238 | */ 239 | public static Xid getSmallestWithDate(final Date date) { 240 | return new Xid(dateToTimestampSeconds(date), 0, (short) 0, 0, false); 241 | } 242 | 243 | /** 244 | * Convert to a byte array. Note that the numbers are stored in big-endian order. 245 | * 246 | * @return the byte array 247 | */ 248 | public byte[] toByteArray() { 249 | ByteBuffer buffer = ByteBuffer.allocate(ID_LENGTH); 250 | putToByteBuffer(buffer); 251 | return buffer.array(); // using .allocate ensures there is a backing array that can be returned 252 | } 253 | 254 | /** 255 | * Convert to bytes and put those bytes to the provided ByteBuffer. 256 | * Note that the numbers are stored in big-endian order. 257 | * 258 | * @param buffer the ByteBuffer 259 | * @throws IllegalArgumentException if the buffer is null or does not have at least 12 bytes remaining 260 | */ 261 | public void putToByteBuffer(final ByteBuffer buffer) { 262 | paramNotNull("buffer", buffer); 263 | isTrue("buffer.remaining() >=12", buffer.remaining() >= ID_LENGTH); 264 | 265 | buffer.put(int3(timestamp)); 266 | buffer.put(int2(timestamp)); 267 | buffer.put(int1(timestamp)); 268 | buffer.put(int0(timestamp)); 269 | buffer.put(int2(randomValue1)); 270 | buffer.put(int1(randomValue1)); 271 | buffer.put(int0(randomValue1)); 272 | buffer.put(short1(randomValue2)); 273 | buffer.put(short0(randomValue2)); 274 | buffer.put(int2(counter)); 275 | buffer.put(int1(counter)); 276 | buffer.put(int0(counter)); 277 | } 278 | 279 | /** 280 | * Gets the timestamp (number of seconds since the Unix epoch). 281 | * 282 | * @return the timestamp 283 | */ 284 | public int getTimestamp() { 285 | return timestamp; 286 | } 287 | 288 | /** 289 | * Gets the timestamp as a {@code Date} instance. 290 | * 291 | * @return the Date 292 | */ 293 | public Date getDate() { 294 | return new Date((timestamp & 0xFFFFFFFFL) * 1000L); 295 | } 296 | 297 | /** 298 | * Converts this instance into a 20-byte hexadecimal string representation. 299 | * 300 | * @return a string representation of the Xid in hexadecimal format 301 | */ 302 | public String toHexString() { 303 | return base32Hex(toByteArray()); 304 | } 305 | 306 | @Override 307 | public boolean equals(final Object o) { 308 | if (this == o) { 309 | return true; 310 | } 311 | if (o == null || getClass() != o.getClass()) { 312 | return false; 313 | } 314 | 315 | Xid other = (Xid) o; 316 | 317 | if (counter != other.counter) { 318 | return false; 319 | } 320 | if (timestamp != other.timestamp) { 321 | return false; 322 | } 323 | 324 | if (randomValue1 != other.randomValue1) { 325 | return false; 326 | } 327 | 328 | return randomValue2 == other.randomValue2; 329 | } 330 | 331 | @Override 332 | public int hashCode() { 333 | int result = timestamp; 334 | result = 31 * result + counter; 335 | result = 31 * result + randomValue1; 336 | result = 31 * result + randomValue2; 337 | return result; 338 | } 339 | 340 | @Override 341 | public int compareTo(final Xid other) { 342 | if (other == null) { 343 | throw new NullPointerException(); 344 | } 345 | 346 | byte[] byteArray = toByteArray(); 347 | byte[] otherByteArray = other.toByteArray(); 348 | for (int i = 0; i < ID_LENGTH; i++) { 349 | if (byteArray[i] != otherByteArray[i]) { 350 | return ((byteArray[i] & 0xff) < (otherByteArray[i] & 0xff)) ? -1 : 1; 351 | } 352 | } 353 | return 0; 354 | } 355 | 356 | @Override 357 | public String toString() { 358 | return toHexString(); 359 | } 360 | 361 | /** 362 | * Checks if a string could be an {@code Xid}. 363 | * 364 | * @param hexString a potential Xid as a String. 365 | * @return whether the string could be an object id 366 | * @throws IllegalArgumentException if hexString is null 367 | */ 368 | public static boolean isValid(final String hexString) { 369 | if (hexString == null) { 370 | throw new IllegalArgumentException(); 371 | } 372 | 373 | int len = hexString.length(); 374 | if (len != 20) { 375 | return false; 376 | } 377 | 378 | for (int i = 0; i < len; i++) { 379 | char c = hexString.charAt(i); 380 | if (c >= '0' && c <= '9') { 381 | continue; 382 | } 383 | if (c >= 'a' && c <= 'v') { 384 | continue; 385 | } 386 | 387 | return false; 388 | } 389 | 390 | return true; 391 | } 392 | 393 | private static byte[] parseHexString(final String id) { 394 | if (!isValid(id)) { 395 | throw new IllegalArgumentException("invalid hexadecimal representation of an Xid: [" + id + "]"); 396 | } 397 | 398 | return base32Hex(id); 399 | } 400 | 401 | /** 402 | * Encodes byte array to Base32 String. 403 | * 404 | * @param bytes Bytes to encode. 405 | * @return Encoded byte arraybytes as a String.
406 | */
407 | private static String base32Hex(final byte[] bytes) {
408 | int i = 0;
409 | int index = 0;
410 | int digit = 0;
411 | int currByte;
412 | int nextByte;
413 | StringBuilder base32 = new StringBuilder((bytes.length + 7) * 8 / 5);
414 |
415 | while (i < bytes.length) {
416 | currByte = (bytes[i] >= 0) ? bytes[i] : (bytes[i] + 256); // unsigned
417 |
418 | if (index > 3) { // Current digit spanning a byte boundary?
419 | if ((i + 1) < bytes.length) {
420 | nextByte = (bytes[i + 1] >= 0) ? bytes[i + 1] : (bytes[i + 1] + 256);
421 | } else {
422 | nextByte = 0;
423 | }
424 |
425 | digit = currByte & (0xFF >> index);
426 | index = (index + 5) % 8;
427 | digit <<= index;
428 | digit |= nextByte >> (8 - index);
429 | i++;
430 | } else {
431 | digit = (currByte >> (8 - (index + 5))) & 0x1F;
432 | index = (index + 5) % 8;
433 | if (index == 0) {
434 | i++;
435 | }
436 | }
437 | base32.append(BASE32_HEX_CHARS[digit]);
438 | }
439 |
440 | return base32.toString();
441 | }
442 |
443 | /**
444 | * Decodes the given Base32 String to a raw byte array.
445 | *
446 | * @return Decoded base32 String as a raw byte array.
447 | */
448 | private static byte[] base32Hex(final String base32) {
449 | int i;
450 | int index;
451 | int lookup;
452 | int offset;
453 | int digit;
454 | byte[] bytes = new byte[base32.length() * 5 / 8];
455 |
456 | for (i = 0, index = 0, offset = 0; i < base32.length(); i++) {
457 | lookup = base32.charAt(i) - '0';
458 |
459 | /* Skip chars outside the lookup table. */
460 | if (lookup < 0 || lookup >= BASE32_LOOKUP_TABLE.length) {
461 | continue;
462 | }
463 |
464 | digit = BASE32_LOOKUP_TABLE[lookup];
465 |
466 | /* If this digit is not in the table, ignore it. */
467 | if (digit == 0xFF) {
468 | continue;
469 | }
470 |
471 | if (index <= 3) {
472 | index = (index + 5) % 8;
473 | if (index == 0) {
474 | bytes[offset] |= digit;
475 | offset++;
476 | if (offset >= bytes.length) {
477 | break;
478 | }
479 | } else {
480 | bytes[offset] |= digit << (8 - index);
481 | }
482 | } else {
483 | index = (index + 5) % 8;
484 | bytes[offset] |= (digit >>> index);
485 | offset++;
486 |
487 | if (offset >= bytes.length) {
488 | break;
489 | }
490 | bytes[offset] |= digit << (8 - index);
491 | }
492 | }
493 | return bytes;
494 | }
495 |
496 | private static int dateToTimestampSeconds(final Date time) {
497 | return (int) (time.getTime() / 1000);
498 | }
499 |
500 | // Big-Endian helpers, in this class because all other BSON numbers are little-endian
501 |
502 | private static int makeInt(final byte b3, final byte b2, final byte b1, final byte b0) {
503 | return (((b3) << 24) |
504 | ((b2 & 0xff) << 16) |
505 | ((b1 & 0xff) << 8) |
506 | ((b0 & 0xff)));
507 | }
508 |
509 | private static short makeShort(final byte b1, final byte b0) {
510 | return (short) (((b1 & 0xff) << 8) | ((b0 & 0xff)));
511 | }
512 |
513 | private static byte int3(final int x) {
514 | return (byte) (x >> 24);
515 | }
516 |
517 | private static byte int2(final int x) {
518 | return (byte) (x >> 16);
519 | }
520 |
521 | private static byte int1(final int x) {
522 | return (byte) (x >> 8);
523 | }
524 |
525 | private static byte int0(final int x) {
526 | return (byte) (x);
527 | }
528 |
529 | private static byte short1(final short x) {
530 | return (byte) (x >> 8);
531 | }
532 |
533 | private static byte short0(final short x) {
534 | return (byte) (x);
535 | }
536 |
537 | public static void isTrue(final String name,
538 | final boolean condition) {
539 | if (!condition) {
540 | throw new IllegalStateException("state should be: " + name);
541 | }
542 | }
543 |
544 | static