// pub struct State<'a> {
// // open_chat: Option<OpenChat<'a>>,
// chats: Vec<BorrowedChat<'a>>,
// roster: Vec<BorrowedContact<'a>>,
// }
// impl Macaw {
// pub fn state(&self) -> State {
// let chats = self
// .chats
// .iter()
// .map(|(_, chat)| {
// let user = chat.user.as_ref().borrow();
// let contact = self.roster.get(&user.inner.jid);
// let latest_message = match &chat.message {
// Some(the_message) => {
// let message: Ref<'_, OwnedMessage> = the_message.as_ref().borrow();
// let user = {
// let user = message.user.as_ref().borrow();
// let contact = self.roster.get(&user.inner.jid);
// BorrowedUser {
// inner: user,
// contact,
// }
// };
// Some(BorrowedMessage {
// inner: message,
// user,
// })
// }
// None => None,
// };
// BorrowedChat {
// inner: &chat,
// user: BorrowedUser {
// inner: user,
// contact,
// },
// latest_message,
// }
// })
// .collect();
// State {
// // open_chat: todo!(),
// chats,
// roster: todo!(),
// }
// }
// }
// pub enum Node<'a> {
// User(BorrowedUser<'a>),
// Message(BorrowedMessage<'a>),
// Contact(BorrowedContact<'a>),
// Chat(BorrowedChat<'a>),
// OpenChat(OpenChat<'a>),
// }
// pub enum Orphan {
// User(JID),
// Message(Uuid),
// }
// pub struct BorrowedUser<'a> {
// inner: Ref<'a, OwnedUser>,
// // inner: &'a OwnedUser,
// contact: Option<&'a OwnedContact>,
// }
// pub struct BorrowedMessage<'a> {
// inner: Ref<'a, OwnedMessage>,
// // user: Rc<RefCell<User>>,
// user: BorrowedUser<'a>,
// }
// pub struct BorrowedContact<'a> {
// inner: &'a OwnedContact,
// user: BorrowedUser<'a>,
// }
// pub struct BorrowedChat<'a> {
// inner: &'a OwnedChat,
// // user: Rc<RefCell<OwnedUser>>,
// user: BorrowedUser<'a>,
// // latest_message: Option<Rc<RefCell<OwnedMessage>>>,
// latest_message: Option<BorrowedMessage<'a>>,
// }
// pub struct OpenChat<'a> {
// chat: BorrowedChat<'a>,
// messages: Vec<BorrowedMessage<'a>>,
// }
// there are two states: an editing state and a reading state.
// because the state is self-referential, each time there is a change, the state needs to be recalculated.
// pub struct State<'a> {
// // open_chat: Option<OpenChat<'a>>,
// chats: Vec<BorrowedChat<'a>>,
// roster: Vec<BorrowedContact<'a>>,
// }
// pub struct AState {
// open_chat: Option<OwnedOpenChat>,
// chats: HashMap<JID, (Chat, (User, Option<Contact>), Option<ChatMessage>)>,
// roster: HashMap<JID, (Contact, User)>,
// }
// pub struct OwnedOpenChat {
// chat: (Chat, (User, Option<Contact>)),
// messages: IndexMap<Uuid, (ChatMessage, (User, Option<Contact>))>,
// }
// pub struct MacawUser {
// inner: User,
// contact: Option<Contact>,
// }
// impl Deref for MacawUser {
// }
// other option is forget about all this bullshit and just build the relations graph again after each update?
// impl Macaw {
// pub async fn insert_contact(
// &mut self,
// contact: Contact,
// ) -> Result<(), CommandError<DatabaseError>> {
// let user_jid = contact.user_jid.clone();
// if !self.users.contains_key(&user_jid) {
// // TODO: all methods only on logged-in client
// match &self.client {
// Account::LoggedIn(client) => {
// let user = client.get_user(user_jid.clone()).await?;
// self.users.insert(user_jid, user);
// }
// Account::LoggedOut(login_modal) => todo!(),
// }
// } else {
// // up the dependency count
// }
// self.roster.insert(contact.user_jid.clone(), contact);
// Ok(())
// }
// pub fn get_contact(&self, jid: &JID) -> Option<(&Contact, &User)> {}
// pub fn get_contact_mut(&mut self, jid: &JID) -> Option<&mut Contact> {}
// pub fn remove_contact(&mut self, jid: JID) -> Option<Contact> {
// self.roster.
// }
// // updating is fine to do directly on any part of the store.
// // if a contact is retrieved, it is guaranteed that there is a user in the store, because when the contact was inserted, a user was added to the user store, and the userstore is a droppable store that does not allow you to remove items if there are other things depending on it.
// }
// pub struct MacawContact<'a> {
// inner: Contact,
// user: &'a User,
// }
// messages must be tombstoned because of this
// items are never directly added to or removed from a droppablestore
// remove can only be called from a store that called insert
// if a store calls insert it must call remove if something is removed from that store
pub struct DroppableStore<K: Clone, V: Clone>(HashMap<K, (usize, V)>);
impl<K: Clone, V: Clone> DroppableStore<K, V> {
pub fn capacity(&self) -> usize {
self.0.capacity()
}
pub fn contains_key<Q: ?Sized>(&self, k: &Q) -> bool
where
Q: std::hash::Hash + Eq,
K: Borrow<Q> + std::hash::Hash + Eq,
{
self.0.contains_key(k)
}
pub fn get<Q>(&self, k: &Q) -> Option<&V>
where
Q: std::hash::Hash + Eq,
K: Borrow<Q> + std::hash::Hash + Eq,
{
self.0.get(k).map(|(_, v)| v)
}
pub fn get_key_value<Q>(&self, k: &Q) -> Option<(&K, &V)>
where
Q: std::hash::Hash + Eq + ?Sized,
K: Borrow<Q> + std::hash::Hash + Eq,
{
self.0.get_key_value(k).map(|(k, (_, v))| (k, v))
}
pub fn get_mut<Q>(&mut self, k: &Q) -> Option<&mut V>
where
Q: std::hash::Hash + Eq + ?Sized,
K: Borrow<Q> + std::hash::Hash + Eq,
{
self.0.get_mut(k).map(|(_, v)| v)
}
pub fn insert(&mut self, k: K, v: V) -> Option<V>
where
K: std::hash::Hash + Eq,
{
if let Some((count, old_v)) = self.0.get_mut(&k) {
*count += 1;
let output = std::mem::replace(old_v, v);
Some(output)
} else {
self.0.insert(k, (1, v));
None
}
}
pub fn is_empty(&self) -> bool {
self.0.is_empty()
}
pub fn iter(&self) -> impl Iterator<Item = (&K, &V)> {
self.0.iter().map(|(k, (_, v))| (k, v))
}
pub fn iter_mut(&mut self) -> impl Iterator<Item = (&K, &mut V)> {
self.0.iter_mut().map(|(k, (_, v))| (k, v))
}
pub fn keys(&self) -> impl Iterator<Item = &K> {
self.0.keys()
}
pub fn len(&self) -> usize {
self.0.len()
}
pub fn new() -> Self {
Self(HashMap::new())
}
pub fn remove<Q>(&mut self, k: &Q) -> Option<V>
where
K: Borrow<Q> + std::hash::Hash + Eq,
Q: std::hash::Hash + Eq + ?Sized,
{
if let Some((count, old_v)) = self.0.get_mut(&k) {
if *count == 1 {
self.0.remove(&k).map(|(_, v)| v)
} else {
*count = *count - 1;
Some(old_v.clone())
}
} else {
None
}
}
pub fn remove_entry<Q>(&mut self, k: &K) -> Option<(K, V)>
where
K: std::hash::Hash + Eq,
{
if let Some((count, old_v)) = self.0.get_mut(&k) {
if *count == 1 {
self.0.remove_entry(&k).map(|(k, (_, v))| (k, v))
} else {
*count = *count - 1;
Some((k.clone(), old_v.clone()))
}
} else {
None
}
}
pub fn reserve(&mut self, additional: usize)
where
K: std::hash::Hash + Eq,
{
self.0.reserve(additional)
}
pub fn shrink_to(&mut self, min_capacity: usize)
where
K: std::hash::Hash + Eq,
{
self.0.shrink_to(min_capacity)
}
pub fn shrink_to_fit(&mut self)
where
K: std::hash::Hash + Eq,
{
self.0.shrink_to_fit()
}
pub fn try_reserve(
&mut self,
additional: usize,
) -> Result<(), std::collections::TryReserveError>
where
K: std::hash::Hash + Eq,
{
self.0.try_reserve(additional)
}
pub fn values(&self) -> impl Iterator<Item = &V> {
self.0.values().map(|(_, v)| v)
}
pub fn values_mut(&mut self) -> impl Iterator<Item = &mut V> {
self.0.values_mut().map(|(_, v)| v)
}
pub fn with_capacity(capacity: usize) -> Self {
Self(HashMap::with_capacity(capacity))
}
}
// #[derive(Debug, Clone)]
// pub struct MacawChat {
// inner: Arc<Mutex<Chat>>,
// jid: JID,
// latest_message: Option<MacawChatMessage>,
// store: MacawChatStore,
// }
// impl Drop for MacawChat {
// fn drop(&mut self) {
// let mut store = match self.store.0.lock() {
// Ok(s) => s,
// Err(s) => s.into_inner(),
// };
// if Arc::<Mutex<Chat>>::strong_count(&self.inner) == 2 {
// store.shift_remove(&self.jid);
// }
// }
// }
// #[derive(Debug, Clone)]
// pub struct MacawChatStore(Arc<Mutex<IndexMap<JID, MacawChat>>>);
// #[derive(Debug, Clone)]
// pub struct MacawChatMessage {
// inner: Arc<Mutex<ChatMessage>>,
// id: Uuid,
// user: BorrowedUser,
// store: MacawChatMessageStore,
// }
// impl Drop for MacawChatMessage {
// fn drop(&mut self) {
// let mut store = match self.store.0.lock() {
// Ok(s) => s,
// Err(s) => s.into_inner(),
// };
// if Rc::<ChatMessage>::strong_count(&self.inner) == 1 {
// store.shift_remove(&self.id)
// }
// }
// }
// #[derive(Debug, Clone)]
// pub struct MacawChatMessageStore(HashMap<Uuid, MacawChatMessage>);
// impl Deref for MacawChatMessageStore {
// type Target = HashMap<Uuid, (ChatMessage, BorrowedUser)>;
// fn deref(&self) -> &Self::Target {
// &self.0
// }
// }
// impl DerefMut for MacawChatMessageStore {
// fn deref_mut(&mut self) -> &mut Self::Target {
// &mut self.0
// }
// }
// #[derive(Debug, Clone)]
// pub struct BorrowedUser {
// inner: Rc<User>,
// contact: Option<Box<BorrowedContact>>,
// store: Rc<RefCell<MacawUserStore>>,
// }
// impl Drop for BorrowedUser {
// fn drop(&mut self) {
// if Rc::<User>::strong_count(&self.inner) == 1 {
// self.store.borrow_mut().remove(&self.inner.jid);
// }
// }
// }
// impl Deref for BorrowedUser {
// type Target = User;
// fn deref(&self) -> &Self::Target {
// self.inner.as_ref()
// }
// }
// #[derive(Debug)]
// pub struct MacawUserStore(HashMap<JID, (User, Option<BorrowedContact>)>);
// impl Deref for MacawUserStore {
// type Target = HashMap<JID, (User, Option<BorrowedContact>)>;
// fn deref(&self) -> &Self::Target {
// &self.0
// }
// }
// impl DerefMut for MacawUserStore {
// fn deref_mut(&mut self) -> &mut Self::Target {
// &mut self.0
// }
// }
// #[derive(Debug, Clone)]
// pub struct BorrowedContact {
// inner: Rc<Contact>,
// user: Box<BorrowedUser>,
// store: Rc<RefCell<MacawRosterStore>>,
// }
// impl Drop for BorrowedContact {
// fn drop(&mut self) {
// if Rc::<Contact>::strong_count(&self.inner) == 1 {
// self.store.borrow_mut().remove(&self.inner.user_jid);
// }
// }
// }
// impl Deref for BorrowedContact {
// type Target = Contact;
// fn deref(&self) -> &Self::Target {
// self.inner.as_ref()
// }
// }
// #[derive(Debug)]
// pub struct MacawRosterStore(HashMap<JID, (Contact, BorrowedUser)>);
// impl Deref for MacawRosterStore {
// type Target = HashMap<JID, (Contact, BorrowedUser)>;
// fn deref(&self) -> &Self::Target {
// &self.0
// }
// }
// impl DerefMut for MacawRosterStore {
// fn deref_mut(&mut self) -> &mut Self::Target {
// &mut self.0
// }
// }
