home *** CD-ROM | disk | FTP | other *** search
/ S283 Planetary Science &n…he Search for Life DVD 2 / DVD-ROM.iso / install / jre1_3 / lib / rt.jar / java / lang / StringBuffer.class (.txt) < prev    next >
Encoding:
Java Class File  |  1979-12-31  |  4.8 KB  |  425 lines
  1. package java.lang;
  2.  
  3. import java.io.IOException;
  4. import java.io.ObjectInputStream;
  5. import java.io.Serializable;
  6.  
  7. public final class StringBuffer implements Serializable {
  8.    private char[] value;
  9.    private int count;
  10.    private boolean shared;
  11.    static final long serialVersionUID = 3388685877147921107L;
  12.  
  13.    public StringBuffer() {
  14.       this(16);
  15.    }
  16.  
  17.    public StringBuffer(int var1) {
  18.       this.value = new char[var1];
  19.       this.shared = false;
  20.    }
  21.  
  22.    public StringBuffer(String var1) {
  23.       this(var1.length() + 16);
  24.       this.append(var1);
  25.    }
  26.  
  27.    public int length() {
  28.       return this.count;
  29.    }
  30.  
  31.    public int capacity() {
  32.       return this.value.length;
  33.    }
  34.  
  35.    private final void copy() {
  36.       char[] var1 = new char[this.value.length];
  37.       System.arraycopy(this.value, 0, var1, 0, this.count);
  38.       this.value = var1;
  39.       this.shared = false;
  40.    }
  41.  
  42.    public synchronized void ensureCapacity(int var1) {
  43.       if (var1 > this.value.length) {
  44.          this.expandCapacity(var1);
  45.       }
  46.  
  47.    }
  48.  
  49.    private void expandCapacity(int var1) {
  50.       int var2 = (this.value.length + 1) * 2;
  51.       if (var2 < 0) {
  52.          var2 = Integer.MAX_VALUE;
  53.       } else if (var1 > var2) {
  54.          var2 = var1;
  55.       }
  56.  
  57.       char[] var3 = new char[var2];
  58.       System.arraycopy(this.value, 0, var3, 0, this.count);
  59.       this.value = var3;
  60.       this.shared = false;
  61.    }
  62.  
  63.    public synchronized void setLength(int var1) {
  64.       if (var1 < 0) {
  65.          throw new StringIndexOutOfBoundsException(var1);
  66.       } else {
  67.          if (var1 > this.value.length) {
  68.             this.expandCapacity(var1);
  69.          }
  70.  
  71.          if (this.count < var1) {
  72.             if (this.shared) {
  73.                this.copy();
  74.             }
  75.  
  76.             while(this.count < var1) {
  77.                this.value[this.count] = 0;
  78.                ++this.count;
  79.             }
  80.          } else {
  81.             this.count = var1;
  82.             if (this.shared) {
  83.                if (var1 > 0) {
  84.                   this.copy();
  85.                } else {
  86.                   this.value = new char[16];
  87.                   this.shared = false;
  88.                }
  89.             }
  90.          }
  91.  
  92.       }
  93.    }
  94.  
  95.    public synchronized char charAt(int var1) {
  96.       if (var1 >= 0 && var1 < this.count) {
  97.          return this.value[var1];
  98.       } else {
  99.          throw new StringIndexOutOfBoundsException(var1);
  100.       }
  101.    }
  102.  
  103.    public synchronized void getChars(int var1, int var2, char[] var3, int var4) {
  104.       if (var1 < 0) {
  105.          throw new StringIndexOutOfBoundsException(var1);
  106.       } else if (var2 >= 0 && var2 <= this.count) {
  107.          if (var1 > var2) {
  108.             throw new StringIndexOutOfBoundsException("srcBegin > srcEnd");
  109.          } else {
  110.             System.arraycopy(this.value, var1, var3, var4, var2 - var1);
  111.          }
  112.       } else {
  113.          throw new StringIndexOutOfBoundsException(var2);
  114.       }
  115.    }
  116.  
  117.    public synchronized void setCharAt(int var1, char var2) {
  118.       if (var1 >= 0 && var1 < this.count) {
  119.          if (this.shared) {
  120.             this.copy();
  121.          }
  122.  
  123.          this.value[var1] = var2;
  124.       } else {
  125.          throw new StringIndexOutOfBoundsException(var1);
  126.       }
  127.    }
  128.  
  129.    public synchronized StringBuffer append(Object var1) {
  130.       return this.append(String.valueOf(var1));
  131.    }
  132.  
  133.    public synchronized StringBuffer append(String var1) {
  134.       if (var1 == null) {
  135.          var1 = String.valueOf(var1);
  136.       }
  137.  
  138.       int var2 = var1.length();
  139.       int var3 = this.count + var2;
  140.       if (var3 > this.value.length) {
  141.          this.expandCapacity(var3);
  142.       }
  143.  
  144.       var1.getChars(0, var2, this.value, this.count);
  145.       this.count = var3;
  146.       return this;
  147.    }
  148.  
  149.    public synchronized StringBuffer append(char[] var1) {
  150.       int var2 = var1.length;
  151.       int var3 = this.count + var2;
  152.       if (var3 > this.value.length) {
  153.          this.expandCapacity(var3);
  154.       }
  155.  
  156.       System.arraycopy(var1, 0, this.value, this.count, var2);
  157.       this.count = var3;
  158.       return this;
  159.    }
  160.  
  161.    public synchronized StringBuffer append(char[] var1, int var2, int var3) {
  162.       int var4 = this.count + var3;
  163.       if (var4 > this.value.length) {
  164.          this.expandCapacity(var4);
  165.       }
  166.  
  167.       System.arraycopy(var1, var2, this.value, this.count, var3);
  168.       this.count = var4;
  169.       return this;
  170.    }
  171.  
  172.    public StringBuffer append(boolean var1) {
  173.       return this.append(String.valueOf(var1));
  174.    }
  175.  
  176.    public synchronized StringBuffer append(char var1) {
  177.       int var2 = this.count + 1;
  178.       if (var2 > this.value.length) {
  179.          this.expandCapacity(var2);
  180.       }
  181.  
  182.       this.value[this.count++] = var1;
  183.       return this;
  184.    }
  185.  
  186.    public StringBuffer append(int var1) {
  187.       return this.append(String.valueOf(var1));
  188.    }
  189.  
  190.    public StringBuffer append(long var1) {
  191.       return this.append(String.valueOf(var1));
  192.    }
  193.  
  194.    public StringBuffer append(float var1) {
  195.       return this.append(String.valueOf(var1));
  196.    }
  197.  
  198.    public StringBuffer append(double var1) {
  199.       return this.append(String.valueOf(var1));
  200.    }
  201.  
  202.    public synchronized StringBuffer delete(int var1, int var2) {
  203.       if (var1 < 0) {
  204.          throw new StringIndexOutOfBoundsException(var1);
  205.       } else {
  206.          if (var2 > this.count) {
  207.             var2 = this.count;
  208.          }
  209.  
  210.          if (var1 > var2) {
  211.             throw new StringIndexOutOfBoundsException();
  212.          } else {
  213.             int var3 = var2 - var1;
  214.             if (var3 > 0) {
  215.                if (this.shared) {
  216.                   this.copy();
  217.                }
  218.  
  219.                System.arraycopy(this.value, var1 + var3, this.value, var1, this.count - var2);
  220.                this.count -= var3;
  221.             }
  222.  
  223.             return this;
  224.          }
  225.       }
  226.    }
  227.  
  228.    public synchronized StringBuffer deleteCharAt(int var1) {
  229.       if (var1 >= 0 && var1 < this.count) {
  230.          if (this.shared) {
  231.             this.copy();
  232.          }
  233.  
  234.          System.arraycopy(this.value, var1 + 1, this.value, var1, this.count - var1 - 1);
  235.          --this.count;
  236.          return this;
  237.       } else {
  238.          throw new StringIndexOutOfBoundsException();
  239.       }
  240.    }
  241.  
  242.    public synchronized StringBuffer replace(int var1, int var2, String var3) {
  243.       if (var1 < 0) {
  244.          throw new StringIndexOutOfBoundsException(var1);
  245.       } else {
  246.          if (var2 > this.count) {
  247.             var2 = this.count;
  248.          }
  249.  
  250.          if (var1 > var2) {
  251.             throw new StringIndexOutOfBoundsException();
  252.          } else {
  253.             int var4 = var3.length();
  254.             int var5 = this.count + var4 - (var2 - var1);
  255.             if (var5 > this.value.length) {
  256.                this.expandCapacity(var5);
  257.             } else if (this.shared) {
  258.                this.copy();
  259.             }
  260.  
  261.             System.arraycopy(this.value, var2, this.value, var1 + var4, this.count - var2);
  262.             var3.getChars(0, var4, this.value, var1);
  263.             this.count = var5;
  264.             return this;
  265.          }
  266.       }
  267.    }
  268.  
  269.    public String substring(int var1) {
  270.       return this.substring(var1, this.count);
  271.    }
  272.  
  273.    public synchronized String substring(int var1, int var2) {
  274.       if (var1 < 0) {
  275.          throw new StringIndexOutOfBoundsException(var1);
  276.       } else if (var2 > this.count) {
  277.          throw new StringIndexOutOfBoundsException(var2);
  278.       } else if (var1 > var2) {
  279.          throw new StringIndexOutOfBoundsException(var2 - var1);
  280.       } else {
  281.          return new String(this.value, var1, var2 - var1);
  282.       }
  283.    }
  284.  
  285.    public synchronized StringBuffer insert(int var1, char[] var2, int var3, int var4) {
  286.       if (var1 >= 0 && var1 <= this.count) {
  287.          if (var3 >= 0 && var3 + var4 >= 0 && var3 + var4 <= var2.length) {
  288.             if (var4 < 0) {
  289.                throw new StringIndexOutOfBoundsException(var4);
  290.             } else {
  291.                int var5 = this.count + var4;
  292.                if (var5 > this.value.length) {
  293.                   this.expandCapacity(var5);
  294.                } else if (this.shared) {
  295.                   this.copy();
  296.                }
  297.  
  298.                System.arraycopy(this.value, var1, this.value, var1 + var4, this.count - var1);
  299.                System.arraycopy(var2, var3, this.value, var1, var4);
  300.                this.count = var5;
  301.                return this;
  302.             }
  303.          } else {
  304.             throw new StringIndexOutOfBoundsException(var3);
  305.          }
  306.       } else {
  307.          throw new StringIndexOutOfBoundsException();
  308.       }
  309.    }
  310.  
  311.    public synchronized StringBuffer insert(int var1, Object var2) {
  312.       return this.insert(var1, String.valueOf(var2));
  313.    }
  314.  
  315.    public synchronized StringBuffer insert(int var1, String var2) {
  316.       if (var1 >= 0 && var1 <= this.count) {
  317.          if (var2 == null) {
  318.             var2 = String.valueOf(var2);
  319.          }
  320.  
  321.          int var3 = var2.length();
  322.          int var4 = this.count + var3;
  323.          if (var4 > this.value.length) {
  324.             this.expandCapacity(var4);
  325.          } else if (this.shared) {
  326.             this.copy();
  327.          }
  328.  
  329.          System.arraycopy(this.value, var1, this.value, var1 + var3, this.count - var1);
  330.          var2.getChars(0, var3, this.value, var1);
  331.          this.count = var4;
  332.          return this;
  333.       } else {
  334.          throw new StringIndexOutOfBoundsException();
  335.       }
  336.    }
  337.  
  338.    public synchronized StringBuffer insert(int var1, char[] var2) {
  339.       if (var1 >= 0 && var1 <= this.count) {
  340.          int var3 = var2.length;
  341.          int var4 = this.count + var3;
  342.          if (var4 > this.value.length) {
  343.             this.expandCapacity(var4);
  344.          } else if (this.shared) {
  345.             this.copy();
  346.          }
  347.  
  348.          System.arraycopy(this.value, var1, this.value, var1 + var3, this.count - var1);
  349.          System.arraycopy(var2, 0, this.value, var1, var3);
  350.          this.count = var4;
  351.          return this;
  352.       } else {
  353.          throw new StringIndexOutOfBoundsException();
  354.       }
  355.    }
  356.  
  357.    public StringBuffer insert(int var1, boolean var2) {
  358.       return this.insert(var1, String.valueOf(var2));
  359.    }
  360.  
  361.    public synchronized StringBuffer insert(int var1, char var2) {
  362.       int var3 = this.count + 1;
  363.       if (var3 > this.value.length) {
  364.          this.expandCapacity(var3);
  365.       } else if (this.shared) {
  366.          this.copy();
  367.       }
  368.  
  369.       System.arraycopy(this.value, var1, this.value, var1 + 1, this.count - var1);
  370.       this.value[var1] = var2;
  371.       this.count = var3;
  372.       return this;
  373.    }
  374.  
  375.    public StringBuffer insert(int var1, int var2) {
  376.       return this.insert(var1, String.valueOf(var2));
  377.    }
  378.  
  379.    public StringBuffer insert(int var1, long var2) {
  380.       return this.insert(var1, String.valueOf(var2));
  381.    }
  382.  
  383.    public StringBuffer insert(int var1, float var2) {
  384.       return this.insert(var1, String.valueOf(var2));
  385.    }
  386.  
  387.    public StringBuffer insert(int var1, double var2) {
  388.       return this.insert(var1, String.valueOf(var2));
  389.    }
  390.  
  391.    public synchronized StringBuffer reverse() {
  392.       if (this.shared) {
  393.          this.copy();
  394.       }
  395.  
  396.       int var1 = this.count - 1;
  397.  
  398.       for(int var2 = var1 - 1 >> 1; var2 >= 0; --var2) {
  399.          char var3 = this.value[var2];
  400.          this.value[var2] = this.value[var1 - var2];
  401.          this.value[var1 - var2] = var3;
  402.       }
  403.  
  404.       return this;
  405.    }
  406.  
  407.    public String toString() {
  408.       return new String(this);
  409.    }
  410.  
  411.    final void setShared() {
  412.       this.shared = true;
  413.    }
  414.  
  415.    final char[] getValue() {
  416.       return this.value;
  417.    }
  418.  
  419.    private synchronized void readObject(ObjectInputStream var1) throws IOException, ClassNotFoundException {
  420.       var1.defaultReadObject();
  421.       this.value = (char[])this.value.clone();
  422.       this.shared = false;
  423.    }
  424. }
  425.