buzzerstar - static - core - DataTable - SOURCE CODE

<?php
/**
 * Piwik - free/libre analytics platform
 *
 * @link http://piwik.org
 * @license http://www.gnu.org/licenses/gpl-3.0.html GPL v3 or later
 *
 */
namespace Piwik\DataTable\Filter;

use Piwik\DataTable\BaseFilter;
use Piwik\DataTable;
use Piwik\Plugin\Metric;
use Piwik\Plugins\CoreHome\Columns\Metrics\ActionsPerVisit;
use Piwik\Plugins\CoreHome\Columns\Metrics\AverageTimeOnSite;
use Piwik\Plugins\CoreHome\Columns\Metrics\BounceRate;
use Piwik\Plugins\CoreHome\Columns\Metrics\ConversionRate;

/**
 * Adds processed metrics columns to a {@link DataTable} using metrics that already exist.
 *
 * Columns added are:
 *
 * - **conversion_rate**: percent value of `nb_visits_converted / nb_visits
 * - **nb_actions_per_visit**: `nb_actions / nb_visits`
 * - **avg_time_on_site**: in number of seconds, `round(visit_length / nb_visits)`. Not
 *                         pretty formatted.
 * - **bounce_rate**: percent value of `bounce_count / nb_visits`
 *
 * Adding the **filter_add_columns_when_show_all_columns** query parameter to
 * an API request will trigger the execution of this Filter.
 *
 * _Note: This filter must be called before {@link ReplaceColumnNames} is called._
 *
 * **Basic usage example**
 *
 *     $dataTable->filter('AddColumnsProcessedMetrics');
 *
 * @api
 */
class AddColumnsProcessedMetrics extends BaseFilter
{
    protected $invalidDivision = 0;
    protected $roundPrecision = 2;
    protected $deleteRowsWithNoVisit = true;

    /**
     * Constructor.
     *
     * @param DataTable $table The table to eventually filter.

... [truncated, 46 more lines] ...

<?php
/**
 * Piwik - free/libre analytics platform
 *
 * @link http://piwik.org
 * @license http://www.gnu.org/licenses/gpl-3.0.html GPL v3 or later
 *
 */
namespace Piwik\DataTable\Filter;

use Piwik\Archive\DataTableFactory;
use Piwik\DataTable;
use Piwik\Piwik;
use Piwik\Plugin\Metric;
use Piwik\Plugins\Goals\Columns\Metrics\GoalSpecific\AverageOrderRevenue;
use Piwik\Plugins\Goals\Columns\Metrics\GoalSpecific\ConversionRate;
use Piwik\Plugins\Goals\Columns\Metrics\GoalSpecific\Conversions;
use Piwik\Plugins\Goals\Columns\Metrics\GoalSpecific\ItemsCount;
use Piwik\Plugins\Goals\Columns\Metrics\GoalSpecific\Revenue;
use Piwik\Plugins\Goals\Columns\Metrics\GoalSpecific\RevenuePerVisit as GoalSpecificRevenuePerVisit;
use Piwik\Plugins\Goals\Columns\Metrics\RevenuePerVisit;

/**
 * Adds goal related metrics to a {@link DataTable} using metrics that already exist.
 *
 * Metrics added are:
 *
 * - **revenue_per_visit**: total goal and ecommerce revenue / nb_visits
 * - **goal_%idGoal%_conversion_rate**: the conversion rate. There will be one of
 *                                      these columns for each goal that exists
 *                                      for the site.
 * - **goal_%idGoal%_nb_conversions**: the number of conversions. There will be one of
 *                                     these columns for each goal that exists
 *                                     for the site.
 * - **goal_%idGoal%_revenue_per_visit**: goal revenue / nb_visits. There will be one of
 *                                        these columns for each goal that exists
 *                                        for the site.
 * - **goal_%idGoal%_revenue**: goal revenue. There will be one of
 *                              these columns for each goal that exists
 *                              for the site.
 * - **goal_%idGoal%_avg_order_revenue**: goal revenue / number of orders or abandoned
 *                                        carts. Only for ecommerce order and abandoned cart
 *                                        reports.
 * - **goal_%idGoal%_items**: number of items. Only for ecommerce order and abandoned cart
 *                            reports.
 *
 * Adding the **filter_update_columns_when_show_all_goals** query parameter to
 * an API request will trigger the execution of this Filter.
 *
 * _Note: This filter must be called before {@link ReplaceColumnNames} is called._

... [truncated, 116 more lines] ...

<?php
/**
 * Piwik - free/libre analytics platform
 *
 * @link http://piwik.org
 * @license http://www.gnu.org/licenses/gpl-3.0.html GPL v3 or later
 *
 */
namespace Piwik\DataTable\Filter;

use Piwik\DataTable;
use Piwik\DataTable\BaseFilter;
use Piwik\Development;

/**
 * Executes a filter for each row of a {@link DataTable} and generates a segment filter for each row.
 *
 * **Basic usage example**
 *
 *     $dataTable->filter('AddSegmentByLabel', array('segmentName'));
 *     $dataTable->filter('AddSegmentByLabel', array(array('segmentName1', 'segment2'), ';');
 *
 * @api
 */
class AddSegmentByLabel extends BaseFilter
{
    private $segments;
    private $delimiter;

    /**
     * Generates a segment filter based on the label column and the given segment names
     *
     * @param DataTable $table
     * @param string|array $segmentOrSegments Either one segment or an array of segments.
     *                                        If more than one segment is given a delimter has to be defined.
     * @param string $delimiter               The delimiter by which the label should be splitted.
     */
    public function __construct($table, $segmentOrSegments, $delimiter = '')
    {
        parent::__construct($table);

        if (!is_array($segmentOrSegments)) {
            $segmentOrSegments = array($segmentOrSegments);
        }

        $this->segments  = $segmentOrSegments;
        $this->delimiter = $delimiter;
    }

    /**

... [truncated, 50 more lines] ...

<?php
/**
 * Piwik - free/libre analytics platform
 *
 * @link http://piwik.org
 * @license http://www.gnu.org/licenses/gpl-3.0.html GPL v3 or later
 *
 */
namespace Piwik\DataTable\Filter;

use Piwik\DataTable;
use Piwik\DataTable\BaseFilter;

/**
 * Executes a filter for each row of a {@link DataTable} and generates a segment filter for each row.
 * It will map the label column to a segmentValue by searching for the label in the index of the given
 * mapping array.
 *
 * **Basic usage example**
 *
 *     $dataTable->filter('AddSegmentByLabelMapping', array('segmentName', array('1' => 'smartphone, '2' => 'desktop')));
 *
 * @api
 */
class AddSegmentByLabelMapping extends BaseFilter
{
    private $segment;
    private $mapping;

    /**
     * @param DataTable $table
     * @param string $segment
     * @param array $mapping
     */
    public function __construct($table, $segment, $mapping)
    {
        parent::__construct($table);

        $this->segment = $segment;
        $this->mapping = $mapping;
    }

    /**
     * See {@link AddSegmentByLabelMapping}.
     *
     * @param DataTable $table
     */
    public function filter($table)
    {
        if (empty($this->segment) || empty($this->mapping)) {

... [truncated, 14 more lines] ...

<?php
/**
 * Piwik - free/libre analytics platform
 *
 * @link http://piwik.org
 * @license http://www.gnu.org/licenses/gpl-3.0.html GPL v3 or later
 *
 */
namespace Piwik\DataTable\Filter;

use Piwik\DataTable\BaseFilter;
use Piwik\DataTable;

/**
 * Converts for each row of a {@link DataTable} a segmentValue to a segment (expression). The name of the segment
 * is automatically detected based on the given report.
 *
 * **Basic usage example**
 *
 *     $dataTable->filter('AddSegmentBySegmentValue', array($reportInstance));
 *
 * @api
 */
class AddSegmentBySegmentValue extends BaseFilter
{
    /**
     * @var \Piwik\Plugin\Report
     */
    private $report;

    /**
     * @param DataTable $table
     * @param $report
     */
    public function __construct($table, $report)
    {
        parent::__construct($table);
        $this->report = $report;
    }

    /**
     * See {@link AddSegmentBySegmentValue}.
     *
     * @param DataTable $table
     * @return int The number of deleted rows.
     */
    public function filter($table)
    {
        if (empty($this->report) || !$table->getRowsCount()) {
            return;

... [truncated, 29 more lines] ...

<?php
/**
 * Piwik - free/libre analytics platform
 *
 * @link http://piwik.org
 * @license http://www.gnu.org/licenses/gpl-3.0.html GPL v3 or later
 *
 */
namespace Piwik\DataTable\Filter;

use Piwik\DataTable;

/**
 * Executes a filter for each row of a {@link DataTable} and generates a segment filter for each row.
 *
 * **Basic usage example**
 *
 *     $dataTable->filter('AddSegmentValue', array());
 *     $dataTable->filter('AddSegmentValue', array(function ($label) {
 *        $transformedValue = urldecode($transformedValue);
 *        return $transformedValue;
 *    });
 *
 * @api
 */
class AddSegmentValue extends ColumnCallbackAddMetadata
{
    public function __construct($table, $callback = null)
    {
        parent::__construct($table, 'label', 'segmentValue', $callback, null, false);
    }
}

<?php
/**
 * Piwik - free/libre analytics platform
 *
 * @link http://piwik.org
 * @license http://www.gnu.org/licenses/gpl-3.0.html GPL v3 or later
 *
 */
namespace Piwik\DataTable\Filter;

use Piwik\DataTable\BaseFilter;
use Piwik\DataTable;
use Piwik\DataTable\Row\DataTableSummaryRow;

/**
 * Adds a summary row to {@link DataTable}s that contains the sum of all other table rows.
 *
 * **Basic usage example**
 *
 *     $dataTable->filter('AddSummaryRow');
 *
 *     // use a human readable label for the summary row (instead of '-1')
 *     $dataTable->filter('AddSummaryRow', array($labelSummaryRow = Piwik::translate('General_Total')));
 *
 * @api
 */
class AddSummaryRow extends BaseFilter
{
    /**
     * Constructor.
     *
     * @param DataTable $table The table that will be filtered.
     * @param int $labelSummaryRow The value of the label column for the new row.
     */
    public function __construct($table, $labelSummaryRow = DataTable::LABEL_SUMMARY_ROW)
    {
        parent::__construct($table);
        $this->labelSummaryRow = $labelSummaryRow;
    }

    /**
     * Executes the filter. See {@link AddSummaryRow}.
     *
     * @param DataTable $table
     */
    public function filter($table)
    {
        $row = new DataTableSummaryRow($table);
        $row->setColumn('label', $this->labelSummaryRow);
        $table->addSummaryRow($row);

... [truncated, 3 more lines] ...

<?php
/**
 * Piwik - free/libre analytics platform
 *
 * @link http://piwik.org
 * @license http://www.gnu.org/licenses/gpl-3.0.html GPL v3 or later
 *
 */
namespace Piwik\DataTable\Filter;

use Piwik\DataTable;
use Piwik\Piwik;

/**
 * A {@link DataTable} filter that replaces range label columns with prettier,
 * human-friendlier versions.
 *
 * When reports that summarize data over a set of ranges (such as the
 * reports in the **VisitorInterest** plugin) are archived, they are
 * archived with labels that read as: '$min-$max' or '$min+'. These labels
 * have no units and can look like '1-1'.
 *
 * This filter can be used to clean up and add units to those range labels. To
 * do this, you supply a string to use when the range specifies only
 * one unit (ie '1-1') and another format string when the range specifies
 * more than one unit (ie '2-2', '3-5' or '6+').
 *
 * This filter can be extended to vary exactly how ranges are prettified based
 * on the range values found in the DataTable. To see an example of this,
 * take a look at the {@link BeautifyTimeRangeLabels} filter.
 *
 * **Basic usage example**
 *
 *     $dataTable->queueFilter('BeautifyRangeLabels', array("1 visit", "%s visits"));
 *
 * @api
 */
class BeautifyRangeLabels extends ColumnCallbackReplace
{
    /**
     * The string to use when the range being beautified is between 1-1 units.
     * @var string
     */
    protected $labelSingular;

    /**
     * The format string to use when the range being beautified references more than
     * one unit.
     * @var string
     */

... [truncated, 119 more lines] ...

<?php
/**
 * Piwik - free/libre analytics platform
 *
 * @link http://piwik.org
 * @license http://www.gnu.org/licenses/gpl-3.0.html GPL v3 or later
 *
 */
namespace Piwik\DataTable\Filter;

use Piwik\DataTable;

/**
 * A {@link DataTable} filter that replaces range labels whose values are in seconds with
 * prettier, human-friendlier versions.
 *
 * This filter customizes the behavior of the {@link BeautifyRangeLabels} filter
 * so range values that are less than one minute are displayed in seconds but
 * other ranges are displayed in minutes.
 *
 * **Basic usage**
 *
 *     $dataTable->filter('BeautifyTimeRangeLabels', array("%1$s-%2$s min", "1 min", "%s min"));
 *
 * @api
 */
class BeautifyTimeRangeLabels extends BeautifyRangeLabels
{
    /**
     * A format string used to create pretty range labels when the range's
     * lower bound is between 0 and 60.
     *
     * This format string must take two numeric parameters, one for each
     * range bound.
     */
    protected $labelSecondsPlural;

    /**
     * Constructor.
     *
     * @param DataTable $table The DataTable this filter will run over.
     * @param string $labelSecondsPlural A string to use when beautifying range labels
     *                                   whose lower bound is between 0 and 60. Must be
     *                                   a format string that takes two numeric params.
     * @param string $labelMinutesSingular A string to use when replacing a range that
     *                                     equals 60-60 (or 1 minute - 1 minute).
     * @param string $labelMinutesPlural A string to use when replacing a range that
     *                                   spans multiple minutes. This must be a
     *                                   format string that takes one string parameter.
     */

... [truncated, 72 more lines] ...

<?php
/**
 * Piwik - free/libre analytics platform
 *
 * @link http://piwik.org
 * @license http://www.gnu.org/licenses/gpl-3.0.html GPL v3 or later
 *
 */
namespace Piwik\DataTable\Filter;

use Piwik\Common;
use Piwik\DataTable;
use Piwik\DataTable\Row;
use Piwik\NumberFormatter;
use Piwik\Site;

/**
 * A {@link DataTable} filter that calculates the evolution of a metric and adds
 * it to each row as a percentage.
 *
 * **This filter cannot be used as an argument to {@link Piwik\DataTable::filter()}** since
 * it requires corresponding data from another DataTable. Instead,
 * you must manually perform a binary filter (see the **MultiSites** API for an
 * example).
 *
 * The evolution metric is calculated as:
 *
 *     ((currentValue - pastValue) / pastValue) * 100
 *
 * @api
 * @deprecated since v2.10.0
 */
class CalculateEvolutionFilter extends ColumnCallbackAddColumnPercentage
{
    /**
     * The the DataTable that contains past data.
     *
     * @var DataTable
     */
    protected $pastDataTable;

    /**
     * Tells if column being added is the revenue evolution column.
     */
    protected $isRevenueEvolution = null;

    /**
     * Constructor.
     *
     * @param DataTable $table The DataTable being filtered.

... [truncated, 148 more lines] ...

<?php
/**
 * Piwik - free/libre analytics platform
 *
 * @link http://piwik.org
 * @license http://www.gnu.org/licenses/gpl-3.0.html GPL v3 or later
 *
 */
namespace Piwik\DataTable\Filter;

use Piwik\DataTable;
use Piwik\DataTable\BaseFilter;
use Piwik\Plugins\CoreHome\Columns\Metrics\CallableProcessedMetric;

/**
 * Adds a new column to every row of a {@link DataTable} based on the result of callback.
 *
 * **Basic usage example**
 *
 *     $callback = function ($visits, $timeSpent) {
 *         return round($timeSpent / $visits, 2);
 *     };
 *
 *     $dataTable->filter('ColumnCallbackAddColumn', array(array('nb_visits', 'sum_time_spent'), 'avg_time_on_site', $callback));
 *
 * @api
 */
class ColumnCallbackAddColumn extends BaseFilter
{
    /**
     * The names of the columns to pass to the callback.
     */
    private $columns;

    /**
     * The name of the column to add.
     */
    private $columnToAdd;

    /**
     * The callback to apply to each row of the DataTable. The result is added as
     * the value of a new column.
     */
    private $functionToApply;

    /**
     * Extra parameters to pass to the callback.
     */
    private $functionParameters;


... [truncated, 64 more lines] ...

<?php
/**
 * Piwik - free/libre analytics platform
 *
 * @link http://piwik.org
 * @license http://www.gnu.org/licenses/gpl-3.0.html GPL v3 or later
 *
 */
namespace Piwik\DataTable\Filter;

use Piwik\Piwik;

/**
 * Calculates a percentage value for each row of a {@link DataTable} and adds the result
 * to each row.
 *
 * See {@link ColumnCallbackAddColumnQuotient} for more information.
 *
 * **Basic usage example**
 *
 *     $nbVisits = // ... get the visits for a period ...
 *     $dataTable->queueFilter('ColumnCallbackAddColumnPercentage', array('nb_visits', 'nb_visits_percentage', $nbVisits, 1));
 *
 * @api
 */
class ColumnCallbackAddColumnPercentage extends ColumnCallbackAddColumnQuotient
{
    /**
     * Formats the given value as a percentage.
     *
     * @param number $value
     * @param number $divisor
     * @return string
     */
    protected function formatValue($value, $divisor)
    {
        return Piwik::getPercentageSafe($value, $divisor, $this->quotientPrecision) . '%';
    }
}

<?php
/**
 * Piwik - free/libre analytics platform
 *
 * @link http://piwik.org
 * @license http://www.gnu.org/licenses/gpl-3.0.html GPL v3 or later
 *
 */
namespace Piwik\DataTable\Filter;

use Piwik\DataTable\BaseFilter;
use Piwik\DataTable;
use Piwik\DataTable\Row;

/**
 * Calculates the quotient of two columns and adds the result as a new column
 * for each row of a DataTable.
 *
 * This filter is used to calculate rate values (eg, `'bounce_rate'`), averages
 * (eg, `'avg_time_on_page'`) and other types of values.
 *
 * **Basic usage example**
 *
 *     $dataTable->queueFilter('ColumnCallbackAddColumnQuotient', array('bounce_rate', 'bounce_count', 'nb_visits', $precision = 2));
 *
 * @api
 */
class ColumnCallbackAddColumnQuotient extends BaseFilter
{
    protected $table;
    protected $columnValueToRead;
    protected $columnNameToAdd;
    protected $columnNameUsedAsDivisor;
    protected $totalValueUsedAsDivisor;
    protected $quotientPrecision;
    protected $shouldSkipRows;
    protected $getDivisorFromSummaryRow;

    /**
     * Constructor.
     *
     * @param DataTable $table The DataTable that will eventually be filtered.
     * @param string $columnNameToAdd The name of the column to add the quotient value to.
     * @param string $columnValueToRead The name of the column that holds the dividend.
     * @param number|string $divisorValueOrDivisorColumnName
     *                           Either numeric value to use as the divisor for every row,
     *                           or the name of the column whose value should be used as the
     *                           divisor.
     * @param int $quotientPrecision The precision to use when rounding the quotient.
     * @param bool|number $shouldSkipRows Whether rows w/o the column to read should be skipped or not.

... [truncated, 97 more lines] ...

<?php
/**
 * Piwik - free/libre analytics platform
 *
 * @link http://piwik.org
 * @license http://www.gnu.org/licenses/gpl-3.0.html GPL v3 or later
 *
 */
namespace Piwik\DataTable\Filter;

use Piwik\DataTable;
use Piwik\DataTable\BaseFilter;

/**
 * Executes a callback for each row of a {@link DataTable} and adds the result as a new
 * row metadata value.
 *
 * **Basic usage example**
 *
 *     $dataTable->filter('ColumnCallbackAddMetadata', array('label', 'logo', 'Piwik\Plugins\MyPlugin\getLogoFromLabel'));
 *
 * @api
 */
class ColumnCallbackAddMetadata extends BaseFilter
{
    private $columnsToRead;
    private $functionToApply;
    private $functionParameters;
    private $metadataToAdd;
    private $applyToSummaryRow;

    /**
     * Constructor.
     *
     * @param DataTable $table The DataTable instance that will be filtered.
     * @param string|array $columnsToRead The columns to read from each row and pass on to the callback.
     * @param string $metadataToAdd The name of the metadata field that will be added to each row.
     * @param callable $functionToApply The callback to apply for each row.
     * @param array $functionParameters deprecated - use an [anonymous function](http://php.net/manual/en/functions.anonymous.php)
     *                                  instead.
     * @param bool $applyToSummaryRow Whether the callback should be applied to the summary row or not.
     */
    public function __construct($table, $columnsToRead, $metadataToAdd, $functionToApply = null,
                                $functionParameters = null, $applyToSummaryRow = true)
    {
        parent::__construct($table);

        if (!is_array($columnsToRead)) {
            $columnsToRead = array($columnsToRead);
        }

... [truncated, 42 more lines] ...

<?php
/**
 * Piwik - free/libre analytics platform
 *
 * @link http://piwik.org
 * @license http://www.gnu.org/licenses/gpl-3.0.html GPL v3 or later
 *
 */
namespace Piwik\DataTable\Filter;

use Piwik\DataTable;
use Piwik\DataTable\BaseFilter;

/**
 * Executes a callback for each row of a {@link DataTable} and removes the defined metadata column from each row.
 *
 * **Basic usage example**
 *
 *     $dataTable->filter('ColumnCallbackDeleteMetadata', array('segmentValue'));
 *
 * @api
 */
class ColumnCallbackDeleteMetadata extends BaseFilter
{
    private $metadataToRemove;

    /**
     * Constructor.
     *
     * @param DataTable $table The DataTable instance that will be filtered.
     * @param string $metadataToRemove The name of the metadata field that will be removed from each row.
     */
    public function __construct($table, $metadataToRemove)
    {
        parent::__construct($table);

        $this->metadataToRemove = $metadataToRemove;
    }

    /**
     * See {@link ColumnCallbackDeleteMetadata}.
     *
     * @param DataTable $table
     */
    public function filter($table)
    {
        $this->enableRecursive(true);

        foreach ($table->getRows() as $row) {
            $row->deleteMetadata($this->metadataToRemove);

... [truncated, 6 more lines] ...

<?php
/**
 * Piwik - free/libre analytics platform
 *
 * @link http://piwik.org
 * @license http://www.gnu.org/licenses/gpl-3.0.html GPL v3 or later
 *
 */
namespace Piwik\DataTable\Filter;

use Piwik\DataTable;
use Piwik\DataTable\BaseFilter;

/**
 * Deletes all rows for which a callback returns true.
 *
 * **Basic usage example**
 *
 *     $labelsToRemove = array('label1', 'label2', 'label2');
 *     $dataTable->filter('ColumnCallbackDeleteRow', array('label', function ($label) use ($labelsToRemove) {
 *         return in_array($label, $labelsToRemove);
 *     }));
 *
 * @api
 */
class ColumnCallbackDeleteRow extends BaseFilter
{
    private $function;
    private $functionParams;

    /**
     * Constructor.
     *
     * @param DataTable $table The DataTable that will be filtered eventually.
     * @param array|string $columnsToFilter The column or array of columns that should be
     *                                      passed to the callback.
     * @param callback $function The callback that determines whether a row should be deleted
     *                           or not. Should return `true` if the row should be deleted.
     * @param array $functionParams deprecated - use an [anonymous function](http://php.net/manual/en/functions.anonymous.php)
     *                              instead.
     */
    public function __construct($table, $columnsToFilter, $function, $functionParams = array())
    {
        parent::__construct($table);

        if (!is_array($functionParams)) {
            $functionParams = array($functionParams);
        }

        if (!is_array($columnsToFilter)) {

... [truncated, 31 more lines] ...

<?php
/**
 * Piwik - free/libre analytics platform
 *
 * @link http://piwik.org
 * @license http://www.gnu.org/licenses/gpl-3.0.html GPL v3 or later
 *
 */
namespace Piwik\DataTable\Filter;

use Piwik\DataTable\BaseFilter;
use Piwik\DataTable;
use Piwik\DataTable\Row;

/**
 * Replaces one or more column values in each row of a DataTable with the results
 * of a callback.
 *
 * **Basic usage example**
 *
 *     $truncateString = function ($value, $truncateLength) {
 *         if (strlen($value) > $truncateLength) {
 *             return substr(0, $truncateLength);
 *         } else {
 *             return $value;
 *         }
 *     };
 *
 *     // label, url and truncate_length are columns in $dataTable
 *     $dataTable->filter('ColumnCallbackReplace', array('label', 'url'), $truncateString, null, array('truncate_length'));
 *
 * @api
 */
class ColumnCallbackReplace extends BaseFilter
{
    private $columnsToFilter;
    private $functionToApply;
    private $functionParameters;
    private $extraColumnParameters;

    /**
     * Constructor.
     *
     * @param DataTable $table The DataTable to filter.
     * @param array|string $columnsToFilter The columns whose values should be passed to the callback
     *                                      and then replaced with the callback's result.
     * @param callable $functionToApply The function to execute. Must take the column value as a parameter
     *                                  and return a value that will be used to replace the original.
     * @param array|null $functionParameters deprecated - use an [anonymous function](http://php.net/manual/en/functions.anonymous.php)
     *                                       instead.

... [truncated, 82 more lines] ...

<?php
/**
 * Piwik - free/libre analytics platform
 *
 * @link http://piwik.org
 * @license http://www.gnu.org/licenses/gpl-3.0.html GPL v3 or later
 *
 */
namespace Piwik\DataTable\Filter;

use Piwik\DataTable;
use Piwik\DataTable\BaseFilter;

/**
 * Filter that will remove columns from a {@link DataTable} using either a blacklist,
 * whitelist or both.
 *
 * This filter is used to handle the **hideColumn** and **showColumn** query parameters.
 *
 * **Basic usage example**
 *
 *     $columnsToRemove = array('nb_hits', 'nb_pageviews');
 *     $dataTable->filter('ColumnDelete', array($columnsToRemove));
 *
 *     $columnsToKeep = array('nb_visits');
 *     $dataTable->filter('ColumnDelete', array(array(), $columnsToKeep));
 *
 * @api
 */
class ColumnDelete extends BaseFilter
{
    /**
     * The columns that should be removed from DataTable rows.
     *
     * @var array
     */
    private $columnsToRemove;

    /**
     * The columns that should be kept in DataTable rows. All other columns will be
     * removed. If a column is in $columnsToRemove and this variable, it will NOT be kept.
     *
     * @var array
     */
    private $columnsToKeep;

    /**
     * Hack: when specifying "showColumns", sometimes we'd like to also keep columns that "look" like a given column,
     * without manually specifying all these columns (which may not be possible if column names are generated dynamically)
     *

... [truncated, 104 more lines] ...

<?php
/**
 * Piwik - free/libre analytics platform
 *
 * @link http://piwik.org
 * @license http://www.gnu.org/licenses/gpl-3.0.html GPL v3 or later
 *
 */
namespace Piwik\DataTable\Filter;

use Piwik\DataTable;
use Piwik\DataTable\BaseFilter;
use Piwik\Metrics;

/**
 * Deletes all rows for which a specific column has a value that is lower than
 * specified minimum threshold value.
 *
 * **Basic usage examples**
 *
 *     // remove all countries from UserCountry.getCountry that have less than 3 visits
 *     $dataTable = // ... get a DataTable whose queued filters have been run ...
 *     $dataTable->filter('ExcludeLowPopulation', array('nb_visits', 3));
 *
 *     // remove all countries from UserCountry.getCountry whose percent of total visits is less than 5%
 *     $dataTable = // ... get a DataTable whose queued filters have been run ...
 *     $dataTable->filter('ExcludeLowPopulation', array('nb_visits', false, 0.05));
 *
 *     // remove all countries from UserCountry.getCountry whose bounce rate is less than 10%
 *     $dataTable = // ... get a DataTable that has a numerical bounce_rate column ...
 *     $dataTable->filter('ExcludeLowPopulation', array('bounce_rate', 0.10));
 *
 * @api
 */
class ExcludeLowPopulation extends BaseFilter
{
    const MINIMUM_SIGNIFICANT_PERCENTAGE_THRESHOLD = 0.02;

    /**
     * The minimum value to enforce in a datatable for a specified column. Rows found with
     * a value less than this are removed.
     *
     * @var number
     */
    private $minimumValue;

    /**
     * Constructor.
     *
     * @param DataTable $table The DataTable that will be filtered eventually.

... [truncated, 76 more lines] ...

<?php
/**
 * Piwik - free/libre analytics platform
 *
 * @link http://piwik.org
 * @license http://www.gnu.org/licenses/gpl-3.0.html GPL v3 or later
 *
 */
namespace Piwik\DataTable\Filter;

use Piwik\DataTable;
use Piwik\DataTable\BaseFilter;
use Piwik\DataTable\Row;

/**
 * DataTable filter that will group {@link DataTable} rows together based on the results
 * of a reduce function. Rows with the same reduce result will be summed and merged.
 *
 * _NOTE: This filter should never be queued, it must be applied directly on a {@link DataTable}._
 *
 * **Basic usage example**
 *
 *     // group URLs by host
 *     $dataTable->filter('GroupBy', array('label', function ($labelUrl) {
 *         return parse_url($labelUrl, PHP_URL_HOST);
 *     }));
 *
 * @api
 */
class GroupBy extends BaseFilter
{
    /**
     * The name of the columns to reduce.
     * @var string
     */
    private $groupByColumn;

    /**
     * A callback that modifies the $groupByColumn of each row in some way. Rows with
     * the same reduction result will be added together.
     */
    private $reduceFunction;

    /**
     * Extra parameters to pass to the reduce function.
     */
    private $parameters;

    /**
     * Constructor.

... [truncated, 60 more lines] ...

<?php
/**
 * Piwik - free/libre analytics platform
 *
 * @link http://piwik.org
 * @license http://www.gnu.org/licenses/gpl-3.0.html GPL v3 or later
 *
 */
namespace Piwik\DataTable\Filter;

use Piwik\DataTable;
use Piwik\DataTable\BaseFilter;

/**
 * Delete all rows from the table that are not in the given [offset, offset+limit) range.
 *
 * **Basic example usage**
 *
 *     // delete all rows from 5 -> 15
 *     $dataTable->filter('Limit', array(5, 10));
 *
 * @api
 */
class Limit extends BaseFilter
{
    /**
     * Constructor.
     *
     * @param DataTable $table The DataTable that will be filtered eventually.
     * @param int $offset The starting row index to keep.
     * @param int $limit Number of rows to keep (specify -1 to keep all rows).
     * @param bool $keepSummaryRow Whether to keep the summary row or not.
     */
    public function __construct($table, $offset, $limit = -1, $keepSummaryRow = false)
    {
        parent::__construct($table);

        $this->offset = $offset;
        $this->limit  = $limit;
        $this->keepSummaryRow = $keepSummaryRow;
    }

    /**
     * See {@link Limit}.
     *
     * @param DataTable $table
     */
    public function filter($table)
    {
        $table->setMetadata(DataTable::TOTAL_ROWS_BEFORE_LIMIT_METADATA_NAME, $table->getRowsCount());

... [truncated, 20 more lines] ...

<?php
/**
 * Piwik - free/libre analytics platform
 *
 * @link http://piwik.org
 * @license http://www.gnu.org/licenses/gpl-3.0.html GPL v3 or later
 *
 */
namespace Piwik\DataTable\Filter;

use Piwik\DataTable;
use Piwik\DataTable\BaseFilter;

/**
 * Executes a callback for each row of a {@link DataTable} and adds the result to the
 * row as a metadata value. Only metadata values are passed to the callback.
 *
 * **Basic usage example**
 *
 *     // add a logo metadata based on the url metadata
 *     $dataTable->filter('MetadataCallbackAddMetadata', array('url', 'logo', 'Piwik\Plugins\MyPlugin\getLogoFromUrl'));
 *
 * @api
 */
class MetadataCallbackAddMetadata extends BaseFilter
{
    private $metadataToRead;
    private $functionToApply;
    private $metadataToAdd;
    private $applyToSummaryRow;

    /**
     * Constructor.
     *
     * @param DataTable $table The DataTable that will eventually be filtered.
     * @param string|array $metadataToRead The metadata to read from each row and pass to the callback.
     * @param string $metadataToAdd The name of the metadata to add.
     * @param callable $functionToApply The callback to execute for each row. The result will be
     *                                  added as metadata with the name `$metadataToAdd`.
     * @param bool $applyToSummaryRow True if the callback should be applied to the summary row, false
     *                                if otherwise.
     */
    public function __construct($table, $metadataToRead, $metadataToAdd, $functionToApply,
                                $applyToSummaryRow = true)
    {
        parent::__construct($table);
        $this->functionToApply = $functionToApply;

        if (!is_array($metadataToRead)) {
            $metadataToRead = array($metadataToRead);

... [truncated, 34 more lines] ...

<?php
/**
 * Piwik - free/libre analytics platform
 *
 * @link http://piwik.org
 * @license http://www.gnu.org/licenses/gpl-3.0.html GPL v3 or later
 *
 */
namespace Piwik\DataTable\Filter;

use Piwik\DataTable;
use Piwik\DataTable\Row;

/**
 * Execute a callback for each row of a {@link DataTable} passing certain column values and metadata
 * as metadata, and replaces row metadata with the callback result.
 *
 * **Basic usage example**
 *
 *     $dataTable->filter('MetadataCallbackReplace', array('url', function ($url) {
 *         return $url . '#index';
 *     }));
 *
 * @api
 */
class MetadataCallbackReplace extends ColumnCallbackReplace
{
    /**
     * Constructor.
     *
     * @param DataTable $table The DataTable that will eventually be filtered.
     * @param array|string $metadataToFilter The metadata whose values should be passed to the callback
     *                                       and then replaced with the callback's result.
     * @param callable $functionToApply The function to execute. Must take the metadata value as a parameter
     *                                  and return a value that will be used to replace the original.
     * @param array|null $functionParameters deprecated - use an [anonymous function](http://php.net/manual/en/functions.anonymous.php)
     *                                       instead.
     * @param array $extraColumnParameters Extra column values that should be passed to the callback, but
     *                                     shouldn't be replaced.
     */
    public function __construct($table, $metadataToFilter, $functionToApply, $functionParameters = null,
                                $extraColumnParameters = array())
    {
        parent::__construct($table, $metadataToFilter, $functionToApply, $functionParameters, $extraColumnParameters);
    }

    /**
     * @param Row $row
     * @param string $metadataToFilter
     * @param mixed $newValue

... [truncated, 17 more lines] ...

<?php
/**
 * Piwik - free/libre analytics platform
 *
 * @link http://piwik.org
 * @license http://www.gnu.org/licenses/gpl-3.0.html GPL v3 or later
 *
 */
namespace Piwik\DataTable\Filter;

use Piwik\DataTable;
use Piwik\DataTable\BaseFilter;

/**
 * Deletes every row for which a specific column does not match a supplied regex pattern.
 *
 * **Example**
 *
 *     // filter out all rows whose labels doesn't start with piwik
 *     $dataTable->filter('Pattern', array('label', '^piwik'));
 *
 * @api
 */
class Pattern extends BaseFilter
{
    /**
     * @var string|array
     */
    private $columnToFilter;
    private $patternToSearch;
    private $patternToSearchQuoted;
    private $invertedMatch;

    /**
     * Constructor.
     *
     * @param DataTable $table The table to eventually filter.
     * @param string $columnToFilter The column to match with the `$patternToSearch` pattern.
     * @param string $patternToSearch The regex pattern to use.
     * @param bool $invertedMatch Whether to invert the pattern or not. If true, will remove
     *                            rows if they match the pattern.
     */
    public function __construct($table, $columnToFilter, $patternToSearch, $invertedMatch = false)
    {
        parent::__construct($table);
        $this->patternToSearch = $patternToSearch;
        $this->patternToSearchQuoted = self::getPatternQuoted($patternToSearch);
        $this->columnToFilter = $columnToFilter;
        $this->invertedMatch = $invertedMatch;
    }

... [truncated, 76 more lines] ...

<?php
/**
 * Piwik - free/libre analytics platform
 *
 * @link http://piwik.org
 * @license http://www.gnu.org/licenses/gpl-3.0.html GPL v3 or later
 *
 */
namespace Piwik\DataTable\Filter;

use Piwik\DataTable\BaseFilter;
use Piwik\DataTable;

/**
 * Deletes rows that do not contain a column that matches a regex pattern and do not contain a
 * subtable that contains a column that matches a regex pattern.
 *
 * **Example**
 *
 *     // only display index pageviews in Actions.getPageUrls
 *     $dataTable->filter('PatternRecursive', array('label', 'index'));
 *
 * @api
 */
class PatternRecursive extends BaseFilter
{
    private $columnToFilter;
    private $patternToSearch;
    private $patternToSearchQuoted;

    /**
     * Constructor.
     *
     * @param DataTable $table The table to eventually filter.
     * @param string $columnToFilter The column to match with the `$patternToSearch` pattern.
     * @param string $patternToSearch The regex pattern to use.
     */
    public function __construct($table, $columnToFilter, $patternToSearch)
    {
        parent::__construct($table);
        $this->patternToSearch = $patternToSearch;
        $this->patternToSearchQuoted = Pattern::getPatternQuoted($patternToSearch);
        $this->patternToSearch = $patternToSearch; //preg_quote($patternToSearch);
        $this->columnToFilter = $columnToFilter;
    }

    /**
     * See {@link PatternRecursive}.
     *
     * @param DataTable $table

... [truncated, 34 more lines] ...

<?php
/**
 * Piwik - free/libre analytics platform
 *
 * @link http://piwik.org
 * @license http://www.gnu.org/licenses/gpl-3.0.html GPL v3 or later
 *
 */
namespace Piwik\DataTable\Filter;

use Exception;
use Piwik\Columns\Dimension;
use Piwik\Common;
use Piwik\Config;
use Piwik\DataTable;
use Piwik\DataTable\BaseFilter;
use Piwik\DataTable\Row;
use Piwik\Log;
use Piwik\Metrics;
use Piwik\Period;
use Piwik\Piwik;
use Piwik\Plugin\Report;
use Piwik\Plugin\Segment;
use Piwik\Site;

/**
 * DataTable filter that creates a pivot table from a report.
 *
 * A pivot table is a table that displays one metric value for two dimensions. The rows of
 * the table represent one dimension and the columns another.
 *
 * This filter can pivot any report by any dimension as long as either:
 *
 * - the pivot-by dimension is the dimension of the report's subtable
 * - or, the pivot-by dimension has an associated report, and the report to pivot has a dimension with
 *   a segment
 *
 * Reports are pivoted by iterating over the rows of the report, fetching the pivot-by report
 * for the current row, and setting the columns of row to the rows of the pivot-by report. For example:
 *
 * to pivot Referrers.getKeywords by UserCountry.City, we first loop through the Referrers.getKeywords
 * report's rows. For each row, we take the label (which is the referrer keyword), and get the
 * UserCountry.getCity report using the referrerKeyword=... segment. If the row's label were 'abcdefg',
 * we would use the 'referrerKeyword==abcdefg' segment.
 *
 * The UserCountry.getCity report we find is the report on visits by country, but only for the visits
 * for the specific row. We take this report's row labels and add them as columns for the Referrers.getKeywords
 * table.
 *
 * Implementation details:

... [truncated, 501 more lines] ...

<?php
/**
 * Piwik - free/libre analytics platform
 *
 * @link http://piwik.org
 * @license http://www.gnu.org/licenses/gpl-3.0.html GPL v3 or later
 *
 */
namespace Piwik\DataTable\Filter;

use Piwik\DataTable;

/**
 * Executes a callback for each row of a {@link DataTable} and prepends each existing segment with the
 * given segment.
 *
 * **Basic usage example**
 *
 *     $dataTable->filter('PrependSegment', array('segmentName==segmentValue;'));
 *
 * @api
 */
class PrependSegment extends PrependValueToMetadata
{
    /**
     * @param DataTable $table
     * @param string $prependSegment The segment to prepend if a segment is already defined. Make sure to include
     *                               A condition, eg the segment should end with ';' or ','
     */
    public function __construct($table, $prependSegment = '')
    {
        parent::__construct($table, 'segment', $prependSegment);
    }
}

<?php
/**
 * Piwik - free/libre analytics platform
 *
 * @link http://piwik.org
 * @license http://www.gnu.org/licenses/gpl-3.0.html GPL v3 or later
 *
 */
namespace Piwik\DataTable\Filter;

use Piwik\DataTable;
use Piwik\DataTable\BaseFilter;

/**
 * Executes a callback for each row of a {@link DataTable} and prepends the given value to each metadata entry
 * but only if the given metadata entry exists.
 *
 * **Basic usage example**
 *
 *     $dataTable->filter('PrependValueToMetadata', array('segment', 'segmentName==segmentValue'));
 *
 * @api
 */
class PrependValueToMetadata extends BaseFilter
{
    private $metadataColumn;
    private $valueToPrepend;

    /**
     * @param DataTable $table
     * @param string $metadataName    The name of the metadata that should be prepended
     * @param string $valueToPrepend  The value to prepend if the metadata entry exists
     */
    public function __construct($table, $metadataName, $valueToPrepend)
    {
        parent::__construct($table);

        $this->metadataColumn = $metadataName;
        $this->valueToPrepend = $valueToPrepend;
    }

    /**
     * See {@link PrependValueToMetadata}.
     *
     * @param DataTable $table
     */
    public function filter($table)
    {
        if (empty($this->metadataColumn) || empty($this->valueToPrepend)) {
            return;

... [truncated, 16 more lines] ...

<?php
/**
 * Piwik - free/libre analytics platform
 *
 * @link http://piwik.org
 * @license http://www.gnu.org/licenses/gpl-3.0.html GPL v3 or later
 *
 */
namespace Piwik\DataTable\Filter;

use Piwik\DataTable;
use Piwik\DataTable\BaseFilter;

/**
 * Check range
 *
 */
class RangeCheck extends BaseFilter
{
    public static $minimumValue = 0.00;
    public static $maximumValue = 100.0;

    /**
     * @param DataTable $table
     * @param string $columnToFilter name of the column to filter
     * @param float $minimumValue minimum value for range
     * @param float $maximumValue maximum value for range
     */
    public function __construct($table, $columnToFilter, $minimumValue = 0.00, $maximumValue = 100.0)
    {
        parent::__construct($table);

        $this->columnToFilter = $columnToFilter;

        if ((float) $minimumValue < (float) $maximumValue) {
            self::$minimumValue = $minimumValue;
            self::$maximumValue = $maximumValue;
        }
    }

    /**
     * Executes the filter an adjusts all columns to fit the defined range
     *
     * @param DataTable $table
     */
    public function filter($table)
    {
        foreach ($table->getRows() as $row) {
            $value = $row->getColumn($this->columnToFilter);


... [truncated, 23 more lines] ...

<?php
/**
 * Piwik - free/libre analytics platform
 *
 * @link http://piwik.org
 * @license http://www.gnu.org/licenses/gpl-3.0.html GPL v3 or later
 *
 */
namespace Piwik\DataTable\Filter;

use Piwik\DataTable\BaseFilter;
use Piwik\DataTable\Simple;
use Piwik\DataTable;
use Piwik\Metrics;
use Piwik\Piwik;
use Piwik\Tracker\GoalManager;

/**
 * Replaces column names in each row of a table using an array that maps old column
 * names new ones.
 *
 * If no mapping is provided, this column will use one that maps index metric names
 * (which are integers) with their string column names. In the database, reports are
 * stored with integer metric names because it results in blobs that take up less space.
 * When loading the reports, the column names must be replaced, which is handled by this
 * class. (See {@link Piwik\Metrics} for more information about integer metric names.)
 *
 * **Basic example**
 *
 *     // filter use in a plugin's API method
 *     public function getMyReport($idSite, $period, $date, $segment = false, $expanded = false)
 *     {
 *         $dataTable = Archive::getDataTableFromArchive('MyPlugin_MyReport', $idSite, $period, $date, $segment, $expanded);
 *         $dataTable->queueFilter('ReplaceColumnNames');
 *         return $dataTable;
 *     }
 *
 * @api
 */
class ReplaceColumnNames extends BaseFilter
{
    protected $mappingToApply;

    /**
     * Constructor.
     *
     * @param DataTable $table The table that will be eventually filtered.
     * @param array|null $mappingToApply The name mapping to apply. Must map old column names
     *                                   with new ones, eg,
     *

... [truncated, 121 more lines] ...

<?php
/**
 * Piwik - free/libre analytics platform
 *
 * @link http://piwik.org
 * @license http://www.gnu.org/licenses/gpl-3.0.html GPL v3 or later
 *
 */
namespace Piwik\DataTable\Filter;

use Piwik\DataTable\BaseFilter;
use Piwik\DataTable;
use Piwik\Piwik;

/**
 * Replaces the label of the summary row with a supplied label.
 *
 * This filter is only used to prettify the summary row label and so it should
 * always be queued on a {@link DataTable}.
 *
 * This filter always recurses. In other words, this filter will always apply itself to
 * all subtables in the given {@link DataTable}'s table hierarchy.
 *
 * **Basic example**
 *
 *     $dataTable->queueFilter('ReplaceSummaryRowLabel', array(Piwik::translate('General_Others')));
 *
 * @api
 */
class ReplaceSummaryRowLabel extends BaseFilter
{
    /**
     * Constructor.
     *
     * @param DataTable $table The table that will eventually be filtered.
     * @param string|null $newLabel The new label for summary row. If null, defaults to
     *                              `Piwik::translate('General_Others')`.
     */
    public function __construct($table, $newLabel = null)
    {
        parent::__construct($table);
        if (is_null($newLabel)) {
            $newLabel = Piwik::translate('General_Others');
        }
        $this->newLabel = $newLabel;
    }

    /**
     * See {@link ReplaceSummaryRowLabel}.
     *

... [truncated, 24 more lines] ...

<?php
/**
 * Piwik - free/libre analytics platform
 *
 * @link http://piwik.org
 * @license http://www.gnu.org/licenses/gpl-3.0.html GPL v3 or later
 *
 */
namespace Piwik\DataTable\Filter;

use Piwik\DataTable;
use Piwik\DataTable\BaseFilter;

/**
 * Sanitizes DataTable labels as an extra precaution. Called internally by Piwik.
 *
 */
class SafeDecodeLabel extends BaseFilter
{
    private $columnToDecode;

    /**
     * @param DataTable $table
     */
    public function __construct($table)
    {
        parent::__construct($table);
        $this->columnToDecode = 'label';
    }

    /**
     * Decodes the given value
     *
     * @param string $value
     * @return mixed|string
     */
    public static function decodeLabelSafe($value)
    {
        if (empty($value)) {
            return $value;
        }
        $raw = urldecode($value);
        $value = htmlspecialchars_decode($raw, ENT_QUOTES);

        // ENT_IGNORE so that if utf8 string has some errors, we simply discard invalid code unit sequences
        $style = ENT_QUOTES | ENT_IGNORE;

        // See changes in 5.4: http://nikic.github.com/2012/01/28/htmlspecialchars-improvements-in-PHP-5-4.html
        // Note: at some point we should change ENT_IGNORE to ENT_SUBSTITUTE
        $value = htmlspecialchars($value, $style, 'UTF-8');

... [truncated, 23 more lines] ...

<?php
/**
 * Piwik - free/libre analytics platform
 *
 * @link http://piwik.org
 * @license http://www.gnu.org/licenses/gpl-3.0.html GPL v3 or later
 *
 */
namespace Piwik\DataTable\Filter;

use Piwik\DataTable\BaseFilter;
use Piwik\DataTable\Row;
use Piwik\DataTable\Simple;
use Piwik\DataTable;
use Piwik\Metrics;

/**
 * Sorts a {@link DataTable} based on the value of a specific column.
 *
 * It is possible to specify a natural sorting (see [php.net/natsort](http://php.net/natsort) for details).
 *
 * @api
 */
class Sort extends BaseFilter
{
    protected $columnToSort;
    protected $order;
    protected $sign;

    const ORDER_DESC = 'desc';
    const ORDER_ASC  = 'asc';

    /**
     * Constructor.
     *
     * @param DataTable $table The table to eventually filter.
     * @param string $columnToSort The name of the column to sort by.
     * @param string $order order `'asc'` or `'desc'`.
     * @param bool $naturalSort Whether to use a natural sort or not (see {@link http://php.net/natsort}).
     * @param bool $recursiveSort Whether to sort all subtables or not.
     */
    public function __construct($table, $columnToSort, $order = 'desc', $naturalSort = true, $recursiveSort = true)
    {
        parent::__construct($table);

        if ($recursiveSort) {
            $table->enableRecursiveSort();
        }

        $this->columnToSort = $columnToSort;

... [truncated, 241 more lines] ...

<?php
/**
 * Piwik - free/libre analytics platform
 *
 * @link http://piwik.org
 * @license http://www.gnu.org/licenses/gpl-3.0.html GPL v3 or later
 *
 */
namespace Piwik\DataTable\Filter;

use Piwik\DataTable\BaseFilter;
use Piwik\DataTable;
use Piwik\DataTable\Row;
use Piwik\Piwik;

/**
 * Truncates a {@link DataTable} by merging all rows after a certain index into a new summary
 * row. If the count of rows is less than the index, nothing happens.
 *
 * The {@link ReplaceSummaryRowLabel} filter will be queued after the table is truncated.
 *
 * ### Examples
 *
 * **Basic usage**
 *
 *     $dataTable->filter('Truncate', array($truncateAfter = 500));
 *
 * **Using a custom summary row label**
 *
 *     $dataTable->filter('Truncate', array($truncateAfter = 500, $summaryRowLabel = Piwik::translate('General_Total')));
 *
 * @api
 */
class Truncate extends BaseFilter
{
    /**
     * Constructor.
     *
     * @param DataTable $table The table that will be filtered eventually.
     * @param int $truncateAfter The row index to truncate at. All rows passed this index will
     *                           be removed.
     * @param string $labelSummaryRow The label to use for the summary row. Defaults to
     *                                `Piwik::translate('General_Others')`.
     * @param string $columnToSortByBeforeTruncating The column to sort by before truncation, eg,
     *                                               `'nb_visits'`.
     * @param bool $filterRecursive If true executes this filter on all subtables descending from
     *                              `$table`.
     */
    public function __construct($table,
                                $truncateAfter,

... [truncated, 74 more lines] ...

<?php
/**
 * Piwik - free/libre analytics platform
 *
 * @link http://piwik.org
 * @license http://www.gnu.org/licenses/gpl-3.0.html GPL v3 or later
 *
 */
namespace Piwik\DataTable\Renderer;

use Piwik\DataTable;
use Piwik\DataTable\Renderer;

/**
 * Simple output
 */
class Console extends Renderer
{
    /**
     * Prefix
     *
     * @var string
     */
    protected $prefixRows = '#';

    /**
     * Computes the dataTable output and returns the string/binary
     *
     * @return string
     */
    public function render()
    {
        return $this->renderTable($this->table);
    }

    /**
     * Sets the prefix to be used
     *
     * @param string $str new prefix
     */
    public function setPrefixRow($str)
    {
        $this->prefixRows = $str;
    }

    /**
     * Computes the output of the given array of data tables
     *
     * @param DataTable\Map $map data tables to render
     * @param string $prefix prefix to output before table data

... [truncated, 107 more lines] ...

<?php
/**
 * Piwik - free/libre analytics platform
 *
 * @link http://piwik.org
 * @license http://www.gnu.org/licenses/gpl-3.0.html GPL v3 or later
 *
 */
namespace Piwik\DataTable\Renderer;

use Piwik\Common;
use Piwik\DataTable\Renderer;
use Piwik\DataTable\Simple;
use Piwik\DataTable;
use Piwik\Date;
use Piwik\Period;
use Piwik\Period\Range;
use Piwik\Piwik;
use Piwik\ProxyHttp;

/**
 * CSV export
 *
 * When rendered using the default settings, a CSV report has the following characteristics:
 * The first record contains headers for all the columns in the report.
 * All rows have the same number of columns.
 * The default field delimiter string is a comma (,).
 * Formatting and layout are ignored.
 *
 */
class Csv extends Renderer
{
    /**
     * Column separator
     *
     * @var string
     */
    public $separator = ",";

    /**
     * Line end
     *
     * @var string
     */
    public $lineEnd = "\n";

    /**
     * 'metadata' columns will be exported, prefixed by 'metadata_'
     *
     * @var bool

... [truncated, 447 more lines] ...

<?php
/**
 * Piwik - free/libre analytics platform
 *
 * @link http://piwik.org
 * @license http://www.gnu.org/licenses/gpl-3.0.html GPL v3 or later
 *
 */
namespace Piwik\DataTable\Renderer;

use Exception;
use Piwik\DataTable;
use Piwik\DataTable\Renderer;

/**
 * Simple HTML output
 * Does not work with recursive DataTable (i.e., when a row can be associated with a subDataTable).
 *
 */
class Html extends Renderer
{
    protected $tableId;
    protected $allColumns;
    protected $tableStructure;
    protected $i;

    /**
     * Sets the table id
     *
     * @param string $id
     */
    public function setTableId($id)
    {
        $this->tableId = str_replace('.', '_', $id);
    }

    /**
     * Computes the dataTable output and returns the string/binary
     *
     * @return string
     */
    public function render()
    {
        $this->tableStructure = array();
        $this->allColumns = array();
        $this->i = 0;

        return $this->renderTable($this->table);
    }


... [truncated, 141 more lines] ...