Read timestamps from either the fast cache, or the serialized file.

@return array An array of timestamps for build files.
348323
protected function _readTimestamp()
    {
        $data = array();
        if (empty($data) && file_exists($this->path . static::BUILD_TIME_FILE)) {
            $data = file_get_contents($this->path . static::BUILD_TIME_FILE);
            if ($data) {
                $data = unserialize($data);
            }
        }
        return $data;
    }
878142
function getTimestamps() {
					try {
						var trans = db.transaction(['save'], "read"),
						store = trans.objectStore('save'),
						request = store.getAll();
						request.onsuccess = function (e) {
							var i = 0, a = event.target.result, l = a.length;
							for (; i < l; i++) {
								timestamps[a[i].key] = a[i].timestamp;
							}
						};
					}
					catch (e) {
					}
				}
1314094
public function read(): array
    {
        if ( isset($this->data)) {
            return $this->data;
        }

        $this->data = [];
        foreach ($this->source as &$row) {
            //checking if the source corresponds to the wanted format
            if (array_filter($row, 'is_scalar') == $row) {
                $this->data[] = $row;
            }
        }

        return $this->data;
    }
696568
private function getRunTimes()
    {
        foreach (array_keys($this->jobs) as $interimName) {
            if (!$runEntity = $this->repository->getNextRunTime($interimName)) {
                $epoch = new \DateTime();
                $epoch->setTimestamp(0);
                $runEntity = new Entity\Cron(['interim' => $interimName, 'lastrun' => $epoch]);
            }

            $this->jobs[$interimName]['entity'] = $runEntity;
            $this->jobs[$interimName]['lastRunTime'] = $runEntity->getLastrun();
            $this->jobs[$interimName]['nextRunTime'] = $this->getNextRunTime($interimName, $runEntity);
        }
    }
363616
protected function readData() {
		$used = $this->readSize();
		return 0 === $used ? array() : json_decode($this->read(self::SHM_DATA_OFFSET, $used), true);
	}
796887
public function getAttributes(): array
    {
        $attributes = [];
        if (null !== $this->from) {
            $attributes['from'] = $this->from->getTimestamp();
        }
        return $attributes;
    }
897317
public function toTempData()
    {
        return [
            'type' => $this->sType,
            'name' => $this->sName,
            'filename' => $this->sFilename,
            'extension' => $this->sExtension,
            'size' => $this->sSize,
            'path' => $this->sPath,
        ];
    }
1297283
function get_timestamp() {
        if (!empty($this->timestamp)) {
            $timestamp = $this->timestamp;
            unset($this->timestamp);
            return $timestamp;
        }
        return time();
    }
692934
protected function read()
	{
		if( $this->useCache )
		{
			$fileName	= $this->pathCache.basename( $this->fileName ).".cache";
			if( file_exists( $fileName ) && file_exists( $this->fileName ) && filemtime( $fileName ) == filemtime( $this->pathConfig.$this->fileName ) )
			{
				return $this->readCache( $fileName );
			}
			else
			{
				$this->readWDDX();
				return $this->writeCache( $fileName );
			}
		}
		return $this->readWDDX();

	}
342867
public function readLog(): array
    {
        $logFilePath = $this->getLogFilePath();

        if (!file_exists($logFilePath)) {
            return [];
        }

        $data = @unserialize(file_get_contents($logFilePath));

        if (false === $data) {
            throw new \RuntimeException('Could not unserialize log file '.$logFilePath);
        }

        return (array) $data;
    }
581993
public function getModificationTime() {

		if(false !== $this -> file -> getExists()) {

			$this -> refresh();
			
			return $this -> file -> getModificationTime();
		}
	}
87420
protected function parseTransactionEntryTimestamp()
    {
        $results = [];
        if (preg_match('/^:60F:[C|D]([\d]{6})/m', $this->getCurrentStatementData(), $results) && !empty($results[1])) {
            return $this->sanitizeTimestamp($results[1]);
        }

        return 0;
    }
374226
public function cachedData()
    {
        if (!$this->isCached()) {
            return null;
        }

        $contents = file_get_contents($this->file);

        $serializationEnabled = static::config('serialize');

        $data = $serializationEnabled ? unserialize($contents) : $contents;

        return $data;
    }
611767
public function toArray(): array
    {
        return [
            'time_low'                  => $this->timeLow,
            'time_mid'                  => $this->timeMid,
            'time_hi_and_version'       => $this->timeHiAndVersion,
            'clock_seq_hi_and_reserved' => $this->clockSeqHiAndReserved,
            'clock_seq_low'             => $this->clockSeqLow,
            'node'                      => $this->node
        ];
    }
1214104
public function read()
    {
        $rarray = [];
        $count = 0;

        while ($data = fread($this->socket, 4)) {
            $data = unpack('V1Size', $data);

            if ($data['Size'] > 4096) {
                $packet = '';
                for ($i = 0; $i < 8; $i++) {
                    $packet .= "\x00";
                }
                $packet .= fread($this->socket, 4096);
            } else {
                $packet = fread($this->socket, $data['Size']);
            }

            $rarray[] = unpack('V1ID/V1Response/a*S1/a*S2', $packet);
        }

        return $rarray;
    }
1204033
public function updateCacheDetails()
    {
        $date         = $this->http->getDate(time());
        $maxAge       = $this->http->getMaxAge($this->defaultMaxAge);
        $lastModified = $this->http->getLastModified();

        $this->cache['Date']    = gmdate("D, d M Y H:i:s T", $date);
        $this->cache['Max-Age'] = $maxAge;

        if ($lastModified) {
            $this->cache['Last-Modified'] = gmdate("D, d M Y H:i:s T", $lastModified);
        }

        file_put_contents($this->fileJson, json_encode($this->cache));
        return $this->fileName;
    }
145403
private function readRoutineMetadata(): array
  {
    $data = file_get_contents($this->metadataFilename);

    $routines = (array)json_decode($data, true);
    if (json_last_error()!=JSON_ERROR_NONE)
    {
      throw new RuntimeException("Error decoding JSON: '%s'.", json_last_error_msg());
    }

    return $routines;
  }