1// This file is part of the ustl library, an STL implementation.
2//
3// Copyright (C) 2005 by Mike Sharov <msharov@users.sourceforge.net>
4// This file is free software, distributed under the MIT License.
5//
6// umemory.h
7//
8
9#ifndef UMEMORY_H_4AB5B0DB5BF09140541409CC47BCD17A
10#define UMEMORY_H_4AB5B0DB5BF09140541409CC47BCD17A
11
12#include "unew.h"
13#ifdef HAVE_ALLOCA_H
14    #include <alloca.h>
15#else
16    #include <stdlib.h>
17#endif
18#include "upair.h"
19#include "uiterator.h"
20#include "ulimits.h"
21
22namespace ustl {
23
24/// \class auto_ptr umemory.h ustl.h
25/// \ingroup MemoryManagement
26///
27/// \brief A smart pointer.
28///
29/// Calls delete in the destructor; assignment transfers ownership.
30/// This class does not work with void pointers due to the absence
31/// of the required dereference operator.
32///
33template <typename T>
34class auto_ptr {
35public:
36    typedef T		value_type;
37    typedef T*		pointer;
38    typedef T&		reference;
39public:
40    /// Takes ownership of \p p.
41    inline explicit	auto_ptr (pointer p = NULL)	: m_p (p) {}
42    /// Takes ownership of pointer in \p p. \p p relinquishes ownership.
43    inline		auto_ptr (auto_ptr<T>& p)	: m_p (p.release()) {}
44    /// Deletes the owned pointer.
45    inline	       ~auto_ptr (void)			{ delete m_p; }
46    /// Returns the pointer without relinquishing ownership.
47    inline pointer	get (void) const		{ return (m_p); }
48    /// Returns the pointer and gives up ownership.
49    inline pointer	release (void)			{ pointer rv (m_p); m_p = NULL; return (rv); }
50    /// Deletes the pointer and sets it equal to \p p.
51    inline void		reset (pointer p)		{ if (p != m_p) { delete m_p; m_p = p; } }
52    /// Takes ownership of \p p.
53    inline auto_ptr<T>&	operator= (pointer p)		{ reset (p); return (*this); }
54    /// Takes ownership of pointer in \p p. \p p relinquishes ownership.
55    inline auto_ptr<T>&	operator= (auto_ptr<T>& p)	{ reset (p.release()); return (*this); }
56    inline reference	operator* (void) const		{ return (*m_p); }
57    inline pointer	operator-> (void) const		{ return (m_p); }
58    inline bool		operator== (const pointer p) const	{ return (m_p == p); }
59    inline bool		operator== (const auto_ptr<T>& p) const	{ return (m_p == p.m_p); }
60    inline bool		operator< (const auto_ptr<T>& p) const	{ return (p.m_p < m_p); }
61private:
62    pointer		m_p;
63};
64
65/// Calls the placement new on \p p.
66/// \ingroup RawStorageAlgorithms
67///
68template <typename T>
69inline void construct (T* p)
70{
71    new (p) T;
72}
73
74/// Calls the placement new on \p p.
75/// \ingroup RawStorageAlgorithms
76///
77template <typename ForwardIterator>
78inline void construct (ForwardIterator first, ForwardIterator last)
79{
80    typedef typename iterator_traits<ForwardIterator>::value_type value_type;
81    if (!numeric_limits<value_type>::is_integral) {
82	while (first < last) {
83	    construct (&*first);
84	    ++ first;
85	}
86    }
87}
88
89/// Calls the placement new on \p p.
90/// \ingroup RawStorageAlgorithms
91///
92template <typename T>
93inline void construct (T* p, const T& value)
94{
95    new (p) T (value);
96}
97
98/// Calls the destructor of \p p without calling delete.
99/// \ingroup RawStorageAlgorithms
100///
101template <typename T>
102inline void destroy (T* p) throw()
103{
104    p->~T();
105}
106
107/// Calls the destructor on elements in range [first, last) without calling delete.
108/// \ingroup RawStorageAlgorithms
109///
110template <typename ForwardIterator>
111inline void destroy (ForwardIterator first, ForwardIterator last) throw()
112{
113    typedef typename iterator_traits<ForwardIterator>::value_type value_type;
114    if (!numeric_limits<value_type>::is_integral)
115	for (; first < last; ++ first)
116	    destroy (&*first);
117}
118
119/// Casts \p p to the type of the second pointer argument.
120template <typename T> inline T* cast_to_type (void* p, const T*) { return ((T*) p); }
121
122/// \brief Creates a temporary buffer pair from \p p and \p n
123/// This is intended to be used with alloca to create temporary buffers.
124/// The size in the returned pair is set to 0 if the allocation is unsuccessful.
125/// \ingroup RawStorageAlgorithms
126///
127template <typename T>
128inline pair<T*, ptrdiff_t> make_temporary_buffer (void* p, size_t n, const T* ptype)
129{
130    return (make_pair (cast_to_type(p,ptype), ptrdiff_t(p ? n : 0)));
131}
132
133#ifdef HAVE_ALLOCA_H
134    /// \brief Allocates a temporary buffer, if possible.
135    /// \ingroup RawStorageAlgorithms
136    #define get_temporary_buffer(size, ptype)	make_temporary_buffer (alloca(size_of_elements(size, ptype)), size, ptype)
137    #define return_temporary_buffer(p)
138#else
139    #define get_temporary_buffer(size, ptype)	make_temporary_buffer (malloc(size_of_elements(size, ptype)), size, ptype)
140    #define return_temporary_buffer(p)		if (p) free (p), p = NULL
141#endif
142
143/// Copies [first, last) into result by calling copy constructors in result.
144/// \ingroup RawStorageAlgorithms
145///
146template <typename InputIterator, typename ForwardIterator>
147ForwardIterator uninitialized_copy (InputIterator first, InputIterator last, ForwardIterator result)
148{
149    while (first < last) {
150	construct (&*result, *first);
151	++ result;
152	++ first;
153    }
154    return (result);
155}
156
157/// Copies [first, first + n) into result by calling copy constructors in result.
158/// \ingroup RawStorageAlgorithms
159///
160template <typename InputIterator, typename ForwardIterator>
161ForwardIterator uninitialized_copy_n (InputIterator first, size_t n, ForwardIterator result)
162{
163    while (n--) {
164	construct (&*result, *first);
165	++ result;
166	++ first;
167    }
168    return (result);
169}
170
171/// Calls construct on all elements in [first, last) with value \p v.
172/// \ingroup RawStorageAlgorithms
173///
174template <typename ForwardIterator, typename T>
175void uninitialized_fill (ForwardIterator first, ForwardIterator last, const T& v)
176{
177    while (first < last) {
178	construct (&*first, v);
179	++ first;
180    }
181}
182
183/// Calls construct on all elements in [first, first + n) with value \p v.
184/// \ingroup RawStorageAlgorithms
185///
186template <typename ForwardIterator, typename T>
187ForwardIterator uninitialized_fill_n (ForwardIterator first, size_t n, const T& v)
188{
189    while (n--) {
190	construct (&*first, v);
191	++ first;
192    }
193    return (first);
194}
195
196} // namespace ustl
197
198#endif
199
200