Java Code Examples for org.apache.flink.core.memory.DataInputView#readInt()

@SuppressWarnings("unchecked")
@Override
public void read(DataInputView in) throws IOException {
	super.read(in);

	// read in a way that allows the stream to recover from exceptions
	int serializerBytes = in.readInt();
	byte[] buffer = new byte[serializerBytes];
	in.readFully(buffer);

	ClassLoader previousClassLoader = Thread.currentThread().getContextClassLoader();
	try (
		InstantiationUtil.FailureTolerantObjectInputStream ois =
			new InstantiationUtil.FailureTolerantObjectInputStream(new ByteArrayInputStream(buffer), userClassLoader)) {

		Thread.currentThread().setContextClassLoader(userClassLoader);
		typeSerializer = (TypeSerializer<T>) ois.readObject();
	} catch (Exception e) {
		throw new UnloadableTypeSerializerException(e, buffer);
	} finally {
		Thread.currentThread().setContextClassLoader(previousClassLoader);
	}
}
 

@Override
public StreamElement deserialize(DataInputView source) throws IOException {
	int tag = source.readByte();
	if (tag == TAG_REC_WITH_TIMESTAMP) {
		long timestamp = source.readLong();
		return new StreamRecord<T>(typeSerializer.deserialize(source), timestamp);
	}
	else if (tag == TAG_REC_WITHOUT_TIMESTAMP) {
		return new StreamRecord<T>(typeSerializer.deserialize(source));
	}
	else if (tag == TAG_WATERMARK) {
		return new Watermark(source.readLong());
	}
	else if (tag == TAG_STREAM_STATUS) {
		return new StreamStatus(source.readInt());
	}
	else if (tag == TAG_LATENCY_MARKER) {
		return new LatencyMarker(source.readLong(), new OperatorID(source.readLong(), source.readLong()), source.readInt());
	}
	else {
		throw new IOException("Corrupt stream, found tag: " + tag);
	}
}
 

@Override
public void readSnapshot(int readVersion, DataInputView in, ClassLoader userCodeClassLoader)
		throws IOException {
	int length = in.readInt();
	DataInputViewStream stream = new DataInputViewStream(in);
	previousTypes = new LogicalType[length];
	for (int i = 0; i < length; i++) {
		try {
			previousTypes[i] = InstantiationUtil.deserializeObject(
					stream,
					userCodeClassLoader
			);
		}
		catch (ClassNotFoundException e) {
			throw new IOException(e);
		}
	}
	this.nestedSerializersSnapshotDelegate = NestedSerializersSnapshotDelegate.readNestedSerializerSnapshots(
			in,
			userCodeClassLoader
	);
}
 

@Override
public void copy(DataInputView source, DataOutputView target) throws IOException {
	final int size = source.readInt();
	target.writeInt(size);

	for (int i = 0; i < size; ++i) {
		boolean keyIsNull = source.readBoolean();
		target.writeBoolean(keyIsNull);
		if (!keyIsNull) {
			keySerializer.copy(source, target);
		}

		boolean valueIsNull = source.readBoolean();
		target.writeBoolean(valueIsNull);

		if (!valueIsNull) {
			valueSerializer.copy(source, target);
		}
	}
}
 

@Override
public void readMappingsInKeyGroup(@Nonnull DataInputView in, @Nonnegative int keyGroupId) throws IOException {
	int numElements = in.readInt();
	for (int i = 0; i < numElements; i++) {
		T element = readerFunction.readElement(in);
		elementConsumer.consume(element, keyGroupId);
	}
}
 

private BucketState<BucketID> deserializeV2(DataInputView dataInputView) throws IOException {
	final BucketID bucketId = SimpleVersionedSerialization.readVersionAndDeSerialize(bucketIdSerializer, dataInputView);
	final String bucketPathStr = dataInputView.readUTF();
	final long creationTime = dataInputView.readLong();

	// then get the current resumable stream
	InProgressFileWriter.InProgressFileRecoverable current = null;
	if (dataInputView.readBoolean()) {
		current = SimpleVersionedSerialization.readVersionAndDeSerialize(inProgressFileRecoverableSerializer, dataInputView);
	}

	final int pendingFileRecoverableSerializerVersion = dataInputView.readInt();
	final int numCheckpoints = dataInputView.readInt();
	final HashMap<Long, List<InProgressFileWriter.PendingFileRecoverable>> pendingFileRecoverablesPerCheckpoint = new HashMap<>(numCheckpoints);

	for (int i = 0; i < numCheckpoints; i++) {
		final long checkpointId = dataInputView.readLong();
		final int numOfPendingFileRecoverables = dataInputView.readInt();

		final List<InProgressFileWriter.PendingFileRecoverable> pendingFileRecoverables = new ArrayList<>(numOfPendingFileRecoverables);
		for (int j = 0; j < numOfPendingFileRecoverables; j++) {
			final byte[] bytes = new byte[dataInputView.readInt()];
			dataInputView.readFully(bytes);
			pendingFileRecoverables.add(pendingFileRecoverableSerializer.deserialize(pendingFileRecoverableSerializerVersion, bytes));
		}
		pendingFileRecoverablesPerCheckpoint.put(checkpointId, pendingFileRecoverables);
	}

	return new BucketState<>(bucketId, new Path(bucketPathStr), creationTime, current, pendingFileRecoverablesPerCheckpoint);
}
 

@Override
public void readMappingsInKeyGroup(@Nonnull DataInputView in, @Nonnegative int keyGroupId) throws IOException {
	int numElements = in.readInt();
	for (int i = 0; i < numElements; i++) {
		T element = readerFunction.readElement(in);
		elementConsumer.consume(element, keyGroupId);
	}
}
 

@Override
protected PriorityQueue<StreamRecord<Tuple2<String, IN>>> restoreQueuerState(DataInputView dataInputView) throws IOException {
    int snapshotSize = dataInputView.readInt();
    int sizeOfQueue = snapshotSize > 0 ? snapshotSize : this.INITIAL_PRIORITY_QUEUE_CAPACITY;
    PriorityQueue<StreamRecord<Tuple2<String, IN>>> priorityQueue = new PriorityQueue<>(sizeOfQueue);
    for (int i = 0; i < snapshotSize; i++) {
        String streamId = dataInputView.readUTF();
        StreamElement streamElement = getStreamRecordSerializer(streamId).deserialize(dataInputView);
        priorityQueue.offer(streamElement.<Tuple2<String, IN>>asRecord());
    }
    return priorityQueue;
}
 

@Override
public void copy(DataInputView source, DataOutputView target) throws IOException {
	int len = source.readInt();
	target.writeInt(len);
	
	for (int i = 0; i < len; i++) {
		boolean isNonNull = source.readBoolean();
		target.writeBoolean(isNonNull);
		
		if (isNonNull) {
			componentSerializer.copy(source, target);
		}
	}
}
 

@Override
public void read(DataInputView in) throws IOException {
	position = in.readInt();
	mark = 0;

	ensureCapacity(position);

	for (int i = 0; i < position; i++) {
		data[i] = in.readFloat();
	}
}
 

@Test
public void close() throws Exception {

	int count = 0;
	int stopCount = NUM_HANDLES / 2;
	boolean isClosed = false;

	try {
		for (KeyGroupStatePartitionStreamProvider stateStreamProvider
				: initializationContext.getRawKeyedStateInputs()) {
			Assert.assertNotNull(stateStreamProvider);

			if (count == stopCount) {
				closableRegistry.close();
				isClosed = true;
			}

			try (InputStream is = stateStreamProvider.getStream()) {
				DataInputView div = new DataInputViewStreamWrapper(is);
				try {
					int val = div.readInt();
					Assert.assertEquals(stateStreamProvider.getKeyGroupId(), val);
					if (isClosed) {
						Assert.fail("Close was ignored: stream");
					}
					++count;
				} catch (IOException ioex) {
					if (!isClosed) {
						throw ioex;
					}
				}
			}
		}
		Assert.fail("Close was ignored: registry");
	} catch (IOException iex) {
		Assert.assertTrue(isClosed);
		Assert.assertEquals(stopCount, count);
	}

}
 

static KryoRegistration tryReadKryoRegistration(
	DataInputView in,
	ClassLoader userCodeClassLoader) throws IOException {

	String registeredClassname = in.readUTF();
	Class<?> registeredClass;
	try {
		registeredClass = Class.forName(registeredClassname, true, userCodeClassLoader);
	}
	catch (ClassNotFoundException e) {
		LOG.warn("Cannot find registered class " + registeredClassname + " for Kryo serialization in classpath;" +
			" using a dummy class as a placeholder.", e);
		return null;
	}

	final KryoRegistration.SerializerDefinitionType serializerDefinitionType =
		KryoRegistration.SerializerDefinitionType.values()[in.readInt()];

	switch (serializerDefinitionType) {
		case UNSPECIFIED: {
			return new KryoRegistration(registeredClass);
		}
		case CLASS: {
			return tryReadWithSerializerClass(in, userCodeClassLoader, registeredClassname, registeredClass);
		}
		case INSTANCE: {
			return tryReadWithSerializerInstance(in, userCodeClassLoader, registeredClassname, registeredClass);
		}
		default: {
			throw new IllegalStateException(
				"Unrecognized Kryo registration serializer definition type: " + serializerDefinitionType);
		}
	}
}
 

@Override
public void read(DataInputView in) throws IOException {
	val = in.readInt();
	size = in.readInt();
	
	for (int i = 0; i < size; i++) {
		byte b = in.readByte();
		assertEquals((byte) i, b);
	}
}
 

@Override
public Tuple deserialize(DataInputView source) throws IOException {

	// read length
	int arity = source.readInt();

	// initialize or resize null fields if necessary
	if(this.nullFields == null || this.nullFields.length < arity) {
		this.nullFields = new boolean[arity];
	}

	// read null mask
	NullMaskSerDeUtils.readNullMask(this.nullFields, arity, source);

	// read non-null fields
	Tuple tuple = Tuple.size(arity);
	for (int i = 0; i < arity; i++) {
		Object field;
		if(!this.nullFields[i]) {
			field = fieldSer.deserialize(source);
		}
		else {
			field = null;
		}
		tuple.set(i, field);
	}

	return tuple;
}
 

@Override
public float[] deserialize(DataInputView source) throws IOException {
	final int len = source.readInt();
	float[] result = new float[len];
	
	for (int i = 0; i < len; i++) {
		result[i] = source.readFloat();
	}
	
	return result;
}
 

@Override
public void read(final DataInputView in) throws IOException {
	this.value = in.readInt();
}
 

@Override
public IntPair deserialize(DataInputView source) throws IOException {
	return new IntPair(source.readInt(), source.readInt());
}
 

public void copy(DataInputView source, DataOutputView target) throws IOException {
  int serializedSize = source.readInt();
  target.writeInt(serializedSize);
  target.write(source, serializedSize);
}
 

@Override
public void read(DataInputView in) throws IOException {
	this.value = in.readInt();
}
 

@Override
public void copy(DataInputView source, DataOutputView target) throws IOException {
	final int len = source.readInt();
	target.writeInt(len);
	target.write(source, len);
}