Merge "Avoid DB_MASTER queries in User::newSystemUser() when possible"

[lhc/web/wiklou.git] / includes / jobqueue / JobQueueMemory.php

diff --git a/includes/jobqueue/JobQueueMemory.php b/includes/jobqueue/JobQueueMemory.php
index d9b30c7..2866c7f 100644 (file)
--- a/includes/jobqueue/JobQueueMemory.php
+++ b/includes/jobqueue/JobQueueMemory.php
@@ -31,12 +31,17 @@
  */
 class JobQueueMemory extends JobQueue {
        /** @var array[] */
-       protected static $data = array();
-
+       protected static $data = [];
+
+       /**
+        * @see JobQueue::doBatchPush
+        *
+        * @param IJobSpecification[] $jobs
+        * @param int $flags
+        */
        protected function doBatchPush( array $jobs, $flags ) {
-               $unclaimed =& $this->getQueueData( 'unclaimed', array() );
+               $unclaimed =& $this->getQueueData( 'unclaimed', [] );
 
-               /** @var IJobSpecification[] $jobs */
                foreach ( $jobs as $job ) {
                        if ( $job->ignoreDuplicates() ) {
                                $sha1 = Wikimedia\base_convert(
@@ -52,37 +57,67 @@ class JobQueueMemory extends JobQueue {
                }
        }
 
+       /**
+        * @see JobQueue::supportedOrders
+        *
+        * @return string[]
+        */
        protected function supportedOrders() {
-               return array( 'random', 'timestamp', 'fifo' );
+               return [ 'random', 'timestamp', 'fifo' ];
        }
 
+       /**
+        * @see JobQueue::optimalOrder
+        *
+        * @return string
+        */
        protected function optimalOrder() {
                return 'fifo';
        }
 
+       /**
+        * @see JobQueue::doIsEmpty
+        *
+        * @return bool
+        */
        protected function doIsEmpty() {
                return ( $this->doGetSize() == 0 );
        }
 
+       /**
+        * @see JobQueue::doGetSize
+        *
+        * @return int
+        */
        protected function doGetSize() {
                $unclaimed = $this->getQueueData( 'unclaimed' );
 
                return $unclaimed ? count( $unclaimed ) : 0;
        }
 
+       /**
+        * @see JobQueue::doGetAcquiredCount
+        *
+        * @return int
+        */
        protected function doGetAcquiredCount() {
                $claimed = $this->getQueueData( 'claimed' );
 
                return $claimed ? count( $claimed ) : 0;
        }
 
+       /**
+        * @see JobQueue::doPop
+        *
+        * @return Job|bool
+        */
        protected function doPop() {
                if ( $this->doGetSize() == 0 ) {
                        return false;
                }
 
                $unclaimed =& $this->getQueueData( 'unclaimed' );
-               $claimed =& $this->getQueueData( 'claimed', array() );
+               $claimed =& $this->getQueueData( 'claimed', [] );
 
                if ( $this->order === 'random' ) {
                        $key = array_rand( $unclaimed );
@@ -103,6 +138,11 @@ class JobQueueMemory extends JobQueue {
                return $job;
        }
 
+       /**
+        * @see JobQueue::doAck
+        *
+        * @param Job $job
+        */
        protected function doAck( Job $job ) {
                if ( $this->getAcquiredCount() == 0 ) {
                        return;
@@ -112,6 +152,9 @@ class JobQueueMemory extends JobQueue {
                unset( $claimed[$job->metadata['claimId']] );
        }
 
+       /**
+        * @see JobQueue::doDelete
+        */
        protected function doDelete() {
                if ( isset( self::$data[$this->type][$this->wiki] ) ) {
                        unset( self::$data[$this->type][$this->wiki] );
@@ -121,40 +164,59 @@ class JobQueueMemory extends JobQueue {
                }
        }
 
+       /**
+        * @see JobQueue::getAllQueuedJobs
+        *
+        * @return Iterator of Job objects.
+        */
        public function getAllQueuedJobs() {
                $unclaimed = $this->getQueueData( 'unclaimed' );
                if ( !$unclaimed ) {
-                       return new ArrayIterator( array() );
+                       return new ArrayIterator( [] );
                }
 
-               $that = $this;
                return new MappedIterator(
                        $unclaimed,
-                       function ( $value ) use ( $that ) {
-                               $that->jobFromSpecInternal( $value );
+                       function ( $value ) {
+                               $this->jobFromSpecInternal( $value );
                        }
                );
        }
 
+       /**
+        * @see JobQueue::getAllAcquiredJobs
+        *
+        * @return Iterator of Job objects.
+        */
        public function getAllAcquiredJobs() {
                $claimed = $this->getQueueData( 'claimed' );
                if ( !$claimed ) {
-                       return new ArrayIterator( array() );
+                       return new ArrayIterator( [] );
                }
 
-               $that = $this;
                return new MappedIterator(
                        $claimed,
-                       function ( $value ) use ( $that ) {
-                               $that->jobFromSpecInternal( $value );
+                       function ( $value ) {
+                               $this->jobFromSpecInternal( $value );
                        }
                );
        }
 
+       /**
+        * @param IJobSpecification $spec
+        *
+        * @return Job
+        */
        public function jobFromSpecInternal( IJobSpecification $spec ) {
                return Job::factory( $spec->getType(), $spec->getTitle(), $spec->getParams() );
        }
 
+       /**
+        * @param string $field
+        * @param mixed $init
+        *
+        * @return mixed
+        */
        private function &getQueueData( $field, $init = null ) {
                if ( !isset( self::$data[$this->type][$this->wiki][$field] ) ) {
                        if ( $init !== null ) {