Removes the method at the beginning of the queue. You can optionally
filter to dequeue a specific platform method.

@param string $platform

@return MethodInterface|null
198043
public function dequeue($platform = null)
    {
        if (null === $platform) {
            return array_shift($this->queue);
        }

        // The array pointer does not reset between method calls. So we need to reset it manually.
        reset($this->queue);

        do {
            $index = key($this->queue);
            $method = current($this->queue);
            next($this->queue);
        } while ($method instanceof MethodInterface && !$method->supports($platform));

        if (null !== $index) {
            unset($this->queue[$index]);
        }
        if (false === $method) {
            $method = null;
        }

        return $method;
    }
824104
public function getPlatform(string $platform) : Platform
    {
        if (!array_key_exists($platform, $this->platforms)) {
            throw new \OutOfBoundsException(
                'Platform "' . $platform . '" does not exist in data'
            );
        }

        return $this->platforms[$platform];
    }
382266
public function remove($offset) // -> mixed
	{
		$return = null;
		
		if($this->offsetExists($offset))
		{
			if(0 === $offset)
			{
				$return = $this->shift();
			}
			else
			{
				$this->moveToOffset($offset - 1);
				
				$prev   = $this->worker;
				$pos    = $prev->next;
				$return = $pos->data;
				$last   = $offset === $this->size - 1;
				
				if($last)
				{
					$prev->next = null;
					$this->last = $prev;
				}
				else
				{
					$prev->next = $pos->next;
				}
				
				unset($pos);
				
				--$this->size;
				
				if(null !== $this->current_key)
				{
					if($this->current_key === $offset)
					{
						$this->current = $prev->next;
					}
					else if($this->current_key > $offset)
					{
						--$this->current_key;
					}
				}
			}
		}
		else
		{
			throw new OutOfRangeException('Offset invalid or out of range');
		}
		
		return $return;
	}
1063562
public function deleteFrom($table, $where = null)
    {
        $this->clear();

        if (isset($where)) {
            $this->where = "WHERE\n\t(" . $where . ")";
        }

        $this->start = "DELETE";
        $this->from($table);
        return $this;
    }
1164804
public function deleteBatch($where = [], $limit = null)
    {
        $this->where($where);

        if (isset($limit)) {
            $this->limit($limit);
        }

        return $this->platformDeleteBatchHandler($this->builderCache);
    }
454106
public function deletePlatformIdAction(){
        $translator = $this->getServiceLocator()->get('translator');
        $this->getEventManager()->trigger('meliscms_platform_IDs_delete_start', $this, array());
        $request = $this->getRequest();
        $datas = get_object_vars($request->getPost());
        
        $pids_id = (int) $datas['pid_id'];
        $melisEngineTablePlatformIds = $this->getServiceLocator()->get('MelisEngineTablePlatformIds');
        $melisEngineTablePlatformIds->deleteById($pids_id);
        
        $response = array(
            'success' => 1,
            'textTitle' => 'tr_meliscms_tool_platform_ids',
            'textMessage' => 'tr_meliscms_tool_platform_ids_delete_success_msg',
        );
        $this->getEventManager()->trigger('meliscms_platform_IDs_delete_end', $this, array_merge($response, array('typeCode' => 'CMS_PLATFORM_IDS_DELETE', 'itemId' => $pids_id)));
        return new JsonModel($response);
    }
866113
public function remove($queueName)
    {
        $queue = null;
        if (isset($this->queues[$queueName])) {
            $queue = $this->queues[$queueName];
        }
        unset($this->queues[$queueName]);

        return $queue;
    }
864568
public function dequeue()
    {
        // if there is only one queue defined, let's use that
        if(count($this->getQueues()) === 1) {
            return $this->getFirstQueue()->dequeue();
        }

        // default: getting a task using the current task selector strategy
        return $this->selectorStrategy->pickNextTask($this->getQueues());
    }
138099
public function pop($queue = null)
    {
        $queue = $this->getQueue($queue);

        return $this->database->transaction(function () use ($queue)
        {
            if (! is_null($job = $this->getNextAvailableJob($queue))) {
                $this->markJobAsReserved($job->id, $job->attempts);

                return new DatabaseJob(
                    $this->container, $this, $job, $queue
                );
            }
        });
    }
757128
public static function remove(string $index):int
    {
        unset(self::$framework_paths[$index]);
        if (isset(self::$framework_paths[$index])) {
            return (0);
        } else {
            return (1);
        }
    }
344431
public function removeParameters(array $parameters = null)
  {
    if ($this->isLocked()) {
      return $this->getObj()->removeParameters($parameters)->setLocked();
    } else {
      return parent::removeParameters($parameters);
    }
  }
930454
public function methodsStart($method) {
        if (is_string($method)) {
            $method = array($method);
        }
        $this->rule = "start";
        $this->method = $method;
        return $this;
    }
614934
public function offsetUnset($offset)
    {
        if (false === method_exists($this, 'set' . ucfirst($offset))) {
            unset($this->$offset);

            return $this;
        }

        return $this->offsetSet($offset, null);
    }
840727
public function dequeue()
    {
        if ($this->items === []) {
            throw new LogicException('You should not reach a dequeue() on an empty queue inside tests');
        }
        $item = array_pop($this->items);

        return $this->invisibleItems[$item->getReceipt()] = $item;
    }
242340
public function removeFromReferencing(array $values, $table, $viaColumn = null, Filtering $filtering = null, $strategy = null)
    {
        $this->result->removeFromReferencing($values, $table, $viaColumn, $filtering, $strategy);
    }
750989
public function remove($model)
    {
        $class    = $this->manager->getClassMetadata(get_class($model));
        $managers = $class->getFieldManagerNames();
        $priority = $this->manager->getPool()->getPriority('transaction');

        foreach ($managers as $key => $managerName) {
            if (isset($priority[$managerName])) {
                $this->manager->remove($model);

                unset($managers[$key]); // dereference index
            }
        }

        foreach ($managers as $managerName) {
            $this->addQueue(self::QUEUE_ACTION_REMOVE, $managerName, $model);
        }
    }
1264844
public function remove($identifier)
    {
        if (!$this->has($identifier)) {
            return null;
        }

        $removedValue = $this->container[$identifier];

        unset($this->container[$identifier]);

        return $removedValue;
    }