{"action":"created","comment":{"url":"https://api.github.com/repos/airlift/slice/pulls/comments/29386880","id":29386880,"diff_hunk":"@@ -0,0 +1,810 @@\n+/*\n+ * Licensed under the Apache License, Version 2.0 (the \"License\");\n+ * you may not use this file except in compliance with the License.\n+ * You may obtain a copy of the License at\n+ *\n+ *     http://www.apache.org/licenses/LICENSE-2.0\n+ *\n+ * Unless required by applicable law or agreed to in writing, software\n+ * distributed under the License is distributed on an \"AS IS\" BASIS,\n+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n+ * See the License for the specific language governing permissions and\n+ * limitations under the License.\n+ */\n+package io.airlift.slice;\n+\n+import static io.airlift.slice.Preconditions.checkArgument;\n+import static io.airlift.slice.Preconditions.checkPositionIndex;\n+import static io.airlift.slice.Preconditions.checkPositionIndexes;\n+import static java.lang.Character.MAX_CODE_POINT;\n+import static java.lang.Integer.toHexString;\n+\n+/**\n+ * Utility methods for UTF-8 encoded slices.\n+ */\n+public final class SliceUtf8\n+{\n+    private static final int REPLACEMENT_CODE_POINT = 0xFFFD;\n+\n+    private SliceUtf8() {}\n+\n+    private static final int TOP_MASK32 = 0x80808080;\n+    private static final long TOP_MASK64 = 0x8080808080808080L;\n+\n+    private static final int[] LOWER_CODE_POINTS;\n+    private static final int[] UPPER_CODE_POINTS;\n+    private static final boolean[] WHITESPACE_CODE_POINTS;\n+\n+    static {\n+        LOWER_CODE_POINTS = new int[MAX_CODE_POINT];\n+        UPPER_CODE_POINTS = new int[MAX_CODE_POINT];\n+        WHITESPACE_CODE_POINTS = new boolean[MAX_CODE_POINT];\n+        for (int codePoint = 0; codePoint < MAX_CODE_POINT; codePoint++) {\n+            int type = Character.getType(codePoint);\n+            if (type != Character.UNASSIGNED && type != Character.SURROGATE) {\n+                LOWER_CODE_POINTS[codePoint] = Character.toLowerCase(codePoint);\n+                UPPER_CODE_POINTS[codePoint] = Character.toUpperCase(codePoint);\n+                WHITESPACE_CODE_POINTS[codePoint] = Character.isWhitespace(codePoint);\n+            }\n+            else {\n+                LOWER_CODE_POINTS[codePoint] = 0xFFFD;\n+                UPPER_CODE_POINTS[codePoint] = 0xFFFD;\n+                WHITESPACE_CODE_POINTS[codePoint] = false;\n+            }\n+        }\n+    }\n+\n+    /**\n+     * Does the slice contain only 7-bit ASCII characters.\n+     */\n+    public static boolean isAscii(Slice utf8)\n+    {\n+        int length = utf8.length();\n+        int offset = 0;\n+\n+        // Length rounded to 8 bytes\n+        int length8 = length & 0x7FFFFFF8;\n+        for (; offset < length8; offset += 8) {\n+            if ((utf8.getLongUnchecked(offset) & TOP_MASK64) != 0) {\n+                return false;\n+            }\n+        }\n+        // Enough bytes left for 32 bits?\n+        if (offset + 4 < length) {\n+            if ((utf8.getIntUnchecked(offset) & TOP_MASK32) != 0) {\n+                return false;\n+            }\n+\n+            offset += 4;\n+        }\n+        // Do the rest one by one\n+        for (; offset < length; offset++) {\n+            if ((utf8.getByteUnchecked(offset) & 0x80) != 0) {\n+                return false;\n+            }\n+        }\n+\n+        return true;\n+    }\n+\n+    /**\n+     * Counts the code points within UTF-8 encoded slice.\n+     * </p>\n+     * Note: This method does not explicitly check for valid UTF-8, and may\n+     * return incorrect results or throw an exception for invalid UTF-8.\n+     */\n+    public static int countCodePoints(Slice utf8)\n+    {\n+        return countCodePoints(utf8, 0, utf8.length());\n+    }\n+\n+    /**\n+     * Counts the code points within UTF-8 encoded slice up to {@code length}.\n+     * </p>\n+     * Note: This method does not explicitly check for valid UTF-8, and may\n+     * return incorrect results or throw an exception for invalid UTF-8.\n+     */\n+    public static int countCodePoints(Slice utf8, int offset, int length)\n+    {\n+        checkPositionIndexes(offset, offset + length, utf8.length());\n+\n+        // Quick exit if empty string\n+        if (length == 0) {\n+            return 0;\n+        }\n+\n+        int continuationBytesCount = 0;\n+        // Length rounded to 8 bytes\n+        int length8 = length & 0x7FFFFFF8;\n+        for (; offset < length8; offset += 8) {\n+            // Count bytes which are NOT the start of a code point\n+            continuationBytesCount += countContinuationBytes(utf8.getLongUnchecked(offset));\n+        }\n+        // Enough bytes left for 32 bits?\n+        if (offset + 4 < length) {\n+            // Count bytes which are NOT the start of a code point\n+            continuationBytesCount += countContinuationBytes(utf8.getIntUnchecked(offset));\n+\n+            offset += 4;\n+        }\n+        // Do the rest one by one\n+        for (; offset < length; offset++) {\n+            // Count bytes which are NOT the start of a code point\n+            continuationBytesCount += countContinuationBytes(utf8.getByteUnchecked(offset));\n+        }\n+\n+        assert continuationBytesCount <= length;\n+        return length - continuationBytesCount;\n+    }\n+\n+    /**\n+     * Gets the substring starting at {@code codePointStart} and extending for\n+     * {@code codePointLength} code points.\n+     * </p>\n+     * Note: This method does not explicitly check for valid UTF-8, and may\n+     * return incorrect results or throw an exception for invalid UTF-8.\n+     */\n+    public static Slice substring(Slice utf8, int codePointStart, int codePointLength)\n+    {\n+        checkArgument(codePointStart >= 0, \"codePointStart is negative\");\n+        checkArgument(codePointLength >= 0, \"codePointLength is negative\");\n+\n+        int indexStart = offsetOfCodePoint(utf8, codePointStart);\n+        if (indexStart < 0) {\n+            throw new IllegalArgumentException(\"UTF-8 does not contain \" + codePointStart + \" code points\");\n+        }\n+        if (codePointLength == 0) {\n+            return Slices.EMPTY_SLICE;\n+        }\n+        int indexEnd = offsetOfCodePoint(utf8, indexStart, codePointLength - 1);\n+        if (indexEnd < 0) {\n+            throw new IllegalArgumentException(\"UTF-8 does not contain \" + (codePointStart + codePointLength) + \" code points\");\n+        }\n+        indexEnd += lengthOfCodePoint(utf8, indexEnd);\n+        if (indexEnd > utf8.length()) {\n+            throw new InvalidUtf8Exception(\"UTF-8 is not well formed\");\n+        }\n+        return utf8.slice(indexStart, indexEnd - indexStart);\n+    }\n+\n+    /**\n+     * Reverses the slice code point by code point.\n+     * </p>\n+     * Note: This method does not explicitly check for valid UTF-8, and may\n+     * return incorrect results or throw an exception for invalid UTF-8.\n+     */\n+    public static Slice reverse(Slice utf8)\n+    {\n+        int length = utf8.length();\n+        Slice reverse = Slices.allocate(length);\n+\n+        int forwardPosition = 0;\n+        int reversePosition = length;\n+        while (forwardPosition < length) {\n+            int codePointLength = lengthOfCodePointFromStartByte(utf8.getByteUnchecked(forwardPosition));\n+\n+            // backup the reverse pointer\n+            reversePosition -= codePointLength;\n+            if (reversePosition < 0) {\n+                throw new InvalidUtf8Exception(\"UTF-8 is not well formed\");\n+            }\n+            // copy the character\n+            switch (codePointLength) {\n+                case 1:\n+                    reverse.setByteUnchecked(reversePosition, utf8.getByteUnchecked(forwardPosition));\n+                    break;\n+                case 2:\n+                    reverse.setShortUnchecked(reversePosition, utf8.getShortUnchecked(forwardPosition));\n+                    break;\n+                case 3:\n+                    reverse.setByteUnchecked(reversePosition, utf8.getByteUnchecked(forwardPosition));\n+                    reverse.setShortUnchecked(reversePosition + 1, utf8.getShortUnchecked(forwardPosition + 1));\n+                    break;\n+                case 4:\n+                    reverse.setIntUnchecked(reversePosition, utf8.getIntUnchecked(forwardPosition));\n+                    break;\n+                default:\n+                    throw new IllegalStateException(\"Invalid code point length \" + codePointLength);\n+            }\n+\n+            forwardPosition += codePointLength;\n+        }\n+        return reverse;\n+    }\n+\n+    /**\n+     * Converts slice to upper case code point by code point.  This method does\n+     * not perform perform locale-sensitive, context-sensitive, or one-to-many\n+     * mappings required for some languages.  Specifically, this will return\n+     * incorrect results for Lithuanian, Turkish, and Azeri.\n+     * </p>\n+     * Note: This method does not explicitly check for valid UTF-8, and may\n+     * return incorrect results or throw an exception for invalid UTF-8.\n+     */\n+    public static Slice toUpperCase(Slice utf8)\n+    {\n+        int length = utf8.length();\n+        Slice upperUtf8 = Slices.allocate(length);\n+\n+        int position = 0;\n+        int upperPosition = 0;\n+        while (position < length) {\n+            int codePoint = getCodePointAt(utf8, position);\n+            int upperCodePoint = UPPER_CODE_POINTS[codePoint];\n+\n+            // grow slice if necessary\n+            int nextUpperPosition = upperPosition + lengthOfCodePoint(upperCodePoint);\n+            if (nextUpperPosition > length) {\n+                upperUtf8 = Slices.ensureSize(upperUtf8, nextUpperPosition);\n+            }\n+\n+            // write new byte\n+            setCodePointAt(upperCodePoint, upperUtf8, upperPosition);\n+\n+            position += lengthOfCodePoint(codePoint);\n+            upperPosition = nextUpperPosition;\n+        }\n+        return upperUtf8.slice(0, upperPosition);\n+    }\n+\n+    /**\n+     * Converts slice to lower case code point by code point.  This method does\n+     * not perform perform locale-sensitive, context-sensitive, or one-to-many\n+     * mappings required for some languages.  Specifically, this will return\n+     * incorrect results for Lithuanian, Turkish, and Azeri.\n+     * </p>\n+     * Note: This method does not explicitly check for valid UTF-8, and may\n+     * return incorrect results or throw an exception for invalid UTF-8.\n+     */\n+    public static Slice toLowerCase(Slice utf8)\n+    {\n+        int length = utf8.length();\n+        Slice lowerUtf8 = Slices.allocate(length);\n+\n+        int position = 0;\n+        int lowerPosition = 0;\n+        while (position < length) {\n+            int codePoint = getCodePointAt(utf8, position);\n+            int lowerCodePoint = LOWER_CODE_POINTS[codePoint];\n+\n+            // grow slice if necessary\n+            int nextLowerPosition = lowerPosition + lengthOfCodePoint(lowerCodePoint);\n+            if (nextLowerPosition > length) {\n+                lowerUtf8 = Slices.ensureSize(lowerUtf8, nextLowerPosition);\n+            }\n+\n+            // write new byte\n+            setCodePointAt(lowerCodePoint, lowerUtf8, lowerPosition);\n+\n+            position += lengthOfCodePoint(codePoint);\n+            lowerPosition = nextLowerPosition;\n+        }\n+        return lowerUtf8.slice(0, lowerPosition);\n+    }\n+\n+    /**\n+     * Removes all white space characters from the left string of the string.\n+     * </p>\n+     * Note: This method does not explicitly check for valid UTF-8, and may\n+     * return incorrect results or throw an exception for invalid UTF-8.\n+     */\n+    public static Slice leftTrim(Slice utf8)\n+    {\n+        int length = utf8.length();\n+\n+        int position = firstNonWhitespacePosition(utf8);\n+        return utf8.slice(position, length - position);\n+    }\n+\n+    private static int firstNonWhitespacePosition(Slice utf8)\n+    {\n+        int length = utf8.length();\n+\n+        int position = 0;\n+        while (position < length) {\n+            int codePoint = getCodePointAt(utf8, position);\n+            if (!WHITESPACE_CODE_POINTS[codePoint]) {\n+                break;\n+            }\n+            position += lengthOfCodePoint(codePoint);\n+        }\n+        return position;\n+    }\n+\n+    /**\n+     * Removes all white space characters from the right side of the string.\n+     * </p>\n+     * Note: This method does not explicitly check for valid UTF-8, and may\n+     * return incorrect results or throw an exception for invalid UTF-8.\n+     */\n+    public static Slice rightTrim(Slice utf8)\n+    {\n+        int position = lastNonWhitespacePosition(utf8, 0);\n+        return utf8.slice(0, position);\n+    }\n+\n+    private static int lastNonWhitespacePosition(Slice utf8, int minPosition)\n+    {\n+        int length = utf8.length();\n+\n+        int position = length;\n+        while (minPosition < position) {\n+            int codePoint = getCodePointBefore(utf8, position);\n+            if (!WHITESPACE_CODE_POINTS[codePoint]) {\n+                break;\n+            }\n+            position -= lengthOfCodePoint(codePoint);\n+        }\n+        return position;\n+    }\n+\n+    /**\n+     * Removes all white space characters from the left and right side of the string.\n+     * </p>\n+     * Note: This method does not explicitly check for valid UTF-8, and may\n+     * return incorrect results or throw an exception for invalid UTF-8.\n+     */\n+    public static Slice trim(Slice utf8)\n+    {\n+        int start = firstNonWhitespacePosition(utf8);\n+        int end = lastNonWhitespacePosition(utf8, start);\n+        return utf8.slice(start, end - start);\n+    }\n+\n+    public static Slice fixInvalidUtf8(Slice slice)\n+    {\n+        return fixInvalidUtf8(slice, REPLACEMENT_CODE_POINT);\n+    }\n+\n+    public static Slice fixInvalidUtf8(Slice slice, int replacementCodePoint)\n+    {\n+        if (isAscii(slice)) {\n+            return slice;\n+        }\n+\n+        int replacementCodePointLength = lengthOfCodePoint(replacementCodePoint);\n+\n+        int length = slice.length();\n+        Slice utf8 = Slices.allocate(length);\n+\n+        int dataPosition = 0;\n+        int utf8Position = 0;\n+        while (dataPosition < length) {\n+            int codePoint = getCodePointAtSafe(slice, dataPosition);\n+            int codePointLength;\n+            if (codePoint >= 0) {\n+                codePointLength = lengthOfCodePoint(codePoint);\n+                dataPosition += codePointLength;\n+            }\n+            else {\n+                // negative number carries the number of invalid bytes\n+                dataPosition += (-codePoint);\n+                codePoint = replacementCodePoint;\n+                codePointLength = replacementCodePointLength;\n+            }\n+            utf8 = Slices.ensureSize(utf8, utf8Position + codePointLength);\n+            utf8Position += setCodePointAt(codePoint, utf8, utf8Position);\n+        }\n+        return utf8.slice(0, utf8Position);\n+    }\n+\n+    private static int getCodePointAtSafe(Slice utf8, int position)\n+    {\n+        byte firstByte = utf8.getByte(position);\n+\n+        int length = lengthOfCodePointFromStartByteSafe(firstByte);\n+        if (length < 0) {\n+            return length;\n+        }\n+\n+        // Are there enough bytes left for this code point?\n+        if (position + length > utf8.length()) {\n+            return -(utf8.length() - position);\n+        }\n+\n+        if (length == 1) {\n+            // normal ASCII\n+            // 0xxx_xxxx\n+            return firstByte;\n+        }\n+\n+        byte secondByte = utf8.getByte(position + 1);\n+        if (!isContinuationByte(secondByte)) {\n+            return -1;\n+        }\n+\n+        if (length == 2) {\n+            // 110x_xxxx 10xx_xxxx\n+            return ((firstByte & 0b0001_1111) << 6) |\n+                    (secondByte & 0b0011_1111);\n+        }\n+\n+        byte thirdByte = utf8.getByteUnchecked(position + 2);\n+        if (!isContinuationByte(thirdByte)) {\n+            return -2;\n+        }\n+\n+        if (length == 3) {\n+            // 1110_xxxx 10xx_xxxx 10xx_xxxx\n+            return ((firstByte & 0b0000_1111) << 12) |\n+                    ((secondByte & 0b0011_1111) << 6) |\n+                    (thirdByte & 0b0011_1111);\n+        }\n+\n+        byte forthByte = utf8.getByteUnchecked(position + 3);\n+        if (!isContinuationByte(forthByte)) {\n+            return -3;\n+        }\n+\n+        if (length == 4) {\n+            // 1111_0xxx 10xx_xxxx 10xx_xxxx 10xx_xxxx\n+            int codePoint = ((firstByte & 0b0000_0111) << 18) |\n+                    ((secondByte & 0b0011_1111) << 12) |\n+                    ((thirdByte & 0b0011_1111) << 6) |\n+                    (forthByte & 0b0011_1111);\n+            // 4 byte code points have a limited valid range\n+            if (codePoint < 0x11_0000) {\n+                return codePoint;\n+            }\n+            return -4;\n+        }\n+\n+        byte fifthByte = utf8.getByteUnchecked(position + 4);\n+        if (!isContinuationByte(fifthByte)) {\n+            return -4;\n+        }\n+\n+        if (length == 5) {\n+            // According to RFC3629 limited to 4 bytes so 5 and 6 bytes are illegal\n+            return -5;\n+        }\n+\n+        byte sixthByte = utf8.getByteUnchecked(position + 5);\n+        if (!isContinuationByte(sixthByte)) {\n+            return -5;\n+        }\n+\n+        if (length == 6) {\n+            // According to RFC3629 limited to 4 bytes so 5 and 6 bytes are illegal\n+            return -6;\n+        }\n+\n+        // for longer sequence\n+        return -1;\n+    }\n+\n+    static int lengthOfCodePointFromStartByteSafe(byte startByte)\n+    {\n+        int unsignedStartByte = startByte & 0xFF;\n+        if (unsignedStartByte < 0b1000_0000) {\n+            // normal ASCII\n+            // 0xxx_xxxx\n+            return 1;\n+        }\n+        if (unsignedStartByte < 0b1100_0000) {\n+            // illegal bytes\n+            // 10xx_xxxx\n+            return -1;\n+        }\n+        if (unsignedStartByte < 0b1110_0000) {\n+            // 110x_xxxx 10xx_xxxx\n+            return 2;\n+        }\n+        if (unsignedStartByte < 0b1111_0000) {\n+            // 1110_xxxx 10xx_xxxx 10xx_xxxx\n+            return 3;\n+        }\n+        if (unsignedStartByte < 0b1111_1000) {\n+            // 1111_0xxx 10xx_xxxx 10xx_xxxx 10xx_xxxx\n+            return 4;\n+        }\n+        if (unsignedStartByte < 0b1111_1100) {\n+            // 1111_10xx 10xx_xxxx 10xx_xxxx 10xx_xxxx 10xx_xxxx\n+            return 5;\n+        }\n+        if (unsignedStartByte < 0b1111_1110) {\n+            // 1111_110x 10xx_xxxx 10xx_xxxx 10xx_xxxx 10xx_xxxx 10xx_xxxx\n+            return 6;\n+        }\n+        return -1;\n+    }\n+\n+    /**\n+     * Finds the index of the first byte of the code point at a position, or\n+     * {@code -1} if the position is not withing the slice.\n+     * </p>\n+     * Note: This method does not explicitly check for valid UTF-8, and may\n+     * return incorrect results or throw an exception for invalid UTF-8.\n+     */\n+    public static int offsetOfCodePoint(Slice utf8, int codePointPosition)\n+    {\n+        return offsetOfCodePoint(utf8, 0, codePointPosition);\n+    }\n+\n+    /**\n+     * Finds the index of the first byte of the code point at a position, or\n+     * {@code -1} if the position is not withing the slice.","path":"src/main/java/io/airlift/slice/SliceUtf8.java","position":526,"original_position":526,"commit_id":"de87a8867f3d34ae9b39dad95482b6a5f98bcac7","original_commit_id":"de87a8867f3d34ae9b39dad95482b6a5f98bcac7","user":{"login":"haozhun","id":2020503,"avatar_url":"https://avatars.githubusercontent.com/u/2020503?v=3","gravatar_id":"","url":"https://api.github.com/users/haozhun","html_url":"https://github.com/haozhun","followers_url":"https://api.github.com/users/haozhun/followers","following_url":"https://api.github.com/users/haozhun/following{/other_user}","gists_url":"https://api.github.com/users/haozhun/gists{/gist_id}","starred_url":"https://api.github.com/users/haozhun/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/haozhun/subscriptions","organizations_url":"https://api.github.com/users/haozhun/orgs","repos_url":"https://api.github.com/users/haozhun/repos","events_url":"https://api.github.com/users/haozhun/events{/privacy}","received_events_url":"https://api.github.com/users/haozhun/received_events","type":"User","site_admin":false},"body":"This function turns code point position into byte offset? It is hard to understand what this function does by reading the name or the javadoc.","created_at":"2015-04-29T22:13:43Z","updated_at":"2015-04-29T22:13:43Z","html_url":"https://github.com/airlift/slice/pull/38#discussion_r29386880","pull_request_url":"https://api.github.com/repos/airlift/slice/pulls/38","_links":{"self":{"href":"https://api.github.com/repos/airlift/slice/pulls/comments/29386880"},"html":{"href":"https://github.com/airlift/slice/pull/38#discussion_r29386880"},"pull_request":{"href":"https://api.github.com/repos/airlift/slice/pulls/38"}}},"pull_request":{"url":"https://api.github.com/repos/airlift/slice/pulls/38","id":34133896,"html_url":"https://github.com/airlift/slice/pull/38","diff_url":"https://github.com/airlift/slice/pull/38.diff","patch_url":"https://github.com/airlift/slice/pull/38.patch","issue_url":"https://api.github.com/repos/airlift/slice/issues/38","number":38,"state":"open","locked":false,"title":"Add utility methods for UTF-8 encoded Slices","user":{"login":"dain","id":58298,"avatar_url":"https://avatars.githubusercontent.com/u/58298?v=3","gravatar_id":"","url":"https://api.github.com/users/dain","html_url":"https://github.com/dain","followers_url":"https://api.github.com/users/dain/followers","following_url":"https://api.github.com/users/dain/following{/other_user}","gists_url":"https://api.github.com/users/dain/gists{/gist_id}","starred_url":"https://api.github.com/users/dain/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/dain/subscriptions","organizations_url":"https://api.github.com/users/dain/orgs","repos_url":"https://api.github.com/users/dain/repos","events_url":"https://api.github.com/users/dain/events{/privacy}","received_events_url":"https://api.github.com/users/dain/received_events","type":"User","site_admin":false},"body":"Benchmark results\r\n```\r\ni.a.s.SliceUtf8Benchmark.benchmarkCountCodePoints                     true        2   avgt         5        5.264        0.483    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkCountCodePoints                     true        5   avgt         5        4.922        0.407    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkCountCodePoints                     true       10   avgt         5        6.629        0.263    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkCountCodePoints                     true      100   avgt         5       32.332        0.891    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkCountCodePoints                     true     1000   avgt         5      217.946       17.012    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkCountCodePoints                     true    10000   avgt         5     2167.985       81.910    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkCountCodePoints                    false        2   avgt         5        4.338        0.217    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkCountCodePoints                    false        5   avgt         5       11.658        0.364    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkCountCodePoints                    false       10   avgt         5       16.457        0.921    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkCountCodePoints                    false      100   avgt         5       92.792        4.184    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkCountCodePoints                    false     1000   avgt         5      803.745       11.548    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkCountCodePoints                    false    10000   avgt         5     8355.725      433.531    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkLeftTrim                            true        2   avgt         5       20.901       10.740    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkLeftTrim                            true        5   avgt         5       33.384       21.220    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkLeftTrim                            true       10   avgt         5       61.011       23.851    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkLeftTrim                            true      100   avgt         5      427.053       17.286    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkLeftTrim                            true     1000   avgt         5     4158.446      424.360    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkLeftTrim                            true    10000   avgt         5    42400.839    10942.289    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkLeftTrim                           false        2   avgt         5       41.403       27.100    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkLeftTrim                           false        5   avgt         5       56.880       24.005    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkLeftTrim                           false       10   avgt         5      103.239       34.702    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkLeftTrim                           false      100   avgt         5      710.831       20.477    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkLeftTrim                           false     1000   avgt         5     7122.720      358.856    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkLeftTrim                           false    10000   avgt         5   101649.618     3738.675    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkLengthOfCodePointFromStartByte      true        2   avgt         5        5.327        0.296    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkLengthOfCodePointFromStartByte      true        5   avgt         5       10.930        0.320    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkLengthOfCodePointFromStartByte      true       10   avgt         5       20.225        0.840    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkLengthOfCodePointFromStartByte      true      100   avgt         5      187.906       64.800    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkLengthOfCodePointFromStartByte      true     1000   avgt         5     1598.730       26.842    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkLengthOfCodePointFromStartByte      true    10000   avgt         5    15742.387      853.695    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkLengthOfCodePointFromStartByte     false        2   avgt         5        8.434        0.358    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkLengthOfCodePointFromStartByte     false        5   avgt         5       18.323        1.291    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkLengthOfCodePointFromStartByte     false       10   avgt         5       34.781        2.343    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkLengthOfCodePointFromStartByte     false      100   avgt         5      360.887       19.849    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkLengthOfCodePointFromStartByte     false     1000   avgt         5     3138.388       76.290    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkLengthOfCodePointFromStartByte     false    10000   avgt         5    50879.856     2758.392    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkOffsetByCodePoints                  true        2   avgt         5        7.860        0.379    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkOffsetByCodePoints                  true        5   avgt         5        7.801        0.454    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkOffsetByCodePoints                  true       10   avgt         5        9.631        0.157    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkOffsetByCodePoints                  true      100   avgt         5       33.787        1.311    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkOffsetByCodePoints                  true     1000   avgt         5      231.924        4.757    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkOffsetByCodePoints                  true    10000   avgt         5     2094.478       32.523    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkOffsetByCodePoints                 false        2   avgt         5       15.203        0.745    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkOffsetByCodePoints                 false        5   avgt         5       27.458        1.881    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkOffsetByCodePoints                 false       10   avgt         5       40.367       10.629    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkOffsetByCodePoints                 false      100   avgt         5      107.515        5.352    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkOffsetByCodePoints                 false     1000   avgt         5      847.706      147.243    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkOffsetByCodePoints                 false    10000   avgt         5     7714.655      561.249    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkReverse                             true        2   avgt         5       27.706       14.324    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkReverse                             true        5   avgt         5       39.282       24.624    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkReverse                             true       10   avgt         5       61.571       34.689    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkReverse                             true      100   avgt         5      348.024       31.436    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkReverse                             true     1000   avgt         5     3320.644      317.888    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkReverse                             true    10000   avgt         5    47145.389     7162.010    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkReverse                            false        2   avgt         5       28.251       14.266    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkReverse                            false        5   avgt         5       47.905       22.201    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkReverse                            false       10   avgt         5       70.392       49.835    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkReverse                            false      100   avgt         5      565.449      299.421    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkReverse                            false     1000   avgt         5     5343.788     2555.660    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkReverse                            false    10000   avgt         5    67555.599    14676.626    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkRightTrim                           true        2   avgt         5       13.274        6.028    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkRightTrim                           true        5   avgt         5       22.778       10.008    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkRightTrim                           true       10   avgt         5       32.094       27.510    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkRightTrim                           true      100   avgt         5      213.380        9.532    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkRightTrim                           true     1000   avgt         5     1894.472       98.399    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkRightTrim                           true    10000   avgt         5    20227.306     1015.801    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkRightTrim                          false        2   avgt         5       35.952       23.220    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkRightTrim                          false        5   avgt         5       58.451       19.854    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkRightTrim                          false       10   avgt         5       58.859       27.906    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkRightTrim                          false      100   avgt         5      767.062       63.887    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkRightTrim                          false     1000   avgt         5     7184.909      291.870    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkRightTrim                          false    10000   avgt         5    86720.593     6585.779    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkSubstring                           true        2   avgt         5       16.644        7.514    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkSubstring                           true        5   avgt         5       24.660       10.987    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkSubstring                           true       10   avgt         5       31.801       22.176    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkSubstring                           true      100   avgt         5       61.838       23.996    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkSubstring                           true     1000   avgt         5      299.220       17.071    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkSubstring                           true    10000   avgt         5     2590.615       86.662    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkSubstring                          false        2   avgt         5       17.025        4.429    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkSubstring                          false        5   avgt         5       44.734       24.780    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkSubstring                          false       10   avgt         5       85.637       22.671    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkSubstring                          false      100   avgt         5      187.405       19.694    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkSubstring                          false     1000   avgt         5      984.944       79.446    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkSubstring                          false    10000   avgt         5     9099.247      592.327    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkToLowerCase                         true        2   avgt         5       36.988       19.571    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkToLowerCase                         true        5   avgt         5       69.404       47.251    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkToLowerCase                         true       10   avgt         5      100.714       10.001    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkToLowerCase                         true      100   avgt         5      771.862       54.309    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkToLowerCase                         true     1000   avgt         5     9208.320      863.557    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkToLowerCase                         true    10000   avgt         5    73833.935     5782.127    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkToLowerCase                        false        2   avgt         5       68.258        6.927    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkToLowerCase                        false        5   avgt         5      127.339        4.060    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkToLowerCase                        false       10   avgt         5      251.350       11.612    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkToLowerCase                        false      100   avgt         5     2373.579       98.422    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkToLowerCase                        false     1000   avgt         5    23098.647      764.618    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkToLowerCase                        false    10000   avgt         5   238104.430    13268.704    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkToUpperCase                         true        2   avgt         5       37.856       23.958    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkToUpperCase                         true        5   avgt         5       67.245       54.394    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkToUpperCase                         true       10   avgt         5      103.224       54.001    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkToUpperCase                         true      100   avgt         5      713.009       63.180    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkToUpperCase                         true     1000   avgt         5     8735.651     1226.680    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkToUpperCase                         true    10000   avgt         5    71755.313     3992.698    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkToUpperCase                        false        2   avgt         5       76.162       41.506    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkToUpperCase                        false        5   avgt         5      157.197       42.894    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkToUpperCase                        false       10   avgt         5      275.479       25.238    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkToUpperCase                        false      100   avgt         5     2296.063      159.783    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkToUpperCase                        false     1000   avgt         5    23477.471     2041.813    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkToUpperCase                        false    10000   avgt         5   237794.031    13939.784    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkTrim                                true        2   avgt         5       15.228        1.139    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkTrim                                true        5   avgt         5       26.319        1.538    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkTrim                                true       10   avgt         5       45.508        1.747    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkTrim                                true      100   avgt         5      416.759       16.930    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkTrim                                true     1000   avgt         5     3811.637      253.413    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkTrim                                true    10000   avgt         5    39724.417    13021.642    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkTrim                               false        2   avgt         5       21.034        0.652    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkTrim                               false        5   avgt         5       40.319        2.198    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkTrim                               false       10   avgt         5       72.650        3.365    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkTrim                               false      100   avgt         5      606.472       56.464    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkTrim                               false     1000   avgt         5     6318.165      278.271    ns/op\r\ni.a.s.SliceUtf8Benchmark.benchmarkTrim                               false    10000   avgt         5   104226.421     6254.750    ns/op\r\n```","created_at":"2015-04-27T01:14:03Z","updated_at":"2015-04-29T22:13:43Z","closed_at":null,"merged_at":null,"merge_commit_sha":"3891d54e7e73ca55cef888820c38602c1fde31b3","assignee":null,"milestone":null,"commits_url":"https://api.github.com/repos/airlift/slice/pulls/38/commits","review_comments_url":"https://api.github.com/repos/airlift/slice/pulls/38/comments","review_comment_url":"https://api.github.com/repos/airlift/slice/pulls/comments{/number}","comments_url":"https://api.github.com/repos/airlift/slice/issues/38/comments","statuses_url":"https://api.github.com/repos/airlift/slice/statuses/de87a8867f3d34ae9b39dad95482b6a5f98bcac7","head":{"label":"dain:utf-8","ref":"utf-8","sha":"de87a8867f3d34ae9b39dad95482b6a5f98bcac7","user":{"login":"dain","id":58298,"avatar_url":"https://avatars.githubusercontent.com/u/58298?v=3","gravatar_id":"","url":"https://api.github.com/users/dain","html_url":"https://github.com/dain","followers_url":"https://api.github.com/users/dain/followers","following_url":"https://api.github.com/users/dain/following{/other_user}","gists_url":"https://api.github.com/users/dain/gists{/gist_id}","starred_url":"https://api.github.com/users/dain/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/dain/subscriptions","organizations_url":"https://api.github.com/users/dain/orgs","repos_url":"https://api.github.com/users/dain/repos","events_url":"https://api.github.com/users/dain/events{/privacy}","received_events_url":"https://api.github.com/users/dain/received_events","type":"User","site_admin":false},"repo":{"id":10683434,"name":"slice","full_name":"dain/slice","owner":{"login":"dain","id":58298,"avatar_url":"https://avatars.githubusercontent.com/u/58298?v=3","gravatar_id":"","url":"https://api.github.com/users/dain","html_url":"https://github.com/dain","followers_url":"https://api.github.com/users/dain/followers","following_url":"https://api.github.com/users/dain/following{/other_user}","gists_url":"https://api.github.com/users/dain/gists{/gist_id}","starred_url":"https://api.github.com/users/dain/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/dain/subscriptions","organizations_url":"https://api.github.com/users/dain/orgs","repos_url":"https://api.github.com/users/dain/repos","events_url":"https://api.github.com/users/dain/events{/privacy}","received_events_url":"https://api.github.com/users/dain/received_events","type":"User","site_admin":false},"private":false,"html_url":"https://github.com/dain/slice","description":"Java library for efficiently working with heap and off-heap memory","fork":true,"url":"https://api.github.com/repos/dain/slice","forks_url":"https://api.github.com/repos/dain/slice/forks","keys_url":"https://api.github.com/repos/dain/slice/keys{/key_id}","collaborators_url":"https://api.github.com/repos/dain/slice/collaborators{/collaborator}","teams_url":"https://api.github.com/repos/dain/slice/teams","hooks_url":"https://api.github.com/repos/dain/slice/hooks","issue_events_url":"https://api.github.com/repos/dain/slice/issues/events{/number}","events_url":"https://api.github.com/repos/dain/slice/events","assignees_url":"https://api.github.com/repos/dain/slice/assignees{/user}","branches_url":"https://api.github.com/repos/dain/slice/branches{/branch}","tags_url":"https://api.github.com/repos/dain/slice/tags","blobs_url":"https://api.github.com/repos/dain/slice/git/blobs{/sha}","git_tags_url":"https://api.github.com/repos/dain/slice/git/tags{/sha}","git_refs_url":"https://api.github.com/repos/dain/slice/git/refs{/sha}","trees_url":"https://api.github.com/repos/dain/slice/git/trees{/sha}","statuses_url":"https://api.github.com/repos/dain/slice/statuses/{sha}","languages_url":"https://api.github.com/repos/dain/slice/languages","stargazers_url":"https://api.github.com/repos/dain/slice/stargazers","contributors_url":"https://api.github.com/repos/dain/slice/contributors","subscribers_url":"https://api.github.com/repos/dain/slice/subscribers","subscription_url":"https://api.github.com/repos/dain/slice/subscription","commits_url":"https://api.github.com/repos/dain/slice/commits{/sha}","git_commits_url":"https://api.github.com/repos/dain/slice/git/commits{/sha}","comments_url":"https://api.github.com/repos/dain/slice/comments{/number}","issue_comment_url":"https://api.github.com/repos/dain/slice/issues/comments{/number}","contents_url":"https://api.github.com/repos/dain/slice/contents/{+path}","compare_url":"https://api.github.com/repos/dain/slice/compare/{base}...{head}","merges_url":"https://api.github.com/repos/dain/slice/merges","archive_url":"https://api.github.com/repos/dain/slice/{archive_format}{/ref}","downloads_url":"https://api.github.com/repos/dain/slice/downloads","issues_url":"https://api.github.com/repos/dain/slice/issues{/number}","pulls_url":"https://api.github.com/repos/dain/slice/pulls{/number}","milestones_url":"https://api.github.com/repos/dain/slice/milestones{/number}","notifications_url":"https://api.github.com/repos/dain/slice/notifications{?since,all,participating}","labels_url":"https://api.github.com/repos/dain/slice/labels{/name}","releases_url":"https://api.github.com/repos/dain/slice/releases{/id}","created_at":"2013-06-14T06:46:59Z","updated_at":"2015-04-15T04:31:47Z","pushed_at":"2015-04-27T05:56:35Z","git_url":"git://github.com/dain/slice.git","ssh_url":"git@github.com:dain/slice.git","clone_url":"https://github.com/dain/slice.git","svn_url":"https://github.com/dain/slice","homepage":null,"size":449,"stargazers_count":0,"watchers_count":0,"language":"Java","has_issues":false,"has_downloads":true,"has_wiki":true,"has_pages":false,"forks_count":0,"mirror_url":null,"open_issues_count":0,"forks":0,"open_issues":0,"watchers":0,"default_branch":"master"}},"base":{"label":"airlift:master","ref":"master","sha":"b0cde361d11d6e12477d85faaf50e74cbadd4a5e","user":{"login":"airlift","id":1855389,"avatar_url":"https://avatars.githubusercontent.com/u/1855389?v=3","gravatar_id":"","url":"https://api.github.com/users/airlift","html_url":"https://github.com/airlift","followers_url":"https://api.github.com/users/airlift/followers","following_url":"https://api.github.com/users/airlift/following{/other_user}","gists_url":"https://api.github.com/users/airlift/gists{/gist_id}","starred_url":"https://api.github.com/users/airlift/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/airlift/subscriptions","organizations_url":"https://api.github.com/users/airlift/orgs","repos_url":"https://api.github.com/users/airlift/repos","events_url":"https://api.github.com/users/airlift/events{/privacy}","received_events_url":"https://api.github.com/users/airlift/received_events","type":"Organization","site_admin":false},"repo":{"id":9155612,"name":"slice","full_name":"airlift/slice","owner":{"login":"airlift","id":1855389,"avatar_url":"https://avatars.githubusercontent.com/u/1855389?v=3","gravatar_id":"","url":"https://api.github.com/users/airlift","html_url":"https://github.com/airlift","followers_url":"https://api.github.com/users/airlift/followers","following_url":"https://api.github.com/users/airlift/following{/other_user}","gists_url":"https://api.github.com/users/airlift/gists{/gist_id}","starred_url":"https://api.github.com/users/airlift/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/airlift/subscriptions","organizations_url":"https://api.github.com/users/airlift/orgs","repos_url":"https://api.github.com/users/airlift/repos","events_url":"https://api.github.com/users/airlift/events{/privacy}","received_events_url":"https://api.github.com/users/airlift/received_events","type":"Organization","site_admin":false},"private":false,"html_url":"https://github.com/airlift/slice","description":"Java library for efficiently working with heap and off-heap memory","fork":false,"url":"https://api.github.com/repos/airlift/slice","forks_url":"https://api.github.com/repos/airlift/slice/forks","keys_url":"https://api.github.com/repos/airlift/slice/keys{/key_id}","collaborators_url":"https://api.github.com/repos/airlift/slice/collaborators{/collaborator}","teams_url":"https://api.github.com/repos/airlift/slice/teams","hooks_url":"https://api.github.com/repos/airlift/slice/hooks","issue_events_url":"https://api.github.com/repos/airlift/slice/issues/events{/number}","events_url":"https://api.github.com/repos/airlift/slice/events","assignees_url":"https://api.github.com/repos/airlift/slice/assignees{/user}","branches_url":"https://api.github.com/repos/airlift/slice/branches{/branch}","tags_url":"https://api.github.com/repos/airlift/slice/tags","blobs_url":"https://api.github.com/repos/airlift/slice/git/blobs{/sha}","git_tags_url":"https://api.github.com/repos/airlift/slice/git/tags{/sha}","git_refs_url":"https://api.github.com/repos/airlift/slice/git/refs{/sha}","trees_url":"https://api.github.com/repos/airlift/slice/git/trees{/sha}","statuses_url":"https://api.github.com/repos/airlift/slice/statuses/{sha}","languages_url":"https://api.github.com/repos/airlift/slice/languages","stargazers_url":"https://api.github.com/repos/airlift/slice/stargazers","contributors_url":"https://api.github.com/repos/airlift/slice/contributors","subscribers_url":"https://api.github.com/repos/airlift/slice/subscribers","subscription_url":"https://api.github.com/repos/airlift/slice/subscription","commits_url":"https://api.github.com/repos/airlift/slice/commits{/sha}","git_commits_url":"https://api.github.com/repos/airlift/slice/git/commits{/sha}","comments_url":"https://api.github.com/repos/airlift/slice/comments{/number}","issue_comment_url":"https://api.github.com/repos/airlift/slice/issues/comments{/number}","contents_url":"https://api.github.com/repos/airlift/slice/contents/{+path}","compare_url":"https://api.github.com/repos/airlift/slice/compare/{base}...{head}","merges_url":"https://api.github.com/repos/airlift/slice/merges","archive_url":"https://api.github.com/repos/airlift/slice/{archive_format}{/ref}","downloads_url":"https://api.github.com/repos/airlift/slice/downloads","issues_url":"https://api.github.com/repos/airlift/slice/issues{/number}","pulls_url":"https://api.github.com/repos/airlift/slice/pulls{/number}","milestones_url":"https://api.github.com/repos/airlift/slice/milestones{/number}","notifications_url":"https://api.github.com/repos/airlift/slice/notifications{?since,all,participating}","labels_url":"https://api.github.com/repos/airlift/slice/labels{/name}","releases_url":"https://api.github.com/repos/airlift/slice/releases{/id}","created_at":"2013-04-01T20:39:10Z","updated_at":"2015-04-23T03:06:20Z","pushed_at":"2015-04-27T05:56:36Z","git_url":"git://github.com/airlift/slice.git","ssh_url":"git@github.com:airlift/slice.git","clone_url":"https://github.com/airlift/slice.git","svn_url":"https://github.com/airlift/slice","homepage":null,"size":821,"stargazers_count":128,"watchers_count":128,"language":"Java","has_issues":true,"has_downloads":true,"has_wiki":true,"has_pages":false,"forks_count":26,"mirror_url":null,"open_issues_count":3,"forks":26,"open_issues":3,"watchers":128,"default_branch":"master"}},"_links":{"self":{"href":"https://api.github.com/repos/airlift/slice/pulls/38"},"html":{"href":"https://github.com/airlift/slice/pull/38"},"issue":{"href":"https://api.github.com/repos/airlift/slice/issues/38"},"comments":{"href":"https://api.github.com/repos/airlift/slice/issues/38/comments"},"review_comments":{"href":"https://api.github.com/repos/airlift/slice/pulls/38/comments"},"review_comment":{"href":"https://api.github.com/repos/airlift/slice/pulls/comments{/number}"},"commits":{"href":"https://api.github.com/repos/airlift/slice/pulls/38/commits"},"statuses":{"href":"https://api.github.com/repos/airlift/slice/statuses/de87a8867f3d34ae9b39dad95482b6a5f98bcac7"}}}}