CString (Common API for the CLARUS plugins and modules 1.0.1 API)

java.lang.Object
- eu.clarussecure.proxy.spi.CString

All Implemented Interfaces:: io.netty.util.ReferenceCounted, CharSequence, Cloneable, Comparable<CharSequence>

public class CString
extends Object
implements CharSequence, Cloneable, Comparable<CharSequence>, io.netty.util.ReferenceCounted

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`CString`	`append(char c)`
`CString`	`append(char[] array)`
`CString`	`append(CharSequence other)`
`CString`	`append(CharSequence other, int length)`
`char`	`charAt(int index)`
`int`	`clen()`
`Object`	`clone()`
`int`	`compareTo(CharSequence other)` Compares this `CString` with a `CharSequence` lexicographically.
`boolean`	`endsWith(CharSequence suffix)`
`boolean`	`equals(Object obj)`
`boolean`	`equalsIgnoreCase(CharSequence cs)` Compares this `CString` to a `CharSequence`, ignoring case considerations.
`io.netty.buffer.ByteBuf`	`getByteBuf()`
`io.netty.buffer.ByteBuf`	`getByteBuf(int maxCapacity)`
`int`	`hashCode()`
`int`	`indexOf(CharSequence target)`
`int`	`indexOf(CharSequence target, int fromIndex)`
`int`	`indexOf(int ch)`
`int`	`indexOf(int ch, int fromIndex)`
`boolean`	`isBuffered()`
`boolean`	`isEmpty()`
`int`	`lastIndexOf(CharSequence target)`
`int`	`lastIndexOf(CharSequence target, int fromIndex)`
`int`	`lastIndexOf(int ch)`
`int`	`lastIndexOf(int ch, int fromIndex)`
`int`	`length()`
`int`	`refCnt()`
`boolean`	`regionMatches(boolean ignoreCase, int toffset, CharSequence other, int ooffset, int len)` Tests if this `CString` region and a `CharSequence` region are equal.
`boolean`	`release()`
`boolean`	`release(int decrement)`
`CString`	`replace(char oldChar, char newChar)`
`CString`	`replace(CharSequence target, CharSequence replacement)`
`CString`	`reset()`
`io.netty.util.ReferenceCounted`	`retain()`
`io.netty.util.ReferenceCounted`	`retain(int increment)`
`boolean`	`startsWith(CharSequence prefix)`
`boolean`	`startsWith(CharSequence prefix, int toffset)`
`CString`	`subSequence(int start, int end)`
`CString`	`substring(int beginIndex)`
`CString`	`substring(int beginIndex, int endIndex)`
`String`	`toString()`
`io.netty.util.ReferenceCounted`	`touch()`
`io.netty.util.ReferenceCounted`	`touch(Object hint)`
`static CString`	`valueOf(io.netty.buffer.ByteBuf buffer)`
`static CString`	`valueOf(io.netty.buffer.ByteBuf buffer, int strLen)`
`static CString`	`valueOf(CharSequence cs)`

Methods inherited from class java.lang.Object
finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface java.lang.CharSequence
chars, codePoints

- Method Detail
  - valueOf
```
public static CString valueOf(io.netty.buffer.ByteBuf buffer)
```
  - valueOf
```
public static CString valueOf(io.netty.buffer.ByteBuf buffer,
                              int strLen)
```
  - valueOf
```
public static CString valueOf(CharSequence cs)
```
  - clone
```
public Object clone()
```
    Overrides:
    
    clone in class Object
  - refCnt
```
public int refCnt()
```
    Specified by:
    
    refCnt in interface io.netty.util.ReferenceCounted
  - retain
```
public io.netty.util.ReferenceCounted retain()
```
    Specified by:
    
    retain in interface io.netty.util.ReferenceCounted
  - retain
```
public io.netty.util.ReferenceCounted retain(int increment)
```
    Specified by:
    
    retain in interface io.netty.util.ReferenceCounted
  - touch
```
public io.netty.util.ReferenceCounted touch()
```
    Specified by:
    
    touch in interface io.netty.util.ReferenceCounted
  - touch
```
public io.netty.util.ReferenceCounted touch(Object hint)
```
    Specified by:
    
    touch in interface io.netty.util.ReferenceCounted
  - release
```
public boolean release()
```
    Specified by:
    
    release in interface io.netty.util.ReferenceCounted
  - release
```
public boolean release(int decrement)
```
    Specified by:
    
    release in interface io.netty.util.ReferenceCounted
  - isBuffered
```
public boolean isBuffered()
```
  - getByteBuf
```
public io.netty.buffer.ByteBuf getByteBuf(int maxCapacity)
```
  - getByteBuf
```
public io.netty.buffer.ByteBuf getByteBuf()
```
  - length
```
public int length()
```
    Specified by:
    
    length in interface CharSequence
  - clen
```
public int clen()
```
  - isEmpty
```
public boolean isEmpty()
```
  - charAt
```
public char charAt(int index)
```
    Specified by:
    
    charAt in interface CharSequence
  - substring
```
public CString substring(int beginIndex)
```
  - substring
```
public CString substring(int beginIndex,
                         int endIndex)
```
  - subSequence
```
public CString subSequence(int start,
                           int end)
```
    Specified by:
    
    subSequence in interface CharSequence
  - indexOf
```
public int indexOf(int ch)
```
  - indexOf
```
public int indexOf(int ch,
                   int fromIndex)
```
  - indexOf
```
public int indexOf(CharSequence target)
```
  - indexOf
```
public int indexOf(CharSequence target,
                   int fromIndex)
```
  - lastIndexOf
```
public int lastIndexOf(int ch)
```
  - lastIndexOf
```
public int lastIndexOf(int ch,
                       int fromIndex)
```
  - lastIndexOf
```
public int lastIndexOf(CharSequence target)
```
  - lastIndexOf
```
public int lastIndexOf(CharSequence target,
                       int fromIndex)
```
  - startsWith
```
public boolean startsWith(CharSequence prefix,
                          int toffset)
```
  - startsWith
```
public boolean startsWith(CharSequence prefix)
```
  - endsWith
```
public boolean endsWith(CharSequence suffix)
```
  - replace
```
public CString replace(char oldChar,
                       char newChar)
```
  - replace
```
public CString replace(CharSequence target,
                       CharSequence replacement)
```
  - append
```
public CString append(char c)
```
  - append
```
public CString append(char[] array)
```
  - append
```
public CString append(CharSequence other)
```
  - append
```
public CString append(CharSequence other,
                      int length)
```
  - reset
```
public CString reset()
```
  - toString
```
public String toString()
```
    Specified by:
    
    toString in interface CharSequence
    
    Overrides:
    
    toString in class Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - equals
```
public boolean equals(Object obj)
```
    Overrides:
    
    equals in class Object
  - equalsIgnoreCase
```
public boolean equalsIgnoreCase(CharSequence cs)
```
    Compares this CString to a CharSequence, ignoring case considerations. Two are considered equal ignoring case if they are of the same length and corresponding characters in the two are equal ignoring case.
    Two characters c1 and c2 are considered the same ignoring case if at least one of the following is true:
    - The two characters are the same (as compared by the == operator)
    - Applying the method Character.toUpperCase(char) to each character produces the same result
    - Applying the method Character.toLowerCase(char) to each character produces the same result
    Parameters:
    
    cs - The CharSequence to compare this CString against
    
    Returns:
    
    true if the argument is not null and it represents an equivalent CharSequence ignoring case; false otherwise
    
    See Also:
    
    equals(Object)
  - regionMatches
```
public boolean regionMatches(boolean ignoreCase,
                             int toffset,
                             CharSequence other,
                             int ooffset,
                             int len)
```
    Tests if this CString region and a CharSequence region are equal.
    A subsequence of this CString object is compared to a subsequence of the argument other. The result is true if these subsequences represent character sequences that are the same, ignoring case if and only if ignoreCase is true. The subsequence of this CString object to be compared begins at index toffset and has length len. The subsequence of other to be compared begins at index ooffset and has length len. The result is false if and only if at least one of the following is true:
    - toffset is negative.
    - ooffset is negative.
    - toffset+len is greater than the length of this CString object.
    - ooffset+len is greater than the length of the other argument.
    - ignoreCase is false and there is some nonnegative integer k less than len such that:
      this.charAt(toffset+k) != other.charAt(ooffset+k)
    - ignoreCase is true and there is some nonnegative integer k less than len such that:
      Character.toLowerCase(this.charAt(toffset+k)) != Character.toLowerCase(other.charAt(ooffset+k))
      and:
      Character.toUpperCase(this.charAt(toffset+k)) != Character.toUpperCase(other.charAt(ooffset+k))
    Parameters:
    
    ignoreCase - if true, ignore case when comparing characters.
    
    toffset - the starting offset of the subregion in this CString.
    
    other - the CharSequence argument.
    
    ooffset - the starting offset of the subregion in the CharSequence argument.
    
    len - the number of characters to compare.
    
    Returns:
    
    true if the specified subregion of this CString matches the specified subregion of the CharSequence argument; false otherwise. Whether the matching is exact or case insensitive depends on the ignoreCase argument.
  - compareTo
```
public int compareTo(CharSequence other)
```
    Compares this CString with a CharSequence lexicographically. The comparison is based on the Unicode value of each character in the strings. The character sequence represented by this CString object is compared lexicographically to the argument character sequence. The result is a negative integer if this CString object lexicographically precedes the argument character sequence. The result is a positive integer if this CString object lexicographically follows the argument character sequence. The result is zero if the strings are equal; compareTo returns 0 exactly when the equals(Object) method would return true.
    This is the definition of lexicographic ordering. If two strings are different, then either they have different characters at some index that is a valid index for both strings, or their lengths are different, or both. If they have different characters at one or more index positions, let k be the smallest such index; then the string whose character at position k has the smaller value, as determined by using the < operator, lexicographically precedes the other string. In this case, compareTo returns the difference of the two character values at position k in the two string -- that is, the value:
    this.charAt(k)-other.charAt(k)
    If there is no index position at which they differ, then the shorter string lexicographically precedes the longer string. In this case, compareTo returns the difference of the lengths of the strings -- that is, the value:
    this.length()-other.length()
    Specified by:
    
    compareTo in interface Comparable<CharSequence>
    
    Parameters:
    
    other - the CharSequence to be compared.
    
    Returns:
    
    the value 0 if the argument string is equal to this string; a value less than 0 if this string is lexicographically less than the string argument; and a value greater than 0 if this string is lexicographically greater than the char sequence argument.

Class CString

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface java.lang.CharSequence

Method Detail

valueOf

valueOf

valueOf

clone

refCnt

retain

retain

touch

touch

release

release

isBuffered

getByteBuf

getByteBuf

length

clen

isEmpty

charAt

substring

substring

subSequence

indexOf

indexOf

indexOf

indexOf

lastIndexOf

lastIndexOf

lastIndexOf

lastIndexOf

startsWith

startsWith

endsWith

replace

replace

append

append

append

append

reset

toString

hashCode

equals

equalsIgnoreCase

regionMatches

compareTo