public function testSetWeight()
{
$tag = new Tag\Item(array('title' => 'foo', 'weight' => 1));
$tag->setWeight('10');
$this->assertEquals(10.0, $tag->getWeight());
$this->assertTrue(is_float($tag->getWeight()));
}
/**
* Returns the given amount as a formatted string according to the
* given currency.
* IMPORTANT NOTE:
* The amount must always be the smallest unit passed as a string
* or int! It is a very bad idea to use float for monetary
* calculations if you need exact values, therefore
* this method won't accept float values.
* Examples:
* format (500, 'EUR'); --> '5,00 EUR'
* format (4.23, 'EUR'); --> FALSE
* format ('872331', 'EUR'); --> '8.723,31 EUR'.
*
* @param int|string $amount Amount to be formatted. Must be the smalles unit
* @param string $currencyKey ISO 3 letter code of the currency
* @param bool $withSymbol If set the currency symbol will be rendered
*
* @return string|bool String representation of the amount including currency
* symbol(s) or FALSE if $amount was of the type float
*/
public static function format($amount, $currencyKey, $withSymbol = true)
{
if (is_float($amount)) {
return false;
}
/**
* Currency repository.
*
* @var CurrencyRepository
*/
$currencyRepository = GeneralUtility::makeInstance('CommerceTeam\\Commerce\\Domain\\Repository\\CurrencyRepository');
$currency = $currencyRepository->findByIso3($currencyKey);
if (empty($currency)) {
return false;
}
$formattedAmount = number_format($amount / $currency['cu_sub_divisor'], $currency['cu_decimal_digits'], $currency['cu_decimal_point'], $currency['cu_thousands_point']);
if ($withSymbol) {
$wholeString = $formattedAmount;
if (!empty($currency['cu_symbol_left'])) {
$wholeString = $currency['cu_symbol_left'] . ' ' . $wholeString;
}
if (!empty($currency['cu_symbol_right'])) {
$wholeString .= ' ' . $currency['cu_symbol_right'];
}
} else {
$wholeString = $formattedAmount;
}
return $wholeString;
}
/**
* converts a value from the standard unit for the dimension to this unit.
*/
public function fromStandardUnit($value)
{
if (!is_float($value)) {
throw new \Exception('value must be a float');
}
return $value * $this->divisor;
}
/**
* Determines the type of a scalar value
* @param mixed The scalar value
* @return string The type of the scalar value
*/
function getScalarTypeFromValue(&$value)
{
require_once DOM_XMLRPC_INCLUDE_PATH . 'dom_xmlrpc_constants.php';
if (is_string($value)) {
return DOM_XMLRPC_TYPE_STRING;
} else {
if (is_int($value)) {
return DOM_XMLRPC_TYPE_INT;
} else {
if (is_float($value)) {
return DOM_XMLRPC_TYPE_DOUBLE;
} else {
if (is_bool($value)) {
return DOM_XMLRPC_TYPE_BOOLEAN;
} else {
if (is_object($value)) {
require_once DOM_XMLRPC_INCLUDE_PATH . 'dom_xmlrpc_datetime_iso8601.php';
require_once DOM_XMLRPC_INCLUDE_PATH . 'dom_xmlrpc_base64.php';
if (get_class($value) == 'dom_xmlrpc_datetime_iso8601') {
return DOM_XMLRPC_TYPE_DATETIME;
} else {
if (get_class($value) == 'dom_xmlrpc_base64') {
return DOM_XMLRPC_TYPE_BASE64;
}
}
}
}
}
}
}
return '';
}
public static function serializeValue($value)
{
if ($value === null) {
return 'null';
} elseif ($value === false) {
return 'false';
} elseif ($value === true) {
return 'true';
} elseif (is_float($value) && (int) $value == $value) {
return $value . '.0';
} elseif (is_object($value) || gettype($value) == 'object') {
return 'Object ' . get_class($value);
} elseif (is_resource($value)) {
return 'Resource ' . get_resource_type($value);
} elseif (is_array($value)) {
return 'Array of length ' . count($value);
} elseif (is_integer($value)) {
return (int) $value;
} else {
$value = (string) $value;
if (function_exists('mb_convert_encoding')) {
$value = mb_convert_encoding($value, 'UTF-8', 'UTF-8');
}
return $value;
}
}
public function appendValue($value)
{
if (is_null($value)) {
$this->append('null');
} elseif (is_string($value)) {
$this->_toPhpSyntax($value);
} elseif (is_float($value)) {
$this->append('<');
$this->append($value);
$this->append('F>');
} elseif (is_bool($value)) {
$this->append('<');
$this->append($value ? 'true' : 'false');
$this->append('>');
} elseif (is_array($value) || $value instanceof \Iterator || $value instanceof \IteratorAggregate) {
$this->appendValueList('[', ', ', ']', $value);
} elseif (is_object($value) && !method_exists($value, '__toString')) {
$this->append('<');
$this->append(get_class($value));
$this->append('>');
} else {
$this->append('<');
$this->append($value);
$this->append('>');
}
return $this;
}
/**
* Sets the ouput gamma
*
* @param float
*/
public function setOutputGamma($gamma)
{
if (is_float($gamma)) {
$this->ouput_gamma = (double) $gamma;
return true;
}
}
/** Constructor
*
*/
public function __construct($value, $lang = null, $datatype = null)
{
if (EasyRdf_Utils::is_associative_array($value)) {
$this->_value = isset($value['value']) ? $value['value'] : null;
$this->_lang = isset($value['lang']) ? $value['lang'] : null;
$this->_datatype = isset($value['datatype']) ? $value['datatype'] : null;
} else {
$this->_value = $value;
$this->_lang = $lang ? $lang : null;
$this->_datatype = $datatype ? $datatype : null;
}
// Automatic datatype selection
if ($this->_datatype == null) {
if (is_float($this->_value)) {
$this->_datatype = 'xsd:decimal';
} else {
if (is_int($this->_value)) {
$this->_datatype = 'xsd:integer';
} else {
if (is_bool($this->_value)) {
$this->_datatype = 'xsd:boolean';
}
}
}
}
// Expand shortened URIs (qnames)
if ($this->_datatype) {
$this->_datatype = EasyRdf_Namespace::expand($this->_datatype);
}
}
/**
* Set an Azure property
*
* @param string $name Property name
* @param mixed $value Property value
* @param string $type Property type (Edm.xxxx)
* @return DynamicTableEntity
*/
public function setAzureProperty($name, $value = '', $type = null)
{
if (strtolower($name) == 'partitionkey') {
$this->setPartitionKey($value);
} elseif (strtolower($name) == 'rowkey') {
$this->setRowKey($value);
} elseif (strtolower($name) == 'etag') {
$this->setEtag($value);
} else {
if (!array_key_exists(strtolower($name), $this->_dynamicProperties)) {
// Determine type?
if ($type === null) {
$type = 'Edm.String';
if (is_int($value)) {
$type = 'Edm.Int32';
} elseif (is_float($value)) {
$type = 'Edm.Double';
} elseif (is_bool($value)) {
$type = 'Edm.Boolean';
}
}
// Set dynamic property
$this->_dynamicProperties[strtolower($name)] = (object) array('Name' => $name, 'Type' => $type, 'Value' => $value);
}
$this->_dynamicProperties[strtolower($name)]->Value = $value;
}
return $this;
}
/**
* convert a money amount (represented by a float or string (based on locale) ie.: R$ 5,00) to cents (represented by an int).
*
* @param float $amount
*
* @throws \UnexpectedValueException
*
* @return int
*/
public static function toCents($amount)
{
/*
* There's probably a better way, but this is what i could come up with
* to avoid rounding errors
* todo: search for a better way
*/
if (!is_float($amount)) {
$type = gettype($amount);
throw new \UnexpectedValueException("Needs a float! not {$type}");
}
//handle locales
$locale = localeconv();
$amount = str_replace($locale['mon_thousands_sep'], '', $amount);
$amount = str_replace($locale['mon_decimal_point'], '.', $amount);
$amount = str_replace($locale['decimal_point'], '.', $amount);
$parts = explode('.', "{$amount}");
// handle the case where $amount has a .0 fraction part
if (count($parts) == 1) {
$parts[] = '00';
}
list($whole, $fraction) = $parts;
/*
* since the documentation only mentions decimals with a precision of two
* and doesn't specify any rounding method i'm truncating the number
*
* the str_pad is to handle the case where $amount is, for example, 6.9
*/
$fraction = str_pad(substr($fraction, 0, 2), 2, '0');
$whole = (int) $whole * 100;
$fraction = (int) $fraction;
return $whole + $fraction;
}
/**
* Constructor.
*
* @param array $index Index specification
*/
public function __construct(array $index)
{
if (!isset($index['key'])) {
throw new InvalidArgumentException('Required "key" document is missing from index specification');
}
if (!is_array($index['key']) && !is_object($index['key'])) {
throw new InvalidArgumentTypeException('"key" option', $index['key'], 'array or object');
}
foreach ($index['key'] as $fieldName => $order) {
if (!is_int($order) && !is_float($order) && !is_string($order)) {
throw new InvalidArgumentTypeException(sprintf('order value for "%s" field within "key" option', $fieldName), $order, 'numeric or string');
}
}
if (!isset($index['ns'])) {
throw new InvalidArgumentException('Required "ns" option is missing from index specification');
}
if (!is_string($index['ns'])) {
throw new InvalidArgumentTypeException('"ns" option', $index['ns'], 'string');
}
if (!isset($index['name'])) {
$index['name'] = \MongoDB\generate_index_name($index['key']);
}
if (!is_string($index['name'])) {
throw new InvalidArgumentTypeException('"name" option', $index['name'], 'string');
}
$this->index = $index;
}
/**
* This function will return clean variable info
*
* @param mixed $var
* @param string $indent Indent is used when dumping arrays recursivly
* @param string $indent_close_bracet Indent close bracket param is used
* internaly for array output. It is shorter that var indent for 2 spaces
* @return null
*/
function clean_var_info($var, $indent = ' ', $indent_close_bracet = '')
{
if (is_object($var)) {
return 'Object (class: ' . get_class($var) . ')';
} elseif (is_resource($var)) {
return 'Resource (type: ' . get_resource_type($var) . ')';
} elseif (is_array($var)) {
$result = 'Array (';
if (count($var)) {
foreach ($var as $k => $v) {
$k_for_display = is_integer($k) ? $k : "'" . clean($k) . "'";
$result .= "\n" . $indent . '[' . $k_for_display . '] => ' . clean_var_info($v, $indent . ' ', $indent_close_bracet . $indent);
}
// foreach
}
// if
return $result . "\n{$indent_close_bracet})";
} elseif (is_int($var)) {
return '(int)' . $var;
} elseif (is_float($var)) {
return '(float)' . $var;
} elseif (is_bool($var)) {
return $var ? 'true' : 'false';
} elseif (is_null($var)) {
return 'NULL';
} else {
return "(string) '" . clean($var) . "'";
}
// if
}
/**
* @param integer $value The max value for comparison
*/
public function __construct($value = null)
{
if ($value === null || !is_int($value) && !is_float($value)) {
throw new InvalidArgumentException("invalid value provided for 'value'; " . "expecting an integer or a float");
}
$this->max = $value;
}
public function __construct($arg1, $arg2 = null)
{
if (is_object($arg1) && is_null($arg2)) {
if (!is_a($arg1, 'midgard_object')) {
throw new InvalidArgumentException("You can instantiate spots only from MgdSchema objects");
}
$this->latitude = $arg1->latitude;
$this->longitude = $arg1->longitude;
if (isset($arg1->accuracy)) {
$this->accuracy = $arg1->accuracy;
}
$this->when = $arg1->metadata->created;
} elseif (is_string($arg1) && is_null($arg2)) {
$this->text = $arg1;
$this->accuracy = 80;
} else {
if (!is_float($arg1) || !is_float($arg2)) {
throw new InvalidArgumentException("A pair of WGS-84 coordinates expected");
}
$this->latitude = $arg1;
$this->longitude = $arg2;
}
if ($this->latitude > 90 || $this->latitude < -90) {
throw new InvalidArgumentException("WGS-84 latitude must be between 90 and -90 degrees");
}
if ($this->longitude > 180 || $this->longitude < -180) {
throw new InvalidArgumentException("WGS-84 longitude must be between 180 and -180 degrees");
}
}
/**
* Defined by Zend_Validate_Interface
*
* Returns true if and only if $value is a valid integer
*
* @param string|integer $value
* @return boolean
*/
public function isValid($value)
{
if (!is_string($value) && !is_int($value) && !is_float($value)) {
$this->error(self::INVALID);
return false;
}
if (is_int($value)) {
return true;
}
$this->setValue($value);
if ($this->locale === null) {
$locale = localeconv();
$valueFiltered = str_replace($locale['decimal_point'], '.', $value);
$valueFiltered = str_replace($locale['thousands_sep'], '', $valueFiltered);
if (strval(intval($valueFiltered)) != $valueFiltered) {
$this->error(self::NOT_INT);
return false;
}
} else {
try {
if (!Zend_Locale_Format::isInteger($value, ['locale' => $this->locale])) {
$this->error(self::NOT_INT);
return false;
}
} catch (Zend_Locale_Exception $e) {
$this->error(self::NOT_INT);
return false;
}
}
return true;
}
function mypercentile($X, $percentile)
{
if (0 < $percentile && $percentile < 1) {
$p = $percentile;
} else {
if (1 < $percentile && $percentile <= 100) {
$p = $percentile * 0.01;
} else {
return "";
}
}
$count = count($X);
$allindex = ($count - 1) * $p;
$intvalindex = intval($allindex);
$floatval = $allindex - $intvalindex;
sort($X);
if (!is_float($floatval)) {
$result = $X[$intvalindex];
} else {
if ($count > $intvalindex + 1) {
$result = $floatval * ($X[$intvalindex + 1] - $X[$intvalindex]) + $X[$intvalindex];
} else {
$result = $X[$intvalindex];
}
}
return $result;
}
public $optional_fields = array();
/**
* course_module ID associated
* @var int $instanceid
*/
public $taskid;
/**
* Assessor ID associated
* @var int $assessorid
*/
public $assessorid;
/**
* Student ID associated
* @var int $studentid
*/
public $studentid;
/**
* Grade
* @var int $grade
*/
public $grade;
/**
* The last time this evalcomix_assessment was modified.
* @var int $timemodified
*/
public $timemodified;
/**
* Constructor
*
* @param int $id ID
* @param int $instanceid //foreign key of table 'block_evalcomix_tasks'
* @param int $assessorid //foreign key of table 'user'
/**
* (non-PHPdoc)
* @see IValidator::isValid()
*/
public function isValid($val)
{
$this->val = $val;
$ereg = '/^' . $this->type . '$/i';
if (preg_match($ereg, 'int') || preg_match($ereg, 'integer')) {
$state = is_int($val);
} else {
if (preg_match($ereg, 'float')) {
$state = is_float($val);
} else {
if (preg_match($ereg, 'string')) {
$state = is_string($val);
} else {
if (preg_match($ereg, 'array')) {
$state = is_array($val);
} else {
if (preg_match($ereg, 'bool')) {
$state = is_bool($val);
} else {
if (preg_match($ereg, 'null')) {
$state = is_null($val);
}
}
}
}
}
}
if ($state === false) {
throw new TypeException($this->val, $this->type);
return false;
}
return true;
}
/**
* Returns true if and only if $value is a valid integer
*
* @param string|int $value
* @return bool
* @throws Exception\InvalidArgumentException
*/
public function isValid($value)
{
if (!is_string($value) && !is_int($value) && !is_float($value)) {
$this->error(self::INVALID);
return false;
}
if (is_int($value)) {
return true;
}
$this->setValue($value);
$locale = $this->getLocale();
$format = new NumberFormatter($locale, NumberFormatter::DECIMAL);
if (intl_is_failure($format->getErrorCode())) {
throw new Exception\InvalidArgumentException("Invalid locale string given");
}
$parsedInt = $format->parse($value, NumberFormatter::TYPE_INT64);
if (intl_is_failure($format->getErrorCode())) {
$this->error(self::NOT_INT);
return false;
}
$decimalSep = $format->getSymbol(NumberFormatter::DECIMAL_SEPARATOR_SYMBOL);
$groupingSep = $format->getSymbol(NumberFormatter::GROUPING_SEPARATOR_SYMBOL);
$valueFiltered = str_replace($groupingSep, '', $value);
$valueFiltered = str_replace($decimalSep, '.', $valueFiltered);
if (strval($parsedInt) !== $valueFiltered) {
$this->error(self::NOT_INT);
return false;
}
return true;
}
function _formatVar(&$value)
{
if (is_null($value)) {
return Artx_Log_Formatter::_formatNull($value);
}
if (is_bool($value)) {
return Artx_Log_Formatter::_formatBool($value);
}
if (is_int($value) || is_float($value)) {
return $value;
}
if (is_object($value)) {
return Artx_Log_Formatter::_formatObject($value);
}
// is_callable should be placed before is_string and is_array:
if (is_callable($value)) {
return Artx_Log_Formatter::_formatCallback($value);
}
if (is_string($value)) {
return Artx_Log_Formatter::_formatString($value);
}
if (is_array($value)) {
return Artx_Log_Formatter::_formatArray($value);
}
return gettype($value) . ' { ... }';
}
private function formatValue($value)
{
if (is_string($value)) {
if (strlen($value) > 20) {
$this->remaining[] = $value;
return '?';
} else {
return $this->connection->quote($value);
}
} elseif (is_int($value)) {
return (string) $value;
} elseif (is_float($value)) {
return rtrim(rtrim(number_format($value, 10, '.', ''), '0'), '.');
} elseif (is_bool($value)) {
return $this->driver->formatBool($value);
} elseif ($value === NULL) {
return 'NULL';
} elseif ($value instanceof Table\ActiveRow) {
return $value->getPrimary();
} elseif (is_array($value) || $value instanceof \Traversable) {
$vx = $kx = array();
if ($value instanceof \Traversable) {
$value = iterator_to_array($value);
}
if (isset($value[0])) {
// non-associative; value, value, value
foreach ($value as $v) {
$vx[] = $this->formatValue($v);
}
return implode(', ', $vx);
} elseif ($this->arrayMode === 'values') {
// (key, key, ...) VALUES (value, value, ...)
$this->arrayMode = 'multi';
foreach ($value as $k => $v) {
$kx[] = $this->driver->delimite($k);
$vx[] = $this->formatValue($v);
}
return '(' . implode(', ', $kx) . ') VALUES (' . implode(', ', $vx) . ')';
} elseif ($this->arrayMode === 'assoc') {
// key=value, key=value, ...
foreach ($value as $k => $v) {
$vx[] = $this->driver->delimite($k) . '=' . $this->formatValue($v);
}
return implode(', ', $vx);
} elseif ($this->arrayMode === 'multi') {
// multiple insert (value, value, ...), ...
foreach ($value as $v) {
$vx[] = $this->formatValue($v);
}
return '(' . implode(', ', $vx) . ')';
}
} elseif ($value instanceof \DateTime) {
return $this->driver->formatDateTime($value);
} elseif ($value instanceof SqlLiteral) {
return $value->__toString();
} else {
$this->remaining[] = $value;
return '?';
}
}
/**
* @param mixed $value
* @return Node\Expr
*/
public static function parserNodeFromValue($value)
{
if (is_array($value)) {
$items = array();
foreach ($value as $k => $v) {
$items[] = new Node\Expr\ArrayItem(static::parserNodeFromValue($v), static::parserNodeFromValue($k));
}
return new Node\Expr\Array_($items);
} else {
if (is_string($value)) {
return new Node\Scalar\String_($value);
} else {
if (is_int($value)) {
return new Node\Scalar\LNumber($value);
} else {
if (is_float($value)) {
return new Node\Scalar\DNumber($value);
} else {
if (is_null($value)) {
return new Node\Expr\ConstFetch(new Node\Name('null'));
} else {
if (is_bool($value)) {
return new Node\Expr\ConstFetch(new Node\Name($value ? 'true' : 'false'));
} else {
throw new Exception\DomainException('Unsupported value: ' . Utils::varInfo($value));
}
}
}
}
}
}
}
function StatsdPostResult(&$test, $testPath)
{
require_once 'page_data.inc';
$runs = $test['runs'];
if (array_key_exists('discard', $test) && $test['discard'] > 0 && $test['discard'] <= $runs) {
$runs -= $test['discard'];
}
if ($runs) {
$pageData = loadAllPageData($testPath);
$medians = array(GetMedianRun($pageData, 0), GetMedianRun($pageData, 1));
if (isset($pageData) && is_array($pageData)) {
foreach ($pageData as $run => &$pageRun) {
foreach ($pageRun as $cached => &$testData) {
if (GetSetting('statsdPattern') && !preg_match('/' . GetSetting('statsdPattern') . '/', $test['label'])) {
continue;
}
if (GetSetting('statsdMedianOnly') && !($medians[$cached] == $run)) {
continue;
}
$graphData = array();
foreach ($testData as $metric => $value) {
if (is_float($value)) {
$value = intval($value);
}
if (is_int($value) && $metric != 'result') {
$graphData[$metric] = $value;
}
}
StatsdPost($test['location'], $test['browser'], $test['label'], $cached, $graphData);
}
}
}
}
}
function display($op, $p1, $p2 = null)
{
global $calc;
$search = ['Chippyash\\Type\\Number\\Rational\\', 'Chippyash\\Type\\Number\\Complex\\', 'Chippyash\\Type\\Number\\'];
$replace = ['', '', ''];
if (is_int($p1)) {
$tA = 'PHP-Int';
} elseif (is_float($p1)) {
$tA = 'PHP-Float';
} else {
$tA = str_replace($search, $replace, get_class($p1));
}
if (!is_null($p2)) {
if (is_int($p2)) {
$tB = 'PHP-Int';
} elseif (is_float($p2)) {
$tB = 'PHP-Float';
} else {
$tB = str_replace($search, $replace, get_class($p2));
}
}
try {
$res = $calc->{$op}($p1, $p2);
$tR = str_replace($search, $replace, get_class($res));
if (!is_null($p2)) {
echo "{$tA}({$p1}) {$op} {$tB}({$p2}) = {$tR}({$res})" . PHP_EOL;
} else {
echo "{$op}({$tA}({$p1})) = {$tR}({$res})" . PHP_EOL;
}
} catch (InvalidTypeException $e) {
$msg = $e->getMessage();
echo "{$tA}({$p1}) {$op} {$tB}({$p2}) is invalid: {$msg}" . PHP_EOL;
}
}
function json_encode($data)
{
if (is_array($data)) {
$ret = array();
// OBJECT
if (array_keys($data) !== range(0, count($data) - 1)) {
foreach ($data as $key => $val) {
$ret[] = kcfinder_json_string_encode($key) . ':' . json_encode($val);
}
return "{" . implode(",", $ret) . "}";
// ARRAY
} else {
foreach ($data as $val) {
$ret[] = json_encode($val);
}
return "[" . implode(",", $ret) . "]";
}
// BOOLEAN OR NULL
} elseif (is_bool($data) || $data === null) {
return $data === null ? "null" : ($data ? "true" : "false");
} elseif (is_float($data)) {
return rtrim(rtrim(number_format($data, 14, ".", ""), "0"), ".");
} elseif (is_int($data)) {
return $data;
}
// STRING
return kcfinder_json_string_encode($data);
}
/**
* Constructor. Will build a new XML_RPC2_Backend_Php_Value_Datetime with the given value
*
* The provided value can be an int, which will be interpreted as a Unix timestamp, or
* a string in iso8601 format, or a "stdclass native value"
*
* @param mixed $nativeValue a timestamp, an iso8601 date or a "stdclass native value"
* @see http://www.w3.org/TR/NOTE-datetime
*/
public function __construct($nativeValue)
{
if (!is_int($nativeValue) and !is_float($nativeValue) and !is_string($nativeValue) and !is_object($nativeValue)) {
throw new XML_RPC2_InvalidTypeException(sprintf('Cannot create XML_RPC2_Backend_Php_Value_Datetime from type \'%s\'.', gettype($nativeValue)));
}
if (is_object($nativeValue) && strtolower(get_class($nativeValue)) == 'stdclass' && isset($nativeValue->xmlrpc_type)) {
$scalar = $nativeValue->scalar;
$timestamp = $nativeValue->timestamp;
} else {
if (is_int($nativeValue) or is_float($nativeValue)) {
$scalar = XML_RPC2_Backend_Php_Value_Datetime::_timestampToIso8601($nativeValue);
$timestamp = (int) $nativeValue;
} elseif (is_string($nativeValue)) {
$scalar = $nativeValue;
$timestamp = (int) XML_RPC2_Backend_Php_Value_Datetime::_iso8601ToTimestamp($nativeValue);
} else {
throw new XML_RPC2_InvalidTypeException(sprintf('Cannot create XML_RPC2_Backend_Php_Value_Datetime from type \'%s\'.', gettype($nativeValue)));
}
}
$tmp = new stdclass();
$tmp->scalar = $scalar;
$tmp->timestamp = $timestamp;
$tmp->xmlrpc_type = 'datetime';
$this->setNativeValue($tmp);
}
public static function doConvert(array $data, array $parent = array())
{
$output = '';
foreach ($data as $k => $v) {
$index = str_replace(' ', '-', $k);
if (is_array($v)) {
$sec = array_merge((array) $parent, (array) $index);
$output .= PHP_EOL . '[' . join('.', $sec) . ']' . PHP_EOL;
$output .= self::doConvert($v, $sec);
} else {
$output .= "{$index}=";
if (is_numeric($v) || is_float($v)) {
$output .= "{$v}";
} elseif (is_bool($v)) {
$output .= $v === true ? 1 : 0;
} elseif (is_string($v)) {
$output .= "'" . addcslashes($v, "'") . "'";
} else {
$output .= "{$v}";
}
$output .= PHP_EOL;
}
}
return $output;
}
public function timestamp($mapping, $value)
{
if ($value instanceof MongoDate) {
return $value->sec;
} else {
if ($value === NULL) {
return NULL;
} else {
if (is_int($value) || is_float($value)) {
return (int) $value;
} else {
if ($value instanceof Zend_Date) {
return $value->getTimestamp();
} else {
if (is_array($value) && isset($value['sec'])) {
return $value['sec'];
} else {
if (!strlen($value)) {
return NULL;
} else {
if (ctype_digit($value)) {
return intval($value);
} else {
if (($time = strtotime($value)) !== false) {
return $time;
}
}
}
}
}
}
}
}
return NULL;
}
/**
* Returns `true` if value is of the specified type
*
* @param string $type
* @param mixed $value
* @return bool
*/
protected function checkType($type, $value)
{
switch ($type) {
case 'array':
return is_array($value);
case 'bool':
case 'boolean':
return is_bool($value);
case 'callable':
return is_callable($value);
case 'float':
case 'double':
return is_float($value);
case 'int':
case 'integer':
return is_int($value);
case 'null':
return is_null($value);
case 'numeric':
return is_numeric($value);
case 'object':
return is_object($value);
case 'resource':
return is_resource($value);
case 'scalar':
return is_scalar($value);
case 'string':
return is_string($value);
case 'mixed':
return true;
default:
return $value instanceof $type;
}
}
/**
* getSum
* Get the sum for the transaction
*/
public function getSum()
{
if (is_float($this->sum)) {
return number_format($this->sum, 2, ',', '');
}
return str_replace(".", ",", $this->sum);
}
