PHP ModelInterface::setVariable方法代码示例

 /**
  * @return mixed
  */
 public function notFoundByRequestedCriteria($criteriaErrors)
 {
     $zendResponse = $this->mvcEvent->getResponse();
     $zendResponse->setStatusCode(404);
     $this->viewModel->setVariable('message', 'The requested resource was not found by requested criteria');
     $this->viewModel->setTemplate('error/404');
     $this->mvcEvent->setResult($this->viewModel);
     return $this->viewModel;
 }

 /**
  *
  * @param ModelInterface $model
  */
 protected function renderChildren(ModelInterface $model)
 {
     foreach ($model->getChildren() as $child) {
         $result = $this->render($child);
         $capture = $child->captureTo();
         if (!empty($capture)) {
             if ($child->isAppend()) {
                 $oldResult = $model->{$capture};
                 $model->setVariable($capture, $oldResult . $result);
             } else {
                 $model->setVariable($capture, $result);
             }
         }
     }
 }

 /**
  * @param \Zend\View\Model\ModelInterface $oViewModel
  * @throws \DomainException
  * @return \BoilerAppMessenger\Media\Mail\MailMessageRenderer
  */
 protected function renderChildren(\Zend\View\Model\ModelInterface $oViewModel)
 {
     foreach ($oViewModel as $oChild) {
         if ($oChild->terminate()) {
             throw new \DomainException('Inconsistent state; child view model is marked as terminal');
         }
         $oChild->setOption('has_parent', true);
         $sResult = $this->renderChildren($oChild)->render($oChild);
         $oChild->setOption('has_parent', null);
         $sCapture = $oChild->captureTo();
         if (!empty($sCapture)) {
             $oViewModel->setVariable($sCapture, $oChild->isAppend() ? $oViewModel->{$sCapture} . $sResult : $sResult);
         }
     }
     return $this;
 }

 /**
  * Loop through children, rendering each
  *
  * @param  Model $model
  * @throws Exception\DomainException
  * @return void
  */
 protected function renderChildren(Model $model)
 {
     foreach ($model as $child) {
         if ($child->terminate()) {
             throw new Exception\DomainException('Inconsistent state; child view model is marked as terminal');
         }
         $child->setOption('has_parent', true);
         $result = $this->render($child);
         $child->setOption('has_parent', null);
         $capture = $child->captureTo();
         if (!empty($capture)) {
             if ($child->isAppend()) {
                 $oldResult = $model->{$capture};
                 $model->setVariable($capture, $oldResult . $result);
             } else {
                 $model->setVariable($capture, $result);
             }
         }
     }
 }

 /**
  * Inject discovered child model values into parent model
  *
  * @todo   detect collisions and decide whether to append and/or aggregate?
  * @param  Model $model
  * @param  array $children
  */
 protected function injectChildren(Model $model, array $children)
 {
     foreach ($children as $child => $value) {
         // TODO detect collisions and decide whether to append and/or aggregate?
         $model->setVariable($child, $value);
     }
 }

 /**
  * Do a recursive, depth-first rendering of a view model.
  *
  * @param ModelInterface $model
  * @param RendererInterface $renderer
  * @return string
  * @throws Exception\RenderingException if it encounters a terminal child.
  */
 private function renderModel(ModelInterface $model, RendererInterface $renderer)
 {
     foreach ($model as $child) {
         if ($child->terminate()) {
             throw new Exception\RenderingException('Cannot render; encountered a child marked terminal');
         }
         $capture = $child->captureTo();
         if (empty($capture)) {
             continue;
         }
         $result = $this->renderModel($child, $renderer);
         if ($child->isAppend()) {
             $oldResult = $model->{$capture};
             $model->setVariable($capture, $oldResult . $result);
             continue;
         }
         $model->setVariable($capture, $result);
     }
     return $renderer->render($model);
 }

 /**
  * assign wrapper template to block
  *
  * @param ModelInterface $block
  * @param array|string $options
  */
 protected function wrapBlock(ModelInterface $block, $options)
 {
     $attributes = $options;
     if (is_string($options)) {
         $wrapperTemplate = $options;
         $attributes = [];
     } elseif (is_array($options) && !isset($options['template'])) {
         $wrapperTemplate = self::WRAPPER_DEFAULT;
     } else {
         $wrapperTemplate = $options['template'];
         unset($attributes['template']);
     }
     if (isset($options['tag'])) {
         $block->setVariable('wrapperTag', $options['tag']);
         unset($attributes['tag']);
     }
     $originalTemplate = $block->getTemplate();
     $block->setOption('is_wrapped', true);
     $block->setTemplate($wrapperTemplate);
     $block->setVariable('wrapperAttributes', $attributes);
     $block->setVariable('originalTemplate', $originalTemplate);
 }

 /**
  *
  * @param ViewModel $block
  * @return string
  */
 protected function determineAnonymousBlockId(ModelInterface $block)
 {
     $blockId = $block->getVariable(self::BLOCK_ID_VAR);
     if (!$blockId) {
         $blockId = sprintf(self::ANONYMOUS_ID_PATTERN, $block->captureTo(), self::$anonymousSuffix++);
         $block->setVariable(self::BLOCK_ID_VAR, $blockId);
     }
     return $blockId;
 }

 /**
  * @inheritDoc
  */
 public function configure(ModelInterface $block, array $specs)
 {
     $specs = $this->prepareOptions($specs);
     foreach ($this->getOption('options', $specs) as $name => $option) {
         $block->setOption($name, $option);
     }
     foreach ($this->getOption('variables', $specs) as $name => $variable) {
         $block->setVariable($name, $variable);
     }
     foreach ($this->getOption('actions', $specs) as $params) {
         if (isset($params['method'])) {
             $method = (string) $params['method'];
             if (method_exists($block, $method)) {
                 $this->invokeArgs($block, $method, $params);
             } else {
                 throw new BadMethodCallException(sprintf('Call to undefined block method %s::%s()', get_class($block), $method));
             }
         }
     }
     if (!$block->getTemplate() && ($template = $this->getOption('template', $specs))) {
         $block->setTemplate($template);
     }
     $block->setCaptureTo($this->getOption('capture_to', $specs));
     $block->setAppend($this->getOption('append', $specs));
     $block->setVariable('block', $block);
     if ($block instanceof BlockInterface) {
         $block->setView($this->container->get('ViewRenderer'));
         $block->setRequest($this->container->get('Request'));
     }
     $results = $this->getEventManager()->trigger(__FUNCTION__ . '.post', $this, ['block' => $block, 'specs' => $specs], function ($result) {
         return $result instanceof ModelInterface;
     });
     if ($results->stopped()) {
         $block = $results->last();
     }
     return $block;
 }

 /**
  * Add a variable to the View Model
  * 
  * @param string $name
  * @param mixed $value
  */
 protected function addVariable($name, $value)
 {
     $this->model->setVariable($name, $value);
 }

 /**
  * Add acl to the view model
  *
  * @param ModelInterface $viewModel
  *
  * @return mixed
  */
 public function attachToView(ModelInterface $viewModel)
 {
     $viewModel->setVariable('acl', $this->getAcl());
     return $this;
 }

 /**
  * Prepare the layout, if any.
  *
  * Injects the view model in the layout view model, if present.
  *
  * If the view model contains a non-empty 'layout' variable, that value
  * will be used to seed a layout view model, if:
  *
  * - it is a string layout template name
  * - it is a ModelInterface instance
  *
  * If a layout is discovered in this way, it will override the one set in
  * the constructor, if any.
  *
  * Returns the provided $viewModel unchanged if no layout is discovered;
  * otherwise, a view model representing the layout, with the provided
  * view model as a child, is returned.
  *
  * @param ModelInterface $viewModel
  * @return ModelInterface
  */
 private function prepareLayout(ModelInterface $viewModel)
 {
     $layout = $this->layout ? clone $this->layout : null;
     $providedLayout = $viewModel->getVariable('layout', false);
     if (is_string($providedLayout) && !empty($providedLayout)) {
         $layout = new ViewModel();
         $layout->setTemplate($providedLayout);
         $viewModel->setVariable('layout', null);
     } elseif ($providedLayout instanceof ModelInterface) {
         $layout = $providedLayout;
         $viewModel->setVariable('layout', null);
     }
     if ($layout) {
         $layout->addChild($viewModel);
         $viewModel = $layout;
     }
     return $viewModel;
 }