corlib 0.4.1

A various ideas library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

use std::marker::PhantomData;
use std::rc::{Rc, Weak};

use std::ops::Fn;

use crate::collections::List;

use crate::rc::WeakByPtr;

use std::vec::Vec;

use delegate::delegate;

use super::base_list_event::{BaseListEvent, LEPubEvent};

//use std::ops::{AddAssign, SubAssign};

//UniqueList

use crate::rc::RcByPtr;

//type FuncType<S, A> = dyn Fn(&S, &A); //mut 

pub type SenderArgEventFunc<S, A> = dyn Fn(&S, &A) -> bool; 

///
/// A UniqueItemList based event containing event handler functions that each take an event-arguments reference in addition to the sender reference argument.
/// 
pub struct ListArgsEvent<S, A>
    //where F: Fn(&mut S, &A)
{

    ble: BaseListEvent<SenderArgEventFunc<S, A>, S>,
    phantom: PhantomData<A>

}

impl<S, A> ListArgsEvent<S, A>
    //where F: Fn(&mut S, &A)
{

    pub fn new() -> Self
    {

        Self
        {

            ble: BaseListEvent::new(),
            phantom: PhantomData::default()

        }

    }

    pub fn with_capacity(capacity: usize) -> Self
    {

        Self
        {


            ble: BaseListEvent::with_capacity(capacity),
            phantom: PhantomData::default()

        }

    }

    delegate! {
        to self.ble { //contents {

            fn subscribe(&mut self, f: &Rc<SenderArgEventFunc<S, A>>) -> bool;

            fn unsubscribe(&mut self, f: &Rc<SenderArgEventFunc<S, A>>) -> bool;

            fn get_pub_event<'a>(&'a mut self) -> LEPubEvent<'a, SenderArgEventFunc<S, A>, S>;

            fn len(&self) -> usize;

            fn is_empty(&self) -> bool;

        }
    }

}

//https://doc.rust-lang.org/error_codes/E0403.html

impl<S, A> ListArgsEvent<S, A> 
    //where F: Fn(&mut S, &A)
{

    pub fn raise(&mut self, sender: &S, event_args: &A) -> usize //mut 
        //where F: Fn(&mut S, &A)
    {

        let mut items_to_remove = Vec::new();

        let mut index: usize = 0;

        for item in self.ble.iter()
        {

            //if !item.get_contents_ref()(sender, event_args)
            if !item.contents_ref()(sender, event_args)
            {

                items_to_remove.push(index);

            }

            index += 1;

        }

        self.ble.remove_at_indexes(items_to_remove)
        
    }

}