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);
 }
Example #2
0
  @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());
   }
 }
Example #4
0
 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_);
 }
Example #6
0
 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);
 }
Example #8
0
  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);
   }
 }
Example #14
0
 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);
    }
  }
Example #22
0
 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
Example #26
0
 @Override
 public void writeShort(int v) {
   try {
     output.writeShort(v);
   } catch (IOException impossible) {
     throw new AssertionError(impossible);
   }
 }
Example #27
0
 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);
   }
 }
Example #30
0
  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());
    }
  }