/home/mip/public_html/img/credit/datatables/Type.tar
NumberInterface.php 0000644 00000001173 15152100363 0010324 0 ustar 00 <?php
/**
* This file is part of the ramsey/uuid library
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*
* @copyright Copyright (c) Ben Ramsey <ben@benramsey.com>
* @license http://opensource.org/licenses/MIT MIT
*/
declare(strict_types=1);
namespace Ramsey\Uuid\Type;
/**
* NumberInterface ensures consistency in numeric values returned by ramsey/uuid
*
* @psalm-immutable
*/
interface NumberInterface extends TypeInterface
{
/**
* Returns true if this number is less than zero
*/
public function isNegative(): bool;
}
Hexadecimal.php 0000644 00000005227 15152100363 0007463 0 ustar 00 <?php
/**
* This file is part of the ramsey/uuid library
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*
* @copyright Copyright (c) Ben Ramsey <ben@benramsey.com>
* @license http://opensource.org/licenses/MIT MIT
*/
declare(strict_types=1);
namespace Ramsey\Uuid\Type;
use Ramsey\Uuid\Exception\InvalidArgumentException;
use ValueError;
use function preg_match;
use function sprintf;
use function substr;
/**
* A value object representing a hexadecimal number
*
* This class exists for type-safety purposes, to ensure that hexadecimal numbers
* returned from ramsey/uuid methods as strings are truly hexadecimal and not some
* other kind of string.
*
* @psalm-immutable
*/
final class Hexadecimal implements TypeInterface
{
private string $value;
/**
* @param self|string $value The hexadecimal value to store
*/
public function __construct(self | string $value)
{
$this->value = $value instanceof self ? (string) $value : $this->prepareValue($value);
}
public function toString(): string
{
return $this->value;
}
public function __toString(): string
{
return $this->toString();
}
public function jsonSerialize(): string
{
return $this->toString();
}
public function serialize(): string
{
return $this->toString();
}
/**
* @return array{string: string}
*/
public function __serialize(): array
{
return ['string' => $this->toString()];
}
/**
* Constructs the object from a serialized string representation
*
* @param string $data The serialized string representation of the object
*
* @psalm-suppress UnusedMethodCall
*/
public function unserialize(string $data): void
{
$this->__construct($data);
}
/**
* @param array{string?: string} $data
*/
public function __unserialize(array $data): void
{
// @codeCoverageIgnoreStart
if (!isset($data['string'])) {
throw new ValueError(sprintf('%s(): Argument #1 ($data) is invalid', __METHOD__));
}
// @codeCoverageIgnoreEnd
$this->unserialize($data['string']);
}
private function prepareValue(string $value): string
{
$value = strtolower($value);
if (str_starts_with($value, '0x')) {
$value = substr($value, 2);
}
if (!preg_match('/^[A-Fa-f0-9]+$/', $value)) {
throw new InvalidArgumentException(
'Value must be a hexadecimal number'
);
}
return $value;
}
}
Decimal.php 0000644 00000006053 15152100363 0006613 0 ustar 00 <?php
/**
* This file is part of the ramsey/uuid library
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*
* @copyright Copyright (c) Ben Ramsey <ben@benramsey.com>
* @license http://opensource.org/licenses/MIT MIT
*/
declare(strict_types=1);
namespace Ramsey\Uuid\Type;
use Ramsey\Uuid\Exception\InvalidArgumentException;
use ValueError;
use function is_numeric;
use function sprintf;
use function str_starts_with;
/**
* A value object representing a decimal
*
* This class exists for type-safety purposes, to ensure that decimals
* returned from ramsey/uuid methods as strings are truly decimals and not some
* other kind of string.
*
* To support values as true decimals and not as floats or doubles, we store the
* decimals as strings.
*
* @psalm-immutable
*/
final class Decimal implements NumberInterface
{
private string $value;
private bool $isNegative = false;
public function __construct(float | int | string | self $value)
{
$value = (string) $value;
if (!is_numeric($value)) {
throw new InvalidArgumentException(
'Value must be a signed decimal or a string containing only '
. 'digits 0-9 and, optionally, a decimal point or sign (+ or -)'
);
}
// Remove the leading +-symbol.
if (str_starts_with($value, '+')) {
$value = substr($value, 1);
}
// For cases like `-0` or `-0.0000`, convert the value to `0`.
if (abs((float) $value) === 0.0) {
$value = '0';
}
if (str_starts_with($value, '-')) {
$this->isNegative = true;
}
$this->value = $value;
}
public function isNegative(): bool
{
return $this->isNegative;
}
public function toString(): string
{
return $this->value;
}
public function __toString(): string
{
return $this->toString();
}
public function jsonSerialize(): string
{
return $this->toString();
}
public function serialize(): string
{
return $this->toString();
}
/**
* @return array{string: string}
*/
public function __serialize(): array
{
return ['string' => $this->toString()];
}
/**
* Constructs the object from a serialized string representation
*
* @param string $data The serialized string representation of the object
*
* @psalm-suppress UnusedMethodCall
*/
public function unserialize(string $data): void
{
$this->__construct($data);
}
/**
* @param array{string?: string} $data
*
* @psalm-suppress UnusedMethodCall
*/
public function __unserialize(array $data): void
{
// @codeCoverageIgnoreStart
if (!isset($data['string'])) {
throw new ValueError(sprintf('%s(): Argument #1 ($data) is invalid', __METHOD__));
}
// @codeCoverageIgnoreEnd
$this->unserialize($data['string']);
}
}
Integer.php 0000644 00000007443 15152100363 0006656 0 ustar 00 <?php
/**
* This file is part of the ramsey/uuid library
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*
* @copyright Copyright (c) Ben Ramsey <ben@benramsey.com>
* @license http://opensource.org/licenses/MIT MIT
*/
declare(strict_types=1);
namespace Ramsey\Uuid\Type;
use Ramsey\Uuid\Exception\InvalidArgumentException;
use ValueError;
use function assert;
use function is_numeric;
use function preg_match;
use function sprintf;
use function substr;
/**
* A value object representing an integer
*
* This class exists for type-safety purposes, to ensure that integers
* returned from ramsey/uuid methods as strings are truly integers and not some
* other kind of string.
*
* To support large integers beyond PHP_INT_MAX and PHP_INT_MIN on both 64-bit
* and 32-bit systems, we store the integers as strings.
*
* @psalm-immutable
*/
final class Integer implements NumberInterface
{
/**
* @psalm-var numeric-string
*/
private string $value;
private bool $isNegative = false;
public function __construct(float | int | string | self $value)
{
$this->value = $value instanceof self ? (string) $value : $this->prepareValue($value);
}
public function isNegative(): bool
{
return $this->isNegative;
}
/**
* @psalm-return numeric-string
*/
public function toString(): string
{
return $this->value;
}
/**
* @psalm-return numeric-string
*/
public function __toString(): string
{
return $this->toString();
}
public function jsonSerialize(): string
{
return $this->toString();
}
public function serialize(): string
{
return $this->toString();
}
/**
* @return array{string: string}
*/
public function __serialize(): array
{
return ['string' => $this->toString()];
}
/**
* Constructs the object from a serialized string representation
*
* @param string $data The serialized string representation of the object
*
* @psalm-suppress UnusedMethodCall
*/
public function unserialize(string $data): void
{
$this->__construct($data);
}
/**
* @param array{string?: string} $data
*/
public function __unserialize(array $data): void
{
// @codeCoverageIgnoreStart
if (!isset($data['string'])) {
throw new ValueError(sprintf('%s(): Argument #1 ($data) is invalid', __METHOD__));
}
// @codeCoverageIgnoreEnd
$this->unserialize($data['string']);
}
/**
* @return numeric-string
*/
private function prepareValue(float | int | string $value): string
{
$value = (string) $value;
$sign = '+';
// If the value contains a sign, remove it for digit pattern check.
if (str_starts_with($value, '-') || str_starts_with($value, '+')) {
$sign = substr($value, 0, 1);
$value = substr($value, 1);
}
if (!preg_match('/^\d+$/', $value)) {
throw new InvalidArgumentException(
'Value must be a signed integer or a string containing only '
. 'digits 0-9 and, optionally, a sign (+ or -)'
);
}
// Trim any leading zeros.
$value = ltrim($value, '0');
// Set to zero if the string is empty after trimming zeros.
if ($value === '') {
$value = '0';
}
// Add the negative sign back to the value.
if ($sign === '-' && $value !== '0') {
$value = $sign . $value;
/** @psalm-suppress InaccessibleProperty */
$this->isNegative = true;
}
assert(is_numeric($value));
return $value;
}
}
TypeInterface.php 0000644 00000001225 15152100363 0010013 0 ustar 00 <?php
/**
* This file is part of the ramsey/uuid library
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*
* @copyright Copyright (c) Ben Ramsey <ben@benramsey.com>
* @license http://opensource.org/licenses/MIT MIT
*/
declare(strict_types=1);
namespace Ramsey\Uuid\Type;
use JsonSerializable;
use Serializable;
/**
* TypeInterface ensures consistency in typed values returned by ramsey/uuid
*
* @psalm-immutable
*/
interface TypeInterface extends JsonSerializable, Serializable
{
public function toString(): string;
public function __toString(): string;
}
Time.php 0000644 00000006570 15152100363 0006157 0 ustar 00 <?php
/**
* This file is part of the ramsey/uuid library
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*
* @copyright Copyright (c) Ben Ramsey <ben@benramsey.com>
* @license http://opensource.org/licenses/MIT MIT
*/
declare(strict_types=1);
namespace Ramsey\Uuid\Type;
use Ramsey\Uuid\Exception\UnsupportedOperationException;
use Ramsey\Uuid\Type\Integer as IntegerObject;
use ValueError;
use function json_decode;
use function json_encode;
use function sprintf;
/**
* A value object representing a timestamp
*
* This class exists for type-safety purposes, to ensure that timestamps used
* by ramsey/uuid are truly timestamp integers and not some other kind of string
* or integer.
*
* @psalm-immutable
*/
final class Time implements TypeInterface
{
private IntegerObject $seconds;
private IntegerObject $microseconds;
public function __construct(
float | int | string | IntegerObject $seconds,
float | int | string | IntegerObject $microseconds = 0,
) {
$this->seconds = new IntegerObject($seconds);
$this->microseconds = new IntegerObject($microseconds);
}
public function getSeconds(): IntegerObject
{
return $this->seconds;
}
public function getMicroseconds(): IntegerObject
{
return $this->microseconds;
}
public function toString(): string
{
return $this->seconds->toString() . '.' . sprintf('%06s', $this->microseconds->toString());
}
public function __toString(): string
{
return $this->toString();
}
/**
* @return string[]
*/
public function jsonSerialize(): array
{
return [
'seconds' => $this->getSeconds()->toString(),
'microseconds' => $this->getMicroseconds()->toString(),
];
}
public function serialize(): string
{
return (string) json_encode($this);
}
/**
* @return array{seconds: string, microseconds: string}
*/
public function __serialize(): array
{
return [
'seconds' => $this->getSeconds()->toString(),
'microseconds' => $this->getMicroseconds()->toString(),
];
}
/**
* Constructs the object from a serialized string representation
*
* @param string $data The serialized string representation of the object
*
* @psalm-suppress UnusedMethodCall
*/
public function unserialize(string $data): void
{
/** @var array{seconds?: int|float|string, microseconds?: int|float|string} $time */
$time = json_decode($data, true);
if (!isset($time['seconds']) || !isset($time['microseconds'])) {
throw new UnsupportedOperationException(
'Attempted to unserialize an invalid value'
);
}
$this->__construct($time['seconds'], $time['microseconds']);
}
/**
* @param array{seconds?: string, microseconds?: string} $data
*/
public function __unserialize(array $data): void
{
// @codeCoverageIgnoreStart
if (!isset($data['seconds']) || !isset($data['microseconds'])) {
throw new ValueError(sprintf('%s(): Argument #1 ($data) is invalid', __METHOD__));
}
// @codeCoverageIgnoreEnd
$this->__construct($data['seconds'], $data['microseconds']);
}
}
