in sdk/cosmos/azure-cosmos/src/main/java/com/azure/cosmos/implementation/uuid/Jug.java [105:327]
public static void main(String[] args)
{
if (args.length == 0) {
printUsage();
return;
}
int count = args.length;
String type = args[count-1];
boolean verbose = false;
int genCount = 1;
String name = null;
String nameSpace = null;
EthernetAddress addr = null;
boolean performance = false;
--count;
// Type we recognize?
String tmp = TYPES.get(type);
if (tmp == null) {
if (!TYPES.containsValue(type)) {
System.err.println("Unrecognized UUID generation type '"+
type+"'; currently available ones are:");
printMap(TYPES, System.err, false);
System.err.println();
System.exit(1);
}
} else {
// Long names get translated to shorter ones:
type = tmp;
}
NoArgGenerator noArgGenerator = null; // random- or time-based
StringArgGenerator nameArgGenerator = null; // name-based
for (int i = 0; i < count; ++i) {
String opt = args[i];
if (opt.length() == 0 || opt.charAt(0) != '-') {
System.err.println("Unrecognized option '"+opt+"' (missing leading hyphen?), exiting.");
System.exit(1);
}
char option = (char)0;
if (opt.startsWith("--")) {
String o = OPTIONS.get(opt.substring(2));
// Let's translate longer names to simple names:
if (o != null) {
option = o.charAt(0);
}
} else {
if (OPTIONS.containsValue(opt.substring(1))) {
option = opt.charAt(1);
}
}
if (option == (char) 0) {
System.err.println("Unrecognized option '"+opt+"'; exiting.");
System.err.print("[options currently available are: ");
printMap(OPTIONS, System.err, true);
System.err.println("]");
System.exit(1);
}
// K. Now we have one-letter options to handle:
try {
String next;
switch (option) {
case 'c':
// Need a number now:
next = args[++i];
try {
genCount = Integer.parseInt(next);
} catch (NumberFormatException nex) {
System.err.println("Invalid number argument for option '"+opt+"', exiting.");
System.exit(1);
}
if (genCount < 1) {
System.err.println("Invalid number argument for option '"+opt+"'; negative numbers not allowed, ignoring (defaults to 1).");
}
break;
case 'e':
// Need the ethernet address:
next = args[++i];
try {
addr = EthernetAddress.valueOf(next);
} catch (NumberFormatException nex) {
System.err.println("Invalid ethernet address for option '"+opt+"', error: "+nex.toString());
System.exit(1);
}
break;
case 'h':
printUsage();
return;
case 'n':
// Need the name
name = args[++i];
break;
case 'p': // performance:
performance = true;
break;
case 's':
// Need the namespace id
nameSpace = args[++i];
break;
case 'v':
verbose = true;
break;
}
} catch (IndexOutOfBoundsException ie) {
// We get here when an arg is missing...
System.err.println("Missing argument for option '"+opt+"', exiting.");
System.exit(1);
}
} // for (int i = 0....)
/* Ok, args look ok so far. Now to the generation; some args/options
* can't be validated without knowing the type:
*/
char typeC = type.charAt(0);
UUID nsUUID = null;
boolean usesRnd = false;
switch (typeC) {
case 't': // time-based
usesRnd = true;
// No address specified? Need a dummy one...
if (addr == null) {
if (verbose) {
System.out.print("(no address specified, generating dummy address: ");
}
addr = EthernetAddress.constructMulticastAddress(new Random(System.currentTimeMillis()));
if (verbose) {
System.out.print(addr.toString());
System.out.println(")");
}
}
noArgGenerator = Generators.timeBasedGenerator(addr);
break;
case 'r': // random-based
usesRnd = true;
{
SecureRandom r = new SecureRandom();
if (verbose) {
System.out.print("(using secure random generator, info = '"+r.getProvider().getInfo()+"')");
}
noArgGenerator = Generators.randomBasedGenerator(r);
}
break;
case 'n': // name-based
if (name == null) {
System.err.println("--name-space (-s) - argument missing when using method that requires it, exiting.");
System.exit(1);
}
if (name == null) {
System.err.println("--name (-n) - argument missing when using method that requires it, exiting.");
System.exit(1);
}
if (typeC == 'n') {
String orig = nameSpace;
nameSpace = nameSpace.toLowerCase();
if (nameSpace.equals("url")) {
nsUUID = NameBasedGenerator.NAMESPACE_URL;
} else if (nameSpace.equals("dns")) {
nsUUID = NameBasedGenerator.NAMESPACE_DNS;
} else {
System.err.println("Unrecognized namespace '"+orig
+"'; only DNS and URL allowed for name-based generation.");
System.exit(1);
}
}
nameArgGenerator = Generators.nameBasedGenerator(nsUUID);
break;
}
// And then let's rock:
if (verbose) {
System.out.println();
}
/* When measuring performance, make sure that the random number
* generator is initialized prior to measurements...
*/
long now = 0L;
if (performance) {
// No need to pre-initialize for name-based schemes?
if (usesRnd) {
if (verbose) {
System.out.println("(initializing random number generator before UUID generation so that performance measurements are not skewed due to one-time init costs)");
}
// should initialize by just calling it
noArgGenerator.generate();
if (verbose) {
System.out.println("(random number generator initialized ok)");
}
}
now = System.currentTimeMillis();
}
for (int i = 0; i < genCount; ++i) {
UUID uuid = (nameArgGenerator == null) ?
noArgGenerator.generate() : nameArgGenerator.generate(name);
if (verbose) {
System.out.print("UUID: ");
}
if (!performance || verbose) {
System.out.println(uuid.toString());
}
} // for (int i = 0; ...)
if (verbose) {
System.out.println("Done.");
}
if (performance) {
now = System.currentTimeMillis() - now;
long avg = (now * 10 + (genCount / 2)) / genCount;
System.out.println("Performance: took "+now+" milliseconds to generate (and print out) "+genCount+" UUIDs; average being "+(avg / 10)+"."+(avg%10)+" msec.");
}
}