1. sfPager.class.php
  2. /**
 * sfPager class.
 *
 * @package    symfony
 * @subpackage addon
 * @author     Fabien Potencier 
 * @version    SVN: $Id: sfPager.class.php 24533 2009-11-29 15:58:01Z Kris.Wallsmith $
 */
  3. abstract class sfPager implements Iterator, Countable
  4. {
  5.   protected
  6.     $page            = 1,
  7.     $maxPerPage      = 0,
  8.     $lastPage        = 1,
  9.     $nbResults       = 0,
  10.     $class           = '',
  11.     $tableName       = '',
  12.     $objects         = null,
  13.     $cursor          = 1,
  14.     $parameters      = array(),
  15.     $currentMaxLink  = 1,
  16.     $parameterHolder = null,
  17.     $maxRecordLimit  = false,
  18.     $results         = null,
  19.     $resultsCounter  = 0;
  21.   /**
  22.    * Constructor.
  23.    *
  24.    * @param string  $class      The model class
  25.    * @param integer $maxPerPage Number of records to display per page
  26.    */
  27.   public function __construct($class, $maxPerPage = 10)
  28.   {
  29.     $this->setClass($class);
  30.     $this->setMaxPerPage($maxPerPage);
  31.     $this->parameterHolder = new sfParameterHolder();
  32.   }
  34.   /**
  35.    * Initialize the pager.
  36.    *
  37.    * Function to be called after parameters have been set.
  38.    */
  39.   abstract public function init();
  41.   /**
  42.    * Returns an array of results on the given page.
  43.    *
  44.    * @return array
  45.    */
  46.   abstract public function getResults();
  48.   /**
  49.    * Returns an object at a certain offset.
  50.    *
  51.    * Used internally by {@link getCurrent()}.
  52.    *
  53.    * @return mixed
  54.    */
  55.   abstract protected function retrieveObject($offset);
  57.   /**
  58.    * Returns the current pager's max link.
  59.    *
  60.    * @return integer
  61.    */
  62.   public function getCurrentMaxLink()
  63.   {
  64.     return $this->currentMaxLink;
  65.   }
  67.   /**
  68.    * Returns the current pager's max record limit.
  69.    *
  70.    * @return integer
  71.    */
  72.   public function getMaxRecordLimit()
  73.   {
  74.     return $this->maxRecordLimit;
  75.   }
  77.   /**
  78.    * Sets the current pager's max record limit.
  79.    *
  80.    * @param integer $limit
  81.    */
  82.   public function setMaxRecordLimit($limit)
  83.   {
  84.     $this->maxRecordLimit = $limit;
  85.   }
  87.   /**
  88.    * Returns an array of page numbers to use in pagination links.
  89.    *
  90.    * @param  integer $nb_links The maximum number of page numbers to return
  91.    *
  92.    * @return array
  93.    */
  94.   public function getLinks($nb_links = 5)
  95.   {
  96.     $links = array();
  97.     $tmp   = $this->page - floor($nb_links / 2);
  98.     $check = $this->lastPage - $nb_links + 1;
  99.     $limit = $check > 0 ? $check : 1;
  100.     $begin = $tmp > 0 ? ($tmp > $limit ? $limit : $tmp) : 1;
  102.     $i = (int) $begin;
  103.     while ($i < $begin + $nb_links && $i <= $this->lastPage)
  104.     {
  105.       $links[] = $i++;
  106.     }
  108.     $this->currentMaxLink = count($links) ? $links[count($links) - 1] : 1;
  110.     return $links;
  111.   }
  113.   /**
  114.    * Returns true if the current query requires pagination.
  115.    *
  116.    * @return boolean
  117.    */
  118.   public function haveToPaginate()
  119.   {
  120.     return $this->getMaxPerPage() && $this->getNbResults() > $this->getMaxPerPage();
  121.   }
  123.   /**
  124.    * Returns the current cursor.
  125.    *
  126.    * @return integer
  127.    */
  128.   public function getCursor()
  129.   {
  130.     return $this->cursor;
  131.   }
  133.   /**
  134.    * Sets the current cursor.
  135.    *
  136.    * @param integer $pos
  137.    */
  138.   public function setCursor($pos)
  139.   {
  140.     if ($pos < 1)
  141.     {
  142.       $this->cursor = 1;
  143.     }
  144.     else if ($pos > $this->nbResults)
  145.     {
  146.       $this->cursor = $this->nbResults;
  147.     }
  148.     else
  149.     {
  150.       $this->cursor = $pos;
  151.     }
  152.   }
  154.   /**
  155.    * Returns an object by cursor position.
  156.    *
  157.    * @param  integer $pos
  158.    *
  159.    * @return mixed
  160.    */
  161.   public function getObjectByCursor($pos)
  162.   {
  163.     $this->setCursor($pos);
  165.     return $this->getCurrent();
  166.   }
  168.   /**
  169.    * Returns the current object.
  170.    *
  171.    * @return mixed
  172.    */
  173.   public function getCurrent()
  174.   {
  175.     return $this->retrieveObject($this->cursor);
  176.   }
  178.   /**
  179.    * Returns the next object.
  180.    *
  181.    * @return mixed|null
  182.    */
  183.   public function getNext()
  184.   {
  185.     if ($this->cursor + 1 > $this->nbResults)
  186.     {
  187.       return null;
  188.     }
  189.     else
  190.     {
  191.       return $this->retrieveObject($this->cursor + 1);
  192.     }
  193.   }
  195.   /**
  196.    * Returns the previous object.
  197.    *
  198.    * @return mixed|null
  199.    */
  200.   public function getPrevious()
  201.   {
  202.     if ($this->cursor - 1 < 1)
  203.     {
  204.       return null;
  205.     }
  206.     else
  207.     {
  208.       return $this->retrieveObject($this->cursor - 1);
  209.     }
  210.   }
  212.   /**
  213.    * Returns the first index on the current page.
  214.    *
  215.    * @return integer
  216.    */
  217.   public function getFirstIndice()
  218.   {
  219.     if ($this->page == 0)
  220.     {
  221.       return 1;
  222.     }
  223.     else
  224.     {
  225.       return ($this->page - 1) * $this->maxPerPage + 1;
  226.     }
  227.   }
  229.   /**
  230.    * Returns the last index on the current page.
  231.    *
  232.    * @return integer
  233.    */
  234.   public function getLastIndice()
  235.   {
  236.     if ($this->page == 0)
  237.     {
  238.       return $this->nbResults;
  239.     }
  240.     else
  241.     {
  242.       if ($this->page * $this->maxPerPage >= $this->nbResults)
  243.       {
  244.         return $this->nbResults;
  245.       }
  246.       else
  247.       {
  248.         return $this->page * $this->maxPerPage;
  249.       }
  250.     }
  251.   }
  253.   /**
  254.    * Returns the current class.
  255.    *
  256.    * @return string
  257.    */
  258.   public function getClass()
  259.   {
  260.     return $this->class;
  261.   }
  263.   /**
  264.    * Sets the current class.
  265.    *
  266.    * @param string $class
  267.    */
  268.   public function setClass($class)
  269.   {
  270.     $this->class = $class;
  271.   }
  273.   /**
  274.    * Returns the number of results.
  275.    *
  276.    * @return integer
  277.    */
  278.   public function getNbResults()
  279.   {
  280.     return $this->nbResults;
  281.   }
  283.   /**
  284.    * Sets the number of results.
  285.    *
  286.    * @param integer $nb
  287.    */
  288.   protected function setNbResults($nb)
  289.   {
  290.     $this->nbResults = $nb;
  291.   }
  293.   /**
  294.    * Returns the first page number.
  295.    *
  296.    * @return integer
  297.    */
  298.   public function getFirstPage()
  299.   {
  300.     return 1;
  301.   }
  303.   /**
  304.    * Returns the last page number.
  305.    *
  306.    * @return integer
  307.    */
  308.   public function getLastPage()
  309.   {
  310.     return $this->lastPage;
  311.   }
  313.   /**
  314.    * Sets the last page number.
  315.    *
  316.    * @param integer $page
  317.    */
  318.   protected function setLastPage($page)
  319.   {
  320.     $this->lastPage = $page;
  322.     if ($this->getPage() > $page)
  323.     {
  324.       $this->setPage($page);
  325.     }
  326.   }
  328.   /**
  329.    * Returns the current page.
  330.    *
  331.    * @return integer
  332.    */
  333.   public function getPage()
  334.   {
  335.     return $this->page;
  336.   }
  338.   /**
  339.    * Returns the next page.
  340.    *
  341.    * @return integer
  342.    */
  343.   public function getNextPage()
  344.   {
  345.     return min($this->getPage() + 1, $this->getLastPage());
  346.   }
  348.   /**
  349.    * Returns the previous page.
  350.    *
  351.    * @return integer
  352.    */
  353.   public function getPreviousPage()
  354.   {
  355.     return max($this->getPage() - 1, $this->getFirstPage());
  356.   }
  358.   /**
  359.    * Sets the current page.
  360.    *
  361.    * @param integer $page
  362.    */
  363.   public function setPage($page)
  364.   {
  365.     $this->page = intval($page);
  367.     if ($this->page <= 0)
  368.     {
  369.       // set first page, which depends on a maximum set
  370.       $this->page = $this->getMaxPerPage() ? 1 : 0;
  371.     }
  372.   }
  374.   /**
  375.    * Returns the maximum number of results per page.
  376.    *
  377.    * @return integer
  378.    */
  379.   public function getMaxPerPage()
  380.   {
  381.     return $this->maxPerPage;
  382.   }
  384.   /**
  385.    * Sets the maximum number of results per page.
  386.    *
  387.    * @param integer $max
  388.    */
  389.   public function setMaxPerPage($max)
  390.   {
  391.     if ($max > 0)
  392.     {
  393.       $this->maxPerPage = $max;
  394.       if ($this->page == 0)
  395.       {
  396.         $this->page = 1;
  397.       }
  398.     }
  399.     else if ($max == 0)
  400.     {
  401.       $this->maxPerPage = 0;
  402.       $this->page = 0;
  403.     }
  404.     else
  405.     {
  406.       $this->maxPerPage = 1;
  407.       if ($this->page == 0)
  408.       {
  409.         $this->page = 1;
  410.       }
  411.     }
  412.   }
  414.   /**
  415.    * Returns true if on the first page.
  416.    *
  417.    * @return boolean
  418.    */
  419.   public function isFirstPage()
  420.   {
  421.     return 1 == $this->page;
  422.   }
  424.   /**
  425.    * Returns true if on the last page.
  426.    *
  427.    * @return boolean
  428.    */
  429.   public function isLastPage()
  430.   {
  431.     return $this->page == $this->lastPage;
  432.   }
  434.   /**
  435.    * Returns the current pager's parameter holder.
  436.    *
  437.    * @return sfParameterHolder
  438.    */
  439.   public function getParameterHolder()
  440.   {
  441.     return $this->parameterHolder;
  442.   }
  444.   /**
  445.    * Returns a parameter.
  446.    *
  447.    * @param  string $name
  448.    * @param  mixed  $default
  449.    *
  450.    * @return mixed
  451.    */
  452.   public function getParameter($name, $default = null)
  453.   {
  454.     return $this->parameterHolder->get($name, $default);
  455.   }
  457.   /**
  458.    * Checks whether a parameter has been set.
  459.    *
  460.    * @param  string $name
  461.    *
  462.    * @return boolean
  463.    */
  464.   public function hasParameter($name)
  465.   {
  466.     return $this->parameterHolder->has($name);
  467.   }
  469.   /**
  470.    * Sets a parameter.
  471.    *
  472.    * @param  string $name
  473.    * @param  mixed  $value
  474.    */
  475.   public function setParameter($name, $value)
  476.   {
  477.     $this->parameterHolder->set($name, $value);
  478.   }
  480.   /**
  481.    * Returns the current result.
  482.    *
  483.    * @see Iterator
  484.    */
  485.   public function current()
  486.   {
  487.     if (null === $this->results)
  488.     {
  489.       $this->results = $this->getResults();
  490.       $this->resultsCounter = count($this->results);
  491.     }
  493.     return current($this->results);
  494.   }
  496.   /**
  497.    * Returns the current key.
  498.    *
  499.    * @see Iterator
  500.    */
  501.   public function key()
  502.   {
  503.     if (null === $this->results)
  504.     {
  505.       $this->results = $this->getResults();
  506.       $this->resultsCounter = count($this->results);
  507.     }
  509.     return key($this->results);
  510.   }
  512.   /**
  513.    * Advances the internal pointer and returns the current result.
  514.    *
  515.    * @see Iterator
  516.    */
  517.   public function next()
  518.   {
  519.     if (null === $this->results)
  520.     {
  521.       $this->results = $this->getResults();
  522.       $this->resultsCounter = count($this->results);
  523.     }
  525.     --$this->resultsCounter;
  527.     return next($this->results);
  528.   }
  530.   /**
  531.    * Resets the internal pointer and returns the current result.
  532.    *
  533.    * @see Iterator
  534.    */
  535.   public function rewind()
  536.   {
  537.     if (null === $this->results)
  538.     {
  539.       $this->results = $this->getResults();
  540.       $this->resultsCounter = count($this->results);
  541.     }
  543.     return reset($this->results);
  544.   }
  546.   /**
  547.    * Returns true if pointer is within bounds.
  548.    *
  549.    * @see Iterator
  550.    */
  551.   public function valid()
  552.   {
  553.     if (null === $this->results)
  554.     {
  555.       $this->results = $this->getResults();
  556.       $this->resultsCounter = count($this->results);
  557.     }
  559.     return $this->resultsCounter > 0;
  560.   }
  562.   /**
  563.    * Returns the total number of results.
  564.    *
  565.    * @see Countable
  566.    */
  567.   public function count()
  568.   {
  569.     return $this->getNbResults();
  570.   }
  571. }
Debug toolbar