vendor/jms/serializer/src/JsonSerializationVisitor.php line 90

  1. <?php
  3. declare(strict_types=1);
  5. namespace JMS\Serializer;
  7. use JMS\Serializer\Exception\NotAcceptableException;
  8. use JMS\Serializer\Exception\RuntimeException;
  9. use JMS\Serializer\Metadata\ClassMetadata;
  10. use JMS\Serializer\Metadata\PropertyMetadata;
  11. use JMS\Serializer\Visitor\SerializationVisitorInterface;
  13. final class JsonSerializationVisitor extends AbstractVisitor implements SerializationVisitorInterface
  14. {
  15. /**
  16. * @var int
  17. */
  18. private $options;
  20. /**
  21. * @var array
  22. */
  23. private $dataStack;
  24. /**
  25. * @var \ArrayObject|array
  26. */
  27. private $data;
  29. public function __construct(
  30. int $options = JSON_PRESERVE_ZERO_FRACTION
  31. ) {
  32. $this->dataStack = [];
  33. $this->options = $options;
  34. }
  36. /**
  37. * {@inheritdoc}
  38. */
  39. public function visitNull($data, array $type)
  40. {
  41. return null;
  42. }
  44. /**
  45. * {@inheritdoc}
  46. */
  47. public function visitString(string $data, array $type)
  48. {
  49. return $data;
  50. }
  52. /**
  53. * {@inheritdoc}
  54. */
  55. public function visitBoolean(bool $data, array $type)
  56. {
  57. return $data;
  58. }
  60. /**
  61. * {@inheritdoc}
  62. */
  63. public function visitInteger(int $data, array $type)
  64. {
  65. return $data;
  66. }
  68. /**
  69. * {@inheritdoc}
  70. */
  71. public function visitDouble(float $data, array $type)
  72. {
  73. $precision = $type['params'][0] ?? null;
  74. if (!is_int($precision)) {
  75. return $data;
  76. }
  78. $roundMode = $type['params'][1] ?? null;
  79. $roundMode = $this->mapRoundMode($roundMode);
  81. return round($data, $precision, $roundMode);
  82. }
  84. public function visitArray(array $data, array $type)
  85. {
  86. \array_push($this->dataStack, $data);
  88. $rs = isset($type['params'][1]) ? new \ArrayObject() : [];
  90. $isList = isset($type['params'][0]) && !isset($type['params'][1]);
  92. $elType = $this->getElementType($type);
  93. foreach ($data as $k => $v) {
  94. try {
  95. $v = $this->navigator->accept($v, $elType);
  96. } catch (NotAcceptableException $e) {
  97. continue;
  98. }
  100. if ($isList) {
  101. $rs[] = $v;
  102. } else {
  103. $rs[$k] = $v;
  104. }
  105. }
  107. \array_pop($this->dataStack);
  109. return $rs;
  110. }
  112. public function startVisitingObject(ClassMetadata $metadata, object $data, array $type): void
  113. {
  114. \array_push($this->dataStack, $this->data);
  115. $this->data = true === $metadata->isMap ? new \ArrayObject() : [];
  116. }
  118. /**
  119. * @return array|\ArrayObject
  120. */
  121. public function endVisitingObject(ClassMetadata $metadata, object $data, array $type)
  122. {
  123. $rs = $this->data;
  124. $this->data = \array_pop($this->dataStack);
  126. if (true !== $metadata->isList && empty($rs)) {
  127. return new \ArrayObject();
  128. }
  130. return $rs;
  131. }
  133. /**
  134. * {@inheritdoc}
  135. */
  136. public function visitProperty(PropertyMetadata $metadata, $v): void
  137. {
  138. try {
  139. $v = $this->navigator->accept($v, $metadata->type);
  140. } catch (NotAcceptableException $e) {
  141. return;
  142. }
  144. if (true === $metadata->skipWhenEmpty && ($v instanceof \ArrayObject || \is_array($v)) && 0 === count($v)) {
  145. return;
  146. }
  148. if ($metadata->inline) {
  149. if (\is_array($v) || ($v instanceof \ArrayObject)) {
  150. // concatenate the two array-like structures
  151. // is there anything faster?
  152. foreach ($v as $key => $value) {
  153. $this->data[$key] = $value;
  154. }
  155. }
  156. } else {
  157. $this->data[$metadata->serializedName] = $v;
  158. }
  159. }
  161. /**
  162. * Checks if some data key exists.
  163. */
  164. public function hasData(string $key): bool
  165. {
  166. return isset($this->data[$key]);
  167. }
  169. /**
  170. * @deprecated Use `::visitProperty(new StaticPropertyMetadata('', 'name', 'value'), 'value')` instead
  171. *
  172. * Allows you to replace existing data on the current object element.
  173. *
  174. * @param mixed $value This value must either be a regular scalar, or an array.
  175. * It must not contain any objects anymore.
  176. */
  177. public function setData(string $key, $value): void
  178. {
  179. $this->data[$key] = $value;
  180. }
  182. /**
  183. * {@inheritdoc}
  184. */
  185. public function getResult($data)
  186. {
  187. $this->navigator = null;
  189. $result = @json_encode($data, $this->options);
  191. switch (json_last_error()) {
  192. case JSON_ERROR_NONE:
  193. return $result;
  195. case JSON_ERROR_UTF8:
  196. throw new RuntimeException('Your data could not be encoded because it contains invalid UTF8 characters.');
  198. default:
  199. throw new RuntimeException(sprintf('An error occurred while encoding your data (error code %d).', json_last_error()));
  200. }
  201. }
  202. }