RubyString

java.lang.Object
- org.jruby.RubyBasicObject
- - org.jruby.RubyObject
  - - org.jruby.RubyString

All Implemented Interfaces:

java.io.Serializable, java.lang.Cloneable, java.lang.Comparable<IRubyObject>, InstanceVariables, InternalVariables, IRubyObject, EncodingCapable, MarshalEncoding, CoreObjectType
```
public class RubyString
extends RubyObject
implements EncodingCapable, MarshalEncoding
```
Implementation of Ruby String class Concurrency: no synchronization is required among readers, but all users must synchronize externally with writers.

See Also:

Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`private static class`	`RubyString.EmptyByteListHolder` Encoding aware String construction routines for 1.9
`private static class`	`RubyString.NeighborChar`
`private static class`	`RubyString.TR`
`private static class`	`RubyString.TrTables`

Nested classes/interfaces inherited from class org.jruby.RubyObject
RubyObject.Data

Nested classes/interfaces inherited from class org.jruby.RubyBasicObject
RubyBasicObject.Finalizer

Field Summary

Fields
Modifier and Type	Field and Description
`private static org.jcodings.specific.ASCIIEncoding`	`ASCII`
`private static org.jruby.util.ByteList`	`EMPTY_ASCII8BIT_BYTELIST`
`private static byte[]`	`EMPTY_BYTE_ARRAY`
`private static RubyString.EmptyByteListHolder[]`	`EMPTY_BYTELISTS`
`private static org.jruby.util.ByteList`	`EMPTY_USASCII_BYTELIST`
`private static java.lang.String[][]`	`opTable18`
`private static java.lang.String[][]`	`opTable19`
`private static int`	`SHARE_LEVEL_BUFFER`
`private static int`	`SHARE_LEVEL_BYTELIST`
`private static int`	`SHARE_LEVEL_NONE`
`private int`	`shareLevel`
`private static org.jruby.util.ByteList`	`SPACE_BYTELIST`
`private static ObjectAllocator`	`STRING_ALLOCATOR`
`private static int`	`TRANS_SIZE`
`private static org.jcodings.specific.UTF8Encoding`	`UTF8`
`private org.jruby.util.ByteList`	`value`

Fields inherited from class org.jruby.RubyObject
FIELD_ALLOCATED_CLASSES, FIELD_ALLOCATORS, IVAR_INSPECTING_OBJECT_ALLOCATOR, OBJECT_ALLOCATOR, OBJECT_VAR0_ALLOCATOR, OBJECT_VAR1_ALLOCATOR, OBJECT_VAR2_ALLOCATOR, OBJECT_VAR3_ALLOCATOR, OBJECT_VAR4_ALLOCATOR, OBJECT_VAR5_ALLOCATOR, OBJECT_VAR6_ALLOCATOR, OBJECT_VAR7_ALLOCATOR, OBJECT_VAR8_ALLOCATOR, OBJECT_VAR9_ALLOCATOR, REIFYING_OBJECT_ALLOCATOR

Fields inherited from class org.jruby.RubyBasicObject
ALL_F, BASICOBJECT_ALLOCATOR, COMPARE_BY_IDENTITY_F, ERR_INSECURE_SET_INST_VAR, FALSE_F, FL_USHIFT, flags, FROZEN_F, metaClass, NEVER, NIL_F, STAMP_OFFSET, TAINTED_F, UNDEF, UNTRUSTED_F, USER0_F, USER1_F, USER2_F, USER3_F, USER4_F, USER5_F, USER6_F, USER7_F, USER8_F, VAR_TABLE_OFFSET, varTable, varTableStamp

Fields inherited from interface org.jruby.runtime.builtin.IRubyObject
NULL_ARRAY

Constructor Summary

Constructors
Modifier	Constructor and Description
	`RubyString(Ruby runtime, RubyClass rubyClass)`
	`RubyString(Ruby runtime, RubyClass rubyClass, byte[] value)`
	`RubyString(Ruby runtime, RubyClass rubyClass, org.jruby.util.ByteList value)`
	`RubyString(Ruby runtime, RubyClass rubyClass, org.jruby.util.ByteList value, boolean objectSpace)`
`protected`	`RubyString(Ruby runtime, RubyClass rubyClass, org.jruby.util.ByteList value, org.jcodings.Encoding enc)`
	`RubyString(Ruby runtime, RubyClass rubyClass, org.jruby.util.ByteList value, org.jcodings.Encoding encoding, boolean objectSpace)`
`protected`	`RubyString(Ruby runtime, RubyClass rubyClass, org.jruby.util.ByteList value, org.jcodings.Encoding enc, int cr)`
`protected`	`RubyString(Ruby runtime, RubyClass rubyClass, org.jruby.util.ByteList value, int cr)`
	`RubyString(Ruby runtime, RubyClass rubyClass, java.lang.CharSequence value)`
	`RubyString(Ruby runtime, RubyClass rubyClass, java.lang.CharSequence value, org.jcodings.Encoding defaultEncoding)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`private org.jruby.util.ByteList`	`addByteLists(org.jruby.util.ByteList value1, org.jruby.util.ByteList value2)`
`RubyString`	`append(IRubyObject other)` rb_str_append
`RubyString`	`append19(IRubyObject other)`
`IRubyObject`	`ascii_only_p(ThreadContext context)`
`java.lang.String`	`asJavaString()` rb_to_id
`void`	`associateEncoding(org.jcodings.Encoding enc)`
`RubyString`	`asString()` rb_obj_as_string First converts this object into a String using the "to_s" method, infects it with the current taint and returns it.
`private RubyArray`	`awkSplit(boolean limit, int lim, int i)`
`private RubyArray`	`awkSplit19(boolean limit, int lim, int i)`
`IRubyObject`	`b(ThreadContext context)`
`private IRubyObject`	`byteARef(Ruby runtime, IRubyObject idx)`
`static java.lang.String`	`byteListToString(org.jruby.util.ByteList bytes)`
`IRubyObject`	`bytes(ThreadContext context, Block block)`
`RubyFixnum`	`bytesize()`
`IRubyObject`	`byteslice(ThreadContext context, IRubyObject arg)`
`IRubyObject`	`byteslice(ThreadContext context, IRubyObject arg1, IRubyObject arg2)`
`static java.lang.String`	`bytesToString(byte[] bytes)`
`static java.lang.String`	`bytesToString(byte[] bytes, int beg, int len)`
`private IRubyObject`	`byteSubstr(Ruby runtime, int beg, int len)`
`IRubyObject`	`capitalize_bang(ThreadContext context)`
`IRubyObject`	`capitalize_bang19(ThreadContext context)`
`IRubyObject`	`capitalize(ThreadContext context)` rb_str_capitalize / rb_str_capitalize_bang
`IRubyObject`	`capitalize19(ThreadContext context)`
`IRubyObject`	`casecmp(ThreadContext context, IRubyObject other)`
`IRubyObject`	`casecmp19(ThreadContext context, IRubyObject other)`
`RubyString`	`cat(byte ch)`
`RubyString`	`cat(byte[] str)`
`RubyString`	`cat(byte[] str, int beg, int len)`
`int`	`cat(byte[] bytes, int p, int len, org.jcodings.Encoding enc)`
`int`	`cat(byte[] bytes, int p, int len, org.jcodings.Encoding enc, int ptr_cr)` Deprecated.
`RubyString`	`cat(org.jruby.util.ByteList str)`
`RubyString`	`cat(int ch)`
`RubyString`	`cat(int code, org.jcodings.Encoding enc)`
`RubyString`	`cat(RubyString str)`
`int`	`cat19(org.jruby.util.ByteList other, int codeRange)`
`RubyString`	`cat19(RubyString str2)`
`RubyString`	`catAscii(byte[] bytes, int p, int len)`
`IRubyObject`	`center(IRubyObject arg0)` rb_str_center
`IRubyObject`	`center(IRubyObject arg0, IRubyObject arg1)`
`IRubyObject`	`center19(IRubyObject arg0)`
`IRubyObject`	`center19(IRubyObject arg0, IRubyObject arg1)`
`IRubyObject`	`chars18(ThreadContext context, Block block)`
`IRubyObject`	`chars19(ThreadContext context, Block block)`
`private long`	`checkBase(IRubyObject arg0)`
`private org.jcodings.Encoding`	`checkDummyEncoding()`
`(package private) org.jcodings.Encoding`	`checkEncoding(EncodingCapable other)`
`org.jcodings.Encoding`	`checkEncoding(RubyString other)`
`private int`	`checkIndex(int beg, int len)`
`private int`	`checkIndexForRef(int beg, int len)`
`private int`	`checkLength(int len)`
`private RubySymbol`	`checkSpecialCasesIntern(org.jruby.util.ByteList value)`
`IRubyObject`	`checkStringType()` rb_check_string_type Tries to return a coerced string representation of this object, using "to_str".
`IRubyObject`	`checkStringType19()` rb_check_string_type Tries to return a coerced string representation of this object, using "to_str".
`IRubyObject`	`chomp_bang(ThreadContext context)` rb_str_chomp_bang In the common case, removes CR and LF characters in various ways depending on the value of the optional args[0].
`IRubyObject`	`chomp_bang(ThreadContext context, IRubyObject arg0)`
`IRubyObject`	`chomp_bang19(ThreadContext context)`
`IRubyObject`	`chomp_bang19(ThreadContext context, IRubyObject arg0)`
`RubyString`	`chomp(ThreadContext context)` rb_str_chop
`RubyString`	`chomp(ThreadContext context, IRubyObject arg0)`
`RubyString`	`chomp19(ThreadContext context)`
`RubyString`	`chomp19(ThreadContext context, IRubyObject arg0)`
`private IRubyObject`	`chompBangCommon(Ruby runtime, IRubyObject rsObj)`
`private IRubyObject`	`chompBangCommon19(Ruby runtime, IRubyObject rsObj)`
`IRubyObject`	`chop_bang(ThreadContext context)`
`IRubyObject`	`chop_bang19(ThreadContext context)`
`IRubyObject`	`chop(ThreadContext context)` rb_str_chop / rb_str_chop_bang
`IRubyObject`	`chop19(ThreadContext context)`
`private int`	`choppedLength()`
`private int`	`choppedLength19(Ruby runtime)`
`IRubyObject`	`chr(ThreadContext context)`
`RubyString`	`clear()`
`void`	`clearCodeRange()`
`IRubyObject`	`codepoints(ThreadContext context, Block block)`
`(package private) static int`	`codeRangeAnd(int cr1, int cr2)`
`int`	`compareTo(IRubyObject other)` Compares this Ruby object with another.
`RubyString`	`concat(IRubyObject other)` rb_str_concat
`RubyString`	`concat19(ThreadContext context, IRubyObject other)`
`private RubyString`	`concatNumeric(Ruby runtime, int c)`
`RubyString`	`convertToString()` Tries to convert this object to a Ruby String using the "to_str" method.
`private void`	`copyCodeRange(RubyString from)`
`private void`	`copyCodeRangeForSubstr(RubyString from, org.jcodings.Encoding enc)`
`IRubyObject`	`count(ThreadContext context)` rb_str_count
`IRubyObject`	`count(ThreadContext context, IRubyObject arg)`
`IRubyObject`	`count(ThreadContext context, IRubyObject[] args)`
`IRubyObject`	`count19(ThreadContext context)`
`IRubyObject`	`count19(ThreadContext context, IRubyObject arg)`
`IRubyObject`	`count19(ThreadContext context, IRubyObject[] args)`
`private IRubyObject`	`countCommon(Ruby runtime, boolean[] table)`
`private IRubyObject`	`countCommon19(Ruby runtime, boolean[] table, RubyString.TrTables tables, org.jcodings.Encoding enc)`
`static RubyClass`	`createStringClass(Ruby runtime)`
`RubyString`	`crypt(ThreadContext context, IRubyObject other)` rb_str_crypt
`java.lang.String`	`decodeString()` Convert this Ruby string to a Java String.
`IRubyObject`	`delete_bang(ThreadContext context)`
`IRubyObject`	`delete_bang(ThreadContext context, IRubyObject arg)`
`IRubyObject`	`delete_bang(ThreadContext context, IRubyObject[] args)`
`IRubyObject`	`delete_bang19(ThreadContext context)`
`IRubyObject`	`delete_bang19(ThreadContext context, IRubyObject arg)`
`IRubyObject`	`delete_bang19(ThreadContext context, IRubyObject[] args)`
`private IRubyObject`	`delete_bangCommon(Ruby runtime, boolean[] squeeze)`
`private IRubyObject`	`delete_bangCommon19(Ruby runtime, boolean[] squeeze, RubyString.TrTables tables, org.jcodings.Encoding enc)`
`IRubyObject`	`delete(ThreadContext context)` rb_str_delete / rb_str_delete_bang
`IRubyObject`	`delete(ThreadContext context, IRubyObject arg)`
`IRubyObject`	`delete(ThreadContext context, IRubyObject[] args)`
`IRubyObject`	`delete19(ThreadContext context)`
`IRubyObject`	`delete19(ThreadContext context, IRubyObject arg)`
`IRubyObject`	`delete19(ThreadContext context, IRubyObject[] args)`
`IRubyObject`	`doClone()`
`IRubyObject`	`downcase_bang(ThreadContext context)`
`IRubyObject`	`downcase_bang19(ThreadContext context)`
`RubyString`	`downcase(ThreadContext context)` rb_str_downcase / rb_str_downcase_bang
`RubyString`	`downcase19(ThreadContext context)`
`IRubyObject`	`dump()` rb_str_dump
`IRubyObject`	`dump19()`
`private IRubyObject`	`dumpCommon(boolean is1_9)`
`IRubyObject`	`dup()` Overridden dup for fast-path logic.
`RubyString`	`each_byte(ThreadContext context, Block block)` rb_str_each_byte
`IRubyObject`	`each_byte19(ThreadContext context, Block block)`
`IRubyObject`	`each_char18(ThreadContext context, Block block)` rb_str_each_char
`IRubyObject`	`each_char19(ThreadContext context, Block block)`
`private IRubyObject`	`each_charCommon18(ThreadContext context, Block block)`
`private IRubyObject`	`each_charCommon19(ThreadContext context, Block block)`
`IRubyObject`	`each_codepoint(ThreadContext context, Block block)` rb_str_each_codepoint
`private IRubyObject`	`each_codepointCommon(ThreadContext context, Block block)`
`IRubyObject`	`each_line(ThreadContext context, Block block)` rb_str_each_line
`IRubyObject`	`each_line(ThreadContext context, IRubyObject arg, Block block)`
`IRubyObject`	`each_line18(ThreadContext context, Block block)`
`IRubyObject`	`each_line18(ThreadContext context, IRubyObject arg, Block block)`
`IRubyObject`	`each_line19(ThreadContext context, Block block)`
`IRubyObject`	`each_line19(ThreadContext context, IRubyObject arg, Block block)`
`IRubyObject`	`each_lineCommon(ThreadContext context, IRubyObject sep, Block block)`
`private IRubyObject`	`each_lineCommon19(ThreadContext context, Block block)`
`private IRubyObject`	`each_lineCommon19(ThreadContext context, IRubyObject sep, Block block)`
`IRubyObject`	`each18(ThreadContext context, Block block)`
`IRubyObject`	`each18(ThreadContext context, IRubyObject arg, Block block)`
`RubyBoolean`	`empty_p(ThreadContext context)` rb_str_empty
`void`	`empty()`
`IRubyObject`	`encode_bang(ThreadContext context, IRubyObject arg0)`
`IRubyObject`	`encode_bang(ThreadContext context, IRubyObject[] args)`
`IRubyObject`	`encode_bang(ThreadContext context, IRubyObject arg0, IRubyObject arg1)`
`IRubyObject`	`encode_bang(ThreadContext context, IRubyObject arg0, IRubyObject arg1, IRubyObject arg2)`
`IRubyObject`	`encode(ThreadContext context)`
`IRubyObject`	`encode(ThreadContext context, IRubyObject arg)`
`IRubyObject`	`encode(ThreadContext context, IRubyObject toEncoding, IRubyObject arg)`
`IRubyObject`	`encode(ThreadContext context, IRubyObject toEncoding, IRubyObject forcedEncoding, IRubyObject opts)`
`private static org.jruby.util.ByteList`	`encodeBytelist(java.lang.CharSequence value, org.jcodings.Encoding encoding)`
`IRubyObject`	`encoding(ThreadContext context)`
`IRubyObject`	`end_with_p(ThreadContext context)`
`IRubyObject`	`end_with_p(ThreadContext context, IRubyObject arg)`
`IRubyObject`	`end_with_p(ThreadContext context, IRubyObject[] args)`
`private boolean`	`end_with_pCommon(IRubyObject arg)`
`boolean`	`eql(IRubyObject other)` short circuit for String key comparison
`private boolean`	`eql18(Ruby runtime, IRubyObject other)`
`private boolean`	`eql19(Ruby runtime, IRubyObject other)`
`boolean`	`equals(java.lang.Object other)` This method is just a wrapper around the Ruby "==" method, provided so that RubyObjects can be used as keys in the Java HashMap object underlying RubyHash.
`private void`	`exciseHead(int len)` Excises (removes) a slice of the string that starts at index zero
`private void`	`exciseTail(int len)` Excises (removes) a slice of the string that ends at the last byte in the string
`private IRubyObject`	`force_encoding(ThreadContext context, org.jcodings.Encoding encoding)`
`IRubyObject`	`force_encoding(ThreadContext context, IRubyObject enc)`
`private void`	`frozenCheck()`
`private void`	`frozenCheck(boolean runtimeError)`
`IRubyObject`	`getbyte(ThreadContext context, IRubyObject index)`
`org.jruby.util.ByteList`	`getByteList()`
`byte[]`	`getBytes()`
`int`	`getCodeRange()`
`(package private) static RubyString.EmptyByteListHolder`	`getEmptyByteList(org.jcodings.Encoding enc)`
`org.jcodings.Encoding`	`getEncoding()`
`private static org.jcodings.Encoding`	`getEncoding(Ruby runtime, IRubyObject toEnc)`
`private org.jcodings.Encoding`	`getEncodingForKCodeDefault(Ruby runtime, org.joni.Regex pattern, IRubyObject pat)`
`java.lang.Class`	`getJavaClass()` Will return the Java interface that most closely can represent this object, when working through JAva integration translations.
`org.jcodings.Encoding`	`getMarshalEncoding()`
`int`	`getNativeTypeIndex()` This is overridden in the other concrete Java builtins to provide a fast way to determine what type they are.
`private RubyRegexp`	`getPattern(IRubyObject obj)` get_pat (used by match/match19)
`private org.joni.Regex`	`getQuotedPattern(IRubyObject obj)`
`private RubyString`	`getStringForPattern(IRubyObject obj)`
`private org.joni.Regex`	`getStringPattern(Ruby runtime, org.jcodings.Encoding enc, IRubyObject obj)`
`private org.joni.Regex`	`getStringPattern19(Ruby runtime, IRubyObject obj)`
`java.lang.String`	`getUnicodeValue()` used by ar-jdbc
`java.lang.CharSequence`	`getValue()`
`IRubyObject`	`gsub_bang(ThreadContext context, IRubyObject arg0, Block block)`
`IRubyObject`	`gsub_bang(ThreadContext context, IRubyObject arg0, IRubyObject arg1, Block block)`
`IRubyObject`	`gsub_bang19(ThreadContext context, IRubyObject arg0, Block block)`
`IRubyObject`	`gsub_bang19(ThreadContext context, IRubyObject arg0, IRubyObject arg1, Block block)`
`IRubyObject`	`gsub(ThreadContext context, IRubyObject arg0, Block block)` rb_str_gsub / rb_str_gsub_bang
`private IRubyObject`	`gsub(ThreadContext context, IRubyObject arg0, Block block, boolean bang)`
`IRubyObject`	`gsub(ThreadContext context, IRubyObject arg0, IRubyObject arg1, Block block)`
`private IRubyObject`	`gsub(ThreadContext context, IRubyObject arg0, IRubyObject arg1, Block block, boolean bang)`
`IRubyObject`	`gsub19(ThreadContext context, IRubyObject arg0, Block block)`
`IRubyObject`	`gsub19(ThreadContext context, IRubyObject arg0, IRubyObject arg1, Block block)`
`private IRubyObject`	`gsub19(ThreadContext context, IRubyObject arg0, IRubyObject arg1, Block block, boolean bang)`
`private IRubyObject`	`gsubCommon(ThreadContext context, boolean bang, IRubyObject arg, Block block, RubyString repl, int tuFlags)`
`private IRubyObject`	`gsubCommon19(ThreadContext context, Block block, RubyString repl, RubyHash hash, IRubyObject arg0, boolean bang, int tuFlags)`
`private IRubyObject`	`gsubCommon19(ThreadContext context, Block block, RubyString repl, RubyHash hash, IRubyObject arg0, boolean bang, int tuFlags, boolean useBackref)`
`RubyFixnum`	`hash()` rb_obj_id Will return the hash code of this object.
`int`	`hashCode()` Override the Object#hashCode method to make sure that the Ruby hash is actually used as the hashcode for Ruby objects.
`IRubyObject`	`hex(ThreadContext context)` rb_str_hex
`IRubyObject`	`hex19(ThreadContext context)`
`RubyBoolean`	`include_p(ThreadContext context, IRubyObject obj)` rb_str_include
`RubyBoolean`	`include_p19(ThreadContext context, IRubyObject obj)`
`boolean`	`independent()`
`IRubyObject`	`index(ThreadContext context, IRubyObject arg0)` rb_str_index_m
`IRubyObject`	`index(ThreadContext context, IRubyObject arg0, IRubyObject arg1)`
`IRubyObject`	`index19(ThreadContext context, IRubyObject arg0)`
`IRubyObject`	`index19(ThreadContext context, IRubyObject arg0, IRubyObject arg1)`
`private IRubyObject`	`indexCommon(Ruby runtime, ThreadContext context, IRubyObject sub, int pos)`
`private IRubyObject`	`indexCommon19(Ruby runtime, ThreadContext context, IRubyObject sub, int pos)`
`(package private) static int`	`indexOf(byte[] source, int sourceOffset, int sourceCount, byte[] target, int targetOffset, int targetCount, int fromIndex)`
`IRubyObject`	`initialize_copy(IRubyObject other)` rb_obj_init_copy Initializes this object as a copy of the original, that is the parameter to this object.
`RubyString`	`initialize_copy19(IRubyObject other)`
`IRubyObject`	`initialize(ThreadContext context)`
`IRubyObject`	`initialize(ThreadContext context, IRubyObject arg0)`
`IRubyObject`	`initialize19(ThreadContext context)`
`IRubyObject`	`initialize19(ThreadContext context, IRubyObject arg0)`
`IRubyObject`	`insert(ThreadContext context, IRubyObject indexArg, IRubyObject stringArg)`
`IRubyObject`	`insert19(ThreadContext context, IRubyObject indexArg, IRubyObject stringArg)`
`IRubyObject`	`inspect()` rb_str_inspect
`IRubyObject`	`inspect19()`
`RubySymbol`	`intern()`
`RubySymbol`	`intern19()`
`boolean`	`isAsciiOnly()`
`boolean`	`isCodeRangeAsciiOnly()`
`boolean`	`isCodeRangeBroken()`
`boolean`	`isCodeRangeValid()`
`private boolean`	`isComparableViaCodeRangeWith(RubyString other)`
`private boolean`	`isComparableWith(RubyString other)`
`(package private) org.jcodings.Encoding`	`isCompatibleWith(EncodingCapable other)`
`private org.jcodings.Encoding`	`isCompatibleWith(RubyString other)`
`boolean`	`isEmpty()`
`private boolean`	`isEVStr(byte[] bytes, int p, int end)`
`boolean`	`isEVStr(int c)`
`private boolean`	`isHeadSlice(int beg, int len)`
`private boolean`	`isTailSlice(int beg, int len)`
`private IRubyObject`	`justify(IRubyObject arg0, int jflag)`
`private IRubyObject`	`justify(IRubyObject arg0, IRubyObject arg1, int jflag)`
`private IRubyObject`	`justify19(IRubyObject arg0, int jflag)`
`private IRubyObject`	`justify19(IRubyObject arg0, IRubyObject arg1, int jflag)`
`private RubyString`	`justifyCommon(Ruby runtime, org.jruby.util.ByteList pad, int padCharLen, boolean padSinglebyte, org.jcodings.Encoding enc, int width, int jflag)`
`private RubyString`	`justifyCommon(Ruby runtime, org.jruby.util.ByteList pad, int width, int jflag)`
`private void`	`keepCodeRange()`
`RubyFixnum`	`length()` rb_str_length
`RubyFixnum`	`length19()`
`IRubyObject`	`lines(ThreadContext context, Block block)`
`IRubyObject`	`lines(ThreadContext context, IRubyObject arg, Block block)`
`IRubyObject`	`lines18(ThreadContext context, Block block)`
`IRubyObject`	`lines18(ThreadContext context, IRubyObject arg, Block block)`
`IRubyObject`	`lines20(ThreadContext context, Block block)`
`IRubyObject`	`lines20(ThreadContext context, IRubyObject arg, Block block)`
`IRubyObject`	`ljust(IRubyObject arg0)` rb_str_ljust
`IRubyObject`	`ljust(IRubyObject arg0, IRubyObject arg1)`
`IRubyObject`	`ljust19(IRubyObject arg0)`
`IRubyObject`	`ljust19(IRubyObject arg0, IRubyObject arg1)`
`IRubyObject`	`lstrip_bang(ThreadContext context)`
`IRubyObject`	`lstrip_bang19(ThreadContext context)`
`IRubyObject`	`lstrip(ThreadContext context)` rb_str_lstrip / rb_str_lstrip_bang
`IRubyObject`	`lstrip19(ThreadContext context)`
`RubyString`	`makeIndependent()`
`RubyString`	`makeShared(Ruby runtime, int index, int len)`
`RubyString`	`makeShared(Ruby runtime, RubyClass meta, int index, int len)`
`private RubyString`	`makeShared19(Ruby runtime, org.jruby.util.ByteList value, int index, int len)`
`RubyString`	`makeShared19(Ruby runtime, int index, int len)`
`private RubyString`	`makeShared19(Ruby runtime, RubyClass meta, org.jruby.util.ByteList value, int index, int len)`
`RubyString`	`makeShared19(Ruby runtime, RubyClass meta, int index, int len)`
`RubyString`	`makeSharedString(Ruby runtime, int index, int len)`
`RubyString`	`makeSharedString19(Ruby runtime, int index, int len)`
`IRubyObject`	`match(ThreadContext context, IRubyObject pattern)` String#match(pattern) rb_str_match_m
`IRubyObject`	`match19(ThreadContext context, IRubyObject[] args, Block block)`
`IRubyObject`	`match19(ThreadContext context, IRubyObject pattern, Block block)`
`void`	`modify()` rb_str_modify
`void`	`modify(int length)` rb_str_modify (with length bytes ensured)
`void`	`modify19()`
`void`	`modify19(int length)`
`private void`	`modifyAndKeepCodeRange()`
`void`	`modifyCheck()` Check that the string can be modified, raising error otherwise.
`private void`	`modifyCheck(byte[] b, int len)`
`private void`	`modifyCheck(byte[] b, int len, org.jcodings.Encoding enc)`
`private IRubyObject`	`multiByteCasecmp(Ruby runtime, org.jcodings.Encoding enc, org.jruby.util.ByteList value, org.jruby.util.ByteList otherValue)`
`private IRubyObject`	`multiByteDowncase(Ruby runtime, org.jcodings.Encoding enc, byte[] bytes, int s, int end)`
`private IRubyObject`	`multiByteLStrip(Ruby runtime, org.jcodings.Encoding enc, byte[] bytes, int s, int end)`
`private IRubyObject`	`multiByteRStrip19(Ruby runtime)`
`private IRubyObject`	`multibyteSubstr19(Ruby runtime, org.jcodings.Encoding enc, int len, int beg, int length)`
`private IRubyObject`	`multiByteSwapcase(Ruby runtime, org.jcodings.Encoding enc, byte[] bytes, int s, int end)`
`private IRubyObject`	`multiByteUpcase(Ruby runtime, org.jcodings.Encoding enc, byte[] bytes, int s, int end)`
`private RubyString`	`multiplyByteList(ThreadContext context, IRubyObject arg)`
`static RubyString`	`newAllocatedString(Ruby runtime, RubyClass metaClass)`
`static RubyString`	`newEmptyString(Ruby runtime)`
`static RubyString`	`newEmptyString(Ruby runtime, org.jcodings.Encoding enc)`
`static RubyString`	`newEmptyString(Ruby runtime, RubyClass metaClass)`
`static RubyString`	`newEmptyString(Ruby runtime, RubyClass metaClass, org.jcodings.Encoding enc)`
`static RubyString`	`newInstance(IRubyObject recv, IRubyObject[] args, Block block)` rb_str_s_new
`static RubyString`	`newInternalFromJavaExternal(Ruby runtime, java.lang.String str)` Return a new Ruby String encoded as the default internal encoding given a Java String that has come from an external source.
`RubyString`	`newString(org.jruby.util.ByteList s)` Deprecated.
`RubyString`	`newString(java.lang.CharSequence s)` Deprecated.
`static RubyString`	`newString(Ruby runtime, byte[] bytes)`
`static RubyString`	`newString(Ruby runtime, byte[] bytes, int start, int length)`
`static RubyString`	`newString(Ruby runtime, org.jruby.util.ByteList bytes)`
`static RubyString`	`newString(Ruby runtime, org.jruby.util.ByteList bytes, org.jcodings.Encoding encoding)`
`static RubyString`	`newString(Ruby runtime, java.lang.CharSequence str)`
`static RubyString`	`newString(Ruby runtime, RubyClass clazz, java.lang.CharSequence str)` Deprecated.
`static RubyString`	`newString(Ruby runtime, java.lang.String str)`
`static RubyString`	`newStringLight(Ruby runtime, org.jruby.util.ByteList bytes)`
`static RubyString`	`newStringLight(Ruby runtime, int size)`
`static RubyString`	`newStringLight(Ruby runtime, int size, org.jcodings.Encoding encoding)`
`static RubyString`	`newStringNoCopy(Ruby runtime, byte[] bytes)`
`static RubyString`	`newStringNoCopy(Ruby runtime, byte[] bytes, int start, int length)`
`static RubyString`	`newStringNoCopy(Ruby runtime, org.jruby.util.ByteList bytes)`
`static RubyString`	`newStringNoCopy(Ruby runtime, org.jruby.util.ByteList bytes, org.jcodings.Encoding enc, int cr)`
`static RubyString`	`newStringNoCopy(Ruby runtime, RubyClass clazz, org.jruby.util.ByteList bytes)`
`static RubyString`	`newStringNoCopy(Ruby runtime, RubyClass clazz, org.jruby.util.ByteList bytes, org.jcodings.Encoding enc, int cr)`
`static RubyString`	`newStringShared(Ruby runtime, byte[] bytes)`
`static RubyString`	`newStringShared(Ruby runtime, byte[] bytes, org.jcodings.Encoding encoding)`
`static RubyString`	`newStringShared(Ruby runtime, byte[] bytes, int start, int length)`
`static RubyString`	`newStringShared(Ruby runtime, byte[] bytes, int start, int length, org.jcodings.Encoding encoding)`
`static RubyString`	`newStringShared(Ruby runtime, org.jruby.util.ByteList bytes)`
`static RubyString`	`newStringShared(Ruby runtime, org.jruby.util.ByteList bytes, org.jcodings.Encoding encoding)`
`static RubyString`	`newStringShared(Ruby runtime, org.jruby.util.ByteList bytes, int codeRange)`
`static RubyString`	`newStringShared(Ruby runtime, RubyClass clazz, org.jruby.util.ByteList bytes)`
`static RubyString`	`newStringShared(Ruby runtime, RubyClass clazz, org.jruby.util.ByteList bytes, org.jcodings.Encoding encoding)`
`static RubyString`	`newStringShared(Ruby runtime, RubyString orig)`
`static RubyString`	`newUnicodeString(Ruby runtime, java.lang.CharSequence str)`
`static RubyString`	`newUnicodeString(Ruby runtime, java.lang.String str)`
`static RubyString`	`newUSASCIIString(Ruby runtime, java.lang.String str)`
`static RubyString`	`newUsAsciiStringNoCopy(Ruby runtime, org.jruby.util.ByteList bytes)`
`static RubyString`	`newUsAsciiStringShared(Ruby runtime, byte[] bytes, int start, int length)`
`static RubyString`	`newUsAsciiStringShared(Ruby runtime, org.jruby.util.ByteList bytes)`
`static RubyString`	`newUTF16String(Ruby runtime, java.lang.CharSequence str)`
`static RubyString`	`newUTF16String(Ruby runtime, java.lang.String str)`
`static RubyString`	`newUTF8String(Ruby runtime, java.lang.CharSequence str)`
`static RubyString`	`newUTF8String(Ruby runtime, java.lang.String str)`
`static RubyString`	`objAsString(ThreadContext context, IRubyObject obj)` rb_obj_as_string
`IRubyObject`	`oct(ThreadContext context)` rb_str_oct
`IRubyObject`	`oct19(ThreadContext context)`
`private IRubyObject`	`op_aref(Ruby runtime, int idx)`
`IRubyObject`	`op_aref(ThreadContext context, IRubyObject arg)`
`IRubyObject`	`op_aref(ThreadContext context, IRubyObject arg1, IRubyObject arg2)` rb_str_aref, rb_str_aref_m
`private IRubyObject`	`op_aref19(Ruby runtime, int idx)`
`IRubyObject`	`op_aref19(ThreadContext context, IRubyObject arg)`
`IRubyObject`	`op_aref19(ThreadContext context, IRubyObject arg1, IRubyObject arg2)`
`private IRubyObject`	`op_aset(ThreadContext context, int idx, IRubyObject arg1)`
`IRubyObject`	`op_aset(ThreadContext context, IRubyObject arg0, IRubyObject arg1)` rb_str_aset, rb_str_aset_m
`IRubyObject`	`op_aset(ThreadContext context, IRubyObject arg0, IRubyObject arg1, IRubyObject arg2)`
`private IRubyObject`	`op_aset19(ThreadContext context, int idx, IRubyObject arg1)`
`IRubyObject`	`op_aset19(ThreadContext context, IRubyObject arg0, IRubyObject arg1)`
`IRubyObject`	`op_aset19(ThreadContext context, IRubyObject arg0, IRubyObject arg1, IRubyObject arg2)`
`int`	`op_cmp(RubyString other)` rb_str_cmp
`IRubyObject`	`op_cmp(ThreadContext context, IRubyObject other)`
`int`	`op_cmp19(RubyString other)`
`IRubyObject`	`op_cmp19(ThreadContext context, IRubyObject other)`
`private IRubyObject`	`op_cmpCommon(ThreadContext context, IRubyObject other)`
`IRubyObject`	`op_equal(ThreadContext context, IRubyObject other)` rb_str_equal
`IRubyObject`	`op_equal19(ThreadContext context, IRubyObject other)`
`private IRubyObject`	`op_equalCommon(ThreadContext context, IRubyObject other)`
`IRubyObject`	`op_format(ThreadContext context, IRubyObject arg)`
`IRubyObject`	`op_ge(ThreadContext context, IRubyObject other)`
`IRubyObject`	`op_ge19(ThreadContext context, IRubyObject other)`
`IRubyObject`	`op_gt(ThreadContext context, IRubyObject other)`
`IRubyObject`	`op_gt19(ThreadContext context, IRubyObject other)`
`IRubyObject`	`op_le(ThreadContext context, IRubyObject other)`
`IRubyObject`	`op_le19(ThreadContext context, IRubyObject other)`
`IRubyObject`	`op_lt(ThreadContext context, IRubyObject other)`
`IRubyObject`	`op_lt19(ThreadContext context, IRubyObject other)`
`IRubyObject`	`op_match(ThreadContext context, IRubyObject other)` rb_str_match
`IRubyObject`	`op_match19(ThreadContext context, IRubyObject other)`
`IRubyObject`	`op_mul(ThreadContext context, IRubyObject other)`
`IRubyObject`	`op_mul19(ThreadContext context, IRubyObject other)`
`IRubyObject`	`op_plus(ThreadContext context, IRubyObject _str)`
`IRubyObject`	`op_plus19(ThreadContext context, IRubyObject _str)`
`private IRubyObject`	`opFormatCommon(ThreadContext context, IRubyObject arg, CompatVersion compat)`
`IRubyObject`	`ord(ThreadContext context)`
`IRubyObject`	`partition(ThreadContext context, Block block)`
`IRubyObject`	`partition(ThreadContext context, IRubyObject arg, Block block)`
`private IRubyObject`	`partitionMismatch(Ruby runtime)`
`private IRubyObject`	`populateCapturesForScan(Ruby runtime, org.joni.Matcher matcher, int range, int tuFlags, boolean is19)`
`private void`	`populateCapturesForSplit(Ruby runtime, RubyArray result, org.joni.Matcher matcher, boolean is19)`
`private int`	`positionEnd(org.joni.Matcher matcher, org.jcodings.Encoding enc, int begin, int range)`
`private static RubyString.NeighborChar`	`predChar(org.jcodings.Encoding enc, byte[] bytes, int p, int len)`
`private void`	`prefixEscapeCat(int c)`
`private static RubyString.EmptyByteListHolder`	`prepareEmptyByteList(org.jcodings.Encoding enc)`
`IRubyObject`	`prepend(ThreadContext context, IRubyObject other)` rb_str_prepend
`private void`	`raiseIndexOutOfString(int index)`
`private RubyArray`	`regexSplit(ThreadContext context, IRubyObject pat, boolean limit, int lim, int i)`
`private RubyArray`	`regexSplit19(ThreadContext context, org.joni.Regex pattern, org.joni.Regex prepared, boolean limit, int lim, int i, boolean useBackref)`
`IRubyObject`	`replace(IRubyObject other)` rb_str_replace_m
`RubyString`	`replace19(IRubyObject other)`
`private RubyString`	`replaceCommon(IRubyObject other)`
`private IRubyObject`	`replaceInternal(int beg, int len, RubyString repl)`
`private void`	`replaceInternal19(int beg, int len, RubyString repl)`
`void`	`resize(int length)` rb_str_resize
`RubyString`	`reverse_bang(ThreadContext context)`
`RubyString`	`reverse_bang19(ThreadContext context)`
`IRubyObject`	`reverse(ThreadContext context)`
`IRubyObject`	`reverse19(ThreadContext context)`
`IRubyObject`	`rindex(ThreadContext context, IRubyObject arg0)` rb_str_rindex_m
`IRubyObject`	`rindex(ThreadContext context, IRubyObject arg0, IRubyObject arg1)`
`IRubyObject`	`rindex19(ThreadContext context, IRubyObject arg0)`
`IRubyObject`	`rindex19(ThreadContext context, IRubyObject arg0, IRubyObject arg1)`
`private IRubyObject`	`rindexCommon(Ruby runtime, ThreadContext context, IRubyObject sub, int pos)`
`private IRubyObject`	`rindexCommon19(Ruby runtime, ThreadContext context, IRubyObject sub, int pos)`
`IRubyObject`	`rjust(IRubyObject arg0)` rb_str_rjust
`IRubyObject`	`rjust(IRubyObject arg0, IRubyObject arg1)`
`IRubyObject`	`rjust19(IRubyObject arg0)`
`IRubyObject`	`rjust19(IRubyObject arg0, IRubyObject arg1)`
`IRubyObject`	`rpartition(ThreadContext context, IRubyObject arg)`
`private IRubyObject`	`rpartitionMismatch(Ruby runtime)`
`IRubyObject`	`rstrip_bang(ThreadContext context)`
`IRubyObject`	`rstrip_bang19(ThreadContext context)`
`IRubyObject`	`rstrip(ThreadContext context)` rb_str_rstrip / rb_str_rstrip_bang
`IRubyObject`	`rstrip19(ThreadContext context)`
`IRubyObject`	`scan(ThreadContext context, IRubyObject arg, Block block)` rb_str_scan
`IRubyObject`	`scan19(ThreadContext context, IRubyObject arg, Block block)`
`int`	`scanForCodeRange()`
`private IRubyObject`	`scanIter(ThreadContext context, org.joni.Regex pattern, org.joni.Matcher matcher, org.jcodings.Encoding enc, Block block, int begin, int range, int tuFlags)`
`private IRubyObject`	`scanIter19(ThreadContext context, org.joni.Regex pattern, org.joni.Regex prepared, org.jcodings.Encoding enc, Block block, RubyRegexp regexp, int tuFlags)`
`private IRubyObject`	`scanNoIter(ThreadContext context, org.joni.Regex pattern, org.joni.Matcher matcher, org.jcodings.Encoding enc, int begin, int range, int tuFlags)`
`private IRubyObject`	`scanNoIter19(ThreadContext context, org.joni.Regex pattern, org.joni.Regex prepared, org.jcodings.Encoding enc, RubyRegexp regexp, int tuFlags)`
`IRubyObject`	`setbyte(ThreadContext context, IRubyObject index, IRubyObject val)`
`void`	`setByteListShared()`
`void`	`setCodeRange(int codeRange)`
`void`	`setEncoding(org.jcodings.Encoding encoding)`
`void`	`setEncodingAndCodeRange(org.jcodings.Encoding enc, int cr)`
`void`	`setValue(org.jruby.util.ByteList value)`
`void`	`setValue(java.lang.CharSequence value)` Deprecated.
`boolean`	`shouldMarshalEncoding()`
`private IRubyObject`	`singleByteDowncase(Ruby runtime, byte[] bytes, int s, int end)`
`private IRubyObject`	`singleByteLStrip(Ruby runtime, byte[] bytes, int s, int end)`
`(package private) boolean`	`singleByteOptimizable()`
`(package private) boolean`	`singleByteOptimizable(org.jcodings.Encoding enc)`
`private IRubyObject`	`singleByteRStrip(Ruby runtime, byte[] bytes, int s, int end)`
`private IRubyObject`	`singleByteRStrip19(Ruby runtime)`
`private IRubyObject`	`singleByteStrip(Ruby runtime, byte[] bytes, int s, int end)`
`private IRubyObject`	`singleByteSwapcase(Ruby runtime, byte[] bytes, int s, int end)`
`private IRubyObject`	`singleByteUpcase(Ruby runtime, byte[] bytes, int s, int end)`
`int`	`size()`
`private static boolean`	`sizeIsSmaller(org.jruby.util.ByteList byteList, int offset, org.jruby.util.ByteList other)`
`IRubyObject`	`slice_bang(ThreadContext context, IRubyObject arg0)` rb_str_slice_bang
`IRubyObject`	`slice_bang(ThreadContext context, IRubyObject arg0, IRubyObject arg1)`
`IRubyObject`	`slice_bang19(ThreadContext context, IRubyObject arg0)`
`IRubyObject`	`slice_bang19(ThreadContext context, IRubyObject arg0, IRubyObject arg1)`
`private IRubyObject`	`smartChopBangCommon(Ruby runtime)`
`private IRubyObject`	`smartChopBangCommon19(Ruby runtime)`
`RubyArray`	`split(ThreadContext context)` rb_str_split_m
`RubyArray`	`split(ThreadContext context, IRubyObject arg0)`
`RubyArray`	`split(ThreadContext context, IRubyObject arg0, IRubyObject arg1)`
`RubyArray`	`split19(ThreadContext context)`
`RubyArray`	`split19(ThreadContext context, IRubyObject arg0)`
`RubyArray`	`split19(ThreadContext context, IRubyObject arg0, boolean useBackref)`
`RubyArray`	`split19(ThreadContext context, IRubyObject arg0, IRubyObject arg1)`
`private RubyArray`	`splitCommon(IRubyObject spat, boolean limit, int lim, int i, ThreadContext context)`
`private RubyArray`	`splitCommon19(IRubyObject spat, boolean limit, int lim, int i, ThreadContext context, boolean useBackref)`
`IRubyObject`	`squeeze_bang(ThreadContext context)`
`IRubyObject`	`squeeze_bang(ThreadContext context, IRubyObject arg)`
`IRubyObject`	`squeeze_bang(ThreadContext context, IRubyObject[] args)`
`IRubyObject`	`squeeze_bang19(ThreadContext context)`
`IRubyObject`	`squeeze_bang19(ThreadContext context, IRubyObject arg)`
`IRubyObject`	`squeeze_bang19(ThreadContext context, IRubyObject[] args)`
`IRubyObject`	`squeeze(ThreadContext context)` rb_str_squeeze / rb_str_squeeze_bang
`IRubyObject`	`squeeze(ThreadContext context, IRubyObject arg)`
`IRubyObject`	`squeeze(ThreadContext context, IRubyObject[] args)`
`IRubyObject`	`squeeze19(ThreadContext context)`
`IRubyObject`	`squeeze19(ThreadContext context, IRubyObject arg)`
`IRubyObject`	`squeeze19(ThreadContext context, IRubyObject[] args)`
`private IRubyObject`	`squeezeCommon(Ruby runtime, boolean[] squeeze)`
`private IRubyObject`	`squeezeCommon19(Ruby runtime, boolean[] squeeze, RubyString.TrTables tables, org.jcodings.Encoding enc, boolean isArg)`
`IRubyObject`	`start_with_p(ThreadContext context)`
`IRubyObject`	`start_with_p(ThreadContext context, IRubyObject arg)`
`IRubyObject`	`start_with_p(ThreadContext context, IRubyObject[] args)`
`private boolean`	`start_with_pCommon(IRubyObject arg)`
`IRubyObject`	`str_eql_p(ThreadContext context, IRubyObject other)`
`IRubyObject`	`str_eql_p19(ThreadContext context, IRubyObject other)`
`RubyString`	`strDup()` Deprecated.
`RubyString`	`strDup(Ruby runtime)`
`(package private) RubyString`	`strDup(RubyClass clazz)` Deprecated.
`(package private) RubyString`	`strDup(Ruby runtime, RubyClass clazz)`
`int`	`strHashCode(Ruby runtime)` Generate a hash for the String, using its associated Ruby instance's hash seed.
`private int`	`strIndex(RubyString sub, int offset)`
`private int`	`strIndex19(RubyString sub, int offset)`
`private RubyArray`	`stringSplit19(ThreadContext context, RubyString spat, boolean limit, int lim, int i)`
`static byte[]`	`stringToBytes(java.lang.String string)`
`IRubyObject`	`stringToInum(int base, boolean badcheck)` rb_str_to_inum
`IRubyObject`	`stringToInum19(int base, boolean badcheck)`
`static RubyString`	`stringValue(IRubyObject object)`
`IRubyObject`	`strip_bang(ThreadContext context)`
`IRubyObject`	`strip_bang19(ThreadContext context)`
`IRubyObject`	`strip(ThreadContext context)` rb_str_strip / rb_str_strip_bang
`IRubyObject`	`strip19(ThreadContext context)`
`int`	`strLength()`
`private int`	`strLength(org.jruby.util.ByteList bytes)`
`private int`	`strLength(org.jruby.util.ByteList bytes, org.jcodings.Encoding enc)`
`private int`	`strLength(org.jcodings.Encoding enc)`
`private int`	`strRindex(RubyString sub, int pos)`
`private int`	`strRindex19(RubyString sub, int pos)`
`IRubyObject`	`sub_bang(ThreadContext context, IRubyObject arg0, Block block)`
`IRubyObject`	`sub_bang(ThreadContext context, IRubyObject arg0, IRubyObject arg1, Block block)`
`IRubyObject`	`sub_bang19(ThreadContext context, IRubyObject arg0, Block block)`
`IRubyObject`	`sub_bang19(ThreadContext context, IRubyObject arg0, IRubyObject arg1, Block block)`
`IRubyObject`	`sub(ThreadContext context, IRubyObject arg0, Block block)` rb_str_sub / rb_str_sub_bang
`IRubyObject`	`sub(ThreadContext context, IRubyObject arg0, IRubyObject arg1, Block block)`
`IRubyObject`	`sub19(ThreadContext context, IRubyObject arg0, Block block)`
`IRubyObject`	`sub19(ThreadContext context, IRubyObject arg0, IRubyObject arg1, Block block)`
`private IRubyObject`	`subBangCommon(ThreadContext context, org.joni.Regex pattern, org.joni.Matcher matcher, RubyString repl, int tuFlags)`
`private IRubyObject`	`subBangCommon19(ThreadContext context, org.joni.Regex pattern, org.joni.Matcher matcher, RubyString repl, int tuFlags)`
`private IRubyObject`	`subBangIter(ThreadContext context, org.joni.Regex pattern, Block block)`
`private IRubyObject`	`subBangIter19(Ruby runtime, ThreadContext context, org.joni.Regex pattern, org.joni.Regex prepared, RubyHash hash, Block block, RubyRegexp regexp)`
`private IRubyObject`	`subBangNoIter(ThreadContext context, org.joni.Regex pattern, RubyString repl)`
`private IRubyObject`	`subBangNoIter19(Ruby runtime, ThreadContext context, org.joni.Regex pattern, org.joni.Regex prepared, RubyString repl, RubyRegexp regexp)`
`private org.jcodings.Encoding`	`subBangVerifyEncoding(ThreadContext context, RubyString repl, int beg, int end)`
`(package private) int`	`subLength(int pos)`
`private IRubyObject`	`subpat(Ruby runtime, ThreadContext context, RubyRegexp regex, int nth)`
`private IRubyObject`	`subpat19(Ruby runtime, ThreadContext context, RubyRegexp regex)`
`private IRubyObject`	`subpat19(Ruby runtime, ThreadContext context, RubyRegexp regex, IRubyObject backref)`
`private void`	`subpatSet(ThreadContext context, RubyRegexp regexp, int nth, IRubyObject repl)` rb_str_subpat_set
`private void`	`subpatSet19(ThreadContext context, RubyRegexp regexp, IRubyObject backref, IRubyObject repl)`
`private int`	`subpatSetCheck(Ruby runtime, int nth, org.joni.Region regs)`
`IRubyObject`	`substr(int beg, int len)` Deprecated.
`IRubyObject`	`substr(Ruby runtime, int beg, int len)`
`IRubyObject`	`substr19(Ruby runtime, int beg, int len)`
`IRubyObject`	`succ_bang()`
`IRubyObject`	`succ_bang19()`
`IRubyObject`	`succ(ThreadContext context)`
`IRubyObject`	`succ19(ThreadContext context)`
`private static RubyString.NeighborChar`	`succAlnumChar(org.jcodings.Encoding enc, byte[] bytes, int p, int len, byte[] carry, int carryP)`
`private static RubyString.NeighborChar`	`succChar(org.jcodings.Encoding enc, byte[] bytes, int p, int len)`
`private org.jruby.util.ByteList`	`succCommon19(org.jruby.util.ByteList original)`
`IRubyObject`	`sum(ThreadContext context)`
`IRubyObject`	`sum(ThreadContext context, IRubyObject arg)`
`IRubyObject`	`sumCommon(ThreadContext context, long bits)`
`IRubyObject`	`swapcase_bang(ThreadContext context)`
`IRubyObject`	`swapcase_bang19(ThreadContext context)`
`RubyString`	`swapcase(ThreadContext context)` rb_str_swapcase / rb_str_swapcase_bang
`RubyString`	`swapcase19(ThreadContext context)`
`IRubyObject`	`to_c(ThreadContext context)` string_to_c
`IRubyObject`	`to_f()` rb_str_to_f
`IRubyObject`	`to_f19()`
`IRubyObject`	`to_i()` rb_str_to_i
`IRubyObject`	`to_i(IRubyObject arg0)` rb_str_to_i
`IRubyObject`	`to_i19()`
`IRubyObject`	`to_i19(IRubyObject arg0)`
`IRubyObject`	`to_r(ThreadContext context)` string_to_r
`IRubyObject`	`to_s()` rb_any_to_s call-seq: obj.to_s => string Returns a string representing obj.
`private RubySymbol`	`to_sym()` rb_str_intern
`org.jcodings.Encoding`	`toEncoding(Ruby runtime)`
`java.lang.Object`	`toJava(java.lang.Class target)` Convert the object to the specified Java class, if possible.
`java.lang.String`	`toString()` The default toString method is just a wrapper that calls the Ruby "to_s" method.
`IRubyObject`	`tr_bang(ThreadContext context, IRubyObject src, IRubyObject repl)`
`IRubyObject`	`tr_bang19(ThreadContext context, IRubyObject src, IRubyObject repl)`
`IRubyObject`	`tr_s_bang(ThreadContext context, IRubyObject src, IRubyObject repl)`
`IRubyObject`	`tr_s_bang19(ThreadContext context, IRubyObject src, IRubyObject repl)`
`IRubyObject`	`tr_s(ThreadContext context, IRubyObject src, IRubyObject repl)` rb_str_tr_s / rb_str_tr_s_bang
`IRubyObject`	`tr_s19(ThreadContext context, IRubyObject src, IRubyObject repl)`
`IRubyObject`	`tr(ThreadContext context, IRubyObject src, IRubyObject repl)` rb_str_tr / rb_str_tr_bang
`IRubyObject`	`tr19(ThreadContext context, IRubyObject src, IRubyObject repl)`
`private int`	`trCode(int c, int[] trans, org.jcodings.util.IntHash<java.lang.Integer> hash, boolean cflag, int last, boolean set)`
`private boolean`	`trFind(int c, boolean[] table, RubyString.TrTables tables)`
`private int`	`trNext(RubyString.TR t)` trnext
`private int`	`trNext(RubyString.TR t, Ruby runtime, org.jcodings.Encoding enc)`
`private void`	`trSetupTable(boolean[] table, boolean init)` tr_setup_table
`private RubyString.TrTables`	`trSetupTable(Ruby runtime, boolean[] table, RubyString.TrTables tables, boolean init, org.jcodings.Encoding enc)`
`private IRubyObject`	`trTrans(ThreadContext context, IRubyObject src, IRubyObject repl, boolean sflag)` tr_trans
`private IRubyObject`	`trTrans19(ThreadContext context, IRubyObject src, IRubyObject repl, boolean sflag)`
`static IRubyObject`	`try_convert(ThreadContext context, IRubyObject recv, IRubyObject str)`
`static RubyString`	`unmarshalFrom(UnmarshalStream input)`
`RubyArray`	`unpack(IRubyObject obj)`
`int`	`unseededStrHashCode(Ruby runtime)` Generate a hash for the String, without a seed.
`IRubyObject`	`upcase_bang(ThreadContext context)`
`IRubyObject`	`upcase_bang19(ThreadContext context)`
`RubyString`	`upcase(ThreadContext context)` rb_str_upcase / rb_str_upcase_bang
`RubyString`	`upcase19(ThreadContext context)`
`IRubyObject`	`upto18(ThreadContext context, IRubyObject end, Block block)` rb_str_upto_m
`IRubyObject`	`upto18(ThreadContext context, IRubyObject end, IRubyObject excl, Block block)`
`IRubyObject`	`upto19(ThreadContext context, IRubyObject end, Block block)`
`IRubyObject`	`upto19(ThreadContext context, IRubyObject end, IRubyObject excl, Block block)`
`(package private) IRubyObject`	`uptoCommon18(ThreadContext context, IRubyObject arg, boolean excl, Block block)`
`(package private) IRubyObject`	`uptoCommon19(ThreadContext context, IRubyObject arg, boolean excl, Block block)`
`(package private) IRubyObject`	`uptoCommon19(ThreadContext context, IRubyObject arg, boolean excl, Block block, boolean asSymbol)`
`private IRubyObject`	`uptoCommon19NoDigits(ThreadContext context, RubyString end, boolean excl, Block block, boolean asSymbol)`
`IRubyObject`	`valid_encoding_p(ThreadContext context)`
`private void`	`view(byte[] bytes)`
`void`	`view(org.jruby.util.ByteList bytes)`
`private void`	`view(int index, int len)`

Methods inherited from class org.jruby.RubyObject
attachToObjectSpace, callInit, callInit, callInit, callInit, callInit, callInit, callInit, callInit, callInit, callInit, convertToType, createObjectClass, eqlInternal, equalInternal, initialize, inspect, op_eqq, puts, specificEval

Methods inherited from class org.jruby.RubyBasicObject
addFinalizer, anyToString, callMethod, callMethod, callMethod, callMethod, callMethod, callMethod, callMethod, callMethod, callSuper, checkArrayType, checkCallMethod, checkFrozen, convertToArray, convertToFloat, convertToHash, convertToInteger, convertToInteger, convertToInteger, copyInstanceVariablesInto, copySpecialInstanceVariables, createBasicObjectClass, dataGetStruct, dataGetStructChecked, dataWrapStruct, display, ensureInstanceVariablesSettable, eql_p, equal_p, equal_p19, evalUnder, extend, fastGetInstanceVariable, fastGetInternalVariable, fastHasInstanceVariable, fastHasInternalVariable, fastSetInstanceVariable, fastSetInternalVariable, freeze, frozen_p, getFFIHandle, getFlag, getInstanceEvalClass, getInstanceVariable, getInstanceVariableList, getInstanceVariableNameList, getInstanceVariables, getInternalVariable, getInternalVariables, getMetaClass, getNativeHandle, getObjectId, getRuntime, getSingletonClass, getSingletonClassClone, getType, getVariable, getVariableCount, getVariableList, getVariableNameList, hashyInspect, hasInstanceVariable, hasInternalVariable, hasVariables, id_deprecated, id, infectBy, infectBy, infectBy, inspectHashCode, instance_eval, instance_eval, instance_eval, instance_eval, instance_eval19, instance_eval19, instance_eval19, instance_eval19, instance_exec, instance_exec19, instance_of_p, instance_variable_defined_p, instance_variable_get, instance_variable_set, instance_variables, instance_variables19, isBuiltin, isClass, isFalse, isFrozen, isImmediate, isModule, isNil, isTaint, isTrue, isUntrusted, kind_of_p, makeMetaClass, method_missing19, method, method19, methods, methods, methods19, nil_p, op_equal_19, op_not_equal, op_not_match, op_not, private_methods, private_methods19, protected_methods, protected_methods19, public_methods, public_methods19, rbClone, recacheBuiltinMethods, remove_instance_variable, removeFinalizers, removeInstanceVariable, removeInternalVariable, respond_to_p, respond_to_p, respond_to_p19, respond_to_p19, respondsTo, respondsToMissing, respondsToMissing, send, send, send, send, send, send19, send19, send19, send19, setFFIHandle, setFlag, setFrozen, setInstanceVariable, setInternalVariable, setMetaClass, setNativeHandle, setTaint, setUntrusted, setVariable, singleton_method_added19, singleton_method_removed19, singleton_method_undefined19, singleton_methods, singleton_methods19, specificEval, specificEval, specificEval, specificEval, syncVariables, syncVariables, taint, taint, tainted_p, testFrozen, testFrozen, to_a, trust, type_deprecated, type, untaint, untrust, untrusted_p, validateInstanceVariable, variableTableContains, variableTableFastContains, variableTableFastFetch, variableTableFastStore, variableTableFetch, variableTableRemove, variableTableStore, variableTableSync, yieldUnder, yieldUnder

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

Field Detail

ASCII

private static final org.jcodings.specific.ASCIIEncoding ASCII

UTF8

private static final org.jcodings.specific.UTF8Encoding UTF8

EMPTY_BYTE_ARRAY

private static final byte[] EMPTY_BYTE_ARRAY

SHARE_LEVEL_NONE
```
private static final int SHARE_LEVEL_NONE
```
See Also:

Constant Field Values

SHARE_LEVEL_BUFFER
```
private static final int SHARE_LEVEL_BUFFER
```
See Also:

Constant Field Values

SHARE_LEVEL_BYTELIST
```
private static final int SHARE_LEVEL_BYTELIST
```
See Also:

Constant Field Values

shareLevel
```
private volatile int shareLevel
```

value
```
private org.jruby.util.ByteList value
```

opTable19

private static final java.lang.String[][] opTable19

opTable18

private static final java.lang.String[][] opTable18

STRING_ALLOCATOR

private static ObjectAllocator STRING_ALLOCATOR

EMPTY_ASCII8BIT_BYTELIST

private static final org.jruby.util.ByteList EMPTY_ASCII8BIT_BYTELIST

EMPTY_USASCII_BYTELIST

private static final org.jruby.util.ByteList EMPTY_USASCII_BYTELIST

EMPTY_BYTELISTS

private static RubyString.EmptyByteListHolder[] EMPTY_BYTELISTS

SPACE_BYTELIST

private static final org.jruby.util.ByteList SPACE_BYTELIST

TRANS_SIZE
```
private static final int TRANS_SIZE
```
See Also:

Constant Field Values

Constructor Detail

RubyString

public RubyString(Ruby runtime,
                  RubyClass rubyClass)

RubyString

public RubyString(Ruby runtime,
                  RubyClass rubyClass,
                  java.lang.CharSequence value)

RubyString

public RubyString(Ruby runtime,
                  RubyClass rubyClass,
                  java.lang.CharSequence value,
                  org.jcodings.Encoding defaultEncoding)

RubyString

public RubyString(Ruby runtime,
                  RubyClass rubyClass,
                  byte[] value)

RubyString

public RubyString(Ruby runtime,
                  RubyClass rubyClass,
                  org.jruby.util.ByteList value)

RubyString

public RubyString(Ruby runtime,
                  RubyClass rubyClass,
                  org.jruby.util.ByteList value,
                  boolean objectSpace)

RubyString

public RubyString(Ruby runtime,
                  RubyClass rubyClass,
                  org.jruby.util.ByteList value,
                  org.jcodings.Encoding encoding,
                  boolean objectSpace)

RubyString

protected RubyString(Ruby runtime,
                     RubyClass rubyClass,
                     org.jruby.util.ByteList value,
                     org.jcodings.Encoding enc,
                     int cr)

RubyString

protected RubyString(Ruby runtime,
                     RubyClass rubyClass,
                     org.jruby.util.ByteList value,
                     org.jcodings.Encoding enc)

RubyString

protected RubyString(Ruby runtime,
                     RubyClass rubyClass,
                     org.jruby.util.ByteList value,
                     int cr)

Method Detail

createStringClass

public static RubyClass createStringClass(Ruby runtime)

getEncoding
```
public org.jcodings.Encoding getEncoding()
```
Specified by:

getEncoding in interface EncodingCapable

setEncoding
```
public void setEncoding(org.jcodings.Encoding encoding)
```
Specified by:

setEncoding in interface EncodingCapable

shouldMarshalEncoding
```
public boolean shouldMarshalEncoding()
```
Specified by:

shouldMarshalEncoding in interface MarshalEncoding

getMarshalEncoding
```
public org.jcodings.Encoding getMarshalEncoding()
```
Specified by:

getMarshalEncoding in interface MarshalEncoding

associateEncoding

public void associateEncoding(org.jcodings.Encoding enc)

setEncodingAndCodeRange

public final void setEncodingAndCodeRange(org.jcodings.Encoding enc,
                                          int cr)

toEncoding

public final org.jcodings.Encoding toEncoding(Ruby runtime)

getCodeRange
```
public final int getCodeRange()
```

setCodeRange

public final void setCodeRange(int codeRange)

clearCodeRange
```
public final void clearCodeRange()
```

keepCodeRange
```
private void keepCodeRange()
```

isCodeRangeAsciiOnly

public final boolean isCodeRangeAsciiOnly()

isAsciiOnly
```
public final boolean isAsciiOnly()
```

isCodeRangeValid

public final boolean isCodeRangeValid()

isCodeRangeBroken

public final boolean isCodeRangeBroken()

codeRangeAnd

static int codeRangeAnd(int cr1,
                        int cr2)

copyCodeRangeForSubstr

private void copyCodeRangeForSubstr(RubyString from,
                                    org.jcodings.Encoding enc)

copyCodeRange

private void copyCodeRange(RubyString from)

scanForCodeRange
```
public final int scanForCodeRange()
```

singleByteOptimizable
```
final boolean singleByteOptimizable()
```

singleByteOptimizable

final boolean singleByteOptimizable(org.jcodings.Encoding enc)

isCompatibleWith

private org.jcodings.Encoding isCompatibleWith(RubyString other)

isCompatibleWith

final org.jcodings.Encoding isCompatibleWith(EncodingCapable other)

checkEncoding

public final org.jcodings.Encoding checkEncoding(RubyString other)

checkEncoding

final org.jcodings.Encoding checkEncoding(EncodingCapable other)

checkDummyEncoding

private org.jcodings.Encoding checkDummyEncoding()

isComparableWith

private boolean isComparableWith(RubyString other)

isComparableViaCodeRangeWith

private boolean isComparableViaCodeRangeWith(RubyString other)

strLength

private int strLength(org.jcodings.Encoding enc)

strLength
```
public final int strLength()
```

strLength

private int strLength(org.jruby.util.ByteList bytes)

strLength

private int strLength(org.jruby.util.ByteList bytes,
                      org.jcodings.Encoding enc)

subLength
```
final int subLength(int pos)
```

eql
```
public final boolean eql(IRubyObject other)
```
short circuit for String key comparison

Specified by:

eql in interface IRubyObject

Overrides:

eql in class RubyBasicObject

eql18

private boolean eql18(Ruby runtime,
                      IRubyObject other)

eql19

private boolean eql19(Ruby runtime,
                      IRubyObject other)

newString
```
@Deprecated
public RubyString newString(java.lang.CharSequence s)
```
Deprecated.

Create a new String which uses the same Ruby runtime and the same class like this String. This method should be used to satisfy RCR #38.

newString
```
@Deprecated
public RubyString newString(org.jruby.util.ByteList s)
```
Deprecated.

Create a new String which uses the same Ruby runtime and the same class like this String. This method should be used to satisfy RCR #38.

newString

@Deprecated
public static RubyString newString(Ruby runtime,
                                               RubyClass clazz,
                                               java.lang.CharSequence str)

Deprecated.

newStringLight

public static RubyString newStringLight(Ruby runtime,
                                        org.jruby.util.ByteList bytes)

newStringLight

public static RubyString newStringLight(Ruby runtime,
                                        int size)

newStringLight

public static RubyString newStringLight(Ruby runtime,
                                        int size,
                                        org.jcodings.Encoding encoding)

newString

public static RubyString newString(Ruby runtime,
                                   java.lang.CharSequence str)

newString

public static RubyString newString(Ruby runtime,
                                   java.lang.String str)

newUSASCIIString

public static RubyString newUSASCIIString(Ruby runtime,
                                          java.lang.String str)

newString

public static RubyString newString(Ruby runtime,
                                   byte[] bytes)

newString

public static RubyString newString(Ruby runtime,
                                   byte[] bytes,
                                   int start,
                                   int length)

newString

public static RubyString newString(Ruby runtime,
                                   org.jruby.util.ByteList bytes)

newString

public static RubyString newString(Ruby runtime,
                                   org.jruby.util.ByteList bytes,
                                   org.jcodings.Encoding encoding)

newUnicodeString

public static RubyString newUnicodeString(Ruby runtime,
                                          java.lang.String str)

newUTF8String

public static RubyString newUTF8String(Ruby runtime,
                                       java.lang.String str)

newUTF16String

public static RubyString newUTF16String(Ruby runtime,
                                        java.lang.String str)

newUnicodeString

public static RubyString newUnicodeString(Ruby runtime,
                                          java.lang.CharSequence str)

newUTF8String

public static RubyString newUTF8String(Ruby runtime,
                                       java.lang.CharSequence str)

newUTF16String

public static RubyString newUTF16String(Ruby runtime,
                                        java.lang.CharSequence str)

newInternalFromJavaExternal
```
public static RubyString newInternalFromJavaExternal(Ruby runtime,
                                                     java.lang.String str)
```
Return a new Ruby String encoded as the default internal encoding given a Java String that has come from an external source. If there is no default internal encoding set, the Ruby String will be encoded using Java's default external encoding. If an internal encoding is set, that encoding will be used for the Ruby String.

Parameters:

runtime -

str -

Returns:

newStringShared

public static RubyString newStringShared(Ruby runtime,
                                         RubyString orig)

newStringShared

public static RubyString newStringShared(Ruby runtime,
                                         org.jruby.util.ByteList bytes)

newStringShared

public static RubyString newStringShared(Ruby runtime,
                                         org.jruby.util.ByteList bytes,
                                         org.jcodings.Encoding encoding)

newStringShared

public static RubyString newStringShared(Ruby runtime,
                                         org.jruby.util.ByteList bytes,
                                         int codeRange)

newStringShared

public static RubyString newStringShared(Ruby runtime,
                                         RubyClass clazz,
                                         org.jruby.util.ByteList bytes)

newStringShared

public static RubyString newStringShared(Ruby runtime,
                                         RubyClass clazz,
                                         org.jruby.util.ByteList bytes,
                                         org.jcodings.Encoding encoding)

newStringShared

public static RubyString newStringShared(Ruby runtime,
                                         byte[] bytes)

newStringShared

public static RubyString newStringShared(Ruby runtime,
                                         byte[] bytes,
                                         org.jcodings.Encoding encoding)

newStringShared

public static RubyString newStringShared(Ruby runtime,
                                         byte[] bytes,
                                         int start,
                                         int length)

newStringShared

public static RubyString newStringShared(Ruby runtime,
                                         byte[] bytes,
                                         int start,
                                         int length,
                                         org.jcodings.Encoding encoding)

newEmptyString

public static RubyString newEmptyString(Ruby runtime)

newAllocatedString

public static RubyString newAllocatedString(Ruby runtime,
                                            RubyClass metaClass)

newEmptyString

public static RubyString newEmptyString(Ruby runtime,
                                        RubyClass metaClass)

newStringNoCopy

public static RubyString newStringNoCopy(Ruby runtime,
                                         org.jruby.util.ByteList bytes)

newStringNoCopy

public static RubyString newStringNoCopy(Ruby runtime,
                                         RubyClass clazz,
                                         org.jruby.util.ByteList bytes)

newStringNoCopy

public static RubyString newStringNoCopy(Ruby runtime,
                                         byte[] bytes,
                                         int start,
                                         int length)

newStringNoCopy

public static RubyString newStringNoCopy(Ruby runtime,
                                         byte[] bytes)

independent
```
public boolean independent()
```

makeIndependent
```
public RubyString makeIndependent()
```

getEmptyByteList

static RubyString.EmptyByteListHolder getEmptyByteList(org.jcodings.Encoding enc)

prepareEmptyByteList

private static RubyString.EmptyByteListHolder prepareEmptyByteList(org.jcodings.Encoding enc)

newEmptyString

public static RubyString newEmptyString(Ruby runtime,
                                        RubyClass metaClass,
                                        org.jcodings.Encoding enc)

newEmptyString

public static RubyString newEmptyString(Ruby runtime,
                                        org.jcodings.Encoding enc)

newStringNoCopy

public static RubyString newStringNoCopy(Ruby runtime,
                                         RubyClass clazz,
                                         org.jruby.util.ByteList bytes,
                                         org.jcodings.Encoding enc,
                                         int cr)

newStringNoCopy

public static RubyString newStringNoCopy(Ruby runtime,
                                         org.jruby.util.ByteList bytes,
                                         org.jcodings.Encoding enc,
                                         int cr)

newUsAsciiStringNoCopy

public static RubyString newUsAsciiStringNoCopy(Ruby runtime,
                                                org.jruby.util.ByteList bytes)

newUsAsciiStringShared

public static RubyString newUsAsciiStringShared(Ruby runtime,
                                                org.jruby.util.ByteList bytes)

newUsAsciiStringShared

public static RubyString newUsAsciiStringShared(Ruby runtime,
                                                byte[] bytes,
                                                int start,
                                                int length)

getNativeTypeIndex
```
public int getNativeTypeIndex()
```
Description copied from class: RubyObject

This is overridden in the other concrete Java builtins to provide a fast way to determine what type they are. Will generally return a value from org.jruby.runtime.ClassIndex

Specified by:

getNativeTypeIndex in interface CoreObjectType

Overrides:

getNativeTypeIndex in class RubyObject

Returns:

the ClassIndex of the native type this object was constructed from

See Also:

ClassIndex

getJavaClass
```
public java.lang.Class getJavaClass()
```
Description copied from class: RubyBasicObject

Will return the Java interface that most closely can represent this object, when working through JAva integration translations.

Specified by:

getJavaClass in interface IRubyObject

Overrides:

getJavaClass in class RubyBasicObject

Returns:

Class

convertToString
```
public RubyString convertToString()
```
Description copied from class: RubyBasicObject

Tries to convert this object to a Ruby String using the "to_str" method.

Specified by:

convertToString in interface IRubyObject

Overrides:

convertToString in class RubyBasicObject

Returns:

toString
```
public java.lang.String toString()
```
Description copied from class: RubyObject

The default toString method is just a wrapper that calls the Ruby "to_s" method.

Overrides:

toString in class RubyObject

decodeString
```
public java.lang.String decodeString()
```
Convert this Ruby string to a Java String. This version is encoding-aware.

Returns:

A decoded Java String, based on this Ruby string's encoding.

dup
```
public IRubyObject dup()
```
Overridden dup for fast-path logic.

Specified by:

dup in interface IRubyObject

Overrides:

dup in class RubyBasicObject

Returns:

A new RubyString sharing the original backing store.

strDup

@Deprecated
public final RubyString strDup()

Deprecated.

rb_str_dup

strDup

public final RubyString strDup(Ruby runtime)

strDup

@Deprecated
final RubyString strDup(RubyClass clazz)

Deprecated.

strDup

final RubyString strDup(Ruby runtime,
                        RubyClass clazz)

makeSharedString

public final RubyString makeSharedString(Ruby runtime,
                                         int index,
                                         int len)

makeSharedString19

public RubyString makeSharedString19(Ruby runtime,
                                     int index,
                                     int len)

makeShared

public final RubyString makeShared(Ruby runtime,
                                   int index,
                                   int len)

makeShared

public final RubyString makeShared(Ruby runtime,
                                   RubyClass meta,
                                   int index,
                                   int len)

makeShared19

public final RubyString makeShared19(Ruby runtime,
                                     int index,
                                     int len)

makeShared19

public final RubyString makeShared19(Ruby runtime,
                                     RubyClass meta,
                                     int index,
                                     int len)

makeShared19

private RubyString makeShared19(Ruby runtime,
                                org.jruby.util.ByteList value,
                                int index,
                                int len)

makeShared19

private RubyString makeShared19(Ruby runtime,
                                RubyClass meta,
                                org.jruby.util.ByteList value,
                                int index,
                                int len)

setByteListShared
```
public final void setByteListShared()
```

modifyCheck
```
public final void modifyCheck()
```
Check that the string can be modified, raising error otherwise. If you plan to modify a string with shared backing store, this method is not sufficient; you will need to call modify() instead.

modifyCheck

private void modifyCheck(byte[] b,
                         int len)

modifyCheck

private void modifyCheck(byte[] b,
                         int len,
                         org.jcodings.Encoding enc)

frozenCheck
```
private void frozenCheck()
```

frozenCheck

private void frozenCheck(boolean runtimeError)

modify
```
public final void modify()
```
rb_str_modify

modify19
```
public final void modify19()
```

modifyAndKeepCodeRange
```
private void modifyAndKeepCodeRange()
```

modify
```
public final void modify(int length)
```
rb_str_modify (with length bytes ensured)

modify19

public final void modify19(int length)

resize
```
public final void resize(int length)
```
rb_str_resize

view

public final void view(org.jruby.util.ByteList bytes)

view
```
private void view(byte[] bytes)
```

view

private void view(int index,
                  int len)

bytesToString

public static java.lang.String bytesToString(byte[] bytes,
                                             int beg,
                                             int len)

byteListToString

public static java.lang.String byteListToString(org.jruby.util.ByteList bytes)

bytesToString

public static java.lang.String bytesToString(byte[] bytes)

stringToBytes

public static byte[] stringToBytes(java.lang.String string)

asString
```
public RubyString asString()
```
Description copied from class: RubyBasicObject

rb_obj_as_string First converts this object into a String using the "to_s" method, infects it with the current taint and returns it. If to_s doesn't return a Ruby String, RubyBasicObject.anyToString() is used instead.

Specified by:

asString in interface IRubyObject

Overrides:

asString in class RubyBasicObject

Returns:

checkStringType
```
public IRubyObject checkStringType()
```
Description copied from class: RubyBasicObject

rb_check_string_type Tries to return a coerced string representation of this object, using "to_str". If that returns something other than a String or nil, an empty String will be returned.

Specified by:

checkStringType in interface IRubyObject

Overrides:

checkStringType in class RubyBasicObject

Returns:

checkStringType19
```
public IRubyObject checkStringType19()
```
Description copied from class: RubyBasicObject

rb_check_string_type Tries to return a coerced string representation of this object, using "to_str". If that returns something other than a String or nil, an empty String will be returned.

Specified by:

checkStringType19 in interface IRubyObject

Overrides:

checkStringType19 in class RubyBasicObject

Returns:

try_convert

public static IRubyObject try_convert(ThreadContext context,
                                      IRubyObject recv,
                                      IRubyObject str)

to_s
```
public IRubyObject to_s()
```
Description copied from class: RubyBasicObject

rb_any_to_s call-seq: obj.to_s => string Returns a string representing obj. The default to_s prints the object's class and an encoding of the object id. As a special case, the top-level object that is the initial execution context of Ruby programs returns ``main.''

Overrides:

to_s in class RubyBasicObject

compareTo
```
public final int compareTo(IRubyObject other)
```
Description copied from class: RubyBasicObject

Compares this Ruby object with another.

Specified by:

compareTo in interface java.lang.Comparable<IRubyObject>

Overrides:

compareTo in class RubyBasicObject

Parameters:

other - another IRubyObject

Returns:

0 if equal, < 0 if this is less than other, > 0 if this is greater than other

op_cmp

public IRubyObject op_cmp(ThreadContext context,
                          IRubyObject other)

Overrides:: op_cmp in class RubyBasicObject

op_cmp19

public IRubyObject op_cmp19(ThreadContext context,
                            IRubyObject other)

op_cmpCommon

private IRubyObject op_cmpCommon(ThreadContext context,
                                 IRubyObject other)

op_equal

public IRubyObject op_equal(ThreadContext context,
                            IRubyObject other)

rb_str_equal

Specified by:: op_equal in interface IRubyObject
Overrides:: op_equal in class RubyBasicObject

op_equal19

public IRubyObject op_equal19(ThreadContext context,
                              IRubyObject other)

op_equalCommon

private IRubyObject op_equalCommon(ThreadContext context,
                                   IRubyObject other)

op_plus

public IRubyObject op_plus(ThreadContext context,
                           IRubyObject _str)

op_plus19

public IRubyObject op_plus19(ThreadContext context,
                             IRubyObject _str)

addByteLists

private org.jruby.util.ByteList addByteLists(org.jruby.util.ByteList value1,
                                             org.jruby.util.ByteList value2)

op_mul

public IRubyObject op_mul(ThreadContext context,
                          IRubyObject other)

op_mul19

public IRubyObject op_mul19(ThreadContext context,
                            IRubyObject other)

multiplyByteList

private RubyString multiplyByteList(ThreadContext context,
                                    IRubyObject arg)

op_format

public IRubyObject op_format(ThreadContext context,
                             IRubyObject arg)

opFormatCommon

private IRubyObject opFormatCommon(ThreadContext context,
                                   IRubyObject arg,
                                   CompatVersion compat)

hash
```
public RubyFixnum hash()
```
Description copied from class: RubyBasicObject

rb_obj_id Will return the hash code of this object. In comparison to MRI, this method will use the Java identity hash code instead of using rb_obj_id, since the usage of id in JRuby will incur the cost of some. ObjectSpace maintenance.

Overrides:

hash in class RubyBasicObject

hashCode
```
public int hashCode()
```
Description copied from class: RubyObject

Override the Object#hashCode method to make sure that the Ruby hash is actually used as the hashcode for Ruby objects. If the Ruby "hash" method doesn't return a number, the Object#hashCode implementation will be used instead.

Overrides:

hashCode in class RubyObject

strHashCode
```
public int strHashCode(Ruby runtime)
```
Generate a hash for the String, using its associated Ruby instance's hash seed.

Parameters:

runtime -

Returns:

unseededStrHashCode
```
public int unseededStrHashCode(Ruby runtime)
```
Generate a hash for the String, without a seed.

Parameters:

runtime -

Returns:

equals
```
public boolean equals(java.lang.Object other)
```
Description copied from class: RubyObject

This method is just a wrapper around the Ruby "==" method, provided so that RubyObjects can be used as keys in the Java HashMap object underlying RubyHash.

Overrides:

equals in class RubyObject

objAsString

public static RubyString objAsString(ThreadContext context,
                                     IRubyObject obj)

rb_obj_as_string

op_cmp

public final int op_cmp(RubyString other)

rb_str_cmp

op_cmp19

public final int op_cmp19(RubyString other)

asJavaString
```
public java.lang.String asJavaString()
```
rb_to_id

Specified by:

asJavaString in interface IRubyObject

Overrides:

asJavaString in class RubyBasicObject

Returns:

String the symbol name

doClone
```
public IRubyObject doClone()
```

cat

public final RubyString cat(byte[] str)

cat

public final RubyString cat(byte[] str,
                            int beg,
                            int len)

cat19

public final RubyString cat19(RubyString str2)

cat19

public final int cat19(org.jruby.util.ByteList other,
                       int codeRange)

cat

public final RubyString cat(RubyString str)

cat

public final RubyString cat(org.jruby.util.ByteList str)

cat
```
public final RubyString cat(byte ch)
```

cat
```
public final RubyString cat(int ch)
```

cat

public final RubyString cat(int code,
                            org.jcodings.Encoding enc)

cat

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

catAscii

public final RubyString catAscii(byte[] bytes,
                                 int p,
                                 int len)

replace

public IRubyObject replace(IRubyObject other)

rb_str_replace_m

replace19

public RubyString replace19(IRubyObject other)

initialize_copy
```
public IRubyObject initialize_copy(IRubyObject other)
```
Description copied from class: RubyBasicObject

rb_obj_init_copy Initializes this object as a copy of the original, that is the parameter to this object. Will make sure that the argument actually has the same real class as this object. It shouldn't be possible to initialize an object with something totally different.

Overrides:

initialize_copy in class RubyBasicObject

initialize_copy19

public RubyString initialize_copy19(IRubyObject other)

replaceCommon

private RubyString replaceCommon(IRubyObject other)

clear
```
public RubyString clear()
```

reverse

public IRubyObject reverse(ThreadContext context)

reverse19

public IRubyObject reverse19(ThreadContext context)

reverse_bang

public RubyString reverse_bang(ThreadContext context)

reverse_bang19

public RubyString reverse_bang19(ThreadContext context)

newInstance

public static RubyString newInstance(IRubyObject recv,
                                     IRubyObject[] args,
                                     Block block)

rb_str_s_new

initialize

public IRubyObject initialize(ThreadContext context)

Overrides:: initialize in class RubyObject

initialize

public IRubyObject initialize(ThreadContext context,
                              IRubyObject arg0)

initialize19

public IRubyObject initialize19(ThreadContext context)

Overrides:: initialize19 in class RubyBasicObject

initialize19

public IRubyObject initialize19(ThreadContext context,
                                IRubyObject arg0)

casecmp

public IRubyObject casecmp(ThreadContext context,
                           IRubyObject other)

casecmp19

public IRubyObject casecmp19(ThreadContext context,
                             IRubyObject other)

multiByteCasecmp

private IRubyObject multiByteCasecmp(Ruby runtime,
                                     org.jcodings.Encoding enc,
                                     org.jruby.util.ByteList value,
                                     org.jruby.util.ByteList otherValue)

op_match

public IRubyObject op_match(ThreadContext context,
                            IRubyObject other)

rb_str_match

Overrides:: op_match in class RubyBasicObject

op_match19

public IRubyObject op_match19(ThreadContext context,
                              IRubyObject other)

Overrides:: op_match19 in class RubyBasicObject

match

public IRubyObject match(ThreadContext context,
                         IRubyObject pattern)

String#match(pattern) rb_str_match_m

Parameters:: pattern - Regexp or String

match19

public IRubyObject match19(ThreadContext context,
                           IRubyObject pattern,
                           Block block)

match19

public IRubyObject match19(ThreadContext context,
                           IRubyObject[] args,
                           Block block)

capitalize

public IRubyObject capitalize(ThreadContext context)

rb_str_capitalize / rb_str_capitalize_bang

capitalize_bang

public IRubyObject capitalize_bang(ThreadContext context)

capitalize19

public IRubyObject capitalize19(ThreadContext context)

capitalize_bang19

public IRubyObject capitalize_bang19(ThreadContext context)

op_ge

public IRubyObject op_ge(ThreadContext context,
                         IRubyObject other)

op_ge19

public IRubyObject op_ge19(ThreadContext context,
                           IRubyObject other)

op_gt

public IRubyObject op_gt(ThreadContext context,
                         IRubyObject other)

op_gt19

public IRubyObject op_gt19(ThreadContext context,
                           IRubyObject other)

op_le

public IRubyObject op_le(ThreadContext context,
                         IRubyObject other)

op_le19

public IRubyObject op_le19(ThreadContext context,
                           IRubyObject other)

op_lt

public IRubyObject op_lt(ThreadContext context,
                         IRubyObject other)

op_lt19

public IRubyObject op_lt19(ThreadContext context,
                           IRubyObject other)

str_eql_p

public IRubyObject str_eql_p(ThreadContext context,
                             IRubyObject other)

str_eql_p19

public IRubyObject str_eql_p19(ThreadContext context,
                               IRubyObject other)

upcase

public RubyString upcase(ThreadContext context)

rb_str_upcase / rb_str_upcase_bang

upcase_bang

public IRubyObject upcase_bang(ThreadContext context)

upcase19

public RubyString upcase19(ThreadContext context)

upcase_bang19

public IRubyObject upcase_bang19(ThreadContext context)

singleByteUpcase

private IRubyObject singleByteUpcase(Ruby runtime,
                                     byte[] bytes,
                                     int s,
                                     int end)

multiByteUpcase

private IRubyObject multiByteUpcase(Ruby runtime,
                                    org.jcodings.Encoding enc,
                                    byte[] bytes,
                                    int s,
                                    int end)

downcase

public RubyString downcase(ThreadContext context)

rb_str_downcase / rb_str_downcase_bang

downcase_bang

public IRubyObject downcase_bang(ThreadContext context)

downcase19

public RubyString downcase19(ThreadContext context)

downcase_bang19

public IRubyObject downcase_bang19(ThreadContext context)

singleByteDowncase

private IRubyObject singleByteDowncase(Ruby runtime,
                                       byte[] bytes,
                                       int s,
                                       int end)

multiByteDowncase

private IRubyObject multiByteDowncase(Ruby runtime,
                                      org.jcodings.Encoding enc,
                                      byte[] bytes,
                                      int s,
                                      int end)

swapcase

public RubyString swapcase(ThreadContext context)

rb_str_swapcase / rb_str_swapcase_bang

swapcase_bang

public IRubyObject swapcase_bang(ThreadContext context)

swapcase19

public RubyString swapcase19(ThreadContext context)

swapcase_bang19

public IRubyObject swapcase_bang19(ThreadContext context)

singleByteSwapcase

private IRubyObject singleByteSwapcase(Ruby runtime,
                                       byte[] bytes,
                                       int s,
                                       int end)

multiByteSwapcase

private IRubyObject multiByteSwapcase(Ruby runtime,
                                      org.jcodings.Encoding enc,
                                      byte[] bytes,
                                      int s,
                                      int end)

dump
```
public IRubyObject dump()
```
rb_str_dump

dump19
```
public IRubyObject dump19()
```

dumpCommon

private IRubyObject dumpCommon(boolean is1_9)

insert

public IRubyObject insert(ThreadContext context,
                          IRubyObject indexArg,
                          IRubyObject stringArg)

insert19

public IRubyObject insert19(ThreadContext context,
                            IRubyObject indexArg,
                            IRubyObject stringArg)

checkIndex

private int checkIndex(int beg,
                       int len)

checkIndexForRef

private int checkIndexForRef(int beg,
                             int len)

checkLength
```
private int checkLength(int len)
```

raiseIndexOutOfString

private void raiseIndexOutOfString(int index)

prefixEscapeCat
```
private void prefixEscapeCat(int c)
```

isEVStr

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

isEVStr
```
public boolean isEVStr(int c)
```

inspect
```
public IRubyObject inspect()
```
rb_str_inspect

Specified by:

inspect in interface IRubyObject

Overrides:

inspect in class RubyBasicObject

Returns:

String

inspect19
```
public IRubyObject inspect19()
```

size
```
public int size()
```

length
```
public RubyFixnum length()
```
rb_str_length

length19
```
public RubyFixnum length19()
```

bytesize
```
public RubyFixnum bytesize()
```

empty_p

public RubyBoolean empty_p(ThreadContext context)

rb_str_empty

isEmpty
```
public boolean isEmpty()
```

append

public RubyString append(IRubyObject other)

rb_str_append

append19

public RubyString append19(IRubyObject other)

concat

public RubyString concat(IRubyObject other)

rb_str_concat

concat19

public RubyString concat19(ThreadContext context,
                           IRubyObject other)

concatNumeric

private RubyString concatNumeric(Ruby runtime,
                                 int c)

prepend

public IRubyObject prepend(ThreadContext context,
                           IRubyObject other)

rb_str_prepend

crypt

public RubyString crypt(ThreadContext context,
                        IRubyObject other)

rb_str_crypt

stringValue

public static RubyString stringValue(IRubyObject object)

sub

public IRubyObject sub(ThreadContext context,
                       IRubyObject arg0,
                       Block block)

rb_str_sub / rb_str_sub_bang

sub

public IRubyObject sub(ThreadContext context,
                       IRubyObject arg0,
                       IRubyObject arg1,
                       Block block)

sub_bang

public IRubyObject sub_bang(ThreadContext context,
                            IRubyObject arg0,
                            Block block)

sub_bang

public IRubyObject sub_bang(ThreadContext context,
                            IRubyObject arg0,
                            IRubyObject arg1,
                            Block block)

subBangIter

private IRubyObject subBangIter(ThreadContext context,
                                org.joni.Regex pattern,
                                Block block)

subBangNoIter

private IRubyObject subBangNoIter(ThreadContext context,
                                  org.joni.Regex pattern,
                                  RubyString repl)

subBangCommon

private IRubyObject subBangCommon(ThreadContext context,
                                  org.joni.Regex pattern,
                                  org.joni.Matcher matcher,
                                  RubyString repl,
                                  int tuFlags)

sub19

public IRubyObject sub19(ThreadContext context,
                         IRubyObject arg0,
                         Block block)

sub19

public IRubyObject sub19(ThreadContext context,
                         IRubyObject arg0,
                         IRubyObject arg1,
                         Block block)

sub_bang19

public IRubyObject sub_bang19(ThreadContext context,
                              IRubyObject arg0,
                              Block block)

sub_bang19

public IRubyObject sub_bang19(ThreadContext context,
                              IRubyObject arg0,
                              IRubyObject arg1,
                              Block block)

subBangIter19

private IRubyObject subBangIter19(Ruby runtime,
                                  ThreadContext context,
                                  org.joni.Regex pattern,
                                  org.joni.Regex prepared,
                                  RubyHash hash,
                                  Block block,
                                  RubyRegexp regexp)

subBangNoIter19

private IRubyObject subBangNoIter19(Ruby runtime,
                                    ThreadContext context,
                                    org.joni.Regex pattern,
                                    org.joni.Regex prepared,
                                    RubyString repl,
                                    RubyRegexp regexp)

subBangCommon19

private IRubyObject subBangCommon19(ThreadContext context,
                                    org.joni.Regex pattern,
                                    org.joni.Matcher matcher,
                                    RubyString repl,
                                    int tuFlags)

subBangVerifyEncoding

private org.jcodings.Encoding subBangVerifyEncoding(ThreadContext context,
                                                    RubyString repl,
                                                    int beg,
                                                    int end)

gsub

public IRubyObject gsub(ThreadContext context,
                        IRubyObject arg0,
                        Block block)

rb_str_gsub / rb_str_gsub_bang

gsub

public IRubyObject gsub(ThreadContext context,
                        IRubyObject arg0,
                        IRubyObject arg1,
                        Block block)

gsub_bang

public IRubyObject gsub_bang(ThreadContext context,
                             IRubyObject arg0,
                             Block block)

gsub_bang

public IRubyObject gsub_bang(ThreadContext context,
                             IRubyObject arg0,
                             IRubyObject arg1,
                             Block block)

gsub

private IRubyObject gsub(ThreadContext context,
                         IRubyObject arg0,
                         Block block,
                         boolean bang)

gsub

private IRubyObject gsub(ThreadContext context,
                         IRubyObject arg0,
                         IRubyObject arg1,
                         Block block,
                         boolean bang)

gsubCommon

private IRubyObject gsubCommon(ThreadContext context,
                               boolean bang,
                               IRubyObject arg,
                               Block block,
                               RubyString repl,
                               int tuFlags)

gsub19

public IRubyObject gsub19(ThreadContext context,
                          IRubyObject arg0,
                          Block block)

gsub19

public IRubyObject gsub19(ThreadContext context,
                          IRubyObject arg0,
                          IRubyObject arg1,
                          Block block)

gsub_bang19

public IRubyObject gsub_bang19(ThreadContext context,
                               IRubyObject arg0,
                               Block block)

gsub_bang19

public IRubyObject gsub_bang19(ThreadContext context,
                               IRubyObject arg0,
                               IRubyObject arg1,
                               Block block)

gsub19

private IRubyObject gsub19(ThreadContext context,
                           IRubyObject arg0,
                           IRubyObject arg1,
                           Block block,
                           boolean bang)

gsubCommon19

private IRubyObject gsubCommon19(ThreadContext context,
                                 Block block,
                                 RubyString repl,
                                 RubyHash hash,
                                 IRubyObject arg0,
                                 boolean bang,
                                 int tuFlags)

gsubCommon19

private IRubyObject gsubCommon19(ThreadContext context,
                                 Block block,
                                 RubyString repl,
                                 RubyHash hash,
                                 IRubyObject arg0,
                                 boolean bang,
                                 int tuFlags,
                                 boolean useBackref)

index

public IRubyObject index(ThreadContext context,
                         IRubyObject arg0)

rb_str_index_m

index

public IRubyObject index(ThreadContext context,
                         IRubyObject arg0,
                         IRubyObject arg1)

indexCommon

private IRubyObject indexCommon(Ruby runtime,
                                ThreadContext context,
                                IRubyObject sub,
                                int pos)

strIndex

private int strIndex(RubyString sub,
                     int offset)

sizeIsSmaller

private static boolean sizeIsSmaller(org.jruby.util.ByteList byteList,
                                     int offset,
                                     org.jruby.util.ByteList other)

index19

public IRubyObject index19(ThreadContext context,
                           IRubyObject arg0)

index19

public IRubyObject index19(ThreadContext context,
                           IRubyObject arg0,
                           IRubyObject arg1)

indexCommon19

private IRubyObject indexCommon19(Ruby runtime,
                                  ThreadContext context,
                                  IRubyObject sub,
                                  int pos)

strIndex19

private int strIndex19(RubyString sub,
                       int offset)

rindex

public IRubyObject rindex(ThreadContext context,
                          IRubyObject arg0)

rb_str_rindex_m

rindex

public IRubyObject rindex(ThreadContext context,
                          IRubyObject arg0,
                          IRubyObject arg1)

rindexCommon

private IRubyObject rindexCommon(Ruby runtime,
                                 ThreadContext context,
                                 IRubyObject sub,
                                 int pos)

strRindex

private int strRindex(RubyString sub,
                      int pos)

rindex19

public IRubyObject rindex19(ThreadContext context,
                            IRubyObject arg0)

rindex19

public IRubyObject rindex19(ThreadContext context,
                            IRubyObject arg0,
                            IRubyObject arg1)

rindexCommon19

private IRubyObject rindexCommon19(Ruby runtime,
                                   ThreadContext context,
                                   IRubyObject sub,
                                   int pos)

strRindex19

private int strRindex19(RubyString sub,
                        int pos)

substr

@Deprecated
public final IRubyObject substr(int beg,
                                            int len)

Deprecated.

substr

public final IRubyObject substr(Ruby runtime,
                                int beg,
                                int len)

byteSubstr

private IRubyObject byteSubstr(Ruby runtime,
                               int beg,
                               int len)

byteARef

private IRubyObject byteARef(Ruby runtime,
                             IRubyObject idx)

substr19

public final IRubyObject substr19(Ruby runtime,
                                  int beg,
                                  int len)

multibyteSubstr19

private IRubyObject multibyteSubstr19(Ruby runtime,
                                      org.jcodings.Encoding enc,
                                      int len,
                                      int beg,
                                      int length)

replaceInternal

private IRubyObject replaceInternal(int beg,
                                    int len,
                                    RubyString repl)

replaceInternal19

private void replaceInternal19(int beg,
                               int len,
                               RubyString repl)

op_aref

public IRubyObject op_aref(ThreadContext context,
                           IRubyObject arg1,
                           IRubyObject arg2)

rb_str_aref, rb_str_aref_m

op_aref

public IRubyObject op_aref(ThreadContext context,
                           IRubyObject arg)

op_aref

private IRubyObject op_aref(Ruby runtime,
                            int idx)

op_aref19

public IRubyObject op_aref19(ThreadContext context,
                             IRubyObject arg1,
                             IRubyObject arg2)

op_aref19

public IRubyObject op_aref19(ThreadContext context,
                             IRubyObject arg)

byteslice

public IRubyObject byteslice(ThreadContext context,
                             IRubyObject arg1,
                             IRubyObject arg2)

byteslice

public IRubyObject byteslice(ThreadContext context,
                             IRubyObject arg)

op_aref19

private IRubyObject op_aref19(Ruby runtime,
                              int idx)

subpatSet

private void subpatSet(ThreadContext context,
                       RubyRegexp regexp,
                       int nth,
                       IRubyObject repl)

rb_str_subpat_set

subpatSetCheck

private int subpatSetCheck(Ruby runtime,
                           int nth,
                           org.joni.Region regs)

subpat

private IRubyObject subpat(Ruby runtime,
                           ThreadContext context,
                           RubyRegexp regex,
                           int nth)

subpatSet19

private void subpatSet19(ThreadContext context,
                         RubyRegexp regexp,
                         IRubyObject backref,
                         IRubyObject repl)

subpat19

private IRubyObject subpat19(Ruby runtime,
                             ThreadContext context,
                             RubyRegexp regex,
                             IRubyObject backref)

subpat19

private IRubyObject subpat19(Ruby runtime,
                             ThreadContext context,
                             RubyRegexp regex)

op_aset

public IRubyObject op_aset(ThreadContext context,
                           IRubyObject arg0,
                           IRubyObject arg1)

rb_str_aset, rb_str_aset_m

op_aset

private IRubyObject op_aset(ThreadContext context,
                            int idx,
                            IRubyObject arg1)

op_aset

public IRubyObject op_aset(ThreadContext context,
                           IRubyObject arg0,
                           IRubyObject arg1,
                           IRubyObject arg2)

op_aset19

public IRubyObject op_aset19(ThreadContext context,
                             IRubyObject arg0,
                             IRubyObject arg1)

op_aset19

private IRubyObject op_aset19(ThreadContext context,
                              int idx,
                              IRubyObject arg1)

op_aset19

public IRubyObject op_aset19(ThreadContext context,
                             IRubyObject arg0,
                             IRubyObject arg1,
                             IRubyObject arg2)

isHeadSlice

private boolean isHeadSlice(int beg,
                            int len)

isTailSlice

private boolean isTailSlice(int beg,
                            int len)

exciseHead
```
private void exciseHead(int len)
```
Excises (removes) a slice of the string that starts at index zero

Parameters:

len - The number of bytes to remove.

exciseTail
```
private void exciseTail(int len)
```
Excises (removes) a slice of the string that ends at the last byte in the string

Parameters:

len - The number of bytes to remove.

slice_bang

public IRubyObject slice_bang(ThreadContext context,
                              IRubyObject arg0)

rb_str_slice_bang

slice_bang

public IRubyObject slice_bang(ThreadContext context,
                              IRubyObject arg0,
                              IRubyObject arg1)

slice_bang19

public IRubyObject slice_bang19(ThreadContext context,
                                IRubyObject arg0)

slice_bang19

public IRubyObject slice_bang19(ThreadContext context,
                                IRubyObject arg0,
                                IRubyObject arg1)

succ

public IRubyObject succ(ThreadContext context)

succ_bang
```
public IRubyObject succ_bang()
```

succChar

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

predChar

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

succAlnumChar

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

succ19

public IRubyObject succ19(ThreadContext context)

succ_bang19
```
public IRubyObject succ_bang19()
```

succCommon19

private org.jruby.util.ByteList succCommon19(org.jruby.util.ByteList original)

upto18

public IRubyObject upto18(ThreadContext context,
                          IRubyObject end,
                          Block block)

rb_str_upto_m

upto18

public IRubyObject upto18(ThreadContext context,
                          IRubyObject end,
                          IRubyObject excl,
                          Block block)

uptoCommon18

final IRubyObject uptoCommon18(ThreadContext context,
                               IRubyObject arg,
                               boolean excl,
                               Block block)

upto19

public IRubyObject upto19(ThreadContext context,
                          IRubyObject end,
                          Block block)

upto19

public IRubyObject upto19(ThreadContext context,
                          IRubyObject end,
                          IRubyObject excl,
                          Block block)

uptoCommon19

final IRubyObject uptoCommon19(ThreadContext context,
                               IRubyObject arg,
                               boolean excl,
                               Block block)

uptoCommon19

final IRubyObject uptoCommon19(ThreadContext context,
                               IRubyObject arg,
                               boolean excl,
                               Block block,
                               boolean asSymbol)

uptoCommon19NoDigits

private IRubyObject uptoCommon19NoDigits(ThreadContext context,
                                         RubyString end,
                                         boolean excl,
                                         Block block,
                                         boolean asSymbol)

include_p

public RubyBoolean include_p(ThreadContext context,
                             IRubyObject obj)

rb_str_include

include_p19

public RubyBoolean include_p19(ThreadContext context,
                               IRubyObject obj)

chr

public IRubyObject chr(ThreadContext context)

getbyte

public IRubyObject getbyte(ThreadContext context,
                           IRubyObject index)

setbyte

public IRubyObject setbyte(ThreadContext context,
                           IRubyObject index,
                           IRubyObject val)

to_i
```
public IRubyObject to_i()
```
rb_str_to_i

to_i

public IRubyObject to_i(IRubyObject arg0)

rb_str_to_i

to_i19
```
public IRubyObject to_i19()
```

to_i19

public IRubyObject to_i19(IRubyObject arg0)

checkBase

private long checkBase(IRubyObject arg0)

stringToInum

public IRubyObject stringToInum(int base,
                                boolean badcheck)

rb_str_to_inum

stringToInum19

public IRubyObject stringToInum19(int base,
                                  boolean badcheck)

oct

public IRubyObject oct(ThreadContext context)

rb_str_oct

oct19

public IRubyObject oct19(ThreadContext context)

hex

public IRubyObject hex(ThreadContext context)

rb_str_hex

hex19

public IRubyObject hex19(ThreadContext context)

to_f
```
public IRubyObject to_f()
```
rb_str_to_f

to_f19
```
public IRubyObject to_f19()
```

split

public RubyArray split(ThreadContext context)

rb_str_split_m

split

public RubyArray split(ThreadContext context,
                       IRubyObject arg0)

split

public RubyArray split(ThreadContext context,
                       IRubyObject arg0,
                       IRubyObject arg1)

splitCommon

private RubyArray splitCommon(IRubyObject spat,
                              boolean limit,
                              int lim,
                              int i,
                              ThreadContext context)

regexSplit

private RubyArray regexSplit(ThreadContext context,
                             IRubyObject pat,
                             boolean limit,
                             int lim,
                             int i)

getEncodingForKCodeDefault

private org.jcodings.Encoding getEncodingForKCodeDefault(Ruby runtime,
                                                         org.joni.Regex pattern,
                                                         IRubyObject pat)

populateCapturesForSplit

private void populateCapturesForSplit(Ruby runtime,
                                      RubyArray result,
                                      org.joni.Matcher matcher,
                                      boolean is19)

awkSplit

private RubyArray awkSplit(boolean limit,
                           int lim,
                           int i)

split19

public RubyArray split19(ThreadContext context)

split19

public RubyArray split19(ThreadContext context,
                         IRubyObject arg0)

split19

public RubyArray split19(ThreadContext context,
                         IRubyObject arg0,
                         IRubyObject arg1)

split19

public RubyArray split19(ThreadContext context,
                         IRubyObject arg0,
                         boolean useBackref)

splitCommon19

private RubyArray splitCommon19(IRubyObject spat,
                                boolean limit,
                                int lim,
                                int i,
                                ThreadContext context,
                                boolean useBackref)

regexSplit19

private RubyArray regexSplit19(ThreadContext context,
                               org.joni.Regex pattern,
                               org.joni.Regex prepared,
                               boolean limit,
                               int lim,
                               int i,
                               boolean useBackref)

awkSplit19

private RubyArray awkSplit19(boolean limit,
                             int lim,
                             int i)

stringSplit19

private RubyArray stringSplit19(ThreadContext context,
                                RubyString spat,
                                boolean limit,
                                int lim,
                                int i)

indexOf

static int indexOf(byte[] source,
                   int sourceOffset,
                   int sourceCount,
                   byte[] target,
                   int targetOffset,
                   int targetCount,
                   int fromIndex)

getStringForPattern

private RubyString getStringForPattern(IRubyObject obj)

getPattern

private RubyRegexp getPattern(IRubyObject obj)

get_pat (used by match/match19)

getQuotedPattern

private org.joni.Regex getQuotedPattern(IRubyObject obj)

getStringPattern

private org.joni.Regex getStringPattern(Ruby runtime,
                                        org.jcodings.Encoding enc,
                                        IRubyObject obj)

getStringPattern19

private org.joni.Regex getStringPattern19(Ruby runtime,
                                          IRubyObject obj)

scan

public IRubyObject scan(ThreadContext context,
                        IRubyObject arg,
                        Block block)

rb_str_scan

scanIter

private IRubyObject scanIter(ThreadContext context,
                             org.joni.Regex pattern,
                             org.joni.Matcher matcher,
                             org.jcodings.Encoding enc,
                             Block block,
                             int begin,
                             int range,
                             int tuFlags)

scanNoIter

private IRubyObject scanNoIter(ThreadContext context,
                               org.joni.Regex pattern,
                               org.joni.Matcher matcher,
                               org.jcodings.Encoding enc,
                               int begin,
                               int range,
                               int tuFlags)

positionEnd

private int positionEnd(org.joni.Matcher matcher,
                        org.jcodings.Encoding enc,
                        int begin,
                        int range)

populateCapturesForScan

private IRubyObject populateCapturesForScan(Ruby runtime,
                                            org.joni.Matcher matcher,
                                            int range,
                                            int tuFlags,
                                            boolean is19)

scan19

public IRubyObject scan19(ThreadContext context,
                          IRubyObject arg,
                          Block block)

scanIter19

private IRubyObject scanIter19(ThreadContext context,
                               org.joni.Regex pattern,
                               org.joni.Regex prepared,
                               org.jcodings.Encoding enc,
                               Block block,
                               RubyRegexp regexp,
                               int tuFlags)

scanNoIter19

private IRubyObject scanNoIter19(ThreadContext context,
                                 org.joni.Regex pattern,
                                 org.joni.Regex prepared,
                                 org.jcodings.Encoding enc,
                                 RubyRegexp regexp,
                                 int tuFlags)

start_with_p

public IRubyObject start_with_p(ThreadContext context)

start_with_p

public IRubyObject start_with_p(ThreadContext context,
                                IRubyObject arg)

start_with_p

public IRubyObject start_with_p(ThreadContext context,
                                IRubyObject[] args)

start_with_pCommon

private boolean start_with_pCommon(IRubyObject arg)

end_with_p

public IRubyObject end_with_p(ThreadContext context)

end_with_p

public IRubyObject end_with_p(ThreadContext context,
                              IRubyObject arg)

end_with_p

public IRubyObject end_with_p(ThreadContext context,
                              IRubyObject[] args)

end_with_pCommon

private boolean end_with_pCommon(IRubyObject arg)

justify

private IRubyObject justify(IRubyObject arg0,
                            int jflag)

justify

private IRubyObject justify(IRubyObject arg0,
                            IRubyObject arg1,
                            int jflag)

justifyCommon

private RubyString justifyCommon(Ruby runtime,
                                 org.jruby.util.ByteList pad,
                                 int width,
                                 int jflag)

justify19

private IRubyObject justify19(IRubyObject arg0,
                              int jflag)

justify19

private IRubyObject justify19(IRubyObject arg0,
                              IRubyObject arg1,
                              int jflag)

justifyCommon

private RubyString justifyCommon(Ruby runtime,
                                 org.jruby.util.ByteList pad,
                                 int padCharLen,
                                 boolean padSinglebyte,
                                 org.jcodings.Encoding enc,
                                 int width,
                                 int jflag)

ljust

public IRubyObject ljust(IRubyObject arg0)

rb_str_ljust

ljust

public IRubyObject ljust(IRubyObject arg0,
                         IRubyObject arg1)

ljust19

public IRubyObject ljust19(IRubyObject arg0)

ljust19

public IRubyObject ljust19(IRubyObject arg0,
                           IRubyObject arg1)

rjust

public IRubyObject rjust(IRubyObject arg0)

rb_str_rjust

rjust

public IRubyObject rjust(IRubyObject arg0,
                         IRubyObject arg1)

rjust19

public IRubyObject rjust19(IRubyObject arg0)

rjust19

public IRubyObject rjust19(IRubyObject arg0,
                           IRubyObject arg1)

center

public IRubyObject center(IRubyObject arg0)

rb_str_center

center

public IRubyObject center(IRubyObject arg0,
                          IRubyObject arg1)

center19

public IRubyObject center19(IRubyObject arg0)

center19

public IRubyObject center19(IRubyObject arg0,
                            IRubyObject arg1)

partition

public IRubyObject partition(ThreadContext context,
                             Block block)

partition

public IRubyObject partition(ThreadContext context,
                             IRubyObject arg,
                             Block block)

partitionMismatch

private IRubyObject partitionMismatch(Ruby runtime)

rpartition

public IRubyObject rpartition(ThreadContext context,
                              IRubyObject arg)

rpartitionMismatch

private IRubyObject rpartitionMismatch(Ruby runtime)

chop

public IRubyObject chop(ThreadContext context)

rb_str_chop / rb_str_chop_bang

chop_bang

public IRubyObject chop_bang(ThreadContext context)

choppedLength
```
private int choppedLength()
```

chop19

public IRubyObject chop19(ThreadContext context)

chop_bang19

public IRubyObject chop_bang19(ThreadContext context)

choppedLength19

private int choppedLength19(Ruby runtime)

chomp

public RubyString chomp(ThreadContext context)

rb_str_chop

chomp

public RubyString chomp(ThreadContext context,
                        IRubyObject arg0)

chomp_bang
```
public IRubyObject chomp_bang(ThreadContext context)
```
rb_str_chomp_bang In the common case, removes CR and LF characters in various ways depending on the value of the optional args[0]. If args.length==0 removes one instance of CR, CRLF or LF from the end of the string. If args.length>0 and args[0] is "\n" then same behaviour as args.length==0 . If args.length>0 and args[0] is "" then removes trailing multiple LF or CRLF (but no CRs at all(!)).

chomp_bang

public IRubyObject chomp_bang(ThreadContext context,
                              IRubyObject arg0)

chompBangCommon

private IRubyObject chompBangCommon(Ruby runtime,
                                    IRubyObject rsObj)

smartChopBangCommon

private IRubyObject smartChopBangCommon(Ruby runtime)

chomp19

public RubyString chomp19(ThreadContext context)

chomp19

public RubyString chomp19(ThreadContext context,
                          IRubyObject arg0)

chomp_bang19

public IRubyObject chomp_bang19(ThreadContext context)

chomp_bang19

public IRubyObject chomp_bang19(ThreadContext context,
                                IRubyObject arg0)

chompBangCommon19

private IRubyObject chompBangCommon19(Ruby runtime,
                                      IRubyObject rsObj)

smartChopBangCommon19

private IRubyObject smartChopBangCommon19(Ruby runtime)

lstrip

public IRubyObject lstrip(ThreadContext context)

rb_str_lstrip / rb_str_lstrip_bang

lstrip_bang

public IRubyObject lstrip_bang(ThreadContext context)

lstrip19

public IRubyObject lstrip19(ThreadContext context)

lstrip_bang19

public IRubyObject lstrip_bang19(ThreadContext context)

singleByteLStrip

private IRubyObject singleByteLStrip(Ruby runtime,
                                     byte[] bytes,
                                     int s,
                                     int end)

multiByteLStrip

private IRubyObject multiByteLStrip(Ruby runtime,
                                    org.jcodings.Encoding enc,
                                    byte[] bytes,
                                    int s,
                                    int end)

rstrip

public IRubyObject rstrip(ThreadContext context)

rb_str_rstrip / rb_str_rstrip_bang

rstrip_bang

public IRubyObject rstrip_bang(ThreadContext context)

rstrip19

public IRubyObject rstrip19(ThreadContext context)

rstrip_bang19

public IRubyObject rstrip_bang19(ThreadContext context)

singleByteRStrip

private IRubyObject singleByteRStrip(Ruby runtime,
                                     byte[] bytes,
                                     int s,
                                     int end)

singleByteRStrip19

private IRubyObject singleByteRStrip19(Ruby runtime)

multiByteRStrip19

private IRubyObject multiByteRStrip19(Ruby runtime)

strip

public IRubyObject strip(ThreadContext context)

rb_str_strip / rb_str_strip_bang

strip_bang

public IRubyObject strip_bang(ThreadContext context)

strip19

public IRubyObject strip19(ThreadContext context)

strip_bang19

public IRubyObject strip_bang19(ThreadContext context)

singleByteStrip

private IRubyObject singleByteStrip(Ruby runtime,
                                    byte[] bytes,
                                    int s,
                                    int end)

count

public IRubyObject count(ThreadContext context)

rb_str_count

count

public IRubyObject count(ThreadContext context,
                         IRubyObject arg)

count

public IRubyObject count(ThreadContext context,
                         IRubyObject[] args)

countCommon

private IRubyObject countCommon(Ruby runtime,
                                boolean[] table)

count19

public IRubyObject count19(ThreadContext context)

count19

public IRubyObject count19(ThreadContext context,
                           IRubyObject arg)

count19

public IRubyObject count19(ThreadContext context,
                           IRubyObject[] args)

countCommon19

private IRubyObject countCommon19(Ruby runtime,
                                  boolean[] table,
                                  RubyString.TrTables tables,
                                  org.jcodings.Encoding enc)

delete

public IRubyObject delete(ThreadContext context)

rb_str_delete / rb_str_delete_bang

delete

public IRubyObject delete(ThreadContext context,
                          IRubyObject arg)

delete

public IRubyObject delete(ThreadContext context,
                          IRubyObject[] args)

delete_bang

public IRubyObject delete_bang(ThreadContext context)

delete_bang

public IRubyObject delete_bang(ThreadContext context,
                               IRubyObject arg)

delete_bang

public IRubyObject delete_bang(ThreadContext context,
                               IRubyObject[] args)

delete_bangCommon

private IRubyObject delete_bangCommon(Ruby runtime,
                                      boolean[] squeeze)

delete19

public IRubyObject delete19(ThreadContext context)

delete19

public IRubyObject delete19(ThreadContext context,
                            IRubyObject arg)

delete19

public IRubyObject delete19(ThreadContext context,
                            IRubyObject[] args)

delete_bang19

public IRubyObject delete_bang19(ThreadContext context)

delete_bang19

public IRubyObject delete_bang19(ThreadContext context,
                                 IRubyObject arg)

delete_bang19

public IRubyObject delete_bang19(ThreadContext context,
                                 IRubyObject[] args)

delete_bangCommon19

private IRubyObject delete_bangCommon19(Ruby runtime,
                                        boolean[] squeeze,
                                        RubyString.TrTables tables,
                                        org.jcodings.Encoding enc)

squeeze

public IRubyObject squeeze(ThreadContext context)

rb_str_squeeze / rb_str_squeeze_bang

squeeze

public IRubyObject squeeze(ThreadContext context,
                           IRubyObject arg)

squeeze

public IRubyObject squeeze(ThreadContext context,
                           IRubyObject[] args)

squeeze_bang

public IRubyObject squeeze_bang(ThreadContext context)

squeeze_bang

public IRubyObject squeeze_bang(ThreadContext context,
                                IRubyObject arg)

squeeze_bang

public IRubyObject squeeze_bang(ThreadContext context,
                                IRubyObject[] args)

squeezeCommon

private IRubyObject squeezeCommon(Ruby runtime,
                                  boolean[] squeeze)

squeeze19

public IRubyObject squeeze19(ThreadContext context)

squeeze19

public IRubyObject squeeze19(ThreadContext context,
                             IRubyObject arg)

squeeze19

public IRubyObject squeeze19(ThreadContext context,
                             IRubyObject[] args)

squeeze_bang19

public IRubyObject squeeze_bang19(ThreadContext context)

squeeze_bang19

public IRubyObject squeeze_bang19(ThreadContext context,
                                  IRubyObject arg)

squeeze_bang19

public IRubyObject squeeze_bang19(ThreadContext context,
                                  IRubyObject[] args)

squeezeCommon19

private IRubyObject squeezeCommon19(Ruby runtime,
                                    boolean[] squeeze,
                                    RubyString.TrTables tables,
                                    org.jcodings.Encoding enc,
                                    boolean isArg)

tr

public IRubyObject tr(ThreadContext context,
                      IRubyObject src,
                      IRubyObject repl)

rb_str_tr / rb_str_tr_bang

tr_bang

public IRubyObject tr_bang(ThreadContext context,
                           IRubyObject src,
                           IRubyObject repl)

tr19

public IRubyObject tr19(ThreadContext context,
                        IRubyObject src,
                        IRubyObject repl)

tr_bang19

public IRubyObject tr_bang19(ThreadContext context,
                             IRubyObject src,
                             IRubyObject repl)

trSetupTable

private void trSetupTable(boolean[] table,
                          boolean init)

tr_setup_table

trSetupTable

private RubyString.TrTables trSetupTable(Ruby runtime,
                                         boolean[] table,
                                         RubyString.TrTables tables,
                                         boolean init,
                                         org.jcodings.Encoding enc)

trFind

private boolean trFind(int c,
                       boolean[] table,
                       RubyString.TrTables tables)

trTrans

private IRubyObject trTrans(ThreadContext context,
                            IRubyObject src,
                            IRubyObject repl,
                            boolean sflag)

tr_trans

trTrans19

private IRubyObject trTrans19(ThreadContext context,
                              IRubyObject src,
                              IRubyObject repl,
                              boolean sflag)

trCode

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

trNext
```
private int trNext(RubyString.TR t)
```
trnext

trNext

private int trNext(RubyString.TR t,
                   Ruby runtime,
                   org.jcodings.Encoding enc)

tr_s

public IRubyObject tr_s(ThreadContext context,
                        IRubyObject src,
                        IRubyObject repl)

rb_str_tr_s / rb_str_tr_s_bang

tr_s_bang

public IRubyObject tr_s_bang(ThreadContext context,
                             IRubyObject src,
                             IRubyObject repl)

tr_s19

public IRubyObject tr_s19(ThreadContext context,
                          IRubyObject src,
                          IRubyObject repl)

tr_s_bang19

public IRubyObject tr_s_bang19(ThreadContext context,
                               IRubyObject src,
                               IRubyObject repl)

each_line

public IRubyObject each_line(ThreadContext context,
                             Block block)

rb_str_each_line

each_line

public IRubyObject each_line(ThreadContext context,
                             IRubyObject arg,
                             Block block)

each_lineCommon

public IRubyObject each_lineCommon(ThreadContext context,
                                   IRubyObject sep,
                                   Block block)

each18

public IRubyObject each18(ThreadContext context,
                          Block block)

each18

public IRubyObject each18(ThreadContext context,
                          IRubyObject arg,
                          Block block)

each_line18

public IRubyObject each_line18(ThreadContext context,
                               Block block)

each_line18

public IRubyObject each_line18(ThreadContext context,
                               IRubyObject arg,
                               Block block)

lines18

public IRubyObject lines18(ThreadContext context,
                           Block block)

lines18

public IRubyObject lines18(ThreadContext context,
                           IRubyObject arg,
                           Block block)

each_line19

public IRubyObject each_line19(ThreadContext context,
                               Block block)

each_line19

public IRubyObject each_line19(ThreadContext context,
                               IRubyObject arg,
                               Block block)

lines

public IRubyObject lines(ThreadContext context,
                         Block block)

lines

public IRubyObject lines(ThreadContext context,
                         IRubyObject arg,
                         Block block)

lines20

public IRubyObject lines20(ThreadContext context,
                           Block block)

lines20

public IRubyObject lines20(ThreadContext context,
                           IRubyObject arg,
                           Block block)

each_lineCommon19

private IRubyObject each_lineCommon19(ThreadContext context,
                                      Block block)

each_lineCommon19

private IRubyObject each_lineCommon19(ThreadContext context,
                                      IRubyObject sep,
                                      Block block)

each_byte

public RubyString each_byte(ThreadContext context,
                            Block block)

rb_str_each_byte

each_byte19

public IRubyObject each_byte19(ThreadContext context,
                               Block block)

bytes

public IRubyObject bytes(ThreadContext context,
                         Block block)

each_char18

public IRubyObject each_char18(ThreadContext context,
                               Block block)

rb_str_each_char

chars18

public IRubyObject chars18(ThreadContext context,
                           Block block)

each_charCommon18

private IRubyObject each_charCommon18(ThreadContext context,
                                      Block block)

each_char19

public IRubyObject each_char19(ThreadContext context,
                               Block block)

chars19

public IRubyObject chars19(ThreadContext context,
                           Block block)

each_charCommon19

private IRubyObject each_charCommon19(ThreadContext context,
                                      Block block)

each_codepoint

public IRubyObject each_codepoint(ThreadContext context,
                                  Block block)

rb_str_each_codepoint

codepoints

public IRubyObject codepoints(ThreadContext context,
                              Block block)

each_codepointCommon

private IRubyObject each_codepointCommon(ThreadContext context,
                                         Block block)

to_sym
```
private RubySymbol to_sym()
```
rb_str_intern

checkSpecialCasesIntern

private RubySymbol checkSpecialCasesIntern(org.jruby.util.ByteList value)

intern
```
public RubySymbol intern()
```

intern19
```
public RubySymbol intern19()
```

ord

public IRubyObject ord(ThreadContext context)

sum

public IRubyObject sum(ThreadContext context)

sum

public IRubyObject sum(ThreadContext context,
                       IRubyObject arg)

sumCommon

public IRubyObject sumCommon(ThreadContext context,
                             long bits)

to_c

public IRubyObject to_c(ThreadContext context)

string_to_c

to_r

public IRubyObject to_r(ThreadContext context)

string_to_r

unmarshalFrom

public static RubyString unmarshalFrom(UnmarshalStream input)
                                throws java.io.IOException

Throws:: java.io.IOException

unpack
```
public RubyArray unpack(IRubyObject obj)
```
See Also:

Pack.unpack(org.jruby.Ruby, org.jruby.util.ByteList, org.jruby.util.ByteList)

empty
```
public void empty()
```

encoding

public IRubyObject encoding(ThreadContext context)

encode_bang

public IRubyObject encode_bang(ThreadContext context,
                               IRubyObject arg0)

encode_bang

public IRubyObject encode_bang(ThreadContext context,
                               IRubyObject arg0,
                               IRubyObject arg1)

encode_bang

public IRubyObject encode_bang(ThreadContext context,
                               IRubyObject arg0,
                               IRubyObject arg1,
                               IRubyObject arg2)

encode_bang

public IRubyObject encode_bang(ThreadContext context,
                               IRubyObject[] args)

encode

public IRubyObject encode(ThreadContext context)

encode

public IRubyObject encode(ThreadContext context,
                          IRubyObject arg)

encode

public IRubyObject encode(ThreadContext context,
                          IRubyObject toEncoding,
                          IRubyObject arg)

encode

public IRubyObject encode(ThreadContext context,
                          IRubyObject toEncoding,
                          IRubyObject forcedEncoding,
                          IRubyObject opts)

getEncoding

private static org.jcodings.Encoding getEncoding(Ruby runtime,
                                                 IRubyObject toEnc)

force_encoding

public IRubyObject force_encoding(ThreadContext context,
                                  IRubyObject enc)

force_encoding

private IRubyObject force_encoding(ThreadContext context,
                                   org.jcodings.Encoding encoding)

valid_encoding_p

public IRubyObject valid_encoding_p(ThreadContext context)

ascii_only_p

public IRubyObject ascii_only_p(ThreadContext context)

setValue
```
public void setValue(java.lang.CharSequence value)
```
Deprecated.

Mutator for internal string representation.

Parameters:

value - The new java.lang.String this RubyString should encapsulate

setValue

public void setValue(org.jruby.util.ByteList value)

getValue

public java.lang.CharSequence getValue()

getBytes
```
public byte[] getBytes()
```

getByteList

public org.jruby.util.ByteList getByteList()

getUnicodeValue

public java.lang.String getUnicodeValue()

used by ar-jdbc

encodeBytelist

private static org.jruby.util.ByteList encodeBytelist(java.lang.CharSequence value,
                                                      org.jcodings.Encoding encoding)

toJava
```
public java.lang.Object toJava(java.lang.Class target)
```
Description copied from interface: IRubyObject

Convert the object to the specified Java class, if possible.

Specified by:

toJava in interface IRubyObject

Overrides:

toJava in class RubyBasicObject

Parameters:

target - The target type to which the object should be converted.

See Also:

IRubyObject.toJava(java.lang.Class)

cat

@Deprecated
public final int cat(byte[] bytes,
                                 int p,
                                 int len,
                                 org.jcodings.Encoding enc,
                                 int ptr_cr)

Deprecated.

b

public IRubyObject b(ThreadContext context)

Class RubyString

Nested Class Summary

Nested classes/interfaces inherited from class org.jruby.RubyObject

Nested classes/interfaces inherited from class org.jruby.RubyBasicObject

Field Summary

Fields inherited from class org.jruby.RubyObject

Fields inherited from class org.jruby.RubyBasicObject

Fields inherited from interface org.jruby.runtime.builtin.IRubyObject

Constructor Summary

Method Summary

Methods inherited from class org.jruby.RubyObject

Methods inherited from class org.jruby.RubyBasicObject

Methods inherited from class java.lang.Object

Field Detail

ASCII

UTF8

EMPTY_BYTE_ARRAY

SHARE_LEVEL_NONE

SHARE_LEVEL_BUFFER

SHARE_LEVEL_BYTELIST

shareLevel

value

opTable19

opTable18

STRING_ALLOCATOR

EMPTY_ASCII8BIT_BYTELIST

EMPTY_USASCII_BYTELIST

EMPTY_BYTELISTS

SPACE_BYTELIST

TRANS_SIZE

Constructor Detail

RubyString

RubyString

RubyString

RubyString

RubyString

RubyString

RubyString

RubyString

RubyString

RubyString

Method Detail

createStringClass

getEncoding

setEncoding

shouldMarshalEncoding

getMarshalEncoding

associateEncoding

setEncodingAndCodeRange

toEncoding

getCodeRange

setCodeRange

clearCodeRange

keepCodeRange

isCodeRangeAsciiOnly

isAsciiOnly

isCodeRangeValid

isCodeRangeBroken

codeRangeAnd

copyCodeRangeForSubstr

copyCodeRange

scanForCodeRange

singleByteOptimizable

singleByteOptimizable

isCompatibleWith

isCompatibleWith

checkEncoding

checkEncoding

checkDummyEncoding

isComparableWith

isComparableViaCodeRangeWith

strLength

strLength

strLength

strLength

subLength

eql

eql18

eql19

newString