[rust] Genericize flexbuffer reader (#6450)

* feature/rust-tokio-bytes added feature name for tokio-bytes

* Added flexbuffer implementation, TODO: typecast to avoid recurse

* Converted codebase to utilize FlexBuffer implementation, need to resolve deserialization issues

* Added todo for lifetime issue, may use &'de [u8] for deserializer instead of current method

* Added proper &[u8] implementation

* Removed unused struct

* Added experimental fix to get_slice

* Added experimental fix to get_slice

* Avoided lifetime issues via ref structs, need to check if this hurts peformance

* Updated deserializer implementation to allow for borrowed data from Reader struct

* Fixed bug with str

* Removed unnecessary generic parameter

* Added unsafe to avoid lifetime complaints, current tests pass, need to review alternatives to unsafe

* Opinionated: Removed bytes crate as this implementation could be done in a separate crate

* Cleaned up flatbuffer

* Fixed sample / example

* Resolved PR feedback, need to resolve issues with tests

* Cleaned up FlexBuffer trait to be an auto impl

* Removed TODO

* Reverted Deserializer to only support &'de [u8]

* Cleaned up / renamed function for clarification

* Renamed FlexBuffer -> InternalBuffer for clarification on it's purpose

* Fixed issue with key bytes

* resolved issues with broken tests, confirming this is a breaking change

* Removed FIXME that's solved by splitting String and Key variants

* Implemented associated types approach

* Fixed backward slice logic

* Fixed MapReader compile error

* Added from_buffer for deserialization, removed  function since it's only needed for deserialization

* Removed dead code

* Cleaned up buffer, removed AsRef in favor of Deref

* Renamed Buffer::as_str -> Buffer::buffer_str

* Minor cleanup

* Updated documentation, need to fix tests

* Removed unnecessary &

* Removed unused lifetime

* removed unnecessary as_ref

* Minor optimization wrap-up

* resolved issue with Clone

* Added test to verify no deep-copy

* Added  for optimization

* Updated to use empty fn instead of default

* Updated comments / test name - plus the 0.3.0 version bump

* comment

rust/flexbuffers/src/reader/vector.rs

@@ -13,22 +13,39 @@
 // limitations under the License.
 
 use super::{unpack_type, Error, Reader, ReaderIterator};
-use crate::{BitWidth, FlexBufferType};
+use crate::{BitWidth, Buffer, 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>,
+pub struct VectorReader<B> {
+    pub(super) reader: Reader<B>,
     // Cache the length because read_usize can be slow.
     pub(super) length: usize,
 }
 
-impl<'de> VectorReader<'de> {
+impl<B: Buffer> Clone for VectorReader<B> {
+    fn clone(&self) -> Self {
+        VectorReader {
+            reader: self.reader.clone(),
+            ..*self
+        }
+    }
+}
+
+impl<B: Buffer> Default for VectorReader<B> {
+    fn default() -> Self {
+        VectorReader {
+            reader: Reader::default(),
+            length: usize::default()
+        }
+    }
+}
+
+impl<B: Buffer> VectorReader<B> {
     /// Returns the number of elements in the vector.
     pub fn len(&self) -> usize {
         self.length
@@ -50,25 +67,26 @@ impl<'de> VectorReader<'de> {
         }
     }
     /// Index into a flexbuffer vector. Any errors are defaulted to Null Readers.
-    pub fn idx(&self, i: usize) -> Reader<'de> {
+    pub fn idx(&self, i: usize) -> Reader<B> {
         self.index(i).unwrap_or_default()
     }
     /// Index into a flexbuffer.
-    pub fn index(&self, i: usize) -> Result<Reader<'de>, Error> {
+    pub fn index(&self, i: usize) -> Result<Reader<B>, 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,
+            self.reader.buffer.shallow_copy(),
             data_address,
             fxb_type,
             bw,
             self.reader.width,
         )
     }
-    pub fn iter(&self) -> ReaderIterator<'de> {
+
+    pub fn iter(&self) -> ReaderIterator<B> {
         ReaderIterator::new(self.clone())
     }
 }