/*

  *

  * Copyright (c) 1994

  * Hewlett-Packard Company

  *

  * Copyright (c) 1996,1997

  * Silicon Graphics Computer Systems, Inc.

  *

  * Copyright (c) 1997

  * Moscow Center for SPARC Technology

  *

  * Copyright (c) 1999

  * Boris Fomitchev

  *

  * 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.

  *

  */

 /* NOTE: This is an internal header file, included by other STL headers.

  *   You should not attempt to use it directly.

  */

 #ifndef _STLP_INTERNAL_TEMPBUF_H

 #define _STLP_INTERNAL_TEMPBUF_H

 #ifndef _STLP_CLIMITS

 #  include <climits>

 #endif

 #ifndef _STLP_INTERNAL_CSTDLIB

 #  include <stl/_cstdlib.h>

 #endif

 #ifndef _STLP_INTERNAL_UNINITIALIZED_H

 #  include <stl/_uninitialized.h>

 #endif

 _STLP_BEGIN_NAMESPACE

 template <class _Tp>

 pair<_Tp*, ptrdiff_t>  _STLP_CALL

 __get_temporary_buffer(ptrdiff_t __len, _Tp*);

 #ifndef _STLP_NO_EXPLICIT_FUNCTION_TMPL_ARGS

 template <class _Tp>

 inline pair<_Tp*, ptrdiff_t>  _STLP_CALL get_temporary_buffer(ptrdiff_t __len) {

   return __get_temporary_buffer(__len, (_Tp*) 0);

 }

 # if ! defined(_STLP_NO_EXTENSIONS)

 // This overload is not required by the standard; it is an extension.

 // It is supported for backward compatibility with the HP STL, and

 // because not all compilers support the language feature (explicit

 // function template arguments) that is required for the standard

 // version of get_temporary_buffer.

 template <class _Tp>

 inline pair<_Tp*, ptrdiff_t>  _STLP_CALL

 get_temporary_buffer(ptrdiff_t __len, _Tp*) {

   return __get_temporary_buffer(__len, (_Tp*) 0);

 }

 # endif

 #endif

 template <class _Tp>

 inline void  _STLP_CALL return_temporary_buffer(_Tp* __p) {

 // SunPro brain damage

   free((char*)__p);

 }

 template <class _ForwardIterator, class _Tp>

 class _Temporary_buffer {

 private:

   ptrdiff_t  _M_original_len;

   ptrdiff_t  _M_len;

   _Tp*       _M_buffer;

   void _M_allocate_buffer() {

     _M_original_len = _M_len;

     _M_buffer = 0;

     if (_M_len > (ptrdiff_t)(INT_MAX / sizeof(_Tp)))

       _M_len = INT_MAX / sizeof(_Tp);

     while (_M_len > 0) {

       _M_buffer = (_Tp*) malloc(_M_len * sizeof(_Tp));

       if (_M_buffer)

         break;

       _M_len /= 2;

     }

   }

   void _M_initialize_buffer(const _Tp&, const __true_type&) {}

   void _M_initialize_buffer(const _Tp& val, const __false_type&) {

     uninitialized_fill_n(_M_buffer, _M_len, val);

   }

 public:

   ptrdiff_t size() const { return _M_len; }

   ptrdiff_t requested_size() const { return _M_original_len; }

   _Tp* begin() { return _M_buffer; }

   _Tp* end() { return _M_buffer + _M_len; }

   _Temporary_buffer(_ForwardIterator __first, _ForwardIterator __last) {

     // Workaround for a __type_traits bug in the pre-7.3 compiler.

 #   if defined(__sgi) && !defined(__GNUC__) && _COMPILER_VERSION < 730

     typedef typename __type_traits<_Tp>::is_POD_type _Trivial;

 #   else

     typedef typename __type_traits<_Tp>::has_trivial_default_constructor  _Trivial;

 #   endif

     _STLP_TRY {

       _M_len = distance(__first, __last);

       _M_allocate_buffer();

       if (_M_len > 0)

         _M_initialize_buffer(*__first, _Trivial());

     }

     _STLP_UNWIND(free(_M_buffer); _M_buffer = 0; _M_len = 0)

   }

   ~_Temporary_buffer() {

     _STLP_STD::_Destroy_Range(_M_buffer, _M_buffer + _M_len);

     free(_M_buffer);

   }

 private:

   // Disable copy constructor and assignment operator.

   _Temporary_buffer(const _Temporary_buffer<_ForwardIterator, _Tp>&) {}

   void operator=(const _Temporary_buffer<_ForwardIterator, _Tp>&) {}

 };

 # ifndef _STLP_NO_EXTENSIONS

 // Class temporary_buffer is not part of the standard.  It is an extension.

 template <class _ForwardIterator,

           class _Tp

 #ifdef _STLP_CLASS_PARTIAL_SPECIALIZATION

                     = typename iterator_traits<_ForwardIterator>::value_type

 #endif /* _STLP_CLASS_PARTIAL_SPECIALIZATION */

          >

 struct temporary_buffer : public _Temporary_buffer<_ForwardIterator, _Tp>

 {

   temporary_buffer(_ForwardIterator __first, _ForwardIterator __last)

     : _Temporary_buffer<_ForwardIterator, _Tp>(__first, __last) {}

   ~temporary_buffer() {}

 };

 # endif /* _STLP_NO_EXTENSIONS */

 _STLP_END_NAMESPACE

 # ifndef _STLP_LINK_TIME_INSTANTIATION

 #  include <stl/_tempbuf.c>

 # endif

 #endif /* _STLP_INTERNAL_TEMPBUF_H */

 // Local Variables:

 // mode:C++

 // End: