_id stringlengths 2 7 | title stringlengths 3 140 | partition stringclasses 3
values | text stringlengths 73 34.1k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q171900 | ModuleWriter.putAttributes | test | void putAttributes(final ByteVector output) {
// 6 bytes for name, flags and version, and 5 * 2 bytes for counts.
int moduleAttributeLength =
16 + requires.length + exports.length + opens.length + usesIndex.length + provides.length;
output
.putShort(symbolTable.addConstantUtf8(Constants.MODULE))
.putInt(moduleAttributeLength)
.putShort(moduleNameIndex)
.putShort(moduleFlags)
.putShort(moduleVersionIndex)
.putShort(requiresCount)
.putByteArray(requires.data, 0, requires.length)
.putShort(exportsCount)
.putByteArray(exports.data, 0, exports.length)
.putShort(opensCount)
.putByteArray(opens.data, 0, opens.length)
.putShort(usesCount)
.putByteArray(usesIndex.data, 0, usesIndex.length)
.putShort(providesCount)
.putByteArray(provides.data, 0, provides.length);
if (packageCount > 0) {
output
.putShort(symbolTable.addConstantUtf8(Constants.MODULE_PACKAGES))
.putInt(2 + packageIndex.length)
.putShort(packageCount)
.putByteArray(packageIndex.data, 0, packageIndex.length);
}
if (mainClassIndex > 0) {
output
.putShort(symbolTable.addConstantUtf8(Constants.MODULE_MAIN_CLASS))
.putInt(2)
.putShort(mainClassIndex);
}
} | java | {
"resource": ""
} |
q171901 | URLDecoder.decode | test | public static String decode(final String source, final String encoding) {
return decode(source, encoding, false);
} | java | {
"resource": ""
} |
q171902 | URLDecoder.decodeQuery | test | public static String decodeQuery(final String source, final String encoding) {
return decode(source, encoding, true);
} | java | {
"resource": ""
} |
q171903 | JoyDb.start | test | @Override
@SuppressWarnings("unchecked")
public void start() {
initLogger();
if (!databaseEnabled) {
log.info("DB not enabled.");
return;
}
log.info("DB start ----------");
final PetiteContainer petiteContainer = joyPetiteSupplier.get().getPetiteContainer();
// connection pool
connectionProvider = createConnectionProviderIfNotSupplied();
petiteContainer.addBean(beanNamePrefix() + "pool", connectionProvider);
if (connectionProvider instanceof CoreConnectionPool) {
final CoreConnectionPool pool = (CoreConnectionPool) connectionProvider;
if (pool.getDriver() == null) {
databaseEnabled = false;
log.warn("DB configuration not set (" + beanNamePrefix() + "pool.*). DB will be disabled.");
return;
}
}
connectionProvider.init();
checkConnectionProvider();
// transactions manager
jtxManager = createJtxTransactionManager(connectionProvider);
jtxManager.setValidateExistingTransaction(true);
final AnnotationTxAdviceManager annTxAdviceManager = new AnnotationTxAdviceManager(new LeanJtxWorker(jtxManager), jtxScopePattern);
AnnotationTxAdviceSupport.manager = annTxAdviceManager;
// create proxy
joyProxettaSupplier.get().getProxetta().withAspect(createTxProxyAspects(annTxAdviceManager.getAnnotations()));
final DbSessionProvider sessionProvider = new DbJtxSessionProvider(jtxManager);
// querymap
final long startTime = System.currentTimeMillis();
final QueryMap queryMap = new DbPropsQueryMap();
log.debug("Queries loaded in " + (System.currentTimeMillis() - startTime) + "ms.");
log.debug("Total queries: " + queryMap.size());
// dboom
dbOom = DbOom.create()
.withConnectionProvider(connectionProvider)
.withSessionProvider(sessionProvider)
.withQueryMap(queryMap)
.get();
dbOom.connect();
final DbEntityManager dbEntityManager = dbOom.entityManager();
dbEntityManager.reset();
petiteContainer.addBean(beanNamePrefix() + "query", dbOom.queryConfig());
petiteContainer.addBean(beanNamePrefix() + "oom", dbOom.config());
// automatic configuration
if (autoConfiguration) {
final AutomagicDbOomConfigurator automagicDbOomConfigurator =
new AutomagicDbOomConfigurator(dbEntityManager, true);
automagicDbOomConfigurator.registerAsConsumer(
joyScannerSupplier.get().getClassScanner());
}
dbEntityManagerConsumers.accept(dbEntityManager);
log.info("DB OK!");
} | java | {
"resource": ""
} |
q171904 | JoyDb.checkConnectionProvider | test | protected void checkConnectionProvider() {
final Connection connection = connectionProvider.getConnection();
try {
final DatabaseMetaData databaseMetaData = connection.getMetaData();
String name = databaseMetaData.getDatabaseProductName();
String version = databaseMetaData.getDatabaseProductVersion();
if (log.isInfoEnabled()) {
log.info("Connected to database: " + name + " v" + version);
}
} catch (SQLException sex) {
log.error("DB connection failed: ", sex);
} finally {
connectionProvider.closeConnection(connection);
}
} | java | {
"resource": ""
} |
q171905 | TargetClassInfoReader.visitMethod | test | @Override
public MethodVisitor visitMethod(final int access, final String name, final String desc, final String signature, final String[] exceptions) {
// if ((access & AsmUtil.ACC_FINAL) != 0) {
// return null; // skip finals
// }
MethodSignatureVisitor msign = createMethodSignature(access, name, desc, signature, exceptions, thisReference, this.generics);
String key = ProxettaAsmUtil.createMethodSignaturesKey(access, name, desc, thisReference);
methodSignatures.put(key, msign);
allMethodSignatures.add(msign.getCleanSignature());
return new MethodAnnotationReader(msign);
} | java | {
"resource": ""
} |
q171906 | TargetClassInfoReader.visitEnd | test | @Override
public void visitEnd() {
// prepare class annotations
if (classAnnotations != null) {
annotations = classAnnotations.toArray(new AnnotationInfo[0]);
classAnnotations = null;
}
List<String> superList = new ArrayList<>();
Set<String> allInterfaces = new HashSet<>();
if (nextInterfaces != null) {
allInterfaces.addAll(nextInterfaces);
}
// check all public super methods that are not overridden in superclass
while (nextSupername != null) {
InputStream inputStream = null;
ClassReader cr;
try {
inputStream = ClassLoaderUtil.getClassAsStream(nextSupername, classLoader);
cr = new ClassReader(inputStream);
} catch (IOException ioex) {
throw new ProxettaException("Unable to inspect super class: " + nextSupername, ioex);
} finally {
StreamUtil.close(inputStream);
}
superList.add(nextSupername);
superClassReaders.add(cr); // remember the super class reader
cr.accept(new SuperClassVisitor(), 0);
if (cr.getInterfaces() != null) {
Collections.addAll(allInterfaces, cr.getInterfaces());
}
}
superClasses = superList.toArray(new String[0]);
// check all interface methods that are not overridden in super-interface
Set<String> todoInterfaces = new HashSet<>(allInterfaces);
Set<String> newCollectedInterfaces = new HashSet<>();
while (true) {
for (String next : todoInterfaces) {
InputStream inputStream = null;
ClassReader cr;
try {
inputStream = ClassLoaderUtil.getClassAsStream(next, classLoader);
cr = new ClassReader(inputStream);
}
catch (IOException ioex) {
throw new ProxettaException("Unable to inspect super interface: " + next, ioex);
}
finally {
StreamUtil.close(inputStream);
}
superClassReaders.add(cr); // remember the super class reader
cr.accept(new SuperClassVisitor(), 0);
if (cr.getInterfaces() != null) {
for (String newInterface : cr.getInterfaces()) {
if (!allInterfaces.contains(newInterface) && !todoInterfaces.contains(newInterface)) {
// new interface found
newCollectedInterfaces.add(newInterface);
}
}
}
}
// perform collection
allInterfaces.addAll(todoInterfaces);
if (newCollectedInterfaces.isEmpty()) {
// no new interface found
break;
}
todoInterfaces.clear();
todoInterfaces.addAll(newCollectedInterfaces);
newCollectedInterfaces.clear();
}
} | java | {
"resource": ""
} |
q171907 | TargetClassInfoReader.createMethodSignature | test | protected MethodSignatureVisitor createMethodSignature(
final int access,
final String methodName,
final String description,
final String signature,
final String[] exceptions,
final String classname,
final Map<String, String> declaredTypeGenerics) {
MethodSignatureVisitor v = new MethodSignatureVisitor(methodName, access, classname, description, exceptions, signature, declaredTypeGenerics, this);
new SignatureReader(signature != null ? signature : description).accept(v);
return v;
} | java | {
"resource": ""
} |
q171908 | CsvUtil.toCsvString | test | public static String toCsvString(final Object... elements) {
StringBuilder line = new StringBuilder();
int last = elements.length -1;
for (int i = 0; i < elements.length; i++) {
if (elements[i] == null) {
if (i != last) {
line.append(FIELD_SEPARATOR);
}
continue;
}
String field = elements[i].toString();
// check for special cases
int ndx = field.indexOf(FIELD_SEPARATOR);
if (ndx == -1) {
ndx = field.indexOf(FIELD_QUOTE);
}
if (ndx == -1) {
if (field.startsWith(StringPool.SPACE) || field.endsWith(StringPool.SPACE)) {
ndx = 1;
}
}
if (ndx == -1) {
ndx = StringUtil.indexOfChars(field, SPECIAL_CHARS);
}
// add field
if (ndx != -1) {
line.append(FIELD_QUOTE);
}
field = StringUtil.replace(field, StringPool.QUOTE, DOUBLE_QUOTE);
line.append(field);
if (ndx != -1) {
line.append(FIELD_QUOTE);
}
// last
if (i != last) {
line.append(FIELD_SEPARATOR);
}
}
return line.toString();
} | java | {
"resource": ""
} |
q171909 | CsvUtil.toStringArray | test | public static String[] toStringArray(final String line) {
List<String> row = new ArrayList<>();
boolean inQuotedField = false;
int fieldStart = 0;
final int len = line.length();
for (int i = 0; i < len; i++) {
char c = line.charAt(i);
if (c == FIELD_SEPARATOR) {
if (!inQuotedField) { // ignore we are quoting
addField(row, line, fieldStart, i, inQuotedField);
fieldStart = i + 1;
}
} else if (c == FIELD_QUOTE) {
if (inQuotedField) {
if (i + 1 == len || line.charAt(i + 1) == FIELD_SEPARATOR) { // we are already quoting - peek to see if this is the end of the field
addField(row, line, fieldStart, i, inQuotedField);
fieldStart = i + 2;
i++; // and skip the comma
inQuotedField = false;
}
} else if (fieldStart == i) {
inQuotedField = true; // this is a beginning of a quote
fieldStart++; // move field start
}
}
}
// add last field - but only if string was not empty
if (len > 0 && fieldStart <= len) {
addField(row, line, fieldStart, len, inQuotedField);
}
return row.toArray(new String[0]);
} | java | {
"resource": ""
} |
q171910 | CtorResolver.resolve | test | public CtorInjectionPoint resolve(final Class type, final boolean useAnnotation) {
// lookup methods
ClassDescriptor cd = ClassIntrospector.get().lookup(type);
CtorDescriptor[] allCtors = cd.getAllCtorDescriptors();
Constructor foundedCtor = null;
Constructor defaultCtor = null;
BeanReferences[] references = null;
for (CtorDescriptor ctorDescriptor : allCtors) {
Constructor<?> ctor = ctorDescriptor.getConstructor();
Class<?>[] paramTypes = ctor.getParameterTypes();
if (paramTypes.length == 0) {
defaultCtor = ctor; // detects default ctors
}
if (!useAnnotation) {
continue;
}
BeanReferences[] ctorReferences = referencesResolver.readAllReferencesFromAnnotation(ctor);
if (ctorReferences == null) {
continue;
}
if (foundedCtor != null) {
throw new PetiteException("Two or more constructors are annotated as injection points in the bean: " + type.getName());
}
foundedCtor = ctor;
references = ctorReferences;
}
if (foundedCtor == null) {
// there is no annotated constructor
if (allCtors.length == 1) {
foundedCtor = allCtors[0].getConstructor();
} else {
foundedCtor = defaultCtor;
}
if (foundedCtor == null) {
// no matching ctor found
// still this is not an error if bean is already instantiated.
return CtorInjectionPoint.EMPTY;
}
references = referencesResolver.readAllReferencesFromAnnotation(foundedCtor);
if (references == null) {
references = new BeanReferences[0];
}
}
return new CtorInjectionPoint(foundedCtor, references);
} | java | {
"resource": ""
} |
q171911 | ProxyAspectData.createAdviceClassReader | test | private ClassReader createAdviceClassReader(final Class<? extends ProxyAdvice> advice) {
InputStream inputStream = null;
try {
inputStream = ClassLoaderUtil.getClassAsStream(advice);
return new ClassReader(inputStream);
} catch (IOException ioex) {
throw new ProxettaException(ioex);
} finally {
StreamUtil.close(inputStream);
}
} | java | {
"resource": ""
} |
q171912 | ProxyAspectData.getCachedAdviceClassReader | test | private ClassReader getCachedAdviceClassReader(final Class<? extends ProxyAdvice> advice) {
if (adviceClassReaderCache == null) {
adviceClassReaderCache = TypeCache.createDefault();
}
ClassReader adviceReader = adviceClassReaderCache.get(advice);
if (adviceReader == null) {
adviceReader = createAdviceClassReader(advice);
adviceClassReaderCache.put(advice, adviceReader);
}
return adviceReader;
} | java | {
"resource": ""
} |
q171913 | PBKDF2Encryptor.encrypt | test | public String encrypt(final String str) {
try {
byte[] utf8 = StringUtil.getBytes(str); // encode the string into bytes using utf-8
byte[] enc = ecipher.doFinal(utf8); // encrypt
return Base64.encodeToString(enc); // encode bytes to base64 to get a string
} catch (Throwable ignore) {
return null;
}
} | java | {
"resource": ""
} |
q171914 | PBKDF2Encryptor.decrypt | test | public String decrypt(String str) {
try {
str = StringUtil.replaceChar(str, ' ', '+'); // replace spaces with chars.
byte[] dec = Base64.decode(str); // decode base64 to get bytes
byte[] utf8 = dcipher.doFinal(dec); // decrypt
return new String(utf8, UTF_8); // decode using utf-8
} catch (Throwable ignore) {
return null;
}
} | java | {
"resource": ""
} |
q171915 | LoggerFactory.getLogger | test | public static Logger getLogger(final String name) {
if (loggers == null) {
return loggerProvider.apply(name);
}
return loggers.computeIfAbsent(name, loggerProvider);
} | java | {
"resource": ""
} |
q171916 | Cookie.setName | test | private void setName(final String name) {
if (name.contains(";") || name.contains(",") || name.startsWith("$")) {
throw new IllegalArgumentException("Invalid cookie name:" + name);
}
for (int n = 0; n < name.length(); n++) {
char c = name.charAt(n);
if (c <= 0x20 || c >= 0x7f) {
throw new IllegalArgumentException("Invalid cookie name:" + name);
}
}
this.name = name;
} | java | {
"resource": ""
} |
q171917 | MadvocController.createActionRequest | test | protected ActionRequest createActionRequest(
final String actionPath,
final String[] actionPathChunks,
final ActionRuntime actionRuntime,
final Object action,
final HttpServletRequest servletRequest,
final HttpServletResponse servletResponse) {
return new ActionRequest(this, actionPath, actionPathChunks, actionRuntime, action, servletRequest, servletResponse);
} | java | {
"resource": ""
} |
q171918 | PetiteFilterManager.createWrapper | test | @Override
protected <R extends ActionFilter> R createWrapper(final Class<R> wrapperClass) {
return petiteContainer.createBean(wrapperClass);
} | java | {
"resource": ""
} |
q171919 | ShutdownAwareScope.destroyBean | test | protected void destroyBean(final BeanData beanData) {
if (destroyableBeans == null) {
return;
}
if (!isBeanDestroyable(beanData)) {
return;
}
if (destroyableBeans.remove(beanData)) {
beanData.callDestroyMethods();
}
} | java | {
"resource": ""
} |
q171920 | ShutdownAwareScope.shutdown | test | @Override
public void shutdown() {
if (destroyableBeans == null) {
return;
}
for (final BeanData destroyableBean : destroyableBeans) {
destroyableBean.callDestroyMethods();
}
destroyableBeans.clear();
} | java | {
"resource": ""
} |
q171921 | ReceiverBuilder.get | test | public ReceivedEmail[] get() {
if (fromFolder != null) {
session.useFolder(fromFolder);
}
return session.receiveMessages(filter, flagsToSet, flagsToUnset, envelopeOnly, messages -> {
if (targetFolder != null) {
try {
session.folder.copyMessages(messages, session.getFolder(targetFolder));
} catch (MessagingException e) {
throw new MailException("Copying messages failed");
}
}
});
} | java | {
"resource": ""
} |
q171922 | ClusteredServiceContainer.main | test | public static void main(final String[] args)
{
loadPropertiesFiles(args);
try (ClusteredServiceContainer container = launch())
{
container.context().shutdownSignalBarrier().await();
System.out.println("Shutdown ClusteredServiceContainer...");
}
} | java | {
"resource": ""
} |
q171923 | RateReporter.run | test | public void run()
{
do
{
LockSupport.parkNanos(parkNs);
final long currentTotalMessages = totalMessages;
final long currentTotalBytes = totalBytes;
final long currentTimestamp = System.nanoTime();
final long timeSpanNs = currentTimestamp - lastTimestamp;
final double messagesPerSec =
((currentTotalMessages - lastTotalMessages) * (double)reportIntervalNs) / (double)timeSpanNs;
final double bytesPerSec =
((currentTotalBytes - lastTotalBytes) * (double)reportIntervalNs) / (double)timeSpanNs;
reportingFunc.onReport(messagesPerSec, bytesPerSec, currentTotalMessages, currentTotalBytes);
lastTotalBytes = currentTotalBytes;
lastTotalMessages = currentTotalMessages;
lastTimestamp = currentTimestamp;
}
while (!halt);
} | java | {
"resource": ""
} |
q171924 | SamplesUtil.printError | test | @SuppressWarnings("unused")
public static void printError(
final String channel,
final int streamId,
final int sessionId,
final String message,
final HeaderFlyweight cause)
{
System.out.println(message);
} | java | {
"resource": ""
} |
q171925 | SamplesUtil.printRate | test | public static void printRate(
final double messagesPerSec,
final double bytesPerSec,
final long totalMessages,
final long totalBytes)
{
System.out.println(String.format(
"%.02g msgs/sec, %.02g payload bytes/sec, totals %d messages %d MB",
messagesPerSec, bytesPerSec, totalMessages, totalBytes / (1024 * 1024)));
} | java | {
"resource": ""
} |
q171926 | SamplesUtil.mapExistingFileReadOnly | test | public static MappedByteBuffer mapExistingFileReadOnly(final File location)
{
if (!location.exists())
{
final String msg = "file not found: " + location.getAbsolutePath();
throw new IllegalStateException(msg);
}
MappedByteBuffer mappedByteBuffer = null;
try (RandomAccessFile file = new RandomAccessFile(location, "r");
FileChannel channel = file.getChannel())
{
mappedByteBuffer = channel.map(READ_ONLY, 0, channel.size());
}
catch (final IOException ex)
{
LangUtil.rethrowUnchecked(ex);
}
return mappedByteBuffer;
} | java | {
"resource": ""
} |
q171927 | ReplayMerge.close | test | public void close()
{
final State state = this.state;
if (State.CLOSED != state)
{
if (isReplayActive)
{
isReplayActive = false;
archive.stopReplay(replaySessionId);
}
if (State.MERGED != state)
{
subscription.removeDestination(replayDestination);
}
state(State.CLOSED);
}
} | java | {
"resource": ""
} |
q171928 | ReplayMerge.doWork | test | public int doWork()
{
int workCount = 0;
switch (state)
{
case AWAIT_INITIAL_RECORDING_POSITION:
workCount += awaitInitialRecordingPosition();
break;
case AWAIT_REPLAY:
workCount += awaitReplay();
break;
case AWAIT_CATCH_UP:
workCount += awaitCatchUp();
break;
case AWAIT_CURRENT_RECORDING_POSITION:
workCount += awaitUpdatedRecordingPosition();
break;
case AWAIT_STOP_REPLAY:
workCount += awaitStopReplay();
break;
}
return workCount;
} | java | {
"resource": ""
} |
q171929 | Publication.position | test | public long position()
{
if (isClosed)
{
return CLOSED;
}
final long rawTail = rawTailVolatile(logMetaDataBuffer);
final int termOffset = termOffset(rawTail, termBufferLength);
return computePosition(termId(rawTail), termOffset, positionBitsToShift, initialTermId);
} | java | {
"resource": ""
} |
q171930 | ExclusivePublication.offer | test | public long offer(final DirectBufferVector[] vectors, final ReservedValueSupplier reservedValueSupplier)
{
final int length = DirectBufferVector.validateAndComputeLength(vectors);
long newPosition = CLOSED;
if (!isClosed)
{
final long limit = positionLimit.getVolatile();
final ExclusiveTermAppender termAppender = termAppenders[activePartitionIndex];
final long position = termBeginPosition + termOffset;
if (position < limit)
{
final int result;
if (length <= maxPayloadLength)
{
result = termAppender.appendUnfragmentedMessage(
termId, termOffset, headerWriter, vectors, length, reservedValueSupplier);
}
else
{
checkMaxMessageLength(length);
result = termAppender.appendFragmentedMessage(
termId,
termOffset,
headerWriter,
vectors,
length,
maxPayloadLength,
reservedValueSupplier);
}
newPosition = newPosition(result);
}
else
{
newPosition = backPressureStatus(position, length);
}
}
return newPosition;
} | java | {
"resource": ""
} |
q171931 | ExclusivePublication.appendPadding | test | public long appendPadding(final int length)
{
checkMaxMessageLength(length);
long newPosition = CLOSED;
if (!isClosed)
{
final long limit = positionLimit.getVolatile();
final ExclusiveTermAppender termAppender = termAppenders[activePartitionIndex];
final long position = termBeginPosition + termOffset;
if (position < limit)
{
checkPositiveLength(length);
final int result = termAppender.appendPadding(termId, termOffset, headerWriter, length);
newPosition = newPosition(result);
}
else
{
newPosition = backPressureStatus(position, length);
}
}
return newPosition;
} | java | {
"resource": ""
} |
q171932 | AeronArchive.close | test | public void close()
{
lock.lock();
try
{
if (!isClosed)
{
isClosed = true;
archiveProxy.closeSession(controlSessionId);
if (!context.ownsAeronClient())
{
CloseHelper.close(controlResponsePoller.subscription());
CloseHelper.close(archiveProxy.publication());
}
context.close();
}
}
finally
{
lock.unlock();
}
} | java | {
"resource": ""
} |
q171933 | AeronArchive.pollForErrorResponse | test | public String pollForErrorResponse()
{
lock.lock();
try
{
ensureOpen();
if (controlResponsePoller.poll() != 0 && controlResponsePoller.isPollComplete())
{
if (controlResponsePoller.controlSessionId() == controlSessionId &&
controlResponsePoller.templateId() == ControlResponseDecoder.TEMPLATE_ID &&
controlResponsePoller.code() == ControlResponseCode.ERROR)
{
return controlResponsePoller.errorMessage();
}
}
return null;
}
finally
{
lock.unlock();
}
} | java | {
"resource": ""
} |
q171934 | AeronArchive.stopReplay | test | public void stopReplay(final long replaySessionId)
{
lock.lock();
try
{
ensureOpen();
final long correlationId = aeron.nextCorrelationId();
if (!archiveProxy.stopReplay(replaySessionId, correlationId, controlSessionId))
{
throw new ArchiveException("failed to send stop replay request");
}
pollForResponse(correlationId);
}
finally
{
lock.unlock();
}
} | java | {
"resource": ""
} |
q171935 | MultipleSubscribersWithFragmentAssembly.eventAvailableImage | test | public static void eventAvailableImage(final Image image)
{
final Subscription subscription = image.subscription();
System.out.format(
"new image on %s streamId %x sessionId %x from %s%n",
subscription.channel(), subscription.streamId(), image.sessionId(), image.sourceIdentity());
} | java | {
"resource": ""
} |
q171936 | MultipleSubscribersWithFragmentAssembly.eventUnavailableImage | test | public static void eventUnavailableImage(final Image image)
{
final Subscription subscription = image.subscription();
System.out.format(
"inactive image on %s streamId %d sessionId %x%n",
subscription.channel(), subscription.streamId(), image.sessionId());
} | java | {
"resource": ""
} |
q171937 | StatusUtil.sendChannelStatus | test | public static StatusIndicatorReader sendChannelStatus(final CountersReader countersReader, final String channel)
{
StatusIndicatorReader statusReader = null;
final MutableInteger id = new MutableInteger(-1);
countersReader.forEach(
(counterId, typeId, keyBuffer, label) ->
{
if (typeId == SendChannelStatus.SEND_CHANNEL_STATUS_TYPE_ID)
{
if (channel.startsWith(keyBuffer.getStringAscii(ChannelEndpointStatus.CHANNEL_OFFSET)))
{
id.value = counterId;
}
}
});
if (Aeron.NULL_VALUE != id.value)
{
statusReader = new UnsafeBufferStatusIndicator(countersReader.valuesBuffer(), id.value);
}
return statusReader;
} | java | {
"resource": ""
} |
q171938 | StatusUtil.receiveChannelStatus | test | public static StatusIndicatorReader receiveChannelStatus(final CountersReader countersReader, final String channel)
{
StatusIndicatorReader statusReader = null;
final MutableInteger id = new MutableInteger(-1);
countersReader.forEach(
(counterId, typeId, keyBuffer, label) ->
{
if (typeId == ReceiveChannelStatus.RECEIVE_CHANNEL_STATUS_TYPE_ID)
{
if (channel.startsWith(keyBuffer.getStringAscii(ChannelEndpointStatus.CHANNEL_OFFSET)))
{
id.value = counterId;
}
}
});
if (Aeron.NULL_VALUE != id.value)
{
statusReader = new UnsafeBufferStatusIndicator(countersReader.valuesBuffer(), id.value);
}
return statusReader;
} | java | {
"resource": ""
} |
q171939 | BufferBuilder.limit | test | public void limit(final int limit)
{
if (limit < 0 || limit >= buffer.capacity())
{
throw new IllegalArgumentException(
"limit outside range: capacity=" + buffer.capacity() + " limit=" + limit);
}
this.limit = limit;
} | java | {
"resource": ""
} |
q171940 | BufferBuilder.append | test | public BufferBuilder append(final DirectBuffer srcBuffer, final int srcOffset, final int length)
{
ensureCapacity(length);
buffer.putBytes(limit, srcBuffer, srcOffset, length);
limit += length;
return this;
} | java | {
"resource": ""
} |
q171941 | ControlResponsePoller.poll | test | public int poll()
{
controlSessionId = -1;
correlationId = -1;
relevantId = -1;
templateId = -1;
errorMessage = null;
pollComplete = false;
return subscription.controlledPoll(fragmentAssembler, fragmentLimit);
} | java | {
"resource": ""
} |
q171942 | LossReportUtil.mapLossReport | test | public static MappedByteBuffer mapLossReport(final String aeronDirectoryName, final int reportFileLength)
{
return mapNewFile(file(aeronDirectoryName), reportFileLength, false);
} | java | {
"resource": ""
} |
q171943 | StreamStat.snapshot | test | public Map<StreamCompositeKey, List<StreamPosition>> snapshot()
{
final Map<StreamCompositeKey, List<StreamPosition>> streams = new HashMap<>();
counters.forEach(
(counterId, typeId, keyBuffer, label) ->
{
if ((typeId >= PUBLISHER_LIMIT_TYPE_ID && typeId <= RECEIVER_POS_TYPE_ID) ||
typeId == SENDER_LIMIT_TYPE_ID || typeId == PER_IMAGE_TYPE_ID || typeId == PUBLISHER_POS_TYPE_ID)
{
final StreamCompositeKey key = new StreamCompositeKey(
keyBuffer.getInt(SESSION_ID_OFFSET),
keyBuffer.getInt(STREAM_ID_OFFSET),
keyBuffer.getStringAscii(CHANNEL_OFFSET));
final StreamPosition position = new StreamPosition(
keyBuffer.getLong(REGISTRATION_ID_OFFSET),
counters.getCounterValue(counterId),
typeId);
streams
.computeIfAbsent(key, (ignore) -> new ArrayList<>())
.add(position);
}
});
return streams;
} | java | {
"resource": ""
} |
q171944 | DataHeaderFlyweight.createDefaultHeader | test | public static UnsafeBuffer createDefaultHeader(final int sessionId, final int streamId, final int termId)
{
final UnsafeBuffer buffer = new UnsafeBuffer(
BufferUtil.allocateDirectAligned(HEADER_LENGTH, CACHE_LINE_LENGTH));
buffer.putByte(VERSION_FIELD_OFFSET, CURRENT_VERSION);
buffer.putByte(FLAGS_FIELD_OFFSET, (byte)BEGIN_AND_END_FLAGS);
buffer.putShort(TYPE_FIELD_OFFSET, (short)HDR_TYPE_DATA, LITTLE_ENDIAN);
buffer.putInt(SESSION_ID_FIELD_OFFSET, sessionId, LITTLE_ENDIAN);
buffer.putInt(STREAM_ID_FIELD_OFFSET, streamId, LITTLE_ENDIAN);
buffer.putInt(TERM_ID_FIELD_OFFSET, termId, LITTLE_ENDIAN);
buffer.putLong(RESERVED_VALUE_OFFSET, DEFAULT_RESERVE_VALUE);
return buffer;
} | java | {
"resource": ""
} |
q171945 | CounterMessageFlyweight.keyBuffer | test | public CounterMessageFlyweight keyBuffer(final DirectBuffer keyBuffer, final int keyOffset, final int keyLength)
{
buffer.putInt(KEY_LENGTH_OFFSET, keyLength);
if (null != keyBuffer && keyLength > 0)
{
buffer.putBytes(keyBufferOffset(), keyBuffer, keyOffset, keyLength);
}
return this;
} | java | {
"resource": ""
} |
q171946 | CounterMessageFlyweight.labelBuffer | test | public CounterMessageFlyweight labelBuffer(
final DirectBuffer labelBuffer, final int labelOffset, final int labelLength)
{
buffer.putInt(labelOffset(), labelLength);
buffer.putBytes(labelBufferOffset(), labelBuffer, labelOffset, labelLength);
return this;
} | java | {
"resource": ""
} |
q171947 | ArchiveProxy.connect | test | public boolean connect(final String responseChannel, final int responseStreamId, final long correlationId)
{
connectRequestEncoder
.wrapAndApplyHeader(buffer, 0, messageHeaderEncoder)
.correlationId(correlationId)
.responseStreamId(responseStreamId)
.version(AeronArchive.Configuration.SEMANTIC_VERSION)
.responseChannel(responseChannel);
return offerWithTimeout(connectRequestEncoder.encodedLength(), null);
} | java | {
"resource": ""
} |
q171948 | ArchiveProxy.tryConnect | test | public boolean tryConnect(final String responseChannel, final int responseStreamId, final long correlationId)
{
connectRequestEncoder
.wrapAndApplyHeader(buffer, 0, messageHeaderEncoder)
.correlationId(correlationId)
.responseStreamId(responseStreamId)
.version(AeronArchive.Configuration.SEMANTIC_VERSION)
.responseChannel(responseChannel);
final int length = MessageHeaderEncoder.ENCODED_LENGTH + connectRequestEncoder.encodedLength();
return publication.offer(buffer, 0, length) > 0;
} | java | {
"resource": ""
} |
q171949 | ArchiveProxy.closeSession | test | public boolean closeSession(final long controlSessionId)
{
closeSessionRequestEncoder
.wrapAndApplyHeader(buffer, 0, messageHeaderEncoder)
.controlSessionId(controlSessionId);
return offer(closeSessionRequestEncoder.encodedLength());
} | java | {
"resource": ""
} |
q171950 | ArchiveProxy.startRecording | test | public boolean startRecording(
final String channel,
final int streamId,
final SourceLocation sourceLocation,
final long correlationId,
final long controlSessionId)
{
startRecordingRequestEncoder
.wrapAndApplyHeader(buffer, 0, messageHeaderEncoder)
.controlSessionId(controlSessionId)
.correlationId(correlationId)
.streamId(streamId)
.sourceLocation(sourceLocation)
.channel(channel);
return offer(startRecordingRequestEncoder.encodedLength());
} | java | {
"resource": ""
} |
q171951 | ArchiveProxy.stopRecording | test | public boolean stopRecording(
final String channel,
final int streamId,
final long correlationId,
final long controlSessionId)
{
stopRecordingRequestEncoder
.wrapAndApplyHeader(buffer, 0, messageHeaderEncoder)
.controlSessionId(controlSessionId)
.correlationId(correlationId)
.streamId(streamId)
.channel(channel);
return offer(stopRecordingRequestEncoder.encodedLength());
} | java | {
"resource": ""
} |
q171952 | ArchiveProxy.replay | test | public boolean replay(
final long recordingId,
final long position,
final long length,
final String replayChannel,
final int replayStreamId,
final long correlationId,
final long controlSessionId)
{
replayRequestEncoder
.wrapAndApplyHeader(buffer, 0, messageHeaderEncoder)
.controlSessionId(controlSessionId)
.correlationId(correlationId)
.recordingId(recordingId)
.position(position)
.length(length)
.replayStreamId(replayStreamId)
.replayChannel(replayChannel);
return offer(replayRequestEncoder.encodedLength());
} | java | {
"resource": ""
} |
q171953 | ArchiveProxy.stopReplay | test | public boolean stopReplay(final long replaySessionId, final long correlationId, final long controlSessionId)
{
stopReplayRequestEncoder
.wrapAndApplyHeader(buffer, 0, messageHeaderEncoder)
.controlSessionId(controlSessionId)
.correlationId(correlationId)
.replaySessionId(replaySessionId);
return offer(replayRequestEncoder.encodedLength());
} | java | {
"resource": ""
} |
q171954 | ArchiveProxy.listRecordings | test | public boolean listRecordings(
final long fromRecordingId, final int recordCount, final long correlationId, final long controlSessionId)
{
listRecordingsRequestEncoder
.wrapAndApplyHeader(buffer, 0, messageHeaderEncoder)
.controlSessionId(controlSessionId)
.correlationId(correlationId)
.fromRecordingId(fromRecordingId)
.recordCount(recordCount);
return offer(listRecordingsRequestEncoder.encodedLength());
} | java | {
"resource": ""
} |
q171955 | ArchiveProxy.listRecordingsForUri | test | public boolean listRecordingsForUri(
final long fromRecordingId,
final int recordCount,
final String channelFragment,
final int streamId,
final long correlationId,
final long controlSessionId)
{
listRecordingsForUriRequestEncoder
.wrapAndApplyHeader(buffer, 0, messageHeaderEncoder)
.controlSessionId(controlSessionId)
.correlationId(correlationId)
.fromRecordingId(fromRecordingId)
.recordCount(recordCount)
.streamId(streamId)
.channel(channelFragment);
return offer(listRecordingsForUriRequestEncoder.encodedLength());
} | java | {
"resource": ""
} |
q171956 | ArchiveProxy.listRecording | test | public boolean listRecording(final long recordingId, final long correlationId, final long controlSessionId)
{
listRecordingRequestEncoder
.wrapAndApplyHeader(buffer, 0, messageHeaderEncoder)
.controlSessionId(controlSessionId)
.correlationId(correlationId)
.recordingId(recordingId);
return offer(listRecordingRequestEncoder.encodedLength());
} | java | {
"resource": ""
} |
q171957 | ArchiveProxy.extendRecording | test | public boolean extendRecording(
final String channel,
final int streamId,
final SourceLocation sourceLocation,
final long recordingId,
final long correlationId,
final long controlSessionId)
{
extendRecordingRequestEncoder
.wrapAndApplyHeader(buffer, 0, messageHeaderEncoder)
.controlSessionId(controlSessionId)
.correlationId(correlationId)
.recordingId(recordingId)
.streamId(streamId)
.sourceLocation(sourceLocation)
.channel(channel);
return offer(extendRecordingRequestEncoder.encodedLength());
} | java | {
"resource": ""
} |
q171958 | ArchiveProxy.getRecordingPosition | test | public boolean getRecordingPosition(final long recordingId, final long correlationId, final long controlSessionId)
{
recordingPositionRequestEncoder
.wrapAndApplyHeader(buffer, 0, messageHeaderEncoder)
.controlSessionId(controlSessionId)
.correlationId(correlationId)
.recordingId(recordingId);
return offer(recordingPositionRequestEncoder.encodedLength());
} | java | {
"resource": ""
} |
q171959 | ArchiveProxy.getStopPosition | test | public boolean getStopPosition(final long recordingId, final long correlationId, final long controlSessionId)
{
stopPositionRequestEncoder
.wrapAndApplyHeader(buffer, 0, messageHeaderEncoder)
.controlSessionId(controlSessionId)
.correlationId(correlationId)
.recordingId(recordingId);
return offer(stopPositionRequestEncoder.encodedLength());
} | java | {
"resource": ""
} |
q171960 | ArchiveProxy.listRecordingSubscriptions | test | public boolean listRecordingSubscriptions(
final int pseudoIndex,
final int subscriptionCount,
final String channelFragment,
final int streamId,
final boolean applyStreamId,
final long correlationId,
final long controlSessionId)
{
listRecordingSubscriptionsRequestEncoder
.wrapAndApplyHeader(buffer, 0, messageHeaderEncoder)
.controlSessionId(controlSessionId)
.correlationId(correlationId)
.pseudoIndex(pseudoIndex)
.subscriptionCount(subscriptionCount)
.applyStreamId(applyStreamId ? BooleanType.TRUE : BooleanType.FALSE)
.streamId(streamId)
.channel(channelFragment);
return offer(listRecordingSubscriptionsRequestEncoder.encodedLength());
} | java | {
"resource": ""
} |
q171961 | UdpChannel.matchesTag | test | public boolean matchesTag(final UdpChannel udpChannel)
{
if (!hasTag || !udpChannel.hasTag() || tag != udpChannel.tag())
{
return false;
}
if (udpChannel.remoteData().getAddress().isAnyLocalAddress() &&
udpChannel.remoteData().getPort() == 0 &&
udpChannel.localData().getAddress().isAnyLocalAddress() &&
udpChannel.localData().getPort() == 0)
{
return true;
}
throw new IllegalArgumentException("matching tag has set endpoint or control address");
} | java | {
"resource": ""
} |
q171962 | UdpChannel.destinationAddress | test | public static InetSocketAddress destinationAddress(final ChannelUri uri)
{
try
{
validateConfiguration(uri);
return getEndpointAddress(uri);
}
catch (final Exception ex)
{
throw new InvalidChannelException(ErrorCode.INVALID_CHANNEL, ex);
}
} | java | {
"resource": ""
} |
q171963 | UdpChannel.description | test | public String description()
{
final StringBuilder builder = new StringBuilder("UdpChannel - ");
if (null != localInterface)
{
builder
.append("interface: ")
.append(localInterface.getDisplayName())
.append(", ");
}
builder
.append("localData: ").append(localData)
.append(", remoteData: ").append(remoteData)
.append(", ttl: ").append(multicastTtl);
return builder.toString();
} | java | {
"resource": ""
} |
q171964 | PublicationImage.addDestination | test | void addDestination(final int transportIndex, final ReceiveDestinationUdpTransport transport)
{
imageConnections = ArrayUtil.ensureCapacity(imageConnections, transportIndex + 1);
if (transport.isMulticast())
{
imageConnections[transportIndex] = new ImageConnection(
cachedNanoClock.nanoTime(), transport.udpChannel().remoteControl());
}
else if (transport.hasExplicitControl())
{
imageConnections[transportIndex] = new ImageConnection(
cachedNanoClock.nanoTime(), transport.explicitControlAddress());
}
} | java | {
"resource": ""
} |
q171965 | PublicationImage.insertPacket | test | int insertPacket(
final int termId,
final int termOffset,
final UnsafeBuffer buffer,
final int length,
final int transportIndex,
final InetSocketAddress srcAddress)
{
final boolean isHeartbeat = DataHeaderFlyweight.isHeartbeat(buffer, length);
final long packetPosition = computePosition(termId, termOffset, positionBitsToShift, initialTermId);
final long proposedPosition = isHeartbeat ? packetPosition : packetPosition + length;
if (!isFlowControlUnderRun(packetPosition) && !isFlowControlOverRun(proposedPosition))
{
trackConnection(transportIndex, srcAddress, lastPacketTimestampNs);
if (isHeartbeat)
{
if (DataHeaderFlyweight.isEndOfStream(buffer) && !isEndOfStream && allEos(transportIndex))
{
LogBufferDescriptor.endOfStreamPosition(rawLog.metaData(), proposedPosition);
isEndOfStream = true;
}
heartbeatsReceived.incrementOrdered();
}
else
{
final UnsafeBuffer termBuffer = termBuffers[indexByPosition(packetPosition, positionBitsToShift)];
TermRebuilder.insert(termBuffer, termOffset, buffer, length);
}
lastPacketTimestampNs = cachedNanoClock.nanoTime();
hwmPosition.proposeMaxOrdered(proposedPosition);
}
return length;
} | java | {
"resource": ""
} |
q171966 | ClusterControl.findControlToggle | test | public static AtomicCounter findControlToggle(final CountersReader counters)
{
final AtomicBuffer buffer = counters.metaDataBuffer();
for (int i = 0, size = counters.maxCounterId(); i < size; i++)
{
final int recordOffset = CountersReader.metaDataOffset(i);
if (counters.getCounterState(i) == RECORD_ALLOCATED &&
buffer.getInt(recordOffset + TYPE_ID_OFFSET) == CONTROL_TOGGLE_TYPE_ID)
{
return new AtomicCounter(counters.valuesBuffer(), i, null);
}
}
return null;
} | java | {
"resource": ""
} |
q171967 | ChannelUri.put | test | public String put(final String key, final String value)
{
return params.put(key, value);
} | java | {
"resource": ""
} |
q171968 | ChannelUri.channelTag | test | public String channelTag()
{
return (null != tags && tags.length > CHANNEL_TAG_INDEX) ? tags[CHANNEL_TAG_INDEX] : null;
} | java | {
"resource": ""
} |
q171969 | ChannelUri.entityTag | test | public String entityTag()
{
return (null != tags && tags.length > ENTITY_TAG_INDEX) ? tags[ENTITY_TAG_INDEX] : null;
} | java | {
"resource": ""
} |
q171970 | ChannelUri.addSessionId | test | public static String addSessionId(final String channel, final int sessionId)
{
final ChannelUri channelUri = ChannelUri.parse(channel);
channelUri.put(CommonContext.SESSION_ID_PARAM_NAME, Integer.toString(sessionId));
return channelUri.toString();
} | java | {
"resource": ""
} |
q171971 | ChannelUri.getTag | test | public static long getTag(final String paramValue)
{
return isTagged(paramValue) ?
AsciiEncoding.parseLongAscii(paramValue, 4, paramValue.length() - 4) : INVALID_TAG;
} | java | {
"resource": ""
} |
q171972 | ExclusiveTermAppender.appendPadding | test | public int appendPadding(
final int termId,
final int termOffset,
final HeaderWriter header,
final int length)
{
final int frameLength = length + HEADER_LENGTH;
final int alignedLength = align(frameLength, FRAME_ALIGNMENT);
final UnsafeBuffer termBuffer = this.termBuffer;
final int termLength = termBuffer.capacity();
int resultingOffset = termOffset + alignedLength;
putRawTailOrdered(termId, resultingOffset);
if (resultingOffset > termLength)
{
resultingOffset = handleEndOfLogCondition(termBuffer, termOffset, header, termLength, termId);
}
else
{
header.write(termBuffer, termOffset, frameLength, termId);
frameType(termBuffer, termOffset, PADDING_FRAME_TYPE);
frameLengthOrdered(termBuffer, termOffset, frameLength);
}
return resultingOffset;
} | java | {
"resource": ""
} |
q171973 | NetworkPublication.updatePublisherLimit | test | final int updatePublisherLimit()
{
int workCount = 0;
final long senderPosition = this.senderPosition.getVolatile();
if (hasReceivers || (spiesSimulateConnection && spyPositions.length > 0))
{
long minConsumerPosition = senderPosition;
for (final ReadablePosition spyPosition : spyPositions)
{
minConsumerPosition = Math.min(minConsumerPosition, spyPosition.getVolatile());
}
final long proposedPublisherLimit = minConsumerPosition + termWindowLength;
if (publisherLimit.proposeMaxOrdered(proposedPublisherLimit))
{
cleanBuffer(proposedPublisherLimit);
workCount = 1;
}
}
else if (publisherLimit.get() > senderPosition)
{
publisherLimit.setOrdered(senderPosition);
}
return workCount;
} | java | {
"resource": ""
} |
q171974 | StreamCounter.allocate | test | public static UnsafeBufferPosition allocate(
final MutableDirectBuffer tempBuffer,
final String name,
final int typeId,
final CountersManager countersManager,
final long registrationId,
final int sessionId,
final int streamId,
final String channel)
{
return new UnsafeBufferPosition(
(UnsafeBuffer)countersManager.valuesBuffer(),
allocateCounterId(tempBuffer, name, typeId, countersManager, registrationId, sessionId, streamId, channel),
countersManager);
} | java | {
"resource": ""
} |
q171975 | StreamCounter.labelName | test | public static String labelName(final int typeId)
{
switch (typeId)
{
case PublisherLimit.PUBLISHER_LIMIT_TYPE_ID:
return PublisherLimit.NAME;
case SenderPos.SENDER_POSITION_TYPE_ID:
return SenderPos.NAME;
case ReceiverHwm.RECEIVER_HWM_TYPE_ID:
return ReceiverHwm.NAME;
case SubscriberPos.SUBSCRIBER_POSITION_TYPE_ID:
return SubscriberPos.NAME;
case ReceiverPos.RECEIVER_POS_TYPE_ID:
return ReceiverPos.NAME;
case SenderLimit.SENDER_LIMIT_TYPE_ID:
return SenderLimit.NAME;
case PublisherPos.PUBLISHER_POS_TYPE_ID:
return PublisherPos.NAME;
case SenderBpe.SENDER_BPE_TYPE_ID:
return SenderBpe.NAME;
default:
return "<unknown>";
}
} | java | {
"resource": ""
} |
q171976 | TermScanner.scanForAvailability | test | public static long scanForAvailability(final UnsafeBuffer termBuffer, final int offset, final int maxLength)
{
final int limit = Math.min(maxLength, termBuffer.capacity() - offset);
int available = 0;
int padding = 0;
do
{
final int termOffset = offset + available;
final int frameLength = frameLengthVolatile(termBuffer, termOffset);
if (frameLength <= 0)
{
break;
}
int alignedFrameLength = align(frameLength, FRAME_ALIGNMENT);
if (isPaddingFrame(termBuffer, termOffset))
{
padding = alignedFrameLength - HEADER_LENGTH;
alignedFrameLength = HEADER_LENGTH;
}
available += alignedFrameLength;
if (available > limit)
{
available -= alignedFrameLength;
padding = 0;
break;
}
}
while (0 == padding && available < limit);
return pack(padding, available);
} | java | {
"resource": ""
} |
q171977 | ChannelUriStringBuilder.clear | test | public ChannelUriStringBuilder clear()
{
prefix = null;
media = null;
endpoint = null;
networkInterface = null;
controlEndpoint = null;
controlMode = null;
tags = null;
alias = null;
reliable = null;
ttl = null;
mtu = null;
termLength = null;
initialTermId = null;
termId = null;
termOffset = null;
sessionId = null;
linger = null;
sparse = null;
eos = null;
tether = null;
isSessionIdTagged = false;
return this;
} | java | {
"resource": ""
} |
q171978 | ChannelUriStringBuilder.validate | test | public ChannelUriStringBuilder validate()
{
if (null == media)
{
throw new IllegalStateException("media type is mandatory");
}
if (CommonContext.UDP_MEDIA.equals(media) && (null == endpoint && null == controlEndpoint))
{
throw new IllegalStateException("either 'endpoint' or 'control' must be specified for UDP.");
}
int count = 0;
count += null == initialTermId ? 0 : 1;
count += null == termId ? 0 : 1;
count += null == termOffset ? 0 : 1;
if (count > 0)
{
if (count < 3)
{
throw new IllegalStateException(
"if any of then a complete set of 'initialTermId', 'termId', and 'termOffset' must be provided");
}
if (termId - initialTermId < 0) // lgtm [java/dereferenced-value-may-be-null]
{
throw new IllegalStateException(
"difference greater than 2^31 - 1: termId=" + termId + " - initialTermId=" + initialTermId);
}
if (null != termLength && termOffset > termLength) // lgtm [java/dereferenced-value-may-be-null]
{
throw new IllegalStateException("termOffset=" + termOffset + " > termLength=" + termLength);
}
}
return this;
} | java | {
"resource": ""
} |
q171979 | ChannelUriStringBuilder.prefix | test | public ChannelUriStringBuilder prefix(final String prefix)
{
if (null != prefix && !prefix.equals("") && !prefix.equals(SPY_QUALIFIER))
{
throw new IllegalArgumentException("invalid prefix: " + prefix);
}
this.prefix = prefix;
return this;
} | java | {
"resource": ""
} |
q171980 | ChannelUriStringBuilder.media | test | public ChannelUriStringBuilder media(final String media)
{
switch (media)
{
case CommonContext.UDP_MEDIA:
case CommonContext.IPC_MEDIA:
break;
default:
throw new IllegalArgumentException("invalid media: " + media);
}
this.media = media;
return this;
} | java | {
"resource": ""
} |
q171981 | ChannelUriStringBuilder.controlMode | test | public ChannelUriStringBuilder controlMode(final String controlMode)
{
if (null != controlMode &&
!controlMode.equals(CommonContext.MDC_CONTROL_MODE_MANUAL) &&
!controlMode.equals(CommonContext.MDC_CONTROL_MODE_DYNAMIC))
{
throw new IllegalArgumentException("invalid control mode: " + controlMode);
}
this.controlMode = controlMode;
return this;
} | java | {
"resource": ""
} |
q171982 | ChannelUriStringBuilder.termLength | test | public ChannelUriStringBuilder termLength(final Integer termLength)
{
if (null != termLength)
{
LogBufferDescriptor.checkTermLength(termLength);
}
this.termLength = termLength;
return this;
} | java | {
"resource": ""
} |
q171983 | ChannelUriStringBuilder.termOffset | test | public ChannelUriStringBuilder termOffset(final Integer termOffset)
{
if (null != termOffset)
{
if ((termOffset < 0 || termOffset > LogBufferDescriptor.TERM_MAX_LENGTH))
{
throw new IllegalArgumentException("term offset not in range 0-1g: " + termOffset);
}
if (0 != (termOffset & (FRAME_ALIGNMENT - 1)))
{
throw new IllegalArgumentException("term offset not multiple of FRAME_ALIGNMENT: " + termOffset);
}
}
this.termOffset = termOffset;
return this;
} | java | {
"resource": ""
} |
q171984 | ChannelUriStringBuilder.linger | test | public ChannelUriStringBuilder linger(final Long lingerNs)
{
if (null != lingerNs && lingerNs < 0)
{
throw new IllegalArgumentException("linger value cannot be negative: " + lingerNs);
}
this.linger = lingerNs;
return this;
} | java | {
"resource": ""
} |
q171985 | UdpChannelTransport.openDatagramChannel | test | public void openDatagramChannel(final AtomicCounter statusIndicator)
{
try
{
sendDatagramChannel = DatagramChannel.open(udpChannel.protocolFamily());
receiveDatagramChannel = sendDatagramChannel;
if (udpChannel.isMulticast())
{
if (null != connectAddress)
{
receiveDatagramChannel = DatagramChannel.open(udpChannel.protocolFamily());
}
receiveDatagramChannel.setOption(StandardSocketOptions.SO_REUSEADDR, true);
receiveDatagramChannel.bind(new InetSocketAddress(endPointAddress.getPort()));
receiveDatagramChannel.join(endPointAddress.getAddress(), udpChannel.localInterface());
sendDatagramChannel.setOption(StandardSocketOptions.IP_MULTICAST_IF, udpChannel.localInterface());
if (udpChannel.isHasMulticastTtl())
{
sendDatagramChannel.setOption(StandardSocketOptions.IP_MULTICAST_TTL, udpChannel.multicastTtl());
multicastTtl = sendDatagramChannel.getOption(StandardSocketOptions.IP_MULTICAST_TTL);
}
else if (context.socketMulticastTtl() != 0)
{
sendDatagramChannel.setOption(StandardSocketOptions.IP_MULTICAST_TTL, context.socketMulticastTtl());
multicastTtl = sendDatagramChannel.getOption(StandardSocketOptions.IP_MULTICAST_TTL);
}
}
else
{
sendDatagramChannel.bind(bindAddress);
}
if (null != connectAddress)
{
sendDatagramChannel.connect(connectAddress);
}
if (0 != context.socketSndbufLength())
{
sendDatagramChannel.setOption(SO_SNDBUF, context.socketSndbufLength());
}
if (0 != context.socketRcvbufLength())
{
receiveDatagramChannel.setOption(SO_RCVBUF, context.socketRcvbufLength());
}
sendDatagramChannel.configureBlocking(false);
receiveDatagramChannel.configureBlocking(false);
}
catch (final IOException ex)
{
if (null != statusIndicator)
{
statusIndicator.setOrdered(ChannelEndpointStatus.ERRORED);
}
CloseHelper.quietClose(sendDatagramChannel);
if (receiveDatagramChannel != sendDatagramChannel)
{
CloseHelper.quietClose(receiveDatagramChannel);
}
sendDatagramChannel = null;
receiveDatagramChannel = null;
throw new AeronException(
"channel error - " + ex.getMessage() +
" (at " + ex.getStackTrace()[0].toString() + "): " +
udpChannel.originalUriString(), ex);
}
} | java | {
"resource": ""
} |
q171986 | UdpChannelTransport.close | test | public void close()
{
if (!isClosed)
{
isClosed = true;
try
{
if (null != selectionKey)
{
selectionKey.cancel();
}
if (null != transportPoller)
{
transportPoller.cancelRead(this);
transportPoller.selectNowWithoutProcessing();
}
if (null != sendDatagramChannel)
{
sendDatagramChannel.close();
}
if (receiveDatagramChannel != sendDatagramChannel && null != receiveDatagramChannel)
{
receiveDatagramChannel.close();
}
if (null != transportPoller)
{
transportPoller.selectNowWithoutProcessing();
}
}
catch (final IOException ex)
{
errorLog.record(ex);
}
}
} | java | {
"resource": ""
} |
q171987 | UdpChannelTransport.isValidFrame | test | public boolean isValidFrame(final UnsafeBuffer buffer, final int length)
{
boolean isFrameValid = true;
if (frameVersion(buffer, 0) != HeaderFlyweight.CURRENT_VERSION)
{
isFrameValid = false;
invalidPackets.increment();
}
else if (length < HeaderFlyweight.MIN_HEADER_LENGTH)
{
isFrameValid = false;
invalidPackets.increment();
}
return isFrameValid;
} | java | {
"resource": ""
} |
q171988 | UdpChannelTransport.receive | test | public InetSocketAddress receive(final ByteBuffer buffer)
{
buffer.clear();
InetSocketAddress address = null;
try
{
if (receiveDatagramChannel.isOpen())
{
address = (InetSocketAddress)receiveDatagramChannel.receive(buffer);
}
}
catch (final PortUnreachableException ignored)
{
}
catch (final Exception ex)
{
LangUtil.rethrowUnchecked(ex);
}
return address;
} | java | {
"resource": ""
} |
q171989 | RetransmitHandler.onNak | test | public void onNak(
final int termId,
final int termOffset,
final int length,
final int termLength,
final RetransmitSender retransmitSender)
{
if (!isInvalid(termOffset, termLength))
{
if (null == activeRetransmitsMap.get(termId, termOffset) &&
activeRetransmitsMap.size() < MAX_RETRANSMITS_DEFAULT)
{
final RetransmitAction action = assignRetransmitAction();
action.termId = termId;
action.termOffset = termOffset;
action.length = Math.min(length, termLength - termOffset);
final long delay = delayGenerator.generateDelay();
if (0 == delay)
{
retransmitSender.resend(termId, termOffset, action.length);
action.linger(lingerTimeoutGenerator.generateDelay(), nanoClock.nanoTime());
}
else
{
action.delay(delay, nanoClock.nanoTime());
}
activeRetransmitsMap.put(termId, termOffset, action);
}
}
} | java | {
"resource": ""
} |
q171990 | RetransmitHandler.processTimeouts | test | public void processTimeouts(final long nowNs, final RetransmitSender retransmitSender)
{
if (activeRetransmitsMap.size() > 0)
{
for (final RetransmitAction action : retransmitActionPool)
{
if (DELAYED == action.state && (action.expireNs - nowNs < 0))
{
retransmitSender.resend(action.termId, action.termOffset, action.length);
action.linger(lingerTimeoutGenerator.generateDelay(), nanoClock.nanoTime());
}
else if (LINGERING == action.state && (action.expireNs - nowNs < 0))
{
action.cancel();
activeRetransmitsMap.remove(action.termId, action.termOffset);
}
}
}
} | java | {
"resource": ""
} |
q171991 | ChannelEndpointStatus.status | test | public static String status(final long status)
{
if (INITIALIZING == status)
{
return "INITIALIZING";
}
if (ERRORED == status)
{
return "ERRORED";
}
if (ACTIVE == status)
{
return "ACTIVE";
}
if (CLOSING == status)
{
return "CLOSING";
}
return "unknown id=" + status;
} | java | {
"resource": ""
} |
q171992 | ChannelEndpointStatus.allocate | test | public static AtomicCounter allocate(
final MutableDirectBuffer tempBuffer,
final String name,
final int typeId,
final CountersManager countersManager,
final String channel)
{
final int keyLength = tempBuffer.putStringWithoutLengthAscii(
CHANNEL_OFFSET + SIZE_OF_INT, channel, 0, MAX_CHANNEL_LENGTH);
tempBuffer.putInt(CHANNEL_OFFSET, keyLength);
int labelLength = 0;
labelLength += tempBuffer.putStringWithoutLengthAscii(keyLength + labelLength, name);
labelLength += tempBuffer.putStringWithoutLengthAscii(keyLength + labelLength, ": ");
labelLength += tempBuffer.putStringWithoutLengthAscii(
keyLength + labelLength, channel, 0, MAX_LABEL_LENGTH - labelLength);
return countersManager.newCounter(typeId, tempBuffer, 0, keyLength, tempBuffer, keyLength, labelLength);
} | java | {
"resource": ""
} |
q171993 | DirectBufferVector.reset | test | public DirectBufferVector reset(final DirectBuffer buffer, final int offset, final int length)
{
this.buffer = buffer;
this.offset = offset;
this.length = length;
return this;
} | java | {
"resource": ""
} |
q171994 | DirectBufferVector.validate | test | public DirectBufferVector validate()
{
final int capacity = buffer.capacity();
if (offset < 0 || offset >= capacity)
{
throw new IllegalArgumentException("offset=" + offset + " capacity=" + capacity);
}
if (length < 0 || length > (capacity - offset))
{
throw new IllegalArgumentException("offset=" + offset + " capacity=" + capacity + " length=" + length);
}
return this;
} | java | {
"resource": ""
} |
q171995 | DirectBufferVector.validateAndComputeLength | test | public static int validateAndComputeLength(final DirectBufferVector[] vectors)
{
int messageLength = 0;
for (final DirectBufferVector vector : vectors)
{
vector.validate();
messageLength += vector.length;
if (messageLength < 0)
{
throw new IllegalStateException("length overflow: " + Arrays.toString(vectors));
}
}
return messageLength;
} | java | {
"resource": ""
} |
q171996 | Configuration.producerWindowLength | test | public static int producerWindowLength(final int termBufferLength, final int defaultTermWindowLength)
{
int termWindowLength = termBufferLength / 2;
if (0 != defaultTermWindowLength)
{
termWindowLength = Math.min(defaultTermWindowLength, termWindowLength);
}
return termWindowLength;
} | java | {
"resource": ""
} |
q171997 | Configuration.validateSocketBufferLengths | test | public static void validateSocketBufferLengths(final MediaDriver.Context ctx)
{
try (DatagramChannel probe = DatagramChannel.open())
{
final int defaultSoSndBuf = probe.getOption(StandardSocketOptions.SO_SNDBUF);
probe.setOption(StandardSocketOptions.SO_SNDBUF, Integer.MAX_VALUE);
final int maxSoSndBuf = probe.getOption(StandardSocketOptions.SO_SNDBUF);
if (maxSoSndBuf < ctx.socketSndbufLength())
{
System.err.format(
"WARNING: Could not get desired SO_SNDBUF, adjust OS to allow %s: attempted=%d, actual=%d%n",
SOCKET_SNDBUF_LENGTH_PROP_NAME,
ctx.socketSndbufLength(),
maxSoSndBuf);
}
probe.setOption(StandardSocketOptions.SO_RCVBUF, Integer.MAX_VALUE);
final int maxSoRcvBuf = probe.getOption(StandardSocketOptions.SO_RCVBUF);
if (maxSoRcvBuf < ctx.socketRcvbufLength())
{
System.err.format(
"WARNING: Could not get desired SO_RCVBUF, adjust OS to allow %s: attempted=%d, actual=%d%n",
SOCKET_RCVBUF_LENGTH_PROP_NAME,
ctx.socketRcvbufLength(),
maxSoRcvBuf);
}
final int soSndBuf = 0 == ctx.socketSndbufLength() ? defaultSoSndBuf : ctx.socketSndbufLength();
if (ctx.mtuLength() > soSndBuf)
{
throw new ConfigurationException(String.format(
"MTU greater than socket SO_SNDBUF, adjust %s to match MTU: mtuLength=%d, SO_SNDBUF=%d",
SOCKET_SNDBUF_LENGTH_PROP_NAME,
ctx.mtuLength(),
soSndBuf));
}
if (ctx.initialWindowLength() > maxSoRcvBuf)
{
throw new ConfigurationException("window length greater than socket SO_RCVBUF, increase '" +
Configuration.INITIAL_WINDOW_LENGTH_PROP_NAME +
"' to match window: windowLength=" + ctx.initialWindowLength() + ", SO_RCVBUF=" + maxSoRcvBuf);
}
}
catch (final IOException ex)
{
throw new AeronException("probe socket: " + ex.toString(), ex);
}
} | java | {
"resource": ""
} |
q171998 | Configuration.validatePageSize | test | public static void validatePageSize(final int pageSize)
{
if (pageSize < PAGE_MIN_SIZE)
{
throw new ConfigurationException(
"page size less than min size of " + PAGE_MIN_SIZE + ": " + pageSize);
}
if (pageSize > PAGE_MAX_SIZE)
{
throw new ConfigurationException(
"page size greater than max size of " + PAGE_MAX_SIZE + ": " + pageSize);
}
if (!BitUtil.isPowerOfTwo(pageSize))
{
throw new ConfigurationException("page size not a power of 2: " + pageSize);
}
} | java | {
"resource": ""
} |
q171999 | Configuration.validateSessionIdRange | test | public static void validateSessionIdRange(final int low, final int high)
{
if (low > high)
{
throw new ConfigurationException("low session id value " + low + " must be <= high value " + high);
}
if (Math.abs((long)high - low) > Integer.MAX_VALUE)
{
throw new ConfigurationException("reserved range to too large");
}
} | java | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.