stl_alloc.h

本系统采用VC开发.可实现点云数据的处理,图像缩放,生成曲面.

  // Create one to get critical section initialized.
  // We do this onece per file, but only the first constructor
  // does anything.
  static alloc __node_allocator_dummy_instance;
# endif

#endif /* ! __USE_MALLOC */

// This implements allocators as specified in the C++ standard.  
//
// Note that standard-conforming allocators use many language features
// that are not yet widely implemented.  In particular, they rely on
// member templates, partial specialization, partial ordering of function
// templates, the typename keyword, and the use of the template keyword
// to refer to a template member of a dependent type.

#ifdef __STL_USE_STD_ALLOCATORS

template <class _T>
class allocator {
  typedef alloc _Alloc;          // The underlying allocator.
public:
  typedef size_t    size_type;
  typedef ptrdiff_t difference_type;
  typedef _T*       pointer;
  typedef const _T* const_pointer;
  typedef _T&       reference;
  typedef const _T& const_reference;
  typedef _T        value_type;

  template <class _T1> struct rebind {
    typedef allocator<_T1> other;
  };

  allocator() __STL_NOTHROW {}
  allocator(const allocator&) __STL_NOTHROW {}
  template <class _T1> allocator(const allocator<_T1>&) __STL_NOTHROW {}
  ~allocator() __STL_NOTHROW {}

  pointer address(reference __x) const { return &__x; }
  const_pointer address(const_reference __x) const { return &__x; }

  // __n is permitted to be 0.  The C++ standard says nothing about what
  // the return value is when __n == 0.
  _T* allocate(size_type __n, const void* = 0) {
    return __n != 0 ? static_cast<_T*>(_Alloc::allocate(__n * sizeof(_T))) 
                    : 0;
  }

  // __p is not permitted to be a null pointer.
  void deallocate(pointer __p, size_type __n)
    { _Alloc::deallocate(__p, __n * sizeof(_T)); }

  size_type max_size() const __STL_NOTHROW 
    { return size_t(-1) / sizeof(_T); }

  void construct(pointer __p, const _T& __val) { new(__p) _T(__val); }
  void destroy(pointer __p) { __p->~_T(); }
};

template<>
class allocator<void> {
  typedef size_t      size_type;
  typedef ptrdiff_t   difference_type;
  typedef void*       pointer;
  typedef const void* const_pointer;
  typedef void        value_type;

  template <class _T1> struct rebind {
    typedef allocator<_T1> other;
  };
};


template <class T1, class T2>
inline bool operator==(const allocator<T1>& __a1,
                       const allocator<T2>& __a2) 
{
  return true;
}

template <class T1, class T2>
inline bool operator!=(const allocator<T1>& __a1,
                       const allocator<T2>& __a2)
{
  return false;
}

// Allocator adaptor to turn an SGI-style allocator (e.g. alloc, malloc_alloc)
// into a standard-conforming allocator.   Note that this adaptor does
// *not* assume that all objects of the underlying alloc class are
// identical, nor does it assume that all of the underlying alloc's
// member functions are static member functions.  Note, also, that 
// __allocator<_T, alloc> is essentially the same thing as allocator<_T>.

template <class _T, class _Alloc>
struct __allocator {
  _Alloc __underlying_alloc;

  typedef size_t    size_type;
  typedef ptrdiff_t difference_type;
  typedef _T*       pointer;
  typedef const _T* const_pointer;
  typedef _T&       reference;
  typedef const _T& const_reference;
  typedef _T        value_type;

  template <class _T1> struct rebind {
    typedef __allocator<_T1, _Alloc> other;
  };

  __allocator() __STL_NOTHROW {}
  __allocator(const __allocator& __a) __STL_NOTHROW
    : __underlying_alloc(__a.__underlying_alloc) {}
  template <class _T1> 
  __allocator(const __allocator<_T1, _Alloc>& __a) __STL_NOTHROW
    : __underlying_alloc(__a.__underlying_alloc) {}
  ~__allocator() __STL_NOTHROW {}

  pointer address(reference __x) const { return &__x; }
  const_pointer address(const_reference __x) const { return &__x; }

  // __n is permitted to be 0.
  _T* allocate(size_type __n, const void* = 0) {
    return __n != 0 
        ? static_cast<_T*>(__underlying_alloc.allocate(__n * sizeof(_T))) 
        : 0;
  }

  // __p is not permitted to be a null pointer.
  void deallocate(pointer __p, size_type __n)
    { __underlying_alloc.deallocate(__p, __n * sizeof(_T)); }

  size_type max_size() const __STL_NOTHROW 
    { return size_t(-1) / sizeof(_T); }

  void construct(pointer __p, const _T& __val) { new(__p) _T(__val); }
  void destroy(pointer __p) { __p->~_T(); }
};

template <class _Alloc>
class __allocator<void, _Alloc> {
  typedef size_t      size_type;
  typedef ptrdiff_t   difference_type;
  typedef void*       pointer;
  typedef const void* const_pointer;
  typedef void        value_type;

  template <class _T1> struct rebind {
    typedef __allocator<_T1, _Alloc> other;
  };
};

template <class _T, class _Alloc>
inline bool operator==(const __allocator<_T, _Alloc>& __a1,
                       const __allocator<_T, _Alloc>& __a2)
{
  return __a1.__underlying_alloc == __a2.__underlying_alloc;
}

#ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDER
template <class _T, class _Alloc>
inline bool operator!=(const __allocator<_T, _Alloc>& __a1,
                       const __allocator<_T, _Alloc>& __a2)
{
  return __a1.__underlying_alloc != __a2.__underlying_alloc;
}
#endif /* __STL_FUNCTION_TMPL_PARTIAL_ORDER */

// Comparison operators for all of the predifined SGI-style allocators.
// This ensures that __allocator<malloc_alloc> (for example) will
// work correctly.

template <int inst>
inline bool operator==(const __malloc_alloc_template<inst>&,
                       const __malloc_alloc_template<inst>&)
{
  return true;
}

#ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDER
template <int __inst>
inline bool operator!=(const __malloc_alloc_template<__inst>&,
                       const __malloc_alloc_template<__inst>&)
{
  return false;
}
#endif /* __STL_FUNCTION_TMPL_PARTIAL_ORDER */

template <bool __threads, int __inst>
inline bool operator==(const __default_alloc_template<__threads, __inst>&,
                       const __default_alloc_template<__threads, __inst>&)
{
  return true;
}

#ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDER
template <bool __threads, int __inst>
inline bool operator!=(const __default_alloc_template<__threads, __inst>&,
                       const __default_alloc_template<__threads, __inst>&)
{
  return false;
}
#endif /* __STL_FUNCTION_TMPL_PARTIAL_ORDER */

template <class _Alloc>
inline bool operator==(const debug_alloc<_Alloc>&,
                       const debug_alloc<_Alloc>&) {
  return true;
}

#ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDER
template <class _Alloc>
inline bool operator!=(const debug_alloc<_Alloc>&,
                       const debug_alloc<_Alloc>&) {
  return false;
}
#endif /* __STL_FUNCTION_TMPL_PARTIAL_ORDER */

// Another allocator adaptor: _Alloc_traits.  This serves two
// purposes.  First, make it possible to write containers that can use
// either SGI-style allocators or standard-conforming allocator.
// Second, provide a mechanism so that containers can query whether or
// not the allocator has distinct instances.  If not, the container
// can avoid wasting a word of memory to store an empty object.

// This adaptor uses partial specialization.  The general case of
// _Alloc_traits<_T, _Alloc> assumes that _Alloc is a
// standard-conforming allocator, possibly with non-equal instances
// and non-static members.  (It still behaves correctly even if _Alloc
// has static member and if all instances are equal.  Refinements
// affect performance, not correctness.)

// There are always two members: allocator_type, which is a standard-
// conforming allocator type for allocating objects of type _T, and
// _S_instanceless, a static const member of type bool.  If
// _S_instanceless is true, this means that there is no difference
// between any two instances of type allocator_type.  Furthermore, if
// _S_instanceless is true, then _Alloc_traits has one additional
// member: _Alloc_type.  This type encapsulates allocation and
// deallocation of objects of type _T through a static interface; it
// has two member functions, whose signatures are
//    static _T* allocate(size_t)
//    static void deallocate(_T*, size_t)

// The fully general version.

template <class _T, class _Allocator>
struct _Alloc_traits
{
  static const bool _S_instanceless = false;
  typedef typename _Allocator::__STL_TEMPLATE rebind<_T>::other 
          allocator_type;
};

template <class _T, class _Allocator>
const bool _Alloc_traits<_T, _Allocator>::_S_instanceless;

// The version for the default allocator.

template <class _T, class _T1>
struct _Alloc_traits<_T, allocator<_T1> >
{
  static const bool _S_instanceless = true;
  typedef simple_alloc<_T, alloc> _Alloc_type;
  typedef allocator<_T> allocator_type;
};

// Versions for the predefined SGI-style allocators.

template <class _T, int __inst>
struct _Alloc_traits<_T, __malloc_alloc_template<__inst> >
{
  static const bool _S_instanceless = true;
  typedef simple_alloc<_T, __malloc_alloc_template<__inst> > _Alloc_type;
  typedef __allocator<_T, __malloc_alloc_template<__inst> > allocator_type;
};

template <class _T, bool __threads, int __inst>
struct _Alloc_traits<_T, __default_alloc_template<__threads, __inst> >
{
  static const bool _S_instanceless = true;
  typedef simple_alloc<_T, __default_alloc_template<__threads, __inst> > 
          _Alloc_type;
  typedef __allocator<_T, __default_alloc_template<__threads, __inst> > 
          allocator_type;
};

template <class _T, class _Alloc>
struct _Alloc_traits<_T, debug_alloc<_Alloc> >
{
  static const bool _S_instanceless = true;
  typedef simple_alloc<_T, debug_alloc<_Alloc> > _Alloc_type;
  typedef __allocator<_T, debug_alloc<_Alloc> > allocator_type;
};

// Versions for the __allocator adaptor used with the predefined
// SGI-style allocators.

template <class _T, class _T1, int __inst>
struct _Alloc_traits<_T, __allocator<_T1, __malloc_alloc_template<__inst> > >
{
  static const bool _S_instanceless = true;
  typedef simple_alloc<_T, __malloc_alloc_template<__inst> > _Alloc_type;
  typedef __allocator<_T, __malloc_alloc_template<__inst> > allocator_type;
};

template <class _T, class _T1, bool __thr, int __inst>
struct _Alloc_traits<_T, 
                      __allocator<_T1, 
                                  __default_alloc_template<__thr, __inst> > >
{
  static const bool _S_instanceless = true;
  typedef simple_alloc<_T, __default_alloc_template<__thr,__inst> > 
          _Alloc_type;
  typedef __allocator<_T, __default_alloc_template<__thr,__inst> > 
          allocator_type;
};

template <class _T, class _T1, class _Alloc>
struct _Alloc_traits<_T, __allocator<_T1, debug_alloc<_Alloc> > >
{
  static const bool _S_instanceless = true;
  typedef simple_alloc<_T, debug_alloc<_Alloc> > _Alloc_type;
  typedef __allocator<_T, debug_alloc<_Alloc> > allocator_type;
};


#endif /* __STL_USE_STD_ALLOCATORS */

#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
#pragma reset woff 1174
#endif

__STL_END_NAMESPACE

#undef __PRIVATE

#endif /* __SGI_STL_INTERNAL_ALLOC_H */

// Local Variables:
// mode:C++
// End: