org.jruby.util

Class ConvertBytes

java.lang.Object

org.jruby.util.ConvertBytes

public class ConvertBytes
extends java.lang.Object

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	ConvertBytes.ERange

Field Summary

Fields

Modifier and Type	Field and Description
private org.jruby.util.ByteList	_str
private boolean	badcheck
private int	base
private static byte[]	conv_digit
private byte[]	data
private static boolean[]	digit
private int	end
private boolean	is19
private static byte[]	LOWER_DIGITS
private static byte[][]	MIN_VALUE_BYTES
private Ruby	runtime
private static boolean[]	space
private static boolean[]	spaceOrUnderscore
private int	str
private static byte[]	UPPER_DIGITS
private static byte[]	ZERO_BYTES

Constructor Summary

Constructors

Constructor and Description
ConvertBytes(Ruby runtime, org.jruby.util.ByteList _str, int base, boolean badcheck)
ConvertBytes(Ruby runtime, org.jruby.util.ByteList _str, int base, boolean badcheck, boolean is19)

Method Summary

Modifier and Type	Method and Description
private RubyInteger	bigParse(int len, boolean sign)
RubyInteger	byteListToInum()
static RubyInteger	byteListToInum(Ruby runtime, org.jruby.util.ByteList str, int base, boolean badcheck) rb_cstr_to_inum
static RubyInteger	byteListToInum19(Ruby runtime, org.jruby.util.ByteList str, int base, boolean badcheck)
static byte[]	bytesToUUIDBytes(byte[] randBytes, boolean upper)
private int	calculateLength()
private byte	convertDigit(byte c) conv_digit
private void	figureOutBase()
private boolean	getSign()
private void	ignoreLeadingWhitespace()
static org.jruby.util.ByteList	intToBinaryByteList(int i)
static byte[]	intToBinaryBytes(int i)
static byte[]	intToByteArray(int i, int radix, boolean upper)
static byte[]	intToCharBytes(int i)
static org.jruby.util.ByteList	intToHexByteList(int i)
static org.jruby.util.ByteList	intToHexByteList(int i, boolean upper)
static byte[]	intToHexBytes(int i)
static byte[]	intToHexBytes(int i, boolean upper)
static org.jruby.util.ByteList	intToOctalByteList(int i)
static byte[]	intToOctalBytes(int i)
private static org.jruby.util.ByteList	intToUnsignedByteList(int i, int shift, byte[] digitmap)
private void	invalidString(java.lang.String type) rb_invalid_str
private boolean	isDigit(byte[] buf, int str) ISDIGIT
private boolean	isSpace(int str) ISSPACE
private boolean	isSpaceOrUnderscore(int str) ISSPACE || *str == '_'
static org.jruby.util.ByteList	longToBinaryByteList(long i)
static byte[]	longToBinaryBytes(long i)
static byte[]	longToByteArray(long i, int radix, boolean upper)
static org.jruby.util.ByteList	longToByteList(long i)
static org.jruby.util.ByteList	longToByteList(long i, int radix)
static org.jruby.util.ByteList	longToByteList(long i, int radix, byte[] digitmap)
static byte[]	longToCharBytes(long i)
static org.jruby.util.ByteList	longToHexByteList(long i)
static org.jruby.util.ByteList	longToHexByteList(long i, boolean upper)
static byte[]	longToHexBytes(long i)
static byte[]	longToHexBytes(long i, boolean upper)
static org.jruby.util.ByteList	longToOctalByteList(long i)
static byte[]	longToOctalBytes(long i)
private static org.jruby.util.ByteList	longToUnsignedByteList(long i, int shift, byte[] digitmap)
private void	squeezeZeroes()
private long	stringToLong(int nptr, int[] endptr, int base)
static byte[]	twosComplementToBinaryBytes(byte[] in)
static byte[]	twosComplementToHexBytes(byte[] in, boolean upper)
static byte[]	twosComplementToOctalBytes(byte[] in)
static byte[]	twosComplementToUnsignedBytes(byte[] in, int shift, boolean upper)

Methods inherited from class java.lang.Object

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

Field Detail

runtime

private final Ruby runtime

_str

private final org.jruby.util.ByteList _str

str

private int str

end

private int end

data

private byte[] data

base

private int base

badcheck

private final boolean badcheck

is19

private final boolean is19

ZERO_BYTES

private static final byte[] ZERO_BYTES

MIN_VALUE_BYTES

private static final byte[][] MIN_VALUE_BYTES

LOWER_DIGITS

private static final byte[] LOWER_DIGITS

UPPER_DIGITS

private static final byte[] UPPER_DIGITS

conv_digit

private static final byte[] conv_digit

digit

private static final boolean[] digit

space

private static final boolean[] space

spaceOrUnderscore

private static final boolean[] spaceOrUnderscore

Constructor Detail

ConvertBytes

public ConvertBytes(Ruby runtime,
                    org.jruby.util.ByteList _str,
                    int base,
                    boolean badcheck)

ConvertBytes

public ConvertBytes(Ruby runtime,
                    org.jruby.util.ByteList _str,
                    int base,
                    boolean badcheck,
                    boolean is19)

Method Detail

intToBinaryBytes

public static final byte[] intToBinaryBytes(int i)

intToOctalBytes

public static final byte[] intToOctalBytes(int i)

intToHexBytes

public static final byte[] intToHexBytes(int i)

intToHexBytes

public static final byte[] intToHexBytes(int i,
                                         boolean upper)

intToBinaryByteList

public static final org.jruby.util.ByteList intToBinaryByteList(int i)

intToOctalByteList

public static final org.jruby.util.ByteList intToOctalByteList(int i)

intToHexByteList

public static final org.jruby.util.ByteList intToHexByteList(int i)

intToHexByteList

public static final org.jruby.util.ByteList intToHexByteList(int i,
                                                             boolean upper)

intToByteArray

public static final byte[] intToByteArray(int i,
                                          int radix,
                                          boolean upper)

intToCharBytes

public static final byte[] intToCharBytes(int i)

longToBinaryBytes

public static final byte[] longToBinaryBytes(long i)

longToOctalBytes

public static final byte[] longToOctalBytes(long i)

longToHexBytes

public static final byte[] longToHexBytes(long i)

longToHexBytes

public static final byte[] longToHexBytes(long i,
                                          boolean upper)

longToBinaryByteList

public static final org.jruby.util.ByteList longToBinaryByteList(long i)

longToOctalByteList

public static final org.jruby.util.ByteList longToOctalByteList(long i)

longToHexByteList

public static final org.jruby.util.ByteList longToHexByteList(long i)

longToHexByteList

public static final org.jruby.util.ByteList longToHexByteList(long i,
                                                              boolean upper)

longToByteArray

public static final byte[] longToByteArray(long i,
                                           int radix,
                                           boolean upper)

longToCharBytes

public static final byte[] longToCharBytes(long i)

longToByteList

public static final org.jruby.util.ByteList longToByteList(long i)

longToByteList

public static final org.jruby.util.ByteList longToByteList(long i,
                                                           int radix)

longToByteList

public static final org.jruby.util.ByteList longToByteList(long i,
                                                           int radix,
                                                           byte[] digitmap)

intToUnsignedByteList

private static final org.jruby.util.ByteList intToUnsignedByteList(int i,
                                                                   int shift,
                                                                   byte[] digitmap)

longToUnsignedByteList

private static final org.jruby.util.ByteList longToUnsignedByteList(long i,
                                                                    int shift,
                                                                    byte[] digitmap)

twosComplementToBinaryBytes

public static final byte[] twosComplementToBinaryBytes(byte[] in)

twosComplementToOctalBytes

public static final byte[] twosComplementToOctalBytes(byte[] in)

twosComplementToHexBytes

public static final byte[] twosComplementToHexBytes(byte[] in,
                                                    boolean upper)

twosComplementToUnsignedBytes

public static final byte[] twosComplementToUnsignedBytes(byte[] in,
                                                         int shift,
                                                         boolean upper)

byteListToInum

public static RubyInteger byteListToInum(Ruby runtime,
                                         org.jruby.util.ByteList str,
                                         int base,
                                         boolean badcheck)

rb_cstr_to_inum

byteListToInum19

public static RubyInteger byteListToInum19(Ruby runtime,
                                           org.jruby.util.ByteList str,
                                           int base,
                                           boolean badcheck)

bytesToUUIDBytes

public static byte[] bytesToUUIDBytes(byte[] randBytes,
                                      boolean upper)

convertDigit

private byte convertDigit(byte c)

conv_digit

isSpace

private boolean isSpace(int str)

ISSPACE

isDigit

private boolean isDigit(byte[] buf,
                        int str)

ISDIGIT

isSpaceOrUnderscore

private boolean isSpaceOrUnderscore(int str)

ISSPACE || *str == '_'

getSign

private boolean getSign()

ignoreLeadingWhitespace

private void ignoreLeadingWhitespace()

figureOutBase

private void figureOutBase()

calculateLength

private int calculateLength()

squeezeZeroes

private void squeezeZeroes()

stringToLong

private long stringToLong(int nptr,
                          int[] endptr,
                          int base)

byteListToInum

public RubyInteger byteListToInum()

bigParse

private RubyInteger bigParse(int len,
                             boolean sign)

invalidString

private void invalidString(java.lang.String type)

rb_invalid_str