_id stringlengths 2 7 | title stringlengths 3 140 | partition stringclasses 3
values | text stringlengths 73 34.1k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q173500 | HollowPrefixIndex.initialize | test | private void initialize() {
String lastRefType = this.fieldPath.getLastRefTypeInPath();
// get all cardinality to estimate size of array bits needed.
totalWords = readStateEngine.getTypeState(lastRefType).getPopulatedOrdinals().cardinality();
averageWordLen = 0;
double avg = 0;
HollowObjectTypeReadState objectTypeReadState = (HollowObjectTypeReadState) readStateEngine.getTypeState(lastRefType);
BitSet keyBitSet = objectTypeReadState.getPopulatedOrdinals();
int ordinal = keyBitSet.nextSetBit(0);
while (ordinal != -1) {
avg += ((double) objectTypeReadState.readString(ordinal, 0).length()) / ((double) objectTypeReadState.maxOrdinal());
ordinal = keyBitSet.nextSetBit(ordinal + 1);
}
averageWordLen = (int) Math.ceil(avg);
HollowObjectTypeReadState valueState = (HollowObjectTypeReadState) readStateEngine.getTypeDataAccess(type);
maxOrdinalOfType = valueState.maxOrdinal();
// initialize the prefix index.
build();
} | java | {
"resource": ""
} |
q173501 | HollowPrefixIndex.contains | test | public boolean contains(String key) {
if (key == null) throw new IllegalArgumentException("key cannot be null");
TST current;
boolean result;
do {
current = prefixIndexVolatile;
result = current.contains(key);
} while (current != this.prefixIndexVolatile);
return result;
} | java | {
"resource": ""
} |
q173502 | RecordCountVarianceValidator.getChangePercent | test | float getChangePercent(int latestCardinality, int previousCardinality) {
int diff = Math.abs(latestCardinality - previousCardinality);
return (100.0f * diff) / previousCardinality;
} | java | {
"resource": ""
} |
q173503 | HollowFilterConfig.addField | test | public void addField(String type, String objectField) {
ObjectFilterConfig typeConfig = specifiedFieldConfigs.get(type);
if(typeConfig == null) {
typeConfig = new ObjectFilterConfig();
specifiedFieldConfigs.put(type, typeConfig);
}
typeConfig.addField(objectField);
} | java | {
"resource": ""
} |
q173504 | HollowSchemaSorter.dependencyOrderedSchemaList | test | public static List<HollowSchema> dependencyOrderedSchemaList(Collection<HollowSchema> schemas) {
DependencyIndex idx = new DependencyIndex();
Map<String, HollowSchema> schemaMap = new HashMap<String, HollowSchema>();
for(HollowSchema schema : schemas) {
schemaMap.put(schema.getName(), schema);
idx.indexSchema(schema, schemas);
}
List<HollowSchema> orderedSchemas = new ArrayList<HollowSchema>();
while(idx.hasMoreTypes())
orderedSchemas.add(schemaMap.get(idx.getNextType()));
return orderedSchemas;
} | java | {
"resource": ""
} |
q173505 | CodeGeneratorConfig.initWithNextMajorVersionDefaults_V3 | test | public void initWithNextMajorVersionDefaults_V3() {
usePackageGrouping = true;
useBooleanFieldErgonomics = true;
reservePrimaryKeyIndexForTypeWithPrimaryKey = true;
useHollowPrimitiveTypes = true;
restrictApiToFieldType = true;
useVerboseToString = true;
} | java | {
"resource": ""
} |
q173506 | GrowingSegmentedLongArray.get | test | public long get(long index) {
int segmentIndex = (int)(index >> log2OfSegmentSize);
if(segmentIndex >= segments.length || segments[segmentIndex] == null)
return 0;
int longInSegment = (int)(index & bitmask);
return segments[segmentIndex][longInSegment];
} | java | {
"resource": ""
} |
q173507 | HollowFieldMatchQuery.findMatchingRecords | test | public Map<String, BitSet> findMatchingRecords(String fieldName, String fieldValue) {
Map<String, BitSet> matches = new HashMap<String, BitSet>();
for(HollowTypeReadState typeState : readEngine.getTypeStates()) {
augmentMatchingRecords(typeState, fieldName, fieldValue, matches);
}
return matches;
} | java | {
"resource": ""
} |
q173508 | HollowFieldMatchQuery.findMatchingRecords | test | public Map<String, BitSet> findMatchingRecords(String typeName, String fieldName, String fieldValue) {
Map<String, BitSet> matches = new HashMap<String, BitSet>();
HollowTypeReadState typeState = readEngine.getTypeState(typeName);
if(typeState != null)
augmentMatchingRecords(typeState, fieldName, fieldValue, matches);
return matches;
} | java | {
"resource": ""
} |
q173509 | HollowSpecificDiff.setElementMatchPaths | test | public void setElementMatchPaths(String... paths) {
resetResults();
this.elementPaths = paths;
this.elementKeyPaths = null;
this.elementNonKeyPaths = null;
} | java | {
"resource": ""
} |
q173510 | HollowSpecificDiff.setElementKeyPaths | test | public void setElementKeyPaths(String... paths) {
resetResults();
elementKeyPaths = new BitSet(elementPaths.length);
for(int i=0;i<paths.length;i++) {
int elementPathIdx = getElementPathIdx(paths[i]);
if(elementPathIdx == -1)
throw new IllegalArgumentException("Key path must have been specified as an element match path. Offending path: " + paths[i]);
elementKeyPaths.set(elementPathIdx);
}
elementNonKeyPaths = new BitSet(elementPaths.length);
elementNonKeyPaths.set(0, elementPaths.length);
elementNonKeyPaths.andNot(elementKeyPaths);
} | java | {
"resource": ""
} |
q173511 | HollowSpecificDiff.calculate | test | public void calculate() {
resetResults();
SimultaneousExecutor executor = new SimultaneousExecutor(getClass(), "calculate");
final int numThreads = executor.getCorePoolSize();
for(int i=0;i<numThreads;i++) {
final int threadNumber = i;
executor.execute(new Runnable() {
public void run() {
HollowIndexerValueTraverser fromTraverser = new HollowIndexerValueTraverser(from, type, elementPaths);
HollowIndexerValueTraverser toTraverser = new HollowIndexerValueTraverser(to, type, elementPaths);
int hashedResults[] = new int[16];
for(int i=threadNumber;i<matcher.getMatchedOrdinals().size();i += numThreads) {
long ordinalPair = matcher.getMatchedOrdinals().get(i);
int fromOrdinal = (int)(ordinalPair >>> 32);
int toOrdinal = (int)ordinalPair;
fromTraverser.traverse(fromOrdinal);
toTraverser.traverse(toOrdinal);
if(fromTraverser.getNumMatches() * 2 > hashedResults.length)
hashedResults = new int[hashTableSize(fromTraverser.getNumMatches())];
populateHashTable(fromTraverser, hashedResults);
countMatches(fromTraverser, toTraverser, hashedResults);
}
for(int i=threadNumber;i<matcher.getExtraInFrom().size();i+=numThreads) {
fromTraverser.traverse(matcher.getExtraInFrom().get(i));
totalUnmatchedFromElements.addAndGet(fromTraverser.getNumMatches());
}
for(int i=threadNumber;i<matcher.getExtraInTo().size();i+=numThreads) {
toTraverser.traverse(matcher.getExtraInTo().get(i));
totalUnmatchedToElements.addAndGet(toTraverser.getNumMatches());
}
}
});
}
try {
executor.awaitSuccessfulCompletion();
} catch (Exception ex) {
throw new RuntimeException(ex);
}
} | java | {
"resource": ""
} |
q173512 | HollowIncrementalProducer.restoreFromLastState | test | public void restoreFromLastState() {
producer.initializeDataModel(dataModel);
long latestAnnouncedVersion = announcementWatcher.getLatestVersion();
if (latestAnnouncedVersion == HollowFilesystemAnnouncementWatcher.NO_ANNOUNCEMENT_AVAILABLE || latestAnnouncedVersion < 0) {
return;
}
restore(latestAnnouncedVersion, blobRetriever);
} | java | {
"resource": ""
} |
q173513 | HollowIncrementalProducer.runCycle | test | public long runCycle() {
long recordsRemoved = countRecordsToRemove();
long recordsAddedOrModified = this.mutations.values().size() - recordsRemoved;
try {
long version = producer.runCycle(populator);
if(version == lastSucessfulCycle) {
return version;
}
listeners.fireIncrementalCycleComplete(version, recordsAddedOrModified, recordsRemoved, new HashMap<String, Object>(cycleMetadata));
//Only clean changes when the version is new.
clearChanges();
lastSucessfulCycle = version;
return version;
} catch (Exception e) {
listeners.fireIncrementalCycleFail(e, recordsAddedOrModified, recordsRemoved, new HashMap<String, Object>(cycleMetadata));
return FAILED_VERSION;
} finally {
clearCycleMetadata();
}
} | java | {
"resource": ""
} |
q173514 | HollowCombinerExcludePrimaryKeysCopyDirector.excludeKey | test | public void excludeKey(HollowPrimaryKeyIndex idx, Object... key) {
int excludeOrdinal = idx.getMatchingOrdinal(key);
if(excludeOrdinal >= 0) {
BitSet excludedOrdinals = this.excludedOrdinals.get(idx.getTypeState());
if(excludedOrdinals == null) {
excludedOrdinals = new BitSet(idx.getTypeState().maxOrdinal()+1);
this.excludedOrdinals.put(idx.getTypeState(), excludedOrdinals);
}
excludedOrdinals.set(excludeOrdinal);
}
} | java | {
"resource": ""
} |
q173515 | HollowCombinerExcludePrimaryKeysCopyDirector.excludeReferencedObjects | test | public void excludeReferencedObjects() {
Set<HollowReadStateEngine> stateEngines = new HashSet<HollowReadStateEngine>();
for(Map.Entry<HollowTypeReadState, BitSet> entry : excludedOrdinals.entrySet())
stateEngines.add(entry.getKey().getStateEngine());
for(HollowReadStateEngine stateEngine : stateEngines) {
Map<String, BitSet> typeBitSetsForStateEngine = new HashMap<String, BitSet>();
for(Map.Entry<HollowTypeReadState, BitSet> entry : excludedOrdinals.entrySet()) {
if(entry.getKey().getStateEngine() == stateEngine) {
String type = entry.getKey().getSchema().getName();
typeBitSetsForStateEngine.put(type, BitSet.valueOf(entry.getValue().toLongArray()));
}
}
TransitiveSetTraverser.addTransitiveMatches(stateEngine, typeBitSetsForStateEngine);
for(Map.Entry<String, BitSet> entry : typeBitSetsForStateEngine.entrySet())
excludedOrdinals.put(stateEngine.getTypeState(entry.getKey()), entry.getValue());
}
} | java | {
"resource": ""
} |
q173516 | HollowBlobHeaderWriter.writeHeader | test | public void writeHeader(HollowBlobHeader header, DataOutputStream dos) throws IOException {
/// save 4 bytes to indicate FastBlob version header. This will be changed to indicate backwards incompatibility.
dos.writeInt(HollowBlobHeader.HOLLOW_BLOB_VERSION_HEADER);
/// Write randomized tag data -- every state gets a random 64-bit tag.
/// When attempting to apply a delta, the originating state's random 64-bit tag is compared against the current 64-bit tag.
/// This prevents deltas from being applied to incorrect states.
dos.writeLong(header.getOriginRandomizedTag());
dos.writeLong(header.getDestinationRandomizedTag());
/// write the schemas contained in this blob to the stream in the pre v2.2.0 backwards compatibility envelope
ByteArrayOutputStream schemasStream = new ByteArrayOutputStream();
VarInt.writeVInt(schemasStream, header.getSchemas().size());
for(HollowSchema schema : header.getSchemas())
schema.writeTo(schemasStream);
byte[] schemasData = schemasStream.toByteArray();
VarInt.writeVInt(dos, schemasData.length + 1); // plus one byte for new backwards compatibility envelope.
dos.write(schemasData);
///backwards compatibility -- new data can be added here by first indicating number of bytes used, will be skipped by existing readers.
VarInt.writeVInt(dos, 0);
/// write the header tags -- intended to include input source data versions
dos.writeShort(header.getHeaderTags().size());
for (Map.Entry<String, String> headerTag : header.getHeaderTags().entrySet()) {
dos.writeUTF(headerTag.getKey());
dos.writeUTF(headerTag.getValue());
}
} | java | {
"resource": ""
} |
q173517 | HollowMetrics.calculateTypeMetrics | test | void calculateTypeMetrics(HollowReadStateEngine hollowReadStateEngine) {
Collection<HollowTypeReadState> typeStates = hollowReadStateEngine.getTypeStates();
if (typeStates == null)
return;
totalHeapFootprint = 0L;
totalPopulatedOrdinals = 0;
for (HollowTypeReadState typeState : typeStates) {
long heapCost = typeState.getApproximateHeapFootprintInBytes();
totalHeapFootprint += heapCost;
int populatedOrdinals = typeState.getPopulatedOrdinals().cardinality();
totalPopulatedOrdinals += populatedOrdinals;
String type = typeState.getSchema().getName();
typeHeapFootprint.put(type, heapCost);
typePopulatedOrdinals.put(type, populatedOrdinals);
}
} | java | {
"resource": ""
} |
q173518 | HollowObjectWriteRecord.writeDataTo | test | public void writeDataTo(ByteDataBuffer buf) {
for (int i = 0; i < fieldData.length; i++) {
writeField(buf, i);
}
} | java | {
"resource": ""
} |
q173519 | HollowObjectWriteRecord.writeFixedLengthInt | test | private static void writeFixedLengthInt(ByteDataBuffer fieldBuffer, int intBits) {
fieldBuffer.write((byte) (intBits >>> 24));
fieldBuffer.write((byte) (intBits >>> 16));
fieldBuffer.write((byte) (intBits >>> 8));
fieldBuffer.write((byte) (intBits));
} | java | {
"resource": ""
} |
q173520 | HollowObjectWriteRecord.writeFixedLengthLong | test | private static void writeFixedLengthLong(ByteDataBuffer fieldBuffer, long intBits) {
fieldBuffer.write((byte) (intBits >>> 56));
fieldBuffer.write((byte) (intBits >>> 48));
fieldBuffer.write((byte) (intBits >>> 40));
fieldBuffer.write((byte) (intBits >>> 32));
fieldBuffer.write((byte) (intBits >>> 24));
fieldBuffer.write((byte) (intBits >>> 16));
fieldBuffer.write((byte) (intBits >>> 8));
fieldBuffer.write((byte) (intBits));
} | java | {
"resource": ""
} |
q173521 | FreeOrdinalTracker.returnOrdinalToPool | test | public void returnOrdinalToPool(int ordinal) {
if(size == freeOrdinals.length) {
freeOrdinals = Arrays.copyOf(freeOrdinals, freeOrdinals.length * 3 / 2);
}
freeOrdinals[size] = ordinal;
size++;
} | java | {
"resource": ""
} |
q173522 | FreeOrdinalTracker.sort | test | public void sort() {
Arrays.sort(freeOrdinals, 0, size);
/// reverse the ordering
int midpoint = size / 2;
for(int i=0;i<midpoint;i++) {
int temp = freeOrdinals[i];
freeOrdinals[i] = freeOrdinals[size-i-1];
freeOrdinals[size-i-1] = temp;
}
} | java | {
"resource": ""
} |
q173523 | SetMapKeyHasher.hash | test | public static int hash(Object key[], FieldType fieldType[]) {
int hash = 0;
for (int i = 0; i < key.length; i++) {
hash *= 31;
hash ^= hash(key[i], fieldType[i]);
}
return hash;
} | java | {
"resource": ""
} |
q173524 | SetMapKeyHasher.hash | test | public static int hash(Object key, FieldType fieldType) {
switch(fieldType) {
case INT:
return HashCodes.hashInt(((Integer)key).intValue());
case LONG:
long longVal = ((Long)key).longValue();
return HashCodes.hashInt((int)(longVal ^ (longVal >>> 32)));
case REFERENCE:
return HashCodes.hashInt(((Integer)key).intValue());
case BYTES:
return HashCodes.hashInt(HashCodes.hashCode((byte[])key));
case STRING:
return HashCodes.hashInt(key.hashCode());
case BOOLEAN:
return HashCodes.hashInt(((Boolean)key).booleanValue() ? 1231 : 1237);
case DOUBLE:
long longBits = Double.doubleToRawLongBits(((Double)key).doubleValue());
return HashCodes.hashInt((int)(longBits ^ (longBits >>> 32)));
case FLOAT:
return HashCodes.hashInt(Float.floatToRawIntBits(((Float)key).floatValue()));
default:
throw new IllegalArgumentException("Unknown field type: " + fieldType);
}
} | java | {
"resource": ""
} |
q173525 | FixedLengthMultipleOccurrenceElementArray.resizeStorage | test | private void resizeStorage() {
int currentElementsPerNode = maxElementsPerNode;
int newElementsPerNode = (int) (currentElementsPerNode * RESIZE_MULTIPLE);
if (newElementsPerNode <= currentElementsPerNode) {
throw new IllegalStateException("cannot resize fixed length array from "
+ currentElementsPerNode + " to " + newElementsPerNode);
}
FixedLengthElementArray newStorage = new FixedLengthElementArray(memoryRecycler,
numNodes * bitsPerElement * newElementsPerNode);
LongStream.range(0, numNodes).forEach(nodeIndex -> {
long currentBucketStart = nodeIndex * currentElementsPerNode * bitsPerElement;
long newBucketStart = nodeIndex * newElementsPerNode * bitsPerElement;
for (int offset = 0; offset < currentElementsPerNode; offset++) {
long element = storage.getElementValue(currentBucketStart + offset * bitsPerElement,
bitsPerElement, elementMask);
if (element == NO_ELEMENT) {
break; // we have exhausted the elements at this index
}
newStorage.setElementValue(
newBucketStart + offset * bitsPerElement, bitsPerElement, element);
}
});
storage.destroy(memoryRecycler);
storage = newStorage;
maxElementsPerNode = newElementsPerNode;
} | java | {
"resource": ""
} |
q173526 | ByteArrayOrdinalMap.findFreeOrdinal | test | private int findFreeOrdinal(int preferredOrdinal) {
if (preferredOrdinal != -1 && unusedPreviousOrdinals.get(preferredOrdinal)) {
unusedPreviousOrdinals.clear(preferredOrdinal);
return preferredOrdinal;
}
return freeOrdinalTracker.getFreeOrdinal();
} | java | {
"resource": ""
} |
q173527 | ByteArrayOrdinalMap.prepareForWrite | test | public void prepareForWrite() {
int maxOrdinal = 0;
AtomicLongArray pao = pointersAndOrdinals;
for (int i = 0; i < pao.length(); i++) {
long key = pao.get(i);
if (key != EMPTY_BUCKET_VALUE) {
int ordinal = (int) (key >>> BITS_PER_POINTER);
if (ordinal > maxOrdinal) {
maxOrdinal = ordinal;
}
}
}
long[] pbo = new long[maxOrdinal + 1];
Arrays.fill(pbo, -1);
for (int i = 0; i < pao.length(); i++) {
long key = pao.get(i);
if (key != EMPTY_BUCKET_VALUE) {
int ordinal = (int) (key >>> BITS_PER_POINTER);
pbo[ordinal] = key & POINTER_MASK;
}
}
pointersByOrdinal = pbo;
} | java | {
"resource": ""
} |
q173528 | ByteArrayOrdinalMap.compare | test | private boolean compare(ByteDataBuffer serializedRepresentation, long key) {
long position = key & POINTER_MASK;
int sizeOfData = VarInt.readVInt(byteData.getUnderlyingArray(), position);
if (sizeOfData != serializedRepresentation.length()) {
return false;
}
position += VarInt.sizeOfVInt(sizeOfData);
for (int i = 0; i < sizeOfData; i++) {
if (serializedRepresentation.get(i) != byteData.get(position++)) {
return false;
}
}
return true;
} | java | {
"resource": ""
} |
q173529 | ByteArrayOrdinalMap.growKeyArray | test | private void growKeyArray() {
int newSize = pointersAndOrdinals.length() << 1;
if (newSize < 0) {
throw new IllegalStateException("New size computed to grow the underlying array for the map is negative. " +
"This is most likely due to the total number of keys added to map has exceeded the max capacity of the keys map can hold. "
+
"Current array size :" + pointersAndOrdinals.length() + " and size to grow :" + newSize);
}
growKeyArray(newSize);
} | java | {
"resource": ""
} |
q173530 | ByteArrayOrdinalMap.rehashPreviouslyAddedData | test | private int rehashPreviouslyAddedData(long key) {
long position = key & POINTER_MASK;
int sizeOfData = VarInt.readVInt(byteData.getUnderlyingArray(), position);
position += VarInt.sizeOfVInt(sizeOfData);
return HashCodes.hashCode(byteData.getUnderlyingArray(), position, sizeOfData);
} | java | {
"resource": ""
} |
q173531 | ByteArrayOrdinalMap.emptyKeyArray | test | private AtomicLongArray emptyKeyArray(int size) {
AtomicLongArray arr = new AtomicLongArray(size);
// Volatile store not required, could use plain store
// See VarHandles for JDK >= 9
for (int i = 0; i < arr.length(); i++) {
arr.lazySet(i, EMPTY_BUCKET_VALUE);
}
return arr;
} | java | {
"resource": ""
} |
q173532 | HollowIndexerValueTraverser.isMatchEqual | test | public boolean isMatchEqual(int matchIdx, HollowIndexerValueTraverser otherTraverser, int otherMatchIdx) {
for(int i=0;i<getNumFieldPaths();i++) {
if(!HollowReadFieldUtils.fieldsAreEqual((HollowObjectTypeDataAccess)fieldTypeDataAccess[i], fieldMatchLists[i].get(matchIdx), fieldSchemaPosition[i],
(HollowObjectTypeDataAccess)otherTraverser.fieldTypeDataAccess[i], otherTraverser.fieldMatchLists[i].get(otherMatchIdx), otherTraverser.fieldSchemaPosition[i]))
return false;
}
return true;
} | java | {
"resource": ""
} |
q173533 | UniqueKeyIndex.findMatch | test | public T findMatch(Q key) {
Object[] keyArray = matchFields.stream().map(mf -> mf.extract(key)).toArray();
int ordinal = hpki.getMatchingOrdinal(keyArray);
if (ordinal == -1) {
return null;
}
return uniqueTypeExtractor.extract(api, ordinal);
} | java | {
"resource": ""
} |
q173534 | ReadStateHelper.swap | test | ReadStateHelper swap() {
return new ReadStateHelper(newReadState(current.getVersion(), pending.getStateEngine()),
newReadState(pending.getVersion(), current.getStateEngine()));
} | java | {
"resource": ""
} |
q173535 | HashCodes.hashTableSize | test | public static int hashTableSize(int numElements) throws IllegalArgumentException {
if (numElements < 0) {
throw new IllegalArgumentException("cannot be negative; numElements="+numElements);
} else if (numElements > HASH_TABLE_MAX_SIZE) {
throw new IllegalArgumentException("exceeds maximum number of buckets; numElements="+numElements);
}
if (numElements == 0)
return 1;
if (numElements < 3)
return numElements * 2;
// Apply load factor to number of elements and determine next
// largest power of 2 that fits in an int
int sizeAfterLoadFactor = (int)((long)numElements * 10 / 7);
int bits = 32 - Integer.numberOfLeadingZeros(sizeAfterLoadFactor - 1);
return 1 << bits;
} | java | {
"resource": ""
} |
q173536 | HollowProducer.runCompactionCycle | test | public long runCompactionCycle(HollowCompactor.CompactionConfig config) {
if (config != null && readStates.hasCurrent()) {
final HollowCompactor compactor = new HollowCompactor(getWriteEngine(),
readStates.current().getStateEngine(), config);
if (compactor.needsCompaction()) {
return runCycle(newState -> compactor.compact());
}
}
return NO_ANNOUNCEMENT_AVAILABLE;
} | java | {
"resource": ""
} |
q173537 | HollowBlobWriter.writeSnapshot | test | public void writeSnapshot(OutputStream os) throws IOException {
stateEngine.prepareForWrite();
DataOutputStream dos = new DataOutputStream(os);
writeHeader(dos, stateEngine.getSchemas(), false);
VarInt.writeVInt(dos, stateEngine.getOrderedTypeStates().size());
SimultaneousExecutor executor = new SimultaneousExecutor(getClass(), "write-snapshot");
for(final HollowTypeWriteState typeState : stateEngine.getOrderedTypeStates()) {
executor.execute(new Runnable() {
public void run() {
typeState.calculateSnapshot();
}
});
}
try {
executor.awaitSuccessfulCompletion();
} catch (Exception e) {
throw new RuntimeException(e);
}
for(HollowTypeWriteState typeState : stateEngine.getOrderedTypeStates()) {
HollowSchema schema = typeState.getSchema();
schema.writeTo(dos);
writeNumShards(dos, typeState.getNumShards());
typeState.writeSnapshot(dos);
}
os.flush();
} | java | {
"resource": ""
} |
q173538 | HollowBlobWriter.writeDelta | test | public void writeDelta(OutputStream os) throws IOException {
stateEngine.prepareForWrite();
if(stateEngine.isRestored())
stateEngine.ensureAllNecessaryStatesRestored();
List<HollowSchema> changedTypes = changedTypes();
DataOutputStream dos = new DataOutputStream(os);
writeHeader(dos, changedTypes, false);
VarInt.writeVInt(dos, changedTypes.size());
SimultaneousExecutor executor = new SimultaneousExecutor(getClass(), "write-delta");
for(final HollowTypeWriteState typeState : stateEngine.getOrderedTypeStates()) {
executor.execute(new Runnable() {
public void run() {
if(typeState.hasChangedSinceLastCycle())
typeState.calculateDelta();
}
});
}
try {
executor.awaitSuccessfulCompletion();
} catch (Exception e) {
throw new RuntimeException(e);
}
for(HollowTypeWriteState typeState : stateEngine.getOrderedTypeStates()) {
if(typeState.hasChangedSinceLastCycle()) {
HollowSchema schema = typeState.getSchema();
schema.writeTo(dos);
writeNumShards(dos, typeState.getNumShards());
typeState.writeDelta(dos);
}
}
os.flush();
} | java | {
"resource": ""
} |
q173539 | HollowConsumerJavaFileGenerator.addToSetIfNotPrimitiveOrCollection | test | private void addToSetIfNotPrimitiveOrCollection(Set<String> schemaNameSet, String... schemaNames) {
for (String schemaName : schemaNames) {
// collections schemas get brought in by a star import
if (!HollowCodeGenerationUtils.isCollectionType(schemaName, dataset) &&
!HollowCodeGenerationUtils.isPrimitiveType(schemaName)) {
schemaNameSet.add(schemaName);
}
}
} | java | {
"resource": ""
} |
q173540 | HollowCodeGenerationUtils.normalizeFieldPathToParamName | test | public static String normalizeFieldPathToParamName(String fieldPath) {
String result = null;
if (fieldPath.contains(".")) {
String[] parts = fieldPath.split("\\.");
StringBuilder sb = new StringBuilder();
sb.append(lowercase(parts[0]));
for (int i = 1; i < parts.length; i++) {
sb.append(uppercase(parts[i]));
}
result = sb.toString();
} else {
result = lowercase(fieldPath);
}
if (result.endsWith("!")) {
return result.substring(0, result.length() - 1);
}
return result;
} | java | {
"resource": ""
} |
q173541 | HollowHashIndex.reindexHashIndex | test | private void reindexHashIndex() {
HollowHashIndexBuilder builder = new HollowHashIndexBuilder(stateEngine, type, selectField, matchFields);
builder.buildIndex();
this.hashStateVolatile = new HollowHashIndexState(builder);
} | java | {
"resource": ""
} |
q173542 | HollowHashIndex.findMatches | test | public HollowHashIndexResult findMatches(Object... query) {
int hashCode = 0;
for(int i=0;i<query.length;i++) {
if(query[i] == null)
throw new IllegalArgumentException("querying by null unsupported; i=" + i);
hashCode ^= HashCodes.hashInt(keyHashCode(query[i], i));
}
HollowHashIndexResult result;
HollowHashIndexState hashState;
do {
result = null;
hashState = hashStateVolatile;
long bucket = hashCode & hashState.getMatchHashMask();
long hashBucketBit = bucket * hashState.getBitsPerMatchHashEntry();
boolean bucketIsEmpty = hashState.getMatchHashTable().getElementValue(hashBucketBit, hashState.getBitsPerTraverserField()[0]) == 0;
while (!bucketIsEmpty) {
if (matchIsEqual(hashState.getMatchHashTable(), hashBucketBit, query)) {
int selectSize = (int) hashState.getMatchHashTable().getElementValue(hashBucketBit + hashState.getBitsPerMatchHashKey(), hashState.getBitsPerSelectTableSize());
long selectBucketPointer = hashState.getMatchHashTable().getElementValue(hashBucketBit + hashState.getBitsPerMatchHashKey() + hashState.getBitsPerSelectTableSize(), hashState.getBitsPerSelectTablePointer());
result = new HollowHashIndexResult(hashState, selectBucketPointer, selectSize);
break;
}
bucket = (bucket + 1) & hashState.getMatchHashMask();
hashBucketBit = bucket * hashState.getBitsPerMatchHashEntry();
bucketIsEmpty = hashState.getMatchHashTable().getElementValue(hashBucketBit, hashState.getBitsPerTraverserField()[0]) == 0;
}
} while (hashState != hashStateVolatile);
return result;
} | java | {
"resource": ""
} |
q173543 | HollowAnnouncementWatcher.triggerAsyncRefreshWithRandomDelay | test | public void triggerAsyncRefreshWithRandomDelay(int maxDelayMillis) {
Random rand = new Random();
int delayMillis = maxDelayMillis > 0 ? rand.nextInt(maxDelayMillis) : 0;
triggerAsyncRefreshWithDelay(delayMillis);
} | java | {
"resource": ""
} |
q173544 | HollowAnnouncementWatcher.triggerAsyncRefreshWithDelay | test | public void triggerAsyncRefreshWithDelay(int delayMillis) {
final HollowClient client = this.client;
final long targetBeginTime = System.currentTimeMillis() + delayMillis;
refreshExecutor.execute(new Runnable() {
public void run() {
try {
long delay = targetBeginTime - System.currentTimeMillis();
if(delay > 0)
Thread.sleep(delay);
client.triggerRefresh();
} catch(Throwable th) {
log.log(Level.SEVERE, "Async refresh failed", th);
}
}
});
} | java | {
"resource": ""
} |
q173545 | HollowDiff.addTypeDiff | test | public HollowTypeDiff addTypeDiff(String type, String... primaryKeyPaths) {
HollowTypeDiff typeDiff = new HollowTypeDiff(this, type, primaryKeyPaths);
if(typeDiff.hasAnyData())
typeDiffs.put(type, typeDiff);
return typeDiff;
} | java | {
"resource": ""
} |
q173546 | HollowDiff.calculateDiffs | test | public void calculateDiffs() {
long startTime = System.currentTimeMillis();
prepareForDiffCalculation();
long endTime = System.currentTimeMillis();
log.info("PREPARED IN " + (endTime - startTime) + "ms");
for(HollowTypeDiff typeDiff : typeDiffs.values()) {
typeDiff.calculateDiffs();
}
} | java | {
"resource": ""
} |
q173547 | VarInt.writeVLong | test | public static void writeVLong(OutputStream out, long value) throws IOException {
if(value < 0) out.write((byte)0x81);
if(value > 0xFFFFFFFFFFFFFFL || value < 0) out.write((byte)(0x80 | ((value >>> 56) & 0x7FL)));
if(value > 0x1FFFFFFFFFFFFL || value < 0) out.write((byte)(0x80 | ((value >>> 49) & 0x7FL)));
if(value > 0x3FFFFFFFFFFL || value < 0) out.write((byte)(0x80 | ((value >>> 42) & 0x7FL)));
if(value > 0x7FFFFFFFFL || value < 0) out.write((byte)(0x80 | ((value >>> 35) & 0x7FL)));
if(value > 0xFFFFFFFL || value < 0) out.write((byte)(0x80 | ((value >>> 28) & 0x7FL)));
if(value > 0x1FFFFFL || value < 0) out.write((byte)(0x80 | ((value >>> 21) & 0x7FL)));
if(value > 0x3FFFL || value < 0) out.write((byte)(0x80 | ((value >>> 14) & 0x7FL)));
if(value > 0x7FL || value < 0) out.write((byte)(0x80 | ((value >>> 7) & 0x7FL)));
out.write((byte)(value & 0x7FL));
} | java | {
"resource": ""
} |
q173548 | VarInt.writeVInt | test | public static void writeVInt(OutputStream out, int value) throws IOException {
if(value > 0x0FFFFFFF || value < 0) out.write((byte)(0x80 | ((value >>> 28))));
if(value > 0x1FFFFF || value < 0) out.write((byte)(0x80 | ((value >>> 21) & 0x7F)));
if(value > 0x3FFF || value < 0) out.write((byte)(0x80 | ((value >>> 14) & 0x7F)));
if(value > 0x7F || value < 0) out.write((byte)(0x80 | ((value >>> 7) & 0x7F)));
out.write((byte)(value & 0x7F));
} | java | {
"resource": ""
} |
q173549 | VarInt.writeVInt | test | public static int writeVInt(byte data[], int pos, int value) {
if(value > 0x0FFFFFFF || value < 0) data[pos++] = ((byte)(0x80 | ((value >>> 28))));
if(value > 0x1FFFFF || value < 0) data[pos++] = ((byte)(0x80 | ((value >>> 21) & 0x7F)));
if(value > 0x3FFF || value < 0) data[pos++] = ((byte)(0x80 | ((value >>> 14) & 0x7F)));
if(value > 0x7F || value < 0) data[pos++] = ((byte)(0x80 | ((value >>> 7) & 0x7F)));
data[pos++] = (byte)(value & 0x7F);
return pos;
} | java | {
"resource": ""
} |
q173550 | VarInt.readVInt | test | public static int readVInt(InputStream in) throws IOException {
byte b = (byte)in.read();
if(b == (byte) 0x80)
throw new RuntimeException("Attempting to read null value as int");
int value = b & 0x7F;
while ((b & 0x80) != 0) {
b = (byte)in.read();
value <<= 7;
value |= (b & 0x7F);
}
return value;
} | java | {
"resource": ""
} |
q173551 | VarInt.readVLong | test | public static long readVLong(InputStream in) throws IOException {
byte b = (byte)in.read();
if(b == (byte) 0x80)
throw new RuntimeException("Attempting to read null value as long");
long value = b & 0x7F;
while ((b & 0x80) != 0) {
b = (byte)in.read();
value <<= 7;
value |= (b & 0x7F);
}
return value;
} | java | {
"resource": ""
} |
q173552 | PullToRefreshBase.addViewInternal | test | protected final void addViewInternal(View child, int index, ViewGroup.LayoutParams params) {
super.addView(child, index, params);
} | java | {
"resource": ""
} |
q173553 | PullToRefreshBase.refreshLoadingViewsSize | test | protected final void refreshLoadingViewsSize() {
final int maximumPullScroll = (int) (getMaximumPullScroll() * 1.2f);
int pLeft = getPaddingLeft();
int pTop = getPaddingTop();
int pRight = getPaddingRight();
int pBottom = getPaddingBottom();
switch (getPullToRefreshScrollDirection()) {
case HORIZONTAL:
if (mMode.showHeaderLoadingLayout()) {
mHeaderLayout.setWidth(maximumPullScroll);
pLeft = -maximumPullScroll;
} else {
pLeft = 0;
}
if (mMode.showFooterLoadingLayout()) {
mFooterLayout.setWidth(maximumPullScroll);
pRight = -maximumPullScroll;
} else {
pRight = 0;
}
break;
case VERTICAL:
if (mMode.showHeaderLoadingLayout()) {
mHeaderLayout.setHeight(maximumPullScroll);
pTop = -maximumPullScroll;
} else {
pTop = 0;
}
if (mMode.showFooterLoadingLayout()) {
mFooterLayout.setHeight(maximumPullScroll);
pBottom = -maximumPullScroll;
} else {
pBottom = 0;
}
break;
}
if (DEBUG) {
Log.d(LOG_TAG, String.format("Setting Padding. L: %d, T: %d, R: %d, B: %d", pLeft, pTop, pRight, pBottom));
}
setPadding(pLeft, pTop, pRight, pBottom);
} | java | {
"resource": ""
} |
q173554 | PullToRefreshBase.updateUIForMode | test | protected void updateUIForMode() {
// We need to use the correct LayoutParam values, based on scroll
// direction
final LinearLayout.LayoutParams lp = getLoadingLayoutLayoutParams();
// Remove Header, and then add Header Loading View again if needed
if (this == mHeaderLayout.getParent()) {
removeView(mHeaderLayout);
}
if (mMode.showHeaderLoadingLayout()) {
addViewInternal(mHeaderLayout, 0, lp);
}
// Remove Footer, and then add Footer Loading View again if needed
if (this == mFooterLayout.getParent()) {
removeView(mFooterLayout);
}
if (mMode.showFooterLoadingLayout()) {
addViewInternal(mFooterLayout, lp);
}
// Hide Loading Views
refreshLoadingViewsSize();
// If we're not using Mode.BOTH, set mCurrentMode to mMode, otherwise
// set it to pull down
mCurrentMode = (mMode != Mode.BOTH) ? mMode : Mode.PULL_FROM_START;
} | java | {
"resource": ""
} |
q173555 | PullToRefreshBase.pullEvent | test | private void pullEvent() {
final int newScrollValue;
final int itemDimension;
final float initialMotionValue, lastMotionValue;
switch (getPullToRefreshScrollDirection()) {
case HORIZONTAL:
initialMotionValue = mInitialMotionX;
lastMotionValue = mLastMotionX;
break;
case VERTICAL:
default:
initialMotionValue = mInitialMotionY;
lastMotionValue = mLastMotionY;
break;
}
switch (mCurrentMode) {
case PULL_FROM_END:
newScrollValue = Math.round(Math.max(initialMotionValue - lastMotionValue, 0) / FRICTION);
itemDimension = getFooterSize();
break;
case PULL_FROM_START:
default:
newScrollValue = Math.round(Math.min(initialMotionValue - lastMotionValue, 0) / FRICTION);
itemDimension = getHeaderSize();
break;
}
setHeaderScroll(newScrollValue);
if (newScrollValue != 0 && !isRefreshing()) {
float scale = Math.abs(newScrollValue) / (float) itemDimension;
switch (mCurrentMode) {
case PULL_FROM_END:
mFooterLayout.onPull(scale);
break;
case PULL_FROM_START:
default:
mHeaderLayout.onPull(scale);
break;
}
if (mState != State.PULL_TO_REFRESH && itemDimension >= Math.abs(newScrollValue)) {
setState(State.PULL_TO_REFRESH);
} else if (mState == State.PULL_TO_REFRESH && itemDimension < Math.abs(newScrollValue)) {
setState(State.RELEASE_TO_REFRESH);
}
}
} | java | {
"resource": ""
} |
q173556 | OverscrollHelper.overScrollBy | test | public static void overScrollBy(final PullToRefreshBase<?> view, final int deltaX, final int scrollX,
final int deltaY, final int scrollY, final int scrollRange, final int fuzzyThreshold,
final float scaleFactor, final boolean isTouchEvent) {
final int deltaValue, currentScrollValue, scrollValue;
switch (view.getPullToRefreshScrollDirection()) {
case HORIZONTAL:
deltaValue = deltaX;
scrollValue = scrollX;
currentScrollValue = view.getScrollX();
break;
case VERTICAL:
default:
deltaValue = deltaY;
scrollValue = scrollY;
currentScrollValue = view.getScrollY();
break;
}
// Check that OverScroll is enabled and that we're not currently
// refreshing.
if (view.isPullToRefreshOverScrollEnabled() && !view.isRefreshing()) {
final Mode mode = view.getMode();
// Check that Pull-to-Refresh is enabled, and the event isn't from
// touch
if (mode.permitsPullToRefresh() && !isTouchEvent && deltaValue != 0) {
final int newScrollValue = (deltaValue + scrollValue);
if (PullToRefreshBase.DEBUG) {
Log.d(LOG_TAG, "OverScroll. DeltaX: " + deltaX + ", ScrollX: " + scrollX + ", DeltaY: " + deltaY
+ ", ScrollY: " + scrollY + ", NewY: " + newScrollValue + ", ScrollRange: " + scrollRange
+ ", CurrentScroll: " + currentScrollValue);
}
if (newScrollValue < (0 - fuzzyThreshold)) {
// Check the mode supports the overscroll direction, and
// then move scroll
if (mode.showHeaderLoadingLayout()) {
// If we're currently at zero, we're about to start
// overscrolling, so change the state
if (currentScrollValue == 0) {
view.setState(State.OVERSCROLLING);
}
view.setHeaderScroll((int) (scaleFactor * (currentScrollValue + newScrollValue)));
}
} else if (newScrollValue > (scrollRange + fuzzyThreshold)) {
// Check the mode supports the overscroll direction, and
// then move scroll
if (mode.showFooterLoadingLayout()) {
// If we're currently at zero, we're about to start
// overscrolling, so change the state
if (currentScrollValue == 0) {
view.setState(State.OVERSCROLLING);
}
view.setHeaderScroll((int) (scaleFactor * (currentScrollValue + newScrollValue - scrollRange)));
}
} else if (Math.abs(newScrollValue) <= fuzzyThreshold
|| Math.abs(newScrollValue - scrollRange) <= fuzzyThreshold) {
// Means we've stopped overscrolling, so scroll back to 0
view.setState(State.RESET);
}
} else if (isTouchEvent && State.OVERSCROLLING == view.getState()) {
// This condition means that we were overscrolling from a fling,
// but the user has touched the View and is now overscrolling
// from touch instead. We need to just reset.
view.setState(State.RESET);
}
}
} | java | {
"resource": ""
} |
q173557 | GivenRuleBuilder.given | test | GivenRuleBuilder<T, U> given(String name, T value) {
return given(new Fact<T>(name, value));
} | java | {
"resource": ""
} |
q173558 | GivenRuleBuilder.given | test | @SafeVarargs
public final GivenRuleBuilder<T, U> given(NameValueReferable... facts) {
_rule.addFacts(facts);
return this;
} | java | {
"resource": ""
} |
q173559 | RuleBuilder.create | test | public static RuleBuilder<Object, Object> create(Class<? extends Rule> ruleClass,
RuleChainActionType actionType) {
return new RuleBuilder<>(ruleClass, actionType);
} | java | {
"resource": ""
} |
q173560 | RuleBuilder.create | test | public static RuleBuilder<Object, Object> create() {
RuleBuilder<Object, Object> rule = new RuleBuilder<>(GoldenRule.class);
rule._factType = Object.class;
return rule;
} | java | {
"resource": ""
} |
q173561 | RuleBuilder.withFactType | test | public <S> RuleBuilder<S, U> withFactType(Class<S> factType) {
RuleBuilder<S, U> builder = new RuleBuilder<>(_ruleClass);
builder._factType = factType;
builder._resultType = _resultType;
builder._actionType = _actionType;
return builder;
} | java | {
"resource": ""
} |
q173562 | RuleBuilder.withResultType | test | public <S> RuleBuilder<T, S> withResultType(Class<S> resultType) {
RuleBuilder<T, S> builder = new RuleBuilder<>(_ruleClass);
builder._factType = _factType;
builder._resultType = resultType;
builder._actionType = _actionType;
builder._name = _name;
return builder;
} | java | {
"resource": ""
} |
q173563 | RuleBuilder.given | test | @SuppressWarnings("unchecked")
public GivenRuleBuilder<T, U> given(String name, T value) {
Rule<T, U> rule = _name.map(ruleName -> (Rule<T, U>)new AuditableRule<T, U>(newRule(), ruleName)).orElse(newRule());
if (rule == null) {
throw new IllegalStateException("No Rule is instantiated; An invalid Rule class may have been provided");
}
return new GivenRuleBuilder<T, U>(rule, new Fact<T>(name, value));
} | java | {
"resource": ""
} |
q173564 | RuleBuilder.given | test | @SuppressWarnings("unchecked")
@SafeVarargs
public final GivenRuleBuilder<T, U> given(NameValueReferable... facts) {
Rule<T, U> rule = _name.map(name -> (Rule<T, U>)new AuditableRule<T, U>(newRule(), name)).orElse(newRule());
if (rule == null) {
throw new IllegalStateException("No Rule is instantiated; An invalid Rule class may have been provided");
}
return new GivenRuleBuilder<T, U>(rule, facts);
} | java | {
"resource": ""
} |
q173565 | RuleBuilder.then | test | @SuppressWarnings("unchecked")
public ThenRuleBuilder<T, U> then(Consumer<NameValueReferableTypeConvertibleMap<T>> action) {
Rule<T, U> rule = _name.map(name -> (Rule<T, U>)new AuditableRule<T, U>(newRule(), name)).orElse(newRule());
if (rule == null) {
throw new IllegalStateException("No Rule is instantiated; An invalid Rule class may have been provided");
}
return new ThenRuleBuilder<T, U>(rule, action);
} | java | {
"resource": ""
} |
q173566 | AbstractRuleBookRunner.getRuleInstance | test | protected Object getRuleInstance(Class<?> rule) {
try {
return rule.newInstance();
} catch (InstantiationException | IllegalAccessException ex) {
LOGGER.warn("Unable to create instance of rule using '" + rule + "'", ex);
}
return null;
} | java | {
"resource": ""
} |
q173567 | AnnotationUtils.getAnnotatedField | test | public static Optional<Field> getAnnotatedField(Class annotation, Class clazz) {
List<Field> fields = getAnnotatedFields(annotation, clazz);
return Optional.ofNullable(fields.size() > 0 ? fields.get(0) : null);
} | java | {
"resource": ""
} |
q173568 | AnnotationUtils.getAnnotatedMethod | test | public static Optional<Method> getAnnotatedMethod(Class annotation, Class clazz) {
List<Method> methods = getAnnotatedMethods(annotation, clazz);
return Optional.ofNullable(methods.size() > 0 ? methods.get(0) : null);
} | java | {
"resource": ""
} |
q173569 | AnnotationUtils.getAnnotation | test | @SuppressWarnings("unchecked")
public static <A extends Annotation> A getAnnotation(Class<A> annotation, Class<?> clazz) {
return Optional.ofNullable(clazz.getAnnotation(annotation)).orElse((A)
Arrays.stream(clazz.getDeclaredAnnotations())
.flatMap(anno -> Arrays.stream(anno.getClass().getInterfaces())
.flatMap(iface -> Arrays.stream(iface.getDeclaredAnnotations())))
.filter(annotation::isInstance)
.findFirst().orElse(null)
);
} | java | {
"resource": ""
} |
q173570 | Auditor.registerRule | test | public void registerRule(Auditable rule) {
_lock.writeLock().lock();
try {
_auditMap.put(rule.getName(), new HashMap<>());
} finally {
_lock.writeLock().unlock();
}
} | java | {
"resource": ""
} |
q173571 | Auditor.updateRuleStatus | test | public void updateRuleStatus(Auditable rule, RuleStatus status) {
_lock.readLock().lock();
try {
if (_auditMap.containsKey(rule.getName())) {
_lock.readLock().unlock();
_lock.writeLock().lock();
try {
_auditMap.get(rule.getName()).put(Thread.currentThread().getId(), status);
_lock.readLock().lock();
} finally {
_lock.writeLock().unlock();
}
}
} finally {
_lock.readLock().unlock();
}
} | java | {
"resource": ""
} |
q173572 | Auditor.getRuleStatusMap | test | public Map<String, RuleStatus> getRuleStatusMap() {
_lock.readLock().lock();
try {
return _auditMap.keySet().stream()
.collect(
Collectors.toMap(key -> key,
key -> _auditMap.get(key).getOrDefault(Thread.currentThread().getId(), RuleStatus.PENDING)));
} finally {
_lock.readLock().unlock();
}
} | java | {
"resource": ""
} |
q173573 | RuleBookBuilder.withResultType | test | public <U> RuleBookWithResultTypeBuilder<U> withResultType(Class<U> resultType) {
_resultType = resultType;
return new RuleBookWithResultTypeBuilder<U>((new RuleBookBuilder<U>(this)).newRuleBook());
} | java | {
"resource": ""
} |
q173574 | ThenRuleBuilder.then | test | public ThenRuleBuilder<T, U> then(Consumer<NameValueReferableTypeConvertibleMap<T>> action) {
_rule.addAction(action);
return this;
} | java | {
"resource": ""
} |
q173575 | ThenRuleBuilder.then | test | public ThenRuleBuilder<T, U> then(BiConsumer<NameValueReferableTypeConvertibleMap<T>, Result<U>> action) {
_rule.addAction(action);
return this;
} | java | {
"resource": ""
} |
q173576 | Result.reset | test | public void reset() {
_lock.readLock().lock();
try {
if (_defaultValue == null) {
return;
}
} finally {
_lock.readLock().unlock();
}
setValue(_defaultValue);
} | java | {
"resource": ""
} |
q173577 | RuleBookRuleBuilder.withFactType | test | @SuppressWarnings("unchecked")
public <T> RuleBookRuleWithFactTypeBuilder<T, U> withFactType(Class<T> factType) {
Rule<T, U> rule = (Rule<T, U>)RuleBuilder.create(_ruleClass).withFactType(factType).build();
_ruleBook.addRule(rule);
return new RuleBookRuleWithFactTypeBuilder<>(rule);
} | java | {
"resource": ""
} |
q173578 | RuleBookRunner.getPojoRules | test | protected List<Class<?>> getPojoRules() {
Reflections reflections = new Reflections(_package);
List<Class<?>> rules = reflections
.getTypesAnnotatedWith(com.deliveredtechnologies.rulebook.annotation.Rule.class).stream()
.filter(rule -> rule.getAnnotatedSuperclass() != null) // Include classes only, exclude interfaces, etc.
.filter(rule -> _subPkgMatch.test(rule.getPackage().getName()))
.collect(Collectors.toList());
rules.sort(comparingInt(aClass ->
getAnnotation(com.deliveredtechnologies.rulebook.annotation.Rule.class, aClass).order()));
return rules;
} | java | {
"resource": ""
} |
q173579 | AsciiDocParser.readEmptyLineOrEndTable | test | private String readEmptyLineOrEndTable(final BufferedReader tableContent) throws IOException {
final String column = tableContent.readLine();
if (column != null && column.startsWith(END_TABLE)) {
return END_TABLE;
}
if(column == null || !column.isEmpty()) {
throw new IllegalArgumentException(String.format("Trying to read an empty line for end of row, but content %s was found or EOF", column));
}
return "";
} | java | {
"resource": ""
} |
q173580 | DefaultServiceEnricher.toArray | test | private Service[] toArray(List<Service> services) {
if (services == null) {
return new Service[0];
}
if (services instanceof ArrayList) {
return ((ArrayList<Service>) services).toArray(new Service[services.size()]);
} else {
Service[] ret = new Service[services.size()];
for (int i = 0; i < services.size(); i++) {
ret[i] = services.get(i);
}
return ret;
}
} | java | {
"resource": ""
} |
q173581 | DefaultServiceEnricher.getPortsFromBuildConfiguration | test | private List<String> getPortsFromBuildConfiguration(ImageConfiguration image) {
// No build, no default service (doesn't make much sense to have no build config, though)
BuildImageConfiguration buildConfig = image.getBuildConfiguration();
if (buildConfig == null) {
return Collections.emptyList();
}
return buildConfig.getPorts();
} | java | {
"resource": ""
} |
q173582 | DefaultServiceEnricher.extractPortsFromConfig | test | private List<ServicePort> extractPortsFromConfig() {
List<ServicePort> ret = new LinkedList<>();
String ports = getConfig(Config.port);
if (ports != null) {
for (String port : StringUtils.split(ports, ",")) {
ret.add(parsePortMapping(port));
}
}
return ret;
} | java | {
"resource": ""
} |
q173583 | DefaultServiceEnricher.parsePortMapping | test | private ServicePort parsePortMapping(String port) {
Matcher matcher = PORT_MAPPING_PATTERN.matcher(port);
if (!matcher.matches()) {
log.error("Invalid 'port' configuration '%s'. Must match <port>(:<targetPort>)?,<port2>?,...", port);
throw new IllegalArgumentException("Invalid port mapping specification " + port);
}
int servicePort = Integer.parseInt(matcher.group("port"));
String optionalTargetPort = matcher.group("targetPort");
String protocol = getProtocol(matcher.group("protocol"));
ServicePortBuilder builder = new ServicePortBuilder()
.withPort(servicePort)
.withProtocol(protocol)
.withName(getDefaultPortName(servicePort, protocol));
// leave empty if not set. will be filled up with the port from the image config
if (optionalTargetPort != null) {
builder.withNewTargetPort(Integer.parseInt(optionalTargetPort));
}
return builder.build();
} | java | {
"resource": ""
} |
q173584 | DefaultServiceEnricher.addPortIfNotNull | test | private void addPortIfNotNull(List<ServicePort> ret, ServicePort port) {
if (port != null) {
ret.add(port);
}
} | java | {
"resource": ""
} |
q173585 | DefaultServiceEnricher.shiftOrNull | test | private ServicePort shiftOrNull(List<ServicePort> ports) {
if (!ports.isEmpty()) {
return ports.remove(0);
}
return null;
} | java | {
"resource": ""
} |
q173586 | DefaultServiceEnricher.addMissingServiceParts | test | private void addMissingServiceParts(ServiceBuilder service, Service defaultService) {
// If service has no spec -> take over the complete spec from default service
if (!service.hasSpec()) {
service.withNewSpecLike(defaultService.getSpec()).endSpec();
return;
}
// If service has no ports -> take over ports from default service
List<ServicePort> ports = service.buildSpec().getPorts();
if (ports == null || ports.isEmpty()) {
service.editSpec().withPorts(defaultService.getSpec().getPorts()).endSpec();
return;
}
// Complete missing parts:
service.editSpec()
.withPorts(addMissingDefaultPorts(ports, defaultService))
.endSpec();
} | java | {
"resource": ""
} |
q173587 | ImageStreamService.appendImageStreamResource | test | public void appendImageStreamResource(ImageName imageName, File target) throws MojoExecutionException {
String tag = StringUtils.isBlank(imageName.getTag()) ? "latest" : imageName.getTag();
try {
ImageStream is = new ImageStreamBuilder()
.withNewMetadata()
.withName(imageName.getSimpleName())
.endMetadata()
.withNewSpec()
.addNewTag()
.withName(tag)
.withNewFrom().withKind("ImageStreamImage").endFrom()
.endTag()
.endSpec()
.build();
createOrUpdateImageStreamTag(client, imageName, is);
appendImageStreamToFile(is, target);
log.info("ImageStream %s written to %s", imageName.getSimpleName(), target);
} catch (KubernetesClientException e) {
KubernetesResourceUtil.handleKubernetesClientException(e, this.log);
} catch (IOException e) {
throw new MojoExecutionException(String.format("Cannot write ImageStream descriptor for %s to %s : %s",
imageName.getFullName(), target.getAbsoluteFile(), e.getMessage()),e);
}
} | java | {
"resource": ""
} |
q173588 | ServiceUrlUtil.portsMatch | test | private static boolean portsMatch(ServicePort servicePort, IntOrString intOrString) {
if (intOrString != null) {
Integer port = servicePort.getPort();
Integer intVal = intOrString.getIntVal();
String strVal = intOrString.getStrVal();
if (intVal != null) {
if (port != null) {
return port.intValue() == intVal.intValue();
} else {
/// should we find the port by name now?
}
} else if (strVal != null ){
return Objects.equal(strVal, servicePort.getName());
}
}
return false;
} | java | {
"resource": ""
} |
q173589 | ServiceUrlUtil.serviceToPortOrBlank | test | private static String serviceToPortOrBlank(String serviceName) {
String envVarName = toServicePortEnvironmentVariable(serviceName);
return getEnvVarOrSystemProperty(envVarName, "");
} | java | {
"resource": ""
} |
q173590 | ServiceUrlUtil.getServiceHostAndPort | test | private static String getServiceHostAndPort(String serviceName, String defaultHost, String defaultPort) {
String serviceEnvVarPrefix = getServiceEnvVarPrefix(serviceName);
String hostEnvVar = serviceEnvVarPrefix + "_HOST";
String portEnvVar = serviceEnvVarPrefix + "_PORT";
String host = getEnvVarOrSystemProperty(hostEnvVar, hostEnvVar, defaultHost);
String port = getEnvVarOrSystemProperty(portEnvVar, portEnvVar, defaultPort);
String answer = host + ":" + port;
return answer;
} | java | {
"resource": ""
} |
q173591 | MapUtil.putIfAbsent | test | public static void putIfAbsent(Map<String, String> map, String name, String value) {
if (!map.containsKey(name)) {
map.put(name, value);
}
} | java | {
"resource": ""
} |
q173592 | MapUtil.mergeIfAbsent | test | public static void mergeIfAbsent(Map<String, String> map, Map<String, String> toMerge) {
for (Map.Entry<String, String> entry : toMerge.entrySet()) {
putIfAbsent(map, entry.getKey(), entry.getValue());;
}
} | java | {
"resource": ""
} |
q173593 | MapUtil.mergeMaps | test | public static <K,V> Map<K,V> mergeMaps(Map<K, V> map1, Map<K, V> map2) {
Map<K, V> answer = new HashMap<>();
if (map2 != null) {
answer.putAll(map2);
}
if (map1 != null) {
answer.putAll(map1);
}
return answer;
} | java | {
"resource": ""
} |
q173594 | MapUtil.putAllIfNotNull | test | public static void putAllIfNotNull(Map<String, String> ret, Map<String, String> toPut) {
if (toPut != null) {
ret.putAll(toPut);
}
} | java | {
"resource": ""
} |
q173595 | OpenshiftBuildService.waitUntilPodIsReady | test | private void waitUntilPodIsReady(String podName, int nAwaitTimeout, final Logger log) throws InterruptedException {
final CountDownLatch readyLatch = new CountDownLatch(1);
try (Watch watch = client.pods().withName(podName).watch(new Watcher<Pod>() {
@Override
public void eventReceived(Action action, Pod aPod) {
if(KubernetesHelper.isPodReady(aPod)) {
readyLatch.countDown();
}
}
@Override
public void onClose(KubernetesClientException e) {
// Ignore
}
})) {
readyLatch.await(nAwaitTimeout, TimeUnit.SECONDS);
} catch (KubernetesClientException | InterruptedException e) {
log.error("Could not watch pod", e);
}
} | java | {
"resource": ""
} |
q173596 | KubernetesHelper.validateKubernetesId | test | public static String validateKubernetesId(String currentValue, String description) throws IllegalArgumentException {
if (StringUtils.isBlank(currentValue)) {
throw new IllegalArgumentException("No " + description + " is specified!");
}
int size = currentValue.length();
for (int i = 0; i < size; i++) {
char ch = currentValue.charAt(i);
if (Character.isUpperCase(ch)) {
throw new IllegalArgumentException("Invalid upper case letter '" + ch + "' at index " + i + " for " + description + " value: " + currentValue);
}
}
return currentValue;
} | java | {
"resource": ""
} |
q173597 | KubernetesHelper.toItemList | test | @SuppressWarnings("unchecked")
public static List<HasMetadata> toItemList(Object entity) throws IOException {
if (entity instanceof List) {
return (List<HasMetadata>) entity;
} else if (entity instanceof HasMetadata[]) {
HasMetadata[] array = (HasMetadata[]) entity;
return Arrays.asList(array);
} else if (entity instanceof KubernetesList) {
KubernetesList config = (KubernetesList) entity;
return config.getItems();
} else if (entity instanceof Template) {
Template objects = (Template) entity;
return objects.getObjects();
} else {
List<HasMetadata> answer = new ArrayList<>();
if (entity instanceof HasMetadata) {
answer.add((HasMetadata) entity);
}
return answer;
}
} | java | {
"resource": ""
} |
q173598 | KubernetesHelper.getResourceVersion | test | public static String getResourceVersion(HasMetadata entity) {
if (entity != null) {
ObjectMeta metadata = entity.getMetadata();
if (metadata != null) {
String resourceVersion = metadata.getResourceVersion();
if (StringUtils.isNotBlank(resourceVersion)) {
return resourceVersion;
}
}
}
return null;
} | java | {
"resource": ""
} |
q173599 | KubernetesHelper.isPodReady | test | public static boolean isPodReady(Pod pod) {
if (!isPodRunning(pod)) {
return false;
}
PodStatus podStatus = pod.getStatus();
if (podStatus == null) {
return true;
}
List<PodCondition> conditions = podStatus.getConditions();
if (conditions == null || conditions.isEmpty()) {
return true;
}
// Check "ready" condition
for (PodCondition condition : conditions) {
if ("ready".equalsIgnoreCase(condition.getType())) {
return Boolean.parseBoolean(condition.getStatus());
}
}
return true;
} | java | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.