Uses of Class
org.jruby.util.ByteList

Packages that use ByteList

Package	Description
org.jruby
org.jruby.ast
org.jruby.ast.executable
org.jruby.ast.util
org.jruby.ext.bigdecimal
org.jruby.ext.date
org.jruby.ext.digest
org.jruby.ext.ffi
org.jruby.ext.ffi.jffi
org.jruby.ext.nkf
org.jruby.ext.ripper
org.jruby.ext.socket
org.jruby.ext.stringio
org.jruby.ext.timeout
org.jruby.ext.zlib
org.jruby.ir
org.jruby.ir.instructions
org.jruby.ir.operands
org.jruby.ir.persistence
org.jruby.ir.runtime
org.jruby.ir.targets
org.jruby.ir.targets.indy
org.jruby.ir.targets.simple
org.jruby.ir.transformations.inlining
org.jruby.lexer
org.jruby.lexer.yacc
org.jruby.parser
org.jruby.runtime
org.jruby.runtime.encoding
org.jruby.runtime.load
org.jruby.runtime.marshal
org.jruby.util
org.jruby.util.io

Uses of ByteList in org.jruby

Fields in org.jruby declared as ByteList

Modifier and Type	Field	Description
private static final ByteList	RubyComplex._eE
(package private) static final ByteList	RubyFile.BACKSLASH
final ByteList	RubyString.EmptyByteListHolder.bytes
(package private) final ByteList	RubySymbol.SymbolTable.SymbolEntry.bytes
final ByteList	RubyThread.Status.bytes
private static final ByteList	RubyString.EMPTY_ASCII8BIT_BYTELIST
private static final ByteList	RubyString.EMPTY_USASCII_BYTELIST
private static final ByteList	RubyGlobal.CaseInsensitiveStringOnlyRubyHash.ENV
static final ByteList	RubyEncoding.EXTERNAL
(package private) static final ByteList	RubyBoolean.FALSE_BYTES
static final ByteList	RubyEncoding.FILESYSTEM
private static final ByteList	RubyString.GRAPHEME_CLUSTER_PATTERN
(package private) static final ByteList	RubyDir.HOME
private static final ByteList	RubyFloat.INFINITY_BYTELIST
static final ByteList	RubyEncoding.INTERNAL
static final ByteList	RubyEncoding.LOCALE
private final ByteList	RubyEncoding.name
private static final ByteList	RubyFloat.NAN_BYTELIST
private static final ByteList	RubyFloat.NEGATIVE_INFINITY_BYTELIST
private static final ByteList	RubyNil.nil
static final ByteList	RubyIO.PARAGRAPH_SEPARATOR
private static final ByteList	RubyGlobal.StringOnlyRubyHash.PATH_BYTES
private static final ByteList	RubyIO.RECURSIVE_BYTELIST
private static final ByteList	RubyComplex.SEP
(package private) static final ByteList[]	RubyInteger.SINGLE_CHAR_BYTELISTS
static final ByteList[]	RubyInteger.SINGLE_CHAR_BYTELISTS19	Deprecated.
(package private) static final ByteList[]	RubyInteger.SINGLE_CHAR_UTF8_BYTELISTS
(package private) static final ByteList	RubyFile.SLASH
private static final ByteList	RubyString.SPACE_BYTELIST
private ByteList	RubyRegexp.str
private final ByteList	RubySymbol.symbolBytes
(package private) static final ByteList	RubyBoolean.TRUE_BYTES
private static final ByteList	RubyTime.TZ_STRING
private static final ByteList	RubyString.UNDERSCORE
private static final ByteList	RubyDir.user_home
private ByteList	RubyString.value
private static final ByteList	RubyKernel.ZEROx

Fields in org.jruby with type parameters of type ByteList

Modifier and Type	Field	Description
(package private) static final WeakValuedMap<ByteList,org.joni.Regex>	RubyRegexp.patternCache
(package private) static final WeakValuedMap<ByteList,org.joni.Regex>	RubyRegexp.preprocessedPatternCache
(package private) static final WeakValuedMap<ByteList,org.joni.Regex>	RubyRegexp.quotedPatternCache

Methods in org.jruby that return ByteList

Modifier and Type	Method	Description
(package private) static ByteList	RubyEncoding.doEncode(CharSequence cs, Charset charset, org.jcodings.Encoding enc)
(package private) static ByteList	RubyEncoding.doEncode(String cs, Charset charset, org.jcodings.Encoding enc)
(package private) static ByteList	RubyEncoding.doEncodeUTF16(CharSequence str)
(package private) static ByteList	RubyEncoding.doEncodeUTF16(String str)
(package private) static ByteList	RubyEncoding.doEncodeUTF8(CharSequence str)
(package private) static ByteList	RubyEncoding.doEncodeUTF8(String str)
static ByteList	RubyString.encodeBytelist(CharSequence value, org.jcodings.Encoding encoding)
(package private) static ByteList	RubyString.encodeBytelist(String value, org.jcodings.Encoding encoding)
private static ByteList	RubyEncoding.getByteList(ByteBuffer buffer, org.jcodings.Encoding enc, boolean shared)
ByteList	RubyString.getByteList()
final ByteList	RubySymbol.getBytes()
private static ByteList	RubyDir.globArgumentAsByteList(ThreadContext context, IRubyObject arg)
private ByteList	RubyFloat.marshalDump()
(package private) static ByteList	RubyRegexp.quote(RubyString str)
(package private) static ByteList	RubyRegexp.quote(ByteList bs, boolean asciiOnly)
static ByteList	RubyRegexp.quote19(ByteList bs, boolean asciiOnly)	Deprecated.
static ByteList	RubyInteger.singleCharByteList(byte index)
static ByteList	RubyInteger.singleCharUTF8ByteList(byte index)	Return a low ASCII single-character bytelist with UTF-8 encoding, using cached values.
static ByteList	RubySymbol.symbolBytesFromString(Ruby runtime, String internedSymbol)

Methods in org.jruby that return types with arguments of type ByteList

Modifier and Type	Method	Description
private static ArrayList<ByteList>	RubyDir.dirGlobs(ThreadContext context, String cwd, IRubyObject[] args, int flags)

Methods in org.jruby with parameters of type ByteList

Modifier and Type	Method	Description
static String	RubyString.byteListToString(ByteList bytes)
final RubyString	RubyString.cat(ByteList str)
final RubyString	RubyString.cat(ByteList other, int codeRange)
final int	RubyString.cat19(ByteList other, int codeRange)
static org.jcodings.Encoding	RubyString.checkEncoding(Ruby runtime, ByteList str1, ByteList str2)
private RubySymbol	RubySymbol.SymbolTable.createSymbol(String name, ByteList value, int hash, boolean hard)
private RubySymbol	RubySymbol.SymbolTable.createSymbol(String name, ByteList value, RubySymbol.ObjBooleanConsumer<RubySymbol> handler, int hash, boolean hard)
static String	RubyEncoding.decodeISO(ByteList byteList)	Deprecated. use RubyEncoding.decodeRaw(ByteList)
static String	RubyEncoding.decodeRaw(ByteList byteList)	Decode the specified bytelist as "raw" binary content.
private static boolean	RubyFile.dir_fnmatch(ByteList pattern, ByteList path, int flags)
private RubySymbol	RubySymbol.SymbolTable.findSymbol(ByteList bytes, int hash, boolean hard)
IRubyObject	RubyIO.getline(Ruby runtime, ByteList separator)	Deprecated.
IRubyObject	RubyIO.getline(Ruby runtime, ByteList separator, long limit)	Deprecated.
IRubyObject	RubyIO.getline(ThreadContext context, ByteList separator)	Deprecated.
IRubyObject	RubyIO.getline(ThreadContext context, ByteList separator, long limit)	Deprecated.
private static org.joni.Regex	RubyRegexp.getPreprocessedRegexpFromCache(Ruby runtime, ByteList bytes, org.jcodings.Encoding enc, RegexpOptions options, RegexpSupport.ErrorMode mode)
static org.joni.Regex	RubyRegexp.getRegexpFromCache(Ruby runtime, ByteList bytes, org.jcodings.Encoding enc, RegexpOptions options)
RubySymbol	RubySymbol.SymbolTable.getSymbol(ByteList bytes)
RubySymbol	RubySymbol.SymbolTable.getSymbol(ByteList bytes, boolean hard)
RubySymbol	RubySymbol.SymbolTable.getSymbol(ByteList bytes, RubySymbol.ObjBooleanConsumer<RubySymbol> handler, boolean hard)	Get or retrieve an existing symbol from the table, invoking the given handler before return.
static RubyString	RubyString.inspect(Ruby runtime, ByteList byteList)
static IRubyObject	RubyString.inspect19(Ruby runtime, ByteList byteList)	Deprecated.
private static boolean	RubySymbol.SymbolTable.isSymbolMatch(ByteList bytes, int hash, RubySymbol.SymbolTable.SymbolEntry entry)
static int	RubySymbol.javaStringHashCode(ByteList iso8859)
private RubyString	RubyString.justifyCommon(Ruby runtime, ByteList pad, int padCharLen, boolean padSinglebyte, org.jcodings.Encoding enc, int width, int jflag)
private static org.joni.Regex	RubyRegexp.makeRegexp(Ruby runtime, ByteList bytes, RegexpOptions options, org.jcodings.Encoding enc)
private RubyString	RubyString.makeShared(Ruby runtime, RubyClass meta, ByteList value, int index, int len)
private RubyString	RubyString.makeShared(Ruby runtime, ByteList value, int index, int len)
static RubyString	RubyString.newBinaryString(Ruby runtime, ByteList str)
static RubySymbol	RubySymbol.newConstantSymbol(Ruby runtime, IRubyObject fqn, ByteList bytes)	Create a symbol whose intention is to be used as a constant.
static RubySymbol	RubySymbol.newHardSymbol(Ruby runtime, ByteList bytes)
static RubySymbol	RubySymbol.newHardSymbol(Ruby runtime, ByteList bytes, RubySymbol.ObjBooleanConsumer<RubySymbol> handler)
static RubySymbol	RubySymbol.newIDSymbol(Ruby runtime, ByteList bytes)	Generic identifier symbol creation (or retrieval) method.
static RubySymbol	RubySymbol.newIDSymbol(Ruby runtime, ByteList bytes, RubySymbol.ObjBooleanConsumer<RubySymbol> handler)	Generic identifier symbol creation (or retrieval) method that invokes a handler before storing new symbols.
static RubyRegexp	RubyRegexp.newRegexp(Ruby runtime, ByteList pattern)
static RubyRegexp	RubyRegexp.newRegexp(Ruby runtime, ByteList pattern, int options)
(package private) static RubyRegexp	RubyRegexp.newRegexp(Ruby runtime, ByteList str, org.joni.Regex pattern)
static RubyRegexp	RubyRegexp.newRegexp(Ruby runtime, ByteList pattern, RegexpOptions options)
static RubyRegexp	RubyRegexp.newRegexpParser(Ruby runtime, ByteList pattern, RegexpOptions options)	throws RaiseException on error so parser can pick this up and give proper line and line number error as opposed to any non-literal regexp creation which may raise a syntax error but will not have this extra source info in the error message
RubyString	Ruby.newString(ByteList byteList)
static RubyString	RubyString.newString(Ruby runtime, ByteList bytes)
static RubyString	RubyString.newString(Ruby runtime, ByteList bytes, int coderange)
static RubyString	RubyString.newString(Ruby runtime, ByteList bytes, org.jcodings.Encoding encoding)
RubyString	RubyString.newString(ByteList s)	Deprecated.
static RubyString	RubyString.newStringLight(Ruby runtime, ByteList bytes)
static RubyString	RubyString.newStringNoCopy(Ruby runtime, RubyClass clazz, ByteList bytes)
static RubyString	RubyString.newStringNoCopy(Ruby runtime, RubyClass clazz, ByteList bytes, org.jcodings.Encoding enc, int cr)
static RubyString	RubyString.newStringNoCopy(Ruby runtime, ByteList bytes)
static RubyString	RubyString.newStringNoCopy(Ruby runtime, ByteList bytes, org.jcodings.Encoding enc, int cr)
RubyString	Ruby.newStringShared(ByteList byteList)	Deprecated.
static RubyString	RubyString.newStringShared(Ruby runtime, RubyClass clazz, ByteList bytes)
static RubyString	RubyString.newStringShared(Ruby runtime, RubyClass clazz, ByteList bytes, org.jcodings.Encoding encoding)
static RubyString	RubyString.newStringShared(Ruby runtime, ByteList bytes)
static RubyString	RubyString.newStringShared(Ruby runtime, ByteList bytes, int codeRange)
static RubyString	RubyString.newStringShared(Ruby runtime, ByteList bytes, org.jcodings.Encoding encoding)
private static RubyString	RubyString.newStringShared(Ruby runtime, ByteList bytes, org.jcodings.Encoding encoding, int cr)
RubySymbol	Ruby.newSymbol(ByteList name)
static RubySymbol	RubySymbol.newSymbol(Ruby runtime, ByteList bytes)
static RubySymbol	RubySymbol.newSymbol(Ruby runtime, ByteList bytes, RubySymbol.ObjBooleanConsumer<RubySymbol> handler)	Return the symbol in the symbol table if it exists, null otherwise.
static RubyString	RubyString.newUsAsciiStringNoCopy(Ruby runtime, ByteList bytes)
static RubyString	RubyString.newUsAsciiStringShared(Ruby runtime, ByteList bytes)
Node	Ruby.parse(ByteList content, String file, DynamicScope scope, int lineNumber, boolean extraPositionInformation)
Node	Ruby.parseEval(ByteList content, String file, DynamicScope scope, int lineNumber)
static void	RubyRegexp.preprocessCheck(Ruby runtime, ByteList bytes)
private static void	RubyRegexp.preprocessLight(Ruby runtime, ByteList str, org.jcodings.Encoding enc, org.jcodings.Encoding[] fixedEnc, RegexpSupport.ErrorMode mode)	Preprocess the given string for use in regexp, raising errors for encoding incompatibilities that arise.
(package private) static ByteList	RubyRegexp.quote(ByteList bs, boolean asciiOnly)
static ByteList	RubyRegexp.quote19(ByteList bs, boolean asciiOnly)	Deprecated.
final RubyRegexp	RubyRegexp.regexpInitialize(ByteList bytes, org.jcodings.Encoding enc, RegexpOptions options)
static int	RubyString.scanForCodeRange(ByteList bytes)
void	RubyString.setValue(ByteList value)
private void	RubySymbol.SymbolTable.storeSymbol(ByteList value, int hash, boolean hard, RubySymbol.SymbolTable.SymbolEntry[] table, int index, RubySymbol symbol, String internedName)
(package private) final int	RubyString.strLength(ByteList bytes, org.jcodings.Encoding enc)
private void	RubyMatchData.updateCharOffsetManyRegs(ByteList value, org.jcodings.Encoding encoding)
private void	RubyMatchData.updateCharOffsetOnlyOneReg(ByteList value, org.jcodings.Encoding encoding)
private static void	RubyMatchData.updatePairs(ByteList value, org.jcodings.Encoding encoding, RubyMatchData.Pair[] pairs)
final void	RubyString.view(ByteList bytes)
protected static IRubyObject	RubyIO.write(ThreadContext context, IRubyObject maybeIO, ByteList byteList)
protected static IRubyObject	RubyIO.write(ThreadContext context, IRubyObject maybeIO, ByteList byteList, IRubyObject sep)

Method parameters in org.jruby with type arguments of type ByteList

Modifier and Type	Method	Description
private static RubyArray	RubyDir.asRubyStringList(Ruby runtime, List<ByteList> dirs)

Constructors in org.jruby with parameters of type ByteList

Modifier	Constructor	Description
private	RubyEncoding(Ruby runtime, ByteList name, org.jcodings.Encoding encoding, boolean isDummy)
	RubyRegexp(Ruby runtime, org.joni.Regex pattern, ByteList str, RegexpOptions options)
private	RubyRegexp(Ruby runtime, ByteList str)
private	RubyRegexp(Ruby runtime, ByteList str, RegexpOptions options)
	RubyString(Ruby runtime, RubyClass rubyClass, ByteList value)
	RubyString(Ruby runtime, RubyClass rubyClass, ByteList value, boolean objectSpace)
protected	RubyString(Ruby runtime, RubyClass rubyClass, ByteList value, int cr)
protected	RubyString(Ruby runtime, RubyClass rubyClass, ByteList value, org.jcodings.Encoding enc)
	RubyString(Ruby runtime, RubyClass rubyClass, ByteList value, org.jcodings.Encoding encoding, boolean objectSpace)
protected	RubyString(Ruby runtime, RubyClass rubyClass, ByteList value, org.jcodings.Encoding enc, int cr)
private	RubySymbol(Ruby runtime, String internedSymbol, ByteList symbolBytes)
(package private)	SymbolEntry(int hash, String name, ByteList bytes, RubySymbol symbol, RubySymbol.SymbolTable.SymbolEntry next, boolean hard)

Uses of ByteList in org.jruby.ast

Fields in org.jruby.ast declared as ByteList

Modifier and Type	Field	Description
private final ByteList	RegexpNode.value
private final ByteList	StrNode.value
private final ByteList	XStrNode.value

Methods in org.jruby.ast that return ByteList

Modifier and Type	Method	Description
ByteList	BackRefNode.getByteName()
ByteList	LiteralNode.getByteName()
ByteList	OpAsgnConstDeclNode.getByteOperator()
ByteList	OpAsgnNode.getOperatorByteName()
ByteList	OpElementAsgnNode.getOperatorByteName()
ByteList	RegexpNode.getValue()	Gets the value.
ByteList	StrNode.getValue()	Gets the value.
ByteList	XStrNode.getValue()	Gets the value.
ByteList	OpAsgnNode.getVariableByteName()
ByteList	OpAsgnNode.getVariableByteNameAsgn()

Constructors in org.jruby.ast with parameters of type ByteList

Modifier	Constructor	Description
	FileNode(int line, ByteList value)
	RegexpNode(int line, ByteList value, RegexpOptions options)
	StrNode(int line, ByteList value)
	StrNode(int line, ByteList value, int codeRange)
	XStrNode(int line, ByteList value, int coderange)

Uses of ByteList in org.jruby.ast.executable

Fields in org.jruby.ast.executable declared as ByteList

Modifier and Type	Field	Description
ByteList[]	RuntimeCache.byteLists
private static final ByteList[]	RuntimeCache.EMPTY_BYTELISTS

Methods in org.jruby.ast.executable that return ByteList

Modifier and Type	Method	Description
final ByteList	AbstractScript.getByteList(int i)
final ByteList	RuntimeCache.getByteList(int index)
final ByteList	AbstractScript.getByteList0()
final ByteList	AbstractScript.getByteList1()
final ByteList	AbstractScript.getByteList2()
final ByteList	AbstractScript.getByteList3()
final ByteList	AbstractScript.getByteList4()
final ByteList	AbstractScript.getByteList5()
final ByteList	AbstractScript.getByteList6()
final ByteList	AbstractScript.getByteList7()
final ByteList	AbstractScript.getByteList8()
final ByteList	AbstractScript.getByteList9()
final ByteList[]	RuntimeCache.initStrings(int size)

Methods in org.jruby.ast.executable with parameters of type ByteList

Modifier and Type	Method	Description
final RubyRegexp	AbstractScript.getRegexp(ThreadContext context, int i, ByteList pattern, int options)
final RubyRegexp	RuntimeCache.getRegexp(ThreadContext context, int index, ByteList pattern, int options)
final RubyRegexp	AbstractScript.getRegexp0(ThreadContext context, ByteList pattern, int options)
final RubyRegexp	AbstractScript.getRegexp1(ThreadContext context, ByteList pattern, int options)
final RubyRegexp	AbstractScript.getRegexp2(ThreadContext context, ByteList pattern, int options)
final RubyRegexp	AbstractScript.getRegexp3(ThreadContext context, ByteList pattern, int options)
final RubyRegexp	AbstractScript.getRegexp4(ThreadContext context, ByteList pattern, int options)
final RubyRegexp	AbstractScript.getRegexp5(ThreadContext context, ByteList pattern, int options)
final RubyRegexp	AbstractScript.getRegexp6(ThreadContext context, ByteList pattern, int options)
final RubyRegexp	AbstractScript.getRegexp7(ThreadContext context, ByteList pattern, int options)
final RubyRegexp	AbstractScript.getRegexp8(ThreadContext context, ByteList pattern, int options)
final RubyRegexp	AbstractScript.getRegexp9(ThreadContext context, ByteList pattern, int options)

Uses of ByteList in org.jruby.ast.util

Methods in org.jruby.ast.util with parameters of type ByteList

Modifier and Type	Method	Description
SexpMaker.DigestBuilder	SexpMaker.DigestBuilder.append(ByteList str)

Uses of ByteList in org.jruby.ext.bigdecimal

Fields in org.jruby.ext.bigdecimal declared as ByteList

Modifier and Type	Field	Description
private static final ByteList	RubyBigDecimal.VERSION

Uses of ByteList in org.jruby.ext.date

Fields in org.jruby.ext.date declared as ByteList

Modifier and Type	Field	Description
private static final ByteList	RubyDate._parse_bc
private static final ByteList	RubyDate._parse_day
private static final ByteList	RubyDate._parse_dot
private static final ByteList	RubyDate._parse_eu
private static final ByteList	RubyDate._parse_frag
private static final ByteList	RubyDate._parse_impl
private static final ByteList	RubyDate._parse_iso
private static final ByteList	RubyDate._parse_mday
private static final ByteList	RubyDate._parse_mon
private static final ByteList	RubyDate._parse_sla
private static final ByteList	RubyDate._parse_time
private static final ByteList	RubyDate._parse_time2
private static final ByteList	RubyDate._parse_us
private static final ByteList	RubyDate._parse_year
private static final ByteList[]	RubyDate.ABBR_DAYS
private static final ByteList[]	RubyDate.ABBR_MONTHS
private static final ByteList	RubyDate.DEFAULT_FORMAT_BYTES
private static final ByteList	RubyDate.SPACE
private static final ByteList	RubyDateTime.STRF_FORMAT_BYTES
private static final ByteList	RubyDate.TO_S_FORMAT
private static final ByteList	RubyDateTime.TO_S_FORMAT
private static final ByteList	RubyDate.UTC_ZONE

Methods in org.jruby.ext.date that return ByteList

Modifier and Type	Method	Description
private static ByteList	RubyDate.of2str(int of)

Methods in org.jruby.ext.date with parameters of type ByteList

Modifier and Type	Method	Description
private static void	RubyDate.append(ByteList out, String val)
(package private) static RubyString	RubyDate.format(ThreadContext context, ByteList fmt, IRubyObject... args)
private static RubyRegexp	RubyDate.newRegexpFromCache(Ruby runtime, ByteList str, int opts)
private static IRubyObject	RubyDate.parse_sla_dot(ThreadContext context, ByteList pattern, RubyString str, RubyHash hash)

Uses of ByteList in org.jruby.ext.digest

Methods in org.jruby.ext.digest that return ByteList

Modifier and Type	Method	Description
static ByteList	BubbleBabble.bubblebabble(byte[] message, int begin, int length)	Ported from OpenSSH (https://github.com/openssh/openssh-portable/blob/957fbceb0f3166e41b76fdb54075ab3b9cc84cba/sshkey.c#L942-L987) OpenSSH License Notice Copyright (c) 2000, 2001 Markus Friedl.
private static ByteList	RubyDigest.toHex(byte[] val)

Uses of ByteList in org.jruby.ext.ffi

Methods in org.jruby.ext.ffi with parameters of type ByteList

Modifier and Type	Method	Description
private IRubyObject	AbstractMemory.putBytes(ThreadContext context, long off, ByteList bl, int idx, int len)

Uses of ByteList in org.jruby.ext.ffi.jffi

Fields in org.jruby.ext.ffi.jffi declared as ByteList

Modifier and Type	Field	Description
(package private) final ByteList	NativeStringHandle.bl

Constructors in org.jruby.ext.ffi.jffi with parameters of type ByteList

Modifier	Constructor	Description
(package private)	NativeStringHandle(MemoryIO memory, ByteList bl)

Uses of ByteList in org.jruby.ext.nkf

Fields in org.jruby.ext.nkf declared as ByteList

Modifier and Type	Field	Description
private static final ByteList	RubyNKF.BEGIN_MIME_STRING
private static final ByteList	RubyNKF.END_MIME_STRING
private static final ByteList	RubyNKF.PACK_BASE64
private static final ByteList	RubyNKF.PACK_QENCODE

Methods in org.jruby.ext.nkf that return ByteList

Modifier and Type	Method	Description
(package private) ByteList	RubyNKF.Converter.convert_byte(ByteList str, String inputCharset, RubyNKF.NKFCharset output)
private ByteList	RubyNKF.MimeConverter.decodeMimeString(String str)

Methods in org.jruby.ext.nkf with parameters of type ByteList

Modifier and Type	Method	Description
(package private) abstract RubyString	RubyNKF.Converter.convert(ByteList str)
(package private) RubyString	RubyNKF.DefaultConverter.convert(ByteList str)
(package private) RubyString	RubyNKF.MimeConverter.convert(ByteList str)
(package private) ByteList	RubyNKF.Converter.convert_byte(ByteList str, String inputCharset, RubyNKF.NKFCharset output)
private static RubyString	RubyNKF.Converter.encodeMimeString(Ruby runtime, RubyString str, ByteList format)
(package private) static boolean	RubyNKF.Converter.isMimeText(ByteList str, Map<String,RubyNKF.NKFCharset> options)

Method parameters in org.jruby.ext.nkf with type arguments of type ByteList

Modifier and Type	Method	Description
(package private) RubyString	RubyNKF.MimeConverter.makeRubyString(ArrayList<ByteList> list)

Uses of ByteList in org.jruby.ext.ripper

Fields in org.jruby.ext.ripper declared as ByteList

Modifier and Type	Field	Description
protected ByteList	RipperLexer.delayed
protected final ByteList	HeredocTerm.lastLine
private final ByteList	HeredocTerm.nd_lit
private ByteList	RipperLexer.numberBuffer

Fields in org.jruby.ext.ripper with type parameters of type ByteList

Modifier and Type	Field	Description
private List<ByteList>	StringTerm.regexpFragments

Methods in org.jruby.ext.ripper that return ByteList

Modifier and Type	Method	Description
protected ByteList	StringTerm.createByteList(RipperLexer lexer)

Methods in org.jruby.ext.ripper with parameters of type ByteList

Modifier and Type	Method	Description
IRubyObject	RipperLexer.createStr(ByteList buffer, int flags)
protected int	HeredocTerm.error(RipperLexer lexer, int len, ByteList str, ByteList eos)
private void	StringTerm.escaped(RipperLexer lexer, LexerSource src, ByteList buffer)
protected boolean	RipperLexer.onMagicComment(String name, ByteList value)
private void	StringTerm.parseEscapeIntoBuffer(RipperLexer lexer, LexerSource src, ByteList buffer)
int	StringTerm.parseStringIntoBuffer(RipperLexer lexer, LexerSource src, ByteList buffer, org.jcodings.Encoding enc)
private void	RipperLexer.readUTF8EscapeIntoBuffer(int codepoint, ByteList buffer, boolean stringLiteral)
int	RipperLexer.readUTFEscape(ByteList buffer, boolean stringLiteral, boolean symbolLiteral)
void	RipperLexer.readUTFEscapeRegexpLiteral(ByteList buffer)
private char	RipperLexer.scanHexLiteral(ByteList buffer, int count, boolean strict, String errorMessage)	Read up to count hexadecimal digits and store those digits in a token buffer.
protected void	RipperLexer.setCompileOptionFlag(String name, ByteList value)
protected void	RipperLexer.setEncoding(ByteList name)
protected void	RipperLexer.setTokenInfo(String name, ByteList value)
boolean	RipperLexer.tokenAddMBC(int first_byte, ByteList buffer)

Constructors in org.jruby.ext.ripper with parameters of type ByteList

Modifier	Constructor	Description
	HeredocTerm(ByteList marker, int func, int nth, int line, ByteList lastLine)

Uses of ByteList in org.jruby.ext.socket

Fields in org.jruby.ext.socket declared as ByteList

Modifier and Type	Field	Description
private ByteList	Option.data
private static final ByteList	RubyBasicSocket.FORMAT_SMALL_I

Methods in org.jruby.ext.socket that return ByteList

Modifier and Type	Method	Description
protected ByteList	RubyBasicSocket.doRead(ThreadContext context, ByteBuffer buffer)
protected final ByteList	RubyBasicSocket.doReadNonblock(ThreadContext context, ByteBuffer buffer, boolean exception)
static ByteList	Option.packInt(int i)
static ByteList	Option.packLinger(int vonoff, int vsecs)

Methods in org.jruby.ext.socket with parameters of type ByteList

Modifier and Type	Method	Description
static InetAddress[]	SocketUtils.getRubyInetAddresses(ByteList address)	Deprecated.
private IRubyObject	RubyBasicSocket.handleReturnBytes(Ruby runtime, ByteList bytes, IRubyObject str, String exMessage, boolean exception)
static int	Option.unpackInt(ByteList data)
static int[]	Option.unpackLinger(ByteList data)
private static void	Option.validateDataSize(Ruby runtime, ByteList data, int size)

Constructors in org.jruby.ext.socket with parameters of type ByteList

Modifier	Constructor	Description
	Option(Ruby runtime, jnr.constants.platform.ProtocolFamily family, jnr.constants.platform.SocketLevel level, jnr.constants.platform.SocketOption option, ByteList data)
	Option(Ruby runtime, RubyClass klass, jnr.constants.platform.ProtocolFamily family, jnr.constants.platform.SocketLevel level, jnr.constants.platform.SocketOption option, ByteList data)

Uses of ByteList in org.jruby.ext.stringio

Fields in org.jruby.ext.stringio declared as ByteList

Modifier and Type	Field	Description
static final ByteList	StringIO.NEWLINE

Uses of ByteList in org.jruby.ext.timeout

Fields in org.jruby.ext.timeout declared as ByteList

Modifier and Type	Field	Description
private static final ByteList	Timeout.TIMEOUT_MESSAGE

Uses of ByteList in org.jruby.ext.zlib

Fields in org.jruby.ext.zlib declared as ByteList

Modifier and Type	Field	Description
private ByteList	JZlibInflate.input

Methods in org.jruby.ext.zlib that return ByteList

Modifier and Type	Method	Description
private ByteList	JZlibRubyGzipReader.newReadByteList()
private ByteList	JZlibRubyGzipReader.newReadByteList(int size)
private ByteList	JZlibRubyGzipReader.readSize(int length)

Methods in org.jruby.ext.zlib with parameters of type ByteList

Modifier and Type	Method	Description
private void	JZlibDeflate.append(ByteList obj)
void	JZlibInflate.append(ByteList obj)
private IRubyObject	JZlibDeflate.deflate(ByteList str, int flush)
private void	JZlibRubyGzipReader.fixBrokenTrailingCharacter(ByteList result)
IRubyObject	JZlibInflate.inflate(ThreadContext context, ByteList str, Block block)
private IRubyObject	JZlibRubyGzipReader.internalSepGets(ByteList sep)
private IRubyObject	JZlibRubyGzipReader.internalSepGets(ByteList sep, int limit)
protected RubyString	RubyGzipFile.newStr(Ruby runtime, ByteList value)
private static void	JZlibInflate.resetBuffer(ByteList l)

Uses of ByteList in org.jruby.ir

Fields in org.jruby.ir declared as ByteList

Modifier and Type	Field	Description
static final ByteList	IRFor._BEGIN_
private static final ByteList	IRClosure.CLOSURE
private static final ByteList	IRClosure.CLOSURE_CLONE
private static final ByteList	IREvalScript.EVAL
private static final ByteList	IRFor.FOR_LOOP
private static final ByteList	IRFor.FOR_LOOP_CLONE
private ByteList	IRScope.name	Name
private static final ByteList	IRManager.OBJECT

Methods in org.jruby.ir that return ByteList

Modifier and Type	Method	Description
ByteList	IRScope.getByteName()

Methods in org.jruby.ir with parameters of type ByteList

Modifier and Type	Method	Description
IRMethod	IRClosure.convertToMethod(ByteList name)
void	IRClosure.setByteName(ByteList name)
void	IRScope.setByteName(ByteList name)
private RubySymbol	IRBuilder.symbol(ByteList bytelist)

Constructors in org.jruby.ir with parameters of type ByteList

Modifier	Constructor	Description
	IRClassBody(IRManager manager, IRScope lexicalParent, ByteList name, int lineNumber, StaticScope scope, boolean executesOnce)
protected	IRClosure(IRClosure c, IRScope lexicalParent, int closureId, ByteList fullName)	Used by cloning code for inlining
protected	IRClosure(IRManager manager, IRScope lexicalParent, int lineNumber, StaticScope staticScope, int closureId, ByteList fullName)
	IRClosure(IRManager manager, IRScope lexicalParent, int lineNumber, StaticScope staticScope, Signature signature, ByteList prefix)
	IRClosure(IRManager manager, IRScope lexicalParent, int lineNumber, StaticScope staticScope, Signature signature, ByteList prefix, boolean isBeginEndBlock)
	IRClosure(IRManager manager, IRScope lexicalParent, int lineNumber, StaticScope staticScope, Signature signature, ByteList prefix, boolean isBeginEndBlock, int coverageMode)
protected	IRClosure(IRManager manager, IRScope lexicalParent, int lineNumber, StaticScope staticScope, ByteList prefix)
protected	IRClosure(IRManager manager, IRScope lexicalParent, int lineNumber, StaticScope staticScope, ByteList prefix, int coverageMode)
private	IRFor(IRClosure c, IRScope lexicalParent, int id, ByteList fullName)	Used by cloning code for inlining
	IRFor(IRManager manager, IRScope lexicalParent, int lineNumber, StaticScope staticScope, Signature signature, ByteList labelPrefix)
	IRMetaClassBody(IRManager manager, IRScope lexicalParent, ByteList name, int lineNumber, StaticScope scope)
	IRMethod(IRManager manager, IRScope lexicalParent, DefNode defn, ByteList name, boolean isInstanceMethod, int lineNumber, StaticScope staticScope, int coverageMode)
	IRModuleBody(IRManager manager, IRScope lexicalParent, ByteList name, int lineNumber, StaticScope staticScope, boolean executesOnce)
	IRScope(IRManager manager, IRScope lexicalParent, ByteList name, int lineNumber, StaticScope staticScope)
	IRScope(IRManager manager, IRScope lexicalParent, ByteList name, int lineNumber, StaticScope staticScope, int coverageMode)

Uses of ByteList in org.jruby.ir.instructions

Fields in org.jruby.ir.instructions declared as ByteList

Modifier and Type	Field	Description
static final ByteList	ArrayDerefInstr.AREF
static final ByteList	ArrayDerefInstr.ASET
private static final ByteList	UnresolvedSuperInstr.DYNAMIC_SUPER_TARGET
private static final ByteList	MatchInstr.MATCH
static final ByteList	AsStringInstr.TO_S

Uses of ByteList in org.jruby.ir.operands

Fields in org.jruby.ir.operands declared as ByteList

Modifier and Type	Field	Description
final ByteList	FrozenString.bytelist
private final ByteList	Regexp.source

Methods in org.jruby.ir.operands that return ByteList

Modifier and Type	Method	Description
ByteList	FrozenString.getByteList()
ByteList	MutableString.getByteList()
ByteList	StringLiteral.getByteList()
ByteList	Symbol.getBytes()
ByteList	Regexp.getSource()

Methods in org.jruby.ir.operands with parameters of type ByteList

Modifier and Type	Method	Description
private static String	FrozenString.internedStringFromByteList(ByteList val)

Constructors in org.jruby.ir.operands with parameters of type ByteList

Modifier	Constructor	Description
private	FrozenString(ByteList byteList)
	FrozenString(ByteList bytelist, int coderange, String file, int line)	Used by persistence and by .freeze optimization
	MutableString(ByteList val, int coderange, String file, int line)
	Regexp(ByteList source, RegexpOptions options)

Uses of ByteList in org.jruby.ir.persistence

Fields in org.jruby.ir.persistence declared as ByteList

Modifier and Type	Field	Description
private final ByteList	IRReaderStream.filename	Filename to use for the script

Methods in org.jruby.ir.persistence that return ByteList

Modifier and Type	Method	Description
ByteList	IRReaderDecoder.decodeByteList()
ByteList	IRReaderStream.decodeByteList()
ByteList	IRReaderDecoder.getFilename()
ByteList	IRReaderStream.getFilename()

Methods in org.jruby.ir.persistence with parameters of type ByteList

Modifier and Type	Method	Description
static IRScope	IRReader.createScope(IRManager manager, IRScopeType type, ByteList byteName, String file, int line, IRScope lexicalParent, Signature signature, StaticScope staticScope)
void	IRWriterAnalyzer.encode(ByteList value)
void	IRWriterEncoder.encode(ByteList bytelist)
void	IRWriterStream.encode(ByteList value)

Constructors in org.jruby.ir.persistence with parameters of type ByteList

Modifier	Constructor	Description
private	IRReaderStream(ByteBuffer buf, IRManager manager, List<IRScope> scopes, IRScope currentScope, ByteList filename, RubySymbol[] constantPool)
	IRReaderStream(IRManager manager, byte[] bytes, ByteList filename)
	IRReaderStream(IRManager manager, File file, ByteList filename)

Uses of ByteList in org.jruby.ir.runtime

Methods in org.jruby.ir.runtime that return ByteList

Modifier and Type	Method	Description
static final ByteList	IRRuntimeHelpers.newByteListFromRaw(Ruby runtime, String str, String encoding)

Methods in org.jruby.ir.runtime with parameters of type ByteList

Modifier and Type	Method	Description
static RubyString	IRRuntimeHelpers.newFrozenString(ThreadContext context, ByteList bytelist, int coderange, String file, int line)
static RubyRegexp	IRRuntimeHelpers.newLiteralRegexp(ThreadContext context, ByteList source, int embeddedOptions)
static RubyRegexp	IRRuntimeHelpers.newLiteralRegexp(ThreadContext context, ByteList source, RegexpOptions options)
static RubyProc	IRRuntimeHelpers.newSymbolProc(ThreadContext context, ByteList value)	Create a new Symbol.to_proc for the given symbol name and encoding.

Uses of ByteList in org.jruby.ir.targets

Methods in org.jruby.ir.targets with parameters of type ByteList

Modifier and Type	Method	Description
void	ConstantCompiler.inheritanceSearchConst(String id, ByteList name)	Lookup a constant from a given class or module.
void	ConstantCompiler.lexicalSearchConst(String id, ByteList name)	Lookup a constant from a lexical scope.
void	ValueCompiler.pushByteList(ByteList bl)	Stack required: none
void	ValueCompiler.pushConstantLookupSite(String className, String siteName, ByteList name)	Load a ConstantLookupSite onto the stack
void	ValueCompiler.pushFrozenString(ByteList bl, int cr, String path, int line)	Stack required: none
void	ValueCompiler.pushRegexp(ByteList source, int options)	Build and save a literal regular expression.
void	ValueCompiler.pushString(ByteList bl, int cr)	Stack required: none
void	ValueCompiler.pushSymbol(ByteList bytes)	Push a symbol on the stack.
void	ValueCompiler.pushSymbolProc(ByteList bytes)	Push a Symbol.to_proc on the stack.
void	ConstantCompiler.searchConst(String id, ByteList name, boolean noPrivateConsts)	Lookup a constant from current context.
void	ConstantCompiler.searchModuleForConst(String id, ByteList name, boolean noPrivateConsts, boolean callConstMissing)	Lookup a constant from current module.

Uses of ByteList in org.jruby.ir.targets.indy

Fields in org.jruby.ir.targets.indy declared as ByteList

Modifier and Type	Field	Description
protected final ByteList	RegexpObjectSite.pattern

Methods in org.jruby.ir.targets.indy that return ByteList

Modifier and Type	Method	Description
static ByteList	Bootstrap.bytelist(String value, String encodingName)

Methods in org.jruby.ir.targets.indy with parameters of type ByteList

Modifier and Type	Method	Description
static RubyString	Bootstrap.frozenString(ThreadContext context, MutableCallSite site, ByteList value, int cr, String file, int line)
void	IndyConstantCompiler.inheritanceSearchConst(String id, ByteList name)
void	IndyConstantCompiler.lexicalSearchConst(String id, ByteList name)
void	IndyValueCompiler.pushByteList(ByteList bl)
void	IndyValueCompiler.pushConstantLookupSite(String className, String siteName, ByteList name)
void	IndyValueCompiler.pushFrozenString(ByteList bl, int cr, String file, int line)
void	IndyValueCompiler.pushRegexp(ByteList source, int options)
void	IndyValueCompiler.pushString(ByteList bl, int cr)
void	IndyValueCompiler.pushSymbol(ByteList bytes)
void	IndyValueCompiler.pushSymbolProc(ByteList bytes)
void	IndyConstantCompiler.searchConst(String id, ByteList name, boolean noPrivateConsts)
void	IndyConstantCompiler.searchModuleForConst(String id, ByteList name, boolean noPrivateConsts, boolean callConstMissing)
static RubyString	Bootstrap.string(ThreadContext context, ByteList value, int cr)

Constructors in org.jruby.ir.targets.indy with parameters of type ByteList

Modifier	Constructor	Description
	RegexpObjectSite(MethodType type, ByteList pattern, int embeddedOptions)

Uses of ByteList in org.jruby.ir.targets.simple

Methods in org.jruby.ir.targets.simple with parameters of type ByteList

Modifier and Type	Method	Description
void	NormalConstantCompiler.inheritanceSearchConst(String id, ByteList name)
void	NormalConstantCompiler.lexicalSearchConst(String id, ByteList name)
void	NormalValueCompiler.pushByteList(ByteList bl)
void	NormalValueCompiler.pushConstantLookupSite(String className, String siteName, ByteList name)
void	NormalValueCompiler.pushFrozenString(ByteList bl, int cr, String file, int line)
void	NormalValueCompiler.pushRegexp(ByteList source, int options)
void	NormalValueCompiler.pushString(ByteList bl, int cr)
void	NormalValueCompiler.pushSymbol(ByteList bytes)
void	NormalValueCompiler.pushSymbolProc(ByteList bytes)
void	NormalConstantCompiler.searchConst(String id, ByteList name, boolean noPrivateConsts)
void	NormalConstantCompiler.searchModuleForConst(String id, ByteList name, boolean noPrivateConsts, boolean callConstMissing)

Uses of ByteList in org.jruby.ir.transformations.inlining

Fields in org.jruby.ir.transformations.inlining declared as ByteList

Modifier and Type	Field	Description
private ByteList	InlineCloneInfo.inlineVarPrefix

Uses of ByteList in org.jruby.lexer

Fields in org.jruby.lexer declared as ByteList

Modifier and Type	Field	Description
static final ByteList	LexingCommon.AMPERSAND
static final ByteList	LexingCommon.AMPERSAND_AMPERSAND
static final ByteList	LexingCommon.AMPERSAND_DOT
static final ByteList	LexingCommon.BACKSLASH
static final ByteList	LexingCommon.BACKTICK
static final ByteList	LexingCommon.BANG
static final ByteList	LexingCommon.BANG_EQ
static final ByteList	LexingCommon.BANG_TILDE
static ByteList	LexingCommon.BEGIN_DOC_MARKER
static final ByteList	LexingCommon.CALL
static final ByteList	LexingCommon.CARET
static ByteList	LexingCommon.CODING
static final ByteList	LexingCommon.COLON
static final ByteList	LexingCommon.COLON_COLON
static final ByteList	LexingCommon.COMMA
private final ByteList	ByteListLexerSource.completeSource
private ByteList	LexingCommon.current_arg
static final ByteList	LexingCommon.DOLLAR_BANG
static final ByteList	LexingCommon.DOLLAR_DOT
static final ByteList	LexingCommon.DOLLAR_UNDERSCORE
static final ByteList	LexingCommon.DOT
static final ByteList	LexingCommon.DOT_DOT
static final ByteList	LexingCommon.DOT_DOT_DOT
static ByteList	LexingCommon.END_DOC_MARKER
static ByteList	LexingCommon.END_MARKER
static final ByteList	LexingCommon.EQ
static final ByteList	LexingCommon.EQ_EQ
static final ByteList	LexingCommon.EQ_EQ_EQ
static final ByteList	LexingCommon.EQ_GT
static final ByteList	LexingCommon.EQ_TILDE
static final ByteList	LexingCommon.GT
static final ByteList	LexingCommon.GT_EQ
static final ByteList	LexingCommon.GT_GT
private ByteList	StrftimeLexer.input
static final ByteList	LexingCommon.LBRACKET
static final ByteList	LexingCommon.LBRACKET_RBRACKET
static final ByteList	LexingCommon.LBRACKET_RBRACKET_EQ
static final ByteList	LexingCommon.LCURLY
ByteList	LexingCommon.lex_lastline
protected ByteList	LexingCommon.lex_nextline
ByteList	LexingCommon.lexb
static final ByteList	LexingCommon.LT
static final ByteList	LexingCommon.LT_EQ
static final ByteList	LexingCommon.LT_EQ_RT
static final ByteList	LexingCommon.LT_LT
static final ByteList	LexingCommon.MINUS
static final ByteList	LexingCommon.MINUS_AT
static final ByteList	LexingCommon.MINUS_GT
static final ByteList	LexingCommon.OR
static final ByteList	LexingCommon.OR_OR
static final ByteList	LexingCommon.PERCENT
static final ByteList	LexingCommon.PLUS
static final ByteList	LexingCommon.PLUS_AT
static final ByteList	LexingCommon.Q
static final ByteList	LexingCommon.QQ
static final ByteList	LexingCommon.QUESTION
static final ByteList	LexingCommon.RBRACKET
static final ByteList	LexingCommon.RCURLY
static final ByteList	LexingCommon.RPAREN
static final ByteList	LexingCommon.SEMICOLON
static final ByteList	LexingCommon.SLASH
static final ByteList	LexingCommon.STAR
static final ByteList	LexingCommon.STAR_STAR
static final ByteList	LexingCommon.TILDE

Methods in org.jruby.lexer that return ByteList

Modifier and Type	Method	Description
ByteList	LexingCommon.createTokenByteList()
ByteList	LexingCommon.createTokenByteList(int start)
ByteList	LexingCommon.getCurrentArg()
ByteList	ByteListLexerSource.gets()
ByteList	GetsLexerSource.gets()
abstract ByteList	LexerSource.gets()
private ByteList	StrftimeLexer.parseFlags()

Methods in org.jruby.lexer with parameters of type ByteList

Modifier and Type	Method	Description
void	LexingCommon.checkRegexpFragment(Ruby runtime, ByteList value, RegexpOptions options)
void	LexingCommon.checkRegexpSyntax(Ruby runtime, ByteList value, RegexpOptions options)
static int	LexingCommon.dedent_string(ByteList string, int width)
RubyDateFormatter.Token	StrftimeLexer.formatter(ByteList flags, Integer widthString)
private boolean	LexingCommon.is7BitASCII(ByteList value)
protected void	LexingCommon.magicCommentEncoding(ByteList encoding)
static int	LexingCommon.magicCommentMarker(ByteList str, int begin)
protected boolean	LexingCommon.onMagicComment(String name, ByteList value)
boolean	LexingCommon.parser_magic_comment(ByteList magicLine)
void	StrftimeLexer.reset(ByteList input)
protected abstract void	LexingCommon.setCompileOptionFlag(String name, ByteList value)
void	LexingCommon.setCurrentArg(ByteList current_arg)
protected abstract void	LexingCommon.setEncoding(ByteList name)
void	LexingCommon.setRegexpEncoding(Ruby runtime, ByteList value, RegexpOptions options)
protected abstract void	LexingCommon.setTokenInfo(String name, ByteList value)
protected boolean	LexingCommon.strncmp(ByteList one, ByteList two, int length)
void	LexingCommon.tokAdd(int first_byte, ByteList buffer)
boolean	LexingCommon.tokadd_mbchar(int first_byte, ByteList buffer)
void	LexingCommon.tokaddmbc(int codepoint, ByteList buffer)	This looks deceptively like tokadd_mbchar(int, ByteList) but it differs in that it uses the bytelists encoding and the first parameter is a full codepoint and not the first byte of a mbc sequence.
void	LexingCommon.tokCopy(int length, ByteList buffer)
void	LexingCommon.validateFormalIdentifier(ByteList identifier)
boolean	LexingCommon.whole_match_p(ByteList eos, boolean indent)

Constructors in org.jruby.lexer with parameters of type ByteList

Modifier	Constructor	Description
	ByteListLexerSource(String sourceName, int line, ByteList in, RubyArray list)	Create our food-source for the lexer.

Uses of ByteList in org.jruby.lexer.yacc

Fields in org.jruby.lexer.yacc declared as ByteList

Modifier and Type	Field	Description
final ByteList	RubyLexer.Keyword.bytes
private final ByteList	RubyLexer.FALSE
protected final ByteList	HeredocTerm.lastLine
private final ByteList	HeredocTerm.nd_lit
private ByteList	RubyLexer.numberBuffer
private final ByteList	RubyLexer.TRUE

Fields in org.jruby.lexer.yacc with type parameters of type ByteList

Modifier and Type	Field	Description
private static final Map<ByteList,RubyLexer.Keyword>	RubyLexer.byteList2Keyword

Methods in org.jruby.lexer.yacc with parameters of type ByteList

Modifier and Type	Method	Description
protected int	RubyLexer.asTruth(String name, ByteList value)
StrNode	RubyLexer.createStr(ByteList buffer, int flags)
protected int	HeredocTerm.error(RubyLexer lexer, int len, ByteList str, ByteList eos)
private void	StringTerm.escaped(RubyLexer lexer, ByteList buffer)
private int	HeredocTerm.flush(RubyLexer lexer, boolean bol, ByteList tok)
static RubyLexer.Keyword	RubyLexer.getKeyword(ByteList str)
private int	RubyLexer.identifierToken(int result, ByteList value)
private void	StringTerm.parseEscapeIntoBuffer(RubyLexer lexer, ByteList buffer)
int	StringTerm.parseStringIntoBuffer(RubyLexer lexer, ByteList buffer, org.jcodings.Encoding encoding, boolean[] encodingDetermined)
private String	RubyLexer.prepareMessage(String message, ByteList line, long start, long end)
private void	RubyLexer.readUTF8EscapeIntoBuffer(int codepoint, ByteList buffer, boolean stringLiteral, boolean[] encodingDetermined)
int	RubyLexer.readUTFEscape(ByteList buffer, boolean stringLiteral, boolean[] encodingDetermined)
void	RubyLexer.readUTFEscapeRegexpLiteral(ByteList buffer)
private char	RubyLexer.scanHexLiteral(ByteList buffer, int count, boolean strict, String errorMessage)	Read up to count hexadecimal digits and store those digits in a token numberBuffer.
protected void	RubyLexer.setCompileOptionFlag(String name, ByteList value)
protected void	RubyLexer.setEncoding(ByteList name)
protected void	RubyLexer.setTokenInfo(String name, ByteList value)

Constructors in org.jruby.lexer.yacc with parameters of type ByteList

Modifier	Constructor	Description
	HeredocTerm(ByteList marker, int func, int nth, int line, ByteList lastLine)
private	Keyword(String name, ByteList bytes, int id0, int id1, int state)

Uses of ByteList in org.jruby.parser

Fields in org.jruby.parser declared as ByteList

Modifier and Type	Field	Description
static final ByteList	ParserSupport.INTERNAL_ID

Methods in org.jruby.parser that return ByteList

Modifier and Type	Method	Description
private ByteList	ParserSupport.createMaster(RegexpOptions options)
ByteList	ParserSupport.formal_argument(ByteList identifier)
ByteList	ParserSupport.shadowing_lvar(ByteList nameBytes)

Methods in org.jruby.parser with parameters of type ByteList

Modifier and Type	Method	Description
ArgumentNode	ParserSupport.arg_var(ByteList byteName)
AssignableNode	ParserSupport.assignableInCurr(ByteList nameBytes, Node value)
AssignableNode	ParserSupport.assignableKeyword(ByteList name, Node value)
AssignableNode	ParserSupport.assignableLabelOrIdentifier(ByteList byteName, Node value)
static int	ParserSupport.associateEncoding(ByteList buffer, org.jcodings.Encoding newEncoding, int codeRange)
Node	ParserSupport.asSymbol(int line, ByteList value)
Node	ParserSupport.attrset(Node receiver, ByteList name)	Define an attribute set condition so we can return lhs
Node	ParserSupport.attrset(Node receiver, ByteList callType, ByteList name)
Node	ParserSupport.declareIdentifier(ByteList byteName)
ByteList	ParserSupport.formal_argument(ByteList identifier)
Node	ParserSupport.getOperatorCallNode(Node firstNode, ByteList operator)
Node	ParserSupport.getOperatorCallNode(Node firstNode, ByteList operator, Node secondNode)
Node	ParserSupport.getOperatorCallNode(Node firstNode, ByteList operator, Node secondNode, int defaultPosition)
private Node	ParserSupport.getOperatorCallNodeInner(Node firstNode, ByteList operator, Node secondNode)
static boolean	ParserSupport.is_local_id(ByteList name)
static boolean	ParserSupport.is_private_local_id(ByteList name)
boolean	ParserSupport.isLazy(ByteList callType)
ArgsTailHolder	ParserSupport.new_args_tail(int line, ListNode keywordArg, ByteList keywordRestArgName, BlockArgNode blockArg)
Node	ParserSupport.new_ary_op_assign(Node receiverNode, ByteList operatorName, Node argsNode, Node valueNode)
Node	ParserSupport.new_attr_op_assign(Node receiverNode, ByteList callType, Node valueNode, ByteList variableName, ByteList operatorName)
Node	ParserSupport.new_attrassign(int line, Node receiver, ByteList name, Node argsNode, boolean isLazy)
Node	ParserSupport.new_bv(ByteList identifier)
Node	ParserSupport.new_call(Node receiver, ByteList name, Node argsNode, Node iter)
Node	ParserSupport.new_call(Node receiver, ByteList callType, ByteList name, Node argsNode, Node iter)
Node	ParserSupport.new_call(Node receiver, ByteList callType, ByteList name, Node argsNode, Node iter, int line)
Colon2Node	ParserSupport.new_colon2(int line, Node leftNode, ByteList name)
Colon3Node	ParserSupport.new_colon3(int line, ByteList name)
Node	ParserSupport.new_const_op_assign(int line, Node lhs, ByteList operatorName, Node rhs)
Node	ParserSupport.new_fcall(ByteList operation)
Node	ParserSupport.new_op_assign(AssignableNode receiverNode, ByteList operatorName, Node valueNode)
Node	Parser.parse(String file, ByteList content, DynamicScope blockScope, ParserConfiguration configuration)
ByteList	ParserSupport.shadowing_lvar(ByteList nameBytes)
RubySymbol	ParserSupport.symbolID(ByteList identifierValue)

Uses of ByteList in org.jruby.runtime

Methods in org.jruby.runtime with parameters of type ByteList

Modifier and Type	Method	Description
static RubyString	Helpers.appendByteList(RubyString target, ByteList source)	Deprecated.
static String	Helpers.byteListToString(ByteList bytes)	Convert a ByteList into a Java String by using its Encoding's Charset.
static String	Helpers.decodeByteList(Ruby runtime, ByteList value)	Decode a given ByteList to a Java string.
static IRubyObject	Helpers.stringOrNil(ByteList value, ThreadContext context)	Deprecated.
static String	Helpers.symbolBytesToString(ByteList value)	Decode the given value to a Java string using the following rules: * If the string is all US-ASCII characters, it will be decoded as US-ASCII.

Uses of ByteList in org.jruby.runtime.encoding

Fields in org.jruby.runtime.encoding declared as ByteList

Modifier and Type	Field	Description
private static ByteList	EncodingService.defaultCharsetName
private static final ByteList	EncodingService.EXTERNAL_BL
private static final ByteList	EncodingService.FILESYSTEM_BL
private static final ByteList	EncodingService.INTERNAL_BL
private static final ByteList	EncodingService.LOCALE_BL

Methods in org.jruby.runtime.encoding with parameters of type ByteList

Modifier and Type	Method	Description
private void	EncodingService.checkAsciiEncodingName(ByteList name)
org.jcodings.EncodingDB.Entry	EncodingService.findAliasEntry(ByteList bytes)
private org.jcodings.Encoding	EncodingService.findEncodingCommon(ByteList name, boolean error)
org.jcodings.EncodingDB.Entry	EncodingService.findEncodingEntry(ByteList bytes)
org.jcodings.Encoding	EncodingService.findEncodingNoError(ByteList str)
org.jcodings.EncodingDB.Entry	EncodingService.findEncodingOrAliasEntry(ByteList bytes)
org.jcodings.Encoding	EncodingService.findEncodingWithError(ByteList name)	Find a non-special encoding, raising argument error if it does not exist.
private org.jcodings.EncodingDB.Entry	EncodingService.findEntryWithError(ByteList name)	Find a non-special encoding Entry, raising argument error if it does not exist.
org.jcodings.Encoding	EncodingService.loadEncoding(ByteList name)
static EncodingService.SpecialEncoding	EncodingService.SpecialEncoding.valueOf(ByteList name)	Returns the enum constant of this type with the specified name.

Uses of ByteList in org.jruby.runtime.load

Methods in org.jruby.runtime.load that return ByteList

Modifier and Type	Method	Description
ByteList	LibrarySearcher.Suffix.forTarget(ByteList targetName)

Methods in org.jruby.runtime.load with parameters of type ByteList

Modifier and Type	Method	Description
ByteList	LibrarySearcher.Suffix.forTarget(ByteList targetName)

Uses of ByteList in org.jruby.runtime.marshal

Fields in org.jruby.runtime.marshal with type parameters of type ByteList

Modifier and Type	Field	Description
private final Map<ByteList,Integer>	MarshalCache.symbolCache

Methods in org.jruby.runtime.marshal that return ByteList

Modifier and Type	Method	Description
ByteList	UnmarshalStream.unmarshalString()

Methods in org.jruby.runtime.marshal with parameters of type ByteList

Modifier and Type	Method	Description
void	MarshalStream.dumpSymbol(ByteList value)
boolean	MarshalCache.isSymbolRegistered(ByteList sym)
private int	MarshalCache.registeredSymbolIndex(ByteList sym)
void	MarshalCache.registerSymbol(ByteList sym)
void	MarshalStream.registerSymbol(ByteList sym)
private void	MarshalStream.writeAndRegisterSymbol(ByteList sym)
void	MarshalStream.writeString(ByteList value)
void	MarshalCache.writeSymbolLink(MarshalStream output, ByteList sym)

Uses of ByteList in org.jruby.util

Fields in org.jruby.util declared as ByteList

Modifier and Type	Field	Description
static final ByteList	CommonByteLists._END_
private static final ByteList	RubyDateFormatter.AM
static final ByteList	CommonByteLists.AMPERSAND_AMPERSAND
static final ByteList	CommonByteLists.AREF_METHOD
static final ByteList	CommonByteLists.ASET_METHOD
static final ByteList	CommonByteLists.BACKTRACE_IN
private static final ByteList	RubyDateFormatter.CAPITAL_AM
private static final ByteList	RubyDateFormatter.CAPITAL_PM
static final ByteList	CommonByteLists.CARET
static final ByteList	CommonByteLists.COLON
static final ByteList	CommonByteLists.COLON_COLON
static final ByteList	CommonByteLists.CONSTANTS
static final ByteList	CommonByteLists.DASH
static final ByteList	CommonByteLists.DEFINE_METHOD_METHOD
static final ByteList	CommonByteLists.DOLLAR_BACKSLASH
static final ByteList	CommonByteLists.DOLLAR_SLASH
static final ByteList	CommonByteLists.DOT
static final ByteList	CommonByteLists.EACH
static final ByteList	CommonByteLists.EMPTY
static final ByteList	Inspector.EMPTY_ARRAY_BL
static final ByteList	ByteList.EMPTY_BYTELIST
static final ByteList[]	StringSupport.EMPTY_BYTELIST_ARRAY
static final ByteList	Inspector.EMPTY_HASH_BL
static final ByteList	CommonByteLists.EQUAL_TILDE
static final ByteList	CommonByteLists.EXCEPTION
(package private) final ByteList	RubyTimeOutputFormatter.flags
static final ByteList	CommonByteLists.FREEZE_METHOD
final ByteList	Dir.DirGlobber.link
static final ByteList	CommonByteLists.METHODS
static final ByteList	CommonByteLists.MINUS
static final ByteList	CommonByteLists.NEW
static final ByteList	CommonByteLists.NEW_METHOD
static final ByteList	CommonByteLists.NEWLINE
static final ByteList	CommonByteLists.NOT_IMPLEMENTED_ERROR
static final ByteList	CommonByteLists.OR_OR
static final ByteList	CommonByteLists.PERCENT_PLUS
static final ByteList	CommonByteLists.PERCENT_Q
private static final ByteList	RubyDateFormatter.PM
static final ByteList	Inspector.RECURSIVE_ARRAY_BL
static final ByteList	Inspector.RECURSIVE_HASH_BL
static final ByteList	CommonByteLists.REFINE_METHOD
static final ByteList	CommonByteLists.SINGLE_QUOTE
static final ByteList	CommonByteLists.SLASH
static final ByteList	CommonByteLists.STAR
private final ByteList	ConvertBytes.str
static final ByteList	CommonByteLists.TAB
static final ByteList	CommonByteLists.UNDERSCORE
static final ByteList	CommonByteLists.USING_METHOD
private static final ByteList	RegexpOptions.WINDOWS31J
static final ByteList	CommonByteLists.ZERO

Fields in org.jruby.util with type parameters of type ByteList

Modifier and Type	Field	Description
(package private) final List<ByteList>	Dir.GlobArgs.arg
(package private) final Dir.GlobFunc<List<ByteList>>	Dir.GlobArgs.func
private static final Dir.GlobFunc<List<ByteList>>	Dir.push_pattern

Methods in org.jruby.util that return ByteList

Modifier and Type	Method	Description
static ByteList	StringSupport.addByteLists(ByteList value1, ByteList value2)
ByteList	ByteList.append(byte b)	Append a single byte to the ByteList
ByteList	ByteList.append(int b)	Append a single byte to the ByteList by truncating the given int
ByteList	ByteList.append(InputStream input, int len)	Append up to length bytes from InputStream to the ByteList.
static ByteList	StringSupport.caseMap(Ruby runtime, ByteList src, org.jcodings.IntHolder flags, org.jcodings.Encoding enc)
static ByteList	ByteList.create(CharSequence s)	Create a bytelist with ISO_8859_1 encoding from the provided CharSequence.
static ByteList	StringSupport.dumpCommon(Ruby runtime, ByteList bytelist)	rb_str_dump
static ByteList	StringSupport.dumpCommon(Ruby runtime, ByteList byteList, boolean quoteOnlyIfNeeded)
ByteList	ByteList.dup()	creates a duplicate of this bytelist but only in the case of a stringValue and its resulting hash value.
ByteList	ByteList.dup(int length)
private static ByteList	Pack.encodes(Ruby runtime, ByteList io2Append, byte[] charsToEncode, int startIndex, int length, int charCount, byte encodingType, boolean tailLf)	encodes a String in base64 or its uuencode variant.
private ByteList	RubyDateFormatter.formatToByteList(RubyDateFormatter.Token[] compiledPattern, org.joda.time.DateTime dt, long nsec, RubyNumeric sub_millis)
private static ByteList	RubyDateFormatter.formatZone(int colons, int value, RubyTimeOutputFormatter formatter)
ByteList	ByteListHolder.getByteList()
private static final ByteList	Pack.grow(ByteList i2Grow, byte[] iPads, int iLength)	grows a stringbuffer.
static final ByteList	ConvertBytes.intToBinaryByteList(int i)
static final ByteList	ConvertBytes.intToHexByteList(int i)
static final ByteList	ConvertBytes.intToHexByteList(int i, boolean upper)
static final ByteList	ConvertBytes.intToOctalByteList(int i)
private static final ByteList	ConvertBytes.intToUnsignedByteList(int i, int shift, byte[] digitmap)
static final ByteList	ConvertBytes.longToBinaryByteList(long i)
static final ByteList	ConvertBytes.longToByteList(long i)
static final ByteList	ConvertBytes.longToByteList(long i, int radix)
static final ByteList	ConvertBytes.longToByteList(long i, int radix, byte[] digitmap)
static final ByteList	ConvertBytes.longToByteListSimple(long i)
static final ByteList	ConvertBytes.longToHexByteList(long i)
static final ByteList	ConvertBytes.longToHexByteList(long i, boolean upper)
static final ByteList	ConvertBytes.longToOctalByteList(long i)
private static final ByteList	ConvertBytes.longToUnsignedByteList(long i, int shift, byte[] digitmap)
ByteList	ByteList.makeShared(int index, int len)	Make a shared copy of this ByteList.
static ByteList	Pack.packInt_i(ByteList result, int s)
static ByteList	RegexpSupport.preprocess(Ruby runtime, ByteList str, org.jcodings.Encoding enc, org.jcodings.Encoding[] fixedEnc, RegexpSupport.ErrorMode mode)	Preprocess the given string for use in regexp, raising errors for encoding incompatibilities that arise.
static ByteList	PackUtils.qpencode(ByteList io2Append, ByteList i2Encode, int iLength)	encodes a String with the Quoted printable, MIME encoding (see RFC2045).
private static ByteList	RegexpSupport.regexpDescription19(Ruby runtime, byte[] s, int start, int len, RegexpOptions options, org.jcodings.Encoding enc)
static ByteList	RegexpSupport.regexpDescription19(Ruby runtime, ByteList bytes, RegexpOptions options, org.jcodings.Encoding enc)
static ByteList	StringSupport.replaceInternal(int beg, int len, ByteListHolder source, CodeRangeable repl)
ByteList	ByteList.shallowDup()	Create a new ByteList but do not array copy the byte backing store.
private static final ByteList	Pack.shrink(ByteList i2Shrink, int iLength)	shrinks a stringbuffer.
static ByteList	StringSupport.succCommon(Ruby runtime, ByteList original)
static ByteList	StringSupport.succCommon(ByteList original)

Methods in org.jruby.util that return types with arguments of type ByteList

Modifier and Type	Method	Description
static List<ByteList>	Dir.push_glob(Ruby runtime, String cwd, ByteList globByteList, int flags)

Methods in org.jruby.util with parameters of type ByteList

Modifier and Type	Method	Description
static ByteList	StringSupport.addByteLists(ByteList value1, ByteList value2)
void	ByteList.append(ByteList moreBytes)	Append moreBytes onto the end of the current ByteList.
void	ByteList.append(ByteList moreBytes, int index, int len)	Append moreBytes onto the end of the current ByteList with +index as the new begin for len bytes from the moreBytes ByteList.
static void	RegexpSupport.appendOptions(ByteList to, RegexpOptions options)
private static IRubyObject	Pack.appendOrYield(ThreadContext context, Block block, RubyArray result, ByteList item, int mode, boolean taint)
static void	RegexpSupport.appendRegexpString19(Ruby runtime, ByteList to, byte[] bytes, int start, int len, org.jcodings.Encoding enc, org.jcodings.Encoding resEnc)
private static void	RegexpSupport.appendUtf8(Ruby runtime, ByteList to, int code, org.jcodings.Encoding[] enc, ByteList str, RegexpSupport.ErrorMode mode)	Append the given utf8 characters to the buffer, if given, checking for errors along the way.
static org.jcodings.Encoding	StringSupport.areCompatible(ByteList str1, ByteList str2)
static void	StringSupport.asciiOnlyCaseMap(Ruby runtime, ByteList value, org.jcodings.IntHolder flags, org.jcodings.Encoding enc)
static String	StringSupport.byteListAsString(ByteList bytes)
static double	ConvertDouble.byteListToDouble19(ByteList bytes, boolean strict)	Converts supplied ByteList into a double.
static RubyInteger	ConvertBytes.byteListToInum(Ruby runtime, ByteList str, int base, boolean badcheck)
static IRubyObject	ConvertBytes.byteListToInum(Ruby runtime, ByteList str, int base, boolean badcheck, boolean exception)	rb_cstr_to_inum
static RubyInteger	ConvertBytes.byteListToInum(Ruby runtime, ByteList str, int off, int end, int base, boolean badcheck)
static RubyInteger	ConvertBytes.byteListToInum19(Ruby runtime, ByteList str, int base, boolean badcheck)	Deprecated.
static int	StringSupport.bytesToFixBrokenTrailingCharacter(ByteList val, int usingLength)
int	ByteList.caseInsensitiveCmp(ByteList other)	Do a case insensitive comparison with other ByteList with return types similiar to compareTo.
static ByteList	StringSupport.caseMap(Ruby runtime, ByteList src, org.jcodings.IntHolder flags, org.jcodings.Encoding enc)
static RubyString	RubyStringBuilder.cat(Ruby runtime, RubyString buf, ByteList bytes)
private void	Sprintf.Args.checkNameArg(ByteList name, char startDelim, char endDelim)
private static void	RegexpSupport.checkUnicodeRange(Ruby runtime, int code, ByteList str, RegexpSupport.ErrorMode mode)
int	ByteList.cmp(ByteList other)	This comparison matches MRI comparison of Strings (rb_str_cmp).
static int	StringSupport.codePoint(Ruby runtime, ByteList value)
static int	StringSupport.codeRangeScan(org.jcodings.Encoding enc, ByteList bytes)
void	RubyDateFormatter.compilePattern(ByteList pattern, boolean dateLibrary)
static int	StringSupport.countCommon19(ByteList str, Ruby runtime, boolean[] table, StringSupport.TrTables tables, org.jcodings.Encoding enc)	Deprecated. renamed to StringSupport.strCount(ByteList, Ruby, boolean[], TrTables, Encoding)
static SymbolNameType	IdUtil.determineSymbolNameType(Ruby runtime, ByteList data)
static ByteList	StringSupport.dumpCommon(Ruby runtime, ByteList bytelist)	rb_str_dump
static ByteList	StringSupport.dumpCommon(Ruby runtime, ByteList byteList, boolean quoteOnlyIfNeeded)
static boolean	ByteListHelper.eachCodePoint(ByteList bytelist, ByteListHelper.CodePoint each)	This method assumes the ByteList will be a valid string for the encoding which it is marked as.
static int	ByteListHelper.eachCodePointWhile(Ruby runtime, ByteList bytelist, int offset, ByteListHelper.CodePoint each)	If you know you have an ASCII ByteList you should do something else.
private static int	ByteListHelper.eachMBCCodePointWhile(ByteList bytelist, int offset, ByteListHelper.CodePoint each)
abstract void	Pack.Converter.encode(Ruby runtime, IRubyObject from, ByteList result)
abstract void	Pack.ConverterExecutor.encode(Ruby runtime, IRubyObject from, ByteList result)
static int	Pack.encode(Ruby runtime, int occurrences, ByteList result, RubyArray list, int index, Pack.ConverterExecutor converter)
private static void	Pack.encodeDoubleBigEndian(ByteList result, double d)	Encode a double in big-endian format into a packed value
private static void	Pack.encodeDoubleLittleEndian(ByteList result, double d)	Encode a double in little endian format into a packed value
private static void	Pack.encodeFloatBigEndian(ByteList result, float f)	Encode a float in big-endian format into a packed value
private static void	Pack.encodeFloatLittleEndian(ByteList result, float f)	Encode a float in little endian format into a packed value
private static void	Pack.encodeIntBigEndian(ByteList result, int s)	Encode an int in big-endian format into a packed representation.
private static void	Pack.encodeIntLittleEndian(ByteList result, int s)	Encode an int in little endian format into a packed representation.
private static void	Pack.encodeLongBigEndian(ByteList result, long l)	Encode a long in big-endian format into a packed value
protected void	Pack.QuadConverter.encodeLongByByteOrder(ByteList result, long l)
private static void	Pack.encodeLongLittleEndian(ByteList result, long l)	Encode a long in little-endian format into a packed value
private static ByteList	Pack.encodes(Ruby runtime, ByteList io2Append, byte[] charsToEncode, int startIndex, int length, int charCount, byte encodingType, boolean tailLf)	encodes a String in base64 or its uuencode variant.
private static void	Pack.encodeShortBigEndian(ByteList result, int s)	Encode an shortin big-endian format into a packed representation.
protected void	Pack.QuadConverter.encodeShortByByteOrder(ByteList result, int s)
private static void	Pack.encodeShortLittleEndian(ByteList result, int s)	Encode an short in little endian format into a packed representation.
static void	Pack.encodeUM(Ruby runtime, ByteList lCurElemString, int occurrences, boolean ignoreStar, char type, ByteList result)
boolean	ByteList.endsWith(ByteList other)	Does this ByteList end with the supplied ByteList?
boolean	ByteList.equal(ByteList other)	Does this ByteList equal the other ByteList?
void	RubyTimeOutputFormatter.format(ByteList out, long value, RubyDateFormatter.FieldType type)
void	RubyTimeOutputFormatter.format(ByteList out, CharSequence sequence)
(package private) static void	RubyTimeOutputFormatter.formatNumber(ByteList out, long value, int width, char padder)
(package private) static void	RubyTimeOutputFormatter.formatSignedNumber(ByteList out, long value, long second, int width, char padder)
private static void	RubyDateFormatter.formatSubMillisGt3(Ruby runtime, ByteList buff, int width, RubyNumeric sub_millis)
private IRubyObject	Sprintf.Args.getHashValue(ByteList name, char startDelim, char endDelim)
private static int	Dir.glob_helper(Ruby runtime, String cwd, ByteList path, int sub, int flags, Dir.GlobFunc<Dir.GlobArgs> func, Dir.GlobArgs arg)
private static final ByteList	Pack.grow(ByteList i2Grow, byte[] iPads, int iLength)	grows a stringbuffer.
static int	StringSupport.index(ByteList source, ByteList other, int offset, org.jcodings.Encoding enc)
int	ByteList.indexOf(ByteList find)	Get the index of first occurrence of Bytelist find in this ByteList.
int	ByteList.indexOf(ByteList find, int i)	Get the index of first occurrence of Bytelist find in this ByteList starting at index i.
void	ConvertDouble.DoubleConverter.init(ByteList list, boolean isStrict)
static RubyString	RubyStringBuilder.inspectIdentifierByteList(Ruby runtime, ByteList byteList)
static boolean	IdUtil.isConstantInitial(ByteList byteList)
int	ByteList.lastIndexOf(ByteList find)	Get the index of last occurrence of find in ByteList from the end of the ByteList.
int	ByteList.lastIndexOf(ByteList find, int pos)	Get the index of last occurrence of find in ByteList from the end of the ByteList.
static int	StringSupport.multiByteCasecmp(org.jcodings.Encoding enc, ByteList value, ByteList otherValue)
static boolean	StringSupport.multiByteSqueeze(Ruby runtime, ByteList value, boolean[] squeeze, StringSupport.TrTables tables, org.jcodings.Encoding enc, boolean isArg)
static boolean	StringSupport.multiByteSqueeze(ByteList value, boolean[] squeeze, StringSupport.TrTables tables, org.jcodings.Encoding enc, boolean isArg)
(package private) IRubyObject	Sprintf.Args.next(ByteList name)	Deprecated.
(package private) static void	RubyTimeOutputFormatter.outputLong(ByteList out, int length, long value)
static RubyString	Pack.pack(Ruby runtime, RubyArray list, ByteList formatString)	Same as pack but defaults tainting of output to false.
private static void	Pack.pack_at(ByteList result, int occurrences)
private static boolean	Pack.pack_h(ThreadContext context, RubyArray list, ByteList result, boolean taintOutput, Pack.PackInts packInts, int type, int occurrences, boolean isStar)
private static void	Pack.pack_h_aAZ(ByteList result, int type, ByteList lCurElemString, int occurrences)
private static void	Pack.pack_h_b(ByteList result, ByteList lCurElemString, int occurrences)
private static void	Pack.pack_h_B(ByteList result, ByteList lCurElemString, int occurrences)
private static void	Pack.pack_h_h(ByteList result, ByteList lCurElemString, int occurrences)
private static void	Pack.pack_h_H(ByteList result, ByteList lCurElemString, int occurrences)
private static void	Pack.pack_h_inner(ByteList result, int type, ByteList lCurElemString, int occurrences)
private static boolean	Pack.pack_m(ThreadContext context, RubyArray list, ByteList result, boolean taintOutput, Pack.PackInts packInts, char type, int occurrences, boolean ignoreStar)
private static boolean	Pack.pack_M(ThreadContext context, RubyArray list, ByteList result, boolean taintOutput, Pack.PackInts packInts, int occurrences)
private static void	Pack.pack_U(ThreadContext context, RubyArray list, ByteList result, Pack.PackInts packInts, int occurrences)
private static void	Pack.pack_w(ThreadContext context, RubyArray list, ByteList result, Pack.PackInts packInts, int occurrences)
private static void	Pack.pack_X(ThreadContext context, ByteList result, int occurrences)
private static RubyString	Pack.packCommon(ThreadContext context, RubyArray list, ByteList formatString, boolean tainted, Pack.ConverterExecutor executor, RubyString buffer)
static ByteList	Pack.packInt_i(ByteList result, int s)
private static void	RubyTimeOutputFormatter.padding(ByteList out, int len, int width, char padder)
double	ConvertDouble.DoubleConverter.parse(ByteList list, boolean strict, boolean is19)	Everything runs in 1.9+ mode now, so the `is19` parameter is vestigial.
static int	StringSupport.positionEndForScan(ByteList value, org.joni.Matcher matcher, org.jcodings.Encoding enc, int begin, int range)	rb_str_scan
static ByteList	RegexpSupport.preprocess(Ruby runtime, ByteList str, org.jcodings.Encoding enc, org.jcodings.Encoding[] fixedEnc, RegexpSupport.ErrorMode mode)	Preprocess the given string for use in regexp, raising errors for encoding incompatibilities that arise.
static List<ByteList>	Dir.push_glob(Ruby runtime, String cwd, ByteList globByteList, int flags)
private static int	Dir.push_globs(Ruby runtime, String cwd, List<ByteList> ary, ByteList pattern, int flags)
static ByteList	PackUtils.qpencode(ByteList io2Append, ByteList i2Encode, int iLength)	encodes a String with the Quoted printable, MIME encoding (see RFC2045).
static int	RegexpSupport.raisePreprocessError(Ruby runtime, ByteList str, String err, RegexpSupport.ErrorMode mode)
static void	RegexpSupport.raiseRegexpError19(Ruby runtime, ByteList bytes, org.jcodings.Encoding enc, RegexpOptions options, String err)
static int	RegexpSupport.readEscapedByte(Ruby runtime, byte[] to, int toP, byte[] bytes, int p, int end, ByteList str, RegexpSupport.ErrorMode mode)
static ByteList	RegexpSupport.regexpDescription19(Ruby runtime, ByteList bytes, RegexpOptions options, org.jcodings.Encoding enc)
void	ByteList.replace(int targetOff, int targetLen, ByteList source)	Replace a region of bytes in this ByteList with bytes from the given ByteList.
static int	StringSupport.rindex(ByteList source, int sourceChars, int subChars, int pos, CodeRangeable subStringCodeRangeable, org.jcodings.Encoding enc)
private static boolean	Sprintf.rubySprintf(ByteList to, CharSequence charFormat, Sprintf.Args args)
private static boolean	Sprintf.rubySprintfToBuffer(ByteList buf, CharSequence charFormat, Sprintf.Args args)
private static boolean	Sprintf.rubySprintfToBuffer(ByteList buf, CharSequence charFormat, Sprintf.Args args, boolean usePrefixForZero)
static int	StringSupport.searchNonAscii(ByteList bytes)
private static final ByteList	Pack.shrink(ByteList i2Shrink, int iLength)	shrinks a stringbuffer.
static boolean	StringSupport.singleByteSqueeze(ByteList value, boolean[] squeeze)
static <T> T	ByteListHelper.split(ByteList value, ByteList pattern, ByteListHelper.Visit<ByteList,T> bodyVisitor, ByteListHelper.Visit<ByteList,T> headVisitor)	Deprecated. This was only used by Module#const_defined, but was difficult to match MRI's equivalent in this form
static boolean	Sprintf.sprintf(Ruby runtime, ByteList to, CharSequence format, int arg)
static boolean	Sprintf.sprintf(Ruby runtime, ByteList to, CharSequence format, long arg)
static boolean	Sprintf.sprintf(ByteList to, CharSequence format, IRubyObject args)
static boolean	Sprintf.sprintf(ByteList to, Locale locale, CharSequence format, IRubyObject args)
static boolean	Sprintf.sprintf(ByteList to, RubyString format, IRubyObject args)
static boolean	Sprintf.sprintf1_9(ByteList to, Locale locale, CharSequence format, IRubyObject args)
boolean	ByteList.startsWith(ByteList other)	Does this ByteList start with the supplied ByteList?
boolean	ByteList.startsWith(ByteList other, int toffset)
static RubyDateFormatter.Token	RubyDateFormatter.Token.str(ByteList str)
static int	StringSupport.strCount(ByteList str, boolean[] table, StringSupport.TrTables tables, org.jcodings.Encoding enc)	rb_str_count
static int	StringSupport.strCount(ByteList str, Ruby runtime, boolean[] table, StringSupport.TrTables tables, org.jcodings.Encoding enc)
static int	StringSupport.strLength(ByteList bytes)
static int	StringSupport.strLengthFromRubyString(CodeRangeable string, ByteList bytes, org.jcodings.Encoding enc)
private static int	StringSupport.strLengthFromRubyStringFull(CodeRangeable string, ByteList bytes, org.jcodings.Encoding enc)
static long	StringSupport.strLengthWithCodeRange(ByteList bytes)
static long	StringSupport.strLengthWithCodeRange(ByteList bytes, org.jcodings.Encoding enc)
static ByteList	StringSupport.succCommon(Ruby runtime, ByteList original)
static ByteList	StringSupport.succCommon(ByteList original)
static StringSupport.TrTables	StringSupport.trSetupTable(ByteList str, boolean[] stable, StringSupport.TrTables tables, boolean first, org.jcodings.Encoding enc)
static StringSupport.TrTables	StringSupport.trSetupTable(ByteList str, Ruby runtime, boolean[] stable, StringSupport.TrTables tables, boolean first, org.jcodings.Encoding enc)
private static int	RegexpSupport.unescapeEscapedNonAscii(Ruby runtime, ByteList to, byte[] bytes, int p, int end, org.jcodings.Encoding enc, org.jcodings.Encoding[] encp, ByteList str, RegexpSupport.ErrorMode mode)	Unescape escaped non-ascii character at start position, appending all to the given bytelist if provided.
static boolean	RegexpSupport.unescapeNonAscii(Ruby runtime, ByteList to, byte[] bytes, int p, int end, org.jcodings.Encoding enc, org.jcodings.Encoding[] encp, ByteList str, RegexpSupport.ErrorMode mode)	Unescape non-ascii elements in the given string, appending the results to the given bytelist if provided.
private static int	RegexpSupport.unescapeUnicodeBmp(Ruby runtime, ByteList to, byte[] bytes, int p, int end, org.jcodings.Encoding[] encp, ByteList str, RegexpSupport.ErrorMode mode)	Unescape unicode BMP char at given offset, appending to the specified buffer if non-null.
private static int	RegexpSupport.unescapeUnicodeList(Ruby runtime, ByteList to, byte[] bytes, int p, int end, org.jcodings.Encoding[] encp, ByteList str, RegexpSupport.ErrorMode mode)	Unescape unicode characters at given offset, appending to the given out buffer if provided.
static RubyArray	Pack.unpack(Ruby runtime, ByteList encodedString, ByteList formatString)
static RubyArray	Pack.unpack(ThreadContext context, RubyString encoded, ByteList formatString)
private static void	Pack.unpack_at(Ruby runtime, ByteList encodedString, ByteBuffer encode, int occurrences)
static IRubyObject	Pack.unpack1WithBlock(ThreadContext context, RubyString encoded, ByteList formatString, Block block)
private static RubyString	Pack.unpackBase46Strict(Ruby runtime, ByteList input)
private static IRubyObject	Pack.unpackInternal(ThreadContext context, RubyString encoded, ByteList formatString, int mode, Block block)
static RubyArray	Pack.unpackWithBlock(ThreadContext context, Ruby runtime, ByteList encodedString, ByteList formatString, Block block)	Deprecated.
static RubyArray	Pack.unpackWithBlock(ThreadContext context, RubyString encoded, ByteList formatString, Block block)	Decodes str (which may contain binary data) according to the format string, returning an array of each value extracted.
void	ByteList.unsafeReplace(int beg, int len, ByteList nbytes)	Unsafe version of replace(int,int,ByteList).
static int	StringSupport.utf8Length(ByteList bytes)
private static void	Sprintf.writeExp(ByteList buf, int exponent, byte expChar)

Method parameters in org.jruby.util with type arguments of type ByteList

Modifier and Type	Method	Description
private static int	Dir.push_braces(Ruby runtime, String cwd, List<ByteList> result, Dir.GlobPattern pattern)
private static int	Dir.push_globs(Ruby runtime, String cwd, List<ByteList> ary, ByteList pattern, int flags)
static <T> T	ByteListHelper.split(ByteList value, ByteList pattern, ByteListHelper.Visit<ByteList,T> bodyVisitor, ByteListHelper.Visit<ByteList,T> headVisitor)	Deprecated. This was only used by Module#const_defined, but was difficult to match MRI's equivalent in this form

Constructors in org.jruby.util with parameters of type ByteList

Modifier	Constructor	Description
	ByteList(ByteList wrap)	Create a new instance of byte list with the same contents as the passed in ByteList wrap.
	ByteList(ByteList wrap, int index, int len)	Create a new instance of ByteList using wrap as a backing store where index is the first index in the byte array where the data starts and len indicates how long the data portion of the bytelist is.
	ConvertBytes(Ruby runtime, ByteList str, int base, boolean badcheck)
	ConvertBytes(Ruby runtime, ByteList str, int base, boolean badcheck, boolean is19)	Deprecated.
(package private)	ConvertBytes(Ruby runtime, ByteList str, int off, int end, int base, boolean badcheck)
(package private)	DirGlobber(ByteList link)
(package private)	GlobPattern(ByteList bytes, int flags)
	RubyTimeOutputFormatter(ByteList flags, int width)
	TR(ByteList bytes)

Constructor parameters in org.jruby.util with type arguments of type ByteList

Modifier	Constructor	Description
(package private)	GlobArgs(Dir.GlobFunc<List<ByteList>> func, List<ByteList> arg)
(package private)	GlobArgs(Dir.GlobFunc<List<ByteList>> func, List<ByteList> arg)

Uses of ByteList in org.jruby.util.io

Methods in org.jruby.util.io that return ByteList

Modifier and Type	Method	Description
ByteList	OpenFile.doWriteconv(ThreadContext context, byte[] bytes, int start, int length, org.jcodings.Encoding encoding)
static ByteList	EncodingUtils.econvAppend(ThreadContext context, org.jcodings.transcode.EConv ec, byte[] bytes, int start, int length, ByteList dst, int flags)
static ByteList	EncodingUtils.econvAppend(ThreadContext context, org.jcodings.transcode.EConv ec, ByteList sByteList, ByteList dst, int flags)
static ByteList	EncodingUtils.econvByteConvert(ThreadContext context, org.jcodings.transcode.EConv ec, byte[] bytes, int start, int length, int flags)
static ByteList	EncodingUtils.econvStrConvert(ThreadContext context, org.jcodings.transcode.EConv ec, ByteList src, int flags)
static ByteList	EncodingUtils.econvSubstrAppend(ThreadContext context, org.jcodings.transcode.EConv ec, ByteList src, ByteList dst, int flags)
static ByteList	EncodingUtils.rbByteEncode(ThreadContext context, byte[] bytes, int start, int length, org.jcodings.Encoding encoding, int cr, org.jcodings.Encoding to, int ecflags, IRubyObject ecopt)
static ByteList	EncodingUtils.strConvEnc(ThreadContext context, ByteList value, org.jcodings.Encoding fromEncoding, org.jcodings.Encoding toEncoding)
static ByteList	EncodingUtils.strConvEncOpts(ThreadContext context, ByteList str, org.jcodings.Encoding fromEncoding, org.jcodings.Encoding toEncoding, int ecflags, IRubyObject ecopts)
static ByteList	EncodingUtils.transcodeString(String string, org.jcodings.Encoding toEncoding, int ecflags)	A version of transcodeLoop for working without any Ruby runtime available.

Methods in org.jruby.util.io with parameters of type ByteList

Modifier and Type	Method	Description
static InetSocketAddress	Sockaddr.addressFromSockaddr_in(ThreadContext context, ByteList val)
static jnr.unixsocket.UnixSocketAddress	Sockaddr.addressFromSockaddr_un(ThreadContext context, ByteList bl)
int	OpenFile.appendline(ThreadContext context, int delim, ByteList[] strp, int[] lp)
static ByteList	EncodingUtils.econvAppend(ThreadContext context, org.jcodings.transcode.EConv ec, byte[] bytes, int start, int length, ByteList dst, int flags)
static ByteList	EncodingUtils.econvAppend(ThreadContext context, org.jcodings.transcode.EConv ec, ByteList sByteList, ByteList dst, int flags)
static ByteList	EncodingUtils.econvStrConvert(ThreadContext context, org.jcodings.transcode.EConv ec, ByteList src, int flags)
static ByteList	EncodingUtils.econvSubstrAppend(ThreadContext context, org.jcodings.transcode.EConv ec, ByteList src, ByteList dst, int flags)
static int	EncodingUtils.encCrStrBufCat(Ruby runtime, CodeRangeable str, ByteList ptr, org.jcodings.Encoding ptrEnc, int ptr_cr)
static void	EncodingUtils.encStrBufCat(Ruby runtime, RubyString str, ByteList ptr)
static void	EncodingUtils.encStrBufCat(Ruby runtime, RubyString str, ByteList ptr, org.jcodings.Encoding enc)
static org.jcodings.Encoding	EncodingUtils.getActualEncoding(org.jcodings.Encoding enc, ByteList byteList)
static jnr.constants.platform.AddressFamily	Sockaddr.getAddressFamilyFromSockaddr(Ruby runtime, ByteList val)
static org.jcodings.Encoding	EncodingUtils.getEncoding(ByteList str)
(package private) static void	EncodingUtils.moreOutputBuffer(ByteList destination, EncodingUtils.ResizeFunction resizeDestination, int maxOutput, org.jcodings.Ptr outStart, org.jcodings.Ptr outPos, org.jcodings.Ptr outStop)
static RubyString	EncodingUtils.newExternalStringWithEncoding(Ruby runtime, ByteList bytelist, org.jcodings.Encoding encoding)
static void	EncodingUtils.rbStrBufCat(Ruby runtime, RubyString str, ByteList ptr)
static void	EncodingUtils.rbStrBufCat(Ruby runtime, ByteList str, byte[] ptrBytes, int ptr, int len)
int	EncodingUtils.ResizeFunction.resize(ByteList destination, int len, int new_len)	Resize the destination, returning the new begin offset.
static void	EncodingUtils.strBufCat(Ruby runtime, RubyString str, ByteList ptr)
static void	EncodingUtils.strBufCat(ByteList str, byte[] ptrBytes, int ptr, int len)
static ByteList	EncodingUtils.strConvEnc(ThreadContext context, ByteList value, org.jcodings.Encoding fromEncoding, org.jcodings.Encoding toEncoding)
static ByteList	EncodingUtils.strConvEncOpts(ThreadContext context, ByteList str, org.jcodings.Encoding fromEncoding, org.jcodings.Encoding toEncoding, int ecflags, IRubyObject ecopts)
static <Data> boolean	EncodingUtils.transcodeLoop(org.jcodings.transcode.EConv ec, EncodingUtils.TranscodeFallback<Data> fallbackFunc, ThreadContext context, Data fallbackData, byte[] inBytes, org.jcodings.Ptr inPos, byte[] outBytes, org.jcodings.Ptr outPos, int inStop, int outStop, ByteList destination, EncodingUtils.ResizeFunction resizeFunction)	Perform the inner transcoding loop.
static void	EncodingUtils.transcodeLoop(ThreadContext context, byte[] inBytes, org.jcodings.Ptr inPos, byte[] outBytes, org.jcodings.Ptr outPos, int inStop, int _outStop, ByteList destination, EncodingUtils.ResizeFunction resizeFunction, byte[] sname, byte[] dname, int ecflags, IRubyObject ecopts)	Perform the inner transcoding loop.
static RubyArray	Sockaddr.unpack_sockaddr_in(ThreadContext context, ByteList val)