btreemap | A simple and high-performance Java B-tree : drop-in | Dataset library

BTreeMaps are already sorted by key, and tuples implement ordering traits when all of their component types do. Tuples are ordered by their first element, then their second, and so on. Therefore, you can just grab the first key in the map:

== in Rust is not guaranteed to be O(1). For containers specifically, it may be much costlier.

Both Vec (actually slice, since it implements the underlying comparison for both vecs and slices) and BTreeMap are O(n) where n is the number of elements in the container. Both however are O(1) where the sizes of the compared containers are different.

The code for BTreeMap is here:

The reason is that BTreeMap has a deterministic iteration order and HashMap does not. To quote the docs from the Hash trait,

When implementing both Hash and Eq, it is important that the following property holds:

Is there a way to work around this issue without imposing additional constraints on map key and value types?

It doesn't appear doable in safe Rust, at least not with reasonable algorithmic complexity. (See Aiden4's answer for a solution that does it by re-building the whole map.)

But if you're allowed to use unsafe, and if you're determined enough that you want to delve into it, this code could do it:

Rust BTreeMap becomes invalid when key is mutated

This is documented:

It is a logic error for a key to be modified in such a way that the key’s ordering relative to any other key, as determined by the Ord trait, changes while it is in the map.

Is it possible to work around this somehow and prevent such a value from being automatically moved to the right place when it is changed

It's not moved at all, which is why you're breaking the map when you do that.

Clippy has a lint which warns about such misuses.

Though it can not be perfect (it has both false positives and false negatives), here if you plug your code in the playground and select Tools > Clippy, you will see:

If you're looking specifically to serialize a map into a query string, you probably want to use something like serde_qs.

If you're trying to perform this serialization manually, an efficient way (minimizing allocations) would be to use Iterator::fold like so:

You're right that a B-Tree map is a little expensive for this application.

Since the window size is constant, a faster implementation would be to partition the sequence numbers into buckets of size about WINDOW_SIZE/2. Then just put the flows into a hash table according to their rcvd bucket.

To find flows for a particular packet, then, you only need to look up the 3 buckets that could possibly contain matching flows, and test each flow in the buckets. This will be faster than a B-Tree lookup.

On update, the situation is even better, because you only need to update the hash table when an entry changes buckets, and that only happens every once every WINDOW_SIZE/2 packets.

Your problem boils down to matching your rust struct with the response structure. I'm using the example with String from your playground link.

Floating point numbers are not good candidates for keys. Maybe you should consider converting them to integers or strings. For example, if you only care about 2 digits after the decimal separator, you can do something like n*100, rounded and converted to an integer type.