Struct for PHP

<?PHP
    /**
     * ILLI
     *
     * @category   ILLI_Core
     * @package    ILLI
     * @link       http://illi.be
     * @license    http://l.illi.be
     * @copyright  ILLI Conference
     */
    NAMESPACE ILLI\Core;
    USE Closure;

    /**
     * ILLI Memberfield (pseudo Struct)
     *
     * I like structs!
     *
     * tMemberfield allows you to implement a qualified table of private/protected members
     * including trigger-events for set/get.
     *
     * features:
     *  - strict type definition
     *  - you can set an initial value
     *  - reset everytime to initial
     *  - blacklist for scalar values
     *  - whitelist for scalar values
     *  - undo-function/-history
     *  - redo-function/-history
     *  - flag fields as read-only
     *  - flag fields as required
     *  - validate fields
     *  - event-handler for set
     *  - event-handler for get
     *  - lock everything virtual
     *
     *
     * class design is a pseudo-static collection, stored by spl hash per object;
     *
     * note:
     *  - isset() doesn't mean isset()! isset is PHP-gutter politics...
     *      for isset in sense of PHP @see isDefined().
     *
     *  - events: they should not be used as adapters and not to overwrite stored values
     *      converting a registered integer to a non-registered string will throw an exception
     *
     *
     * bitflags are bad for performance, hu?
     *
     *
     * @category   ILLI_Core
     * @package    ILLI
     * @subpackage Core
     * @namespace  ILLI\Core
     * @link       http://illi.be
     * @license    http://l.illi.be
     * @copyright  ILLI Conference
     * @since      2.0.1
     * @version    3.0.1
     *
     * @todo i believe it's useful to fire some exceptions
     * @todo prototype study to create a setter-/getter-class with \ILLI\Core\Dynamic\Spl
     */
    TRAIT tMemberfield
    {
        /**
         * what do whant to see in var_dump()
         * @var int
         * @static
         * @internal
         */
        private static  $__printableFlag            = 0;

        /**
         * what do you set
         * @var array
         * @static
         * @internal
         */
        private static  $__tMemberfield_PropContains        = [];

        /**
         * strict type definitions
         * @var array
         * @static
         * @internal
         */
        private static  $__tMemberfield_PropAcceptsType     = [];

        /**
         * can not overwrite|undo|redo|reset
         * @var array
         * @static
         * @internal
         */
        private static  $__tMemberfield_PropIsLocked        = [];

        /**
         * set() was called after initialization
         * @var array
         * @static
         * @internal
         */
        private static  $__tMemberfield_PropIsTouched       = [];

        /**
         * fast validate: compares between init- and contains-value; considered stop-handle
         * @var array
         * @static
         * @internal
         */
        private static  $__tMemberfield_PropIsRequired      = [];

        /**
         * allows you to switch in __set() between protected and local access
         * @var array
         * @static
         * @internal
         */
        private static  $__tMemberfield_PropPrivateSet      = [];

        /**
         * allows you to switch in __get() between protected and local access
         * @var array
         * @static
         * @internal
         */
        private static  $__tMemberfield_PropPrivateGet      = [];

        /**
         * stores the initial value (for reset; for comparison)
         * @var array
         * @static
         * @internal
         */
        private static  $__tMemberfield_PropInitializedAs   = [];

        /**
         * switch: allowed is only from whitelist (only scalar now)
         * @var array
         * @static
         * @internal
         */
        private static  $__tMemberfield_PropAcceptsValues   = [];

        /**
         * switch: forbidden is all in blacklist (only scalar now)
         * @var array
         * @static
         * @internal
         */
        private static  $__tMemberfield_PropForbidsValues   = [];

        /**
         * onSet-event
         * @var array
         * @static
         * @internal
         */
        private static  $__tMemberfield_PropOnSetEvent      = [];

        /**
         * onGet-event
         * @var array
         * @static
         * @internal
         */
        private static  $__tMemberfield_PropOnGetEvent      = [];

        /**
         * counter
         * @var array
         * @static
         * @internal
         */
        private static  $__tMemberfield_PropUndoSteps       = [];

        /**
         * last values
         * @var array
         * @static
         * @internal
         */
        private static  $__tMemberfield_PropUndoStack       = [];

        /**
         * counter
         * @var array
         * @static
         * @internal
         */
        private static  $__tMemberfield_PropRedoSteps       = [];

        /**
         * next values
         * @var array
         * @static
         * @internal
         */
        private static  $__tMemberfield_PropRedoStack       = [];

        /**
         * accessor: limitation of visible fields in var_dump(); short hand...
         * @var array property => reference to static prop-tables
         */
        protected   $__tMemberfields            = [];

        /**
         * lock registration of new fields
         * @var array
         */
        private     $__tMemberfield_LockRegistration    = FALSE;

        /**
         * keep property-lock-state set a lock-wrapper
         * @var array
         */
        private     $__tMemberfield_LockAllFields       = FALSE;

        /**
         * spl hash
         * @internal
         */
        private     $__tMemberfield_Hash            = NULL;

        /**
         * trait-constructor
         */
        private function tMemberfield_register()
        {
            if(NULL !== $this->__tMemberfield_Hash)
                return;

            $this->__tMemberfield_Hash = spl_object_hash($this);

            self::$__tMemberfield_PropContains      [$this->__tMemberfield_Hash] = [];
            self::$__tMemberfield_PropAcceptsType       [$this->__tMemberfield_Hash] = [];
            self::$__tMemberfield_PropIsLocked      [$this->__tMemberfield_Hash] = [];
            self::$__tMemberfield_PropIsTouched     [$this->__tMemberfield_Hash] = [];
            self::$__tMemberfield_PropIsRequired        [$this->__tMemberfield_Hash] = [];
            self::$__tMemberfield_PropPrivateSet        [$this->__tMemberfield_Hash] = [];
            self::$__tMemberfield_PropPrivateGet        [$this->__tMemberfield_Hash] = [];
            self::$__tMemberfield_PropInitializedAs     [$this->__tMemberfield_Hash] = [];
            self::$__tMemberfield_PropAcceptsValues     [$this->__tMemberfield_Hash] = [];
            self::$__tMemberfield_PropForbidsValues     [$this->__tMemberfield_Hash] = [];
            self::$__tMemberfield_PropOnSetEvent        [$this->__tMemberfield_Hash] = [];
            self::$__tMemberfield_PropOnGetEvent        [$this->__tMemberfield_Hash] = [];
            self::$__tMemberfield_PropUndoSteps     [$this->__tMemberfield_Hash] = [];
            self::$__tMemberfield_PropUndoStack     [$this->__tMemberfield_Hash] = [];
            self::$__tMemberfield_PropRedoSteps     [$this->__tMemberfield_Hash] = [];
            self::$__tMemberfield_PropRedoStack     [$this->__tMemberfield_Hash] = [];
        }

        /**
         * trait-destructor
         */
        private function tMemberfield_unregister()
        {
            unset(self::$__tMemberfield_PropContains    [$this->__tMemberfield_Hash]);
            unset(self::$__tMemberfield_PropAcceptsType [$this->__tMemberfield_Hash]);
            unset(self::$__tMemberfield_PropIsLocked    [$this->__tMemberfield_Hash]);
            unset(self::$__tMemberfield_PropIsTouched   [$this->__tMemberfield_Hash]);
            unset(self::$__tMemberfield_PropIsRequired  [$this->__tMemberfield_Hash]);
            unset(self::$__tMemberfield_PropPrivateSet  [$this->__tMemberfield_Hash]);
            unset(self::$__tMemberfield_PropPrivateGet  [$this->__tMemberfield_Hash]);
            unset(self::$__tMemberfield_PropInitializedAs   [$this->__tMemberfield_Hash]);
            unset(self::$__tMemberfield_PropAcceptsValues   [$this->__tMemberfield_Hash]);
            unset(self::$__tMemberfield_PropForbidsValues   [$this->__tMemberfield_Hash]);
            unset(self::$__tMemberfield_PropOnSetEvent  [$this->__tMemberfield_Hash]);
            unset(self::$__tMemberfield_PropOnGetEvent  [$this->__tMemberfield_Hash]);
            unset(self::$__tMemberfield_PropUndoSteps   [$this->__tMemberfield_Hash]);
            unset(self::$__tMemberfield_PropUndoStack   [$this->__tMemberfield_Hash]);
            unset(self::$__tMemberfield_PropRedoSteps   [$this->__tMemberfield_Hash]);
            unset(self::$__tMemberfield_PropRedoStack   [$this->__tMemberfield_Hash]);
            unset($this->__tMemberfields);
            unset($this->__tMemberfield_Hash);
            unset($this->__tMemberfield_Locked);
        }

        /**
         * register a new memberfield
         *
         * @param string $field name of memberfield
         * @param string $type type-def e. g. integer, array, double or \Exception, \Closure etc
         * @param array $options [
         *      @init       mixed       initial value (not typesafe)
         *      @locked     bool        value is locked and can not changed
         *      @required   bool        its required to touch the value, e. g. config-struct
         *      @private:set    bool
         *      @private:get    bool
         *      @types      string|array    type-def
         *      @only       scalar      scalar whitelist for values
         *      @not        scalar      scalar blacklist for values
         *      @get        Closure|array   list of closures: applied by get(); format: closure(['contains', 'initializedAs'])
         *      @set        Closure|array   list of closures: applied by set(); format: closure(['new', 'contains', 'initializedAs'])
         *  ]
         * @param int $__debugFlag control-flag for var_dump()
         */
        protected function tMemberfield_registerProperty($field, $type, array $options = [], $__debugFlag = iMemberfield::DEBUG_CONTAINS)
        {
            $this->tMemberfield_register();

            $defaults = [
                'init'      => NULL,
                'locked'    => FALSE,
                'required'  => FALSE,
                'private:set'   => FALSE,
                'private:get'   => FALSE,
                'types'     => (array) $type,
                'only'      => [],
                'not'       => [],
                'get'       => (function(array $data){ return $data; }),
                'set'       => (function(array $data){ return $data; })
            ];

            $options += $defaults;

            self::$__tMemberfield_PropIsLocked      [$this->__tMemberfield_Hash][$field] = $options['locked'];
            self::$__tMemberfield_PropIsTouched     [$this->__tMemberfield_Hash][$field] = FALSE;
            self::$__tMemberfield_PropIsRequired        [$this->__tMemberfield_Hash][$field] = $options['required'];
            self::$__tMemberfield_PropContains      [$this->__tMemberfield_Hash][$field] = $options['init'];
            self::$__tMemberfield_PropInitializedAs     [$this->__tMemberfield_Hash][$field] = $options['init'];
            self::$__tMemberfield_PropAcceptsType       [$this->__tMemberfield_Hash][$field] = (array) $options['types'];
            self::$__tMemberfield_PropAcceptsValues     [$this->__tMemberfield_Hash][$field] = (array) $options['only'];
            self::$__tMemberfield_PropForbidsValues     [$this->__tMemberfield_Hash][$field] = (array) $options['not'];
            self::$__tMemberfield_PropOnGetEvent        [$this->__tMemberfield_Hash][$field] = (array) $options['get'];
            self::$__tMemberfield_PropOnSetEvent        [$this->__tMemberfield_Hash][$field] = (array) $options['set'];
            self::$__tMemberfield_PropPrivateSet        [$this->__tMemberfield_Hash][$field] = $options['private:set'];
            self::$__tMemberfield_PropPrivateGet        [$this->__tMemberfield_Hash][$field] = $options['private:get'];
            self::$__tMemberfield_PropUndoSteps     [$this->__tMemberfield_Hash][$field] = 0;
            self::$__tMemberfield_PropRedoSteps     [$this->__tMemberfield_Hash][$field] = 0;
            self::$__tMemberfield_PropUndoStack     [$this->__tMemberfield_Hash][$field] = [];
            self::$__tMemberfield_PropRedoStack     [$this->__tMemberfield_Hash][$field] = [];

            // primary to cast isset(array[key]) (instead of array-key-exists), because its ~60% faster;
            // an initialValue of a memberfield in PHP is always null (not void). and we want to know if the key exists - not if its not null
            // the proplem is:
            //  $array[key] = NULL; isset($array[key]) -> FALSE
            //  $array[key] = NULL; array_key_exists(key, $array) -> TRUE (NULL but exists!)
            //
            //
            // solution: create an array into our array[key]... with some references
            // comment in/out what do you want to see in var_dump()
            $this->__tMemberfields[$field] = []; // never delete this line!

            if($__debugFlag & iMemberfield::DEBUG_IS_LOCKED)
                $this->__tMemberfields[$field]['isLocked']  = & self::$__tMemberfield_PropIsLocked      [$this->__tMemberfield_Hash][$field];
            if($__debugFlag & iMemberfield::DEBUG_IS_TOUCHED)
                $this->__tMemberfields[$field]['isTouched'] = & self::$__tMemberfield_PropIsTouched     [$this->__tMemberfield_Hash][$field];
            if($__debugFlag & iMemberfield::DEBUG_IS_REQUIRED)
                $this->__tMemberfields[$field]['isRequired']    = & self::$__tMemberfield_PropIsRequired    [$this->__tMemberfield_Hash][$field];
            if($__debugFlag & iMemberfield::DEBUG_CONTAINS)
                $this->__tMemberfields[$field]['contains']  = & self::$__tMemberfield_PropContains      [$this->__tMemberfield_Hash][$field];
            if($__debugFlag & iMemberfield::DEBUG_INITIALIZED_AS)
                $this->__tMemberfields[$field]['initializedAs'] = & self::$__tMemberfield_PropInitializedAs [$this->__tMemberfield_Hash][$field];
            if($__debugFlag & iMemberfield::DEBUG_ACCEPTED_TYPES)
                $this->__tMemberfields[$field]['acceptedTypes'] = & self::$__tMemberfield_PropAcceptsType   [$this->__tMemberfield_Hash][$field];
            if($__debugFlag & iMemberfield::DEBUG_WHITELISTE)
                $this->__tMemberfields[$field]['allowsOnly']    = & self::$__tMemberfield_PropAcceptsValues [$this->__tMemberfield_Hash][$field];
            if($__debugFlag & iMemberfield::DEBUG_BLACKLIST)
                $this->__tMemberfields[$field]['allowsNever']   = & self::$__tMemberfield_PropForbidsValues [$this->__tMemberfield_Hash][$field];
            if($__debugFlag & iMemberfield::DEBUG_EVENT_GET)
                $this->__tMemberfields[$field]['event:get'] = & self::$__tMemberfield_PropOnGetEvent    [$this->__tMemberfield_Hash][$field];
            if($__debugFlag & iMemberfield::DEBUG_EVENT_SET)
                $this->__tMemberfields[$field]['event:set'] = & self::$__tMemberfield_PropOnSetEvent    [$this->__tMemberfield_Hash][$field];
            if($__debugFlag & iMemberfield::DEBUG_IS_PRIVATE_SET)
                $this->__tMemberfields[$field]['private:set']   = & self::$__tMemberfield_PropPrivateSet    [$this->__tMemberfield_Hash][$field];
            if($__debugFlag & iMemberfield::DEBUG_IS_PRIVATE_GET)
                $this->__tMemberfields[$field]['private:get']   = & self::$__tMemberfield_PropPrivateGet    [$this->__tMemberfield_Hash][$field];
            if($__debugFlag & iMemberfield::DEBUG_UNDO_STEPS)
                $this->__tMemberfields[$field]['undo:steps']    = & self::$__tMemberfield_PropUndoSteps     [$this->__tMemberfield_Hash][$field];
            if($__debugFlag & iMemberfield::DEBUG_UNDO_STACK)
                $this->__tMemberfields[$field]['undo:stack']    = & self::$__tMemberfield_PropUndoStack     [$this->__tMemberfield_Hash][$field];
            if($__debugFlag & iMemberfield::DEBUG_REDO_STEPS)
                $this->__tMemberfields[$field]['redo:steps']    = & self::$__tMemberfield_PropRedoSteps     [$this->__tMemberfield_Hash][$field];
            if($__debugFlag & iMemberfield::DEBUG_REDO_STACK)
                $this->__tMemberfields[$field]['redo:stack']    = & self::$__tMemberfield_PropRedoStack     [$this->__tMemberfield_Hash][$field];
        }

        protected function tMemberfield_template__set($key, $value)
        {
            if(FALSE === $this->tMemberfield_isPrivateSet($key))
                $this->tMemberfield_set($key, $value);
        }

        protected function tMemberfield_template__get($key)
        {
            if(FALSE === $this->tMemberfield_isPrivateGet($key))
                return $this->tMemberfield_get($key);
        }

        /**
         * memberfield is registered as { private set; }
         *
         * @param string $field name of memberfield
         * @return bool
         * @see tMemberfield_registerProperty
         */
        protected function tMemberfield_isPrivateSet($field)
        {
            $this->tMemberfield_register();
            if(FALSE === isset($this->__tMemberfields[$field]))
                return;

            return self::$__tMemberfield_PropPrivateSet[$this->__tMemberfield_Hash][$field];
        }

        /**
         * memberfield is registered as { private get; }
         *
         * @param string $field name of memberfield
         * @return bool
         * @see tMemberfield_registerProperty
         */
        protected function tMemberfield_isPrivateGet($field)
        {
            $this->tMemberfield_register();
            if(FALSE === isset($this->__tMemberfields[$field]))
                return;

            return self::$__tMemberfield_PropPrivateGet[$this->__tMemberfield_Hash][$field];
        }

        /**
         * memberfield is registered as { required to store data }
         *
         * @param string $field name of memberfield
         * @return bool
         * @see tMemberfield_registerProperty
         */
        protected function tMemberfield_isRequired($field)
        {
            $this->tMemberfield_register();
            if(FALSE === isset($this->__tMemberfields[$field]))
                return;

            return self::$__tMemberfield_PropIsRequired[$this->__tMemberfield_Hash][$field];
        }

        /**
         * memberfield::set() was called after initialization
         *
         * @param string $field name of memberfield
         * @return bool
         */
        protected function tMemberfield_isTouched($field)
        {
            $this->tMemberfield_register();
            if(FALSE === isset($this->__tMemberfields[$field]))
                return;

            return self::$__tMemberfield_PropIsTouched[$this->__tMemberfield_Hash][$field];
        }

        /**
         * compare: current value === initial-value
         *
         * applies stored filters to compare
         *
         * @param string $field name of memberfield
         * @return bool
         */
        protected function tMemberfield_isInitialValue($field)
        {
            $this->tMemberfield_register();
            if(FALSE === isset($this->__tMemberfields[$field]))
                return;

            $contains   = self::$__tMemberfield_PropIsRequired[$this->__tMemberfield_Hash][$field];
            $initializedAs  = self::$__tMemberfield_PropInitializedAs[$this->__tMemberfield_Hash][$field];

            return $contains === $initializedAs;
        }

        /**
         * memberfield exists (PHP: __isset())
         *
         * @param string $field name of memberfield
         * @return bool
         */
        protected function tMemberfield_isDefined($field)
        {
            $this->tMemberfield_register();
            return isset($this->__tMemberfields[$field]);
        }

        /**
         * returns true if field is explicit or virtual locked
         *
         * @param string $field name of memberfield
         * @return bool
         */
        protected function tMemberfield_isFieldLocked($field)
        {
            $this->tMemberfield_register();
            if(FALSE === isset($this->__tMemberfields[$field]))
                return;

            return TRUE === self::$__tMemberfield_PropIsLocked[$this->__tMemberfield_Hash][$field]
                || TRUE === $this->__tMemberfield_LockAllFields;
        }

        /**
         * setter
         *
         * @param string $field name of memberfield
         * @param mixed $value type by field definition
         * @see tMemberfield_registerProperty
         */
        protected function tMemberfield_set($field, $value)
        {
            $this->tMemberfield_register();

            if(FALSE === isset($this->__tMemberfields[$field]))
                return;

            if(TRUE === self::$__tMemberfield_PropIsLocked[$this->__tMemberfield_Hash][$field]
            || TRUE === $this->__tMemberfield_LockAllFields)
                return;

            $filtered = $this->tMemberfield_applyFilter
            (
                self::$__tMemberfield_PropOnSetEvent[$this->__tMemberfield_Hash][$field],
                [
                    'new'       => $value,
                    'contains'  => self::$__tMemberfield_PropContains[$this->__tMemberfield_Hash][$field],
                    'initializedAs' => self::$__tMemberfield_PropInitializedAs[$this->__tMemberfield_Hash][$field]
                ]
            );

            $new = $filtered['new'];

            if(FALSE === $this->tMemberfield_isAcceptable($field, $new))
                return;

            // undo back to initialVualue?
            if(TRUE === self::$__tMemberfield_PropIsTouched[$this->__tMemberfield_Hash][$field]) // yes: delete this or write an option
            {
                // no
                self::$__tMemberfield_PropUndoSteps[$this->__tMemberfield_Hash][$field]++;
                self::$__tMemberfield_PropRedoSteps[$this->__tMemberfield_Hash][$field]     = 0;
                self::$__tMemberfield_PropRedoStack[$this->__tMemberfield_Hash][$field]     = [];
                self::$__tMemberfield_PropUndoStack[$this->__tMemberfield_Hash][$field][]
                    = self::$__tMemberfield_PropContains[$this->__tMemberfield_Hash][$field];
            }

            self::$__tMemberfield_PropContains[$this->__tMemberfield_Hash][$field]  = $new;
            self::$__tMemberfield_PropIsTouched[$this->__tMemberfield_Hash][$field] = TRUE;
        }

        /**
         * getter
         *
         * @param string $field name of memberfield
         * @return mixed type by field definition
         */
        protected function tMemberfield_get($field)
        {
            $this->tMemberfield_register();
            if(FALSE === isset($this->__tMemberfields[$field]))
                return;

            $filtered = $this->tMemberfield_applyFilter
            (
                self::$__tMemberfield_PropOnGetEvent[$this->__tMemberfield_Hash][$field],
                [
                    'contains'  => self::$__tMemberfield_PropContains[$this->__tMemberfield_Hash][$field],
                    'initializedAs' => self::$__tMemberfield_PropInitializedAs[$this->__tMemberfield_Hash][$field]
                ]
            );

            $contains = $filtered['contains'];

            return $contains;
        }

        /**
         * reset the current value to the initial value; deletes undo-/redo-stack
         *
         * @param string $field name of memberfield
         */
        protected function tMemberfield_reset($field)
        {
            $this->tMemberfield_register();
            if(FALSE === isset($this->__tMemberfields[$field]))
                return;

            if(TRUE === self::$__tMemberfield_PropIsLocked[$this->__tMemberfield_Hash][$field]
            || TRUE === $this->__tMemberfield_LockAllFields)
                return;

            self::$__tMemberfield_PropContains[$this->__tMemberfield_Hash][$field]
                = self::$__tMemberfield_PropInitializedAs[$this->__tMemberfield_Hash][$field];
            self::$__tMemberfield_PropUndoSteps[$this->__tMemberfield_Hash][$field]     = 0;
            self::$__tMemberfield_PropRedoSteps[$this->__tMemberfield_Hash][$field]     = 0;
            self::$__tMemberfield_PropRedoStack[$this->__tMemberfield_Hash][$field]     = [];
            self::$__tMemberfield_PropUndoStack[$this->__tMemberfield_Hash][$field]     = [];

            return $this;
        }

        /**
         * go one step back (not tested with objects!)
         *
         * @param string $field name of memberfield
         * @beta
         */
        protected function tMemberfield_undo($field)
        {
            $this->tMemberfield_register();

            if(FALSE === isset($this->__tMemberfields[$field]))
                return;

            if(TRUE === self::$__tMemberfield_PropIsLocked[$this->__tMemberfield_Hash][$field]
            || TRUE === $this->__tMemberfield_LockAllFields)
                return;

            if(0 === self::$__tMemberfield_PropUndoSteps[$this->__tMemberfield_Hash][$field])
                return;

            self::$__tMemberfield_PropUndoSteps[$this->__tMemberfield_Hash][$field]--;
            self::$__tMemberfield_PropRedoSteps[$this->__tMemberfield_Hash][$field]++;
            self::$__tMemberfield_PropRedoStack[$this->__tMemberfield_Hash][$field][]
                = self::$__tMemberfield_PropContains[$this->__tMemberfield_Hash][$field];
            self::$__tMemberfield_PropContains[$this->__tMemberfield_Hash][$field]
                = array_pop(self::$__tMemberfield_PropUndoStack[$this->__tMemberfield_Hash][$field]);
        }

        /**
         * forwards one step (not tested with objects!)
         *
         * @param string $field name of memberfield
         * @beta
         */
        protected function tMemberfield_redo($field)
        {
            $this->tMemberfield_register();
            if(FALSE === isset($this->__tMemberfields[$field]))
                return;

            if(TRUE === self::$__tMemberfield_PropIsLocked[$this->__tMemberfield_Hash][$field]
            || TRUE === $this->__tMemberfield_LockAllFields)
                return;

            if(0 === self::$__tMemberfield_PropRedoSteps[$this->__tMemberfield_Hash][$field])
                return;

            self::$__tMemberfield_PropUndoSteps[$this->__tMemberfield_Hash][$field]++;
            self::$__tMemberfield_PropRedoSteps[$this->__tMemberfield_Hash][$field]--;
            self::$__tMemberfield_PropUndoStack[$this->__tMemberfield_Hash][$field][]
                = self::$__tMemberfield_PropContains[$this->__tMemberfield_Hash][$field];
            self::$__tMemberfield_PropContains[$this->__tMemberfield_Hash][$field]
                = array_pop(self::$__tMemberfield_PropRedoStack[$this->__tMemberfield_Hash][$field]);
        }

        /**
         * change to read-only mode for one field
         *
         * @param string $field name of memberfield
         */
        protected function tMemberfield_lockField($field)
        {
            $this->tMemberfield_register();
            if(FALSE === isset($this->__tMemberfields[$field]))
                return;

            self::$__tMemberfield_PropIsLocked[$this->__tMemberfield_Hash][$field] = TRUE;
            return $this;
        }

        /**
         * change to read-only mode for all field
         *
         * @param bool $explicit false: virtual (wrapper); true: all fields will be locked
         */
        protected function tMemberfield_lockAllFields($explicit = FALSE)
        {
            $this->tMemberfield_register();

            $this->__tMemberfield_LockAllFields = TRUE;

            if(TRUE === $explicit)
                foreach(self::$__tMemberfield_PropContains[$this->__tMemberfield_Hash] as $field => $data)
                    $this->tMemberfield_lockField($field);

            return $this;
        }

        /**
         * selct ALL members
         *
         * @param bool $applyGetFilters apply get-filters
         * @return array name => value
         */
        protected function tMemberfield_createFieldValuePair($applyGetFilters = TRUE)
        {
            $this->tMemberfield_register();

            $selected = [];
            foreach(self::$__tMemberfield_PropContains[$this->__tMemberfield_Hash] as $field => $data)
                $selected[$field] = (TRUE === $applyGetFilters)
                    ? $this->tMemberfield_get($field)
                    : $data;

            return $selected;
        }

        /**
         * select all untouched fields (with initial-value)
         *
         * @param bool $applyGetFilters apply get-filters
         * @return array name => value
         */
        protected function tMemberfield_createUntouchedFieldValuePair($applyGetFilters = TRUE)
        {
            $this->tMemberfield_register();

            $selected = [];
            foreach(self::$__tMemberfield_PropContains[$this->__tMemberfield_Hash] as $field => $data)
                if(FALSE === $this->tMemberfield_isTouched($field))
                    $selected[$field] = (TRUE === $applyGetFilters)
                        ? $this->tMemberfield_get($field)
                        : $data;

            return $selected;
        }

        /**
         * select all writable fields
         *
         * @param bool $applyGetFilters apply get-filters
         * @return array name => value
         */
        protected function tMemberfield_createUnlockedFieldValuePair($applyGetFilters = TRUE)
        {
            $this->tMemberfield_register();

            if(TRUE === $this->__tMemberfield_LockAllFields)
                return [];

            $selected = [];
            foreach(self::$__tMemberfield_PropIsLocked[$this->__tMemberfield_Hash] as $field => $locked)
                if(FALSE === $locked)
                    $selected[$field] = (TRUE === $applyGetFilters)
                        ? $this->tMemberfield_get($field)
                        : self::$__tMemberfield_PropContains[$this->__tMemberfield_Hash][$field];

            return $selected;
        }

        /**
         * create a list of all fields with accepted datatypes
         *
         * @param string $field name of memberfield
         * @return array name => array with types
         */
        protected function tMemberfield_createFieldAcceptsPair()
        {
            $this->tMemberfield_register();

            $selected = [];
            foreach(self::$__tMemberfield_PropAcceptsType[$this->__tMemberfield_Hash] as $field => $types)
                $selected[$field] = $types;

            return $selected;
        }

        /**
         * validate required fields by isTouched
         *
         * @param Closure $handleStop action when field is untouched
         */
        protected function tMemberfield_validateFields(Closure $handleStop)
        {
            $this->tMemberfield_register();

            foreach(self::$__tMemberfield_PropContains[$this->__tMemberfield_Hash] as $field => $data)
                if(FALSE === $this->tMemberfield_isTouched($field)
                && TRUE  === $this->tMemberfield_isRequired($field))
                    $handleStop($field);

            return $this;
        }

        /**
         * validate value by datatype(s) and black-/whitelist
         *
         * @param string $field name of memberfield
         * @param mixed $value incoming data
         * @return bool
         */
        protected function tMemberfield_isAcceptable($field, $value)
        {
            $this->tMemberfield_register();

            if(FALSE === (bool) $this->__tMemberfields)
                return FALSE;

            $typePassed = FALSE;
            $whitePassed    = FALSE;
            $blackPassed    = FALSE;

            // type
            foreach(self::$__tMemberfield_PropAcceptsType[$this->__tMemberfield_Hash][$field] as $type)
            {
                if(is_object($value))
                {
                    if(TRUE === ($typePassed = (get_class($value) === $type)))
                        break;

                    if(TRUE === ($typePassed = ($value instanceOf $type)))
                        break;

                    continue;
                }

                if(TRUE === ($typePassed = ($type === getType($value))))
                    break;

            }

            // whitelist
            if(FALSE === (bool) self::$__tMemberfield_PropAcceptsValues[$this->__tMemberfield_Hash][$field])
            {
                $whitePassed = TRUE;
            }
            else
            if(is_object($value) || is_array($value))
            {
                /**
                 * @todo compare... structure only or strict?
                 */
            }
            else
            {
                foreach(self::$__tMemberfield_PropAcceptsValues[$this->__tMemberfield_Hash][$field] as $allowed)
                    if(TRUE === ($whitePassed = ($allowed === $value)))
                        break;
            }

            // blacklist
            if(FALSE === (bool) self::$__tMemberfield_PropForbidsValues[$this->__tMemberfield_Hash][$field])
            {
                $blackPassed = TRUE;
            }
            else
            if(is_object($value) || is_array($value))
            {
                /**
                 * @todo compare... structure only or strict?
                 */
            }
            else
            {
                foreach(self::$__tMemberfield_PropForbidsValues[$this->__tMemberfield_Hash][$field] as $forbidden)
                    if(TRUE === ($blackPassed = ($forbidden !== $value)))
                        break;
            }


            return $typePassed && $whitePassed && $blackPassed;
        }

        /**
         * apply your registered filters
         *
         * @param array $filterStack array with closures
         * @param array $data the arguments
         * @return array
         * @internal
         */
        private function tMemberfield_applyFilter(array $filterStack, array $data)
        {
            if(sizeOf($data) === 0)
                return $data;

            $passable_args  = ['data' => $data];

            foreach($filterStack as $FilterAlias)
            {
                if(FALSE === ($FilterAlias instanceOf Closure))
                    continue;

                $passable_args['data'] = $FilterAlias($passable_args['data']);
            }

            return $passable_args['data'];
        }
    }