* @version 0.0.0
* @copyright Copyright (c) 2007, 2008 Roland Haeder, 2009 - 2023 Core Developer Team
* @license GNU GPL 3.0 or any newer version
* @link http://www.shipsimu.org
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*/
abstract class BaseFrameworkSystem extends stdClass implements FrameworkInterface {
/**
* Self-referencing instance
*/
private static $selfInstance = NULL;
/**
* Debug instance
*/
private static $debugInstance = NULL;
/**
* Stub methods
*/
private static $stubMethods = [
'partialStub' => true,
'__call' => true,
'__callStatic' => true,
];
/**
* The real class name
*/
private $realClass = __CLASS__;
/**
* Call-back instance
*/
private $callbackInstance = NULL;
/**
* Generic array
*/
private $genericArray = [];
/***********************
* Exception codes.... *
***********************/
// @todo Try to clean these constants up
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_RESOURCE = 0x01b;
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_FACTORY_REQUIRE_PARAMETER = 0x02e;
const EXCEPTION_MISSING_ELEMENT = 0x02f;
const EXCEPTION_HEADERS_ALREADY_SENT = 0x030;
const EXCEPTION_DEFAULT_CONTROLLER_GONE = 0x031;
const EXCEPTION_REQUIRED_INTERFACE_MISSING = 0x033;
const EXCEPTION_FATAL_ERROR = 0x034;
const EXCEPTION_FILE_NOT_FOUND = 0x035;
const EXCEPTION_ASSERTION_FAILED = 0x036;
const EXCEPTION_FILE_NOT_REACHABLE = 0x037;
const EXCEPTION_FILE_CANNOT_BE_READ = 0x038;
const EXCEPTION_FILE_CANNOT_BE_WRITTEN = 0x039;
const EXCEPTION_PATH_CANNOT_BE_WRITTEN = 0x03a;
const EXCEPTION_DATABASE_UPDATED_NOT_ALLOWED = 0x03b;
const EXCEPTION_FILTER_CHAIN_INTERCEPTED = 0x03c;
const EXCEPTION_INVALID_SOCKET = 0x03d;
const EXCEPTION_SELF_INSTANCE = 0x03e;
/**
* Startup time in miliseconds
*/
private static $startupTime = 0;
/**
* Protected super constructor
*
* @param $className Name of the class
* @return void
*/
protected function __construct (string $className) {
// Set real class
$this->setRealClass($className);
// Is the startup time set? (0 cannot be true anymore)
if (self::$startupTime == 0) {
// Then set it
self::$startupTime = microtime(true);
}
}
/**
* Destructor for all classes. You should not call this method on your own.
*
* @return void
*/
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
self::createDebugInstance(__CLASS__, __LINE__)->warningMessage(sprintf('The object %s is already destroyed.',
$this->__toString()
));
} else {
// Do not call this twice
trigger_error(__METHOD__ . ': Called twice.');
exit(255);
}
}
/**
* The __call() method where all non-implemented methods end up
*
* @param $methodName Name of the missing method
* @args $args Arguments passed to the method
* @return void
*/
public final function __call (string $methodName, array $args = NULL) {
// Set self-instance
self::$selfInstance = $this;
// Call static method
self::__callStatic($methodName, $args);
// Clear self-instance
self::$selfInstance = NULL;
}
/**
* The __callStatic() method where all non-implemented static methods end up
*
* @param $methodName Name of the missing method
* @param $args Arguments passed to the method
* @return void
* @throws InvalidArgumentException If self::$selfInstance is not a framework's own object
*/
public static final function __callStatic (string $methodName, array $args = NULL) {
// Init argument string and class name
//* PRINT-DEBUG: */ printf('[%s:%d]: methodName=%s,args[]=%s - CALLED!' . PHP_EOL, __METHOD__, __LINE__, $methodName, gettype($args));
$argsString = '';
$className = 'unknown';
// Is self-instance set?
if (self::$selfInstance instanceof FrameworkInterface) {
// Framework's own instance
$className = self::$selfInstance->__toString();
} elseif (!is_null(self::$selfInstance)) {
// Invalid argument!
throw new InvalidArgumentException(sprintf('self::instance[%s] is not expected.', gettype(self::$selfInstance)), self::EXCEPTION_SELF_INSTANCE);
}
// Is it NULL, empty or an array?
if (is_null($args)) {
// No arguments
$argsString = 'NULL';
} elseif (is_array($args)) {
// Start braces
$argsString = '(';
// Some arguments are there
foreach ($args as $arg) {
// Add data about the argument
$argsString .= gettype($arg) . ':';
if (is_null($arg)) {
// Found a NULL argument
$argsString .= 'NULL';
} elseif (is_string($arg)) {
// Add length for strings
$argsString .= strlen($arg);
} elseif ((is_int($arg)) || (is_float($arg))) {
// ... integer/float
$argsString .= $arg;
} elseif (is_array($arg)) {
// .. or size if array
$argsString .= count($arg);
} elseif (is_object($arg)) {
// Get reflection
$reflection = new ReflectionClass($arg);
// Is an other object, maybe no __toString() available
$argsString .= $reflection->getName();
} elseif ($arg === true) {
// ... is boolean 'true'
$argsString .= 'true';
} elseif ($arg === false) {
// ... is boolean 'false'
$argsString .= 'false';
}
// Comma for next one
$argsString .= ', ';
}
// Last comma found?
if (substr($argsString, -2, 1) == ',') {
// Remove last comma
$argsString = substr($argsString, 0, -2);
}
// Close braces
$argsString .= ')';
}
// Output stub message
// @TODO __CLASS__ does always return BaseFrameworkSystem but not the extending (=child) class
self::createDebugInstance(__CLASS__, __LINE__)->warningMessage(sprintf('[%s::%s]: Stub! Args: %s',
$className,
$methodName,
$argsString
));
// Return nothing
return NULL;
}
/**
* Getter for $realClass
*
* @return $realClass The name of the real class (not BaseFrameworkSystem)
*/
public function __toString () {
return $this->realClass;
}
/**
* Magic method to catch setting of missing but set class fields/attributes
*
* @param $name Name of the field/attribute
* @param $value Value to store
* @return void
*/
public final function __set (string $name, $value) {
$this->debugBackTrace(sprintf('Tried to set a missing field. name=%s, value[%s]=%s',
$name,
gettype($value),
print_r($value, true)
));
}
/**
* Magic method to catch getting of missing fields/attributes
*
* @param $name Name of the field/attribute
* @return void
*/
public final function __get (string $name) {
$this->debugBackTrace(sprintf('Tried to get a missing field. name=%s',
$name
));
}
/**
* Magic method to catch unsetting of missing fields/attributes
*
* @param $name Name of the field/attribute
* @return void
*/
public final function __unset (string $name) {
$this->debugBackTrace(sprintf('Tried to unset a missing field. name=%s',
$name
));
}
/**
* Magic method to catch object serialization
*
* @return $unsupported Unsupported method
* @throws UnsupportedOperationException Objects of this framework cannot be serialized
*/
public final function __sleep () {
throw new UnsupportedOperationException([$this, __FUNCTION__], FrameworkInterface::EXCEPTION_UNSPPORTED_OPERATION);
}
/**
* Magic method to catch object deserialization
*
* @return $unsupported Unsupported method
* @throws UnsupportedOperationException Objects of this framework cannot be serialized
*/
public final function __wakeup () {
throw new UnsupportedOperationException([$this, __FUNCTION__], FrameworkInterface::EXCEPTION_UNSPPORTED_OPERATION);
}
/**
* Magic method to catch calls when an object instance is called
*
* @return $unsupported Unsupported method
* @throws UnsupportedOperationException Objects of this framework cannot be serialized
*/
public final function __invoke () {
throw new UnsupportedOperationException([$this, __FUNCTION__], FrameworkInterface::EXCEPTION_UNSPPORTED_OPERATION);
}
/**
* Setter for the real class name
*
* @param $realClass Class name (string)
* @return void
*/
public final function setRealClass (string $realClass) {
// Set real class
$this->realClass = $realClass;
}
/**
* Setter for debug instance
*
* @param $debugInstance The instance for debug output class
* @return void
*/
public final function setDebugInstance (DebugMiddleware $debugInstance) {
self::$debugInstance = $debugInstance;
}
/**
* Getter for debug instance
*
* @return $debugInstance Instance to class DebugConsoleOutput or DebugWebOutput
*/
public final function getDebugInstance () {
return self::$debugInstance;
}
/**
* Setter for web output instance
*
* @param $webInstance The instance for web output class
* @return void
*/
public final function setWebOutputInstance (OutputStreamer $webInstance) {
ObjectRegistry::getRegistry('generic')->addInstance('web_output', $webInstance);
}
/**
* Getter for web output instance
*
* @return $webOutputInstance - Instance to class WebOutput
*/
public final function getWebOutputInstance () {
return ObjectRegistry::getRegistry('generic')->getInstance('web_output');
}
/**
* Setter for call-back instance
*
* @param $callbackInstance An instance of a FrameworkInterface class
* @return void
*/
public final function setCallbackInstance (FrameworkInterface $callbackInstance) {
$this->callbackInstance = $callbackInstance;
}
/**
* Getter for call-back instance
*
* @return $callbackInstance An instance of a FrameworkInterface class
*/
protected final function getCallbackInstance () {
return $this->callbackInstance;
}
/**
* Checks whether an object equals this object. You should overwrite this
* method to implement own equality checks
*
* @param $objectInstance An instance of a FrameworkInterface object
* @return $equals Whether both objects equals
*/
public function equals (FrameworkInterface $objectInstance) {
// Now test it
$equals = ((
$this->__toString() == $objectInstance->__toString()
) && (
$this->hashCode() == $objectInstance->hashCode()
));
// Return the result
return $equals;
}
/**
* Generates a generic hash code of this class. You should really overwrite
* this method with your own hash code generator code. But keep KISS in mind.
*
* @return $hashCode A generic hash code respresenting this whole class
*/
public function hashCode () {
// Simple hash code
return crc32($this->__toString());
}
/**
* Appends a trailing slash to a string
*
* @param $str A string (maybe) without trailing slash
* @return $str A string with an auto-appended trailing slash
* @throws InvalidArgumentException If a paramter has an invalid value
*/
public final function addMissingTrailingSlash (string $str) {
// Check parameter
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugMessage(sprintf('BASE-FRAMEWORK-SYSTEM: str=%s - CALLED!', $str));
if (empty($str)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "str" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
}
// Is there a trailing slash?
if (substr($str, -1, 1) != '/') {
$str .= '/';
}
// Return string with trailing slash
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugMessage(sprintf('BASE-FRAMEWORK-SYSTEM: str=%s - EXIT!', $str));
return $str;
}
/**
* Debugs this instance by putting out it's full content
*
* @param $message Optional message to show in debug output
* @return void
* @throws InvalidArgumentException If a paramter has an invalid value
*/
public final function debugInstance (string $message = '') {
// Check parameter
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugMessage(sprintf('BASE-FRAMEWORK-SYSTEM: message=%s - CALLED!', $message));
if (empty($message)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "message" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
}
// 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('
Message: %s
' . PHP_EOL, $message);
}
// Generate the output
$content .= sprintf('%s
',
trim(
htmlentities(
print_r($this, true)
)
)
);
// Output it
ApplicationEntryPoint::exitApplication(sprintf('
%s
Loaded includes:
%s
',
$this->__toString(),
$content,
ClassLoader::getSelfInstance()->getPrintableIncludeList()
));
}
/**
* Outputs a debug backtrace and stops further script execution
*
* @param $message An optional message to output
* @param $doExit Whether exit the program (true is default)
* @return void
* @throws InvalidArgumentException If a paramter has an invalid value
*/
public function debugBackTrace (string $message = '', bool $doExit = true) {
// Check parameter
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugMessage(sprintf('BASE-FRAMEWORK-SYSTEM: message=%s,doExit=%d - CALLED!', $message, intval($doExit)));
if (empty($message)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "message" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
}
// Sorry, there is no other way getting this nice backtrace
if (!empty($message)) {
// Output message
printf('Message: %s
' . PHP_EOL, $message);
}
print('');
debug_print_backtrace();
print('');
// Exit program?
if ($doExit === true) {
// Yes, with error code
exit(255);
}
}
/**
* Creates an instance of a debugger instance
*
* @param $className Name of the class (currently unsupported)
* @param $lineNumber Line number where the call was made
* @return $debugInstance An instance of a debugger class
* @throws InvalidArgumentException If a parameter has an invalid value
* @deprecated Not fully, as the new Logger facilities are not finished yet.
*/
public final static function createDebugInstance (string $className, int $lineNumber = NULL) {
// Validate parameter
//* NOISY-DEBUG: */ printf('[%s:%d]: className=%s,lineNumber[%s]=%d - CALLED!' . PHP_EOL, __METHOD__, __LINE__, $className, gettype($lineNumber), $lineNumber);
if (empty($className)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "className" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
}
// Is the debug instance set?
//* NOISY-DEBUG: */ printf('[%s:%d]: self::debugInstance[]=%s' . PHP_EOL, __METHOD__, __LINE__, gettype(self::$debugInstance));
if (is_null(self::$debugInstance)) {
// Init debug instance
self::$debugInstance = NULL;
// Try it
try {
// Get a debugger instance
//* NOISY-DEBUG: */ printf('[%s:%d]: className=%s' . PHP_EOL, __METHOD__, __LINE__, $className);
self::$debugInstance = DebugMiddleware::createDebugMiddleware(FrameworkBootstrap::getConfigurationInstance()->getConfigEntry('debug_' . FrameworkBootstrap::getRequestTypeFromSystem() . '_class'), $className);
} catch (NullPointerException $e) {
// Didn't work, no instance there
exit(sprintf('[%s:%d]: Cannot create debugInstance! Exception=%s,message=%s,className=%s,lineNumber=%d' . PHP_EOL, __METHOD__, __LINE__, $e->__toString(), $e->getMessage(), $className, $lineNumber));
}
}
// Return it
//* NOISY-DEBUG: */ printf('[%s:%d]: self::debugInstance=%s - EXIT!' . PHP_EOL, __METHOD__, __LINE__, self::$debugInstance->__toString());
return self::$debugInstance;
}
/**
* Simple output of a message with line-break
*
* @param $message Message to output
* @return void
* @throws InvalidArgumentException If a paramter has an invalid value
*/
public function outputLine (string $message) {
// Check parameter
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugMessage(sprintf('BASE-FRAMEWORK-SYSTEM: message=%s - CALLED!', $message));
if (empty($message)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "message" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
}
// Simply output it
print($message . PHP_EOL);
}
/**
* Marks up the code by adding e.g. line numbers
*
* @param $phpCode Unmarked PHP code
* @return $markedCode Marked PHP code
* @throws InvalidArgumentException If a paramter has an invalid value
*/
public function markupCode (string $phpCode) {
// Check parameter
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugMessage(sprintf('BASE-FRAMEWORK-SYSTEM: phpCode=%s - CALLED!', $phpCode));
if (empty($phpCode)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "phpCode" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
}
// 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('',
basename($errorArray['file']),
$errorArray['line'],
$errorArray['message'],
$errorArray['type']
);
}
// Add line number to the code
foreach (explode(chr(10), $phpCode) as $lineNo => $code) {
// Add line numbers
$markedCode .= sprintf('%s: %s' . PHP_EOL,
($lineNo + 1),
htmlentities($code, ENT_QUOTES)
);
}
// Return the code
return $markedCode;
}
/**
* "Getter" for databse entry
*
* @return $entry An array with database entries
* @throws NullPointerException If the database result is not found
* @throws InvalidDatabaseResultException If the database result is invalid
* @deprecated Monolithic method, should be moved to proper classes
*/
protected final function getDatabaseEntry () {
// This method is deprecated
/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage('BASE-FRAMEWORK-SYSTEM: CALLED!');
$this->deprecationWarning('Monolithic method, should be moved to proper classes');
// Is there an instance?
/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugMessage(sprintf('BASE-FRAMEWORK-SYSTEM: this->resultInstance[]=%s', gettype($this->getResultInstance())));
if (!$this->getResultInstance() instanceof SearchableResult) {
// Throw an exception here
throw new NullPointerException($this, FrameworkInterface::EXCEPTION_IS_NULL_POINTER);
}
// Rewind it
/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage('BASE-FRAMEWORK-SYSTEM: Invoking this->resultInstance->rewind() ...');
$this->getResultInstance()->rewind();
// Do we have an entry?
/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugMessage(sprintf('BASE-FRAMEWORK-SYSTEM: this->resultInstance->isValid()=%d', intval($this->getResultInstance()->isValid())));
if ($this->getResultInstance()->valid() === false) {
// @TODO Move the constant to e.g. BaseDatabaseResult when there is a non-cached database result available
throw new InvalidDatabaseResultException(array($this, $this->getResultInstance()), CachedDatabaseResult::EXCEPTION_INVALID_DATABASE_RESULT);
}
// Get next entry
/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage('BASE-FRAMEWORK-SYSTEM: Invoking this->resultInstance->next() ...');
$this->getResultInstance()->next();
// Fetch it
$entry = $this->getResultInstance()->current();
// And return it
/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-FRAMEWORK-SYSTEM: entry[]=%s - EXIT!', gettype($entry)));
return $entry;
}
/**
* Getter for field name
*
* @param $fieldName Field name which we shall get
* @return $fieldValue Field value from the user
* @throws NullPointerException If the result instance is null
* @throws InvalidArgumentException If a parameter is not valid
* @deprecated Monolithic method, should be moved to proper classes
*/
public final function getField (string $fieldName) {
// Check parameter
/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-FRAMEWORK-SYSTEM: fieldName=%s - CALLED!', $fieldName));
if (empty($fieldName)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "fieldName" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
}
// This method is deprecated
$this->deprecationWarning('Monolithic method, should be moved to proper classes');
// Default field value
$fieldValue = NULL;
// Get result instance
$resultInstance = $this->getResultInstance();
// Is this instance null?
/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugMessage(sprintf('BASE-FRAMEWORK-SYSTEM: resultInstance[]=%s', gettype($resultInstance)));
if (is_null($resultInstance)) {
// Then the user instance is no longer valid (expired cookies?)
throw new NullPointerException($this, FrameworkInterface::EXCEPTION_IS_NULL_POINTER);
}
// Get current array
$fieldArray = $resultInstance->current();
// Convert dashes to underscore
/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugMessage(sprintf('BASE-FRAMEWORK-SYSTEM: fieldArray()=%d', count($fieldArray)));
$fieldName2 = StringUtils::convertDashesToUnderscores($fieldName);
// Does the field exist?
/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugMessage(sprintf('BASE-FRAMEWORK-SYSTEM: fieldName2=%s', $fieldName2));
if ($this->isFieldSet($fieldName)) {
// Get it
$fieldValue = $fieldArray[$fieldName2];
} elseif (FrameworkBootstrap::getConfigurationInstance()->isEnabled('developer_mode')) {
// Missing field entry, may require debugging
self::createDebugInstance(__CLASS__, __LINE__)->warningMessage('BASE-FRAMEWORK-SYSTEM: fieldArray=' . print_r($fieldArray, true) . '
,fieldName=' . $fieldName . ' not found!');
} else {
// Missing field entry, may require debugging
self::createDebugInstance(__CLASS__, __LINE__)->warningMessage('BASE-FRAMEWORK-SYSTEM: fieldName=' . $fieldName . ' not found!');
}
// Return it
/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-FRAMEWORK-SYSTEM: fieldValue[]=%s - EXIT!', gettype($fieldValue)));
return $fieldValue;
}
/**
* Checks if given field is set
*
* @param $fieldName Field name to check
* @return $isSet Whether the given field name is set
* @throws NullPointerException If the result instance is null
* @throws InvalidArgumentException If a parameter is not valid
*/
public function isFieldSet (string $fieldName) {
// Check parameter
/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-FRAMEWORK-SYSTEM: fieldName=%s - CALLED!', $fieldName));
if (empty($fieldName)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "fieldName" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
}
// Get result instance
$resultInstance = $this->getResultInstance();
// Is this instance null?
/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugMessage(sprintf('BASE-FRAMEWORK-SYSTEM: resultInstance[]=%s', gettype($resultInstance)));
if (is_null($resultInstance)) {
// Then the user instance is no longer valid (expired cookies?)
throw new NullPointerException($this, FrameworkInterface::EXCEPTION_IS_NULL_POINTER);
}
// Get current array
$fieldArray = $resultInstance->current();
// Convert dashes to underscore
/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugMessage(sprintf('BASE-FRAMEWORK-SYSTEM: fieldArray()=%d,fieldName=%s - BEFORE!', count($fieldArray), $fieldName));
$fieldName = StringUtils::convertDashesToUnderscores($fieldName);
// Determine it
/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugMessage(sprintf('BASE-FRAMEWORK-SYSTEM: fieldName=%s - AFTER!', $fieldName));
$isset = isset($fieldArray[$fieldName]);
// Return result
/* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-FRAMEWORK-SYSTEM: isset=%d - EXIT!', intval($isset)));
return $isset;
}
/**
* Outputs a deprecation warning to the developer.
*
* @param $message The message we shall output to the developer
* @return void
* @throws InvalidArgumentException If a paramter has an invalid value
* @todo Write a logging mechanism for productive mode
*/
public function deprecationWarning (string $message) {
// Check parameter
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-FRAMEWORK-SYSTEM: message=%s - CALLED!', $message));
if (empty($message)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "message" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
}
// Is developer mode active?
if (FrameworkBootstrap::getConfigurationInstance()->isEnabled('developer_mode')) {
// Debug instance is there?
if (!is_null($this->getDebugInstance())) {
// Output stub message
self::createDebugInstance(__CLASS__, __LINE__)->warningMessage($message);
} else {
// Trigger an error
trigger_error($message . "
\n");
exit(255);
}
} else {
// @TODO Finish this part!
DebugMiddleware::getSelfInstance()->partialStub('Developer mode inactive. Message:' . $message);
}
// Trace mesage
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage('BASE-FRAMEWORK-SYSTEM: EXIT!');
}
/**
* Checks whether the given PHP extension is loaded
*
* @param $phpExtension The PHP extension we shall check
* @return $isLoaded Whether the PHP extension is loaded
* @throws InvalidArgumentException If a parameter is not valid
*/
public final function isPhpExtensionLoaded (string $phpExtension) {
// Check parameter
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-FRAMEWORK-SYSTEM: phpExtension=%s - CALLED!', $phpExtension));
if (empty($phpExtension)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "phpExtension" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
}
// Is it loaded?
$isLoaded = in_array($phpExtension, get_loaded_extensions());
// Return result
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-FRAMEWORK-SYSTEM: isLoaded=%d - EXIT!', intval($isLoaded)));
return $isLoaded;
}
/**
* "Getter" as a time() replacement but with milliseconds. You should use this
* method instead of the encapsulated getimeofday() function.
*
* @return $milliTime Timestamp with milliseconds
*/
public function getMilliTime () {
// Get the time of day as float
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage('BASE-FRAMEWORK-SYSTEM: CALLED!');
$milliTime = gettimeofday(true);
// Return it
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-FRAMEWORK-SYSTEM: milliTime=%s - EXIT!', $milliTime));
return $milliTime;
}
/**
* Idles (sleeps) for given milliseconds
*
* @return $hasSlept Whether it goes fine
* @throws InvalidArgumentException If a parameter is not valid
*/
public function idle (int $milliSeconds) {
// Check parameter
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-FRAMEWORK-SYSTEM: milliSeconds=%s - CALLED!', $milliSeconds));
if ($milliSeconds < 1) {
// Throw IAE
throw new InvalidArgumentException(sprintf('milliSeconds=%d are not a reasonable value to idle', $milliSeconds));
}
// Sleep is fine by default
$hasSlept = true;
// Idle so long with found function
if (function_exists('time_sleep_until')) {
// Get current time and add idle time
$sleepUntil = $this->getMilliTime() + abs($milliSeconds) / 1000;
// 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. :(
*/
usleep($milliSeconds * 1000);
}
// Return result
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-FRAMEWORK-SYSTEM: hasSlept=%d - EXIT!', intval($hasSlept)));
return $hasSlept;
}
/**
* Checks whether the given encoded data was encoded with Base64
*
* @param $encodedData Encoded data we shall check
* @return $isBase64 Whether the encoded data is Base64
* @throws InvalidArgumentException If a parameter is not valid
*/
protected function isBase64Encoded (string $encodedData) {
// Check parameter
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-FRAMEWORK-SYSTEM: encodedData=%s - CALLED!', $encodedData));
if (empty($encodedData)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "encodedData" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
}
// Determine it
$isBase64 = (@base64_decode($encodedData, true) !== false);
// Return it
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-FRAMEWORK-SYSTEM: isBase64=%d - EXIT!', intval($isBase64)));
return $isBase64;
}
/**
* 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 () {
// Calculate execution time and pack it in nice braces
$executionTime = sprintf('[ %01.5f ] ', (microtime(true) - $this->getStartupTime()));
// And return it
return $executionTime;
}
/**
* Determines if an element is set in the generic array
*
* @param $keyGroup Main group for the key
* @param $subGroup Sub group for the key
* @param $key Key to check
* @param $element Element to check
* @return $isset Whether the given key is set
* @throws InvalidArgumentException If a parameter is not valid
*/
protected final function isGenericArrayElementSet (string $keyGroup, string $subGroup, string $key, string $element) {
// Check parameter
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-FRAMEWORK-SYSTEM: keyGroup=%s,subGroup=%s,key=%s,element=%s - CALLED!', $keyGroup, $subGroup, $key, $element));
if (empty($keyGroup)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "keyGroup" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
} elseif (empty($subGroup)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "subGroup" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
} elseif (empty($key)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "key" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
} elseif ($element === '') {
// Throw IAE
throw new InvalidArgumentException('Parameter "element" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
}
// Is it there?
$isset = isset($this->genericArray[$keyGroup][$subGroup][$key][$element]);
// Return it
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-FRAMEWORK-SYSTEM: isset=%d - EXIT!', intval($isset)));
return $isset;
}
/**
* Determines if a key is set in the generic array
*
* @param $keyGroup Main group for the key
* @param $subGroup Sub group for the key
* @param $key Key to check
* @return $isset Whether the given key is set
* @throws InvalidArgumentException If a parameter is not valid
*/
protected final function isGenericArrayKeySet (string $keyGroup, string $subGroup, string $key) {
// Check parameter
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-FRAMEWORK-SYSTEM: keyGroup=%s,subGroup=%s,key=%s - CALLED!', $keyGroup, $subGroup, $key));
if (empty($keyGroup)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "keyGroup" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
} elseif (empty($subGroup)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "subGroup" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
} elseif (empty($key)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "key" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
}
// Is it there?
$isset = isset($this->genericArray[$keyGroup][$subGroup][$key]);
// Return it
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-FRAMEWORK-SYSTEM: isset=%d - EXIT!', intval($isset)));
return $isset;
}
/**
* Determines if a group is set in the generic array
*
* @param $keyGroup Main group
* @param $subGroup Sub group
* @return $isset Whether the given group is set
* @throws InvalidArgumentException If a parameter is not valid
*/
protected final function isGenericArrayGroupSet (string $keyGroup, string $subGroup) {
// Check parameter
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-FRAMEWORK-SYSTEM: keyGroup=%s,subGroup=%s - CALLED!', $keyGroup, $subGroup));
if (empty($keyGroup)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "keyGroup" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
} elseif (empty($subGroup)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "subGroup" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
}
// Is it there?
$isset = isset($this->genericArray[$keyGroup][$subGroup]);
// Return it
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-FRAMEWORK-SYSTEM: isset=%d - EXIT!', intval($isset)));
return $isset;
}
/**
* Getter for sub key group
*
* @param $keyGroup Main key group
* @param $subGroup Sub key group
* @return $array An array with all array elements
* @throws InvalidArgumentException If a parameter is not valid
* @throws BadMethodCallException If key/sub group isn't there but this method is invoked
*/
protected final function getGenericSubArray (string $keyGroup, string $subGroup) {
// Check parameter
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-FRAMEWORK-SYSTEM: keyGroup=%s,subGroup=%s - CALLED!', $keyGroup, $subGroup));
if (empty($keyGroup)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "keyGroup" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
} elseif (empty($subGroup)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "subGroup" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
} elseif (!$this->isGenericArrayGroupSet($keyGroup, $subGroup)) {
// No, then abort here
throw new BadMethodCallException(sprintf('keyGroup=%s,subGroup=%s not found.', $keyGroup, $subGroup), FrameworkInterface::EXCEPTION_BAD_METHOD_CALL);
}
// Return it
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-FRAMEWORK-SYSTEM: this->genericArray[%s][%s][]=%s - EXIT!', $keyGroup, $subGroup, gettype($this->genericArray[$keyGroup][$subGroup])));
return $this->genericArray[$keyGroup][$subGroup];
}
/**
* Unsets a given key in generic array
*
* @param $keyGroup Main group for the key
* @param $subGroup Sub group for the key
* @param $key Key to unset
* @return void
* @throws InvalidArgumentException If a parameter is not valid
*/
protected final function unsetGenericArrayKey (string $keyGroup, string $subGroup, string $key) {
// Check parameter
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-FRAMEWORK-SYSTEM: keyGroup=%s,subGroup=%s,key=%s - CALLED!', $keyGroup, $subGroup, $key));
if (empty($keyGroup)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "keyGroup" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
} elseif (empty($subGroup)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "subGroup" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
} elseif (empty($key)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "key" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
}
// Remove it
unset($this->genericArray[$keyGroup][$subGroup][$key]);
// Trace mesage
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage('BASE-FRAMEWORK-SYSTEM: EXIT!');
}
/**
* Unsets a given element in generic array
*
* @param $keyGroup Main group for the key
* @param $subGroup Sub group for the key
* @param $key Key to unset
* @param $element Element to unset
* @return void
* @throws InvalidArgumentException If a parameter is not valid
*/
protected final function unsetGenericArrayElement (string $keyGroup, string $subGroup, string $key, string $element) {
// Check parameter
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-FRAMEWORK-SYSTEM: keyGroup=%s,subGroup=%s,key=%s,element=%s - CALLED!', $keyGroup, $subGroup, $key, $element));
if (empty($keyGroup)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "keyGroup" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
} elseif (empty($subGroup)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "subGroup" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
} elseif (empty($key)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "key" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
} elseif ($element === '') {
// Throw IAE
throw new InvalidArgumentException('Parameter "element" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
}
// Remove it
unset($this->genericArray[$keyGroup][$subGroup][$key][$element]);
// Trace mesage
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage('BASE-FRAMEWORK-SYSTEM: EXIT!');
}
/**
* Append a string to a given generic array key
*
* @param $keyGroup Main group for the key
* @param $subGroup Sub group for the key
* @param $key Key to unset
* @param $value Value to add/append
* @return void
* @throws InvalidArgumentException If a parameter is not valid
*/
protected final function appendStringToGenericArrayKey (string $keyGroup, string $subGroup, string $key, string $value, string $appendGlue = '') {
// Check parameter
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-FRAMEWORK-SYSTEM: keyGroup=%s,subGroup=%s,key=%s,value=%s,appendGlue=%s - CALLED!', $keyGroup, $subGroup, $key, $value, $appendGlue));
if (empty($keyGroup)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "keyGroup" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
} elseif (empty($subGroup)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "subGroup" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
} elseif (empty($key)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "key" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
}
// Is it already there?
if ($this->isGenericArrayKeySet($keyGroup, $subGroup, $key)) {
// Append it
$this->genericArray[$keyGroup][$subGroup][$key] .= $appendGlue . $value;
} else {
// Add it
$this->genericArray[$keyGroup][$subGroup][$key] = $value;
}
// Trace mesage
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage('BASE-FRAMEWORK-SYSTEM: EXIT!');
}
/**
* Append a string to a given generic array element
*
* @param $keyGroup Main group for the key
* @param $subGroup Sub group for the key
* @param $key Key to unset
* @param $element Element to check
* @param $value Value to add/append
* @return void
* @throws InvalidArgumentException If a parameter is not valid
*/
protected final function appendStringToGenericArrayElement (string $keyGroup, string $subGroup, string $key, string $element, string $value, string $appendGlue = '') {
// Check parameter
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-FRAMEWORK-SYSTEM: keyGroup=%s,subGroup=%s,key=%s,element=%s,value=%s,appendGlue=%s - CALLED!', $keyGroup, $subGroup, $key, $element, $value, $appendGlue));
if (empty($keyGroup)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "keyGroup" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
} elseif (empty($subGroup)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "subGroup" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
} elseif (empty($key)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "key" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
} elseif ($element === '') {
// Throw IAE
throw new InvalidArgumentException('Parameter "element" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
}
// Is it already there?
if ($this->isGenericArrayElementSet($keyGroup, $subGroup, $key, $element)) {
// Append it
$this->genericArray[$keyGroup][$subGroup][$key][$element] .= $appendGlue . $value;
} else {
// Add it
$this->setGenericArrayElement($keyGroup, $subGroup, $key, $element, $value);
}
// Trace mesage
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage('BASE-FRAMEWORK-SYSTEM: EXIT!');
}
/**
* Initializes given generic array group
*
* @param $keyGroup Main group for the key
* @param $subGroup Sub group for the key
* @param $key Key to use
* @param $forceInit Optionally force initialization
* @return void
* @throws InvalidArgumentException If a parameter is not valid
* @throws BadMethodCallException If key/sub group has already been initialized
*/
protected final function initGenericArrayGroup (string $keyGroup, string $subGroup, bool $forceInit = false) {
// Check parameter
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-FRAMEWORK-SYSTEM: keyGroup=%s,subGroup=%s,forceInit=%d - CALLED!', $keyGroup, $subGroup, intval($forceInit)));
if (empty($keyGroup)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "keyGroup" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
} elseif (empty($subGroup)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "subGroup" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
} elseif (($forceInit === false) && ($this->isGenericArrayGroupSet($keyGroup, $subGroup))) {
// Already initialized
throw new BadMethodCallException(sprintf('keyGroup=%s,subGroup=%s already initialized.', $keyGroup, $subGroup), FrameworkInterface::EXCEPTION_BAD_METHOD_CALL);
}
// Initialize it
$this->genericArray[$keyGroup][$subGroup] = [];
// Trace mesage
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage('BASE-FRAMEWORK-SYSTEM: EXIT!');
}
/**
* Initializes given generic array key
*
* @param $keyGroup Main group for the key
* @param $subGroup Sub group for the key
* @param $key Key to use
* @param $forceInit Optionally force initialization
* @return void
* @throws InvalidArgumentException If a parameter is not valid
* @throws BadMethodCallException If key/sub group has already been initialized
*/
protected final function initGenericArrayKey (string $keyGroup, string $subGroup, string $key, bool $forceInit = false) {
// Check parameter
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-FRAMEWORK-SYSTEM: keyGroup=%s,subGroup=%s,key=%s,forceInit=%d - CALLED!', $keyGroup, $subGroup, $key, intval($forceInit)));
if (empty($keyGroup)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "keyGroup" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
} elseif (empty($subGroup)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "subGroup" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
} elseif (empty($key)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "key" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
} elseif (($forceInit === false) && ($this->isGenericArrayKeySet($keyGroup, $subGroup, $key))) {
// Already initialized
throw new BadMethodCallException(sprintf('keyGroup=%s,subGroup=%s,key[%s]=%s already initialized.', $keyGroup, $subGroup, gettype($key), $key), FrameworkInterface::EXCEPTION_BAD_METHOD_CALL);
}
// Initialize it
$this->genericArray[$keyGroup][$subGroup][$key] = [];
// Trace mesage
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage('BASE-FRAMEWORK-SYSTEM: EXIT!');
}
/**
* Initializes given generic array element
*
* @param $keyGroup Main group for the key
* @param $subGroup Sub group for the key
* @param $key Key to use
* @param $element Element to use
* @param $forceInit Optionally force initialization
* @return void
* @throws InvalidArgumentException If a parameter is not valid
* @throws BadMethodCallException If key/sub group isn't there but this method is invoked
*/
protected final function initGenericArrayElement (string $keyGroup, string $subGroup, string $key, string $element, bool $forceInit = false) {
// Check parameter
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-FRAMEWORK-SYSTEM: keyGroup=%s,subGroup=%s,key=%s,element=%s,forceInit=%d - CALLED!', $keyGroup, $subGroup, $key, $element, intval($forceInit)));
if (empty($keyGroup)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "keyGroup" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
} elseif (empty($subGroup)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "subGroup" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
} elseif (empty($key)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "key" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
} elseif ($element === '') {
// Throw IAE
throw new InvalidArgumentException('Parameter "element" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
} elseif (($forceInit === false) && ($this->isGenericArrayElementSet($keyGroup, $subGroup, $key, $element))) {
// Already initialized
throw new BadMethodCallException(sprintf('keyGroup=%s,subGroup=%s,key[%s]=%s,element[%s]=%s already initialized.', $keyGroup, $subGroup, gettype($key), $key, gettype($element), $element), FrameworkInterface::EXCEPTION_BAD_METHOD_CALL);
}
// Initialize it
$this->genericArray[$keyGroup][$subGroup][$key][$element] = [];
// Trace mesage
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage('BASE-FRAMEWORK-SYSTEM: EXIT!');
}
/**
* Pushes an element to a generic key. If the key isn't found, it will be initialized.
*
* @param $keyGroup Main group for the key
* @param $subGroup Sub group for the key
* @param $key Key to use
* @param $value Value to add/append
* @return $count Number of array elements
* @throws InvalidArgumentException If a parameter is not valid
*/
protected final function pushValueToGenericArrayKey (string $keyGroup, string $subGroup, string $key, $value) {
// Check parameter
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-FRAMEWORK-SYSTEM: keyGroup=%s,subGroup=%s,key=%s,value[]=%s - CALLED!', $keyGroup, $subGroup, $key, gettype($value)));
if (empty($keyGroup)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "keyGroup" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
} elseif (empty($subGroup)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "subGroup" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
} elseif (empty($key)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "key" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
} elseif (!$this->isGenericArrayKeySet($keyGroup, $subGroup, $key)) {
// Initialize array
$this->initGenericArrayKey($keyGroup, $subGroup, $key);
}
// Then push it
$count = array_push($this->genericArray[$keyGroup][$subGroup][$key], $value);
// Return count
//* DEBUG: */ print(__METHOD__ . ': genericArray=' . print_r($this->genericArray[$keyGroup][$subGroup][$key], true));
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-FRAMEWORK-SYSTEM: count=%d - EXIT!', $count));
return $count;
}
/**
* Pushes an element to a generic array element. If the key isn't found, it will be initialized.
*
* @param $keyGroup Main group for the key
* @param $subGroup Sub group for the key
* @param $key Key to use
* @param $element Element to check
* @param $value Value to add/append
* @return $count Number of array elements
* @throws InvalidArgumentException If a parameter is not valid
*/
protected final function pushValueToGenericArrayElement (string $keyGroup, string $subGroup, string $key, string $element, $value) {
// Check parameter
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-FRAMEWORK-SYSTEM: keyGroup=%s,subGroup=%s,key=%s,element=%s,value[]=%s - CALLED!', $keyGroup, $subGroup, $key, $element, gettype($value)));
if (empty($keyGroup)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "keyGroup" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
} elseif (empty($subGroup)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "subGroup" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
} elseif (empty($key)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "key" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
} elseif ($element === '') {
// Throw IAE
throw new InvalidArgumentException('Parameter "element" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
} elseif (!$this->isGenericArrayElementSet($keyGroup, $subGroup, $key, $element)) {
// Initialize array
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-FRAMEWORK-SYSTEM: Invoking this->initGenericArrayElement(%s,%s,%s,%s) ...', $keyGroup, $subGroup, $key, $element));
$this->initGenericArrayElement($keyGroup, $subGroup, $key, $element);
}
// Then push it
$count = array_push($this->genericArray[$keyGroup][$subGroup][$key][$element], $value);
// Return count
//* DEBUG: */ print(__METHOD__ . ': genericArray=' . print_r($this->genericArray[$keyGroup][$subGroup][$key], true));
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-FRAMEWORK-SYSTEM: count=%d - EXIT!', $count));
return $count;
}
/**
* Pops an element from a generic group
*
* @param $keyGroup Main group for the key
* @param $subGroup Sub group for the key
* @param $key Key to unset
* @return $value Last "popped" value
* @throws InvalidArgumentException If a parameter is not valid
* @throws BadMethodCallException If key/sub group isn't there but this method is invoked
*/
protected final function popGenericArrayElement (string $keyGroup, string $subGroup, string $key) {
// Check parameter
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-FRAMEWORK-SYSTEM: keyGroup=%s,subGroup=%s,key=%s - CALLED!', $keyGroup, $subGroup, $key));
if (empty($keyGroup)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "keyGroup" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
} elseif (empty($subGroup)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "subGroup" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
} elseif (empty($key)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "key" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
} elseif (!$this->isGenericArrayKeySet($keyGroup, $subGroup, $key)) {
// Not found
throw new BadMethodCallException(sprintf('keyGroup=%s,subGroup=%s,key[%s]=%s not found.', $keyGroup, $subGroup, gettype($key), $key), FrameworkInterface::EXCEPTION_BAD_METHOD_CALL);
}
// Then "pop" it
$value = array_pop($this->genericArray[$keyGroup][$subGroup][$key]);
// Return value
//* DEBUG: */ print(__METHOD__ . ': genericArray=' . print_r($this->genericArray[$keyGroup][$subGroup][$key], true));
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-FRAMEWORK-SYSTEM: value[]=%s - EXIT!', gettype($value)));
return $value;
}
/**
* Shifts an element from a generic group
*
* @param $keyGroup Main group for the key
* @param $subGroup Sub group for the key
* @param $key Key to unset
* @return $value Last "shifted" value
* @throws InvalidArgumentException If a parameter is not valid
* @throws BadMethodCallException If key/sub group isn't there but this method is invoked
*/
protected final function shiftGenericArrayElement (string $keyGroup, string $subGroup, string $key) {
// Check parameter
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-FRAMEWORK-SYSTEM: keyGroup=%s,subGroup=%s,key=%s - CALLED!', $keyGroup, $subGroup, $key));
if (empty($keyGroup)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "keyGroup" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
} elseif (empty($subGroup)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "subGroup" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
} elseif (empty($key)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "key" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
} elseif (!$this->isGenericArrayKeySet($keyGroup, $subGroup, $key)) {
// Not found
throw new BadMethodCallException(sprintf('keyGroup=%s,subGroup=%s,key[%s]=%s not found.', $keyGroup, $subGroup, gettype($key), $key), FrameworkInterface::EXCEPTION_BAD_METHOD_CALL);
}
// Then "shift" it
$value = array_shift($this->genericArray[$keyGroup][$subGroup][$key]);
// Return value
//* DEBUG: */ print(__METHOD__ . ': genericArray=' . print_r($this->genericArray[$keyGroup][$subGroup][$key], true));
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-FRAMEWORK-SYSTEM: value[]=%s - EXIT!', gettype($value)));
return $value;
}
/**
* Count generic array group
*
* @param $keyGroup Main group for the key
* @return $count Count of given group
* @throws InvalidArgumentException If a parameter is not valid
* @throws BadMethodCallException If key group isn't there but this method is invoked
*/
protected final function countGenericArray (string $keyGroup) {
// Check parameter
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-FRAMEWORK-SYSTEM: keyGroup=%s - CALLED!', $keyGroup));
if (empty($keyGroup)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "keyGroup" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
} elseif (!isset($this->genericArray[$keyGroup])) {
// Not found
throw new BadMethodCallException(sprintf('keyGroup=%s not found.', $keyGroup), FrameworkInterface::EXCEPTION_BAD_METHOD_CALL);
}
// Then count it
$count = count($this->genericArray[$keyGroup]);
// Return it
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-FRAMEWORK-SYSTEM: count=%d - EXIT!', $count));
return $count;
}
/**
* Count generic array sub group
*
* @param $keyGroup Main group for the key
* @param $subGroup Sub group for the key
* @return $count Count of given group
* @throws InvalidArgumentException If a parameter is not valid
* @throws BadMethodCallException If key/sub group isn't there but this method is invoked
*/
protected final function countGenericArrayGroup (string $keyGroup, string $subGroup) {
// Check parameter
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-FRAMEWORK-SYSTEM: keyGroup=%s,subGroup=%s - CALLED!', $keyGroup, $subGroup));
if (empty($keyGroup)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "keyGroup" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
} elseif (empty($subGroup)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "subGroup" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
} elseif (!$this->isGenericArrayGroupSet($keyGroup, $subGroup)) {
// Abort here
throw new BadMethodCallException(sprintf('keyGroup=%s,subGroup=%s not found.', $keyGroup, $subGroup), FrameworkInterface::EXCEPTION_BAD_METHOD_CALL);
}
// Then count it
$count = count($this->genericArray[$keyGroup][$subGroup]);
// Return it
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-FRAMEWORK-SYSTEM: count=%d - EXIT!', $count));
return $count;
}
/**
* Count generic array elements
*
* @param $keyGroup Main group for the key
* @param $subGroup Sub group for the key
* @param $key Key to count
* @return $count Count of given key
* @throws InvalidArgumentException If a parameter is not valid
* @throws BadMethodCallException If key/sub group isn't there but this method is invoked
*/
protected final function countGenericArrayElements (string $keyGroup, string $subGroup, string $key) {
// Check parameter
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-FRAMEWORK-SYSTEM: keyGroup=%s,subGroup=%s,key=%s - CALLED!', $keyGroup, $subGroup, $key));
if (empty($keyGroup)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "keyGroup" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
} elseif (empty($subGroup)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "subGroup" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
} elseif (empty($key)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "key" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
} elseif (!$this->isGenericArrayKeySet($keyGroup, $subGroup, $key)) {
// Abort here
throw new BadMethodCallException(sprintf('keyGroup=%s,subGroup=%s,key[%s]=%s not found.', $keyGroup, $subGroup, gettype($key), $key), FrameworkInterface::EXCEPTION_BAD_METHOD_CALL);
} elseif (!$this->isValidGenericArrayGroup($keyGroup, $subGroup)) {
// Not valid
throw new BadMethodCallException(sprintf('keyGroup=%s,subGroup=%s is not a valid key/sub group.', $keyGroup, $subGroup), FrameworkInterface::EXCEPTION_BAD_METHOD_CALL);
}
// Then count it
$count = count($this->genericArray[$keyGroup][$subGroup][$key]);
// Return it
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-FRAMEWORK-SYSTEM: count=%d - EXIT!', $count));
return $count;
}
/**
* Getter for whole generic group array
*
* @param $keyGroup Key group to get
* @return $array Whole generic array group
* @throws InvalidArgumentException If a parameter is not valid
* @throws BadMethodCallException If key/sub group isn't there but this method is invoked
*/
protected final function getGenericArray (string $keyGroup) {
// Check parameters
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-FRAMEWORK-SYSTEM: keyGroup=%s - CALLED!', $keyGroup));
if (empty($keyGroup)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "keyGroup" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
} elseif (!isset($this->genericArray[$keyGroup])) {
// Then abort here
throw new BadMethodCallException(sprintf('keyGroup=%s not found', $keyGroup), FrameworkInterface::EXCEPTION_BAD_METHOD_CALL);
}
// Return it
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-FRAMEWORK-SYSTEM: this->genericArray[%s][]=%s - EXIT!', $keyGroup, gettype($this->genericArray[$keyGroup])));
return $this->genericArray[$keyGroup];
}
/**
* Setter for generic array key
*
* @param $keyGroup Key group to get
* @param $subGroup Sub group for the key
* @param $key Key to unset
* @param $value Mixed value from generic array element
* @return void
* @throws InvalidArgumentException If a parameter is not valid
* @throws BadMethodCallException If key/sub group isn't there but this method is invoked
*/
protected final function setGenericArrayKey (string $keyGroup, string $subGroup, string $key, $value) {
// Check parameters
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-FRAMEWORK-SYSTEM: keyGroup=%s,subGroup=%s,key=%s,value[]=%s - CALLED!', $keyGroup, $subGroup, $key, gettype($value)));
if (empty($keyGroup)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "keyGroup" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
} elseif (empty($subGroup)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "subGroup" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
} elseif (empty($key)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "key" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
} elseif (!$this->isValidGenericArrayGroup($keyGroup, $subGroup)) {
// Then abort here
throw new BadMethodCallException(sprintf('keyGroup=%s,subGroup=%s not found', $keyGroup), FrameworkInterface::EXCEPTION_BAD_METHOD_CALL);
}
// Set value here
$this->genericArray[$keyGroup][$subGroup][$key] = $value;
// Trace mesage
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage('BASE-FRAMEWORK-SYSTEM: EXIT!');
}
/**
* Getter for generic array key
*
* @param $keyGroup Key group to get
* @param $subGroup Sub group for the key
* @param $key Key to unset
* @return $value Mixed value from generic array element
* @throws InvalidArgumentException If a parameter is not valid
* @throws BadMethodCallException If key/sub group isn't there but this method is invoked
*/
protected final function getGenericArrayKey (string $keyGroup, string $subGroup, string $key) {
// Check parameters
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-FRAMEWORK-SYSTEM: keyGroup=%s,subGroup=%s,key=%s - CALLED!', $keyGroup, $subGroup, $key));
if (empty($keyGroup)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "keyGroup" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
} elseif (empty($subGroup)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "subGroup" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
} elseif (empty($key)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "key" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
} elseif (!$this->isGenericArrayKeySet($keyGroup, $subGroup, $key)) {
// Then abort here
throw new BadMethodCallException(sprintf('keyGroup=%s,subGroup=%s,key[%s]=%s not found.', $keyGroup, $subGroup, gettype($key), $key), FrameworkInterface::EXCEPTION_BAD_METHOD_CALL);
}
// Return it
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-FRAMEWORK-SYSTEM: this->genericArray[%s][%s][%s][]=%s - EXIT!', $keyGroup, $subGroup, $key, gettype($this->genericArray[$keyGroup][$subGroup][$key])));
return $this->genericArray[$keyGroup][$subGroup][$key];
}
/**
* Sets a value in given generic array key/element
*
* @param $keyGroup Main group for the key
* @param $subGroup Sub group for the key
* @param $key Key to set
* @param $element Element to set
* @param $value Value to set
* @return void
* @throws InvalidArgumentException If a parameter is not valid
*/
protected final function setGenericArrayElement (string $keyGroup, string $subGroup, string $key, string $element, $value) {
// Check parameter
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-FRAMEWORK-SYSTEM: keyGroup=%s,subGroup=%s,key=%s,element=%s,value[]=%s - CALLED!', $keyGroup, $subGroup, $key, $element, gettype($value)));
if (empty($keyGroup)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "keyGroup" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
} elseif (empty($subGroup)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "subGroup" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
} elseif (empty($key)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "key" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
} elseif ($element === '') {
// Throw IAE
throw new InvalidArgumentException('Parameter "element" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
} elseif (!$this->isGenericArrayElementSet($keyGroup, $subGroup, $key, $element)) {
// Initialize array
$this->initGenericArrayElement($keyGroup, $subGroup, $key, $element);
}
// Then set it
$this->genericArray[$keyGroup][$subGroup][$key][$element] = $value;
// Trace mesage
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage('BASE-FRAMEWORK-SYSTEM: EXIT!');
}
/**
* Getter for generic array element
*
* @param $keyGroup Key group to get
* @param $subGroup Sub group for the key
* @param $key Key to look for
* @param $element Element to look for
* @return $value Mixed value from generic array element
* @throws InvalidArgumentException If a parameter is not valid
* @throws BadMethodCallException If key/sub group isn't there but this method is invoked
*/
protected final function getGenericArrayElement (string $keyGroup, string $subGroup, string $key, string $element) {
// Check parameter
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-FRAMEWORK-SYSTEM: keyGroup=%s,subGroup=%s,key=%s,element=%s - CALLED!', $keyGroup, $subGroup, $key, $element));
if (empty($keyGroup)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "keyGroup" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
} elseif (empty($subGroup)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "subGroup" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
} elseif (empty($key)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "key" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
} elseif ($element === '') {
// Throw IAE
throw new InvalidArgumentException('Parameter "element" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
} elseif (!$this->isGenericArrayElementSet($keyGroup, $subGroup, $key, $element)) {
// Then abort here
throw new BadMethodCallException(sprintf('keyGroup=%s,subGroup=%s,key[%s]=%s,element[%s]=%s not found.', $keyGroup, $subGroup, gettype($key), $key, gettype($element), $element), FrameworkInterface::EXCEPTION_BAD_METHOD_CALL);
}
// Return it
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-FRAMEWORK-SYSTEM: this->genericArray[%s][%s][%s][%s][]=%s - EXIT!', $keyGroup, $subGroup, $key, gettype($this->genericArray[$keyGroup][$subGroup][$key][$element])));
return $this->genericArray[$keyGroup][$subGroup][$key][$element];
}
/**
* Checks if a given sub group is valid (array)
*
* @param $keyGroup Key group to get
* @param $subGroup Sub group for the key
* @return $isValid Whether given sub group is valid
* @throws InvalidArgumentException If a parameter is not valid
*/
protected final function isValidGenericArrayGroup (string $keyGroup, string $subGroup) {
// Check parameter
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-FRAMEWORK-SYSTEM: keyGroup=%s,subGroup=%s - CALLED!', $keyGroup, $subGroup));
if (empty($keyGroup)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "keyGroup" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
} elseif (empty($subGroup)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "subGroup" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
}
// Determine it
$isValid = (($this->isGenericArrayGroupSet($keyGroup, $subGroup)) && (is_array($this->getGenericSubArray($keyGroup, $subGroup))));
// Return it
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-FRAMEWORK-SYSTEM: isValid=%d - EXIT!', intval($isValid)));
return $isValid;
}
/**
* Checks if a given key is valid (array)
*
* @param $keyGroup Key group to get
* @param $subGroup Sub group for the key
* @param $key Key to check
* @return $isValid Whether given sub group is valid
*/
protected final function isValidGenericArrayKey (string $keyGroup, string $subGroup, string $key) {
// Check parameters
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-FRAMEWORK-SYSTEM: keyGroup=%s,subGroup=%s,key=%s - CALLED!', $keyGroup, $subGroup, $key));
if (empty($keyGroup)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "keyGroup" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
} elseif (empty($subGroup)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "subGroup" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
} elseif (empty($key)) {
// Throw IAE
throw new InvalidArgumentException('Parameter "key" is empty', FrameworkInterface::EXCEPTION_INVALID_ARGUMENT);
}
// Determine it
$isValid = (($this->isGenericArrayKeySet($keyGroup, $subGroup, $key)) && (is_array($this->getGenericArrayKey($keyGroup, $subGroup, $key))));
// Return it
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-FRAMEWORK-SYSTEM: isValid=%d - EXIT!', intval($isValid)));
return $isValid;
}
/**
* Initializes the web output instance
*
* @return void
*/
protected function initWebOutputInstance () {
// Init web output instance
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage('BASE-FRAMEWORK-SYSTEM: CALLED!');
$outputInstance = ObjectFactory::createObjectByConfiguredName('output_class');
// Set it locally
$this->setWebOutputInstance($outputInstance);
// Trace mesage
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage('BASE-FRAMEWORK-SYSTEM: EXIT!');
}
/**
* Translates boolean true to 'Y' and false to 'N'
*
* @param $boolean Boolean value
* @return $translated Translated boolean value
*/
public static final function translateBooleanToYesNo (bool $boolean) {
// "Translate" it
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-FRAMEWORK-SYSTEM: boolean=%d - CALLED!', intval($boolean)));
$translated = ($boolean === true) ? 'Y' : 'N';
// ... and return it
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-FRAMEWORK-SYSTEM: translated=%s - EXIT!', $translated));
return $translated;
}
/**
* Creates a full-qualified file name (FQFN) for given file name by adding
* a configured temporary file path to it.
*
* @param $infoInstance An instance of a SplFileInfo class
* @return $fileInfoInstance An instance of a SplFileInfo class (temporary file)
* @throw PathWriteProtectedException If the path in 'temp_file_path' is write-protected
* @throws FileIoException If the file cannot be written
*/
protected static function createTempPathForFile (SplFileInfo $infoInstance) {
// Get config entry
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-FRAMEWORK-SYSTEM: infoInstance=%s - CALLED!', $infoInstance->__toString()));
$basePath = FrameworkBootstrap::getConfigurationInstance()->getConfigEntry('temp_file_path');
// Is the path writeable?
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-FRAMEWORK-SYSTEM: basePath=%s', $basePath));
if (!is_writable($basePath)) {
// Path is write-protected
throw new PathWriteProtectedException($infoInstance, self::EXCEPTION_PATH_CANNOT_BE_WRITTEN);
}
// Add it
$fileInfoInstance = new SplFileInfo($basePath . DIRECTORY_SEPARATOR . $infoInstance->getBasename());
// Is it reachable?
if (!FrameworkBootstrap::isReachableFilePath($fileInfoInstance)) {
// Not reachable
throw new FileIoException($fileInfoInstance, self::EXCEPTION_FILE_NOT_REACHABLE);
}
// Return it
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-FRAMEWORK-SYSTEM: fileInfoInstance=%s - EXIT!', $fileInfoInstance->__toString()));
return $fileInfoInstance;
}
/**
* "Getter" for a printable state name
*
* @return $stateName Name of the node's state in a printable format
* @throws BadMethodCallException If this instance doesn't have a callable getter for stateInstance
* @todo Move this class away from this monolithic place (not whole class is monolithic)
*/
public final function getPrintableState () {
// Check if getter is there
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage('BASE-FRAMEWORK-SYSTEM: CALLED!');
if (!is_callable($this, 'getStateInstance')) {
// Throw BMCE
throw new BadMethodCallException(sprintf('this=%s has no callable getter for stateInstance', $this->__toString()), FrameworkInterface::EXCEPTION_BAD_METHOD_CALL);
}
// Default is 'null'
$stateName = 'null';
// Get the state instance
$stateInstance = $this->getStateInstance();
// Is it an instance of Stateable?
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-FRAMEWORK-SYSTEM: stateInstance[]=%s', gettype($stateInstance)));
if ($stateInstance instanceof Stateable) {
// Then use that state name
$stateName = $stateInstance->getStateName();
}
// Return result
//* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->traceMessage(sprintf('BASE-FRAMEWORK-SYSTEM: stateName=%s - EXIT!', $stateName));
return $stateName;
}
}