Explicit array serialization in serde

[Schuwi]

This PR aims to implement Byte/Int/Long array serialization support for serde.
Right now every Vec<i8> or similar sequence types get serialized to a List of Bytes instead of the ByteArray type. This PR implements a serde serialize_with function to tag fields of collection types to serialize into ByteArray/IntArray/LongArray (called i8_array/i32_array/i64_array respectively).

For example:

#[derive(Serialize)]
struct MyStruct {
    #[serde(serialize_with="hematite_nbt::i8_array")]
    byte_array: Vec<i8>,
}

This will serialize to a compound containing a ByteArray instead of a List of Bytes.

Current limitations

• As this approach uses a bit of a hack internally because of serde limitations, fields tagged to use the array serializer can only be serialized with hematite-nbt. When serializing with a different serializer this will try to serialize as a serde tuple_struct with the name __hematite_nbt_i8_array__ (or i32/i64 respectively) and the array elements as fields of that tuple.
• Serde currently doesn't support using serialize_with on inner elements (of Option, Vec, ...) and thus nested arrays are not trivially supported (see Using de/serialize_with inside of an Option, Map, Vec serde-rs/serde#723). A workaround for this as also currently used in hematite_nbt tests is not that clean, but it can be made to work:

  #[derive(Debug, PartialEq, Serialize, Deserialize)]
  struct NestedArrayNbt {
      #[serde(serialize_with = "nested_i32_array")]
      data: Vec<Vec<i32>>,
  }
  
  fn nested_i32_array<S>(outer_arr: &Vec<Vec<i32>>, serializer: S) -> Result<S::Ok, S::Error>
  where
      S: Serializer,
  {
      #[derive(Debug, Serialize)]
      struct Wrapper(#[serde(serialize_with = "nbt::i32_array")] Vec<i32>);
  
      // clone should be optimized to a no-op
      serializer.collect_seq(outer_arr.iter().map(|vec| Wrapper(vec.clone())))
  }
  

---

More details and discussion can also be found in the PR of a previous, different approach on implicitely converting all NBT lists that can be represented as arrays: #51

Resolves #27
Resolves #32

[atheriel]

Is this a "real" example? If so, it'd be neat to mention where it comes from.

[Schuwi]

nah, just had a bit of fun with those examples. it's "binary sheep" in ASCII ;)

[atheriel]

Shouldn't this just be UnrepresentableType("tuple struct")?

[Schuwi]

yeah, I basically just 1:1 copied what the macro did before, but I can change that if that's more readable
Edit: so stringify! does resolve to either "tuple_struct" or "tuple struct" dunno whether it removes the underscore

[atheriel]

Yes, please change.

[Schuwi]

okay will do

[atheriel]

Can you squash this and rebase against master?

[Schuwi]

Never done either of them. Squashing is putting multiple commits into one and rebase is that it looks like it branches off the current master HEAD?
I'll find out how to do it, but I'll have to do it later this evening.

[Schuwi]

Alright, it's done

[atheriel]

Thanks for all your work!