StringTools (Apache Directory Shared 0.9.19 API)

java.lang.Object
- org.apache.directory.shared.ldap.util.StringTools

```
public class StringTools
extends Object
```
Various string manipulation methods that are more efficient then chaining string operations: all is done in the same buffer without creating a bunch of string objects.

Version:

$Rev: 928945 $

Author:

Apache Directory Project

Field Summary

Fields
Modifier and Type	Field and Description
`static boolean[]`	`ALPHA` <alpha> ::= [0x41-0x5A] \| [0x61-0x7A]
`static boolean[]`	`ALPHA_DIGIT` <alpha-digit> \| <digit>
`static boolean[]`	`ALPHA_LOWER_CASE` <alpha-lower-case> ::= [0x61-0x7A]
`static boolean[]`	`ALPHA_UPPER_CASE` <alpha-upper-case> ::= [0x41-0x5A]
`static boolean[]`	`CHAR` <alpha> \| <digit> \| '-'
`static String`	`EMPTY` The empty String `""`.
`static byte[]`	`EMPTY_BYTES` The empty byte[]
`static String[]`	`EMPTY_STRINGS` The empty String[]
`static int`	`NOT_EQUAL`

Constructor Summary

Constructors
Constructor and Description

StringTools()

Constructors
Constructor and Description
`StringTools()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static int`	`areEquals(byte[] bytes, int index, byte[] bytes2)` Check if a text is present at the current position in a buffer.
`static int`	`areEquals(byte[] bytes, int index, String text)` Check if a text is present at the current position in a buffer.
`static int`	`areEquals(char[] chars, int index, char[] chars2)` Check if a text is present at the current position in a buffer.
`static int`	`areEquals(char[] chars, int index, String text)` Check if a text is present at the current position in a buffer.
`static boolean`	`areEquals(String string, int index, String text)` Check if a text is present at the current position in another string.
`static String`	`asciiBytesToString(byte[] bytes)` Thansform an array of ASCII bytes to a string.
`static char`	`bytesToChar(byte[] bytes)` Return the Unicode char which is coded in the bytes at position 0.
`static char`	`bytesToChar(byte[] bytes, int pos)` Return the Unicode char which is coded in the bytes at the given position.
`static String`	`centerTrunc(String str, int head, int tail)` Truncates large Strings showing a portion of the String's head and tail with the center cut out and replaced with '...'.
`static char`	`charAt(String string, int index)` Get the character at a given position in a string, checking fo limits
`static byte[]`	`charToBytes(char car)` Return the Unicode char which is coded in the bytes at the given position.
`static int`	`collectEscapedHexBytes(ByteBuffer bb, String str, int index)` Collects an hex sequence from a string, and returns the value as an integer, after having modified the initial value (the escaped hex value is transsformed to the byte it represents).
`static byte[]`	`convertEscapedHex(String str)` Convert an escaoed list of bytes to a byte[]
`static int`	`countBytes(char[] chars)` Count the number of bytes included in the given char[].
`static int`	`countBytesPerChar(byte[] bytes, int pos)` Count the number of bytes needed to return an Unicode char.
`static int`	`countChars(byte[] bytes)` Count the number of chars included in the given byte[].
`static int`	`countNbBytesPerChar(char car)` Return the number of bytes that hold an Unicode char.
`static String`	`decodeEscapedHex(String str)` Decodes sequences of escaped hex within an attribute's value into a UTF-8 String.
`static String`	`decodeHexString(String str)` Decodes values of attributes in the DN encoded in hex into a UTF-8 String.
`static String`	`deepTrim(String string)` A deep trim of a string remove whitespace from the ends as well as excessive whitespace within the inside of the string between non-whitespace characters.
`static String`	`deepTrim(String str, boolean toLowerCase)` Put common code to deepTrim(String) and deepTrimToLower here.
`static String`	`deepTrimToLower(String string)` This does the same thing as a trim but we also lowercase the string while performing the deep trim within the same buffer.
`static String`	`dumpByte(byte octet)` Helper function that dump a byte in hex form
`static String`	`dumpBytes(byte[] buffer)` Helper function that dump an array of bytes in hex form
`static char`	`dumpHex(byte hex)` Helper function that returns a char from an hex
`static String`	`dumpHexPairs(byte[] buffer)` Helper function that dump an array of bytes in hex pair form, without '0x' and space chars
`static String`	`dumpObject(Object object)` Helper method to render an object which can be a String or a byte[]
`static boolean`	`equals(String str1, String str2)` Compares two Strings, returning `true` if they are equal.
`static String`	`formatHtml(String source, boolean replaceNl, boolean replaceTag, boolean replaceQuote)` This method is used to insert HTML block dynamically
`static byte[]`	`getBytesUtf8(String string)` Return UTF-8 encoded byte[] representation of a String
`static String`	`getDefaultCharsetName()` Get the default charset
`static byte`	`getHexValue(byte high, byte low)` Translate two bytes to an hex value.
`static byte`	`getHexValue(char c)` Return an hex value from a sinle char The char must be in [0-9a-fA-F]
`static byte`	`getHexValue(char high, char low)` Translate two chars to an hex value.
`static List<String>`	`getPaths(String paths, FileFilter filter)` Splits apart a OS separator delimited set of paths in a string into multiple Strings.
`static Pattern`	`getRegex(String ldapRegex)` Generates a regular expression from an LDAP substring match expression by parsing out the supplied string argument.
`static Pattern`	`getRegex(String initialPattern, String[] anyPattern, String finalPattern)` Creates a regular expression from an LDAP substring assertion filter specification.
`static String`	`getType(byte[] bytes)` Build an AttributeType froma byte array.
`static boolean`	`isAlpha(byte c)` Test if the current byte is an Alpha character : <alpha> ::= [0x41-0x5A] \| [0x61-0x7A]
`static boolean`	`isAlpha(char c)` Test if the current character is an Alpha character : <alpha> ::= [0x41-0x5A] \| [0x61-0x7A]
`static boolean`	`isAlphaASCII(byte[] bytes, int index)` Test if the current character is an Alpha character : <alpha> ::= [0x41-0x5A] \| [0x61-0x7A]
`static boolean`	`isAlphaASCII(char[] chars, int index)` Test if the current character is an Alpha character : <alpha> ::= [0x41-0x5A] \| [0x61-0x7A]
`static boolean`	`isAlphaASCII(String string, int index)` Test if the current character is an Alpha character : <alpha> ::= [0x41-0x5A] \| [0x61-0x7A]
`static boolean`	`isAlphaDigit(String string, int index)` Check if the current character is an 7 bits ASCII CHAR (between 0 and 127).
`static boolean`	`isAlphaDigitMinus(byte[] bytes, int index)` Check if the current character is an 7 bits ASCII CHAR (between 0 and 127).
`static boolean`	`isAlphaDigitMinus(char[] chars, int index)` Check if the current character is an 7 bits ASCII CHAR (between 0 and 127).
`static boolean`	`isAlphaDigitMinus(String string, int index)` Check if the current character is an 7 bits ASCII CHAR (between 0 and 127).
`static boolean`	`isAlphaLowercaseASCII(String string, int index)` Test if the current character is a lowercased Alpha character : <alpha> ::= [0x61-0x7A]
`static boolean`	`isAlphaUppercaseASCII(String string, int index)` Test if the current character is a uppercased Alpha character : <alpha> ::= [0x61-0x7A]
`static boolean`	`isBit(String string, int index)` Test if the current character is a bit, ie 0 or 1.
`static boolean`	`isCharASCII(byte[] byteArray, int index, char car)` Test if the current character is equal to a specific character.
`static boolean`	`isCharASCII(char[] chars, int index, char car)` Test if the current character is equal to a specific character.
`static boolean`	`isCharASCII(String string, int index, char car)` Test if the current character is equal to a specific character.
`static boolean`	`isDigit(byte[] bytes)` Test if the current character is a digit <digit> ::= '0' \| '1' \| '2' \| '3' \| '4' \| '5' \| '6' \| '7' \| '8' \| '9'
`static boolean`	`isDigit(byte[] bytes, int index)` Test if the current character is a digit <digit> ::= '0' \| '1' \| '2' \| '3' \| '4' \| '5' \| '6' \| '7' \| '8' \| '9'
`static boolean`	`isDigit(char car)` Test if the current character is a digit <digit> ::= '0' \| '1' \| '2' \| '3' \| '4' \| '5' \| '6' \| '7' \| '8' \| '9'
`static boolean`	`isDigit(char[] chars)` Test if the current character is a digit <digit> ::= '0' \| '1' \| '2' \| '3' \| '4' \| '5' \| '6' \| '7' \| '8' \| '9'
`static boolean`	`isDigit(char[] chars, int index)` Test if the current character is a digit <digit> ::= '0' \| '1' \| '2' \| '3' \| '4' \| '5' \| '6' \| '7' \| '8' \| '9'
`static boolean`	`isDigit(String string, int index)` Test if the current character is a digit <digit> ::= '0' \| '1' \| '2' \| '3' \| '4' \| '5' \| '6' \| '7' \| '8' \| '9'
`static boolean`	`isEmpty(byte[] bytes)` Checks if a bytes array is empty or null.
`static boolean`	`isEmpty(String str)` Checks if a String is empty ("") or null.
`static boolean`	`isHex(byte[] bytes, int index)` Check if the current character is an Hex Char <hex> ::= [0x30-0x39] \| [0x41-0x46] \| [0x61-0x66]
`static boolean`	`isHex(char[] chars, int index)` Check if the current character is an Hex Char <hex> ::= [0x30-0x39] \| [0x41-0x46] \| [0x61-0x66]
`static boolean`	`isHex(String string, int index)` Check if the current character is an Hex Char <hex> ::= [0x30-0x39] \| [0x41-0x46] \| [0x61-0x66]
`static boolean`	`isIA5String(String str)` Check that a String is a valid IA5String.
`static boolean`	`isICharASCII(byte[] bytes, int index, char car)` Test if the current character is equal to a specific character.
`static boolean`	`isICharASCII(String string, int index, char car)` Test if the current character is equal to a specific character.
`static boolean`	`isNotEmpty(String str)` Checks if a String is not empty ("") and not null.
`static boolean`	`isPrintableString(String str)` Check that a String is a valid PrintableString.
`static boolean`	`isUnicodeSubset(char c)` Check if the current char is in the unicodeSubset : all chars but '\0', '(', ')', '*' and '\'
`static boolean`	`isUnicodeSubset(String str, int pos)` Check if the current char is in the unicodeSubset : all chars but '\0', '(', ')', '*' and '\'
`static String`	`listToString(List<?> list)` Utility method that return a String representation of a list
`static String`	`listToString(List<?> list, String tabs)` Utility method that return a String representation of a list
`static String`	`lowerCase(String str)` Converts a String to lower case as per `String.toLowerCase()`.
`static String`	`lowerCaseAscii(String str)` Rewrote the toLowercase method to improve performances.
`static String`	`mapToString(Map<?,?> map)` Utility method that return a String representation of a map.
`static String`	`mapToString(Map<?,?> map, String tabs)` Utility method that return a String representation of a map.
`static String`	`setToString(Set<?> set)` Utility method that return a String representation of a set
`static byte[]`	`toByteArray(String hexString)` Get byte array from hex string
`static String`	`toHexString(byte[] res)` Gets a hex string from byte array.
`static String`	`toLowerCase(String value)` Rewrote the toLowercase method to improve performances.
`static String`	`toUpperCase(String value)` Rewrote the toLowercase method to improve performances.
`static byte[]`	`trim(byte[] bytes)` Removes spaces (char <= 32) from both start and ends of this bytes array, handling `null` by returning `null`.
`static String`	`trim(String str)` Removes spaces (char <= 32) from both start and ends of this String, handling `null` by returning `null`.
`static String`	`trimConsecutiveToOne(String str, char ch)` Trims several consecutive characters into one.
`static int`	`trimLeft(byte[] bytes, int pos)` Removes spaces (char <= 32) from start of this array, handling `null` by returning `null`.
`static void`	`trimLeft(byte[] bytes, Position pos)` Removes spaces (char <= 32) from a position in this array, handling `null` by returning `null`.
`static int`	`trimLeft(char[] chars, int pos)` Removes spaces (char <= 32) from start of this array, handling `null` by returning `null`.
`static String`	`trimLeft(String str)` Removes spaces (char <= 32) from start of this String, handling `null` by returning `null`.
`static void`	`trimLeft(String string, Position pos)` Removes spaces (char <= 32) from a position in this array, handling `null` by returning `null`.
`static int`	`trimRight(byte[] bytes, int pos)` Removes spaces (char <= 32) from end of this array, handling `null` by returning `null`.
`static String`	`trimRight(byte[] bytes, Position pos)` Removes spaces (char <= 32) from end of this string, handling `null` by returning `null`.
`static int`	`trimRight(char[] chars, int pos)` Removes spaces (char <= 32) from end of this array, handling `null` by returning `null`.
`static String`	`trimRight(String str)` Removes spaces (char <= 32) from end of this String, handling `null` by returning `null`.
`static String`	`trimRight(String str, int escapedSpace)` Removes spaces (char <= 32) from end of this String, handling `null` by returning `null`.
`static String`	`trimRight(String string, Position pos)` Removes spaces (char <= 32) from end of this string, handling `null` by returning `null`.
`static String`	`upperCase(String str)` Converts a String to upper case as per `String.toUpperCase()`.
`static String`	`utf8ToString(byte[] bytes)` Return an UTF-8 encoded String
`static String`	`utf8ToString(byte[] bytes, int length)` Return an UTF-8 encoded String
`static String`	`utf8ToString(byte[] bytes, int start, int length)` Return an UTF-8 encoded String
`static byte[]`	`uuidToBytes(String string)` converts the string representation of an UUID to bytes
`static String`	`uuidToString(byte[] bytes)` converts the bytes of a UUID to string

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

- Field Detail
  - ALPHA
```
public static final boolean[] ALPHA
```
    <alpha> ::= [0x41-0x5A] | [0x61-0x7A]
  - ALPHA_LOWER_CASE
```
public static final boolean[] ALPHA_LOWER_CASE
```
    <alpha-lower-case> ::= [0x61-0x7A]
  - ALPHA_UPPER_CASE
```
public static final boolean[] ALPHA_UPPER_CASE
```
    <alpha-upper-case> ::= [0x41-0x5A]
  - ALPHA_DIGIT
```
public static final boolean[] ALPHA_DIGIT
```
    <alpha-digit> | <digit>
  - CHAR
```
public static final boolean[] CHAR
```
    <alpha> | <digit> | '-'
  - NOT_EQUAL
```
public static final int NOT_EQUAL
```
    See Also:
    
    Constant Field Values
  - EMPTY
```
public static final String EMPTY
```
    The empty String "".
    
    Since:
    
    2.0
    
    See Also:
    
    Constant Field Values
  - EMPTY_BYTES
```
public static final byte[] EMPTY_BYTES
```
    The empty byte[]
  - EMPTY_STRINGS
```
public static final String[] EMPTY_STRINGS
```
    The empty String[]
- Constructor Detail
  - StringTools
```
public StringTools()
```
- Method Detail
  - trimConsecutiveToOne
```
public static final String trimConsecutiveToOne(String str,
                                                char ch)
```
    Trims several consecutive characters into one.
    
    Parameters:
    
    str - the string to trim consecutive characters of
    
    ch - the character to trim down
    
    Returns:
    
    the newly trimmed down string
  - deepTrim
```
public static final String deepTrim(String string)
```
    A deep trim of a string remove whitespace from the ends as well as excessive whitespace within the inside of the string between non-whitespace characters. A deep trim reduces internal whitespace down to a single space to perserve the whitespace separated tokenization order of the String.
    
    Parameters:
    
    string - the string to deep trim.
    
    Returns:
    
    the trimmed string.
  - deepTrimToLower
```
public static final String deepTrimToLower(String string)
```
    This does the same thing as a trim but we also lowercase the string while performing the deep trim within the same buffer. This saves us from having to create multiple String and StringBuffer objects and is much more efficient.
    
    See Also:
    
    deepTrim( String )
  - deepTrim
```
public static final String deepTrim(String str,
                                    boolean toLowerCase)
```
    Put common code to deepTrim(String) and deepTrimToLower here.
    
    Parameters:
    
    str - the string to deep trim
    
    toLowerCase - how to normalize for case: upper or lower
    
    Returns:
    
    the deep trimmed string
    
    See Also:
    
    TODO Replace the toCharArray() by substring manipulations
  - centerTrunc
```
public static final String centerTrunc(String str,
                                       int head,
                                       int tail)
```
    Truncates large Strings showing a portion of the String's head and tail with the center cut out and replaced with '...'. Also displays the total length of the truncated string so size of '...' can be interpreted. Useful for large strings in UIs or hex dumps to log files.
    
    Parameters:
    
    str - the string to truncate
    
    head - the amount of the head to display
    
    tail - the amount of the tail to display
    
    Returns:
    
    the center truncated string
  - toHexString
```
public static final String toHexString(byte[] res)
```
    Gets a hex string from byte array.
    
    Parameters:
    
    res - the byte array
    
    Returns:
    
    the hex string representing the binary values in the array
  - toLowerCase
```
public static final String toLowerCase(String value)
```
    Rewrote the toLowercase method to improve performances. In Ldap, attributesType are supposed to use ASCII chars : 'a'-'z', 'A'-'Z', '0'-'9', '.' and '-' only.
    
    Parameters:
    
    value - The String to lowercase
    
    Returns:
    
    The lowercase string
  - toUpperCase
```
public static final String toUpperCase(String value)
```
    Rewrote the toLowercase method to improve performances. In Ldap, attributesType are supposed to use ASCII chars : 'a'-'z', 'A'-'Z', '0'-'9', '.' and '-' only.
    
    Parameters:
    
    value - The String to uppercase
    
    Returns:
    
    The uppercase string
  - toByteArray
```
public static final byte[] toByteArray(String hexString)
```
    Get byte array from hex string
    
    Parameters:
    
    hexString - the hex string to convert to a byte array
    
    Returns:
    
    the byte form of the hex string.
  - formatHtml
```
public static final String formatHtml(String source,
                                      boolean replaceNl,
                                      boolean replaceTag,
                                      boolean replaceQuote)
```
    This method is used to insert HTML block dynamically
    
    Parameters:
    
    source - the HTML code to be processes
    
    replaceNl - if true '\n' will be replaced by <br>
    
    replaceTag - if true '<' will be replaced by < and '>' will be replaced by >
    
    replaceQuote - if true '\"' will be replaced by "
    
    Returns:
    
    the formated html block
  - getRegex
```
public static final Pattern getRegex(String initialPattern,
                                     String[] anyPattern,
                                     String finalPattern)
                              throws PatternSyntaxException
```
    Creates a regular expression from an LDAP substring assertion filter specification.
    
    Parameters:
    
    initialPattern - the initial fragment before wildcards
    
    anyPattern - fragments surrounded by wildcards if any
    
    finalPattern - the final fragment after last wildcard if any
    
    Returns:
    
    the regular expression for the substring match filter
    
    Throws:
    
    PatternSyntaxException - if a syntactically correct regular expression cannot be compiled
  - getRegex
```
public static final Pattern getRegex(String ldapRegex)
                              throws PatternSyntaxException
```
    Generates a regular expression from an LDAP substring match expression by parsing out the supplied string argument.
    
    Parameters:
    
    ldapRegex - the substring match expression
    
    Returns:
    
    the regular expression for the substring match filter
    
    Throws:
    
    PatternSyntaxException - if a syntactically correct regular expression cannot be compiled
  - getPaths
```
public static final List<String> getPaths(String paths,
                                          FileFilter filter)
```
    Splits apart a OS separator delimited set of paths in a string into multiple Strings. File component path strings are returned within a List in the order they are found in the composite path string. Optionally, a file filter can be used to filter out path strings to control the components returned. If the filter is null all path components are returned.
    
    Parameters:
    
    paths - a set of paths delimited using the OS path separator
    
    filter - a FileFilter used to filter the return set
    
    Returns:
    
    the filter accepted path component Strings in the order encountered
  - dumpByte
```
public static final String dumpByte(byte octet)
```
    Helper function that dump a byte in hex form
    
    Parameters:
    
    octet - The byte to dump
    
    Returns:
    
    A string representation of the byte
  - dumpHex
```
public static final char dumpHex(byte hex)
```
    Helper function that returns a char from an hex
    
    Parameters:
    
    hex - The hex to dump
    
    Returns:
    
    A char representation of the hex
  - dumpBytes
```
public static final String dumpBytes(byte[] buffer)
```
    Helper function that dump an array of bytes in hex form
    
    Parameters:
    
    buffer - The bytes array to dump
    
    Returns:
    
    A string representation of the array of bytes
  - dumpObject
```
public static String dumpObject(Object object)
```
    Helper method to render an object which can be a String or a byte[]
    
    Returns:
    
    A string representing the object
  - dumpHexPairs
```
public static final String dumpHexPairs(byte[] buffer)
```
    Helper function that dump an array of bytes in hex pair form, without '0x' and space chars
    
    Parameters:
    
    buffer - The bytes array to dump
    
    Returns:
    
    A string representation of the array of bytes
  - bytesToChar
```
public static final char bytesToChar(byte[] bytes)
```
    Return the Unicode char which is coded in the bytes at position 0.
    
    Parameters:
    
    bytes - The byte[] represntation of an Unicode string.
    
    Returns:
    
    The first char found.
  - countBytesPerChar
```
public static final int countBytesPerChar(byte[] bytes,
                                          int pos)
```
    Count the number of bytes needed to return an Unicode char. This can be from 1 to 6.
    
    Parameters:
    
    bytes - The bytes to read
    
    pos - Position to start counting. It must be a valid start of a encoded char !
    
    Returns:
    
    The number of bytes to create a char, or -1 if the encoding is wrong. TODO : Should stop after the third byte, as a char is only 2 bytes long.
  - countNbBytesPerChar
```
public static final int countNbBytesPerChar(char car)
```
    Return the number of bytes that hold an Unicode char.
    
    Parameters:
    
    car - The character to be decoded
    
    Returns:
    
    The number of bytes to hold the char. TODO : Should stop after the third byte, as a char is only 2 bytes long.
  - countBytes
```
public static final int countBytes(char[] chars)
```
    Count the number of bytes included in the given char[].
    
    Parameters:
    
    chars - The char array to decode
    
    Returns:
    
    The number of bytes in the char array
  - bytesToChar
```
public static final char bytesToChar(byte[] bytes,
                                     int pos)
```
    Return the Unicode char which is coded in the bytes at the given position.
    
    Parameters:
    
    bytes - The byte[] represntation of an Unicode string.
    
    pos - The current position to start decoding the char
    
    Returns:
    
    The decoded char, or -1 if no char can be decoded TODO : Should stop after the third byte, as a char is only 2 bytes long.
  - charToBytes
```
public static final byte[] charToBytes(char car)
```
    Return the Unicode char which is coded in the bytes at the given position.
    
    Parameters:
    
    car - The character to be transformed to an array of bytes
    
    Returns:
    
    The byte array representing the char TODO : Should stop after the third byte, as a char is only 2 bytes long.
  - countChars
```
public static final int countChars(byte[] bytes)
```
    Count the number of chars included in the given byte[].
    
    Parameters:
    
    bytes - The byte array to decode
    
    Returns:
    
    The number of char in the byte array
  - areEquals
```
public static final int areEquals(byte[] bytes,
                                  int index,
                                  String text)
```
    Check if a text is present at the current position in a buffer.
    
    Parameters:
    
    bytes - The buffer which contains the data
    
    index - Current position in the buffer
    
    text - The text we want to check
    
    Returns:
    
    true if the buffer contains the text.
  - areEquals
```
public static final int areEquals(char[] chars,
                                  int index,
                                  String text)
```
    Check if a text is present at the current position in a buffer.
    
    Parameters:
    
    chars - The buffer which contains the data
    
    index - Current position in the buffer
    
    text - The text we want to check
    
    Returns:
    
    true if the buffer contains the text.
  - areEquals
```
public static final int areEquals(char[] chars,
                                  int index,
                                  char[] chars2)
```
    Check if a text is present at the current position in a buffer.
    
    Parameters:
    
    chars - The buffer which contains the data
    
    index - Current position in the buffer
    
    chars2 - The text we want to check
    
    Returns:
    
    true if the buffer contains the text.
  - areEquals
```
public static final boolean areEquals(String string,
                                      int index,
                                      String text)
```
    Check if a text is present at the current position in another string.
    
    Parameters:
    
    string - The string which contains the data
    
    index - Current position in the string
    
    text - The text we want to check
    
    Returns:
    
    true if the string contains the text.
  - areEquals
```
public static final int areEquals(byte[] bytes,
                                  int index,
                                  byte[] bytes2)
```
    Check if a text is present at the current position in a buffer.
    
    Parameters:
    
    bytes - The buffer which contains the data
    
    index - Current position in the buffer
    
    bytes2 - The text we want to check
    
    Returns:
    
    true if the buffer contains the text.
  - isCharASCII
```
public static final boolean isCharASCII(byte[] byteArray,
                                        int index,
                                        char car)
```
    Test if the current character is equal to a specific character. This function works only for character between 0 and 127, as it does compare a byte and a char (which is 16 bits wide)
    
    Parameters:
    
    byteArray - The buffer which contains the data
    
    index - Current position in the buffer
    
    car - The character we want to compare with the current buffer position
    
    Returns:
    
    true if the current character equals the given character.
  - isCharASCII
```
public static final boolean isCharASCII(char[] chars,
                                        int index,
                                        char car)
```
    Test if the current character is equal to a specific character.
    
    Parameters:
    
    chars - The buffer which contains the data
    
    index - Current position in the buffer
    
    car - The character we want to compare with the current buffer position
    
    Returns:
    
    true if the current character equals the given character.
  - isCharASCII
```
public static final boolean isCharASCII(String string,
                                        int index,
                                        char car)
```
    Test if the current character is equal to a specific character.
    
    Parameters:
    
    string - The String which contains the data
    
    index - Current position in the string
    
    car - The character we want to compare with the current string position
    
    Returns:
    
    true if the current character equals the given character.
  - isICharASCII
```
public static final boolean isICharASCII(String string,
                                         int index,
                                         char car)
```
    Test if the current character is equal to a specific character.
    
    Parameters:
    
    string - The String which contains the data
    
    index - Current position in the string
    
    car - The character we want to compare with the current string position
    
    Returns:
    
    true if the current character equals the given character.
  - isICharASCII
```
public static final boolean isICharASCII(byte[] bytes,
                                         int index,
                                         char car)
```
    Test if the current character is equal to a specific character.
    
    Parameters:
    
    string - The String which contains the data
    
    index - Current position in the string
    
    car - The character we want to compare with the current string position
    
    Returns:
    
    true if the current character equals the given character.
  - isBit
```
public static final boolean isBit(String string,
                                  int index)
```
    Test if the current character is a bit, ie 0 or 1.
    
    Parameters:
    
    string - The String which contains the data
    
    index - Current position in the string
    
    Returns:
    
    true if the current character is a bit (0 or 1)
  - charAt
```
public static final char charAt(String string,
                                int index)
```
    Get the character at a given position in a string, checking fo limits
    
    Parameters:
    
    string - The string which contains the data
    
    index - Current position in the string
    
    Returns:
    
    The character ar the given position, or '\0' if something went wrong
  - getHexValue
```
public static byte getHexValue(char high,
                               char low)
```
    Translate two chars to an hex value. The chars must be in [a-fA-F0-9]
    
    Parameters:
    
    high - The high value
    
    low - The low value
    
    Returns:
    
    A byte representation of the two chars
  - getHexValue
```
public static byte getHexValue(byte high,
                               byte low)
```
    Translate two bytes to an hex value. The bytes must be in [0-9a-fA-F]
    
    Parameters:
    
    high - The high value
    
    low - The low value
    
    Returns:
    
    A byte representation of the two bytes
  - getHexValue
```
public static byte getHexValue(char c)
```
    Return an hex value from a sinle char The char must be in [0-9a-fA-F]
    
    Parameters:
    
    c - The char we want to convert
    
    Returns:
    
    A byte between 0 and 15
  - isHex
```
public static final boolean isHex(byte[] bytes,
                                  int index)
```
    Check if the current character is an Hex Char <hex> ::= [0x30-0x39] | [0x41-0x46] | [0x61-0x66]
    
    Parameters:
    
    bytes - The buffer which contains the data
    
    index - Current position in the buffer
    
    Returns:
    
    true if the current character is a Hex Char
  - isHex
```
public static final boolean isHex(char[] chars,
                                  int index)
```
    Check if the current character is an Hex Char <hex> ::= [0x30-0x39] | [0x41-0x46] | [0x61-0x66]
    
    Parameters:
    
    chars - The buffer which contains the data
    
    index - Current position in the buffer
    
    Returns:
    
    true if the current character is a Hex Char
  - isHex
```
public static final boolean isHex(String string,
                                  int index)
```
    Check if the current character is an Hex Char <hex> ::= [0x30-0x39] | [0x41-0x46] | [0x61-0x66]
    
    Parameters:
    
    string - The string which contains the data
    
    index - Current position in the string
    
    Returns:
    
    true if the current character is a Hex Char
  - isDigit
```
public static final boolean isDigit(byte[] bytes)
```
    Test if the current character is a digit <digit> ::= '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9'
    
    Parameters:
    
    bytes - The buffer which contains the data
    
    Returns:
    
    true if the current character is a Digit
  - isDigit
```
public static final boolean isDigit(char car)
```
    Test if the current character is a digit <digit> ::= '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9'
    
    Parameters:
    
    car - the character to test
    
    Returns:
    
    true if the character is a Digit
  - isAlpha
```
public static final boolean isAlpha(byte c)
```
    Test if the current byte is an Alpha character : <alpha> ::= [0x41-0x5A] | [0x61-0x7A]
    
    Parameters:
    
    c - The byte to test
    
    Returns:
    
    true if the byte is an Alpha character
  - isAlpha
```
public static final boolean isAlpha(char c)
```
    Test if the current character is an Alpha character : <alpha> ::= [0x41-0x5A] | [0x61-0x7A]
    
    Parameters:
    
    c - The char to test
    
    Returns:
    
    true if the character is an Alpha character
  - isAlphaASCII
```
public static final boolean isAlphaASCII(byte[] bytes,
                                         int index)
```
    Test if the current character is an Alpha character : <alpha> ::= [0x41-0x5A] | [0x61-0x7A]
    
    Parameters:
    
    bytes - The buffer which contains the data
    
    index - Current position in the buffer
    
    Returns:
    
    true if the current character is an Alpha character
  - isAlphaASCII
```
public static final boolean isAlphaASCII(char[] chars,
                                         int index)
```
    Test if the current character is an Alpha character : <alpha> ::= [0x41-0x5A] | [0x61-0x7A]
    
    Parameters:
    
    chars - The buffer which contains the data
    
    index - Current position in the buffer
    
    Returns:
    
    true if the current character is an Alpha character
  - isAlphaASCII
```
public static final boolean isAlphaASCII(String string,
                                         int index)
```
    Test if the current character is an Alpha character : <alpha> ::= [0x41-0x5A] | [0x61-0x7A]
    
    Parameters:
    
    string - The string which contains the data
    
    index - Current position in the string
    
    Returns:
    
    true if the current character is an Alpha character
  - isAlphaLowercaseASCII
```
public static final boolean isAlphaLowercaseASCII(String string,
                                                  int index)
```
    Test if the current character is a lowercased Alpha character :
    <alpha> ::= [0x61-0x7A]
    
    Parameters:
    
    string - The string which contains the data
    
    index - Current position in the string
    
    Returns:
    
    true if the current character is a lower Alpha character
  - isAlphaUppercaseASCII
```
public static final boolean isAlphaUppercaseASCII(String string,
                                                  int index)
```
    Test if the current character is a uppercased Alpha character :
    <alpha> ::= [0x61-0x7A]
    
    Parameters:
    
    string - The string which contains the data
    
    index - Current position in the string
    
    Returns:
    
    true if the current character is a lower Alpha character
  - isDigit
```
public static final boolean isDigit(byte[] bytes,
                                    int index)
```
    Test if the current character is a digit <digit> ::= '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9'
    
    Parameters:
    
    bytes - The buffer which contains the data
    
    index - Current position in the buffer
    
    Returns:
    
    true if the current character is a Digit
  - isDigit
```
public static final boolean isDigit(char[] chars,
                                    int index)
```
    Test if the current character is a digit <digit> ::= '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9'
    
    Parameters:
    
    chars - The buffer which contains the data
    
    index - Current position in the buffer
    
    Returns:
    
    true if the current character is a Digit
  - isDigit
```
public static final boolean isDigit(String string,
                                    int index)
```
    Test if the current character is a digit <digit> ::= '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9'
    
    Parameters:
    
    string - The string which contains the data
    
    index - Current position in the string
    
    Returns:
    
    true if the current character is a Digit
  - isDigit
```
public static final boolean isDigit(char[] chars)
```
    Test if the current character is a digit <digit> ::= '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9'
    
    Parameters:
    
    chars - The buffer which contains the data
    
    Returns:
    
    true if the current character is a Digit
  - isAlphaDigit
```
public static final boolean isAlphaDigit(String string,
                                         int index)
```
    Check if the current character is an 7 bits ASCII CHAR (between 0 and 127). <char> ::= <alpha> | <digit>
    
    Parameters:
    
    string - The string which contains the data
    
    index - Current position in the string
    
    Returns:
    
    The position of the next character, if the current one is a CHAR.
  - isAlphaDigitMinus
```
public static final boolean isAlphaDigitMinus(byte[] bytes,
                                              int index)
```
    Check if the current character is an 7 bits ASCII CHAR (between 0 and 127). <char> ::= <alpha> | <digit> | '-'
    
    Parameters:
    
    bytes - The buffer which contains the data
    
    index - Current position in the buffer
    
    Returns:
    
    The position of the next character, if the current one is a CHAR.
  - isAlphaDigitMinus
```
public static final boolean isAlphaDigitMinus(char[] chars,
                                              int index)
```
    Check if the current character is an 7 bits ASCII CHAR (between 0 and 127). <char> ::= <alpha> | <digit> | '-'
    
    Parameters:
    
    chars - The buffer which contains the data
    
    index - Current position in the buffer
    
    Returns:
    
    The position of the next character, if the current one is a CHAR.
  - isAlphaDigitMinus
```
public static final boolean isAlphaDigitMinus(String string,
                                              int index)
```
    Check if the current character is an 7 bits ASCII CHAR (between 0 and 127). <char> ::= <alpha> | <digit> | '-'
    
    Parameters:
    
    string - The string which contains the data
    
    index - Current position in the string
    
    Returns:
    
    The position of the next character, if the current one is a CHAR.
  - isEmpty
```
public static final boolean isEmpty(String str)
```
    Checks if a String is empty ("") or null.
```
  StringUtils.isEmpty(null)      = true
  StringUtils.isEmpty("")        = true
  StringUtils.isEmpty(" ")       = false
  StringUtils.isEmpty("bob")     = false
  StringUtils.isEmpty("  bob  ") = false
 
```
    NOTE: This method changed in Lang version 2.0. It no longer trims the String. That functionality is available in isBlank().
    Parameters:
    
    str - the String to check, may be null
    
    Returns:
    
    true if the String is empty or null
  - isEmpty
```
public static final boolean isEmpty(byte[] bytes)
```
    Checks if a bytes array is empty or null.
    
    Parameters:
    
    bytes - The bytes array to check, may be null
    
    Returns:
    
    true if the bytes array is empty or null
  - isNotEmpty
```
public static final boolean isNotEmpty(String str)
```
    Checks if a String is not empty ("") and not null.
```
  StringUtils.isNotEmpty(null)      = false
  StringUtils.isNotEmpty("")        = false
  StringUtils.isNotEmpty(" ")       = true
  StringUtils.isNotEmpty("bob")     = true
  StringUtils.isNotEmpty("  bob  ") = true
 
```
    Parameters:
    
    str - the String to check, may be null
    
    Returns:
    
    true if the String is not empty and not null
  - trim
```
public static final String trim(String str)
```
    Removes spaces (char <= 32) from both start and ends of this String, handling null by returning null.
    Trim removes start and end characters <= 32.
```
  StringUtils.trim(null)          = null
  StringUtils.trim("")            = ""
  StringUtils.trim("     ")       = ""
  StringUtils.trim("abc")         = "abc"
  StringUtils.trim("    abc    ") = "abc"
 
```
    Parameters:
    
    str - the String to be trimmed, may be null
    
    Returns:
    
    the trimmed string, null if null String input
  - trim
```
public static final byte[] trim(byte[] bytes)
```
    Removes spaces (char <= 32) from both start and ends of this bytes array, handling null by returning null.
    Trim removes start and end characters <= 32.
```
  StringUtils.trim(null)          = null
  StringUtils.trim("")            = ""
  StringUtils.trim("     ")       = ""
  StringUtils.trim("abc")         = "abc"
  StringUtils.trim("    abc    ") = "abc"
 
```
    Parameters:
    
    bytes - the byte array to be trimmed, may be null
    
    Returns:
    
    the trimmed byte array
  - trimLeft
```
public static final String trimLeft(String str)
```
    Removes spaces (char <= 32) from start of this String, handling null by returning null.
    Trim removes start characters <= 32.
```
  StringUtils.trimLeft(null)          = null
  StringUtils.trimLeft("")            = ""
  StringUtils.trimLeft("     ")       = ""
  StringUtils.trimLeft("abc")         = "abc"
  StringUtils.trimLeft("    abc    ") = "abc    "
 
```
    Parameters:
    
    str - the String to be trimmed, may be null
    
    Returns:
    
    the trimmed string, null if null String input
  - trimLeft
```
public static final int trimLeft(char[] chars,
                                 int pos)
```
    Removes spaces (char <= 32) from start of this array, handling null by returning null.
    Trim removes start characters <= 32.
```
  StringUtils.trimLeft(null)          = null
  StringUtils.trimLeft("")            = ""
  StringUtils.trimLeft("     ")       = ""
  StringUtils.trimLeft("abc")         = "abc"
  StringUtils.trimLeft("    abc    ") = "abc    "
 
```
    Parameters:
    
    chars - the chars array to be trimmed, may be null
    
    Returns:
    
    the position of the first char which is not a space, or the last position of the array.
  - trimLeft
```
public static final void trimLeft(String string,
                                  Position pos)
```
    Removes spaces (char <= 32) from a position in this array, handling null by returning null.
    Trim removes start characters <= 32.
```
  StringUtils.trimLeft(null)          = null
  StringUtils.trimLeft("",...)            = ""
  StringUtils.trimLeft("     ",...)       = ""
  StringUtils.trimLeft("abc",...)         = "abc"
  StringUtils.trimLeft("    abc    ",...) = "abc    "
 
```
    Parameters:
    
    string - the string to be trimmed, may be null
    
    pos - The starting position
  - trimLeft
```
public static final void trimLeft(byte[] bytes,
                                  Position pos)
```
    Removes spaces (char <= 32) from a position in this array, handling null by returning null.
    Trim removes start characters <= 32.
```
  StringUtils.trimLeft(null)          = null
  StringUtils.trimLeft("",...)            = ""
  StringUtils.trimLeft("     ",...)       = ""
  StringUtils.trimLeft("abc",...)         = "abc"
  StringUtils.trimLeft("    abc    ",...) = "abc    "
 
```
    Parameters:
    
    bytes - the byte array to be trimmed, may be null
    
    pos - The starting position
  - trimLeft
```
public static final int trimLeft(byte[] bytes,
                                 int pos)
```
    Removes spaces (char <= 32) from start of this array, handling null by returning null.
    Trim removes start characters <= 32.
```
  StringUtils.trimLeft(null)          = null
  StringUtils.trimLeft("")            = ""
  StringUtils.trimLeft("     ")       = ""
  StringUtils.trimLeft("abc")         = "abc"
  StringUtils.trimLeft("    abc    ") = "abc    "
 
```
    Parameters:
    
    bytes - the byte array to be trimmed, may be null
    
    Returns:
    
    the position of the first byte which is not a space, or the last position of the array.
  - trimRight
```
public static final String trimRight(String str)
```
    Removes spaces (char <= 32) from end of this String, handling null by returning null.
    Trim removes start characters <= 32.
```
  StringUtils.trimRight(null)          = null
  StringUtils.trimRight("")            = ""
  StringUtils.trimRight("     ")       = ""
  StringUtils.trimRight("abc")         = "abc"
  StringUtils.trimRight("    abc    ") = "    abc"
 
```
    Parameters:
    
    str - the String to be trimmed, may be null
    
    Returns:
    
    the trimmed string, null if null String input
  - trimRight
```
public static final String trimRight(String str,
                                     int escapedSpace)
```
    Removes spaces (char <= 32) from end of this String, handling null by returning null.
    Trim removes start characters <= 32.
```
  StringUtils.trimRight(null)          = null
  StringUtils.trimRight("")            = ""
  StringUtils.trimRight("     ")       = ""
  StringUtils.trimRight("abc")         = "abc"
  StringUtils.trimRight("    abc    ") = "    abc"
 
```
    Parameters:
    
    str - the String to be trimmed, may be null
    
    escapedSpace - The last escaped space, if any
    
    Returns:
    
    the trimmed string, null if null String input
  - trimRight
```
public static final int trimRight(char[] chars,
                                  int pos)
```
    Removes spaces (char <= 32) from end of this array, handling null by returning null.
    Trim removes start characters <= 32.
```
  StringUtils.trimRight(null)          = null
  StringUtils.trimRight("")            = ""
  StringUtils.trimRight("     ")       = ""
  StringUtils.trimRight("abc")         = "abc"
  StringUtils.trimRight("    abc    ") = "    abc"
 
```
    Parameters:
    
    chars - the chars array to be trimmed, may be null
    
    Returns:
    
    the position of the first char which is not a space, or the last position of the array.
  - trimRight
```
public static final String trimRight(String string,
                                     Position pos)
```
    Removes spaces (char <= 32) from end of this string, handling null by returning null.
    Trim removes start characters <= 32.
```
  StringUtils.trimRight(null)          = null
  StringUtils.trimRight("")            = ""
  StringUtils.trimRight("     ")       = ""
  StringUtils.trimRight("abc")         = "abc"
  StringUtils.trimRight("    abc    ") = "    abc"
 
```
    Parameters:
    
    string - the string to be trimmed, may be null
    
    Returns:
    
    the position of the first char which is not a space, or the last position of the string.
  - trimRight
```
public static final String trimRight(byte[] bytes,
                                     Position pos)
```
    Removes spaces (char <= 32) from end of this string, handling null by returning null.
    Trim removes start characters <= 32.
```
  StringUtils.trimRight(null)          = null
  StringUtils.trimRight("")            = ""
  StringUtils.trimRight("     ")       = ""
  StringUtils.trimRight("abc")         = "abc"
  StringUtils.trimRight("    abc    ") = "    abc"
 
```
    Parameters:
    
    bytes - the byte array to be trimmed, may be null
    
    Returns:
    
    the position of the first char which is not a space, or the last position of the byte array.
  - trimRight
```
public static final int trimRight(byte[] bytes,
                                  int pos)
```
    Removes spaces (char <= 32) from end of this array, handling null by returning null.
    Trim removes start characters <= 32.
```
  StringUtils.trimRight(null)          = null
  StringUtils.trimRight("")            = ""
  StringUtils.trimRight("     ")       = ""
  StringUtils.trimRight("abc")         = "abc"
  StringUtils.trimRight("    abc    ") = "    abc"
 
```
    Parameters:
    
    bytes - the byte array to be trimmed, may be null
    
    Returns:
    
    the position of the first char which is not a space, or the last position of the array.
  - upperCase
```
public static final String upperCase(String str)
```
    Converts a String to upper case as per String.toUpperCase().
    
    A null input String returns null.
```
  StringUtils.upperCase(null)  = null
  StringUtils.upperCase("")    = ""
  StringUtils.upperCase("aBc") = "ABC"
 
```
    Parameters:
    
    str - the String to upper case, may be null
    
    Returns:
    
    the upper cased String, null if null String input
  - lowerCase
```
public static final String lowerCase(String str)
```
    Converts a String to lower case as per String.toLowerCase().
    
    A null input String returns null.
```
  StringUtils.lowerCase(null)  = null
  StringUtils.lowerCase("")    = ""
  StringUtils.lowerCase("aBc") = "abc"
 
```
    Parameters:
    
    str - the String to lower case, may be null
    
    Returns:
    
    the lower cased String, null if null String input
  - lowerCaseAscii
```
public static final String lowerCaseAscii(String str)
```
    Rewrote the toLowercase method to improve performances. In Ldap, attributesType are supposed to use ASCII chars : 'a'-'z', 'A'-'Z', '0'-'9', '.' and '-' only. We will take care of any other chars either.
    
    Parameters:
    
    str - The String to lowercase
    
    Returns:
    
    The lowercase string
  - equals
```
public static final boolean equals(String str1,
                                   String str2)
```
    Compares two Strings, returning true if they are equal.
    
    nulls are handled without exceptions. Two null references are considered to be equal. The comparison is case sensitive.
```
  StringUtils.equals(null, null)   = true
  StringUtils.equals(null, "abc")  = false
  StringUtils.equals("abc", null)  = false
  StringUtils.equals("abc", "abc") = true
  StringUtils.equals("abc", "ABC") = false
 
```
    Parameters:
    
    str1 - the first String, may be null
    
    str2 - the second String, may be null
    
    Returns:
    
    true if the Strings are equal, case sensitive, or both null
    
    See Also:
    
    String.equals(Object)
  - utf8ToString
```
public static final String utf8ToString(byte[] bytes)
```
    Return an UTF-8 encoded String
    
    Parameters:
    
    bytes - The byte array to be transformed to a String
    
    Returns:
    
    A String.
  - utf8ToString
```
public static final String utf8ToString(byte[] bytes,
                                        int length)
```
    Return an UTF-8 encoded String
    
    Parameters:
    
    bytes - The byte array to be transformed to a String
    
    length - The length of the byte array to be converted
    
    Returns:
    
    A String.
  - utf8ToString
```
public static final String utf8ToString(byte[] bytes,
                                        int start,
                                        int length)
```
    Return an UTF-8 encoded String
    
    Parameters:
    
    bytes - The byte array to be transformed to a String
    
    start - the starting position in the byte array
    
    length - The length of the byte array to be converted
    
    Returns:
    
    A String.
  - getBytesUtf8
```
public static final byte[] getBytesUtf8(String string)
```
    Return UTF-8 encoded byte[] representation of a String
    
    Parameters:
    
    string - The string to be transformed to a byte array
    
    Returns:
    
    The transformed byte array
  - listToString
```
public static final String listToString(List<?> list)
```
    Utility method that return a String representation of a list
    
    Parameters:
    
    list - The list to transform to a string
    
    Returns:
    
    A csv string
  - setToString
```
public static final String setToString(Set<?> set)
```
    Utility method that return a String representation of a set
    
    Parameters:
    
    set - The set to transform to a string
    
    Returns:
    
    A csv string
  - listToString
```
public static final String listToString(List<?> list,
                                        String tabs)
```
    Utility method that return a String representation of a list
    
    Parameters:
    
    list - The list to transform to a string
    
    tabs - The tabs to add in ffront of the elements
    
    Returns:
    
    A csv string
  - mapToString
```
public static final String mapToString(Map<?,?> map)
```
    Utility method that return a String representation of a map. The elements will be represented as "key = value"
    
    Parameters:
    
    map - The map to transform to a string
    
    Returns:
    
    A csv string
  - mapToString
```
public static final String mapToString(Map<?,?> map,
                                       String tabs)
```
    Utility method that return a String representation of a map. The elements will be represented as "key = value"
    
    Parameters:
    
    map - The map to transform to a string
    
    tabs - The tabs to add in ffront of the elements
    
    Returns:
    
    A csv string
  - getDefaultCharsetName
```
public static final String getDefaultCharsetName()
```
    Get the default charset
    
    Returns:
    
    The default charset
  - decodeHexString
```
public static final String decodeHexString(String str)
                                    throws InvalidNameException
```
    Decodes values of attributes in the DN encoded in hex into a UTF-8 String. RFC2253 allows a DN's attribute to be encoded in hex. The encoded value starts with a # then is followed by an even number of hex characters.
    
    Parameters:
    
    str - the string to decode
    
    Returns:
    
    the decoded string
    
    Throws:
    
    InvalidNameException
  - decodeEscapedHex
```
public static final String decodeEscapedHex(String str)
                                     throws InvalidNameException
```
    Decodes sequences of escaped hex within an attribute's value into a UTF-8 String. The hex is decoded inline and the complete decoded String is returned.
    
    Parameters:
    
    str - the string containing hex escapes
    
    Returns:
    
    the decoded string
    
    Throws:
    
    InvalidNameException
  - convertEscapedHex
```
public static final byte[] convertEscapedHex(String str)
                                      throws InvalidNameException
```
    Convert an escaoed list of bytes to a byte[]
    
    Parameters:
    
    str - the string containing hex escapes
    
    Returns:
    
    the converted byte[]
    
    Throws:
    
    InvalidNameException
  - collectEscapedHexBytes
```
public static int collectEscapedHexBytes(ByteBuffer bb,
                                         String str,
                                         int index)
```
    Collects an hex sequence from a string, and returns the value as an integer, after having modified the initial value (the escaped hex value is transsformed to the byte it represents).
    
    Parameters:
    
    bb - the buffer which will contain the unescaped byte
    
    str - the initial string with ecaped chars
    
    index - the position in the string of the escaped data
    
    Returns:
    
    the byte as an integer
  - asciiBytesToString
```
public static String asciiBytesToString(byte[] bytes)
```
    Thansform an array of ASCII bytes to a string. the byte array should contains only values in [0, 127].
    
    Parameters:
    
    bytes - The byte array to transform
    
    Returns:
    
    The resulting string
  - getType
```
public static String getType(byte[] bytes)
```
    Build an AttributeType froma byte array. An AttributeType contains only chars within [0-9][a-z][A-Z][-.].
    
    Parameters:
    
    bytes - The bytes containing the AttributeType
    
    Returns:
    
    The AttributeType as a String
  - isIA5String
```
public static boolean isIA5String(String str)
```
    Check that a String is a valid IA5String. An IA5String contains only char which values is between [0, 7F]
    
    Parameters:
    
    str - The String to check
    
    Returns:
    
    true if the string is an IA5String or is empty, false otherwise
  - isPrintableString
```
public static boolean isPrintableString(String str)
```
    Check that a String is a valid PrintableString. A PrintableString contains only the following set of chars : { ' ', ''', '(', ')', '+', '-', '.', '/', [0-9], ':', '=', '?', [A-Z], [a-z]}
    
    Parameters:
    
    str - The String to check
    
    Returns:
    
    true if the string is a PrintableString or is empty, false otherwise
  - isUnicodeSubset
```
public static boolean isUnicodeSubset(String str,
                                      int pos)
```
    Check if the current char is in the unicodeSubset : all chars but '\0', '(', ')', '*' and '\'
    
    Parameters:
    
    str - The string to check
    
    pos - Position of the current char
    
    Returns:
    
    True if the current char is in the unicode subset
  - isUnicodeSubset
```
public static boolean isUnicodeSubset(char c)
```
    Check if the current char is in the unicodeSubset : all chars but '\0', '(', ')', '*' and '\'
    
    Parameters:
    
    c - The char to check
    
    Returns:
    
    True if the current char is in the unicode subset
  - uuidToString
```
public static String uuidToString(byte[] bytes)
```
    converts the bytes of a UUID to string
    
    Parameters:
    
    bytes - bytes of a UUID
    
    Returns:
    
    UUID in string format
  - uuidToBytes
```
public static byte[] uuidToBytes(String string)
```
    converts the string representation of an UUID to bytes
    
    Parameters:
    
    string - the string representation of an UUID
    
    Returns:
    
    the bytes, null if the the syntax is not valid

Class StringTools

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

ALPHA

ALPHA_LOWER_CASE

ALPHA_UPPER_CASE

ALPHA_DIGIT

CHAR

NOT_EQUAL

EMPTY

EMPTY_BYTES

EMPTY_STRINGS

Constructor Detail

StringTools

Method Detail

trimConsecutiveToOne

deepTrim

deepTrimToLower

deepTrim

centerTrunc

toHexString

toLowerCase

toUpperCase

toByteArray

formatHtml

getRegex

getRegex

getPaths

dumpByte

dumpHex

dumpBytes

dumpObject

dumpHexPairs

bytesToChar

countBytesPerChar

countNbBytesPerChar

countBytes

bytesToChar

charToBytes

countChars

areEquals

areEquals

areEquals

areEquals

areEquals

isCharASCII

isCharASCII

isCharASCII

isICharASCII

isICharASCII

isBit

charAt

getHexValue

getHexValue

getHexValue

isHex

isHex

isHex

isDigit

isDigit

isAlpha

isAlpha

isAlphaASCII

isAlphaASCII

isAlphaASCII

isAlphaLowercaseASCII

isAlphaUppercaseASCII

isDigit

isDigit

isDigit

isDigit

isAlphaDigit

isAlphaDigitMinus

isAlphaDigitMinus

isAlphaDigitMinus

isEmpty

isEmpty