Get unzipped data. Will recursively unpack data until it looks like it's no longer gzipped

@return string
12818
public function getUnpacked() {
        $tries = 0;
        $obj = $this->_original;

        while ($this->_dataLooksZipped($obj)) {
            $unpacked = gzdecode($obj);
            if (null === $unpacked || false === $unpacked) {
                // If anything went wrong with decoding, return result of previous iteration
                return $obj;
            }
            $obj = $unpacked;

            $tries++;

            if ($this->_maxDepthReached($tries)) {
                // Zipped ridiculously deep? Screw that, return the original
                return $this->_original;
            }
        }
        return $obj;
    }
1008303
public function getEtags()
    {
        $etag = '';

        if ($this->data instanceof ArrayableInterface) {
            $this->data = $this->data->toArray();
        }

        foreach ( $this->data as $item ) {
            $item = new Resource($item);
            $etag .= $item->getEtag();
            unset($item);
        }

        return md5( $etag );
    }
10480
public function getData()
	{
		$data = $this->data;

		foreach ($data as $key => $value)
		{
			if (is_object($value) and $this->isWhitelisted($value))
			{
				continue;
			}

			if ($this->shouldBeFiltered($key))
			{
				if ($value instanceof Sanitize)
				{
					$data[$key] = $value->sanitize();
				}
				else
				{
					$data[$key] = $this->filter($value);
				}
			}
		}

		return $data;
	}
473242
function getData()
    {
        $buffer = 4096;

        // Return data stored in memory
        if (isset($this->_data)) {
            $tmp   = $this->_data;
            unset($this->_data);
            $fh    = $this->_filehandle;
            if ($this->_using_tmpfile) {
                fseek($fh, 0);
            }
            return $tmp;
        }
        // Return data stored on disk
        if ($this->_using_tmpfile) {
            if ($tmp = fread($this->_filehandle, $buffer)) {
                return $tmp;
            }
        }

        // No data to return
        return '';
    }
309673
public function getData()
    {
        if (is_null($this->data)) {
            $this->data = $this->index->getParser()->getData($this->getOffset());
            
        }
        return $this->data;
    }
981780
public function getBytes()
    {
        if ($this->isDirty && $this->bytes) {
            return $this->bytes;
        }
        if ($this->isDirty && $this->filename) {
            return file_get_contents($this->filename);
        }
        if ($this->mongoGridFSFile instanceof \MongoGridFSFile) {
            return $this->mongoGridFSFile->getBytes();
        }
        return null;
    }
1107371
public function read()
    {
        if ($this->data || !file_exists($this->filename)) {
            return $this->data;
        }

        return @unserialize(file_get_contents($this->filename)) ?: [];
    }
1125245
public function unescape()
 	{
		$length			= $this->getLength();
		$this->string	= stripslashes( $this->string );
		return $length - $this->getLength();
 	}
1131167
public function get_unlabelled_data() {
        // Delegates all processing to the analysis.
        $result = new \core_analytics\local\analysis\result_file($this->get_modelid(), false, $this->get_options());
        $analysis = new \core_analytics\analysis($this, false, $result);
        $analysis->run();
        return $result->get();
    }
35843
public function getETags()
    {
        $result = array();
        if($this->_headers->has('If-None-Match'))
        {
            $result = preg_split('/\s*,\s*/', $this->_headers->get('If-None-Match'), null, PREG_SPLIT_NO_EMPTY);

            //Remove the encoding from the etag
            //
            //RFC-7232 explicitly states that ETags should be content-coding aware
            $result = str_replace('-gzip', '', $result);
        }

        return $result;
    }
959995
public function get_data() {

		if ( empty( $this->data ) ) {
			$this->data = array(
				$this->slug => $this->get_child_data(),
			);
		}

		return $this->data;
	}
1140507
public function getData()
    {
        $relationObject = $this->ContentObjectAttribute->attribute( 'content' );

        if ( $relationObject instanceof eZContentObject )
        {
            return trim( $relationObject->attribute( 'name' ) );
        }

        return "";
    }
1343287
function file()
    {
        $data    = implode('', $this -> datasec);
        $ctrldir = implode('', $this -> ctrl_dir);

        return
            $data .
            $ctrldir .
            $this -> eof_ctrl_dir .
            pack('v', sizeof($this -> ctrl_dir)) .  // total # of entries "on this disk"
            pack('v', sizeof($this -> ctrl_dir)) .  // total # of entries overall
            pack('V', strlen($ctrldir)) .           // size of central dir
            pack('V', strlen($data)) .              // offset to start of central dir
            "\x00\x00";                             // .zip file comment length
    }
466174
public function unseal()
    {
        $file = $this->getVaultKeyFile();

        if (!file_exists($file)) {
            return $this->abort($file . ' does not exist - call "create" first');
        }

        $sysService = $this->sys();

        $sealed = $sysService->sealed();
        if (!$sealed) {
            return $this->success('Vault is unsealed');
        }

        $content = json_decode(file_get_contents($file), true);

        while ($sysService->sealed()) {
            $this->info('Unsealing with key ...');
            $sysService->unseal(['key' => array_pop($content['keys'])]);
        }

        $this->success('Vault has been unsealed successfully');
    }
783664
final protected function getData()
    {
        if ($this->storage->has($this->ns)) {
            return $this->storage->get($this->ns);
        } else {
            // If can't find in storage, then return default
            return $this->default;
        }
    }
452430
public function get_zip()
	{
		// Is there any data to return?
		if ($this->entries === 0)
		{
			return FALSE;
		}

		return $this->zipdata
			.$this->directory."\x50\x4b\x05\x06\x00\x00\x00\x00"
			.pack('v', $this->entries) // total # of entries "on this disk"
			.pack('v', $this->entries) // total # of entries overall
			.pack('V', strlen($this->directory)) // size of central dir
			.pack('V', strlen($this->zipdata)) // offset to start of central dir
			."\x00\x00"; // .zip file comment length
	}
445124
public function getData()
    {
        $fp = $this->getStream();
        $data = '';

        while (feof($fp) === false) {
            $data .= fread($fp, self::CHUNK_SIZE);
        }

        @fclose($fp);

        return $data;
    }