@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; }
@Override public double doubleValue() { return getInteger(); } }
@Override public double getValue(byte[] bytes, int offset) { return IntegerPointable.getInteger(bytes, offset); } };
@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; } }
@Override public int compare(byte[] b1, int s1, int l1, byte[] b2, int s2, int l2) { for (int i = 0; i < dim; i++) { a[i] = IntegerPointable.getInteger(b1, s1 + (i * l1)); b[i] = IntegerPointable.getInteger(b2, s2 + (i * l2)); } return compare(); }
@Override public boolean operateDTDurationYMDuration(LongPointable longp1, IntegerPointable intp2) throws SystemException, IOException { if (longp1.getLong() == 0 && intp2.getInteger() == 0) { return true; } return false; }
@Override public boolean operateYMDurationDTDuration(IntegerPointable intp1, LongPointable longp2) throws SystemException, IOException { if (intp1.getInteger() == 0 && longp2.getLong() == 0) { return true; } return false; }
@Override public void print(byte[] b, int s, int l, PrintStream ps) throws HyracksDataException { int d = IntegerPointable.getInteger(b, s); try { WriteValueTools.writeInt(d, ps); } catch (IOException e) { throw HyracksDataException.create(e); } }
@Override public boolean operateDurationYMDuration(XSDurationPointable durationp1, IntegerPointable intp2) throws SystemException, IOException { if (durationp1.getYearMonth() == intp2.getInteger() && durationp1.getDayTime() == 0) { return true; } return false; }
public int getNamespaceURICode(NodeTreePointable nodeTree, int nsEntryIdx) { if (!nsChunkExists()) { return -1; } if (getNamespaceEntryCount(nodeTree) <= nsEntryIdx) { throw new IndexOutOfBoundsException(nsEntryIdx + " >= " + getNamespaceEntryCount(nodeTree)); } return IntegerPointable.getInteger(bytes, getNamespaceChunkOffset(nodeTree) + NS_CHUNK_SIZE_SIZE + NS_ENTRY_SIZE * nsEntryIdx + 1); }
public int getNamespacePrefixCode(NodeTreePointable nodeTree, int nsEntryIdx) { if (!nsChunkExists()) { return -1; } if (getNamespaceEntryCount(nodeTree) <= nsEntryIdx) { throw new IndexOutOfBoundsException(nsEntryIdx + " >= " + getNamespaceEntryCount(nodeTree)); } return IntegerPointable.getInteger(bytes, getNamespaceChunkOffset(nodeTree) + NS_CHUNK_SIZE_SIZE + NS_ENTRY_SIZE * nsEntryIdx); }
@Override public int getIntegerValue(byte[] bytes, int offset, int length) { tvp.set(bytes, offset, length); assert tvp.getTag() == ValueTag.XS_INT_TAG; tvp.getValue(ip); return ip.getInteger(); } };
public void getString(int idx, IPointable string) { int nEntries = getDictionaryEntryCount(); if (idx < 0 || idx >= nEntries) { throw new IllegalArgumentException(idx + " not within [0, " + nEntries + ")"); } int dataAreaStart = getDictionaryDataAreaStartOffset(); int idxSlotValue = idx == 0 ? 0 : IntegerPointable.getInteger(bytes, getDictionaryIndexPointerArrayOffset() + (idx - 1) * IDX_PTR_SLOT_SIZE); int strLen = UTF8StringPointable.getUTFLength(bytes, dataAreaStart + idxSlotValue); string.set(bytes, dataAreaStart + idxSlotValue, strLen + 2); }
@Override public void evaluate(IFrameTupleReference tuple, IPointable result) throws HyracksDataException { eval1.evaluate(tuple, p); int v1 = IntegerPointable.getInteger(p.getByteArray(), p.getStartOffset()); eval2.evaluate(tuple, p); int v2 = IntegerPointable.getInteger(p.getByteArray(), p.getStartOffset()); BooleanPointable.setBoolean(rBytes, 0, v1 == v2); result.set(rBytes, 0, 1); } };
@Override public void operateDatetimeYMDuration(XSDateTimePointable datetimep, IntegerPointable intp, DataOutput dOut) throws SystemException, IOException { // Add duration. abvsInner1.reset(); DateTime.normalizeDateTime(datetimep.getYearMonth() - intp.getInteger(), datetimep.getDayTime(), datetimep.getTimezoneHour(), datetimep.getTimezoneMinute(), dOutInner1); dOut.write(ValueTag.XS_DATETIME_TAG); dOut.write(abvsInner1.getByteArray(), abvsInner1.getStartOffset() + 1, XSDateTimePointable.TYPE_TRAITS.getFixedLength()); }
public static long getIntervalStart(byte[] data, int start) { if (getIntervalTimeType(data, start) == ATypeTag.DATETIME.serialize()) { return LongPointable.getLong(data, getIntervalStartOffset(data, start)); } else { return IntegerPointable.getInteger(data, getIntervalStartOffset(data, start)); } }
public static long getIntervalEnd(byte[] data, int start) { if (getIntervalTimeType(data, start) == ATypeTag.DATETIME.serialize()) { return LongPointable.getLong(data, getIntervalEndOffset(data, start)); } else { return IntegerPointable.getInteger(data, getIntervalEndOffset(data, start)); } }
public long getStartValue() throws HyracksDataException { switch (getTypeTag()) { case DATE: case TIME: return IntegerPointable.getInteger(bytes, getStartOffset()); case DATETIME: return LongPointable.getLong(bytes, getStartOffset()); default: throw new HyracksDataException("Unsupported interval type: " + getTypeTag() + "."); } }
public int getItemOffset(AbstractCollectionType inputType, int index) throws HyracksDataException { if (isFixedType(inputType)) { return getItemCountOffset() + getItemCountSize() + index * getFixedLength(inputType); } else { int offset = getItemCountOffset() + getItemCountSize() + index * ITEM_OFFSET_SIZE; return start + IntegerPointable.getInteger(bytes, offset); } }
protected SequenceType getSequenceType(final ConstantExpression cTypeEx) { final VXQueryConstantValue typeCodeVal = (VXQueryConstantValue) cTypeEx.getValue(); tvp.set(typeCodeVal.getValue(), 0, typeCodeVal.getValue().length); assert tvp.getTag() == ValueTag.XS_INT_TAG; tvp.getValue(ip); int typeCode = ip.getInteger(); SequenceType type = ctx.lookupSequenceType(typeCode); return type; }