/FileExtraction/Java_unseen/dlitz_resin/modules/quercus/src/com/caucho/quercus/env/LargeStringBuilderValue.java
/*
 * Copyright (c) 1998-2011 Caucho Technology -- all rights reserved
 *
 * This file is part of Resin(R) Open Source
 *
 * Each copy or derived work must preserve the copyright notice and this
 * notice unmodified.
 *
 * Resin Open Source is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * Resin Open Source is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE, or any warranty
 * of NON-INFRINGEMENT.  See the GNU General Public License for more
 * details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Resin Open Source; if not, write to the
 *
 *   Free Software Foundation, Inc.
 *   59 Temple Place, Suite 330
 *   Boston, MA 02111-1307  USA
 *
 * @author Scott Ferguson
 */

package com.caucho.quercus.env;

import java.io.*;
import java.util.*;

import com.caucho.vfs.*;
import com.caucho.quercus.QuercusRuntimeException;
import com.caucho.util.*;

/**
 * Represents a 8-bit PHP 5 style binary builder (unicode.semantics = off),
 * used for large data like file reads.
 */
public class LargeStringBuilderValue
  extends StringValue
{
  public static final StringValue EMPTY = StringBuilderValue.EMPTY;
  
  public static final int SIZE = 4 * 1024;
  
  protected byte [][]_bufferList;
  protected int _length;

  private int _hashCode;
  private String _value;

  public LargeStringBuilderValue()
  {
    _bufferList = new byte[32][];
    _bufferList[0] = new byte[SIZE];
  }

  public LargeStringBuilderValue(byte [][]bufferList, int length)
  {
    _bufferList = bufferList;
    _length = length;
  }
  
  public LargeStringBuilderValue(StringValue s)
  {
    this();
    
    s.appendTo(this);
  }
  
  /**
   * Creates an empty string builder of the same type.
   */
  public StringValue createEmptyStringBuilder()
  {
    return new StringBuilderValue();
  }

  /**
   * Returns the value.
   */
  public String getValue()
  {
    return toString();
  }

  /**
   * Returns the type.
   */
  @Override
  public String getType()
  {
    return "string";
  }

  /**
   * Returns the ValueType.
   */
  @Override
  public ValueType getValueType()
  {
    return StringBuilderValue.getValueType(_bufferList[0], 0, _length);
  }

  /**
   * Returns true for a long
   */
  @Override
  public boolean isLongConvertible()
  {
    return false;
  }

  /**
   * Returns true for a double
   */
  public boolean isDouble()
  {
    return false;
  }

  /**
   * Returns true for a number
   */
  @Override
  public boolean isNumber()
  {
    return false;
  }

  /**
   * Returns true for a scalar
   */
  @Override
  public boolean isScalar()
  {
    return true;
  }

  /**
   * Converts to a boolean.
   */
  @Override
  public boolean toBoolean()
  {
    if (_length == 0)
      return false;
    else if (_length == 1 && _bufferList[0][0] == '0')
      return false;
    else
      return true;
  }

  /**
   * Converts to a long.
   */
  @Override
  public long toLong()
  {
    return parseLong(_bufferList[0], 0, _length);
  }

  /**
   * Converts to a double.
   */
  @Override
  public double toDouble()
  {
    return StringBuilderValue.toDouble(_bufferList[0], 0, _length);
  }

  /**
   * Convert to an input stream.
   */
  @Override
  public InputStream toInputStream()
  {
    return new BuilderInputStream();
  }

  /**
   * Converts to a string.
   */
  @Override
  public String toString()
  {
    char []buffer = new char[_length];

    byte [][]bufferList = _bufferList;
    for (int i = _length - 1; i >= 0; i--) {
      buffer[i] = (char) bufferList[i / SIZE][i % SIZE];
    }

    return new String(buffer, 0, _length);
  }

  /**
   * Converts to an object.
   */
  @Override
  public Object toJavaObject()
  {
    return toString();
  }

  /**
   * Converts to a string builder
   */
  @Override
  public StringValue toStringBuilder()
  {
    // XXX: can this just return this, or does it need to return a copy?
    
    return new LargeStringBuilderValue(_bufferList, _length);
  }

  /**
   * Converts to a BinaryValue.
   */
  @Override
  public StringValue toBinaryValue(Env env)
  {
    return this;
  }

  /**
   * Converts to a BinaryValue in desired charset.
   */
  @Override
  public StringValue toBinaryValue(String charset)
  {
    return this;
  }
  
  /**
   * Append to a string builder.
   */
  public void appendTo(StringValue bb)
  {
    int tail = _length % SIZE;
    int fixedLength = (_length - tail) / SIZE;

    int i = 0;
    for (; i < fixedLength; i++) {
      bb.append(_bufferList[i], 0, SIZE);
    }

    bb.append(_bufferList[i], 0, tail);
  }

  /**
   * Converts to a key.
   */
  @Override
  public Value toKey()
  {
    if (getValueType().isLongAdd())
      return LongValue.create(toLong());
    else
      return this;
  }

  /**
   * Converts to a byte array, with no consideration of character encoding.
   * Each character becomes one byte, characters with values above 255 are
   * not correctly preserved.
   */
  public byte[] toBytes()
  {
    byte[] bytes = new byte[_length];

    byte [][]bufferList = _bufferList;
    for (int i = _length - 1; i >= 0; i--) {
      bytes[i] = bufferList[i / SIZE][i % SIZE];
    }

    return bytes;
  }

  //
  // Operations
  //

  /**
   * Returns the character at an index
   */
  public Value get(Value key)
  {
    return charValueAt(key.toLong());
  }

  /**
   * Returns the character at an index
   */
  @Override
  public Value charValueAt(long index)
  {
    int len = _length;

    if (index < 0 || len <= index)
      return UnsetStringValue.UNSET;
    else {
      int data = _bufferList[(int) (index / SIZE)][(int) (index % SIZE)];
      
      return StringBuilderValue.create((char) (data & 0xff));
    }
  }

  //
  // CharSequence
  //

  /**
   * Returns the length of the string.
   */
  @Override
  public int length()
  {
    return _length;
  }

  /**
   * Returns the character at a particular location
   */
  @Override
  public char charAt(int index)
  {
    int data = _bufferList[index / SIZE][index % SIZE] & 0xff;
    
    return (char) data;
  }

  /**
   * Returns a subsequence
   */
  @Override
  public CharSequence subSequence(int start, int end)
  {
    if (end <= start)
      return StringBuilderValue.EMPTY;

    StringValue stringValue;
    
    if (end - start < 1024)
      stringValue = new StringBuilderValue(end - start);
    else
      stringValue = new LargeStringBuilderValue();

    int endChunk = end / SIZE;
      
    while (start < end) {
      int startChunk = start / SIZE;
      int startOffset = start % SIZE;

      if (startChunk == endChunk) {
        stringValue.append(_bufferList[startChunk],
                           startOffset,
                           (end - start));

        return stringValue;
      }
      else {
        int len = SIZE - startOffset;

        stringValue.append(_bufferList[startChunk], startOffset, len);

        start += len;
      }
    }

    return stringValue;
  }

  /**
   * Convert to lower case.
   */
  @Override
  public StringValue toLowerCase()
  {
    int length = _length;
    
    StringValue string = new LargeStringBuilderValue();

    byte [][]bufferList = _bufferList;

    for (int i = 0; i < length; i++) {
      int ch = bufferList[i / SIZE][i % SIZE] & 0xff;

      if ('A' <= ch && ch <= 'Z')
        ch = (ch + 'a' - 'A');

      string.append((char) ch);
    }

    return string;
  }
  
  /**
   * Convert to lower case.
   */
  @Override
  public StringValue toUpperCase()
  {
    int length = _length;
    
    StringValue string = new LargeStringBuilderValue();

    byte [][]bufferList = _bufferList;

    for (int i = 0; i < length; i++) {
      int ch = bufferList[i / SIZE][i % SIZE] & 0xff;

      if ('a' <= ch && ch <= 'z')
        ch = (ch + 'A' - 'a');

      string.append((char) ch);
    }

    return string;
  }

  //
  // append code
  //

  /**
   * Creates a string builder of the same type.
   */
  @Override
  public StringValue createStringBuilder()
  {
    return new StringBuilderValue();
  }

  /**
   * Creates a string builder of the same type.
   */
  @Override
  public StringValue createStringBuilder(int length)
  {
    return new StringBuilderValue(length);
  }

  /**
   * Converts to a string builder
   */
  @Override
  public StringValue toStringBuilder(Env env)
  {
    return new LargeStringBuilderValue(_bufferList, _length);
  }

  /**
   * Append a Java buffer to the value.
   */
  @Override
  public final StringValue appendUnicode(char []buf, int offset, int length)
  {
    return append(buf, offset, length);
  }
  
  /**
   * Append a Java string to the value.
   */
  @Override
  public StringValue append(String s)
  {
    int len = s.length();
    
    ensureCapacity(_length + len);
    
    for (int i = 0; i < len; i++) {
      _bufferList[_length / SIZE][_length % SIZE] = (byte) s.charAt(i);
      
      _length++;
    }
    
    return this;
  }
  
  /**
   * Append a Java buffer to the value.
   */
  public StringValue append(CharSequence buf, int head, int tail)
  {
    int len = tail - head;
    
    ensureCapacity(_length + len);
    
    for (int i = 0; i < len; i++) {
      _bufferList[_length / SIZE][_length % SIZE] = (byte) buf.charAt(i);
      
      _length++;
    }
    
    return this;
  }
  
  /**
   * Append a Java buffer to the value.
   */
  @Override
  public final StringValue append(char []buf, int offset, int length)
  {
    ensureCapacity(_length + length);

    for (int i = offset; i < length + offset; i++) {
      _bufferList[_length / SIZE][_length % SIZE] = (byte) buf[i];
      
      _length++;
    }

    return this;
  }

  /**
   * Append a buffer to the value.
   */
  public final StringValue append(byte []buf, int offset, int length)
  {
    ensureCapacity(_length + length);

    while (length > 0) {
      int chunk = _length / SIZE;
      int chunkOffset = _length % SIZE;

      int sublen = SIZE - chunkOffset;
      if (length < sublen)
        sublen = length;

      System.arraycopy(buf, offset, _bufferList[chunk], chunkOffset, sublen);

      offset += sublen;
      length -= sublen;
      _length += sublen;
    }
      
    return this;
  }

  /**
   * Append a double to the value.
   */
  public final StringValue append(byte []buf)
  {
    return append(buf, 0, buf.length);
  }

  /**
   * Append a Java byte to the value without conversions.
   */
  @Override
  public final StringValue append(char v)
  {
    if (_length % SIZE == 0)
      ensureCapacity(_length + 1);

    _bufferList[_length / SIZE][_length % SIZE] = (byte) v;

    _length += 1;

    return this;
  }

  /**
   * Append a Java byte to the value without conversions.
   */
  public final StringValue append(byte v)
  {
    if (_length % SIZE == 0)
      ensureCapacity(_length + 1);

    _bufferList[_length / SIZE][_length % SIZE] = (byte) v;

    _length += 1;

    return this;
  }

  /**
   * Append a Java boolean to the value.
   */
  @Override
  public final StringValue append(boolean v)
  {
    return append(v ? "true" : "false");
  }

  /**
   * Append a Java long to the value.
   */
  @Override
  public StringValue append(long v)
  {
    // XXX: this probably is frequent enough to special-case
    
    return append(String.valueOf(v));
  }

  /**
   * Append a Java double to the value.
   */
  @Override
  public StringValue append(double v)
  {
    return append(String.valueOf(v));
  }
  
  /**
   * Append a Java value to the value.
   */
  @Override
  public final StringValue append(Value v)
  {
    v.appendTo(this);

    return this;
  }

  /**
   * Append from an input stream, using InputStream.read semantics,
   * i.e. just call is.read once even if more data is available.
   */
  public int appendRead(InputStream is, long length)
  {
    try {
      int offset = _length % SIZE;

      if (offset == 0) {
        ensureCapacity(_length + SIZE);
      }
      
      byte []buffer = _bufferList[_length / SIZE];
      int sublen = SIZE - offset;

      if (length < sublen)
        sublen = (int) length;

      sublen = is.read(buffer, 0, sublen);

      if (sublen > 0) {
        _length += sublen;

        return sublen;
      }
      else
        return -1;
    } catch (IOException e) {
      throw new QuercusRuntimeException(e);
    }
  }

  /**
   * Append from an input stream, reading from the input stream until
   * end of file or the length is reached.
   */
  public int appendReadAll(InputStream is, long length)
  {
    int readLength = 0;
    
    while (length > 0) {
      int sublen = appendRead(is, length);

      if (sublen < 0)
        return readLength <= 0 ? -1 : readLength;

      length -= sublen;
      readLength += sublen;
    }

    return readLength;
  }
  
  /**
   * Append to a string builder.
   */
  public StringValue appendTo(UnicodeBuilderValue sb)
  {
    if (length() == 0)
      return sb;
    
    Env env = Env.getInstance();

    try {
      Reader reader = env.getRuntimeEncodingFactory().create(toInputStream());
      
      if (reader != null) {
        sb.append(reader);

        reader.close();
      }

      return sb;
    } catch (IOException e) {
      throw new QuercusRuntimeException(e);
    }
  }

  //
  // Java generator code
  //

  /**
   * Prints the value.
   * @param env
   */
  public void print(Env env)
  {
    for (int i = 0; i < _length; i += SIZE) {
      int chunk = i / SIZE;
      int sublen = _length - i;

      if (SIZE < sublen)
        sublen = SIZE;

      env.write(_bufferList[chunk], 0, sublen);
    }
  }

  /**
   * Prints the value.
   * @param env
   */
  public void print(Env env, WriteStream out)
  {
    try {
      for (int i = 0; i < _length; i += SIZE) {
        int chunk = i / SIZE;
        int sublen = _length - i;

        if (SIZE < sublen)
          sublen = SIZE;

        out.write(_bufferList[chunk], 0, sublen);
      }
    } catch (IOException e) {
      throw new QuercusRuntimeException(e);
    }
  }

  /**
   * Serializes the value.
   */
  public void serialize(Env env, StringBuilder sb)
  {
    sb.append("s:");
    sb.append(_length);
    sb.append(":\"");
    sb.append(toString());
    sb.append("\";");
  }

  /**
   * Returns an OutputStream.
   */
  public OutputStream getOutputStream()
  {
    return new BuilderOutputStream();
  }

  private void ensureCapacity(int newCapacity)
  {
    if (newCapacity > 10000000) {
      Thread.dumpStack();
      throw new IllegalStateException();
    }
    
    int chunk = _length / SIZE;
    int endChunk = newCapacity / SIZE;

    if (_bufferList.length <= endChunk) {
      byte [][]bufferList = new byte[endChunk + 32][];
      System.arraycopy(_bufferList, 0, bufferList, 0, _bufferList.length);
      _bufferList = bufferList;
    }

    for (; chunk <= endChunk; chunk++) {
      if (_bufferList[chunk] == null)
        _bufferList[chunk] = new byte[SIZE];
    }
  }

  /**
   * Returns the hash code.
   */
  @Override
  public int hashCode()
  {
    if (_hashCode != 0)
      return _hashCode;
    
    int hash = 37;

    int length = _length;

    byte [][]bufferList = _bufferList;
    for (int i = 0; i < length; i++) {
      hash = 65521 * hash + (bufferList[i / SIZE][i % SIZE] & 0xff);
    }

    _hashCode = hash;

    return hash;
  }

  @Override
  public String toDebugString()
  {
    StringBuilder sb = new StringBuilder();

    int length = length();

    sb.append("string(");
    sb.append(length);
    sb.append(") \"");

    int appendLength = length > 256 ? 256 : length;

    for (int i = 0; i < appendLength; i++)
      sb.append(charAt(i));

    if (length > 256)
      sb.append(" ...");

    sb.append('"');

    return sb.toString();
  }

  @Override
  public void varDumpImpl(Env env,
                          WriteStream out,
                          int depth,
                          IdentityHashMap<Value, String> valueSet)
    throws IOException
  {
    int length = length();

    if (length < 0)
        length = 0;
    
    out.print("string(");
    out.print(length);
    out.print(") \"");

    for (int i = 0; i < length; i++) {
      int ch = charAt(i);

      out.print((char) ch);
    }

    out.print("\"");
    
    /*
    int length = length();

    if (length < 0)
        length = 0;

    out.print("string");
    
    out.print("(");
    out.print(length);
    out.print(") \"");

    for (int i = 0; i < length; i++) {
      char ch = charAt(i);

      if (0x20 <= ch && ch <= 0x7f || ch == '\t' || ch == '\r' || ch == '\n')
        out.print(ch);
      else if (ch <= 0xff)
        out.print("\\x"
        + Integer.toHexString(ch / 16) + Integer.toHexString(ch % 16));
      else {
        out.print("\\u"
                  + Integer.toHexString((ch >> 12) & 0xf)
                  + Integer.toHexString((ch >> 8) & 0xf)
                  + Integer.toHexString((ch >> 4) & 0xf)
                  + Integer.toHexString((ch) & 0xf));
      }
    }

    out.print("\"");
    */
  }

  class BuilderInputStream extends InputStream {
    private int _index;
    
    /**
     * Reads the next byte.
     */
    @Override
    public int read()
    {
      if (_index < _length)
        return charAt(_index++);
      else
        return -1;
    }

    /**
     * Reads into a buffer.
     */
    @Override
    public int read(byte []buffer, int offset, int length)
    {
      int sublen = _length - _index;

      if (length < sublen)
        sublen = length;

      if (sublen <= 0)
        return -1;

      for (int i = 0; i < sublen; i++)
        buffer[offset + i] = (byte) charAt(_index + i);

      _index += sublen;

      return sublen;
    }
  }

  class BuilderOutputStream extends OutputStream {
    /**
     * Writes the next byte.
     */
    @Override
    public void write(int ch)
    {
      append(ch);
    }

    /**
     * Reads into a buffer.
     */
    @Override
    public void write(byte []buffer, int offset, int length)
    {
      append(buffer, offset, length);
    }
  }
}

