/* * this.values = copy.values; this.table = copy.table; this.state = copy.state; this.freeEntries = * copy.freeEntries; this.distinct = copy.distinct; this.lowWaterMark = copy.lowWaterMark; * this.highWaterMark = copy.highWaterMark; this.minLoadFactor = copy.minLoadFactor; * this.maxLoadFactor = copy.maxLoadFactor; */ @Override public void write(DataOutput out) throws IOException { this.trimToSize(); WritableUtils.writeVInt(out, freeEntries); WritableUtils.writeVInt(out, distinct); WritableUtils.writeVInt(out, lowWaterMark); WritableUtils.writeVInt(out, highWaterMark); out.writeDouble(minLoadFactor); out.writeDouble(maxLoadFactor); WritableUtils.writeVInt(out, table.length); for (int i = 0; i < table.length; i++) { WritableUtils.writeVInt(out, table[i]); } WritableUtils.writeVInt(out, values.length); for (int i = 0; i < values.length; i++) { out.writeDouble(values[i]); } WritableUtils.writeVInt(out, state.length); for (int i = 0; i < state.length; i++) { out.writeByte(state[i]); } }
@Override public void toData(DataOutput out) throws IOException { out.writeInt(this.prId); out.writeByte(this.scope.ordinal); InternalDataSerializer.invokeToData(this.pAttrs, out); out.writeBoolean(this.isDestroying); out.writeBoolean(this.isColocationComplete); InternalDataSerializer.invokeToData(this.nodes, out); DataSerializer.writeString(this.partitionResolver, out); DataSerializer.writeString(this.colocatedWith, out); DataSerializer.writeString(this.fullPath, out); InternalDataSerializer.invokeToData(this.ea, out); InternalDataSerializer.invokeToData(this.regionIdleTimeout, out); InternalDataSerializer.invokeToData(this.regionTimeToLive, out); InternalDataSerializer.invokeToData(this.entryIdleTimeout, out); InternalDataSerializer.invokeToData(this.entryTimeToLive, out); out.writeBoolean(this.firstDataStoreCreated); DataSerializer.writeObject(elderFPAs, out); DataSerializer.writeArrayList(this.partitionListenerClassNames, out); if (this.gatewaySenderIds.isEmpty()) { DataSerializer.writeObject(null, out); } else { DataSerializer.writeObject(this.gatewaySenderIds, out); } }
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 write(DataOutput out) throws IOException { out.writeInt(set.size()); for (long l : set) { out.writeLong(l); } }
@Override protected void writeNode(DataOutput out) throws IOException { out.writeInt(attr); out.writeDouble(split); loChild.write(out); hiChild.write(out); }
/** * See PIG-2936. The purpose of this test is to ensure that Tuples are being serialized in the * specific way that we expect. */ @Test public void testTupleSerializationSpecific() throws Exception { byte[] flags = { BinInterSedes.TUPLE_0, BinInterSedes.TUPLE_1, BinInterSedes.TUPLE_2, BinInterSedes.TUPLE_3, BinInterSedes.TUPLE_4, BinInterSedes.TUPLE_5, BinInterSedes.TUPLE_6, BinInterSedes.TUPLE_7, BinInterSedes.TUPLE_8, BinInterSedes.TUPLE_9, }; for (int i = 0; i < flags.length; i++) { Tuple t = mTupleFactory.newTuple(i); ByteArrayOutputStream baos = new ByteArrayOutputStream(); DataOutput out = new DataOutputStream(baos); out.writeByte(flags[i]); for (int j = 0; j < i; j++) { Integer val = Integer.valueOf(random.nextInt()); bis.writeDatum(out, val); t.set(j, val); } testSerTuple(t, baos.toByteArray()); } }
@Override public void toData(DataOutput out) throws IOException { super.toData(out); out.writeInt(this.prId); out.writeInt(this.processorId); DataSerializer.writeObject(this.profiles, out); }
void writeData(DataOutput out) throws IOException { out.writeInt(rowIndices.size()); if (rowIndices.size() > 0) { int n = rowIndices.get(0).length; out.writeInt(n); if (this.useDictionary == true) { dict.write(out); for (int i = 0; i < rowIndices.size(); i++) { int[] row = rowIndices.get(i); for (int j = 0; j < n; j++) { out.writeInt(row[j]); } } } else { for (int i = 0; i < rowIndices.size(); i++) { int[] row = rowIndices.get(i); for (int j = 0; j < n; j++) { out.writeUTF(dict.getValueFromId(row[j])); } } } } }
public void save(final DataOutput out) { super.save(out); myType.save(out); try { if (myValue instanceof String) { out.writeByte(STRING); String value = (String) myValue; RW.writeUTF(out, value); } else if (myValue instanceof Integer) { out.writeByte(INTEGER); DataInputOutputUtil.writeINT(out, ((Integer) myValue).intValue()); } else if (myValue instanceof Long) { out.writeByte(LONG); out.writeLong(((Long) myValue).longValue()); } else if (myValue instanceof Float) { out.writeByte(FLOAT); out.writeFloat(((Float) myValue).floatValue()); } else if (myValue instanceof Double) { out.writeByte(DOUBLE); out.writeDouble(((Double) myValue).doubleValue()); } else if (myValue instanceof Type) { out.writeByte(TYPE); RW.writeUTF(out, ((Type) myValue).getDescriptor()); } else { out.writeByte(NONE); } } catch (IOException e) { throw new BuildDataCorruptedException(e); } }
public void writeObject(DataOutput out) throws IOException { super.writeObject(out); scope = new int[((Light) node).numScopes()]; for (int i = 0; i < ((Light) node).numScopes(); i++) { scope[i] = control.getSymbolTable().addReference(((Light) node).getScope(i)); ; } boundingLeaf = control.getSymbolTable().addReference(((Light) node).getInfluencingBoundingLeaf()); Color3f color = new Color3f(); ((Light) node).getColor(color); control.writeColor3f(out, color); out.writeBoolean(((Light) node).getEnable()); out.writeInt(boundingLeaf); control.writeBounds(out, ((Light) node).getInfluencingBounds()); out.writeInt(scope.length); for (int i = 0; i < scope.length; i++) { out.writeInt(scope[i]); } }
/** * Write a Map<String, Integer> * * @param out DataOutput * @param map Map to write * @throws IOException I/O errors */ public static void writeStrIntMap(DataOutput out, Map<String, Integer> map) throws IOException { out.writeInt(map.size()); for (Map.Entry<String, Integer> entry : map.entrySet()) { WritableUtils.writeString(out, entry.getKey()); out.writeInt(entry.getValue()); } }
@Override public void write(final DataOutput out) throws IOException { out.writeUTF(this.inputSpecID); Class<?> delegateClass = this.delegate.getClass(); out.writeUTF(delegateClass.getName()); serializeDelegate(new AdapterOutput(out), delegateClass); }
/** Write the actual data contents of the tag, implemented in NBT extension classes */ void write(DataOutput output) throws IOException { output.writeInt(this.intArray.length); for (int var2 = 0; var2 < this.intArray.length; ++var2) { output.writeInt(this.intArray[var2]); } }
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 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); } }
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(); } } } }
/** * The object implements the writeTo method to save its contents by calling the methods of * DataOutput for its primitive values and strings or calling the writeTo method for other * objects. * * @param out the stream to write the object to. * @throws IOException Includes any I/O exceptions that may occur. */ public void writeTo(DataOutput out) throws IOException { out.writeInt(schemaId); out.writeInt(ids.length); for (Integer id : ids) out.writeInt(id); }
@Override public void writeObject(DataOutput out) throws IOException { super.writeObject(out); out.writeFloat(((PositionInterpolator) node).getStartPosition()); out.writeFloat(((PositionInterpolator) node).getEndPosition()); }
public void serialize(final DataOutput output) { try { output.writeDouble(maxError); output.writeDouble(alpha); output.writeLong(landmarkInSeconds); output.writeLong(min); output.writeLong(max); output.writeInt(totalNodeCount); postOrderTraversal( root, new Callback() { @Override public boolean process(Node node) { try { serializeNode(output, node); } catch (IOException e) { Throwables.propagate(e); } return true; } }); } catch (IOException e) { Throwables.propagate(e); } }
protected void tightMarshalByteArray2(byte[] data, DataOutput dataOut, BooleanStream bs) throws IOException { if (bs.readBoolean()) { dataOut.writeInt(data.length); dataOut.write(data); } }
/** Abstract. Writes the raw packet data to the data stream. */ public void writePacketData(DataOutput par1DataOutput) throws IOException { par1DataOutput.writeDouble(this.xPosition); par1DataOutput.writeDouble(this.yPosition); par1DataOutput.writeDouble(this.stance); par1DataOutput.writeDouble(this.zPosition); super.writePacketData(par1DataOutput); }
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()); } }
/** * Serializes this object. * * @param out where to write the raw byte representation */ public void write(DataOutput out) throws IOException { int size = size(); out.writeInt(size); for (int i = 0; i < size; i++) { out.writeInt(get(i)); } }
@Override public void serialize(DataOutput out) throws IOException { out.write(multiplexerSessions.size()); for (String id : multiplexerSessions) { out.writeUTF(id); } }
@Override public void write(DataOutput out) throws IOException { out.writeInt(VERSION); out.writeInt(byteSize); out.writeInt(hashCount); out.writeInt(keyCount.intValue()); }
@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()); }
/** * Serializes a long to a binary stream with zero-compressed encoding. For -112 <= i <= 127, only * one byte is used with the actual value. For other values of i, the first byte value indicates * whether the long is positive or negative, and the number of bytes that follow. If the first * byte value v is between -113 and -120, the following long is positive, with number of bytes * that follow are -(v+112). If the first byte value v is between -121 and -128, the following * long is negative, with number of bytes that follow are -(v+120). Bytes are stored in the * high-non-zero-byte-first order. * * @param stream Binary output stream * @param i Long to be serialized * @throws java.io.IOException */ public static void writeVLong(DataOutput stream, long i) throws IOException { if (i >= -112 && i <= 127) { stream.writeByte((byte) i); return; } int len = -112; if (i < 0) { i ^= -1L; // take one's complement' len = -120; } long tmp = i; while (tmp != 0) { tmp = tmp >> 8; len--; } stream.writeByte((byte) len); len = (len < -120) ? -(len + 120) : -(len + 112); for (int idx = len; idx != 0; idx--) { int shiftbits = (idx - 1) * 8; long mask = 0xFFL << shiftbits; stream.writeByte((byte) ((i & mask) >> shiftbits)); } }
@Override public void write(DataOutput out) throws IOException { super.write(out); out.writeLong(myTimestamp); out.writeBoolean(isReadOnly); myContent.write(out); }
@Override public void toData(DataOutput out) throws IOException { super.toData(out); out.writeByte(this.attributeCode); out.writeInt(this.newValue); out.writeInt(this.cacheId); }
@Override public void write(DataOutput out) throws IOException { out.writeShort(vbuckets.size()); for (Integer v : vbuckets) { out.writeShort(v.shortValue()); } }