Returns frame status - whatever its completed (payload can be fetched) or not.
If frame is not completed it tries to fetch remaining data.

@return bool
@throws LogicException
@throws WebSocketException
164274
public function isComplete()
    {
        $this->logger->debug("NetworkFrame::isComplete?");
        if ($this->remainingPayloadBytes === 0 && $this->headersCollected) {
            $this->logger->debug("NetworkFrame::isComplete => OK, buffer load - " . strlen($this->buffer));

            return true;
        }

        $this->logger->debug("NetworkFrame::isComplete => not yet, buffer load - " . strlen($this->buffer));
        if (!empty($this->buffer)) {
            if ($this->headersCollected || $this->collectHeader()) {
                return $this->collectPayload();
            }
        }

        return false;
    }
627942
public function getStatus()
    {
        if (isset($this->_statuses[(int) $this->status])) {
            return $this->_statuses[(int) $this->status];
        }
        throw new \Exception('Status "' . $this->status . '" not found for Page with id ' . $this->id . '.');
    }
206044
public function getStatus()
    {
        $status_event = $this->call->startBatch([
            OP_RECV_STATUS_ON_CLIENT => true,
        ]);

        $this->trailing_metadata = $status_event->status->metadata;

        return $status_event->status;
    }
691046
public function onRead()
    {
        if ($this->state === self::STATE_PREHANDSHAKE) {
            if ($this->getInputLength() < 8) {
                return;
            }
            $this->key = $this->readUnlimited();
            $this->handshake();
        }
        if ($this->state === self::STATE_HANDSHAKED) {
            while (($buflen = $this->getInputLength()) >= 2) {
                $hdr = $this->look(10);
                $frametype = ord(mb_orig_substr($hdr, 0, 1));
                if (($frametype & 0x80) === 0x80) {
                    $len = 0;
                    $i = 0;
                    do {
                        if ($buflen < $i + 1) {
                            // not enough data yet
                            return;
                        }
                        $b = ord(mb_orig_substr($hdr, ++$i, 1));
                        $n = $b & 0x7F;
                        $len *= 0x80;
                        $len += $n;
                    } while ($b > 0x80);

                    if ($this->pool->maxAllowedPacket <= $len) {
                        // Too big packet
                        $this->finish();
                        return;
                    }

                    if ($buflen < $len + $i + 1) {
                        // not enough data yet
                        return;
                    }
                    $this->drain($i + 1);
                    $this->onFrame($this->read($len), 'BINARY');
                } else {
                    if (($p = $this->search("\xFF")) !== false) {
                        if ($this->pool->maxAllowedPacket <= $p - 1) {
                            // Too big packet
                            $this->finish();
                            return;
                        }
                        $this->drain(1);
                        $data = $this->read($p);
                        $this->drain(1);
                        $this->onFrame($data, 'STRING');
                    } else {
                        if ($this->pool->maxAllowedPacket < $buflen - 1) {
                            // Too big packet
                            $this->finish();
                            return;
                        }
                        // not enough data yet
                        return;
                    }
                }
            }
        }
    }
909582
public function is_finished() {

        if ($this->finished === null) {
            $endtime = $this->get_end();
            if ($endtime === 0 || $this->now < $endtime) {
                // It is not yet finished or no idea when it finishes.
                $this->finished = false;
            } else {
                $this->finished = true;
            }
        }

        return $this->finished;
    }
483713
public function getCurrentRound()
    {
        $isStop = false;
        $today  = new \Zend_Date();
        $tokens = $this->getTokens();
        $stop   = $this->util->getReceptionCodeLibrary()->getStopString();

        foreach ($tokens as $token) {
            $validUntil = $token->getValidUntil();

            if (! empty($validUntil) && $validUntil->isEarlier($today)) {
                continue;
            }

            if ($token->isCompleted()) {
                continue;
            }

            $code = $token->getReceptionCode();
            if (! $code->isSuccess()) {
                if ($code->getCode() === $stop) {
                    $isStop = true;
                }
                continue;
            }

            return $token->getRoundDescription();
        }
        if ($isStop) {
            return $this->translate->_('Track stopped');
        }

        return $this->translate->_('Track completed');
    }
49623
public function isComplete()
    {
        if (!$this->buffer) {
            return false;
        }

        try {
            return $this->getBufferLength() >= $this->getExpectedBufferLength();
        } catch (FrameException $e) {
            return false;
        }
    }
633403
public function status()
	{
		try
		{
			$pingRequest = $this->connection->createPing();
			$ping = $this->connection->ping($pingRequest);
			$pong = $ping->getData();
			$alive = false;

			if (isset($pong['status']) && $pong['status'] === "OK")
			{
				return true;
			}
		}
		catch (\Solarium\Exception $e)
		{
			return false;
		}
	}
1072086
protected function getCurrentFrame()
    {
        if (empty($this->frames)) {
            array_push($this->frames, $this->getFrame());
        }
        return end($this->frames);
    }
371936
public function getStatus()
    {
        if (!$this->entity->getStatus()) {
            return null;
        }

        return new ApiShippingStatus($this->entity->getStatus(), $this->locale);
    }
208807
public function bytesLeft(): int
    {
        if (null === $this->handle || !is_resource($this->handle)) {
            throw new \LogicException('Can not read from closed input stream.');
        }

        $bytesRead = ftell($this->handle);
        if (!is_int($bytesRead)) {
            return 0;
        }

        return $this->getResourceLength() - $bytesRead;
    }
544776
public boolean read()
    {
        if (state == State.READING_FRAME_SIZE)
        {
            // try to read the frame size completely
            if (!internalRead(frameSizeBuffer))
                return false;

            // if the frame size has been read completely, then prepare to read the
            // actual frame.
            if (frameSizeBuffer.remaining() == 0)
            {
                // pull out the frame size as an integer.
                int frameSize = frameSizeBuffer.getInt(0);

                if (frameSize <= 0)
                {
                    logger.error("Read an invalid frame size of " + frameSize + ". Are you using TFramedTransport on the client side?");
                    return false;
                }

                if (frameSize > thriftFactories.maxFrameSizeInBytes)
                {
                    logger.error("Invalid frame size got (" + frameSize + "), maximum expected " + thriftFactories.maxFrameSizeInBytes);
                    return false;
                }


                // reallocate to match frame size (if needed)
                reallocateDataBuffer(frameSize);

                frameSizeBuffer.clear(); // prepare it to the next round of reading (if any)

                state = State.READING_FRAME;
            }
            else
            {
                // this skips the check of READING_FRAME state below, since we can't
                // possibly go on to that state if there's data left to be read at
                // this one.
                state = State.READY_TO_READ_FRAME_SIZE;
                return true;
            }
        }

        // it is possible to fall through from the READING_FRAME_SIZE section
        // to READING_FRAME if there's already some frame data available once
        // READING_FRAME_SIZE is complete.

        if (state == State.READING_FRAME)
        {
            if (!internalRead(dataBuffer))
                return false;

            state = (dataBuffer.remaining() == 0)
                     ? State.READ_FRAME_COMPLETE
                     : State.READY_TO_READ_FRAME;

            // Do not read until we finish processing request.
            if (state == State.READ_FRAME_COMPLETE)
            {
                switchMode(State.READ_FRAME_COMPLETE);
            }

            return true;
        }

        // if we fall through to this point, then the state must be invalid.
        logger.error("Read was called but state is invalid (" + state + ")");
        return false;
    }
53315
function statusObject()
    {
        if ( $this->Status === null )
        {
            $this->Status = eZOrderStatus::fetchByStatus( $this->StatusID );
        }
        return $this->Status;
    }
1126945
public function getIsComplete ()
		{
			if ($this->_isComplete)
				return true;

			for ($i = 1; $i <= $this->_params[ 'totalChunks' ]; $i++)
			{
				if (!$this->chunkIsUploaded($i))
				{
					$this->_isComplete = false;

					return false;
				}
			}

			$this->_isComplete = true;

			return true;
		}
373371
public function getFrameCount()
    {
        if ($this->frameCount === null) {
            $this->frameCount = (int)($this->getDuration() * $this->getFrameRate());
        }

        return $this->frameCount;
    }
759430
protected function getStatus()
    {
        if (!$this->getModuleSetting('status')) {
            return false;
        }

        if ($this->getModuleSetting('test')) {
            return $this->getModuleSetting('test_key') && $this->getModuleSetting('test_public_key');
        }

        return $this->getModuleSetting('live_key') && $this->getModuleSetting('live_public_key');
    }
868173
public function getIsNew ()
		{
			if ($this->_isNew == false)
				return false;

			for ($i = 1; $i <= $this->_params[ 'totalChunks' ]; $i++)
			{
				if ($this->chunkIsUploaded($i))
				{
					$this->_isNew = false;

					return false;
				}
			}

			$this->_isNew = true;

			return true;
		}