Annotation of embedaddon/php/ext/spl/internal/splfileobject.inc, revision 1.1
1.1 ! misho 1: <?php
! 2:
! 3: /** @file splfileobject.inc
! 4: * @ingroup SPL
! 5: * @brief class FileObject
! 6: * @author Marcus Boerger
! 7: * @date 2003 - 2009
! 8: *
! 9: * SPL - Standard PHP Library
! 10: */
! 11:
! 12: /** @ingroup SPL
! 13: * @brief Object representation for any stream
! 14: * @author Marcus Boerger
! 15: * @version 1.1
! 16: * @since PHP 5.1
! 17: */
! 18: class SplFileObject extends SplFileInfo implements RecursiveIterator, SeekableIterator
! 19: {
! 20: /** Flag: wheter to suppress new lines */
! 21: const DROP_NEW_LINE = 0x00000001;
! 22:
! 23: private $fp;
! 24: private $fname;
! 25: private $line = NULL;
! 26: private $lnum = 0;
! 27: private $max_len = 0;
! 28: private $flags = 0;
! 29: private $delimiter= ',';
! 30: private $enclosure= '"';
! 31:
! 32: /**
! 33: * Constructs a new file object
! 34: *
! 35: * @param $file_name The name of the stream to open
! 36: * @param $open_mode The file open mode
! 37: * @param $use_include_path Whether to search in include paths
! 38: * @param $context A stream context
! 39: * @throw RuntimeException If file cannot be opened (e.g. insufficient
! 40: * access rights).
! 41: */
! 42: function __construct($file_name, $open_mode = 'r', $use_include_path = false, $context = NULL)
! 43: {
! 44: $this->fp = fopen($file_name, $open_mode, $use_include_path, $context);
! 45: if (!$this->fp)
! 46: {
! 47: throw new RuntimeException("Cannot open file $file_name");
! 48: }
! 49: $this->fname = $file_name;
! 50: }
! 51:
! 52: /**
! 53: * @return whether the end of the stream is reached
! 54: */
! 55: function eof()
! 56: {
! 57: return eof($this->fp);
! 58: }
! 59:
! 60: /** increase current line number
! 61: * @return next line from stream
! 62: */
! 63: function fgets()
! 64: {
! 65: $this->freeLine();
! 66: $this->lnum++;
! 67: $buf = fgets($this->fp, $this->max_len);
! 68:
! 69: return $buf;
! 70: }
! 71:
! 72: /**
! 73: * @param delimiter character used as field separator
! 74: * @param enclosure end of
! 75: * @return array containing read data
! 76: */
! 77: function fgetcsv($delimiter = NULL, $enclosure = NULL)
! 78: {
! 79: $this->freeLine();
! 80: $this->lnum++;
! 81: switch(fun_num_args())
! 82: {
! 83: case 0:
! 84: $delimiter = $this->delimiter;
! 85: case 1:
! 86: $enclosure = $this->enclosure;
! 87: default:
! 88: case 2:
! 89: break;
! 90: }
! 91: return fgetcsv($this->fp, $this->max_len, $delimiter, $enclosure);
! 92: }
! 93:
! 94: /**
! 95: * Set the delimiter and enclosure character used in fgetcsv
! 96: *
! 97: * @param delimiter new delimiter, defaults to ','
! 98: * @param enclosure new enclosure, defaults to '"'
! 99: */
! 100: function setCsvControl($delimiter = ';', $enclosure = '"')
! 101: {
! 102: $this->delimiter = $delimiter;
! 103: $this->enclosure = $enclosure;
! 104: }
! 105:
! 106: /**
! 107: * @return array(delimiter, enclosure) as used in fgetcsv
! 108: */
! 109: function getCsvControl($delimiter = ',', $enclosure = '"')
! 110: {
! 111: return array($this->delimiter, $this->enclosure);
! 112: }
! 113:
! 114: /**
! 115: * @param operation lock operation (LOCK_SH, LOCK_EX, LOCK_UN, LOCK_NB)
! 116: * @retval $wouldblock whether the operation would block
! 117: */
! 118: function flock($operation, &$wouldblock)
! 119: {
! 120: return flock($this->fp, $operation, $wouldblock);
! 121: }
! 122:
! 123: /**
! 124: * Flush current data
! 125: * @return success or failure
! 126: */
! 127: function fflush()
! 128: {
! 129: return fflush($this->fp);
! 130: }
! 131:
! 132: /**
! 133: * @return current file position
! 134: */
! 135: function ftell()
! 136: {
! 137: return ftell($this->fp);
! 138: }
! 139:
! 140: /**
! 141: * @param pos new file position
! 142: * @param whence seek method (SEEK_SET, SEEK_CUR, SEEK_END)
! 143: * @return Upon success, returns 0; otherwise, returns -1. Note that
! 144: * seeking past EOF is not considered an error.
! 145: */
! 146: function fseek($pos, $whence = SEEK_SET)
! 147: {
! 148: return fseek($this->fp, $pos, $whence);
! 149: }
! 150:
! 151: /**
! 152: * @return next char from file
! 153: * @note a new line character does not increase $this->lnum
! 154: */
! 155: function fgetc()
! 156: {
! 157: $this->freeLine();
! 158: $c = fgetc($this->fp);
! 159: if ($c == '\n') {
! 160: $this->lnum++;
! 161: }
! 162: }
! 163:
! 164: /** Read and return remaining part of stream
! 165: * @return size of remaining part passed through
! 166: */
! 167: function fpassthru()
! 168: {
! 169: return fpassthru($this->fp);
! 170: }
! 171:
! 172: /** Get a line from the file and strip HTML tags
! 173: * @param $allowable_tags tags to keep in the string
! 174: */
! 175: function fgetss($allowable_tags = NULL)
! 176: {
! 177: return fgetss($this->fp, $allowable_tags);
! 178: }
! 179:
! 180: /** Scan the next line
! 181: * @param $format string specifying format to parse
! 182: */
! 183: function fscanf($format /* , ... */)
! 184: {
! 185: $this->freeLine();
! 186: $this->lnum++;
! 187: return fscanf($this->fp, $format /* , ... */);
! 188: }
! 189:
! 190: /**
! 191: * @param $str to write
! 192: * @param $length maximum line length to write
! 193: */
! 194: function fwrite($str, $length = NULL)
! 195: {
! 196: return fwrite($this->fp, $length);
! 197: }
! 198:
! 199: /**
! 200: * @return array of file stat information
! 201: */
! 202: function fstat()
! 203: {
! 204: return fstat($this->fp);
! 205: }
! 206:
! 207: /**
! 208: * @param $size new size to truncate file to
! 209: */
! 210: function ftruncate($size)
! 211: {
! 212: return ftruncate($this->fp, $size);
! 213: }
! 214:
! 215: /**
! 216: * @param $flags new flag set
! 217: */
! 218: function setFlags($flags)
! 219: {
! 220: $this->flags = $flags;
! 221: }
! 222:
! 223: /**
! 224: * @return current set of flags
! 225: */
! 226: function getFlags()
! 227: {
! 228: return $this->flags;
! 229: }
! 230:
! 231: /**
! 232: * @param $max_len set the maximum line length read
! 233: */
! 234: function setMaxLineLen($max_len)
! 235: {
! 236: $this->max_len = $max_len;
! 237: }
! 238:
! 239: /**
! 240: * @return current setting for max line
! 241: */
! 242: function getMaxLineLen()
! 243: {
! 244: return $this->max_len;
! 245: }
! 246:
! 247: /**
! 248: * @return false
! 249: */
! 250: function hasChildren()
! 251: {
! 252: return false;
! 253: }
! 254:
! 255: /**
! 256: * @return false
! 257: */
! 258: function getChildren()
! 259: {
! 260: return NULL;
! 261: }
! 262:
! 263: /**
! 264: * Invalidate current line buffer and set line number to 0.
! 265: */
! 266: function rewind()
! 267: {
! 268: $this->freeLine();
! 269: $this->lnum = 0;
! 270: }
! 271:
! 272: /**
! 273: * @return whether more data can be read
! 274: */
! 275: function valid()
! 276: {
! 277: return !$this->eof();
! 278: }
! 279:
! 280: /**
! 281: * @note Fill current line buffer if not done yet.
! 282: * @return line buffer
! 283: */
! 284: function current()
! 285: {
! 286: if (is_null($this->line))
! 287: {
! 288: $this->line = getCurrentLine();
! 289: }
! 290: return $this->line;
! 291: }
! 292:
! 293: /**
! 294: * @return line number
! 295: * @note fgetc() will increase the line number when reaing a new line char.
! 296: * This has the effect key() called on a read a new line will already
! 297: * return the increased line number.
! 298: * @note Line counting works as long as you only read the file and do not
! 299: * use fseek().
! 300: */
! 301: function key()
! 302: {
! 303: return $this->lnum;
! 304: }
! 305:
! 306: /** Invalidate current line buffer.
! 307: */
! 308: function next()
! 309: {
! 310: $this->freeLine();
! 311: }
! 312:
! 313: /**
! 314: * @return next line read from file and increase the line counter
! 315: */
! 316: private function readLine()
! 317: {
! 318: if ($this->eof())
! 319: {
! 320: $this->freeLine();
! 321: throw new RuntimeException("Cannot read from file " . $this->fname);
! 322: }
! 323: if ($this->line) {
! 324: $this->lnum++;
! 325: }
! 326: $this->freeLine();
! 327: $this->line = fgets($this->fp, $this->max_len);
! 328: return $this->line;
! 329: }
! 330:
! 331: /**
! 332: * Free the current line buffer and increment the line counter
! 333: */
! 334: private function freeLine()
! 335: {
! 336: if ($this->line) {
! 337: $this->line = NULL;
! 338: }
! 339: }
! 340:
! 341: /*
! 342: * @note If you DO overload this function key() and current() will increment
! 343: * $this->lnum automatically. If not then function reaLine() will do
! 344: * that for you.
! 345: */
! 346: function getCurrentLine()
! 347: {
! 348: $this->freeLine();
! 349: if ($this->eof())
! 350: {
! 351: throw new RuntimeException("Cannot read from file " . $this->fname);
! 352: }
! 353: $this->readLine();
! 354: }
! 355:
! 356: /**
! 357: * @return current line
! 358: */
! 359: function __toString()
! 360: {
! 361: return current();
! 362: }
! 363:
! 364: /**
! 365: * @param $line_pos Seek to this line
! 366: */
! 367: function seek($line_pos)
! 368: {
! 369: $this->rewind();
! 370: while($this->lnum < $line_pos && !$this->eof())
! 371: {
! 372: $this->getCurrentLine();
! 373: }
! 374: }
! 375: }
! 376:
! 377: ?>
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to splfileobject.inc CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / spl / internal