ba7883f7264edc55b4991d4acefbee0070c50455
[shipsimu.git] / application / ship-simu / main / personell / class_SimulatorPersonell.php
1 <?php
2 /**
3  * The general simulator personell class
4  *
5  * @author              Roland Haeder <webmaster@ship-simu.org>
6  * @version             0.0.0
7  * @copyright   Copyright (c) 2007, 2008 Roland Haeder, 2009 Ship-Simu Developer Team
8  * @license             GNU GPL 3.0 or any newer version
9  * @link                http://www.ship-simu.org
10  *
11  * This program is free software: you can redistribute it and/or modify
12  * it under the terms of the GNU General Public License as published by
13  * the Free Software Foundation, either version 3 of the License, or
14  * (at your option) any later version.
15  *
16  * This program is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19  * GNU General Public License for more details.
20  *
21  * You should have received a copy of the GNU General Public License
22  * along with this program. If not, see <http://www.gnu.org/licenses/>.
23  */
24 class SimulatorPersonell extends BasePersonell {
25         // Personell list
26         private $personellList = null;
27
28         // A cache for lists
29         private $cacheList = null;
30
31         // A string for cached conditions
32         private $cacheCond = null;
33
34         /**
35          * Protected constructor
36          *
37          * @return      void
38          */
39         protected function __construct () {
40                 // Call parent constructor
41                 parent::__construct(__CLASS__);
42         }
43
44         /**
45          * Magic wake-up method called when unserialize() is called. This is
46          * neccessary because in this case a personell does not need to know the
47          * min/max ages range and system classes. This would anyway use more RAM
48          * what is not required.
49          *
50          * @return      void
51          */
52         public function __wakeup () {
53                 // Tidy up a little
54                 $this->removePersonellList();
55                 $this->removeMinMaxAge();
56                 $this->removeCache();
57         }
58
59         /**
60          * Generate a specified amount of personell and return the prepared instance
61          *
62          * @param               $amountPersonell                Number of personell we shall
63          *                                                              generate
64          * @return      $personellInstance              An instance of this object with a
65          *                                                              list of personells
66          */
67         public static final function createSimulatorPersonell ($amountPersonell) {
68                 // Make sure only integer can pass
69                 $amountPersonell = (int) $amountPersonell;
70
71                 // Get a new instance
72                 $personellInstance = new SimulatorPersonell();
73
74                 // Debug message
75                 if ((defined('DEBUG_PERSONELL')) || (defined('DEBUG_ALL'))) $personellInstance->debugOutput(sprintf("[%s:%d] Es werden <strong>%d</strong> Personal bereitgestellt.",
76                         __CLASS__,
77                         __LINE__,
78                         $amountPersonell
79                 ));
80
81                 // Initialize the personell list
82                 $personellInstance->createPersonellList();
83
84                 // Create requested amount of personell
85                 for ($idx = 0; $idx < $amountPersonell; $idx++) {
86                         $personellInstance->addRandomPersonell();
87                 }
88
89                 // Debug message
90                 if ((defined('DEBUG_PERSONELL')) || (defined('DEBUG_ALL'))) $personellInstance->debugOutput(sprintf("[%s:%d] <strong>%d</strong> Personal bereitgestellt.",
91                         __CLASS__,
92                         __LINE__,
93                         $amountPersonell
94                 ));
95
96                 // Tidy up a little
97                 $personellInstance->removeGender();
98                 $personellInstance->removeNames();
99                 $personellInstance->removeBirthday();
100                 $personellInstance->removeSalary();
101                 $personellInstance->removeEmployed();
102                 $personellInstance->removeMarried();
103                 //$personellInstance->removeCache();
104
105                 // Instanz zurueckgeben
106                 return $personellInstance;
107         }
108
109         /**
110          * Create a SimulatorPersonell object by loading the specified personell
111          * list from an existing database backend
112          *
113          * @param       $idNumber                       The ID number (only right part) of the list
114          * @return      $personellInstance      An instance of this class
115          * @throws      InvalidIDFormatException        If the given id number
116          *                                                                              $idNumber is invalid
117          * @throws      MissingSimulatorIdException             If an ID number was not found
118          * @deprecated
119          */
120         public static final function createSimulatorPersonellByID ($idNumber) {
121                 // Get instance
122                 $personellInstance = new SimulatorPersonell(false);
123                 $personellInstance->makeDeprecated();
124         }
125
126         // Create personell list
127         public function createPersonellList () {
128                 // Is the list already created?
129                 if ($this->personelllList instanceof FrameworkArrayObject) {
130                         // Throw an exception
131                         throw new PersonellListAlreadyCreatedException($this, self::EXCEPTION_DIMENSION_ARRAY_INVALID);
132                 } // END - if
133
134                 // Initialize the array
135                 $this->personellList = new FrameworkArrayObject("FakedPersonellList");
136         }
137
138         // Remove the personell list
139         private final function removePersonellList () {
140                 unset($this->personellList);
141         }
142
143         // Add new personell object to our list
144         public function addRandomPersonell () {
145                 // Gender list...
146                 $genders = array("M", "F");
147
148                 // Create new personell members
149                 $personellInstance = new SimulatorPersonell();
150
151                 // Set a randomized gender
152                 $personellInstance->setGender($genders[mt_rand(0, 1)]);
153
154                 // Set a randomized birthday (maximum age required, see const MAX_AGE)
155                 $personellInstance->createBirthday();
156
157                 // Married? Same values means: married
158                 if (mt_rand(0, 5) == mt_rand(0, 5)) $personellInstance->setMarried(true);
159
160                 // Tidy up a little
161                 $personellInstance->removePersonellList();
162                 $personellInstance->removeMinMaxAge();
163                 $personellInstance->removeCache();
164
165                 // Add new member to the list
166                 $this->personellList->append($personellInstance);
167         }
168
169         /**
170          * Get a specifyable list of our people, null or empty string will be ignored!
171          *
172          * @return      $cacheList      A list of cached personells
173          */
174         function getSpecialPersonellList ($isEmployed = null, $isMarried = null, $hasGender = "") {
175                 // Serialize the conditions for checking if we can take the cache
176                 $serialized = serialize(array($isEmployed, $isMarried, $hasGender));
177
178                 // The same (last) conditions?
179                 if (($serialized == $this->cacheCond) && (!is_null($this->cacheCond))) {
180                         if ((defined('DEBUG_PERSONELL')) || (defined('DEBUG_ALL'))) $this->debugOutput(sprintf("[%s:%d] Gecachte Liste wird verwendet.",
181                                 __CLASS__,
182                                 __LINE__
183                         ));
184
185                         // Return cached list
186                         return $this->cacheList;
187                 }
188
189                 // Output debug message
190                 if ((defined('DEBUG_PERSONELL')) || (defined('DEBUG_ALL'))) $this->debugOutput(sprintf("[%s:%d] Personalliste wird nach Kriterien durchsucht...",
191                         __CLASS__,
192                         __LINE__
193                 ));
194
195                 // Remember the conditions
196                 $this->setCacheCond($serialized);
197
198                 // Create cached list
199                 $this->setAllCacheList(new FrameworkArrayObject('FakedCacheList'));
200
201                 // Search all unemployed personells
202                 for ($idx = $this->personellList->getIterator(); $idx->valid(); $idx->next()) {
203                         // Element holen
204                         $el = $idx->current();
205
206                         // Check currenylt all single conditions (combined conditions are not yet supported)
207                         if ((!is_null($isEmployed)) && ($el->isEmployed() == $isEmployed)) {
208                                 // Add this one (employed status asked)
209                                 $this->cacheList->append($el);
210                         } elseif ((!is_null($isMarried)) && ($el->isMarried() == $isMarried)) {
211                                 // Add this one (marrital status asked)
212                                 $this->cacheList->append($el);
213                         } elseif ((!empty($hasGender)) && ($el->getGender() == $hasGender)) {
214                                 // Add this one (specified gender)
215                                 $this->cacheList->append($el);
216                         }
217                 }
218
219                 // Return the completed list
220                 return $this->cacheList;
221         }
222
223         /**
224          * Get amount of unemployed personell
225          *
226          * @return      $count  Amount of unemployed personell
227          */
228         public final function getAllUnemployed () {
229                 // Get a temporary list
230                 $list = $this->getSpecialPersonellList(false);
231
232                 // Anzahl zurueckliefern
233                 return $list->count();
234         }
235
236         /**
237          * Remove cache things
238          *
239          * @return      void
240          */
241         private function removeCache () {
242                 // Remove cache data
243                 unset($this->cacheList);
244                 unset($this->cacheCond);
245         }
246
247         /**
248          * Setter for cache list
249          *
250          * @param               $cacheList      The new cache list to set or null for initialization/reset
251          * @return      void
252          */
253         private final function setAllCacheList (FrameworkArrayObject $cacheList = null) {
254                 $this->cacheList = $cacheList;
255         }
256
257         /**
258          * Setter for cache conditions
259          *
260          * @param               $cacheCond      The new cache conditions to set
261          * @return      void
262          */
263         private final function setCacheCond ($cacheCond) {
264                 $this->cacheCond = (string) $cacheCond;
265         }
266
267         /**
268          * Reset cache list
269          *
270          * @return      void
271          */
272         public function resetCache () {
273                 $this->setAllCacheList(null);
274                 $this->setCacheCond("");
275         }
276
277         /**
278          * Getter for surname. If no surname is set then default surnames are set
279          * for male and female personells.
280          *
281          * @return      $surname        The personell' surname
282          */
283         public final function getSurname () {
284                 $surname = parent::getSurname();
285
286                 // Make sure every one has a surname...
287                 if (empty($surname)) {
288                         if ($this->isMale()) {
289                                 // Typical male name
290                                 $surname = "John";
291                         } else {
292                                 // Typical female name
293                                 $surname = "Jennifer";
294                         }
295
296                         // Set typical family name
297                         parent::setFamily("Smith");
298                 } // END - if
299
300                 // Return surname
301                 return $surname;
302         }
303
304         /**
305          * Getter for personell list
306          *
307          * @return      $personellList          The list of all personells
308          */
309         public final function getPersonellList () {
310                 return $this->personellList;
311         }
312
313         /**
314          * Loads the mostly pre-cached personell list
315          *
316          * @param       $idNumber       The ID number we shall use for looking up
317          *                                              the right data.
318          * @return      void
319          * @deprecated
320          */
321         public function loadPersonellList ($idNumber) {
322                 $this->makeDeprecated();
323         }
324 }
325
326 // [EOF]
327 ?>