/*

 * Copyright (c) 1997-1999

 * Silicon Graphics Computer Systems, Inc.

 *

 * Copyright (c) 1999

 * Boris Fomitchev

 *

 * Copyright (c) 2003

 * Francois Dumont

 *

 * This material is provided "as is", with absolutely no warranty expressed

 * or implied. Any use is at your own risk.

 *

 * Permission to use or copy this software for any purpose is hereby granted

 * without fee, provided the above notices are retained on all copies.

 * Permission to modify the code and to distribute modified code is granted,

 * provided the above notices are retained, and a notice that the code was

 * modified is included with the above copyright notice.

 *

 */

#ifndef _STLP_STRING_BASE_H

#define _STLP_STRING_BASE_H

// ------------------------------------------------------------

// Class _String_base.

// _String_base is a helper class that makes it it easier to write an

// exception-safe version of basic_string.  The constructor allocates,

// but does not initialize, a block of memory.  The destructor

// deallocates, but does not destroy elements within, a block of

// memory.  The destructor assumes that _M_start either is null, or else

// points to a block of memory that was allocated using _String_base's

// allocator and whose size is _M_end_of_storage._M_data - _M_start.

_STLP_BEGIN_NAMESPACE

_STLP_MOVE_TO_PRIV_NAMESPACE

#ifndef _STLP_SHORT_STRING_SZ

#  define _STLP_SHORT_STRING_SZ 16

#endif

template <class _Tp, class _Alloc>

class _String_base {

  typedef _String_base<_Tp, _Alloc> _Self;

protected:

  _STLP_FORCE_ALLOCATORS(_Tp, _Alloc)

public:

  //dums: Some compiler(MSVC6) require it to be public not simply protected!

  enum {_DEFAULT_SIZE = _STLP_SHORT_STRING_SZ};

  //This is needed by the full move framework

  typedef typename _Alloc_traits<_Tp, _Alloc>::allocator_type allocator_type;

  typedef _STLP_alloc_proxy<_Tp*, _Tp, allocator_type> _AllocProxy;

  typedef size_t size_type;

private:

#if defined (_STLP_USE_SHORT_STRING_OPTIM)

  union _Buffers {

    _Tp*  _M_dynamic_buf;

    _Tp   _M_static_buf[_DEFAULT_SIZE];

  } _M_buffers;

#else

  _Tp*    _M_start;

#endif /* _STLP_USE_SHORT_STRING_OPTIM */

protected:

#if defined (_STLP_USE_SHORT_STRING_OPTIM)

  bool _M_using_static_buf() const {

    return (_M_end_of_storage._M_data == _M_buffers._M_static_buf + _DEFAULT_SIZE);

  }

  _Tp const* _M_Start() const {

    return _M_using_static_buf()?_M_buffers._M_static_buf:_M_buffers._M_dynamic_buf;

  }

  _Tp* _M_Start() {

    return _M_using_static_buf()?_M_buffers._M_static_buf:_M_buffers._M_dynamic_buf;

  }

#else

  _Tp const* _M_Start() const {return _M_start;}

  _Tp* _M_Start() {return _M_start;}

#endif /* _STLP_USE_SHORT_STRING_OPTIM */

  _Tp*    _M_finish;

  _AllocProxy _M_end_of_storage;

  _Tp const* _M_Finish() const {return _M_finish;}

  _Tp* _M_Finish() {return _M_finish;}

  // Precondition: 0 < __n <= max_size().

  void _M_allocate_block(size_t __n = _DEFAULT_SIZE);

  void _M_deallocate_block() {

#if defined (_STLP_USE_SHORT_STRING_OPTIM)

    if (!_M_using_static_buf() && (_M_buffers._M_dynamic_buf != 0))

      _M_end_of_storage.deallocate(_M_buffers._M_dynamic_buf, _M_end_of_storage._M_data - _M_buffers._M_dynamic_buf);

#else

    if (_M_start != 0)

      _M_end_of_storage.deallocate(_M_start, _M_end_of_storage._M_data - _M_start);

#endif /* _STLP_USE_SHORT_STRING_OPTIM */

  }

  size_t max_size() const {

    const size_type __string_max_size = size_type(-1) / sizeof(_Tp);

    typename allocator_type::size_type __alloc_max_size = _M_end_of_storage.max_size();

    return (min)(__alloc_max_size, __string_max_size) - 1;

  }

  _String_base(const allocator_type& __a)

#if defined (_STLP_USE_SHORT_STRING_OPTIM)

    : _M_finish(_M_buffers._M_static_buf), _M_end_of_storage(__a, _M_buffers._M_static_buf + _DEFAULT_SIZE)

#else

    : _M_start(0), _M_finish(0), _M_end_of_storage(__a, (_Tp*)0)

#endif

    {}

  _String_base(const allocator_type& __a, size_t __n)

#if defined (_STLP_USE_SHORT_STRING_OPTIM)

    : _M_finish(_M_buffers._M_static_buf), _M_end_of_storage(__a, _M_buffers._M_static_buf + _DEFAULT_SIZE) {

#else

    : _M_start(0), _M_finish(0), _M_end_of_storage(__a, (_Tp*)0) {

#endif

      _M_allocate_block(__n);

    }

#if defined (_STLP_USE_SHORT_STRING_OPTIM)

  void _M_move_src (_Self &src) {

      if (src._M_using_static_buf()) {

        _M_buffers = src._M_buffers;

        _M_finish = _M_buffers._M_static_buf + (src._M_finish - src._M_buffers._M_static_buf);

        _M_end_of_storage._M_data = _M_buffers._M_static_buf + _DEFAULT_SIZE;

      }

      else {

        _M_buffers._M_dynamic_buf = src._M_buffers._M_dynamic_buf;

        _M_finish = src._M_finish;

        _M_end_of_storage._M_data = src._M_end_of_storage._M_data;

        src._M_buffers._M_dynamic_buf = 0;

      }

    }

#endif

  _String_base(__move_source<_Self> src)

#if defined (_STLP_USE_SHORT_STRING_OPTIM)

    : _M_end_of_storage(__move_source<_AllocProxy>(src.get()._M_end_of_storage)) {

      _M_move_src(src.get());

#else

    : _M_start(src.get()._M_start), _M_finish(src.get()._M_finish),

      _M_end_of_storage(__move_source<_AllocProxy>(src.get()._M_end_of_storage)) {

      src.get()._M_start = 0;

#endif

    }

  ~_String_base() { _M_deallocate_block(); }

  void _M_reset(_Tp *__start, _Tp *__finish, _Tp *__end_of_storage) {

#if defined (_STLP_USE_SHORT_STRING_OPTIM)

    _M_buffers._M_dynamic_buf = __start;

#else

    _M_start = __start;

#endif

    _M_finish = __finish;

    _M_end_of_storage._M_data = __end_of_storage;

  }

  void _M_destroy_back () {

#if defined (_STLP_USE_SHORT_STRING_OPTIM)

    if (!_M_using_static_buf())

#endif /* _STLP_USE_SHORT_STRING_OPTIM */

      _STLP_STD::_Destroy(_M_finish);

  }

  void _M_destroy_range(size_t __from_off = 0, size_t __to_off = 1) {

#if defined (_STLP_USE_SHORT_STRING_OPTIM)

    if (!_M_using_static_buf())

      _STLP_STD::_Destroy_Range(_M_buffers._M_dynamic_buf + __from_off, _M_finish + __to_off);

#else

    _STLP_STD::_Destroy_Range(_M_start + __from_off, _M_finish + __to_off);

#endif /* _STLP_USE_SHORT_STRING_OPTIM */

  }

  void _M_destroy_ptr_range(_Tp *__f, _Tp *__l) {

#if defined (_STLP_USE_SHORT_STRING_OPTIM)

    if (!_M_using_static_buf())

#endif /* _STLP_USE_SHORT_STRING_OPTIM */

      _STLP_STD::_Destroy_Range(__f, __l);

  }

  void _M_Swap(_Self &__s) {

#if defined (_STLP_USE_SHORT_STRING_OPTIM)

    if (_M_using_static_buf()) {

      if (__s._M_using_static_buf()) {

        _STLP_STD::swap(_M_buffers, __s._M_buffers);

        _Tp *__tmp = _M_finish;

        _M_finish = _M_buffers._M_static_buf + (__s._M_finish - __s._M_buffers._M_static_buf);

        __s._M_finish = __s._M_buffers._M_static_buf + (__tmp - _M_buffers._M_static_buf);

        //We need to swap _M_end_of_storage for allocators with state:

        _M_end_of_storage.swap(__s._M_end_of_storage);

        _M_end_of_storage._M_data = _M_buffers._M_static_buf + _DEFAULT_SIZE;

        __s._M_end_of_storage._M_data = __s._M_buffers._M_static_buf + _DEFAULT_SIZE;

      } else {

        __s._M_Swap(*this);

        return;

      }

    }

    else if (__s._M_using_static_buf()) {

      _Tp *__tmp = _M_buffers._M_dynamic_buf;

      _Tp *__tmp_finish = _M_finish;

      _Tp *__tmp_end_data = _M_end_of_storage._M_data;

      _M_buffers = __s._M_buffers;

      //We need to swap _M_end_of_storage for allocators with state:

      _M_end_of_storage.swap(__s._M_end_of_storage);

      _M_end_of_storage._M_data = _M_buffers._M_static_buf + _DEFAULT_SIZE;

      _M_finish = _M_buffers._M_static_buf + (__s._M_finish - __s._M_buffers._M_static_buf);

      __s._M_buffers._M_dynamic_buf = __tmp;

      __s._M_end_of_storage._M_data = __tmp_end_data;

      __s._M_finish = __tmp_finish;

    }

    else {

      _STLP_STD::swap(_M_buffers._M_dynamic_buf, __s._M_buffers._M_dynamic_buf);

      _M_end_of_storage.swap(__s._M_end_of_storage);

      _STLP_STD::swap(_M_finish, __s._M_finish);

    }

#else

    _STLP_STD::swap(_M_start, __s._M_start);

    _M_end_of_storage.swap(__s._M_end_of_storage);

    _STLP_STD::swap(_M_finish, __s._M_finish);

#endif /* _STLP_USE_SHORT_STRING_OPTIM */

  }

  void _STLP_FUNCTION_THROWS _M_throw_length_error() const;

  void _STLP_FUNCTION_THROWS _M_throw_out_of_range() const;

};

#undef _STLP_SHORT_STRING_SZ

#if defined (_STLP_USE_TEMPLATE_EXPORT)

_STLP_EXPORT_TEMPLATE_CLASS _String_base<char, allocator<char> >;

#  if defined (_STLP_HAS_WCHAR_T)

_STLP_EXPORT_TEMPLATE_CLASS _String_base<wchar_t, allocator<wchar_t> >;

#  endif

#endif /* _STLP_USE_TEMPLATE_EXPORT */

_STLP_MOVE_TO_STD_NAMESPACE

_STLP_END_NAMESPACE

#endif /* _STLP_STRING_BASE_H */

/*

 * Local Variables:

 * mode:C++

 * End:

 */