public static UTF8StringPointable generateUTF8Pointable(String string) { byte[] bytes; bytes = UTF8StringUtil.writeStringToBytes(string); UTF8StringPointable ptr = new UTF8StringPointable(); ptr.set(bytes, 0, bytes.length); return ptr; }
protected void processArgument(int argIdx, IPointable argPtr, UTF8StringPointable outStrPtr) throws HyracksDataException { byte[] bytes = argPtr.getByteArray(); int start = argPtr.getStartOffset(); // Type check. if (bytes[start] != ATypeTag.SERIALIZED_STRING_TYPE_TAG) { throw new TypeMismatchException(sourceLoc, funcID, argIdx, bytes[start], ATypeTag.SERIALIZED_STRING_TYPE_TAG); } int len = argPtr.getLength(); outStrPtr.set(bytes, start + 1, len); }
@Override public void convertDouble(DoublePointable doublep, DataOutput dOut) throws SystemException, IOException { if (doublep.getDouble() == 0) { long bits = Double.doubleToLongBits(doublep.getDouble()); boolean negative = ((bits >> 63) == 0) ? false : true; if (negative) { throw new SystemException(ErrorCode.FORG0001); } } if (Double.isNaN(doublep.getDouble()) || Double.isInfinite(doublep.getDouble())) { throw new SystemException(ErrorCode.FORG0001); } abvsInner.reset(); dOutInner.write(ValueTag.XS_STRING_TAG); dOutInner.writeUTF(Double.toString(doublep.getDouble())); stringp.set(abvsInner.getByteArray(), abvsInner.getStartOffset() + 1, abvsInner.getLength() - 1); convertStringExtra(stringp, dOut, true); }
private void printStringAbvs(PrintStream ps) { UTF8StringPointable utf8sp = pp.takeOne(UTF8StringPointable.class); try { utf8sp.set(abvs.getByteArray(), abvs.getStartOffset() + 1, abvs.getLength() - 1); printString(ps, utf8sp); } finally { pp.giveBack(utf8sp); } }
@Override public void convertFloat(FloatPointable floatp, DataOutput dOut) throws SystemException, IOException { if (floatp.getFloat() == 0) { long bits = Float.floatToIntBits(floatp.getFloat()); boolean negative = ((bits >> 31) == 0) ? false : true; if (negative) { throw new SystemException(ErrorCode.FORG0001); } } abvsInner.reset(); castToString.convertFloatCanonical(floatp, dOutInner); stringp.set(abvsInner.getByteArray(), abvsInner.getStartOffset() + 1, abvsInner.getLength() - 1); convertStringExtra(stringp, dOut, true); }
public static UTF8StringPointable copyResetUTF8Pointable(UTF8StringPointable srcString, ByteArrayAccessibleOutputStream destCopyStorage, UTF8StringPointable destString) { destCopyStorage.reset(); destCopyStorage.write(srcString.getByteArray(), srcString.getStartOffset(), srcString.getMetaDataLength() + srcString.getUTF8Length()); destString.set(destCopyStorage.getByteArray(), 0, destCopyStorage.size()); return destString; }
@Override public void evaluate(IFrameTupleReference tuple, IPointable result) throws HyracksDataException { try { eval.evaluate(tuple, inputArg); byte[] binary = inputArg.getByteArray(); int startOffset = inputArg.getStartOffset(); int len = inputArg.getLength(); byte tt = binary[startOffset]; if (tt == ATypeTag.SERIALIZED_BINARY_TYPE_TAG) { result.set(inputArg); } else if (tt == ATypeTag.SERIALIZED_STRING_TYPE_TAG) { resultStorage.reset(); utf8Ptr.set(inputArg.getByteArray(), startOffset + 1, len - 1); char[] buffer = utf8Ptr.toString().toCharArray(); out.write(ATypeTag.BINARY.serialize()); byteArrayParser.parse(buffer, 0, buffer.length, out); result.set(resultStorage); } else { throw new TypeMismatchException(sourceLoc, BuiltinFunctions.BINARY_HEX_CONSTRUCTOR, 0, tt, ATypeTag.SERIALIZED_BINARY_TYPE_TAG, ATypeTag.SERIALIZED_STRING_TYPE_TAG); } } catch (IOException e) { throw new InvalidDataFormatException(sourceLoc, BuiltinFunctions.BINARY_HEX_CONSTRUCTOR, e, ATypeTag.SERIALIZED_BINARY_TYPE_TAG); } } }
protected void evaluateImpl(IPointable result) throws IOException { byte[] bytes = inputArg.getByteArray(); int startOffset = inputArg.getStartOffset(); byte tt = bytes[startOffset]; if (tt == ATypeTag.SERIALIZED_DOUBLE_TYPE_TAG) { result.set(inputArg); } else if (tt == ATypeTag.SERIALIZED_STRING_TYPE_TAG) { utf8Ptr.set(bytes, startOffset + 1, inputArg.getLength() - 1); if (NumberUtils.parseDouble(utf8Ptr, aDouble)) { DOUBLE_SERDE.serialize(aDouble, out); result.set(resultStorage); } else { handleUparseableString(result); } } else { throw new TypeMismatchException(sourceLoc, getIdentifier(), 0, tt, ATypeTag.SERIALIZED_STRING_TYPE_TAG); } }
protected void evaluateImpl(IPointable result) throws IOException { byte[] bytes = inputArg.getByteArray(); int startOffset = inputArg.getStartOffset(); byte tt = bytes[startOffset]; if (tt == ATypeTag.SERIALIZED_INT64_TYPE_TAG) { result.set(inputArg); } else if (tt == ATypeTag.SERIALIZED_STRING_TYPE_TAG) { utf8Ptr.set(bytes, startOffset + 1, inputArg.getLength() - 1); if (NumberUtils.parseInt64(utf8Ptr, aInt64)) { INT64_SERDE.serialize(aInt64, out); result.set(resultStorage); } else { handleUnparseableString(result); } } else { throw new TypeMismatchException(sourceLoc, getIdentifier(), 0, tt, ATypeTag.SERIALIZED_STRING_TYPE_TAG); } }
@Override public void evaluate(IFrameTupleReference tuple, IPointable resultPointable) throws HyracksDataException { resultStorage.reset(); argEval.evaluate(tuple, argPtr); byte[] argBytes = argPtr.getByteArray(); int offset = argPtr.getStartOffset(); byte inputTypeTag = argBytes[offset]; if (inputTypeTag != ATypeTag.SERIALIZED_STRING_TYPE_TAG) { throw new TypeMismatchException(sourceLoc, funcID, 0, argBytes[offset], ATypeTag.SERIALIZED_STRING_TYPE_TAG); } stringPtr.set(argBytes, offset + 1, argPtr.getLength() - 1); resultArray.reset(); try { process(stringPtr, resultPointable); writeResult(resultPointable); } catch (IOException e) { throw HyracksDataException.create(e); } }
str.set(bytes, offset + 1, len - 1); return new AdmStringNode(str.toString()); default:
@Test public void runTest() throws Exception { try (KVTestReader cbreader = new KVTestReader(0, "TestBucket", new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 }, 150, 0, 0, 0)) { final UTF8StringPointable pointable = new UTF8StringPointable(); final DCPMessageToRecordConverter converter = new DCPMessageToRecordConverter(); while (cbreader.hasNext()) { final IRawRecord<DCPRequest> dcp = cbreader.next(); final RecordWithMetadataAndPK<char[]> record = converter.convert(dcp); if (record.getRecord().size() == 0) { pointable.set(record.getMetadata(0).getByteArray(), 1, record.getMetadata(0).getLength()); } else { pointable.set(record.getMetadata(0).getByteArray(), 1, record.getMetadata(0).getLength()); } } } catch (final Throwable th) { System.err.println("TEST FAILED"); th.printStackTrace(); throw th; } System.err.println("TEST PASSED."); } }
private static IAdmNode getOpenField(ARecordPointable recPointable, ARecordType type, int i) throws IOException { byte tagByte = recPointable.getOpenFieldTag(type, i); ATypeTag tag = ATypeTag.VALUE_TYPE_MAPPING[tagByte]; switch (tag) { case ARRAY: return getOpenFieldAsArray(recPointable, type, i); case BIGINT: return new AdmBigIntNode(LongPointable.getLong(recPointable.getByteArray(), recPointable.getOpenFieldValueOffset(type, i) + 1)); case BOOLEAN: return AdmBooleanNode.get(BooleanPointable.getBoolean(recPointable.getByteArray(), recPointable.getOpenFieldValueOffset(type, i) + 1)); case DOUBLE: return new AdmDoubleNode(DoublePointable.getDouble(recPointable.getByteArray(), recPointable.getOpenFieldValueOffset(type, i) + 1)); case NULL: return AdmNullNode.INSTANCE; case OBJECT: return getOpenFieldAsObject(recPointable, type, i); case STRING: UTF8StringPointable str = UTF8StringPointable.FACTORY.createPointable(); str.set(recPointable.getByteArray(), recPointable.getOpenFieldValueOffset(type, i) + 1, recPointable.getOpenFieldValueSize(type, i) - 1); return new AdmStringNode(str.toString()); default: throw new UnsupportedOperationException("Unsupported item type: " + tag); } }
case STRING: UTF8StringPointable str = UTF8StringPointable.FACTORY.createPointable(); str.set(listPointable.getByteArray(), listPointable.getItemOffset(AOrderedListType.FULL_OPEN_ORDEREDLIST_TYPE, i) + 1, listPointable.getItemSize(AOrderedListType.FULL_OPEN_ORDEREDLIST_TYPE, i));
stringp.set(abvsInner.getByteArray(), abvsInner.getStartOffset() + 1, abvsInner.getLength() - 1); } catch (IOException e) {
ATypeTag.SERIALIZED_STRING_TYPE_TAG); utf8Ptr.set(stringPtr.getByteArray(), stringPtr.getStartOffset() + 1, stringPtr.getLength()); int strLen = utf8Ptr.getStringLength();