interface/modules/zend_modules/library/Zend/View/Helper/Placeholder/Container/AbstractContainer.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\Helper\Placeholder\Container;
  11
  12 use ArrayObject;
  13 use Zend\View\Exception;
  14
  15 /**
  16  * Abstract class representing container for placeholder values
  17  */
  18 abstract class AbstractContainer extends ArrayObject
  19 {
  20     /**
  21      * Whether or not to override all contents of placeholder
  22      *
  23      * @const string
  24      */
  25     const SET = 'SET';
  26
  27     /**
  28      * Whether or not to append contents to placeholder
  29      *
  30      * @const string
  31      */
  32     const APPEND = 'APPEND';
  33
  34     /**
  35      * Whether or not to prepend contents to placeholder
  36      *
  37      * @const string
  38      */
  39     const PREPEND = 'PREPEND';
  40
  41     /**
  42      * Key to which to capture content
  43      *
  44      * @var string
  45      */
  46     protected $captureKey;
  47
  48     /**
  49      * Whether or not we're already capturing for this given container
  50      *
  51      * @var bool
  52      */
  53     protected $captureLock = false;
  54
  55     /**
  56      * What type of capture (overwrite (set), append, prepend) to use
  57      *
  58      * @var string
  59      */
  60     protected $captureType;
  61
  62     /**
  63      * What string to use as the indentation of output, this will typically be spaces. Eg: '    '
  64      *
  65      * @var string
  66      */
  67     protected $indent = '';
  68
  69     /**
  70      * What text to append the placeholder with when rendering
  71      *
  72      * @var string
  73      */
  74     protected $postfix   = '';
  75
  76     /**
  77      * What text to prefix the placeholder with when rendering
  78      *
  79      * @var string
  80      */
  81     protected $prefix    = '';
  82
  83     /**
  84      * What string to use between individual items in the placeholder when rendering
  85      *
  86      * @var string
  87      */
  88     protected $separator = '';
  89
  90     /**
  91      * Constructor - This is needed so that we can attach a class member as the ArrayObject container
  92      */
  93     public function __construct()
  94     {
  95         parent::__construct(array(), parent::ARRAY_AS_PROPS);
  96     }
  97
  98     /**
  99      * Serialize object to string
 100      *
 101      * @return string
 102      */
 103     public function __toString()
 104     {
 105         return $this->toString();
 106     }
 107
 108     /**
 109      * Render the placeholder
 110      *
 111      * @param  null|int|string $indent
 112      * @return string
 113      */
 114     public function toString($indent = null)
 115     {
 116         $indent = ($indent !== null)
 117             ? $this->getWhitespace($indent)
 118             : $this->getIndent();
 119
 120         $items  = $this->getArrayCopy();
 121         $return = $indent
 122             . $this->getPrefix()
 123             . implode($this->getSeparator(), $items)
 124             . $this->getPostfix();
 125         $return = preg_replace("/(\r\n?|\n)/", '$1' . $indent, $return);
 126
 127         return $return;
 128     }
 129
 130     /**
 131      * Start capturing content to push into placeholder
 132      *
 133      * @param  string $type How to capture content into placeholder; append, prepend, or set
 134      * @param  mixed  $key  Key to which to capture content
 135      * @throws Exception\RuntimeException if nested captures detected
 136      * @return void
 137      */
 138     public function captureStart($type = AbstractContainer::APPEND, $key = null)
 139     {
 140         if ($this->captureLock) {
 141             throw new Exception\RuntimeException(
 142                 'Cannot nest placeholder captures for the same placeholder'
 143             );
 144         }
 145
 146         $this->captureLock = true;
 147         $this->captureType = $type;
 148         if ((null !== $key) && is_scalar($key)) {
 149             $this->captureKey = (string) $key;
 150         }
 151         ob_start();
 152     }
 153
 154     /**
 155      * End content capture
 156      *
 157      * @return void
 158      */
 159     public function captureEnd()
 160     {
 161         $data               = ob_get_clean();
 162         $key                = null;
 163         $this->captureLock = false;
 164         if (null !== $this->captureKey) {
 165             $key = $this->captureKey;
 166         }
 167         switch ($this->captureType) {
 168             case self::SET:
 169                 if (null !== $key) {
 170                     $this[$key] = $data;
 171                 } else {
 172                     $this->exchangeArray(array($data));
 173                 }
 174                 break;
 175             case self::PREPEND:
 176                 if (null !== $key) {
 177                     $array  = array($key => $data);
 178                     $values = $this->getArrayCopy();
 179                     $final  = $array + $values;
 180                     $this->exchangeArray($final);
 181                 } else {
 182                     $this->prepend($data);
 183                 }
 184                 break;
 185             case self::APPEND:
 186             default:
 187                 if (null !== $key) {
 188                     if (empty($this[$key])) {
 189                         $this[$key] = $data;
 190                     } else {
 191                         $this[$key] .= $data;
 192                     }
 193                 } else {
 194                     $this[$this->nextIndex()] = $data;
 195                 }
 196                 break;
 197         }
 198     }
 199
 200     /**
 201      * Get keys
 202      *
 203      * @return array
 204      */
 205     public function getKeys()
 206     {
 207         $array = $this->getArrayCopy();
 208
 209         return array_keys($array);
 210     }
 211
 212     /**
 213      * Retrieve container value
 214      *
 215      * If single element registered, returns that element; otherwise,
 216      * serializes to array.
 217      *
 218      * @return mixed
 219      */
 220     public function getValue()
 221     {
 222         if (1 == count($this)) {
 223             $keys = $this->getKeys();
 224             $key  = array_shift($keys);
 225             return $this[$key];
 226         }
 227
 228         return $this->getArrayCopy();
 229     }
 230
 231     /**
 232      * Retrieve whitespace representation of $indent
 233      *
 234      * @param  int|string $indent
 235      * @return string
 236      */
 237     public function getWhitespace($indent)
 238     {
 239         if (is_int($indent)) {
 240             $indent = str_repeat(' ', $indent);
 241         }
 242
 243         return (string) $indent;
 244     }
 245
 246     /**
 247      * Set a single value
 248      *
 249      * @param  mixed $value
 250      * @return void
 251      */
 252     public function set($value)
 253     {
 254         $this->exchangeArray(array($value));
 255
 256         return $this;
 257     }
 258
 259     /**
 260      * Prepend a value to the top of the container
 261      *
 262      * @param  mixed $value
 263      * @return self
 264      */
 265     public function prepend($value)
 266     {
 267         $values = $this->getArrayCopy();
 268         array_unshift($values, $value);
 269         $this->exchangeArray($values);
 270
 271         return $this;
 272     }
 273
 274     /**
 275      * Append a value to the end of the container
 276      *
 277      * @param  mixed $value
 278      * @return self
 279      */
 280     public function append($value)
 281     {
 282         parent::append($value);
 283         return $this;
 284     }
 285
 286     /**
 287      * Next Index as defined by the PHP manual
 288      *
 289      * @return int
 290      */
 291     public function nextIndex()
 292     {
 293         $keys = $this->getKeys();
 294         if (0 == count($keys)) {
 295             return 0;
 296         }
 297
 298         return $nextIndex = max($keys) + 1;
 299     }
 300
 301     /**
 302      * Set the indentation string for __toString() serialization,
 303      * optionally, if a number is passed, it will be the number of spaces
 304      *
 305      * @param  string|int $indent
 306      * @return self
 307      */
 308     public function setIndent($indent)
 309     {
 310         $this->indent = $this->getWhitespace($indent);
 311         return $this;
 312     }
 313
 314     /**
 315      * Retrieve indentation
 316      *
 317      * @return string
 318      */
 319     public function getIndent()
 320     {
 321         return $this->indent;
 322     }
 323
 324     /**
 325      * Set postfix for __toString() serialization
 326      *
 327      * @param  string $postfix
 328      * @return self
 329      */
 330     public function setPostfix($postfix)
 331     {
 332         $this->postfix = (string) $postfix;
 333         return $this;
 334     }
 335
 336     /**
 337      * Retrieve postfix
 338      *
 339      * @return string
 340      */
 341     public function getPostfix()
 342     {
 343         return $this->postfix;
 344     }
 345
 346     /**
 347      * Set prefix for __toString() serialization
 348      *
 349      * @param  string $prefix
 350      * @return self
 351      */
 352     public function setPrefix($prefix)
 353     {
 354         $this->prefix = (string) $prefix;
 355         return $this;
 356     }
 357
 358     /**
 359      * Retrieve prefix
 360      *
 361      * @return string
 362      */
 363     public function getPrefix()
 364     {
 365         return $this->prefix;
 366     }
 367
 368     /**
 369      * Set separator for __toString() serialization
 370      *
 371      * Used to implode elements in container
 372      *
 373      * @param  string $separator
 374      * @return self
 375      */
 376     public function setSeparator($separator)
 377     {
 378         $this->separator = (string) $separator;
 379         return $this;
 380     }
 381
 382     /**
 383      * Retrieve separator
 384      *
 385      * @return string
 386      */
 387     public function getSeparator()
 388     {
 389         return $this->separator;
 390     }
 391 }