+ * The mode of an {@link CommunicationConnection} can be one of the following enum values. This makes it possible use + * the connection without starting connection and later starting the connection when required + *
+ * The modes have the following semantics: + *+ * a {@link CommunicationConnection} undergoes a serious of state changes. These states can be viewed by a client to + * monitor the state of the connection + *
+ * The states have the following semantics: + *+ * An {@link IoMessage} is the object containing the data to be transmitted in IO. Implementations of + * {@link CommunicationConnection} should implement sub classes of this method to hold the actual payload. + *
+ * + *+ * This class also contains a {@link Map} to store transient meta data to the actual payload + *
+ * + * @author Robert von Burg+ * Visitors to read and write {@link IoMessage} using different kind of endpoints. Different endpoints will require + * different ways of writing or reading message, thus this is not defined here. Known extensions are + * {@link ConsoleMessageVisitor}, {@link StreamMessageVisitor}. + *
+ * + *+ * Concrete implementations must be thread safe! + *
+ * + * @author Robert von Burg+ * {@link IoMessageVisitor} to read or write using IO Streams. + *
+ * + *+ * Concrete implementations must be thread safe! + *
+ * + * @author Robert von Burg+ * This {@link CommunicationEndpoint} is an abstract implementation with everything needed to connect through a + * {@link Socket} to a remote server which is listening for incoming {@link Socket} connections. This {@link Socket} + * endpoint can send messages to the remote side, as well as receive messages from the remote side + *
+ *+ * This endpoint is maintained as a client connection. This means that this endpoint opens the {@link Socket} to the + * remote server + *
+ * + * @author Robert von Burg+ * Configures this {@link ClientSocketEndpoint} + *
+ * gets the parameter map from the connection and reads the following parameters from the map: + *+ * This {@link CommunicationEndpoint} is an abstract implementation with everything needed to start a {@link Socket} + * server which waits for a request from a single client + *
+ *+ * This end point only allows a single connection at a time and implements all exception handling for opening and + * closing a {@link Socket} connection + *
+ * + * @see ServerSocketEndpoint#configure(CommunicationConnection, IoMessageVisitor) for details on configuring the end + * point + * + * @author Robert von Burg+ * Configures this {@link ServerSocketEndpoint} + *
+ * gets the parameter map from the connection and reads the following parameters from the map: + *+ * Returns {@link StringMatchMode#EQUALS_CASE_SENSITIVE} + *
+ * + *+ * Short method, useful for static imports, or simply for shorter code + *
+ * + * @return {@link StringMatchMode#EQUALS_CASE_SENSITIVE} + */ + public static StringMatchMode es() { + return EQUALS_CASE_SENSITIVE; + } + + /** + *+ * Returns {@link #EQUALS_CASE_INSENSITIVE} + *
+ * + *+ * Short method, useful for static imports, or simply for shorter code + *
+ * + * @return {@link #EQUALS_CASE_INSENSITIVE} + */ + public static StringMatchMode ei() { + return EQUALS_CASE_INSENSITIVE; + } + + /** + *+ * Returns {@link #CONTAINS_CASE_SENSITIVE} + *
+ * + *+ * Short method, useful for static imports, or simply for shorter code + *
+ * + * @return {@link #CONTAINS_CASE_SENSITIVE} + */ + public static StringMatchMode cs() { + return CONTAINS_CASE_SENSITIVE; + } + + /** + *+ * Returns {@link #CONTAINS_CASE_INSENSITIVE} + *
+ * + *+ * Short method, useful for static imports, or simply for shorter code + *
+ * + * @return {@link #CONTAINS_CASE_INSENSITIVE} + */ + public static StringMatchMode ci() { + return CONTAINS_CASE_INSENSITIVE; + } +} diff --git a/ch.eitchnet.utils/src/main/java/ch/eitchnet/utils/Version.java b/ch.eitchnet.utils/src/main/java/ch/eitchnet/utils/Version.java new file mode 100644 index 000000000..7b6b93dd6 --- /dev/null +++ b/ch.eitchnet.utils/src/main/java/ch/eitchnet/utils/Version.java @@ -0,0 +1,507 @@ +package ch.eitchnet.utils; + +import java.util.NoSuchElementException; +import java.util.StringTokenizer; + +import ch.eitchnet.utils.helper.StringHelper; + +/** + * This class has been adapted from org.osgi.framework.Version + * + * Version identifier. + * + *+ * Version identifiers have four components. + *
+ * The grammar for parsing version strings is as follows: + * + *
+ * version ::= major('.'minor('.'micro('.'qualifier)?)?)?
+ * major ::= digit+
+ * minor ::= digit+
+ * micro ::= digit+
+ * qualifier ::= (alpha|digit|'_'|'-')+
+ * digit ::= [0..9]
+ * alpha ::= [a..zA..Z]
+ *
+ *
+ * Note: There must be no whitespace in version.
+ *
+ *
+ * + * Note: {@code Version} objects are immutable and thus thread safe + *
+ */ +public class Version implements Comparable+ * The qualifier is set to the empty string. + * + * @param major + * Major component of the version identifier. + * @param minor + * Minor component of the version identifier. + * @param micro + * Micro component of the version identifier. + * @throws IllegalArgumentException + * If the numerical components are negative. + */ + public Version(final int major, final int minor, final int micro) { + this(major, minor, micro, null); + } + + /** + * Creates a version identifier from the specified components. This instance will have {@link #isOsgiStyle()} return + * false + * + * @param major + * Major component of the version identifier. + * @param minor + * Minor component of the version identifier. + * @param micro + * Micro component of the version identifier. + * @param qualifier + * Qualifier component of the version identifier. If {@code null} is specified, then the qualifier will + * be set to the empty string. + * + * @throws IllegalArgumentException + * If the numerical components are negative or the qualifier string is invalid. + */ + public Version(final int major, final int minor, final int micro, String qualifier) { + this(major, minor, micro, null, false); + } + + /** + * Creates a version identifier from the specified components. + * + * @param major + * Major component of the version identifier. + * @param minor + * Minor component of the version identifier. + * @param micro + * Micro component of the version identifier. + * @param qualifier + * Qualifier component of the version identifier. If {@code null} is specified, then the qualifier will + * be set to the empty string. + * @param osgiStyle + * if true, then this is an osgi style version, otherwise not + * + * @throws IllegalArgumentException + * If the numerical components are negative or the qualifier string is invalid. + */ + public Version(final int major, final int minor, final int micro, String qualifier, boolean osgiStyle) { + this.major = major; + this.minor = minor; + this.micro = micro; + this.qualifier = qualifier == null ? "" : qualifier; + this.versionString = null; + validate(); + } + + /** + *
+ * Creates a version identifier from the specified string. + *
+ * + * @param version + * String representation of the version identifier. + * + * @throws IllegalArgumentException + * If {@code version} is improperly formatted. + */ + private Version(final String version) { + int maj = 0; + int min = 0; + int mic = 0; + String qual = StringHelper.EMPTY; + + try { + StringTokenizer st = new StringTokenizer(version, + SEPARATOR + MAVEN_QUALIFIER_SEPARATOR + OSGI_QUALIFIER_SEPARATOR, true); + maj = Integer.parseInt(st.nextToken()); + + if (st.hasMoreTokens()) { // minor + st.nextToken(); // consume delimiter + min = Integer.parseInt(st.nextToken()); + + if (st.hasMoreTokens()) { // micro + st.nextToken(); // consume delimiter + mic = Integer.parseInt(st.nextToken()); + + if (st.hasMoreTokens()) { // qualifier + + String qualifierSeparator = st.nextToken(); // consume delimiter + this.osgiStyle = qualifierSeparator.equals(OSGI_QUALIFIER_SEPARATOR); + + qual = st.nextToken(StringHelper.EMPTY); // remaining string + + if (st.hasMoreTokens()) { // fail safe + throw new IllegalArgumentException("invalid format: " + version); + } + } + } + } + } catch (NoSuchElementException e) { + IllegalArgumentException iae = new IllegalArgumentException("invalid format: " + version); + iae.initCause(e); + throw iae; + } + + this.major = maj; + this.minor = min; + this.micro = mic; + this.qualifier = qual; + this.versionString = null; + validate(); + } + + /** + * Called by the Version constructors to validate the version components. + * + * @throws IllegalArgumentException + * If the numerical components are negative or the qualifier string is invalid. + */ + private void validate() { + if (this.major < 0) { + throw new IllegalArgumentException("negative major"); + } + if (this.minor < 0) { + throw new IllegalArgumentException("negative minor"); + } + if (this.micro < 0) { + throw new IllegalArgumentException("negative micro"); + } + char[] chars = this.qualifier.toCharArray(); + for (char ch : chars) { + if (('A' <= ch) && (ch <= 'Z')) { + continue; + } + if (('a' <= ch) && (ch <= 'z')) { + continue; + } + if (('0' <= ch) && (ch <= '9')) { + continue; + } + if ((ch == '_') || (ch == '-')) { + continue; + } + throw new IllegalArgumentException("invalid qualifier: " + this.qualifier); + } + } + + public Boolean isFullyQualified() { + return !this.qualifier.isEmpty(); + } + + /** + * Parses a version identifier from the specified string. + * + *+ * See {@code Version(String)} for the format of the version string. + * + * @param version + * String representation of the version identifier. Leading and trailing whitespace will be ignored. + * + * @return A {@code Version} object representing the version identifier. If {@code version} is {@code null} or the + * empty string then {@code emptyVersion} will be returned. + * + * @throws IllegalArgumentException + * If {@code version} is improperly formatted. + */ + public static Version valueOf(String version) { + if (version == null) + return emptyVersion; + + String trimmedVersion = version.trim(); + if (trimmedVersion.length() == 0) + return emptyVersion; + + return new Version(trimmedVersion); + } + + /** + * Returns true if the given version string can be parsed, meaning a {@link Version} instance can be instantiated + * with it + * + * @param version + * String representation of the version identifier. Leading and trailing whitespace will be ignored. + * + * @return true if no parse errors occurr + */ + public static boolean isParseable(String version) { + try { + valueOf(version); + return true; + } catch (IllegalArgumentException e) { + return false; + } + } + + /** + * Returns the major component of this version identifier. + * + * @return The major component. + */ + public int getMajor() { + return this.major; + } + + /** + * Returns the minor component of this version identifier. + * + * @return The minor component. + */ + public int getMinor() { + return this.minor; + } + + /** + * Returns the micro component of this version identifier. + * + * @return The micro component. + */ + public int getMicro() { + return this.micro; + } + + /** + * Returns the qualifier component of this version identifier. + * + * @return The qualifier component. + */ + public String getQualifier() { + return this.qualifier; + } + + /** + * Returns a new {@link Version} where each version number is incremented or decreased by the given parameters + * + * @param major + * the value to increase or decrease the major part of the version + * @param minor + * the value to increase or decrease the minor part of the version + * @param micro + * the value to increase or decrease the micro part of the version + * + * @return the new Version with the version parts modified as passed in by the parameters + */ + public Version add(int major, int minor, int micro) { + return new Version(this.major + major, this.minor + minor, this.micro + micro, this.qualifier, this.osgiStyle); + } + + /** + * @return true if this is an OSGI style version, i.e. if has a qualifier, then osgi defines how the qualifier is + * appended to the version + */ + public boolean isOsgiStyle() { + return this.osgiStyle; + } + + /** + * @return true if this version is for a snapshot version, i.e. ends with {@link #MAVEN_SNAPSHOT_QUALIFIER} or + * {@link #OSGI_SNAPSHOT_QUALIFIER} + */ + public boolean isSnapshot() { + return MAVEN_SNAPSHOT_QUALIFIER.equals(this.qualifier) || OSGI_SNAPSHOT_QUALIFIER.equals(this.qualifier); + } + + /** + * Returns a hash code value for the object. + * + * @return An integer which is a hash code value for this object. + */ + @Override + public int hashCode() { + return (this.major << 24) + (this.minor << 16) + (this.micro << 8) + this.qualifier.hashCode(); + } + + /** + * Compares this {@code Version} object to another object. + * + *
+ * A version is considered to be equal to another version if the major, minor and micro components are equal + * and the qualifier component is equal (using {@code String.equals}). + * + * @param object + * The {@code Version} object to be compared. + * @return {@code true} if {@code object} is a {@code Version} and is equal to this object; {@code false} otherwise. + */ + @Override + public boolean equals(final Object object) { + if (object == this) + return true; + if (!(object instanceof Version)) + return false; + + Version other = (Version) object; + return (this.major == other.major) && (this.minor == other.minor) && (this.micro == other.micro) + && this.qualifier.equals(other.qualifier); + } + + /** + * Compares this {@code Version} object to another object ignoring the qualifier part. + * + *
+ * A version is considered to be equal to another version if the major, minor and micro components are + * equal. + * + * @param object + * The {@code Version} object to be compared. + * @return {@code true} if {@code object} is a {@code Version} and is equal to this object; {@code false} otherwise. + */ + public boolean equalsIgnoreQualifier(final Object object) { + if (object == this) + return true; + if (!(object instanceof Version)) + return false; + + Version other = (Version) object; + return (this.major == other.major) && (this.minor == other.minor) && (this.micro == other.micro); + } + + /** + * Compares this {@code Version} object to another {@code Version}. + * + *
+ * A version is considered to be less than another version if its major component is less than the other + * version's major component, or the major components are equal and its minor component is less than the other + * version's minor component, or the major and minor components are equal and its micro component is less than the + * other version's micro component, or the major, minor and micro components are equal and it's qualifier component + * is less than the other version's qualifier component (using {@code String.compareTo}). + * + *
+ * A version is considered to be equal to another version if the major, minor and micro components are equal + * and the qualifier component is equal (using {@code String.compareTo}). + * + * @param other + * The {@code Version} object to be compared. + * @return A negative integer, zero, or a positive integer if this version is less than, equal to, or greater than + * the specified {@code Version} object. + * @throws ClassCastException + * If the specified object is not a {@code Version} object. + */ + @Override + public int compareTo(final Version other) { + if (other == this) + return 0; + + int result = this.major - other.major; + if (result != 0) + return result; + + result = this.minor - other.minor; + if (result != 0) + return result; + + result = this.micro - other.micro; + if (result != 0) + return result; + + return this.qualifier.compareTo(other.qualifier); + } + + /** + * Returns the string representation of this version identifier. + * + *
+ * The format of the version string will be {@code major.minor.micro} if qualifier is the empty string or
+ * {@code major.minor.micro.qualifier} otherwise.
+ *
+ * @return The string representation of this version identifier.
+ */
+ @Override
+ public String toString() {
+ if (this.versionString == null)
+ this.versionString = toString(this.osgiStyle);
+ return this.versionString;
+ }
+
+ private String toString(final boolean withOsgiStyle) {
+ int q = this.qualifier.length();
+ StringBuilder result = new StringBuilder(20 + q);
+ result.append(this.major);
+ result.append(SEPARATOR);
+ result.append(this.minor);
+ result.append(SEPARATOR);
+ result.append(this.micro);
+ if (q > 0) {
+ if (withOsgiStyle) {
+ result.append(OSGI_QUALIFIER_SEPARATOR);
+ } else {
+ result.append(MAVEN_QUALIFIER_SEPARATOR);
+ }
+ result.append(createQualifier(withOsgiStyle));
+ }
+ return result.toString();
+ }
+
+ private String createQualifier(boolean withOsgiStyle) {
+ if (this.qualifier.equals(MAVEN_SNAPSHOT_QUALIFIER) || this.qualifier.equals(OSGI_SNAPSHOT_QUALIFIER)) {
+ if (withOsgiStyle)
+ return OSGI_SNAPSHOT_QUALIFIER;
+ return MAVEN_SNAPSHOT_QUALIFIER;
+ }
+
+ return this.qualifier;
+ }
+
+ /**
+ * @return This version represented in a maven compatible form.
+ */
+ public String toMavenStyleString() {
+ return toString(false);
+ }
+
+ /**
+ * @return This version represented in an OSGi compatible form.
+ */
+ public String toOsgiStyleString() {
+ return toString(true);
+ }
+
+ /**
+ * @return This only the major and minor version in a string
+ */
+ public String toMajorAndMinorString() {
+ StringBuilder result = new StringBuilder(20);
+ result.append(this.major);
+ result.append(SEPARATOR);
+ result.append(this.minor);
+ return result.toString();
+ }
+}
diff --git a/ch.eitchnet.utils/src/main/java/ch/eitchnet/utils/collections/DateRange.java b/ch.eitchnet.utils/src/main/java/ch/eitchnet/utils/collections/DateRange.java
new file mode 100644
index 000000000..b4410b8a9
--- /dev/null
+++ b/ch.eitchnet.utils/src/main/java/ch/eitchnet/utils/collections/DateRange.java
@@ -0,0 +1,133 @@
+/*
+ * Copyright 2013 Robert von Burg
+ * Collection to store a tree with a depth of 3 elements. This solves having to always write the declaration:
+ *
+ * As an example to persist a map of MyObject where the branches are String one would write it as follows:
+ *
+ * This class implements the encoding and decoding of RFC 4648 https://tools.ietf.org/html/rfc4648.
+ *
+ * The following implementations are supported:
+ *
+ * Map<String, Map&lgt;String, MyObject>> mapOfMaps = new HashMap<>;
+ *
+ *
+ *
+ * MapOfMaps<String, String, MyObject> mapOfMaps = new MapOfMaps<>();
+ *
+ *
+ *
+ * @author Robert von Burg
+ * Description: Null character
+ */
+ public static final char NUL = (char) 0; // Null character
+
+ /**
+ * ASCII Value 1, interpretation: SOH
+ * Description: Start of Header
+ */
+ public static final char SOH = (char) 1; // Start of Header
+
+ /**
+ * ASCII Value 2, interpretation: STX
+ * Description: Start of Text
+ */
+ public static final char STX = (char) 2; // Start of Text
+
+ /**
+ * ASCII Value 3, interpretation: ETX
+ * Description: End of Text
+ */
+ public static final char ETX = (char) 3; // End of Text
+
+ /**
+ * ASCII Value 4, interpretation: EOT
+ * Description: End of Transmission
+ */
+ public static final char EOT = (char) 4; // End of Transmission
+
+ /**
+ * ASCII Value 5, interpretation: ENQ
+ * Description: Enquiry
+ */
+ public static final char ENQ = (char) 5; // Enquiry
+
+ /**
+ * ASCII Value 6, interpretation: ACK
+ * Description: Acknowledgement
+ */
+ public static final char ACK = (char) 6; // Acknowledgement
+
+ /**
+ * ASCII Value 7, interpretation: BEL
+ * Description: Bell
+ */
+ public static final char BEL = (char) 7; // Bell
+
+ /**
+ * ASCII Value 8, interpretation: BS
+ * Description: Backspace
+ */
+ public static final char BS = (char) 8; // Backspace
+
+ /**
+ * ASCII Value 9, interpretation: HT
+ * Description: Horizontal Tab
+ */
+ public static final char HT = (char) 9; // Horizontal Tab
+
+ /**
+ * ASCII Value 10, interpretation: LF
+ * Description: Line Feed
+ */
+ public static final char LF = (char) 10; // Line Feed
+
+ /**
+ * ASCII Value 11, interpretation: VT
+ * Description: Vertical Tab
+ */
+ public static final char VT = (char) 11; // Vertical Tab
+
+ /**
+ * ASCII Value 12, interpretation: FF
+ * Description: Form Feed
+ */
+ public static final char FF = (char) 12; // Form Feed
+
+ /**
+ * ASCII Value 13, interpretation: CR
+ * Description: Carriage Return
+ */
+ public static final char CR = (char) 13; // Carriage Return
+
+ /**
+ * ASCII Value 14, interpretation: SO
+ * Description: Shift Out
+ */
+ public static final char SO = (char) 14; // Shift Out
+
+ /**
+ * ASCII Value 15, interpretation: SI
+ * Description: Shift In
+ */
+ public static final char SI = (char) 15; // Shift In
+
+ /**
+ * ASCII Value 16, interpretation: DLE
+ * Description: Data Link Escape
+ */
+ public static final char DLE = (char) 16; // Data Link Escape
+
+ /**
+ * ASCII Value 17, interpretation: DC1
+ * Description: (XON) Device Control 1
+ */
+ public static final char DC1 = (char) 17; // (XON) Device Control 1
+
+ /**
+ * ASCII Value 18, interpretation: DC2
+ * Description: Device Control 2
+ */
+ public static final char DC2 = (char) 18; // Device Control 2
+
+ /**
+ * ASCII Value 19 interpretation: DC3
+ * Description: (XOFF) Device Control 3
+ */
+ public static final char DC3 = (char) 19; // (XOFF) Device Control 3
+
+ /**
+ * ASCII Value 20, interpretation: DC4
+ * Description: Device Control 4
+ */
+ public static final char DC4 = (char) 20; // Device Control 4
+
+ /**
+ * ASCII Value 21, interpretation: NAK
+ * Description: Negative Acknowledgment
+ */
+ public static final char NAK = (char) 21; // Negative Acknowledgment
+
+ /**
+ * ASCII Value 22, interpretation: SYN
+ * Description: Synchronous Idle
+ */
+ public static final char SYN = (char) 22; // Synchronous Idle
+
+ /**
+ * ASCII Value 23, interpretation: ETB
+ * Description: End of Transmission Block
+ */
+ public static final char ETB = (char) 23; // End of Transmission Block
+
+ /**
+ * ASCII Value 24, interpretation: CAN
+ * Description: Cancel
+ */
+ public static final char CAN = (char) 24; // Cancel
+
+ /**
+ * ASCII Value 25, interpretation: EM
+ * Description: End of Medium
+ */
+ public static final char EM = (char) 25; // End of Medium
+
+ /**
+ * ASCII Value 26, interpretation: SUB
+ * Description: Substitute
+ */
+ public static final char SUB = (char) 26; // Substitute
+
+ /**
+ * ASCII Value 27, interpretation: ESC
+ * Description: Escape
+ */
+ public static final char ESC = (char) 27; // Escape
+
+ /**
+ * ASCII Value 28, interpretation: FS
+ * Description: File Separator
+ */
+ public static final char FS = (char) 28; // File Separator
+
+ /**
+ * ASCII Value 29, interpretation: GS
+ * Description: Group Separator
+ */
+ public static final char GS = (char) 29; // Group Separator
+
+ /**
+ * ASCII Value 30, interpretation: RS
+ * Description: Request to Send (Record Separator)
+ */
+ public static final char RS = (char) 30; // Request to Send (Record Separator)
+
+ /**
+ * ASCII Value 31, interpretation: US
+ * Description: Unit Separator
+ */
+ public static final char US = (char) 31; // Unit Separator
+
+ /**
+ * ASCII Value 32, interpretation: SP
+ * Description: Space
+ */
+ public static final char SP = (char) 32; // Space
+
+ /**
+ * ASCII Value 127, interpretation: DEL
+ * Description: Delete
+ */
+ public static final char DEL = (char) 127; // Delete
+
+ /**
+ * Returns the ASCII Text of a certain bye value
+ *
+ * @param b
+ * @return String
+ */
+ public static String getAsciiText(byte b) {
+ return getAsciiText((char) b);
+ }
+
+ /**
+ * Returns the ASCII Text of a certain char value
+ *
+ * @param c
+ * @return String
+ */
+ @SuppressWarnings("nls")
+ public static String getAsciiText(char c) {
+ // else if(c == ) { return "";}
+ if (c == NUL) {
+ return "NUL";
+ } else if (c == SOH) {
+ return "SOH";
+ } else if (c == STX) {
+ return "STX";
+ } else if (c == ETX) {
+ return "ETX";
+ } else if (c == EOT) {
+ return "EOT";
+ } else if (c == ENQ) {
+ return "ENQ";
+ } else if (c == ACK) {
+ return "ACK";
+ } else if (c == BEL) {
+ return "BEL";
+ } else if (c == BS) {
+ return "BS";
+ } else if (c == HT) {
+ return "HT";
+ } else if (c == LF) {
+ return "LF";
+ } else if (c == VT) {
+ return "VT";
+ } else if (c == FF) {
+ return "FF";
+ } else if (c == CR) {
+ return "CR";
+ } else if (c == SO) {
+ return "SO";
+ } else if (c == SI) {
+ return "SI";
+ } else if (c == DLE) {
+ return "DLE";
+ } else if (c == DC1) {
+ return "DC1";
+ } else if (c == DC2) {
+ return "DC2";
+ } else if (c == DC3) {
+ return "DC3";
+ } else if (c == DC4) {
+ return "DC4";
+ } else if (c == NAK) {
+ return "NAK";
+ } else if (c == SYN) {
+ return "SYN";
+ } else if (c == ETB) {
+ return "ETB";
+ } else if (c == CAN) {
+ return "CAN";
+ } else if (c == EM) {
+ return "EM";
+ } else if (c == SUB) {
+ return "SUB";
+ } else if (c == ESC) {
+ return "ESC";
+ } else if (c == FS) {
+ return "FS";
+ } else if (c == GS) {
+ return "GS";
+ } else if (c == RS) {
+ return "RS";
+ } else if (c == US) {
+ return "US";
+ } else if (c == SP) {
+ return "SP";
+ } else if (c == DEL) {
+ return "DEL";
+ } else if ((c) > 32 && (c) < 127) {
+ return String.valueOf(c);
+ } else {
+ return "(null:" + (byte) c + ")";
+ }
+ }
+}
diff --git a/ch.eitchnet.utils/src/main/java/ch/eitchnet/utils/helper/BaseEncoding.java b/ch.eitchnet.utils/src/main/java/ch/eitchnet/utils/helper/BaseEncoding.java
new file mode 100644
index 000000000..8a3437a49
--- /dev/null
+++ b/ch.eitchnet.utils/src/main/java/ch/eitchnet/utils/helper/BaseEncoding.java
@@ -0,0 +1,1008 @@
+/*
+ * Copyright 2013 Robert von Burg
+ *
+ *
+ * As a further bonus, it is possible to use the algorithm with a client specified alphabet. In this case the client is + * responsible for generating the alphabet for use in the decoding + *
+ * + *+ * This class also implements a number of utility methods to check if given data is in a valid encoding + *
+ * + * @author Robert von Burg+ * Returns a message for the given {@link Throwable} + *
+ * + *
+ * A {@link NullPointerException} only has null as the message so this methods returns the class name
+ * in such a case
+ *
+ * Returns a message for the given {@link Throwable} + *
+ * + *
+ * A {@link NullPointerException} only has null as the message so this methods returns the class name
+ * in such a case
+ *
+ * Copy a given list of {@link File Files}. Recursively copies the files and directories to the destination. + *
+ * + * @param srcFiles + * The source files to copy + * @param dstDirectory + * The destination where to copy the files + * @param checksum + * if true, then a MD5 checksum is made to validate copying + * @return true if and only if the copying succeeded; false otherwise + */ + public final static boolean copy(File[] srcFiles, File dstDirectory, boolean checksum) { + + if (!dstDirectory.isDirectory() || !dstDirectory.canWrite()) { + String msg = "Destination is not a directory or is not writeable: {0}"; //$NON-NLS-1$ + throw new IllegalArgumentException(MessageFormat.format(msg, dstDirectory.getAbsolutePath())); + } + + for (File srcFile : srcFiles) { + + File dstFile = new File(dstDirectory, srcFile.getName()); + if (srcFile.isDirectory()) { + dstFile.mkdir(); + if (!copy(srcFile.listFiles(), dstFile, checksum)) { + String msg = "Failed to copy contents of {0} to {1}"; //$NON-NLS-1$ + msg = MessageFormat.format(msg, srcFile.getAbsolutePath(), dstFile.getAbsolutePath()); + logger.error(msg); + return false; + } + } else { + if (!copy(srcFile, dstFile, checksum)) { + return false; + } + } + } + + return true; + } + + /** + * Copy a {@link File} The renameTo method does not allow action across NFS mounted filesystems this method is the + * workaround + * + * @param fromFile + * The existing File + * @param toFile + * The new File + * @param checksum + * if true, then a MD5 checksum is made to validate copying + * @return true if and only if the renaming succeeded; false otherwise + */ + public final static boolean copy(File fromFile, File toFile, boolean checksum) { + + try (BufferedInputStream inBuffer = new BufferedInputStream(new FileInputStream(fromFile)); + BufferedOutputStream outBuffer = new BufferedOutputStream(new FileOutputStream(toFile));) { + + int theByte = 0; + + while ((theByte = inBuffer.read()) > -1) { + outBuffer.write(theByte); + } + + outBuffer.flush(); + + if (checksum) { + String fromFileMD5 = StringHelper.getHexString(FileHelper.hashFileMd5(fromFile)); + String toFileMD5 = StringHelper.getHexString(FileHelper.hashFileMd5(toFile)); + if (!fromFileMD5.equals(toFileMD5)) { + FileHelper.logger.error(MessageFormat.format( + "Copying failed, as MD5 sums are not equal: {0} / {1}", fromFileMD5, toFileMD5)); //$NON-NLS-1$ + toFile.delete(); + + return false; + } + } + + // cleanup if files are not the same length + if (fromFile.length() != toFile.length()) { + String msg = "Copying failed, as new files are not the same length: {0} / {1}"; //$NON-NLS-1$ + msg = MessageFormat.format(msg, fromFile.length(), toFile.length()); + FileHelper.logger.error(msg); + toFile.delete(); + + return false; + } + + } catch (Exception e) { + String msg = MessageFormat.format("Failed to copy path from {0} to + {1} due to:", fromFile, toFile); //$NON-NLS-1$ + FileHelper.logger.error(msg, e); + return false; + } + + return true; + } + + /** + * Move a File The renameTo method does not allow action across NFS mounted filesystems this method is the + * workaround + * + * @param fromFile + * The existing File + * @param toFile + * The new File + * @return true if and only if the renaming succeeded; false otherwise + */ + public final static boolean move(File fromFile, File toFile) { + + if (fromFile.renameTo(toFile)) { + return true; + } + + FileHelper.logger.warn("Simple File.renameTo failed, trying copy/delete..."); //$NON-NLS-1$ + + // delete if copy was successful, otherwise move will fail + if (FileHelper.copy(fromFile, toFile, true)) { + FileHelper.logger.info("Deleting fromFile: " + fromFile.getAbsolutePath()); //$NON-NLS-1$ + return fromFile.delete(); + } + + return false; + } + + /** + * Finds the common parent for the files in the given list + * + * @param files + * the files to find the common parent for + * + * @return the {@link File} representing the common parent, or null if there is none + */ + public static File findCommonParent(List+ * Note: this implementation tests if the value < bound, and if this is not so, checks if the values are equal under + * the precision. Thus, it's efficient whenever the value is expected to be smaller than the bound. + * + * @param value + * The value to check + * @param bound + * The bound given + * @return true, if value < bound under the given precision. False, otherwise. + */ + public static boolean isSmallerEqualPrecision(double value, double bound) { + if (value < bound) + return true; + return isEqualPrecision(value, bound); + } + + /** + * Comparison between two values. Given the precision, this function determines if the given value is greater than + * the given bound. + *
+ * Note: This implementation tests if value > bound and, if it is so, if equality does NOT hold. Thus, it is + * efficient whenever the value is not expected to be greater than the bound. + * + * @param value + * The value to check + * @param bound + * The bound given. + * @return true, if value > bound and the values do not test equal under precision. False, otherwise. + */ + public static boolean isGreaterPrecision(double value, double bound) { + return (value > bound) && !isEqualPrecision(value, bound); + } + + /** + *
+ * Rounds the given double value to the number of decimals + *
+ * + *+ * Warning: Do not use the returned value for further calculations. Always finish calculates and use one of + * the following methods: + *
prefix{...} sequences. Theses sequences are
+ * replaced with a {@link Properties#getProperty(String)} value if such a value exists in the properties map. If the
+ * value of the sequence is not in the properties, then the sequence is not replaced
+ *
+ * @param properties
+ * the {@link Properties} in which to get the value
+ * @param prefix
+ * the prefix to use, for instance use $ to replace occurrences of ${...}
+ * @param value
+ * the value in which to replace any system properties
+ *
+ * @return a new string with all defined properties replaced or if an error occurred the original value is returned
+ */
+ public static String replacePropertiesIn(Properties properties, char prefix, String value) {
+
+ String prefixS = String.valueOf(prefix);
+
+ // get a copy of the value
+ String tmpValue = value;
+
+ // get first occurrence of $ character
+ int pos = -1;
+ int stop = 0;
+
+ // loop on $ character positions
+ while ((pos = tmpValue.indexOf(prefix, pos + 1)) != -1) {
+
+ // if pos+1 is not { character then continue
+ if (tmpValue.charAt(pos + 1) != '{') {
+ continue;
+ }
+
+ // find end of sequence with } character
+ stop = tmpValue.indexOf('}', pos + 1);
+
+ // if no stop found, then break as another sequence should be able to start
+ if (stop == -1) {
+ logger.error(MessageFormat.format("Sequence starts at offset {0} but does not end!", pos)); //$NON-NLS-1$
+ tmpValue = value;
+ break;
+ }
+
+ // get sequence enclosed by pos and stop
+ String sequence = tmpValue.substring(pos + 2, stop);
+
+ // make sure sequence doesn't contain $ { } characters
+ if (sequence.contains(prefixS) || sequence.contains("{") || sequence.contains("}")) { //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+ String msg = "Enclosed sequence in offsets {0} - {1} contains one of the illegal chars: {2} { }: {3}";
+ msg = MessageFormat.format(msg, pos, stop, prefixS, sequence);
+ logger.error(msg);
+ tmpValue = value;
+ break;
+ }
+
+ // sequence is good, so see if we have a property for it
+ String property = properties.getProperty(sequence, StringHelper.EMPTY);
+
+ // if no property exists, then log and continue
+ if (property.isEmpty()) {
+ // logger.warn("No system property found for sequence " + sequence);
+ continue;
+ }
+
+ // property exists, so replace in value
+ tmpValue = tmpValue.replace(prefixS + "{" + sequence + "}", property); //$NON-NLS-1$ //$NON-NLS-2$
+ }
+
+ return tmpValue;
+ }
+
+ /**
+ * Calls {@link #replaceProperties(Properties, Properties)} with null as the second argument. This allows for
+ * replacing all properties with itself
+ *
+ * @param properties
+ * the properties in which the values must have any ${...} replaced by values of the respective key
+ */
+ public static void replaceProperties(Properties properties) {
+ replaceProperties(properties, null);
+ }
+
+ /**
+ * Checks every value in the {@link Properties} and then then replaces any ${...} variables with keys in this
+ * {@link Properties} value using {@link StringHelper#replacePropertiesIn(Properties, String)}
+ *
+ * @param properties
+ * the properties in which the values must have any ${...} replaced by values of the respective key
+ * @param altProperties
+ * if properties does not contain the ${...} key, then try these alternative properties
+ */
+ public static void replaceProperties(Properties properties, Properties altProperties) {
+
+ for (Object keyObj : properties.keySet()) {
+ String key = (String) keyObj;
+ String property = properties.getProperty(key);
+ String newProperty = replacePropertiesIn(properties, property);
+
+ // try first properties
+ if (!property.equals(newProperty)) {
+ // logger.info("Key " + key + " has replaced property " + property + " with new value " + newProperty);
+ properties.put(key, newProperty);
+ } else if (altProperties != null) {
+
+ // try alternative properties
+ newProperty = replacePropertiesIn(altProperties, property);
+ if (!property.equals(newProperty)) {
+ // logger.info("Key " + key + " has replaced property " + property + " from alternative properties with new value " + newProperty);
+ properties.put(key, newProperty);
+ }
+ }
+ }
+ }
+
+ /**
+ * This is a helper method with which it is possible to print the location in the two given strings where they start
+ * to differ. The length of string returned is currently 40 characters, or less if either of the given strings are
+ * shorter. The format of the string is 3 lines. The first line has information about where in the strings the
+ * difference occurs, and the second and third lines contain contexts
+ *
+ * @param s1
+ * the first string
+ * @param s2
+ * the second string
+ *
+ * @return the string from which the strings differ with a length of 40 characters within the original strings
+ */
+ public static String printUnequalContext(String s1, String s2) {
+
+ byte[] bytes1 = s1.getBytes();
+ byte[] bytes2 = s2.getBytes();
+ int i = 0;
+ for (; i < bytes1.length; i++) {
+ if (i > bytes2.length)
+ break;
+
+ if (bytes1[i] != bytes2[i])
+ break;
+ }
+
+ int maxContext = 40;
+ int start = Math.max(0, (i - maxContext));
+ int end = Math.min(i + maxContext, (Math.min(bytes1.length, bytes2.length)));
+
+ StringBuilder sb = new StringBuilder();
+ sb.append("Strings are not equal! Start of inequality is at " + i); //$NON-NLS-1$
+ sb.append(". Showing " + maxContext); //$NON-NLS-1$
+ sb.append(" extra characters and start and end:\n"); //$NON-NLS-1$
+ sb.append("context s1: "); //$NON-NLS-1$
+ sb.append(s1.substring(start, end));
+ sb.append("\n"); //$NON-NLS-1$
+ sb.append("context s2: "); //$NON-NLS-1$
+ sb.append(s2.substring(start, end));
+ sb.append("\n"); //$NON-NLS-1$
+
+ return sb.toString();
+ }
+
+ /**
+ * Formats the given number of milliseconds to a time like #h/m/s/ms/us/ns
+ *
+ * @param millis
+ * the number of milliseconds
+ *
+ * @return format the given number of milliseconds to a time like #h/m/s/ms/us/ns
+ */
+ public static String formatMillisecondsDuration(final long millis) {
+ return formatNanoDuration(millis * 1000000L);
+ }
+
+ /**
+ * Formats the given number of nanoseconds to a time like #h/m/s/ms/us/ns
+ *
+ * @param nanos
+ * the number of nanoseconds
+ *
+ * @return format the given number of nanoseconds to a time like #h/m/s/ms/us/ns
+ */
+ public static String formatNanoDuration(final long nanos) {
+ if (nanos >= 3600000000000L) {
+ return String.format("%.0fh", (nanos / 3600000000000.0D)); //$NON-NLS-1$
+ } else if (nanos >= 60000000000L) {
+ return String.format("%.0fm", (nanos / 60000000000.0D)); //$NON-NLS-1$
+ } else if (nanos >= 1000000000L) {
+ return String.format("%.0fs", (nanos / 1000000000.0D)); //$NON-NLS-1$
+ } else if (nanos >= 1000000L) {
+ return String.format("%.0fms", (nanos / 1000000.0D)); //$NON-NLS-1$
+ } else if (nanos >= 1000L) {
+ return String.format("%.0fus", (nanos / 1000.0D)); //$NON-NLS-1$
+ } else {
+ return nanos + "ns"; //$NON-NLS-1$
+ }
+ }
+
+ /**
+ * @see ExceptionHelper#formatException(Throwable)
+ */
+ public static String getExceptionMessage(Throwable t) {
+ return ExceptionHelper.getExceptionMessage(t);
+ }
+
+ /**
+ * @see ExceptionHelper#formatException(Throwable)
+ */
+ public static String formatException(Throwable t) {
+ return ExceptionHelper.formatException(t);
+ }
+
+ /**
+ * @see ExceptionHelper#formatExceptionMessage(Throwable)
+ */
+ public static String formatExceptionMessage(Throwable t) {
+ return ExceptionHelper.formatExceptionMessage(t);
+ }
+
+ /**
+ * Simply returns true if the value is null, or empty
+ *
+ * @param value
+ * the value to check
+ *
+ * @return true if the value is null, or empty
+ */
+ public static boolean isEmpty(String value) {
+ return value == null || value.isEmpty();
+ }
+
+ /**
+ * Simply returns true if the value is neither null nor empty
+ *
+ * @param value
+ * the value to check
+ *
+ * @return true if the value is neither null nor empty
+ */
+ public static boolean isNotEmpty(String value) {
+ return value != null && !value.isEmpty();
+ }
+
+ /**
+ * + * Parses the given string value to a boolean. This extends the default {@link Boolean#parseBoolean(String)} as it + * throws an exception if the string value is not equal to "true" or "false" being case insensitive. + *
+ * + *+ * This additional restriction is important where false should really be caught, not any random vaue for false + *
+ * + * @param value + * the value to check + * + * @return true or false, depending on the string value + * + * @throws RuntimeException + * if the value is empty, or not equal to the case insensitive value "true" or "false" + */ + public static boolean parseBoolean(String value) throws RuntimeException { + if (isEmpty(value)) + throw new RuntimeException("Value to parse to boolean is empty! Expected case insensitive true or false"); //$NON-NLS-1$ + String tmp = value.toLowerCase(); + if (tmp.equals(Boolean.TRUE.toString())) { + return true; + } else if (tmp.equals(Boolean.FALSE.toString())) { + return false; + } else { + String msg = "Value {0} can not be parsed to boolean! Expected case insensitive true or false"; //$NON-NLS-1$ + msg = MessageFormat.format(msg, value); + throw new RuntimeException(msg); + } + } + + public static String commaSeparated(String... values) { + StringBuilder sb = new StringBuilder(); + for (int i = 0; i < values.length; i++) { + sb.append(values[i]); + if (i < values.length - 1) + sb.append(", "); //$NON-NLS-1$ + } + return sb.toString(); + } + + public static String[] splitCommaSeparated(String values) { + String[] split = values.split(","); //$NON-NLS-1$ + for (int i = 0; i < split.length; i++) { + split[i] = split[i].trim(); + } + return split; + } + + /** + * If the value parameter is empty, then a {@link #DASH} is returned, otherwise the value is returned + * + * @param value + * + * @return the non-empty value, or a {@link #DASH} + */ + public static String valueOrDash(String value) { + if (isNotEmpty(value)) + return value; + return DASH; + } + + /** + * Return a pseudo unique id which is incremented on each call. The id is initialized from the current time + * + * @return a pseudo unique id + */ + public static synchronized String getUniqueId() { + return Long.toString(getUniqueIdLong()); + } + + /** + * Return a pseudo unique id which is incremented on each call. The id is initialized from the current time + * + * @return a pseudo unique id + */ + public static synchronized long getUniqueIdLong() { + + if (uniqueId == Long.MAX_VALUE - 1) { + uniqueId = 0; + } + + uniqueId += 1; + return uniqueId; + } +} diff --git a/ch.eitchnet.utils/src/main/java/ch/eitchnet/utils/helper/SystemHelper.java b/ch.eitchnet.utils/src/main/java/ch/eitchnet/utils/helper/SystemHelper.java new file mode 100644 index 000000000..f7f97d8f0 --- /dev/null +++ b/ch.eitchnet.utils/src/main/java/ch/eitchnet/utils/helper/SystemHelper.java @@ -0,0 +1,121 @@ +/* + * Copyright 2013 Robert von Burg