new home directory
[feisty_meow.git] / nucleus / library / processes / mailbox.cpp
1 /*****************************************************************************\
2 *                                                                             *
3 *  Name   : mailbox                                                           *
4 *  Author : Chris Koeritz                                                     *
5 *                                                                             *
6 *******************************************************************************
7 * Copyright (c) 1998-$now By Author.  This program is free software; you can  *
8 * redistribute it and/or modify it under the terms of the GNU General Public  *
9 * License as published by the Free Software Foundation; either version 2 of   *
10 * the License or (at your option) any later version.  This is online at:      *
11 *     http://www.fsf.org/copyleft/gpl.html                                    *
12 * Please send any updates to: fred@gruntose.com                               *
13 \*****************************************************************************/
14
15 #include "letter.h"
16 #include "mailbox.h"
17
18 #include <basis/astring.h>
19 #include <basis/functions.h>
20 #include <basis/guards.h>
21 #include <basis/mutex.h>
22 #include <loggers/critical_events.h>
23 #include <structures/amorph.h>
24 #include <structures/int_hash.h>
25 #include <structures/unique_id.h>
26 #include <textual/parser_bits.h>
27 #include <textual/string_manipulation.h>
28
29 using namespace basis;
30 using namespace loggers;
31 using namespace structures;
32 using namespace textual;
33
34 namespace processes {
35
36 const int MAILBOX_BITS = 9;
37   // we allow N bits in our table size, which means the table will have 2^N
38   // elements.  careful with that increase...
39
40 class mail_cabinet
41 {
42 public:
43   amorph<letter> _waiting;
44
45   mail_cabinet() : _waiting(0) {}
46
47   ~mail_cabinet() { _waiting.reset(); }
48
49   mail_cabinet(mail_cabinet &formal(to_copy)) {
50     non_continuable_error("mail_cabinet", "copy constructor", "should never be called");
51   }
52
53   mail_cabinet &operator =(mail_cabinet &formal(to_copy)) {
54     non_continuable_error("mail_cabinet", "assignment operator",
55         "should never be called");
56     return *this;
57   }
58 };
59
60 //////////////
61
62 class mailbox_bank : public int_hash<mail_cabinet>
63 {
64 public:
65   mailbox_bank() : int_hash<mail_cabinet> (MAILBOX_BITS) {}
66   ~mailbox_bank() { reset(); }
67
68   void get_ids(int_set &to_fill);
69     // returns the list of identifiers for people with mailboxes.
70
71   void add_cabinet(const unique_int &id);
72     // creates a new mail receptacle for the "id".
73
74   bool zap_cabinet(const unique_int &id);
75     // removes the cabinet for "id".
76
77   void add_item(const unique_int &id, letter *to_add);
78     // stuffs an item "to_add" in for "id".
79
80   bool get(const unique_int &id, letter * &to_receive);
81     // retrieves the next waiting package for "id" into "to_receive".
82
83   void clean_up();
84     // gets rid of any cabinets without any packages.
85 };
86
87 void mailbox_bank::clean_up()
88 {
89   int_set ids;
90   get_ids(ids);
91   for (int i = 0; i < ids.elements(); i++) {
92     mail_cabinet *entry = find(ids[i]);
93     // if the cabinet has zero elements, we zap it.
94     if (!entry->_waiting.elements()) zap(ids[i]);
95   }
96 }
97
98 void mailbox_bank::get_ids(int_set &to_fill) { to_fill = ids(); }
99
100 void mailbox_bank::add_cabinet(const unique_int &id)
101 {
102   if (find(id.raw_id())) return;  // already exists.
103   mail_cabinet *to_add = new mail_cabinet;
104   add(id.raw_id(), to_add);
105 }
106
107 bool mailbox_bank::zap_cabinet(const unique_int &id)
108 {
109   if (!find(id.raw_id())) return false;  // doesn't exist.
110   return zap(id.raw_id());
111 }
112
113 void mailbox_bank::add_item(const unique_int &id, letter *to_add)
114 {
115   mail_cabinet *found = find(id.raw_id());
116   if (!found) {
117     add_cabinet(id);
118     found = find(id.raw_id());
119     // there should never be a failure case that would prevent the new cabinet
120     // from being added (besides overall memory failure).
121     if (!found) {
122 //complain
123       return;
124     }
125   }
126   found->_waiting.append(to_add);
127 }
128
129 bool mailbox_bank::get(const unique_int &id, letter * &to_receive)
130 {
131   mail_cabinet *found = find(id.raw_id());
132   if (!found) return false;  // no cabinet, much less any mail.
133
134   if (!found->_waiting.elements()) return false;  // no mail waiting.
135   for (int i = 0; i < found->_waiting.elements(); i++) {
136     // check if its time is ripe...
137     if (!found->_waiting.borrow(i)->ready_to_send()) continue;
138     // get the waiting mail and remove its old slot.
139     to_receive = found->_waiting.acquire(i);
140     found->_waiting.zap(i, i);
141     return true;
142   }
143   return false;
144 }
145
146 //////////////
147
148 mailbox::mailbox()
149 : _transaction_lock(new mutex),
150   _packages(new mailbox_bank)
151 {
152 }
153
154 mailbox::~mailbox()
155 {
156   WHACK(_packages);
157   WHACK(_transaction_lock);
158 }
159
160 void mailbox::get_ids(int_set &to_fill)
161 {
162   auto_synchronizer l(*_transaction_lock);
163   _packages->get_ids(to_fill);
164 }
165
166 void mailbox::drop_off(const unique_int &id, letter *package)
167 {
168   auto_synchronizer l(*_transaction_lock);
169   _packages->add_item(id, package);
170 }
171
172 void mailbox::clean_up()
173 {
174   auto_synchronizer l(*_transaction_lock);
175   _packages->clean_up();
176 }
177
178 int mailbox::waiting(const unique_int &id) const
179 {
180   auto_synchronizer l(*_transaction_lock);
181   mail_cabinet *found = _packages->find(id.raw_id());
182   int to_return = 0;  // if no cabinet, this is the proper count.
183   // if there is a cabinet, then get the size.
184   if (found)
185     to_return = found->_waiting.elements();
186   return to_return;
187 }
188
189 bool mailbox::pick_up(const unique_int &id, letter * &package)
190 {
191   package = NULL_POINTER;
192   auto_synchronizer l(*_transaction_lock);
193   return _packages->get(id, package);
194 }
195
196 bool mailbox::close_out(const unique_int &id)
197 {
198   auto_synchronizer l(*_transaction_lock);
199   bool ret = _packages->zap_cabinet(id);
200   return ret;
201 }
202
203 void mailbox::show(astring &to_fill)
204 {
205   auto_synchronizer l(*_transaction_lock);
206   int_set ids;
207   _packages->get_ids(ids);
208   for (int i = 0; i < ids.elements(); i++) {
209     mail_cabinet &mc = *_packages->find(ids[i]);
210     to_fill += astring(astring::SPRINTF, "cabinet %d:", ids[i])
211         + parser_bits::platform_eol_to_chars();
212     for (int j = 0; j < mc._waiting.elements(); j++) {
213       letter &l = *mc._waiting.borrow(j);
214       astring text;
215       l.text_form(text);
216       to_fill += string_manipulation::indentation(4)
217           + astring(astring::SPRINTF, "%4ld: ", j + 1)
218           + text + parser_bits::platform_eol_to_chars();
219     }
220   }
221 }
222
223 void mailbox::limit_boxes(int max_letters)
224 {
225   auto_synchronizer l(*_transaction_lock);
226   int_set ids;
227   _packages->get_ids(ids);
228   for (int i = 0; i < ids.elements(); i++) {
229     mail_cabinet &mc = *_packages->find(ids[i]);
230     if (mc._waiting.elements() > max_letters) {
231       // this one needs cleaning.
232       mc._waiting.zap(max_letters, mc._waiting.elements() - 1);
233     }
234   }
235 }
236
237 void mailbox::apply(apply_function *to_apply, void *data_link)
238 {
239   auto_synchronizer l(*_transaction_lock);
240   int_set ids;
241   _packages->get_ids(ids);
242   for (int i = 0; i < ids.elements(); i++) {
243     mail_cabinet &mc = *_packages->find(ids[i]);
244     for (int j = 0; j < mc._waiting.elements(); j++) {
245       letter &l = *mc._waiting.borrow(j);
246       outcome ret = to_apply(l, ids[i], data_link);
247       if ( (ret == APPLY_WHACK) || (ret == APPLY_WHACK_STOP) ) {
248         // they wanted this node removed.
249         mc._waiting.zap(j, j);
250         j--;  // skip back before missing guy so we don't omit anyone.
251         if (ret == APPLY_WHACK_STOP)
252           break;  // they wanted to be done with it also.
253       } else if (ret == APPLY_STOP) {
254         break;  // we hit the exit condition.
255       }
256     }
257   }
258 }
259
260 } //namespace.
261
262