git.mxchange.org Git - hub.git/blob

   1 <?php
   2 // Own namespace
   3 namespace Org\Shipsimu\Hub\Cruncher\Template\Engine\Xml\TestUnit;
   4
   5 // Import application-specific stuff
   6
   7 // Import framework stuff
   8 use Org\Mxchange\CoreFramework\Registry\Registerable;
   9 use Org\Mxchange\CoreFramework\Template\Engine\Xml\BaseXmlTemplateEngine;
  10 use Org\Mxchange\CoreFramework\Template\Xml\CompileableXmlTemplate;
  11
  12 /**
  13  * An TestUnit template engine class for XML templates
  14  *
  15  * @author              Roland Haeder <webmaster@shipsimu.org>
  16  * @version             0.0.0
  17  * @copyright   Copyright (c) 2011 - 2020 Cruncher Developer Team
  18  * @license             GNU GPL 3.0 or any newer version
  19  * @link                http://www.shipsimu.org
  20  * @todo                This template engine does not make use of setTemplateType()
  21  *
  22  * This program is free software: you can redistribute it and/or modify
  23  * it under the terms of the GNU General Public License as published by
  24  * the Free Software Foundation, either version 3 of the License, or
  25  * (at your option) any later version.
  26  *
  27  * This program is distributed in the hope that it will be useful,
  28  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  29  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  30  * GNU General Public License for more details.
  31  *
  32  * You should have received a copy of the GNU General Public License
  33  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  34  */
  35 class XmlCruncherTestUnitTemplateEngine extends BaseXmlTemplateEngine implements CompileableXmlTemplate, Registerable {
  36         /**
  37          * Protected constructor
  38          *
  39          * @return      void
  40          */
  41         private function __construct () {
  42                 // Call parent constructor
  43                 parent::__construct(__CLASS__);
  44
  45                 // Init sub nodes
  46                 $this->setSubNodes(array(
  47                         'meta-data',
  48                         'global-project-identifier',
  49                         'test-unit-created',
  50                         'cipher',
  51                         'cipher-function',
  52                         'cipher-name',
  53                         'unprocessed-data',
  54                         'encrypted-message',
  55                         'cruncher-key-list',
  56                         'cruncher-key',
  57                         'key-id',
  58                         'key-value'
  59                 ));
  60         }
  61
  62         /**
  63          * Creates an instance of the class TemplateEngine and prepares it for usage
  64          *
  65          * @return      $templateInstance               An instance of TemplateEngine
  66          * @throws      BasePathIsEmptyException                If the provided $templateBasePath is empty
  67          * @throws      InvalidBasePathStringException  If $templateBasePath is no string
  68          * @throws      BasePathIsNoDirectoryException  If $templateBasePath is no
  69          *                                                                                      directory or not found
  70          * @throws      BasePathReadProtectedException  If $templateBasePath is
  71          *                                                                                      read-protected
  72          */
  73         public static final function createXmlCruncherTestUnitTemplateEngine () {
  74                 // Get a new instance
  75                 $templateInstance = new XmlCruncherTestUnitTemplateEngine();
  76
  77                 // Init template instance
  78                 $templateInstance->initXmlTemplateEngine('cruncher', 'test_unit');
  79
  80                 // Return the prepared instance
  81                 return $templateInstance;
  82         }
  83
  84         /**
  85          * Currently not used
  86          *
  87          * @param       $resource               XML parser resource (currently ignored)
  88          * @param       $characters             Characters to handle
  89          * @return      void
  90          */
  91         public function characterHandler ($resource, string $characters) {
  92                 // Trim all spaces away
  93                 $characters = trim($characters);
  94
  95                 // Is this string empty?
  96                 if (empty($characters)) {
  97                         // Then skip it silently
  98                         return;
  99                 }
 100
 101                 // Assign the found characters to variable and use the last entry from
 102                 // stack as the name
 103                 parent::assignVariable($this->getStackInstance()->getNamed('cruncher_test_unit'), $characters);
 104         }
 105
 106         /**
 107          * Getter for cache file (FQFN)
 108          *
 109          * @return      $fqfn   Full-qualified file name of the menu cache
 110          */
 111         public function getCruncherTestUnitCacheFqfn () {
 112                 $this->partialStub('Please implement this method.');
 113         }
 114
 115         /**
 116          * Starts the test-unit
 117          *
 118          * @return      void
 119          */
 120         protected function startTestUnit () {
 121                 // Push the node name on the stacker
 122                 $this->getStackInstance()->pushNamed('cruncher_test_unit', 'cruncher-test-unit');
 123         }
 124
 125         /**
 126          * Starts the meta-data
 127          *
 128          * @return      void
 129          */
 130         protected function startMetaData () {
 131                 // Push the node name on the stacker
 132                 $this->getStackInstance()->pushNamed('cruncher_test_unit', 'meta-data');
 133         }
 134
 135         /**
 136          * Starts the global-project-identifier
 137          *
 138          * @return      void
 139          */
 140         protected function startGlobalProjectIdentifier () {
 141                 // Push the node name on the stacker
 142                 $this->getStackInstance()->pushNamed('cruncher_test_unit', 'global-project-identifier');
 143         }
 144
 145         /**
 146          * Finishes the global-project-identifier
 147          *
 148          * @return      void
 149          */
 150         protected function finishGlobalProjectIdentifier () {
 151                 // Pop the last entry
 152                 $this->getStackInstance()->popNamed('cruncher_test_unit');
 153         }
 154
 155         /**
 156          * Starts the test-unit-created
 157          *
 158          * @return      void
 159          */
 160         protected function startTestUnitCreated () {
 161                 // Push the node name on the stacker
 162                 $this->getStackInstance()->pushNamed('cruncher_test_unit', 'test-unit-created');
 163         }
 164
 165         /**
 166          * Finishes the test-unit-created
 167          *
 168          * @return      void
 169          */
 170         protected function finishTestUnitCreated () {
 171                 // Pop the last entry
 172                 $this->getStackInstance()->popNamed('cruncher_test_unit');
 173         }
 174
 175         /**
 176          * Starts the cipher
 177          *
 178          * @return      void
 179          */
 180         protected function startCipher () {
 181                 // Push the node name on the stacker
 182                 $this->getStackInstance()->pushNamed('cruncher_test_unit', 'cipher');
 183         }
 184
 185         /**
 186          * Starts the cipher-function
 187          *
 188          * @return      void
 189          */
 190         protected function startCipherFunction () {
 191                 // Push the node name on the stacker
 192                 $this->getStackInstance()->pushNamed('cruncher_test_unit', 'cipher-function');
 193         }
 194
 195         /**
 196          * Finishes the cipher-function
 197          *
 198          * @return      void
 199          */
 200         protected function finishCipherFunction () {
 201                 // Pop the last entry
 202                 $this->getStackInstance()->popNamed('cruncher_test_unit');
 203         }
 204
 205         /**
 206          * Starts the cipher-name
 207          *
 208          * @return      void
 209          */
 210         protected function startCipherName () {
 211                 // Push the node name on the stacker
 212                 $this->getStackInstance()->pushNamed('cruncher_test_unit', 'cipher-name');
 213         }
 214
 215         /**
 216          * Finishes the cipher-name
 217          *
 218          * @return      void
 219          */
 220         protected function finishCipherName () {
 221                 // Pop the last entry
 222                 $this->getStackInstance()->popNamed('cruncher_test_unit');
 223         }
 224
 225         /**
 226          * Finishes the cipher
 227          *
 228          * @return      void
 229          */
 230         protected function finishCipher () {
 231                 // Pop the last entry
 232                 $this->getStackInstance()->popNamed('cruncher_test_unit');
 233         }
 234
 235         /**
 236          * Finishes the meta-data
 237          *
 238          * @return      void
 239          */
 240         protected function finishMetaData () {
 241                 // Pop the last entry
 242                 $this->getStackInstance()->popNamed('cruncher_test_unit');
 243         }
 244
 245         /**
 246          * Starts the unprocessed-data
 247          *
 248          * @return      void
 249          */
 250         protected function startUnprocessedData () {
 251                 // Push the node name on the stacker
 252                 $this->getStackInstance()->pushNamed('cruncher_test_unit', 'unprocessed-data');
 253         }
 254
 255         /**
 256          * Starts the encrypted-message
 257          *
 258          * @return      void
 259          */
 260         protected function startEncryptedMessage () {
 261                 // Push the node name on the stacker
 262                 $this->getStackInstance()->pushNamed('cruncher_test_unit', 'encrypted-message');
 263         }
 264
 265         /**
 266          * Finishes the encrypted-message
 267          *
 268          * @return      void
 269          */
 270         protected function finishEncryptedMessage () {
 271                 // Pop the last entry
 272                 $this->getStackInstance()->popNamed('cruncher_test_unit');
 273         }
 274
 275         /**
 276          * Starts the cruncher-key-list
 277          *
 278          * @param       $keyCount       Count of keys in this test unit
 279          * @return      void
 280          * @todo        Handle $keyCount
 281          */
 282         protected function startCruncherKeyList ($keyCount) {
 283                 // Push the node name on the stacker
 284                 $this->getStackInstance()->pushNamed('cruncher_test_unit', 'cruncher-key-list');
 285         }
 286
 287         /**
 288          * Starts the cruncher-key
 289          *
 290          * @return      void
 291          */
 292         protected function startCruncherKey () {
 293                 // Push the node name on the stacker
 294                 $this->getStackInstance()->pushNamed('cruncher_test_unit', 'cruncher-key');
 295         }
 296
 297         /**
 298          * Starts the key-id
 299          *
 300          * @return      void
 301          */
 302         protected function startKeyId () {
 303                 // Push the node name on the stacker
 304                 $this->getStackInstance()->pushNamed('cruncher_test_unit', 'key-id');
 305         }
 306
 307         /**
 308          * Finishes the key-id
 309          *
 310          * @return      void
 311          */
 312         protected function finishKeyId () {
 313                 // Pop the last entry
 314                 $this->getStackInstance()->popNamed('cruncher_test_unit');
 315         }
 316
 317         /**
 318          * Starts the key-value
 319          *
 320          * @return      void
 321          */
 322         protected function startKeyValue () {
 323                 // Push the node name on the stacker
 324                 $this->getStackInstance()->pushNamed('cruncher_test_unit', 'key-value');
 325         }
 326
 327         /**
 328          * Finishes the key-value
 329          *
 330          * @return      void
 331          */
 332         protected function finishKeyValue () {
 333                 // Pop the last entry
 334                 $this->getStackInstance()->popNamed('cruncher_test_unit');
 335         }
 336
 337         /**
 338          * Finishes the cruncher-key
 339          *
 340          * @return      void
 341          */
 342         protected function finishCruncherKey () {
 343                 // Pop the last entry
 344                 $this->getStackInstance()->popNamed('cruncher_test_unit');
 345         }
 346
 347         /**
 348          * Finishes the cruncher-key-list
 349          *
 350          * @return      void
 351          */
 352         protected function finishCruncherKeyList () {
 353                 // Pop the last entry
 354                 $this->getStackInstance()->popNamed('cruncher_test_unit');
 355         }
 356
 357         /**
 358          * Finishes the unprocessed-data
 359          *
 360          * @return      void
 361          */
 362         protected function finishUnprocessedData () {
 363                 // Pop the last entry
 364                 $this->getStackInstance()->popNamed('cruncher_test_unit');
 365         }
 366
 367         /**
 368          * Finishes the test-unit
 369          *
 370          * @return      void
 371          */
 372         protected function finishTestUnit () {
 373                 // Pop the last entry
 374                 $this->getStackInstance()->popNamed('cruncher_test_unit');
 375         }
 376
 377 }