name stringlengths 12 178 | code_snippet stringlengths 8 36.5k | score float64 3.26 3.68 |
|---|---|---|
flink_AbstractBlockResettableIterator_open_rdh | // --------------------------------------------------------------------------------------------
public void
open() {if (f0.isDebugEnabled()) {
f0.debug("Block Resettable Iterator opened.");
}
} | 3.26 |
flink_AbstractBlockResettableIterator_close_rdh | /**
* This method closes the iterator and releases all resources. This method works both as a
* regular shutdown and as a canceling method. The method may be called multiple times and will
* not produce an error.
*/
public void close() {
synchronized(this) {
if (this.closed) {
return;}
... | 3.26 |
flink_Costs_setCpuCost_rdh | /**
* Sets the cost for the CPU.
*
* @param cost
* The CPU Cost.
*/
public void setCpuCost(double cost) {
if ((cost == UNKNOWN) || (cost >= 0)) {
this.cpuCost = cost;
} else {
throw new IllegalArgumentException();
}
} | 3.26 |
flink_Costs_addCpuCost_rdh | /**
* Adds the given CPU cost to the current CPU cost for this Costs object.
*
* @param cost
* The CPU cost to add.
*/
public void addCpuCost(double cost) {
this.cpuCost = ((this.cpuCost < 0) || (cost < 0)) ? UNKNOWN : this.cpuCost +
cost;
} | 3.26 |
flink_Costs_setHeuristicDiskCost_rdh | /**
* Sets the heuristic costs for disk for this Costs object.
*
* @param cost
* The heuristic disk cost to set.
*/public void setHeuristicDiskCost(double cost) {
if (cost <= 0) {
throw new IllegalArgumentException("Heuristic costs must be positive.");
}
this.heuristicDiskCost = cost;
} | 3.26 |
flink_Costs_addCosts_rdh | // --------------------------------------------------------------------------------------------
/**
* Adds the given costs to these costs. If for one of the different cost components (network,
* disk), the costs are unknown, the resulting costs will be unknown.
*
* @param other
* The costs to add.
*/
public voi... | 3.26 |
flink_Costs_compareTo_rdh | // --------------------------------------------------------------------------------------------
/**
* The order of comparison is: network first, then disk, then CPU. The comparison here happens
* each time primarily after the heuristic costs, then after the quantifiable costs.
... | 3.26 |
flink_Costs_setDiskCost_rdh | /**
* Sets the costs for disk for this Costs object.
*
* @param bytes
* The disk cost to set, in bytes to be written and read.
*/
public void setDiskCost(double bytes) {
if ((bytes == UNKNOWN) || (bytes >= 0)) {
this.diskCost = bytes;
} else {
throw new IllegalArgumentException();
}
} | 3.26 |
flink_Costs_addHeuristicDiskCost_rdh | /**
* Adds the heuristic costs for disk to the current heuristic disk costs for this Costs object.
*
* @param cost
* The heuristic disk cost to add.
*/
public void addHeuristicDiskCost(double cost) {
if (cost <= 0) {
throw new IllegalArgumentException("Heuristic costs must be positive.");
}
t... | 3.26 |
flink_Costs_subtractCosts_rdh | /**
* Subtracts the given costs from these costs. If the given costs are unknown, then these costs
* are remain unchanged.
*
* @param other
* The costs to subtract.
*/
public void subt... | 3.26 |
flink_Costs_setHeuristicNetworkCost_rdh | /**
* Sets the heuristic network cost for this Costs object.
*
* @param cost
* The heuristic network cost to set, in bytes to be transferred.
*/
public void setHeuristicNetworkCost(double cost) {
if (cost <= 0) {
throw new IllegalArgumentException("Heuristic costs must be positive.");
}
... | 3.26 |
flink_Costs_setNetworkCost_rdh | /**
* Sets the network cost for this Costs object.
*
* @param bytes
* The network cost to set, in bytes to be transferred.
*/
public void setNetworkCost(double bytes)
{
if ((bytes == UNKNOWN) || (bytes >= 0)) {
this.networkCost = bytes;
} else {
throw new IllegalArgumentException();
}... | 3.26 |
flink_Costs_addHeuristicNetworkCost_rdh | /**
* Adds the heuristic costs for network to the current heuristic network costs for this Costs
* object.
*
* @param cost
* The heuristic network cost to add.
*/
public void addHeuristicNetworkCost(double cost) {
if (cost <= 0) {
throw new IllegalArgumentException("Heuristic costs must be positive... | 3.26 |
flink_Costs_getCpuCost_rdh | /**
* Gets the cost for the CPU.
*
* @return The CPU Cost.
*/
public double getCpuCost() {
return this.cpuCost;
} | 3.26 |
flink_Costs_addHeuristicCpuCost_rdh | /**
* Adds the given heuristic CPU cost to the current heuristic CPU cost for this Costs object.
*
* @param cost
* The heuristic CPU cost to add.
*/
public void addHeuristicCpuCost(double cost) {
if (cost <= 0) {
throw new IllegalArgumentException("Heuristic costs must be positive.");
}
this... | 3.26 |
flink_Costs_addDiskCost_rdh | /**
* Adds the costs for disk to the current disk costs for this Costs object.
*
* @param bytes
* The disk cost to add, in bytes to be written and read.
*/
public void addDiskCost(double bytes) {
this.diskCost = ((this.diskCost < 0) || (bytes < 0)) ?
UNKNOWN : this.diskCost + bytes;
} | 3.26 |
flink_Costs_addNetworkCost_rdh | /**
* Adds the costs for network to the current network costs for this Costs object.
*
* @param bytes
* The network cost to add, in bytes to be transferred.
*/
public void addNetworkCost(double bytes) {
this.networkCost = ((this.networkCost < 0) || (bytes < 0)) ? UNKNOWN : this.networkCost + bytes;
} | 3.26 |
flink_Costs_getHeuristicCpuCost_rdh | /**
* Gets the heuristic cost for the CPU.
*
* @return The heuristic CPU Cost.
*/
public double getHeuristicCpuCost() {
return this.heuristicCpuCost;
} | 3.26 |
flink_Costs_getHeuristicNetworkCost_rdh | // --------------------------------------------------------------------------------------------
/**
* Gets the heuristic network cost.
*
* @return The heuristic network cost, in bytes to be transferred.
*/
public double getHeuristicNetworkCost() {
return this.heuristicNetworkCost;
} | 3.26 |
flink_Costs_getNetworkCost_rdh | // --------------------------------------------------------------------------------------------
/**
* Gets the network cost.
*
* @return The network cost, in bytes to be transferred.
*/
public double getNetworkCost() {
return networkCost;
} | 3.26 |
flink_Costs_setHeuristicCpuCost_rdh | /**
* Sets the heuristic cost for the CPU.
*
* @param cost
* The heuristic CPU Cost.
*/
public void setHeuristicCpuCost(double cost) {
if (cost <= 0) {
throw new IllegalArgumentException("Heuristic costs must be positive.");
}
this.heuristicCpuCost = cost;
} | 3.26 |
flink_SlicingWindowOperator_m2_rdh | // ------------------------------------------------------------------------------
// Visible For Testing
// ------------------------------------------------------------------------------
@VisibleForTesting
public Counter m2() {
return
numLateRecordsDropped;
} | 3.26 |
flink_DefaultBlocklistTracker_tryAddOrMerge_rdh | /**
* Try to add a new blocked node record. If the node (identified by node id) already exists, the
* newly added one will be merged with the existing one.
*
* @param newNode
* the new blocked node record
* @return the add status
*/
private AddStatus tryAddOrMerge(BlockedNode newNode) {
checkNotNull(newNod... | 3.26 |
flink_EndOfSegmentEvent_hashCode_rdh | // ------------------------------------------------------------------------
@Override
public int hashCode() {
return 1965146672;
} | 3.26 |
flink_CreditBasedPartitionRequestClientHandler_exceptionCaught_rdh | /**
* Called on exceptions in the client handler pipeline.
*
* <p>Remote exceptions are received as regular payload.
*/
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
if (cause instanceof TransportException) {
notifyAllChannelsOfErrorAndClo... | 3.26 |
flink_CreditBasedPartitionRequestClientHandler_addInputChannel_rdh | // ------------------------------------------------------------------------
// Input channel/receiver registration
// ------------------------------------------------------------------------
@Override
public void addInputChannel(RemoteInputChannel listener) throws IOException {
checkError();
inputChannels.putIf... | 3.26 |
flink_CreditBasedPartitionRequestClientHandler_channelActive_rdh | // ------------------------------------------------------------------------
// Network events
// ------------------------------------------------------------------------
@Override
public void channelActive(final ChannelHandlerContext ctx) throws Exception {
if (this.ctx == null) {
this.ctx = ctx;
}
... | 3.26 |
flink_CreditBasedPartitionRequestClientHandler_checkError_rdh | // ------------------------------------------------------------------------
/**
* Checks for an error and rethrows it if one was reported.
*/
@VisibleForTesting
void checkError() throws IOException {
final Throwable t = channelError.get();
if (t != null) {
if (t instanceof IOException) {
... | 3.26 |
flink_CreditBasedPartitionRequestClientHandler_writeAndFlushNextMessageIfPossible_rdh | /**
* Tries to write&flush unannounced credits for the next input channel in queue.
*
* <p>This method may be called by the first input channel enqueuing, or the complete future's
* callback in previous input channel, or the channel writability changed event.
*/
private void writeAndFlushNextMessageIfPossible(Chan... | 3.26 |
flink_CreditBasedPartitionRequestClientHandler_userEventTriggered_rdh | /**
* Triggered by notifying credit available in the client handler pipeline.
*
* <p>Enqueues the input channel and will trigger write&flush unannounced credits for this input
* channel if it is the first one in the queue.
*/
@Override
public void userEventTriggered(ChannelHandlerContext ctx,
Object msg) throws E... | 3.26 |
flink_StructuredType_newBuilder_rdh | /**
* Creates a builder for a {@link StructuredType} that is not stored in a catalog and is
* identified by an implementation {@link Class}.
*/
public static StructuredType.Builder newBuilder(Class<?> implementationClass)
{
return new StructuredType.Builder(implementationClass);
} | 3.26 |
flink_UnionIterator_iterator_rdh | // ------------------------------------------------------------------------
@Override
public Iterator<T> iterator() {
if (iteratorAvailable) {
iteratorAvailable = false;
return this;
} else {
throw new TraversableOnceException();
}
} | 3.26 |
flink_LogicalScopeProvider_castFrom_rdh | /**
* Casts the given metric group to a {@link LogicalScopeProvider}, if it implements the
* interface.
*
* @param metricGroup
* metric group to cast
* @return cast metric group
* @throws IllegalStateException
* if the metric group did not implement the LogicalScopeProvider
* interface
*/static LogicalS... | 3.26 |
flink_FlinkAggregateRemoveRule_onMatch_rdh | // ~ Methods ----------------------------------------------------------------
public void onMatch(RelOptRuleCall call) {
final Aggregate aggregate = call.rel(0);
final RelNode input = call.rel(1);
// Distinct is "GROUP BY c1, c2" (where c1, c2 are a set of columns on
// which the input is unique, i.e. ... | 3.26 |
flink_TieredStorageNettyServiceImpl_setupInputChannels_rdh | /**
* Set up input channels in {@link SingleInputGate}. The method will be invoked by the pekko rpc
* thread at first, and then the method {@link TieredStorageNettyService#registerConsumer(TieredStoragePartitionId,
* TieredStorageSubpartitionId)} will be invoked by the same thread sequentially, which... | 3.26 |
flink_TieredStorageNettyServiceImpl_createResultSubpartitionView_rdh | /**
* Create a {@link ResultSubpartitionView} for the netty server.
*
* @param partitionId
* partition id indicates the unique id of {@link TieredResultPartition}.
* @param subpartitionId
* subpartition id indicates the unique id of subpartition.
* @param availabilityListener
* listener is used to listen ... | 3.26 |
flink_ProcessingTimeTriggers_every_rdh | /**
* Creates a trigger that fires by a certain interval after reception of the first element.
*
* @param time
* the certain interval
*/
public static <W extends Window> AfterFirstElementPeriodic<W> every(Duration time) {
return new AfterFirstElementPeriodic<>(time.toMillis());
} | 3.26 |
flink_ProcessingTimeTriggers_afterEndOfWindow_rdh | /**
* Creates a trigger that fires when the processing time passes the end of the window.
*/
public static <W extends Window> AfterEndOfWindow<W> afterEndOfWindow() {
return
new AfterEndOfWindow<>();
} | 3.26 |
flink_BlobCacheSizeTracker_untrackAll_rdh | /**
* Unregister all the tracked BLOBs related to the given job.
*/
public void untrackAll(JobID jobId) {
checkNotNull(jobId);
synchronized(lock) {
Set<BlobKey> keysToRemove = blobKeyByJob.remove(jobId);
if (keysToRemove != null) {
for (BlobKey key : keysToRemove) {
... | 3.26 |
flink_BlobCacheSizeTracker_untrack_rdh | /**
* Remove the BLOB from the tracker.
*/
private void untrack(JobID jobId, BlobKey blobKey) {
checkNotNull(jobId);
checkNotNull(blobKey);
untrack(Tuple2.of(jobId, blobKey));
} | 3.26 |
flink_BlobCacheSizeTracker_track_rdh | /**
* Register the BLOB to the tracker.
*/
public void track(JobID jobId, BlobKey blobKey, long size) {
checkNotNull(jobId);
checkNotNull(blobKey);
checkArgument(size >= 0);
synchronized(lock) {
if (caches.putIfAbsent(Tuple2.of(jobId, blobKey), size) == null) {blobKeyByJob.computeIfAbsent(jo... | 3.26 |
flink_BlobCacheSizeTracker_update_rdh | /**
* Update the least used index for the BLOBs so that the tracker can easily find out the least
* recently used BLOBs.
*/
public void update(JobID jobId, BlobKey blobKey) {
checkNotNull(jobId);
checkNotNull(blobKey);
synchronized(lock) {
caches.get(Tuple2.of(jobI... | 3.26 |
flink_BlobCacheSizeTracker_checkLimit_rdh | /**
* Check the size limit and return the BLOBs to delete.
*
* @param size
* size of the BLOB intended to put into the cache
* @return list of BLOBs to delete before putting into the target BLOB
*/
public List<Tuple2<JobID, BlobKey>> checkLimit(long size) {
checkArgument(size >= 0);
synchronized(lock) {... | 3.26 |
flink_SharedBufferNode_snapshotConfiguration_rdh | // -----------------------------------------------------------------------------------
@Override
public TypeSerializerSnapshot<SharedBufferNode> snapshotConfiguration() {
return new SharedBufferNodeSerializerSnapshot(this);
} | 3.26 |
flink_HiveFunction_createTypeInference_rdh | /**
* Creates {@link TypeInference} for the function.
*/
default TypeInference createTypeInference() {
TypeInference.Builder builder = TypeInference.newBuilder();
builder.inputTypeStrategy(new HiveFunctionInputStrategy(this));builder.outputTypeStrategy(new HiveFunctionOutputStrategy(this));
return builder... | 3.26 |
flink_TaskManagerServices_shutDown_rdh | // --------------------------------------------------------------------------------------------
// Shut down method
// --------------------------------------------------------------------------------------------
/**
* Shuts the {@link TaskExecutor} services down.
*/
public void shutDown() throws FlinkException {
... | 3.26 |
flink_TaskManagerServices_checkTempDirs_rdh | /**
* Validates that all the directories denoted by the strings do actually exist or can be
* created, are proper directories (not files), and are writable.
*
* @param tmpDirs
* The array of directory paths to check.
* @throws IOException
* Thrown if any of the directories does not exist and cannot be create... | 3.26 |
flink_TaskManagerServices_fromConfiguration_rdh | // --------------------------------------------------------------------------------------------
// Static factory methods for task manager services
// --------------------------------------------------------------------------------------------
/**
* Creates and returns the task manager services.
*
* @param taskManag... | 3.26 |
flink_TaskManagerServices_getManagedMemorySize_rdh | // --------------------------------------------------------------------------------------------
// Getter/Setter
// --------------------------------------------------------------------------------------------
public long getManagedMemorySize() {
return managedMemorySize;
} | 3.26 |
flink_MemorySegment_getShort_rdh | /**
* Reads a short integer value (16 bit, 2 bytes) from the given position, composing them into a
* short value according to the current byte order.
*
* @param index
* The position from which the memory will be read.
* @return The short value at the given position.
* @throws IndexOutOfBoundsException
* Thr... | 3.26 |
flink_MemorySegment_putFloatBigEndian_rdh | /**
* Writes the given single-precision float value (32bit, 4 bytes) to the given position in big
* endian byte order. This method's speed depends on the system's native byte order, and it is
* possibly slower than {@link #putFloat(int, float)}. For most cases (such as transient storage
* in memory or serialization... | 3.26 |
flink_MemorySegment_putShortBigEndian_rdh | /**
* Writes the given short integer value (16 bit, 2 bytes) to the given position in big-endian
* byte order. This method's speed depends on the system's native byte order, and it is possibly
* slower than {@link #putShort(int, short)}. For most cases (such as transient storage in
* memory or serialization for I/O... | 3.26 |
flink_MemorySegment_copyFromUnsafe_rdh | /**
* Bulk copy method. Copies {@code numBytes} bytes from source unsafe object and pointer. NOTE:
* This is an unsafe method, no check here, please be careful.
*
* @param offset
* The position where the bytes are started to be write in this memory segment.
* @param source
* The unsafe memory to copy the byt... | 3.26 |
flink_MemorySegment_getDoubleLittleEndian_rdh | /**
* Reads a double-precision floating point value (64bit, 8 bytes) from the given position, in
* little endian byte order. This method's speed depends on the system's native byte order, and
* it is possibly slower than {@link #getDouble(int)}. For most cases (such as transient storage
* in memory or serialization... | 3.26 |
flink_MemorySegment_getFloat_rdh | /**
* Reads a single-precision floating point value (32bit, 4 bytes) from the given position, in
* the system's native byte order. This method offers the best speed for float reading and
* should be used unless a specific byte order is required. In most cases, it suffices to know
* that the byte order in which the ... | 3.26 |
flink_MemorySegment_getLong_rdh | /**
* Reads a long value (64bit, 8 bytes) from the given position, in the system's native byte
* order. This method offers the best speed for long integer reading and should be used unless a
* specific byte order is required. In most cases, it suffices to know that the byte order in
* which the value is written is ... | 3.26 |
flink_MemorySegment_getArray_rdh | /**
* Returns the byte array of on-heap memory segments.
*
* @return underlying byte array
* @throws IllegalStateException
* if the memory segment does not represent on-heap memory
*/
public byte[] getArray() {
if (heapMemory
!= null) {
return heapMemory;
} else {
throw new IllegalSt... | 3.26 |
flink_MemorySegment_get_rdh | /**
* Bulk get method. Copies {@code numBytes} bytes from this memory segment, starting at position
* {@code offset} to the target {@code ByteBuffer}. The bytes will be put into the target buffer
* starting at the buffer's current position. If this method attempts to write more bytes than
* the target byte buffer h... | 3.26 |
flink_MemorySegment_getIntLittleEndian_rdh | /**
* Reads an int value (32bit, 4 bytes) from the given position, in little-endian byte order.
* This method's speed depends on the system's native byte order, and it is possibly slower than
* {@link #getInt(int)}. For most cases (such as transient storage in memory or serialization
* for I/O and network), it suff... | 3.26 |
flink_MemorySegment_getDoubleBigEndian_rdh | /**
* Reads a double-precision floating point value (64bit, 8 bytes) from the given position, in
* big endian byte order. This method's speed depends on the system's native byte order, and it
* is possibly slower than {@link #getDouble(int)}. For most cases (such as transient storage in
* memory or serialization fo... | 3.26 |
flink_MemorySegment_wrap_rdh | /**
* Wraps the chunk of the underlying memory located between <tt>offset</tt> and <tt>offset +
* length</tt> in a NIO ByteBuffer. The ByteBuffer has the full segment as capacity and the
* offset and length parameters set the buffers position and limit.
*
* @param offset
* The offset in the memory segment.
* @... | 3.26 |
flink_MemorySegment_getIntBigEndian_rdh | /**
* Reads an int value (32bit, 4 bytes) from the given position, in big-endian byte order. This
* method's speed depends on the system's native byte order, and it is possibly slower than
* {@link #getInt(int)}. For most cases (such as transient storage in memory or serialization
* for I/O and network), it suffice... | 3.26 |
flink_MemorySegment_processAsByteBuffer_rdh | /**
* Supplies a {@link ByteBuffer} that represents this entire segment to the given process
* consumer.
*
* <p>Note: The {@link ByteBuffer} passed into the process consumer is temporary and could
* become invalid after the processing. Thus, the process consumer should not try to keep any
* reference of the {@lin... | 3.26 |
flink_MemorySegment_getCharLittleEndian_rdh | /**
* Reads a character value (16 bit, 2 bytes) from the given position, in little-endian byte
* order. This method's speed depends on the system's native byte order, and it is possibly
* slower than {@link #getChar(int)}. For most cases (such as transient storage in memory or
* serialization for I/O and network), ... | 3.26 |
flink_MemorySegment_getFloatLittleEndian_rdh | /**
* Reads a single-precision floating point value (32bit, 4 bytes) from the given position, in
* little endian byte order. This method's speed depends on the system's native byte order, and
* it is possibly slower than {@link #getFloat(int)}. For most cases (such as transient storage
* in memory or serialization ... | 3.26 |
flink_MemorySegment_m0_rdh | /**
* Reads an int value (32bit, 4 bytes) from the given position, in the system's native byte
* order. This method offers the best speed for integer reading and should be used unless a
* specific byte order is required. In most cases, it suffices to know that the byte order in
* which the value is written is the s... | 3.26 |
flink_MemorySegment_copyToUnsafe_rdh | /**
* Bulk copy method. Copies {@code numBytes} bytes to target unsafe object and pointer. NOTE:
* This is an unsafe method, no check here, please be careful.
*
* @param offset
* The position where the bytes are started to be read from in this memory
* segment.
* @param target
* The unsafe memory to copy ... | 3.26 |
flink_MemorySegment_putLongLittleEndian_rdh | /**
* Writes the given long value (64bit, 8 bytes) to the given position in little endian byte
* order. This method's speed depends on the system's native byte order, and it is possibly
* slower than {@link #putLong(int, long)}. For most cases (such as transient storage in memory
* or serialization for I/O and netw... | 3.26 |
flink_MemorySegment_getChar_rdh | /**
* Reads a char value from the given position, in the system's native byte order.
*
* @param index
* The position from which the memory will be read.
* @return The char value at the given position.
* @throws IndexOutOfBoundsException
* Thrown, if the index is negative, or larger than the
* segment size... | 3.26 |
flink_MemorySegment_compare_rdh | /**
* Compares two memory segment regions with different length.
*
* @param seg2
* Segment to compare this segment with
* @param offset1
* Offset of this segment to start comparing
* @param offset2
* Offset of seg2 to start comparing
* @param len1
* Length of this memory region to compare
* @param le... | 3.26 |
flink_MemorySegment_putDoubleLittleEndian_rdh | /**
* Writes the given double-precision floating-point value (64bit, 8 bytes) to the given position
* in little endian byte order. This method's speed depends on the system's native byte order,
* and it is possibly slower than {@link #putDouble(int, double)}. For most cases (such as
* transient storage in memory or... | 3.26 |
flink_MemorySegment_getShortBigEndian_rdh | /**
* Reads a short integer value (16 bit, 2 bytes) from the given position, in big-endian byte
* order. This method's speed depends on the system's native byte order, and it is possibly
* slower than {@link #getShort(int)}. For most cases (such as transient storage in memory or
* serialization for I/O and network)... | 3.26 |
flink_MemorySegment_getFloatBigEndian_rdh | /**
* Reads a single-precision floating point value (32bit, 4 bytes) from the given position, in
* big endian byte order. This method's speed depends on the system's native byte order, and it
* is possibly slower than {@link #getFloat(int)}. For most cases (such as transient storage in
* memory or serialization for... | 3.26 |
flink_MemorySegment_putDoubleBigEndian_rdh | /**
* Writes the given double-precision floating-point value (64bit, 8 bytes) to the given position
* in big endian byte order. This method's speed depends on the system's native byte order, and
* it is possibly slower than {@link #putDouble(int, double)}. For most cases (such as transient
* storage in memory or se... | 3.26 |
flink_MemorySegment_putShortLittleEndian_rdh | /**
* Writes the given short integer value (16 bit, 2 bytes) to the given position in little-endian
* byte order. This method's speed depends on the system's native byte order, and it is possibly
* slower than {@link #putShort(int, short)}. For most cases (such as transient storage in
* memory or serialization for ... | 3.26 |
flink_MemorySegment_swapBytes_rdh | /**
* Swaps bytes between two memory segments, using the given auxiliary buffer.
*
* @param tempBuffer
* The auxiliary buffer in which to put data during triangle swap.
* @param seg2
* Segment to swap bytes with
* @param offset1
* Offset of this segment to start swapping
* @param offset2
* Offset of ... | 3.26 |
flink_MemorySegment_free_rdh | /**
* Frees this memory segment.
*
* <p>After this operation has been called, no further operations are possible on the memory
* segment and will fail. The actual memory (heap or off-heap) will only be released after this
* memory segment object has become garbage collected.
*/
pub... | 3.26 |
flink_MemorySegment_isFreed_rdh | /**
* Checks whether the memory segment was freed.
*
* @return <tt>true</tt>, if the memory segment has been freed, <tt>false</tt> otherwise.
*/
@VisibleForTesting
public boolean isFreed() {
return address > f0;
} | 3.26 |
flink_MemorySegment_putShort_rdh | /**
* Writes the given short value into this buffer at the given position, using the native byte
* order of the system.
*
* @param index
* The position at which the value will be written.
* @param value
* The short value to be written.
* @throws IndexOutOfBoundsException
* Thrown, if the index is negativ... | 3.26 |
flink_MemorySegment_putInt_rdh | /**
* Writes the given int value (32bit, 4 bytes) to the given position in the system's native byte
* order. This method offers the best speed for integer writing and should be used unless a
* specific byte order is required. In most cases, it suffices to know that the byte order in
* which the value is written is ... | 3.26 |
flink_MemorySegment_putLongBigEndian_rdh | /**
* Writes the given long value (64bit, 8 bytes) to the given position in big endian byte order.
* This method's speed depends on the system's native byte order, and it is possibly slower than
* {@link #putLong(int, long)}. For most cases (such as transient storage in memory or
* serialization for I/O and network... | 3.26 |
flink_MemorySegment_put_rdh | /**
* Bulk put method. Copies {@code numBytes} bytes from the given {@code ByteBuffer}, into this
* memory segment. The bytes will be read from the target buffer starting at the buffer's
* current position, and will be written to this memory segment starting at {@code offset}. If
* this method attempts to read more... | 3.26 |
flink_MemorySegment_copyTo_rdh | /**
* Bulk copy method. Copies {@code numBytes} bytes from this memory segment, starting at
* position {@code offset} to the target memory segment. The bytes will be put into the target
* segment starting at position {@code targetOffset}.
*
* @param offset
* The position where the bytes are started to be read f... | 3.26 |
flink_MemorySegment_putFloat_rdh | /**
* Writes the given single-precision float value (32bit, 4 bytes) to the given position in the
* system's native byte order. This method offers the best speed for float writing and should be
* used unless a specific byte order is required. In most cases, it suffices to know that the
* byte order in which the val... | 3.26 |
flink_MemorySegment_getCharBigEndian_rdh | /**
* Reads a character value (16 bit, 2 bytes) from the given position, in big-endian byte order.
* This method's speed depends on the system's native byte order, and it is possibly slower than
* {@link #getChar(int)}. For most cases (such as transient storage in memory or serialization
* for I/O and network), it ... | 3.26 |
flink_MemorySegment_size_rdh | // ------------------------------------------------------------------------
/**
* Gets the size of the memory segment, in bytes.
*
* @return The size of the memory segment.
*/
public int size() {return size;
} | 3.26 |
flink_MemorySegment_putCharBigEndian_rdh | /**
* Writes the given character (16 bit, 2 bytes) to the given position in big-endian byte order.
* This method's speed depends on the system's native byte order, and it is possibly slower than
* {@link #putChar(int, char)}. For most cases (such as transient storage in memory or
* serialization for I/O and network... | 3.26 |
flink_MemorySegment_getBoolean_rdh | /**
* Reads one byte at the given position and returns its boolean representation.
*
* @param index
* The position from which the memory will be read.
* @return The boolean value at the given position.
* @throws IndexOutOfBoundsException
* Thrown, if the index is negative, or larger than the
* segment siz... | 3.26 |
flink_MemorySegment_putBoolean_rdh | /**
* Writes one byte containing the byte value into this buffer at the given position.
*
* @param index
* The position at which the memory will be written.
* @param value
* The char value to be written.
* @throws IndexOutOfBoundsException
* Thrown, if the index is negative, or larger than the
* segmen... | 3.26 |
flink_MemorySegment_putCharLittleEndian_rdh | /**
* Writes the given character (16 bit, 2 bytes) to the given position in little-endian byte
* order. This method's speed depends on the system's native byte order, and it is possibly
* slower than {@link #putChar(int, char)}. For most cases (such as transient storage in memory
* or serialization for I/O and netw... | 3.26 |
flink_MemorySegment_putDouble_rdh | /**
* Writes the given double-precision floating-point value (64bit, 8 bytes) to the given position
* in the system's native byte order. This method offers the best speed for double writing and
* should be used unless a specific byte order is required. In most cases, it suffices to know
* that the byte order in whi... | 3.26 |
flink_MemorySegment_getLongBigEndian_rdh | /**
* Reads a long integer value (64bit, 8 bytes) from the given position, in big endian byte
* order. This method's speed depends on the system's native byte order, and it is possibly
* slower than {@link #getLong(int)}. For most cases (such as transient storage in memory or
* serialization for I/O and network), i... | 3.26 |
flink_MemorySegment_equalTo_rdh | /**
* Equals two memory segment regions.
*
* @param seg2
* Segment to equal this segment with
* @param offset1
* Offset of this segment to start equaling
* @param offset2
* Offset of seg2 to start equaling
* @param length
* Length of the equaled memory region
* @return true if equal, false otherwise
... | 3.26 |
flink_MemorySegment_getDouble_rdh | /**
* Reads a double-precision floating point value (64bit, 8 bytes) from the given position, in
* the system's native byte order. This method offers the best speed for double reading and
* should be used unless a specific byte order is required. In most cases, it suffices to know
* that the byte order in which the... | 3.26 |
flink_MemorySegment_getOffHeapBuffer_rdh | /**
* Returns the off-heap buffer of memory segments.
*
* @return underlying off-heap buffer
* @throws IllegalStateException
* if the memory segment does not represent off-heap buffer
*/
public ByteBuffer getOffHeapBuffer() {
if (offHeapBuffer !=
null) {
return offHeapBuffer;
} else {
... | 3.26 |
flink_MemorySegment_putFloatLittleEndian_rdh | /**
* Writes the given single-precision float value (32bit, 4 bytes) to the given position in
* little endian byte order. This method's speed depends on the system's native byte order, and
* it is possibly slower than {@link #putFloat(int, float)}. For most cases (such as transient
* storage in memory or serializat... | 3.26 |
flink_MemorySegment_putIntBigEndian_rdh | /**
* Writes the given int value (32bit, 4 bytes) to the given position in big endian byte order.
* This method's speed depends on the system's native byte order, and it is possibly slower than
* {@link #putInt(int, int)}. For most cases (such as transient storage in memory or
* serialization for I/O and network), ... | 3.26 |
flink_MemorySegment_putIntLittleEndian_rdh | /**
* Writes the given int value (32bit, 4 bytes) to the given position in little endian byte
* order. This method's speed depends on the system's native byte order, and it is possibly
* slower than {@link #putInt(int, int)}. For most cases (such as transient storage in memory or
* serialization for I/O and network... | 3.26 |
flink_MemorySegment_getLongLittleEndian_rdh | /**
* Reads a long integer value (64bit, 8 bytes) from the given position, in little endian byte
* order. This method's speed depends on the system's native byte order, and it is possibly
* slower than {@link #getLong(int)}. For most cases (such as transient storage in memory or
* serialization for I/O and network)... | 3.26 |
flink_InternalTimersSnapshotReaderWriters_getWriterForVersion_rdh | // -------------------------------------------------------------------------------
// Writers
// - pre-versioned: Flink 1.4.0
// - v1: Flink 1.4.1
// - v2: Flink 1.8.0
// -------------------------------------------------------------------------------
public static <K, N> InternalTimersSnapshotWriter getWriterForVersion... | 3.26 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.