Java DataInput.readShort方法代码示例

import java.io.DataInput; //导入方法依赖的package包/类
/**
 * Reads an array of <code>short</code>s from a <code>DataInput</code>.
 *
 * @throws IOException A problem occurs while reading from <code>in</code>
 *
 * @see #writeShortArray
 */
public static short[] readShortArray(DataInput in) throws IOException {

  InternalDataSerializer.checkIn(in);

  int length = InternalDataSerializer.readArrayLength(in);
  if (length == -1) {
    return null;
  } else {
    short[] array = new short[length];
    for (int i = 0; i < length; i++) {
      array[i] = in.readShort();
    }

    if (logger.isTraceEnabled(LogMarker.SERIALIZER)) {
      logger.trace(LogMarker.SERIALIZER, "Read short array of length {}", length);
    }

    return array;
  }
}
 

import java.io.DataInput; //导入方法依赖的package包/类
/**
 * Fill out this instance of the message using the <code>DataInput</code> Required to be a
 * {@link org.apache.geode.DataSerializable}Note: must be symmetric with
 * {@link #toData(DataOutput)}in what it reads
 */
@Override
public void fromData(DataInput in) throws IOException, ClassNotFoundException {
  super.fromData(in);
  this.flags = in.readShort();
  setFlags(this.flags, in);
  this.regionPath = DataSerializer.readString(in);
  this.isTransactionDistributed = in.readBoolean();
}
 

import java.io.DataInput; //导入方法依赖的package包/类
/**
 * Creates a new {@link NormalizedNodeDataInput} instance that reads from the given input. This method first reads
 * and validates that the input contains a valid NormalizedNode stream.
 *
 * @param input the DataInput to read from
 * @return a new {@link NormalizedNodeDataInput} instance
 * @throws IOException if an error occurs reading from the input
 */
public static NormalizedNodeDataInput newDataInput(@Nonnull final DataInput input) throws IOException {
    final byte marker = input.readByte();
    if (marker != TokenTypes.SIGNATURE_MARKER) {
        throw new InvalidNormalizedNodeStreamException(String.format("Invalid signature marker: %d", marker));
    }

    final short version = input.readShort();
    switch (version) {
        case TokenTypes.LITHIUM_VERSION:
            return new NormalizedNodeInputStreamReader(input, true);
        default:
            throw new InvalidNormalizedNodeStreamException(String.format("Unhandled stream version %s", version));
    }
}
 

import java.io.DataInput; //导入方法依赖的package包/类
/**
 * Load information about root, and use the information to update the root
 * directory of NameSystem.
 * @param in The {@link DataInput} instance to read.
 * @param counter Counter to increment for namenode startup progress
 */
private void loadRoot(DataInput in, Counter counter)
    throws IOException {
  // load root
  if (in.readShort() != 0) {
    throw new IOException("First node is not root");
  }
  final INodeDirectory root = loadINode(null, false, in, counter)
    .asDirectory();
  // update the root's attributes
  updateRootAttr(root);
}
 

import java.io.DataInput; //导入方法依赖的package包/类
public void fromData(DataInput in) throws IOException, ClassNotFoundException {
  int flags = in.readUnsignedShort();
  if (logger.isTraceEnabled(LogMarker.VERSION_TAG)) {
    logger.info(LogMarker.VERSION_TAG, "deserializing {} with flags 0x{}", this.getClass(),
        Integer.toHexString(flags));
  }
  bitsUpdater.set(this, in.readUnsignedShort());
  this.distributedSystemId = in.readByte();
  if ((flags & VERSION_TWO_BYTES) != 0) {
    this.entryVersion = in.readShort() & 0xffff;
  } else {
    this.entryVersion = in.readInt() & 0xffffffff;
  }
  if ((flags & HAS_RVV_HIGH_BYTE) != 0) {
    this.regionVersionHighBytes = in.readShort();
  }
  this.regionVersionLowBytes = in.readInt();
  this.timeStamp = InternalDataSerializer.readUnsignedVL(in);
  if ((flags & HAS_MEMBER_ID) != 0) {
    this.memberID = readMember(in);
  }
  if ((flags & HAS_PREVIOUS_MEMBER_ID) != 0) {
    if ((flags & DUPLICATE_MEMBER_IDS) != 0) {
      this.previousMemberID = this.memberID;
    } else {
      this.previousMemberID = readMember(in);
    }
  }
  setIsRemoteForTesting();
}
 

import java.io.DataInput; //导入方法依赖的package包/类
public void fromData662(DataInput in) throws IOException, ClassNotFoundException {
  long diskStoreIdHigh = in.readLong();
  long diskStoreIdLow = in.readLong();
  this.diskStoreId = new DiskStoreID(diskStoreIdHigh, diskStoreIdLow);
  this.host = DataSerializer.readInetAddress(in);
  this.directory = DataSerializer.readString(in);
  this.timeStamp = in.readLong();
  this.version = in.readShort();
}
 

import java.io.DataInput; //导入方法依赖的package包/类
protected long readId(final DataInput in, final byte idType) throws IOException {
    switch (idType) {
    case ID_ONE_BYTE:
        return in.readByte() - Byte.MIN_VALUE;
    case ID_TWO_BYTES:
        return in.readShort() - Short.MIN_VALUE;
    case ID_FOUR_BYTES:
        return in.readInt() - Integer.MIN_VALUE;
    case ID_EIGHT_BYTES:
        return in.readLong() - Long.MIN_VALUE;
    default:
        throw new Error("Unknown idType " + idType);
    }
}
 

import java.io.DataInput; //导入方法依赖的package包/类
/**
 * Utility method to read a {@code String} from a {@code DataInput}, as encoded by {@link ByteBufferOut#writeString(String)}.
 * @param data The {@code DataInput} from which to read the {@code String}.
 * @return The {@code String}.
 * @throws IOException from reading {@code data}.
 */
public static String readString(DataInput data) throws IOException {
	int sz = data.readShort();
	if (sz < 0)
		return null;
	if (sz == 0)
		return "";
	byte[] buf = new byte[sz];
	data.readFully(buf);
	return new String(buf, Message.charset);
}
 

import java.io.DataInput; //导入方法依赖的package包/类
/**
 * Reads ordinal as written by {@link #writeOrdinal} from given {@link DataInput}.
 */
public static short readOrdinal(DataInput in) throws IOException {
  final byte ordinal = in.readByte();
  if (ordinal != TOKEN_ORDINAL) {
    return ordinal;
  } else {
    return in.readShort();
  }
}
 

import java.io.DataInput; //导入方法依赖的package包/类
@Override
public void read(DataInput stream) throws IOException{
    this.data = stream.readShort();
}
 

import java.io.DataInput; //导入方法依赖的package包/类
public static byte[] readLocalName(DataInput in) throws IOException {
  byte[] createdNodeName = new byte[in.readShort()];
  in.readFully(createdNodeName);
  return createdNodeName;
}
 

import java.io.DataInput; //导入方法依赖的package包/类
@Override
public void fromData(DataInput in) throws IOException, ClassNotFoundException {
  // super.fromData(in);
  short bits = in.readShort();
  short extBits = in.readShort();
  this.flags = bits;
  setFlags(bits, in);
  this.regionPath = DataSerializer.readString(in);
  this.op = Operation.fromOrdinal(in.readByte());
  // TODO dirack There's really no reason to send this flag across the wire
  // anymore
  this.directAck = (bits & DIRECT_ACK_MASK) != 0;
  this.possibleDuplicate = (bits & POSSIBLE_DUPLICATE_MASK) != 0;
  if ((bits & CALLBACK_ARG_MASK) != 0) {
    this.callbackArg = DataSerializer.readObject(in);
  }
  this.hasDelta = (bits & DELTA_MASK) != 0;
  this.hasOldValue = (bits & OLD_VALUE_MASK) != 0;
  if (this.hasOldValue) {
    byte b = in.readByte();
    if (b == 0) {
      this.oldValueIsSerialized = false;
    } else if (b == 1) {
      this.oldValueIsSerialized = true;
    } else {
      throw new IllegalStateException("expected 0 or 1");
    }
    this.oldValue = DataSerializer.readByteArray(in);
  }
  boolean hasFilterInfo = (bits & FILTER_INFO_MASK) != 0;
  this.needsRouting = (bits & NEEDS_ROUTING_MASK) != 0;
  if (hasFilterInfo) {
    this.filterRouting = new FilterRoutingInfo();
    InternalDataSerializer.invokeFromData(this.filterRouting, in);
  }
  if ((bits & VERSION_TAG_MASK) != 0) {
    boolean persistentTag = (bits & PERSISTENT_TAG_MASK) != 0;
    this.versionTag = VersionTag.create(persistentTag, in);
  }
  if ((extBits & INHIBIT_NOTIFICATIONS_MASK) != 0) {
    this.inhibitAllNotifications = true;
  }
}
 

import java.io.DataInput; //导入方法依赖的package包/类
@Override
public void fromData(DataInput in) throws IOException, ClassNotFoundException {
  versionOrdinal = in.readShort();
}
 

import java.io.DataInput; //导入方法依赖的package包/类
void read(DataInput input, int depth, NBTSizeTracker sizeTracker) throws IOException
{
    sizeTracker.read(80L);
    this.data = input.readShort();
}
 

import java.io.DataInput; //导入方法依赖的package包/类
@Override
public void readFields(DataInput in) throws IOException {
  super.readFields(in);
  type = in.readShort();
}