#ifndef __pxx_string_ih__
#define __pxx_string_ih__

#include "pxx_string.hh"
#include "pxx_common.ih"
#include "pxx_default_allocator.ih"
//#include "pxx_stream.ih"

#include <typeinfo>
#include <new>
#include <string.h>
#include <wchar.h>

namespace pxx
{

template <typename type_t>
String<type_t>::String (size_t _length /* = 0 */) :
  length (_length)
{
//  PMETHOD;
  size_t n;
  if ((default_allocator.get_features() & ALLOCATOR_HAS_GET_REAL_SIZE) != 0) {
    n = default_allocator.get_real_size(
      sizeof(StringDataInfo) + sizeof(type_t) * (length + 1));
  } else {
    n = exps_of_two[
      get_order(sizeof(StringDataInfo) + sizeof(type_t) * (length + 1))];
  }
  datainfo = static_cast<StringDataInfo*>(default_allocator.allocate(n));
  datainfo->ref_count = 1;
  datainfo->capacity = (n - sizeof(StringDataInfo)) / sizeof(type_t) - 1;
  data = reinterpret_cast<type_t*>(
    ptr_add_offset(datainfo, sizeof(StringDataInfo)));
  data[length] = 0;
}

template <typename type_t>
String<type_t>::String (
  type_t const* _s, const_t _const /* = non_const_data */
)
{
//  PMETHOD;
  size_t n = compute_length(_s);
  new(this) String(_s, n, _const);
}

template <typename type_t>
String<type_t>::String (
  type_t const* _s, size_t _len, const_t _const /* = non_const_data */
)
{
//  PMETHOD;
  if (_const == non_const_data) {
    new(this) String(_len);
    memcpy(data, _s, (_len) * sizeof(type_t));
    data[_len] = 0;
  } else {
    datainfo = null;
    length = _len;
    data = const_cast<type_t*>(_s);
    if (data[_len] != 0) throw NonTerminated();
  }
}

template <typename type_t>
String<type_t>::String (String const& _s) :
  data (_s.data),
  datainfo (_s.datainfo),
  length (_s.length)
{
//  PMETHOD;
  if (datainfo != null) datainfo->ref_count++;
}

template <typename type_t>
String<type_t>::~String ()
{
//  PMETHOD;
  if (datainfo != null) {
    if (--(datainfo->ref_count) == 0) default_allocator.deallocate(datainfo);
  }
}

template <typename type_t>
String<type_t>& String<type_t>::operator = (String const& _s)
{
  if (this != &_s) {
    this->~String();
    new(this) String(_s);
  }
  return self;
}

template <typename type_t>
type_t const* String<type_t>::get_data () const
{
  return data;
}

template <typename type_t>
String<type_t> String<type_t>::operator + (String const& _s) const
{
  String s(length + _s.length);
  memcpy(s.data, data, length * sizeof(type_t));
  memcpy(s.data + length, _s.data, _s.length * sizeof(type_t));
  s.data[s.length] = 0;
  return s;
}

#if 0
template <typename type_t>
String<type_t>& String<type_t>::operator << (String const& _s)
{
  expand(_s.length);
  memcpy(data + length, _s.data, _s.length * sizeof(type_t));
  length += _s.length;
  data[length] = 0;
  return self;
}
#endif

template <typename type_t>
String<type_t> String<type_t>::head (size_t _len) const
{
  if (_len <= length) {
    return String(data, _len);
  } else {
    throw OutOfRange();
  }
}

template <typename type_t>
String<type_t> String<type_t>::tail (size_t _from) const
{
  if (_from <= length) {
    return String(data + _from, length - _from);
  } else {
    throw OutOfRange();
  }
}

template <typename type_t>
String<type_t> String<type_t>::substring (size_t _from, size_t _len) const
{
  if (_from + _len <= length) {
    return String(data + _from, _len);
  } else {
    throw OutOfRange();
  }
}

template <typename type_t>
void String<type_t>::replace (size_t _from, String const& _s)
{
  if (_from <= length) {
    deconstify();
    if (_s.length > length - _from) {
      expand(_from + _s.length - length);
      length = _from + _s.length;
      data[length] = 0;
    }
    memcpy(data + _from, _s.data, _s.length * sizeof(type_t));
  } else {
    throw OutOfRange();
  }
}

template <typename type_t>
void String<type_t>::expand (size_t _extra)
{
  deconstify();
  size_t n;
  if (datainfo->capacity - length < _extra) {
    if ((default_allocator.get_features() & ALLOCATOR_HAS_GET_REAL_SIZE) != 0) {
      n = default_allocator.get_real_size(
        sizeof(StringDataInfo) + sizeof(type_t) * (length + _extra + 1));
    } else {
      n = exps_of_two[get_order(
        sizeof(StringDataInfo) + sizeof(type_t) * (length + _extra + 1))];
    }
    datainfo = static_cast<StringDataInfo*>(
      default_allocator.reallocate(datainfo, n));
    datainfo->capacity = (n - sizeof(StringDataInfo)) / sizeof(type_t) - 1;
    data = reinterpret_cast<type_t*>(
      ptr_add_offset(datainfo, sizeof(StringDataInfo)));
  }
}

template <typename type_t>
type_t const& String<type_t>::operator [] (size_t _index) const
{
  if (_index < length) {
    return data[_index];
  } else {
    throw OutOfRange();
  }
}

template <typename type_t>
type_t& String<type_t>::operator [] (size_t _index)
{
  if (_index < length) {
    return data[_index];
  } else {
    throw OutOfRange();
  }
}

template <typename type_t>
size_t String<type_t>::get_length () const
{
  return length;
}

template <typename type_t>
size_t String<type_t>::get_capacity () const
{
  if (datainfo != null) return datainfo->capacity;
  else return length;
}

template <typename type_t>
void String<type_t>::deconstify ()
{
  if (datainfo == null || (datainfo != null && datainfo->ref_count > 1)) {
    type_t* old_data = data;
    size_t old_length = length;
    this->~String();
    new(this) String(old_data, old_length);
  }
}

template <typename type_t>
size_t String<type_t>::compute_length (type_t const* _strdata)
{
  size_t len = 0;
  while (*_strdata++ != 0) len++;
  return len;
}

template <>
size_t String<char>::compute_length (char const* _strdata)
{
  return strlen(_strdata);
}

template <>
size_t String<wchar_t>::compute_length (wchar_t const* _strdata)
{
  return wcslen(_strdata);
}

#if 0
template <typename type_t>
Stream& operator << (Stream& _stream, String<type_t> _s)
{
  type_t const* p = _s.data;
  type_t const* q = p + _s.length;
  while (p < q) {
    _stream << *p++;
  }
  return _stream;
}
#endif


}

#endif // __pxx_string_ih__