1 /*

     2  * Copyright (c) 2014, 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 

    26 package jdk.internal.jimage;

    27 

    28 import java.nio.charset.Charset;

    29 import java.util.Arrays;

    30 

    31 public final class UTF8String implements CharSequence {

    32 

    33     // Same as StandardCharsets.UTF_8 without loading all of the standard charsets

    34     static final Charset UTF_8 = Charset.forName("UTF-8");

    35 

    36     static final int NOT_FOUND = -1;

    37     static final int HASH_MULTIPLIER = 0x01000193;

    38     static final UTF8String EMPTY_STRING  = new UTF8String("");

    39     static final UTF8String CLASS_STRING  = new UTF8String(".class");

    40 

    41     final byte[] bytes;

    42     final int offset;

    43     final int count;

    44     int hashcode;

    45 

    46     public UTF8String(byte[] bytes, int offset, int count) {

    47         if (offset < 0 || count < 0 || (offset + count) > bytes.length) {

    48             throw new IndexOutOfBoundsException("offset/count out of range");

    49         }

    50         this.bytes = bytes;

    51         this.offset = offset;

    52         this.count = count;

    53         this.hashcode = -1;

    54     }

    55 

    56     public UTF8String(byte[] bytes, int offset) {

    57         this(bytes, offset, bytes.length - offset);

    58     }

    59 

    60     public UTF8String(byte[] bytes) {

    61         this(bytes, 0, bytes.length);

    62     }

    63 

    64     public UTF8String(String string) {

    65         this(stringToBytes(string));

    66     }

    67 

    68     @Override

    69     public int length() {

    70         return count;

    71     }

    72 

    73     public boolean isEmpty() {

    74         return count == 0;

    75     }

    76 

    77     public int byteAt(int index) {

    78         return bytes[offset + index] & 0xFF;

    79     }

    80 

    81     public UTF8String concat(UTF8String s) {

    82         int total = count + s.count;

    83         byte[] combined = new byte[total];

    84         System.arraycopy(bytes, offset, combined, 0, count);

    85         System.arraycopy(s.bytes, s.offset, combined, count, s.count);

    86 

    87         return new UTF8String(combined, 0, total);

    88     }

    89 

    90     public UTF8String concat(UTF8String... s) {

    91         int total = count;

    92 

    93         for (UTF8String i : s) {

    94             total += i.count;

    95         }

    96 

    97         byte[] combined = new byte[total];

    98         System.arraycopy(bytes, offset, combined, 0, count);

    99         int next = count;

   100 

   101         for (UTF8String i : s) {

   102             System.arraycopy(i.bytes, i.offset, combined, next, i.count);

   103             next += i.count;

   104         }

   105 

   106         return new UTF8String(combined, 0, total);

   107     }

   108 

   109     public UTF8String substring(int offset) {

   110         return substring(offset, this.count - offset);

   111     }

   112 

   113     public UTF8String substring(int offset, int count) {

   114         int newOffset = this.offset + offset;

   115         return new UTF8String(bytes, newOffset, count);

   116     }

   117 

   118     public UTF8String trimToSize() {

   119         return offset == 0 && bytes.length == count ? this :

   120                new UTF8String(Arrays.copyOfRange(bytes, offset, offset + count));

   121     }

   122 

   123     public int indexOf(int ch) {

   124         return indexOf(ch, 0);

   125     }

   126 

   127     public int indexOf(int ch, int start) {

   128         for (int i = Math.max(start, 0); i < count; i++) {

   129             if (byteAt(i) == ch) {

   130                 return i;

   131             }

   132         }

   133 

   134         return NOT_FOUND;

   135     }

   136 

   137     public int lastIndexOf(int ch) {

   138         return lastIndexOf(ch, count - 1);

   139     }

   140 

   141     public int lastIndexOf(int ch, int start) {

   142         for (int i = Math.min(start, count); i > 0; i--) {

   143             if (byteAt(i) == ch) {

   144                 return i;

   145             }

   146         }

   147 

   148         return NOT_FOUND;

   149     }

   150 

   151     void writeTo(ImageStream buffer) {

   152         buffer.put(bytes, offset, count);

   153     }

   154 

   155     static int hashCode(int seed, byte[] bytes, int offset, int count) {

   156         for (int i = offset, limit = offset + count; i < limit; i++) {

   157             seed = (seed * HASH_MULTIPLIER) ^ (bytes[i] & 0xFF);

   158         }

   159 

   160         return seed & 0x7FFFFFFF;

   161     }

   162 

   163     int hashCode(int base) {

   164         return hashCode(base, bytes, offset, count);

   165     }

   166 

   167     @Override

   168     public int hashCode() {

   169         if (hashcode < 0) {

   170             hashcode = hashCode(HASH_MULTIPLIER, bytes, offset, count);

   171         }

   172 

   173         return hashcode;

   174     }

   175 

   176     @Override

   177     public boolean equals(Object obj) {

   178         if (obj == null) {

   179             return false;

   180         }

   181 

   182         if (getClass() != obj.getClass()) {

   183             return false;

   184         }

   185 

   186         return equals(this, (UTF8String)obj);

   187     }

   188 

   189     private static boolean equals(UTF8String a, UTF8String b) {

   190         if (a == b) {

   191             return true;

   192         }

   193 

   194         int count = a.count;

   195 

   196         if (count != b.count) {

   197             return false;

   198         }

   199 

   200         byte[] aBytes = a.bytes;

   201         byte[] bBytes = b.bytes;

   202         int aOffset = a.offset;

   203         int bOffset = b.offset;

   204 

   205         for (int i = 0; i < count; i++) {

   206             if (aBytes[aOffset + i] != bBytes[bOffset + i]) {

   207                 return false;

   208             }

   209         }

   210 

   211         return true;

   212     }

   213 

   214     byte[] getBytes() {

   215         if (offset != 0 || bytes.length != count) {

   216             return Arrays.copyOfRange(bytes, offset, offset + count);

   217         }

   218 

   219         return bytes;

   220     }

   221 

   222     private static byte[] stringToBytes(String string) {

   223         return string.getBytes(UTF_8);

   224     }

   225 

   226     @Override

   227     public String toString() {

   228         return new String(bytes, offset, count, UTF_8);

   229     }

   230 

   231     @Override

   232     public char charAt(int index) {

   233         int ch = byteAt(index);

   234 

   235         return (ch & 0x80) != 0 ? (char)ch : '\0';

   236     }

   237 

   238     @Override

   239     public CharSequence subSequence(int start, int end) {

   240         return (CharSequence)substring(start, end - start);

   241     }

   242 

   243     static UTF8String match(UTF8String a, UTF8String b) {

   244         int aCount = a.count;

   245         int bCount = b.count;

   246 

   247         if (aCount < bCount) {

   248             return null;

   249         }

   250 

   251         byte[] aBytes = a.bytes;

   252         byte[] bBytes = b.bytes;

   253         int aOffset = a.offset;

   254         int bOffset = b.offset;

   255 

   256         for (int i = 0; i < bCount; i++) {

   257             if (aBytes[aOffset + i] != bBytes[bOffset + i]) {

   258                 return null;

   259             }

   260         }

   261 

   262         return new UTF8String(aBytes, aOffset + bCount, aCount - bCount);

   263     }

   264 }