1/*
2 * Copyright (c) 2016, 2017, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.  Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26package java.lang;
27
28/**
29 * A helper class to get access to package-private members
30 */
31public class Helper {
32    @jdk.internal.vm.annotation.ForceInline
33    public static boolean StringCodingHasNegatives(byte[] ba, int off, int len) {
34        return StringCoding.hasNegatives(ba, off, len);
35    }
36
37    @jdk.internal.vm.annotation.ForceInline
38    public static byte[] compressByte(byte[] src, int srcOff, int dstSize, int dstOff, int len) {
39        byte[] dst = new byte[dstSize];
40        StringUTF16.compress(src, srcOff, dst, dstOff, len);
41        return dst;
42    }
43
44    @jdk.internal.vm.annotation.ForceInline
45    public static byte[] compressChar(char[] src, int srcOff, int dstSize, int dstOff, int len) {
46        byte[] dst = new byte[dstSize];
47        StringUTF16.compress(src, srcOff, dst, dstOff, len);
48        return dst;
49    }
50
51    @jdk.internal.vm.annotation.ForceInline
52    public static byte[] inflateByte(byte[] src, int srcOff, int dstSize, int dstOff, int len) {
53        byte[] dst = new byte[dstSize];
54        StringLatin1.inflate(src, srcOff, dst, dstOff, len);
55        return dst;
56    }
57
58    @jdk.internal.vm.annotation.ForceInline
59    public static char[] inflateChar(byte[] src, int srcOff, int dstSize, int dstOff, int len) {
60        char[] dst = new char[dstSize];
61        StringLatin1.inflate(src, srcOff, dst, dstOff, len);
62        return dst;
63    }
64
65    @jdk.internal.vm.annotation.ForceInline
66    public static byte[] toBytes(char[] value, int off, int len) {
67        return StringUTF16.toBytes(value, off, len);
68    }
69
70    @jdk.internal.vm.annotation.ForceInline
71    public static char[] getChars(byte[] value, int srcBegin, int srcEnd, int dstSize, int dstBegin) {
72        char[] dst = new char[dstSize];
73        StringUTF16.getChars(value, srcBegin, srcEnd, dst, dstBegin);
74        return dst;
75    }
76
77    public static void putCharSB(byte[] val, int index, int c) {
78        StringUTF16.putCharSB(val, index, c);
79    }
80
81    public static void putCharsSB(byte[] val, int index, char[] ca, int off, int end) {
82        StringUTF16.putCharsSB(val, index, ca, off, end);
83    }
84
85    public static void putCharsSB(byte[] val, int index, CharSequence s, int off, int end) {
86        StringUTF16.putCharsSB(val, index, s, off, end);
87    }
88
89    public static int codePointAtSB(byte[] val, int index, int end) {
90        return StringUTF16.codePointAtSB(val, index, end);
91    }
92
93    public static int codePointBeforeSB(byte[] val, int index) {
94        return StringUTF16.codePointBeforeSB(val, index);
95    }
96
97    public static int codePointCountSB(byte[] val, int beginIndex, int endIndex) {
98        return StringUTF16.codePointCountSB(val, beginIndex, endIndex);
99    }
100
101    public static int getChars(int i, int begin, int end, byte[] value) {
102        return StringUTF16.getChars(i, begin, end, value);
103    }
104
105    public static int getChars(long l, int begin, int end, byte[] value) {
106        return StringUTF16.getChars(l, begin, end, value);
107    }
108
109    public static boolean contentEquals(byte[] v1, byte[] v2, int len) {
110        return StringUTF16.contentEquals(v1, v2, len);
111    }
112
113    public static boolean contentEquals(byte[] value, CharSequence cs, int len) {
114        return StringUTF16.contentEquals(value, cs, len);
115    }
116
117    public static int putCharsAt(byte[] value, int i, char c1, char c2, char c3, char c4) {
118        return StringUTF16.putCharsAt(value, i, c1, c2, c3, c4);
119    }
120
121    public static int putCharsAt(byte[] value, int i, char c1, char c2, char c3, char c4, char c5) {
122        return StringUTF16.putCharsAt(value, i, c1, c2, c3, c4, c5);
123    }
124
125    public static char charAt(byte[] value, int index) {
126        return StringUTF16.charAt(value, index);
127    }
128
129    public static void reverse(byte[] value, int count) {
130        StringUTF16.reverse(value, count);
131    }
132
133    public static void inflate(byte[] src, int srcOff, byte[] dst, int dstOff, int len) {
134        StringUTF16.inflate(src, srcOff, dst, dstOff, len);
135    }
136
137    public static int indexOf(byte[] src, int srcCount,
138                                    byte[] tgt, int tgtCount, int fromIndex) {
139        return StringUTF16.indexOf(src, srcCount, tgt, tgtCount, fromIndex);
140    }
141
142    public static int indexOfLatin1(byte[] src, int srcCount,
143                                    byte[] tgt, int tgtCount, int fromIndex) {
144        return StringUTF16.indexOfLatin1(src, srcCount, tgt, tgtCount, fromIndex);
145    }
146    public static int lastIndexOf(byte[] src, byte[] tgt, int tgtCount, int fromIndex) {
147        int srcCount = StringUTF16.length(src); // ignored
148        return StringUTF16.lastIndexOf(src, srcCount, tgt, tgtCount, fromIndex);
149    }
150
151    public static int lastIndexOfLatin1(byte[] src, byte[] tgt, int tgtCount, int fromIndex) {
152        int srcCount = StringUTF16.length(src); // ignored
153        return StringUTF16.lastIndexOfLatin1(src, srcCount, tgt, tgtCount, fromIndex);
154    }
155
156}
157