-1 
pub trait Observer{
    type DataType;
    fn new(action: fn(&mut Self::DataType))->Self;
    fn update(&self, data:&mut Self::DataType);
}

pub trait Subject{
    type ObserverType: Observer;
    fn new()-> Self;
    fn add_observer(&mut self,observer:Rc<Self::ObserverType>);
    fn remove_observer(&mut self,observer:&Rc<Self::ObserverType>);
    fn data(&mut self)-> &<<Self as Subject>::ObserverType as Observer>::DataType;
    fn notification(&mut self);
}

pub struct SubjectMgr{
}

impl SubjectMgr {
    fn new(){
        let mut map = HashMap::new();
        map.insert("PlayerList",PlayerListSubject::new());
        map.insert("MonsterList",MonsterListSubject::new());
    }
}

尝试使用具有关联值的哈希图作为成员。但是我不能有一个 hashmap 值类型吗？

文件结构如下： 在此处输入图片描述

4

2 回答 2

0

在大多数 Rust 集合中，值（和键）必须具有相同的类型。PlayerListSubject并且MonsterListSubject是不同的类型，因此它们的值不能放入同一个映射中，除非您在特征对象后面对它们进行类型擦除（假设特征是对象安全的，我认为这里不是这种情况）。

将来，您可能希望提供该问题的最少可重现示例，而不是提供不完整的不可用代码。这使得潜在的帮助者更容易尝试和理解这个问题，确保没有人在误解上浪费时间，并增加获得有用答案的几率（我不确定这个答案是否）。

不过，整个事情看起来都是从 Java 或 C# 中提取出来的，这预示着它实际上无法正常工作。Rust 是一种完全不同的语言，它对语言用户设置了自己的一组限制。尝试在其中复制 Java 设计通常会导致挫败感并且无法正常工作。

于 2021-07-12T05:47:52.173 回答
0 
use std::{ops::Deref, rc::Rc};
use super::{Observer, Subject};

struct Monster{
    id: String,
    password: String,
}

#[derive(Default)]
struct MonsterList{
    players: Vec<Monster>
}

impl Deref for MonsterList {
    type Target = Vec<Monster>;

    fn deref(&self) -> &Self::Target {
        &self.players
    }
}

impl MonsterList {
    pub fn new() -> Self {
        MonsterList::default()
    }
}

pub struct MonsterListObserver{
    action: fn(&mut MonsterList),
}

impl Observer for MonsterListObserver{
    type DataType = MonsterList;

    fn new(action: fn(&mut Self::DataType))->Self {
        Self {action}
    }

    fn update(&self, data:&mut Self::DataType) {
        (self.action)(data);
    }
}

pub struct MonsterListSubject{
    monster_list: MonsterList,
    observers: Vec<Rc<MonsterListObserver>>,
}

impl Subject for MonsterListSubject{
    type ObserverType = MonsterListObserver;

    fn new()-> Self {
        Self {
            monster_list: MonsterList::new(),
            observers: Vec::new(),
        }
    }

    fn add_observer(&mut self,observer:Rc<Self::ObserverType>) {
        self.observers.push(observer);
    }

    fn remove_observer(&mut self,remove_observer:&Rc<Self::ObserverType>) {
        self.observers.retain(|observer|{
            let observer = &**observer as *const MonsterListObserver;
            let remove_observer = &**remove_observer as *const MonsterListObserver;
            observer != remove_observer
        })
    }

    fn data(&mut self)-> &<Self::ObserverType as Observer>::DataType {
        &mut self.monster_list
    }

    fn notification(&mut self) {
        let monster_list = &mut self.monster_list;
        self.observers
            .iter()
            .for_each(|observer| observer.update(monster_list))
    }
}
于 2021-07-12T06:25:59.030 回答