如何实现一个委托给 HashMap::values() 的迭代器

Question

I am trying to implement a datastructure to store 'registers' in groups. There is a master list which I am considering the owner of the register data.

I have the following :

use std::collections::hash_map::HashMap;

pub struct Register {
    pub name: String,
    pub address: u16,
}

// map with references to 'master' list of registers
type RegisterMap<'a> = HashMap<String, &'a Register>;

struct RegisterGroup<'a> {
    start_address: u16,
    registers: RegisterMap<'a>,
}

struct RegisterGroupIter<'a> {
    inner: std::collections::hash_map::Values<'a,String,&'a Register>,
}

impl<'a> Iterator for RegisterGroupIter<'a> {
    type Item = &'a Register;
    fn next(&mut self) -> Option<&'a Register> {
        self.inner.next()
    }
}
impl<'a> RegisterGroup<'a> {

    // return iterator over references to Register
    fn registers(&self) -> RegisterGroupIter {
        RegisterGroupIter {
            inner: self.registers.values(),
        }
    }
}

Is this reasonable/idiomatic? If so what is the correct setup for the item type wrt references/lifetimes etc? Otherwise what should I be doing instead?

   Compiling playground v0.0.1 (/playground)
error[E0308]: mismatched types
  --> src/main.rs:22:9
   |
21 |     fn next(&mut self) -> Option<&'a Register> {
   |                           -------------------- expected `std::option::Option<&'a Register>` because of return type
22 |         self.inner.next()
   |         ^^^^^^^^^^^^^^^^^ expected struct `Register`, found `&Register`
   |
   = note: expected enum `std::option::Option<&'a Register>`
              found enum `std::option::Option<&&'a Register>`

Answer 1

Since the values iterator of a HashMap yields references to the values type, and the values type is a reference itself in this case, the iterator items are of type &&Register . This means you need to dereference the items before returning them in your iterator. The easiest way to dereference inside an option is to use the copied() method:

impl<'a> Iterator for RegisterGroupIter<'a> {
    type Item = &'a Register;
    fn next(&mut self) -> Option<&'a Register> {
        self.inner.next().copied()
    }
}

I'm not sure why you store the name both as the hash map key and inside the Register struct. I'd usually try to normalize the data and only sore the name as the map keys.

You don't really need to implement your own iterator type here. Directly returning the values iterator of the hash map will work just fine:

impl RegisterGroup<'_> {
    fn registers(&self) -> impl Iterator<Item = &Register> {
        self.registers.values().copied()
    }
}