Package org.jruby.util

Class StringSupport

java.lang.Object
org.jruby.util.StringSupport
public final class StringSupport extends Object

  • Field Details

    • CR_7BIT_F

      public static final int CR_7BIT_F

    • CR_VALID_F

      public static final int CR_VALID_F

    • CR_UNKNOWN

      public static final int CR_UNKNOWN
      See Also:

    • CR_7BIT

      public static final int CR_7BIT
      See Also:

    • CR_VALID

      public static final int CR_VALID
      See Also:

    • CR_BROKEN

      public static final int CR_BROKEN
      See Also:

    • CR_MASK

      public static final int CR_MASK
      See Also:

    • ARRAY_BYTE_BASE_OFFSET

      static final int ARRAY_BYTE_BASE_OFFSET

    • TRANS_SIZE

      public static final int TRANS_SIZE
      See Also:

    • EMPTY_BYTELIST_ARRAY

      public static final ByteList[] EMPTY_BYTELIST_ARRAY

    • EMPTY_STRING_ARRAY

      public static final String[] EMPTY_STRING_ARRAY

    • NONASCII_MASK

      private static final long NONASCII_MASK
      See Also:

    • LONG_SIZE

      private static final int LONG_SIZE
      See Also:

    • LOWBITS

      private static final int LOWBITS
      See Also:

    • DUMMY_VALUE

      private static final Object DUMMY_VALUE

    • NULL_POINTER

      private static final int NULL_POINTER
      See Also:

    • CASE_MAPPING_ADDITIONAL_LENGTH

      private static final int CASE_MAPPING_ADDITIONAL_LENGTH
      See Also:

  • Constructor Details

    • StringSupport

      public StringSupport()

  • Method Details

    • split

      public static List<String> split(String str, char sep)
      Split string into sub-parts.
      Parameters:
      str - the string
      sep - the separator
      See Also:

    • split

      public static List<String> split(String str, char sep, int lim)
      Split string into (limited) sub-parts.
      Parameters:
      str - the string
      sep - the separator
      lim - has same effect as with String.split(String, int)

    • startsWith

      public static boolean startsWith(CharSequence str, String prefix)

    • startsWith

      public static boolean startsWith(CharSequence str, char c)

    • startsWith

      public static boolean startsWith(CharSequence str, char c1, char c2)

    • lastIndexOf

      public static int lastIndexOf(CharSequence str, char c, int index)

    • contentEquals

      public static boolean contentEquals(CharSequence str, int chr)

    • contentEquals

      public static boolean contentEquals(CharSequence str, int chr1, int chr2)

    • concat

      public static CharSequence concat(CharSequence str1, CharSequence str2)

    • concat

      public static String concat(String str1, String str2)

    • delete

      public static String delete(String str, char c)

    • replaceFirst

      public static CharSequence replaceFirst(String str, String sub, String repl)

    • replaceAll

      public static CharSequence replaceAll(String str, String sub, String repl)

    • replaceImpl

      private static CharSequence replaceImpl(String str, String sub, String repl, int max, boolean ignoreCase)

    • copy

      private static int copy(String str, int soff, int slen, char[] dest, int doff)

    • codeRangeAsString

      public static String codeRangeAsString(int codeRange)

    • encFastMBCLen

      public static int encFastMBCLen(byte[] bytes, int p, int e, org.jcodings.Encoding enc)

    • length

      public static int length(org.jcodings.Encoding enc, byte[] bytes, int p, int end)

    • preciseLength

      public static int preciseLength(org.jcodings.Encoding enc, byte[] bytes, int p, int end)

    • MBCLEN_NEEDMORE_P

      public static boolean MBCLEN_NEEDMORE_P(int r)

    • MBCLEN_NEEDMORE

      public static int MBCLEN_NEEDMORE(int n)

    • MBCLEN_NEEDMORE_LEN

      public static int MBCLEN_NEEDMORE_LEN(int r)

    • MBCLEN_INVALID_P

      public static boolean MBCLEN_INVALID_P(int r)

    • MBCLEN_CHARFOUND_LEN

      public static int MBCLEN_CHARFOUND_LEN(int r)

    • MBCLEN_CHARFOUND_P

      public static boolean MBCLEN_CHARFOUND_P(int r)

    • CONSTRUCT_MBCLEN_CHARFOUND

      public static int CONSTRUCT_MBCLEN_CHARFOUND(int n)

    • searchNonAscii

      public static int searchNonAscii(byte[] bytes, int p, int end)

    • searchNonAscii

      public static int searchNonAscii(ByteList bytes)

    • searchNonAscii

      public static int searchNonAscii(String string)

    • codeRangeScan

      public static int codeRangeScan(org.jcodings.Encoding enc, byte[] bytes, int p, int len)

    • codeRangeScanAsciiCompatible

      private static int codeRangeScanAsciiCompatible(org.jcodings.Encoding enc, byte[] bytes, int p, int len)

    • codeRangeScanNonAsciiCompatible

      private static int codeRangeScanNonAsciiCompatible(org.jcodings.Encoding enc, byte[] bytes, int p, int len)

    • codeRangeScan

      public static int codeRangeScan(org.jcodings.Encoding enc, ByteList bytes)

    • codeRangeScanRestartable

      public static long codeRangeScanRestartable(org.jcodings.Encoding enc, byte[] bytes, int s, int end, int cr)

    • countUtf8LeadBytes

      private static int countUtf8LeadBytes(long d)

    • utf8Length

      public static int utf8Length(byte[] bytes, int p, int end)

    • utf8Length

      public static int utf8Length(ByteList bytes)

    • strLength

      public static int strLength(org.jcodings.Encoding enc, byte[] bytes, int p, int end)

    • strLength

      public static int strLength(org.jcodings.Encoding enc, byte[] bytes, int p, int e, int cr)

    • strLength

      public static int strLength(ByteList bytes)

    • strLengthWithCodeRange

      public static long strLengthWithCodeRange(org.jcodings.Encoding enc, byte[] bytes, int p, int end)

    • strLengthWithCodeRangeAsciiCompatible

      public static long strLengthWithCodeRangeAsciiCompatible(org.jcodings.Encoding enc, byte[] bytes, int p, int end)

    • strLengthWithCodeRangeNonAsciiCompatible

      public static long strLengthWithCodeRangeNonAsciiCompatible(org.jcodings.Encoding enc, byte[] bytes, int p, int end)

    • strLengthWithCodeRange

      public static long strLengthWithCodeRange(ByteList bytes)

    • strLengthWithCodeRange

      public static long strLengthWithCodeRange(ByteList bytes, org.jcodings.Encoding enc)

    • pack

      public static long pack(int result, int arg)

    • unpackResult

      public static int unpackResult(long len)

    • unpackArg

      public static int unpackArg(long cr)

    • codePoint

      public static int codePoint(org.jcodings.Encoding enc, byte[] bytes, int p, int end)

    • codePoint

      public static int codePoint(Ruby runtime, org.jcodings.Encoding enc, byte[] bytes, int p, int end)

    • codePoint

      public static int codePoint(Ruby runtime, ByteList value)

    • codeLength

      public static int codeLength(org.jcodings.Encoding enc, int c)

    • checkCodepointError

      public static int checkCodepointError(int i)

    • getAscii

      public static long getAscii(org.jcodings.Encoding enc, byte[] bytes, int p, int end)

    • getAscii

      public static long getAscii(org.jcodings.Encoding enc, byte[] bytes, int p, int end, int len)

    • preciseCodePoint

      public static int preciseCodePoint(org.jcodings.Encoding enc, byte[] bytes, int p, int end)

    • utf8Nth

      public static int utf8Nth(byte[] bytes, int p, int e, int nth)

    • nth

      public static int nth(org.jcodings.Encoding enc, byte[] bytes, int p, int end, int n)
      Return the byte offset of the nth character n in the given byte array between p and n using enc as the encoding. Note that the resulting offset will absolute, and therefore >= p. Subtract p to get a relative offset.
      Parameters:
      enc - the encoding of the characters in the byte array
      bytes - the byte array
      p - starting offset
      end - limit offset
      n - character offset to find
      Returns:
      the byte offset of the requested character, or -1 if the requested character offset is outside the given byte offset range

    • nth

      public static int nth(org.jcodings.Encoding enc, byte[] bytes, int p, int end, int n, boolean singlebyte)
      Get the position of the nth character in the given byte array, using the given encoding and range.
      Parameters:
      enc - encoding to use
      bytes - bytes to scan
      p - starting byte offset
      end - ending byte offset
      n - index of character for which to find byte offset
      singlebyte - whether the byte contents are in a single byte encoding
      Returns:
      the offset of the nth character in the string, or -1 if nth is out of the string

    • nthAsciiCompatible

      private static int nthAsciiCompatible(org.jcodings.Encoding enc, byte[] bytes, int p, int end, int n)

    • nthNonAsciiCompatible

      private static int nthNonAsciiCompatible(org.jcodings.Encoding enc, byte[] bytes, int p, int end, int n)

    • utf8Offset

      public static int utf8Offset(byte[] bytes, int p, int end, int n)

    • offset

      public static int offset(org.jcodings.Encoding enc, byte[] bytes, int p, int end, int n)

    • offset

      public static int offset(org.jcodings.Encoding enc, byte[] bytes, int p, int end, int n, boolean singlebyte)

    • offset

      public static int offset(RubyString str, int pos)

    • toLower

      @Deprecated public static int toLower(org.jcodings.Encoding enc, int c)
      Deprecated.

    • toUpper

      @Deprecated public static int toUpper(org.jcodings.Encoding enc, int c)
      Deprecated.

    • caseCmp

      public static int caseCmp(byte[] bytes1, int p1, byte[] bytes2, int p2, int len)

    • scanHex

      public static int scanHex(byte[] bytes, int p, int len)

    • scanHex

      public static int scanHex(byte[] bytes, int p, int len, org.jcodings.Encoding enc)

    • hexLength

      public static int hexLength(byte[] bytes, int p, int len)

    • hexLength

      public static int hexLength(byte[] bytes, int p, int len, org.jcodings.Encoding enc)

    • scanOct

      public static int scanOct(byte[] bytes, int p, int len)

    • scanOct

      public static int scanOct(byte[] bytes, int p, int len, org.jcodings.Encoding enc)

    • octLength

      public static int octLength(byte[] bytes, int p, int len)

    • octLength

      public static int octLength(byte[] bytes, int p, int len, org.jcodings.Encoding enc)

    • checkStringSafety

      public static final void checkStringSafety(Ruby runtime, IRubyObject value)
      Check whether input object's string value contains a null byte, and if so throw ArgumentError.
      Parameters:
      runtime -
      value -

    • escapedCharFormat

      public static String escapedCharFormat(int c, boolean isUnicode)

    • isIncompleteChar

      public static boolean isIncompleteChar(int b)

    • bytesToFixBrokenTrailingCharacter

      public static int bytesToFixBrokenTrailingCharacter(ByteList val, int usingLength)

    • bytesToFixBrokenTrailingCharacter

      public static int bytesToFixBrokenTrailingCharacter(byte[] bytes, int begin, int byteSize, org.jcodings.Encoding encoding, int usingLength)

    • memchr

      public static int memchr(byte[] ptr, int start, int find, int len)

    • checkEmbeddedNulls

      public static RubyString checkEmbeddedNulls(Ruby runtime, IRubyObject ptr)

    • strNullChar

      private static int strNullChar(byte[] sBytes, int s, int len, int minlen, org.jcodings.Encoding enc)

    • zeroFilled

      private static boolean zeroFilled(byte[] sBytes, int s, int n)

    • strFillTerm

      private static RubyString strFillTerm(RubyString str, byte[] sBytes, int beg, int len, int termlen)

    • TERM_FILL

      private static void TERM_FILL(byte[] ptr, int beg, int len, int termlen)

    • positionEndForScan

      public static int positionEndForScan(ByteList value, org.joni.Matcher matcher, org.jcodings.Encoding enc, int begin, int range)
      rb_str_scan

    • dumpCommon

      public static ByteList dumpCommon(Ruby runtime, ByteList bytelist)
      rb_str_dump

    • dumpCommon

      public static ByteList dumpCommon(Ruby runtime, ByteList byteList, boolean quoteOnlyIfNeeded)

    • isEVStr

      public static boolean isEVStr(byte[] bytes, int p, int end)

    • isEVStr

      public static boolean isEVStr(int c)

    • strCount

      public static int strCount(ByteList str, boolean[] table, StringSupport.TrTables tables, org.jcodings.Encoding enc)
      rb_str_count

    • strCount

      public static int strCount(ByteList str, Ruby runtime, boolean[] table, StringSupport.TrTables tables, org.jcodings.Encoding enc)

    • countCommon19

      public static int countCommon19(ByteList str, Ruby runtime, boolean[] table, StringSupport.TrTables tables, org.jcodings.Encoding enc)
      Deprecated.
      renamed to strCount(ByteList, Ruby, boolean[], TrTables, Encoding)

    • rindex

      public static int rindex(ByteList source, int sourceChars, int subChars, int pos, CodeRangeable subStringCodeRangeable, org.jcodings.Encoding enc)

    • strRindex

      private static int strRindex(byte[] strBytes, int strBeg, int strLen, byte[] subBytes, int subBeg, int subLen, int s, int pos, org.jcodings.Encoding enc)

    • strLengthFromRubyString

      public static int strLengthFromRubyString(CodeRangeable string, org.jcodings.Encoding enc)

    • strLengthFromRubyString

      public static int strLengthFromRubyString(CodeRangeable string)

    • strLengthFromRubyString

      public static int strLengthFromRubyString(CodeRangeable string, ByteList bytes, org.jcodings.Encoding enc)

    • strLengthFromRubyStringFull

      private static int strLengthFromRubyStringFull(CodeRangeable string, ByteList bytes, org.jcodings.Encoding enc)

    • trSetupTable

      public static StringSupport.TrTables trSetupTable(ByteList str, boolean[] stable, StringSupport.TrTables tables, boolean first, org.jcodings.Encoding enc)

    • trSetupTable

      public static StringSupport.TrTables trSetupTable(ByteList str, Ruby runtime, boolean[] stable, StringSupport.TrTables tables, boolean first, org.jcodings.Encoding enc)

    • trFind

      public static boolean trFind(int c, boolean[] table, StringSupport.TrTables tables)

    • trNext

      public static int trNext(StringSupport.TR tr, org.jcodings.Encoding enc)

    • trNext

      public static int trNext(StringSupport.TR tr, Ruby runtime, org.jcodings.Encoding enc)

    • trNext_nextpart

      private static int trNext_nextpart(StringSupport.TR tr, org.jcodings.Encoding enc)

    • succCommon

      public static ByteList succCommon(ByteList original)

    • succCommon

      public static ByteList succCommon(Ruby runtime, ByteList original)

    • succChar

      public static StringSupport.NeighborChar succChar(org.jcodings.Encoding enc, byte[] bytes, int p, int len)

    • succChar

      public static StringSupport.NeighborChar succChar(Ruby runtime, org.jcodings.Encoding enc, byte[] bytes, int p, int len)

    • succAlnumChar

      private static StringSupport.NeighborChar succAlnumChar(org.jcodings.Encoding enc, byte[] bytes, int p, int len, byte[] carry, int carryP)

    • predChar

      private static StringSupport.NeighborChar predChar(org.jcodings.Encoding enc, byte[] bytes, int p, int len)

    • isSingleByteOptimizable

      public static boolean isSingleByteOptimizable(CodeRangeable string, org.jcodings.Encoding encoding)

    • index

      public static int index(ByteList source, ByteList other, int offset, org.jcodings.Encoding enc)
      Parameters:
      source - string to find index within
      other - string to match in source
      offset - in bytes to start looking
      enc - encoding to use to walk the source string.
      Returns:

    • index

      public static int index(CodeRangeable sourceString, CodeRangeable otherString, int offset, org.jcodings.Encoding enc)

    • associateEncoding

      public static void associateEncoding(CodeRangeable string, org.jcodings.Encoding enc)

    • replaceInternal

      public static ByteList replaceInternal(int beg, int len, ByteListHolder source, CodeRangeable repl)

    • replaceInternal19

      public static void replaceInternal19(int beg, int len, CodeRangeable source, CodeRangeable repl)

    • replaceInternal19

      public static void replaceInternal19(Ruby runtime, int beg, int len, RubyString source, RubyString repl)

    • isAsciiOnly

      public static boolean isAsciiOnly(CodeRangeable string)

    • isAsciiOnly

      private static boolean isAsciiOnly(org.jcodings.Encoding encoding, int codeRange)

    • strDeleteBang

      static CodeRangeable strDeleteBang(CodeRangeable rubyString, boolean[] squeeze, StringSupport.TrTables tables, org.jcodings.Encoding enc)
      rb_str_delete_bang

    • strDeleteBang

      public static CodeRangeable strDeleteBang(CodeRangeable rubyString, Ruby runtime, boolean[] squeeze, StringSupport.TrTables tables, org.jcodings.Encoding enc)

    • choppedLength

      public static int choppedLength(CodeRangeable str)
      MRI: chopped_length

    • choppedLength19

      @Deprecated public static int choppedLength19(CodeRangeable str, Ruby runtime)
      Deprecated.

    • areCompatible

      public static org.jcodings.Encoding areCompatible(CodeRangeable str1, CodeRangeable str2)
      rb_enc_compatible

    • areCompatible

      public static org.jcodings.Encoding areCompatible(ByteList str1, ByteList str2)

    • addByteLists

      public static ByteList addByteLists(ByteList value1, ByteList value2)

    • areComparable

      public static boolean areComparable(CodeRangeable string, CodeRangeable other)

    • areComparableViaCodeRange

      public static boolean areComparableViaCodeRange(CodeRangeable string, CodeRangeable other)

    • rbStrEnumerateLines

      public static IRubyObject rbStrEnumerateLines(RubyString str, ThreadContext context, String name, IRubyObject arg, Block block, boolean wantarray)

    • rbStrEnumerateLines

      public static IRubyObject rbStrEnumerateLines(RubyString str, ThreadContext context, String name, IRubyObject arg, IRubyObject opts, Block block, boolean wantarray)

    • rbStrEnumerateLinesEmptySep

      private static void rbStrEnumerateLinesEmptySep(RubyString str, ThreadContext context, boolean chomp, Block block, RubyArray ary, byte[] strBytes, int ptr, int len, int pend, org.jcodings.Encoding enc, int subptr)

    • chomp_newline

      private static int chomp_newline(byte[] bytes, int p, int e, org.jcodings.Encoding enc)

    • memsearch

      public static int memsearch(byte[] xBytes, int x0, int m, byte[] yBytes, int y0, int n, org.jcodings.Encoding enc)

    • trTransHelper

      public static CodeRangeable trTransHelper(CodeRangeable self, CodeRangeable srcStr, CodeRangeable replStr, boolean sflag)
      rb_str_tr / rb_str_tr_bang

    • trTransHelper

      public static CodeRangeable trTransHelper(Ruby runtime, CodeRangeable self, CodeRangeable srcStr, CodeRangeable replStr, boolean sflag)

    • trCode

      private static int trCode(int c, int[] trans, org.jcodings.util.IntHash<Integer> hash, boolean cflag, int last, boolean set)

    • multiByteCasecmp

      public static int multiByteCasecmp(org.jcodings.Encoding enc, ByteList value, ByteList otherValue)

    • singleByteSqueeze

      public static boolean singleByteSqueeze(ByteList value, boolean[] squeeze)

    • multiByteSqueeze

      public static boolean multiByteSqueeze(ByteList value, boolean[] squeeze, StringSupport.TrTables tables, org.jcodings.Encoding enc, boolean isArg)

    • multiByteSqueeze

      public static boolean multiByteSqueeze(Ruby runtime, ByteList value, boolean[] squeeze, StringSupport.TrTables tables, org.jcodings.Encoding enc, boolean isArg)

    • rb_memsearch_ss

      private static int rb_memsearch_ss(byte[] xsBytes, int xs, int m, byte[] ysBytes, int ys, int n)

    • memmem

      public static int memmem(byte[] aBytes, int aStart, int aLen, byte[] p, int pStart, int pLen)

    • failure

      private static int[] failure(byte[] p, int pStart, int pLen)

    • rb_memsearch_qs

      private static int rb_memsearch_qs(byte[] xsBytes, int xs, int m, byte[] ysBytes, int ys, int n)

    • rb_memsearch_qs_utf8_hash

      private static int rb_memsearch_qs_utf8_hash(byte[] xBytes, int x)

    • rb_memsearch_qs_utf8

      private static int rb_memsearch_qs_utf8(byte[] xsBytes, int xs, int m, byte[] ysBytes, int ys, int n)

    • checkCaseMapOptions

      public static int checkCaseMapOptions(Ruby runtime, IRubyObject arg0, IRubyObject arg1, int flags)

    • checkCaseMapOptions

      public static int checkCaseMapOptions(Ruby runtime, IRubyObject arg0, int flags)

    • caseMap

      public static ByteList caseMap(Ruby runtime, ByteList src, org.jcodings.IntHolder flags, org.jcodings.Encoding enc)

    • asciiOnlyCaseMap

      public static void asciiOnlyCaseMap(Ruby runtime, ByteList value, org.jcodings.IntHolder flags, org.jcodings.Encoding enc)

    • encCoderangeClean

      public static int encCoderangeClean(int cr)

    • byteListAsString

      public static String byteListAsString(ByteList bytes)

    • isUnicode

      @Deprecated public static boolean isUnicode(org.jcodings.Encoding enc)
      Deprecated.