library/Zend/Paginator.php

   1 <?php
   2 /**
   3  * Zend Framework
   4  *
   5  * LICENSE
   6  *
   7  * This source file is subject to the new BSD license that is bundled
   8  * with this package in the file LICENSE.txt.
   9  * It is also available through the world-wide-web at this URL:
  10  * http://framework.zend.com/license/new-bsd
  11  * If you did not receive a copy of the license and are unable to
  12  * obtain it through the world-wide-web, please send an email
  13  * to license@zend.com so we can send you a copy immediately.
  14  *
  15  * @category   Zend
  16  * @package    Zend_Paginator
  17  * @copyright  Copyright (c) 2005-2009 Zend Technologies USA Inc. (http://www.zend.com)
  18  * @license    http://framework.zend.com/license/new-bsd     New BSD License
  19  * @version    $Id: Paginator.php 17631 2009-08-16 12:29:46Z norm2782 $
  20  */
  21
  22 /**
  23  * @see Zend_Loader_PluginLoader
  24  */
  25 require_once 'Zend/Loader/PluginLoader.php';
  26
  27 /**
  28  * @see Zend_Json
  29  */
  30 require_once 'Zend/Json.php';
  31
  32 /**
  33  * @category   Zend
  34  * @package    Zend_Paginator
  35  * @copyright  Copyright (c) 2005-2009 Zend Technologies USA Inc. (http://www.zend.com)
  36  * @license    http://framework.zend.com/license/new-bsd     New BSD License
  37  */
  38 class Zend_Paginator implements Countable, IteratorAggregate
  39 {
  40     /**
  41      * Specifies that the factory should try to detect the proper adapter type first
  42      *
  43      * @var string
  44      */
  45     const INTERNAL_ADAPTER = 'Zend_Paginator_Adapter_Internal';
  46
  47     /**
  48      * The cache tag prefix used to namespace Paginator results in the cache
  49      *
  50      */
  51     const CACHE_TAG_PREFIX = 'Zend_Paginator_';
  52
  53     /**
  54      * Adapter plugin loader
  55      *
  56      * @var Zend_Loader_PluginLoader
  57      */
  58     protected static $_adapterLoader = null;
  59
  60     /**
  61      * Configuration file
  62      *
  63      * @var Zend_Config
  64      */
  65     protected static $_config = null;
  66
  67     /**
  68      * Default scrolling style
  69      *
  70      * @var string
  71      */
  72     protected static $_defaultScrollingStyle = 'Sliding';
  73
  74     /**
  75      * Default item count per page
  76      *
  77      * @var int
  78      */
  79     protected static $_defaultItemCountPerPage = 10;
  80
  81     /**
  82      * Scrolling style plugin loader
  83      *
  84      * @var Zend_Loader_PluginLoader
  85      */
  86     protected static $_scrollingStyleLoader = null;
  87
  88     /**
  89      * Cache object
  90      *
  91      * @var Zend_Cache_Core
  92      */
  93     protected static $_cache;
  94
  95     /**
  96      * Enable or desable the cache by Zend_Paginator instance
  97      *
  98      * @var bool
  99      */
 100     protected $_cacheEnabled = true;
 101
 102     /**
 103      * Adapter
 104      *
 105      * @var Zend_Paginator_Adapter_Interface
 106      */
 107     protected $_adapter = null;
 108
 109     /**
 110      * Number of items in the current page
 111      *
 112      * @var integer
 113      */
 114     protected $_currentItemCount = null;
 115
 116     /**
 117      * Current page items
 118      *
 119      * @var Traversable
 120      */
 121     protected $_currentItems = null;
 122
 123     /**
 124      * Current page number (starting from 1)
 125      *
 126      * @var integer
 127      */
 128     protected $_currentPageNumber = 1;
 129
 130     /**
 131      * Result filter
 132      *
 133      * @var Zend_Filter_Interface
 134      */
 135     protected $_filter = null;
 136
 137     /**
 138      * Number of items per page
 139      *
 140      * @var integer
 141      */
 142     protected $_itemCountPerPage = null;
 143
 144     /**
 145      * Number of pages
 146      *
 147      * @var integer
 148      */
 149     protected $_pageCount = null;
 150
 151     /**
 152      * Number of local pages (i.e., the number of discrete page numbers
 153      * that will be displayed, including the current page number)
 154      *
 155      * @var integer
 156      */
 157     protected $_pageRange = 10;
 158
 159     /**
 160      * Pages
 161      *
 162      * @var array
 163      */
 164     protected $_pages = null;
 165
 166     /**
 167      * View instance used for self rendering
 168      *
 169      * @var Zend_View_Interface
 170      */
 171     protected $_view = null;
 172
 173     /**
 174      * Adds an adapter prefix path to the plugin loader.
 175      *
 176      * @param string $prefix
 177      * @param string $path
 178      */
 179     public static function addAdapterPrefixPath($prefix, $path)
 180     {
 181         self::getAdapterLoader()->addPrefixPath($prefix, $path);
 182     }
 183
 184     /**
 185      * Adds an array of adapter prefix paths to the plugin
 186      * loader.
 187      *
 188      * <code>
 189      * $prefixPaths = array(
 190      *     'My_Paginator_Adapter'   => 'My/Paginator/Adapter/',
 191      *     'Your_Paginator_Adapter' => 'Your/Paginator/Adapter/'
 192      * );
 193      * </code>
 194      *
 195      * @param array $prefixPaths
 196      */
 197     public static function addAdapterPrefixPaths(array $prefixPaths)
 198     {
 199         if (isset($prefixPaths['prefix']) && isset($prefixPaths['path'])) {
 200             self::addAdapterPrefixPath($prefixPaths['prefix'], $prefixPaths['path']);
 201         } else {
 202             foreach ($prefixPaths as $prefix => $path) {
 203                 if (is_array($path) && isset($path['prefix']) && isset($path['path'])) {
 204                     $prefix = $path['prefix'];
 205                     $path   = $path['path'];
 206                 }
 207
 208                 self::addAdapterPrefixPath($prefix, $path);
 209             }
 210         }
 211     }
 212
 213     /**
 214      * Adds a scrolling style prefix path to the plugin loader.
 215      *
 216      * @param string $prefix
 217      * @param string $path
 218      */
 219     public static function addScrollingStylePrefixPath($prefix, $path)
 220     {
 221         self::getScrollingStyleLoader()->addPrefixPath($prefix, $path);
 222     }
 223
 224     /**
 225      * Adds an array of scrolling style prefix paths to the plugin
 226      * loader.
 227      *
 228      * <code>
 229      * $prefixPaths = array(
 230      *     'My_Paginator_ScrollingStyle'   => 'My/Paginator/ScrollingStyle/',
 231      *     'Your_Paginator_ScrollingStyle' => 'Your/Paginator/ScrollingStyle/'
 232      * );
 233      * </code>
 234      *
 235      * @param array $prefixPaths
 236      */
 237     public static function addScrollingStylePrefixPaths(array $prefixPaths)
 238     {
 239         if (isset($prefixPaths['prefix']) && isset($prefixPaths['path'])) {
 240             self::addScrollingStylePrefixPath($prefixPaths['prefix'], $prefixPaths['path']);
 241         } else {
 242             foreach ($prefixPaths as $prefix => $path) {
 243                 if (is_array($path) && isset($path['prefix']) && isset($path['path'])) {
 244                     $prefix = $path['prefix'];
 245                     $path   = $path['path'];
 246                 }
 247
 248                 self::addScrollingStylePrefixPath($prefix, $path);
 249             }
 250         }
 251     }
 252
 253     /**
 254      * Factory.
 255      *
 256      * @param  mixed $data
 257      * @param  string $adapter
 258      * @param  array $prefixPaths
 259      * @return Zend_Paginator
 260      */
 261     public static function factory($data, $adapter = self::INTERNAL_ADAPTER,
 262                                    array $prefixPaths = null)
 263     {
 264         if ($data instanceof Zend_Paginator_AdapterAggregate) {
 265             return new self($data->getPaginatorAdapter());
 266         } else {
 267             if ($adapter == self::INTERNAL_ADAPTER) {
 268                 if (is_array($data)) {
 269                     $adapter = 'Array';
 270                 } else if ($data instanceof Zend_Db_Table_Select) {
 271                     $adapter = 'DbTableSelect';
 272                 } else if ($data instanceof Zend_Db_Select) {
 273                     $adapter = 'DbSelect';
 274                 } else if ($data instanceof Iterator) {
 275                     $adapter = 'Iterator';
 276                 } else if (is_integer($data)) {
 277                     $adapter = 'Null';
 278                 } else {
 279                     $type = (is_object($data)) ? get_class($data) : gettype($data);
 280
 281                     /**
 282                      * @see Zend_Paginator_Exception
 283                      */
 284                     require_once 'Zend/Paginator/Exception.php';
 285
 286                     throw new Zend_Paginator_Exception('No adapter for type ' . $type);
 287                 }
 288             }
 289
 290             $pluginLoader = self::getAdapterLoader();
 291
 292             if (null !== $prefixPaths) {
 293                 foreach ($prefixPaths as $prefix => $path) {
 294                     $pluginLoader->addPrefixPath($prefix, $path);
 295                 }
 296             }
 297
 298             $adapterClassName = $pluginLoader->load($adapter);
 299
 300             return new self(new $adapterClassName($data));
 301         }
 302     }
 303
 304     /**
 305      * Returns the adapter loader.  If it doesn't exist it's created.
 306      *
 307      * @return Zend_Loader_PluginLoader
 308      */
 309     public static function getAdapterLoader()
 310     {
 311         if (self::$_adapterLoader === null) {
 312             self::$_adapterLoader = new Zend_Loader_PluginLoader(
 313                 array('Zend_Paginator_Adapter' => 'Zend/Paginator/Adapter')
 314             );
 315         }
 316
 317         return self::$_adapterLoader;
 318     }
 319
 320     /**
 321      * Set a global config
 322      *
 323      * @param Zend_Config $config
 324      */
 325     public static function setConfig(Zend_Config $config)
 326     {
 327         self::$_config = $config;
 328
 329         $adapterPaths = $config->get('adapterpaths');
 330
 331         if ($adapterPaths != null) {
 332             self::addAdapterPrefixPaths($adapterPaths->adapterpath->toArray());
 333         }
 334
 335         $prefixPaths = $config->get('prefixpaths');
 336
 337         if ($prefixPaths != null) {
 338             self::addScrollingStylePrefixPaths($prefixPaths->prefixpath->toArray());
 339         }
 340
 341         $scrollingStyle = $config->get('scrollingstyle');
 342
 343         if ($scrollingStyle != null) {
 344             self::setDefaultScrollingStyle($scrollingStyle);
 345         }
 346     }
 347
 348     /**
 349      * Returns the default scrolling style.
 350      *
 351      * @return  string
 352      */
 353     public static function getDefaultScrollingStyle()
 354     {
 355         return self::$_defaultScrollingStyle;
 356     }
 357
 358     /**
 359      * Get the default item count per page
 360      *
 361      * @return int
 362      */
 363     public static function getDefaultItemCountPerPage()
 364     {
 365         return self::$_defaultItemCountPerPage;
 366     }
 367
 368     /**
 369      * Set the default item count per page
 370      *
 371      * @param int $count
 372      */
 373     public static function setDefaultItemCountPerPage($count)
 374     {
 375         self::$_defaultItemCountPerPage = (int) $count;
 376     }
 377
 378     /**
 379      * Sets a cache object
 380      *
 381      * @param Zend_Cache_Core $cache
 382      */
 383     public static function setCache(Zend_Cache_Core $cache)
 384     {
 385         self::$_cache = $cache;
 386     }
 387
 388     /**
 389      * Sets the default scrolling style.
 390      *
 391      * @param  string $scrollingStyle
 392      */
 393     public static function setDefaultScrollingStyle($scrollingStyle = 'Sliding')
 394     {
 395         self::$_defaultScrollingStyle = $scrollingStyle;
 396     }
 397
 398     /**
 399      * Returns the scrolling style loader.  If it doesn't exist it's
 400      * created.
 401      *
 402      * @return Zend_Loader_PluginLoader
 403      */
 404     public static function getScrollingStyleLoader()
 405     {
 406         if (self::$_scrollingStyleLoader === null) {
 407             self::$_scrollingStyleLoader = new Zend_Loader_PluginLoader(
 408                 array('Zend_Paginator_ScrollingStyle' => 'Zend/Paginator/ScrollingStyle')
 409             );
 410         }
 411
 412         return self::$_scrollingStyleLoader;
 413     }
 414
 415     /**
 416      * Constructor.
 417      *
 418      * @param Zend_Paginator_Adapter_Interface|Zend_Paginator_AdapterAggregate $adapter
 419      */
 420     public function __construct($adapter)
 421     {
 422         if ($adapter instanceof Zend_Paginator_Adapter_Interface) {
 423             $this->_adapter = $adapter;
 424         } else if ($adapter instanceof Zend_Paginator_AdapterAggregate) {
 425             $this->_adapter = $adapter->getPaginatorAdapter();
 426         } else {
 427             /**
 428              * @see Zend_Paginator_Exception
 429              */
 430             require_once 'Zend/Paginator/Exception.php';
 431
 432             throw new Zend_Paginator_Exception(
 433                 'Zend_Paginator only accepts instances of the type ' .
 434                 'Zend_Paginator_Adapter_Interface or Zend_Paginator_AdapterAggregate.'
 435             );
 436         }
 437
 438         $config = self::$_config;
 439
 440         if ($config != null) {
 441             $setupMethods = array('ItemCountPerPage', 'PageRange');
 442
 443             foreach ($setupMethods as $setupMethod) {
 444                 $value = $config->get(strtolower($setupMethod));
 445
 446                 if ($value != null) {
 447                     $setupMethod = 'set' . $setupMethod;
 448                     $this->$setupMethod($value);
 449                 }
 450             }
 451         }
 452     }
 453
 454     /**
 455      * Serializes the object as a string.  Proxies to {@link render()}.
 456      *
 457      * @return string
 458      */
 459     public function __toString()
 460     {
 461         try {
 462             $return = $this->render();
 463             return $return;
 464         } catch (Exception $e) {
 465             trigger_error($e->getMessage(), E_USER_WARNING);
 466         }
 467
 468         return '';
 469     }
 470
 471     /**
 472      * Enables/Disables the cache for this instance
 473      *
 474      * @param bool $enable
 475      * @return Zend_Paginator
 476      */
 477     public function setCacheEnabled($enable)
 478     {
 479         $this->_cacheEnabled = (bool)$enable;
 480         return $this;
 481     }
 482
 483     /**
 484      * Returns the number of pages.
 485      *
 486      * @return integer
 487      */
 488     public function count()
 489     {
 490         if (!$this->_pageCount) {
 491             $this->_pageCount = $this->_calculatePageCount();
 492         }
 493
 494         return $this->_pageCount;
 495     }
 496
 497     /**
 498      * Returns the total number of items available.
 499      *
 500      * @return integer
 501      */
 502     public function getTotalItemCount()
 503     {
 504         return count($this->getAdapter());
 505     }
 506
 507     /**
 508      * Clear the page item cache.
 509      *
 510      * @param int $pageNumber
 511      * @return Zend_Paginator
 512      */
 513     public function clearPageItemCache($pageNumber = null)
 514     {
 515         if (!$this->_cacheEnabled()) {
 516             return $this;
 517         }
 518
 519         if (null === $pageNumber) {
 520             $cleanTags = self::CACHE_TAG_PREFIX;
 521             foreach (self::$_cache->getIdsMatchingTags(array($this->_getCacheInternalId())) as $id) {
 522                 if (preg_match('|'.self::CACHE_TAG_PREFIX."(\d+)_.*|", $id, $page)) {
 523                     self::$_cache->remove($this->_getCacheId($page[1]));
 524                 }
 525             }
 526         } else {
 527             $cleanId = $this->_getCacheId($pageNumber);
 528             self::$_cache->remove($cleanId);
 529         }
 530         return $this;
 531     }
 532
 533     /**
 534      * Returns the absolute item number for the specified item.
 535      *
 536      * @param  integer $relativeItemNumber Relative item number
 537      * @param  integer $pageNumber Page number
 538      * @return integer
 539      */
 540     public function getAbsoluteItemNumber($relativeItemNumber, $pageNumber = null)
 541     {
 542         $relativeItemNumber = $this->normalizeItemNumber($relativeItemNumber);
 543
 544         if ($pageNumber == null) {
 545             $pageNumber = $this->getCurrentPageNumber();
 546         }
 547
 548         $pageNumber = $this->normalizePageNumber($pageNumber);
 549
 550         return (($pageNumber - 1) * $this->getItemCountPerPage()) + $relativeItemNumber;
 551     }
 552
 553     /**
 554      * Returns the adapter.
 555      *
 556      * @return Zend_Paginator_Adapter_Interface
 557      */
 558     public function getAdapter()
 559     {
 560         return $this->_adapter;
 561     }
 562
 563     /**
 564      * Returns the number of items for the current page.
 565      *
 566      * @return integer
 567      */
 568     public function getCurrentItemCount()
 569     {
 570         if ($this->_currentItemCount === null) {
 571             $this->_currentItemCount = $this->getItemCount($this->getCurrentItems());
 572         }
 573
 574         return $this->_currentItemCount;
 575     }
 576
 577     /**
 578      * Returns the items for the current page.
 579      *
 580      * @return Traversable
 581      */
 582     public function getCurrentItems()
 583     {
 584         if ($this->_currentItems === null) {
 585             $this->_currentItems = $this->getItemsByPage($this->getCurrentPageNumber());
 586         }
 587
 588         return $this->_currentItems;
 589     }
 590
 591     /**
 592      * Returns the current page number.
 593      *
 594      * @return integer
 595      */
 596     public function getCurrentPageNumber()
 597     {
 598         return $this->normalizePageNumber($this->_currentPageNumber);
 599     }
 600
 601     /**
 602      * Sets the current page number.
 603      *
 604      * @param  integer $pageNumber Page number
 605      * @return Zend_Paginator $this
 606      */
 607     public function setCurrentPageNumber($pageNumber)
 608     {
 609         $this->_currentPageNumber = (integer) $pageNumber;
 610         $this->_currentItems      = null;
 611         $this->_currentItemCount  = null;
 612
 613         return $this;
 614     }
 615
 616     /**
 617      * Get the filter
 618      *
 619      * @return Zend_Filter_Interface
 620      */
 621     public function getFilter()
 622     {
 623         return $this->_filter;
 624     }
 625
 626     /**
 627      * Set a filter chain
 628      *
 629      * @param Zend_Filter_Interface $filter
 630      * @return Zend_Paginator
 631      */
 632     public function setFilter(Zend_Filter_Interface $filter)
 633     {
 634         $this->_filter = $filter;
 635
 636         return $this;
 637     }
 638
 639     /**
 640      * Returns an item from a page.  The current page is used if there's no
 641      * page sepcified.
 642      *
 643      * @param  integer $itemNumber Item number (1 to itemCountPerPage)
 644      * @param  integer $pageNumber
 645      * @return mixed
 646      */
 647     public function getItem($itemNumber, $pageNumber = null)
 648     {
 649         $itemNumber = $this->normalizeItemNumber($itemNumber);
 650
 651         if ($pageNumber == null) {
 652             $pageNumber = $this->getCurrentPageNumber();
 653         }
 654
 655         $page = $this->getItemsByPage($pageNumber);
 656         $itemCount = $this->getItemCount($page);
 657
 658         if ($itemCount == 0) {
 659             /**
 660              * @see Zend_Paginator_Exception
 661              */
 662             require_once 'Zend/Paginator/Exception.php';
 663
 664             throw new Zend_Paginator_Exception('Page ' . $pageNumber . ' does not exist');
 665         }
 666
 667         if ($itemNumber > $itemCount) {
 668             /**
 669              * @see Zend_Paginator_Exception
 670              */
 671             require_once 'Zend/Paginator/Exception.php';
 672
 673             throw new Zend_Paginator_Exception('Page ' . $pageNumber . ' does not'
 674                                              . ' contain item number ' . $itemNumber);
 675         }
 676
 677         return $page[$itemNumber - 1];
 678     }
 679
 680     /**
 681      * Returns the number of items per page.
 682      *
 683      * @return integer
 684      */
 685     public function getItemCountPerPage()
 686     {
 687         if (empty($this->_itemCountPerPage)) {
 688             $this->_itemCountPerPage = self::getDefaultItemCountPerPage();
 689         }
 690
 691         return $this->_itemCountPerPage;
 692     }
 693
 694     /**
 695      * Sets the number of items per page.
 696      *
 697      * @param  integer $itemCountPerPage
 698      * @return Zend_Paginator $this
 699      */
 700     public function setItemCountPerPage($itemCountPerPage)
 701     {
 702         $this->_itemCountPerPage = (integer) $itemCountPerPage;
 703         if ($this->_itemCountPerPage < 1) {
 704             $this->_itemCountPerPage = $this->getItemCountPerPage();
 705         }
 706         $this->_pageCount        = $this->_calculatePageCount();
 707         $this->_currentItems     = null;
 708         $this->_currentItemCount = null;
 709
 710         return $this;
 711     }
 712
 713     /**
 714      * Returns the number of items in a collection.
 715      *
 716      * @param  mixed $items Items
 717      * @return integer
 718      */
 719     public function getItemCount($items)
 720     {
 721         $itemCount = 0;
 722
 723         if (is_array($items) || $items instanceof Countable) {
 724             $itemCount = count($items);
 725         } else { // $items is something like LimitIterator
 726             $itemCount = iterator_count($items);
 727         }
 728
 729         return $itemCount;
 730     }
 731
 732     /**
 733      * Returns the items for a given page.
 734      *
 735      * @return Traversable
 736      */
 737     public function getItemsByPage($pageNumber)
 738     {
 739         $pageNumber = $this->normalizePageNumber($pageNumber);
 740
 741         if ($this->_cacheEnabled()) {
 742             $data = self::$_cache->load($this->_getCacheId($pageNumber));
 743             if ($data !== false) {
 744                 return $data;
 745             }
 746         }
 747
 748         $offset = ($pageNumber - 1) * $this->getItemCountPerPage();
 749
 750         $items = $this->_adapter->getItems($offset, $this->getItemCountPerPage());
 751
 752         $filter = $this->getFilter();
 753
 754         if ($filter !== null) {
 755             $items = $filter->filter($items);
 756         }
 757
 758         if (!$items instanceof Traversable) {
 759             $items = new ArrayIterator($items);
 760         }
 761
 762         if ($this->_cacheEnabled()) {
 763             self::$_cache->save($items, $this->_getCacheId($pageNumber), array($this->_getCacheInternalId()));
 764         }
 765
 766         return $items;
 767     }
 768
 769     /**
 770      * Returns a foreach-compatible iterator.
 771      *
 772      * @return Traversable
 773      */
 774     public function getIterator()
 775     {
 776         return $this->getCurrentItems();
 777     }
 778
 779     /**
 780      * Returns the page range (see property declaration above).
 781      *
 782      * @return integer
 783      */
 784     public function getPageRange()
 785     {
 786         return $this->_pageRange;
 787     }
 788
 789     /**
 790      * Sets the page range (see property declaration above).
 791      *
 792      * @param  integer $pageRange
 793      * @return Zend_Paginator $this
 794      */
 795     public function setPageRange($pageRange)
 796     {
 797         $this->_pageRange = (integer) $pageRange;
 798
 799         return $this;
 800     }
 801
 802     /**
 803      * Returns the page collection.
 804      *
 805      * @param  string $scrollingStyle Scrolling style
 806      * @return array
 807      */
 808     public function getPages($scrollingStyle = null)
 809     {
 810         if ($this->_pages === null) {
 811             $this->_pages = $this->_createPages($scrollingStyle);
 812         }
 813
 814         return $this->_pages;
 815     }
 816
 817     /**
 818      * Returns a subset of pages within a given range.
 819      *
 820      * @param  integer $lowerBound Lower bound of the range
 821      * @param  integer $upperBound Upper bound of the range
 822      * @return array
 823      */
 824     public function getPagesInRange($lowerBound, $upperBound)
 825     {
 826         $lowerBound = $this->normalizePageNumber($lowerBound);
 827         $upperBound = $this->normalizePageNumber($upperBound);
 828
 829         $pages = array();
 830
 831         for ($pageNumber = $lowerBound; $pageNumber <= $upperBound; $pageNumber++) {
 832             $pages[$pageNumber] = $pageNumber;
 833         }
 834
 835         return $pages;
 836     }
 837
 838     /**
 839      * Returns the page item cache.
 840      *
 841      * @return array
 842      */
 843     public function getPageItemCache()
 844     {
 845         $data = array();
 846         if ($this->_cacheEnabled()) {
 847             foreach (self::$_cache->getIdsMatchingTags(array($this->_getCacheInternalId())) as $id) {
 848                     if (preg_match('|'.self::CACHE_TAG_PREFIX."(\d+)_.*|", $id, $page)) {
 849                         $data[$page[1]] = self::$_cache->load($this->_getCacheId($page[1]));
 850                     }
 851             }
 852         }
 853         return $data;
 854     }
 855
 856     /**
 857      * Retrieves the view instance.  If none registered, attempts to pull f
 858      * rom ViewRenderer.
 859      *
 860      * @return Zend_View_Interface|null
 861      */
 862     public function getView()
 863     {
 864         if ($this->_view === null) {
 865             /**
 866              * @see Zend_Controller_Action_HelperBroker
 867              */
 868             require_once 'Zend/Controller/Action/HelperBroker.php';
 869
 870             $viewRenderer = Zend_Controller_Action_HelperBroker::getStaticHelper('viewRenderer');
 871             if ($viewRenderer->view === null) {
 872                 $viewRenderer->initView();
 873             }
 874             $this->_view = $viewRenderer->view;
 875         }
 876
 877         return $this->_view;
 878     }
 879
 880     /**
 881      * Sets the view object.
 882      *
 883      * @param  Zend_View_Interface $view
 884      * @return Zend_Paginator
 885      */
 886     public function setView(Zend_View_Interface $view = null)
 887     {
 888         $this->_view = $view;
 889
 890         return $this;
 891     }
 892
 893     /**
 894      * Brings the item number in range of the page.
 895      *
 896      * @param  integer $itemNumber
 897      * @return integer
 898      */
 899     public function normalizeItemNumber($itemNumber)
 900     {
 901         if ($itemNumber < 1) {
 902             $itemNumber = 1;
 903         }
 904
 905         if ($itemNumber > $this->getItemCountPerPage()) {
 906             $itemNumber = $this->getItemCountPerPage();
 907         }
 908
 909         return $itemNumber;
 910     }
 911
 912     /**
 913      * Brings the page number in range of the paginator.
 914      *
 915      * @param  integer $pageNumber
 916      * @return integer
 917      */
 918     public function normalizePageNumber($pageNumber)
 919     {
 920         if ($pageNumber < 1) {
 921             $pageNumber = 1;
 922         }
 923
 924         $pageCount = $this->count();
 925
 926         if ($pageCount > 0 && $pageNumber > $pageCount) {
 927             $pageNumber = $pageCount;
 928         }
 929
 930         return $pageNumber;
 931     }
 932
 933     /**
 934      * Renders the paginator.
 935      *
 936      * @param  Zend_View_Interface $view
 937      * @return string
 938      */
 939     public function render(Zend_View_Interface $view = null)
 940     {
 941         if (null !== $view) {
 942             $this->setView($view);
 943         }
 944
 945         $view = $this->getView();
 946
 947         return $view->paginationControl($this);
 948     }
 949
 950     /**
 951      * Returns the items of the current page as JSON.
 952      *
 953      * @return string
 954      */
 955     public function toJson()
 956     {
 957         $currentItems = $this->getCurrentItems();
 958
 959         if ($currentItems instanceof Zend_Db_Table_Rowset_Abstract) {
 960             return Zend_Json::encode($currentItems->toArray());
 961         } else {
 962             return Zend_Json::encode($currentItems);
 963         }
 964     }
 965
 966     /**
 967      * Tells if there is an active cache object
 968      * and if the cache has not been desabled
 969      *
 970      * @return bool
 971      */
 972     protected function _cacheEnabled()
 973     {
 974         return ((self::$_cache !== null) && $this->_cacheEnabled);
 975     }
 976
 977     /**
 978      * Makes an Id for the cache
 979      * Depends on the adapter object and the page number
 980      *
 981      * Used to store item in cache from that Paginator instance
 982      *  and that current page
 983      *
 984      * @param int $page
 985      * @return string
 986      */
 987     protected function _getCacheId($page = null)
 988     {
 989         if ($page === null) {
 990             $page = $this->getCurrentPageNumber();
 991         }
 992         return self::CACHE_TAG_PREFIX . $page . '_' . $this->_getCacheInternalId();
 993     }
 994
 995     /**
 996      * Get the internal cache id
 997      * Depends on the adapter and the item count per page
 998      *
 999      * Used to tag that unique Paginator instance in cache
1000      *
1001      * @return string
1002      */
1003     protected function _getCacheInternalId()
1004     {
1005         return md5(serialize($this->getAdapter()) . $this->getItemCountPerPage());
1006     }
1007
1008     /**
1009      * Calculates the page count.
1010      *
1011      * @return integer
1012      */
1013     protected function _calculatePageCount()
1014     {
1015         return (integer) ceil($this->getAdapter()->count() / $this->getItemCountPerPage());
1016     }
1017
1018     /**
1019      * Creates the page collection.
1020      *
1021      * @param  string $scrollingStyle Scrolling style
1022      * @return stdClass
1023      */
1024     protected function _createPages($scrollingStyle = null)
1025     {
1026         $pageCount         = $this->count();
1027         $currentPageNumber = $this->getCurrentPageNumber();
1028
1029         $pages = new stdClass();
1030         $pages->pageCount        = $pageCount;
1031         $pages->itemCountPerPage = $this->getItemCountPerPage();
1032         $pages->first            = 1;
1033         $pages->current          = $currentPageNumber;
1034         $pages->last             = $pageCount;
1035
1036         // Previous and next
1037         if ($currentPageNumber - 1 > 0) {
1038             $pages->previous = $currentPageNumber - 1;
1039         }
1040
1041         if ($currentPageNumber + 1 <= $pageCount) {
1042             $pages->next = $currentPageNumber + 1;
1043         }
1044
1045         // Pages in range
1046         $scrollingStyle = $this->_loadScrollingStyle($scrollingStyle);
1047         $pages->pagesInRange     = $scrollingStyle->getPages($this);
1048         $pages->firstPageInRange = min($pages->pagesInRange);
1049         $pages->lastPageInRange  = max($pages->pagesInRange);
1050
1051         // Item numbers
1052         if ($this->getCurrentItems() !== null) {
1053             $pages->currentItemCount = $this->getCurrentItemCount();
1054             $pages->itemCountPerPage = $this->getItemCountPerPage();
1055             $pages->totalItemCount   = $this->getTotalItemCount();
1056             $pages->firstItemNumber  = (($currentPageNumber - 1) * $this->getItemCountPerPage()) + 1;
1057             $pages->lastItemNumber   = $pages->firstItemNumber + $pages->currentItemCount - 1;
1058         }
1059
1060         return $pages;
1061     }
1062
1063     /**
1064      * Loads a scrolling style.
1065      *
1066      * @param string $scrollingStyle
1067      * @return Zend_Paginator_ScrollingStyle_Interface
1068      */
1069     protected function _loadScrollingStyle($scrollingStyle = null)
1070     {
1071         if ($scrollingStyle === null) {
1072             $scrollingStyle = self::$_defaultScrollingStyle;
1073         }
1074
1075         switch (strtolower(gettype($scrollingStyle))) {
1076             case 'object':
1077                 if (!$scrollingStyle instanceof Zend_Paginator_ScrollingStyle_Interface) {
1078                     /**
1079                      * @see Zend_View_Exception
1080                      */
1081                     require_once 'Zend/View/Exception.php';
1082
1083                     throw new Zend_View_Exception('Scrolling style must implement ' .
1084                         'Zend_Paginator_ScrollingStyle_Interface');
1085                 }
1086
1087                 return $scrollingStyle;
1088
1089             case 'string':
1090                 $className = self::getScrollingStyleLoader()->load($scrollingStyle);
1091
1092                 return new $className();
1093
1094             case 'null':
1095                 // Fall through to default case
1096
1097             default:
1098                 /**
1099                  * @see Zend_View_Exception
1100                  */
1101                 require_once 'Zend/View/Exception.php';
1102
1103                 throw new Zend_View_Exception('Scrolling style must be a class ' .
1104                     'name or object implementing Zend_Paginator_ScrollingStyle_Interface');
1105         }
1106     }
1107 }