1 mike  1.4 //%/////////////////////////////////////////////////////////////////////////////
  2           //
  3           // Copyright (c) 2000, 2001 The Open group, BMC Software, Tivoli Systems, IBM
  4           //
  5           // Permission is hereby granted, free of charge, to any person obtaining a copy
  6           // of this software and associated documentation files (the "Software"), to 
  7           // deal in the Software without restriction, including without limitation the 
  8           // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or 
  9           // sell copies of the Software, and to permit persons to whom the Software is
 10           // furnished to do so, subject to the following conditions:
 11           // 
 12           // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN 
 13           // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
 14           // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
 15           // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR 
 16           // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT 
 17           // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 
 18           // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 19           // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 20           //
 21           //==============================================================================
 22 mike  1.4 //
 23           // Author: Mike Brasher (mbrasher@bmc.com)
 24           //
 25           // Modified By:
 26           //
 27           //%/////////////////////////////////////////////////////////////////////////////
 28           

 29 mike  1.5 #include <Pegasus/Common/HashTable.h>

 30 mike  1.4 #include "MessageQueue.h"
 31           
 32           PEGASUS_USING_STD;
 33           
 34           PEGASUS_NAMESPACE_BEGIN
 35           

 36 mike  1.5 typedef HashTable<Uint32, MessageQueue*, EqualFunc<Uint32>, HashFunc<Uint32> >
 37               QueueTable;
 38           
 39           static QueueTable _queueTable(128);
 40           
 41           static Uint32 _GetNextQueueId()
 42           {
 43               static Uint32 _queueId = 1;
 44           
 45               // Handle wrap-around!
 46           
 47               if (_queueId == 0)
 48           	_queueId++;
 49               
 50               return _queueId++;
 51           }
 52           
 53           MessageQueue::MessageQueue() : _count(0), _front(0), _back(0)
 54           {
 55               // ATTN-A: thread safety!
 56           
 57 mike  1.5     while (!_queueTable.insert(_queueId = _GetNextQueueId(), this))
 58           	;
 59           }
 60           
 61           MessageQueue::~MessageQueue()
 62           {
 63               // ATTN-A: thread safety!
 64           
 65               _queueTable.remove(_queueId);
 66           }
 67           

 68 mike  1.4 void MessageQueue::enqueue(Message* message)
 69           {
 70               if (!message)
 71           	throw NullPointer();
 72           
 73               if (_back)
 74               {
 75           	_back->_next = message;
 76           	message->_prev = _back;
 77           	message->_next = 0;
 78           	_back = message;
 79               }
 80               else
 81               {
 82           	_front = message;
 83           	_back = message;
 84           	message->_prev = 0;
 85           	message->_next = 0;
 86               }
 87               message->_owner = this;
 88               _count++;
 89 mike  1.4 }
 90           
 91           Message* MessageQueue::dequeue()
 92           {
 93               if (_front)
 94               {
 95           	Message* message = _front;
 96           	_front = _front->_next;
 97           	if (_front)
 98           	    _front->_prev = 0;
 99           
100           	if (_back == message)
101           	    _back = 0;
102           	
103           	message->_next = 0;
104           	message->_prev = 0;
105           	message->_owner = 0;
106           	_count--;
107           	return message;
108               }
109               return 0;
110 mike  1.4 }
111           
112           void MessageQueue::remove(Message* message)
113           {
114               if (!message)
115           	throw NullPointer();
116           
117               if (message->_owner != this)
118           	throw NoSuchMessageOnQueue();
119           
120               if (message->_next)
121           	message->_next->_prev = message->_prev;
122               else
123           	_back = message->_prev;
124           
125               if (message->_prev)
126           	message->_prev->_next = message->_next;
127               else
128           	_front = message->_next;
129           
130               message->_prev = 0;
131 mike  1.4     message->_next = 0;
132               message->_owner = 0;
133               _count--;
134           }
135           
136           Message* MessageQueue::findByType(Uint32 type)
137           {
138               for (Message* m = front(); m; m = m->getNext())
139               {
140           	if (m->getType() == type)
141           	    return m;
142               }
143           
144               return 0;
145           }
146           
147           Message* MessageQueue::findByKey(Uint32 key)
148           {
149               for (Message* m = front(); m; m = m->getNext())
150               {
151           	if (m->getKey() == key)
152 mike  1.4 	    return m;
153               }
154           
155               return 0;
156           }
157           
158           void MessageQueue::print(ostream& os) const
159           {
160               for (const Message* m = front(); m; m = m->getNext())
161           	m->print(os);
162           }
163           
164           Message* MessageQueue::find(Uint32 type, Uint32 key)
165           {
166               for (Message* m = front(); m; m = m->getNext())
167               {
168           	if (m->getType() == type && m->getKey() == key)
169           	    return m;
170               }
171           

172 mike  1.5     return 0;
173           }
174           
175           void MessageQueue::lock()
176           {
177           
178           }
179           
180           void MessageQueue::unlock()
181           {
182           
183           }
184           
185           MessageQueue* MessageQueue::lookup(Uint32 queueId)
186           {
187               MessageQueue* queue = 0;
188           
189               if (_queueTable.lookup(queueId, queue))
190           	return queue;
191           
192               // Not found!

193 mike  1.4     return 0;
194           }
195           
196           PEGASUS_NAMESPACE_END