Hashmap 值不会在连续插入时更新 [Rust]

Question

I have a struct that contains various Routers. Mostly hashmaps. But for this specific hashmap, the values are not updating after insertion. There is no delete function. Just an insert function(shown below).

This is the main struct

pub struct Router {
....
    web_socket_routes: Arc<RwLock<HashMap<String, HashMap<String, (PyFunction, u8)>>>>,
}

This is a getter

    #[inline]
    pub fn get_web_socket_map(
        &self,
    ) -> &Arc<RwLock<HashMap<String, HashMap<String, (PyFunction, u8)>>>> {
        &self.web_socket_routes
    }

This is the insert method

    pub fn add_websocket_route(
        &mut self,
        route: &str,
        connect_route: (Py<PyAny>, bool, u8),
        close_route: (Py<PyAny>, bool, u8),
        message_route: (Py<PyAny>, bool, u8),
    ) {
        let table = self.get_web_socket_map();
        let (connect_route_function, connect_route_is_async, connect_route_params) = connect_route;
        let (close_route_function, close_route_is_async, close_route_params) = close_route;
        let (message_route_function, message_route_is_async, message_route_params) = message_route;

        let insert_in_router =
            |handler: Py<PyAny>, is_async: bool, number_of_params: u8, socket_type: &str| {
                let function = if is_async {
                    PyFunction::CoRoutine(handler)
                } else {
                    PyFunction::SyncFunction(handler)
                };

                let mut route_map = HashMap::new();
                route_map.insert(socket_type.to_string(), (function, number_of_params));

                println!("socket type is {:?} {:?}", table, route);
                table.write().unwrap().insert(route.to_string(), route_map);
            };

        insert_in_router(
            connect_route_function,
            connect_route_is_async,
            connect_route_params,
            "connect",
        );

        insert_in_router(
            close_route_function,
            close_route_is_async,
            close_route_params,
            "close",
        );

        insert_in_router(
            message_route_function,
            message_route_is_async,
            message_route_params,
            "message",
        );
    }

After all the 3 insert_in_router calls, web_socket_routes only contains the insertion of the last insert_in_router call?

I have tried changing the Arc<RwLock< for a generic DashMap but I am still facing the same issues.

Why is this happening?

Answer 1

Your closure unconditionally creates a new inner HashMap each time, which it uses as value in the outer hashmap. However, it puts it into the outer hashmap under the same key ( route.to_string() ) all three times, which results in each insert overwriting the previous one(s).

You need to implement a logic that will create a new inner hashmap only if the key is missing. Then it should insert the value into the inner hashmap, either the freshly created one, or the one looked up. In Rust this is done using the entry API:

table
    .write()
    .unwrap()
    .entry(route.to_string())
    .or_default()
    .insert(socket_type.to_string(), (function, number_of_params))