29 SchedulerList::SchedulerList () |
29 SchedulerList::SchedulerList () |
30 {} |
30 {} |
31 SchedulerList::~SchedulerList () |
31 SchedulerList::~SchedulerList () |
32 {} |
32 {} |
33 |
33 |
34 /* !! WARNING !! |
|
35 * This is a very nasty piece of code but it really should work |
|
36 * with pretty much any implementation of a std::list. |
|
37 * it relies on the fact that a std::list<>::iterator has a single |
|
38 * member variable, a pointer. |
|
39 */ |
|
40 EventId |
|
41 SchedulerList::GetEventId (Scheduler::EventKey key, EventsI i) |
|
42 { |
|
43 assert (sizeof (i) <= sizeof (void *)); |
|
44 void *internalIterator; |
|
45 memcpy ((char *)&(internalIterator), (char *)&i, sizeof (void *)); |
|
46 EventImpl *ev = i->first; |
|
47 ev->SetInternalIterator (internalIterator); |
|
48 return EventId (ev, key.m_ns, key.m_uid); |
|
49 } |
|
50 SchedulerList::EventsI |
|
51 SchedulerList::GetIterator (EventId id) |
|
52 { |
|
53 SchedulerList::EventsI i; |
|
54 assert (sizeof (i) <= sizeof (void *)); |
|
55 EventImpl *ev = id.GetEventImpl (); |
|
56 void *internalIterator = ev->GetInternalIterator (); |
|
57 memcpy ((char *)&i, (char *)&(internalIterator), sizeof (void *)); |
|
58 return i; |
|
59 } |
|
60 |
|
61 |
34 |
62 EventId |
35 EventId |
63 SchedulerList::RealInsert (EventImpl *event, Scheduler::EventKey key) |
36 SchedulerList::RealInsert (EventImpl *event, Scheduler::EventKey key) |
64 { |
37 { |
65 Scheduler::EventKeyCompare compare; |
38 Scheduler::EventKeyCompare compare; |
66 for (EventsI i = m_events.begin (); i != m_events.end (); i++) |
39 for (EventsI i = m_events.begin (); i != m_events.end (); i++) |
67 { |
40 { |
68 if (compare (key, i->second)) |
41 if (compare (key, i->second)) |
69 { |
42 { |
70 m_events.insert (i, std::make_pair (event, key)); |
43 m_events.insert (i, std::make_pair (event, key)); |
71 return GetEventId (key, i); |
44 return EventId (event, key.m_ns, key.m_uid); |
72 } |
45 } |
73 } |
46 } |
74 m_events.push_back (std::make_pair (event, key)); |
47 m_events.push_back (std::make_pair (event, key)); |
75 return GetEventId (key, --(m_events.end ())); |
48 return EventId (event, key.m_ns, key.m_uid); |
76 } |
49 } |
77 bool |
50 bool |
78 SchedulerList::RealIsEmpty (void) const |
51 SchedulerList::RealIsEmpty (void) const |
79 { |
52 { |
80 return m_events.empty (); |
53 return m_events.empty (); |
97 } |
70 } |
98 |
71 |
99 EventImpl * |
72 EventImpl * |
100 SchedulerList::RealRemove (EventId id, Scheduler::EventKey *key) |
73 SchedulerList::RealRemove (EventId id, Scheduler::EventKey *key) |
101 { |
74 { |
102 EventsI i = GetIterator (id); |
75 for (EventsI i = m_events.begin (); i != m_events.end (); i++) |
103 *key = i->second; |
76 { |
104 assert (key->m_ns == id.GetNs () && |
77 if (i->second.m_uid == id.GetUid ()) |
105 key->m_uid == id.GetUid ()); |
78 { |
106 EventImpl *ev = i->first; |
79 EventImpl *retval = i->first; |
107 m_events.erase (i); |
80 assert (id.GetEventImpl () == retval); |
108 return ev; |
81 m_events.erase (i); |
|
82 return retval; |
|
83 } |
|
84 } |
|
85 assert (false); |
|
86 return 0; |
109 } |
87 } |
110 |
88 |
111 bool |
89 bool |
112 SchedulerList::RealIsValid (EventId id) |
90 SchedulerList::RealIsValid (EventId id) |
113 { |
91 { |
114 EventsI i = GetIterator (id); |
92 return true; |
115 Scheduler::EventKey key = i->second; |
|
116 return (key.m_ns == id.GetNs () && |
|
117 key.m_uid == id.GetUid ()); |
|
118 |
|
119 } |
93 } |
120 |
94 |
121 }; // namespace ns3 |
95 }; // namespace ns3 |