Your IP : 216.73.217.77
<?php
/**
* This file is part of the rybakit/msgpack.php package.
*
* (c) Eugene Leonovich <gen.work@gmail.com>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace MessagePack;
use MessagePack\Exception\InvalidOptionException;
use MessagePack\Exception\PackingFailedException;
class Packer
{
private const UTF8_REGEX = '/\A(?:
[\x00-\x7F]++ # ASCII
| [\xC2-\xDF][\x80-\xBF] # non-overlong 2-byte
| \xE0[\xA0-\xBF][\x80-\xBF] # excluding overlongs
| [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2} # straight 3-byte
| \xED[\x80-\x9F][\x80-\xBF] # excluding surrogates
| \xF0[\x90-\xBF][\x80-\xBF]{2} # planes 1-3
| [\xF1-\xF3][\x80-\xBF]{3} # planes 4-15
| \xF4[\x80-\x8F][\x80-\xBF]{2} # plane 16
)*+\z/x';
/** @var bool */
private $isDetectStrBin;
/** @var bool */
private $isForceStr;
/** @var bool */
private $isDetectArrMap;
/** @var bool */
private $isForceArr;
/** @var bool */
private $isForceFloat32;
/** @var CanPack[] */
private $transformers = [];
/**
* @param PackOptions|int|null $options
* @param CanPack[] $transformers
*
* @throws InvalidOptionException
*/
public function __construct($options = null, array $transformers = [])
{
if (\is_null($options)) {
$options = PackOptions::fromDefaults();
} elseif (!$options instanceof PackOptions) {
$options = PackOptions::fromBitmask($options);
}
$this->isDetectStrBin = $options->isDetectStrBinMode();
$this->isForceStr = $options->isForceStrMode();
$this->isDetectArrMap = $options->isDetectArrMapMode();
$this->isForceArr = $options->isForceArrMode();
$this->isForceFloat32 = $options->isForceFloat32Mode();
if ($transformers) {
$this->transformers = $transformers;
}
}
public function extendWith(CanPack $transformer, CanPack ...$transformers) : self
{
$new = clone $this;
$new->transformers[] = $transformer;
if ($transformers) {
$new->transformers = \array_merge($new->transformers, $transformers);
}
return $new;
}
/**
* @param mixed $value
*
* @return string
*/
public function pack($value)
{
if (\is_int($value)) {
return $this->packInt($value);
}
if (\is_string($value)) {
if ('' === $value) {
return $this->isForceStr || $this->isDetectStrBin ? "\xa0" : "\xc4\x00";
}
if ($this->isForceStr) {
return $this->packStr($value);
}
if ($this->isDetectStrBin && \preg_match(self::UTF8_REGEX, $value)) {
return $this->packStr($value);
}
return $this->packBin($value);
}
if (\is_array($value)) {
if ([] === $value) {
return $this->isDetectArrMap || $this->isForceArr ? "\x90" : "\x80";
}
if ($this->isDetectArrMap) {
if (!isset($value[0]) && !\array_key_exists(0, $value)) {
return $this->packMap($value);
}
return \array_values($value) === $value
? $this->packArray($value)
: $this->packMap($value);
}
return $this->isForceArr ? $this->packArray($value) : $this->packMap($value);
}
if (\is_null($value)) {
return "\xc0";
}
if (\is_bool($value)) {
return $value ? "\xc3" : "\xc2";
}
if (\is_float($value)) {
return $this->packFloat($value);
}
if ($this->transformers) {
foreach ($this->transformers as $transformer) {
if (!\is_null($packed = $transformer->pack($this, $value))) {
return $packed;
}
}
}
if ($value instanceof CanBePacked) {
return $value->pack($this);
}
throw PackingFailedException::unsupportedType($value);
}
/**
* @return string
*/
public function packNil()
{
return "\xc0";
}
/**
* @param string $bool
*
* @return string
*/
public function packBool($bool)
{
return $bool ? "\xc3" : "\xc2";
}
/**
* @param int $int
*
* @return string
*/
public function packInt($int)
{
if ($int >= 0) {
if ($int <= 0x7f) {
return \chr($int);
}
if ($int <= 0xff) {
return "\xcc".\chr($int);
}
if ($int <= 0xffff) {
return "\xcd".\chr($int >> 8).\chr($int);
}
if ($int <= 0xffffffff) {
return \pack('CN', 0xce, $int);
}
return \pack('CJ', 0xcf, $int);
}
if ($int >= -0x20) {
return \chr(0xe0 | $int);
}
if ($int >= -0x80) {
return "\xd0".\chr($int);
}
if ($int >= -0x8000) {
return "\xd1".\chr($int >> 8).\chr($int);
}
if ($int >= -0x80000000) {
return \pack('CN', 0xd2, $int);
}
return \pack('CJ', 0xd3, $int);
}
/**
* @param float $float
*
* @return string
*/
public function packFloat($float)
{
return $this->isForceFloat32
? "\xca".\pack('G', $float)
: "\xcb".\pack('E', $float);
}
/**
* @param float $float
*
* @return string
*/
public function packFloat32($float)
{
return "\xca".\pack('G', $float);
}
/**
* @param float $float
*
* @return string
*/
public function packFloat64($float)
{
return "\xcb".\pack('E', $float);
}
/**
* @param string $str
*
* @return string
*/
public function packStr($str)
{
$length = \strlen($str);
if ($length < 32) {
return \chr(0xa0 | $length).$str;
}
if ($length <= 0xff) {
return "\xd9".\chr($length).$str;
}
if ($length <= 0xffff) {
return "\xda".\chr($length >> 8).\chr($length).$str;
}
return \pack('CN', 0xdb, $length).$str;
}
/**
* @param string $str
*
* @return string
*/
public function packBin($str)
{
$length = \strlen($str);
if ($length <= 0xff) {
return "\xc4".\chr($length).$str;
}
if ($length <= 0xffff) {
return "\xc5".\chr($length >> 8).\chr($length).$str;
}
return \pack('CN', 0xc6, $length).$str;
}
/**
* @param array $array
*
* @return string
*/
public function packArray($array)
{
$data = $this->packArrayHeader(\count($array));
foreach ($array as $val) {
$data .= $this->pack($val);
}
return $data;
}
/**
* @param int $size
*
* @return string
*/
public function packArrayHeader($size)
{
if ($size <= 0xf) {
return \chr(0x90 | $size);
}
if ($size <= 0xffff) {
return "\xdc".\chr($size >> 8).\chr($size);
}
return \pack('CN', 0xdd, $size);
}
/**
* @param array $map
*
* @return string
*/
public function packMap($map)
{
$data = $this->packMapHeader(\count($map));
if ($this->isForceStr) {
foreach ($map as $key => $val) {
$data .= \is_string($key) ? $this->packStr($key) : $this->packInt($key);
$data .= $this->pack($val);
}
return $data;
}
if ($this->isDetectStrBin) {
foreach ($map as $key => $val) {
$data .= \is_string($key)
? (\preg_match(self::UTF8_REGEX, $key) ? $this->packStr($key) : $this->packBin($key))
: $this->packInt($key);
$data .= $this->pack($val);
}
return $data;
}
foreach ($map as $key => $val) {
$data .= \is_string($key) ? $this->packBin($key) : $this->packInt($key);
$data .= $this->pack($val);
}
return $data;
}
/**
* @param int $size
*
* @return string
*/
public function packMapHeader($size)
{
if ($size <= 0xf) {
return \chr(0x80 | $size);
}
if ($size <= 0xffff) {
return "\xde".\chr($size >> 8).\chr($size);
}
return \pack('CN', 0xdf, $size);
}
/**
* @param int $type
* @param string $data
*
* @return string
*/
public function packExt($type, $data)
{
$length = \strlen($data);
switch ($length) {
case 1: return "\xd4".\chr($type).$data;
case 2: return "\xd5".\chr($type).$data;
case 4: return "\xd6".\chr($type).$data;
case 8: return "\xd7".\chr($type).$data;
case 16: return "\xd8".\chr($type).$data;
}
if ($length <= 0xff) {
return "\xc7".\chr($length).\chr($type).$data;
}
if ($length <= 0xffff) {
return \pack('CnC', 0xc8, $length, $type).$data;
}
return \pack('CNC', 0xc9, $length, $type).$data;
}
}