1: <?php
  2: /**
  3:  * Pinoco: makes existing static web site dynamic transparently.
  4:  * Copyright 2010-2012, Hisateru Tanaka <tanakahisateru@gmail.com>
  5:  *
  6:  * Licensed under The MIT License
  7:  * Redistributions of files must retain the above copyright notice.
  8:  *
  9:  * PHP Version 5
 10:  *
 11:  * @author     Hisateru Tanaka <tanakahisateru@gmail.com>
 12:  * @copyright  Copyright 2010-2012, Hisateru Tanaka <tanakahisateru@gmail.com>
 13:  * @license    MIT License (http://www.opensource.org/licenses/mit-license.php)
 14:  * @package    Pinoco
 15:  */
 16: 
 17: /**
 18:  * List model
 19:  *
 20:  * @package Pinoco
 21:  */
 22: class Pinoco_List implements IteratorAggregate, ArrayAccess, Countable, Pinoco_ArrayConvertible
 23: {
 24:     private $_arr;
 25:     private $_default_val;
 26: 
 27:     /**
 28:      * Constructor to make an empty instance.
 29:      */
 30:     public function __construct()
 31:     {
 32:         $this->_arr = array();
 33:         $this->_default_val = null;
 34:     }
 35: 
 36:     /**
 37:      * Makes a new object from Array.
 38:      *
 39:      * @param mixed $src
 40:      * @return Pinoco_List
 41:      */
 42:     public static function fromArray($src)
 43:     {
 44:         $self = new Pinoco_List();
 45:         $self->concat($src);
 46:         return $self;
 47:     }
 48: 
 49:     /**
 50:      * Wraps an existing Array.
 51:      *
 52:      * @param array &$srcref
 53:      * @throws InvalidArgumentException
 54:      * @return Pinoco_List
 55:      */
 56:     public static function wrap(&$srcref)
 57:     {
 58:         if (!is_array($srcref)) {
 59:             throw new InvalidArgumentException("Non array variable was given.");
 60:         }
 61:         $self = new Pinoco_List();
 62:         $self->_arr = &$srcref;
 63:         return $self;
 64:     }
 65: 
 66:     /**
 67:      * Appends a value to tail.
 68:      *
 69:      * @param mixed $value,...
 70:      * @return void
 71:      */
 72:     public function push($value)
 73:     {
 74:         $args = func_get_args();
 75:         foreach ($args as $a) {
 76:             array_push($this->_arr, $a);
 77:         }
 78:     }
 79: 
 80:     /**
 81:      * Removes and return a value from tail.
 82:      *
 83:      * @return mixed
 84:      */
 85:     public function pop()
 86:     {
 87:         return array_pop($this->_arr);
 88:     }
 89: 
 90:     /**
 91:      * Inserts a value to head.
 92:      *
 93:      * @param mixed $value,...
 94:      * @return void
 95:      */
 96:     public function unshift($value)
 97:     {
 98:         $args = func_get_args();
 99:         foreach ($args as $a) {
100:             array_unshift($this->_arr, $a);
101:         }
102:     }
103: 
104:     /**
105:      * Removes and return a value from head.
106:      *
107:      * @return mixed
108:      */
109:     public function shift()
110:     {
111:         return array_shift($this->_arr);
112:     }
113: 
114:     /**
115:      * Concatenates another iterative object.
116:      *
117:      * @param mixed $source,...
118:      * @return void
119:      */
120:     public function concat($source)
121:     {
122:         $args = func_get_args();
123:         foreach ($args as $a) {
124:             foreach ($a as $e) {
125:                 array_push($this->_arr, $e);
126:             }
127:         }
128:     }
129: 
130:     /**
131:      * Sorts this list.
132:      *
133:      * @param callback $callable
134:      * @return void
135:      */
136:     public function sort($callable=null)
137:     {
138:         if (!$callable) {
139:             sort($this->_arr);
140:         }
141:         else {
142:             usort($this->_arr, $callable);
143:         }
144:     }
145: 
146:     /**
147:      * Returns sorted list.
148:      *
149:      * @param callback $callable
150:      * @return Pinoco_List
151:      */
152:     public function sorted($callable=null)
153:     {
154:         $tmp = clone($this);
155:         $tmp->sort($callable);
156:         return $tmp;
157:     }
158: 
159:     /**
160:      * Returns a number of element of this list.
161:      *
162:      * @return int
163:      */
164:     public function count()
165:     {
166:         return count($this->_arr);
167:     }
168: 
169:     /**
170:      * Converts this list to string.
171:      *
172:      * @param string $sep
173:      * @return string
174:      */
175:     public function join($sep=",")
176:     {
177:         return implode($sep, $this->_arr);
178:     }
179: 
180:     /**
181:      * Returns a reversed list.
182:      *
183:      * @return Pinoco_List
184:      */
185:     public function reverse()
186:     {
187:         return self::fromArray(array_reverse($this->_arr));
188:     }
189: 
190:     /**
191:      * Returns a slice.
192:      *
193:      * @param int $offset
194:      * @param int $length
195:      * @return Pinoco_List
196:      */
197:     public function slice($offset, $length=null)
198:     {
199:         if (!is_null($length)) {
200:             return self::fromArray(array_slice($this->_arr, $offset, $length));
201:         }
202:         else {
203:             return self::fromArray(array_slice($this->_arr, $offset));
204:         }
205:     }
206: 
207:     /**
208:      * Removes elements by range and inserts another.
209:      *
210:      * @param int $offset
211:      * @param int $length
212:      * @param array $replacement
213:      * @return Pinoco_List;
214:      */
215:     public function splice($offset, $length=null, $replacement=null)
216:     {
217:         return self::fromArray(array_splice($this->_arr, $offset, $length, $replacement));
218:     }
219: 
220:     /**
221:      * Inserts another.
222:      *
223:      * @param int $offset
224:      * @param mixed $value,...
225:      * @return void
226:      */
227:     public function insert($offset, $value)
228:     {
229:         $args = func_get_args();
230:         array_shift($args);
231:         array_splice($this->_arr, $offset, 0, $args);
232:     }
233: 
234:     /**
235:      * Removes by range.
236:      *
237:      * @param int $offset
238:      * @param int $length
239:      * @return void
240:      */
241:     public function remove($offset, $length=1)
242:     {
243:         array_splice($this->_arr, $offset, $length);
244:     }
245: 
246:     /**
247:      * Returns the first position where value found in this list.
248:      *
249:      * @param mixed $value
250:      * @return int
251:      */
252:     public function index($value)
253:     {
254:         $r = array_search($value, $this->_arr);
255:         return $r===false ? -1 : $r;
256:     }
257: 
258:     /**
259:      * Returns value or default by position.
260:      *
261:      * @param int $idx
262:      * @param mixed $default
263:      * @return mixed
264:      */
265:     public function get($idx, $default=Pinoco_OptionalParam::UNSPECIFIED)
266:     {
267:         if (isset($this->_arr[$idx])) {
268:             return $this->_arr[$idx];
269:         }
270:         else {
271:             return Pinoco_OptionalParam::isSpecifiedBy($default) ? $default : $this->_default_val;
272:         }
273:     }
274: 
275:     /**
276:      * Returns a value or default by tree expression.
277:      *
278:      * @param string $expression
279:      * @param mixed $default
280:      * @return mixed
281:      */
282:     public function rget($expression, $default=Pinoco_OptionalParam::UNSPECIFIED)
283:     {
284:         $default = Pinoco_OptionalParam::isSpecifiedBy($default) ? $default : $this->_default_val;
285:         $es = explode('/', $expression);
286:         $v = $this;
287:         while (count($es) > 0) {
288:             $name = trim(array_shift($es));
289:             if ($name === "") {
290:                 continue;
291:             }
292:             if ($v instanceof Pinoco_ArrayConvertible) {
293:                 $v = $v->get($name, $default);
294:             }
295:             elseif (is_object($v)) {
296:                 if (property_exists($v, $name)) {
297:                     $v = $v->$name;
298:                 }
299:                 else {
300:                     return $default;
301:                 }
302:             }
303:             elseif (is_array($v)) {
304:                 if (array_key_exists($name, $v)) {
305:                     $v = $v[$name];
306:                 }
307:                 else {
308:                     return $default;
309:                 }
310:             }
311:             else {
312:                 return $default;
313:             }
314:         }
315:         return $v;
316:     }
317: 
318:     /**
319:      * Sets value by position.
320:      *
321:      * @param int $idx
322:      * @param mixed $value
323:      * @param mixed $default
324:      * @return void
325:      */
326:     public function set($idx, $value, $default=Pinoco_OptionalParam::UNSPECIFIED)
327:     {
328:         $default = Pinoco_OptionalParam::isSpecifiedBy($default) ? $default : $this->_default_val;
329:         for ($i = count($this->_arr); $i < $idx; $i++) {
330:             $this->_arr[$i] = $default;
331:         }
332:         $this->_arr[$idx] = $value;
333:     }
334: 
335:     /**
336:      * Sets a default value for overflow access.
337:      *
338:      * @param mixed $value
339:      * @return void
340:      */
341:     public function setDefault($value)
342:     {
343:         $this->_default_val = $value;
344:     }
345: 
346:     /**
347:      * Exports elements to Array.
348:      *
349:      * @param array $modifier
350:      * @return array
351:      */
352:     public function toArray($modifier=null)
353:     {
354:         $arr = array();
355:         if ($modifier) {
356:             foreach ($this->_arr as $i=>$v) {
357:                 $name = (strpos($modifier, "%") !== false) ? sprintf($modifier, $i) : (
358:                     is_callable($modifier) ? call_user_func($modifier, $i) : ($modifier . $i)
359:                 );
360:                 $arr[$name] = $v;
361:             }
362:         }
363:         else {
364:             foreach ($this->_arr as $i=>$v) {
365:                 $arr[$i] = $v;
366:             }
367:         }
368:         return $arr;
369:     }
370: 
371:     /**
372:      * Exports properties to Array recursively.
373:      *
374:      * @param int $depth
375:      * @return array
376:      */
377:     public function toArrayRecurse($depth=null)
378:     {
379:         if ($depth !== null && $depth == 0) { return $this; }
380:         $arr = array();
381:         foreach ($this->_arr as $i=>$v) {
382:             if ($v instanceof Pinoco_ArrayConvertible) {
383:                 $v = $v->toArrayRecurse($depth !== null ? $depth - 1 : null);
384:             }
385:             $arr[$i] = $v;
386:         }
387:         return $arr;
388:     }
389: 
390:     /**
391:      * Fold operation for each elements.
392:      *
393:      * @param callback $callable
394:      * @param mixed $initial
395:      * @return mixed
396:      */
397:     public function reduce($callable, $initial=null)
398:     {
399:         return array_reduce($this->_arr, $callable, $initial);
400:     }
401: 
402:     /**
403:      * Some operation for each elements.
404:      *
405:      * @param callback $callable
406:      * @return void
407:      */
408:     public function each($callable)
409:     {
410:         foreach ($this->_arr as $e) {
411:             call_user_func($callable, $e);
412:         }
413:     }
414: 
415:     /**
416:      * Regenerates list from this list which elements are applied given function.
417:      *
418:      * @param callback $callable
419:      * @return Pinoco_List
420:      */
421:     public function map($callable)
422:     {
423:         return self::fromArray(array_map($callable, $this->_arr));
424:     }
425: 
426:     /**
427:      * Regenerates list from this list which elements are filtered by given function.
428:      *
429:      * @param callback $callable
430:      * @return Pinoco_List
431:      */
432:     public function filter($callable)
433:     {
434:         return self::fromArray(array_filter($this->_arr, $callable));
435:     }
436: 
437:     /*
438:     public function any($callable)
439:     {
440:     }
441:     public function all($callable)
442:     {
443:     }
444:     */
445: 
446:     public function offsetSet($offset, $value)
447:     {
448:         $this->set($offset, $value);
449:     }
450:     public function offsetExists($offset)
451:     {
452:         return $offset < count($this->_arr);
453:     }
454:     public function offsetUnset($offset)
455:     {
456:         array_splice($this->_arr, $offset, 1);
457:     }
458:     public function offsetGet($offset)
459:     {
460:         return $this->get($offset);
461:     }
462: 
463:     public function getIterator()
464:     {
465:         return new Pinoco_ArrayConvertiblesIterator($this->_arr);
466:     }
467: 
468:     public function __toString() { return __CLASS__; } // TODO: dump vars name/values
469: }
470: 
471: