/**
* Write data for key into cache
*
* @param string $key Identifier for the data
* @param mixed $data Data to be cached
* @return bool True if the data was successfully cached, false on failure
*/
public function write($key, $data)
{
if ($data === '' || !$this->_init) {
return false;
}
$key = $this->_key($key);
if ($this->_setKey($key, true) === false) {
return false;
}
$lineBreak = "\n";
if ($this->_config['isWindows']) {
$lineBreak = "\r\n";
}
if (!empty($this->_config['serialize'])) {
if ($this->_config['isWindows']) {
$data = str_replace('\\', '\\\\\\\\', serialize($data));
} else {
$data = serialize($data);
}
}
$duration = $this->_config['duration'];
$expires = time() + $duration;
$contents = $expires . $lineBreak . $data . $lineBreak;
if ($this->_config['lock']) {
$this->_File->flock(LOCK_EX);
}
$this->_File->rewind();
$success = $this->_File->ftruncate(0) && $this->_File->fwrite($contents) && $this->_File->fflush();
if ($this->_config['lock']) {
$this->_File->flock(LOCK_UN);
}
$this->_File = null;
return $success;
}
/**
* Truncates the collection, removing all the data from the file
*
* @return bool
*/
public function truncate()
{
$this->file->flock(LOCK_EX);
$result = $this->file->ftruncate(0);
$this->file->flock(LOCK_UN);
return $result;
}
public function write($key, $data, $cache_duration)
{
if ($data === '' || is_null($data) || !$this->is_init) {
return false;
}
if ($this->_openFile($key, true) === false) {
return false;
}
$line_break = "\n";
if ($this->settings['is_windows']) {
$lineBreak = "\r\n";
}
if (!empty($this->settings['serialize'])) {
if ($this->settings['is_windows']) {
$data = str_replace('\\', '\\\\\\\\', json_encode($data));
} else {
$data = json_encode($data);
}
}
$expires = time() + $cache_duration;
$contents = $expires . $line_break . $data . $line_break;
if ($this->settings['lock']) {
$this->file->flock(LOCK_EX);
}
$this->file->rewind();
$success = $this->file->ftruncate(0) && $this->file->fwrite($contents) && $this->file->fflush();
if ($this->settings['lock']) {
$this->file->flock(LOCK_UN);
}
return $success;
}
/**
* Saves the current connection to `$this->file` if set.
*/
public function __destruct()
{
if (isset($this->file) && $this->file->isWritable()) {
$this->file->ftruncate(0);
$this->file->rewind();
$this->file->fwrite($this->toJson());
}
}
private function _write()
{
$this->_file->ftruncate(0);
foreach ($this->_data as $domain => $stats) {
foreach ($stats as $date => $row) {
$this->_file->fputcsv([$domain, $date] + $row);
}
}
}
/**
* Free the used slots
*
* @param $sliced_report_definitions_count
*/
private function freeUsedRequestCount($sliced_report_definitions_count)
{
$this->file_counter->flock(LOCK_EX);
$this->file_counter->rewind();
$used_request_count = (int) $this->file_counter->fgets();
$new_used_request_count = $used_request_count - $sliced_report_definitions_count;
$this->file_counter->ftruncate(0);
$this->file_counter->fwrite($new_used_request_count);
$this->file_counter->flock(LOCK_UN);
}
public function finalizeFile(\SplFileObject $fileObject)
{
if ($this->headers !== null) {
// Create tmp file with header
$fd = fopen('php://temp', 'w+b');
fputcsv($fd, $this->headers);
// Copy file content into tmp file
$fileObject->rewind();
fwrite($fd, $fileObject->fread($fileObject->getSize()));
// Overwrite file content with tmp content
rewind($fd);
$fileObject->rewind();
$fileObject->fwrite(stream_get_contents($fd));
clearstatcache(true, $fileObject->getPathname());
fclose($fd);
}
// Remove last line feed
$fileObject->ftruncate($fileObject->getSize() - 1);
}
/**
* Writes the record data from memory into the file store.
*
* @return void
*/
public function save()
{
$tmpHandle = new \SplFileObject('php://temp', 'w+');
$tmpData = '';
$tmpHandle->fputcsv($this->model->columns());
foreach ($this->all() as $record) {
$tmpHandle->fputcsv($record->toArray());
$record->exists = true;
}
$tmpHandle->rewind();
while (!$tmpHandle->eof()) {
$tmpData .= $tmpHandle->fgets();
}
$this->file->flock(\LOCK_EX | \LOCK_NB);
$this->file->ftruncate(0);
$this->file->rewind();
$this->file->fwrite($tmpData);
$this->file->flock(\LOCK_UN);
}
<?php
set_include_path(dirname(dirname(__FILE__)));
$path = dirname(__FILE__) . DIRECTORY_SEPARATOR . 'fileobject_005.txt';
touch($path);
$fo = new SplFileObject('tests' . DIRECTORY_SEPARATOR . 'fileobject_005.txt', 'w+', true);
$fo->fwrite("blahlubba");
var_dump($fo->ftruncate(4));
$fo->rewind();
var_dump($fo->fgets(8));
$fo->rewind();
$fo->fwrite("blahlubba");
// This should throw a warning and return NULL since an argument is missing
var_dump($fo->ftruncate());
?>
==DONE==
<?php
//create a basic stream class
class VariableStream
{
var $position;
var $varname;
function stream_open($path, $mode, $options, &$opened_path)
{
return true;
}
function url_stat()
{
}
}
stream_wrapper_register("SPLtest", "VariableStream");
$ftruncate_test = "";
//end creating stream
//open an SplFileObject using the above test stream
$obj = new SplFileObject("SPLtest://ftruncate_test");
try {
$obj->ftruncate(1);
} catch (LogicException $e) {
echo $e->getMessage();
}
private function updateOrDelete($id, $data = null)
{
/* Thanks to https://www.daniweb.com/web-development/php/threads/102279/deleting-a-line-from-a-file#post1353582 */
/*
* Create a new SplFileObject representation of the file
* Open it for reading and writing and place the pointer at the beginning of the file
* @see fopen for additional modes
*/
$file = new \SplFileObject($this->filename, 'a+');
/*
* Set a bitmask of the flags to apply - Only relates to reading from file
* In this case SplFileObject::DROP_NEW_LINE to remove new line charachters
* and SplFileObject::SKIP_EMPTY to remove empty lines
*/
$file->setFlags(7);
/*
* Lock the file so no other user can interfere with reading and writing while we work with it
*/
$file->flock(LOCK_EX);
/*
* Create a SplTempFileObject
* 0 indicates not to use memory to store the temp file.
* This is probably slower than using memory, but for a large file it will be much more effective
* than loading the entire file into memory
* @see http://www.php.net/manual/en/spltempfileobject.construct.php for more details
*/
$temp = new \SplTempFileObject(0);
/*
* Lock the temp file just in case
*/
$temp->flock(LOCK_EX);
/*
* Iterate over each line of the file only loading one line into memory at any point in time
*/
foreach ($file as $key => $line) {
if ($key != $id) {
/*
* If this line does NOT match out delete write it to the temp file
* Append a line ending to it
*/
$temp->fwrite($line . PHP_EOL);
} else {
if ($data !== null) {
$temp->fwrite($data . PHP_EOL);
}
}
}
/*
* Truncate the existing file to 0
*/
$file->ftruncate(0);
/*
* Write the temp file back to the existing file
*/
foreach ($temp as $line) {
/*
* Iterate over temp file and put each line back into original file
*/
$file->fwrite($line);
}
/*
* Release the file locks
*/
$temp->flock(LOCK_UN);
$file->flock(LOCK_UN);
return true;
}
/**
* @return void
*/
public function testClear()
{
$filePath = __DIR__ . '/example_write1.txt';
$fileObject = new FileWriter($filePath, 'a+');
$fileObject->clear();
$filePath = __DIR__ . '/example_write2.txt';
$fileObject = new \SplFileObject($filePath, 'a+');
$fileObject->ftruncate(0);
}
private function bufferCallback($chunk, $flags)
{
$chunkSize = strlen($chunk);
if ($this->verbose) {
$level = ob_get_level();
$constants = array('PHP_OUTPUT_HANDLER_START', 'PHP_OUTPUT_HANDLER_WRITE', 'PHP_OUTPUT_HANDLER_FLUSH', 'PHP_OUTPUT_HANDLER_CLEAN', 'PHP_OUTPUT_HANDLER_FINAL');
$flagsText = '';
foreach ($constants as $i => $constant) {
if ($flags & ($value = constant($constant)) || $value == $flags) {
$flagsText .= (strlen($flagsText) ? ' | ' : '') . $constant . "[{$value}]";
}
}
$total = $this->bufferedCounter;
file_put_contents('php://stderr', sprintf("Buffer Callback: Chunk Size %s; Total %s; Flags %s (%s); Level %d\n", number_format($chunkSize), number_format($total + $chunkSize), $flags, $flagsText, $level));
}
if ($flags & PHP_OUTPUT_HANDLER_FINAL) {
return TRUE;
}
if ($flags & PHP_OUTPUT_HANDLER_START) {
$this->store->fseek(0, SEEK_END);
}
$chunkSize && $this->store->fwrite($chunk);
$this->bufferedCounter += $chunkSize;
if ($flags & PHP_OUTPUT_HANDLER_FLUSH) {
// there is nothing to d
}
if ($flags & PHP_OUTPUT_HANDLER_CLEAN) {
$this->store->ftruncate(0);
}
return "";
}
/**
* Compiles the javascript files for the passed shop template.
*
* @param $timestamp
* @param Shop\Template $template
* @param Shop\Shop $shop
*/
public function compileJavascript($timestamp, Shop\Template $template, Shop\Shop $shop)
{
if ($shop->getMain()) {
$shop = $shop->getMain();
}
$file = $this->pathResolver->getJsFilePath($shop, $timestamp);
$file = new \SplFileObject($file, "a");
if (!$file->flock(LOCK_EX)) {
return;
}
$file->ftruncate(0);
$settings = $this->service->getSystemConfiguration(AbstractQuery::HYDRATE_OBJECT);
$javascriptFiles = $this->collectJavascriptFiles($template, $shop);
$content = '';
foreach ($javascriptFiles as $jsFile) {
$content .= file_get_contents($jsFile) . "\n";
}
if ($settings->getCompressJs()) {
$content = $this->jsCompressor->compress($content);
}
$file->fwrite($content);
$file->flock(LOCK_UN);
// release the lock
}
