mirror of
https://github.com/Lastorder-DC/rhymix.git
synced 2026-01-07 18:51:41 +09:00
3f7330fde7
git-svn-id: http://xe-core.googlecode.com/svn/trunk@8245 201d5d3c-b55e-5fd7-737f-ddc643e51545
677 lines
No EOL
26 KiB
PHP
677 lines
No EOL
26 KiB
PHP
<?php
|
|
/**
|
|
* @class FileHandler
|
|
* @author NHN (developers@xpressengine.com)
|
|
* @brief contains methods for accessing file system
|
|
**/
|
|
|
|
class FileHandler extends Handler {
|
|
/**
|
|
* @brief changes path of target file, directory into absolute path
|
|
* @param[in] $source path
|
|
* @return absolute path
|
|
**/
|
|
function getRealPath($source) {
|
|
$temp = explode('/', $source);
|
|
if($temp[0] == '.') $source = _XE_PATH_.substr($source, 2);
|
|
return $source;
|
|
}
|
|
|
|
/**
|
|
* @brief copy a directory to target
|
|
* @param[in] $source_dir path of source directory
|
|
* @param[in] $target_dir path of target dir
|
|
* @param[in] $filter
|
|
* @param[in] $type
|
|
* @remarks if target directory does not exist, this function creates it
|
|
* @return none
|
|
**/
|
|
function copyDir($source_dir, $target_dir, $filter=null,$type=null){
|
|
$source_dir = FileHandler::getRealPath($source_dir);
|
|
$target_dir = FileHandler::getRealPath($target_dir);
|
|
if(!is_dir($source_dir)) return false;
|
|
|
|
// target이 없을땐 생성
|
|
if(!file_exists($target_dir)) FileHandler::makeDir($target_dir);
|
|
|
|
if(substr($source_dir, -1) != '/') $source_dir .= '/';
|
|
if(substr($target_dir, -1) != '/') $target_dir .= '/';
|
|
|
|
$oDir = dir($source_dir);
|
|
while($file = $oDir->read()) {
|
|
if(substr($file,0,1)=='.') continue;
|
|
if($filter && preg_match($filter, $file)) continue;
|
|
if(is_dir($source_dir.$file)){
|
|
FileHandler::copyDir($source_dir.$file,$target_dir.$file,$type);
|
|
}else{
|
|
if($type == 'force'){
|
|
@unlink($target_dir.$file);
|
|
}else{
|
|
if(!file_exists($target_dir.$file)) @copy($source_dir.$file,$target_dir.$file);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief copy a file to target
|
|
* @param[in] $source path of source file
|
|
* @param[in] $target path of target file
|
|
* @param[in] $force Y: overwrite
|
|
* @return none
|
|
**/
|
|
function copyFile($source, $target, $force='Y'){
|
|
setlocale(LC_CTYPE, 'en_US.UTF8', 'ko_KR.UTF8');
|
|
$source = FileHandler::getRealPath($source);
|
|
$target_dir = FileHandler::getRealPath(dirname($target));
|
|
$target = basename($target);
|
|
if(!file_exists($target_dir)) FileHandler::makeDir($target_dir);
|
|
if($force=='Y') @unlink($target_dir.'/'.$target);
|
|
@copy($source, $target_dir.'/'.$target);
|
|
}
|
|
|
|
/**
|
|
* @brief returns the content of the file
|
|
* @param[in] $file_name path of target file
|
|
* @return the content of the file. if target file does not exist, this function returns nothing.
|
|
**/
|
|
function readFile($file_name) {
|
|
$file_name = FileHandler::getRealPath($file_name);
|
|
|
|
if(!file_exists($file_name)) return;
|
|
$filesize = filesize($file_name);
|
|
if($filesize<1) return;
|
|
|
|
if(function_exists('file_get_contents')) return file_get_contents($file_name);
|
|
|
|
$fp = fopen($file_name, "r");
|
|
$buff = '';
|
|
if($fp) {
|
|
while(!feof($fp) && strlen($buff)<=$filesize) {
|
|
$str = fgets($fp, 1024);
|
|
$buff .= $str;
|
|
}
|
|
fclose($fp);
|
|
}
|
|
return $buff;
|
|
}
|
|
|
|
/**
|
|
* @brief write $buff into the specified file
|
|
* @param[in] $file_name path of target file
|
|
* @param[in] $buff content to be writeen
|
|
* @param[in] $mode a(append) / w(write)
|
|
* @return none
|
|
**/
|
|
function writeFile($file_name, $buff, $mode = "w") {
|
|
$file_name = FileHandler::getRealPath($file_name);
|
|
|
|
$pathinfo = pathinfo($file_name);
|
|
$path = $pathinfo['dirname'];
|
|
if(!is_dir($path)) FileHandler::makeDir($path);
|
|
|
|
$mode = strtolower($mode);
|
|
if($mode != "a") $mode = "w";
|
|
if(@!$fp = fopen($file_name,$mode)) return false;
|
|
fwrite($fp, $buff);
|
|
fclose($fp);
|
|
@chmod($file_name, 0644);
|
|
}
|
|
|
|
/**
|
|
* @brief remove a file
|
|
* @param[in] $file_name path of target file
|
|
* @return returns true on success or false on failure.
|
|
**/
|
|
function removeFile($file_name) {
|
|
$file_name = FileHandler::getRealPath($file_name);
|
|
return (file_exists($file_name) && @unlink($file_name));
|
|
}
|
|
|
|
/**
|
|
* @brief rename a file
|
|
* @param[in] $source path of source file
|
|
* @param[in] $target path of target file
|
|
* @remarks In order to move a file, use this function.
|
|
* @return returns true on success or false on failure.
|
|
**/
|
|
function rename($source, $target) {
|
|
$source = FileHandler::getRealPath($source);
|
|
$target = FileHandler::getRealPath($target);
|
|
return @rename($source, $target);
|
|
}
|
|
|
|
/**
|
|
* @brief Move a file
|
|
* @param[in] $source path of source file
|
|
* @param[in] $target path of target file
|
|
* @return returns true on success or false on failure.
|
|
*/
|
|
function moveFile($source, $target) {
|
|
$source = FileHandler::getRealPath($source);
|
|
return (file_exists($source) && FileHandler::removeFile($target) && FileHandler::rename($source, $target));
|
|
}
|
|
|
|
/**
|
|
* @brief move a directory
|
|
* @param[in] $source_dir path of source directory
|
|
* @param[in] $target_dir path of target directory
|
|
* @remarks this function just wraps rename function.
|
|
* @return none
|
|
**/
|
|
function moveDir($source_dir, $target_dir) {
|
|
FileHandler::rename($source_dir, $target_dir);
|
|
}
|
|
|
|
/**
|
|
* @brief return list of the files in the path
|
|
* @param[in] $path path of target directory
|
|
* @param[in] $filter if specified, return only files matching with the filter
|
|
* @param[in] $to_lower if true, file names will be changed into lower case.
|
|
* @param[in] $concat_prefix if true, return file name as absolute path
|
|
* @remarks the array does not contain files, such as '.', '..', and files starting with '.'
|
|
* @return array of the filenames in the path
|
|
**/
|
|
function readDir($path, $filter = '', $to_lower = false, $concat_prefix = false) {
|
|
$path = FileHandler::getRealPath($path);
|
|
|
|
if(substr($path,-1)!='/') $path .= '/';
|
|
if(!is_dir($path)) return array();
|
|
|
|
$oDir = dir($path);
|
|
while($file = $oDir->read()) {
|
|
if(substr($file,0,1)=='.') continue;
|
|
|
|
if($filter && !preg_match($filter, $file)) continue;
|
|
|
|
if($to_lower) $file = strtolower($file);
|
|
|
|
if($filter) $file = preg_replace($filter, '$1', $file);
|
|
else $file = $file;
|
|
|
|
if($concat_prefix) {
|
|
$file = sprintf('%s%s', str_replace(_XE_PATH_, '', $path), $file);
|
|
}
|
|
|
|
$output[] = $file;
|
|
}
|
|
if(!$output) return array();
|
|
|
|
return $output;
|
|
}
|
|
|
|
/**
|
|
* @brief creates a directory
|
|
* @param[in] $path_string path of target directory
|
|
* @return true if success. it might return nothing when ftp is used and connection to the ftp address failed.
|
|
* @remarks This function creates directories recursively, which means that if ancestors of the target directory does not exist, they will be created too.
|
|
**/
|
|
function makeDir($path_string) {
|
|
static $oFtp = null;
|
|
|
|
// if safe_mode is on, use FTP
|
|
if(ini_get('safe_mode')) {
|
|
$ftp_info = Context::getFTPInfo();
|
|
if($oFtp == null) {
|
|
if(!Context::isFTPRegisted()) return;
|
|
|
|
require_once(_XE_PATH_.'libs/ftp.class.php');
|
|
$oFtp = new ftp();
|
|
if(!$ftp_info->ftp_host) $ftp_info->ftp_host = "127.0.0.1";
|
|
if(!$ftp_info->ftp_port) $ftp_info->ftp_port = 21;
|
|
if(!$oFtp->ftp_connect($ftp_info->ftp_host, $ftp_info->ftp_port)) return;
|
|
if(!$oFtp->ftp_login($ftp_info->ftp_user, $ftp_info->ftp_password)) {
|
|
$oFtp->ftp_quit();
|
|
return;
|
|
}
|
|
}
|
|
$ftp_path = $ftp_info->ftp_root_path;
|
|
if(!$ftp_path) $ftp_path = "/";
|
|
}
|
|
|
|
$path_string = str_replace(_XE_PATH_,'',$path_string);
|
|
$path_list = explode('/', $path_string);
|
|
|
|
$path = _XE_PATH_;
|
|
for($i=0;$i<count($path_list);$i++) {
|
|
if(!$path_list[$i]) continue;
|
|
$path .= $path_list[$i].'/';
|
|
$ftp_path .= $path_list[$i].'/';
|
|
if(!is_dir($path)) {
|
|
if(ini_get('safe_mode')) {
|
|
$oFtp->ftp_mkdir($ftp_path);
|
|
$oFtp->ftp_site("CHMOD 777 ".$ftp_path);
|
|
} else {
|
|
@mkdir($path, 0755);
|
|
@chmod($path, 0755);
|
|
}
|
|
}
|
|
}
|
|
|
|
return is_dir($path_string);
|
|
}
|
|
|
|
/**
|
|
* @brief remove all files under the path
|
|
* @param[in] $path path of the target directory
|
|
* @return none
|
|
**/
|
|
function removeDir($path) {
|
|
$path = FileHandler::getRealPath($path);
|
|
if(!is_dir($path)) return;
|
|
$directory = dir($path);
|
|
while($entry = $directory->read()) {
|
|
if ($entry != "." && $entry != "..") {
|
|
if (is_dir($path."/".$entry)) {
|
|
FileHandler::removeDir($path."/".$entry);
|
|
} else {
|
|
@unlink($path."/".$entry);
|
|
}
|
|
}
|
|
}
|
|
$directory->close();
|
|
@rmdir($path);
|
|
}
|
|
|
|
/**
|
|
* @brief remove a directory only if it is empty
|
|
* @param[in] $path path of the target directory
|
|
* @return none
|
|
**/
|
|
function removeBlankDir($path) {
|
|
$item_cnt = 0;
|
|
|
|
$path = FileHandler::getRealPath($path);
|
|
if(!is_dir($path)) return;
|
|
$directory = dir($path);
|
|
while($entry = $directory->read()) {
|
|
if ($entry == "." || $entry == "..") continue;
|
|
if (is_dir($path."/".$entry)) $item_cnt = FileHandler::removeBlankDir($path.'/'.$entry);
|
|
}
|
|
$directory->close();
|
|
|
|
if($item_cnt < 1) @rmdir($path);
|
|
}
|
|
|
|
|
|
/**
|
|
* @biref remove files in the target directory.
|
|
* @param[in] $path path of the target directory
|
|
* @remarks This function keeps the directory structure.
|
|
* @return none
|
|
**/
|
|
function removeFilesInDir($path) {
|
|
$path = FileHandler::getRealPath($path);
|
|
if(!is_dir($path)) return;
|
|
$directory = dir($path);
|
|
while($entry = $directory->read()) {
|
|
if ($entry != "." && $entry != "..") {
|
|
if (is_dir($path."/".$entry)) {
|
|
FileHandler::removeFilesInDir($path."/".$entry);
|
|
} else {
|
|
@unlink($path."/".$entry);
|
|
}
|
|
}
|
|
}
|
|
$directory->close();
|
|
}
|
|
|
|
/**
|
|
* @brief makes file size byte into KB, MB according to the size
|
|
* @param[in] $size number of the size
|
|
* @return file size string
|
|
**/
|
|
function filesize($size) {
|
|
if(!$size) return "0Byte";
|
|
if($size < 1024) return ($size."Byte");
|
|
if($size >= 1024 && $size < 1024*1024) return sprintf("%0.1fKB",$size / 1024);
|
|
return sprintf("%0.2fMB",$size / (1024*1024));
|
|
}
|
|
|
|
/**
|
|
* @brief return remote file's content via HTTP
|
|
* @param[in] $url the address of the target file
|
|
* @param[in] $body HTTP request body
|
|
* @param[in] $timeout connection timeout
|
|
* @param[in] $method GET/POST
|
|
* @param[in] $content_type content type header of HTTP request
|
|
* @param[in] $headers headers key vaule array.
|
|
* @param[in] $cookies cookies key value array.
|
|
* @param[in] $post_data request arguments array for POST method
|
|
* @return if success, the content of the target file. otherwise: none
|
|
* @remarks if the target is moved (when return code is 300~399), this function follows the location specified response header.
|
|
**/
|
|
function getRemoteResource($url, $body = null, $timeout = 3, $method = 'GET', $content_type = null, $headers = array(), $cookies = array(), $post_data = array()) {
|
|
requirePear();
|
|
require_once('HTTP/Request.php');
|
|
|
|
$parsed_url = parse_url(__PROXY_SERVER__);
|
|
if($parsed_url["host"]) {
|
|
$oRequest = new HTTP_Request(__PROXY_SERVER__);
|
|
$oRequest->setMethod('POST');
|
|
$oRequest->_timeout = $timeout;
|
|
$oRequest->addPostData('arg', serialize(array('Destination'=>$url, 'method'=>$method, 'body'=>$body, 'content_type'=>$content_type, "headers"=>$headers, "post_data"=>$post_data)));
|
|
} else {
|
|
$oRequest = new HTTP_Request($url);
|
|
if(count($headers)) {
|
|
foreach($headers as $key => $val) {
|
|
$oRequest->addHeader($key, $val);
|
|
}
|
|
}
|
|
if($cookies[$host]) {
|
|
foreach($cookies[$host] as $key => $val) {
|
|
$oRequest->addCookie($key, $val);
|
|
}
|
|
}
|
|
if(count($post_data)) {
|
|
foreach($post_data as $key => $val) {
|
|
$oRequest->addPostData($key, $val);
|
|
}
|
|
}
|
|
if(!$content_type) $oRequest->addHeader('Content-Type', 'text/html');
|
|
else $oRequest->addHeader('Content-Type', $content_type);
|
|
$oRequest->setMethod($method);
|
|
if($body) $oRequest->setBody($body);
|
|
|
|
$oRequest->_timeout = $timeout;
|
|
}
|
|
|
|
$oResponse = $oRequest->sendRequest();
|
|
|
|
$code = $oRequest->getResponseCode();
|
|
$header = $oRequest->getResponseHeader();
|
|
$response = $oRequest->getResponseBody();
|
|
if($c = $oRequest->getResponseCookies()) {
|
|
foreach($c as $k => $v) {
|
|
$cookies[$host][$v['name']] = $v['value'];
|
|
}
|
|
}
|
|
|
|
if($code > 300 && $code < 399 && $header['location']) {
|
|
return FileHandler::getRemoteResource($header['location'], $body, $timeout, $method, $content_type, $headers, $cookies, $post_data);
|
|
}
|
|
|
|
if($code != 200) return;
|
|
|
|
return $response;
|
|
}
|
|
|
|
/**
|
|
* @brief retrieves remote file, then stores it into target path.
|
|
* @param[in] $url the address of the target file
|
|
* @param[in] $target_file the location to store
|
|
* @param[in] $body HTTP request body
|
|
* @param[in] $timeout connection timeout
|
|
* @param[in] $method GET/POST
|
|
* @param[in] $content_type content type header of HTTP request
|
|
* @param[in] $headers headers key vaule array.
|
|
* @return true: success, false: failed
|
|
**/
|
|
function getRemoteFile($url, $target_filename, $body = null, $timeout = 3, $method = 'GET', $content_type = null, $headers = array()) {
|
|
$body = FileHandler::getRemoteResource($url, $body, $timeout, $method, $content_type, $headers);
|
|
if(!$body) return false;
|
|
$target_filename = FileHandler::getRealPath($target_filename);
|
|
FileHandler::writeFile($target_filename, $body);
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* @brief convert size in string into numeric value
|
|
* @param[in] $val size in string (ex., 10, 10K, 10M, 10G )
|
|
* @return converted size
|
|
*/
|
|
function returnBytes($val)
|
|
{
|
|
$val = trim($val);
|
|
$last = strtolower(substr($val, -1));
|
|
if($last == 'g') $val *= 1024*1024*1024;
|
|
else if($last == 'm') $val *= 1024*1024;
|
|
else if($last == 'k') $val *= 1024;
|
|
|
|
return $val;
|
|
}
|
|
|
|
/**
|
|
* @brief check available memory to load image file
|
|
* @param[in] $imageInfo image info retrieved by getimagesize function
|
|
* @return true: it's ok, false: otherwise
|
|
*/
|
|
function checkMemoryLoadImage(&$imageInfo)
|
|
{
|
|
if(!function_exists('memory_get_usage')) return true;
|
|
$K64 = 65536;
|
|
$TWEAKFACTOR = 2.0;
|
|
$channels = $imageInfo['channels'];
|
|
if(!$channels) $channels = 6; //for png
|
|
$memoryNeeded = round( ($imageInfo[0] * $imageInfo[1] * $imageInfo['bits'] * $channels / 8 + $K64 ) * $TWEAKFACTOR );
|
|
$availableMemory = FileHandler::returnBytes(ini_get('memory_limit')) - memory_get_usage();
|
|
if($availableMemory < $memoryNeeded) return false;
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* @brief moves an image file (resizing is possible)
|
|
* @param[in] $source_file path of the source file
|
|
* @param[in] $target_file path of the target file
|
|
* @param[in] $resize_width width to resize
|
|
* @param[in] $resize_height height to resize
|
|
* @param[in] $target_type if $target_type is set (gif, jpg, png, bmp), result image will be saved as target type
|
|
* @param[in] $thumbnail_type thumbnail type(crop, ratio)
|
|
* @return true: success, false: failed
|
|
**/
|
|
function createImageFile($source_file, $target_file, $resize_width = 0, $resize_height = 0, $target_type = '', $thumbnail_type = 'crop') {
|
|
$source_file = FileHandler::getRealPath($source_file);
|
|
$target_file = FileHandler::getRealPath($target_file);
|
|
|
|
if(!file_exists($source_file)) return;
|
|
if(!$resize_width) $resize_width = 100;
|
|
if(!$resize_height) $resize_height = $resize_width;
|
|
|
|
// retrieve source image's information
|
|
$imageInfo = getimagesize($source_file);
|
|
if(!FileHandler::checkMemoryLoadImage($imageInfo)) return false;
|
|
list($width, $height, $type, $attrs) = $imageInfo;
|
|
|
|
if($width<1 || $height<1) return;
|
|
|
|
switch($type) {
|
|
case '1' :
|
|
$type = 'gif';
|
|
break;
|
|
case '2' :
|
|
$type = 'jpg';
|
|
break;
|
|
case '3' :
|
|
$type = 'png';
|
|
break;
|
|
case '6' :
|
|
$type = 'bmp';
|
|
break;
|
|
default :
|
|
return;
|
|
break;
|
|
}
|
|
|
|
// if original image is larger than specified size to resize, calculate the ratio
|
|
if($resize_width > 0 && $width >= $resize_width) $width_per = $resize_width / $width;
|
|
else $width_per = 1;
|
|
|
|
if($resize_height>0 && $height >= $resize_height) $height_per = $resize_height / $height;
|
|
else $height_per = 1;
|
|
|
|
if($thumbnail_type == 'ratio') {
|
|
if($width_per>$height_per) $per = $height_per;
|
|
else $per = $width_per;
|
|
$resize_width = $width * $per;
|
|
$resize_height = $height * $per;
|
|
} else {
|
|
if($width_per < $height_per) $per = $height_per;
|
|
else $per = $width_per;
|
|
}
|
|
|
|
if(!$per) $per = 1;
|
|
|
|
// get type of target file
|
|
if(!$target_type) $target_type = $type;
|
|
$target_type = strtolower($target_type);
|
|
|
|
// create temporary image with target size
|
|
if(function_exists('imagecreatetruecolor')) $thumb = imagecreatetruecolor($resize_width, $resize_height);
|
|
else if(function_exists('imagecreate')) $thumb = imagecreate($resize_width, $resize_height);
|
|
else return false;
|
|
if(!$thumb) return false;
|
|
|
|
$white = imagecolorallocate($thumb, 255,255,255);
|
|
imagefilledrectangle($thumb,0,0,$resize_width-1,$resize_height-1,$white);
|
|
|
|
// create temporary image having original type
|
|
switch($type) {
|
|
case 'gif' :
|
|
if(!function_exists('imagecreatefromgif')) return false;
|
|
$source = imagecreatefromgif($source_file);
|
|
break;
|
|
// jpg
|
|
case 'jpeg' :
|
|
case 'jpg' :
|
|
if(!function_exists('imagecreatefromjpeg')) return false;
|
|
$source = imagecreatefromjpeg($source_file);
|
|
break;
|
|
// png
|
|
case 'png' :
|
|
if(!function_exists('imagecreatefrompng')) return false;
|
|
$source = imagecreatefrompng($source_file);
|
|
break;
|
|
// bmp
|
|
case 'wbmp' :
|
|
case 'bmp' :
|
|
if(!function_exists('imagecreatefromwbmp')) return false;
|
|
$source = imagecreatefromwbmp($source_file);
|
|
break;
|
|
default :
|
|
return;
|
|
}
|
|
|
|
// resize original image and put it into temporary image
|
|
$new_width = (int)($width * $per);
|
|
$new_height = (int)($height * $per);
|
|
|
|
if($thumbnail_type == 'crop') {
|
|
$x = (int)($resize_width/2 - $new_width/2);
|
|
$y = (int)($resize_height/2 - $new_height/2);
|
|
} else {
|
|
$x = 0;
|
|
$y = 0;
|
|
}
|
|
|
|
if($source) {
|
|
if(function_exists('imagecopyresampled')) imagecopyresampled($thumb, $source, $x, $y, 0, 0, $new_width, $new_height, $width, $height);
|
|
else imagecopyresized($thumb, $source, $x, $y, 0, 0, $new_width, $new_height, $width, $height);
|
|
} else return false;
|
|
|
|
// create directory
|
|
$path = dirname($target_file);
|
|
if(!is_dir($path)) FileHandler::makeDir($path);
|
|
|
|
// write into the file
|
|
switch($target_type) {
|
|
case 'gif' :
|
|
if(!function_exists('imagegif')) return false;
|
|
$output = imagegif($thumb, $target_file);
|
|
break;
|
|
case 'jpeg' :
|
|
case 'jpg' :
|
|
if(!function_exists('imagejpeg')) return false;
|
|
$output = imagejpeg($thumb, $target_file, 100);
|
|
break;
|
|
case 'png' :
|
|
if(!function_exists('imagepng')) return false;
|
|
$output = imagepng($thumb, $target_file, 9);
|
|
break;
|
|
case 'wbmp' :
|
|
case 'bmp' :
|
|
if(!function_exists('imagewbmp')) return false;
|
|
$output = imagewbmp($thumb, $target_file, 100);
|
|
break;
|
|
}
|
|
|
|
imagedestroy($thumb);
|
|
imagedestroy($source);
|
|
|
|
if(!$output) return false;
|
|
@chmod($target_file, 0644);
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* @brief reads ini file, and puts result into array
|
|
* @param[in] $filename path of the ini file
|
|
* @return ini array (if the target file does not exist, it returns false)
|
|
**/
|
|
function readIniFile($filename){
|
|
$filename = FileHandler::getRealPath($filename);
|
|
if(!file_exists($filename)) return false;
|
|
$arr = parse_ini_file($filename, true);
|
|
if(is_array($arr) && count($arr)>0) return $arr;
|
|
else return array();
|
|
}
|
|
|
|
|
|
/**
|
|
* @brief write array into ini file
|
|
* @param[in] $filename target ini file name
|
|
* @param[in] $arr array
|
|
* @return if array contains nothing it returns false, otherwise true
|
|
**/
|
|
function writeIniFile($filename, $arr){
|
|
if(count($arr)==0) return false;
|
|
FileHandler::writeFile($filename, FileHandler::_makeIniBuff($arr));
|
|
return true;
|
|
}
|
|
|
|
function _makeIniBuff($arr){
|
|
$return = '';
|
|
foreach($arr as $key => $val){
|
|
// section
|
|
if(is_array($val)){
|
|
$return .= sprintf("[%s]\n",$key);
|
|
foreach($val as $k => $v){
|
|
$return .= sprintf("%s=\"%s\"\n",$k,$v);
|
|
}
|
|
// value
|
|
}else if(is_string($val) || is_int($val)){
|
|
$return .= sprintf("%s=\"%s\"\n",$key,$val);
|
|
}
|
|
}
|
|
return $return;
|
|
}
|
|
|
|
/**
|
|
* @brief return file object
|
|
* @param[in] $filename target file name
|
|
* @param[in] $mode file mode for fopen
|
|
* @remarks if the directory of the file does not exist, create it.
|
|
* @return file object
|
|
**/
|
|
function openFile($filename, $mode)
|
|
{
|
|
$pathinfo = pathinfo($filename);
|
|
$path = $pathinfo['dirname'];
|
|
if(!is_dir($path)) FileHandler::makeDir($path);
|
|
|
|
require_once("FileObject.class.php");
|
|
$file_object = new FileObject($file_name, $mode);
|
|
return $file_object;
|
|
}
|
|
|
|
/**
|
|
* @brief check whether the given file has the content.
|
|
* @param[in] $file_name target file name
|
|
* @return return true if the file exists and contains something.
|
|
*/
|
|
function hasContent($filename)
|
|
{
|
|
return (is_readable($filename) && !!filesize($filename));
|
|
}
|
|
}
|
|
?>
|