下面列出了java.io.DataInput#readByte ( ) 实例代码,或者点击链接到github查看源代码,也可以在右侧发表评论。
@Override
public void handleRequest(final DataInput input, final ActiveOperation.ResultHandler<Void> resultHandler, final ManagementRequestContext<ServerInventory> context) throws IOException {
final byte param = input.readByte(); // Started / Failed PARAM_OK
final String message = input.readUTF(); // Server started/failed message
context.executeAsync(new ManagementRequestContext.AsyncTask<ServerInventory>() {
@Override
public void execute(ManagementRequestContext<ServerInventory> serverInventoryManagementRequestContext) throws Exception {
try {
final ServerInventory inventory = context.getAttachment();
if(param == DomainServerProtocol.PARAM_OK) {
inventory.serverStarted(serverProcessName);
} else {
inventory.serverStartFailed(serverProcessName);
}
} finally {
resultHandler.done(null);
}
}
});
}
private void readEndOfRecord(DataInput di) throws IOException {
int b = di.readByte();
if (b != DiskInitFile.END_OF_RECORD_ID) {
if (b == 0) {
// this is expected if this is the last record and we died while writing it.
throw new EOFException("found partial last record");
} else {
// Our implementation currently relies on all unwritten bytes having
// a value of 0. So throw this exception if we find one we didn't expect.
throw new IllegalStateException("expected end of record (byte=="
+ DiskInitFile.END_OF_RECORD_ID
+ ") or zero but found " + b);
}
}
}
static OfYear readFrom(DataInput in) throws IOException {
return new OfYear((char)in.readUnsignedByte(),
(int)in.readUnsignedByte(),
(int)in.readByte(),
(int)in.readUnsignedByte(),
in.readBoolean(),
(int)readMillis(in));
}
@Override
public void readFields(DataInput in) throws IOException {
byte version = in.readByte();
if (version != VERSION) {
throw new IOException("Unknown version of delegation token " +
version);
}
owner.readFields(in, Text.DEFAULT_MAX_LEN);
renewer.readFields(in, Text.DEFAULT_MAX_LEN);
realUser.readFields(in, Text.DEFAULT_MAX_LEN);
issueDate = WritableUtils.readVLong(in);
maxDate = WritableUtils.readVLong(in);
sequenceNumber = WritableUtils.readVInt(in);
masterKeyId = WritableUtils.readVInt(in);
}
public static ZoneInfo getZoneInfo(DataInput in, String zoneId) throws Exception {
byte type = in.readByte();
// TBD: assert ZRULES:
int stdSize = in.readInt();
long[] stdTrans = new long[stdSize];
for (int i = 0; i < stdSize; i++) {
stdTrans[i] = readEpochSec(in);
}
int [] stdOffsets = new int[stdSize + 1];
for (int i = 0; i < stdOffsets.length; i++) {
stdOffsets[i] = readOffset(in);
}
int savSize = in.readInt();
long[] savTrans = new long[savSize];
for (int i = 0; i < savSize; i++) {
savTrans[i] = readEpochSec(in);
}
int[] savOffsets = new int[savSize + 1];
for (int i = 0; i < savOffsets.length; i++) {
savOffsets[i] = readOffset(in);
}
int ruleSize = in.readByte();
ZoneOffsetTransitionRule[] rules = new ZoneOffsetTransitionRule[ruleSize];
for (int i = 0; i < ruleSize; i++) {
rules[i] = new ZoneOffsetTransitionRule(in);
}
return getZoneInfo(zoneId, stdTrans, stdOffsets, savTrans, savOffsets, rules);
}
private static long readBits(DataInput input, int bytes) throws IOException {
long result = 0;
long shift = 0;
for (int i = 0; i < bytes; ++i) {
result = result | ((input.readByte() & 0xFFL) << shift);
shift += 8;
}
return result;
}
/**
* @param in to read bytes from
* @return decode value
* @throws IOException if {@link DataInput} throws {@link IOException}
* @throws IllegalArgumentException if variable-length value does not terminate
* after 9 bytes have been read
* @see #writeUnsignedVarLong(long, DataOutput)
*/
public static long readUnsignedVarLong(DataInput in) throws IOException {
long value = 0L;
int i = 0;
long b;
while (((b = in.readByte()) & 0x80L) != 0) {
value |= (b & 0x7F) << i;
i += 7;
if (i > 63) {
throw new RuntimeException("Variable length quantity is too long");
}
}
return value | (b << i);
}
@Override
public void fromData(DataInput in) throws IOException, ClassNotFoundException {
boolean keysPresent = in.readBoolean();
if (keysPresent) {
this.keys = new ArrayList();
}
this.hasKeys = keysPresent;
int numObjects = in.readInt();
this.objectTypeArray = new byte[numObjects];
if (numObjects > 0) {
for (int index = 0; index < numObjects; ++index) {
if (keysPresent) {
Object key = DataSerializer.readObject(in);
this.keys.add(key);
}
byte objectType = in.readByte();
this.objectTypeArray[index] = objectType;
Object value;
if (objectType==EXCEPTION) {
byte[] exBytes = DataSerializer.readByteArray(in);
value = CacheServerHelper.deserialize(exBytes);
// ignore the exception string meant for native clients
DataSerializer.readString(in);
}
else {
value = DataSerializer.readByteArray(in);
}
this.objects.add(value);
}
}
}
@Override
public void fromData(DataInput in)
throws IOException, ClassNotFoundException {
super.fromData(in);
this.name = in.readUTF();
this.fromClause = in.readUTF();
this.indexedExpression = in.readUTF();
this.indexType = in.readByte();
this.importsNeeded = in.readBoolean();
if (this.importsNeeded)
this.imports = in.readUTF();
// this.ifNew = in.readBoolean();
// this.ifOld = in.readBoolean();
}
public static int readUnsignedInt(@Nonnull final DataInput in) throws IOException {
int value = 0;
int i = 0;
int b;
while (((b = in.readByte()) & 0x80) != 0) {
value |= (b & 0x7F) << i;
i += 7;
if (i > 35) {
throw new IllegalArgumentException("Variable length quantity is too long: " + i);
}
}
return value | (b << i);
}
public void expand(DataInput in, byte[] out, int outPos, int outLen) throws IOException {
// if ((inPos | outPos | outLen) < 0) {
assert(outLen>=0);
do {
int ctrl = in.readByte() & 255;
if (ctrl < MAX_LITERAL) {
// literal run of length = ctrl + 1,
ctrl++;
// copy to output and move forward this many bytes
in.readFully(out,outPos,ctrl);
outPos += ctrl;
} else {
// back reference
// the highest 3 bits are the match length
int len = ctrl >> 5;
// if the length is maxed, add the next byte to the length
if (len == 7) {
len += in.readByte() & 255;
}
// minimum back-reference is 3 bytes,
// so 2 was subtracted before storing size
len += 2;
// ctrl is now the offset for a back-reference...
// the logical AND operation removes the length bits
ctrl = -((ctrl & 0x1f) << 8) - 1;
// the next byte augments/increases the offset
ctrl -= in.readByte() & 255;
// copy the back-reference bytes from the given
// location in output to current position
ctrl += outPos;
if (outPos + len >= out.length) {
// reduce array bounds checking
throw new ArrayIndexOutOfBoundsException();
}
for (int i = 0; i < len; i++) {
out[outPos++] = out[ctrl++];
}
}
} while (outPos < outLen);
}
static LocalDate readExternal(DataInput in) throws IOException {
int year = in.readInt();
int month = in.readByte();
int dayOfMonth = in.readByte();
return LocalDate.of(year, month, dayOfMonth);
}
static ThaiBuddhistDate readExternal(DataInput in) throws IOException {
int year = in.readInt();
int month = in.readByte();
int dayOfMonth = in.readByte();
return ThaiBuddhistChronology.INSTANCE.date(year, month, dayOfMonth);
}
static Object read(DataInput in) throws IOException {
byte type = in.readByte();
return readInternal(type, in);
}
static Object read(DataInput in) throws IOException, ClassNotFoundException {
byte type = in.readByte();
return readInternal(type, in);
}
/**
* Constructor to use when receiving a putall from someone else
*/
public PutAllEntryData(DataInput in, EventID baseEventID, int idx,
Version version, ByteArrayDataInput bytesIn) throws IOException,
ClassNotFoundException {
this.key = DataSerializer.readObject(in);
byte flgs = in.readByte();
if ((flgs & IS_OBJECT) != 0) {
this.value = DataSerializer.readObject(in);
}
else {
byte[] bb = DataSerializer.readByteArray(in);
if ((flgs & IS_CACHED_DESER) != 0) {
if (CachedDeserializableFactory.preferObject()) {
this.value = EntryEventImpl.deserialize(bb, version, bytesIn);
}
else {
this.value = CachedDeserializableFactory.create(bb);
}
}
else {
this.value = bb;
}
}
this.oldValue = null;
this.op = Operation.fromOrdinal(in.readByte());
this.flags = in.readByte();
if ((this.flags & FILTER_ROUTING) != 0) {
this.filterRouting = (FilterRoutingInfo)DataSerializer.readObject(in);
}
if ((this.flags & VERSION_TAG) != 0) {
boolean persistentTag = (this.flags & PERSISTENT_TAG) != 0;
this.versionTag = VersionTag.create(persistentTag, in);
}
if (isUsedFakeEventId()) {
this.eventID = new EventID();
InternalDataSerializer.invokeFromData(this.eventID, in);
}
else {
this.eventID = new EventID(baseEventID, idx);
}
if ((this.flags & HAS_CALLBACKARG) != 0) {
this.callbackArg = DataSerializer.readObject(in);
}
else {
this.callbackArg = null;
}
if ((this.flags & HAS_TAILKEY) != 0) {
this.tailKey = InternalDataSerializer.readSignedVL(in);
}
}
/**
* Reads one constant from the given input, the type depends on a tag byte.
*
* @param dataInput Input stream
* @return Constant object
* @throws IOException if an I/O error occurs reading from the given {@code dataInput}.
* @throws ClassFormatException if the next byte is not recognized
* @since 6.0 made public
*/
public static Constant readConstant(final DataInput dataInput) throws IOException, ClassFormatException {
final byte b = dataInput.readByte(); // Read tag byte
switch (b) {
case Const.CONSTANT_Class:
return new ConstantClass(dataInput);
case Const.CONSTANT_Fieldref:
return new ConstantFieldref(dataInput);
case Const.CONSTANT_Methodref:
return new ConstantMethodref(dataInput);
case Const.CONSTANT_InterfaceMethodref:
return new ConstantInterfaceMethodref(dataInput);
case Const.CONSTANT_String:
return new ConstantString(dataInput);
case Const.CONSTANT_Integer:
return new ConstantInteger(dataInput);
case Const.CONSTANT_Float:
return new ConstantFloat(dataInput);
case Const.CONSTANT_Long:
return new ConstantLong(dataInput);
case Const.CONSTANT_Double:
return new ConstantDouble(dataInput);
case Const.CONSTANT_NameAndType:
return new ConstantNameAndType(dataInput);
case Const.CONSTANT_Utf8:
return ConstantUtf8.getInstance(dataInput);
case Const.CONSTANT_MethodHandle:
return new ConstantMethodHandle(dataInput);
case Const.CONSTANT_MethodType:
return new ConstantMethodType(dataInput);
case Const.CONSTANT_Dynamic:
return new ConstantDynamic(dataInput);
case Const.CONSTANT_InvokeDynamic:
return new ConstantInvokeDynamic(dataInput);
case Const.CONSTANT_Module:
return new ConstantModule(dataInput);
case Const.CONSTANT_Package:
return new ConstantPackage(dataInput);
default:
throw new ClassFormatException("Invalid byte tag in constant pool: " + b);
}
}
static MonthDay readExternal(DataInput in) throws IOException {
byte month = in.readByte();
byte day = in.readByte();
return MonthDay.of(month, day);
}
@Override
public void fromData(DataInput in)
throws IOException, ClassNotFoundException {
super.fromData(in);
final Version version = InternalDataSerializer.getVersionForDataStream(in);
final boolean isVer11 = (Version.SQLF_11.compareTo(version) <= 0);
setKey(DataSerializer.readObject(in));
final int extraFlags = in.readUnsignedByte();
this.deserializationPolicy = (byte)(extraFlags
& DistributedCacheOperation.DESERIALIZATION_POLICY_MASK);
if (!isVer11) {
this.cbArg = DataSerializer.readObject(in);
}
this.lastModified = in.readLong();
this.op = Operation.fromOrdinal(in.readByte());
if (isVer11 && (extraFlags & HAS_CALLBACKARG) != 0) {
this.cbArg = DataSerializer.readObject(in);
}
if ((extraFlags & HAS_BRIDGE_CONTEXT) != 0) {
this.bridgeContext = DataSerializer.readObject(in);
}
if ((extraFlags & HAS_ORIGINAL_SENDER) != 0) {
this.originalSender = DataSerializer.readObject(in);
}
this.eventId = new EventID();
InternalDataSerializer.invokeFromData(this.eventId, in);
final short flags = this.flags;
this.ifNew = (flags & IF_NEW) != 0;
this.ifOld = (flags & IF_OLD) != 0;
this.requireOldValue = (flags & REQUIRED_OLD_VAL) != 0;
this.hasOldValue = (flags & HAS_OLD_VAL) != 0;
this.cacheWrite = (flags & CACHE_WRITE) != 0;
this.useOriginRemote = (flags & USE_ORIGIN_REMOTE) != 0;
this.isPutDML = (flags & IS_PUT_DML) != 0;
if ((flags & HAS_EXPECTED_OLD_VAL) != 0) {
this.expectedOldValue = DataSerializer.readObject(in);
}
if (this.hasOldValue) {
this.oldValueIsSerialized = in.readByte();
if (this.oldValueIsSerialized == VALUE_IS_OBJECT) {
setOldValObj(DataSerializer.readObject(in));
}
else {
setOldValBytes(DataSerializer.readByteArray(in));
}
}
if (this.deserializationPolicy ==
DistributedCacheOperation.DESERIALIZATION_POLICY_EAGER) {
setValObj(DataSerializer.readObject(in));
}
else {
setValBytes(DataSerializer.readByteArray(in));
}
if ((flags & HAS_DELTA_BYTES) != 0) {
this.applyDeltaBytes = true;
this.deltaBytes = DataSerializer.readByteArray(in);
}
if ((extraFlags & HAS_VERSION_TAG) != 0) {
this.versionTag = DataSerializer.readObject(in);
}
}
/**
* Reads the state from the stream.
*
* @param in the input stream, not null
* @return the created object, not null
* @throws IOException if an error occurs
*/
static ZoneOffset readOffset(DataInput in) throws IOException {
int offsetByte = in.readByte();
return (offsetByte == 127 ? ZoneOffset.ofTotalSeconds(in.readInt()) : ZoneOffset.ofTotalSeconds(offsetByte * 900));
}