diff options
Diffstat (limited to 'test/files/presentation/akka/src/com')
6 files changed, 1134 insertions, 0 deletions
diff --git a/test/files/presentation/akka/src/com/eaio/util/lang/Hex.java b/test/files/presentation/akka/src/com/eaio/util/lang/Hex.java new file mode 100644 index 0000000000..7794059517 --- /dev/null +++ b/test/files/presentation/akka/src/com/eaio/util/lang/Hex.java @@ -0,0 +1,215 @@ +/* + * Hex.java + * + * Created 04.07.2003. + * + * eaio: UUID - an implementation of the UUID specification Copyright (c) 2003-2009 Johann Burkard (jb@eaio.com) + * http://eaio.com. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated + * documentation files (the "Software"), to deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE + * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR + * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR + * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + */ +package com.eaio.util.lang; + +import java.io.IOException; + +/** + * Number-to-hexadecimal and hexadecimal-to-number conversions. + * + * @see <a href="http://johannburkard.de/software/uuid/">UUID</a> + * @author <a href="mailto:jb@eaio.com">Johann Burkard</a> + * @version $Id: Hex.java 1888 2009-03-15 12:43:24Z johann $ + */ +public final class Hex { + + /** + * No instances needed. + */ + private Hex() { + super(); + } + + private static final char[] DIGITS = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', + 'f' }; + + /** + * Turns a <code>short</code> into hex octets. + * + * @param a the {@link Appendable}, may not be <code>null</code> + * @param in the integer + * @return {@link Appendable} + */ + public static Appendable append(Appendable a, short in) { + return append(a, (long) in, 4); + } + + /** + * Turns a <code>short</code> into hex octets. + * + * @param a the {@link Appendable}, may not be <code>null</code> + * @param in the integer + * @param length the number of octets to produce + * @return {@link Appendable} + */ + public static Appendable append(Appendable a, short in, int length) { + return append(a, (long) in, length); + } + + /** + * Turns an <code>int</code> into hex octets. + * + * @param a the {@link Appendable}, may not be <code>null</code> + * @param in the integer + * @return {@link Appendable} + */ + public static Appendable append(Appendable a, int in) { + return append(a, (long) in, 8); + } + + /** + * Turns an <code>int</code> into hex octets. + * + * @param a the {@link Appendable}, may not be <code>null</code> + * @param in the integer + * @param length the number of octets to produce + * @return {@link Appendable} + */ + public static Appendable append(Appendable a, int in, int length) { + return append(a, (long) in, length); + } + + /** + * Turns a <code>long</code> into hex octets. + * + * @param a the {@link Appendable}, may not be <code>null</code> + * @param in the long + * @return {@link Appendable} + */ + public static Appendable append(Appendable a, long in) { + return append(a, in, 16); + } + + /** + * Turns a <code>long</code> into hex octets. + * + * @param a the {@link Appendable}, may not be <code>null</code> + * @param in the long + * @param length the number of octets to produce + * @return {@link Appendable} + */ + public static Appendable append(Appendable a, long in, int length) { + try { + int lim = (length << 2) - 4; + while (lim >= 0) { + a.append(DIGITS[(byte) (in >> lim) & 0x0f]); + lim -= 4; + } + } + catch (IOException ex) { + // Bla + } + return a; + } + + /** + * Turns a <code>byte</code> array into hex octets. + * + * @param a the {@link Appendable}, may not be <code>null</code> + * @param bytes the <code>byte</code> array + * @return {@link Appendable} + */ + public static Appendable append(Appendable a, byte[] bytes) { + try { + for (byte b : bytes) { + a.append(DIGITS[(byte) ((b & 0xF0) >> 4)]); + a.append(DIGITS[(byte) (b & 0x0F)]); + } + } + catch (IOException ex) { + // Bla + } + return a; + } + + /** + * Parses a <code>long</code> from a hex encoded number. This method will skip all characters that are not 0-9, + * A-F and a-f. + * <p> + * Returns 0 if the {@link CharSequence} does not contain any interesting characters. + * + * @param s the {@link CharSequence} to extract a <code>long</code> from, may not be <code>null</code> + * @return a <code>long</code> + * @throws NullPointerException if the {@link CharSequence} is <code>null</code> + */ + public static long parseLong(CharSequence s) { + long out = 0; + byte shifts = 0; + char c; + for (int i = 0; i < s.length() && shifts < 16; i++) { + c = s.charAt(i); + if ((c > 47) && (c < 58)) { + ++shifts; + out <<= 4; + out |= c - 48; + } + else if ((c > 64) && (c < 71)) { + ++shifts; + out <<= 4; + out |= c - 55; + } + else if ((c > 96) && (c < 103)) { + ++shifts; + out <<= 4; + out |= c - 87; + } + } + return out; + } + + /** + * Parses a <code>short</code> from a hex encoded number. This method will skip all characters that are not 0-9, + * A-F and a-f. + * <p> + * Returns 0 if the {@link CharSequence} does not contain any interesting characters. + * + * @param s the {@link CharSequence} to extract a <code>short</code> from, may not be <code>null</code> + * @return a <code>short</code> + * @throws NullPointerException if the {@link CharSequence} is <code>null</code> + */ + public static short parseShort(String s) { + short out = 0; + byte shifts = 0; + char c; + for (int i = 0; i < s.length() && shifts < 4; i++) { + c = s.charAt(i); + if ((c > 47) && (c < 58)) { + ++shifts; + out <<= 4; + out |= c - 48; + } + else if ((c > 64) && (c < 71)) { + ++shifts; + out <<= 4; + out |= c - 55; + } + else if ((c > 96) && (c < 103)) { + ++shifts; + out <<= 4; + out |= c - 87; + } + } + return out; + } + +} diff --git a/test/files/presentation/akka/src/com/eaio/uuid/MACAddressParser.java b/test/files/presentation/akka/src/com/eaio/uuid/MACAddressParser.java new file mode 100644 index 0000000000..c077147470 --- /dev/null +++ b/test/files/presentation/akka/src/com/eaio/uuid/MACAddressParser.java @@ -0,0 +1,116 @@ +/* + * MACAddressParserTest.java + * + * Created 30.01.2006. + * + * eaio: UUID - an implementation of the UUID specification + * Copyright (c) 2003-2009 Johann Burkard (jb@eaio.com) http://eaio.com. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN + * NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, + * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR + * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE + * USE OR OTHER DEALINGS IN THE SOFTWARE. + * + */ +package com.eaio.uuid; + +/** + * The MAC address parser attempts to find the following patterns: + * <ul> + * <li>.{1,2}:.{1,2}:.{1,2}:.{1,2}:.{1,2}:.{1,2}</li> + * <li>.{1,2}-.{1,2}-.{1,2}-.{1,2}-.{1,2}-.{1,2}</li> + * </ul> + * + * @see <a href="http://johannburkard.de/software/uuid/">UUID</a> + * @author <a href="mailto:jb@eaio.com">Johann Burkard</a> + * @version $Id: MACAddressParser.java 1888 2009-03-15 12:43:24Z johann $ + */ +class MACAddressParser { + + /** + * No instances needed. + */ + private MACAddressParser() { + super(); + } + + /** + * Attempts to find a pattern in the given String. + * + * @param in the String, may not be <code>null</code> + * @return the substring that matches this pattern or <code>null</code> + */ + static String parse(String in) { + + String out = in; + + // lanscan + + int hexStart = out.indexOf("0x"); + if (hexStart != -1 && out.indexOf("ETHER") != -1) { + int hexEnd = out.indexOf(' ', hexStart); + if (hexEnd > hexStart + 2) { + out = out.substring(hexStart, hexEnd); + } + } + + else { + + int octets = 0; + int lastIndex, old, end; + + if (out.indexOf('-') > -1) { + out = out.replace('-', ':'); + } + + lastIndex = out.lastIndexOf(':'); + + if (lastIndex > out.length() - 2) { + out = null; + } + else { + + end = Math.min(out.length(), lastIndex + 3); + + ++octets; + old = lastIndex; + while (octets != 5 && lastIndex != -1 && lastIndex > 1) { + lastIndex = out.lastIndexOf(':', --lastIndex); + if (old - lastIndex == 3 || old - lastIndex == 2) { + ++octets; + old = lastIndex; + } + } + + if (octets == 5 && lastIndex > 1) { + out = out.substring(lastIndex - 2, end).trim(); + } + else { + out = null; + } + + } + + } + + if (out != null && out.startsWith("0x")) { + out = out.substring(2); + } + + return out; + } + +} diff --git a/test/files/presentation/akka/src/com/eaio/uuid/UUID.java b/test/files/presentation/akka/src/com/eaio/uuid/UUID.java new file mode 100644 index 0000000000..6c49bcd1c8 --- /dev/null +++ b/test/files/presentation/akka/src/com/eaio/uuid/UUID.java @@ -0,0 +1,311 @@ +/* + * UUID.java + * + * Created 07.02.2003 + * + * eaio: UUID - an implementation of the UUID specification + * Copyright (c) 2003-2009 Johann Burkard (jb@eaio.com) http://eaio.com. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN + * NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, + * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR + * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE + * USE OR OTHER DEALINGS IN THE SOFTWARE. + * + */ +package com.eaio.uuid; + +import java.io.IOException; +import java.io.ObjectInputStream; +import java.io.ObjectOutputStream; +import java.io.Serializable; + +import org.omg.CORBA.portable.IDLEntity; + +import com.eaio.util.lang.Hex; + +/** + * Creates UUIDs according to the DCE Universal Token Identifier specification. + * <p> + * All you need to know: + * <pre> + * UUID u = new UUID(); + * </pre> + * + * @see <a href="http://www.opengroup.org/onlinepubs/9629399/apdxa.htm"> + * http://www.opengroup.org/onlinepubs/9629399/apdxa.htm + * </a> + * @see <a href="http://www.uddi.org/pubs/draft-leach-uuids-guids-01.txt"> + * http://www.uddi.org/pubs/draft-leach-uuids-guids-01.txt + * </a> + * @see <a href="http://johannburkard.de/software/uuid/">UUID</a> + * @author <a href="mailto:jb@eaio.de">Johann Burkard</a> + * @version $Id: UUID.java 1888 2009-03-15 12:43:24Z johann $ + */ +public class UUID implements Comparable<UUID>, Serializable, Cloneable, + IDLEntity { + + /** + * Hasn't ever changed between versions. + */ + static final long serialVersionUID = 7435962790062944603L; + + /** + * The time field of the UUID. + * + * @serial + */ + public long time; + + /** + * The clock sequence and node field of the UUID. + * + * @serial + */ + public long clockSeqAndNode; + + /** + * Constructor for UUID. Constructs a new, unique UUID. + * + * @see UUIDGen#newTime() + * @see UUIDGen#getClockSeqAndNode() + */ + public UUID() { + this(UUIDGen.newTime(), UUIDGen.getClockSeqAndNode()); + } + + /** + * Constructor for UUID. Constructs a UUID from two <code>long</code> values. + * + * @param time the upper 64 bits + * @param clockSeqAndNode the lower 64 bits + */ + public UUID(long time, long clockSeqAndNode) { + this.time = time; + this.clockSeqAndNode = clockSeqAndNode; + } + + /** + * Copy constructor for UUID. Values of the given UUID are copied. + * + * @param u the UUID, may not be <code>null</code> + */ + public UUID(UUID u) { + this(u.time, u.clockSeqAndNode); + } + + /** + * Parses a textual representation of a UUID. + * <p> + * No validation is performed. If the {@link CharSequence} is shorter than 36 characters, + * {@link ArrayIndexOutOfBoundsException}s will be thrown. + * + * @param s the {@link CharSequence}, may not be <code>null</code> + */ + public UUID(CharSequence s) { + this(Hex.parseLong(s.subSequence(0, 18)), Hex.parseLong(s.subSequence( + 19, 36))); + } + + /** + * Compares this UUID to another Object. Throws a {@link ClassCastException} if + * the other Object is not an instance of the UUID class. Returns a value + * smaller than zero if the other UUID is "larger" than this UUID and a value + * larger than zero if the other UUID is "smaller" than this UUID. + * + * @param t the other UUID, may not be <code>null</code> + * @return a value < 0, 0 or a value > 0 + * @see java.lang.Comparable#compareTo(java.lang.Object) + * @throws ClassCastException + */ + public int compareTo(UUID t) { + if (this == t) { + return 0; + } + if (time > t.time) { + return 1; + } + if (time < t.time) { + return -1; + } + if (clockSeqAndNode > t.clockSeqAndNode) { + return 1; + } + if (clockSeqAndNode < t.clockSeqAndNode) { + return -1; + } + return 0; + } + + /** + * Tweaked Serialization routine. + * + * @param out the ObjectOutputStream + * @throws IOException + */ + private void writeObject(ObjectOutputStream out) throws IOException { + out.writeLong(time); + out.writeLong(clockSeqAndNode); + } + + /** + * Tweaked Serialization routine. + * + * @param in the ObjectInputStream + * @throws IOException + */ + private void readObject(ObjectInputStream in) throws IOException { + time = in.readLong(); + clockSeqAndNode = in.readLong(); + } + + /** + * Returns this UUID as a String. + * + * @return a String, never <code>null</code> + * @see java.lang.Object#toString() + * @see #toAppendable(Appendable) + */ + @Override + public final String toString() { + return toAppendable(null).toString(); + } + + /** + * Appends a String representation of this to the given {@link StringBuffer} or + * creates a new one if none is given. + * + * @param in the StringBuffer to append to, may be <code>null</code> + * @return a StringBuffer, never <code>null</code> + * @see #toAppendable(Appendable) + */ + public StringBuffer toStringBuffer(StringBuffer in) { + StringBuffer out = in; + if (out == null) { + out = new StringBuffer(36); + } + else { + out.ensureCapacity(out.length() + 36); + } + return (StringBuffer) toAppendable(out); + } + + /** + * Appends a String representation of this object to the given {@link Appendable} object. + * <p> + * For reasons I'll probably never understand, Sun has decided to have a number of I/O classes implement + * Appendable which forced them to destroy an otherwise nice and simple interface with {@link IOException}s. + * <p> + * I decided to ignore any possible IOExceptions in this method. + * + * @param a the Appendable object, may be <code>null</code> + * @return an Appendable object, defaults to a {@link StringBuilder} if <code>a</code> is <code>null</code> + */ + public Appendable toAppendable(Appendable a) { + Appendable out = a; + if (out == null) { + out = new StringBuilder(36); + } + try { + Hex.append(out, (int) (time >> 32)).append('-'); + Hex.append(out, (short) (time >> 16)).append('-'); + Hex.append(out, (short) time).append('-'); + Hex.append(out, (short) (clockSeqAndNode >> 48)).append('-'); + Hex.append(out, clockSeqAndNode, 12); + } + catch (IOException ex) { + // What were they thinking? + } + return out; + } + + /** + * Returns a hash code of this UUID. The hash code is calculated by XOR'ing the + * upper 32 bits of the time and clockSeqAndNode fields and the lower 32 bits of + * the time and clockSeqAndNode fields. + * + * @return an <code>int</code> representing the hash code + * @see java.lang.Object#hashCode() + */ + @Override + public int hashCode() { + return (int) ((time >> 32) ^ time ^ (clockSeqAndNode >> 32) ^ clockSeqAndNode); + } + + /** + * Clones this UUID. + * + * @return a new UUID with identical values, never <code>null</code> + */ + @Override + public Object clone() { + try { + return super.clone(); + } + catch (CloneNotSupportedException ex) { + // One of Sun's most epic fails. + return null; + } + } + + /** + * Returns the time field of the UUID (upper 64 bits). + * + * @return the time field + */ + public final long getTime() { + return time; + } + + /** + * Returns the clock and node field of the UUID (lower 64 bits). + * + * @return the clockSeqAndNode field + */ + public final long getClockSeqAndNode() { + return clockSeqAndNode; + } + + /** + * Compares two Objects for equality. + * + * @see java.lang.Object#equals(Object) + * @param obj the Object to compare this UUID with, may be <code>null</code> + * @return <code>true</code> if the other Object is equal to this UUID, + * <code>false</code> if not + */ + @Override + public boolean equals(Object obj) { + if (!(obj instanceof UUID)) { + return false; + } + return compareTo((UUID) obj) == 0; + } + + /** + * Returns the nil UUID (a UUID whose values are both set to zero). + * <p> + * Starting with version 2.0, this method does return a new UUID instance every + * time it is called. Earlier versions returned one instance. This has now been + * changed because this UUID has public, non-final instance fields. Returning a + * new instance is therefore more safe. + * + * @return a nil UUID, never <code>null</code> + */ + public static UUID nilUUID() { + return new UUID(0, 0); + } + +} diff --git a/test/files/presentation/akka/src/com/eaio/uuid/UUIDGen.java b/test/files/presentation/akka/src/com/eaio/uuid/UUIDGen.java new file mode 100644 index 0000000000..a42ed666bc --- /dev/null +++ b/test/files/presentation/akka/src/com/eaio/uuid/UUIDGen.java @@ -0,0 +1,364 @@ +/* + * UUIDGen.java + * + * Created on 09.08.2003. + * + * eaio: UUID - an implementation of the UUID specification + * Copyright (c) 2003-2009 Johann Burkard (jb@eaio.com) http://eaio.com. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN + * NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, + * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR + * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE + * USE OR OTHER DEALINGS IN THE SOFTWARE. + * + */ +package com.eaio.uuid; + +import java.io.BufferedReader; +import java.io.File; +import java.io.IOException; +import java.io.InputStreamReader; +import java.net.InetAddress; +import java.net.InterfaceAddress; +import java.net.NetworkInterface; +import java.net.SocketException; +import java.net.UnknownHostException; +import java.util.Enumeration; + +import com.eaio.util.lang.Hex; + +/** + * This class contains methods to generate UUID fields. These methods have been + * refactored out of {@link com.eaio.uuid.UUID}. + * <p> + * Starting with version 2, this implementation tries to obtain the MAC address + * of the network card. Under Microsoft Windows, the <code>ifconfig</code> + * command is used which may pop up a command window in Java Virtual Machines + * prior to 1.4 once this class is initialized. The command window is closed + * automatically. + * <p> + * The MAC address code has been tested extensively in Microsoft Windows, + * Linux, Solaris 8, HP-UX 11, but should work in MacOS X and BSDs, too. + * <p> + * If you use JDK 6 or later, the code in {@link InterfaceAddress} will be used. + * + * @see <a href="http://johannburkard.de/software/uuid/">UUID</a> + * @author <a href="mailto:jb@eaio.de">Johann Burkard</a> + * @version $Id: UUIDGen.java 2914 2010-04-23 11:35:00Z johann $ + * @see com.eaio.uuid.UUID + */ +public final class UUIDGen { + + /** + * No instances needed. + */ + private UUIDGen() { + super(); + } + + /** + * The last time value. Used to remove duplicate UUIDs. + */ + private static long lastTime = Long.MIN_VALUE; + + /** + * The cached MAC address. + */ + private static String macAddress = null; + + /** + * The current clock and node value. + */ + private static long clockSeqAndNode = 0x8000000000000000L; + + static { + + try { + Class.forName("java.net.InterfaceAddress"); + macAddress = Class.forName( + "com.eaio.uuid.UUIDGen$HardwareAddressLookup").newInstance().toString(); + } + catch (ExceptionInInitializerError err) { + // Ignored. + } + catch (ClassNotFoundException ex) { + // Ignored. + } + catch (LinkageError err) { + // Ignored. + } + catch (IllegalAccessException ex) { + // Ignored. + } + catch (InstantiationException ex) { + // Ignored. + } + catch (SecurityException ex) { + // Ignored. + } + + if (macAddress == null) { + + Process p = null; + BufferedReader in = null; + + try { + String osname = System.getProperty("os.name", ""); + + if (osname.startsWith("Windows")) { + p = Runtime.getRuntime().exec( + new String[] { "ipconfig", "/all" }, null); + } + // Solaris code must appear before the generic code + else if (osname.startsWith("Solaris") + || osname.startsWith("SunOS")) { + String hostName = getFirstLineOfCommand( + "uname", "-n" ); + if (hostName != null) { + p = Runtime.getRuntime().exec( + new String[] { "/usr/sbin/arp", hostName }, + null); + } + } + else if (new File("/usr/sbin/lanscan").exists()) { + p = Runtime.getRuntime().exec( + new String[] { "/usr/sbin/lanscan" }, null); + } + else if (new File("/sbin/ifconfig").exists()) { + p = Runtime.getRuntime().exec( + new String[] { "/sbin/ifconfig", "-a" }, null); + } + + if (p != null) { + in = new BufferedReader(new InputStreamReader( + p.getInputStream()), 128); + String l = null; + while ((l = in.readLine()) != null) { + macAddress = MACAddressParser.parse(l); + if (macAddress != null + && Hex.parseShort(macAddress) != 0xff) { + break; + } + } + } + + } + catch (SecurityException ex) { + // Ignore it. + } + catch (IOException ex) { + // Ignore it. + } + finally { + if (p != null) { + if (in != null) { + try { + in.close(); + } + catch (IOException ex) { + // Ignore it. + } + } + try { + p.getErrorStream().close(); + } + catch (IOException ex) { + // Ignore it. + } + try { + p.getOutputStream().close(); + } + catch (IOException ex) { + // Ignore it. + } + p.destroy(); + } + } + + } + + if (macAddress != null) { + clockSeqAndNode |= Hex.parseLong(macAddress); + } + else { + try { + byte[] local = InetAddress.getLocalHost().getAddress(); + clockSeqAndNode |= (local[0] << 24) & 0xFF000000L; + clockSeqAndNode |= (local[1] << 16) & 0xFF0000; + clockSeqAndNode |= (local[2] << 8) & 0xFF00; + clockSeqAndNode |= local[3] & 0xFF; + } + catch (UnknownHostException ex) { + clockSeqAndNode |= (long) (Math.random() * 0x7FFFFFFF); + } + } + + // Skip the clock sequence generation process and use random instead. + + clockSeqAndNode |= (long) (Math.random() * 0x3FFF) << 48; + + } + + /** + * Returns the current clockSeqAndNode value. + * + * @return the clockSeqAndNode value + * @see UUID#getClockSeqAndNode() + */ + public static long getClockSeqAndNode() { + return clockSeqAndNode; + } + + /** + * Generates a new time field. Each time field is unique and larger than the + * previously generated time field. + * + * @return a new time value + * @see UUID#getTime() + */ + public static long newTime() { + return createTime(System.currentTimeMillis()); + } + + /** + * Creates a new time field from the given timestamp. Note that even identical + * values of <code>currentTimeMillis</code> will produce different time fields. + * + * @param currentTimeMillis the timestamp + * @return a new time value + * @see UUID#getTime() + */ + public static synchronized long createTime(long currentTimeMillis) { + + long time; + + // UTC time + + long timeMillis = (currentTimeMillis * 10000) + 0x01B21DD213814000L; + + if (timeMillis > lastTime) { + lastTime = timeMillis; + } + else { + timeMillis = ++lastTime; + } + + // time low + + time = timeMillis << 32; + + // time mid + + time |= (timeMillis & 0xFFFF00000000L) >> 16; + + // time hi and version + + time |= 0x1000 | ((timeMillis >> 48) & 0x0FFF); // version 1 + + return time; + + } + + /** + * Returns the MAC address. Not guaranteed to return anything. + * + * @return the MAC address, may be <code>null</code> + */ + public static String getMACAddress() { + return macAddress; + } + + /** + * Returns the first line of the shell command. + * + * @param commands the commands to run + * @return the first line of the command + * @throws IOException + */ + static String getFirstLineOfCommand(String... commands) throws IOException { + + Process p = null; + BufferedReader reader = null; + + try { + p = Runtime.getRuntime().exec(commands); + reader = new BufferedReader(new InputStreamReader( + p.getInputStream()), 128); + + return reader.readLine(); + } + finally { + if (p != null) { + if (reader != null) { + try { + reader.close(); + } + catch (IOException ex) { + // Ignore it. + } + } + try { + p.getErrorStream().close(); + } + catch (IOException ex) { + // Ignore it. + } + try { + p.getOutputStream().close(); + } + catch (IOException ex) { + // Ignore it. + } + p.destroy(); + } + } + + } + + /** + * Scans MAC addresses for good ones. + */ + static class HardwareAddressLookup { + + /** + * @see java.lang.Object#toString() + */ + @Override + public String toString() { + String out = null; + try { + Enumeration<NetworkInterface> ifs = NetworkInterface.getNetworkInterfaces(); + if (ifs != null) { + while (ifs.hasMoreElements()) { + NetworkInterface iface = ifs.nextElement(); + byte[] hardware = iface.getHardwareAddress(); + if (hardware != null && hardware.length == 6 + && hardware[1] != (byte) 0xff) { + out = Hex.append(new StringBuilder(36), hardware).toString(); + break; + } + } + } + } + catch (SocketException ex) { + // Ignore it. + } + return out; + } + + } + +} diff --git a/test/files/presentation/akka/src/com/eaio/uuid/UUIDHelper.java b/test/files/presentation/akka/src/com/eaio/uuid/UUIDHelper.java new file mode 100644 index 0000000000..7abbe85895 --- /dev/null +++ b/test/files/presentation/akka/src/com/eaio/uuid/UUIDHelper.java @@ -0,0 +1,86 @@ +package com.eaio.uuid; + + +/** +* com/eaio/uuid/UUIDHelper.java . +* Generated by the IDL-to-Java compiler (portable), version "3.1" +* from uuid.idl +* Sonntag, 7. März 2004 21.35 Uhr CET +*/ + + +/** + * The UUID struct. + */ +abstract public class UUIDHelper +{ + private static String _id = "IDL:com/eaio/uuid/UUID:1.0"; + + public static void insert (org.omg.CORBA.Any a, com.eaio.uuid.UUID that) + { + org.omg.CORBA.portable.OutputStream out = a.create_output_stream (); + a.type (type ()); + write (out, that); + a.read_value (out.create_input_stream (), type ()); + } + + public static com.eaio.uuid.UUID extract (org.omg.CORBA.Any a) + { + return read (a.create_input_stream ()); + } + + private static org.omg.CORBA.TypeCode __typeCode = null; + private static boolean __active = false; + synchronized public static org.omg.CORBA.TypeCode type () + { + if (__typeCode == null) + { + synchronized (org.omg.CORBA.TypeCode.class) + { + if (__typeCode == null) + { + if (__active) + { + return org.omg.CORBA.ORB.init().create_recursive_tc ( _id ); + } + __active = true; + org.omg.CORBA.StructMember[] _members0 = new org.omg.CORBA.StructMember [2]; + org.omg.CORBA.TypeCode _tcOf_members0 = null; + _tcOf_members0 = org.omg.CORBA.ORB.init ().get_primitive_tc (org.omg.CORBA.TCKind.tk_longlong); + _members0[0] = new org.omg.CORBA.StructMember ( + "time", + _tcOf_members0, + null); + _tcOf_members0 = org.omg.CORBA.ORB.init ().get_primitive_tc (org.omg.CORBA.TCKind.tk_longlong); + _members0[1] = new org.omg.CORBA.StructMember ( + "clockSeqAndNode", + _tcOf_members0, + null); + __typeCode = org.omg.CORBA.ORB.init ().create_struct_tc (com.eaio.uuid.UUIDHelper.id (), "UUID", _members0); + __active = false; + } + } + } + return __typeCode; + } + + public static String id () + { + return _id; + } + + public static com.eaio.uuid.UUID read (org.omg.CORBA.portable.InputStream istream) + { + com.eaio.uuid.UUID value = new com.eaio.uuid.UUID (); + value.time = istream.read_longlong (); + value.clockSeqAndNode = istream.read_longlong (); + return value; + } + + public static void write (org.omg.CORBA.portable.OutputStream ostream, com.eaio.uuid.UUID value) + { + ostream.write_longlong (value.time); + ostream.write_longlong (value.clockSeqAndNode); + } + +} diff --git a/test/files/presentation/akka/src/com/eaio/uuid/UUIDHolder.java b/test/files/presentation/akka/src/com/eaio/uuid/UUIDHolder.java new file mode 100644 index 0000000000..d5531f5e00 --- /dev/null +++ b/test/files/presentation/akka/src/com/eaio/uuid/UUIDHolder.java @@ -0,0 +1,42 @@ +package com.eaio.uuid; + +/** +* com/eaio/uuid/UUIDHolder.java . +* Generated by the IDL-to-Java compiler (portable), version "3.1" +* from uuid.idl +* Sonntag, 7. März 2004 21.35 Uhr CET +*/ + + +/** + * The UUID struct. + */ +public final class UUIDHolder implements org.omg.CORBA.portable.Streamable +{ + public com.eaio.uuid.UUID value = null; + + public UUIDHolder () + { + } + + public UUIDHolder (com.eaio.uuid.UUID initialValue) + { + value = initialValue; + } + + public void _read (org.omg.CORBA.portable.InputStream i) + { + value = com.eaio.uuid.UUIDHelper.read (i); + } + + public void _write (org.omg.CORBA.portable.OutputStream o) + { + com.eaio.uuid.UUIDHelper.write (o, value); + } + + public org.omg.CORBA.TypeCode _type () + { + return com.eaio.uuid.UUIDHelper.type (); + } + +} |