Returns the stat information for the buffer

@return array
352738
public function getStat()
    {
        $stat   = array(
            'ino'       => 0,
            'mode'      => (array_key_exists('mode', $this->objectInfo)) ? $this->objectInfo['mode'] : 0,
            'nlink'     => 0,
            'uid'       => 0,
            'gid'       => 0,
            'rdev'      => 0,
            'size'      => (array_key_exists('size', $this->objectInfo)) ? $this->objectInfo['size'] : 0,
            'atime'     => 0,
            'mtime'     => 0,
            'ctime'     => 0,
            'blksize'   => -1,
            'blocks'    => -1,
        );
        return array_merge($stat, array_values($stat));
    }
708725
public function info()
    {
        $data = [];
        foreach ($this->attributes as $key => $value) {
            switch (gettype($value)) {
                case 'boolean':
                    $data[$key] = [
                        'boolValue' => $value
                    ];
                    break;
                case 'integer':
                    $data[$key] = [
                        'intValue' => $value
                    ];
                    break;
                default:
                    $data[$key] = [
                        'stringValue' => ['value' => (string) $value]
                    ];
            }
        }
        return [
            'attributeMap' => $data
        ];
    }
1360794
public function details()
  {
    $file = $this->file;

    if (file_exists($file)) {
      $data = unserialize($this->decrypt(file_get_contents($file)));

      return [
        'records' => count($data),
        'size' => round(filesize($file) / 1024, 1),
        'updated_at' => date('Y-m-d h:i:s', filemtime($file))
      ];
    }

    return null;
  }
830636
public function getEntityStatus()
    {
        $info = [];
        $entityClassNames = $this->entityManager->getConfiguration()->getMetadataDriverImpl()->getAllClassNames();
        foreach ($entityClassNames as $entityClassName) {
            try {
                $info[$entityClassName] = $this->entityManager->getClassMetadata($entityClassName);
            } catch (MappingException $e) {
                $info[$entityClassName] = $e->getMessage();
            }
        }

        return $info;
    }
540165
public function getStats() {

		$stats = array();

		foreach ( $this->caches as $cache ) {
			$stats[$cache->getName()] = $cache->getStats();
		}

		return $stats;
	}
1065359
private function getAllInfo()
    {
        $data = [];
        $history_area = $this->_parser->find('table', 0);
        if ($history_area) {
            foreach ($history_area->find('tr') as $history) {
                if ($history->find('td', 0)->class != 'borderClass') {
                    continue;
                }
                $h_temp = [];
                $name_area = $history->find('td', 0);

                $h_temp['id'] = $this->getId($name_area);
                $h_temp['title'] = $this->getTitle($name_area);
                $h_temp['type'] = $this->getType($name_area);
                $h_temp['progress'] = $this->getProgress($name_area);
                $h_temp['date'] = $this->getDate($history);

                $data[] = $h_temp;
            }
        }

        return $data;
    }
682009
public function _info()
    {
        $inf = array();
        $ar  = array();
        foreach ($this->attribs as $i => $a) {
            $ar[$i] = self::html_attr2str($a);
        }

        $inf['attribs']   = $ar;
        $inf['attrs']     = $this->attrs;
        $inf['idx_attr']  = $this->idx_attr;
        $inf['tag_idx']   = $this->tag_idx;
        $inf['attr_idx']  = $this->attr_idx;
        $inf['class_idx'] = $this->class_idx;

        $lev = array();
        $nm  = array();
        $st  = array();
        $pb  = -1;
        $pe  = PHP_INT_MAX;
        $l   = 0;
        foreach ($this->ids as $b => $e) {
            if ($pb < $b && $b < $pe) {
                $st[]          = array($pb, $pe);
                list($pb, $pe) = array($b, $e);
            } else {
                while ($pe < $b && $st) {
                    list($pb, $pe) = array_pop($st);
                }
            }

            $nm[$b]  = $this->tags[$b];
            $lev[$b] = count($st);
        }
        foreach ($nm as $b => &$n) {
            $n = str_repeat(' -', $lev[$b]) . ' < ' . $n . ' ' . $this->get_attr_byId($b, null, true) . ' >';
        }
        $nm           = implode("\n", $nm);
        $inf['struc'] = $nm;
        unset($lev, $st, $nm);
        return $inf;
    }
1124956
protected function getPropStats(): array
    {
        $result = [];
        $failed = false;
        
        foreach ($this->proppatch->getOperations() as $operation) {
            $tmp = $operation->getResult();
            
            if (is_integer($tmp)) {
                if (empty($result[$tmp])) {
                    $result[$tmp] = [];
                }
                
                $result[$tmp][] = $operation;
            } elseif ($tmp instanceof HttpException) {
                $tmp = $tmp->getCode();
                
                if (empty($result[$tmp])) {
                    $result[$tmp] = [];
                }
                
                $result[$tmp][] = $operation;
            } else {
                $tmp = WebDav::CODE_CONFLICT;
                
                if (empty($result[$tmp])) {
                    $result[$tmp];
                }
                
                $result[$tmp][] = $operation;
            }
            
            if ($tmp != WebDav::CODE_OK) {
                $failed = true;
            }
        }
        
        if ($failed && !empty($result[WebDav::CODE_OK])) {
            if (empty($result[WebDav::CODE_FAILED_DEPENDENCY])) {
                $result[WebDav::CODE_FAILED_DEPENDENCY] = [];
            }
            
            foreach ($result[WebDav::CODE_OK] as $operation) {
                $result[WebDav::CODE_FAILED_DEPENDENCY][] = $operation;
            }
            
            unset($result[WebDav::CODE_OK]);
        }
        
        ksort($result, SORT_NUMERIC);
        
        return $result;
    }
58228
public function getStatusRules()
    {
        if (!is_string($this->statusAttribute) || empty($this->statusAttribute)) {
            return [];
        }
        if (empty($this->statusRules)) {
            $this->statusRules = [
                [[$this->statusAttribute], 'required'],
                [[$this->statusAttribute], 'number', 'integerOnly' => true, 'min' => 0],
            ];
        }
        return $this->statusRules;
    }
767622
public function stats() {
		$keys = [];
		$keys['unused_valid'] = $this->find('count', ['conditions' => [$this->getAlias() . '.used' => 0, $this->getAlias() . '.created >=' => date(FORMAT_DB_DATETIME, time() - $this->validity)]]);
		$keys['used_valid'] = $this->find('count', ['conditions' => [$this->getAlias() . '.used' => 1, $this->getAlias() . '.created >=' => date(FORMAT_DB_DATETIME, time() - $this->validity)]]);

		$keys['unused_invalid'] = $this->find('count', ['conditions' => [$this->getAlias() . '.used' => 0, $this->getAlias() . '.created <' => date(FORMAT_DB_DATETIME, time() - $this->validity)]]);
		$keys['used_invalid'] = $this->find('count', ['conditions' => [$this->getAlias() . '.used' => 1, $this->getAlias() . '.created <' => date(FORMAT_DB_DATETIME, time() - $this->validity)]]);

		$types = $this->find('all', ['conditions' => [], 'fields' => ['DISTINCT type']])->toArray();
		$keys['types'] = !empty($types) ? Hash::extract($types, '{n}.type') : [];
		return $keys;
	}
296953
public function getStatus() : array
    {
        return [
            'status'        => [
                'entries-stored' => \count($this->store),
                'accessed'       => $this->readCount,
                'removed'        => $this->removeCount,
                'written'        => $this->writeCount,
            ],
        ];
    }
159255
public function getFileInfo()
    {
        return array(
            "originalName" => $this->oriName ,
            "name" => $this->fileName ,
            "url" => $this->fullName ,
            "size" => $this->fileSize ,
            "type" => $this->fileType ,
            "state" => $this->stateInfo
        );
    }
278810
public function getStatusSummary()
    {
        $map = [
            'total' => Slave::ANY,
            'ready' => Slave::READY,
            'busy' => Slave::BUSY,
            'created' => Slave::CREATED,
            'registered' => Slave::REGISTERED,
            'closed' => Slave::CLOSED
        ];

        return array_map(function ($state) {
            return count($this->getByStatus($state));
        }, $map);
    }
1223082
protected final function getPoolDebugInfo()
	{
		return [
			'debug'              => $this->debug ? 1 : 0,
			'size'               => $this->size,
			'max_size'           => $this->maxSize,
			'being_created_size' => $this->beingCreatedSize,
			'max_uuid'           => $this->uuid,
			'idle_count'         => $this->idleQueue->count(),
			'task_count'         => $this->taskQueue->count(),
			'average_idle'       => $this->averageIdle,
			'gc'                 => $this->gc,
		];
	}
214251
private function getBatchInfos()
    {
        return array(
            'DelayMs' => $this->getDelayStarted(),
            'DelayStr' => sprintf('%.2f %s', $this->getDelayStarted(), ' ms'),
            'Performed' => $this->count,
            'Ok' => $this->success,
        );
    }
609170
public function stats()
    {
        if ($this->_stats !== null) {
            return $this->_stats;
        }

        Suite::push($this);

        $builder = function ($block) {
            $block->load();
            $normal = 0;
            $inactive = 0;
            $focused = 0;
            $excluded = 0;

            foreach ($block->children() as $child) {
                if ($block->excluded()) {
                    $child->type('exclude');
                }
                if ($child instanceof Group) {
                    $result = $child->stats();
                    if ($child->focused() && !$result['focused']) {
                        $focused += $result['normal'];
                        $excluded += $result['excluded'];
                        $child->broadcastFocus();
                    } elseif (!$child->enabled()) {
                        $inactive += $result['normal'];
                        $focused += $result['focused'];
                        $excluded += $result['excluded'];
                    } else {
                        $normal += $result['normal'];
                        $focused += $result['focused'];
                        $excluded += $result['excluded'];
                    }
                } else {
                    switch ($child->type()) {
                        case 'exclude':
                            $excluded++;
                            break;
                        case 'focus':
                            $focused++;
                            break;
                        default:
                            $normal++;
                            break;
                    }
                }
            }
            return compact('normal', 'inactive', 'focused', 'excluded');
        };

        if (Suite::$PHP >= 7 && !defined('HHVM_VERSION')) {
            try {
                $stats = $builder($this);
            } catch (Throwable $exception) {
                $this->log()->type('errored');
                $this->log()->exception($exception);

                $stats = [
                    'normal' => 0,
                    'focused' => 0,
                    'excluded' => 0
                ];
            }
        } else {
            $stats = $builder($this);
        }

        Suite::pop();
        return $stats;
    }
272695
public function stream_stat()
    {

        try {
            $file = $this->currentlyOpenedFile->getFile();

            return array_merge($this->getStatArray(), array(
                'mode' => $file->mode(),
                'uid' => $file->user(),
                'gid' => $file->group(),
                'atime' => $file->atime(),
                'mtime' => $file->mtime(),
                'ctime' => $file->ctime(),
                'size' => $file->size()
            ));
        } catch (NotFoundException $e) {
            return false;
        }
    }