name stringlengths 12 178 | code_snippet stringlengths 8 36.5k | score float64 3.26 3.68 |
|---|---|---|
flink_EmbeddedRocksDBStateBackend_m1_rdh | /**
* Gets the type of the priority queue state. It will fallback to the default value, if it is
* not explicitly set.
*
* @return The type of the priority queue state.
*/
public PriorityQueueStateType m1() {
return priorityQueueConfig.getPriorityQueueStateType();
} | 3.26 |
flink_EmbeddedRocksDBStateBackend_getWriteBatchSize_rdh | /**
* Gets the max batch size will be used in {@link RocksDBWriteBatchWrapper}.
*/
public long getWriteBatchSize() {
return writeBatchSize == UNDEFINED_WRITE_BATCH_SIZE ? WRITE_BATCH_SIZE.defaultValue().getBytes() : writeBatchSize;
} | 3.26 |
flink_RestClient_m0_rdh | /**
* Creates a new RestClient for the provided root URL. If the protocol of the URL is "https",
* then SSL is automatically enabled for the REST client.
*/
public static RestClient m0(Configuration configuration, Executor executor, URL rootUrl) throws ConfigurationException {
Preconditions.checkNotNull(configur... | 3.26 |
flink_GroupReduceNode_isCombineable_rdh | /**
* Checks, whether a combiner function has been given for the function encapsulated by this
* reduce contract.
*
* @return True, if a combiner has been given, false otherwise.
*/
public boolean isCombineable()
{
return getOperator().isCombinable();
} | 3.26 |
flink_GroupReduceNode_getOperator_rdh | // ------------------------------------------------------------------------
/**
* Gets the operator represented by this optimizer node.
*
* @return The operator represented by this optimizer node.
*/
@Override
public GroupReduceOperatorBase<?, ?, ?> getOperator() {
return ((GroupReduceOperatorBase<?, ?, ?>) (s... | 3.26 |
flink_GroupReduceNode_computeOperatorSpecificDefaultEstimates_rdh | // --------------------------------------------------------------------------------------------
// Estimates
// --------------------------------------------------------------------------------------------
@Override
protected void computeOperatorSpecificDefaultEstimates(DataStatistics statistics) {
// no real estima... | 3.26 |
flink_DiskCacheManager_increaseNumCachedBytesAndCheckFlush_rdh | // ------------------------------------------------------------------------
// Internal Methods
// ------------------------------------------------------------------------
private void increaseNumCachedBytesAndCheckFlush(int numIncreasedCachedBytes) {
numCachedBytesCounter += numIncreasedCachedBytes;
if (numC... | 3.26 |
flink_DiskCacheManager_release_rdh | /**
* Release this {@link DiskCacheManager}, it means all memory taken by this class will recycle.
*/
void release() {
Arrays.stream(f0).forEach(SubpartitionDiskCacheManager::release);
partitionFileWriter.release();} | 3.26 |
flink_DiskCacheManager_getBufferIndex_rdh | /**
* Return the current buffer index.
*
* @param subpartitionId
* the target subpartition id
* @return the finished buffer index
*/
int getBufferIndex(int subpartitionId) {
return f0[subpartitionId].getBufferIndex();
} | 3.26 |
flink_DiskCacheManager_appendEndOfSegmentEvent_rdh | /**
* Append the end-of-segment event to {@link DiskCacheManager}, which indicates the segment has
* finished.
*
* @param record
* the end-of-segment event
* @param subpartitionId
* target subpartition of this record.
*/ void appendEndOfSegmentEvent(ByteBuffer record,
int subpartitionId) {
f0[subparti... | 3.26 |
flink_DiskCacheManager_close_rdh | /**
* Close this {@link DiskCacheManager}, it means no data can append to memory.
*/void close() {
forceFlushCachedBuffers();
} | 3.26 |
flink_DiskCacheManager_startSegment_rdh | // Called by DiskTierProducerAgent
// ------------------------------------------------------------------------
void startSegment(int subpartitionId, int segmentIndex) {
f0[subpartitionId].startSegment(segmentIndex);
} | 3.26 |
flink_DiskCacheManager_append_rdh | /**
* Append buffer to {@link DiskCacheManager}.
*
* @param buffer
* to be managed by this class.
* @param subpartitionId
* the subpartition of this record.
*/
void append(Buffer buffer, int subpartitionId) {
f0[subpartitionId].append(buffer);
increaseNumCachedBytesAndCheckFlush(buffer.readableBytes... | 3.26 |
flink_DiskCacheManager_flushBuffers_rdh | /**
* Note that the request of flushing buffers may come from the disk check thread or the task
* thread, so the method itself should ensure the thread safety.
*/
private synchronized void flushBuffers(boolean forceFlush) {
if ((!forceFlush) && (!hasFlushCompleted.isDone())) {
return;
}
List<PartitionFileWriter.... | 3.26 |
flink_UpsertTestSink_builder_rdh | /**
* Create a {@link UpsertTestSinkBuilder} to construct a new {@link UpsertTestSink}.
*
* @param <IN>
* type of incoming records
* @return {@link UpsertTestSinkBuilder}
*/
public static <IN> UpsertTestSinkBuilder<IN> builder() {
return new UpsertTestSinkBuilder<>();
} | 3.26 |
flink_CommonExecLegacySink_translateToTransformation_rdh | /**
* Translates {@link TableSink} into a {@link Transformation}.
*
* @param withChangeFlag
* Set to true to emit records with change flags.
* @return The {@link Transformation} that corresponds to the translated {@link TableSink}.
*/
@SuppressWarnings("unchecked")
private Tr... | 3.26 |
flink_StateObjectCollection_empty_rdh | // ------------------------------------------------------------------------
// Helper methods.
// ------------------------------------------------------------------------
@SuppressWarnings("unchecked")
public static <T extends StateObject> StateObjectCollection<T> empty() {
return ((StateObjectCollection<T>) (EMPTY));... | 3.26 |
flink_StateObjectCollection_hasState_rdh | /**
* Returns true if this contains at least one {@link StateObject}.
*/
public boolean hasState() {
for (StateObject state : stateObjects) {
if (state != null) {
return true;
}
}
return false;
} | 3.26 |
flink_Tuple19_equals_rdh | /**
* Deep equality for tuples by calling equals() on the tuple members.
*
* @param o
* the object checked for equality
* @return true if this is equal to o.
*/
@Override
public boolean equals(Object
o) {
if (this == o) {
return true;
}if (!(o instanceof Tuple19)) {
return false;
}
... | 3.26 |
flink_Tuple19_m1_rdh | /**
* Creates a new tuple and assigns the given values to the tuple's fields. This is more
* convenient than using the constructor, because the compiler can infer the generic type
* arguments implicitly. For example: {@code Tuple3.of(n, x, s)} instead of {@code new
* Tuple3<Integer, Double, String>(n, x, s)}
*/
pu... | 3.26 |
flink_Tuple19_m0_rdh | /**
* Sets new values to all fields of the tuple.
*
* @param f0
* The value for field 0
* @param f1
* The value for field 1
* @param f2
* The value for field 2
* @param f3
* The value for field 3
* @param f4
* The value for field 4
* @param f5
* The value for field 5
* @param f6
* The valu... | 3.26 |
flink_Tuple19_toString_rdh | // -------------------------------------------------------------------------------------------------
// standard utilities
// -------------------------------------------------------------------------------------------------
/**
* Creates a string representation of the tuple in the form (f0, f1, f2, f3, f4, f5, f6, f7,... | 3.26 |
flink_Serializers_getContainedGenericTypes_rdh | /**
* Returns all GenericTypeInfos contained in a composite type.
*
* @param typeInfo
* {@link CompositeType}
*/
private static void getContainedGenericTypes(CompositeType<?> typeInfo, List<GenericTypeInfo<?>> target) {
for (int i = 0;
i < typeInfo.getArity(); i++) {
TypeInformation<?> type = typ... | 3.26 |
flink_HsMemoryDataManager_getBuffersInOrder_rdh | // Write lock should be acquired before invoke this method.
@Override
public Deque<BufferIndexAndChannel> getBuffersInOrder(int subpartitionId, SpillStatus spillStatus, ConsumeStatusWithId consumeStatusWithId) {
HsSubpartitionMemoryDataManager targetSubpartitionDataManager = getSubpartitionMemoryDataManager(subpart... | 3.26 |
flink_HsMemoryDataManager_spillBuffers_rdh | /**
* Spill buffers for each subpartition in a decision.
*
* <p>Note that: The method should not be locked, it is the responsibility of each subpartition
* to maintain thread safety itself.
*
* @param toSpill
* All buffers that need to be spilled in a decision.
*/
private void spillBuffers(Map<Integer, List<B... | 3.26 |
flink_HsMemoryDataManager_append_rdh | // ------------------------------------
// For ResultPartition
// ------------------------------------
/**
* Append record to {@link HsMemoryDataManager}, It will be managed by {@link HsSubpartitionMemoryDataManager} witch it belongs to.
*
* @param record
* to be managed by this class.
* @param targetChannel
* ... | 3.26 |
flink_HsMemoryDataManager_registerNewConsumer_rdh | /**
* Register {@link HsSubpartitionConsumerInternalOperations} to {@link #subpartitionViewOperationsMap}. It is used to obtain the consumption progress of the
* subpartition.
*/
public HsDataView registerNewConsumer(int subpartitionId, HsConsumerId consumerId, HsSubpartitionConsumerInternalOperations viewOperations... | 3.26 |
flink_HsMemoryDataManager_releaseBuffers_rdh | /**
* Release buffers for each subpartition in a decision.
*
* <p>Note that: The method should not be locked, it is the responsibility of each subpartition
* to maintain thread safety itself.
*
* @param toRelease
* All buffers that need to be released in a decision.
*/
private void
releaseBuffers(Map<Integer,... | 3.26 |
flink_HsMemoryDataManager_handleDecision_rdh | // ------------------------------------
// Internal Method
// ------------------------------------
// Attention: Do not call this method within the read lock and subpartition lock, otherwise
// deadlock may occur as this method maybe acquire write lock and other subpartition's lock
// inside.
private void handleDecisio... | 3.26 |
flink_HsMemoryDataManager_getNextBufferIndexToConsume_rdh | // Write lock should be acquired before invoke this method.
@Override
public List<Integer> getNextBufferIndexToConsume(HsConsumerId consumerId) {
ArrayList<Integer> consumeIndexes = new ArrayList<>(numSubpartitions);
for (int channel = 0; channel < numSubpartitions; channel++) {
HsSubpartitionConsumerI... | 3.26 |
flink_HsMemoryDataManager_close_rdh | /**
* Close this {@link HsMemoryDataManager}, it means no data can append to memory and all buffer
* taken by this class will recycle.
*/
public void close() {
spillAndReleaseAllData();
spiller.close();
poolSizeChecker.shutdown();
} | 3.26 |
flink_HsMemoryDataManager_markBufferReleasedFromFile_rdh | // ------------------------------------
// Callback for subpartition
// ------------------------------------
@Override
public void markBufferReleasedFromFile(int subpartitionId, int bufferIndex) {
fileDataIndex.markBufferReleased(subpartitionId, bufferIndex);
} | 3.26 |
flink_HsMemoryDataManager_getPoolSize_rdh | // ------------------------------------
// For Spilling Strategy
// ------------------------------------
@Override
public int getPoolSize() {
return poolSize.get();
} | 3.26 |
flink_ClassLoadingUtils_runWithContextClassLoader_rdh | /**
* Runs the given supplier in a {@link TemporaryClassLoaderContext} based on the given
* classloader.
*
* @param supplier
* supplier to run
* @param contextClassLoader
* class loader that should be set as the context class loader
*/
public static <T, E extends Throwable> T runWithContextClassLoader(Suppl... | 3.26 |
flink_ClassLoadingUtils_withContextClassLoader_rdh | /**
* Wraps the given executor such that all submitted are runnables are run in a {@link TemporaryClassLoaderContext} based on the given classloader.
*
* @param executor
* executor to wrap
* @param contextClassLoader
* class loader that should be set as the context class loader
* @return wrapped executor
*/... | 3.26 |
flink_BinaryIndexedSortable_writeIndexAndNormalizedKey_rdh | /**
* Write of index and normalizedKey.
*/
protected void writeIndexAndNormalizedKey(RowData record, long currOffset) {
// add the pointer and the normalized key
this.currentSortIndexSegment.putLong(this.currentSortIndexOffset, currOffset);
if (this.numKeyBytes != 0) {
... | 3.26 |
flink_BinaryIndexedSortable_checkNextIndexOffset_rdh | /**
* check if we need request next index memory.
*/
protected boolean checkNextIndexOffset() {
if (this.currentSortIndexOffset > this.lastIndexEntryOffset) {
MemorySegment returnSegment = nextMemorySegment();
if (returnSegment
!=
null) {
this.currentSortIndexSegment = ... | 3.26 |
flink_BinaryIndexedSortable_writeToOutput_rdh | /**
* Spill: Write all records to a {@link AbstractPagedOutputView}.
*/
public void writeToOutput(AbstractPagedOutputView output) throws IOException {
final int numRecords = this.numRecords;
int currentMemSeg = 0;
int currentRecord = 0;
while (currentRecord < numRecord... | 3.26 |
flink_WrappingCollector_setCollector_rdh | /**
* Sets the current collector which is used to emit the final result.
*/
public void
setCollector(Collector<T> collector) {
this.collector = collector;
} | 3.26 |
flink_WrappingCollector_outputResult_rdh | /**
* Outputs the final result to the wrapped collector.
*/
public void outputResult(T result) {
this.collector.collect(result);
} | 3.26 |
flink_AvroParquetReaders_forGenericRecord_rdh | /**
* Creates a new {@link AvroParquetRecordFormat} that reads the parquet file into Avro {@link GenericRecord GenericRecords}.
*
* <p>To read into {@link GenericRecord GenericRecords}, this method needs an Avro Schema. That
* is because Flink needs to be able to serialize the results in its data flow, which is ver... | 3.26 |
flink_AvroParquetReaders_forSpecificRecord_rdh | /**
* Creates a new {@link AvroParquetRecordFormat} that reads the parquet file into Avro {@link org.apache.avro.specific.SpecificRecord SpecificRecords}.
*
* <p>To read into Avro {@link GenericRecord GenericRecords}, use the {@link #forGenericRecord(Schema)} method.
*
* @see #forGenericRec... | 3.26 |
flink_AvroParquetReaders_forReflectRecord_rdh | /**
* Creates a new {@link AvroParquetRecordFormat} that reads the parquet file into Avro records
* via reflection.
*
* <p>To read into Avro {@link GenericRecord GenericRecords}, use the {@link #forGenericRecord(Schema)} method.
*
* <p>To read into Avro {@link org.apache.avro.specific.SpecificRecord SpecificRecor... | 3.26 |
flink_SqlGatewayRestEndpointUtils_parseToken_rdh | /**
* Parse token from the result uri.
*/
@Nullable
public static Long parseToken(@Nullable
String nextResultUri) {
if ((nextResultUri == null) || (nextResultUri.length() == 0)) { return null;
}
String[] split = nextResultUri.split("/");
// remove query string
String s = split[split.length - 1];
... | 3.26 |
flink_Tuple6_of_rdh | /**
* Creates a new tuple and assigns the given values to the tuple's fields. This is more
* convenient than using the constructor, because the compiler can infer the generic type
* arguments implicitly. For example: {@code Tuple3.of(n, x, s)} instead of {@code new
* Tuple3<Integer, Double, String>(n, x, s)}
*/
pu... | 3.26 |
flink_Tuple6_equals_rdh | /**
* Deep equality for tuples by calling equals() on the tuple members.
*
* @param o
* the object checked for equality
* @return true if this is equal to o.
*/
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if
(!(o instanceof Tuple6)) {
return false;... | 3.26 |
flink_Tuple6_toString_rdh | // -------------------------------------------------------------------------------------------------
// standard utilities
// -------------------------------------------------------------------------------------------------
/**
* Creates a string representation of the tuple in the form (f0, f1, f2, f3, f4, f5), where ... | 3.26 |
flink_Tuple6_setFields_rdh | /**
* Sets new values to all fields of the tuple.
*
* @param f0
* The value for field 0
* @param f1
* The value for field 1
* @param f2
* The value for field 2
* @param f3
* The value for field 3
* @param f4
* The value for field 4
* @param f5
* The value for field 5
*/
public void setFields... | 3.26 |
flink_RocksDBOptionsFactory_createNativeMetricsOptions_rdh | /**
* This method should enable certain RocksDB metrics to be forwarded to Flink's metrics
* reporter.
*
* <p>Enabling these monitoring options may degrade RockDB performance and should be set with
* care.
*
* @param nativeMetricOptions
* The options object with the pre-defined options.
* @return The options... | 3.26 |
flink_RocksDBOptionsFactory_createReadOptions_rdh | /**
* This method should set the additional options on top of the current options object. The
* current options object may contain pre-defined options based on flags that have been
* configured on the state backend.
*
* <p>It is important to set the options on the current object and return the result from the
* s... | 3.26 |
flink_RocksDBOptionsFactory_createWriteOptions_rdh | /**
* This method should set the additional options on top of the current options object. The
* current options object may contain pre-defined options based on flags that have been
* configured on the state backend.
*
* <p>It is important to set the options on the current object and return the result from the
* s... | 3.26 |
flink_TestSignalHandler_handle_rdh | /**
* Handle an incoming signal.
*
* @param signal
* The incoming signal
*/
@Override
public void handle(Signal signal) {
LOG.warn("RECEIVED SIGNAL {}: SIG{}. Shutting down as requested.", signal.getNumber(), signal.getName());
prevH... | 3.26 |
flink_TestSignalHandler_register_rdh | /**
* Register some signal handlers.
*/
public static void register() {
synchronized(TestSignalHandler.class) {
if (f0) {
return;
}
f0 = true;
final String[] signals = (System.getProperty("os.name").startsWith("Windows")) ? new String[]{ "TERM", "INT" } : new String... | 3.26 |
flink_AutoCloseableRegistry_doClose_rdh | /**
* This implementation implies that any exception is possible during closing.
*/@Override
protected void doClose(List<AutoCloseable> toClose) throws Exception {
IOUtils.closeAll(reverse(toClose), Throwable.class);
} | 3.26 |
flink_CountEvictor_of_rdh | /**
* Creates a {@code CountEvictor} that keeps the given number of elements in the pane Eviction
* is done before/after the window function based on the value of doEvictAfter.
*
* @param maxCount
* The number of elements to keep in the pane.
* @param doEvictAfter
* Whether to do eviction after the window fu... | 3.26 |
flink_BytesMap_m0_rdh | /**
*
* @param reservedRecordMemory
* reserved fixed memory or not.
*/
public void m0(boolean reservedRecordMemory) {
returnSegments(this.bucketSegments); this.bucketSegments.clear();if (!reservedRecordMemory) {
memoryPool.close();
}
numElements = 0;
} | 3.26 |
flink_BytesMap_calcSecondHashCode_rdh | // M(the num of buckets) is the nth power of 2, so the second hash code must be odd, and always
// is
// H2(K) = 1 + 2 * ((H1(K)/M) mod (M-1))
protected int calcSecondHashCode(final int firstHashCode) {return (((firstHashCode >> log2NumBuckets) & numBucketsMask2) << 1) + 1;
} | 3.26 |
flink_BytesMap_reset_rdh | /**
* reset the map's record and bucket area's memory segments for reusing.
*/
public void reset()
{
setBucketVariables(bucketSegments);
resetBucketSegments(bucketSegments);
numElements = 0;
LOG.debug("reset BytesHashMap with record memory segments {}, {} in bytes, init allocating {} for bucket area."... | 3.26 |
flink_BytesMap_growAndRehash_rdh | /**
*
* @throws EOFException
* if the map can't allocate much more memory.
*/
protected void growAndRehash() throws EOFException {
// allocate the new data structures
int required = 2 * bucketSegments.size();
if ((required * ((long)
(numBucketsPerSegment))) > Integer.MAX_VALUE) {
LOG.war... | 3.26 |
flink_BytesMap_lookup_rdh | /**
*
* @param key
* by which looking up the value in the hash map. Only support the key in the
* BinaryRowData form who has only one MemorySegment.
* @return {@link LookupInfo}
*/
public LookupInfo<K, V> lookup(K key) {
final int hashCode1 = key.hashCode();
int v6 = hashCode1 & numBucketsMask;
//... | 3.26 |
flink_SavepointMetadataV2_getNewOperators_rdh | /**
*
* @return List of new operator states for the savepoint, represented by their target {@link OperatorID} and {@link StateBootstrapTransformation}.
*/
public List<StateBootstrapTransformationWithID<?>> getNewOperators() {
return operatorStateIndex.values().stream().filter(OperatorStateSpecV2::isNewStateTrans... | 3.26 |
flink_SavepointMetadataV2_getOperatorState_rdh | /**
*
* @return Operator state for the given UID.
* @throws IOException
* If the savepoint does not contain operator state with the given uid.
*/
public OperatorState getOperatorState(OperatorIdentifier identifier) throws IOException {
OperatorID operatorID = identifier.getOperatorId();
OperatorStateSpec... | 3.26 |
flink_SavepointMetadataV2_getExistingOperators_rdh | /**
*
* @return List of {@link OperatorState} that already exists within the savepoint.
*/
public List<OperatorState> getExistingOperators() {
return operatorStateIndex.values().stream().filter(OperatorStateSpecV2::isExistingState).map(OperatorStateSpecV2::asExistingState).collect(Collectors.toList());
} | 3.26 |
flink_TableStreamOperator_computeMemorySize_rdh | /**
* Compute memory size from memory faction.
*/
public long computeMemorySize() {
final
Environment environment = getContainingTask().getEnvironment();
return environment.getMemoryManager().computeMemorySize(getOperatorConfig().getManagedMemoryFractionOperatorUseCaseOfSlot(ManagedMemoryUseCa... | 3.26 |
flink_TwoInputNode_getOperator_rdh | // ------------------------------------------------------------------------
@Override
public DualInputOperator<?, ?, ?, ?> getOperator() {
return ((DualInputOperator<?, ?, ?, ?>) (super.getOperator()));
} | 3.26 |
flink_TwoInputNode_getSecondIncomingConnection_rdh | /**
* Gets the DagConnection through which this node receives its <i>second</i> input.
*
* @return The second input connection.
*/
public DagConnection getSecondIncomingConnection() {
return
this.input2;
} | 3.26 |
flink_TwoInputNode_accept_rdh | // --------------------------------------------------------------------------------------------
// Miscellaneous
// --------------------------------------------------------------------------------------------
@Override
public void accept(Visitor<OptimizerNode> visitor) {
if (visitor.preVisit(this)) {
if ((t... | 3.26 |
flink_CliOptionsParser_printHelpClient_rdh | // --------------------------------------------------------------------------------------------
// Help
// --------------------------------------------------------------------------------------------
/**
* Prints the help for the client.
*/
public static void printHelpClient(PrintWriter writer) {
writer.println("./s... | 3.26 |
flink_CliOptionsParser_checkUrl_rdh | // --------------------------------------------------------------------------------------------
private static URL checkUrl(CommandLine line, Option option)
{
final List<URL> urls = checkUrls(line, option);
if ((urls != null) && (!urls.isEmpty())) {
return urls.get(0);
}
return null;
} | 3.26 |
flink_CliOptionsParser_parseEmbeddedModeClient_rdh | // --------------------------------------------------------------------------------------------
// Line Parsing
// --------------------------------------------------------------------------------------------
public static EmbeddedCliOptions parseEmbeddedModeClient(String[] args) {
try {
DefaultParser parser... | 3.26 |
flink_KafkaStandaloneGenerator_main_rdh | /**
* Entry point to the kafka data producer.
*/
public static void main(String[] args) throws Exception {
final KafkaCollector[] collectors = new KafkaCollector[NUM_PARTITIONS];
// create the generator threads
for (int i = 0; i < collectors.length; i++) {
collectors[i] = new KafkaCollector(BRO... | 3.26 |
flink_FileSystemCommitter_commitPartitions_rdh | /**
* Commits the partitions with a filter to filter out invalid task attempt files. In speculative
* execution mode, there might be some files which do not belong to the finished attempt.
*
* @param taskAttemptFilter
* the filter that accepts subtaskIndex and attemptNumber
* @throws Exception
* if partition... | 3.26 |
flink_FileSystemCommitter_commitPartitionsWithFiles_rdh | /**
* For committing job's output after successful batch job completion, it will commit with the
* given partitions and corresponding files written which means it'll move the temporary files
* to partition's location.
*/
public void commitPartitionsWithFiles(Map<String, List<Path>> partitionsFiles) throws Exception... | 3.26 |
flink_SerializedCheckpointData_fromDeque_rdh | /**
* Converts a list of checkpoints into an array of SerializedCheckpointData.
*
* @param checkpoints
* The checkpoints to be converted into IdsCheckpointData.
* @param serializer
* The serializer to serialize the IDs.
* @param outputBuffer
* The reusable serialization buffer.
* @param <T>
* The type... | 3.26 |
flink_SerializedCheckpointData_getNumIds_rdh | /**
* Gets the number of IDs in the checkpoint.
*
* @return The number of IDs in the checkpoint.
*/
public int getNumIds() {
return numIds;
} | 3.26 |
flink_SerializedCheckpointData_toDeque_rdh | // ------------------------------------------------------------------------
// De-Serialize from Checkpoint
// ------------------------------------------------------------------------
/**
* De-serializes an array of SerializedCheckpointData back into an ArrayDeque of element
* checkpoints.
*
* @param data
* The ... | 3.26 |
flink_CompileUtils_compile_rdh | /**
* Compiles a generated code to a Class.
*
* @param cl
* the ClassLoader used to load the class
* @param name
* the class name
* @param code
* the generated code
* @param <T>
* the class type
* @return the compiled class
*/
@SuppressWarnings("unchecked")
public static <T>
Class<T> compile(ClassLo... | 3.26 |
flink_CompileUtils_compileExpression_rdh | /**
* Compiles an expression code to a janino {@link ExpressionEvaluator}.
*
* @param code
* the expression code
* @param argumentNames
* the expression argument names
* @param argumentClasses
* the expression argument classes
* @param returnClass
* the return type of the expression
* @return the com... | 3.26 |
flink_CompileUtils_cleanUp_rdh | /**
* Triggers internal garbage collection of expired cache entries.
*/
public static void cleanUp() {
COMPILED_CLASS_CACHE.cleanUp();
COMPILED_EXPRESSION_CACHE.cleanUp();
} | 3.26 |
flink_GivenJavaClasses_javaClassesThat_rdh | /**
* Equivalent of {@link ArchRuleDefinition#classes()}, but only for Java classes.
*/
public static GivenClassesConjunction javaClassesThat(DescribedPredicate<JavaClass> predicate) {
return classes().that(areJavaClasses()).and(predicate);
} | 3.26 |
flink_GivenJavaClasses_noJavaClassesThat_rdh | /**
* Equivalent of {@link ArchRuleDefinition#noClasses()}, but only for Java classes.
*/
public static GivenClassesConjunction noJavaClassesThat(DescribedPredicate<JavaClass> predicate) {
return noClasses().that(areJavaClasses()).and(predicate);
} | 3.26 |
flink_NettyProtocol_getClientChannelHandlers_rdh | /**
* Returns the client channel handlers.
*
* <pre>
* +-----------+----------+ +----------------------+
* | Remote input channel | | request client |
* +-----------+----------+ +-----------+----------+
* | ... | 3.26 |
flink_NettyProtocol_getServerChannelHandlers_rdh | /**
* Returns the server channel handlers.
*
* <pre>
* +-------------------------------------------------------------------+
* | SERVER CHANNEL PIPELINE |
* | |
* | +----------+----------+ (3) write +-... | 3.26 |
flink_TpcdsTestProgram_prepareTableEnv_rdh | /**
* Prepare TableEnvironment for query.
*
* @param sourceTablePath
* @return */
private static TableEnvironment prepareTableEnv(String sourceTablePath, Boolean useTableStats) {
// init Table Env
EnvironmentSettings environmentSettings = EnvironmentSettings.inBatchMode();TableEnvironment tEnv = TableEnvir... | 3.26 |
flink_ClassLoaderUtil_validateClassLoadable_rdh | /**
* Checks, whether the class that was not found in the given exception, can be resolved through
* the given class loader.
*
* @param cnfe
* The ClassNotFoundException that defines the name of the class.
* @param cl
* The class loader to use for the class resolution.
* @return True, if the class can be re... | 3.26 |
flink_ClassLoaderUtil_formatURL_rdh | /**
* Returns the interpretation of URL in string format.
*
* <p>If the URL is null, it returns '(null)'.
*
* <p>If the URL protocol is file, prepend 'file:' flag before the formatted URL. Otherwise, use
* 'url: ' as the prefix instead.
*
* <p>Also, it checks whether the object that the URL directs to exists or... | 3.26 |
flink_DataOutputSerializer_getSharedBuffer_rdh | /**
* Gets a reference to the internal byte buffer. This buffer may be larger than the actual
* serialized data. Only the bytes from zero to {@link #length()} are valid. The buffer will
* also be overwritten with the next write calls.
*
* <p>This method is useful when trying to avid byte copies, but should be used... | 3.26 |
flink_DataOutputSerializer_write_rdh | // ----------------------------------------------------------------------------------------
// Data Output
// ----------------------------------------------------------------------------------------
@Override
public void write(int b) throws IOException {
if (this.position >= this.f0.length) {resize(1);
}
th... | 3.26 |
flink_DataOutputSerializer_getByteArray_rdh | /**
*
* @deprecated Replaced by {@link #getSharedBuffer()} for a better, safer name.
*/
@Deprecated
public byte[] getByteArray() {
return getSharedBuffer();
} | 3.26 |
flink_DataOutputSerializer_getCopyOfBuffer_rdh | /**
* Gets a copy of the buffer that has the right length for the data serialized so far. The
* returned buffer is an exclusive copy and can be safely used without being overwritten by
* future write calls to this serializer.
*
* <p>This method is equivalent to {@code Arrays.copyOf(getSharedBuffer(), length());}
... | 3.26 |
flink_JobManagerSharedServices_shutdown_rdh | /**
* Shutdown the {@link JobMaster} services.
*
* <p>This method makes sure all services are closed or shut down, even when an exception
* occurred in the shutdown of one component. The first encountered exception is thrown, with
* successive exceptions added as suppressed exceptions.
*
* @throws Exception
* ... | 3.26 |
flink_JobManagerSharedServices_fromConfiguration_rdh | // ------------------------------------------------------------------------
// Creating the components from a configuration
// ------------------------------------------------------------------------
public static JobManagerSharedServices fromConfiguration(Configuration config, BlobServer blobServer, FatalErrorHandler ... | 3.26 |
flink_FromElementsGeneratorFunction_checkIterable_rdh | // ------------------------------------------------------------------------
// Utilities
// ------------------------------------------------------------------------
/**
* Verifies that all elements in the iterable are non-null, and are of the given class, or a
* subclass thereof.
*
* @param elements
* The iterab... | 3.26 |
flink_FromElementsGeneratorFunction_setOutputType_rdh | // For backward compatibility: Supports legacy usage of
// StreamExecutionEnvironment#fromElements() which lacked type information and relied on the
// returns() method. See FLINK-21386 for details.
@Override
public void setOutputType(TypeInformation<OUT> outTypeInfo, ExecutionConfig executionConfig) {
Precondition... | 3.26 |
flink_NonSpanningWrapper_transferTo_rdh | /**
* Copies the data and transfers the "ownership" (i.e. clears current wrapper).
*/
void transferTo(ByteBuffer dst) {
segment.get(position, dst, remaining());
clear();
} | 3.26 |
flink_NonSpanningWrapper_readFully_rdh | // -------------------------------------------------------------------------------------------------------------
// DataInput specific methods
// -------------------------------------------------------------------------------------------------------------
@Override
public final void readFully(byte[] b) {
readFull... | 3.26 |
flink_HandlerRequest_create_rdh | /**
* Short-cut for {@link #create(RequestBody, MessageParameters, Collection)} without any
* uploaded files.
*/
@VisibleForTestingpublic static <R extends RequestBody, M extends MessageParameters> HandlerRequest<R> create(R requestBody, M messageParameters) {
return create(requestBody, messageParameters, Colle... | 3.26 |
flink_HandlerRequest_m0_rdh | /**
* Returns the request body.
*
* @return request body
*/
public R m0() {
return requestBody;
} | 3.26 |
flink_HandlerRequest_resolveParametersAndCreate_rdh | /**
* Creates a new {@link HandlerRequest} after resolving the given {@link MessageParameters}
* against the given query/path parameter maps.
*
* <p>For tests it is recommended to resolve the parameters manually and use {@link #create}.
*/
public static <R extends RequestBody, M extends MessageParameters> HandlerR... | 3.26 |
flink_HandlerRequest_getPathParameter_rdh | /**
* Returns the value of the {@link MessagePathParameter} for the given class.
*
* @param parameterClass
* class of the parameter
* @param <X>
* the value type that the parameter contains
* @param <PP>
* type of the path parameter
* @return path parameter value for the given class
* @throws IllegalSta... | 3.26 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.