Made lower to upper case:
[core.git] / inc / classes / main / resolver / class_
1 <?php
2 /**
3  * A ??? resolver
4  *
5  * @author              Roland Haeder <webmaster@ship-simu.org>
6  * @version             0.0.0
7  * @copyright   Copyright (c) 2007, 2008 Roland Haeder, 2009 - 2012 Core 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 ???Resolver extends BaseResolver implements Resolver {
25         /**
26          * Protected constructor
27          *
28          * @return      void
29          */
30         protected function __construct () {
31                 // Call parent constructor
32                 parent::__construct(__CLASS__);
33
34                 // Set prefix to '???'
35                 $this->setClassPrefix('???');
36         }
37
38         /**
39          * Creates an instance of a Web action resolver with a given default action
40          *
41          * @param       $!!!Name                                The default action we shall execute
42          * @param       $appInstance                    An instance of a manageable application helper class
43          * @return      $resolverInstance               The prepared action resolver instance
44          * @throws      EmptyVariableException  Thrown if default action is not set
45          * @throws      Invalid|||Exception     Thrown if default action is invalid
46          */
47         public static final function create???Resolver ($!!!Name, ManageableApplication $appInstance) {
48                 // Create the new instance
49                 $resolverInstance = new ???Resolver();
50
51                 // Is the variable $!!!Name set and the action is valid?
52                 if (empty($!!!Name)) {
53                         // Then thrown an exception here
54                         throw new EmptyVariableException(array($resolverInstance, 'default|||'), self::EXCEPTION_UNEXPECTED_EMPTY_STRING);
55                 } elseif ($resolverInstance->is|||Valid($!!!Name) === FALSE) {
56                         // Invalid action found
57                         throw new Invalid|||Exception(array($resolverInstance, $!!!Name), self::EXCEPTION_INVALID_ACTION);
58                 }
59
60                 // Set the application instance
61                 $resolverInstance->setApplicationInstance($appInstance);
62
63                 // Return the prepared instance
64                 return $resolverInstance;
65         }
66
67         /**
68          * Returns an action instance for a given request class or null if
69          * it was not found
70          *
71          * @param       $requestInstance        An instance of a request class
72          * @return      $!!!Instance    An instance of the resolved action
73          * @throws      Invalid|||Exception                             Thrown if $!!!Name is
74          *                                                                                              invalid
75          * @throws      Invalid|||InstanceException             Thrown if $!!!Instance
76          *                                                                                              is an invalid instance
77          */
78         public function resolve|||ByRequest (Requestable $requestInstance) {
79                 // Init variables
80                 $!!!Name = '';
81                 $!!!Instance = null;
82
83                 // This goes fine so let's resolve the action
84                 $!!!Name = $requestInstance->getRequestElement('action');
85
86                 // Is the action empty? Then fall back to default action
87                 if (empty($!!!Name)) $!!!Name = $this->getConfigInstance()->getConfigEntry('default_action');
88
89                 // Check if action is valid
90                 if ($this->is|||Valid($!!!Name) === FALSE) {
91                         // This action is invalid!
92                         throw new Invalid|||Exception(array($this, $!!!Name), self::EXCEPTION_INVALID_ACTION);
93                 } // END - if
94
95                 // Get the action
96                 $!!!Instance = $this->load|||();
97
98                 // And validate it
99                 if ((!is_object($!!!Instance)) || (!$!!!Instance instanceof |||able)) {
100                         // This action has an invalid instance!
101                         throw new Invalid|||InstanceException(array($this, $!!!Name), self::EXCEPTION_INVALID_ACTION);
102                 } // END - if
103
104                 // Set last action
105                 $this->setResolvedInstance($!!!Instance);
106
107                 // Return the resolved action instance
108                 return $!!!Instance;
109         }
110
111         /**
112          * Resolves the action by its direct name and returns an instance of its class
113          *
114          * @return      $!!!Instance            An instance of the action class
115          * @throws      Invalid|||Exception     Thrown if $!!!Name is invalid
116          */
117         public function resolve||| () {
118                 // Initiate the instance variable
119                 $!!!Instance = null;
120
121                 // Get action name
122                 $!!!Name = $this->get|||Name();
123
124                 // Is the action empty? Then fall back to default action
125                 if (empty($!!!Name)) {
126                         $!!!Name = $this->getConfigInstance()->getConfigEntry('default_action');
127                 } // END - if
128
129                 // Check if action is valid
130                 if ($this->is|||Valid($!!!Name) === FALSE) {
131                         // This action is invalid!
132                         throw new Invalid|||Exception(array($this, $!!!Name), self::EXCEPTION_INVALID_ACTION);
133                 } // END - if
134
135                 // Get the action
136                 $!!!Instance = $this->load|||();
137
138                 // Return the instance
139                 return $!!!Instance;
140         }
141 }
142
143 // [EOF]
144 ?>
145 <?php
146 /**
147  * A ??? resolver
148  *
149  * @author              Roland Haeder <webmaster@ship-simu.org>
150  * @version             0.0.0
151  * @copyright   Copyright (c) 2007, 2008 Roland Haeder, 2009 - 2012 Core Developer Team
152  * @license             GNU GPL 3.0 or any newer version
153  * @link                http://www.ship-simu.org
154  *
155  * This program is free software: you can redistribute it and/or modify
156  * it under the terms of the GNU General Public License as published by
157  * the Free Software Foundation, either version 3 of the License, or
158  * (at your option) any later version.
159  *
160  * This program is distributed in the hope that it will be useful,
161  * but WITHOUT ANY WARRANTY; without even the implied warranty of
162  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
163  * GNU General Public License for more details.
164  *
165  * You should have received a copy of the GNU General Public License
166  * along with this program. If not, see <http://www.gnu.org/licenses/>.
167  */
168 class ???Resolver extends BaseResolver implements Resolver {
169         /**
170          * Protected constructor
171          *
172          * @return      void
173          */
174         protected function __construct () {
175                 // Call parent constructor
176                 parent::__construct(__CLASS__);
177
178                 // Set prefix to '???'
179                 $this->setClassPrefix('???');
180         }
181
182         /**
183          * Creates an instance of a Web action resolver with a given default action
184          *
185          * @param       $!!!Name                                The default action we shall execute
186          * @param       $appInstance                    An instance of a manageable application helper class
187          * @return      $resolverInstance               The prepared action resolver instance
188          * @throws      EmptyVariableException  Thrown if default action is not set
189          * @throws      Invalid|||Exception     Thrown if default action is invalid
190          */
191         public static final function create???Resolver ($!!!Name, ManageableApplication $appInstance) {
192                 // Create the new instance
193                 $resolverInstance = new ???Resolver();
194
195                 // Is the variable $!!!Name set and the action is valid?
196                 if (empty($!!!Name)) {
197                         // Then thrown an exception here
198                         throw new EmptyVariableException(array($resolverInstance, 'default|||'), self::EXCEPTION_UNEXPECTED_EMPTY_STRING);
199                 } elseif ($resolverInstance->is|||Valid($!!!Name) === FALSE) {
200                         // Invalid action found
201                         throw new Invalid|||Exception(array($resolverInstance, $!!!Name), self::EXCEPTION_INVALID_ACTION);
202                 }
203
204                 // Set the application instance
205                 $resolverInstance->setApplicationInstance($appInstance);
206
207                 // Return the prepared instance
208                 return $resolverInstance;
209         }
210
211         /**
212          * Returns an action instance for a given request class or null if
213          * it was not found
214          *
215          * @param       $requestInstance        An instance of a request class
216          * @return      $!!!Instance    An instance of the resolved action
217          * @throws      Invalid|||Exception                             Thrown if $!!!Name is
218          *                                                                                              invalid
219          * @throws      Invalid|||InstanceException             Thrown if $!!!Instance
220          *                                                                                              is an invalid instance
221          */
222         public function resolve|||ByRequest (Requestable $requestInstance) {
223                 // Init variables
224                 $!!!Name = '';
225                 $!!!Instance = null;
226
227                 // This goes fine so let's resolve the action
228                 $!!!Name = $requestInstance->getRequestElement('action');
229
230                 // Is the action empty? Then fall back to default action
231                 if (empty($!!!Name)) $!!!Name = $this->getConfigInstance()->getConfigEntry('default_action');
232
233                 // Check if action is valid
234                 if ($this->is|||Valid($!!!Name) === FALSE) {
235                         // This action is invalid!
236                         throw new Invalid|||Exception(array($this, $!!!Name), self::EXCEPTION_INVALID_ACTION);
237                 } // END - if
238
239                 // Get the action
240                 $!!!Instance = $this->load|||();
241
242                 // And validate it
243                 if ((!is_object($!!!Instance)) || (!$!!!Instance instanceof |||able)) {
244                         // This action has an invalid instance!
245                         throw new Invalid|||InstanceException(array($this, $!!!Name), self::EXCEPTION_INVALID_ACTION);
246                 } // END - if
247
248                 // Set last action
249                 $this->setResolvedInstance($!!!Instance);
250
251                 // Return the resolved action instance
252                 return $!!!Instance;
253         }
254
255         /**
256          * Resolves the action by its direct name and returns an instance of its class
257          *
258          * @return      $!!!Instance            An instance of the action class
259          * @throws      Invalid|||Exception     Thrown if $!!!Name is invalid
260          */
261         public function resolve||| () {
262                 // Initiate the instance variable
263                 $!!!Instance = null;
264
265                 // Get action name
266                 $!!!Name = $this->get|||Name();
267
268                 // Is the action empty? Then fall back to default action
269                 if (empty($!!!Name)) {
270                         $!!!Name = $this->getConfigInstance()->getConfigEntry('default_action');
271                 } // END - if
272
273                 // Check if action is valid
274                 if ($this->is|||Valid($!!!Name) === FALSE) {
275                         // This action is invalid!
276                         throw new Invalid|||Exception(array($this, $!!!Name), self::EXCEPTION_INVALID_ACTION);
277                 } // END - if
278
279                 // Get the action
280                 $!!!Instance = $this->load|||();
281
282                 // Return the instance
283                 return $!!!Instance;
284         }
285 }
286
287 // [EOF]
288 ?>
289 <?php
290 /**
291  * A ??? resolver
292  *
293  * @author              Roland Haeder <webmaster@ship-simu.org>
294  * @version             0.0.0
295  * @copyright   Copyright (c) 2007, 2008 Roland Haeder, 2009 - 2012 Core Developer Team
296  * @license             GNU GPL 3.0 or any newer version
297  * @link                http://www.ship-simu.org
298  *
299  * This program is free software: you can redistribute it and/or modify
300  * it under the terms of the GNU General Public License as published by
301  * the Free Software Foundation, either version 3 of the License, or
302  * (at your option) any later version.
303  *
304  * This program is distributed in the hope that it will be useful,
305  * but WITHOUT ANY WARRANTY; without even the implied warranty of
306  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
307  * GNU General Public License for more details.
308  *
309  * You should have received a copy of the GNU General Public License
310  * along with this program. If not, see <http://www.gnu.org/licenses/>.
311  */
312 class ???Resolver extends BaseResolver implements Resolver {
313         /**
314          * Protected constructor
315          *
316          * @return      void
317          */
318         protected function __construct () {
319                 // Call parent constructor
320                 parent::__construct(__CLASS__);
321
322                 // Set prefix to '???'
323                 $this->setClassPrefix('???');
324         }
325
326         /**
327          * Creates an instance of a Web action resolver with a given default action
328          *
329          * @param       $!!!Name                                The default action we shall execute
330          * @param       $appInstance                    An instance of a manageable application helper class
331          * @return      $resolverInstance               The prepared action resolver instance
332          * @throws      EmptyVariableException  Thrown if default action is not set
333          * @throws      Invalid|||Exception     Thrown if default action is invalid
334          */
335         public static final function create???Resolver ($!!!Name, ManageableApplication $appInstance) {
336                 // Create the new instance
337                 $resolverInstance = new ???Resolver();
338
339                 // Is the variable $!!!Name set and the action is valid?
340                 if (empty($!!!Name)) {
341                         // Then thrown an exception here
342                         throw new EmptyVariableException(array($resolverInstance, 'default|||'), self::EXCEPTION_UNEXPECTED_EMPTY_STRING);
343                 } elseif ($resolverInstance->is|||Valid($!!!Name) === FALSE) {
344                         // Invalid action found
345                         throw new Invalid|||Exception(array($resolverInstance, $!!!Name), self::EXCEPTION_INVALID_ACTION);
346                 }
347
348                 // Set the application instance
349                 $resolverInstance->setApplicationInstance($appInstance);
350
351                 // Return the prepared instance
352                 return $resolverInstance;
353         }
354
355         /**
356          * Returns an action instance for a given request class or null if
357          * it was not found
358          *
359          * @param       $requestInstance        An instance of a request class
360          * @return      $!!!Instance    An instance of the resolved action
361          * @throws      Invalid|||Exception                             Thrown if $!!!Name is
362          *                                                                                              invalid
363          * @throws      Invalid|||InstanceException             Thrown if $!!!Instance
364          *                                                                                              is an invalid instance
365          */
366         public function resolve|||ByRequest (Requestable $requestInstance) {
367                 // Init variables
368                 $!!!Name = '';
369                 $!!!Instance = null;
370
371                 // This goes fine so let's resolve the action
372                 $!!!Name = $requestInstance->getRequestElement('action');
373
374                 // Is the action empty? Then fall back to default action
375                 if (empty($!!!Name)) $!!!Name = $this->getConfigInstance()->getConfigEntry('default_action');
376
377                 // Check if action is valid
378                 if ($this->is|||Valid($!!!Name) === FALSE) {
379                         // This action is invalid!
380                         throw new Invalid|||Exception(array($this, $!!!Name), self::EXCEPTION_INVALID_ACTION);
381                 } // END - if
382
383                 // Get the action
384                 $!!!Instance = $this->load|||();
385
386                 // And validate it
387                 if ((!is_object($!!!Instance)) || (!$!!!Instance instanceof |||able)) {
388                         // This action has an invalid instance!
389                         throw new Invalid|||InstanceException(array($this, $!!!Name), self::EXCEPTION_INVALID_ACTION);
390                 } // END - if
391
392                 // Set last action
393                 $this->setResolvedInstance($!!!Instance);
394
395                 // Return the resolved action instance
396                 return $!!!Instance;
397         }
398
399         /**
400          * Resolves the action by its direct name and returns an instance of its class
401          *
402          * @return      $!!!Instance            An instance of the action class
403          * @throws      Invalid|||Exception     Thrown if $!!!Name is invalid
404          */
405         public function resolve||| () {
406                 // Initiate the instance variable
407                 $!!!Instance = null;
408
409                 // Get action name
410                 $!!!Name = $this->get|||Name();
411
412                 // Is the action empty? Then fall back to default action
413                 if (empty($!!!Name)) {
414                         $!!!Name = $this->getConfigInstance()->getConfigEntry('default_action');
415                 } // END - if
416
417                 // Check if action is valid
418                 if ($this->is|||Valid($!!!Name) === FALSE) {
419                         // This action is invalid!
420                         throw new Invalid|||Exception(array($this, $!!!Name), self::EXCEPTION_INVALID_ACTION);
421                 } // END - if
422
423                 // Get the action
424                 $!!!Instance = $this->load|||();
425
426                 // Return the instance
427                 return $!!!Instance;
428         }
429 }
430
431 // [EOF]
432 ?>
433 <?php
434 /**
435  * A ??? resolver
436  *
437  * @author              Roland Haeder <webmaster@ship-simu.org>
438  * @version             0.0.0
439  * @copyright   Copyright (c) 2007, 2008 Roland Haeder, 2009 - 2012 Core Developer Team
440  * @license             GNU GPL 3.0 or any newer version
441  * @link                http://www.ship-simu.org
442  *
443  * This program is free software: you can redistribute it and/or modify
444  * it under the terms of the GNU General Public License as published by
445  * the Free Software Foundation, either version 3 of the License, or
446  * (at your option) any later version.
447  *
448  * This program is distributed in the hope that it will be useful,
449  * but WITHOUT ANY WARRANTY; without even the implied warranty of
450  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
451  * GNU General Public License for more details.
452  *
453  * You should have received a copy of the GNU General Public License
454  * along with this program. If not, see <http://www.gnu.org/licenses/>.
455  */
456 class ???Resolver extends BaseResolver implements Resolver {
457         /**
458          * Protected constructor
459          *
460          * @return      void
461          */
462         protected function __construct () {
463                 // Call parent constructor
464                 parent::__construct(__CLASS__);
465
466                 // Set prefix to '???'
467                 $this->setClassPrefix('???');
468         }
469
470         /**
471          * Creates an instance of a Web action resolver with a given default action
472          *
473          * @param       $!!!Name                                The default action we shall execute
474          * @param       $appInstance                    An instance of a manageable application helper class
475          * @return      $resolverInstance               The prepared action resolver instance
476          * @throws      EmptyVariableException  Thrown if default action is not set
477          * @throws      Invalid|||Exception     Thrown if default action is invalid
478          */
479         public static final function create???Resolver ($!!!Name, ManageableApplication $appInstance) {
480                 // Create the new instance
481                 $resolverInstance = new ???Resolver();
482
483                 // Is the variable $!!!Name set and the action is valid?
484                 if (empty($!!!Name)) {
485                         // Then thrown an exception here
486                         throw new EmptyVariableException(array($resolverInstance, 'default|||'), self::EXCEPTION_UNEXPECTED_EMPTY_STRING);
487                 } elseif ($resolverInstance->is|||Valid($!!!Name) === FALSE) {
488                         // Invalid action found
489                         throw new Invalid|||Exception(array($resolverInstance, $!!!Name), self::EXCEPTION_INVALID_ACTION);
490                 }
491
492                 // Set the application instance
493                 $resolverInstance->setApplicationInstance($appInstance);
494
495                 // Return the prepared instance
496                 return $resolverInstance;
497         }
498
499         /**
500          * Returns an action instance for a given request class or null if
501          * it was not found
502          *
503          * @param       $requestInstance        An instance of a request class
504          * @return      $!!!Instance    An instance of the resolved action
505          * @throws      Invalid|||Exception                             Thrown if $!!!Name is
506          *                                                                                              invalid
507          * @throws      Invalid|||InstanceException             Thrown if $!!!Instance
508          *                                                                                              is an invalid instance
509          */
510         public function resolve|||ByRequest (Requestable $requestInstance) {
511                 // Init variables
512                 $!!!Name = '';
513                 $!!!Instance = null;
514
515                 // This goes fine so let's resolve the action
516                 $!!!Name = $requestInstance->getRequestElement('action');
517
518                 // Is the action empty? Then fall back to default action
519                 if (empty($!!!Name)) $!!!Name = $this->getConfigInstance()->getConfigEntry('default_action');
520
521                 // Check if action is valid
522                 if ($this->is|||Valid($!!!Name) === FALSE) {
523                         // This action is invalid!
524                         throw new Invalid|||Exception(array($this, $!!!Name), self::EXCEPTION_INVALID_ACTION);
525                 } // END - if
526
527                 // Get the action
528                 $!!!Instance = $this->load|||();
529
530                 // And validate it
531                 if ((!is_object($!!!Instance)) || (!$!!!Instance instanceof |||able)) {
532                         // This action has an invalid instance!
533                         throw new Invalid|||InstanceException(array($this, $!!!Name), self::EXCEPTION_INVALID_ACTION);
534                 } // END - if
535
536                 // Set last action
537                 $this->setResolvedInstance($!!!Instance);
538
539                 // Return the resolved action instance
540                 return $!!!Instance;
541         }
542
543         /**
544          * Resolves the action by its direct name and returns an instance of its class
545          *
546          * @return      $!!!Instance            An instance of the action class
547          * @throws      Invalid|||Exception     Thrown if $!!!Name is invalid
548          */
549         public function resolve||| () {
550                 // Initiate the instance variable
551                 $!!!Instance = null;
552
553                 // Get action name
554                 $!!!Name = $this->get|||Name();
555
556                 // Is the action empty? Then fall back to default action
557                 if (empty($!!!Name)) {
558                         $!!!Name = $this->getConfigInstance()->getConfigEntry('default_action');
559                 } // END - if
560
561                 // Check if action is valid
562                 if ($this->is|||Valid($!!!Name) === FALSE) {
563                         // This action is invalid!
564                         throw new Invalid|||Exception(array($this, $!!!Name), self::EXCEPTION_INVALID_ACTION);
565                 } // END - if
566
567                 // Get the action
568                 $!!!Instance = $this->load|||();
569
570                 // Return the instance
571                 return $!!!Instance;
572         }
573 }
574
575 // [EOF]
576 ?>