/* Generated automatically by jlpp - do not edit. */

#include <jakelib2.h>
static jakelib::lang::String* jakelib2_strings[] = {null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null};

// "Allocating "
static jchar chars_jakelib2_str_0[] = {65,108,108,111,99,97,116,105,110,103,32};
// " bytes of memory."
static jchar chars_jakelib2_str_1[] = {32,98,121,116,101,115,32,111,102,32,109,101,109,111,114,121,46};
// ""
static jchar chars_jakelib2_str_2[] = {0};
// " < 0"
static jchar chars_jakelib2_str_3[] = {32,60,32,48};
// ""
static jchar chars_jakelib2_str_4[] = {0};
// " < 0"
static jchar chars_jakelib2_str_5[] = {32,60,32,48};
// ""
static jchar chars_jakelib2_str_6[] = {0};
// " < 0"
static jchar chars_jakelib2_str_7[] = {32,60,32,48};
// ""
static jchar chars_jakelib2_str_8[] = {0};
// " > "
static jchar chars_jakelib2_str_9[] = {32,62,32};
// "null"
static jchar chars_jakelib2_str_10[] = {110,117,108,108};
// "Specified offset value negative: "
static jchar chars_jakelib2_str_11[] = {83,112,101,99,105,102,105,101,100,32,111,102,102,115,101,116,32,118,97,108,117,101,32,110,101,103,97,116,105,118,101,58,32};
// " < 0"
static jchar chars_jakelib2_str_12[] = {32,60,32,48};
// "Specified offset value larger than length: "
static jchar chars_jakelib2_str_13[] = {83,112,101,99,105,102,105,101,100,32,111,102,102,115,101,116,32,118,97,108,117,101,32,108,97,114,103,101,114,32,116,104,97,110,32,108,101,110,103,116,104,58,32};
// " > "
static jchar chars_jakelib2_str_14[] = {32,62,32};
// "Specified offset value negative: "
static jchar chars_jakelib2_str_15[] = {83,112,101,99,105,102,105,101,100,32,111,102,102,115,101,116,32,118,97,108,117,101,32,110,101,103,97,116,105,118,101,58,32};
// " < 0 "
static jchar chars_jakelib2_str_16[] = {32,60,32,48,32};
// "Specified offset value larger than length: "
static jchar chars_jakelib2_str_17[] = {83,112,101,99,105,102,105,101,100,32,111,102,102,115,101,116,32,118,97,108,117,101,32,108,97,114,103,101,114,32,116,104,97,110,32,108,101,110,103,116,104,58,32};
// " > "
static jchar chars_jakelib2_str_18[] = {32,62,32};
#line 1 "lang/StringBuffer.jlc"
// -*- c++ -*-

/*
 * Jakelib2 - General purpose C++ library
 * Copyright (C) 2001 Florian Wolff  (florian@donuz.de)
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library 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.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * $Id: StringBuffer.jlc,v 1.8 2003/09/27 08:10:28 florian Exp $
 */


#include "jakelib2.h"
#include "jakelib2/lang/StringBuffer.h"
#include "jakelib2/lang/Character.h"
#include "jakelib2/lang/Integer.h"
#include "jakelib2/lang/Long.h"
#include "jakelib2/lang/Float.h"
#include "jakelib2/lang/Double.h"
#include "jakelib2/lang/System.h"
#include "jakelib2/util/ArrayList.h"
#include "jakelib2/util/Hashtable.h"
#include "jakelib2/util/StringComparator.h"

#include <string.h>

using namespace jakelib::lang;
using namespace jakelib::util;

JAKELIB_IMPLEMENT_CLASS("jakelib.lang.StringBuffer", StringBuffer, Object)

#ifndef BORLAND
# include <ctype.h>
# include <stdarg.h>
#endif

int StringBuffer::initialCapacity = 64;
int StringBuffer::increment = 64;


/*****************************************************************************\
 * StringBuffer                                                               |
 *****************************************************************************/
StringBuffer::StringBuffer(String* str) 
{ 
  int l = str->length();

  init(l);
  memcpy(buffer, str->protectedGetChars(), l * sizeof(jchar));
  len = l;
}

StringBuffer::StringBuffer() 
{ 
  init(initialCapacity);
}

StringBuffer::StringBuffer(const jbyte* str)
{
  init(strlen(str));
  this->len = strlen(str);

  for (int x = 0; x < len; x++)
    buffer[x] = (jchar) str[x];
}

StringBuffer::StringBuffer(int len)
{
  init(len);
}


/*****************************************************************************\
 * init                                                                       |
 *****************************************************************************/
void StringBuffer::init(int initialCapacity)
{
  _capacity = 0;
  len = 0;
  buffer = null;
  if (initialCapacity >= StringBuffer::initialCapacity)
    ensureCapacity(initialCapacity);
  else 
    ensureCapacity(StringBuffer::initialCapacity);
}


/*****************************************************************************\
 * ensureCapacity                                                             |
 *****************************************************************************/
void StringBuffer::ensureCapacity(int minimumCapacity)
{
  if (_capacity >= minimumCapacity) {
    return;
  }
  else {
    int newCapacity = _capacity + increment;
    if (minimumCapacity > newCapacity)
      newCapacity = minimumCapacity;
    jchar* newText = (jchar*) realloc(buffer, sizeof(jchar) * newCapacity);
    if (newText == null) 
      throw new MemoryException(JAKELIB_ONDEMAND(jakelib2_strings[0], new jakelib::lang::String(chars_jakelib2_str_0, 0, 11)) ->plus( (jlong) (sizeof(jchar) * newCapacity)
       )->plus( JAKELIB_ONDEMAND(jakelib2_strings[1], new jakelib::lang::String(chars_jakelib2_str_1, 0, 17))
       )->plus( JAKELIB_AT2("jakelib.lang.StringBuffer.ensureCapacity")));
    else {
      _capacity = newCapacity;
      buffer = newText;
    }
  }
}


/*****************************************************************************\
 * ~StringBuffer                                                              |
 *****************************************************************************/
StringBuffer::~StringBuffer()
{
  free(buffer);
}


/*****************************************************************************\
 * toString                                                                   |
 *****************************************************************************/
String* StringBuffer::toString() 
{ 
  return new String(buffer, 0, len); 
}


// /*****************************************************************************\
//  * getChars                                                                   |
//  *****************************************************************************/
// const char* StringBuffer::latin1() 
// { 
//   return buffer;
// }


/*****************************************************************************\
 * charAt                                                                     |
 *****************************************************************************/
jchar StringBuffer::charAt(int index)
{
  if (index < 0)
    throw new IndexOutOfBoundsException(JAKELIB_ONDEMAND(jakelib2_strings[2], new jakelib::lang::String(chars_jakelib2_str_2, 0, 0)) ->plus( index )->plus( JAKELIB_ONDEMAND(jakelib2_strings[3], new jakelib::lang::String(chars_jakelib2_str_3, 0, 4))
        )->plus( JAKELIB_AT2("jakelib.lang.StringBuffer.charAt")));
  if (index >= len)
    return 0;

  return buffer[index];
}


/*****************************************************************************\
 * setLength                                                                  |
 *****************************************************************************/
void StringBuffer::setLength(int l)
{
  if (l < 0)
    throw new IndexOutOfBoundsException(JAKELIB_ONDEMAND(jakelib2_strings[4], new jakelib::lang::String(chars_jakelib2_str_4, 0, 0)) ->plus( l )->plus( JAKELIB_ONDEMAND(jakelib2_strings[5], new jakelib::lang::String(chars_jakelib2_str_5, 0, 4))
        )->plus( JAKELIB_AT2("jakelib.lang.StringBuffer.setLength")));

  if (len > l)
    len = l;
}


/*****************************************************************************\
 * setCharAt                                                                  |
 *****************************************************************************/
void StringBuffer::setCharAt(int index, jchar c)
{
  if (index < 0)
    throw new StringIndexOutOfBoundsException(JAKELIB_ONDEMAND(jakelib2_strings[6], new jakelib::lang::String(chars_jakelib2_str_6, 0, 0)) ->plus( index )->plus( JAKELIB_ONDEMAND(jakelib2_strings[7], new jakelib::lang::String(chars_jakelib2_str_7, 0, 4))
        )->plus(JAKELIB_AT2("jakelib.lang.StringBuffer.setCharAt")));

  if (index > len)
    throw new StringIndexOutOfBoundsException(JAKELIB_ONDEMAND(jakelib2_strings[8], new jakelib::lang::String(chars_jakelib2_str_8, 0, 0)) ->plus( index )->plus( JAKELIB_ONDEMAND(jakelib2_strings[9], new jakelib::lang::String(chars_jakelib2_str_9, 0, 3)) )->plus( len
        )->plus( JAKELIB_AT2("jakelib.lang.StringBuffer.setCharAt")));

  if (index == len) {
    ensureCapacity(len +1);
    buffer[len] = c;
    len ++;
  }
  else {
    buffer[index] = c;
  }
}


/*****************************************************************************\
 * append                                                                     |
 *****************************************************************************/
StringBuffer* StringBuffer::append(String* str)
{
  if (str != null) {
    ensureCapacity(len + str->length());
    memcpy(&buffer[len], str->protectedGetChars(), str->length() * sizeof(jchar));
    len += str->length();

    return this;
  }
  else {
    return append("null");
  }
}

StringBuffer* StringBuffer::append(Object* obj)
{
  if (obj != null)
    return append(obj->toString());
  else
    return append((String*) null);
}

StringBuffer* StringBuffer::append(jbyte* str)
{
  if (str != null) {
    String s(str);
    append(&s);

    return this;
  }
  else {
    return append("null");
  }
}

StringBuffer* StringBuffer::append(jbyte c)
{
  ensureCapacity(len +1);
  buffer[len] = (jchar) c;
  len ++;

  return this;
}

StringBuffer* StringBuffer::append(jchar c)
{
  ensureCapacity(len +1);
  buffer[len] = c;
  len ++;

  return this;
}

StringBuffer* StringBuffer::append(jlong l)
{
  append(String::valueOf(l));

  return this;
}

StringBuffer* StringBuffer::append(jint i)
{
  append(String::valueOf(i));

  return this;
}

StringBuffer* StringBuffer::append(jfloat f)
{
  append(String::valueOf(f));

  return this;
}

StringBuffer* StringBuffer::append(jdouble d)
{
  append(String::valueOf(d));

  return this;
}


/*****************************************************************************\
 * insert                                                                     |
 *****************************************************************************/
// StringBuffer* StringBuffer::insert(jint offset,
//                                    jchars* str,
//                                    jint str_offset,
//                                    jint inslen)
// {
//   if (offset < 0)
//     throw new StringIndexOutOfBoundsException(`"Specified offset value negative: "` ..
//                                                  offset .. `" < 0"` .. 
//           JAKELIB_AT2("jakelib.lang.StringBuffer.insert(jint,jchars*,jint,jint)"));
  
//   if (offset > len)
//     throw new StringIndexOutOfBoundsException(`"Specified offset larger than buffer length: "` ..
//                                                  offset .. `" > "` .. len ..
//           JAKELIB_AT2("jakelib.lang.StringBuffer.insert(jint,jchars*,jint,jint)"));
  
//   if (inslen < 0)
//     throw new StringIndexOutOfBoundsException(`"Specified insert string length value negative: "` ..
//                                                  offset .. `" < 0"` .. 
//           JAKELIB_AT2("jakelib.lang.StringBuffer.insert(jint,jchars*,jint,jint)"));
  
//   if (str_offset < 0)
//     throw new StringIndexOutOfBoundsException(`"Specified insert string offset value negative: "` ..
//                                                  offset .. `" < 0"` .. 
//           JAKELIB_AT2("jakelib.lang.StringBuffer.insert(jint,jchars*,jint,jint)")); 
  
//   if ((str_offset + inslen) > str->length())
//     throw new StringIndexOutOfBoundsException(`"Specified insert string offset + length larger than it's length: "` ..
//                                                  str_offset + inslen .. `" > "` .. str->length() ..
//           JAKELIB_AT2("jakelib.lang.StringBuffer.insert(jint,jchars*,jint,jint)"));

//   ensureCapacity(len + inslen);

//   jchar* arrptr = null;

//   if (str != null) {
//     arrptr = str->getArray();
//     arrptr += str_offset;
//   }
//   else {
//     String* tmp = `"null"`;
//     arrptr = tmp->protectedGetChars();
//     inslen = tmp->length();
//   }
  
//   memmove(&buffer[offset+inslen], &buffer[offset], (len - offset) * sizeof(jchar));
//   memcpy(&buffer[offset], arrptr, inslen * sizeof(jchar)); 
  
//   len += inslen;
//   return this;
// }

StringBuffer* StringBuffer::insert(jint offset, Object* obj)
{
  return insert(offset, obj != null ? obj->toString() : JAKELIB_ONDEMAND(jakelib2_strings[10], new jakelib::lang::String(chars_jakelib2_str_10, 0, 4)));
}

StringBuffer* StringBuffer::insert(jint offset, String* str)
{
  if (offset < 0)
    throw new StringIndexOutOfBoundsException(JAKELIB_ONDEMAND(jakelib2_strings[11], new jakelib::lang::String(chars_jakelib2_str_11, 0, 33)) ->plus(
                                                 offset )->plus( JAKELIB_ONDEMAND(jakelib2_strings[12], new jakelib::lang::String(chars_jakelib2_str_12, 0, 4)) )->plus( 
          JAKELIB_AT2("jakelib.lang.StringBuffer.insert(jint,String*)")));
  
  if (offset > len)
    throw new StringIndexOutOfBoundsException(JAKELIB_ONDEMAND(jakelib2_strings[13], new jakelib::lang::String(chars_jakelib2_str_13, 0, 43)) ->plus(
                                                 offset )->plus( JAKELIB_ONDEMAND(jakelib2_strings[14], new jakelib::lang::String(chars_jakelib2_str_14, 0, 3)) )->plus( len )->plus(
          JAKELIB_AT2("jakelib.lang.StringBuffer.insert(jint,String*)")));

  if (str == null)
    str = new String("null");

  int length = str->length();

  ensureCapacity(len + length);
  memmove(&buffer[offset + length], &buffer[offset], sizeof(jchar) * (len - offset));
  memcpy(&buffer[offset], str->protectedGetChars(), sizeof(jchar) * length);

  len += length;
  return this;
}

// StringBuffer* StringBuffer::insert(jint offset, jchars* data)
// {
//   return insert(offset, data, 0, data->length());
// }

StringBuffer* StringBuffer::insert(jint offset, jboolean boolean)
{
  return insert(offset, boolean ? new StringBuffer("true") : 
                                  new StringBuffer("false"));
}

StringBuffer* StringBuffer::insert(jint offset, jchar ch)
{
  if (offset < 0)
     throw new StringIndexOutOfBoundsException(JAKELIB_ONDEMAND(jakelib2_strings[15], new jakelib::lang::String(chars_jakelib2_str_15, 0, 33)) ->plus(
                                                 offset )->plus( JAKELIB_ONDEMAND(jakelib2_strings[16], new jakelib::lang::String(chars_jakelib2_str_16, 0, 5)) )->plus( 
          JAKELIB_AT2("jakelib.lang.StringBuffer.insert(jint,String*)")));
  if (offset > len)
     throw new StringIndexOutOfBoundsException(JAKELIB_ONDEMAND(jakelib2_strings[17], new jakelib::lang::String(chars_jakelib2_str_17, 0, 43)) ->plus(
                                                 offset )->plus( JAKELIB_ONDEMAND(jakelib2_strings[18], new jakelib::lang::String(chars_jakelib2_str_18, 0, 3)) )->plus( len )->plus(
          JAKELIB_AT2("jakelib.lang.StringBuffer.insert(jint,String*)")));

  ensureCapacity(len + 1);

  memmove(&buffer[offset + 1], &buffer[offset], sizeof(jchar) * (len - offset));
  buffer[offset] = ch;
  len++;
  return this;
}

StringBuffer* StringBuffer::insert(jint offset, jint inum)
{
  return insert(offset, String::valueOf(inum));
}

StringBuffer* StringBuffer::insert(jint offset, jlong lnum)
{
  return insert(offset, Long::toString(lnum, 10));
}

StringBuffer* StringBuffer::insert(jint offset, jfloat fnum)
{
  return insert(offset, Float::toString(fnum));
}

StringBuffer* StringBuffer::insert(jint offset, jdouble dnum)
{
  return insert(offset, Double::toString(dnum));
}