ChildMaintainance::rewind() - Code Metrics - qua-bla/html - Measure and Improve Code Quality continuously with Scrutinizer

ChildMaintainance::rewind() A
last analyzed 2016-08-05 09:08 UTC

↳ Parent: ChildMaintainance

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes	2
Bugs	0	Features	1

Metric	Value
c	2
b	0
f	1
dl	0
loc	4
rs	10
cc	1
eloc	2
nc	1
nop	0

<?php

namespace hemio\html\Trait_;

/**
 * Most required utils to implement elements that can have childs and
 * containers. Recomended implementation from most of
 * {@link MaintainsChilds} requirements.
 *
 * @uses MaintainsChilds ChildMaintainance is the recommended
 * implementation from most of MaintainsChilds requirements
 * @author Michael Herold <[email protected]>
 * @todo Cleanup
 */
trait ChildMaintainance
{
    /**
     * child elemnts of the element
     * @var array
     */
    private $arrChilds = [];

    /**
     *
     * @var array[callable]
     */
    protected $arrHooksGainChild = [];

    public function addHookGainChild(callable $hook, $idx = null)
    {
        if ($idx === null)
            $this->arrHooksGainChild[]     = $hook;
        else
            $this->arrHooksGainChild[$idx] = $hook;
    }

    /**
     *
     * @return integer
     */
    public function count()
    {
        return count($this->arrChilds);
    }

    /**
     *
     * @param mixed $offset
     * @return boolean
     */
    public function offsetExists($offset)
    {
        return array_key_exists($offset, $this->arrChilds);
    }

    /**
     *
     * @param mixed $offset
     * @return Interface_\HtmlCode
     */
    public function offsetGet($offset)
    {
        return $this->arrChilds[$offset];
    }

    /**
     *
     * @param mixed $offset
     * @param Interface_\HtmlCode $value
     */
    public function offsetSet($offset, $value)
    {
        if ($this->isValidChild($value) || $value instanceof \hemio\html\Nothing) {
            if ($offset === null)
                $this->arrChilds[]        = $value;
            else
                $this->arrChilds[$offset] = $value;

            $this->gainChild($value);
        } else {
            trigger_error('An instance of `'.get_class($value).
                '` is no valid child for `'.get_class($this).'`', E_USER_WARNING);
        }
    }

    /**
     *
     * @param type $offset
     */
    public function offsetUnset($offset)
    {
        unset($this->arrChilds[$offset]);
    }

    /**
     * Implements iteration
     *
     * @return \Traversable
     */
    public function getIterator()
    {
        return new \ArrayIterator($this->arrChilds);
    }

    /**
     *
     * @param callable $selectFilter
     * @return \Traversable
     */
    public function getRecursiveIterator(callable $selectFilter = null)
    {
        if ($selectFilter === null) {
            return new \RecursiveIteratorIterator($this,
                                                  \RecursiveIteratorIterator::SELF_FIRST);
        } else {
            $array = [];

            foreach ($this->getRecursiveIterator() as $child) {
                if ($selectFilter($child)) {
                    $array[] = $child;
                }
            }

            return new \ArrayIterator($array);
        }
    }

    /**
     *
     * @param \hemio\html\Interface_\HtmlCode $child
     * @return \hemio\html\Interface_\HtmlCode
     */
    protected function addChildInternal(\hemio\html\Interface_\HtmlCode $child)
    {
        $this[] = $child;
        return $child;
    }

    /**
     *
     * @param \hemio\html\Interface_\HtmlCode $child
     * @return \hemio\html\Interface_\HtmlCode
     */
    public function addChildBeginning(\hemio\html\Interface_\HtmlCode $child)
    {
        array_unshift($this->arrChilds, $child);
        return $child;
    }

    /**
     *
     * @param \hemio\html\Interface_\HtmlCode $child
     */
    protected function gainChild(\hemio\html\Interface_\HtmlCode $child)
    {
        foreach ($this->arrHooksGainChild as $hook) {
            $hook($this, $child);
        }

        if ($child instanceof \hemio\html\Abstract_\Element)
            $child->setParent($this);

        if ($child instanceof \hemio\html\Interface_\MaintainsAppendages)
            foreach ($this->getInheritableAppendages() as $appKey => $appValue)
                $child->leaveInheritableAppendage($appKey, $appValue);
    }

    public function __clone()
    {
        foreach ($this->arrChilds as $key => $child) {
            $this->arrChilds[$key] = clone $child;
        }
    }

    public function valid()
    {
        return current($this->arrChilds) !== false;
    }

    public function hasChildren()
    {
        return $this->current() instanceof \RecursiveIterator;
    }

    public function next()
    {
        next($this->arrChilds);
    }

    public function current()
    {
        return current($this->arrChilds);
    }

    public function getChildren()
    {
        return $this->current();
    }

    public function rewind()
    {
        reset($this->arrChilds);
    }

    public function key()
    {
        return key($this->arrChilds);
    }

    /**
     * Existence usually ensured via (@link \hemio\html\Interface_\MaintainsChilds)
     */
    abstract public function isValidChild(\hemio\html\Interface_\HtmlCode $child);

    /**
     * Existence usually ensured via (@link \hemio\html\Interface_\MaintainsAppendages)
     */
    abstract public function getInheritableAppendages();
}


1			<?php
2
3			namespace hemio\html\Trait_;
4
5			/**
6			* Most required utils to implement elements that can have childs and
7			* containers. Recomended implementation from most of
8			* {@link MaintainsChilds} requirements.
9			*
10			* @uses MaintainsChilds ChildMaintainance is the recommended
11			* implementation from most of MaintainsChilds requirements
12			* @author Michael Herold <[email protected]>
13			* @todo Cleanup
14			*/
15			trait ChildMaintainance
16			{
17			/**
18			* child elemnts of the element
19			* @var array
20			*/
21			private $arrChilds = [];
22
23			/**
24			*
25			* @var array[callable]
26			*/
27			protected $arrHooksGainChild = [];
28
29			public function addHookGainChild(callable $hook, $idx = null)
30			{
31			if ($idx === null)
32			$this->arrHooksGainChild[] = $hook;
33			else
34			$this->arrHooksGainChild[$idx] = $hook;
35			}
36
37			/**
38			*
39			* @return integer
40			*/
41			public function count()
42			{
43			return count($this->arrChilds);
44			}
45
46			/**
47			*
48			* @param mixed $offset
49			* @return boolean
50			*/
51			public function offsetExists($offset)
52			{
53			return array_key_exists($offset, $this->arrChilds);
54			}
55
56			/**
57			*
58			* @param mixed $offset
59			* @return Interface_\HtmlCode
60			*/
61			public function offsetGet($offset)
62			{
63			return $this->arrChilds[$offset];
64			}
65
66			/**
67			*
68			* @param mixed $offset
69			* @param Interface_\HtmlCode $value
70			*/
71			public function offsetSet($offset, $value)
72			{
73			if ($this->isValidChild($value) \|\| $value instanceof \hemio\html\Nothing) {
74			if ($offset === null)
75			$this->arrChilds[] = $value;
76			else
77			$this->arrChilds[$offset] = $value;
78
79			$this->gainChild($value);
80			} else {
81			trigger_error('An instance of `'.get_class($value).
82			'` is no valid child for `'.get_class($this).'`', E_USER_WARNING);
83			}
84			}
85
86			/**
87			*
88			* @param type $offset
89			*/
90			public function offsetUnset($offset)
91			{
92			unset($this->arrChilds[$offset]);
93			}
94
95			/**
96			* Implements iteration
97			*
98			* @return \Traversable
99			*/
100			public function getIterator()
101			{
102			return new \ArrayIterator($this->arrChilds);
103			}
104
105			/**
106			*
107			* @param callable $selectFilter
108			* @return \Traversable
109			*/
110			public function getRecursiveIterator(callable $selectFilter = null)
111			{
112			if ($selectFilter === null) {
113			return new \RecursiveIteratorIterator($this,
114			\RecursiveIteratorIterator::SELF_FIRST);
115			} else {
116			$array = [];
117
118			foreach ($this->getRecursiveIterator() as $child) {
119			if ($selectFilter($child)) {
120			$array[] = $child;
121			}
122			}
123
124			return new \ArrayIterator($array);
125			}
126			}
127
128			/**
129			*
130			* @param \hemio\html\Interface_\HtmlCode $child
131			* @return \hemio\html\Interface_\HtmlCode
132			*/
133			protected function addChildInternal(\hemio\html\Interface_\HtmlCode $child)
134			{
135			$this[] = $child;
136			return $child;
137			}
138
139			/**
140			*
141			* @param \hemio\html\Interface_\HtmlCode $child
142			* @return \hemio\html\Interface_\HtmlCode
143			*/
144			public function addChildBeginning(\hemio\html\Interface_\HtmlCode $child)
145			{
146			array_unshift($this->arrChilds, $child);
147			return $child;
148			}
149
150			/**
151			*
152			* @param \hemio\html\Interface_\HtmlCode $child
153			*/
154			protected function gainChild(\hemio\html\Interface_\HtmlCode $child)
155			{
156			foreach ($this->arrHooksGainChild as $hook) {
157			$hook($this, $child);
158			}
159
160			if ($child instanceof \hemio\html\Abstract_\Element)
161			$child->setParent($this);
162
163			if ($child instanceof \hemio\html\Interface_\MaintainsAppendages)
164			foreach ($this->getInheritableAppendages() as $appKey => $appValue)
165			$child->leaveInheritableAppendage($appKey, $appValue);
166			}
167
168			public function __clone()
169			{
170			foreach ($this->arrChilds as $key => $child) {
171			$this->arrChilds[$key] = clone $child;
172			}
173			}
174
175			public function valid()
176			{
177			return current($this->arrChilds) !== false;
178			}
179
180			public function hasChildren()
181			{
182			return $this->current() instanceof \RecursiveIterator;
183			}
184
185			public function next()
186			{
187			next($this->arrChilds);
188			}
189
190			public function current()
191			{
192			return current($this->arrChilds);
193			}
194
195			public function getChildren()
196			{
197			return $this->current();
198			}
199
200			public function rewind()
201			{
202			reset($this->arrChilds);
203			}
204
205			public function key()
206			{
207			return key($this->arrChilds);
208			}
209
210			/**
211			* Existence usually ensured via (@link \hemio\html\Interface_\MaintainsChilds)
212			*/
213			abstract public function isValidChild(\hemio\html\Interface_\HtmlCode $child);
214
215			/**
216			* Existence usually ensured via (@link \hemio\html\Interface_\MaintainsAppendages)
217			*/
218			abstract public function getInheritableAppendages();
219			}
220

qua-bla / html

ChildMaintainance::rewind() A last analyzed 2016-08-05 09:08 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

ChildMaintainance::rewind() A
last analyzed 2016-08-05 09:08 UTC