interface/modules/zend_modules/library/Zend/View/Model/ViewModel.php

   1 <?php
   2 /**
   3  * Zend Framework (http://framework.zend.com/)
   4  *
   5  * @link      http://github.com/zendframework/zf2 for the canonical source repository
   6  * @copyright Copyright (c) 2005-2013 Zend Technologies USA Inc. (http://www.zend.com)
   7  * @license   http://framework.zend.com/license/new-bsd New BSD License
   8  */
   9
  10 namespace Zend\View\Model;
  11
  12 use ArrayAccess;
  13 use ArrayIterator;
  14 use Traversable;
  15 use Zend\Stdlib\ArrayUtils;
  16 use Zend\View\Exception;
  17 use Zend\View\Model;
  18 use Zend\View\Variables as ViewVariables;
  19
  20 class ViewModel implements ModelInterface, ClearableModelInterface
  21 {
  22     /**
  23      * What variable a parent model should capture this model to
  24      *
  25      * @var string
  26      */
  27     protected $captureTo = 'content';
  28
  29     /**
  30      * Child models
  31      * @var array
  32      */
  33     protected $children = array();
  34
  35     /**
  36      * Renderer options
  37      * @var array
  38      */
  39     protected $options = array();
  40
  41     /**
  42      * Template to use when rendering this model
  43      *
  44      * @var string
  45      */
  46     protected $template = '';
  47
  48     /**
  49      * Is this a standalone, or terminal, model?
  50      *
  51      * @var bool
  52      */
  53     protected $terminate = false;
  54
  55     /**
  56      * View variables
  57      * @var array|ArrayAccess&Traversable
  58      */
  59     protected $variables = array();
  60
  61
  62     /**
  63      * Is this append to child  with the same capture?
  64      *
  65      * @var bool
  66      */
  67     protected $append = false;
  68
  69     /**
  70      * Constructor
  71      *
  72      * @param  null|array|Traversable $variables
  73      * @param  array|Traversable $options
  74      */
  75     public function __construct($variables = null, $options = null)
  76     {
  77         if (null === $variables) {
  78             $variables = new ViewVariables();
  79         }
  80
  81         // Initializing the variables container
  82         $this->setVariables($variables, true);
  83
  84         if (null !== $options) {
  85             $this->setOptions($options);
  86         }
  87     }
  88
  89     /**
  90      * Property overloading: set variable value
  91      *
  92      * @param  string $name
  93      * @param  mixed $value
  94      * @return void
  95      */
  96     public function __set($name, $value)
  97     {
  98         $this->setVariable($name, $value);
  99     }
 100
 101     /**
 102      * Property overloading: get variable value
 103      *
 104      * @param  string $name
 105      * @return mixed
 106      */
 107     public function __get($name)
 108     {
 109         if (!$this->__isset($name)) {
 110             return null;
 111         }
 112
 113         $variables = $this->getVariables();
 114         return $variables[$name];
 115     }
 116
 117     /**
 118      * Property overloading: do we have the requested variable value?
 119      *
 120      * @param  string $name
 121      * @return bool
 122      */
 123     public function __isset($name)
 124     {
 125         $variables = $this->getVariables();
 126         return isset($variables[$name]);
 127     }
 128
 129     /**
 130      * Property overloading: unset the requested variable
 131      *
 132      * @param  string $name
 133      * @return void
 134      */
 135     public function __unset($name)
 136     {
 137         if (!$this->__isset($name)) {
 138             return null;
 139         }
 140
 141         unset($this->variables[$name]);
 142     }
 143
 144     /**
 145      * Set a single option
 146      *
 147      * @param  string $name
 148      * @param  mixed $value
 149      * @return ViewModel
 150      */
 151     public function setOption($name, $value)
 152     {
 153         $this->options[(string) $name] = $value;
 154         return $this;
 155     }
 156
 157     /**
 158      * Get a single option
 159      *
 160      * @param  string       $name           The option to get.
 161      * @param  mixed|null   $default        (optional) A default value if the option is not yet set.
 162      * @return mixed
 163      */
 164     public function getOption($name, $default = null)
 165     {
 166         $name = (string) $name;
 167         return array_key_exists($name, $this->options) ? $this->options[$name] : $default;
 168     }
 169
 170     /**
 171      * Set renderer options/hints en masse
 172      *
 173      * @param array|Traversable $options
 174      * @throws \Zend\View\Exception\InvalidArgumentException
 175      * @return ViewModel
 176      */
 177     public function setOptions($options)
 178     {
 179         // Assumption is that lowest common denominator for renderer configuration
 180         // is an array
 181         if ($options instanceof Traversable) {
 182             $options = ArrayUtils::iteratorToArray($options);
 183         }
 184
 185         if (!is_array($options)) {
 186             throw new Exception\InvalidArgumentException(sprintf(
 187                 '%s: expects an array, or Traversable argument; received "%s"',
 188                 __METHOD__,
 189                 (is_object($options) ? get_class($options) : gettype($options))
 190             ));
 191         }
 192
 193         $this->options = $options;
 194         return $this;
 195     }
 196
 197     /**
 198      * Get renderer options/hints
 199      *
 200      * @return array
 201      */
 202     public function getOptions()
 203     {
 204         return $this->options;
 205     }
 206
 207     /**
 208      * Clear any existing renderer options/hints
 209      *
 210      * @return ViewModel
 211      */
 212     public function clearOptions()
 213     {
 214         $this->options = array();
 215         return $this;
 216     }
 217
 218     /**
 219      * Get a single view variable
 220      *
 221      * @param  string       $name
 222      * @param  mixed|null   $default (optional) default value if the variable is not present.
 223      * @return mixed
 224      */
 225     public function getVariable($name, $default = null)
 226     {
 227         $name = (string) $name;
 228         if (array_key_exists($name, $this->variables)) {
 229             return $this->variables[$name];
 230         }
 231
 232         return $default;
 233     }
 234
 235     /**
 236      * Set view variable
 237      *
 238      * @param  string $name
 239      * @param  mixed $value
 240      * @return ViewModel
 241      */
 242     public function setVariable($name, $value)
 243     {
 244         $this->variables[(string) $name] = $value;
 245         return $this;
 246     }
 247
 248     /**
 249      * Set view variables en masse
 250      *
 251      * Can be an array or a Traversable + ArrayAccess object.
 252      *
 253      * @param  array|ArrayAccess|Traversable $variables
 254      * @param  bool $overwrite Whether or not to overwrite the internal container with $variables
 255      * @throws Exception\InvalidArgumentException
 256      * @return ViewModel
 257      */
 258     public function setVariables($variables, $overwrite = false)
 259     {
 260         if (!is_array($variables) && !$variables instanceof Traversable) {
 261             throw new Exception\InvalidArgumentException(sprintf(
 262                 '%s: expects an array, or Traversable argument; received "%s"',
 263                 __METHOD__,
 264                 (is_object($variables) ? get_class($variables) : gettype($variables))
 265             ));
 266         }
 267
 268         if ($overwrite) {
 269             if (is_object($variables) && !$variables instanceof ArrayAccess) {
 270                 $variables = ArrayUtils::iteratorToArray($variables);
 271             }
 272
 273             $this->variables = $variables;
 274             return $this;
 275         }
 276
 277         foreach ($variables as $key => $value) {
 278             $this->setVariable($key, $value);
 279         }
 280
 281         return $this;
 282     }
 283
 284     /**
 285      * Get view variables
 286      *
 287      * @return array|ArrayAccess|Traversable
 288      */
 289     public function getVariables()
 290     {
 291         return $this->variables;
 292     }
 293
 294     /**
 295      * Clear all variables
 296      *
 297      * Resets the internal variable container to an empty container.
 298      *
 299      * @return ViewModel
 300      */
 301     public function clearVariables()
 302     {
 303         $this->variables = new ViewVariables();
 304         return $this;
 305     }
 306
 307     /**
 308      * Set the template to be used by this model
 309      *
 310      * @param  string $template
 311      * @return ViewModel
 312      */
 313     public function setTemplate($template)
 314     {
 315         $this->template = (string) $template;
 316         return $this;
 317     }
 318
 319     /**
 320      * Get the template to be used by this model
 321      *
 322      * @return string
 323      */
 324     public function getTemplate()
 325     {
 326         return $this->template;
 327     }
 328
 329     /**
 330      * Add a child model
 331      *
 332      * @param  ModelInterface $child
 333      * @param  null|string $captureTo Optional; if specified, the "capture to" value to set on the child
 334      * @param  null|bool $append Optional; if specified, append to child  with the same capture
 335      * @return ViewModel
 336      */
 337     public function addChild(ModelInterface $child, $captureTo = null, $append = null)
 338     {
 339         $this->children[] = $child;
 340         if (null !== $captureTo) {
 341             $child->setCaptureTo($captureTo);
 342         }
 343         if (null !== $append) {
 344             $child->setAppend($append);
 345         }
 346
 347         return $this;
 348     }
 349
 350     /**
 351      * Return all children.
 352      *
 353      * Return specifies an array, but may be any iterable object.
 354      *
 355      * @return array
 356      */
 357     public function getChildren()
 358     {
 359         return $this->children;
 360     }
 361
 362     /**
 363      * Does the model have any children?
 364      *
 365      * @return bool
 366      */
 367     public function hasChildren()
 368     {
 369         return (0 < count($this->children));
 370     }
 371
 372     /**
 373      * Clears out all child models
 374      *
 375      * @return ViewModel
 376      */
 377     public function clearChildren()
 378     {
 379         $this->children = array();
 380         return $this;
 381     }
 382
 383     /**
 384      * Set the name of the variable to capture this model to, if it is a child model
 385      *
 386      * @param  string $capture
 387      * @return ViewModel
 388      */
 389     public function setCaptureTo($capture)
 390     {
 391         $this->captureTo = (string) $capture;
 392         return $this;
 393     }
 394
 395     /**
 396      * Get the name of the variable to which to capture this model
 397      *
 398      * @return string
 399      */
 400     public function captureTo()
 401     {
 402         return $this->captureTo;
 403     }
 404
 405     /**
 406      * Set flag indicating whether or not this is considered a terminal or standalone model
 407      *
 408      * @param  bool $terminate
 409      * @return ViewModel
 410      */
 411     public function setTerminal($terminate)
 412     {
 413         $this->terminate = (bool) $terminate;
 414         return $this;
 415     }
 416
 417     /**
 418      * Is this considered a terminal or standalone model?
 419      *
 420      * @return bool
 421      */
 422     public function terminate()
 423     {
 424         return $this->terminate;
 425     }
 426
 427     /**
 428      * Set flag indicating whether or not append to child  with the same capture
 429      *
 430      * @param  bool $append
 431      * @return ViewModel
 432      */
 433     public function setAppend($append)
 434     {
 435         $this->append = (bool) $append;
 436         return $this;
 437     }
 438
 439     /**
 440      * Is this append to child  with the same capture?
 441      *
 442      * @return bool
 443      */
 444     public function isAppend()
 445     {
 446         return $this->append;
 447     }
 448
 449     /**
 450      * Return count of children
 451      *
 452      * @return int
 453      */
 454     public function count()
 455     {
 456         return count($this->children);
 457     }
 458
 459     /**
 460      * Get iterator of children
 461      *
 462      * @return ArrayIterator
 463      */
 464     public function getIterator()
 465     {
 466         return new ArrayIterator($this->children);
 467     }
 468 }