bincode | A binary encoder / decoder implementation in Rust | Serialization library

The serde's Deserialize trait has a lifetime 'de. This lifetime is used to implemented zero-copy deserialization: avoiding copying e.g. strings, and instead using the already-exisiting buffer we deserialize from.

But if your object outlives the buffer, it cannot depend on it! In this case, you need a deserialization that lives forever, or for<'de> Deserialize<'de>. Serde has a trait for that, DeserializeOwned, which is essentially this: a shortcut for for<'de> Deserialize<'de>. So what you need if to use DeserializeOwned instead of Deserialize:

Data is being changed and transferred over the network fairly often (by design), so it's probably not a good idea to wait for multiple read locks every time i need to send something.

Forget performance - this won't be your bottleneck in any sort of game networking (which does appear what you're trying to do).

The only correct way is to first acquire a read lock on each field before serializing the data, and then serialize them all. If you don't do this you end up with inconsistent states that never logically existed. A player could be alive yet have 0 hitpoints, or be disconnected yet in the game.

This can lead to deadlocks! This is the difficulty you chose when you started sharing data. There is a very good rule of thumb that can prevent deadlocks if you stick to it religiously, which you have to do throughout your code: any routine that acquires multiple locks must acquire them in the same order. If a new lock is needed but we already have other locks that come later in the order, we must first release all locks before acquiring them all again, in the correct order.

The easiest way to stick to the above is by having only a single lock for a player.

You are writing the code using bincode::serialize but read back the data not with bincode::deserialize but using BufReader.

In order to properly serialize the string in a binary fashion, the encoder adds additional information about the data it stores.

If you know that only strings compatible with BufReader#lines will be processed, you can also use String#as_bytes when writing it to a file. Note that this will cause problems for some inputs, notably newline characters and others.

You can find the collation names of the columns involved in the tables and see if there is any mismatch in collation.

For example, below query gives column level collation information of the tables involved in your query.

In is not possible to serialize references with Serde. See see How do I use Serde to deserialize structs with references from a reader?

You could make a custom wrapper type that takes a deserialized Container value as f64, and builds a proper instance with Arc-s inside:

as Herohtar mentioned, you are truncating the file with fn serialize_to_file, you are creating the file 5 times,this would be a simple solution.

Since your using an Observable you can get the first return with take(1). This will unsubscribe from your Observable as soon as one Value is emitted

I think that the problem occurs because the value of a is dropped after the function returns the pointer but I'm not sure if that's right

Well yes, pretty much. The locals of a function only live for the extent of that function (which is why rustc will refuse compiling if you try to return a reference to function-local data), so get_pointer returns a dangling pointer, serializing and deserializing the pointer does quite literally nothing, and the ptr::read is UB:

Safety

Behavior is undefined if any of the following conditions are violated:

• src must be valid for reads.
• src must be properly aligned. Use read_unaligned if this is not the case.
• src must point to a properly initialized value of type T.

Running the program using miri unambiguously flags the issue: