S283 Planetary Science &n…he Search for Life DVD 2/DVD-ROM.iso/install/jre1_3/lib/rt.jar/java/lang/String.class

Java Class File | 1979-12-31 | 9.2 KB | 777 lines

package java.lang;

import java.io.CharConversionException;
import java.io.ObjectStreamField;
import java.io.Serializable;
import java.io.UnsupportedEncodingException;
import java.lang.ref.SoftReference;
import java.util.Comparator;
import java.util.Locale;
import sun.io.ByteToCharConverter;
import sun.io.CharToByteConverter;

public final class String implements Serializable, Comparable {
   private char[] value;
   private int offset;
   private int count;
   private int hash;
   private static ThreadLocal btcConverter = null;
   private static ThreadLocal ctbConverter = null;
   private static final long serialVersionUID = -6849794470754667710L;
   private static final ObjectStreamField[] serialPersistentFields = new ObjectStreamField[0];
   public static final Comparator CASE_INSENSITIVE_ORDER = new CaseInsensitiveComparator((1)null);

   private static ByteToCharConverter getBTCConverter(String var0) throws UnsupportedEncodingException {
      Object var1 = null;
      if (btcConverter == null) {
         btcConverter = new ThreadLocal();
      }

      SoftReference var2 = (SoftReference)btcConverter.get();
      ByteToCharConverter var3;
      if (var2 != null && (var3 = (ByteToCharConverter)var2.get()) != null && var0.equals(var3.getCharacterEncoding())) {
         var3.reset();
      } else {
         var3 = ByteToCharConverter.getConverter(var0);
         btcConverter.set(new SoftReference(var3));
      }

      return var3;
   }

   private static CharToByteConverter getCTBConverter(String var0) throws UnsupportedEncodingException {
      Object var1 = null;
      if (ctbConverter == null) {
         ctbConverter = new ThreadLocal();
      }

      SoftReference var2 = (SoftReference)ctbConverter.get();
      CharToByteConverter var3;
      if (var2 != null && (var3 = (CharToByteConverter)var2.get()) != null && var0.equals(var3.getCharacterEncoding())) {
         var3.reset();
      } else {
         var3 = CharToByteConverter.getConverter(var0);
         ctbConverter.set(new SoftReference(var3));
      }

      return var3;
   }

   public String() {
      this.hash = 0;
      this.value = new char[0];
   }

   public String(String var1) {
      this.hash = 0;
      this.count = var1.length();
      this.value = new char[this.count];
      var1.getChars(0, this.count, this.value, 0);
   }

   public String(char[] var1) {
      this.hash = 0;
      this.count = var1.length;
      this.value = new char[this.count];
      System.arraycopy(var1, 0, this.value, 0, this.count);
   }

   public String(char[] var1, int var2, int var3) {
      this.hash = 0;
      if (var2 < 0) {
         throw new StringIndexOutOfBoundsException(var2);
      } else if (var3 < 0) {
         throw new StringIndexOutOfBoundsException(var3);
      } else if (var2 > var1.length - var3) {
         throw new StringIndexOutOfBoundsException(var2 + var3);
      } else {
         this.value = new char[var3];
         this.count = var3;
         System.arraycopy(var1, var2, this.value, 0, var3);
      }
   }

   public String(byte[] var1, int var2, int var3, int var4) {
      this.hash = 0;
      if (var3 < 0) {
         throw new StringIndexOutOfBoundsException(var3);
      } else if (var4 < 0) {
         throw new StringIndexOutOfBoundsException(var4);
      } else if (var3 > var1.length - var4) {
         throw new StringIndexOutOfBoundsException(var3 + var4);
      } else {
         char[] var5 = new char[var4];
         this.count = var4;
         this.value = var5;
         if (var2 == 0) {
            for(int var6 = var4; var6-- > 0; var5[var6] = (char)(var1[var6 + var3] & 255)) {
            }
         } else {
            var2 <<= 8;

            for(int var8 = var4; var8-- > 0; var5[var8] = (char)(var2 | var1[var8 + var3] & 255)) {
            }
         }

      }
   }

   public String(byte[] var1, int var2) {
      this(var1, var2, 0, var1.length);
   }

   private String(byte[] var1, int var2, int var3, ByteToCharConverter var4) {
      this.hash = 0;
      if (var3 < 0) {
         throw new StringIndexOutOfBoundsException("length must be >= 0");
      } else if (var2 < 0) {
         throw new StringIndexOutOfBoundsException("offset must be >= 0");
      } else if (var2 > var1.length - var3) {
         throw new StringIndexOutOfBoundsException(var2 + this.count);
      } else {
         int var5 = var4.getMaxCharsPerByte() * var3;
         this.value = new char[var5];

         try {
            this.count = var4.convert(var1, var2, var2 + var3, this.value, 0, var5);
            this.count += var4.flush(this.value, var4.nextCharIndex(), var5);
         } catch (CharConversionException var7) {
            this.count = var4.nextCharIndex();
         }

         if (this.count < var5) {
            char[] var6 = new char[this.count];
            System.arraycopy(this.value, 0, var6, 0, this.count);
            this.value = var6;
         }

      }
   }

   public String(byte[] var1, int var2, int var3, String var4) throws UnsupportedEncodingException {
      this(var1, var2, var3, getBTCConverter(var4));
   }

   public String(byte[] var1, String var2) throws UnsupportedEncodingException {
      this(var1, 0, var1.length, (String)var2);
   }

   public String(byte[] var1, int var2, int var3) {
      this(var1, var2, var3, ByteToCharConverter.getDefault());
   }

   public String(byte[] var1) {
      this(var1, 0, var1.length, (ByteToCharConverter)ByteToCharConverter.getDefault());
   }

   public String(StringBuffer var1) {
      this.hash = 0;
      synchronized(var1) {
         var1.setShared();
         this.value = var1.getValue();
         this.offset = 0;
         this.count = var1.length();
      }
   }

   private String(int var1, int var2, char[] var3) {
      this.hash = 0;
      this.value = var3;
      this.offset = var1;
      this.count = var2;
   }

   public int length() {
      return this.count;
   }

   public char charAt(int var1) {
      if (var1 >= 0 && var1 < this.count) {
         return this.value[var1 + this.offset];
      } else {
         throw new StringIndexOutOfBoundsException(var1);
      }
   }

   public void getChars(int var1, int var2, char[] var3, int var4) {
      if (var1 < 0) {
         throw new StringIndexOutOfBoundsException(var1);
      } else if (var2 > this.count) {
         throw new StringIndexOutOfBoundsException(var2);
      } else if (var1 > var2) {
         throw new StringIndexOutOfBoundsException(var2 - var1);
      } else {
         System.arraycopy(this.value, this.offset + var1, var3, var4, var2 - var1);
      }
   }

   public void getBytes(int var1, int var2, byte[] var3, int var4) {
      if (var1 < 0) {
         throw new StringIndexOutOfBoundsException(var1);
      } else if (var2 > this.count) {
         throw new StringIndexOutOfBoundsException(var2);
      } else if (var1 > var2) {
         throw new StringIndexOutOfBoundsException(var2 - var1);
      } else {
         int var5 = var4;
         int var6 = this.offset + var2;
         int var7 = this.offset + var1;

         for(char[] var8 = this.value; var7 < var6; var3[var5++] = (byte)var8[var7++]) {
         }

      }
   }

   private byte[] getBytes(CharToByteConverter var1) {
      var1.reset();
      int var2 = var1.getMaxBytesPerChar() * this.count;
      byte[] var3 = new byte[var2];
      int var4 = 0;

      try {
         var4 += var1.convertAny(this.value, this.offset, this.offset + this.count, var3, 0, var2);
         var4 += var1.flushAny(var3, var1.nextByteIndex(), var2);
      } catch (CharConversionException var6) {
         throw new InternalError("Converter malfunction: " + var1.getClass().getName());
      }

      if (var4 < var2) {
         byte[] var5 = new byte[var4];
         System.arraycopy(var3, 0, var5, 0, var4);
         return var5;
      } else {
         return var3;
      }
   }

   public byte[] getBytes(String var1) throws UnsupportedEncodingException {
      return this.getBytes(getCTBConverter(var1));
   }

   public byte[] getBytes() {
      return this.getBytes(CharToByteConverter.getDefault());
   }

   public boolean equals(Object var1) {
      if (this == var1) {
         return true;
      } else {
         if (var1 instanceof String) {
            String var2 = (String)var1;
            int var3 = this.count;
            if (var3 == var2.count) {
               char[] var4 = this.value;
               char[] var5 = var2.value;
               int var6 = this.offset;
               int var7 = var2.offset;

               while(var3-- != 0) {
                  if (var4[var6++] != var5[var7++]) {
                     return false;
                  }
               }

               return true;
            }
         }

         return false;
      }
   }

   public boolean equalsIgnoreCase(String var1) {
      return var1 != null && var1.count == this.count && this.regionMatches(true, 0, var1, 0, this.count);
   }

   public int compareTo(String var1) {
      int var2 = this.count;
      int var3 = var1.count;
      int var4 = Math.min(var2, var3);
      char[] var5 = this.value;
      char[] var6 = var1.value;
      int var7 = this.offset;
      int var8 = var1.offset;

      while(var4-- != 0) {
         char var9 = var5[var7++];
         char var10 = var6[var8++];
         if (var9 != var10) {
            return var9 - var10;
         }
      }

      return var2 - var3;
   }

   public int compareTo(Object var1) {
      return this.compareTo((String)var1);
   }

   public int compareToIgnoreCase(String var1) {
      return CASE_INSENSITIVE_ORDER.compare(this, var1);
   }

   public boolean regionMatches(int var1, String var2, int var3, int var4) {
      char[] var5 = this.value;
      int var6 = this.offset + var1;
      int var10000 = this.offset + this.count;
      char[] var8 = var2.value;
      int var9 = var2.offset + var3;
      if (var3 >= 0 && var1 >= 0 && (long)var1 <= (long)this.count - (long)var4 && (long)var3 <= (long)var2.count - (long)var4) {
         while(var4-- > 0) {
            if (var5[var6++] != var8[var9++]) {
               return false;
            }
         }

         return true;
      } else {
         return false;
      }
   }

   public boolean regionMatches(boolean var1, int var2, String var3, int var4, int var5) {
      char[] var6 = this.value;
      int var7 = this.offset + var2;
      int var10000 = this.offset + this.count;
      char[] var9 = var3.value;
      int var10 = var3.offset + var4;
      if (var4 >= 0 && var2 >= 0 && (long)var2 <= (long)this.count - (long)var5 && (long)var4 <= (long)var3.count - (long)var5) {
         while(true) {
            if (var5-- <= 0) {
               return true;
            }

            char var11 = var6[var7++];
            char var12 = var9[var10++];
            if (var11 != var12) {
               if (!var1) {
                  break;
               }

               char var13 = Character.toUpperCase(var11);
               char var14 = Character.toUpperCase(var12);
               if (var13 != var14 && Character.toLowerCase(var13) != Character.toLowerCase(var14)) {
                  break;
               }
            }
         }

         return false;
      } else {
         return false;
      }
   }

   public boolean startsWith(String var1, int var2) {
      char[] var3 = this.value;
      int var4 = this.offset + var2;
      int var10000 = this.offset + this.count;
      char[] var6 = var1.value;
      int var7 = var1.offset;
      int var8 = var1.count;
      if (var2 >= 0 && var2 <= this.count - var8) {
         do {
            --var8;
            if (var8 < 0) {
               return true;
            }
         } while(var3[var4++] == var6[var7++]);

         return false;
      } else {
         return false;
      }
   }

   public boolean startsWith(String var1) {
      return this.startsWith(var1, 0);
   }

   public boolean endsWith(String var1) {
      return this.startsWith(var1, this.count - var1.count);
   }

   public int hashCode() {
      int var1 = this.hash;
      if (var1 == 0) {
         int var2 = this.offset;
         char[] var3 = this.value;
         int var4 = this.count;

         for(int var5 = 0; var5 < var4; ++var5) {
            var1 = 31 * var1 + var3[var2++];
         }

         this.hash = var1;
      }

      return var1;
   }

   public int indexOf(int var1) {
      return this.indexOf(var1, 0);
   }

   public int indexOf(int var1, int var2) {
      int var3 = this.offset + this.count;
      char[] var4 = this.value;
      if (var2 < 0) {
         var2 = 0;
      } else if (var2 >= this.count) {
         return -1;
      }

      for(int var5 = this.offset + var2; var5 < var3; ++var5) {
         if (var4[var5] == var1) {
            return var5 - this.offset;
         }
      }

      return -1;
   }

   public int lastIndexOf(int var1) {
      return this.lastIndexOf(var1, this.count - 1);
   }

   public int lastIndexOf(int var1, int var2) {
      int var3 = this.offset;
      char[] var4 = this.value;

      for(int var5 = this.offset + (var2 >= this.count ? this.count - 1 : var2); var5 >= var3; --var5) {
         if (var4[var5] == var1) {
            return var5 - this.offset;
         }
      }

      return -1;
   }

   public int indexOf(String var1) {
      return this.indexOf(var1, 0);
   }

   public int indexOf(String var1, int var2) {
      char[] var3 = this.value;
      char[] var4 = var1.value;
      int var5 = this.offset + (this.count - var1.count);
      if (var2 >= this.count) {
         return this.count == 0 && var2 == 0 && var1.count == 0 ? 0 : -1;
      } else {
         if (var2 < 0) {
            var2 = 0;
         }

         if (var1.count == 0) {
            return var2;
         } else {
            int var6 = var1.offset;
            char var7 = var4[var6];
            int var8 = this.offset + var2;

            while(true) {
               label47:
               while(var8 > var5 || var3[var8] == var7) {
                  if (var8 > var5) {
                     return -1;
                  }

                  int var9 = var8 + 1;
                  int var10 = var9 + var1.count - 1;
                  int var11 = var6 + 1;

                  while(var9 < var10) {
                     if (var3[var9++] != var4[var11++]) {
                        ++var8;
                        continue label47;
                     }
                  }

                  return var8 - this.offset;
               }

               ++var8;
            }
         }
      }
   }

   public int lastIndexOf(String var1) {
      return this.lastIndexOf(var1, this.count);
   }

   public int lastIndexOf(String var1, int var2) {
      int var3 = this.count - var1.count;
      if (var2 < 0) {
         return -1;
      } else {
         if (var2 > var3) {
            var2 = var3;
         }

         if (var1.count == 0) {
            return var2;
         } else {
            char[] var4 = this.value;
            char[] var5 = var1.value;
            int var6 = var1.offset + var1.count - 1;
            char var7 = var5[var6];
            int var8 = this.offset + var1.count - 1;
            int var9 = var8 + var2;

            while(true) {
               label39:
               while(var9 < var8 || var4[var9] == var7) {
                  if (var9 < var8) {
                     return -1;
                  }

                  int var10 = var9 - 1;
                  int var11 = var10 - (var1.count - 1);
                  int var12 = var6 - 1;

                  while(var10 > var11) {
                     if (var4[var10--] != var5[var12--]) {
                        --var9;
                        continue label39;
                     }
                  }

                  return var11 - this.offset + 1;
               }

               --var9;
            }
         }
      }
   }

   public String substring(int var1) {
      return this.substring(var1, this.count);
   }

   public String substring(int var1, int var2) {
      if (var1 < 0) {
         throw new StringIndexOutOfBoundsException(var1);
      } else if (var2 > this.count) {
         throw new StringIndexOutOfBoundsException(var2);
      } else if (var1 > var2) {
         throw new StringIndexOutOfBoundsException(var2 - var1);
      } else {
         return var1 == 0 && var2 == this.count ? this : new String(this.offset + var1, var2 - var1, this.value);
      }
   }

   public String concat(String var1) {
      int var2 = var1.length();
      if (var2 == 0) {
         return this;
      } else {
         char[] var3 = new char[this.count + var2];
         this.getChars(0, this.count, var3, 0);
         var1.getChars(0, var2, var3, this.count);
         return new String(0, this.count + var2, var3);
      }
   }

   public String replace(char var1, char var2) {
      if (var1 != var2) {
         int var3 = this.count;
         int var4 = -1;
         char[] var5 = this.value;
         int var6 = this.offset;

         do {
            ++var4;
         } while(var4 < var3 && var5[var6 + var4] != var1);

         if (var4 < var3) {
            char[] var7 = new char[var3];

            for(int var8 = 0; var8 < var4; ++var8) {
               var7[var8] = var5[var6 + var8];
            }

            while(var4 < var3) {
               char var9 = var5[var6 + var4];
               var7[var4] = var9 == var1 ? var2 : var9;
               ++var4;
            }

            return new String(0, var3, var7);
         }
      }

      return this;
   }

   public String toLowerCase(Locale var1) {
      int var2 = this.count;
      int var3 = this.offset;
      char[] var4 = this.value;

      for(int var5 = 0; var5 < var2; ++var5) {
         char var6 = this.value[var3 + var5];
         if (var6 != Character.toLowerCase(var6)) {
            char[] var9 = new char[this.count];
            System.arraycopy(var4, var3, var9, 0, var5);
            if (var1.getLanguage().equals("tr")) {
               for(int var7 = var5; var7 < var2; ++var7) {
                  char var8 = var4[var3 + var7];
                  if (var8 == 'I') {
                     var9[var7] = 305;
                  } else if (var8 == 304) {
                     var9[var7] = 'i';
                  } else {
                     var9[var7] = Character.toLowerCase(var8);
                  }
               }
            } else {
               for(int var10 = var5; var10 < var2; ++var10) {
                  var9[var10] = Character.toLowerCase(var4[var3 + var10]);
               }
            }

            return new String(var9);
         }
      }

      return this;
   }

   public String toLowerCase() {
      return this.toLowerCase(Locale.getDefault());
   }

   public String toUpperCase(Locale var1) {
      int var2 = this.count;
      int var3 = this.offset;
      char[] var4 = this.value;

      for(int var5 = 0; var5 < var2; ++var5) {
         char var6 = this.value[var3 + var5];
         if (var6 != Character.toUpperCase(var6)) {
            char[] var11 = new char[var2];
            int var7 = 0;
            System.arraycopy(var4, var3, var11, 0, var5);
            if (var1.getLanguage().equals("tr")) {
               for(int var8 = var5; var8 < var2; ++var8) {
                  char var9 = var4[var3 + var8];
                  if (var9 == 'i') {
                     var11[var8 + var7] = 304;
                  } else if (var9 == 305) {
                     var11[var8 + var7] = 'I';
                  } else if (var9 == 223) {
                     char[] var10 = new char[var11.length + 1];
                     System.arraycopy(var11, 0, var10, 0, var8 + 1 + var7);
                     var10[var8 + var7] = 'S';
                     ++var7;
                     var10[var8 + var7] = 'S';
                     var11 = var10;
                  } else {
                     var11[var8 + var7] = Character.toUpperCase(var9);
                  }
               }
            } else {
               for(int var12 = var5; var12 < var2; ++var12) {
                  char var13 = var4[var3 + var12];
                  if (var13 == 223) {
                     char[] var14 = new char[var11.length + 1];
                     System.arraycopy(var11, 0, var14, 0, var12 + 1 + var7);
                     var14[var12 + var7] = 'S';
                     ++var7;
                     var14[var12 + var7] = 'S';
                     var11 = var14;
                  } else {
                     var11[var12 + var7] = Character.toUpperCase(var13);
                  }
               }
            }

            return new String(var11);
         }
      }

      return this;
   }

   public String toUpperCase() {
      return this.toUpperCase(Locale.getDefault());
   }

   public String trim() {
      int var1 = this.count;
      int var2 = 0;
      int var3 = this.offset;

      char[] var4;
      for(var4 = this.value; var2 < var1 && var4[var3 + var2] <= ' '; ++var2) {
      }

      while(var2 < var1 && var4[var3 + var1 - 1] <= ' ') {
         --var1;
      }

      return var2 <= 0 && var1 >= this.count ? this : this.substring(var2, var1);
   }

   public String toString() {
      return this;
   }

   public char[] toCharArray() {
      char[] var1 = new char[this.count];
      this.getChars(0, this.count, var1, 0);
      return var1;
   }

   public static String valueOf(Object var0) {
      return var0 == null ? "null" : var0.toString();
   }

   public static String valueOf(char[] var0) {
      return new String(var0);
   }

   public static String valueOf(char[] var0, int var1, int var2) {
      return new String(var0, var1, var2);
   }

   public static String copyValueOf(char[] var0, int var1, int var2) {
      return new String(var0, var1, var2);
   }

   public static String copyValueOf(char[] var0) {
      return copyValueOf(var0, 0, var0.length);
   }

   public static String valueOf(boolean var0) {
      return var0 ? "true" : "false";
   }

   public static String valueOf(char var0) {
      char[] var1 = new char[]{var0};
      return new String(0, 1, var1);
   }

   public static String valueOf(int var0) {
      return Integer.toString(var0, 10);
   }

   public static String valueOf(long var0) {
      return Long.toString(var0, 10);
   }

   public static String valueOf(float var0) {
      return Float.toString(var0);
   }

   public static String valueOf(double var0) {
      return Double.toString(var0);
   }

   public native String intern();
}