Teh first one
[mldemos:kalians-mldemos.git] / _AlgorithmsPlugins / KernelMethods / dlib / smart_pointers / scoped_ptr_abstract.h
1 // Copyright (C) 2007  Davis E. King (davis@dlib.net)\r
2 // License: Boost Software License   See LICENSE.txt for the full license.\r
3 #undef DLIB_SCOPED_PTr_ABSTRACT_\r
4 #ifdef DLIB_SCOPED_PTr_ABSTRACT_\r
5 \r
6 #include "../noncopyable.h"\r
7 \r
8 namespace dlib\r
9 {\r
10 \r
11 // ----------------------------------------------------------------------------------------\r
12 \r
13     template <typename T>\r
14     struct default_deleter\r
15     {\r
16         void operator() (\r
17             T* item\r
18         ) const;\r
19         /*!\r
20             ensures\r
21                 - if (T is an array type (e.g. int[])) then\r
22                     - performs "delete [] item;"\r
23                 - else\r
24                     - performs "delete item;"\r
25         !*/\r
26     };\r
27 \r
28 // ----------------------------------------------------------------------------------------\r
29 \r
30     template <\r
31         typename T,\r
32         typename deleter = default_deleter<T>\r
33         > \r
34     class scoped_ptr : noncopyable \r
35     {\r
36         /*!\r
37             REQUIREMENTS ON deleter\r
38                 Must be a function object that performs deallocation of a pointer\r
39                 of type T.  For example, see the default_deleter type defined above.\r
40 \r
41             INITIAL VALUE\r
42                 defined by constructor\r
43 \r
44             WHAT THIS OBJECT REPRESENTS\r
45                 This is a smart pointer class inspired by the implementation of the scoped_ptr \r
46                 class found in the Boost C++ library.  So this is a simple smart pointer \r
47                 class which guarantees that the pointer contained within it will always be \r
48                 deleted.   \r
49                 \r
50                 The class does not permit copying and so does not do any kind of \r
51                 reference counting.  Thus it is very simply and quite fast.\r
52                 \r
53                 Note that this class allows you to use pointers to arrays as well as \r
54                 pointers to single items.  To let it know that it is supposed to point\r
55                 to an array you have to declare it using the bracket syntax.  Consider\r
56                 the following examples:\r
57 \r
58                     // This is how you make a scoped pointer to a single thing\r
59                     scoped_ptr<int> single_item(new int);\r
60                     \r
61                     // This is how you can use a scoped pointer to contain array pointers.\r
62                     // Note the use of [].  This ensures that the proper version of delete\r
63                     // is called.\r
64                     scoped_ptr<int[]> array_of_ints(new int[50]);\r
65         !*/\r
66 \r
67     public:\r
68         typedef T element_type;\r
69         typedef deleter deleter_type;\r
70 \r
71         explicit scoped_ptr (\r
72             T* p = 0\r
73         );\r
74         /*!\r
75             ensures\r
76                 - #get() == p\r
77         !*/\r
78 \r
79         ~scoped_ptr(\r
80         );\r
81         /*!\r
82             ensures\r
83                 - if (get() != 0) then\r
84                     - calls deleter()(get())\r
85                       (i.e. uses the deleter type to delete the pointer that is\r
86                       contained in this scoped pointer)\r
87         !*/\r
88 \r
89         void reset (\r
90             T* p = 0\r
91         );\r
92         /*!\r
93             ensures\r
94                 - if (get() != 0) then\r
95                     - calls deleter()(get())\r
96                       (i.e. uses the deleter type to delete the pointer that is\r
97                       contained in this scoped pointer)\r
98                 - #get() == p\r
99                   (i.e. makes this object contain a pointer to p instead of whatever it \r
100                   used to contain)\r
101         !*/\r
102 \r
103         T& operator*(\r
104         ) const;\r
105         /*!\r
106             requires\r
107                 - get() != 0\r
108                 - T is NOT an array type (e.g. not int[])\r
109             ensures\r
110                 - returns a reference to *get()\r
111         !*/\r
112 \r
113         T* operator->(\r
114         ) const;\r
115         /*!\r
116             requires\r
117                 - get() != 0\r
118                 - T is NOT an array type (e.g. not int[])\r
119             ensures\r
120                 - returns the pointer contained in this object\r
121         !*/\r
122 \r
123         T& operator[](\r
124             unsigned long idx\r
125         ) const;\r
126         /*!\r
127             requires\r
128                 - get() != 0\r
129                 - T is an array type (e.g. int[])\r
130             ensures\r
131                 - returns get()[idx] \r
132         !*/\r
133 \r
134         T* get(\r
135         ) const;\r
136         /*!\r
137             ensures\r
138                 - returns the pointer contained in this object\r
139         !*/\r
140 \r
141         operator bool(\r
142         ) const;\r
143         /*!\r
144             ensures\r
145                 - returns get() != 0\r
146         !*/\r
147 \r
148         void swap(\r
149             scoped_ptr& b\r
150         );\r
151         /*!\r
152             ensures\r
153                 - swaps *this and item\r
154         !*/\r
155     };\r
156 \r
157     template <\r
158         typename T\r
159         > \r
160     void swap(\r
161         scoped_ptr<T>& a, \r
162         scoped_ptr<T>& b\r
163     ) { a.swap(b); }\r
164     /*!\r
165         provides a global swap function\r
166     !*/\r
167 }\r
168 \r
169 #endif // DLIB_SCOPED_PTr_ABSTRACT_\r
170 \r
171 \r