<?PHP
NAMESPACE ILLI\Core\Std\Def;
USE ILLI\Core\Std\Def;
USE ILLI\Core\Std\Def\ADV\ComponentInitializationException;
USE ILLI\Core\Std\Def\ADV\ComponentMethodCallException;
USE ILLI\Core\Std\Exception\ArgumentExpectedException;
USE ILLI\Core\Std\Exception\ClassNotFoundException;
USE ILLI\Core\Std\Invoke;
USE ILLI\Core\Std\Spl\Fsb;
USE ILLI\Core\Util\Spl;
CLASS ADV
{
#:props:
/**
* cache ADT
*
* :hashAddr<string>
* instance of get_called_class(): ILLI\Core\Std\Def\ADT*
* instance of __CLASS__: ILLI\Core\Std\Def\ADT<hash>
*
* :ADT<ILLI\Core\Std\Def\ADT>
* the ADT for the type-value-pair
*
* @var array [{:hashAddr} => ILLI\Core\Std\Spl\Fsb[long offset => {:ADT}]]
*/
private static $__gc = [];
/**
* gc hash address
*
* @var mixed
* @see ::$__gc
*/
protected $__name = NULL;
/**
* stored value, type defined by ADT
*
* @var mixed
* @see ::$__gc
*/
protected $__data = NULL;
#::
/**
* Instantiate a new ADT-Value-Pair.
*
* The ADV stores data. The expected data-type is defined by ADT-definition(s).
*
* (An generic <long> forbids all except integers. Multi-type-def <string|array> forbids all
* except strings and arrays.)
*
* :offset<long>
* zero-based index
*
* :gcType<string>
* a valid __const_Type
*
* @param string $__defineType {:gcType}
* @param array $__defineType [{:offset} => {:gcType}]
* @throws ILLI\Core\Std\Exception\ArgumentExpectedException when given spl-type is not of type string
* @catchable ILLI\Core\Std\Def\ADT\ComponentInitializationException
* @see ILLI\Core\Std\Def\ADT::__construct()
*/
public function __construct($__defineType)
{
try
{
$d = (array) $__defineType;
$n = $this->__name = $this->createHashAddr($d);
$t = &self::$__gc[$n];
if(TRUE === isset($t))
return;
$t = Fsb::fromArray(Def::types($d), TRUE);
}
catch(\Exception $E)
{
$c = get_called_class();
$e = $c.'\ComponentInitializationException';
#! context-based exception: from namespace ILLI\Core\Std\Def\ADV\ to namspace ILLI\Core\Std\Def\ADV*\:
#! wrap anonymous ADT exception into namespace of defined ADT exception without re-implementation of this method in child-class
throw ($c === __CLASS__ || FALSE === class_exists($e))
? new ComponentInitializationException($E, ['class' => get_called_class()])
: new $e($E, ['class' => get_called_class()]);
}
}
/**
* Destroy anonymous ATV definitions
*
* @catchable ILLI\Core\Std\Def\ADT\ComponentMethodCallException ComponentMethodCallException::ERROR_DTOR
* @void
*/
public function __destruct()
{
try
{
if(($c = get_called_class()) === __CLASS__)
unset(self::$__gc[$this->getName()]);
}
catch(\Exception $E)
{
$c = get_called_class();
$e = $c.'\ComponentMethodCallException';
#! context-based exception: from namespace ILLI\Core\Std\Def\ADV\ to namspace ILLI\Core\Std\Def\ADV*\:
#! wrap anonymous ADT exception into namespace of defined ADT exception without re-implementation of this method in child-class
throw ($c === __CLASS__ || FALSE === class_exists($e))
? new ComponentMethodCallException($E, ComponentMethodCallException::ERROR_DTOR, ['method' => __METHOD__])
: new $e($E, $e::ERROR_DTOR, ['method' => __METHOD__]);
}
}
/**
* value validation
*
* use ADT to validate the value
*
* @param mixed $__value
* @return boolean
* @catchable ILLI\Core\Std\Exception\ADV\ComponentMethodCallException
* @see ILLI\Core\Std\Def\ADT::validate()
*/
public function validate($__value)
{
try
{
return $this->getGC()->evaluate('validate', [$__value]);
}
catch(\Exception $E)
{
$c = get_called_class();
$e = $c.'\ComponentMethodCallException';
#! context-based exception: from namespace ILLI\Core\Std\Def\ADV\ to namspace ILLI\Core\Std\Def\ADV*\:
#! wrap anonymous ADT exception into namespace of defined ADT exception without re-implementation of this method in child-class
throw ($c === __CLASS__ || FALSE === class_exists($e))
? new ComponentMethodCallException($E, ComponentMethodCallException::ERROR_VALIDATE, ['method' => __METHOD__])
: new $e($E, $e::ERROR_VALIDATE, ['method' => __METHOD__]);
}
}
/**
* store data when type equals with ADT
*
* @param mixed $__value
* @return this
* @throws ILLI\Core\Std\Exception\ArgumentExpectedException on validation-fail
* @catchable ILLI\Core\Std\Exception\ADV\ComponentMethodCallException
* @see ::validate()
*/
public function set($__value)
{
$c = get_called_class();
$e = $c.'\ComponentMethodCallException';
try
{
if(TRUE === $this->validate($__value))
{
$this->__data = $__value;
return $this;
}
$E = new ArgumentExpectedException
([
'target' => get_called_class(),
'expected' => implode('|', array_unique($this->getGC()->invoke('toString'))),
'detected' => $t = getType($v = $__value),
'value' => is_object($v) ? get_class($v) : (is_scalar($v) ? $v : NULL)
]);
#! context-based exception: from namespace ILLI\Core\Std\Def\ADV\ to namspace ILLI\Core\Std\Def\ADV*\:
#! wrap anonymous ADT exception into namespace of defined ADT exception without re-implementation of this method in child-class
throw ($c === __CLASS__ || FALSE === class_exists($e))
? new ComponentMethodCallException($E, ['method' => __METHOD__], ComponentMethodCallException::ERROR_SET_VALUE_TYPE_EXPECTED)
: new $e($E, ['method' => __METHOD__], $e::ERROR_SET_VALUE_TYPE_EXPECTED);
}
catch(ComponentMethodCallException $E)
{
#! context-based exception: from namespace ILLI\Core\Std\Def\ADV\ to namspace ILLI\Core\Std\Def\ADV*\:
#! wrap anonymous ADT exception into namespace of defined ADT exception without re-implementation of this method in child-class
throw ($c === __CLASS__ || FALSE === class_exists($e))
? new ComponentMethodCallException($E->getPrevious(), ['method' => __METHOD__])
: new $e($E->getPrevious(), ['method' => __METHOD__]);
}
catch(\Exception $E)
{
#! context-based exception: from namespace ILLI\Core\Std\Def\ADV\ to namspace ILLI\Core\Std\Def\ADV*\:
#! wrap anonymous ADT exception into namespace of defined ADT exception without re-implementation of this method in child-class
throw ($c === __CLASS__ || FALSE === class_exists($e))
? new ComponentMethodCallException($E, ComponentMethodCallException::ERROR_SET, ['method' => __METHOD__])
: new $e($E, $e::ERROR_SET, ['method' => __METHOD__]);
}
}
/**
* get the stored data or NULL when nothing was set
*
* @return mixed|NULL
* @catchable ILLI\Core\Std\Exception\ADV\ComponentMethodCallException
*/
public function get()
{
try
{
return $this->__data;
}
catch(\Exception $E)
{
$c = get_called_class();
$e = $c.'\ComponentMethodCallException';
#! context-based exception: from namespace ILLI\Core\Std\Def\ADV\ to namspace ILLI\Core\Std\Def\ADV*\:
#! wrap anonymous ADT exception into namespace of defined ADT exception without re-implementation of this method in child-class
throw ($c === __CLASS__ || FALSE === class_exists($e))
? new ComponentMethodCallException($E, ComponentMethodCallException::ERROR_GET, ['method' => __METHOD__])
: new $e($E, $e::ERROR_GET, ['method' => __METHOD__]);
}
}
/**
* get ADT definition
*
* @return ILLI\Core\Std\Spl\Fsb
* @catchable ILLI\Core\Std\Exception\ADV\ComponentMethodCallException
*/
public function getGC()
{
try
{
return self::$__gc[$this->getName()];
}
catch(\Exception $E)
{
$c = get_called_class();
$e = $c.'\ComponentMethodCallException';
#! context-based exception: from namespace ILLI\Core\Std\Def\ADV\ to namspace ILLI\Core\Std\Def\ADV*\:
#! wrap anonymous ADT exception into namespace of defined ADT exception without re-implementation of this method in child-class
throw ($c === __CLASS__ || FALSE === class_exists($e))
? new ComponentMethodCallException($E, ComponentMethodCallException::ERROR_GET_GC, ['method' => __METHOD__])
: new $e($E, $e::ERROR_GET_GC, ['method' => __METHOD__]);
}
}
/**
* get gc hash address
*
* @return string
* @catchable ILLI\Core\Std\Def\ADT\ComponentMethodCallException ComponentMethodCallException::ERROR_GET_NAME
* @see ::$__gc
*/
public function getName()
{
try
{
return $this->__name;
}
catch(\Exception $E)
{
$c = get_called_class();
$e = $c.'\ComponentMethodCallException';
#! context-based exception: from namespace ILLI\Core\Std\Def\ADV\ to namspace ILLI\Core\Std\Def\ADV*\:
#! wrap anonymous ADT exception into namespace of defined ADT exception without re-implementation of this method in child-class
throw ($c === __CLASS__ || FALSE === class_exists($e))
? new ComponentMethodCallException($E, ComponentMethodCallException::ERROR_GET_NAME, ['method' => __METHOD__])
: new $e($E, $e::ERROR_GET_NAME, ['method' => __METHOD__]);
}
}
protected function createHashAddr(array $__defineTypes = [])
{
try
{
#~ performanced ADT: cache request by called-class; otherwise by hash
return ($c = get_called_class()) === __CLASS__ ? Spl::nameWithHash($c, $this) : $c;
}
catch(\Exception $E)
{
$c = get_called_class();
$e = $c.'\ComponentMethodCallException';
#! context-based exception: from namespace ILLI\Core\Std\Def\ADV\ to namspace ILLI\Core\Std\Def\ADV*\:
#! wrap anonymous ADT exception into namespace of defined ADT exception without re-implementation of this method in child-class
throw ($c === __CLASS__ || FALSE === class_exists($e))
? new ComponentMethodCallException($E, ComponentMethodCallException::ERROR_CREATE_HASH_ADDR, ['method' => __METHOD__])
: new $e($E, $e::ERROR_CREATE_HASH_ADDR, ['method' => __METHOD__]);
}
}
}
Comments