]> Creatis software - creaContours.git/blob - lib/kernel_ManagerContour_NDimensions/CommandsRegisterStructure.cxx
#3381 Clean Code Segmentation VTK
[creaContours.git] / lib / kernel_ManagerContour_NDimensions / CommandsRegisterStructure.cxx
1 /*# ---------------------------------------------------------------------
2 #
3 # Copyright (c) CREATIS (Centre de Recherche en Acquisition et Traitement de l'Image
4 #                        pour la Sant�)
5 # Authors : Eduardo Davila, Frederic Cervenansky, Claire Mouton
6 # Previous Authors : Laurent Guigues, Jean-Pierre Roux
7 # CreaTools website : www.creatis.insa-lyon.fr/site/fr/creatools_accueil
8 #
9 #  This software is governed by the CeCILL-B license under French law and
10 #  abiding by the rules of distribution of free software. You can  use,
11 #  modify and/ or redistribute the software under the terms of the CeCILL-B
12 #  license as circulated by CEA, CNRS and INRIA at the following URL
13 #  http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html
14 #  or in the file LICENSE.txt.
15 #
16 #  As a counterpart to the access to the source code and  rights to copy,
17 #  modify and redistribute granted by the license, users are provided only
18 #  with a limited warranty  and the software's author,  the holder of the
19 #  economic rights,  and the successive licensors  have only  limited
20 #  liability.
21 #
22 #  The fact that you are presently reading this means that you have had
23 #  knowledge of the CeCILL-B license and that you accept its terms.
24 # ------------------------------------------------------------------------ */
25
26
27 //----------------------------------------------------------------------------------------------------------------
28 // Class definition include
29 //----------------------------------------------------------------------------------------------------------------
30 #include "CommandsRegisterStructure.h"
31
32 //----------------------------------------------------------------------------------------------------------------
33 // Class implementation
34 //----------------------------------------------------------------------------------------------------------------
35 /** @file CommandsRegisterStructure.cxx */
36
37 //------------------------------------------------------------------------------------------------------------
38 // Constructors & Destructors
39 //------------------------------------------------------------------------------------------------------------
40
41 /*
42         * Creates the CommandsRegisterStructure
43         */
44         CommandsRegisterStructure :: CommandsRegisterStructure()
45         { 
46                 actualIndexToExec = -1;         
47                 lastAction = -1;
48         }
49
50         /*
51         * Destroys the CommandsRegisterStructure
52         */
53         CommandsRegisterStructure :: ~CommandsRegisterStructure()
54         { 
55                 clearActions();         
56         }
57
58 //------------------------------------------------------------------------------------------------------------
59 // Methods
60 //------------------------------------------------------------------------------------------------------------
61
62         /**
63         * Registers a command in the vector with no verification, is should be well constructed
64         * @param theCommand The command to register
65         */
66         void CommandsRegisterStructure :: registerCommand(CommandObject * theCommand)
67         {
68                 //int antes =registeredActions.size();
69                 levelLastToActual(true);
70                 registeredActions.push_back(theCommand);
71                 actualIndexToExec = registeredActions.size()-1;
72                 lastAction = actualIndexToExec;
73                 //int despues =registeredActions.size();
74                 //int otr = 0;
75         }
76
77
78         /*
79         * Gets the -ACTUAL- command text 
80         * @return
81         */
82         /*std::string CommandsRegisterStructure :: getActualCommandText()
83         { 
84                 return !isEmpty() ? getCommandAt(actualIndexToExec)->includeToExecute(): " ";
85         }*/
86
87         /*
88         * Gets the -LAST- command text 
89         * @return
90         */
91         /*std::string CommandsRegisterStructure :: getLastCommandText()
92         { 
93                 return !isEmpty() ? getCommandAt(lastAction)->executeCommand(): " ";
94         }*/
95
96         /*
97         * Deletes all the registered actions and reinitialize the -ACTUAL- and  -LAST- 
98         */
99         void CommandsRegisterStructure ::  clearActions()
100         { 
101                 if(!registeredActions.empty())
102                 {
103                         for(int i=0; i < registeredActions.size(); i++)
104                         {
105                                 registeredActions[i] = NULL;
106                         }
107                         registeredActions.clear();              
108                         lastAction = -1;                
109                         actualIndexToExec = -1;
110                 }
111         }
112
113         /*
114         * Moves to the the previous position the -ACTUAL- 
115         * @return Indicates true if it was done
116         */
117         bool CommandsRegisterStructure :: moveBack_Actual()
118         { 
119                 if ( !isEmpty() &&  hasActualPrevious() )
120                 {
121                         actualIndexToExec--;
122                         return true;
123                 }
124                 return false;
125         }
126
127         /*
128         * Moves to the the next position the -ACTUAL- 
129         * @return Indicates true if it was done
130         */
131         bool CommandsRegisterStructure :: moveForward_Actual()
132         {
133                 if ( !isEmpty() &&  hasActualNext() )
134                 {
135                         actualIndexToExec++;
136                         return true;
137                 }
138                 return false;
139         }
140
141         /*
142         * Moves to the the previous position the -LAST- 
143         * @return Indicates true if it was done
144         */
145         bool CommandsRegisterStructure :: moveBack_Last()
146         { 
147                 if ( !isEmpty() && hasLastPrevious() )
148                 {
149                         lastAction--;
150                         return true;
151                 }
152                 return false;
153         }
154
155         /*
156         * Moves to the the next position the -LAST- 
157         * @return Indicates true if it was done
158         */
159         bool CommandsRegisterStructure :: moveForward_Last()
160         {
161                 if ( !isEmpty() && hasLastNext() )
162                 {
163                         lastAction++;
164                         return true;
165                 }
166                 return false;
167         }
168
169         /*
170         * Indicates if the -LAST-  has a next action or not
171         * @return Returns true if it has
172         */
173         bool CommandsRegisterStructure :: hasLastNext()
174         {
175                 int total = registeredActions.size();
176                 return total > 0 ? total -1 > lastAction : false;
177         }
178
179         /*
180         * Indicates if the -ACTUAL-  has a next action or not
181         * @return Returns true if it has
182         */
183         bool CommandsRegisterStructure :: hasActualNext()
184         {
185                 int total = registeredActions.size();
186                 return total > 0 ? total -1 > actualIndexToExec : false;
187         }
188
189         /*
190         * Indicates if the -LAST-  has a previous action or not
191         * @return Returns true if it has
192         */
193         bool CommandsRegisterStructure :: hasLastPrevious()
194         {
195                 return ! 0 < lastAction;
196         }
197
198         /*
199         * Indicates if the -ACTUAL-  has a previous action or not
200         * @return Returns true if it has
201         */
202         bool CommandsRegisterStructure :: hasActualPrevious()
203         {
204                 return 0 < actualIndexToExec;
205         }
206
207         /*
208         * Puts to point CommandsRegisterStructure ::  the -ACTUAL-  up to the -LAST-  . 
209         */
210         void CommandsRegisterStructure :: levelActualToLast()
211         { 
212                 actualIndexToExec = lastAction;
213         }
214
215         /*
216         * Puts to point CommandsRegisterStructure ::  the -LAST-  up to the -ACTUAL-  and erases automatically the actions after the 
217         * referenced last new position of the registered actions if nothing is given by parameter.
218         * @clearingAfterActual Indicates if is wondered to erase or not the mentioned range 
219         */
220         void CommandsRegisterStructure :: levelLastToActual( bool clearingAfterActual )
221         {
222                 if ( !isEmpty() )
223                 {
224                         lastAction = actualIndexToExec;
225                         if( clearingAfterActual )
226                         {
227                                 for (int a=registeredActions.size()-1; a>=0 && actualIndexToExec < a; a--)
228                                 {
229                                         if(actualIndexToExec < a)
230                                         {
231                                                 registeredActions.pop_back();
232                                         }
233                                 }                               
234                         }                       
235                 }
236         }
237
238         /*
239         * Clear all the elements in the vector bettween the -LAST-  and the end of the vector
240         */
241         void CommandsRegisterStructure ::  clearAll_afterLast()
242         {
243                 for (int a=registeredActions.size()-1; a>=0 && lastAction < a; a--)
244                 {
245                         if( lastAction < a )
246                         {
247                                 registeredActions.pop_back();
248                         }
249                 }               
250         }
251
252         /*
253         * Clear all the elements in the vector bettween the -ACTUAL-  and the start of the vector       
254         */
255         void CommandsRegisterStructure ::  clearAll_beforeActual()
256         { 
257                 std::vector <CommandObject*>::iterator frontIter;
258                 for (int a=0; a<registeredActions.size() && lastAction < a; a--)
259                 {
260                         frontIter = registeredActions.begin();
261                         if( actualIndexToExec > a )
262                         {
263                                 registeredActions.erase(frontIter);
264                         }
265                 }       
266         }
267
268         /**
269         * Indicates if there are actions in the vector of not
270         * @return Returns true is there are not registered actions      
271         */
272         bool CommandsRegisterStructure :: isEmpty()
273         { 
274                 return registeredActions.empty();
275         }
276
277         /**
278         * Indicates the quantity of actions that are registered
279         * @return Returns the total amount of registered actions in the vector
280         */
281         int CommandsRegisterStructure ::  getCommandsCount()
282         { 
283                 return registeredActions.size();
284         }
285
286         /*
287         * Gets the -ACTUAL-   information data pointer
288         * @return The pointer to the referenced object by the -ACTUAL- 
289         */
290         CommandObject * CommandsRegisterStructure :: getActual_Pointer ()
291         {
292                 return  getCommandAt(actualIndexToExec);
293         }
294
295         /*
296         * Gets the -LAST-   information data pointer 
297         * @return The pointer to the referenced object by the -LAST- 
298         */
299         CommandObject * CommandsRegisterStructure ::getLast_Pointer ()
300         { 
301                 return  getCommandAt(lastAction);
302         }
303
304         /*
305         * Gets the command at the given position 
306         * @return The pointer to the referenced object by the position
307         */
308         CommandObject * CommandsRegisterStructure :: getCommandAt(int position)
309         {
310                 if(position< getCommandsCount())
311                 {
312                         return registeredActions[position];
313                 }
314                 return NULL;
315         }
316
317         /*
318         * Gets the index of the actualAction in the vector
319         * @return actualIndexToExec Is the corresponding index
320         */
321         int CommandsRegisterStructure :: getActualIndex()
322         {
323                 return actualIndexToExec;
324         }
325
326         /*
327         * Gets the index of the lasAction in the vector
328         * @return lasAction Is the corresponding index
329         */
330         int CommandsRegisterStructure :: getLasIndex()
331         {
332                 return lastAction;
333         }
334
335         /*
336         * Sets the index of the actualAction in the vector
337         * @param newActualIndex Is the corresponding index
338         */
339         void CommandsRegisterStructure :: setActualIndex(int newActualIndex)
340         {
341                 actualIndexToExec = newActualIndex;
342         }
343
344         /*
345         * Sets the index of the lasAction in the vector
346         * @param newLasIndex Is the corresponding index
347         */
348         void CommandsRegisterStructure :: setLasIndex(int newLasIndex)
349         {
350                 lastAction = newLasIndex;
351         }
352
353         /*
354         * Gets the registered commands vector size
355         * @return Returns the vector size
356         */
357         int CommandsRegisterStructure :: getRegistereCommandsCount()
358         {
359                 return registeredActions.size();
360         }
361
362         /*
363         * Gets the total registered commands 
364         * @return Returns the total of commands
365         */
366         int CommandsRegisterStructure :: getTotalCommandsCount()
367         {
368                 int totalAccum = 0;
369                 for( int i=0; i< registeredActions.size(); i++)
370                 {
371                         totalAccum+= registeredActions[i]->count();
372                 }
373                 return totalAccum;
374         }
375    
376