PHP SplObjectStorage::current方法代码示例

 /**
  * Registers all the field groups added
  * @author Tim Perry
  */
 public function hookUp()
 {
     $this->hookables->rewind();
     while ($this->hookables->valid()) {
         $hookable = $this->hookables->current();
         $hookable->hookUp();
         $this->hookables->next();
     }
 }

 public function execute(&$request, &$response)
 {
     if ($this->_filters->valid()) {
         /* @var $current Filter */
         $current = $this->_filters->current();
         $this->_filters->next();
         $current->execute($request, $response, $this);
     }
 }

 /**
  *
  * Registers all the image sizes added
  *
  * @author Tim Perry
  *
  */
 public function registerImageSizes()
 {
     $this->sizes->rewind();
     while ($this->sizes->valid()) {
         $imageSize = $this->sizes->current();
         add_image_size($imageSize->getName(), $imageSize->getWidth(), $imageSize->getHeight(), $imageSize->getCrop());
         $this->sizes->next();
     }
 }

 public function onEventProcessingFailed(array $eventMessages, \Exception $cause = null)
 {
     $this->delegates->rewind();
     while ($this->delegates->valid()) {
         $delegate = $this->delegates->current();
         $delegate->onEventProcessingFailed($eventMessages, $cause);
         $this->delegates->next();
     }
 }

 /**
  * Adds all the functions into the twig environment
  *
  * @param \Twig_Environment $twig
  * @return \Twig_Environment
  * @author Tim Perry
  */
 public function getTwig(\Twig_Environment $twig)
 {
     $this->functions->rewind();
     while ($this->functions->valid()) {
         $function = $this->functions->current();
         $twig->addFunction(new \Twig_SimpleFunction($function->getFunctionName(), array($function, 'getFunctionBody')));
         $this->functions->next();
     }
     return $twig;
 }

 /**
  * Registers all shortcodes added
  * @author Tim Perry
  */
 public function registerShortcodes()
 {
     if (!function_exists('add_shortcode')) {
         return;
     }
     $this->shortcodes->rewind();
     while ($this->shortcodes->valid()) {
         $shortcode = $this->shortcodes->current();
         add_shortcode($shortcode->getName(), array($shortcode, 'getCallback'));
         $this->shortcodes->next();
     }
 }

 /**
  * Iterates through user storage until certain $id is found.
  *
  * @param $id
  *
  * @return User
  *
  * @throws UserNotFoundException
  */
 public function find(UserId $id)
 {
     $this->users->rewind();
     while ($this->users->valid()) {
         $user = $this->users->current();
         if ($user->getId()->equals($id)) {
             return $user;
         }
         $this->users->next();
     }
     throw new UserNotFoundException(sprintf('User with id %d not found.', $id->id()));
 }

 /**
  * Registers all the meta boxes added
  * @author Tim Perry
  */
 public function addMetaBoxes()
 {
     $this->metaBoxes->rewind();
     while ($this->metaBoxes->valid()) {
         $metaBox = $this->metaBoxes->current();
         foreach ($metaBox->getSupportedPostTypes() as $postType) {
             add_meta_box($metaBox->getID(), $metaBox->getTitle(), array($metaBox, 'getCallback'), $postType, $metaBox->getContext(), $metaBox->getPriority(), $metaBox->getCallbackArgs());
             add_action('save_post', array($metaBox, 'savePostCallback'));
         }
         $this->metaBoxes->next();
     }
 }

 /**
  * Registers all the taxonomies added
  */
 public function registerTaxonomies()
 {
     if (!function_exists('register_taxonomy')) {
         return;
     }
     $this->taxonomies->rewind();
     while ($this->taxonomies->valid()) {
         $taxonomy = $this->taxonomies->current();
         register_taxonomy($taxonomy->getName(), $taxonomy->getSupportedPostTypes(), $taxonomy->getArgs());
         $this->taxonomies->next();
     }
 }

 /**
  * @param $pos
  *
  * @return null|AbstractSQLConnection
  */
 public function getConnectionByPosition($pos)
 {
     $pos = (int) $pos;
     $this->storage->rewind();
     for ($i = 0; $this->storage->count() > $i; $i++) {
         if ($i === $pos) {
             return $this->storage->current();
         }
         $this->storage->next();
     }
     return null;
 }

 /**
  * Registers all the post types added
  * @author Tim Perry
  */
 public function registerPostTypes()
 {
     if (!function_exists('register_post_type')) {
         return;
     }
     $this->postTypes->rewind();
     while ($this->postTypes->valid()) {
         $postType = $this->postTypes->current();
         register_post_type($postType->getName(), $postType->getArgs());
         $this->postTypes->next();
     }
 }

 /**
  * Registers all the field groups added
  *
  * @author Tim Perry
  */
 public function registerFieldGroups()
 {
     if (!function_exists('register_field_group')) {
         return;
     }
     $this->fieldGroups->rewind();
     while ($this->fieldGroups->valid()) {
         $field = $this->fieldGroups->current();
         register_field_group($field->getConfig());
         $this->fieldGroups->next();
     }
 }

 /**
  * @return int
  */
 public function getNumberOfAdvancedCourses() : int
 {
     $advancedCourses = 0;
     $this->courses->rewind();
     while ($this->courses->valid()) {
         $course = $this->courses->current();
         if ($course->isAdvanced()) {
             $advancedCourses++;
         }
         $this->courses->next();
     }
     return $advancedCourses;
 }

 /**
  * Runs after all steps have been processed bay calling post process method on all steps.
  *
  * @param \WCM\WPStarter\Setup\IO $io
  */
 public function postProcess(IO $io)
 {
     $this->postProcessSteps->rewind();
     while ($this->postProcessSteps->valid()) {
         /** @var \WCM\WPStarter\Setup\Steps\PostProcessStepInterface $step */
         $step = $this->postProcessSteps->current();
         $step->postProcess($io);
         $this->postProcessSteps->next();
     }
 }

 /**
  * @param null|mixed|array $models (optional)
  */
 public function commit($models = null)
 {
     $pool = $this->manager->getPool();
     /** @var ObjectManager[] $managers */
     $managers = $pool->getIterator();
     if (null === $models) {
         foreach ($managers as $manager) {
             $manager->flush();
         }
         if (!$this->models->count()) {
             return;
         }
         $this->models->rewind();
         while ($this->models->valid()) {
             $model = $this->models->current();
             $class = $this->manager->getClassMetadata(get_class($model));
             $managerName = $class->getManagerReferenceGenerator();
             $ref = call_user_func(array($model, 'get' . ucfirst($managerName)));
             $id = call_user_func(array($ref, 'get' . ucfirst($class->getIdentifierReference($managerName)->referenceField)));
             foreach ($this->models->getInfo() as $managerName) {
                 $this->saveSpecificModel($model, $managerName, $id);
             }
             $this->models->next();
         }
         // clear list
         $this->models = new \SplObjectStorage();
     } else {
         if (!is_array($models)) {
             $models = array($models);
         }
         foreach ($models as $model) {
             $class = $this->manager->getClassMetadata(get_class($model));
             $managerName = $class->getManagerReferenceGenerator();
             $ref = call_user_func(array($model, 'get' . ucfirst($managerName)));
             $pool->getManager($managerName)->flush($ref);
             $id = call_user_func(array($ref, 'get' . ucfirst($class->getIdentifierReference($managerName)->referenceField)));
             foreach ($class->getFieldManagerNames() as $managerName) {
                 $this->saveSpecificModel($model, $managerName, $id);
             }
         }
     }
 }