org.jruby.util.io

Class EncodingUtils

java.lang.Object

org.jruby.util.io.EncodingUtils

public class EncodingUtils
extends Object

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static interface	EncodingUtils.ResizeFunction
static interface	EncodingUtils.TranscodeFallback

Field Summary

Fields

Modifier and Type	Field and Description
static int	DEFAULT_TEXTMODE
static int	ECONV_DEFAULT_NEWLINE_DECORATOR
static EncodingUtils.ResizeFunction	strTranscodingResize
static int	TEXTMODE_NEWLINE_DECORATOR_ON_WRITE

Constructor Summary

Constructors

Constructor and Description
EncodingUtils()

Method Summary

Methods

Modifier and Type	Method and Description
static org.jcodings.Encoding	ascii8bitEncoding(Ruby runtime)
static int	decorateConvpath(ThreadContext context, IRubyObject convpath, int ecflags)
static boolean	DECORATOR_P(byte[] sname, byte[] dname)
static org.jcodings.Encoding	defaultExternalEncoding(Ruby runtime)
static org.jcodings.Encoding	defineDummyEncoding(ThreadContext context, byte[] name)
static org.jruby.util.ByteList	econvAppend(ThreadContext context, org.jcodings.transcode.EConv ec, org.jruby.util.ByteList sByteList, org.jruby.util.ByteList dst, int flags)
static void	econvArgs(ThreadContext context, IRubyObject[] args, byte[][] encNames, org.jcodings.Encoding[] encs, int[] ecflags_p, IRubyObject[] ecopts_p)
static org.jcodings.Encoding	econvAsciicompatEncoding(org.jcodings.Encoding enc)
static void	econvCheckError(ThreadContext context, org.jcodings.transcode.EConv ec)
static String	econvDescription(ThreadContext context, byte[] sourceEncoding, byte[] destinationEncoding, int ecflags, String message)
static org.jcodings.transcode.EConv	econvInitByConvpath(ThreadContext context, IRubyObject convpath, byte[][] encNames, org.jcodings.Encoding[] encs)
static RaiseException	econvOpenExc(ThreadContext context, byte[] sourceEncoding, byte[] destinationEncoding, int ecflags)
static org.jcodings.transcode.EConv	econvOpenOpts(ThreadContext context, byte[] sourceEncoding, byte[] destinationEncoding, int ecflags, IRubyObject opthash)
static int	econvOpts(ThreadContext context, IRubyObject opt, int ecflags)
static int	econvPrepareOptions(ThreadContext context, IRubyObject opthash, IRubyObject[] opts, int ecflags)
static int	econvPrepareOpts(ThreadContext context, IRubyObject opthash, IRubyObject[] opts)
static org.jruby.util.ByteList	econvStrConvert(ThreadContext context, org.jcodings.transcode.EConv ec, org.jruby.util.ByteList src, int flags)
static org.jruby.util.ByteList	econvSubstrAppend(ThreadContext context, org.jcodings.transcode.EConv ec, org.jruby.util.ByteList src, org.jruby.util.ByteList dst, int flags)
static org.jcodings.Encoding	encArg(ThreadContext context, IRubyObject encval, byte[][] name_p, org.jcodings.Encoding[] enc_p)
static int	encAscget(byte[] pBytes, int p, int e, int[] len, org.jcodings.Encoding enc)
static boolean	encAsciicompat(org.jcodings.Encoding enc)
static IRubyObject	encAssociateIndex(IRubyObject obj, org.jcodings.Encoding encidx)
static void	encCheckDuplication(ThreadContext context, byte[] name)
static int	encCodepointLength(Ruby runtime, byte[] pBytes, int p, int e, int[] len_p, org.jcodings.Encoding enc)
static void	encCrStrBufCat(Ruby runtime, CodeRangeable str, byte[] ptrBytes, int ptr, int len, org.jcodings.Encoding ptrEnc, int ptr_cr, int[] ptr_cr_ret)
static void	encCrStrBufCat(Ruby runtime, CodeRangeable str, org.jruby.util.ByteList ptr, org.jcodings.Encoding ptrEnc, int ptr_cr, int[] ptr_cr_ret)
static boolean	encDummy(org.jcodings.Encoding enc)
static org.jcodings.Encoding	encGet(ThreadContext context, IRubyObject obj)
static void	encMbcput(int c, byte[] buf, int p, org.jcodings.Encoding enc)
static int	encMbminlen(org.jcodings.Encoding encoding)
static IRubyObject	encodedDup(ThreadContext context, IRubyObject newstr, IRubyObject str, org.jcodings.Encoding encindex)
static boolean	encodingEqual(byte[] enc1, byte[] enc2)
static boolean	encRegistered(byte[] name)
static org.jcodings.Encoding	encReplicate(ThreadContext context, byte[] name, org.jcodings.Encoding encoding)
static boolean	encSetDefaultEncoding(ThreadContext context, org.jcodings.Encoding[] def_p, IRubyObject encoding, String name)
static void	encStrBufCat(Ruby runtime, RubyString str, byte[] ptrBytes, int ptr, int len, org.jcodings.Encoding enc)
static void	encStrBufCat(Ruby runtime, RubyString str, org.jruby.util.ByteList ptr, org.jcodings.Encoding enc)
static IRubyObject	encUintChr(ThreadContext context, int code, org.jcodings.Encoding enc)
static void	extractBinmode(Ruby runtime, IRubyObject optionsArg, int[] fmode_p)
static void	extractModeEncoding(ThreadContext context, IOEncodable ioEncodable, Object vmodeAndVperm_p, IRubyObject options, int[] oflags_p, int[] fmode_p)
static org.jcodings.Encoding	getActualEncoding(org.jcodings.Encoding enc, org.jruby.util.ByteList byteList)
static org.jcodings.Encoding	getEncoding(org.jruby.util.ByteList str)
static IRubyObject	ioEncStr(Ruby runtime, IRubyObject str, OpenFile fptr)
static void	ioExtIntToEncs(ThreadContext context, IOEncodable encodable, org.jcodings.Encoding external, org.jcodings.Encoding internal, int fmode)
static boolean	ioExtractEncodingOption(ThreadContext context, IOEncodable ioEncodable, IRubyObject options, int[] fmode_p)
static void	ioSetEncodingByBOM(ThreadContext context, RubyIO io)
static org.jcodings.Encoding	ioStripBOM(RubyIO io) Deprecated.
static org.jcodings.Encoding	ioStripBOM(ThreadContext context, RubyIO io)
static RaiseException	makeEconvException(Ruby runtime, org.jcodings.transcode.EConv ec)
static int	MODE_BTMODE(int fmode, int a, int b, int c)
static IRubyObject	objEncoding(ThreadContext context, IRubyObject obj)
static IRubyObject[]	openArgsToArgs(Ruby runtime, IRubyObject firstElement, RubyHash options)
static void	parseModeEncoding(ThreadContext context, IOEncodable ioEncodable, String option, int[] fmode_p)
static void	rbEncSetDefaultExternal(ThreadContext context, IRubyObject encoding)
static void	rbEncSetDefaultInternal(ThreadContext context, IRubyObject encoding)
static void	rbStrBufCat(Ruby runtime, org.jruby.util.ByteList str, byte[] ptrBytes, int ptr, int len)
static void	rbStrBufCat(Ruby runtime, ByteListHolder str, byte[] ptrBytes, int ptr, int len)
static void	rbStrBufCat(Ruby runtime, RubyString str, org.jruby.util.ByteList ptr)
static IRubyObject	rbStrEncode(ThreadContext context, IRubyObject str, IRubyObject to, int ecflags, IRubyObject ecopt)
static org.jcodings.Encoding	rbToEncoding(ThreadContext context, IRubyObject enc)
static int	SET_UNIVERSAL_NEWLINE_DECORATOR_IF_ENC2(org.jcodings.Encoding enc2, int ecflags)
static RubyString	setStrBuf(Ruby runtime, IRubyObject obj, int len)
static org.jcodings.Encoding	STR_ENC_GET(ByteListHolder str)
static void	strBufCat(org.jruby.util.ByteList str, byte[] ptrBytes, int ptr, int len)
static void	strBufCat(Ruby runtime, ByteListHolder str, byte[] ptrBytes, int ptr, int len)
static void	strBufCat(Ruby runtime, RubyString str, org.jruby.util.ByteList ptr)
static IRubyObject	strCompatAndValid(ThreadContext context, IRubyObject _str, org.jcodings.Encoding enc)
static org.jruby.util.ByteList	strConvEnc(ThreadContext context, org.jruby.util.ByteList value, org.jcodings.Encoding fromEncoding, org.jcodings.Encoding toEncoding)
static RubyString	strConvEnc(ThreadContext context, RubyString value, org.jcodings.Encoding fromEncoding, org.jcodings.Encoding toEncoding)
static org.jruby.util.ByteList	strConvEncOpts(ThreadContext context, org.jruby.util.ByteList str, org.jcodings.Encoding fromEncoding, org.jcodings.Encoding toEncoding, int ecflags, IRubyObject ecopts)
static RubyString	strConvEncOpts(ThreadContext context, RubyString str, org.jcodings.Encoding fromEncoding, org.jcodings.Encoding toEncoding, int ecflags, IRubyObject ecopts) This will try and transcode the supplied ByteList to the supplied toEncoding.
static IRubyObject	strEncode(ThreadContext context, IRubyObject str, IRubyObject... args)
static IRubyObject	strEncodeAssociate(ThreadContext context, IRubyObject str, org.jcodings.Encoding encidx)
static org.jcodings.Encoding	strTranscode(ThreadContext context, IRubyObject[] args, IRubyObject[] self_p)
static org.jcodings.Encoding	strTranscode0(ThreadContext context, int argc, IRubyObject[] args, IRubyObject[] self_p, int ecflags, IRubyObject ecopts)
static org.jcodings.Encoding	strTranscodeEncArgs(ThreadContext context, IRubyObject str, IRubyObject arg1, IRubyObject arg2, byte[][] sname_p, org.jcodings.Encoding[] senc_p, byte[][] dname_p, org.jcodings.Encoding[] denc_p)
static org.jcodings.Encoding	toEncoding(ThreadContext context, IRubyObject enc)
static org.jcodings.Encoding	toEncodingIndex(ThreadContext context, IRubyObject enc)
static void	transcodeLoop(ThreadContext context, byte[] inBytes, org.jcodings.Ptr inPos, byte[] outBytes, org.jcodings.Ptr outPos, int inStop, int _outStop, org.jruby.util.ByteList destination, EncodingUtils.ResizeFunction resizeFunction, byte[] sname, byte[] dname, int ecflags, IRubyObject ecopts)
static void	validateEncodingBinmode(ThreadContext context, int[] fmode_p, int ecflags, IOEncodable ioEncodable)
static IRubyObject	vmode(Object vmodeVperm)
static void	vmode(Object vmodeVperm, IRubyObject vmode)
static Object	vmodeVperm(IRubyObject vmode, IRubyObject vperm)
static IRubyObject	vperm(Object vmodeVperm)
static void	vperm(Object vmodeVperm, IRubyObject vperm)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

ECONV_DEFAULT_NEWLINE_DECORATOR

public static final int ECONV_DEFAULT_NEWLINE_DECORATOR

DEFAULT_TEXTMODE

public static final int DEFAULT_TEXTMODE

TEXTMODE_NEWLINE_DECORATOR_ON_WRITE

public static final int TEXTMODE_NEWLINE_DECORATOR_ON_WRITE

strTranscodingResize

public static final EncodingUtils.ResizeFunction strTranscodingResize

Constructor Detail

EncodingUtils

public EncodingUtils()

Method Detail

rbToEncoding

public static org.jcodings.Encoding rbToEncoding(ThreadContext context,
                                 IRubyObject enc)

toEncoding

public static org.jcodings.Encoding toEncoding(ThreadContext context,
                               IRubyObject enc)

openArgsToArgs

public static IRubyObject[] openArgsToArgs(Ruby runtime,
                           IRubyObject firstElement,
                           RubyHash options)

extractBinmode

public static void extractBinmode(Ruby runtime,
                  IRubyObject optionsArg,
                  int[] fmode_p)

ascii8bitEncoding

public static org.jcodings.Encoding ascii8bitEncoding(Ruby runtime)

vmodeVperm

public static Object vmodeVperm(IRubyObject vmode,
                IRubyObject vperm)

vmode

public static IRubyObject vmode(Object vmodeVperm)

vmode

public static void vmode(Object vmodeVperm,
         IRubyObject vmode)

vperm

public static IRubyObject vperm(Object vmodeVperm)

vperm

public static void vperm(Object vmodeVperm,
         IRubyObject vperm)

MODE_BTMODE

public static final int MODE_BTMODE(int fmode,
              int a,
              int b,
              int c)

SET_UNIVERSAL_NEWLINE_DECORATOR_IF_ENC2

public static int SET_UNIVERSAL_NEWLINE_DECORATOR_IF_ENC2(org.jcodings.Encoding enc2,
                                          int ecflags)

extractModeEncoding

public static void extractModeEncoding(ThreadContext context,
                       IOEncodable ioEncodable,
                       Object vmodeAndVperm_p,
                       IRubyObject options,
                       int[] oflags_p,
                       int[] fmode_p)

ioExtractEncodingOption

public static boolean ioExtractEncodingOption(ThreadContext context,
                              IOEncodable ioEncodable,
                              IRubyObject options,
                              int[] fmode_p)

ioExtIntToEncs

public static void ioExtIntToEncs(ThreadContext context,
                  IOEncodable encodable,
                  org.jcodings.Encoding external,
                  org.jcodings.Encoding internal,
                  int fmode)

parseModeEncoding

public static void parseModeEncoding(ThreadContext context,
                     IOEncodable ioEncodable,
                     String option,
                     int[] fmode_p)

econvStrConvert

public static org.jruby.util.ByteList econvStrConvert(ThreadContext context,
                                      org.jcodings.transcode.EConv ec,
                                      org.jruby.util.ByteList src,
                                      int flags)

econvSubstrAppend

public static org.jruby.util.ByteList econvSubstrAppend(ThreadContext context,
                                        org.jcodings.transcode.EConv ec,
                                        org.jruby.util.ByteList src,
                                        org.jruby.util.ByteList dst,
                                        int flags)

econvAppend

public static org.jruby.util.ByteList econvAppend(ThreadContext context,
                                  org.jcodings.transcode.EConv ec,
                                  org.jruby.util.ByteList sByteList,
                                  org.jruby.util.ByteList dst,
                                  int flags)

econvCheckError

public static void econvCheckError(ThreadContext context,
                   org.jcodings.transcode.EConv ec)

econvPrepareOpts

public static int econvPrepareOpts(ThreadContext context,
                   IRubyObject opthash,
                   IRubyObject[] opts)

econvPrepareOptions

public static int econvPrepareOptions(ThreadContext context,
                      IRubyObject opthash,
                      IRubyObject[] opts,
                      int ecflags)

econvOpts

public static int econvOpts(ThreadContext context,
            IRubyObject opt,
            int ecflags)

econvOpenOpts

public static org.jcodings.transcode.EConv econvOpenOpts(ThreadContext context,
                                         byte[] sourceEncoding,
                                         byte[] destinationEncoding,
                                         int ecflags,
                                         IRubyObject opthash)

econvOpenExc

public static RaiseException econvOpenExc(ThreadContext context,
                          byte[] sourceEncoding,
                          byte[] destinationEncoding,
                          int ecflags)

econvDescription

public static String econvDescription(ThreadContext context,
                      byte[] sourceEncoding,
                      byte[] destinationEncoding,
                      int ecflags,
                      String message)

econvAsciicompatEncoding

public static org.jcodings.Encoding econvAsciicompatEncoding(org.jcodings.Encoding enc)

encAsciicompat

public static boolean encAsciicompat(org.jcodings.Encoding enc)

encAscget

public static int encAscget(byte[] pBytes,
            int p,
            int e,
            int[] len,
            org.jcodings.Encoding enc)

encMbminlen

public static int encMbminlen(org.jcodings.Encoding encoding)

encDummy

public static boolean encDummy(org.jcodings.Encoding enc)

encGet

public static org.jcodings.Encoding encGet(ThreadContext context,
                           IRubyObject obj)

encodingEqual

public static boolean encodingEqual(byte[] enc1,
                    byte[] enc2)

encArg

public static org.jcodings.Encoding encArg(ThreadContext context,
                           IRubyObject encval,
                           byte[][] name_p,
                           org.jcodings.Encoding[] enc_p)

toEncodingIndex

public static org.jcodings.Encoding toEncodingIndex(ThreadContext context,
                                    IRubyObject enc)

encodedDup

public static IRubyObject encodedDup(ThreadContext context,
                     IRubyObject newstr,
                     IRubyObject str,
                     org.jcodings.Encoding encindex)

strEncodeAssociate

public static IRubyObject strEncodeAssociate(ThreadContext context,
                             IRubyObject str,
                             org.jcodings.Encoding encidx)

encAssociateIndex

public static IRubyObject encAssociateIndex(IRubyObject obj,
                            org.jcodings.Encoding encidx)

strEncode

public static IRubyObject strEncode(ThreadContext context,
                    IRubyObject str,
                    IRubyObject... args)

rbStrEncode

public static IRubyObject rbStrEncode(ThreadContext context,
                      IRubyObject str,
                      IRubyObject to,
                      int ecflags,
                      IRubyObject ecopt)

strTranscode

public static org.jcodings.Encoding strTranscode(ThreadContext context,
                                 IRubyObject[] args,
                                 IRubyObject[] self_p)

strTranscode0

public static org.jcodings.Encoding strTranscode0(ThreadContext context,
                                  int argc,
                                  IRubyObject[] args,
                                  IRubyObject[] self_p,
                                  int ecflags,
                                  IRubyObject ecopts)

objEncoding

public static IRubyObject objEncoding(ThreadContext context,
                      IRubyObject obj)

strTranscodeEncArgs

public static org.jcodings.Encoding strTranscodeEncArgs(ThreadContext context,
                                        IRubyObject str,
                                        IRubyObject arg1,
                                        IRubyObject arg2,
                                        byte[][] sname_p,
                                        org.jcodings.Encoding[] senc_p,
                                        byte[][] dname_p,
                                        org.jcodings.Encoding[] denc_p)

encRegistered

public static boolean encRegistered(byte[] name)

encCheckDuplication

public static void encCheckDuplication(ThreadContext context,
                       byte[] name)

encReplicate

public static org.jcodings.Encoding encReplicate(ThreadContext context,
                                 byte[] name,
                                 org.jcodings.Encoding encoding)

defineDummyEncoding

public static org.jcodings.Encoding defineDummyEncoding(ThreadContext context,
                                        byte[] name)

DECORATOR_P

public static boolean DECORATOR_P(byte[] sname,
                  byte[] dname)

strConvEncOpts

public static org.jruby.util.ByteList strConvEncOpts(ThreadContext context,
                                     org.jruby.util.ByteList str,
                                     org.jcodings.Encoding fromEncoding,
                                     org.jcodings.Encoding toEncoding,
                                     int ecflags,
                                     IRubyObject ecopts)

strConvEncOpts

public static RubyString strConvEncOpts(ThreadContext context,
                        RubyString str,
                        org.jcodings.Encoding fromEncoding,
                        org.jcodings.Encoding toEncoding,
                        int ecflags,
                        IRubyObject ecopts)

This will try and transcode the supplied ByteList to the supplied toEncoding. It will use forceEncoding as its encoding if it is supplied; otherwise it will use the encoding it has tucked away in the bytelist. This will return a new copy of a ByteList in the request encoding or die trying (ConverterNotFound). c: rb_str_conv_enc_opts

strConvEnc

public static RubyString strConvEnc(ThreadContext context,
                    RubyString value,
                    org.jcodings.Encoding fromEncoding,
                    org.jcodings.Encoding toEncoding)

strConvEnc

public static org.jruby.util.ByteList strConvEnc(ThreadContext context,
                                 org.jruby.util.ByteList value,
                                 org.jcodings.Encoding fromEncoding,
                                 org.jcodings.Encoding toEncoding)

setStrBuf

public static RubyString setStrBuf(Ruby runtime,
                   IRubyObject obj,
                   int len)

transcodeLoop

public static void transcodeLoop(ThreadContext context,
                 byte[] inBytes,
                 org.jcodings.Ptr inPos,
                 byte[] outBytes,
                 org.jcodings.Ptr outPos,
                 int inStop,
                 int _outStop,
                 org.jruby.util.ByteList destination,
                 EncodingUtils.ResizeFunction resizeFunction,
                 byte[] sname,
                 byte[] dname,
                 int ecflags,
                 IRubyObject ecopts)

makeEconvException

public static RaiseException makeEconvException(Ruby runtime,
                                org.jcodings.transcode.EConv ec)

ioSetEncodingByBOM

public static void ioSetEncodingByBOM(ThreadContext context,
                      RubyIO io)

ioStripBOM

@Deprecated
public static org.jcodings.Encoding ioStripBOM(RubyIO io)

Deprecated.

ioStripBOM

public static org.jcodings.Encoding ioStripBOM(ThreadContext context,
                               RubyIO io)

validateEncodingBinmode

public static void validateEncodingBinmode(ThreadContext context,
                           int[] fmode_p,
                           int ecflags,
                           IOEncodable ioEncodable)

rbEncSetDefaultExternal

public static void rbEncSetDefaultExternal(ThreadContext context,
                           IRubyObject encoding)

rbEncSetDefaultInternal

public static void rbEncSetDefaultInternal(ThreadContext context,
                           IRubyObject encoding)

encSetDefaultEncoding

public static boolean encSetDefaultEncoding(ThreadContext context,
                            org.jcodings.Encoding[] def_p,
                            IRubyObject encoding,
                            String name)

defaultExternalEncoding

public static org.jcodings.Encoding defaultExternalEncoding(Ruby runtime)

rbStrBufCat

public static void rbStrBufCat(Ruby runtime,
               RubyString str,
               org.jruby.util.ByteList ptr)

rbStrBufCat

public static void rbStrBufCat(Ruby runtime,
               ByteListHolder str,
               byte[] ptrBytes,
               int ptr,
               int len)

rbStrBufCat

public static void rbStrBufCat(Ruby runtime,
               org.jruby.util.ByteList str,
               byte[] ptrBytes,
               int ptr,
               int len)

strBufCat

public static void strBufCat(Ruby runtime,
             RubyString str,
             org.jruby.util.ByteList ptr)

strBufCat

public static void strBufCat(Ruby runtime,
             ByteListHolder str,
             byte[] ptrBytes,
             int ptr,
             int len)

strBufCat

public static void strBufCat(org.jruby.util.ByteList str,
             byte[] ptrBytes,
             int ptr,
             int len)

encStrBufCat

public static void encStrBufCat(Ruby runtime,
                RubyString str,
                org.jruby.util.ByteList ptr,
                org.jcodings.Encoding enc)

encStrBufCat

public static void encStrBufCat(Ruby runtime,
                RubyString str,
                byte[] ptrBytes,
                int ptr,
                int len,
                org.jcodings.Encoding enc)

encCrStrBufCat

public static void encCrStrBufCat(Ruby runtime,
                  CodeRangeable str,
                  org.jruby.util.ByteList ptr,
                  org.jcodings.Encoding ptrEnc,
                  int ptr_cr,
                  int[] ptr_cr_ret)

encCrStrBufCat

public static void encCrStrBufCat(Ruby runtime,
                  CodeRangeable str,
                  byte[] ptrBytes,
                  int ptr,
                  int len,
                  org.jcodings.Encoding ptrEnc,
                  int ptr_cr,
                  int[] ptr_cr_ret)

econvArgs

public static void econvArgs(ThreadContext context,
             IRubyObject[] args,
             byte[][] encNames,
             org.jcodings.Encoding[] encs,
             int[] ecflags_p,
             IRubyObject[] ecopts_p)

econvInitByConvpath

public static org.jcodings.transcode.EConv econvInitByConvpath(ThreadContext context,
                                               IRubyObject convpath,
                                               byte[][] encNames,
                                               org.jcodings.Encoding[] encs)

decorateConvpath

public static int decorateConvpath(ThreadContext context,
                   IRubyObject convpath,
                   int ecflags)

ioEncStr

public static IRubyObject ioEncStr(Ruby runtime,
                   IRubyObject str,
                   OpenFile fptr)

encUintChr

public static IRubyObject encUintChr(ThreadContext context,
                     int code,
                     org.jcodings.Encoding enc)

encMbcput

public static void encMbcput(int c,
             byte[] buf,
             int p,
             org.jcodings.Encoding enc)

encCodepointLength

public static int encCodepointLength(Ruby runtime,
                     byte[] pBytes,
                     int p,
                     int e,
                     int[] len_p,
                     org.jcodings.Encoding enc)

strCompatAndValid

public static IRubyObject strCompatAndValid(ThreadContext context,
                            IRubyObject _str,
                            org.jcodings.Encoding enc)

getEncoding

public static org.jcodings.Encoding getEncoding(org.jruby.util.ByteList str)

getActualEncoding

public static org.jcodings.Encoding getActualEncoding(org.jcodings.Encoding enc,
                                      org.jruby.util.ByteList byteList)

STR_ENC_GET

public static org.jcodings.Encoding STR_ENC_GET(ByteListHolder str)