private String getStringFromBytes(byte[] bytes) { if (bytes == null) { return null; } StringBuilder sb = new StringBuilder(); UTF8StringPointable.toString(sb, bytes, 0); return sb.toString(); }
@Override public String toString() { StringBuilder sb = new StringBuilder("processing-instruction("); if (target != null) { UTF8StringPointable.toString(sb, target, 0); } return sb.append(")").toString(); }
@Override public String toString() { StringBuilder buffer = new StringBuilder(); buffer.append("NameTest({"); if (uri != null) { UTF8StringPointable.toString(buffer, uri, 0); } else { buffer.append('*'); } buffer.append('}'); if (localName != null) { UTF8StringPointable.toString(buffer, localName, 0); } else { buffer.append('*'); } return buffer.toString(); }
/** * Replaces the appearances of a regular expression defined pattern in a source string with a given * replacement string. * * @param replaceStrPtr * , the string for replacing the regular expression. * @param replaceLimit * , the maximum number of replacements to make * @return a new string with contained regular expressions replaced. */ public String replace(UTF8StringPointable replaceStrPtr, int replaceLimit) { if (replaceLimit < 0) { replaceLimit = Integer.MAX_VALUE; } // Sets up a new replacement string if necessary. final boolean newReplace = replaceStrPtr != null && (replaceStr == null || lastReplaceStrPtr.compareTo(replaceStrPtr) != 0); if (newReplace) { StringEvaluatorUtils.copyResetUTF8Pointable(replaceStrPtr, lastReplaceStorage, lastReplaceStrPtr); replaceStr = replaceStrPtr.toString(); } // Does the actual replacement. resultBuf.setLength(0); for (int i = 0; i < replaceLimit && matcher.find(); i++) { matcher.appendReplacement(resultBuf, replaceStr); } matcher.appendTail(resultBuf); return resultBuf.toString(); } }
/** * Builds the charset from a pattern string. * * @param patternPtr * , a pattern string. */ public void build(UTF8StringPointable patternPtr) { final boolean newPattern = charSet == null || lastPatternPtr.compareTo(patternPtr) != 0; if (newPattern) { StringEvaluatorUtils.copyResetUTF8Pointable(patternPtr, lastPatternStorage, lastPatternPtr); charSet = CharSet.getInstance(patternPtr.toString()); } }
stringp.toString(sb); try { valueDouble = Double.parseDouble(sb.toString());
stringp.toString(sb); try { valueFloat = Float.parseFloat(sb.toString());
/** * Parses string as double * @param textPtr input string * @param result placeholder for the result * @return {@code true} if parsing was successful, {@code false} otherwise */ public static boolean parseDouble(UTF8StringPointable textPtr, AMutableDouble result) { double v; if (POSITIVE_INF.compareTo(textPtr) == 0) { v = Double.POSITIVE_INFINITY; } else if (NEGATIVE_INF.compareTo(textPtr) == 0) { v = Double.NEGATIVE_INFINITY; } else if (NAN.compareTo(textPtr) == 0) { v = Double.NaN; } else { try { v = Double.parseDouble(textPtr.toString()); } catch (NumberFormatException e) { return false; } } result.setValue(v); return true; }
StringEvaluatorUtils.copyResetUTF8Pointable(patternPtr, lastPatternStorage, lastPatternPtr); String inputPatternString = lastPatternPtr.toString(); String patternString = patternGenerator == null ? inputPatternString : patternGenerator.toRegExpPatternString(inputPatternString); if (newFlag) { pattern = Pattern.compile(patternString, StringEvaluatorUtils.toFlag(flagPtr.toString()));
@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); } } }
UTF8StringPointable str = UTF8StringPointable.FACTORY.createPointable(); str.set(bytes, offset + 1, len - 1); return new AdmStringNode(str.toString()); default: throw new UnsupportedOperationException("Unsupported item type: " + tag);
return false; stringp.toString(toStr); docArg = toStr.toString();
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); } }
listPointable.getItemOffset(AOrderedListType.FULL_OPEN_ORDEREDLIST_TYPE, i) + 1, listPointable.getItemSize(AOrderedListType.FULL_OPEN_ORDEREDLIST_TYPE, i)); node.add(new AdmStringNode(str.toString())); break; default: