(file) Return to MessageQueue.cpp CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / Common

Diff for /pegasus/src/Pegasus/Common/MessageQueue.cpp between version 1.37 and 1.38

version 1.37, 2003/11/07 19:18:46 version 1.38, 2004/08/12 10:47:43
Line 25 
Line 25 
 // //
 // Author: Mike Brasher (mbrasher@bmc.com) // Author: Mike Brasher (mbrasher@bmc.com)
 // //
 // Modified By:  // Modified By: Amit K Arora, IBM (amita@in.ibm.com) for Bug#1090
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
Line 46 
Line 46 
  
 void MessageQueue::remove_myself(Uint32 qid) void MessageQueue::remove_myself(Uint32 qid)
 { {
    q_table_mut.lock(pegasus_thread_self());     AutoMutex autoMut(q_table_mut);
   
    _queueTable.remove(qid);    _queueTable.remove(qid);
    q_table_mut.unlock();  
 } }
  
  
Line 62 
Line 60 
    //    //
  
    static Mutex _id_mut ;    static Mutex _id_mut ;
    _id_mut.lock(pegasus_thread_self());     AutoMutex autoMut(_id_mut);
  
    Uint32 queueId;    Uint32 queueId;
  
Line 78 
Line 76 
       queueId = _nextQueueId++;       queueId = _nextQueueId++;
    } while (lookup(queueId) != 0);    } while (lookup(queueId) != 0);
  
    //  
    // Unlock mutex:  
    //  
   
    _id_mut.unlock();  
   
    return queueId;    return queueId;
 } }
  
Line 114 
Line 106 
     // Insert into queue table:     // Insert into queue table:
     //     //
  
     q_table_mut.lock(pegasus_thread_self());      AutoMutex autoMut(q_table_mut);
  
     while (!_queueTable.insert(_queueId, this))     while (!_queueTable.insert(_queueId, this))
        ;        ;
  
     q_table_mut.unlock();  
   
   
    PEG_METHOD_EXIT();    PEG_METHOD_EXIT();
 } }
  
Line 134 
Line 123 
     Tracer::trace(TRC_MESSAGEQUEUESERVICE, Tracer::LEVEL3,     Tracer::trace(TRC_MESSAGEQUEUESERVICE, Tracer::LEVEL3,
         "MessageQueue::~MessageQueue queueId = %i, name = %s", _queueId, _name);         "MessageQueue::~MessageQueue queueId = %i, name = %s", _queueId, _name);
  
     q_table_mut.lock(pegasus_thread_self());  
  
       {
         AutoMutex autoMut(q_table_mut);
     _queueTable.remove(_queueId);     _queueTable.remove(_queueId);
     q_table_mut.unlock();      } // mutex unlocks here
  
     // Free the name:     // Free the name:
  
Line 166 
Line 156 
                       MessageTypeToString(message->getType()),                       MessageTypeToString(message->getType()),
                       message->getKey() );                       message->getKey() );
  
     _mut.lock(pegasus_thread_self());      {
       AutoMutex autoMut(_mut);
     if (_back)     if (_back)
     {     {
        _back->_next = message;        _back->_next = message;
Line 187 
Line 178 
     Tracer::trace(TRC_MESSAGEQUEUESERVICE, Tracer::LEVEL4,     Tracer::trace(TRC_MESSAGEQUEUESERVICE, Tracer::LEVEL4,
                   "MessageQueue::enqueue _queueId = %d, _count = %d", _queueId, _count);                   "MessageQueue::enqueue _queueId = %d, _count = %d", _queueId, _count);
  
     _mut.unlock();      } // mutex unlocks here
  
     handleEnqueue();     handleEnqueue();
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
Line 197 
Line 188 
 { {
     PEG_METHOD_ENTER(TRC_MESSAGEQUEUESERVICE,"MessageQueue::dequeue()");     PEG_METHOD_ENTER(TRC_MESSAGEQUEUESERVICE,"MessageQueue::dequeue()");
  
    _mut.lock(pegasus_thread_self());      AutoMutex autoMut(_mut);
     if (_front)     if (_front)
     {     {
         Message* message = _front;         Message* message = _front;
Line 213 
Line 204 
             "MessageQueue::dequeue _queueId = %d, _count = %d",             "MessageQueue::dequeue _queueId = %d, _count = %d",
             _queueId, _count);             _queueId, _count);
  
         _mut.unlock();  
         message->_next = 0;         message->_next = 0;
         message->_prev = 0;         message->_prev = 0;
         message->_owner = 0;         message->_owner = 0;
Line 221 
Line 211 
         PEG_METHOD_EXIT();         PEG_METHOD_EXIT();
         return message;         return message;
     }     }
     _mut.unlock();  
  
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
     return 0;     return 0;
Line 245 
Line 234 
         throw NoSuchMessageOnQueue();         throw NoSuchMessageOnQueue();
     }     }
  
     _mut.lock(pegasus_thread_self());      {
       AutoMutex autoMut(_mut);
  
     if (message->_next)     if (message->_next)
         message->_next->_prev = message->_prev;         message->_next->_prev = message->_prev;
Line 261 
Line 251 
     Tracer::trace(TRC_MESSAGEQUEUESERVICE, Tracer::LEVEL4,     Tracer::trace(TRC_MESSAGEQUEUESERVICE, Tracer::LEVEL4,
        "MessageQueue::remove _count = %d", _count);        "MessageQueue::remove _count = %d", _count);
  
     _mut.unlock();      } // mutex unlocks here
  
     message->_prev = 0;     message->_prev = 0;
     message->_next = 0;     message->_next = 0;
Line 272 
Line 262 
  
 Message* MessageQueue::findByType(Uint32 type) throw(IPCException) Message* MessageQueue::findByType(Uint32 type) throw(IPCException)
 { {
    _mut.lock(pegasus_thread_self());     AutoMutex autoMut(_mut);
  
     for (Message* m = front(); m; m = m->getNext())     for (Message* m = front(); m; m = m->getNext())
     {     {
        if (m->getType() == type)        if (m->getType() == type)
        {        {
           _mut.unlock();  
           return m;           return m;
        }        }
     }     }
     _mut.unlock();  
     return 0;     return 0;
 } }
  
 Message* MessageQueue::findByKey(Uint32 key) throw(IPCException) Message* MessageQueue::findByKey(Uint32 key) throw(IPCException)
 { {
    _mut.lock(pegasus_thread_self());     AutoMutex autoMut(_mut);
  
     for (Message* m = front(); m; m = m->getNext())     for (Message* m = front(); m; m = m->getNext())
     {     {
        if (m->getKey() == key)        if (m->getKey() == key)
        {        {
           _mut.unlock();  
           return m;           return m;
        }        }
  
     }     }
     _mut.unlock();  
     return 0;     return 0;
 } }
  
 void MessageQueue::print(ostream& os) const throw(IPCException) void MessageQueue::print(ostream& os) const throw(IPCException)
 { {
    const_cast<MessageQueue *>(this)->_mut.lock(pegasus_thread_self());     AutoMutex autoMut(const_cast<MessageQueue *>(this)->_mut);
  
    for (const Message* m = front(); m; m = m->getNext())    for (const Message* m = front(); m; m = m->getNext())
         m->print(os);         m->print(os);
    const_cast<MessageQueue *>(this)->_mut.unlock();  
 } }
  
 Message* MessageQueue::find(Uint32 type, Uint32 key) throw(IPCException) Message* MessageQueue::find(Uint32 type, Uint32 key) throw(IPCException)
 { {
    _mut.lock(pegasus_thread_self());     AutoMutex autoMut(_mut);
  
     for (Message* m = front(); m; m = m->getNext())     for (Message* m = front(); m; m = m->getNext())
     {     {
        if (m->getType() == type && m->getKey() == key)        if (m->getType() == type && m->getKey() == key)
        {        {
           _mut.unlock();  
           return m;           return m;
        }        }
     }     }
     _mut.unlock();  
  
     return 0;     return 0;
 } }
Line 348 
Line 331 
 { {
  
     MessageQueue* queue = 0;     MessageQueue* queue = 0;
     q_table_mut.lock(pegasus_thread_self());      AutoMutex autoMut(q_table_mut);
  
     if (_queueTable.lookup(queueId, queue))     if (_queueTable.lookup(queueId, queue))
     {     {
        q_table_mut.unlock();  
        return queue;        return queue;
     }     }
  
     // Not found!     // Not found!
  
     q_table_mut.unlock();  
   
     Tracer::trace(TRC_MESSAGEQUEUESERVICE, Tracer::LEVEL3,     Tracer::trace(TRC_MESSAGEQUEUESERVICE, Tracer::LEVEL3,
         "MessageQueue::lookup failure queueId = %i", queueId);         "MessageQueue::lookup failure queueId = %i", queueId);
  
Line 372 
Line 352 
  
    if(name == NULL)    if(name == NULL)
       throw NullPointer();       throw NullPointer();
    q_table_mut.lock(pegasus_thread_self());     AutoMutex autoMut(q_table_mut);
  
    for(QueueTable::Iterator i = _queueTable.start(); i; i++)    for(QueueTable::Iterator i = _queueTable.start(); i; i++)
    {    {
         // ATTN: Need to decide how many characters to compare in queue names         // ATTN: Need to decide how many characters to compare in queue names
       if(! strcmp( ((MessageQueue *)i.value())->getQueueName(), name) )       if(! strcmp( ((MessageQueue *)i.value())->getQueueName(), name) )
       {       {
          q_table_mut.unlock();  
          return( (MessageQueue *)i.value());          return( (MessageQueue *)i.value());
       }       }
  
    }    }
    q_table_mut.unlock();  
  
    Tracer::trace(TRC_MESSAGEQUEUESERVICE, Tracer::LEVEL3,    Tracer::trace(TRC_MESSAGEQUEUESERVICE, Tracer::LEVEL3,
         "MessageQueue::lookup failure - name = %s", name);         "MessageQueue::lookup failure - name = %s", name);

Legend:
Removed from v.1.37  
changed lines
  Added in v.1.38
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2