Util (Calcite Core 1.2.0-incubating API)

java.lang.Object
- org.apache.calcite.util.Util

```
public class Util
extends Object
```
Miscellaneous utility functions.

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class Util.FoundOne
Exception used to interrupt a tree walk of any kind.

Nested Classes
Modifier and Type	Class and Description
`static class`	`Util.FoundOne` Exception used to interrupt a tree walk of any kind.

Field Summary

Fields
Modifier and Type	Field and Description
`static String`	`FILE_SEPARATOR` System-dependent file separator, for example, "/" or "\."
`static String`	`FILE_TIMESTAMP_FORMAT` Datetime format string for generating a timestamp string to be used as part of a filename.
`static String`	`LINE_SEPARATOR` System-dependent newline character.

Method Summary

Methods
Modifier and Type	Method and Description
`static <K,V> Map<K,V>`	`asIndexMap(Collection<V> values, com.google.common.base.Function<V,K> function)` Returns a map that is a view onto a collection of values, using the provided function to convert a value to a key.
`static <E> Iterable<E>`	`cast(Iterable<? super E> iterable, Class<E> clazz)` Converts an `Iterable` whose members are automatically down-cast to a given type.
`static <E> Iterator<E>`	`cast(Iterator<?> iter, Class<E> clazz)` Converts a iterator whose members are automatically down-cast to a given type.
`static <E> List<E>`	`cast(List<? super E> list, Class<E> clazz)` Converts a list whose members are automatically down-cast to a given type.
`static <T> String`	`commaList(List<T> list)` Converts a list of a string, with commas between elements.
`static boolean`	`contains(String[] a, int length, String s)` Returns whether an array of strings contains a given string among the first `length` entries.
`static void`	`debugCode(PrintStream out, String code)` Prints the given code with line numbering.
`static <T> T`	`deprecated(T argument, boolean fail)` Deprecated. If a piece of code calls this method, it indicates that the code needs to be cleaned up.
`static boolean`	`discard(boolean b)` Does nothing with its argument.
`static void`	`discard(double d)` Does nothing with its argument.
`static void`	`discard(int i)` Does nothing with its argument.
`static void`	`discard(Object o)` Does nothing with its argument.
`static <T extends Enum<T>> Map<String,T>`	`enumConstants(Class<T> clazz)` Creates a map of the values of an enumeration by name.
`static <T extends Enum<T>> T`	`enumVal(Class<T> clazz, String name)` Returns the value of an enumeration with a particular name.
`static <T> boolean`	`equalShallow(List<? extends T> list0, List<? extends T> list1)` Returns whether two lists are equal to each other using shallow comparisons.
`static <E> Collection<E>`	`filter(Collection<?> collection, Class<E> includeFilter)`
`static <E> Iterable<E>`	`filter(Iterable<? extends Object> iterable, Class<E> includeFilter)` Makes a collection of untyped elements appear as a list of strictly typed elements, by filtering out those which are not of the correct type.
`static <E> List<E>`	`filter(List<?> list, Class<E> includeFilter)` Returns a subset of a list containing only elements of a given type.
`static int`	`findMatch(List<String> strings, String seek, boolean caseSensitive)` Looks for a string within a list of strings, using a given case-sensitivity policy, and returns the position at which the first match is found, or -1 if there are no matches.
`static <T> T`	`first(T t0, T t1)`
`static <E> int`	`firstDuplicate(List<E> list)` Returns the ordinal of the first element in the list which is equal to a previous element in the list.
`static Charset`	`getDefaultCharset()` Returns the `Charset` object representing the value of `SaffronProperties.defaultCharset`
`static String`	`getFileTimestamp()` Gets a timestamp string for use in file names.
`static String`	`getMessages(Throwable t)` Retrieves messages in a exception and writes them to a string.
`static String`	`getStackTrace(Throwable t)` Returns the stack trace of a throwable.
`static int`	`hash(int i, int j)` Combines two integers into a hash code.
`static int`	`hash(int h, Object o)` Computes a hash code from an existing hash code and an object (which may be null).
`static int`	`hashArray(int h, Object[] a)` Computes a hash code from an existing hash code and an array of objects (which may be null).
`static int`	`hashCode(double v)` Computes the hash code of a `double` value.
`static String`	`human(double d)` Converts a number into human-readable form, with 3 digits and a "K", "M" or "G" multiplier for thousands, millions or billions.
`static <E> boolean`	`isDistinct(List<E> list)` Returns whether the elements of `list` are distinct.
`static boolean`	`isNullOrEmpty(String s)`
`static <E> E`	`last(List<E> list)` Returns the last element of a list.
`static <E> List<E>`	`last(List<E> list, int n)` Returns the last `n` elements of a list.
`static String`	`lines(Iterable<String> strings)` Converts a list of strings to a string separated by newlines.
`static <K,V> Map<K,V>`	`mapOf(K key, V value, Object... keyValues)` Returns a hashmap with given contents.
`static boolean`	`matches(boolean caseSensitive, String s0, String s1)` Returns whether a name matches another according to a given case-sensitivity policy.
`static <T> Set<T>`	`minus(Set<T> set1, Set<T> set2)` Returns a set of the elements which are in `set1` but not in `set2`, without modifying either.
`static RuntimeException`	`needToImplement(Object o)` Returns a `RuntimeException` indicating that a particular feature has not been implemented, but should be.
`static ProcessBuilder`	`newAppProcess(String[] cmdarray)` Constructs a `ProcessBuilder` to run an external application.
`static Error`	`newInternal()`
`static Error`	`newInternal(String s)`
`static Error`	`newInternal(Throwable e)`
`static Error`	`newInternal(Throwable e, String s)`
`static double`	`nLogN(double d)` Computes `nlogn(n)` using the natural logarithm (or `n` if `n < Math.E`, so the result is never negative.
`static <T> Iterable<T>`	`orEmpty(Iterable<T> t0)`
`static Locale`	`parseLocale(String localeString)` Parses a locale string.
`static void`	`permAssert(boolean b, String description)` Checks an invariant.
`static void`	`post(boolean b, String description)` Checks a post-condition.
`static void`	`pre(boolean b, String description)` Checks a pre-condition.
`static void`	`print(PrintWriter pw, Object o)` Prints an object using reflection.
`static void`	`print(PrintWriter pw, Object o, int indent)`
`static void`	`printJavaString(PrintWriter pw, String s, boolean nullMeansNull)` Prints a string, enclosing in double quotes (") and escaping if necessary.
`static void`	`println(PrintWriter pw, Object o)`
`static <E> List<E>`	`quotientList(List<E> list, int n, int k)` Creates a list that returns every `n`th element of a list, starting at element `k`.
`static List<Integer>`	`range(int end)`
`static List<Integer>`	`range(int start, int end)`
`static String`	`readAllAsString(Reader reader)` Reads all remaining contents from a `Reader` and returns them as a string.
`static String`	`replace(String s, String find, String replace)` Replaces every occurrence of `find` in `s` with `replace`.
`static String`	`rpad(String s, int len)` Pads a string with spaces up to a given length.
`static String`	`rtrim(String s)` Trims trailing spaces from a string.
`static int`	`runApplication(String[] cmdarray, Logger logger, Reader appInput, Writer appOutput)` Runs an external application.
`static int`	`runAppProcess(ProcessBuilder pb, Logger logger, Reader appInput, Writer appOutput)` Runs an external application process.
`static <T> String`	`sepList(List<T> list, String sep)` Converts a list of a string, with a given separator between elements.
`static <E> List<E>`	`skip(List<E> list)` Returns all but the first element of a list.
`static <E> List<E>`	`skip(List<E> list, int fromIndex)` Returns all but the first `n` elements of a list.
`static <E> List<E>`	`skipLast(List<E> list)` Returns every element of a list but its last element.
`static <E> List<E>`	`skipLast(List<E> list, int n)` Returns every element of a list but its last `n` elements.
`static void`	`squelchConnection(Connection connection)` Closes a Connection, ignoring any SQL exception.
`static void`	`squelchJar(JarFile jar)` Closes a Jar, ignoring any I/O exception.
`static void`	`squelchReader(Reader reader)` Closes a Reader, ignoring any I/O exception.
`static void`	`squelchStmt(Statement stmt)` Closes a Statement, ignoring any SQL exception.
`static void`	`squelchStream(InputStream stream)` Closes an InputStream, ignoring any I/O exception.
`static void`	`squelchStream(OutputStream stream)` Closes an OutputStream, ignoring any I/O exception.
`static void`	`squelchWriter(Writer writer)` Closes a Writer, ignoring any I/O exception.
`static <E> boolean`	`startsWith(List<E> list0, List<E> list1)` Returns whether one list is a prefix of another.
`static String`	`stripDoubleQuotes(String value)` Converts double-quoted Java strings to their contents.
`static void`	`swallow(Throwable e, Logger logger)` Records that an exception has been caught but will not be re-thrown.
`static String`	`toJavaId(String s, int ordinal)` Converts an arbitrary string into a string suitable for use as a Java identifier.
`static String`	`toLinux(String s)`
`static <T> List<T>`	`toList(Iterator<T> iter)` Materializes the results of a `Iterator` as a `List`.
`static Map<String,String>`	`toMap(Properties properties)` Converts a `Properties` object to a `Map<String, String>`.
`static String`	`toPosix(TimeZone tz, boolean verbose)` Converts a Java timezone to POSIX format, so that the boost C++ library can instantiate timezone objects.
`static String`	`toScientificNotation(BigDecimal bd)` Formats a `BigDecimal` value to a string in scientific notation For example A value of 0.00001234 would be formated as `1.234E-5` A value of 100000.00 would be formated as `1.00E5` A value of 100 (scale zero) would be formated as `1E2`
`static <T> String`	`toString(Iterable<T> iterable, String start, String sep, String end)` Converts an iterable to a string.
`static URL`	`toURL(File file)` Creates a file-protocol URL for the given file.
`static <E extends Enum<E>> Error`	`unexpected(E value)` Returns an exception indicating that we didn't expect to find this enumeration here.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - LINE_SEPARATOR
```
public static final String LINE_SEPARATOR
```
    System-dependent newline character.
    In general, you should not use this in expected results of tests. Expected results should be the expected result on Linux (or Mac OS) using '\n'. Apply toLinux(String) to Windows actual results, if necessary, to make them look like Linux actual.
  - FILE_SEPARATOR
```
public static final String FILE_SEPARATOR
```
    System-dependent file separator, for example, "/" or "\."
  - FILE_TIMESTAMP_FORMAT
```
public static final String FILE_TIMESTAMP_FORMAT
```
    Datetime format string for generating a timestamp string to be used as part of a filename. Conforms to SimpleDateFormat conventions.
    
    See Also:
    Constant Field Values
- Method Detail
  - discard
```
public static void discard(Object o)
```
    Does nothing with its argument. Call this method when you have a value you are not interested in, but you don't want the compiler to warn that you are not using it.
  - discard
```
public static void discard(int i)
```
    Does nothing with its argument. Call this method when you have a value you are not interested in, but you don't want the compiler to warn that you are not using it.
  - discard
```
public static boolean discard(boolean b)
```
    Does nothing with its argument. Call this method when you have a value you are not interested in, but you don't want the compiler to warn that you are not using it.
  - discard
```
public static void discard(double d)
```
    Does nothing with its argument. Call this method when you have a value you are not interested in, but you don't want the compiler to warn that you are not using it.
  - swallow
```
public static void swallow(Throwable e,
           Logger logger)
```
    Records that an exception has been caught but will not be re-thrown. If the tracer is not null, logs the exception to the tracer.
    
    Parameters:
    e - Exception
    logger - If not null, logs exception to this logger
  - equalShallow
```
public static <T> boolean equalShallow(List<? extends T> list0,
                       List<? extends T> list1)
```
    Returns whether two lists are equal to each other using shallow comparisons.
    
    Parameters:
    list0 - First list
    list1 - Second list
    
    Returns:
    Whether lists are same length and all of their elements are equal using == (may be null).
  - hash
```
public static int hash(int i,
       int j)
```
    Combines two integers into a hash code.
  - hash
```
public static int hash(int h,
       Object o)
```
    Computes a hash code from an existing hash code and an object (which may be null).
  - hashArray
```
public static int hashArray(int h,
            Object[] a)
```
    Computes a hash code from an existing hash code and an array of objects (which may be null).
  - hashCode
```
public static int hashCode(double v)
```
    Computes the hash code of a double value. Equivalent to Double.hashCode(double), but that method was only introduced in JDK 1.8.
    
    Parameters:
    v - Value
    
    Returns:
    Hash code
  - minus
```
public static <T> Set<T> minus(Set<T> set1,
               Set<T> set2)
```
    Returns a set of the elements which are in set1 but not in set2, without modifying either.
  - nLogN
```
public static double nLogN(double d)
```
    Computes nlogn(n) using the natural logarithm (or n if n < Math.E, so the result is never negative.
  - print
```
public static void print(PrintWriter pw,
         Object o)
```
    Prints an object using reflection. We can handle null; arrays of objects and primitive values; for regular objects, we print all public fields.
  - print
```
public static void print(PrintWriter pw,
         Object o,
         int indent)
```
  - printJavaString
```
public static void printJavaString(PrintWriter pw,
                   String s,
                   boolean nullMeansNull)
```
    Prints a string, enclosing in double quotes (") and escaping if necessary. For examples, printDoubleQuoted(w,"x\"y",false) prints "x\"y".
  - println
```
public static void println(PrintWriter pw,
           Object o)
```
  - toScientificNotation
```
public static String toScientificNotation(BigDecimal bd)
```
    Formats a BigDecimal value to a string in scientific notation For example
    - A value of 0.00001234 would be formated as 1.234E-5
    - A value of 100000.00 would be formated as 1.00E5
    - A value of 100 (scale zero) would be formated as 1E2
    If bd has a precision higher than 20, this method will truncate the output string to have a precision of 20 (no rounding will be done, just a truncate).
  - replace
```
public static String replace(String s,
             String find,
             String replace)
```
    Replaces every occurrence of find in s with replace.
  - toURL
```
public static URL toURL(File file)
                 throws MalformedURLException
```
    Creates a file-protocol URL for the given file.
    
    Throws:
    
    MalformedURLException
  - getFileTimestamp
```
public static String getFileTimestamp()
```
    Gets a timestamp string for use in file names. The generated timestamp string reflects the current time.
  - stripDoubleQuotes
```
public static String stripDoubleQuotes(String value)
```
    Converts double-quoted Java strings to their contents. For example, "foo\"bar" becomes foo"bar.
  - toJavaId
```
public static String toJavaId(String s,
              int ordinal)
```
    Converts an arbitrary string into a string suitable for use as a Java identifier.
    The mapping is one-to-one (that is, distinct strings will produce distinct java identifiers). The mapping is also reversible, but the inverse mapping is not implemented.
    
    A valid Java identifier must start with a Unicode letter, underscore, or dollar sign ($). The other characters, if any, can be a Unicode letter, underscore, dollar sign, or digit.
    
    This method uses an algorithm similar to URL encoding. Valid characters are unchanged; invalid characters are converted to an underscore followed by the hex code of the character; and underscores are doubled.
    Examples:
    - toJavaId("foo") returns "foo"
    - toJavaId("foo bar") returns "foo_20_bar"
    - toJavaId("foo_bar") returns "foo__bar"
    - toJavaId("0bar") returns "_40_bar" (digits are illegal as a prefix)
    - toJavaId("foo0bar") returns "foo0bar"
  - toLinux
```
public static String toLinux(String s)
```
  - toList
```
public static <T> List<T> toList(Iterator<T> iter)
```
    Materializes the results of a Iterator as a List.
    
    Parameters:
    iter - iterator to materialize
    
    Returns:
    materialized list
  - isNullOrEmpty
```
public static boolean isNullOrEmpty(String s)
```
    Returns:
    true if s==null or if s.length()==0
  - commaList
```
public static <T> String commaList(List<T> list)
```
    Converts a list of a string, with commas between elements. For example, commaList(Arrays.asList({"a", "b"})) returns "a, b".
    
    Parameters:
    list - List
    
    Returns:
    String representation of string
  - sepList
```
public static <T> String sepList(List<T> list,
                 String sep)
```
    Converts a list of a string, with a given separator between elements.
  - getDefaultCharset
```
public static Charset getDefaultCharset()
```
    Returns the Charset object representing the value of SaffronProperties.defaultCharset
    
    Throws:
    
    IllegalCharsetNameException - If the given charset name is illegal
    
    UnsupportedCharsetException - If no support for the named charset is available in this instance of the Java virtual machine
  - newInternal
```
public static Error newInternal()
```
  - newInternal
```
public static Error newInternal(String s)
```
  - newInternal
```
public static Error newInternal(Throwable e)
```
  - newInternal
```
public static Error newInternal(Throwable e,
                String s)
```
  - getMessages
```
public static String getMessages(Throwable t)
```
    Retrieves messages in a exception and writes them to a string. In the string returned, each message will appear on a different line.
    
    Returns:
    a non-null string containing all messages of the exception
  - getStackTrace
```
public static String getStackTrace(Throwable t)
```
    Returns the stack trace of a throwable. Called from native code.
    
    Parameters:
    t - Throwable
    
    Returns:
    Stack trace
  - pre
```
public static void pre(boolean b,
       String description)
```
    Checks a pre-condition.
    For example,
```
 /**
   * @ pre x != 0
   * /
 void foo(int x) {
     Util.pre(x != 0, "x != 0");
 }
```
    Parameters:
    b - Result of evaluating the pre-condition.
    description - Description of the pre-condition.
  - post
```
public static void post(boolean b,
        String description)
```
    Checks a post-condition.
    For example,
```
 /**
   * @ post return != 0
   * /
 void foo(int x) {
     int res = bar(x);
     Util.post(res != 0, "return != 0");
 }
```
    Parameters:
    b - Result of evaluating the pre-condition.
    description - Description of the pre-condition.
  - permAssert
```
public static void permAssert(boolean b,
              String description)
```
    Checks an invariant.
    This is similar to assert keyword, except that the condition is always evaluated even if asserts are disabled.
  - needToImplement
```
public static RuntimeException needToImplement(Object o)
```
    Returns a RuntimeException indicating that a particular feature has not been implemented, but should be.
    If every 'hole' in our functionality uses this method, it will be easier for us to identity the holes. Throwing a UnsupportedOperationException isn't as good, because sometimes we actually want to partially implement an API.
    Example usage:
    class MyVisitor extends BaseVisitor { void accept(Foo foo) { // Exception will identify which subclass forgot to override // this method throw Util.needToImplement(this); } }
    Parameters:
    o - The object which was the target of the call, or null. Passing the object gives crucial information if a method needs to be overridden and a subclass forgot to do so.
    
    Returns:
    an UnsupportedOperationException.
  - deprecated
```
public static <T> T deprecated(T argument,
               boolean fail)
```
    Deprecated. If a piece of code calls this method, it indicates that the code needs to be cleaned up.
    Flags a piece of code as needing to be cleaned up before you check in.
    Introduce a call to this method to indicate that a piece of code, or a javadoc comment, needs work before you check in. If you have an IDE which can easily trace references, this is an easy way to maintain a to-do list.
    Checked-in code must never call this method: you must remove all calls/references to this method before you check in.
    The argument has generic type and determines the type of the result. This allows you to use the method inside an expression, for example
    int x = Util.deprecated(0, false);
    but the usual usage is to pass in a descriptive string.
    Examples
    
    Example #1: Using deprecated to fail if a piece of supposedly dead code is reached
    void foo(int x) { if (x < 0) { // If this code is executed, an error will be thrown. Util.deprecated( "no longer need to handle negative numbers", true); bar(x); } else { baz(x); } }
    Example #2: Using deprecated to comment out dead code
    if (Util.deprecated(false, false)) { // This code will not be executed, but an error will not be thrown. baz(); }
    Parameters:
    argument - Arbitrary argument to the method.
    fail - Whether to throw an exception if this method is called
    
    Returns:
    The value of the argument.
  - contains
```
public static boolean contains(String[] a,
               int length,
               String s)
```
    Returns whether an array of strings contains a given string among the first length entries.
    
    Parameters:
    a - Array of strings
    length - Number of entries to search
    s - String to seek
    
    Returns:
    Whether array contains the name
  - readAllAsString
```
public static String readAllAsString(Reader reader)
                              throws IOException
```
    Reads all remaining contents from a Reader and returns them as a string.
    
    Parameters:
    reader - reader to read from
    
    Returns:
    reader contents as string
    
    Throws:
    
    IOException
  - squelchJar
```
public static void squelchJar(JarFile jar)
```
    Closes a Jar, ignoring any I/O exception. This should only be used in finally blocks when it's necessary to avoid throwing an exception which might mask a real exception.
    
    Parameters:
    jar - jar to close
  - squelchStream
```
public static void squelchStream(InputStream stream)
```
    Closes an InputStream, ignoring any I/O exception. This should only be used in finally blocks when it's necessary to avoid throwing an exception which might mask a real exception.
    
    Parameters:
    stream - stream to close
  - squelchStream
```
public static void squelchStream(OutputStream stream)
```
    Closes an OutputStream, ignoring any I/O exception. This should only be used in finally blocks when it's necessary to avoid throwing an exception which might mask a real exception. If you want to make sure that data has been successfully flushed, do NOT use this anywhere else; use stream.close() instead.
    
    Parameters:
    stream - stream to close
  - squelchReader
```
public static void squelchReader(Reader reader)
```
    Closes a Reader, ignoring any I/O exception. This should only be used in finally blocks when it's necessary to avoid throwing an exception which might mask a real exception.
    
    Parameters:
    reader - reader to close
  - squelchWriter
```
public static void squelchWriter(Writer writer)
```
    Closes a Writer, ignoring any I/O exception. This should only be used in finally blocks when it's necessary to avoid throwing an exception which might mask a real exception. If you want to make sure that data has been successfully flushed, do NOT use this anywhere else; use writer.close() instead.
    
    Parameters:
    writer - writer to close
  - squelchStmt
```
public static void squelchStmt(Statement stmt)
```
    Closes a Statement, ignoring any SQL exception. This should only be used in finally blocks when it's necessary to avoid throwing an exception which might mask a real exception.
    
    Parameters:
    stmt - stmt to close
  - squelchConnection
```
public static void squelchConnection(Connection connection)
```
    Closes a Connection, ignoring any SQL exception. This should only be used in finally blocks when it's necessary to avoid throwing an exception which might mask a real exception.
    
    Parameters:
    connection - connection to close
  - rtrim
```
public static String rtrim(String s)
```
    Trims trailing spaces from a string.
    
    Parameters:
    s - string to be trimmed
    
    Returns:
    trimmed string
  - rpad
```
public static String rpad(String s,
          int len)
```
    Pads a string with spaces up to a given length.
    
    Parameters:
    s - string to be padded
    len - desired length
    
    Returns:
    padded string
  - toString
```
public static <T> String toString(Iterable<T> iterable,
                  String start,
                  String sep,
                  String end)
```
    Converts an iterable to a string.
  - lines
```
public static String lines(Iterable<String> strings)
```
    Converts a list of strings to a string separated by newlines.
  - toPosix
```
public static String toPosix(TimeZone tz,
             boolean verbose)
```
    Converts a Java timezone to POSIX format, so that the boost C++ library can instantiate timezone objects.
    POSIX IEEE 1003.1 defines a format for timezone specifications.
    The boost C++ library can read these specifications and instantiate posix_time_zone objects from them. The purpose of this method, therefore, is to allow the C++ code such as the fennel calculator to use the same notion of timezone as Java code.
    The format is as follows:
    "std offset dst [offset],start[/time],end[/time]"
    where:
    - 'std' specifies the abbrev of the time zone.
    - 'offset' is the offset from UTC, and takes the form [+|-]hh[:mm[:ss]] {h=0-23, m/s=0-59}
    - 'dst' specifies the abbrev of the time zone during daylight savings time
    - The second offset is how many hours changed during DST. Default=1
    - 'start' and 'end' are the dates when DST goes into (and out of) effect.
      
      They can each be one of three forms:
      
      Mm.w.d {month=1-12, week=1-5 (5 is always last), day=0-6}
      Jn {n=1-365 Feb29 is never counted}
      n {n=0-365 Feb29 is counted in leap years}
    - 'time' has the same format as 'offset', and defaults to 02:00:00.
    For example:
    - "PST-8PDT01:00:00,M4.1.0/02:00:00,M10.1.0/02:00:00"; or more tersely
    - "PST-8PDT,M4.1.0,M10.1.0"
    (Real format strings do not contain spaces; they are in the above template only for readability.)
    Boost apparently diverges from the POSIX standard in how it treats the sign of timezone offsets. The POSIX standard states 'If preceded by a '-', the timezone shall be east of the Prime Meridian; otherwise, it shall be west', yet boost requires the opposite. For instance, PST has offset '-8' above. This method generates timezone strings consistent with boost's expectations.
    Parameters:
    tz - Timezone
    verbose - Whether to include fields which can be omitted because they have their default values
    
    Returns:
    Timezone in POSIX format (offset sign reversed, per boost's idiosyncracies)
  - parseLocale
```
public static Locale parseLocale(String localeString)
```
    Parses a locale string.
    The inverse operation of Locale.toString().
    
    Parameters:
    localeString - Locale string, e.g. "en" or "en_US"
    
    Returns:
    Java locale object
  - runApplication
```
public static int runApplication(String[] cmdarray,
                 Logger logger,
                 Reader appInput,
                 Writer appOutput)
                          throws IOException,
                                 InterruptedException
```
    Runs an external application.
    
    Parameters:
    cmdarray - command and arguments, see ProcessBuilder
    logger - if not null, command and exit status will be logged
    appInput - if not null, data will be copied to application's stdin
    appOutput - if not null, data will be captured from application's stdout and stderr
    
    Returns:
    application process exit value
    
    Throws:
    
    IOException
    
    InterruptedException
  - newAppProcess
```
public static ProcessBuilder newAppProcess(String[] cmdarray)
```
    Constructs a ProcessBuilder to run an external application.
    
    Parameters:
    cmdarray - command and arguments.
    
    Returns:
    a ProcessBuilder.
  - runAppProcess
```
public static int runAppProcess(ProcessBuilder pb,
                Logger logger,
                Reader appInput,
                Writer appOutput)
                         throws IOException,
                                InterruptedException
```
    Runs an external application process.
    
    Parameters:
    pb - ProcessBuilder for the application; might be returned by newAppProcess(java.lang.String[]).
    logger - if not null, command and exit status will be logged here
    appInput - if not null, data will be copied to application's stdin
    appOutput - if not null, data will be captured from application's stdout and stderr
    
    Returns:
    application process exit value
    
    Throws:
    
    IOException
    
    InterruptedException
  - cast
```
public static <E> List<E> cast(List<? super E> list,
               Class<E> clazz)
```
    Converts a list whose members are automatically down-cast to a given type.
    If a member of the backing list is not an instanceof E, the accessing method (such as List.get(int)) will throw a ClassCastException.
    All modifications are automatically written to the backing list. Not synchronized.
    
    Parameters:
    list - Backing list.
    clazz - Class to cast to.
    
    Returns:
    A list whose members are of the desired type.
  - cast
```
public static <E> Iterator<E> cast(Iterator<?> iter,
                   Class<E> clazz)
```
    Converts a iterator whose members are automatically down-cast to a given type.
    If a member of the backing iterator is not an instanceof E, Iterator.next()) will throw a ClassCastException.
    All modifications are automatically written to the backing iterator. Not synchronized.
    
    Parameters:
    iter - Backing iterator.
    clazz - Class to cast to.
    
    Returns:
    An iterator whose members are of the desired type.
  - cast
```
public static <E> Iterable<E> cast(Iterable<? super E> iterable,
                   Class<E> clazz)
```
    Converts an Iterable whose members are automatically down-cast to a given type.
    All modifications are automatically written to the backing iterator. Not synchronized.
    
    Parameters:
    iterable - Backing iterable
    clazz - Class to cast to
    
    Returns:
    An iterable whose members are of the desired type.
  - filter
```
public static <E> Iterable<E> filter(Iterable<? extends Object> iterable,
                     Class<E> includeFilter)
```
    Makes a collection of untyped elements appear as a list of strictly typed elements, by filtering out those which are not of the correct type.
    The returned object is an Iterable, which makes it ideal for use with the 'foreach' construct. For example,
    List<Number> numbers = Arrays.asList(1, 2, 3.14, 4, null, 6E23); for (int myInt : filter(numbers, Integer.class)) { print(i); }
    will print 1, 2, 4.
    
    Parameters:
    iterable - Iterable
    includeFilter - Class whose instances to include
  - filter
```
public static <E> Collection<E> filter(Collection<?> collection,
                       Class<E> includeFilter)
```
  - filter
```
public static <E> List<E> filter(List<?> list,
                 Class<E> includeFilter)
```
    Returns a subset of a list containing only elements of a given type.
    Modifications to the list are NOT written back to the source list.
    
    Parameters:
    list - List of objects
    includeFilter - Class to filter for
    
    Returns:
    List of objects of given class (or a subtype)
  - toMap
```
public static Map<String,String> toMap(Properties properties)
```
    Converts a Properties object to a Map<String, String>.
    This is necessary because Properties is a dinosaur class. It ought to extend Map<String,String>, but instead extends Hashtable<Object,Object>.
    Typical usage, to iterate over a Properties:
    Properties properties; for (Map.Entry<String, String> entry = Util.toMap(properties).entrySet()) { println("key=" + entry.getKey() + ", value=" + entry.getValue()); }
  - mapOf
```
public static <K,V> Map<K,V> mapOf(K key,
                   V value,
                   Object... keyValues)
```
    Returns a hashmap with given contents.
    Use this method in initializers. Type parameters are inferred from context, and the contents are initialized declaratively. For example,
    Map<String, Integer> population = Olap4jUtil.mapOf( "UK", 65000000, "USA", 300000000);
    
    Type Parameters:
    K - Key type
    V - Value type
    Parameters:
    key - First key
    value - First value
    keyValues - Second and sequent key/value pairs
    
    Returns:
    Map with given contents
  - unexpected
```
public static <E extends Enum<E>> Error unexpected(E value)
```
    Returns an exception indicating that we didn't expect to find this enumeration here.
    
    Parameters:
    value - Enumeration value which was not expected
    
    Returns:
    an error, to be thrown
  - enumConstants
```
public static <T extends Enum<T>> Map<String,T> enumConstants(Class<T> clazz)
```
    Creates a map of the values of an enumeration by name.
    
    Parameters:
    clazz - Enumeration class
    
    Returns:
    map of values
  - enumVal
```
public static <T extends Enum<T>> T enumVal(Class<T> clazz,
                            String name)
```
    Returns the value of an enumeration with a particular name.
    Similar to Enum.valueOf(Class, String), but returns null rather than throwing IllegalArgumentException.
    
    Type Parameters:
    T - Enum class type
    Parameters:
    clazz - Enum class
    name - Name of enum constant
    
    Returns:
    Enum constant or null
  - quotientList
```
public static <E> List<E> quotientList(List<E> list,
                       int n,
                       int k)
```
    Creates a list that returns every nth element of a list, starting at element k.
    It is OK if the list is empty or its size is not a multiple of n.
    
    For instance, quotientList(list, 2, 0) returns the even elements of a list, and quotientList(list, 2, 1) returns the odd elements. Those lists are the same length only if list has even size.
  - first
```
public static <T> T first(T t0,
          T t1)
```
  - orEmpty
```
public static <T> Iterable<T> orEmpty(Iterable<T> t0)
```
  - last
```
public static <E> E last(List<E> list)
```
    Returns the last element of a list.
    
    Throws:
    
    IndexOutOfBoundsException - if the list is empty
  - skipLast
```
public static <E> List<E> skipLast(List<E> list)
```
    Returns every element of a list but its last element.
  - skipLast
```
public static <E> List<E> skipLast(List<E> list,
                   int n)
```
    Returns every element of a list but its last n elements.
  - last
```
public static <E> List<E> last(List<E> list,
               int n)
```
    Returns the last n elements of a list.
  - skip
```
public static <E> List<E> skip(List<E> list)
```
    Returns all but the first element of a list.
  - skip
```
public static <E> List<E> skip(List<E> list,
               int fromIndex)
```
    Returns all but the first n elements of a list.
  - range
```
public static List<Integer> range(int end)
```
  - range
```
public static List<Integer> range(int start,
                  int end)
```
  - isDistinct
```
public static <E> boolean isDistinct(List<E> list)
```
    Returns whether the elements of list are distinct.
  - firstDuplicate
```
public static <E> int firstDuplicate(List<E> list)
```
    Returns the ordinal of the first element in the list which is equal to a previous element in the list.
    For example, firstDuplicate(Arrays.asList("a", "b", "c", "b", "a")) returns 3, the ordinal of the 2nd "b".
    
    Parameters:
    list - List
    
    Returns:
    Ordinal of first duplicate, or -1 if not found
  - findMatch
```
public static int findMatch(List<String> strings,
            String seek,
            boolean caseSensitive)
```
    Looks for a string within a list of strings, using a given case-sensitivity policy, and returns the position at which the first match is found, or -1 if there are no matches.
  - matches
```
public static boolean matches(boolean caseSensitive,
              String s0,
              String s1)
```
    Returns whether a name matches another according to a given case-sensitivity policy.
  - startsWith
```
public static <E> boolean startsWith(List<E> list0,
                     List<E> list1)
```
    Returns whether one list is a prefix of another.
  - human
```
public static String human(double d)
```
    Converts a number into human-readable form, with 3 digits and a "K", "M" or "G" multiplier for thousands, millions or billions.
    Examples: -2, 0, 1, 999, 1.00K, 1.99K, 3.45M, 4.56B.
  - asIndexMap
```
public static <K,V> Map<K,V> asIndexMap(Collection<V> values,
                        com.google.common.base.Function<V,K> function)
```
    Returns a map that is a view onto a collection of values, using the provided function to convert a value to a key.
    Unlike Maps.uniqueIndex(Iterable, com.google.common.base.Function), returns a view whose contents change as the collection of values changes.
    
    Type Parameters:
    K - Key type
    V - Value type
    Parameters:
    values - Collection of values
    function - Function to map value to key
    
    Returns:
    Map that is a view onto the values
  - debugCode
```
public static void debugCode(PrintStream out,
             String code)
```
    Prints the given code with line numbering.

Class Util

Nested Class Summary

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

LINE_SEPARATOR

FILE_SEPARATOR

FILE_TIMESTAMP_FORMAT

Method Detail

discard

discard

discard

discard

swallow

equalShallow

hash

hash

hashArray

hashCode

minus

nLogN

print

print

printJavaString

println

toScientificNotation

replace

toURL

getFileTimestamp

stripDoubleQuotes

toJavaId

toLinux

toList

isNullOrEmpty

commaList

sepList

getDefaultCharset

newInternal

newInternal

newInternal

newInternal

getMessages

getStackTrace

pre

post

permAssert

needToImplement

deprecated

Examples

Example #1: Using deprecated to fail if a piece of supposedly dead code is reached

Example #2: Using deprecated to comment out dead code

contains

readAllAsString

squelchJar

squelchStream

squelchStream

squelchReader

squelchWriter

squelchStmt

squelchConnection

rtrim

rpad

toString

lines

toPosix

parseLocale

runApplication

newAppProcess

runAppProcess

cast

cast

cast

filter

filter

filter

toMap

mapOf

unexpected

enumConstants

Example #1: Using `deprecated` to fail if a piece of supposedly dead code is reached

Example #2: Using `deprecated` to comment out dead code