/**
* Instance of a request class
*/
- private $requestInstance = null;
+ private $requestInstance = NULL;
/**
* Instance of a response class
*/
- private $responseInstance = null;
+ private $responseInstance = NULL;
/**
* Search criteria instance
*/
- private $searchInstance = null;
+ private $searchInstance = NULL;
/**
* Update criteria instance
*/
- private $updateInstance = null;
+ private $updateInstance = NULL;
/**
* The file I/O instance for the template loader
*/
- private $fileIoInstance = null;
+ private $fileIoInstance = NULL;
/**
* Resolver instance
*/
- private $resolverInstance = null;
+ private $resolverInstance = NULL;
/**
* Template engine instance
*/
- private $templateInstance = null;
+ private $templateInstance = NULL;
/**
* Database result instance
*/
- private $resultInstance = null;
+ private $resultInstance = NULL;
/**
* Instance for user class
*/
- private $userInstance = null;
+ private $userInstance = NULL;
/**
* A controller instance
*/
- private $controllerInstance = null;
+ private $controllerInstance = NULL;
/**
* Instance of a RNG
*/
- private $rngInstance = null;
+ private $rngInstance = NULL;
/**
* Instance of a crypto helper
*/
- private $cryptoInstance = null;
+ private $cryptoInstance = NULL;
/**
* Instance of an Iterator class
*/
- private $iteratorInstance = null;
+ private $iteratorInstance = NULL;
/**
* Instance of the list
*/
- private $listInstance = null;
+ private $listInstance = NULL;
/**
* Instance of a menu
*/
- private $menuInstance = null;
+ private $menuInstance = NULL;
/**
* Instance of the image
*/
- private $imageInstance = null;
+ private $imageInstance = NULL;
/**
* Instance of the stacker
*/
- private $stackerInstance = null;
+ private $stackerInstance = NULL;
/**
* A Compressor instance
*/
- private $compressorInstance = null;
+ private $compressorInstance = NULL;
/**
* A Parseable instance
*/
- private $parserInstance = null;
+ private $parserInstance = NULL;
/**
* A ProtocolHandler instance
*/
- private $protocolInstance = null;
+ private $protocolInstance = NULL;
/**
* A database wrapper instance
*/
- private $databaseInstance = null;
+ private $databaseInstance = NULL;
+
+ /**
+ * A helper instance for the form
+ */
+ private $helperInstance = NULL;
+
+ /**
+ * An instance of a Sourceable class
+ */
+ private $sourceInstance = NULL;
+
+ /**
+ * An instance of a InputStreamable class
+ */
+ private $inputStreamInstance = NULL;
+
+ /**
+ * An instance of a OutputStreamable class
+ */
+ private $outputStreamInstance = NULL;
+
+ /**
+ * Networkable handler instance
+ */
+ private $handlerInstance = NULL;
+
+ /**
+ * Visitor handler instance
+ */
+ private $visitorInstance = NULL;
/**
* The real class name
*/
private $realClass = 'BaseFrameworkSystem';
+ /**
+ * An instance of a database wrapper class
+ */
+ private $wrapperInstance = NULL;
+
/**
* Thousands seperator
*/
/***********************
* Exception codes.... *
***********************/
+
// @todo Try to clean these constants up
const EXCEPTION_IS_NULL_POINTER = 0x001;
const EXCEPTION_IS_NO_OBJECT = 0x002;
const EXCEPTION_ATTRIBUTES_ARE_MISSING = 0x02b;
const EXCEPTION_ARRAY_ELEMENTS_MISSING = 0x02c;
const EXCEPTION_TEMPLATE_ENGINE_UNSUPPORTED = 0x02d;
+ const EXCEPTION_UNSPPORTED_OPERATION = 0x02e;
const EXCEPTION_MISSING_ELEMENT = 0x030;
const EXCEPTION_HEADERS_ALREADY_SENT = 0x031;
const EXCEPTION_DEFAULT_CONTROLLER_GONE = 0x032;
const EXCEPTION_DATABASE_UPDATED_NOT_ALLOWED = 0x039;
const EXCEPTION_FILTER_CHAIN_INTERCEPTED = 0x040;
+ /**
+ * Hexadecimal->Decimal translation array
+ */
+ private static $hexdec = array(
+ '0' => 0,
+ '1' => 1,
+ '2' => 2,
+ '3' => 3,
+ '4' => 4,
+ '5' => 5,
+ '6' => 6,
+ '7' => 7,
+ '8' => 8,
+ '9' => 9,
+ 'a' => 10,
+ 'b' => 11,
+ 'c' => 12,
+ 'd' => 13,
+ 'e' => 14,
+ 'f' => 15
+ );
+
+ /**
+ * Decimal->hexadecimal translation array
+ */
+ private static $dechex = array(
+ 0 => '0',
+ 1 => '1',
+ 2 => '2',
+ 3 => '3',
+ 4 => '4',
+ 5 => '5',
+ 6 => '6',
+ 7 => '7',
+ 8 => '8',
+ 9 => '9',
+ 10 => 'a',
+ 11 => 'b',
+ 12 => 'c',
+ 13 => 'd',
+ 14 => 'e',
+ 15 => 'f'
+ );
+
+ /**
+ * Startup time in miliseconds
+ */
+ private static $startupTime = 0;
+
/**
* Protected super constructor
*
// ... because registries doesn't need to be configured
$this->setConfigInstance(FrameworkConfiguration::getInstance());
} // END - if
+
+ // Is the startup time set? (0 cannot be true anymore)
+ if (self::$startupTime == 0) {
+ // Then set it
+ self::$startupTime = microtime(true);
+ } // END - if
}
/**
- * Destructor reached...
+ * Destructor for all classes
*
* @return void
*/
* @return void
*/
public final function __set ($name, $value) {
- $this->debugOutput(sprintf("Tried to set a missing field. name=%s, value[%s]=%s",
+ $this->debugBackTrace(sprintf("Tried to set a missing field. name=%s, value[%s]=%s",
$name,
gettype($value),
$value
* @return void
*/
public final function __get ($name) {
- $this->debugOutput(sprintf("Tried to get a missing field. name=%s",
+ $this->debugBackTrace(sprintf("Tried to get a missing field. name=%s",
+ $name
+ ));
+ }
+
+ /**
+ * Magic function to catch unsetting of missing fields/attributes
+ *
+ * @param $name Name of the field/attribute
+ * @return void
+ */
+ public final function __unset ($name) {
+ $this->debugBackTrace(sprintf("Tried to unset a missing field. name=%s",
$name
));
}
/**
* Setter for database instance
*
- * @param $dbInstance The instance for the database connection (forced DatabaseConnection)
+ * @param $databaseInstance The instance for the database connection (forced DatabaseConnection)
* @return void
*/
- public final function setDatabaseInstance (DatabaseConnection $dbInstance) {
- Registry::getRegistry()->addInstance('db_instance', $dbInstance);
+ public final function setDatabaseInstance (DatabaseConnection $databaseInstance) {
+ Registry::getRegistry()->addInstance('db_instance', $databaseInstance);
}
/**
* Getter for database layer
*
- * @return $dbInstance The database layer instance
+ * @return $databaseInstance The database layer instance
*/
public final function getDatabaseInstance () {
// Get instance
- $dbInstance = Registry::getRegistry()->getInstance('db_instance');
+ $databaseInstance = Registry::getRegistry()->getInstance('db_instance');
// Return instance
- return $dbInstance;
+ return $databaseInstance;
}
/**
* @throws NullPointerException If the discovered application
* instance is still null
*/
- protected function prepareTemplateInstance (ManageableApplication $applicationInstance = null) {
+ protected function prepareTemplateInstance (ManageableApplication $applicationInstance = NULL) {
// Is the application instance set?
if (is_null($applicationInstance)) {
// Get the current instance
protected function replaceControlCharacters ($str) {
// Replace them
$str = str_replace(
- "\r", '[r]', str_replace(
- "\n", '[n]', str_replace(
- "\t", '[t]',
+ chr(13), '[r]', str_replace(
+ chr(10), '[n]', str_replace(
+ chr(9) , '[t]',
$str
)));
/**
* Outputs a debug backtrace and stops further script execution
*
+ * @param $message An optional message to output
* @return void
*/
- public function debugBackTrace () {
+ public function debugBackTrace ($message = '') {
// Sorry, there is no other way getting this nice backtrace
+ if (!empty($message)) {
+ // Output message
+ printf("Message: %s<br />\n", $message);
+ } // END - if
+
print("<pre>\n");
debug_print_backtrace();
print("</pre>");
} else {
// Put directly out
if ($doPrint === true) {
- print($message);
+ // Are debug times enabled?
+ if ($this->getConfigInstance()->getConfigEntry('debug_output_timings') == 'Y') {
+ // Output it first
+ print($this->getPrintableExecutionTime());
+ } // END - if
+
+ // Print message
+ print($message . chr(10));
} else {
// DO NOT REWRITE THIS TO app_die() !!!
die($message);
} // END - if
// Add line number to the code
- foreach (explode("\n", $phpCode) as $lineNo => $code) {
+ foreach (explode(chr(10), $phpCode) as $lineNo => $code) {
// Add line numbers
$markedCode .= sprintf("<span id=\"code_line\">%s</span>: %s\n",
($lineNo + 1),
*/
public final function getField ($fieldName) {
// Default field value
- $fieldValue = null;
+ $fieldValue = NULL;
// Get result instance
$resultInstance = $this->getResultInstance();
// Get current time and add idle time
$sleepUntil = $this->getMilliTime() + abs($milliSeconds) / 1000;
- // New PHP 5.1.0 function found
- $hasSlept = time_sleep_until($sleepUntil);
+ // New PHP 5.1.0 function found, ignore errors
+ $hasSlept = @time_sleep_until($sleepUntil);
} else {
// My Sun Station doesn't have that function even with latest PHP
// package. :(
* @param $protocolInstance An instance of an ProtocolHandler
* @return void
*/
- public final function setProtocolInstance (ProtocolHandler $protocolInstance) {
+ public final function setProtocolInstance (ProtocolHandler $protocolInstance = NULL) {
$this->protocolInstance = $protocolInstance;
}
return $this->socketResource;
}
+ /**
+ * Setter for helper instance
+ *
+ * @param $helperInstance An instance of a helper class
+ * @return void
+ */
+ protected final function setHelperInstance (Helper $helperInstance) {
+ $this->helperInstance = $helperInstance;
+ }
+
+ /**
+ * Getter for helper instance
+ *
+ * @return $helperInstance An instance of a helper class
+ */
+ public final function getHelperInstance () {
+ return $this->helperInstance;
+ }
+
+ /**
+ * Setter for a Sourceable instance
+ *
+ * @param $sourceInstance The Sourceable instance
+ * @return void
+ */
+ protected final function setSourceInstance (Sourceable $sourceInstance) {
+ $this->sourceInstance = $sourceInstance;
+ }
+
+ /**
+ * Getter for a Sourceable instance
+ *
+ * @return $sourceInstance The Sourceable instance
+ */
+ protected final function getSourceInstance () {
+ return $this->sourceInstance;
+ }
+
+ /**
+ * Getter for a InputStreamable instance
+ *
+ * @param $inputStreamInstance The InputStreamable instance
+ */
+ protected final function getInputStreamInstance () {
+ return $this->inputStreamInstance;
+ }
+
+ /**
+ * Setter for a InputStreamable instance
+ *
+ * @param $inputStreamInstance The InputStreamable instance
+ * @return void
+ */
+ protected final function setInputStreamInstance (InputStreamable $inputStreamInstance) {
+ $this->inputStreamInstance = $inputStreamInstance;
+ }
+
+ /**
+ * Getter for a OutputStreamable instance
+ *
+ * @param $outputStreamInstance The OutputStreamable instance
+ */
+ protected final function getOutputStreamInstance () {
+ return $this->outputStreamInstance;
+ }
+
+ /**
+ * Setter for a OutputStreamable instance
+ *
+ * @param $outputStreamInstance The OutputStreamable instance
+ * @return void
+ */
+ protected final function setOutputStreamInstance (OutputStreamable $outputStreamInstance) {
+ $this->outputStreamInstance = $outputStreamInstance;
+ }
+
+ /**
+ * Setter for handler instance
+ *
+ * @param $handlerInstance A Networkable instance
+ * @return void
+ */
+ protected final function setHandlerInstance (Networkable $handlerInstance) {
+ $this->handlerInstance = $handlerInstance;
+ }
+
+ /**
+ * Getter for handler instance
+ *
+ * @return $handlerInstance A Networkable instance
+ */
+ protected final function getHandlerInstance () {
+ return $this->handlerInstance;
+ }
+
+ /**
+ * Setter for visitor instance
+ *
+ * @param $visitorInstance A Visitor instance
+ * @return void
+ */
+ protected final function setVisitorInstance (Visitor $visitorInstance) {
+ $this->visitorInstance = $visitorInstance;
+ }
+
+ /**
+ * Getter for visitor instance
+ *
+ * @return $visitorInstance A Visitor instance
+ */
+ protected final function getVisitorInstance () {
+ return $this->visitorInstance;
+ }
+
/**
* Setter for raw package Data
*
public function getPackageData () {
return $this->packageData;
}
+
+ /**
+ * Converts a hexadecimal string, even with negative sign as first string to
+ * a decimal number using BC functions.
+ *
+ * This work is based on comment #86673 on php.net documentation page at:
+ * <http://de.php.net/manual/en/function.dechex.php#86673>
+ *
+ * @param $hex Hexadecimal string
+ * @return $dec Decimal number
+ */
+ protected function hex2dec ($hex) {
+ // Convert to all lower-case
+ $hex = strtolower($hex);
+
+ // Detect sign (negative/positive numbers)
+ $sign = '';
+ if (substr($hex, 0, 1) == '-') {
+ $sign = '-';
+ $hex = substr($hex, 1);
+ } // END - if
+
+ // Decode the hexadecimal string into a decimal number
+ $dec = 0;
+ for ($i = strlen($hex) - 1, $e = 1; $i >= 0; $i--, $e = bcmul($e, 16)) {
+ $factor = self::$hexdec[substr($hex, $i, 1)];
+ $dec = bcadd($dec, bcmul($factor, $e));
+ } // END - for
+
+ // Return the decimal number
+ return $sign . $dec;
+ }
+
+ /**
+ * Converts even very large decimal numbers, also with negative sign, to a
+ * hexadecimal string.
+ *
+ * This work is based on comment #97756 on php.net documentation page at:
+ * <http://de.php.net/manual/en/function.hexdec.php#97756>
+ *
+ * @param $dec Decimal number, even with negative sign
+ * @param $maxLength Optional maximum length of the string
+ * @return $hex Hexadecimal string
+ */
+ protected function dec2hex ($dec, $maxLength = 0) {
+ // maxLength can be zero or devideable by 2
+ assert(($maxLength == 0) || (($maxLength % 2) == 0));
+
+ // Detect sign (negative/positive numbers)
+ $sign = '';
+ if ($dec < 0) {
+ $sign = '-';
+ $dec = abs($dec);
+ } // END - if
+
+ // Encode the decimal number into a hexadecimal string
+ $hex = '';
+ do {
+ $hex = self::$dechex[($dec % 16)] . $hex;
+ $dec /= 16;
+ } while ($dec >= 1);
+
+ /*
+ * We need hexadecimal strings with leading zeros if the length cannot
+ * be divided by 2
+ */
+ if ($maxLength > 0) {
+ // Prepend more zeros
+ $hex = $this->prependStringToString($hex, '0', $maxLength);
+ } elseif ((strlen($hex) % 2) != 0) {
+ $hex = '0' . $hex;
+ }
+
+ // Return the hexadecimal string
+ return $sign . $hex;
+ }
+
+ /**
+ * Converts a ASCII string (0 to 255) into a decimal number.
+ *
+ * @param $asc The ASCII string to be converted
+ * @return $dec Decimal number
+ */
+ protected function asc2dec ($asc) {
+ // Convert it into a hexadecimal number
+ $hex = bin2hex($asc);
+
+ // And back into a decimal number
+ $dec = $this->hex2dec($hex);
+
+ // Return it
+ return $dec;
+ }
+
+ /**
+ * Converts a decimal number into an ASCII string.
+ *
+ * @param $dec Decimal number
+ * @return $asc An ASCII string
+ */
+ protected function dec2asc ($dec) {
+ // First convert the number into a hexadecimal string
+ $hex = $this->dec2hex($dec);
+
+ // Then convert it into the ASCII string
+ $asc = $this->hex2asc($hex);
+
+ // Return it
+ return $asc;
+ }
+
+ /**
+ * Converts a hexadecimal number into an ASCII string. Negative numbers
+ * are not allowed.
+ *
+ * @param $hex Hexadecimal string
+ * @return $asc An ASCII string
+ */
+ protected function hex2asc ($hex) {
+ // Check for length, it must be devideable by 2
+ //* DEBUG: */ $this->debugOutput('hex='.$hex);
+ assert((strlen($hex) % 2) == 0);
+
+ // Walk the string
+ $asc = '';
+ for ($idx = 0; $idx < strlen($hex); $idx+=2) {
+ // Get the decimal number of the chunk
+ $part = hexdec(substr($hex, $idx, 2));
+
+ // Add it to the final string
+ $asc .= chr($part);
+ } // END - for
+
+ // Return the final string
+ return $asc;
+ }
+
+ /**
+ * Prepends a given string $prepend to $str with a given total length
+ *
+ * @param $str Given original string which should be prepended
+ * @param $prepend The string to prepend
+ * @param $length Total length of the final string
+ * @return $strFinal Final prepended string
+ */
+ protected function prependStringToString ($str, $prepend, $length) {
+ // Set final string to original string by default
+ $strFinal = $str;
+
+ // Can it devided
+ if (strlen($str) < $length) {
+ // Difference between total length and length of original string
+ $diff = $length - strlen($str);
+
+ // Prepend the string
+ $prepend = str_repeat($prepend, ($diff / strlen($prepend) + 1));
+
+ // Make sure it will definedly fit
+ assert(strlen($prepend) >= $diff);
+
+ // Cut it a little down
+ $prepend = substr($prepend, 0, $diff);
+ //* DEBUG: */ $this->debugOutput('prepend('.strlen($prepend).')='.$prepend.',diff='.$diff.',length='.$length);
+
+ // Construct the final prepended string
+ $strFinal = $prepend . $str;
+ } // END - if
+
+ // Return it
+ return $strFinal;
+ }
+
+ /**
+ * Checks wether the given encoded data was encoded with Base64
+ *
+ * @param $encodedData Encoded data we shall check
+ * @return $isBase64 Wether the encoded data is Base64
+ */
+ protected function isBase64Encoded ($encodedData) {
+ // Determine it
+ $isBase64 = (@base64_decode($encodedData, true) !== false);
+
+ // Return it
+ return $isBase64;
+ }
+
+ /**
+ * "Getter" to get response/request type from analysis of the system.
+ *
+ * @return $responseType Analyzed response type
+ */
+ protected function getResponseTypeFromSystem () {
+ // Default is console
+ $responseType = 'console';
+
+ // Is 'HTTP_HOST' set?
+ if (isset($_SERVER['HTTP_HOST'])) {
+ // Then it is a HTTP response/request
+ $responseType = 'http';
+ } // END - if
+
+ // Return it
+ return $responseType;
+ }
+
+ /**
+ * Gets a cache key from Criteria instance
+ *
+ * @param $criteriaInstance An instance of a Criteria class
+ * @param $onlyKeys Only use these keys for a cache key
+ * @return $cacheKey A cache key suitable for lookup/storage purposes
+ */
+ protected function getCacheKeyByCriteria (Criteria $criteriaInstance, $onlyKeys = array()) {
+ // Generate it
+ $cacheKey = sprintf("%s@%s",
+ $this->__toString(),
+ $criteriaInstance->getCacheKey($onlyKeys)
+ );
+
+ // And return it
+ //* NOISY-DEBUG: */ $this->debugOutput($this->__toString() . ': cacheKey=' . $cacheKey);
+ return $cacheKey;
+ }
+
+ /**
+ * Getter for startup time in miliseconds
+ *
+ * @return $startupTime Startup time in miliseconds
+ */
+ protected function getStartupTime () {
+ return self::$startupTime;
+ }
+
+ /**
+ * "Getter" for a printable currently execution time in nice braces
+ *
+ * @return $executionTime Current execution time in nice braces
+ */
+ protected function getPrintableExecutionTime () {
+ // Caculate the execution time
+ $executionTime = microtime(true) - $this->getStartupTime();
+
+ // Pack it in nice braces
+ $executionTime = sprintf('[ %01.5f ] ', $executionTime);
+
+ // And return it
+ return $executionTime;
+ }
}
// [EOF]