Teh first one
[mldemos:kalians-mldemos.git] / _AlgorithmsPlugins / KernelMethods / dlib / reference_counter / reference_counter_kernel_abstract.h
1 // Copyright (C) 2003  Davis E. King (davis@dlib.net)\r
2 // License: Boost Software License   See LICENSE.txt for the full license.\r
3 #undef DLIB_REFERENCE_COUNTER_KERNEl_ABSTRACT_\r
4 #ifdef DLIB_REFERENCE_COUNTER_KERNEl_ABSTRACT_\r
5 \r
6 #include "../algs.h"\r
7 \r
8 namespace dlib\r
9 {\r
10 \r
11     template <\r
12         typename T,\r
13         typename copy = copy_functor<T>\r
14         >\r
15     class reference_counter\r
16     {\r
17 \r
18         /*!\r
19             REQUIREMENTS ON T\r
20                 T must have a default constructor\r
21 \r
22             REQUIREMENTS ON copy\r
23                 it should be a function object that copies an object of type T. and\r
24                 it must have a default constructor and\r
25                 operator() should be overloaded as \r
26                 void operator()(const T& source, T& destination);\r
27                 copy may throw any exception \r
28 \r
29             POINTERS AND REFERENCES TO INTERNAL DATA\r
30                 swap() and access() functions do not invalidate pointers or \r
31                 references to internal data.\r
32                 All other functions have no such guarantee\r
33   \r
34 \r
35             INITIAL VALUE\r
36                 reference_counter contains one object of type T and\r
37                 this object of type T has its initial value\r
38 \r
39             WHAT THIS OBJECT REPRESENTS\r
40                 This object represents a container for an object of type T and \r
41                 provides reference counting capabilities for the object it contains   \r
42 \r
43                 Also note that unless specified otherwise, no member functions\r
44                 of this object throw exceptions.\r
45 \r
46         !*/\r
47 \r
48         public:\r
49 \r
50             typedef T type;\r
51 \r
52             reference_counter (\r
53             );\r
54             /*!\r
55                 ensures \r
56                     - #*this is properly initialized\r
57                 throws\r
58                     - std::bad_alloc or any exception thrown by T's constructor\r
59             !*/\r
60 \r
61             reference_counter ( \r
62                 const reference_counter& item\r
63             );\r
64             /*!\r
65                 ensures\r
66                     - #access() == item.access()\r
67             !*/\r
68 \r
69             virtual ~reference_counter (\r
70             ); \r
71             /*!\r
72                 ensures\r
73                     - all memory associated with *this has been released\r
74             !*/\r
75 \r
76             void clear (\r
77             );\r
78             /*!\r
79                 ensures\r
80                     - #*this has its initial value\r
81                 throws\r
82                     - std::bad_alloc or any exception thrown by T's constructor\r
83                         if this exception is thrown then *this is unusable \r
84                         until clear() is called and succeeds\r
85             !*/\r
86 \r
87             T& modify (\r
88             );\r
89             /*!\r
90                 ensures\r
91                     - returns a non-const reference to the item contained in *this \r
92                     - the item is ok to modify.  i.e. there are no other references to it\r
93                 throws\r
94                     - std::bad_alloc or any exception thrown by T's constructor\r
95                         modify() may throw this exception if there are other references\r
96                         to the item and there is not enough memory to copy it. If modify()\r
97                         throws then it has no effect.    \r
98             !*/\r
99 \r
100             const T& access (\r
101             ) const;\r
102             /*!\r
103                 ensures\r
104                     - returns a const reference to the item contained in *this \r
105                     - there may be other references to to the item\r
106             !*/\r
107 \r
108             reference_counter& operator= (\r
109                 const reference_counter& rhs\r
110             );\r
111             /*!\r
112                 ensures\r
113                     - #access() == rhs.access() \r
114             !*/\r
115 \r
116             void swap (\r
117                 reference_counter& item\r
118             );\r
119             /*!\r
120                 ensures\r
121                     - swaps *this and item\r
122             !*/ \r
123 \r
124     };\r
125 \r
126     template <\r
127         typename T,\r
128         typename copy\r
129         >\r
130     inline void swap (\r
131         reference_counter<T,copy>& a, \r
132         reference_counter<T,copy>& b \r
133     ) { a.swap(b); }  \r
134     /*!\r
135         provides a global swap function\r
136     !*/\r
137 \r
138 }\r
139 \r
140 #endif // DLIB_REFERENCE_COUNTER_KERNEl_ABSTRACT_\r
141 \r