Remove operation help.
[anna.git] / include / anna / dbos / AutoSet.hpp
1 // ANNA - Anna is Not Nothingness Anymore                                                         //
2 //                                                                                                //
3 // (c) Copyright 2005-2015 Eduardo Ramos Testillano & Francisco Ruiz Rayo                         //
4 //                                                                                                //
5 // See project site at http://redmine.teslayout.com/projects/anna-suite                           //
6 // See accompanying file LICENSE or copy at http://www.teslayout.com/projects/public/anna.LICENSE //
7
8
9 #ifndef anna_dbos_AutoSet_hpp
10 #define anna_dbos_AutoSet_hpp
11
12 #include <anna/dbos/Set.hpp>
13
14 namespace anna {
15
16 namespace dbos {
17
18
19 /**
20    Facilita el uso de los punteros a objectos obtenidos a partir de los datos guardados en un medio fisico.
21
22    La idea de esta clase es que el constructor y el destructor de esta clase cooperan para reservar y/o
23    liberar correctamente la instancia de T asociada a esta instancia.
24
25    \param T Clase que vamos a gestionar.
26
27    En el siguiente ejemplo podemos ver la forma habitual de trabajar con un objeto persistente tiene
28    el incoveniente de que tenemos que tener en cuenta cada una de las situaciones en las que la
29    referencia obtenida mediante el metodo \em instantiate debe ser liberada.
30
31    \code
32    Server::Set <Server>* servers (NULL);
33    ServerLoader serverLoader;        // ServerLoader hereda de anna::dbos::Loader.
34    Server* server;
35
36    try {
37       serverLoader.setKey (..........); // Establece los parametros de busqueda
38
39       servers = Server::instantiate (serverLoader);
40
41       if (servers->size () == 0) {
42          ....
43          .... Si fuera necesario trataria la condicion de no encontrar ningun registro
44          ....
45       }
46
47       Server::iterator ii, maxii;
48
49       for (ii = servers->begin (), maxii = servers->end (); ii != maxii; ii ++) {
50          server = *ii;
51
52          .... Trataria cada uno de los Server encontrados ....
53       }
54
55       Server::release (servers);
56    }
57    catch (Exception& ex) {
58       Server::release (servers);
59
60       ...
61       ... Si fuera necesario trataria la condificion de error.
62    }
63    \endcode
64
65    Como podemos ver a continuacion el siguiente metodo es mucho mas sencillo y aporta la gran ventaja de que
66    el sistema trabaja por nosotros para liberar correctamente los recursos.
67
68    \code
69    AutoSet <Server> servers;
70    ServerLoader serverLoader;        // ServerLoader hereda de anna::dbos::Loader.
71    Server* server;
72
73    try {
74       serverLoader.setKey (..........); // Establece los parametros de busqueda
75
76       servers = Server::instantiate (serverLoader);
77
78       if (servers->size () == 0) {
79          ....
80          .... Si fuera necesario trataria la condicion de no encontrar ningun registro
81          ....
82       }
83
84       Server::iterator ii, maxii;
85
86       for (ii = servers->begin (), maxii = servers->end (); ii != maxii; ii ++) {
87          server = *ii;
88
89          .... Trataria cada uno de los Server encontrados ....
90       }
91    }
92    catch (Exception& ex) {
93       ...
94       ... Si fuera necesario trataria la condificion de error.
95    }
96    \endcode
97 */
98 template <typename T> class AutoSet {
99 public:
100   /**
101      Constructor.
102      \param t Instancia del objeto asociado a esta instancia.
103      \warning La instancia deberia haber sido obtenida mediate la invocacion a \em T::instantiate de la
104      clase persistente.
105   */
106   explicit AutoSet(Set <T>* t) : a_t(t) {;}
107
108   /**
109      Constructor.
110   */
111   AutoSet() : a_t(NULL) {;}
112
113   /**
114      Destructor. Invoca al metodo \em T::release
115   */
116   ~AutoSet() { if(a_t != NULL) T::release(a_t); }
117
118   /**
119      Operador ->
120      Permite invocar a metodos de la clase T.
121      \return La instancia de la clase T asociada a esta instancia.
122   */
123   Set <T>* operator -> () const throw() { return a_t; }
124
125   /**
126      Operador copia.
127      \return La instancia de la clase T asociada a esta instancia.
128   */
129   Set <T>* operator = (Set<T>* t)
130   throw() {
131     if(a_t == t)
132       return t;
133
134     if(a_t != NULL)
135       T::release(a_t);
136
137     return a_t = t;
138   }
139
140   /**
141      Operador de conversion.
142      \return La instancia de la clase T asociada a esta instancia.
143   */
144   operator Set <T>*() const throw() { return a_t; }
145
146 private:
147   Set <T>* a_t;
148 };
149
150
151 }
152 }
153
154
155
156 #endif
157
158