Package com.xceptance.xlt.api.util

# Class XltCharBuffer

java.lang.Object
com.xceptance.xlt.api.util.XltCharBuffer

All Implemented Interfaces:
  `CharSequence`, `Comparable<XltCharBuffer>`

public class XltCharBuffer extends Object implements CharSequence, Comparable<XltCharBuffer>
This class does not implement the CharBuffer of the JDK, but uses the idea of a shared character array with views. This is also a very unsafe implementation with as little as possible boundary checks to achieve the maximum speed possible. To enhance use, we implement CharSequence and hence can also do regex with it now. It also features common String and StringBuilder methods to make it versatile and avoid the typical overhead when doing conversions back and forth.

Since:
  7.0

- ## Field Summary

  Fields
  Modifier and Type
  Field
  Description
  `static final XltCharBuffer`
  `EMPTY`
  An empty static XltCharBuffer

- ## Constructor Summary

  Constructors
  Constructor
  Description
  `XltCharBuffer(char[] src)`
  New buffer from a raw char array
  `XltCharBuffer(char[] src, int from, int length)`
  A new buffer from a char array including a view port.

- ## Method Summary

  Modifier and Type
  Method
  Description
  `char`
  `charAt(int pos)`
  Return the character at a position.
  `int`
  `compareTo(XltCharBuffer other)`
  Compares this object with the specified object for order.
  `static boolean`
  `contains(XltCharBuffer haystack, XltCharBuffer needle, int[] shiftTable)`
  Checks if the needle is contained in the haystack using the Boyer-Moore-Horspool algorithm.
  `static int[]`
  `createShiftTable(XltCharBuffer needle)`
  Creates the shift table needed for the Boyer-Moore-Horspool algorithm.
  `static XltCharBuffer`
  `empty()`
  Just returns an empty buffer.
  `static XltCharBuffer`
  `emptyWhenNull(XltCharBuffer s)`
  Returns the empty string if the provided buffer is null the buffer otherwise
  `boolean`
  `endsWith(XltCharBuffer s)`
  Checks whether or not a buffer ends with the content of another buffer
  `boolean`
  `equals(Object obj)`
  `int`
  `hashCode()`
  Optimized hashcode calculation for large strings using all execution units of the CPU.
  `int`
  `indexOf(char c)`
  Find the first occurrence of a char
  `int`
  `indexOf(XltCharBuffer s)`
  Search for the first occurrence of another buffer in this buffer
  `int`
  `indexOf(XltCharBuffer s, int fromIndex)`
  Search for the first occurrence of another buffer in this buffer
  `int`
  `lastIndexOf(XltCharBuffer s)`
  Returns the last occurrence of a buffer in this buffer
  `int`
  `lastIndexOf(XltCharBuffer s, int from)`
  Returns the last occurrence of a buffer in this starting from a certain offset and searching backwards(!)
  `int`
  `length()`
  Returns the length of this buffer
  `char`
  `peakAhead(int pos)`
  Looks ahead, otherwise returns 0.
  `XltCharBuffer`
  `put(int pos, char c)`
  Set a character at this position.
  `List<XltCharBuffer>`
  `split(char splitChar)`
  Splits up this sequence into sub-sequences at splitChar markers excluding the marker
  `boolean`
  `startsWith(XltCharBuffer s)`
  Checks if the start of the buffer matches another buffer
  `CharSequence`
  `subSequence(int start, int end)`
  `XltCharBuffer`
  `substring(int from)`
  Creates a new buffer similar to a String.substring call from a position till the end
  `XltCharBuffer`
  `substring(int from, int to)`
  Creates a new buffer similar to a String.substring call.
  `char[]`
  `toCharArray()`
  Returns a copy of the backing char array for the range of this buffer aka not more than needed
  `String`
  `toDebugString()`
  `String`
  `toString()`
  Just return the content of this buffer as string.
  `static XltCharBuffer`
  `valueOf(char[] s)`
  Create a new char buffer from a char array without copying it.
  `static XltCharBuffer`
  `valueOf(XltCharBuffer s1, char c)`
  Creates a new char buffer by adding a single char
  `static XltCharBuffer`
  `valueOf(XltCharBuffer s1, XltCharBuffer s2)`
  Creates a new char buffer by merging XltCharBuffers
  `static XltCharBuffer`
  `valueOf(XltCharBuffer s1, XltCharBuffer s2, XltCharBuffer s3)`
  Creates a new char buffer by merging strings
  `static XltCharBuffer`
  `valueOf(String s)`
  Create a new char buffer from a string.
  `static XltCharBuffer`
  `valueOf(String s1, String s2)`
  Creates a new char buffer by merging strings
  `static XltCharBuffer`
  `valueOf(String s1, String s2, String s3)`
  Creates a new char buffer by merging strings
  `static XltCharBuffer`
  `valueOf(String s1, String s2, String s3, String... more)`
  Creates a new char buffer by merging strings
  `XltCharBuffer`
  `viewByLength(int from, int length)`
  Returns a new buffer with a view on the current.
  `XltCharBuffer`
  `viewFromTo(int from, int to)`
  Returns a new buffer with a view on the current.

  ### Methods inherited from class java.lang.Object

  `clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

  ### Methods inherited from interface java.lang.CharSequence

  `chars, codePoints, isEmpty`

- ## Field Details

  - ### EMPTY

    public static final XltCharBuffer EMPTY
    An empty static XltCharBuffer

- ## Constructor Details

  - ### XltCharBuffer

    public XltCharBuffer(char[] src)
    New buffer from a raw char array
    Parameters:
      `src` - a char array

  - ### XltCharBuffer

    public XltCharBuffer(char[] src, int from, int length)
    A new buffer from a char array including a view port.
    Parameters:
      `src` - the char array, if is is null, we fix that silently
      `from` - from where to deliver the buffer
      `length` - how long should the buffer be

- ## Method Details

  - ### empty

    public static XltCharBuffer empty()
    Just returns an empty buffer. This is a static object and not a new buffer every time, so apply caution.
    Returns:
      the empty buffer

  - ### charAt

    public char charAt(int pos)
    Return the character at a position. This code does not run any checks in regards to pos being correct (≥ 0, < length). This will automatically apply the view on the underlying array hence incorrect pos values might return something unexpected. So know what you do or else...
    Specified by:
      `charAt` in interface `CharSequence`
    Parameters:
      `pos` - the position to return
    Returns:
      the character at this position.

  - ### put

    public XltCharBuffer put(int pos, char c)
    Set a character at this position. Similarly to charAt, this does not check for correctness of pos in favor of speed.
    Parameters:
      `pos` - the pos to write to
      `c` - the character to set
    Returns:
      this instance so put can be chained

  - ### split

    public List<XltCharBuffer> split(char splitChar)
    Splits up this sequence into sub-sequences at splitChar markers excluding the marker
    Parameters:
      `splitChar` - the split character
    Returns:
      a list of the sub-sequences

  - ### peakAhead

    public char peakAhead(int pos)
    Looks ahead, otherwise returns 0. Only safety bound against ahead misses, not any behind misses
    Parameters:
      `pos` - the position to look at
    Returns:
      the content of the peaked pos or 0 if this position does not exist

  - ### viewByLength

    public XltCharBuffer viewByLength(int from, int length)
    Returns a new buffer with a view on the current. No copy is made. No runtime checks
    Parameters:
      `from` - start position
      `length` - length of the view port
    Returns:
      a new buffer

  - ### viewFromTo

    public XltCharBuffer viewFromTo(int from, int to)
    Returns a new buffer with a view on the current. No copy is made. No runtime checks
    Parameters:
      `from` - start position
      `to` - end position
    Returns:
      a new buffer

  - ### substring

    public XltCharBuffer substring(int from, int to)
    Creates a new buffer similar to a String.substring call. There is no copy created, we still look at the same buffer, but have a reduced view.
    Parameters:
      `from` - first position (inclusive)
      `to` - last position (exclusive)
    Returns:

  - ### substring

    public XltCharBuffer substring(int from)
    Creates a new buffer similar to a String.substring call from a position till the end
    Parameters:
      `from` - first position
    Returns:

  - ### valueOf

    public static XltCharBuffer valueOf(String s1, String s2)
    Creates a new char buffer by merging strings
    Parameters:
      `s1` - string 1
      `s2` - string 2
    Returns:
      the new charbuffer

  - ### valueOf

    public static XltCharBuffer valueOf(XltCharBuffer s1, XltCharBuffer s2)
    Creates a new char buffer by merging XltCharBuffers
    Parameters:
      `s1` - buffer 1
      `s2` - buffer 2
    Returns:
      the new charbuffer

  - ### valueOf

    public static XltCharBuffer valueOf(XltCharBuffer s1, char c)
    Creates a new char buffer by adding a single char
    Parameters:
      `s1` -
      `c` -
    Returns:

  - ### valueOf

    public static XltCharBuffer valueOf(String s1, String s2, String s3)
    Creates a new char buffer by merging strings
    Parameters:
      `s1` -
      `s2` -
      `s3` -
    Returns:

  - ### valueOf

    public static XltCharBuffer valueOf(XltCharBuffer s1, XltCharBuffer s2, XltCharBuffer s3)
    Creates a new char buffer by merging strings
    Parameters:
      `s1` -
      `s2` -
      `s3` -
    Returns:

  - ### valueOf

    public static XltCharBuffer valueOf(String s1, String s2, String s3, String... more)
    Creates a new char buffer by merging strings
    Parameters:
      `s1` - string 1
      `s2` - string 2
      `s3` - string 3
      `more` - more strings
    Returns:
      a new char buffer

  - ### valueOf

    public static XltCharBuffer valueOf(char[] s)
    Create a new char buffer from a char array without copying it. It assume that the full array is valid and because we don't copy, we don't have immutability!
    Parameters:
      `s` - the char array to use
    Returns:
      a new charbuffer instance

  - ### valueOf

    public static XltCharBuffer valueOf(String s)
    Create a new char buffer from a string. Because a string does provide array access, we use the returned copy by toCharArray to set up the char buffer.
    Parameters:
      `s` - the string to use
    Returns:
      a new charbuffer instance

  - ### toString

    public String toString()
    Just return the content of this buffer as string. This is of course a copy operation.
    Specified by:
      `toString` in interface `CharSequence`
    Overrides:
      `toString` in class `Object`
    Returns:
      a string representation of this buffer

  - ### toCharArray

    public char[] toCharArray()
    Returns a copy of the backing char array for the range of this buffer aka not more than needed
    Returns:
      a copy of the relevant portion of the backing array

  - ### indexOf

    public int indexOf(char c)
    Find the first occurrence of a char
    Parameters:
      `c` - the char to search
    Returns:
      the position or -1 otherwise

  - ### indexOf

    public int indexOf(XltCharBuffer s)
    Search for the first occurrence of another buffer in this buffer
    Parameters:
      `s` - the buffer to be search for
    Returns:
      the first found position or -1 if not found

  - ### indexOf

    public int indexOf(XltCharBuffer s, int fromIndex)
    Search for the first occurrence of another buffer in this buffer
    Parameters:
      `s` - the buffer to be search for
    Returns:
      the first found position or -1 if not found

  - ### endsWith

    public boolean endsWith(XltCharBuffer s)
    Checks whether or not a buffer ends with the content of another buffer
    Parameters:
      `s` - the buffer that has to be machting the end of this buffer
    Returns:
      true if the end matches, false otherwise

  - ### startsWith

    public boolean startsWith(XltCharBuffer s)
    Checks if the start of the buffer matches another buffer
    Parameters:
      `s` - the buffer to match the start against
    Returns:
      true if the start matches, false otherwise

  - ### lastIndexOf

    public int lastIndexOf(XltCharBuffer s)
    Returns the last occurrence of a buffer in this buffer
    Parameters:
      `s` - the buffer to looks for
    Returns:
      the position of the last occurrence or -1

  - ### lastIndexOf

    public int lastIndexOf(XltCharBuffer s, int from)
    Returns the last occurrence of a buffer in this starting from a certain offset and searching backwards(!) from there
    Parameters:
      `s` - the buffer to looks for
      `from` - the offset to start from
    Returns:
      the position of the last occurrence or -1

  - ### length

    public int length()
    Returns the length of this buffer
    Specified by:
      `length` in interface `CharSequence`

  - ### hashCode

    public int hashCode()
    Optimized hashcode calculation for large strings using all execution units of the CPU. This is a trade off between cpu and branches. Assumes we are not mutating... if we mutate, we would have to reset the hashCode Taken from JDK 19 - JDK-8282664, Code and Idea by Richard Startin https://twitter.com/richardstartin
    Overrides:
      `hashCode` in class `Object`
    Returns:
      the hash code

  - ### emptyWhenNull

    public static XltCharBuffer emptyWhenNull(XltCharBuffer s)
    Returns the empty string if the provided buffer is null the buffer otherwise

  - ### equals

    public boolean equals(Object obj)
    Overrides:
      `equals` in class `Object`

  - ### subSequence

    public CharSequence subSequence(int start, int end)
    Specified by:
      `subSequence` in interface `CharSequence`

  - ### createShiftTable

    public static int[] createShiftTable(XltCharBuffer needle)
    Creates the shift table needed for the Boyer-Moore-Horspool algorithm.
    Parameters:
      `needle` -
    Returns:
      the shift table

  - ### contains

    public static boolean contains(XltCharBuffer haystack, XltCharBuffer needle, int[] shiftTable)
    Checks if the needle is contained in the haystack using the Boyer-Moore-Horspool algorithm.
    Parameters:
      `haystack` - the haystack
      `needle` - the needle
      `shiftTable` - the precomputed shift table for the needle
    Returns:
      true if the needle is contained in the haystack, false otherwise

  - ### compareTo

    public int compareTo(XltCharBuffer other)
    Compares this object with the specified object for order. Returns a negative integer, zero, or a positive integer as this object is less than, equal to, or greater than the specified object.

    The implementor must ensure `sgn(x.compareTo(y)) == -sgn(y.compareTo(x))` for all `x` and `y`. (This implies that `x.compareTo(y)` must throw an exception iff `y.compareTo(x)` throws an exception.)

    Specified by:
      `compareTo` in interface `Comparable<XltCharBuffer>`
    Parameters:
      `other` - the buffer to compare to
    Returns:
      -1, if this is smaller than other, 0 if the same, 1 if this is larger

  - ### toDebugString

    public String toDebugString()