public static String toString(boolean b)
{
return b ? new String("true") : new String("false");
}
public int compareTo(boolean b)
{
return compare(this.value, b.value);
}
public int compareTo(boolean b)
{
return(compare(this.value, b.value));
}
public void writeBoolean(boolean v)
{
@out.write(v ? 1 : 0);
incCount(1);
}
// private boolean enableResolve;
//private SerialCallbackContext curContext;
public ObjectInputStream(InputStream @in)
{
//verifySubclass();
bin = new BlockDataInputStream(@in);
handles = new HandleTable(10);
//vlist = new ValidationList();
enableOverride = false;
readStreamHeader();
bin.setBlockDataMode(true);
}
public new StringBuilder append(boolean b)
{
base.append(b);
return(this);
}
public new StringBuffer insert(int offset, boolean b)
{
return(insert(offset, String.valueOf(b)));
}
private int readBlockHeader(boolean canBlock)
{
//if (defaultDataEnd) {
// /*
// * Fix for 4360508: stream is currently at the end of a field
// * value block written via default serialization; since there
// * is no terminating TC_ENDBLOCKDATA tag, simulate
// * end-of-custom-data behavior explicitly.
// */
// return -1;
//}
try {
for (;;) {
int avail = canBlock ? Integer.MAX_VALUE : @in.available();
if (avail == 0) {
return HEADER_BLOCKED;
}
int tc = @in.peek();
switch (tc) {
case TC_BLOCKDATA:
if (avail < 2) {
return HEADER_BLOCKED;
}
@in.readFully(hbuf, 0, 2);
return hbuf[1] & 0xFF;
case TC_BLOCKDATALONG:
if (avail < 5) {
return HEADER_BLOCKED;
}
@in.readFully(hbuf, 0, 5);
int len = Bits.getInt(hbuf, 1);
if (len < 0) {
throw new Exception(
"illegal block data header length: " +
len);
}
return len;
/*
* TC_RESETs may occur @in between data blocks.
* Unfortunately, this case must be parsed at a lower
* level than other typecodes, since primitive data
* reads may span data blocks separated by a TC_RESET.
*/
case TC_RESET:
throw new NotImplementedException();
//@in.read();
//handleReset();
//break;
default:
if (tc >= 0 && (tc < TC_BASE || tc > TC_MAX)) {
throw new Exception();
}
return -1;
}
}
} catch (Exception) {
throw new Exception(
"unexpected EOF while reading block data header");
}
}
public virtual AbstractStringBuilder insert(int offset, boolean b)
{
return(insert(offset, String.valueOf(b)));
}
public new /*synchronized*/ StringBuffer append(boolean b)
{
base.append(b);
return(this);
}
public String[] split(String regex, int limit)
{
/* fastpath if the regex is a
* (1)one-char String and this character is not one of the
* RegEx's meta characters ".$|()[{^?*+\\", or
* (2)two-char String and the first char is the backslash and
* the second is not the ascii digit or ascii letter.
*/
char ch = (char)0;
if (((regex.value.Length == 1 &&
new String(".$|()[{^?*+\\").indexOf(ch = regex.charAt(0)) == -1) ||
(regex.length() == 2 &&
regex.charAt(0) == '\\' &&
(((ch = regex.charAt(1)) - '0') | ('9' - ch)) < 0 &&
((ch - 'a') | ('z' - ch)) < 0 &&
((ch - 'A') | ('Z' - ch)) < 0)) &&
(ch < Character.MIN_HIGH_SURROGATE ||
ch > Character.MAX_LOW_SURROGATE))
{
int off = 0;
int next = 0;
boolean limited = limit > 0;
ArrayList <String> list = new ArrayList <String>();
while ((next = indexOf(ch, off)) != -1)
{
if (!limited || list.size() < limit - 1)
{
list.add(substring(off, next));
off = next + 1;
}
else // last one
//assert (list.size() == limit - 1);
{
list.add(substring(off, value.Length));
off = value.Length;
break;
}
}
// If no match was found, return this
if (off == 0)
{
return new String[] { this }
}
;
// Add remaining segment
if (!limited || list.size() < limit)
{
list.add(substring(off, value.Length));
}
// Construct result
int resultSize = list.size();
if (limit == 0)
{
while (resultSize > 0 && list.get(resultSize - 1).length() == 0)
{
resultSize--;
}
}
String[] result = new String[resultSize];
return(list.subList(0, resultSize).toArray(result));
}
return(Pattern.compile(regex).split(this, limit));
}
internal String(char[] value, boolean share)
{
this.value = value;
}
public new StringBuilder insert(int offset, boolean b)
{
base.insert(offset, b);
return(this);
}
public void readFully(byte[] b, int off, int len, boolean copy)
{
while (len > 0) {
int n = read(b, off, len, copy);
if (n < 0) {
throw new Exception();
}
off += n;
len -= n;
}
}
protected Throwable(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace)
{
throw new RuntimeException("Stub!");
}
internal int read(byte[] b, int off, int len, boolean copy)
{
if (len == 0) {
return 0;
} else if (blkmode) {
if (pos == end) {
refill();
}
if (end < 0) {
return -1;
}
int nread = Math.min(len, end - pos);
System.Array.Copy(buf, pos, b, off, nread);
pos += nread;
return nread;
} else if (copy) {
int nread = @in.read(buf, 0, Math.min(len, MAX_BLOCK_SIZE));
if (nread > 0) {
System.Array.Copy(buf, 0, b, off, nread);
}
return nread;
} else {
return @in.read(b, off, len);
}
}
public PhoneNumber clearNationalNumber()
{
_hasNationalNumber = false;
nationalNumber_ = 0L;
return this;
}
private Object readHandle(boolean unshared)
{
if (bin.readByte() != TC_REFERENCE) {
throw new Exception();
}
passHandle = bin.readInt() - baseWireHandle;
if (passHandle < 0 || passHandle >= handles.size()) {
throw new Exception();
}
if (unshared) {
// REMIND: what type of exception to throw here?
throw new Exception(
"cannot read back reference as unshared");
}
Object obj = handles.lookupObject(passHandle);
if (obj == unsharedMarker) {
// REMIND: what type of exception to throw here?
throw new Exception(
"cannot read back reference to unshared object");
}
return obj;
}
public PhoneNumber clearPreferredDomesticCarrierCode()
{
_hasPreferredDomesticCarrierCode = false;
preferredDomesticCarrierCode_ = "";
return this;
}
public Matcher useTransparentBounds(boolean b)
{
transparentBounds = b;
return this;
}
public PhoneNumber clearRawInput()
{
_hasRawInput = false;
rawInput_ = "";
return this;
}
public static String toString(boolean b)
{
return(b ? new String("true") : new String("false"));
}
public PhoneNumber setCountryCode(int value)
{
_hasCountryCode = true;
countryCode_ = value;
return this;
}
public static int compare(boolean x, boolean y)
{
return((x == y) ? 0 : (x ? 1 : -1));
}
public PhoneNumber setCountryCodeSource(CountryCodeSource value)
{
//if (value == null) {
// throw new NullPointerException();
//}
_hasCountryCodeSource = true;
countryCodeSource_ = value;
return this;
}
public static int compare(boolean x, boolean y)
{
return (x == y) ? 0 : (x ? 1 : -1);
}
public PhoneNumber setExtension(String value)
{
if (value == null) {
throw new NullPointerException();
}
_hasExtension = true;
extension_ = value;
return this;
}
public static boolean valueOf(boolean b)
{
return (b ? TRUE : FALSE);
}
public PhoneNumber setItalianLeadingZero(boolean value)
{
_hasItalianLeadingZero = true;
italianLeadingZero_ = value;
return this;
}
protected ObjectInputStream()
{
//SecurityManager sm = System.getSecurityManager();
//if (sm != null) {
// sm.checkPermission(SUBCLASS_IMPLEMENTATION_PERMISSION);
//}
bin = null;
handles = null;
//vlist = null;
enableOverride = true;
}
public PhoneNumber setNationalNumber(long value)
{
_hasNationalNumber = true;
nationalNumber_ = value;
return this;
}
public override void close()
{
/*
* Even if stream already closed, propagate redundant close to
* underlying stream to stay consistent with previous implementations.
*/
closed = true;
if (depth == 0) {
clear();
}
bin.close();
}
public PhoneNumber setPreferredDomesticCarrierCode(String value)
{
if (value == null) {
throw new NullPointerException();
}
_hasPreferredDomesticCarrierCode = true;
preferredDomesticCarrierCode_ = value;
return this;
}
internal boolean setBlockDataMode(boolean newmode)
{
if (blkmode == newmode) {
return blkmode;
}
if (newmode) {
pos = 0;
end = 0;
unread = 0;
} else if (pos < end) {
throw new IllegalStateException("unread block data");
}
blkmode = newmode;
return !blkmode;
}
public PhoneNumber setRawInput(String value)
{
if (value == null) {
throw new NullPointerException();
}
_hasRawInput = true;
rawInput_ = value;
return this;
}
//public String readLine() {
// return din.readLine(); // deprecated, not worth optimizing
//}
/* -------------- primitive data array input methods --------------- */
/*
* The following methods read @in spans of primitive data values.
* Though equivalent to calling the corresponding primitive read
* methods repeatedly, these methods are optimized for reading groups
* of primitive data values more efficiently.
*/
void readBooleans(boolean[] v, int off, int len)
{
int stop, endoff = off + len;
while (off < endoff) {
if (!blkmode) {
int span = Math.min(endoff - off, MAX_BLOCK_SIZE);
@in.readFully(buf, 0, span);
stop = off + span;
pos = 0;
} else if (end - pos < 1) {
v[off++] = din.readBoolean();
continue;
} else {
stop = Math.min(endoff, off + end - pos);
}
while (off < stop) {
v[off++] = Bits.getBoolean(buf, pos++);
}
}
}
public virtual AbstractStringBuilder append(boolean b)
{
if (b) {
ensureCapacityInternal(count + 4);
value[count++] = 't';
value[count++] = 'r';
value[count++] = 'u';
value[count++] = 'e';
} else {
ensureCapacityInternal(count + 5);
value[count++] = 'f';
value[count++] = 'a';
value[count++] = 'l';
value[count++] = 's';
value[count++] = 'e';
}
return this;
}
//private Class readClass(boolean unshared) {
// if (bin.readByte() != TC_CLASS) {
// throw new Exception();
// }
// ObjectStreamClass desc = readClassDesc(false);
// Class cl = desc.forClass();
// passHandle = handles.assign(unshared ? unsharedMarker : cl);
// Exception resolveEx = desc.getResolveException();
// if (resolveEx != null) {
// handles.markException(passHandle, resolveEx);
// }
// handles.finish(passHandle);
// return cl;
//}
//private ObjectStreamClass readClassDesc(boolean unshared)
//{
// byte tc = bin.peekByte();
// switch (tc) {
// case TC_NULL:
// return (ObjectStreamClass) readNull();
// case TC_REFERENCE:
// return (ObjectStreamClass) readHandle(unshared);
// case TC_PROXYCLASSDESC:
// return readProxyDesc(unshared);
// case TC_CLASSDESC:
// return readNonProxyDesc(unshared);
// default:
// throw new StreamCorruptedException(
// String.format("invalid type code: %02X", tc));
// }
//}
//private boolean isCustomSubclass() {
// // Return true if this class is a custom subclass of ObjectInputStream
// return getClass().getClassLoader()
// != ObjectInputStream.class.getClassLoader();
//}
//private ObjectStreamClass readProxyDesc(boolean unshared)
//{
// if (bin.readByte() != TC_PROXYCLASSDESC) {
// throw new Exception();
// }
// ObjectStreamClass desc = new ObjectStreamClass();
// int descHandle = handles.assign(unshared ? unsharedMarker : desc);
// passHandle = NULL_HANDLE;
// int numIfaces = bin.readInt();
// String[] ifaces = new String[numIfaces];
// for (int i = 0; i < numIfaces; i++) {
// ifaces[i] = bin.readUTF();
// }
// Class cl = null;
// Exception resolveEx = null;
// bin.setBlockDataMode(true);
// try {
// if ((cl = resolveProxyClass(ifaces)) == null) {
// resolveEx = new Exception("null class");
// } else if (!Proxy.isProxyClass(cl)) {
// throw new InvalidClassException("Not a proxy");
// } else {
// // ReflectUtil.checkProxyPackageAccess makes a test
// // equivalent to isCustomSubclass so there's no need
// // to condition this call to isCustomSubclass == true here.
// ReflectUtil.checkProxyPackageAccess(
// getClass().getClassLoader(),
// cl.getInterfaces());
// }
// } catch (Exception ex) {
// resolveEx = ex;
// }
// skipCustomData();
// desc.initProxy(cl, resolveEx, readClassDesc(false));
// handles.finish(descHandle);
// passHandle = descHandle;
// return desc;
//}
//private ObjectStreamClass readNonProxyDesc(boolean unshared)
//{
// if (bin.readByte() != TC_CLASSDESC) {
// throw new Exception();
// }
// ObjectStreamClass desc = new ObjectStreamClass();
// int descHandle = handles.assign(unshared ? unsharedMarker : desc);
// passHandle = NULL_HANDLE;
// ObjectStreamClass readDesc = null;
// try {
// readDesc = readClassDescriptor();
// } catch (Exception ex) {
// throw (IOException) new InvalidClassException(
// "failed to read class descriptor").initCause(ex);
// }
// Class cl = null;
// Exception resolveEx = null;
// bin.setBlockDataMode(true);
// readonly boolean checksRequired = isCustomSubclass();
// try {
// if ((cl = resolveClass(readDesc)) == null) {
// resolveEx = new Exception("null class");
// } else if (checksRequired) {
// ReflectUtil.checkPackageAccess(cl);
// }
// } catch (Exception ex) {
// resolveEx = ex;
// }
// skipCustomData();
// desc.initNonProxy(readDesc, cl, resolveEx, readClassDesc(false));
// handles.finish(descHandle);
// passHandle = descHandle;
// return desc;
//}
private String readString(boolean unshared)
{
String str;
byte tc = bin.readByte();
switch (tc) {
case TC_STRING:
str = bin.readUTF();
break;
case TC_LONGSTRING:
throw new NotImplementedException();
//str = bin.readLongUTF();
//break;
default:
throw new Exception();
}
passHandle = handles.assign(unshared ? unsharedMarker : str);
handles.finish(passHandle);
return str;
}
public virtual AbstractStringBuilder insert(int offset, boolean b)
{
return insert(offset, String.valueOf(b));
}
public Matcher useAnchoringBounds(boolean b)
{
anchoringBounds = b;
return this;
}
public static boolean valueOf(boolean b)
{
return(b ? TRUE : FALSE);
}
internal boolean search(int from)
{
this._hitEnd = false;
this._requireEnd = false;
from = from < 0 ? 0 : from;
this.first = from;
this.oldLast = oldLast < 0 ? from : oldLast;
for (int i = 0; i < groups.Length; i++)
groups[i] = -1;
acceptMode = NOANCHOR;
boolean result = parentPattern.root.match(this, from, text);
if (!result)
this.first = -1;
this.oldLast = this.last;
return result;
}
public static int parseInt(String s, int radix)
{
/*
* WARNING: This method may be invoked early during VM initialization
* before IntegerCache is initialized. Care must be taken to not use
* the valueOf method.
*/
if (s == null)
{
throw new NumberFormatException("null");
}
if (radix < Character.MIN_RADIX)
{
throw new NumberFormatException("radix " + radix +
" less than Character.MIN_RADIX");
}
if (radix > Character.MAX_RADIX)
{
throw new NumberFormatException("radix " + radix +
" greater than Character.MAX_RADIX");
}
int result = 0;
boolean negative = false;
int i = 0, len = s.length();
int limit = -Integer.MAX_VALUE;
int multmin;
int digit;
if (len > 0)
{
char firstChar = s.charAt(0);
if (firstChar < '0') // Possible leading "+" or "-"
{
if (firstChar == '-')
{
negative = true;
limit = Integer.MIN_VALUE;
}
else if (firstChar != '+')
{
throw NumberFormatException.forInputString(s);
}
if (len == 1) // Cannot have lone "+" or "-"
{
throw NumberFormatException.forInputString(s);
}
i++;
}
multmin = limit / radix;
while (i < len)
{
// Accumulating negatively avoids surprises near MAX_VALUE
digit = Character.digit(s.charAt(i++), radix);
if (digit < 0)
{
throw NumberFormatException.forInputString(s);
}
if (result < multmin)
{
throw NumberFormatException.forInputString(s);
}
result *= radix;
if (result < limit + digit)
{
throw NumberFormatException.forInputString(s);
}
result -= digit;
}
}
else
{
throw NumberFormatException.forInputString(s);
}
return(negative ? result : -result);
}
