CakePHP
  • Documentation
    • Book
    • API
    • Videos
    • Reporting Security Issues
    • Privacy Policy
    • Logos & Trademarks
  • Business Solutions
  • Swag
  • Road Trip
  • Team
  • Community
    • Community
    • Get Involved
    • Issues (GitHub)
    • Bakery
    • Featured Resources
    • Training
    • Meetups
    • My CakePHP
    • CakeFest
    • Newsletter
    • Linkedin
    • YouTube
    • Facebook
    • Twitter
    • Mastodon
    • Help & Support
    • Forum
    • Stack Overflow
    • Slack
    • Paid Support
CakePHP

C CakePHP 1.3 API

  • Overview
  • Tree
  • Deprecated
  • Version:
    • 1.3
      • 4.2
      • 4.1
      • 4.0
      • 3.9
      • 3.8
      • 3.7
      • 3.6
      • 3.5
      • 3.4
      • 3.3
      • 3.2
      • 3.1
      • 3.0
      • 2.10
      • 2.9
      • 2.8
      • 2.7
      • 2.6
      • 2.5
      • 2.4
      • 2.3
      • 2.2
      • 2.1
      • 2.0
      • 1.3
      • 1.2

Classes

  • AclBase
  • AclBehavior
  • AclComponent
  • AclNode
  • AclShell
  • Aco
  • AcoAction
  • AjaxHelper
  • ApcEngine
  • ApiShell
  • App
  • AppController
  • AppHelper
  • AppModel
  • Aro
  • AuthComponent
  • BakeShell
  • BakeTask
  • BehaviorCollection
  • Cache
  • CacheEngine
  • CacheHelper
  • CakeErrorController
  • CakeLog
  • CakeRoute
  • CakeSchema
  • CakeSession
  • CakeSocket
  • ClassRegistry
  • Component
  • Configure
  • ConnectionManager
  • ConsoleShell
  • ContainableBehavior
  • Controller
  • ControllerTask
  • CookieComponent
  • DataSource
  • DbAcl
  • DbConfigTask
  • DboMssql
  • DboMysql
  • DboMysqlBase
  • DboMysqli
  • DboOracle
  • DboPostgres
  • DboSource
  • DboSqlite
  • Debugger
  • EmailComponent
  • ErrorHandler
  • ExtractTask
  • File
  • FileEngine
  • FileLog
  • FixtureTask
  • Folder
  • FormHelper
  • Helper
  • HtmlHelper
  • HttpSocket
  • I18n
  • I18nModel
  • I18nShell
  • Inflector
  • IniAcl
  • JavascriptHelper
  • JqueryEngineHelper
  • JsBaseEngineHelper
  • JsHelper
  • L10n
  • MagicDb
  • MagicFileResource
  • MediaView
  • MemcacheEngine
  • Model
  • ModelBehavior
  • ModelTask
  • MootoolsEngineHelper
  • Multibyte
  • NumberHelper
  • Object
  • Overloadable
  • Overloadable2
  • PagesController
  • PaginatorHelper
  • Permission
  • PluginShortRoute
  • PluginTask
  • ProjectTask
  • PrototypeEngineHelper
  • RequestHandlerComponent
  • Router
  • RssHelper
  • Sanitize
  • Scaffold
  • ScaffoldView
  • SchemaShell
  • Security
  • SecurityComponent
  • SessionComponent
  • SessionHelper
  • Set
  • Shell
  • String
  • TemplateTask
  • TestSuiteShell
  • TestTask
  • TextHelper
  • ThemeView
  • TimeHelper
  • TranslateBehavior
  • TreeBehavior
  • Validation
  • View
  • ViewTask
  • XcacheEngine
  • Xml
  • XmlElement
  • XmlHelper
  • XmlManager
  • XmlNode
  • XmlTextNode

Functions

  • mb_encode_mimeheader
  • mb_stripos
  • mb_stristr
  • mb_strlen
  • mb_strpos
  • mb_strrchr
  • mb_strrichr
  • mb_strripos
  • mb_strrpos
  • mb_strstr
  • mb_strtolower
  • mb_strtoupper
  • mb_substr
  • mb_substr_count
  1: <?php
  2: /**
  3:  * Convenience class for reading, writing and appending to files.
  4:  *
  5:  * PHP versions 4 and 5
  6:  *
  7:  * CakePHP(tm) : Rapid Development Framework (http://cakephp.org)
  8:  * Copyright 2005-2012, Cake Software Foundation, Inc. (http://cakefoundation.org)
  9:  *
 10:  * Licensed under The MIT License
 11:  * Redistributions of files must retain the above copyright notice.
 12:  *
 13:  * @copyright     Copyright 2005-2012, Cake Software Foundation, Inc. (http://cakefoundation.org)
 14:  * @link          http://cakephp.org CakePHP(tm) Project
 15:  * @package       cake
 16:  * @subpackage    cake.cake.libs
 17:  * @since         CakePHP(tm) v 0.2.9
 18:  * @license       MIT License (http://www.opensource.org/licenses/mit-license.php)
 19:  */
 20: 
 21: /**
 22:  * Included libraries.
 23:  *
 24:  */
 25: if (!class_exists('Object')) {
 26:     require LIBS . 'object.php';
 27: }
 28: if (!class_exists('Folder')) {
 29:     require LIBS . 'folder.php';
 30: }
 31: 
 32: /**
 33:  * Convenience class for reading, writing and appending to files.
 34:  *
 35:  * @package       cake
 36:  * @subpackage    cake.cake.libs
 37:  */
 38: class File extends Object {
 39: 
 40: /**
 41:  * Folder object of the File
 42:  *
 43:  * @var Folder
 44:  * @access public
 45:  */
 46:     var $Folder = null;
 47: 
 48: /**
 49:  * Filename
 50:  *
 51:  * @var string
 52:  * @access public
 53:  */
 54:     var $name = null;
 55: 
 56: /**
 57:  * file info
 58:  *
 59:  * @var string
 60:  * @access public
 61:  */
 62:     var $info = array();
 63: 
 64: /**
 65:  * Holds the file handler resource if the file is opened
 66:  *
 67:  * @var resource
 68:  * @access public
 69:  */
 70:     var $handle = null;
 71: 
 72: /**
 73:  * enable locking for file reading and writing
 74:  *
 75:  * @var boolean
 76:  * @access public
 77:  */
 78:     var $lock = null;
 79: 
 80: /**
 81:  * path property
 82:  *
 83:  * Current file's absolute path
 84:  *
 85:  * @var mixed null
 86:  * @access public
 87:  */
 88:     var $path = null;
 89: 
 90: /**
 91:  * Constructor
 92:  *
 93:  * @param string $path Path to file
 94:  * @param boolean $create Create file if it does not exist (if true)
 95:  * @param integer $mode Mode to apply to the folder holding the file
 96:  */
 97:     function __construct($path, $create = false, $mode = 0755) {
 98:         parent::__construct();
 99:         $this->Folder =& new Folder(dirname($path), $create, $mode);
100:         if (!is_dir($path)) {
101:             $this->name = basename($path);
102:         }
103:         $this->pwd();
104:         $create && !$this->exists() && $this->safe($path) && $this->create();
105:     }
106: 
107: /**
108:  * Closes the current file if it is opened
109:  *
110:  */
111:     function __destruct() {
112:         $this->close();
113:     }
114: 
115: /**
116:  * Creates the File.
117:  *
118:  * @return boolean Success
119:  * @access public
120:  */
121:     function create() {
122:         $dir = $this->Folder->pwd();
123:         if (is_dir($dir) && is_writable($dir) && !$this->exists()) {
124:             $old = umask(0);
125:             if (touch($this->path)) {
126:                 umask($old);
127:                 return true;
128:             }
129:         }
130:         return false;
131:     }
132: 
133: /**
134:  * Opens the current file with a given $mode
135:  *
136:  * @param string $mode A valid 'fopen' mode string (r|w|a ...)
137:  * @param boolean $force If true then the file will be re-opened even if its already opened, otherwise it won't
138:  * @return boolean True on success, false on failure
139:  * @access public
140:  */
141:     function open($mode = 'r', $force = false) {
142:         if (!$force && is_resource($this->handle)) {
143:             return true;
144:         }
145:         clearstatcache();
146:         if ($this->exists() === false) {
147:             if ($this->create() === false) {
148:                 return false;
149:             }
150:         }
151: 
152:         $this->handle = fopen($this->path, $mode);
153:         if (is_resource($this->handle)) {
154:             return true;
155:         }
156:         return false;
157:     }
158: 
159: /**
160:  * Return the contents of this File as a string.
161:  *
162:  * @param string $bytes where to start
163:  * @param string $mode A `fread` compatible mode.
164:  * @param boolean $force If true then the file will be re-opened even if its already opened, otherwise it won't
165:  * @return mixed string on success, false on failure
166:  * @access public
167:  */
168:     function read($bytes = false, $mode = 'rb', $force = false) {
169:         if ($bytes === false && $this->lock === null) {
170:             return file_get_contents($this->path);
171:         }
172:         if ($this->open($mode, $force) === false) {
173:             return false;
174:         }
175:         if ($this->lock !== null && flock($this->handle, LOCK_SH) === false) {
176:             return false;
177:         }
178:         if (is_int($bytes)) {
179:             return fread($this->handle, $bytes);
180:         }
181: 
182:         $data = '';
183:         while (!feof($this->handle)) {
184:             $data .= fgets($this->handle, 4096);
185:         }
186: 
187:         if ($this->lock !== null) {
188:             flock($this->handle, LOCK_UN);
189:         }
190:         if ($bytes === false) {
191:             $this->close();
192:         }
193:         return trim($data);
194:     }
195: 
196: /**
197:  * Sets or gets the offset for the currently opened file.
198:  *
199:  * @param mixed $offset The $offset in bytes to seek. If set to false then the current offset is returned.
200:  * @param integer $seek PHP Constant SEEK_SET | SEEK_CUR | SEEK_END determining what the $offset is relative to
201:  * @return mixed True on success, false on failure (set mode), false on failure or integer offset on success (get mode)
202:  * @access public
203:  */
204:     function offset($offset = false, $seek = SEEK_SET) {
205:         if ($offset === false) {
206:             if (is_resource($this->handle)) {
207:                 return ftell($this->handle);
208:             }
209:         } elseif ($this->open() === true) {
210:             return fseek($this->handle, $offset, $seek) === 0;
211:         }
212:         return false;
213:     }
214: 
215: /**
216:  * Prepares a ascii string for writing.  Converts line endings to the 
217:  * correct terminator for the current platform.  If windows "\r\n" will be used
218:  * all other platforms will use "\n"
219:  *
220:  * @param string $data Data to prepare for writing.
221:  * @return string The with converted line endings.
222:  * @access public
223:  */
224:     function prepare($data, $forceWindows = false) {
225:         $lineBreak = "\n";
226:         if (DIRECTORY_SEPARATOR == '\\' || $forceWindows === true) {
227:             $lineBreak = "\r\n";
228:         }
229:         return strtr($data, array("\r\n" => $lineBreak, "\n" => $lineBreak, "\r" => $lineBreak));
230:     }
231: 
232: /**
233:  * Write given data to this File.
234:  *
235:  * @param string $data Data to write to this File.
236:  * @param string $mode Mode of writing. {@link http://php.net/fwrite See fwrite()}.
237:  * @param string $force force the file to open
238:  * @return boolean Success
239:  * @access public
240:  */
241:     function write($data, $mode = 'w', $force = false) {
242:         $success = false;
243:         if ($this->open($mode, $force) === true) {
244:             if ($this->lock !== null) {
245:                 if (flock($this->handle, LOCK_EX) === false) {
246:                     return false;
247:                 }
248:             }
249: 
250:             if (fwrite($this->handle, $data) !== false) {
251:                 $success = true;
252:             }
253:             if ($this->lock !== null) {
254:                 flock($this->handle, LOCK_UN);
255:             }
256:         }
257:         return $success;
258:     }
259: 
260: /**
261:  * Append given data string to this File.
262:  *
263:  * @param string $data Data to write
264:  * @param string $force force the file to open
265:  * @return boolean Success
266:  * @access public
267:  */
268:     function append($data, $force = false) {
269:         return $this->write($data, 'a', $force);
270:     }
271: 
272: /**
273:  * Closes the current file if it is opened.
274:  *
275:  * @return boolean True if closing was successful or file was already closed, otherwise false
276:  * @access public
277:  */
278:     function close() {
279:         if (!is_resource($this->handle)) {
280:             return true;
281:         }
282:         return fclose($this->handle);
283:     }
284: 
285: /**
286:  * Deletes the File.
287:  *
288:  * @return boolean Success
289:  * @access public
290:  */
291:     function delete() {
292:         clearstatcache();
293:         if (is_resource($this->handle)) {
294:             fclose($this->handle);
295:             $this->handle = null;
296:         }
297:         if ($this->exists()) {
298:             return unlink($this->path);
299:         }
300:         return false;
301:     }
302: 
303: /**
304:  * Returns the File info.
305:  *
306:  * @return string The File extension
307:  * @access public
308:  */
309:     function info() {
310:         if ($this->info == null) {
311:             $this->info = pathinfo($this->path);
312:         }
313:         if (!isset($this->info['filename'])) {
314:             $this->info['filename'] = $this->name();
315:         }
316:         return $this->info;
317:     }
318: 
319: /**
320:  * Returns the File extension.
321:  *
322:  * @return string The File extension
323:  * @access public
324:  */
325:     function ext() {
326:         if ($this->info == null) {
327:             $this->info();
328:         }
329:         if (isset($this->info['extension'])) {
330:             return $this->info['extension'];
331:         }
332:         return false;
333:     }
334: 
335: /**
336:  * Returns the File name without extension.
337:  *
338:  * @return string The File name without extension.
339:  * @access public
340:  */
341:     function name() {
342:         if ($this->info == null) {
343:             $this->info();
344:         }
345:         if (isset($this->info['extension'])) {
346:             return basename($this->name, '.'.$this->info['extension']);
347:         } elseif ($this->name) {
348:             return $this->name;
349:         }
350:         return false;
351:     }
352: 
353: /**
354:  * makes filename safe for saving
355:  *
356:  * @param string $name The name of the file to make safe if different from $this->name
357:  * @param strin $ext The name of the extension to make safe if different from $this->ext
358:  * @return string $ext the extension of the file
359:  * @access public
360:  */
361:     function safe($name = null, $ext = null) {
362:         if (!$name) {
363:             $name = $this->name;
364:         }
365:         if (!$ext) {
366:             $ext = $this->ext();
367:         }
368:         return preg_replace( "/(?:[^\w\.-]+)/", "_", basename($name, $ext));
369:     }
370: 
371: /**
372:  * Get md5 Checksum of file with previous check of Filesize
373:  *
374:  * @param mixed $maxsize in MB or true to force
375:  * @return string md5 Checksum {@link http://php.net/md5_file See md5_file()}
376:  * @access public
377:  */
378:     function md5($maxsize = 5) {
379:         if ($maxsize === true) {
380:             return md5_file($this->path);
381:         }
382: 
383:         $size = $this->size();
384:         if ($size && $size < ($maxsize * 1024) * 1024) {
385:             return md5_file($this->path);
386:         }
387: 
388:         return false;
389:     }
390: 
391: /**
392:  * Returns the full path of the File.
393:  *
394:  * @return string Full path to file
395:  * @access public
396:  */
397:     function pwd() {
398:         if (is_null($this->path)) {
399:             $this->path = $this->Folder->slashTerm($this->Folder->pwd()) . $this->name;
400:         }
401:         return $this->path;
402:     }
403: 
404: /**
405:  * Returns true if the File exists.
406:  *
407:  * @return boolean true if it exists, false otherwise
408:  * @access public
409:  */
410:     function exists() {
411:         return (file_exists($this->path) && is_file($this->path));
412:     }
413: 
414: /**
415:  * Returns the "chmod" (permissions) of the File.
416:  *
417:  * @return string Permissions for the file
418:  * @access public
419:  */
420:     function perms() {
421:         if ($this->exists()) {
422:             return substr(sprintf('%o', fileperms($this->path)), -4);
423:         }
424:         return false;
425:     }
426: 
427: /**
428:  * Returns the Filesize
429:  *
430:  * @return integer size of the file in bytes, or false in case of an error
431:  * @access public
432:  */
433:     function size() {
434:         if ($this->exists()) {
435:             return filesize($this->path);
436:         }
437:         return false;
438:     }
439: 
440: /**
441:  * Returns true if the File is writable.
442:  *
443:  * @return boolean true if its writable, false otherwise
444:  * @access public
445:  */
446:     function writable() {
447:         return is_writable($this->path);
448:     }
449: 
450: /**
451:  * Returns true if the File is executable.
452:  *
453:  * @return boolean true if its executable, false otherwise
454:  * @access public
455:  */
456:     function executable() {
457:         return is_executable($this->path);
458:     }
459: 
460: /**
461:  * Returns true if the File is readable.
462:  *
463:  * @return boolean true if file is readable, false otherwise
464:  * @access public
465:  */
466:     function readable() {
467:         return is_readable($this->path);
468:     }
469: 
470: /**
471:  * Returns the File's owner.
472:  *
473:  * @return integer the Fileowner
474:  * @access public
475:  */
476:     function owner() {
477:         if ($this->exists()) {
478:             return fileowner($this->path);
479:         }
480:         return false;
481:     }
482: 
483: /**
484:  * Returns the File's group.
485:  *
486:  * @return integer the Filegroup
487:  * @access public
488:  */
489:     function group() {
490:         if ($this->exists()) {
491:             return filegroup($this->path);
492:         }
493:         return false;
494:     }
495: 
496: /**
497:  * Returns last access time.
498:  *
499:  * @return integer timestamp Timestamp of last access time
500:  * @access public
501:  */
502:     function lastAccess() {
503:         if ($this->exists()) {
504:             return fileatime($this->path);
505:         }
506:         return false;
507:     }
508: 
509: /**
510:  * Returns last modified time.
511:  *
512:  * @return integer timestamp Timestamp of last modification
513:  * @access public
514:  */
515:     function lastChange() {
516:         if ($this->exists()) {
517:             return filemtime($this->path);
518:         }
519:         return false;
520:     }
521: 
522: /**
523:  * Returns the current folder.
524:  *
525:  * @return Folder Current folder
526:  * @access public
527:  */
528:     function &Folder() {
529:         return $this->Folder;
530:     }
531: 
532: /**
533:  * Copy the File to $dest
534:  *
535:  * @param string $dest destination for the copy
536:  * @param boolean $overwrite Overwrite $dest if exists
537:  * @return boolean Succes
538:  * @access public
539:  */
540:     function copy($dest, $overwrite = true) {
541:         if (!$this->exists() || is_file($dest) && !$overwrite) {
542:             return false;
543:         }
544:         return copy($this->path, $dest);
545:     }
546: }
547: 
OpenHub
Rackspace
Rackspace
  • Business Solutions
  • Showcase
  • Documentation
  • Book
  • API
  • Videos
  • Reporting Security Issues
  • Privacy Policy
  • Logos & Trademarks
  • Community
  • Get Involved
  • Issues (GitHub)
  • Bakery
  • Featured Resources
  • Training
  • Meetups
  • My CakePHP
  • CakeFest
  • Newsletter
  • Linkedin
  • YouTube
  • Facebook
  • Twitter
  • Mastodon
  • Help & Support
  • Forum
  • Stack Overflow
  • Slack
  • Paid Support

Generated using CakePHP API Docs