public static final void writeString(CharSequence cs, DataOutput out) throws IOException { if (cs != null) { // the length we write is offset by one, because a length of zero indicates a null value int lenToWrite = cs.length() + 1; if (lenToWrite < 0) { throw new IllegalArgumentException("CharSequence is too long."); } // write the length, variable-length encoded while (lenToWrite >= HIGH_BIT) { out.write(lenToWrite | HIGH_BIT); lenToWrite >>>= 7; } out.write(lenToWrite); // write the char data, variable length encoded for (int i = 0; i < cs.length(); i++) { int c = cs.charAt(i); while (c >= HIGH_BIT) { out.write(c | HIGH_BIT); c >>>= 7; } out.write(c); } } else { out.write(0); } }
public void write(final DataOutput dataoutput) throws IOException { dataoutput.writeInt(fileOffset); dataoutput.write(attribute); dataoutput.write((byte) (uniqueID >> 16)); dataoutput.write((byte) (uniqueID >> 8)); dataoutput.write((byte) uniqueID); }
@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); }
public void a(DataOutput dataoutput) { dataoutput.write(this.e); dataoutput.writeInt(this.a); dataoutput.write(this.b); dataoutput.writeInt(this.c); dataoutput.write(this.face); }
private void writeSearchResults(IFrameTupleAccessor leftAccessor, int tIndex) throws Exception { while (cursor.hasNext()) { tb.reset(); cursor.next(); ITupleReference frameTuple = cursor.getTuple(); for (int i = 0; i < inputRecDesc.getFields().length; i++) { int tupleStart = leftAccessor.getTupleStartOffset(tIndex); int fieldStart = leftAccessor.getFieldStartOffset(tIndex, i); int offset = leftAccessor.getFieldSlotsLength() + tupleStart + fieldStart; int len = leftAccessor.getFieldEndOffset(tIndex, i) - fieldStart; dos.write(leftAccessor.getBuffer().array(), offset, len); tb.addFieldEndOffset(); } for (int i = 0; i < frameTuple.getFieldCount(); i++) { dos.write( frameTuple.getFieldData(i), frameTuple.getFieldStart(i), frameTuple.getFieldLength(i)); tb.addFieldEndOffset(); } if (!appender.append(tb.getFieldEndOffsets(), tb.getByteArray(), 0, tb.getSize())) { FrameUtils.flushFrame(writeBuffer, writer); appender.reset(writeBuffer, true); if (!appender.append(tb.getFieldEndOffsets(), tb.getByteArray(), 0, tb.getSize())) { throw new IllegalStateException(); } } } }
/** * Writes this record to a {@link DataOutput} stream. The output may, in some edge cases, be not * byte-for-byte identical to what was parsed from a {@link DataInput}. However it has the same * meaning and should not lose any information. * * @param out The output stream to which this record should be appended. * @throws IOException */ public void write(DataOutput out) throws IOException { header.write(out); out.write(CRLF_BYTES); out.write(content); out.write(CRLF_BYTES); out.write(CRLF_BYTES); }
public void writePayload(DataOutput buffer) throws IOException { buffer.write(_protocolHeader); buffer.write(_protocolClass); buffer.write(_protocolInstance); buffer.write(_protocolMajor); buffer.write(_protocolMinor); }
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 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
@Override public void writeData(DataOutput writer) throws IOException { for (Map.Entry<String, DataTagBase> entry : dataMap.entrySet()) { writer.write(entry.getValue().getId()); writer.writeChars(entry.getKey()); entry.getValue().writeData(writer); } writer.write(0); }
public void getClosedFieldValue(ARecordType recordType, int fieldId, DataOutput dOut) throws IOException, AsterixException { if (isClosedFieldNull(recordType, fieldId)) { dOut.writeByte(ATypeTag.NULL.serialize()); } else { dOut.write(getClosedFieldTag(recordType, fieldId)); dOut.write( bytes, getClosedFieldOffset(recordType, fieldId), getClosedFieldSize(recordType, fieldId)); } }
@Override public void writeTo(DataOutput out) throws IOException { out.writeUTF(commandName); out.writeUTF(commandIdentifier); out.writeBoolean(expectReply); out.writeUTF(payloadType); out.writeUTF(payloadRevision == null ? "_null" : payloadRevision); out.writeInt(serializedPayload.length); out.write(serializedPayload); out.writeInt(serializedMetaData.length); out.write(serializedMetaData); }
private void write(DataOutput out, ByteBuffer[] nioBuffers) throws IOException { final int length = nioBuffers.length; for (int i = 0; i < length; i++) { int remaining = nioBuffers[i].remaining(); if (nioBuffers[i].hasArray()) { out.write(nioBuffers[i].array(), nioBuffers[i].arrayOffset(), remaining); } else { byte[] me = new byte[remaining]; nioBuffers[i].get(me); out.write(me); } } }
@Override public void convertString(UTF8StringPointable stringp, DataOutput dOut) throws SystemException, IOException { boolean castable = true; try { abvsInner.reset(); CastToIntegerOperation castTo = new CastToIntegerOperation(); castTo.convertString(stringp, dOutInner); } catch (Exception e) { castable = false; } dOut.write(ValueTag.XS_BOOLEAN_TAG); dOut.write((byte) (castable ? 1 : 0)); }
/** * 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); }
@Override public void write(DataOutput dOut) throws IOException { dOut.writeUTF(instanceId); // Hadoop Configuration has to get its act right ByteArrayOutputStream baos = new ByteArrayOutputStream(); conf.writeXml(baos); baos.close(); byte[] array = baos.toByteArray(); dOut.writeInt(array.length); dOut.write(array); def.write(dOut); dOut.writeUTF(status.toString()); dOut.writeInt(executionPaths.size()); for (Map.Entry<String, NodeInstance> entry : executionPaths.entrySet()) { dOut.writeUTF(entry.getKey()); dOut.writeUTF(entry.getValue().nodeName); dOut.writeBoolean(entry.getValue().started); } dOut.writeInt(persistentVars.size()); for (Map.Entry<String, String> entry : persistentVars.entrySet()) { dOut.writeUTF(entry.getKey()); writeStringAsBytes(entry.getValue(), dOut); } }
/** * Write the current message to an ExtendedDataOutput object * * @param dataOutput Where the current message will be written to */ public void writeCurrentMessageBytes(DataOutput dataOutput) { try { dataOutput.write(getByteArray(), messageOffset, messageBytes); } catch (IOException e) { throw new IllegalStateException("writeCurrentMessageBytes: Got " + "IOException", e); } }
@Override public void save(@NotNull DataOutput out, PsiJavaFileStub value) throws IOException { BufferExposingByteArrayOutputStream buffer = new BufferExposingByteArrayOutputStream(); mySerializer.serialize(value, buffer); out.writeInt(buffer.size()); out.write(buffer.getInternalBuffer(), 0, buffer.size()); }
@Override public void serialize(DataOutput out) throws IOException { out.write(multiplexerSessions.size()); for (String id : multiplexerSessions) { out.writeUTF(id); } }
@Override public void convertString(UTF8StringPointable stringp, DataOutput dOut) throws SystemException, IOException { ICharacterIterator charIterator = new UTF8StringCharacterIterator(stringp); charIterator.reset(); long value = 0; int c = 0; boolean negative = false; long limit = -Integer.MAX_VALUE; // Check the first character. c = charIterator.next(); if (c == Character.valueOf('-') && negativeAllowed) { negative = true; c = charIterator.next(); limit = Integer.MIN_VALUE; } // Read the numeric value. do { if (Character.isDigit(c)) { if (value < limit + Character.getNumericValue(c)) { throw new SystemException(ErrorCode.FORG0001); } value = value * 10 - Character.getNumericValue(c); } else { throw new SystemException(ErrorCode.FORG0001); } } while ((c = charIterator.next()) != ICharacterIterator.EOS_CHAR); dOut.write(returnTag); dOut.writeInt((int) (negative ? value : -value)); }
public void write(byte[] b, int off, int len) { try { dataOutput.write(b, off, len); } catch (IOException ex) { throw new RuntimeException(ex.getMessage()); } }
protected void tightMarshalByteArray2(byte[] data, DataOutput dataOut, BooleanStream bs) throws IOException { if (bs.readBoolean()) { dataOut.writeInt(data.length); dataOut.write(data); } }
/** in order to improve the likelihood of not corrupting the header write as a single operation */ protected void write(DataOutput out) throws IOException { ByteBuffer buffer = ByteBuffer.allocate(16); buffer.putLong(dataPointer); buffer.putInt(dataCapacity); buffer.putInt(dataCount); out.write(buffer.array(), 0, 16); }
public void getOpenFieldValue(ARecordType recordType, int fieldId, DataOutput dOut) throws IOException, AsterixException { dOut.write( bytes, getOpenFieldValueOffset(recordType, fieldId), getOpenFieldValueSize(recordType, fieldId)); }
@Override public void writeData(DataOutput writer) throws IOException { for (DataTagBase tag : tags) { writer.write(tag.getId()); tag.writeData(writer); } }
public void write(DataOutput out) throws IOException { out.writeInt(key.length); out.write(key); out.writeLong(createdTime); out.writeLong(modifiedTime); out.writeByte(state); }
public static long inputStream2DataOutput( final InputStream is, final DataOutput output, final BytesPool pool) { long totalBytes = 0; final Ref<byte[]> bytes = pool.retainObject(); try { while (is.available() > 0) { final int actualSize = is.read(bytes.object()); if (actualSize == -1) { break; } output.write(bytes.object(), 0, actualSize); totalBytes += actualSize; if (LOG.isTraceEnabled()) { LOG.trace("read bytebuf's content to bytesList, size {}", actualSize); } } } catch (Throwable e) { LOG.warn( "exception when inputStream -> OutputStream, detail: {}", ExceptionUtils.exception2detail(e)); } finally { bytes.release(); } return totalBytes; }
protected void tightMarshalByteSequence2(ByteSequence data, DataOutput dataOut, BooleanStream bs) throws IOException { if (bs.readBoolean()) { dataOut.writeInt(data.getLength()); dataOut.write(data.getData(), data.getOffset(), data.getLength()); } }
private void buffering(byte[] buffer, int pos, byte value, DataOutput out) throws IOException { int innerPos = pos % buffer.length; if (pos > 0 && innerPos == 0) { out.write(buffer, 0, buffer.length); } buffer[innerPos] = value; }
public void write(int b) { try { dataOutput.write(b); } catch (IOException ex) { throw new RuntimeException(ex.getMessage()); } }