This is an automated email from the ASF dual-hosted git repository.
github-actions[bot] pushed a commit to branch gh-pages
in repository https://gitbox.apache.org/repos/asf/iceberg-rust.git
The following commit(s) were added to refs/heads/gh-pages by this push:
new e3256fb73 deploy: 2fddb1601a9af1c97a559baa9865e1494d93756c
e3256fb73 is described below
commit e3256fb730b0ceb34e01aa6bfc3aa420af9332ef
Author: github-merge-queue[bot]
<github-merge-queue[bot]@users.noreply.github.com>
AuthorDate: Sun Oct 11 18:31:42 2026 +0000
deploy: 2fddb1601a9af1c97a559baa9865e1494d93756c
---
api/search.index/path/119ee0ca2c.js | 1 +
api/search.index/path/a39776ea4f.js | 1 -
api/search.index/root.js | 2 +-
api/src/iceberg/spec/values/serde.rs.html | 643 +++++++++++++++---------------
4 files changed, 325 insertions(+), 322 deletions(-)
diff --git a/api/search.index/path/119ee0ca2c.js
b/api/search.index/path/119ee0ca2c.js
new file mode 100644
index 000000000..fe2a085f1
--- /dev/null
+++ b/api/search.index/path/119ee0ca2c.js
@@ -0,0 +1 @@
+rd_("g[17,\"\"]000f[1,\"\"]0Aa[10,\"bnum::cast\"]Bn[15,\"iceberg_storage_opendal::OpenDalStorage\"]Eg[5,\"tower_http::follow_redirect::policy::or\",\"tower_http::follow_redirect::policy::or\"]1Ce[15,\"iceberg_storage_opendal::OpenDalStorageFactory\"]4Bb[2,\"iceberg::io::storage::config\"]m[2,\"iceberg\"]Ai[2,\"iceberg::encryption\"]2Am[2,\"iceberg_storage_opendal\"]8Ei[5,\"tower_http::follow_redirect::policy::and\",\"tower_http::follow_redirect::policy::and\"]A`[10,\"core::any\"]Ao[5,\"a
[...]
\ No newline at end of file
diff --git a/api/search.index/path/a39776ea4f.js
b/api/search.index/path/a39776ea4f.js
deleted file mode 100644
index 215fbab09..000000000
--- a/api/search.index/path/a39776ea4f.js
+++ /dev/null
@@ -1 +0,0 @@
-rd_("g[17,\"\"]000f[1,\"\"]0Aa[10,\"bnum::cast\"]Bn[15,\"iceberg_storage_opendal::OpenDalStorage\"]Eg[5,\"tower_http::follow_redirect::policy::or\",\"tower_http::follow_redirect::policy::or\"]1Ce[15,\"iceberg_storage_opendal::OpenDalStorageFactory\"]4Bb[2,\"iceberg::io::storage::config\"]m[2,\"iceberg\"]Ai[2,\"iceberg::encryption\"]2Am[2,\"iceberg_storage_opendal\"]8Ei[5,\"tower_http::follow_redirect::policy::and\",\"tower_http::follow_redirect::policy::and\"]A`[10,\"core::any\"]Ao[5,\"a
[...]
\ No newline at end of file
diff --git a/api/search.index/root.js b/api/search.index/root.js
index bdea23c2c..f8a55eed9 100644
--- a/api/search.index/root.js
+++ b/api/search.index/root.js
@@ -1 +1 @@
-rr_('{"normalizedName":{"I":"VYLAAAAUgxOVAVkH5gt9DqQOJQHAAAAwrgOcBAIFNAAFfw4lAcAAABB/DjZ9FlgiVQLAAAAS6AsVoxpyc6YBrgOcBAIFqwt1/MBEAgAAQVkH5gt9DqQOEAAFEX4OHgAfACAAlgFfELsf8iEVAcAAACFWEHYcbqcBBQLAAAATqh8QdRxhcwEBAcUAABvcZOILBQAAIAUAAJEJAAAA4AUCwwAAp8AhovUgZHNFAcIAABWHGmOlCaYJpwndCRUBwAAAEugLcqYBFAHCdGQAABZlZmF1bHRIHGQjBXYbAAH+CE4cAGnLplVyxAAAIBZzANKtGgAA2xUB0QAAFmIiZDUiFQHWAAAWcSJkYSIxwAAAOxCIHoke84ECZnAJAtAAACGtzQAAIT1lbSHDAAARHRwgocgAAH0hFQHHAAAW5iFkKCD7AmNlBQLAAAAUYxOj1SBleQXAwAMBAAAiwhR
[...]
\ No newline at end of file
+rr_('{"normalizedName":{"I":"VYLAAAAUgxOVAVkH5gt9DqQOJQHAAAAwrgOcBAIFNAAFfw4lAcAAABB/DjZ9FlgiVQLAAAAS6AsVoxpyc6YBrgOcBAIFqwt1/MBEAgAAQVkH5gt9DqQOEAAFEX4OHgAfACAAlgFfELsf8iEVAcAAACFWEHYcbqcBBQLAAAATqh8QdRxhcwEBAcUAABvcZOILBQAAIAUAAJEJAAAA4AUCwwAAp8AhovUgZHNFAcIAABWHGmOlCaYJpwndCRUBwAAAEugLcqYBFAHCdGQAABZlZmF1bHRIHGQjBXYbAAH+CE4cAGnLplVyxAAAIBZzANKtGgAA2xUB0QAAFmIiZDUiFQHWAAAWcSJkYSIxwAAAOxCIHoke84ECZnAJAtAAACGtzQAAIT1lbSHDAAARHRwgocgAAH0hFQHHAAAW5iFkKCD7AmNlBQLAAAAUYxOj1SBleQXAwAMBAAAiwhR
[...]
\ No newline at end of file
diff --git a/api/src/iceberg/spec/values/serde.rs.html
b/api/src/iceberg/spec/values/serde.rs.html
index 5b3e53731..1b4ec43cb 100644
--- a/api/src/iceberg/spec/values/serde.rs.html
+++ b/api/src/iceberg/spec/values/serde.rs.html
@@ -428,329 +428,332 @@
<a href=#428 id=428 data-nosnippet>428</a> };
<a href=#429 id=429 data-nosnippet>429</a> <span class="kw">match
</span><span class="self">self </span>{
<a href=#430 id=430 data-nosnippet>430</a> RawLiteralEnum::Null
=> <span class="prelude-val">Ok</span>(<span
class="prelude-val">None</span>),
-<a href=#431 id=431 data-nosnippet>431</a>
RawLiteralEnum::Boolean(v) => <span class="prelude-val">Ok</span>(<span
class="prelude-val">Some</span>(Literal::bool(v))),
-<a href=#432 id=432 data-nosnippet>432</a>
RawLiteralEnum::Int(v) => <span class="kw">match </span>ty {
-<a href=#433 id=433 data-nosnippet>433</a>
Type::Primitive(PrimitiveType::Int) => <span
class="prelude-val">Ok</span>(<span
class="prelude-val">Some</span>(Literal::int(v))),
-<a href=#434 id=434 data-nosnippet>434</a>
Type::Primitive(PrimitiveType::Long) => <span
class="prelude-val">Ok</span>(<span
class="prelude-val">Some</span>(Literal::long(i64::from(v)))),
-<a href=#435 id=435 data-nosnippet>435</a>
Type::Primitive(PrimitiveType::Date) => <span
class="prelude-val">Ok</span>(<span
class="prelude-val">Some</span>(Literal::date(v))),
-<a href=#436 id=436 data-nosnippet>436</a> <span
class="kw">_ </span>=> <span
class="prelude-val">Err</span>(invalid_err(<span class="string">"int"</span>)),
-<a href=#437 id=437 data-nosnippet>437</a> },
-<a href=#438 id=438 data-nosnippet>438</a>
RawLiteralEnum::Long(v) => <span class="kw">match </span>ty {
-<a href=#439 id=439 data-nosnippet>439</a>
Type::Primitive(PrimitiveType::Int) => <span
class="prelude-val">Ok</span>(<span
class="prelude-val">Some</span>(Literal::int(
-<a href=#440 id=440 data-nosnippet>440</a>
i32::try_from(v).map_err(|<span class="kw">_</span>| invalid_err(<span
class="string">"long"</span>))<span class="question-mark">?</span>,
-<a href=#441 id=441 data-nosnippet>441</a> ))),
-<a href=#442 id=442 data-nosnippet>442</a>
Type::Primitive(PrimitiveType::Date) => <span
class="prelude-val">Ok</span>(<span
class="prelude-val">Some</span>(Literal::date(
+<a href=#431 id=431 data-nosnippet>431</a>
RawLiteralEnum::Boolean(v) => <span class="kw">match </span>ty {
+<a href=#432 id=432 data-nosnippet>432</a>
Type::Primitive(PrimitiveType::Boolean) => <span
class="prelude-val">Ok</span>(<span
class="prelude-val">Some</span>(Literal::bool(v))),
+<a href=#433 id=433 data-nosnippet>433</a> <span
class="kw">_ </span>=> <span
class="prelude-val">Err</span>(invalid_err(<span
class="string">"boolean"</span>)),
+<a href=#434 id=434 data-nosnippet>434</a> },
+<a href=#435 id=435 data-nosnippet>435</a>
RawLiteralEnum::Int(v) => <span class="kw">match </span>ty {
+<a href=#436 id=436 data-nosnippet>436</a>
Type::Primitive(PrimitiveType::Int) => <span
class="prelude-val">Ok</span>(<span
class="prelude-val">Some</span>(Literal::int(v))),
+<a href=#437 id=437 data-nosnippet>437</a>
Type::Primitive(PrimitiveType::Long) => <span
class="prelude-val">Ok</span>(<span
class="prelude-val">Some</span>(Literal::long(i64::from(v)))),
+<a href=#438 id=438 data-nosnippet>438</a>
Type::Primitive(PrimitiveType::Date) => <span
class="prelude-val">Ok</span>(<span
class="prelude-val">Some</span>(Literal::date(v))),
+<a href=#439 id=439 data-nosnippet>439</a> <span
class="kw">_ </span>=> <span
class="prelude-val">Err</span>(invalid_err(<span class="string">"int"</span>)),
+<a href=#440 id=440 data-nosnippet>440</a> },
+<a href=#441 id=441 data-nosnippet>441</a>
RawLiteralEnum::Long(v) => <span class="kw">match </span>ty {
+<a href=#442 id=442 data-nosnippet>442</a>
Type::Primitive(PrimitiveType::Int) => <span
class="prelude-val">Ok</span>(<span
class="prelude-val">Some</span>(Literal::int(
<a href=#443 id=443 data-nosnippet>443</a>
i32::try_from(v).map_err(|<span class="kw">_</span>| invalid_err(<span
class="string">"long"</span>))<span class="question-mark">?</span>,
<a href=#444 id=444 data-nosnippet>444</a> ))),
-<a href=#445 id=445 data-nosnippet>445</a>
Type::Primitive(PrimitiveType::Long) => <span
class="prelude-val">Ok</span>(<span
class="prelude-val">Some</span>(Literal::long(v))),
-<a href=#446 id=446 data-nosnippet>446</a>
Type::Primitive(PrimitiveType::Time) => <span
class="prelude-val">Ok</span>(<span
class="prelude-val">Some</span>(Literal::time(v))),
-<a href=#447 id=447 data-nosnippet>447</a>
Type::Primitive(PrimitiveType::Timestamp) => <span
class="prelude-val">Ok</span>(<span
class="prelude-val">Some</span>(Literal::timestamp(v))),
-<a href=#448 id=448 data-nosnippet>448</a>
Type::Primitive(PrimitiveType::Timestamptz) => {
-<a href=#449 id=449 data-nosnippet>449</a> <span
class="prelude-val">Ok</span>(<span
class="prelude-val">Some</span>(Literal::timestamptz(v)))
-<a href=#450 id=450 data-nosnippet>450</a> }
-<a href=#451 id=451 data-nosnippet>451</a>
Type::Primitive(PrimitiveType::TimestampNs) => {
-<a href=#452 id=452 data-nosnippet>452</a> <span
class="prelude-val">Ok</span>(<span
class="prelude-val">Some</span>(Literal::timestamp_nano(v)))
+<a href=#445 id=445 data-nosnippet>445</a>
Type::Primitive(PrimitiveType::Date) => <span
class="prelude-val">Ok</span>(<span
class="prelude-val">Some</span>(Literal::date(
+<a href=#446 id=446 data-nosnippet>446</a>
i32::try_from(v).map_err(|<span class="kw">_</span>| invalid_err(<span
class="string">"long"</span>))<span class="question-mark">?</span>,
+<a href=#447 id=447 data-nosnippet>447</a> ))),
+<a href=#448 id=448 data-nosnippet>448</a>
Type::Primitive(PrimitiveType::Long) => <span
class="prelude-val">Ok</span>(<span
class="prelude-val">Some</span>(Literal::long(v))),
+<a href=#449 id=449 data-nosnippet>449</a>
Type::Primitive(PrimitiveType::Time) => <span
class="prelude-val">Ok</span>(<span
class="prelude-val">Some</span>(Literal::time(v))),
+<a href=#450 id=450 data-nosnippet>450</a>
Type::Primitive(PrimitiveType::Timestamp) => <span
class="prelude-val">Ok</span>(<span
class="prelude-val">Some</span>(Literal::timestamp(v))),
+<a href=#451 id=451 data-nosnippet>451</a>
Type::Primitive(PrimitiveType::Timestamptz) => {
+<a href=#452 id=452 data-nosnippet>452</a> <span
class="prelude-val">Ok</span>(<span
class="prelude-val">Some</span>(Literal::timestamptz(v)))
<a href=#453 id=453 data-nosnippet>453</a> }
-<a href=#454 id=454 data-nosnippet>454</a>
Type::Primitive(PrimitiveType::TimestamptzNs) => {
-<a href=#455 id=455 data-nosnippet>455</a> <span
class="prelude-val">Ok</span>(<span
class="prelude-val">Some</span>(Literal::timestamptz_nano(v)))
+<a href=#454 id=454 data-nosnippet>454</a>
Type::Primitive(PrimitiveType::TimestampNs) => {
+<a href=#455 id=455 data-nosnippet>455</a> <span
class="prelude-val">Ok</span>(<span
class="prelude-val">Some</span>(Literal::timestamp_nano(v)))
<a href=#456 id=456 data-nosnippet>456</a> }
-<a href=#457 id=457 data-nosnippet>457</a> <span
class="kw">_ </span>=> <span
class="prelude-val">Err</span>(invalid_err(<span class="string">"long"</span>)),
-<a href=#458 id=458 data-nosnippet>458</a> },
-<a href=#459 id=459 data-nosnippet>459</a>
RawLiteralEnum::Float(v) => <span class="kw">match </span>ty {
-<a href=#460 id=460 data-nosnippet>460</a>
Type::Primitive(PrimitiveType::Float) => <span
class="prelude-val">Ok</span>(<span
class="prelude-val">Some</span>(Literal::float(v))),
-<a href=#461 id=461 data-nosnippet>461</a>
Type::Primitive(PrimitiveType::Double) => {
-<a href=#462 id=462 data-nosnippet>462</a> <span
class="prelude-val">Ok</span>(<span
class="prelude-val">Some</span>(Literal::double(f64::from(v))))
-<a href=#463 id=463 data-nosnippet>463</a> }
-<a href=#464 id=464 data-nosnippet>464</a> <span
class="kw">_ </span>=> <span
class="prelude-val">Err</span>(invalid_err(<span
class="string">"float"</span>)),
-<a href=#465 id=465 data-nosnippet>465</a> },
-<a href=#466 id=466 data-nosnippet>466</a>
RawLiteralEnum::Double(v) => <span class="kw">match </span>ty {
-<a href=#467 id=467 data-nosnippet>467</a>
Type::Primitive(PrimitiveType::Float) => {
-<a href=#468 id=468 data-nosnippet>468</a> <span
class="kw">let </span>v_32 = v <span class="kw">as </span>f32;
-<a href=#469 id=469 data-nosnippet>469</a> <span
class="kw">if </span>v_32.is_finite() {
-<a href=#470 id=470 data-nosnippet>470</a> <span
class="kw">let </span>v_64 = f64::from(v_32);
-<a href=#471 id=471 data-nosnippet>471</a> <span
class="kw">if </span>(v_64 - v).abs() > f32::EPSILON <span class="kw">as
</span>f64 {
-<a href=#472 id=472 data-nosnippet>472</a>
<span class="comment">// there is a precision loss
-<a href=#473 id=473 data-nosnippet>473</a>
</span><span class="kw">return </span><span
class="prelude-val">Err</span>(invalid_err(<span
class="string">"double"</span>));
-<a href=#474 id=474 data-nosnippet>474</a> }
-<a href=#475 id=475 data-nosnippet>475</a> }
-<a href=#476 id=476 data-nosnippet>476</a> <span
class="prelude-val">Ok</span>(<span
class="prelude-val">Some</span>(Literal::float(v_32)))
-<a href=#477 id=477 data-nosnippet>477</a> }
-<a href=#478 id=478 data-nosnippet>478</a>
Type::Primitive(PrimitiveType::Double) => <span
class="prelude-val">Ok</span>(<span
class="prelude-val">Some</span>(Literal::double(v))),
-<a href=#479 id=479 data-nosnippet>479</a> <span
class="kw">_ </span>=> <span
class="prelude-val">Err</span>(invalid_err(<span
class="string">"double"</span>)),
-<a href=#480 id=480 data-nosnippet>480</a> },
-<a href=#481 id=481 data-nosnippet>481</a>
RawLiteralEnum::String(v) => <span class="kw">match </span>ty {
-<a href=#482 id=482 data-nosnippet>482</a>
Type::Primitive(PrimitiveType::String) => <span
class="prelude-val">Ok</span>(<span
class="prelude-val">Some</span>(Literal::string(v))),
-<a href=#483 id=483 data-nosnippet>483</a> <span
class="kw">_ </span>=> <span
class="prelude-val">Err</span>(invalid_err(<span
class="string">"string"</span>)),
-<a href=#484 id=484 data-nosnippet>484</a> },
-<a href=#485 id=485 data-nosnippet>485</a>
RawLiteralEnum::Bytes(v) => <span class="kw">match </span>ty {
-<a href=#486 id=486 data-nosnippet>486</a>
Type::Primitive(PrimitiveType::Binary) => <span
class="prelude-val">Ok</span>(<span
class="prelude-val">Some</span>(Literal::binary(v.to_vec()))),
-<a href=#487 id=487 data-nosnippet>487</a>
Type::Primitive(PrimitiveType::Fixed(expected_len)) => {
-<a href=#488 id=488 data-nosnippet>488</a> <span
class="kw">if </span>v.len() == <span class="kw-2">*</span>expected_len <span
class="kw">as </span>usize {
-<a href=#489 id=489 data-nosnippet>489</a> <span
class="prelude-val">Ok</span>(<span
class="prelude-val">Some</span>(Literal::fixed(v.to_vec())))
-<a href=#490 id=490 data-nosnippet>490</a> } <span
class="kw">else </span>{
-<a href=#491 id=491 data-nosnippet>491</a> <span
class="prelude-val">Err</span>(invalid_err_with_reason(
-<a href=#492 id=492 data-nosnippet>492</a>
<span class="string">"bytes"</span>,
-<a href=#493 id=493 data-nosnippet>493</a>
<span class="kw-2">&</span><span class="macro">format!</span>(
-<a href=#494 id=494 data-nosnippet>494</a>
<span class="string">"Fixed type must be exactly {} bytes, got {}"</span>,
-<a href=#495 id=495 data-nosnippet>495</a>
expected_len,
-<a href=#496 id=496 data-nosnippet>496</a>
v.len()
-<a href=#497 id=497 data-nosnippet>497</a> ),
-<a href=#498 id=498 data-nosnippet>498</a> ))
-<a href=#499 id=499 data-nosnippet>499</a> }
-<a href=#500 id=500 data-nosnippet>500</a> }
-<a href=#501 id=501 data-nosnippet>501</a>
Type::Primitive(PrimitiveType::Uuid) => {
-<a href=#502 id=502 data-nosnippet>502</a> <span
class="kw">if </span>v.len() == <span class="number">16 </span>{
-<a href=#503 id=503 data-nosnippet>503</a> <span
class="kw">let </span>bytes: [u8; <span class="number">16</span>] =
v.as_slice().try_into().map_err(|<span class="kw">_</span>| {
-<a href=#504 id=504 data-nosnippet>504</a>
invalid_err_with_reason(<span class="string">"bytes"</span>, <span
class="string">"UUID must be exactly 16 bytes"</span>)
-<a href=#505 id=505 data-nosnippet>505</a> })<span
class="question-mark">?</span>;
-<a href=#506 id=506 data-nosnippet>506</a> <span
class="prelude-val">Ok</span>(<span
class="prelude-val">Some</span>(Literal::uuid(uuid::Uuid::from_bytes(bytes))))
-<a href=#507 id=507 data-nosnippet>507</a> } <span
class="kw">else </span>{
-<a href=#508 id=508 data-nosnippet>508</a> <span
class="prelude-val">Err</span>(invalid_err_with_reason(
-<a href=#509 id=509 data-nosnippet>509</a>
<span class="string">"bytes"</span>,
-<a href=#510 id=510 data-nosnippet>510</a>
<span class="string">"UUID must be exactly 16 bytes"</span>,
-<a href=#511 id=511 data-nosnippet>511</a> ))
-<a href=#512 id=512 data-nosnippet>512</a> }
-<a href=#513 id=513 data-nosnippet>513</a> }
-<a href=#514 id=514 data-nosnippet>514</a>
Type::Primitive(PrimitiveType::Decimal { precision, .. }) => {
-<a href=#515 id=515 data-nosnippet>515</a> <span
class="kw">let </span>required_bytes = Type::decimal_required_bytes(<span
class="kw-2">*</span>precision)<span class="question-mark">? </span><span
class="kw">as </span>usize;
-<a href=#516 id=516 data-nosnippet>516</a>
-<a href=#517 id=517 data-nosnippet>517</a> <span
class="kw">if </span>v.len() == required_bytes {
-<a href=#518 id=518 data-nosnippet>518</a> <span
class="comment">// Pad the bytes to 16 bytes (i128 size) with sign extension
-<a href=#519 id=519 data-nosnippet>519</a>
</span><span class="kw">let </span><span class="kw-2">mut </span>padded_bytes =
[<span class="number">0u8</span>; <span class="number">16</span>];
-<a href=#520 id=520 data-nosnippet>520</a> <span
class="kw">let </span>start_idx = <span class="number">16 </span>- v.len();
-<a href=#521 id=521 data-nosnippet>521</a>
-<a href=#522 id=522 data-nosnippet>522</a> <span
class="comment">// Copy the input bytes to the end of the array
-<a href=#523 id=523 data-nosnippet>523</a>
</span>padded_bytes[start_idx..].copy_from_slice(<span
class="kw-2">&</span>v);
+<a href=#457 id=457 data-nosnippet>457</a>
Type::Primitive(PrimitiveType::TimestamptzNs) => {
+<a href=#458 id=458 data-nosnippet>458</a> <span
class="prelude-val">Ok</span>(<span
class="prelude-val">Some</span>(Literal::timestamptz_nano(v)))
+<a href=#459 id=459 data-nosnippet>459</a> }
+<a href=#460 id=460 data-nosnippet>460</a> <span
class="kw">_ </span>=> <span
class="prelude-val">Err</span>(invalid_err(<span class="string">"long"</span>)),
+<a href=#461 id=461 data-nosnippet>461</a> },
+<a href=#462 id=462 data-nosnippet>462</a>
RawLiteralEnum::Float(v) => <span class="kw">match </span>ty {
+<a href=#463 id=463 data-nosnippet>463</a>
Type::Primitive(PrimitiveType::Float) => <span
class="prelude-val">Ok</span>(<span
class="prelude-val">Some</span>(Literal::float(v))),
+<a href=#464 id=464 data-nosnippet>464</a>
Type::Primitive(PrimitiveType::Double) => {
+<a href=#465 id=465 data-nosnippet>465</a> <span
class="prelude-val">Ok</span>(<span
class="prelude-val">Some</span>(Literal::double(f64::from(v))))
+<a href=#466 id=466 data-nosnippet>466</a> }
+<a href=#467 id=467 data-nosnippet>467</a> <span
class="kw">_ </span>=> <span
class="prelude-val">Err</span>(invalid_err(<span
class="string">"float"</span>)),
+<a href=#468 id=468 data-nosnippet>468</a> },
+<a href=#469 id=469 data-nosnippet>469</a>
RawLiteralEnum::Double(v) => <span class="kw">match </span>ty {
+<a href=#470 id=470 data-nosnippet>470</a>
Type::Primitive(PrimitiveType::Float) => {
+<a href=#471 id=471 data-nosnippet>471</a> <span
class="kw">let </span>v_32 = v <span class="kw">as </span>f32;
+<a href=#472 id=472 data-nosnippet>472</a> <span
class="kw">if </span>v_32.is_finite() {
+<a href=#473 id=473 data-nosnippet>473</a> <span
class="kw">let </span>v_64 = f64::from(v_32);
+<a href=#474 id=474 data-nosnippet>474</a> <span
class="kw">if </span>(v_64 - v).abs() > f32::EPSILON <span class="kw">as
</span>f64 {
+<a href=#475 id=475 data-nosnippet>475</a>
<span class="comment">// there is a precision loss
+<a href=#476 id=476 data-nosnippet>476</a>
</span><span class="kw">return </span><span
class="prelude-val">Err</span>(invalid_err(<span
class="string">"double"</span>));
+<a href=#477 id=477 data-nosnippet>477</a> }
+<a href=#478 id=478 data-nosnippet>478</a> }
+<a href=#479 id=479 data-nosnippet>479</a> <span
class="prelude-val">Ok</span>(<span
class="prelude-val">Some</span>(Literal::float(v_32)))
+<a href=#480 id=480 data-nosnippet>480</a> }
+<a href=#481 id=481 data-nosnippet>481</a>
Type::Primitive(PrimitiveType::Double) => <span
class="prelude-val">Ok</span>(<span
class="prelude-val">Some</span>(Literal::double(v))),
+<a href=#482 id=482 data-nosnippet>482</a> <span
class="kw">_ </span>=> <span
class="prelude-val">Err</span>(invalid_err(<span
class="string">"double"</span>)),
+<a href=#483 id=483 data-nosnippet>483</a> },
+<a href=#484 id=484 data-nosnippet>484</a>
RawLiteralEnum::String(v) => <span class="kw">match </span>ty {
+<a href=#485 id=485 data-nosnippet>485</a>
Type::Primitive(PrimitiveType::String) => <span
class="prelude-val">Ok</span>(<span
class="prelude-val">Some</span>(Literal::string(v))),
+<a href=#486 id=486 data-nosnippet>486</a> <span
class="kw">_ </span>=> <span
class="prelude-val">Err</span>(invalid_err(<span
class="string">"string"</span>)),
+<a href=#487 id=487 data-nosnippet>487</a> },
+<a href=#488 id=488 data-nosnippet>488</a>
RawLiteralEnum::Bytes(v) => <span class="kw">match </span>ty {
+<a href=#489 id=489 data-nosnippet>489</a>
Type::Primitive(PrimitiveType::Binary) => <span
class="prelude-val">Ok</span>(<span
class="prelude-val">Some</span>(Literal::binary(v.to_vec()))),
+<a href=#490 id=490 data-nosnippet>490</a>
Type::Primitive(PrimitiveType::Fixed(expected_len)) => {
+<a href=#491 id=491 data-nosnippet>491</a> <span
class="kw">if </span>v.len() == <span class="kw-2">*</span>expected_len <span
class="kw">as </span>usize {
+<a href=#492 id=492 data-nosnippet>492</a> <span
class="prelude-val">Ok</span>(<span
class="prelude-val">Some</span>(Literal::fixed(v.to_vec())))
+<a href=#493 id=493 data-nosnippet>493</a> } <span
class="kw">else </span>{
+<a href=#494 id=494 data-nosnippet>494</a> <span
class="prelude-val">Err</span>(invalid_err_with_reason(
+<a href=#495 id=495 data-nosnippet>495</a>
<span class="string">"bytes"</span>,
+<a href=#496 id=496 data-nosnippet>496</a>
<span class="kw-2">&</span><span class="macro">format!</span>(
+<a href=#497 id=497 data-nosnippet>497</a>
<span class="string">"Fixed type must be exactly {} bytes, got {}"</span>,
+<a href=#498 id=498 data-nosnippet>498</a>
expected_len,
+<a href=#499 id=499 data-nosnippet>499</a>
v.len()
+<a href=#500 id=500 data-nosnippet>500</a> ),
+<a href=#501 id=501 data-nosnippet>501</a> ))
+<a href=#502 id=502 data-nosnippet>502</a> }
+<a href=#503 id=503 data-nosnippet>503</a> }
+<a href=#504 id=504 data-nosnippet>504</a>
Type::Primitive(PrimitiveType::Uuid) => {
+<a href=#505 id=505 data-nosnippet>505</a> <span
class="kw">if </span>v.len() == <span class="number">16 </span>{
+<a href=#506 id=506 data-nosnippet>506</a> <span
class="kw">let </span>bytes: [u8; <span class="number">16</span>] =
v.as_slice().try_into().map_err(|<span class="kw">_</span>| {
+<a href=#507 id=507 data-nosnippet>507</a>
invalid_err_with_reason(<span class="string">"bytes"</span>, <span
class="string">"UUID must be exactly 16 bytes"</span>)
+<a href=#508 id=508 data-nosnippet>508</a> })<span
class="question-mark">?</span>;
+<a href=#509 id=509 data-nosnippet>509</a> <span
class="prelude-val">Ok</span>(<span
class="prelude-val">Some</span>(Literal::uuid(uuid::Uuid::from_bytes(bytes))))
+<a href=#510 id=510 data-nosnippet>510</a> } <span
class="kw">else </span>{
+<a href=#511 id=511 data-nosnippet>511</a> <span
class="prelude-val">Err</span>(invalid_err_with_reason(
+<a href=#512 id=512 data-nosnippet>512</a>
<span class="string">"bytes"</span>,
+<a href=#513 id=513 data-nosnippet>513</a>
<span class="string">"UUID must be exactly 16 bytes"</span>,
+<a href=#514 id=514 data-nosnippet>514</a> ))
+<a href=#515 id=515 data-nosnippet>515</a> }
+<a href=#516 id=516 data-nosnippet>516</a> }
+<a href=#517 id=517 data-nosnippet>517</a>
Type::Primitive(PrimitiveType::Decimal { precision, .. }) => {
+<a href=#518 id=518 data-nosnippet>518</a> <span
class="kw">let </span>required_bytes = Type::decimal_required_bytes(<span
class="kw-2">*</span>precision)<span class="question-mark">? </span><span
class="kw">as </span>usize;
+<a href=#519 id=519 data-nosnippet>519</a>
+<a href=#520 id=520 data-nosnippet>520</a> <span
class="kw">if </span>v.len() == required_bytes {
+<a href=#521 id=521 data-nosnippet>521</a> <span
class="comment">// Pad the bytes to 16 bytes (i128 size) with sign extension
+<a href=#522 id=522 data-nosnippet>522</a>
</span><span class="kw">let </span><span class="kw-2">mut </span>padded_bytes =
[<span class="number">0u8</span>; <span class="number">16</span>];
+<a href=#523 id=523 data-nosnippet>523</a> <span
class="kw">let </span>start_idx = <span class="number">16 </span>- v.len();
<a href=#524 id=524 data-nosnippet>524</a>
-<a href=#525 id=525 data-nosnippet>525</a> <span
class="comment">// Sign extend if the number is negative (MSB is 1)
-<a href=#526 id=526 data-nosnippet>526</a>
</span><span class="kw">if </span>!v.is_empty() && (v[<span
class="number">0</span>] & <span class="number">0x80</span>) != <span
class="number">0 </span>{
-<a href=#527 id=527 data-nosnippet>527</a>
<span class="comment">// Fill the padding with 0xFF for negative numbers
-<a href=#528 id=528 data-nosnippet>528</a>
</span><span class="kw">for </span>byte <span class="kw">in </span><span
class="kw-2">&mut </span>padded_bytes[..start_idx] {
-<a href=#529 id=529 data-nosnippet>529</a>
<span class="kw-2">*</span>byte = <span class="number">0xFF</span>;
-<a href=#530 id=530 data-nosnippet>530</a> }
-<a href=#531 id=531 data-nosnippet>531</a> }
-<a href=#532 id=532 data-nosnippet>532</a>
-<a href=#533 id=533 data-nosnippet>533</a> <span
class="prelude-val">Ok</span>(<span
class="prelude-val">Some</span>(Literal::Primitive(PrimitiveLiteral::Int128(
-<a href=#534 id=534 data-nosnippet>534</a>
i128::from_be_bytes(padded_bytes),
-<a href=#535 id=535 data-nosnippet>535</a> ))))
-<a href=#536 id=536 data-nosnippet>536</a> } <span
class="kw">else </span>{
-<a href=#537 id=537 data-nosnippet>537</a> <span
class="prelude-val">Err</span>(invalid_err_with_reason(
-<a href=#538 id=538 data-nosnippet>538</a>
<span class="string">"bytes"</span>,
-<a href=#539 id=539 data-nosnippet>539</a>
<span class="kw-2">&</span><span class="macro">format!</span>(
-<a href=#540 id=540 data-nosnippet>540</a>
<span class="string">"Decimal with precision {} must be exactly {} bytes, got
{}"</span>,
-<a href=#541 id=541 data-nosnippet>541</a>
precision,
-<a href=#542 id=542 data-nosnippet>542</a>
required_bytes,
-<a href=#543 id=543 data-nosnippet>543</a>
v.len()
-<a href=#544 id=544 data-nosnippet>544</a> ),
-<a href=#545 id=545 data-nosnippet>545</a> ))
-<a href=#546 id=546 data-nosnippet>546</a> }
-<a href=#547 id=547 data-nosnippet>547</a> }
-<a href=#548 id=548 data-nosnippet>548</a> <span
class="kw">_ </span>=> <span
class="prelude-val">Err</span>(invalid_err(<span
class="string">"bytes"</span>)),
-<a href=#549 id=549 data-nosnippet>549</a> },
-<a href=#550 id=550 data-nosnippet>550</a>
RawLiteralEnum::List(v) => <span class="kw">match </span>ty {
-<a href=#551 id=551 data-nosnippet>551</a> Type::List(ty)
=> <span class="prelude-val">Ok</span>(<span
class="prelude-val">Some</span>(Literal::List(
-<a href=#552 id=552 data-nosnippet>552</a> v.list
-<a href=#553 id=553 data-nosnippet>553</a>
.into_iter()
-<a href=#554 id=554 data-nosnippet>554</a> .map(|v|
{
-<a href=#555 id=555 data-nosnippet>555</a>
<span class="kw">if let </span><span class="prelude-val">Some</span>(v) = v {
-<a href=#556 id=556 data-nosnippet>556</a>
v.try_into(<span class="kw-2">&</span>ty.element_field.field_type)
-<a href=#557 id=557 data-nosnippet>557</a> }
<span class="kw">else </span>{
-<a href=#558 id=558 data-nosnippet>558</a>
<span class="prelude-val">Ok</span>(<span class="prelude-val">None</span>)
-<a href=#559 id=559 data-nosnippet>559</a> }
-<a href=#560 id=560 data-nosnippet>560</a> })
-<a href=#561 id=561 data-nosnippet>561</a>
.collect::<<span class="prelude-ty">Result</span><<span
class="kw">_</span>, Error>>()<span class="question-mark">?</span>,
-<a href=#562 id=562 data-nosnippet>562</a> ))),
-<a href=#563 id=563 data-nosnippet>563</a>
Type::Map(map_ty) => {
-<a href=#564 id=564 data-nosnippet>564</a> <span
class="kw">let </span>key_ty = map_ty.key_field.field_type.as_ref();
-<a href=#565 id=565 data-nosnippet>565</a> <span
class="kw">let </span>value_ty = map_ty.value_field.field_type.as_ref();
-<a href=#566 id=566 data-nosnippet>566</a> <span
class="kw">let </span><span class="kw-2">mut </span>map = Map::new();
-<a href=#567 id=567 data-nosnippet>567</a> <span
class="kw">for </span>k_v <span class="kw">in </span>v.list {
-<a href=#568 id=568 data-nosnippet>568</a> <span
class="kw">let </span>k_v = k_v.ok_or_else(|| invalid_err_with_reason(<span
class="string">"list"</span>,<span class="string">"In deserialize, None will be
represented as Some(RawLiteral::Null), all element in list must be
valid"</span>))<span class="question-mark">?</span>;
-<a href=#569 id=569 data-nosnippet>569</a> <span
class="kw">if let </span>RawLiteralEnum::Record(Record {
-<a href=#570 id=570 data-nosnippet>570</a>
required,
-<a href=#571 id=571 data-nosnippet>571</a>
optional: <span class="kw">_</span>,
-<a href=#572 id=572 data-nosnippet>572</a> }) = k_v
-<a href=#573 id=573 data-nosnippet>573</a> {
-<a href=#574 id=574 data-nosnippet>574</a>
<span class="kw">if </span>required.len() != <span class="number">2 </span>{
-<a href=#575 id=575 data-nosnippet>575</a>
<span class="kw">return </span><span
class="prelude-val">Err</span>(invalid_err_with_reason(
-<a href=#576 id=576 data-nosnippet>576</a>
<span class="string">"list"</span>,
-<a href=#577 id=577 data-nosnippet>577</a>
<span class="string">"Record must contains two element(key and value) of
array"</span>,
-<a href=#578 id=578 data-nosnippet>578</a>
));
-<a href=#579 id=579 data-nosnippet>579</a> }
-<a href=#580 id=580 data-nosnippet>580</a>
<span class="kw">let </span><span class="kw-2">mut </span>key = <span
class="prelude-val">None</span>;
-<a href=#581 id=581 data-nosnippet>581</a>
<span class="kw">let </span><span class="kw-2">mut </span>value = <span
class="prelude-val">None</span>;
-<a href=#582 id=582 data-nosnippet>582</a>
required.into_iter().for_each(|(k, v)| {
-<a href=#583 id=583 data-nosnippet>583</a>
<span class="kw">if </span>k == MAP_KEY_FIELD_NAME {
-<a href=#584 id=584 data-nosnippet>584</a>
key = <span class="prelude-val">Some</span>(v);
-<a href=#585 id=585 data-nosnippet>585</a>
} <span class="kw">else if </span>k == MAP_VALUE_FIELD_NAME {
-<a href=#586 id=586 data-nosnippet>586</a>
value = <span class="prelude-val">Some</span>(v);
-<a href=#587 id=587 data-nosnippet>587</a> }
-<a href=#588 id=588 data-nosnippet>588</a> });
-<a href=#589 id=589 data-nosnippet>589</a>
<span class="kw">match </span>(key, value) {
-<a href=#590 id=590 data-nosnippet>590</a>
(<span class="prelude-val">Some</span>(k), <span
class="prelude-val">Some</span>(v)) => {
-<a href=#591 id=591 data-nosnippet>591</a>
<span class="kw">let </span>key = k.try_into(key_ty)<span
class="question-mark">?</span>.ok_or_else(|| {
-<a href=#592 id=592 data-nosnippet>592</a>
invalid_err_with_reason(
-<a href=#593 id=593 data-nosnippet>593</a>
<span class="string">"list"</span>,
-<a href=#594 id=594 data-nosnippet>594</a>
<span class="string">"Key element in Map must be valid"</span>,
-<a href=#595 id=595 data-nosnippet>595</a>
)
-<a href=#596 id=596 data-nosnippet>596</a>
})<span class="question-mark">?</span>;
-<a href=#597 id=597 data-nosnippet>597</a>
<span class="kw">let </span>value = v.try_into(value_ty)<span
class="question-mark">?</span>;
-<a href=#598 id=598 data-nosnippet>598</a>
<span class="kw">if </span>map_ty.value_field.required &&
value.is_none() {
-<a href=#599 id=599 data-nosnippet>599</a>
<span class="kw">return </span><span
class="prelude-val">Err</span>(invalid_err_with_reason(
-<a href=#600 id=600 data-nosnippet>600</a>
<span class="string">"list"</span>,
-<a href=#601 id=601 data-nosnippet>601</a>
<span class="string">"Value element is required in this Map"</span>,
-<a href=#602 id=602 data-nosnippet>602</a>
));
-<a href=#603 id=603 data-nosnippet>603</a>
}
-<a href=#604 id=604 data-nosnippet>604</a>
map.insert(key, value);
-<a href=#605 id=605 data-nosnippet>605</a> }
-<a href=#606 id=606 data-nosnippet>606</a>
<span class="kw">_ </span>=> {
-<a href=#607 id=607 data-nosnippet>607</a>
<span class="kw">return </span><span
class="prelude-val">Err</span>(invalid_err_with_reason(
-<a href=#608 id=608 data-nosnippet>608</a>
<span class="string">"list"</span>,
-<a href=#609 id=609 data-nosnippet>609</a>
<span class="string">"The elements of record in list are not key and
value"</span>,
-<a href=#610 id=610 data-nosnippet>610</a>
));
-<a href=#611 id=611 data-nosnippet>611</a> }
-<a href=#612 id=612 data-nosnippet>612</a> }
-<a href=#613 id=613 data-nosnippet>613</a> } <span
class="kw">else </span>{
-<a href=#614 id=614 data-nosnippet>614</a>
<span class="kw">return </span><span
class="prelude-val">Err</span>(invalid_err_with_reason(
-<a href=#615 id=615 data-nosnippet>615</a>
<span class="string">"list"</span>,
-<a href=#616 id=616 data-nosnippet>616</a>
<span class="string">"Map should represented as record array."</span>,
-<a href=#617 id=617 data-nosnippet>617</a> ));
-<a href=#618 id=618 data-nosnippet>618</a> }
-<a href=#619 id=619 data-nosnippet>619</a> }
-<a href=#620 id=620 data-nosnippet>620</a> <span
class="prelude-val">Ok</span>(<span
class="prelude-val">Some</span>(Literal::Map(map)))
-<a href=#621 id=621 data-nosnippet>621</a> }
-<a href=#622 id=622 data-nosnippet>622</a>
Type::Primitive(PrimitiveType::Uuid) => {
-<a href=#623 id=623 data-nosnippet>623</a> <span
class="kw">if </span>v.list.len() != <span class="number">16 </span>{
-<a href=#624 id=624 data-nosnippet>624</a> <span
class="kw">return </span><span
class="prelude-val">Err</span>(invalid_err_with_reason(
-<a href=#625 id=625 data-nosnippet>625</a>
<span class="string">"list"</span>,
-<a href=#626 id=626 data-nosnippet>626</a>
<span class="string">"The length of list should be 16"</span>,
-<a href=#627 id=627 data-nosnippet>627</a> ));
-<a href=#628 id=628 data-nosnippet>628</a> }
-<a href=#629 id=629 data-nosnippet>629</a> <span
class="kw">let </span><span class="kw-2">mut </span>bytes = [<span
class="number">0u8</span>; <span class="number">16</span>];
-<a href=#630 id=630 data-nosnippet>630</a> <span
class="kw">for </span>(i, v) <span class="kw">in
</span>v.list.iter().enumerate() {
-<a href=#631 id=631 data-nosnippet>631</a> <span
class="kw">if let </span><span
class="prelude-val">Some</span>(RawLiteralEnum::Long(v)) = v {
-<a href=#632 id=632 data-nosnippet>632</a>
bytes[i] = <span class="kw-2">*</span>v <span class="kw">as </span>u8;
-<a href=#633 id=633 data-nosnippet>633</a> } <span
class="kw">else </span>{
-<a href=#634 id=634 data-nosnippet>634</a>
<span class="kw">return </span><span
class="prelude-val">Err</span>(invalid_err_with_reason(
-<a href=#635 id=635 data-nosnippet>635</a>
<span class="string">"list"</span>,
-<a href=#636 id=636 data-nosnippet>636</a>
<span class="string">"The element of list should be int"</span>,
-<a href=#637 id=637 data-nosnippet>637</a> ));
-<a href=#638 id=638 data-nosnippet>638</a> }
-<a href=#639 id=639 data-nosnippet>639</a> }
-<a href=#640 id=640 data-nosnippet>640</a> <span
class="prelude-val">Ok</span>(<span
class="prelude-val">Some</span>(Literal::uuid(uuid::Uuid::from_bytes(bytes))))
-<a href=#641 id=641 data-nosnippet>641</a> }
-<a href=#642 id=642 data-nosnippet>642</a>
Type::Primitive(PrimitiveType::Decimal {
-<a href=#643 id=643 data-nosnippet>643</a> precision:
<span class="kw">_</span>,
-<a href=#644 id=644 data-nosnippet>644</a> scale: <span
class="kw">_</span>,
-<a href=#645 id=645 data-nosnippet>645</a> }) => {
-<a href=#646 id=646 data-nosnippet>646</a> <span
class="kw">if </span>v.list.len() != <span class="number">16 </span>{
-<a href=#647 id=647 data-nosnippet>647</a> <span
class="kw">return </span><span
class="prelude-val">Err</span>(invalid_err_with_reason(
-<a href=#648 id=648 data-nosnippet>648</a>
<span class="string">"list"</span>,
-<a href=#649 id=649 data-nosnippet>649</a>
<span class="string">"The length of list should be 16"</span>,
-<a href=#650 id=650 data-nosnippet>650</a> ));
-<a href=#651 id=651 data-nosnippet>651</a> }
-<a href=#652 id=652 data-nosnippet>652</a> <span
class="kw">let </span><span class="kw-2">mut </span>bytes = [<span
class="number">0u8</span>; <span class="number">16</span>];
-<a href=#653 id=653 data-nosnippet>653</a> <span
class="kw">for </span>(i, v) <span class="kw">in
</span>v.list.iter().enumerate() {
-<a href=#654 id=654 data-nosnippet>654</a> <span
class="kw">if let </span><span
class="prelude-val">Some</span>(RawLiteralEnum::Long(v)) = v {
-<a href=#655 id=655 data-nosnippet>655</a>
bytes[i] = <span class="kw-2">*</span>v <span class="kw">as </span>u8;
-<a href=#656 id=656 data-nosnippet>656</a> } <span
class="kw">else </span>{
-<a href=#657 id=657 data-nosnippet>657</a>
<span class="kw">return </span><span
class="prelude-val">Err</span>(invalid_err_with_reason(
-<a href=#658 id=658 data-nosnippet>658</a>
<span class="string">"list"</span>,
-<a href=#659 id=659 data-nosnippet>659</a>
<span class="string">"The element of list should be int"</span>,
-<a href=#660 id=660 data-nosnippet>660</a> ));
-<a href=#661 id=661 data-nosnippet>661</a> }
-<a href=#662 id=662 data-nosnippet>662</a> }
-<a href=#663 id=663 data-nosnippet>663</a> <span
class="prelude-val">Ok</span>(<span
class="prelude-val">Some</span>(Literal::decimal(i128::from_be_bytes(bytes))))
-<a href=#664 id=664 data-nosnippet>664</a> }
-<a href=#665 id=665 data-nosnippet>665</a>
Type::Primitive(PrimitiveType::Binary) => {
-<a href=#666 id=666 data-nosnippet>666</a> <span
class="kw">let </span>bytes = v
-<a href=#667 id=667 data-nosnippet>667</a> .list
-<a href=#668 id=668 data-nosnippet>668</a>
.into_iter()
-<a href=#669 id=669 data-nosnippet>669</a> .map(|v|
{
-<a href=#670 id=670 data-nosnippet>670</a>
<span class="kw">if let </span><span
class="prelude-val">Some</span>(RawLiteralEnum::Long(v)) = v {
-<a href=#671 id=671 data-nosnippet>671</a>
<span class="prelude-val">Ok</span>(v <span class="kw">as </span>u8)
-<a href=#672 id=672 data-nosnippet>672</a> }
<span class="kw">else </span>{
-<a href=#673 id=673 data-nosnippet>673</a>
<span class="prelude-val">Err</span>(invalid_err_with_reason(
-<a href=#674 id=674 data-nosnippet>674</a>
<span class="string">"list"</span>,
-<a href=#675 id=675 data-nosnippet>675</a>
<span class="string">"The element of list should be int"</span>,
-<a href=#676 id=676 data-nosnippet>676</a>
))
-<a href=#677 id=677 data-nosnippet>677</a> }
-<a href=#678 id=678 data-nosnippet>678</a> })
-<a href=#679 id=679 data-nosnippet>679</a>
.collect::<<span class="prelude-ty">Result</span><Vec<<span
class="kw">_</span>>, Error>>()<span class="question-mark">?</span>;
-<a href=#680 id=680 data-nosnippet>680</a> <span
class="prelude-val">Ok</span>(<span
class="prelude-val">Some</span>(Literal::binary(bytes)))
-<a href=#681 id=681 data-nosnippet>681</a> }
-<a href=#682 id=682 data-nosnippet>682</a>
Type::Primitive(PrimitiveType::Fixed(size)) => {
-<a href=#683 id=683 data-nosnippet>683</a> <span
class="kw">if </span>v.list.len() != <span class="kw-2">*</span>size <span
class="kw">as </span>usize {
-<a href=#684 id=684 data-nosnippet>684</a> <span
class="kw">return </span><span
class="prelude-val">Err</span>(invalid_err_with_reason(
-<a href=#685 id=685 data-nosnippet>685</a>
<span class="string">"list"</span>,
-<a href=#686 id=686 data-nosnippet>686</a>
<span class="string">"The length of list should be equal to size"</span>,
-<a href=#687 id=687 data-nosnippet>687</a> ));
-<a href=#688 id=688 data-nosnippet>688</a> }
-<a href=#689 id=689 data-nosnippet>689</a> <span
class="kw">let </span>bytes = v
-<a href=#690 id=690 data-nosnippet>690</a> .list
-<a href=#691 id=691 data-nosnippet>691</a>
.into_iter()
-<a href=#692 id=692 data-nosnippet>692</a> .map(|v|
{
-<a href=#693 id=693 data-nosnippet>693</a>
<span class="kw">if let </span><span
class="prelude-val">Some</span>(RawLiteralEnum::Long(v)) = v {
-<a href=#694 id=694 data-nosnippet>694</a>
<span class="prelude-val">Ok</span>(v <span class="kw">as </span>u8)
-<a href=#695 id=695 data-nosnippet>695</a> }
<span class="kw">else </span>{
-<a href=#696 id=696 data-nosnippet>696</a>
<span class="prelude-val">Err</span>(invalid_err_with_reason(
-<a href=#697 id=697 data-nosnippet>697</a>
<span class="string">"list"</span>,
-<a href=#698 id=698 data-nosnippet>698</a>
<span class="string">"The element of list should be int"</span>,
-<a href=#699 id=699 data-nosnippet>699</a>
))
-<a href=#700 id=700 data-nosnippet>700</a> }
-<a href=#701 id=701 data-nosnippet>701</a> })
-<a href=#702 id=702 data-nosnippet>702</a>
.collect::<<span class="prelude-ty">Result</span><Vec<<span
class="kw">_</span>>, Error>>()<span class="question-mark">?</span>;
-<a href=#703 id=703 data-nosnippet>703</a> <span
class="prelude-val">Ok</span>(<span
class="prelude-val">Some</span>(Literal::fixed(bytes)))
-<a href=#704 id=704 data-nosnippet>704</a> }
-<a href=#705 id=705 data-nosnippet>705</a> <span
class="kw">_ </span>=> <span
class="prelude-val">Err</span>(invalid_err(<span class="string">"list"</span>)),
-<a href=#706 id=706 data-nosnippet>706</a> },
-<a href=#707 id=707 data-nosnippet>707</a>
RawLiteralEnum::Record(Record {
-<a href=#708 id=708 data-nosnippet>708</a> required,
-<a href=#709 id=709 data-nosnippet>709</a> optional: <span
class="kw">_</span>,
-<a href=#710 id=710 data-nosnippet>710</a> }) => <span
class="kw">match </span>ty {
-<a href=#711 id=711 data-nosnippet>711</a>
Type::Struct(struct_ty) => {
-<a href=#712 id=712 data-nosnippet>712</a> <span
class="kw">let </span>iters: Vec<<span
class="prelude-ty">Option</span><Literal>> = required
-<a href=#713 id=713 data-nosnippet>713</a>
.into_iter()
-<a href=#714 id=714 data-nosnippet>714</a>
.map(|(field_name, value)| {
-<a href=#715 id=715 data-nosnippet>715</a>
<span class="kw">let </span>field = struct_ty
-<a href=#716 id=716 data-nosnippet>716</a>
.field_by_name(field_name.as_str())
-<a href=#717 id=717 data-nosnippet>717</a>
.ok_or_else(|| {
-<a href=#718 id=718 data-nosnippet>718</a>
invalid_err_with_reason(
-<a href=#719 id=719 data-nosnippet>719</a>
<span class="string">"record"</span>,
-<a href=#720 id=720 data-nosnippet>720</a>
<span class="kw-2">&</span><span class="macro">format!</span>(<span
class="string">"field {} is not exist"</span>, field_name),
-<a href=#721 id=721 data-nosnippet>721</a>
)
-<a href=#722 id=722 data-nosnippet>722</a>
})<span class="question-mark">?</span>;
-<a href=#723 id=723 data-nosnippet>723</a>
<span class="kw">let </span>value = value.try_into(<span
class="kw-2">&</span>field.field_type)<span class="question-mark">?</span>;
-<a href=#724 id=724 data-nosnippet>724</a>
<span class="prelude-val">Ok</span>(value)
-<a href=#725 id=725 data-nosnippet>725</a> })
-<a href=#726 id=726 data-nosnippet>726</a>
.collect::<<span class="prelude-ty">Result</span><<span
class="kw">_</span>, Error>>()<span class="question-mark">?</span>;
-<a href=#727 id=727 data-nosnippet>727</a> <span
class="prelude-val">Ok</span>(<span
class="prelude-val">Some</span>(Literal::Struct(Struct::from_iter(iters))))
-<a href=#728 id=728 data-nosnippet>728</a> }
-<a href=#729 id=729 data-nosnippet>729</a>
Type::Map(map_ty) => {
-<a href=#730 id=730 data-nosnippet>730</a> <span
class="kw">if </span><span class="kw-2">*</span>map_ty.key_field.field_type !=
Type::Primitive(PrimitiveType::String) {
-<a href=#731 id=731 data-nosnippet>731</a> <span
class="kw">return </span><span
class="prelude-val">Err</span>(invalid_err_with_reason(
-<a href=#732 id=732 data-nosnippet>732</a>
<span class="string">"record"</span>,
-<a href=#733 id=733 data-nosnippet>733</a>
<span class="string">"Map key must be string"</span>,
-<a href=#734 id=734 data-nosnippet>734</a> ));
-<a href=#735 id=735 data-nosnippet>735</a> }
-<a href=#736 id=736 data-nosnippet>736</a> <span
class="kw">let </span><span class="kw-2">mut </span>map = Map::new();
-<a href=#737 id=737 data-nosnippet>737</a> <span
class="kw">for </span>(k, v) <span class="kw">in </span>required {
-<a href=#738 id=738 data-nosnippet>738</a> <span
class="kw">let </span>value = v.try_into(<span
class="kw-2">&</span>map_ty.value_field.field_type)<span
class="question-mark">?</span>;
-<a href=#739 id=739 data-nosnippet>739</a> <span
class="kw">if </span>map_ty.value_field.required && value.is_none() {
-<a href=#740 id=740 data-nosnippet>740</a>
<span class="kw">return </span><span
class="prelude-val">Err</span>(invalid_err_with_reason(
-<a href=#741 id=741 data-nosnippet>741</a>
<span class="string">"record"</span>,
-<a href=#742 id=742 data-nosnippet>742</a>
<span class="string">"Value element is required in this Map"</span>,
-<a href=#743 id=743 data-nosnippet>743</a> ));
-<a href=#744 id=744 data-nosnippet>744</a> }
-<a href=#745 id=745 data-nosnippet>745</a>
map.insert(Literal::string(k), value);
-<a href=#746 id=746 data-nosnippet>746</a> }
-<a href=#747 id=747 data-nosnippet>747</a> <span
class="prelude-val">Ok</span>(<span
class="prelude-val">Some</span>(Literal::Map(map)))
-<a href=#748 id=748 data-nosnippet>748</a> }
-<a href=#749 id=749 data-nosnippet>749</a> <span
class="kw">_ </span>=> <span
class="prelude-val">Err</span>(invalid_err(<span
class="string">"record"</span>)),
-<a href=#750 id=750 data-nosnippet>750</a> },
-<a href=#751 id=751 data-nosnippet>751</a>
RawLiteralEnum::StringMap(<span class="kw">_</span>) => <span
class="prelude-val">Err</span>(invalid_err(<span class="string">"string
map"</span>)),
-<a href=#752 id=752 data-nosnippet>752</a> }
-<a href=#753 id=753 data-nosnippet>753</a> }
-<a href=#754 id=754 data-nosnippet>754</a> }
-<a href=#755 id=755 data-nosnippet>755</a>}
+<a href=#525 id=525 data-nosnippet>525</a> <span
class="comment">// Copy the input bytes to the end of the array
+<a href=#526 id=526 data-nosnippet>526</a>
</span>padded_bytes[start_idx..].copy_from_slice(<span
class="kw-2">&</span>v);
+<a href=#527 id=527 data-nosnippet>527</a>
+<a href=#528 id=528 data-nosnippet>528</a> <span
class="comment">// Sign extend if the number is negative (MSB is 1)
+<a href=#529 id=529 data-nosnippet>529</a>
</span><span class="kw">if </span>!v.is_empty() && (v[<span
class="number">0</span>] & <span class="number">0x80</span>) != <span
class="number">0 </span>{
+<a href=#530 id=530 data-nosnippet>530</a>
<span class="comment">// Fill the padding with 0xFF for negative numbers
+<a href=#531 id=531 data-nosnippet>531</a>
</span><span class="kw">for </span>byte <span class="kw">in </span><span
class="kw-2">&mut </span>padded_bytes[..start_idx] {
+<a href=#532 id=532 data-nosnippet>532</a>
<span class="kw-2">*</span>byte = <span class="number">0xFF</span>;
+<a href=#533 id=533 data-nosnippet>533</a> }
+<a href=#534 id=534 data-nosnippet>534</a> }
+<a href=#535 id=535 data-nosnippet>535</a>
+<a href=#536 id=536 data-nosnippet>536</a> <span
class="prelude-val">Ok</span>(<span
class="prelude-val">Some</span>(Literal::Primitive(PrimitiveLiteral::Int128(
+<a href=#537 id=537 data-nosnippet>537</a>
i128::from_be_bytes(padded_bytes),
+<a href=#538 id=538 data-nosnippet>538</a> ))))
+<a href=#539 id=539 data-nosnippet>539</a> } <span
class="kw">else </span>{
+<a href=#540 id=540 data-nosnippet>540</a> <span
class="prelude-val">Err</span>(invalid_err_with_reason(
+<a href=#541 id=541 data-nosnippet>541</a>
<span class="string">"bytes"</span>,
+<a href=#542 id=542 data-nosnippet>542</a>
<span class="kw-2">&</span><span class="macro">format!</span>(
+<a href=#543 id=543 data-nosnippet>543</a>
<span class="string">"Decimal with precision {} must be exactly {} bytes, got
{}"</span>,
+<a href=#544 id=544 data-nosnippet>544</a>
precision,
+<a href=#545 id=545 data-nosnippet>545</a>
required_bytes,
+<a href=#546 id=546 data-nosnippet>546</a>
v.len()
+<a href=#547 id=547 data-nosnippet>547</a> ),
+<a href=#548 id=548 data-nosnippet>548</a> ))
+<a href=#549 id=549 data-nosnippet>549</a> }
+<a href=#550 id=550 data-nosnippet>550</a> }
+<a href=#551 id=551 data-nosnippet>551</a> <span
class="kw">_ </span>=> <span
class="prelude-val">Err</span>(invalid_err(<span
class="string">"bytes"</span>)),
+<a href=#552 id=552 data-nosnippet>552</a> },
+<a href=#553 id=553 data-nosnippet>553</a>
RawLiteralEnum::List(v) => <span class="kw">match </span>ty {
+<a href=#554 id=554 data-nosnippet>554</a> Type::List(ty)
=> <span class="prelude-val">Ok</span>(<span
class="prelude-val">Some</span>(Literal::List(
+<a href=#555 id=555 data-nosnippet>555</a> v.list
+<a href=#556 id=556 data-nosnippet>556</a>
.into_iter()
+<a href=#557 id=557 data-nosnippet>557</a> .map(|v|
{
+<a href=#558 id=558 data-nosnippet>558</a>
<span class="kw">if let </span><span class="prelude-val">Some</span>(v) = v {
+<a href=#559 id=559 data-nosnippet>559</a>
v.try_into(<span class="kw-2">&</span>ty.element_field.field_type)
+<a href=#560 id=560 data-nosnippet>560</a> }
<span class="kw">else </span>{
+<a href=#561 id=561 data-nosnippet>561</a>
<span class="prelude-val">Ok</span>(<span class="prelude-val">None</span>)
+<a href=#562 id=562 data-nosnippet>562</a> }
+<a href=#563 id=563 data-nosnippet>563</a> })
+<a href=#564 id=564 data-nosnippet>564</a>
.collect::<<span class="prelude-ty">Result</span><<span
class="kw">_</span>, Error>>()<span class="question-mark">?</span>,
+<a href=#565 id=565 data-nosnippet>565</a> ))),
+<a href=#566 id=566 data-nosnippet>566</a>
Type::Map(map_ty) => {
+<a href=#567 id=567 data-nosnippet>567</a> <span
class="kw">let </span>key_ty = map_ty.key_field.field_type.as_ref();
+<a href=#568 id=568 data-nosnippet>568</a> <span
class="kw">let </span>value_ty = map_ty.value_field.field_type.as_ref();
+<a href=#569 id=569 data-nosnippet>569</a> <span
class="kw">let </span><span class="kw-2">mut </span>map = Map::new();
+<a href=#570 id=570 data-nosnippet>570</a> <span
class="kw">for </span>k_v <span class="kw">in </span>v.list {
+<a href=#571 id=571 data-nosnippet>571</a> <span
class="kw">let </span>k_v = k_v.ok_or_else(|| invalid_err_with_reason(<span
class="string">"list"</span>,<span class="string">"In deserialize, None will be
represented as Some(RawLiteral::Null), all element in list must be
valid"</span>))<span class="question-mark">?</span>;
+<a href=#572 id=572 data-nosnippet>572</a> <span
class="kw">if let </span>RawLiteralEnum::Record(Record {
+<a href=#573 id=573 data-nosnippet>573</a>
required,
+<a href=#574 id=574 data-nosnippet>574</a>
optional: <span class="kw">_</span>,
+<a href=#575 id=575 data-nosnippet>575</a> }) = k_v
+<a href=#576 id=576 data-nosnippet>576</a> {
+<a href=#577 id=577 data-nosnippet>577</a>
<span class="kw">if </span>required.len() != <span class="number">2 </span>{
+<a href=#578 id=578 data-nosnippet>578</a>
<span class="kw">return </span><span
class="prelude-val">Err</span>(invalid_err_with_reason(
+<a href=#579 id=579 data-nosnippet>579</a>
<span class="string">"list"</span>,
+<a href=#580 id=580 data-nosnippet>580</a>
<span class="string">"Record must contains two element(key and value) of
array"</span>,
+<a href=#581 id=581 data-nosnippet>581</a>
));
+<a href=#582 id=582 data-nosnippet>582</a> }
+<a href=#583 id=583 data-nosnippet>583</a>
<span class="kw">let </span><span class="kw-2">mut </span>key = <span
class="prelude-val">None</span>;
+<a href=#584 id=584 data-nosnippet>584</a>
<span class="kw">let </span><span class="kw-2">mut </span>value = <span
class="prelude-val">None</span>;
+<a href=#585 id=585 data-nosnippet>585</a>
required.into_iter().for_each(|(k, v)| {
+<a href=#586 id=586 data-nosnippet>586</a>
<span class="kw">if </span>k == MAP_KEY_FIELD_NAME {
+<a href=#587 id=587 data-nosnippet>587</a>
key = <span class="prelude-val">Some</span>(v);
+<a href=#588 id=588 data-nosnippet>588</a>
} <span class="kw">else if </span>k == MAP_VALUE_FIELD_NAME {
+<a href=#589 id=589 data-nosnippet>589</a>
value = <span class="prelude-val">Some</span>(v);
+<a href=#590 id=590 data-nosnippet>590</a> }
+<a href=#591 id=591 data-nosnippet>591</a> });
+<a href=#592 id=592 data-nosnippet>592</a>
<span class="kw">match </span>(key, value) {
+<a href=#593 id=593 data-nosnippet>593</a>
(<span class="prelude-val">Some</span>(k), <span
class="prelude-val">Some</span>(v)) => {
+<a href=#594 id=594 data-nosnippet>594</a>
<span class="kw">let </span>key = k.try_into(key_ty)<span
class="question-mark">?</span>.ok_or_else(|| {
+<a href=#595 id=595 data-nosnippet>595</a>
invalid_err_with_reason(
+<a href=#596 id=596 data-nosnippet>596</a>
<span class="string">"list"</span>,
+<a href=#597 id=597 data-nosnippet>597</a>
<span class="string">"Key element in Map must be valid"</span>,
+<a href=#598 id=598 data-nosnippet>598</a>
)
+<a href=#599 id=599 data-nosnippet>599</a>
})<span class="question-mark">?</span>;
+<a href=#600 id=600 data-nosnippet>600</a>
<span class="kw">let </span>value = v.try_into(value_ty)<span
class="question-mark">?</span>;
+<a href=#601 id=601 data-nosnippet>601</a>
<span class="kw">if </span>map_ty.value_field.required &&
value.is_none() {
+<a href=#602 id=602 data-nosnippet>602</a>
<span class="kw">return </span><span
class="prelude-val">Err</span>(invalid_err_with_reason(
+<a href=#603 id=603 data-nosnippet>603</a>
<span class="string">"list"</span>,
+<a href=#604 id=604 data-nosnippet>604</a>
<span class="string">"Value element is required in this Map"</span>,
+<a href=#605 id=605 data-nosnippet>605</a>
));
+<a href=#606 id=606 data-nosnippet>606</a>
}
+<a href=#607 id=607 data-nosnippet>607</a>
map.insert(key, value);
+<a href=#608 id=608 data-nosnippet>608</a> }
+<a href=#609 id=609 data-nosnippet>609</a>
<span class="kw">_ </span>=> {
+<a href=#610 id=610 data-nosnippet>610</a>
<span class="kw">return </span><span
class="prelude-val">Err</span>(invalid_err_with_reason(
+<a href=#611 id=611 data-nosnippet>611</a>
<span class="string">"list"</span>,
+<a href=#612 id=612 data-nosnippet>612</a>
<span class="string">"The elements of record in list are not key and
value"</span>,
+<a href=#613 id=613 data-nosnippet>613</a>
));
+<a href=#614 id=614 data-nosnippet>614</a> }
+<a href=#615 id=615 data-nosnippet>615</a> }
+<a href=#616 id=616 data-nosnippet>616</a> } <span
class="kw">else </span>{
+<a href=#617 id=617 data-nosnippet>617</a>
<span class="kw">return </span><span
class="prelude-val">Err</span>(invalid_err_with_reason(
+<a href=#618 id=618 data-nosnippet>618</a>
<span class="string">"list"</span>,
+<a href=#619 id=619 data-nosnippet>619</a>
<span class="string">"Map should represented as record array."</span>,
+<a href=#620 id=620 data-nosnippet>620</a> ));
+<a href=#621 id=621 data-nosnippet>621</a> }
+<a href=#622 id=622 data-nosnippet>622</a> }
+<a href=#623 id=623 data-nosnippet>623</a> <span
class="prelude-val">Ok</span>(<span
class="prelude-val">Some</span>(Literal::Map(map)))
+<a href=#624 id=624 data-nosnippet>624</a> }
+<a href=#625 id=625 data-nosnippet>625</a>
Type::Primitive(PrimitiveType::Uuid) => {
+<a href=#626 id=626 data-nosnippet>626</a> <span
class="kw">if </span>v.list.len() != <span class="number">16 </span>{
+<a href=#627 id=627 data-nosnippet>627</a> <span
class="kw">return </span><span
class="prelude-val">Err</span>(invalid_err_with_reason(
+<a href=#628 id=628 data-nosnippet>628</a>
<span class="string">"list"</span>,
+<a href=#629 id=629 data-nosnippet>629</a>
<span class="string">"The length of list should be 16"</span>,
+<a href=#630 id=630 data-nosnippet>630</a> ));
+<a href=#631 id=631 data-nosnippet>631</a> }
+<a href=#632 id=632 data-nosnippet>632</a> <span
class="kw">let </span><span class="kw-2">mut </span>bytes = [<span
class="number">0u8</span>; <span class="number">16</span>];
+<a href=#633 id=633 data-nosnippet>633</a> <span
class="kw">for </span>(i, v) <span class="kw">in
</span>v.list.iter().enumerate() {
+<a href=#634 id=634 data-nosnippet>634</a> <span
class="kw">if let </span><span
class="prelude-val">Some</span>(RawLiteralEnum::Long(v)) = v {
+<a href=#635 id=635 data-nosnippet>635</a>
bytes[i] = <span class="kw-2">*</span>v <span class="kw">as </span>u8;
+<a href=#636 id=636 data-nosnippet>636</a> } <span
class="kw">else </span>{
+<a href=#637 id=637 data-nosnippet>637</a>
<span class="kw">return </span><span
class="prelude-val">Err</span>(invalid_err_with_reason(
+<a href=#638 id=638 data-nosnippet>638</a>
<span class="string">"list"</span>,
+<a href=#639 id=639 data-nosnippet>639</a>
<span class="string">"The element of list should be int"</span>,
+<a href=#640 id=640 data-nosnippet>640</a> ));
+<a href=#641 id=641 data-nosnippet>641</a> }
+<a href=#642 id=642 data-nosnippet>642</a> }
+<a href=#643 id=643 data-nosnippet>643</a> <span
class="prelude-val">Ok</span>(<span
class="prelude-val">Some</span>(Literal::uuid(uuid::Uuid::from_bytes(bytes))))
+<a href=#644 id=644 data-nosnippet>644</a> }
+<a href=#645 id=645 data-nosnippet>645</a>
Type::Primitive(PrimitiveType::Decimal {
+<a href=#646 id=646 data-nosnippet>646</a> precision:
<span class="kw">_</span>,
+<a href=#647 id=647 data-nosnippet>647</a> scale: <span
class="kw">_</span>,
+<a href=#648 id=648 data-nosnippet>648</a> }) => {
+<a href=#649 id=649 data-nosnippet>649</a> <span
class="kw">if </span>v.list.len() != <span class="number">16 </span>{
+<a href=#650 id=650 data-nosnippet>650</a> <span
class="kw">return </span><span
class="prelude-val">Err</span>(invalid_err_with_reason(
+<a href=#651 id=651 data-nosnippet>651</a>
<span class="string">"list"</span>,
+<a href=#652 id=652 data-nosnippet>652</a>
<span class="string">"The length of list should be 16"</span>,
+<a href=#653 id=653 data-nosnippet>653</a> ));
+<a href=#654 id=654 data-nosnippet>654</a> }
+<a href=#655 id=655 data-nosnippet>655</a> <span
class="kw">let </span><span class="kw-2">mut </span>bytes = [<span
class="number">0u8</span>; <span class="number">16</span>];
+<a href=#656 id=656 data-nosnippet>656</a> <span
class="kw">for </span>(i, v) <span class="kw">in
</span>v.list.iter().enumerate() {
+<a href=#657 id=657 data-nosnippet>657</a> <span
class="kw">if let </span><span
class="prelude-val">Some</span>(RawLiteralEnum::Long(v)) = v {
+<a href=#658 id=658 data-nosnippet>658</a>
bytes[i] = <span class="kw-2">*</span>v <span class="kw">as </span>u8;
+<a href=#659 id=659 data-nosnippet>659</a> } <span
class="kw">else </span>{
+<a href=#660 id=660 data-nosnippet>660</a>
<span class="kw">return </span><span
class="prelude-val">Err</span>(invalid_err_with_reason(
+<a href=#661 id=661 data-nosnippet>661</a>
<span class="string">"list"</span>,
+<a href=#662 id=662 data-nosnippet>662</a>
<span class="string">"The element of list should be int"</span>,
+<a href=#663 id=663 data-nosnippet>663</a> ));
+<a href=#664 id=664 data-nosnippet>664</a> }
+<a href=#665 id=665 data-nosnippet>665</a> }
+<a href=#666 id=666 data-nosnippet>666</a> <span
class="prelude-val">Ok</span>(<span
class="prelude-val">Some</span>(Literal::decimal(i128::from_be_bytes(bytes))))
+<a href=#667 id=667 data-nosnippet>667</a> }
+<a href=#668 id=668 data-nosnippet>668</a>
Type::Primitive(PrimitiveType::Binary) => {
+<a href=#669 id=669 data-nosnippet>669</a> <span
class="kw">let </span>bytes = v
+<a href=#670 id=670 data-nosnippet>670</a> .list
+<a href=#671 id=671 data-nosnippet>671</a>
.into_iter()
+<a href=#672 id=672 data-nosnippet>672</a> .map(|v|
{
+<a href=#673 id=673 data-nosnippet>673</a>
<span class="kw">if let </span><span
class="prelude-val">Some</span>(RawLiteralEnum::Long(v)) = v {
+<a href=#674 id=674 data-nosnippet>674</a>
<span class="prelude-val">Ok</span>(v <span class="kw">as </span>u8)
+<a href=#675 id=675 data-nosnippet>675</a> }
<span class="kw">else </span>{
+<a href=#676 id=676 data-nosnippet>676</a>
<span class="prelude-val">Err</span>(invalid_err_with_reason(
+<a href=#677 id=677 data-nosnippet>677</a>
<span class="string">"list"</span>,
+<a href=#678 id=678 data-nosnippet>678</a>
<span class="string">"The element of list should be int"</span>,
+<a href=#679 id=679 data-nosnippet>679</a>
))
+<a href=#680 id=680 data-nosnippet>680</a> }
+<a href=#681 id=681 data-nosnippet>681</a> })
+<a href=#682 id=682 data-nosnippet>682</a>
.collect::<<span class="prelude-ty">Result</span><Vec<<span
class="kw">_</span>>, Error>>()<span class="question-mark">?</span>;
+<a href=#683 id=683 data-nosnippet>683</a> <span
class="prelude-val">Ok</span>(<span
class="prelude-val">Some</span>(Literal::binary(bytes)))
+<a href=#684 id=684 data-nosnippet>684</a> }
+<a href=#685 id=685 data-nosnippet>685</a>
Type::Primitive(PrimitiveType::Fixed(size)) => {
+<a href=#686 id=686 data-nosnippet>686</a> <span
class="kw">if </span>v.list.len() != <span class="kw-2">*</span>size <span
class="kw">as </span>usize {
+<a href=#687 id=687 data-nosnippet>687</a> <span
class="kw">return </span><span
class="prelude-val">Err</span>(invalid_err_with_reason(
+<a href=#688 id=688 data-nosnippet>688</a>
<span class="string">"list"</span>,
+<a href=#689 id=689 data-nosnippet>689</a>
<span class="string">"The length of list should be equal to size"</span>,
+<a href=#690 id=690 data-nosnippet>690</a> ));
+<a href=#691 id=691 data-nosnippet>691</a> }
+<a href=#692 id=692 data-nosnippet>692</a> <span
class="kw">let </span>bytes = v
+<a href=#693 id=693 data-nosnippet>693</a> .list
+<a href=#694 id=694 data-nosnippet>694</a>
.into_iter()
+<a href=#695 id=695 data-nosnippet>695</a> .map(|v|
{
+<a href=#696 id=696 data-nosnippet>696</a>
<span class="kw">if let </span><span
class="prelude-val">Some</span>(RawLiteralEnum::Long(v)) = v {
+<a href=#697 id=697 data-nosnippet>697</a>
<span class="prelude-val">Ok</span>(v <span class="kw">as </span>u8)
+<a href=#698 id=698 data-nosnippet>698</a> }
<span class="kw">else </span>{
+<a href=#699 id=699 data-nosnippet>699</a>
<span class="prelude-val">Err</span>(invalid_err_with_reason(
+<a href=#700 id=700 data-nosnippet>700</a>
<span class="string">"list"</span>,
+<a href=#701 id=701 data-nosnippet>701</a>
<span class="string">"The element of list should be int"</span>,
+<a href=#702 id=702 data-nosnippet>702</a>
))
+<a href=#703 id=703 data-nosnippet>703</a> }
+<a href=#704 id=704 data-nosnippet>704</a> })
+<a href=#705 id=705 data-nosnippet>705</a>
.collect::<<span class="prelude-ty">Result</span><Vec<<span
class="kw">_</span>>, Error>>()<span class="question-mark">?</span>;
+<a href=#706 id=706 data-nosnippet>706</a> <span
class="prelude-val">Ok</span>(<span
class="prelude-val">Some</span>(Literal::fixed(bytes)))
+<a href=#707 id=707 data-nosnippet>707</a> }
+<a href=#708 id=708 data-nosnippet>708</a> <span
class="kw">_ </span>=> <span
class="prelude-val">Err</span>(invalid_err(<span class="string">"list"</span>)),
+<a href=#709 id=709 data-nosnippet>709</a> },
+<a href=#710 id=710 data-nosnippet>710</a>
RawLiteralEnum::Record(Record {
+<a href=#711 id=711 data-nosnippet>711</a> required,
+<a href=#712 id=712 data-nosnippet>712</a> optional: <span
class="kw">_</span>,
+<a href=#713 id=713 data-nosnippet>713</a> }) => <span
class="kw">match </span>ty {
+<a href=#714 id=714 data-nosnippet>714</a>
Type::Struct(struct_ty) => {
+<a href=#715 id=715 data-nosnippet>715</a> <span
class="kw">let </span>iters: Vec<<span
class="prelude-ty">Option</span><Literal>> = required
+<a href=#716 id=716 data-nosnippet>716</a>
.into_iter()
+<a href=#717 id=717 data-nosnippet>717</a>
.map(|(field_name, value)| {
+<a href=#718 id=718 data-nosnippet>718</a>
<span class="kw">let </span>field = struct_ty
+<a href=#719 id=719 data-nosnippet>719</a>
.field_by_name(field_name.as_str())
+<a href=#720 id=720 data-nosnippet>720</a>
.ok_or_else(|| {
+<a href=#721 id=721 data-nosnippet>721</a>
invalid_err_with_reason(
+<a href=#722 id=722 data-nosnippet>722</a>
<span class="string">"record"</span>,
+<a href=#723 id=723 data-nosnippet>723</a>
<span class="kw-2">&</span><span class="macro">format!</span>(<span
class="string">"field {} is not exist"</span>, field_name),
+<a href=#724 id=724 data-nosnippet>724</a>
)
+<a href=#725 id=725 data-nosnippet>725</a>
})<span class="question-mark">?</span>;
+<a href=#726 id=726 data-nosnippet>726</a>
<span class="kw">let </span>value = value.try_into(<span
class="kw-2">&</span>field.field_type)<span class="question-mark">?</span>;
+<a href=#727 id=727 data-nosnippet>727</a>
<span class="prelude-val">Ok</span>(value)
+<a href=#728 id=728 data-nosnippet>728</a> })
+<a href=#729 id=729 data-nosnippet>729</a>
.collect::<<span class="prelude-ty">Result</span><<span
class="kw">_</span>, Error>>()<span class="question-mark">?</span>;
+<a href=#730 id=730 data-nosnippet>730</a> <span
class="prelude-val">Ok</span>(<span
class="prelude-val">Some</span>(Literal::Struct(Struct::from_iter(iters))))
+<a href=#731 id=731 data-nosnippet>731</a> }
+<a href=#732 id=732 data-nosnippet>732</a>
Type::Map(map_ty) => {
+<a href=#733 id=733 data-nosnippet>733</a> <span
class="kw">if </span><span class="kw-2">*</span>map_ty.key_field.field_type !=
Type::Primitive(PrimitiveType::String) {
+<a href=#734 id=734 data-nosnippet>734</a> <span
class="kw">return </span><span
class="prelude-val">Err</span>(invalid_err_with_reason(
+<a href=#735 id=735 data-nosnippet>735</a>
<span class="string">"record"</span>,
+<a href=#736 id=736 data-nosnippet>736</a>
<span class="string">"Map key must be string"</span>,
+<a href=#737 id=737 data-nosnippet>737</a> ));
+<a href=#738 id=738 data-nosnippet>738</a> }
+<a href=#739 id=739 data-nosnippet>739</a> <span
class="kw">let </span><span class="kw-2">mut </span>map = Map::new();
+<a href=#740 id=740 data-nosnippet>740</a> <span
class="kw">for </span>(k, v) <span class="kw">in </span>required {
+<a href=#741 id=741 data-nosnippet>741</a> <span
class="kw">let </span>value = v.try_into(<span
class="kw-2">&</span>map_ty.value_field.field_type)<span
class="question-mark">?</span>;
+<a href=#742 id=742 data-nosnippet>742</a> <span
class="kw">if </span>map_ty.value_field.required && value.is_none() {
+<a href=#743 id=743 data-nosnippet>743</a>
<span class="kw">return </span><span
class="prelude-val">Err</span>(invalid_err_with_reason(
+<a href=#744 id=744 data-nosnippet>744</a>
<span class="string">"record"</span>,
+<a href=#745 id=745 data-nosnippet>745</a>
<span class="string">"Value element is required in this Map"</span>,
+<a href=#746 id=746 data-nosnippet>746</a> ));
+<a href=#747 id=747 data-nosnippet>747</a> }
+<a href=#748 id=748 data-nosnippet>748</a>
map.insert(Literal::string(k), value);
+<a href=#749 id=749 data-nosnippet>749</a> }
+<a href=#750 id=750 data-nosnippet>750</a> <span
class="prelude-val">Ok</span>(<span
class="prelude-val">Some</span>(Literal::Map(map)))
+<a href=#751 id=751 data-nosnippet>751</a> }
+<a href=#752 id=752 data-nosnippet>752</a> <span
class="kw">_ </span>=> <span
class="prelude-val">Err</span>(invalid_err(<span
class="string">"record"</span>)),
+<a href=#753 id=753 data-nosnippet>753</a> },
+<a href=#754 id=754 data-nosnippet>754</a>
RawLiteralEnum::StringMap(<span class="kw">_</span>) => <span
class="prelude-val">Err</span>(invalid_err(<span class="string">"string
map"</span>)),
+<a href=#755 id=755 data-nosnippet>755</a> }
+<a href=#756 id=756 data-nosnippet>756</a> }
+<a href=#757 id=757 data-nosnippet>757</a> }
+<a href=#758 id=758 data-nosnippet>758</a>}
</code></pre></div></section></main></body></html>
\ No newline at end of file
