Uses of Class
org.jruby.util.ByteList

Packages that use ByteList

Package	Description
org.jruby
org.jruby.api
org.jruby.ast
org.jruby.ast.executable
org.jruby.ext.digest
org.jruby.ext.ripper
org.jruby.ext.socket
org.jruby.ext.zlib
org.jruby.ir
org.jruby.ir.builder
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.lexer
org.jruby.lexer.yacc
org.jruby.parser
org.jruby.runtime
org.jruby.runtime.encoding
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
static final ByteList	RubyEncoding.BINARY_ASCII_NAME
final ByteList	RubyString.EmptyByteListHolder.bytes
final ByteList	RubyThread.Status.bytes
static final ByteList	RubyEncoding.EXTERNAL
static final ByteList	RubyBoolean.FALSE_BYTES
static final ByteList	RubyEncoding.FILESYSTEM
static final ByteList	RubyEncoding.INTERNAL
static final ByteList	RubyEncoding.LOCALE
static final ByteList	RubyFloat.NAN_TO_S_BYTELIST
static final ByteList	RubyFloat.NEGATIVE_INFINITY_TO_S_BYTELIST
static final ByteList	RubyIO.PARAGRAPH_SEPARATOR
static final ByteList	RubyFloat.POSITIVE_INFINITY_TO_S_BYTELIST
static final ByteList	RubyBoolean.TRUE_BYTES

Methods in org.jruby that return ByteList

Modifier and Type	Method	Description
static ByteList	RubyString.encodeBytelist(CharSequence value, org.jcodings.Encoding encoding)
ByteList	RubyString.getByteList()	Get the ByteList which backs this Ruby String
final ByteList	RubySymbol.getBytes()
ByteList	RubyRegexp.rawSource()
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 with parameters of type ByteList

Modifier and Type	Method	Description
protected void	RubyGlobal.CaseInsensitiveStringOnlyRubyHash.appendAssociation(boolean keyIsSymbol, ByteList bytes)
protected void	RubyHash.appendAssociation(boolean keyIsSymbol, ByteList bytes)	Append appropriate characters to indicate association (": " vs " => ").
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)	Deprecated.
final int	RubyString.catWithCodeRange(ByteList other, int codeRange)
static org.jcodings.Encoding	RubyString.checkEncoding(Ruby runtime, ByteList str1, ByteList str2)
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.
RubyString	Ruby.freezeAndDedupString(ByteList bytes)	Given a ByteList, cache a deduplicated FString version of it, or find an existing copy already prepared.
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.
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)	Deprecated.
static RubyString	RubyString.inspect(ThreadContext context, ByteList byteList)
static boolean	RubyModule.isValidConstantName(ByteList bytelist, int start, int end)
static int	RubySymbol.javaStringHashCode(ByteList iso8859)
static RubyString	RubyString.newBinaryString(Ruby runtime, ByteList str)
static RubyString	RubyString.newChilledString(Ruby runtime, ByteList bytes, int coderange, String file, int line)
static RubySymbol	RubySymbol.newConstantSymbol(Ruby runtime, IRubyObject fqn, ByteList bytes)	Deprecated.
static RubySymbol	RubySymbol.newConstantSymbol(ThreadContext context, IRubyObject fqn, ByteList bytes)	Create a symbol whose intention is to be used as a constant.
static RubyString	RubyString.newDebugChilledString(Ruby runtime, RubyClass rubyClass, ByteList value, int cr, String file, int line)
static RubyString	RubyString.newDebugFrozenString(Ruby runtime, RubyClass rubyClass, ByteList value, int cr, String file, int line)
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)
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)
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)
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)	Deprecated.
ParseResult	Ruby.parseEval(ByteList source, String file, DynamicScope scope, int lineNumber)	Deprecated.
static double	RubyKernel.parseHexidecimalExponentString2(Ruby runtime, ByteList str)	Deprecated.
static double	RubyKernel.parseHexidecimalExponentString2(ThreadContext context, ByteList str)	Parse hexidecimal exponential notation: ... This method assumes the string is a valid-formatted string.
static void	RubyRegexp.preprocessCheck(Ruby runtime, ByteList bytes)
final RubyRegexp	RubyRegexp.regexpInitialize(ByteList bytes, org.jcodings.Encoding enc, RegexpOptions options)	Deprecated.
final RubyRegexp	RubyRegexp.regexpInitialize(ByteList bytes, org.jcodings.Encoding enc, RegexpOptions options, IRubyObject timeout)
static int	RubyString.scanForCodeRange(ByteList bytes)
void	RubyString.setValue(ByteList value)
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)

Constructors in org.jruby with parameters of type ByteList

Modifier	Constructor	Description
protected	FString(Ruby runtime, ByteList value, int cr)
	RubyRegexp(Ruby runtime, org.joni.Regex pattern, 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, int cr, boolean objectspace)
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)

Uses of ByteList in org.jruby.api

Methods in org.jruby.api that return ByteList

Modifier and Type	Method	Description
static ByteList	MRI.rb_econv_append(ThreadContext context, org.jcodings.transcode.EConv ec, byte[] bytes, int start, int length, ByteList dst, int flags)
static ByteList	MRI.rb_econv_append(ThreadContext context, org.jcodings.transcode.EConv ec, ByteList sByteList, ByteList dst, int flags)
static ByteList	MRI.rb_econv_str_convert(ThreadContext context, org.jcodings.transcode.EConv ec, byte[] bytes, int start, int length, int flags)
static ByteList	MRI.rb_econv_str_convert(ThreadContext context, org.jcodings.transcode.EConv ec, ByteList src, int flags)
static ByteList	MRI.rb_econv_substr_append(ThreadContext context, org.jcodings.transcode.EConv ec, ByteList src, ByteList dst, int flags)
static ByteList	MRI.rb_str_conv_enc(ThreadContext context, ByteList value, org.jcodings.Encoding fromEncoding, org.jcodings.Encoding toEncoding)
static ByteList	MRI.rb_str_encode(ThreadContext context, byte[] bytes, int start, int length, org.jcodings.Encoding encoding, int cr, org.jcodings.Encoding to, int ecflags, IRubyObject ecopt)

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

Modifier and Type	Method	Description
static RubySymbol	Convert.asSymbol(ThreadContext context, ByteList bytelist)	Creates a new RubySymbol from the provided java String.
static RubyString	Create.newSharedString(ThreadContext context, ByteList bytes)	Creates a new RubyString from the provided bytelist but use the supplied encoding if possible.
static RubyString	Create.newSharedString(ThreadContext context, ByteList bytes, org.jcodings.Encoding encoding)	Creates a new RubyString from the provided bytelist but use the supplied encoding if possible.
static RubyString	Create.newString(ThreadContext context, ByteList bytes)	Creates a new RubyString from the provided bytelist.
static RubyString	Create.newString(ThreadContext context, ByteList bytes, org.jcodings.Encoding encoding)	Creates a new RubyString from the provided bytelist but use the supplied encoding if possible.
static ByteList	MRI.rb_econv_append(ThreadContext context, org.jcodings.transcode.EConv ec, byte[] bytes, int start, int length, ByteList dst, int flags)
static ByteList	MRI.rb_econv_append(ThreadContext context, org.jcodings.transcode.EConv ec, ByteList sByteList, ByteList dst, int flags)
static ByteList	MRI.rb_econv_str_convert(ThreadContext context, org.jcodings.transcode.EConv ec, ByteList src, int flags)
static ByteList	MRI.rb_econv_substr_append(ThreadContext context, org.jcodings.transcode.EConv ec, ByteList src, ByteList dst, int flags)
static void	MRI.rb_enc_str_buf_cat(ThreadContext context, RubyString str, ByteList ptr)
static void	MRI.rb_enc_str_buf_cat(ThreadContext context, RubyString str, ByteList ptr, org.jcodings.Encoding enc)
static RubyString	MRI.rb_external_str_new_with_enc(Ruby runtime, ByteList bytelist, org.jcodings.Encoding encoding)
static void	MRI.rb_str_buf_cat(Ruby runtime, RubyString str, ByteList ptr)
static void	MRI.rb_str_buf_cat(Ruby runtime, ByteList str, byte[] ptrBytes, int ptr, int len)
static ByteList	MRI.rb_str_conv_enc(ThreadContext context, ByteList value, org.jcodings.Encoding fromEncoding, org.jcodings.Encoding toEncoding)

Uses of ByteList in org.jruby.ast

Fields in org.jruby.ast declared as ByteList

Modifier and Type	Field	Description
final ByteList	DefHolder.current_arg
ByteList	DefHolder.dotOrColon

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()

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

Modifier and Type	Method	Description
void	DefHolder.setDotOrColon(ByteList dotOrColon)

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

Modifier	Constructor	Description
	DefHolder(RubySymbol name, ByteList currentArg, LexContext ctxt)
	DefHolder(RubySymbol name, ByteList currentArg, IRubyObject value, LexContext ctxt)
	FileNode(int line, ByteList value)
	RegexpNode(int line, ByteList value, RegexpOptions options)
	StrNode(int line, ByteList value)
	StrNode(int line, ByteList value, int codeRange, StringStyle stringStyle)
	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

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.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.

Uses of ByteList in org.jruby.ext.ripper

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

Modifier and Type	Field	Description
protected ByteList	RubyLexer.delayed
protected final ByteList	HeredocTerm.lastLine
static final ByteList	RipperParserBase.NOT

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

Modifier and Type	Method	Description
protected ByteList	StringTerm.createByteList(RubyLexer lexer)
protected ByteList	RipperParserBase.extractByteList(Object value)
ByteList	RipperParserBase.getCurrentArg()
ByteList	RubyLexer.id()
ByteList	RipperParserBase.shadowing_lvar(ByteList nameBytes)
ByteList	RubyLexer.tokenByteList()

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

Modifier and Type	Method	Description
protected Set<ByteList>	RipperParserBase.push_pktbl()
Set<ByteList>	RipperParserBase.push_pvtbl()

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

Modifier and Type	Method	Description
RubyString	RipperParserBase.arg_var(ByteList byteName)
protected IRubyObject	RipperParserBase.assignable(ByteList name, IRubyObject value)
protected IRubyObject	RipperParserBase.call_bin_op(IRubyObject left, ByteList id, IRubyObject right, int line)
protected IRubyObject	RipperParserBase.call_uni_op(IRubyObject recv, ByteList id)
IRubyObject	RipperParserBase.createStr(ByteList data, int flags)
IRubyObject	RubyLexer.createStr(ByteList buffer, int flags)
protected int	HeredocTerm.error(RubyLexer lexer, int len, ByteList str, ByteList eos)
void	RipperParserBase.error_duplicate_pattern_key(ByteList key)
protected void	RipperParserBase.error_duplicate_pattern_variable(ByteList variable)
IRubyObject	RipperParserBase.formal_argument(ByteList identifier, IRubyObject lhs)
protected void	RipperParserBase.forwarding_arg_check(ByteList rest, ByteList all, String var)
RubySymbol	RipperParserBase.get_id(ByteList value)
protected void	RipperParserBase.getterIdentifierError(ByteList identifier)
boolean	RipperParserBase.id_is_var(ByteList value)
static RubyParserBase.IDType	RipperParserBase.id_type(ByteList identifier)
IRubyObject	RipperParserBase.intern(ByteList value)
boolean	RipperParserBase.is_local_id(ByteList name)
boolean	RipperParserBase.is_private_local_id(ByteList name)
boolean	RipperParserBase.local_id(ByteList value)
protected IRubyObject	RipperParserBase.logop(IRubyObject left, ByteList id, IRubyObject right)
ArgsTailHolder	RipperParserBase.new_args_tail(int line, IRubyObject kwarg, IRubyObject kwargRest, ByteList block)
ArgsTailHolder	RipperParserBase.new_args_tail(int _line, IRubyObject kwarg, ByteList kwargRest, IRubyObject block)
protected ArgsTailHolder	RipperParserBase.new_args_tail(int line, IRubyObject keywordArg, ByteList keywordRestArgName, ByteList block)
IRubyObject	RipperParserBase.new_bv(ByteList identifier)
void	RipperParserBase.numparam_name(ByteList name)
protected boolean	RubyLexer.onMagicComment(String name, ByteList value)
int	StringTerm.parseStringIntoBuffer(RubyLexer lexer, LexerSource src, ByteList buffer, org.jcodings.Encoding encoding, boolean[] encodingDetermined)
protected void	RubyLexer.set_yylval_id(ByteList id)
protected void	RubyLexer.set_yylval_name(ByteList name)
protected void	RubyLexer.set_yylval_val(ByteList name)
protected void	RubyLexer.setCompileOptionFlag(String name, ByteList value)
protected void	RubyLexer.setEncoding(ByteList name)
protected void	RubyLexer.setTokenInfo(String name, ByteList value)
ByteList	RipperParserBase.shadowing_lvar(ByteList nameBytes)
RubySymbol	RipperParserBase.symbolID(ByteList identifierValue)

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

Modifier and Type	Method	Description
protected void	RipperParserBase.pop_pktbl(Set<ByteList> table)
protected void	RipperParserBase.pop_pvtbl(Set<ByteList> table)

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

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.
static int	Option.unpackInt(ByteList data)
static int[]	Option.unpackLinger(ByteList data)

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.zlib

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

Modifier and Type	Method	Description
void	JZlibInflate.append(ThreadContext context, ByteList obj)
void	JZlibInflate.append(ByteList obj)	Deprecated.
IRubyObject	JZlibInflate.inflate(ThreadContext context, ByteList str, Block block)
protected RubyString	RubyGzipFile.newStr(Ruby runtime, ByteList value)	Deprecated.
protected RubyString	RubyGzipFile.newStr(ThreadContext context, ByteList value)

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_

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	IRScope.setByteName(ByteList name)

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)
	IRClosure(IRManager manager, IRScope lexicalParent, int lineNumber, StaticScope staticScope, Signature signature, ByteList prefix, 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)
	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, LazyMethodDefinition 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.builder

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

Modifier and Type	Method	Description
protected Operand	IRBuilder.buildClass(ByteList className, U superNode, U cpath, U bodyNode, StaticScope scope, int line, int endLine)
protected Operand	IRBuilder.buildModule(ByteList name, U cpath, U bodyNode, StaticScope scope, int line, int endLine)
protected void	IRBuilder.createPrefixFromArgs(ByteList prefix, U var)
protected void	IRBuilderAST.createPrefixFromArgs(ByteList prefix, Node args)
protected IRMethod	IRBuilder.defineNewMethod(LazyMethodDefinition<U,V,W,X,Y,Z> defn, ByteList name, int line, StaticScope scope, boolean isInstanceMethod)
protected RubySymbol	IRBuilder.symbol(ByteList bytelist)

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
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

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()

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

Modifier	Constructor	Description
	ChilledString(ByteList bytelist, int coderange, String file, int line)	Used by persistence and by .freeze optimization
protected	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

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

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

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)

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)
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.pushChilledString(ByteList byteList, int codeRange, String file, int line)
void	ValueCompiler.pushConstantLookupSite(String className, String siteName, ByteList name)	Load a ConstantLookupSite onto the stack
void	ValueCompiler.pushFrozenString(ByteList bl, int cr)	Stack required: none
void	ValueCompiler.pushFrozenString(ByteList bl, int cr, String path, int line)	Stack required: none
void	ValueCompiler.pushRange(ByteList begin, int beginCR, ByteList end, int endCR, boolean exclusive)	Build and save a literal string..string range.
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	RangeObjectSite.StringRangeObjectSite.begin
protected final ByteList	RangeObjectSite.StringRangeObjectSite.end
protected final ByteList	RegexpObjectSite.pattern

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

Modifier and Type	Method	Description
static ByteList	StringBootstrap.bytelist(int size, String encodingName)
static ByteList	StringBootstrap.bytelist(String value, String encodingName)

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

Modifier and Type	Method	Description
static RubyString	StringBootstrap.chilledString(ThreadContext context, ByteList value, int cr, String file, int line)
static RubyString	StringBootstrap.frozenString(ThreadContext context, MutableCallSite site, ByteList value, int cr, String file, int line)
static RubyString	StringBootstrap.frozenStringSimple(ThreadContext context, MutableCallSite site, ByteList value, int cr)
void	IndyConstantCompiler.inheritanceSearchConst(String id, ByteList name)
void	IndyConstantCompiler.lexicalSearchConst(String id, ByteList name)
void	IndyValueCompiler.pushByteList(ByteList bl)
void	IndyValueCompiler.pushChilledString(ByteList bl, int cr, String file, int line)
void	IndyValueCompiler.pushConstantLookupSite(String className, String siteName, ByteList name)
void	IndyValueCompiler.pushFrozenString(ByteList bl, int cr)
void	IndyValueCompiler.pushFrozenString(ByteList bl, int cr, String file, int line)
void	IndyValueCompiler.pushRange(ByteList begin, int beginCR, ByteList end, int endCR, boolean exclusive)
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	StringBootstrap.string(ThreadContext context, ByteList value, int cr)
static IRubyObject	JavaBootstrap.stringOrNil(Ruby runtime, ByteList bl)

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

Modifier	Constructor	Description
	RegexpObjectSite(MethodType type, ByteList pattern, int embeddedOptions)
	StringRangeObjectSite(MethodType type, ByteList begin, int beginCR, ByteList end, int endCR, boolean exclusive)

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.pushChilledString(ByteList bl, int cr, String file, int line)
void	NormalValueCompiler.pushConstantLookupSite(String className, String siteName, ByteList name)
void	NormalValueCompiler.pushFrozenString(ByteList bl, int cr)
void	NormalValueCompiler.pushFrozenString(ByteList bl, int cr, String file, int line)
void	NormalValueCompiler.pushRange(ByteList begin, int beginCR, ByteList end, int endCR, boolean exclusive)
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.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.AND_KEYWORD
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
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
static final ByteList	LexingCommon.KWNOREST
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.NIL
static final ByteList	LexingCommon.OR
static final ByteList	LexingCommon.OR_KEYWORD
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()
ByteList	LexingCommon.id()

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)
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)
protected void	LexingCommon.readUTF8EscapeIntoBuffer(int codepoint, ByteList buffer, boolean stringLiteral, boolean[] encodingDetermined)
int	LexingCommon.readUTFEscape(ByteList buffer, boolean stringLiteral, boolean[] encodingDetermined)
void	LexingCommon.readUTFEscapeRegexpLiteral(ByteList buffer)
void	StrftimeLexer.reset(ByteList input)
protected char	LexingCommon.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	LexingCommon.set_yylval_id(ByteList id)
protected void	LexingCommon.set_yylval_name(ByteList name)
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
protected final ByteList	HeredocTerm.lastLine

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)
static RubyLexer.Keyword	RubyLexer.getKeyword(ByteList str)
int	StringTerm.parseStringIntoBuffer(RubyLexer lexer, ByteList buffer, org.jcodings.Encoding encoding, boolean[] encodingDetermined)
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)

Uses of ByteList in org.jruby.parser

Fields in org.jruby.parser declared as ByteList

Modifier and Type	Field	Description
ByteList	ProductionState.id
static final ByteList	RubyParserBase.INTERNAL_ID
static ByteList	RubyParserBase.NIL
static final ByteList	RubyParserBase.NOT

Methods in org.jruby.parser that return ByteList

Modifier and Type	Method	Description
protected ByteList	RubyParserBase.extractByteList(Object value)
ByteList	RubyParserBase.formal_argument(ByteList identifier, Object _unused)
protected ByteList	RubyParserBase.getCurrentArg()
ByteList	RubyParserBase.shadowing_lvar(ByteList nameBytes)

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

Modifier and Type	Method	Description
Set<ByteList>	RubyParserBase.push_pktbl()
Set<ByteList>	RubyParserBase.push_pvtbl()

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

Modifier and Type	Method	Description
ArgumentNode	RubyParserBase.arg_var(ByteList byteName)
AssignableNode	RubyParserBase.assignableInCurr(ByteList nameBytes, Node value)
AssignableNode	RubyParserBase.assignableKeyword(ByteList name, Node value)
AssignableNode	RubyParserBase.assignableLabelOrIdentifier(ByteList byteName, Node value)
static int	RubyParserBase.associateEncoding(ByteList buffer, org.jcodings.Encoding newEncoding, int codeRange)
Node	RubyParserBase.asSymbol(int line, ByteList value)
Node	RubyParserBase.attrset(Node receiver, ByteList name)	Define an attribute set condition so we can return lhs
Node	RubyParserBase.attrset(Node receiver, ByteList callType, ByteList name)
Node	RubyParserBase.call_bin_op(Node firstNode, ByteList operator, Node secondNode)
Node	RubyParserBase.call_bin_op(Node firstNode, ByteList operator, Node secondNode, int defaultPosition)
Node	RubyParserBase.call_uni_op(Node firstNode, ByteList operator)
protected StrNode	RubyParserBase.createStr(ByteList buffer, int flags)
Node	RubyParserBase.declareIdentifier(ByteList byteName)
void	RubyParserBase.error_duplicate_pattern_key(ByteList key)
void	RubyParserBase.error_duplicate_pattern_variable(ByteList variable)
ByteList	RubyParserBase.formal_argument(ByteList identifier, Object _unused)
protected void	RubyParserBase.forwarding_arg_check(ByteList rest, ByteList all, String var)
RubySymbol	RubyParserBase.get_id(ByteList id)
Node	RubyParserBase.gettable(ByteList id)
static RubyParserBase.IDType	RubyParserBase.id_type(ByteList identifier)
static boolean	RubyParserBase.is_local_id(ByteList name)
static boolean	RubyParserBase.is_private_local_id(ByteList name)
boolean	RubyParserBase.isLazy(ByteList callType)
boolean	RubyParserBase.local_id(ByteList value)
Node	RubyParserBase.logop(Node left, ByteList op, Node right)
ArgsTailHolder	RubyParserBase.new_args_tail(int line, ListNode keywordArg, ByteList keywordRestArgName, BlockArgNode blockArg)
protected ArgsTailHolder	RubyParserBase.new_args_tail(int line, ListNode keywordArg, ByteList keywordRestArgName, ByteList block)
ArrayPatternNode	RubyParserBase.new_array_pattern_tail(int line, ListNode preArgs, boolean hasRest, ByteList restArg, ListNode postArgs)
Node	RubyParserBase.new_ary_op_assign(Node receiverNode, Node argsNode, ByteList operatorName, Node valueNode)
Node	RubyParserBase.new_attr_op_assign(Node receiverNode, ByteList callType, ByteList variableName, ByteList operatorName, Node valueNode)
Node	RubyParserBase.new_attrassign(int line, Node receiver, ByteList name, Node argsNode, boolean isLazy)
Node	RubyParserBase.new_bv(ByteList identifier)
Node	RubyParserBase.new_call(Node receiver, ByteList name, Node argsNode, Node iter)
Node	RubyParserBase.new_call(Node receiver, ByteList callType, ByteList name, Node argsNode, Node iter)
Node	RubyParserBase.new_call(Node receiver, ByteList callType, ByteList name, Node argsNode, Node iter, int line)
Colon2Node	RubyParserBase.new_colon2(int line, Node leftNode, ByteList name)
Colon3Node	RubyParserBase.new_colon3(int line, ByteList name)
Node	RubyParserBase.new_const_op_assign(int line, Node lhs, ByteList operatorName, Node rhs, LexContext _lexContext)
Node	RubyParserBase.new_fcall(ByteList operation)
Node	RubyParserBase.new_find_pattern_tail(int line, ByteList preRestArg, ListNode postArgs, ByteList postRestArg)
HashPatternNode	RubyParserBase.new_hash_pattern_tail(int line, HashNode keywordArgs, ByteList keywordRestArg)
Node	RubyParserBase.new_op_assign(AssignableNode receiverNode, ByteList operatorName, Node valueNode, LexContext _lexContext)
void	RubyParserBase.numparam_name(ByteList name)
ParseResult	Parser.parse(String fileName, int lineNumber, ByteList content, DynamicScope existingScope, ParserType type)
Node	Parser.parse(String file, ByteList content, DynamicScope blockScope, ParserConfiguration configuration)	Deprecated.
ParseResult	ParserManager.parseEval(String fileName, int lineNumber, ByteList source, DynamicScope scope)
ByteList	RubyParserBase.shadowing_lvar(ByteList nameBytes)
RubySymbol	RubyParserBase.symbolID(ByteList identifierValue)

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

Modifier and Type	Method	Description
void	RubyParserBase.pop_pktbl(Set<ByteList> table)
void	RubyParserBase.pop_pvtbl(Set<ByteList> table)

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

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

Modifier and Type	Method	Description
org.jcodings.EncodingDB.Entry	EncodingService.findAliasEntry(ByteList bytes)
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.
org.jcodings.Encoding	EncodingService.loadEncoding(ByteList name)

Uses of ByteList in org.jruby.runtime.marshal

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

Modifier and Type	Method	Description
ByteList	MarshalLoader.unmarshalString(ThreadContext context, RubyInputStream in)
ByteList	UnmarshalStream.unmarshalString()	Deprecated, for removal: This API element is subject to removal in a future version.

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

Modifier and Type	Method	Description
void	MarshalDumper.dumpSymbol(RubyOutputStream out, ByteList value)
void	MarshalStream.dumpSymbol(ByteList value)	Deprecated, for removal: This API element is subject to removal in a future version.
boolean	MarshalCache.isSymbolRegistered(ByteList sym)	Deprecated, for removal: This API element is subject to removal in a future version.
void	MarshalCache.registerSymbol(ByteList sym)	Deprecated, for removal: This API element is subject to removal in a future version.
void	MarshalStream.registerSymbol(ByteList sym)	Deprecated, for removal: This API element is subject to removal in a future version.
void	MarshalDumper.writeString(RubyOutputStream out, ByteList value)
void	MarshalStream.writeString(ByteList value)	Deprecated, for removal: This API element is subject to removal in a future version.
void	MarshalCache.writeSymbolLink(MarshalStream output, ByteList sym)	Deprecated, for removal: This API element is subject to removal in a future version.

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_
static final ByteList	CommonByteLists.AMPERSAND
static final ByteList	CommonByteLists.AMPERSAND_AMPERSAND
static final ByteList	CommonByteLists.ANON_BLOCK
static final ByteList	CommonByteLists.AREF_METHOD
static final ByteList	CommonByteLists.ASET_METHOD
static final ByteList	CommonByteLists.BACKTRACE_IN
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_BACKTICK
static final ByteList	CommonByteLists.DOLLAR_SINGLEQUOTE
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
static final ByteList	CommonByteLists.FREEZE_METHOD
static final ByteList	CommonByteLists.FWD_ALL
static final ByteList	CommonByteLists.FWD_BLOCK
static final ByteList	CommonByteLists.FWD_KWREST
static final ByteList	CommonByteLists.FWD_REST
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.NIL
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
static final ByteList	Inspector.RECURSIVE_ARRAY_BL
static final ByteList	Inspector.RECURSIVE_HASH_BL
static final ByteList	CommonByteLists.REFINE_METHOD
static final ByteList	CommonByteLists.SEND
static final ByteList	CommonByteLists.SINGLE_QUOTE
static final ByteList	CommonByteLists.SLASH
static final ByteList	CommonByteLists.STAR
static final ByteList	CommonByteLists.STAR_STAR
static final ByteList	CommonByteLists.TAB
static final ByteList	CommonByteLists.UNDERSCORE
static final ByteList	CommonByteLists.USING_METHOD
static final ByteList	CommonByteLists.ZERO

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 final ByteList	ConvertBytes.byteToSharedByteList(short i)	Return a cached ByteList for values -256..255.
static ByteList	StringSupport.caseMap(Ruby runtime, ByteList src, org.jcodings.IntHolder flags, org.jcodings.Encoding enc)	Deprecated.
static ByteList	StringSupport.caseMap(ThreadContext context, 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)
ByteList	ByteListHolder.getByteList()
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)
static final ByteList	ConvertBytes.longToBinaryByteList(long i)
static final ByteList	ConvertBytes.longToByteList(long i)	Produce a new ByteList of the given long as a string in radix 10.
static final ByteList	ConvertBytes.longToByteList(long i, int radix)	Produce a new ByteList of the given long as a string in the given radix.
static final ByteList	ConvertBytes.longToByteList(long i, int radix, byte[] digitmap)
static final ByteList	ConvertBytes.longToByteListCached(long i)	Produce a ByteList of the radix 10 string form of the given long, possibly returning a cached instance for certain ranges.
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)
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).
static ByteList	RegexpSupport.regexpDescription(Ruby runtime, ByteList bytes, RegexpOptions options, org.jcodings.Encoding enc)
static ByteList	RegexpSupport.regexpDescription19(Ruby runtime, ByteList bytes, RegexpOptions options, org.jcodings.Encoding enc)	Deprecated.
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.
static ByteList	Sprintf.sprintf(org.jcodings.Encoding encoding, CharSequence format, IRubyObject args)
static ByteList	StringSupport.succCommon(Ruby runtime, ByteList original)	Deprecated.
static ByteList	StringSupport.succCommon(ThreadContext context, 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, boolean sort)

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)
static void	RegexpSupport.appendRegexpString(Ruby runtime, ByteList to, byte[] bytes, int start, int len, org.jcodings.Encoding enc, org.jcodings.Encoding resEnc)
static void	RegexpSupport.appendRegexpString19(Ruby runtime, ByteList to, byte[] bytes, int start, int len, org.jcodings.Encoding enc, org.jcodings.Encoding resEnc)	Deprecated.
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)	Deprecated.
static void	StringSupport.asciiOnlyCaseMap(ThreadContext context, ByteList value, org.jcodings.IntHolder flags)
static String	StringSupport.byteListAsString(ByteList bytes)
static double	ConvertDouble.byteListToDouble(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 int	StringSupport.byterindex(ByteList source, int pos, CodeRangeable subStringCodeRangeable, org.jcodings.Encoding enc)
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)	Deprecated.
static ByteList	StringSupport.caseMap(ThreadContext context, ByteList src, org.jcodings.IntHolder flags, org.jcodings.Encoding enc)
static RubyString	RubyStringBuilder.cat(Ruby runtime, RubyString buf, ByteList bytes)
int	ByteList.cmp(ByteList other)	This comparison matches MRI comparison of Strings (rb_str_cmp).
static int	StringSupport.codePoint(Ruby runtime, ByteList value)	Deprecated.
static int	StringSupport.codePoint(ThreadContext context, ByteList value)
static int	StringSupport.codeRangeScan(org.jcodings.Encoding enc, ByteList bytes)
RubyString	RubyDateFormatter.compileAndFormat(ByteList pattern, boolean dateLibrary, org.joda.time.DateTime dt, long nsec, RubyNumeric sub_millis)	Convenience method when using no pattern caching
void	RubyDateFormatter.compilePattern(ByteList pattern, boolean dateLibrary)
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.
abstract void	Pack.Converter.encode(ThreadContext context, IRubyObject from, 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, org.jruby.util.RubyDateFormatter.FieldType type)
void	RubyTimeOutputFormatter.format(ByteList out, CharSequence sequence)
static RegexpOptions	RegexpOptions.fromByteList(Ruby runtime, ByteList string)
static RegexpOptions	RegexpOptions.fromByteList(ThreadContext context, ByteList string)
static int	Pack.getDirective(ThreadContext context, String mode, ByteList formatString, ByteBuffer encode)
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)	Deprecated.
static boolean	StringSupport.multiByteSqueeze(ThreadContext context, 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)
static int	StringSupport.nth(org.jcodings.Encoding enc, ByteList value, int n)
static RubyString	Pack.pack(Ruby runtime, RubyArray list, ByteList formatString)	Deprecated.
static ByteList	Pack.packInt_i(ByteList result, int s)
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, boolean sort)
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.raiseRegexpError(Ruby runtime, ByteList bytes, org.jcodings.Encoding enc, RegexpOptions options, String err)
static void	RegexpSupport.raiseRegexpError19(Ruby runtime, ByteList bytes, org.jcodings.Encoding enc, RegexpOptions options, String err)	Deprecated.
static int	RegexpSupport.readEscapedByte(Ruby runtime, byte[] to, int toP, byte[] bytes, int p, int end, ByteList str, RegexpSupport.ErrorMode mode)
static ByteList	RegexpSupport.regexpDescription(Ruby runtime, ByteList bytes, RegexpOptions options, org.jcodings.Encoding enc)
static ByteList	RegexpSupport.regexpDescription19(Ruby runtime, ByteList bytes, RegexpOptions options, org.jcodings.Encoding enc)	Deprecated.
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)
static int	StringSupport.searchNonAscii(ByteList bytes)
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(ThreadContext context, ByteList str, boolean[] table, StringSupport.TrTables tables, org.jcodings.Encoding enc)
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)	Deprecated.
static int	StringSupport.strLength(ByteList bytes)
static int	StringSupport.strLengthFromRubyString(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)	Deprecated.
static ByteList	StringSupport.succCommon(ThreadContext context, ByteList original)
static ByteList	StringSupport.succCommon(ByteList original)
static StringSupport.TrTables	StringSupport.trSetupTable(ThreadContext context, ByteList str, boolean[] stable, StringSupport.TrTables tables, boolean first, org.jcodings.Encoding enc)
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)	Deprecated.
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.
static RubyArray	Pack.unpack(Ruby runtime, ByteList encodedString, ByteList formatString)	Deprecated.
static RubyArray	Pack.unpack(ThreadContext context, RubyString encoded, ByteList formatString)
static RubyArray	Pack.unpack(ThreadContext context, ByteList encodedString, ByteList formatString)
static IRubyObject	Pack.unpack1WithBlock(ThreadContext context, RubyString encoded, ByteList formatString, long offset, Block block)
static IRubyObject	Pack.unpack1WithBlock(ThreadContext context, RubyString encoded, ByteList formatString, 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, long offset, Block block)
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)

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

Modifier and Type	Method	Description
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.
	RubyTimeOutputFormatter(ByteList flags, int width)
	TR(ByteList bytes)

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)	A version of rbStrEncode that works directly with bytes.
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, org.jcodings.Encoding enc)
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)	Deprecated.
static jnr.constants.platform.AddressFamily	Sockaddr.getAddressFamilyFromSockaddr(ThreadContext context, ByteList val)
static org.jcodings.Encoding	EncodingUtils.getEncoding(ByteList str)
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)