| Current File : /home/escuelai/public_html/wp-content/plugins/w3-total-cache/Util_UsageStatistics.php |
<?php
/**
* File: Util_UsageStatistics.php
*
* @package W3TC
*/
namespace W3TC;
/**
* Class Util_UsageStatistics
*/
class Util_UsageStatistics {
/**
* Converts a byte value into a human-readable size format (KB, MB, or GB).
*
* This method formats a numeric byte value into a string representing the size in
* kilobytes (KB), megabytes (MB), or gigabytes (GB), based on the value's magnitude.
* If the input value is null, it returns 'n/a'.
*
* @param int|float|null $v The byte value to convert.
*
* @return string The formatted size (e.g., '1.2 GB', '512.0 MB', or '256.0 KB'),
* or 'n/a' if the value is null.
*/
public static function bytes_to_size( $v ) {
if ( is_null( $v ) ) {
return 'n/a';
}
if ( $v > 500000000 ) {
return sprintf( '%.1f GB', $v / 1024 /*KB*/ / 1024 /*MB*/ / 1024/*GB*/ );
}
if ( $v > 500000 ) {
return sprintf( '%.1f MB', $v / 1024 /*KB*/ / 1024 /*MB*/ );
} else {
return sprintf( '%.1f KB', $v / 1024 /*KB*/ );
}
}
/**
* Converts a nested byte value from an array into a human-readable size format (KB, MB, or GB).
*
* This method retrieves a nested value from an array using the `v` method, then converts it
* into a human-readable size format using the `bytes_to_size` method. If the value is null,
* it returns 'n/a'.
*
* @param array $a The input array to search for the byte value.
* @param string|int $p1 The first key to search for.
* @param string|int|null $p2 The second key to search for (optional).
* @param string|int|null $p3 The third key to search for (optional).
*
* @return string The formatted size (e.g., '1.2 GB', '512.0 MB', or '256.0 KB'),
* or 'n/a' if the value is null or not found.
*/
public static function bytes_to_size2( $a, $p1, $p2 = null, $p3 = null ) {
$v = self::v( $a, $p1, $p2, $p3 );
if ( is_null( $v ) ) {
return 'n/a';
}
return self::bytes_to_size( $v );
}
/**
* Calculates the percentage of two values and formats it as a string with a '%' symbol.
*
* If the denominator is zero, the result is '0 %'. If the numerator exceeds the denominator,
* the result is capped at '100 %'. Otherwise, the percentage is calculated and formatted
* as an integer.
*
* @param float|int $v1 The numerator value.
* @param float|int $v2 The denominator value.
*
* @return string The calculated percentage as a string (e.g., '75 %'), or '0 %' if $v2 is 0.
*/
public static function percent( $v1, $v2 ) {
if ( 0 === $v2 ) {
return '0 %';
} elseif ( $v1 > $v2 ) {
return '100 %';
} else {
return sprintf( '%d', $v1 / $v2 * 100 ) . ' %';
}
}
/**
* Calculates the percentage of two properties from an array and formats it as a string with a '%' symbol.
*
* If either property is missing or the denominator is zero, a fallback value is returned.
*
* @param array $a {
* The input array containing the properties.
*
* @type string|int $property1 The key for the numerator value.
* @type string|int $property2 The key for the denominator value.
* }
* @param string|int $property1 The key for the numerator value.
* @param string|int $property2 The key for the denominator value.
*
* @return string The calculated percentage as a string (e.g., '75 %'), 'n/a' if properties
* are missing, or '0 %' if $a[$property2] is 0.
*/
public static function percent2( $a, $property1, $property2 ) {
if ( ! isset( $a[ $property1 ] ) || ! isset( $a[ $property2 ] ) ) {
return 'n/a';
} elseif ( empty( $a[ $property2 ] ) ) {
return '0 %';
} else {
return sprintf( '%d', $a[ $property1 ] / $a[ $property2 ] * 100 ) . ' %';
}
}
/**
* Sums up the values of a specified property from an array of arrays.
*
* This method iterates through the array, retrieving the value of the specified property
* using the `v3` method, and sums all non-empty values.
*
* @param array $history An array of arrays to sum values from.
* @param string|int $property The key of the property to sum.
*
* @return int|float The total sum of the specified property.
*/
public static function sum( $history, $property ) {
$v = 0;
foreach ( $history as $i ) {
$item_value = self::v3( $i, $property );
if ( ! empty( $item_value ) ) {
$v += $item_value;
}
}
return $v;
}
/**
* Calculates the average of values of a specified property from an array of arrays.
*
* This method iterates through the array, retrieves the values of the specified property
* using the `v3` method, and calculates the average of all non-empty values.
*
* @param array $history An array of arrays to calculate the average from.
* @param string|int $property The key of the property to average.
*
* @return float The average value, or 0 if there are no valid entries.
*/
public static function avg( $history, $property ) {
$v = 0;
$count = 0;
foreach ( $history as $i ) {
$item_value = self::v3( $i, $property );
if ( ! empty( $item_value ) ) {
$v += $item_value;
++$count;
}
}
return ( $count <= 0 ? 0 : $v / $count );
}
/**
* Sums up all positive values of properties whose names start with a specific prefix.
*
* This method iterates through an array of arrays and aggregates values of keys that start
* with the given prefix. Only positive values are included in the sum.
*
* @param array $output The array to store the aggregated sums by property name.
* @param array $history An array of arrays to sum values from.
* @param string $property_prefix The prefix of the property names to match.
*
* @return void
*/
public static function sum_by_prefix_positive( &$output, $history, $property_prefix ) {
$property_prefix_len = strlen( $property_prefix );
foreach ( $history as $i ) {
foreach ( $i as $key => $value ) {
if ( substr( $key, 0, $property_prefix_len ) === $property_prefix && $value > 0 ) {
if ( ! isset( $output[ $key ] ) ) {
$output[ $key ] = 0;
}
$output[ $key ] += $value;
}
}
}
}
/**
* Formats a timestamp into a human-readable date and time.
*
* This method uses PHP's `date()` function to format the provided timestamp in
* the 'm/d/Y H:i' format.
*
* @param int $timestamp The Unix timestamp to format.
*
* @return string The formatted date and time string.
*/
public static function time_mins( $timestamp ) {
return gmdate( 'm/d/Y H:i', $timestamp );
}
/**
* Formats an integer value with thousand separators.
*
* This method uses `number_format()` to add separators to large integers for readability.
*
* @param int|float $v The value to format.
*
* @return string The formatted number as a string.
*/
public static function integer( $v ) {
return number_format( $v );
}
/**
* Divides a value by a specified divisor and formats the result as an integer with thousand separators.
*
* If the divisor is zero, the method returns 'n/a'.
*
* @param float|int $v The value to divide.
* @param float|int $divide_by The divisor.
*
* @return string The formatted result, or 'n/a' if the divisor is zero.
*/
public static function integer_divideby( $v, $divide_by ) {
if ( empty( $divide_by ) ) {
return 'n/a';
}
return self::integer( $v / $divide_by );
}
/**
* Retrieves a nested value from an array and formats it as an integer with thousand separators.
*
* This method uses the `v` method to retrieve a nested value from an array and formats it
* using `number_format()`. If the value is null, it returns 'n/a'.
*
* @param array $a The input array to search.
* @param string|int $p1 The first key to search for.
* @param string|int|null $p2 The second key to search for (optional).
* @param string|int|null $p3 The third key to search for (optional).
*
* @return string The formatted value, or 'n/a' if the value is null.
*/
public static function integer2( $a, $p1, $p2 = null, $p3 = null ) {
$v = self::v( $a, $p1, $p2, $p3 );
if ( is_null( $v ) ) {
return 'n/a';
} else {
return number_format( $v );
}
}
/**
* Retrieves a nested value from a multidimensional array using up to three keys.
*
* This method safely navigates an array by checking the existence of keys at each level.
* If a key does not exist or the path is incomplete, the method returns `null`.
*
* @param array $a The input array to search.
* @param string|int $p1 The first key, required to locate the initial value.
* @param string|int|null $p2 Optional. The second key to access a nested value. Default is null.
* @param string|int|null $p3 Optional. The third key to access a deeper nested value. Default is null.
*
* @return mixed|null The value located at the specified key path, or null if the path is invalid or incomplete.
*/
public static function v( $a, $p1, $p2 = null, $p3 = null ) {
if ( ! isset( $a[ $p1 ] ) ) {
return null;
}
$v = $a[ $p1 ];
if ( is_null( $p2 ) ) {
return $v;
}
if ( ! isset( $v[ $p2 ] ) ) {
return null;
}
$v = $v[ $p2 ];
if ( is_null( $p3 ) ) {
return $v;
}
if ( ! isset( $v[ $p3 ] ) ) {
return null;
}
return $v[ $p3 ];
}
/**
* Retrieves a deeply nested value from a multidimensional array using an array of keys.
*
* This method safely navigates a nested array by following the sequence of keys provided.
* If any key in the sequence is not set or the path is invalid, the method returns `null`.
*
* @param array $a The input array to search.
* @param string|int|array $p A single key or an array of keys representing the path to the desired value
* If a single key is provided, it will be converted to an array.
*
* @return mixed|null The value at the specified key path, or null if the path is invalid or incomplete.
*/
public static function v3( $a, $p ) {
if ( ! is_array( $p ) ) {
$p = array( $p );
}
$actual = &$a;
$count = count( $p );
for ( $i = 0; $i < $count; $i++ ) {
$property = $p[ $i ];
if ( ! isset( $actual[ $property ] ) ) {
return null;
}
$actual = &$actual[ $property ];
}
return $actual;
}
/**
* Calculates a value per second based on two properties of an array.
*
* This method checks the presence of two properties in an array and calculates the ratio
* of the first property to the second, scaled by 100. If the properties are missing or
* the second property is zero, a fallback value is returned.
*
* @param array $a The input array containing the values to calculate.
* @param string|int $property1 The key for the numerator value.
* @param string|int $property2 The key for the denominator value.
*
* @return string The calculated value as a percentage (formatted to 1 decimal place), '0'
* if the denominator is zero, or 'n/a' if either key is missing.
*/
public static function value_per_second( $a, $property1, $property2 ) {
if ( ! isset( $a[ $property1 ] ) || ! isset( $a[ $property2 ] ) ) {
return 'n/a';
} elseif ( empty( $a[ $property2 ] ) ) {
return '0';
} else {
return sprintf( '%.1f', $a[ $property1 ] / $a[ $property2 ] * 100 );
}
}
/**
* Calculates the average value per second over a specified period.
*
* This method divides a total value by the number of seconds in a period,
* which is retrieved from the provided summary array.
*
* @param float $total The total value to divide.
* @param array $summary {
* The summary array containing the period details.
*
* @type array $period {
* Details about the period.
*
* @type int $seconds The number of seconds in the period.
* }
* }
*
* @return string The calculated value per second (formatted to 1 decimal place), or 'n/a'
* if the period's seconds value is missing or empty.
*/
public static function value_per_period_seconds( $total, $summary ) {
if ( empty( $summary['period']['seconds'] ) ) {
return 'n/a';
}
$period_seconds = $summary['period']['seconds'];
return sprintf( '%.1f', $total / $period_seconds );
}
/**
* Retrieves or initializes a size-related transient for cache summary calculations.
*
* This method checks for the existence of a transient storing cache size details. If the
* transient is invalid or missing, it initializes the transient with placeholder values
* and marks it for counting. It also ensures that the transient corresponds to the current
* period defined in the summary.
*
* @param string $transient The name of the transient to retrieve or initialize.
* @param array $summary {
* Summary array containing the current period's timestamp details.
*
* @type array $period {
* Information about the summary period.
*
* @type int $timestamp_end The end timestamp of the current period.
* }
* }
*
* @return array {
* An array containing the transient value and a flag indicating if counting is required.
*
* @type array $0 The transient value (existing or initialized).
* @type bool $1 Whether counting is required (`true` for initialization).
* }
*/
public static function get_or_init_size_transient( $transient, $summary ) {
$should_count = false;
$v = get_transient( $transient );
if ( is_array( $v ) && isset( $v['timestamp_end'] ) && $v['timestamp_end'] === $summary['period']['timestamp_end'] ) {
return array( $v, false );
}
// limit number of processing counting it at the same time.
$v = array(
'timestamp_end' => $summary['period']['timestamp_end'],
'size_used' => '...counting',
'items' => '...counting',
);
set_transient( $transient, $v, 120 );
return array( $v, true );
}
}