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