Examples with SliceUtf8.getCodePointAt io.airlift.slice.SliceUtf8.getCodePointAt used on opensource projects

Example 1 with SliceUtf8.getCodePointAt

use of io.airlift.slice.SliceUtf8.getCodePointAt in project presto by prestodb.

the class StringFunctions method pad.

private static Slice pad(Slice text, long targetLength, Slice padString, int paddingOffset) {
    checkCondition(0 <= targetLength && targetLength <= Integer.MAX_VALUE, INVALID_FUNCTION_ARGUMENT, "Target length must be in the range [0.." + Integer.MAX_VALUE + "]");
    checkCondition(padString.length() > 0, INVALID_FUNCTION_ARGUMENT, "Padding string must not be empty");
    int textLength = countCodePoints(text);
    int resultLength = (int) targetLength;
    // if our target length is the same as our string then return our string
    if (textLength == resultLength) {
        return text;
    }
    // if our string is bigger than requested then truncate
    if (textLength > resultLength) {
        return SliceUtf8.substring(text, 0, resultLength);
    }
    // number of bytes in each code point
    int padStringLength = countCodePoints(padString);
    int[] padStringCounts = new int[padStringLength];
    for (int i = 0; i < padStringLength; ++i) {
        padStringCounts[i] = lengthOfCodePointSafe(padString, offsetOfCodePoint(padString, i));
    }
    // preallocate the result
    int bufferSize = text.length();
    for (int i = 0; i < resultLength - textLength; ++i) {
        bufferSize += padStringCounts[i % padStringLength];
    }
    Slice buffer = Slices.allocate(bufferSize);
    // fill in the existing string
    int countBytes = bufferSize - text.length();
    int startPointOfExistingText = (paddingOffset + countBytes) % bufferSize;
    buffer.setBytes(startPointOfExistingText, text);
    // assign the pad string while there's enough space for it
    int byteIndex = paddingOffset;
    for (int i = 0; i < countBytes / padString.length(); ++i) {
        buffer.setBytes(byteIndex, padString);
        byteIndex += padString.length();
    }
    // handle the tail: at most we assign padStringLength - 1 code points
    buffer.setBytes(byteIndex, padString.getBytes(0, paddingOffset + countBytes - byteIndex));
    return buffer;
}

Example 2 with SliceUtf8.getCodePointAt

use of io.airlift.slice.SliceUtf8.getCodePointAt in project presto by prestodb.

the class StringFunctions method fromUtf8.

@Description("decodes the UTF-8 encoded string")
@ScalarFunction
@LiteralParameters("x")
@SqlType(StandardTypes.VARCHAR)
public static Slice fromUtf8(@SqlType(StandardTypes.VARBINARY) Slice slice, @SqlType("varchar(x)") Slice replacementCharacter) {
    int count = countCodePoints(replacementCharacter);
    if (count > 1) {
        throw new PrestoException(INVALID_FUNCTION_ARGUMENT, "Replacement character string must empty or a single character");
    }
    OptionalInt replacementCodePoint;
    if (count == 1) {
        try {
            replacementCodePoint = OptionalInt.of(getCodePointAt(replacementCharacter, 0));
        } catch (InvalidUtf8Exception e) {
            throw new PrestoException(INVALID_FUNCTION_ARGUMENT, "Invalid replacement character");
        }
    } else {
        replacementCodePoint = OptionalInt.empty();
    }
    return SliceUtf8.fixInvalidUtf8(slice, replacementCodePoint);
}

Example 3 with SliceUtf8.getCodePointAt

use of io.airlift.slice.SliceUtf8.getCodePointAt in project hetu-core by openlookeng.

the class LikeFunctions method unescapeLiteralLikePattern.

public static Slice unescapeLiteralLikePattern(Slice pattern, Optional<Slice> escape) {
    if (!escape.isPresent()) {
        return pattern;
    }
    int escapeChar = getEscapeCharacter(escape).map(c -> (int) c).orElse(-1);
    @SuppressWarnings("resource") DynamicSliceOutput output = new DynamicSliceOutput(pattern.length());
    boolean escaped = false;
    int position = 0;
    while (position < pattern.length()) {
        int currentChar = getCodePointAt(pattern, position);
        int lengthOfCodePoint = lengthOfCodePoint(currentChar);
        if (!escaped && (currentChar == escapeChar)) {
            escaped = true;
        } else {
            output.writeBytes(pattern, position, lengthOfCodePoint);
            escaped = false;
        }
        position += lengthOfCodePoint;
    }
    checkEscape(!escaped);
    return output.slice();
}

Example 4 with SliceUtf8.getCodePointAt

use of io.airlift.slice.SliceUtf8.getCodePointAt in project hetu-core by openlookeng.

the class LikeFunctions method patternConstantPrefixBytes.

public static int patternConstantPrefixBytes(Slice pattern, Optional<Slice> escape) {
    int escapeChar = getEscapeCharacter(escape).map(c -> (int) c).orElse(-1);
    boolean escaped = false;
    int position = 0;
    while (position < pattern.length()) {
        int currentChar = getCodePointAt(pattern, position);
        if (!escaped && (currentChar == escapeChar)) {
            escaped = true;
        } else if (escaped) {
            checkEscape(currentChar == '%' || currentChar == '_' || currentChar == escapeChar);
            escaped = false;
        } else if ((currentChar == '%') || (currentChar == '_')) {
            return position;
        }
        position += lengthOfCodePoint(currentChar);
    }
    checkEscape(!escaped);
    return position;
}

Example 5 with SliceUtf8.getCodePointAt

use of io.airlift.slice.SliceUtf8.getCodePointAt in project urban-eureka by errir503.

the class StringFunctions method castToCodePoints.

private static int[] castToCodePoints(Slice slice) {
    int[] codePoints = new int[safeCountCodePoints(slice)];
    int position = 0;
    for (int index = 0; index < codePoints.length; index++) {
        codePoints[index] = getCodePointAt(slice, position);
        position += lengthOfCodePoint(slice, position);
    }
    return codePoints;
}