Rust Flexbuffers (#5669)

* Cargo clippy lints

* more lints

* more lints

* Restored a doc comment

* Comment on float eps-eq and adjusted casting

* Rust Flexbuffers

* more serde tests, removed some unsafe

* Redid serde to be map-like and Reader is Display

* Moved iter from Reader to VectorReader

* Serious quickcheck + bugs

* wvo api

* Made types smaller for a reasonable speedup

* redid reading in a way that's a bit faster.

Profiling shows the rust slowdown as building +10%, reading +20%

* src/bin are developer binaries in rust

* Root and Map width are not packed

* key null check is debug only + doc changes

* BuilderOptions

* Documentation

* Documentation

* Moved tests to rust_usage_test

* Moved rust flexbuffers samples to Flatbuffers/samples

* Fixed RustTest

* Fixed for Rust 1.37.0

* Upgraded to rust 1_40_0

* fixed a little-endian-only feature in a test

* 1.40.0

* fixed some benchmarks for bigendian

* Updated .bat file

* misspelling

* Gold Flexbuffer test.

* Serialize,Deserialize, std::error::Error for Errors.

* Undo rustfmt in integration_test.rs

* from_slice instead of from_vec

* Added comments to unsafe blocks

* expanded on comment

* bump

Co-authored-by: CasperN <cneo@google.com>

rust/flexbuffers/src/reader/vector.rs

@@ -0,0 +1,74 @@
+// Copyright 2019 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use super::{unpack_type, Error, Reader, ReaderIterator};
+use crate::{BitWidth, FlexBufferType};
+
+#[derive(Default, Clone)]
+/// Allows indexing on any flexbuffer vector type, (heterogenous vector, typed vector, or fixed
+/// length typed vector).
+///
+/// VectorReaders may be indexed with usize, `index` returns a result type
+/// which may indicate failure due to indexing out of bounds or bad data. `idx` returns a
+/// Null Reader in the event of any failure.
+pub struct VectorReader<'de> {
+    pub(super) reader: Reader<'de>,
+    // Cache the length because read_usize can be slow.
+    pub(super) length: usize,
+}
+
+impl<'de> VectorReader<'de> {
+    /// Returns the number of elements in the vector.
+    pub fn len(&self) -> usize {
+        self.length
+    }
+    /// Returns true if there are 0 elements in the vector.
+    pub fn is_empty(&self) -> bool {
+        self.length == 0
+    }
+    fn get_elem_type(&self, i: usize) -> Result<(FlexBufferType, BitWidth), Error> {
+        if let Some(ty) = self.reader.fxb_type.typed_vector_type() {
+            Ok((ty, self.reader.width))
+        } else {
+            let types_addr = self.reader.address + self.length * self.reader.width.n_bytes();
+            self.reader
+                .buffer
+                .get(types_addr + i)
+                .ok_or(Error::FlexbufferOutOfBounds)
+                .and_then(|&t| unpack_type(t))
+        }
+    }
+    /// Index into a flexbuffer vector. Any errors are defaulted to Null Readers.
+    pub fn idx(&self, i: usize) -> Reader<'de> {
+        self.index(i).unwrap_or_default()
+    }
+    /// Index into a flexbuffer.
+    pub fn index(&self, i: usize) -> Result<Reader<'de>, Error> {
+        if i >= self.length {
+            return Err(Error::IndexOutOfBounds);
+        }
+        let (fxb_type, bw) = self.get_elem_type(i)?;
+        let data_address = self.reader.address + self.reader.width.n_bytes() * i;
+        Reader::new(
+            self.reader.buffer,
+            data_address,
+            fxb_type,
+            bw,
+            self.reader.width,
+        )
+    }
+    pub fn iter(&self) -> ReaderIterator<'de> {
+        ReaderIterator::new(self.clone())
+    }
+}