public void a(DataOutput dataoutput) {
dataoutput.writeInt(this.a);
dataoutput.writeShort(this.b);
dataoutput.writeInt(this.c);
dataoutput.writeByte((byte) this.d);
a(this.e, dataoutput);
}
@Override
public void writeToDataOutput(DataOutput write) throws IOException {
write.writeUTF(buildVersion);
write.writeInt(gameId);
write.writeUTF(guid);
write.writeUTF(password);
write.writeUTF(secret);
write.writeInt(keyTime);
if (key != null) {
write.writeShort(key.length);
write.write(key);
} else {
write.writeShort(0);
}
if (unkStr != null) {
byte[] buf = unkStr.getBytes("UTF-8");
write.writeInt(buf.length);
write.write(buf);
} else {
write.writeInt(0);
}
write.writeUTF(pk);
write.writeUTF(Tq);
write.writeUTF(H);
write.writeUTF(playPlatform);
}
@Override
public void write(DataOutput out) throws IOException {
out.writeShort(vbuckets.size());
for (Integer v : vbuckets) {
out.writeShort(v.shortValue());
}
}
void write(DataOutput out) throws IOException {
out.writeShort(getStartPc());
out.writeShort(getLength());
out.writeShort(getNameIndex());
out.writeShort(getTypeIndex());
out.writeShort(getLocal());
}
public void func_73273_a(DataOutput p_73273_1_) throws IOException {
p_73273_1_.writeByte(this.field_73444_a);
p_73273_1_.writeShort(this.field_73442_b);
p_73273_1_.writeByte(this.field_73443_c);
p_73273_1_.writeShort(this.field_73440_d);
p_73273_1_.writeByte(this.field_73439_f);
func_73270_a(this.field_73441_e, p_73273_1_);
}
public void write(DataOutput buffer) throws IOException {
buffer.writeFloat(size);
buffer.writeFloat(strength);
buffer.writeFloat(phase);
buffer.writeFloat(pad);
buffer.writeShort(depth);
buffer.writeShort(modification);
}
private void writeHeader(int options, int bitmapCount, byte[] packDataChecksum)
throws IOException {
out.write(PackBitmapIndexV1.MAGIC);
dataOutput.writeShort(1);
dataOutput.writeShort(options);
dataOutput.writeInt(bitmapCount);
out.write(packDataChecksum);
}
public void write(DataOutput out) throws InvalidByteCodeException, IOException {
super.write(out);
out.writeShort(startPc);
out.writeShort(endPc);
out.writeShort(handlerPc);
out.writeShort(catchType);
if (debug) debug("wrote ");
}
public void write(DataOutput out) throws InvalidByteCodeException, IOException {
super.write(out);
out.writeShort(innerClassInfoIndex);
out.writeShort(outerClassInfoIndex);
out.writeShort(innerNameIndex);
out.writeShort(innerClassAccessFlags);
if (debug) debug("wrote ");
}
/**
* Writes this message to the given <tt>DataOutput</tt>.
*
* @param dout a <tt>DataOutput</tt> instance.
* @throws IOException if an I/O related error occurs.
*/
public void writeTo(DataOutput dout) throws IOException {
if (!isHeadless()) {
dout.writeShort(getTransactionID());
dout.writeShort(getProtocolID());
dout.writeShort(getDataLength());
}
dout.writeByte(getUnitID());
dout.writeByte(getFunctionCode());
writeData(dout);
} // writeTo
public void writeDataTo(DataOutput dout) throws IOException {
int size = mEntries.size();
dout.writeShort(size);
for (int i = 0; i < size; i++) {
Entry entry = (Entry) mEntries.get(i);
int start_pc = entry.mStart.getLocation();
check("line number table entry start PC", start_pc);
dout.writeShort(start_pc);
dout.writeShort(entry.mLineNumber);
}
}
@Override
protected void writeArray(DataOutput out) throws IOException {
// little endian
if (BufferUtil.isBackedBySimpleArray(content)) {
short[] a = content.array();
for (int k = 0; k < this.cardinality; ++k) {
out.writeShort(Short.reverseBytes(a[k]));
}
} else {
for (int k = 0; k < this.cardinality; ++k) {
out.writeShort(Short.reverseBytes(content.get(k)));
}
}
}
protected void tightMarshalCachedObject2(
OpenWireFormat wireFormat, DataStructure o, DataOutput dataOut, BooleanStream bs)
throws IOException {
if (wireFormat.isCacheEnabled()) {
Short index = wireFormat.getMarshallCacheIndex(o);
if (bs.readBoolean()) {
dataOut.writeShort(index.shortValue());
wireFormat.tightMarshalNestedObject2(o, dataOut, bs);
} else {
dataOut.writeShort(index.shortValue());
}
} else {
wireFormat.tightMarshalNestedObject2(o, dataOut, bs);
}
}
public void writeShort(int v) {
try {
dataOutput.writeShort(v);
} catch (IOException ex) {
throw new RuntimeException(ex.getMessage());
}
}
public void writeDataTo(DataOutput dout) throws IOException {
int size = mInnerClasses.size();
dout.writeShort(size);
for (int i = 0; i < size; i++) {
((Info) mInnerClasses.get(i)).writeTo(dout);
}
}
private static void writeWatchableObject(
DataOutput par0DataOutput, WatchableObject par1WatchableObject) throws IOException {
int i =
(par1WatchableObject.getObjectType() << 5 | par1WatchableObject.getDataValueId() & 31)
& 255;
par0DataOutput.writeByte(i);
switch (par1WatchableObject.getObjectType()) {
case 0:
par0DataOutput.writeByte(((Byte) par1WatchableObject.getObject()).byteValue());
break;
case 1:
par0DataOutput.writeShort(((Short) par1WatchableObject.getObject()).shortValue());
break;
case 2:
par0DataOutput.writeInt(((Integer) par1WatchableObject.getObject()).intValue());
break;
case 3:
par0DataOutput.writeFloat(((Float) par1WatchableObject.getObject()).floatValue());
break;
case 4:
Packet.writeString((String) par1WatchableObject.getObject(), par0DataOutput);
break;
case 5:
ItemStack itemstack = (ItemStack) par1WatchableObject.getObject();
Packet.writeItemStack(itemstack, par0DataOutput);
break;
case 6:
ChunkCoordinates chunkcoordinates = (ChunkCoordinates) par1WatchableObject.getObject();
par0DataOutput.writeInt(chunkcoordinates.posX);
par0DataOutput.writeInt(chunkcoordinates.posY);
par0DataOutput.writeInt(chunkcoordinates.posZ);
}
}
@Override
public void writeToOutput(DataOutput out) throws IOException {
out.writeShort(this.offer.length);
for (boolean b : this.offer) {
out.writeBoolean(b);
}
}
/**
* DO NOT call symbolTable.addReference in writeObject as this (may) result in a
* concurrentModificationException.
*
* <p>All references should be created in the constructor
*/
public void writeObject(DataOutput out) throws IOException {
boolean sgIO = node instanceof com.sun.j3d.utils.scenegraph.io.SceneGraphIO;
out.writeBoolean(sgIO);
out.writeInt(symbol.nodeID);
int nodeClassID = control.getNodeClassID(node);
out.writeShort(nodeClassID);
if (nodeClassID == -1) out.writeUTF(nodeClassName);
writeConstructorParams(out);
if (sgIO) {
ByteArrayOutputStream byteStream = new ByteArrayOutputStream();
DataOutputStream tmpOut = new DataOutputStream(byteStream);
((com.sun.j3d.utils.scenegraph.io.SceneGraphIO) node).writeSceneGraphObject(tmpOut);
tmpOut.close();
out.writeInt(byteStream.size());
out.write(byteStream.toByteArray());
}
writeUserData(out);
writeString(node.getName(), out);
writeCapabilities(out);
}
protected void looseMarshalCachedObject(
OpenWireFormat wireFormat, DataStructure o, DataOutput dataOut) throws IOException {
if (wireFormat.isCacheEnabled()) {
Short index = wireFormat.getMarshallCacheIndex(o);
dataOut.writeBoolean(index == null);
if (index == null) {
index = wireFormat.addToMarshallCache(o);
dataOut.writeShort(index.shortValue());
wireFormat.looseMarshalNestedObject(o, dataOut);
} else {
dataOut.writeShort(index.shortValue());
}
} else {
wireFormat.looseMarshalNestedObject(o, dataOut);
}
}
/**
* Write this class into the the file (out) getting data position from the constant pool
*
* @param cp the constant pool that contain all data
* @param out the file where to write this object info
* @exception java.io.IOException an io problem has occured
* @exception ClassFileFormatException attempt to write a bad classfile info
*/
/*package*/ void write(ConstantPool cp, DataOutput out)
throws IOException, ClassFileFormatException {
out.writeShort(attributes.length);
for (int i = 0; i < attributes.length; i++) {
attributes[i].write(cp, out);
}
}
/** Abstract. Writes the raw packet data to the data stream. */
public void writePacketData(DataOutput par1DataOutput) throws IOException {
par1DataOutput.writeByte(this.windowId);
par1DataOutput.writeShort(this.itemStack.length);
for (int var2 = 0; var2 < this.itemStack.length; ++var2) {
writeItemStack(this.itemStack[var2], par1DataOutput);
}
}
public void writeTo(DataOutput out) throws Exception {
out.writeByte(type);
switch (type) {
case DATA:
Bits.writeLong(seqno, out);
out.writeShort(conn_id);
out.writeBoolean(first);
break;
case ACK:
Bits.writeLong(seqno, out);
out.writeShort(conn_id);
break;
case SEND_FIRST_SEQNO:
Bits.writeLong(seqno, out);
break;
}
}
@Override
public void writeToOutput(DataOutput out) throws IOException {
out.writeInt(this.accountListId);
out.writeShort(this.accountIds.length);
for (String accountId : this.accountIds) {
out.writeUTF(accountId);
}
}
public void writeData(DataOutput dout) throws IOException {
dout.writeShort(getReference());
if (getCoil()) {
dout.write(Modbus.COIL_ON_BYTES, 0, 2);
} else {
dout.write(Modbus.COIL_OFF_BYTES, 0, 2);
}
} // writeData
public void writeData(DataOutput dout) throws IOException {
// 1. the reference
dout.writeShort(m_Reference);
// 2. the word count
dout.writeShort(getWordCount());
// 3. the byte count as byte
dout.writeByte(getByteCount());
// 4. write values
if (m_NonWordDataHandler == null) {
for (int n = 0; n < m_Registers.length; n++) {
dout.write(m_Registers[n].toBytes());
}
} else {
m_NonWordDataHandler.prepareData(getReference(), getWordCount());
dout.write(m_NonWordDataHandler.getData());
}
} // writeData
@Override
public void writeShort(int v) {
try {
output.writeShort(v);
} catch (IOException impossible) {
throw new AssertionError(impossible);
}
}
protected static void writeMessage(Message msg, DataOutput dos, boolean multicast)
throws Exception {
byte flags = 0;
dos.writeShort(Version.version); // write the version
if (multicast) flags += MULTICAST;
dos.writeByte(flags);
msg.writeTo(dos);
}
private void doWrite(DataOutput dataOutput) {
try {
dataOutput.writeByte(getTag());
dataOutput.writeShort(descriptorIndex);
} catch (IOException e) {
}
}
public void writeData(DataOutput dout) throws IOException {
dout.writeShort(m_Reference);
if (m_Coil) {
dout.write(Modbus.COIL_ON_BYTES, 0, 2);
} else {
dout.write(Modbus.COIL_OFF_BYTES, 0, 2);
}
}
public void write(DataOutput out) throws InvalidByteCodeException, IOException {
out.writeShort(attributeNameIndex);
out.writeInt(getAttributeLength());
if (getClass().equals(AttributeInfo.class)) {
out.write(info);
if (debug) debug("wrote " + getDebugMessage());
}
}