"Converting" unordered data structure to 2D HashMap

Question

I have this datastructure in Rust:

objects: [Object { ob: 1, id: 0 }, 
          Object { ob: 1, id: 1 }, 
          Object { ob: 0, id: 3 }, 
          Object { ob: 0, id: 2 },
          ...
         ]

I'm using a HashMap where i can use the two keys "ob" and "id" to reference to data that im gonna store in this 2D HashMap. To create a 2D HashMap, i'm using the code found in this answer: How to implement HashMap with two keys?.

In the code below, i'm trying to firstly create all the structs (aCustomStructOfMine), and store them in the table with their belonging two keys, "ob" and "id". Then later in the code (not written yet), i will be accessing the structs iteratively and will be editing them and using their at-the-moment stored data.

fn analyse(objects: Vec<Object>) {
    let mut table = Table::new();
    for object in objects {
        let ob = &object.ob;
        let id = &object.id;
        table.set(A(ob), B(id), aCustomStructOfMine::new());
    }
}

I'm getting the following error:

borrowed value does not live long enough
assignment requires that `object.id` is borrowed for `'static`

How can i achieve the desired 2D HashMap from the given objects variable.

I'm new to rust, and although i understand the basic principles of ownership, borrowing, lifetime and more, it's really hard to actually code with these concepts in mind.

You need to clone the objects. Right now you are trying to insert pointers to a structure that won't exist much longer — mousetail, Jul 29 '22 at 13:05
Does this answer your question? [Struct property as key and the struct itself as value in HashMaps - Rust](https://stackoverflow.com/questions/72776613/struct-property-as-key-and-the-struct-itself-as-value-in-hashmaps-rust) — Jmb, Jul 29 '22 at 13:10
If i’m not wrong, then the table needs pointers, and cannot store the key values on their own. Therefore the keys need to be stored somewhere else than in the table. Is that right, or can i copy the keys from the objects and move the ownership to the table? — Ólavur Nón, Jul 29 '22 at 13:16
As far as I understand your project, you just need to dereference the variables, i.e. replace the statement in the last line by this `A(*ob), B(*id)`. That's because — محمد جعفر نعمة, Jul 29 '22 at 17:20

Finomnis · Accepted Answer · 2022-07-30T14:35:06.773

I personally think you are getting confused by the other post and make this way too complicated.

If two types KeyA and KeyB implement Hash, then the tuple (KeyA, KeyB) automatically does so as well. There is no need to create a fancy new Table type that can take two keys. Just use a tuple.

There are some other remarks concerning ownership I'd like to make, but I think they are best annotated in the source code. Here is a working version of what you intended, I think:

use std::collections::HashMap;

// This is just for demonstration. Use your own types.
// I used `String` because it already implements `Eq` and `Hash`.
type KeyA = String;
type KeyB = String;

// This is an example type that you should replace with your own
// data type in the HashMap
pub struct MyData {}

// Some generic input type, to stick as close to your example as possible
pub struct Object {
    a: KeyA,
    b: KeyB,
}

// The analyze function, as in your example.
// Note that we take `objects` by value, not by reference.
// That means we own it and can do whatever we want with it.
// This is important because you never mentioned that the Keys are supposed to be
// `Clone` or `Copy`.
pub fn analyse(objects: Vec<Object>) -> HashMap<(KeyA, KeyB), MyData> {
    // No need to use fancy new types for your table.
    // Use use a tuple (KeyA, KeyB) as the key.
    // If both KeyA and KeyB implement `Hash`, then the
    // tuple implements it as automatically well.
    let mut table = HashMap::new();

    // Note that I wrote `in objects` and not `in &objects`, meaning this loop actually
    // consumes and destroys `objects`, extracts `object` out of it and gives you a fully owned
    // `object`.
    for object in objects {
        // This again is not a borrow, but a move.
        // The `object.a` gets moved out of `object` and into `key_a`.
        // No need to reference here, `object` doesn't get used any further
        // anyway. And for inserting it into a `HashMap`, we need owned keys anyway.
        //
        // I think this was the main point you were struggling with in the original code,
        // that you used references here.
        let key_a = object.a;
        let key_b = object.b;

        // Just create the key tuple and insert
        table.insert((key_a, key_b), MyData {});
    }

    // Return the table
    table
}

I cannot believe it, it works flawlessly! And i'm suprised that after my googling, it could be as easy as just using tuples as keys to HashMaps! I tried googling, and the post i referred to was the only thing i could find remotely close to my problem statement. And thank you for the thorough and well solved explanation, i'll surely take a look at the notes again for later problems! — Ólavur Nón, Jul 30 '22 at 14:30

"Converting" unordered data structure to 2D HashMap

1 Answers1