class_BaseFrameworkSystem.php

Go to the documentation of this file.

<?php
class BaseFrameworkSystem extends stdClass implements FrameworkInterface {
        private static $applicationInstance = null;

        private static $langInstance = null;

        private static $debugInstance = null;

        private $requestInstance = null;

        private $responseInstance = null;

        private $searchInstance = null;

        private $fileIoInstance = null;

        private $resolverInstance = null;

        private $templateInstance = null;

        private $resultInstance = null;

        private $userInstance = null;

        private $controllerInstance = null;

        private $realClass      = "FrameworkSystem";

        private $thousands = "."; // German

        private $decimals  = ","; // German

        /***********************
         * Exception codes.... *
         ***********************/

        const EXCEPTION_IS_NULL_POINTER              = 0x001;
        const EXCEPTION_IS_NO_OBJECT                 = 0x002;
        const EXCEPTION_IS_NO_ARRAY                  = 0x003;
        const EXCEPTION_MISSING_METHOD               = 0x004;
        const EXCEPTION_CLASSES_NOT_MATCHING         = 0x005;
        const EXCEPTION_INDEX_OUT_OF_BOUNDS          = 0x006;
        const EXCEPTION_DIMENSION_ARRAY_INVALID      = 0x007;
        const EXCEPTION_ITEM_NOT_TRADEABLE           = 0x008;
        const EXCEPTION_ITEM_NOT_IN_PRICE_LIST       = 0x009;
        const EXCEPTION_GENDER_IS_WRONG              = 0x00a;
        const EXCEPTION_BIRTH_DATE_IS_INVALID        = 0x00b;
        const EXCEPTION_EMPTY_STRUCTURES_ARRAY       = 0x00c;
        const EXCEPTION_HAS_ALREADY_PERSONELL_LIST   = 0x00d;
        const EXCEPTION_NOT_ENOUGTH_UNEMPLOYEES      = 0x00e;
        const EXCEPTION_TOTAL_PRICE_NOT_CALCULATED   = 0x00f;
        const EXCEPTION_HARBOR_HAS_NO_SHIPYARDS      = 0x010;
        const EXCEPTION_CONTRACT_PARTNER_INVALID     = 0x011;
        const EXCEPTION_CONTRACT_PARTNER_MISMATCH    = 0x012;
        const EXCEPTION_CONTRACT_ALREADY_SIGNED      = 0x013;
        const EXCEPTION_UNEXPECTED_EMPTY_STRING      = 0x014;
        const EXCEPTION_PATH_NOT_FOUND               = 0x015;
        const EXCEPTION_INVALID_PATH_NAME            = 0x016;
        const EXCEPTION_READ_PROTECED_PATH           = 0x017;
        const EXCEPTION_WRITE_PROTECED_PATH          = 0x018;
        const EXCEPTION_DIR_POINTER_INVALID          = 0x019;
        const EXCEPTION_FILE_POINTER_INVALID         = 0x01a;
        const EXCEPTION_INVALID_DIRECTORY_POINTER    = 0x01b;
        const EXCEPTION_UNEXPECTED_OBJECT            = 0x01c;
        const EXCEPTION_LIMIT_ELEMENT_IS_UNSUPPORTED = 0x01d;
        const EXCEPTION_GETTER_IS_MISSING            = 0x01e;
        const EXCEPTION_ARRAY_EXPECTED               = 0x01f;
        const EXCEPTION_ARRAY_HAS_INVALID_COUNT      = 0x020;
        const EXCEPTION_ID_IS_INVALID_FORMAT         = 0x021;
        const EXCEPTION_MD5_CHECKSUMS_MISMATCH       = 0x022;
        const EXCEPTION_UNEXPECTED_STRING_SIZE       = 0x023;
        const EXCEPTION_SIMULATOR_ID_INVALID         = 0x024;
        const EXCEPTION_MISMATCHING_COMPRESSORS      = 0x025;
        const EXCEPTION_CONTAINER_ITEM_IS_NULL       = 0x026;
        const EXCEPTION_ITEM_IS_NO_ARRAY             = 0x027;
        const EXCEPTION_CONTAINER_MAYBE_DAMAGED      = 0x028;
        const EXCEPTION_INVALID_STRING               = 0x029;
        const EXCEPTION_VARIABLE_NOT_SET             = 0x02a;
        const EXCEPTION_ATTRIBUTES_ARE_MISSING       = 0x02b;
        const EXCEPTION_ARRAY_ELEMENTS_MISSING       = 0x02c;
        const EXCEPTION_TEMPLATE_ENGINE_UNSUPPORTED  = 0x02d;
        const EXCEPTION_MISSING_LANGUAGE_HANDLER     = 0x02e;
        const EXCEPTION_MISSING_FILE_IO_HANDLER      = 0x02f;
        const EXCEPTION_MISSING_ELEMENT              = 0x030;
        const EXCEPTION_HEADERS_ALREADY_SENT         = 0x031;
        const EXCEPTION_DEFAULT_CONTROLLER_GONE      = 0x032;
        const EXCEPTION_CLASS_NOT_FOUND              = 0x033;
        const EXCEPTION_REQUIRED_INTERFACE_MISSING   = 0x034;
        const EXCEPTION_FATAL_ERROR                  = 0x035;
        const EXCEPTION_FILE_NOT_FOUND               = 0x036;
        const EXCEPTION_ASSERTION_FAILED             = 0x037;
        const EXCEPTION_FILE_CANNOT_BE_READ          = 0x038;
        const EXCEPTION_DATABASE_UPDATED_NOT_ALLOWED = 0x039;

        private $systemClasses = array(
                "DebugMiddleware",                              // Debug middleware output sub-system
                "Registry",                                             // Object registry
                "ObjectFactory",                                // Object factory
                "DebugWebOutput",                               // Debug web output sub-system
                "WebOutput",                                    // Web output sub-system
                "CompressorChannel",                    // Compressor sub-system
                "DebugConsoleOutput",                   // Debug console output sub-system
                "DebugErrorLogOutput",                  // Debug error_log() output sub-system
                "FrameworkDirectoryPointer",    // Directory handler sub-system
                "NullCompressor",                               // Null compressor
                "Bzip2Compressor",                              // BZIP2 compressor
                "GzipCompressor",                               // GZIP compressor
        );

        /* No longer used:
        */

        protected function __construct ($className) {
                // Set real class
                $this->setRealClass($className);

                // Initialize the class if class Registry is there
                if ((class_exists('Registry')) && (Registry::isInitialized() === false)) {
                        // Initialize the registry automatically
                        $this->initInstance();
                } // END - if
        }

        public function __destruct() {
                // Is this object already destroyed?
                if ($this->__toString() != 'DestructedObject') {
                        // Destroy all informations about this class but keep some text about it alive
                        $this->setRealClass('DestructedObject');
                } elseif ((defined('DEBUG_DESTRUCTOR')) && (is_object($this->getDebugInstance()))) {
                        // Already destructed object
                        $this->debugOutput(sprintf("[%s:] The object <span class=\"object_name\">%s</span> is already destroyed.",
                                __CLASS__, $this->__toString()
                        ));
                }
        }

        public final function __call ($methodName, $args) {
                // Implode all given arguments
                $argsString = "";
                if (empty($args)) {
                        // No arguments
                        $argsString = "NULL";
                } elseif (is_array($args)) {
                        // Some arguments are there
                        foreach ($args as $arg) {
                                // Add the type
                                $argsString .= $arg." (".gettype($arg);

                                // Add length if type is string
                                if (gettype($arg) == 'string') $argsString .= ", ".strlen($arg);

                                // Closing bracket
                                $argsString .= "), ";
                        } // END - foreach

                        // Remove last comma
                        if (substr($argsString, -2, 1) === ",") {
                                $argsString = substr($argsString, 0, -2);
                        } // END - if
                } else {
                        // Invalid arguments!
                        $argsString = sprintf("!INVALID:%s!", $args);
                }

                // Output stub message
                $this->debugOutput(sprintf("[%s-&gt;%s] Stub! Args: %s",
                        $this->__toString(),
                        $methodName,
                        $argsString
                ));

                // Return nothing
                return null;
        }

        private final function initInstance () {
                // Is this a system class?
                if (!in_array($this->__toString(), $this->systemClasses)) {
                        // Set configuration instance
                        $this->setConfigInstance(FrameworkConfiguration::getInstance());

                        // Add application helper to our class
                        $this->systemclasses[] = $this->getConfigInstance()->readConfig('app_helper_class');

                        // Set debug instance
                        $this->setDebugInstance(DebugMiddleware::createDebugMiddleware($this->getConfigInstance()->readConfig('debug_class')));

                        // Get output instance and set it
                        $outputInstance = ObjectFactory::createObjectByConfiguredName('web_engine', array($this->getConfigInstance()->readConfig('web_content_type')));
                        $this->setWebOutputInstance($outputInstance);

                        // Set the compressor channel
                        $this->setCompressorChannel(CompressorChannel::createCompressorChannel(sprintf("%s%s",
                                $this->getConfigInstance()->readConfig('base_path'),
                                $this->getConfigInstance()->readConfig('compressor_base_path')
                        )));

                        // Initialization done! :D
                        Registry::isInitialized('OK');
                } elseif ($this->__toString() == 'DebugMiddleware') {
                        // Set configuration instance
                        $this->setConfigInstance(FrameworkConfiguration::getInstance());
                }
        }

        protected final function setResultInstance (SearchableResult $resultInstance) {
                $this->resultInstance =  $resultInstance;
        }

        public final function getResultInstance () {
                return $this->resultInstance;
        }

        protected final function setTemplateInstance (CompileableTemplate $templateInstance) {
                $this->templateInstance = $templateInstance;
        }

        protected final function getTemplateInstance () {
                return $this->templateInstance;
        }

        public final function setSearchInstance (LocalSearchCriteria $searchInstance) {
                $this->searchInstance = $searchInstance;
        }

        public final function getSearchInstance () {
                return $this->searchInstance;
        }

        public final function setResolverInstance (Resolver $resolverInstance) {
                $this->resolverInstance = $resolverInstance;
        }

        public final function getResolverInstance () {
                return $this->resolverInstance;
        }

        public final function setConfigInstance (FrameworkConfiguration $configInstance) {
                Registry::getRegistry()->addInstance('config', $configInstance);
        }

        public final function getConfigInstance () {
                $cfgInstance = Registry::getRegistry()->getInstance('config');
                return $cfgInstance;
        }

        public final function setDebugInstance (DebugMiddleware $debugInstance) {
                self::$debugInstance = $debugInstance;
        }

        public final function getDebugInstance () {
                return self::$debugInstance;
        }

        public final function setWebOutputInstance (OutputStreamer $webInstance) {
                Registry::getRegistry()->addInstance('web_output', $webInstance);
        }

        public final function getWebOutputInstance () {
                return Registry::getRegistry()->getInstance('web_output');
        }

        public final function setDatabaseInstance (DatabaseConnection $dbInstance) {
                Registry::getRegistry()->addInstance('dbInstance', $dbInstance);
        }

        public final function getDatabaseInstance () {
                // Default is invalid db instance
                $dbInstance = null;

                // Is the registry there and initialized?
                if ((class_exists('Registry')) && (Registry::isInitialized() === true)) {
                        $dbInstance = Registry::getRegistry()->getInstance('dbInstance');
                } // END - if

                // Return instance
                return $dbInstance;
        }

        public final function setCompressorChannel (CompressorChannel $compressorChannel) {
                Registry::getRegistry()->addInstance('compressor', $compressorChannel);
        }

        public final function getCompressorChannel () {
                return Registry::getRegistry()->getInstance('compressor');
        }

        protected final function getApplicationInstance () {
                return self::$applicationInstance;
        }

        public final function setApplicationInstance (ManageableApplication $applicationInstance) {
                self::$applicationInstance = $applicationInstance;
        }

        public final function setRequestInstance (Requestable $requestInstance) {
                $this->requestInstance = $requestInstance;
        }

        public final function getRequestInstance () {
                return $this->requestInstance;
        }

        public final function setResponseInstance (Responseable $responseInstance) {
                $this->responseInstance = $responseInstance;
        }

        public final function getResponseInstance () {
                return $this->responseInstance;
        }

        public final function __toString () {
                return $this->realClass;
        }

        public final function setRealClass ($realClass) {
                // Cast to string
                $realClass = (string) $realClass;

                // Set real class
                $this->realClass = $realClass;
        }

        public final function isClass ($className) {
                return ($this->__toString() == $className);
        }

        public function isCabin () {
                return false;
        }

        public function isTradeable () {
                return false;
        }

        public function formatCurrency ($value, $currency = "&euro;", $decNum = 2) {
                // Are all required attriutes set?
                if ((!isset($this->decimals)) || (!isset($this->thousands))) {
                        // Throw an exception
                        throw new MissingDecimalsThousandsSeperatorException($this, self::EXCEPTION_ATTRIBUTES_ARE_MISSING);
                }

                // Cast the number
                $value = (float) $value;

                // Reformat the US number
                $price = sprintf("%s %s",
                        number_format($value, $decNum, $this->decimals, $this->thousands),
                        $currency
                );

                // Return as string...
                return $price;
        }

        public final function removeNumberFormaters () {
                unset($this->thousands);
                unset($this->decimals);
        }

        protected final function getLanguageInstance () {
                return self::$langInstance;
        }

        public final function setLanguageInstance (ManageableLanguage $langInstance) {
                self::$langInstance = $langInstance;
        }

        public final function removeSystemArray () {
                unset($this->systemClasses);
        }

        public final function addMissingTrailingSlash ($str) {
                // Is there a trailing slash?
                if (substr($str, -1, 1) != "/") $str .= "/";
                return $str;
        }

        protected final function getFileIoInstance () {
                return $this->fileIoInstance;
        }

        public final function setFileIoInstance (FileIoHandler $fileIoInstance) {
                $this->fileIoInstance = $fileIoInstance;
        }

        protected function prepareTemplateInstance (BaseFrameworkSystem $appInstance=null) {
                // Is the application instance set?
                if (is_null($appInstance)) {
                        // Get the current instance
                        $appInstance = $this->getApplicationInstance();

                        // Still null?
                        if (is_null($appInstance)) {
                                // Thrown an exception
                                throw new NullPointerException($this, self::EXCEPTION_IS_NULL_POINTER);
                        } // END - if
                } // END - if

                // Generate FQFN for all application templates
                $fqfn = sprintf("%s%s/%s",
                        $this->getConfigInstance()->readConfig('application_path'),
                        strtolower($appInstance->getAppShortName()),
                        $this->getConfigInstance()->readConfig('tpl_base_path')
                );

                // Are both instances set?
                if ($appInstance->getLanguageInstance() === null) {
                        // Invalid language instance
                        throw new MissingLanguageHandlerException($appInstance, self::EXCEPTION_MISSING_LANGUAGE_HANDLER);
                } elseif ($appInstance->getFileIoInstance() === null) {
                        // Invalid language instance
                        throw new MissingFileIoHandlerException($appInstance, self::EXCEPTION_MISSING_FILE_IO_HANDLER);
                }

                // Initialize the template engine
                $templateInstance = ObjectFactory::createObjectByConfiguredName('template_class', array($fqfn, $appInstance->getLanguageInstance(), $appInstance->getFileIoInstance()));

                // Return the prepared instance
                return $templateInstance;
        }

        public final function debugInstance ($message = "") {
                // Restore the error handler to avoid trouble with missing array elements or undeclared variables
                restore_error_handler();

                // Init content
                $content = "";

                // Is a message set?
                if (!empty($message)) {
                        // Construct message
                        $content = sprintf("<div class=\"debug_message\">Message: %s</div>\n", $message);
                } // END - if

                // Generate the output
                $content .= sprintf("<pre>%s</pre>",
                        trim(
                                htmlentities(
                                        print_r($this, true)
                                )
                        )
                );

                // Output it
                ApplicationEntryPoint::app_die(sprintf("<div class=\"debug_header\">%s debug output:</div><div class=\"debug_content\">%s</div>\nLoaded includes: <div class=\"debug_include_list\">%s</div>",
                        $this->__toString(),
                        $content,
                        ClassLoader::getInstance()->getPrintableIncludeList()
                ));
        }

        protected function partialStub ($message = "") {
                // Get the backtrace
                $backtrace = debug_backtrace();

                // Generate the class::method string
                $methodName = "UnknownClass-&gt;unknownMethod";
                if ((isset($backtrace[1]['class'])) && (isset($backtrace[1]['function']))) {
                        $methodName = $backtrace[1]['class']."-&gt;".$backtrace[1]['function'];
                } // END - if

                // Construct the full message
                $stubMessage = sprintf("[%s:] Partial stub!",
                        $methodName
                );

                // Is the extra message given?
                if (!empty($message)) {
                        // Then add it as well
                        $stubMessage .= sprintf(" Message: <span id=\"stub_message\">%s</span>", $message);
                } // END - if

                // Debug instance is there?
                if (!is_null($this->getDebugInstance())) {
                        // Output stub message
                        $this->debugOutput($stubMessage);
                } else {
                        // Trigger an error
                        trigger_error($stubMessage."<br />\n");
                }
        }

        public function debugBackTrace () {
                // Sorry, there is no other way getting this nice backtrace
                print("<pre>\n");
                debug_print_backtrace();
                print("</pre>");
                exit();
        }

        public function debugOutput ($message, $doPrint = true) {
                // Get debug instance
                $debugInstance = $this->getDebugInstance();

                // Is the debug instance there?
                if (is_object($debugInstance)) {
                        // Use debug output handler
                        $debugInstance->output($message);
                        if ($doPrint === false) die(); // Die here if not printed
                } else {
                        // Put directly out
                        if ($doPrint) {
                                print($message);
                        } else {
                                // DO NOT REWRITE THIS TO app_die() !!!
                                die($message);
                        }
                }
        }

        public function convertToClassName ($str) {
                // Init class name
                $className = "";

                // Convert all dashes in underscores
                $str = str_replace("-", "_", $str);

                // Now use that underscores to get classname parts for hungarian style
                foreach (explode("_", $str) as $strPart) {
                        // Make the class name part lower case and first upper case
                        $className .= ucfirst(strtolower($strPart));
                } // END - foreach

                // Return class name
                return $className;
        }

        public function markupCode ($phpCode) {
                // Init marked code
                $markedCode = "";

                // Get last error
                $errorArray = error_get_last();

                // Init the code with error message
                if (is_array($errorArray)) {
                        // Get error infos
                        $markedCode = sprintf("<div id=\"error_header\">File: <span id=\"error_data\">%s</span>, Line: <span id=\"error_data\">%s</span>, Message: <span id=\"error_data\">%s</span>, Type: <span id=\"error_data\">%s</span></div>",
                                basename($errorArray['file']),
                                $errorArray['line'],
                                $errorArray['message'],
                                $errorArray['type']
                        );
                } // END - if

                // Add line number to the code
                foreach (explode("\n", $phpCode) as $lineNo => $code) {
                        // Add line numbers
                        $markedCode .= sprintf("<span id=\"code_line\">%s</span>: %s\n",
                                ($lineNo + 1),
                                htmlentities($code, ENT_QUOTES)
                        );
                } // END - foreach

                // Return the code
                return $markedCode;
        }

        public function doFilterFormatTimestamp ($timestamp) {
                // Default value to return
                $readable = "???";

                // Is the timestamp null?
                if (is_null($timestamp)) {
                        // Get a message string
                        $readable = $this->getLanguageInstance()->getMessage('null_timestamp');
                } else {
                        switch ($this->getLanguageInstance()->getLanguageCode()) {
                                case "de": // German format is a bit different to default
                                        // Split the GMT stamp up
                                        $dateTime = explode(" ", $timestamp);
                                        $dateArray = explode("-", $dateTime[0]);
                                        $timeArray = explode(":", $dateTime[1]);

                                        // Construct the timestamp
                                        $readable = sprintf($this->getConfigInstance()->readConfig('german_date_time'),
                                                $dateArray[0],
                                                $dateArray[1],
                                                $dateArray[2],
                                                $timeArray[0],
                                                $timeArray[1],
                                                $timeArray[2]
                                        );
                                        break;

                                default: // Default is pass-through
                                        $readable = $timestamp;
                                        break;
                        }
                }

                // Return the stamp
                return $readable;
        }

        protected final function getDatabaseEntry () {
                // Is there an instance?
                if (is_null($this->getResultInstance())) {
                        // Throw an exception here
                        throw new NullPointerException($this, self::EXCEPTION_IS_NULL_POINTER);
                } // END - if

                // Rewind it
                $this->getResultInstance()->rewind();

                // Do we have an entry?
                if ($this->getResultInstance()->valid() === false) {
                        throw new InvalidDatabaseResultException(array($this, $this->getResultInstance()), DatabaseResult::EXCEPTION_INVALID_DATABASE_RESULT);
                } // END - if

                // Get next entry
                $this->getResultInstance()->next();

                // Fetch it
                $entry = $this->getResultInstance()->current();

                // And return it
                return $entry;
        }

        public final function getField ($fieldName) {
                // Default field value
                $fieldValue = null;

                // Get result instance
                $resultInstance = $this->getResultInstance();

                // Is this instance null?
                if (is_null($resultInstance)) {
                        // Then the user instance is no longer valid (expired cookies?)
                        throw new NullPointerException($this, self::EXCEPTION_IS_NULL_POINTER);
                } // END - if

                // Get current array
                $fieldArray = $resultInstance->current();

                // Does the field exist?
                if (isset($fieldArray[$fieldName])) {
                        // Get it
                        $fieldValue = $fieldArray[$fieldName];
                } // END - if

                // Return it
                return $fieldValue;
        }

        protected final function setUserInstance (ManageableAccount $userInstance) {
                $this->userInstance = $userInstance;
        }

        public final function getUserInstance () {
                return $this->userInstance;
        }

        public final function setControllerInstance (Controller $controllerInstance) {
                $this->controllerInstance = $controllerInstance;
        }

        public final function getControllerInstance () {
                return $this->controllerInstance;
        }
}

// [EOF]
?>