@Override public int getStart(int index) { int dataAreaStart = getDictionaryDataAreaStartOffset(); int sortedPtrArrayStart = getDictionarySortedPointerArrayOffset(); int sortedSlotValue = IntegerPointable .getInteger(bytes, sortedPtrArrayStart + index * SORTED_PTR_SLOT_SIZE); return dataAreaStart + sortedSlotValue; }
public int preIncrement() { int v = getInteger(); ++v; setInteger(v); return v; }
@Override public IntegerPointable createPointable() { return new IntegerPointable(); }
public static void setYearMonth(byte[] bytes, int start, int value) { IntegerPointable.setInteger(bytes, start + YEAR_MONTH_OFFSET, value); }
@Override public void operateYMDurationYMDuration(IntegerPointable intp, IntegerPointable intp2, DataOutput dOut) throws SystemException, IOException { if (intp2.getInteger() == 0) { throw new SystemException(ErrorCode.FOAR0001); } double value = intp.intValue(); value /= intp2.intValue(); abvsInner.reset(); doublep.set(abvsInner.getByteArray(), abvsInner.getStartOffset(), DoublePointable.TYPE_TRAITS.getFixedLength()); doublep.setDouble(value); CastToDecimalOperation castToDecmial = new CastToDecimalOperation(); castToDecmial.convertDouble(doublep, dOut); }
@Override public boolean operateYMDurationYMDuration(IntegerPointable intp1, IntegerPointable intp2) throws SystemException, IOException { return (intp1.compareTo(intp2) == -1); }
@Override public void doOpen(ICursorInitialState initialState, ISearchPredicate searchPred) throws HyracksDataException { LSMBTreeCursorInitialState lsmInitialState = (LSMBTreeCursorInitialState) initialState; cmp = lsmInitialState.getOriginalKeyComparator(); operationalComponents = lsmInitialState.getOperationalComponents(); lsmHarness = lsmInitialState.getLSMHarness(); includeMutableComponent = false; int numBTrees = operationalComponents.size(); rangeCursors = new IIndexCursor[numBTrees]; btreeAccessors = new BTreeAccessor[numBTrees]; for (int i = 0; i < numBTrees; i++) { ILSMComponent component = operationalComponents.get(i); BTree btree = (BTree) component.getIndex(); btreeAccessors[i] = btree.createAccessor(NoOpIndexAccessParameters.INSTANCE); rangeCursors[i] = btreeAccessors[i].createSearchCursor(false); } IndexCursorUtils.open(btreeAccessors, rangeCursors, searchPred); try { cursorIndexPointable = new IntegerPointable(); int length = IntegerPointable.TYPE_TRAITS.getFixedLength(); cursorIndexPointable.set(new byte[length], 0, length); setPriorityQueueComparator(); initPriorityQueue(); } catch (Throwable th) { // NOSONAR: Must call this on for (int i = 0; i < numBTrees; i++) { IndexCursorUtils.close(rangeCursors[i], th); } throw HyracksDataException.create(th); } }
public void setInteger(int value) { setInteger(bytes, start, value); }
@Override public boolean operateYMDurationYMDuration(IntegerPointable intp1, IntegerPointable intp2) throws SystemException, IOException { return (intp1.compareTo(intp2) == 0); }
@Override public double doubleValue() { return getInteger(); } }
public int postIncrement() { int v = getInteger(); int ov = v++; setInteger(v); return ov; }
public static void setFloat(byte[] bytes, int start, float value) { int bits = Float.floatToIntBits(value); IntegerPointable.setInteger(bytes, start, bits); }
@Override public int compareTo(IPointable pointer) { return compareTo(pointer.getByteArray(), pointer.getStartOffset(), pointer.getLength()); }
@Override public double getValue(byte[] bytes, int offset) { return IntegerPointable.getInteger(bytes, offset); } };
protected void buildHashMap(AbstractAsterixListIterator buildIter) throws HyracksDataException { // Build phase: Add items into hash map, starting with first list. // Value in map is a pair of integers. Set first integer to 1. IntegerPointable.setInteger(valEntry.getBuf(), 0, 1); while (buildIter.hasNext()) { byte[] buf = buildIter.getData(); int off = buildIter.getPos(); int len = buildIter.getItemLen(); keyEntry.set(buf, off, len); BinaryEntry entry = hashMap.put(keyEntry, valEntry); if (entry != null) { // Increment value. int firstValInt = IntegerPointable.getInteger(entry.getBuf(), entry.getOffset()); IntegerPointable.setInteger(entry.getBuf(), entry.getOffset(), firstValInt + 1); } buildIter.next(); } }
public void endNamespaceChunk() { byte[] bytes = mvs.getByteArray(); IntegerPointable.setInteger(bytes, nsChunkStart, nsCount); }
@Override public void normalize(byte[] bytes, int start, int length, int[] normalizedKeys, int keyStart) { int value = IntegerPointable.getInteger(bytes, start); if (value >= 0) { normalizedKeys[keyStart] = value ^ Integer.MIN_VALUE; } else { // invert the key normalizedKeys[keyStart] = ~value; } }
if (entry != null) { int firstValInt = IntegerPointable.getInteger(entry.getBuf(), entry.getOffset()); int secondValInt = IntegerPointable.getInteger(entry.getBuf(), entry.getOffset() + 4); IntegerPointable.setInteger(entry.getBuf(), entry.getOffset() + 4, secondValInt); } else {
public void write(ArrayBackedValueStorage abvs) throws IOException { DataOutput out = abvs.getDataOutput(); int sizeOffset = abvs.getLength(); out.writeInt(0); int entryCount = stringEndOffsets.getSize(); out.writeInt(entryCount); int[] entryOffsets = stringEndOffsets.getArray(); for (int i = 0; i < entryCount; ++i) { out.writeInt(entryOffsets[i]); } if (hashSlotIndexes.isEmpty()) { int[] sortedOffsets = sortedSlotIndexes.getArray(); for (int i = 0; i < entryCount; ++i) { out.writeInt(sortedOffsets[i]); } } else { for (Entry<String, Integer> me : hashSlotIndexes.entrySet()) { out.writeInt((Integer) me.getValue()); } } out.write(dataBuffer.getByteArray(), 0, dataBuffer.size()); IntegerPointable.setInteger(abvs.getByteArray(), sizeOffset, abvs.getLength() - sizeOffset); }
@Override public int hash(byte[] bytes, int offset, int length) { return IntegerPointable.getInteger(bytes, offset + 4); } };