00001 #include "Platform.h"
00002 #include "Declarations.h"
00003 #include "PacketQueue.h"
00004 #include <assert.h>
00005
00006
00007
00008
00009
00010
00011
00012 CPacketQueue::CPacketQueue() : CLockMechanism()
00013 {
00014 INT32 maxsize = DEFAULT_PACKETQUEUE_SIZE;
00015 m_iQueueMaxSize = maxsize;
00016 m_iLastError = ERR_PQ_NONE;
00017
00018 m_pQueueValue = new VOIDP[maxsize];
00019 m_iQueueNextElement = new INT32[maxsize];
00020
00021 for (INT32 i=0;i<maxsize;i++)
00022 {
00023 m_pQueueValue[i] = NULL;
00024 m_iQueueNextElement[i] = -1;
00025 }
00026
00027 m_iQueueFirstElement = -1;
00028 m_iQueueLastElement = -1;
00029 m_iQueueNumElements = 0;
00030 }
00031
00032
00033
00034
00035
00036
00037 CPacketQueue::~CPacketQueue()
00038 {
00039 delete [] m_pQueueValue;
00040 delete [] m_iQueueNextElement;
00041 }
00042
00043
00044
00045
00046
00047 bool CPacketQueue::setQueueMaxsize( INT32 maxsize )
00048 {
00049 UINT32 drop_lasterr;
00050
00051 return setQueueMaxsize(maxsize, drop_lasterr);
00052 }
00053
00054 bool CPacketQueue::pop_front( CMessage **obj )
00055 {
00056 UINT32 drop_lasterr;
00057
00058 return pop_front(obj, drop_lasterr);
00059 }
00060
00061 bool CPacketQueue::push_back( const CMessage* obj)
00062 {
00063 UINT32 drop_lasterr;
00064
00065 return push_back(obj, drop_lasterr);
00066 }
00067
00068 bool CPacketQueue::remove_elem( UINT16 requestid)
00069 {
00070 UINT32 drop_lasterr;
00071
00072 return remove_elem(requestid, drop_lasterr);
00073 }
00074
00075 bool CPacketQueue::find_elem( UINT16 requestid, CMessage ** obj)
00076 {
00077 UINT32 drop_lasterr;
00078
00079 return find_elem(requestid, obj, drop_lasterr);
00080 }
00081
00082 bool CPacketQueue::find_and_remove_elem( UINT16 requestid, CMessage **obj)
00083 {
00084 UINT32 drop_lasterr;
00085
00086 return find_and_remove_elem(requestid, obj, drop_lasterr);
00087 }
00088
00089 bool CPacketQueue::find_elem_ack_and_signal( const CMessage &aAckPacket)
00090 {
00091 UINT32 drop_lasterr;
00092
00093 return find_elem_ack_and_signal( aAckPacket, drop_lasterr);
00094 }
00095
00096 bool CPacketQueue::find_and_remove_passed_elem( CMessage *obj)
00097 {
00098 UINT32 drop_lasterr;
00099
00100 return find_and_remove_passed_elem( obj, drop_lasterr);
00101 }
00102
00103
00104
00105
00106
00107
00122 bool CPacketQueue::setQueueMaxsize( INT32 maxsize, UINT32 &lasterr )
00123 {
00124 if (!lock())
00125 {
00126 m_iLastError = lasterr = ERR_PQ_LOCK;
00127 return false;
00128 }
00129
00130 delete [] m_pQueueValue;
00131 delete [] m_iQueueNextElement;
00132
00133 m_iQueueMaxSize = maxsize;
00134 m_pQueueValue = new VOIDP[maxsize];
00135 m_iQueueNextElement = new INT32[maxsize];
00136
00137 for (INT32 i=0;i<maxsize;i++)
00138 {
00139 m_pQueueValue[i] = NULL;
00140 m_iQueueNextElement[i] = -1;
00141 }
00142
00143 m_iQueueFirstElement = -1;
00144 m_iQueueLastElement = -1;
00145 m_iQueueNumElements = 0;
00146
00147 unlock();
00148
00149 m_iLastError = lasterr = ERR_PQ_NONE;
00150 return true;
00151 }
00152
00153
00154
00155
00156
00175 bool CPacketQueue::pop_front( CMessage **obj, UINT32 &lasterr )
00176 {
00177 bool retval = false;
00178
00179 if (obj == NULL)
00180 {
00181 m_iLastError = lasterr = ERR_PQ_BADPARAM;
00182 return false;
00183 }
00184
00185 if (!lock())
00186 {
00187 m_iLastError = lasterr = ERR_PQ_LOCK;
00188 return false;
00189 }
00190
00191 if (m_iQueueNumElements != 0)
00192 {
00193 INT32 removeidx = m_iQueueFirstElement;
00194
00195 *obj = (CMessage *) m_pQueueValue[removeidx];
00196
00197 m_pQueueValue[removeidx] = NULL;
00198 m_iQueueFirstElement = m_iQueueNextElement[removeidx];
00199 m_iQueueNumElements--;
00200
00201 if (m_iQueueNumElements == 0)
00202 {
00203 assert( m_iQueueFirstElement == -1 );
00204 m_iQueueLastElement = -1;
00205 }
00206
00207 retval = true;
00208 }
00209
00210 unlock();
00211
00212 m_iLastError = lasterr = ERR_PQ_NONE;
00213 return retval;
00214 }
00215
00216
00217
00218
00237 bool CPacketQueue::push_back ( const CMessage *obj, UINT32 &lasterr )
00238 {
00239 bool retval = false;
00240
00241 if (obj == NULL)
00242 {
00243 m_iLastError = lasterr = ERR_PQ_BADPARAM;
00244 return false;
00245 }
00246
00247 if (!lock())
00248 {
00249 m_iLastError = lasterr = ERR_PQ_LOCK;
00250 return false;
00251 }
00252
00253
00254 if (m_iQueueNumElements >= m_iQueueMaxSize)
00255 {
00256 assert( m_iQueueNumElements == m_iQueueMaxSize );
00257 m_iLastError = lasterr = ERR_PQ_FULL;
00258 }
00259 else
00260 {
00261 INT32 free_index = -1;
00262
00263 for (INT32 cur=0;cur<m_iQueueMaxSize;cur++)
00264 {
00265 if (m_pQueueValue[cur] == NULL)
00266 {
00267 free_index = cur;
00268 break;
00269 }
00270 }
00271
00272 assert( free_index != -1 );
00273
00274 if (m_iQueueLastElement == -1)
00275 {
00276
00277 m_iQueueFirstElement = free_index;
00278 m_iQueueLastElement = free_index;
00279 assert( m_pQueueValue[free_index] == NULL );
00280 m_pQueueValue[free_index] = (VOIDP) obj;
00281 m_iQueueNextElement[free_index] = -1;
00282 m_iQueueNumElements++;
00283 }
00284 else
00285 {
00286 m_iQueueNextElement[m_iQueueLastElement] = free_index;
00287 assert( m_pQueueValue[free_index] == NULL );
00288 m_pQueueValue[free_index] = (VOIDP) obj;
00289 m_iQueueNextElement[free_index] = -1;
00290 m_iQueueLastElement = free_index;
00291 m_iQueueNumElements++;
00292 }
00293
00294 m_iLastError = lasterr = ERR_PQ_NONE;
00295 retval = true;
00296 }
00297
00298 unlock();
00299
00300 return retval;
00301 }
00302
00303
00304
00305
00325 bool CPacketQueue::remove_elem( UINT16 requestid, UINT32 &lasterr )
00326 {
00327 if (!lock())
00328 {
00329 m_iLastError = lasterr = ERR_PQ_LOCK;
00330 return false;
00331 }
00332
00333 INT32 found_index = m_iQueueFirstElement;
00334 INT32 last_index = -1;
00335 bool del = false;
00336 bool retval = false;
00337
00338 while( found_index != -1)
00339 {
00340 CMessage *obj = (CMessage *) m_pQueueValue[found_index];
00341
00342 if (obj->internalRequestID == requestid)
00343 {
00344 if (last_index == -1)
00345 {
00346 INT32 removeidx = m_iQueueFirstElement;
00347
00348 m_pQueueValue[removeidx] = NULL;
00349 m_iQueueFirstElement = m_iQueueNextElement[removeidx];
00350 m_iQueueNumElements--;
00351
00352 if (m_iQueueNumElements == 0)
00353 {
00354 assert( m_iQueueFirstElement == -1 );
00355 m_iQueueLastElement = -1;
00356 }
00357
00358 del = true;
00359 }
00360 else
00361 {
00362 INT32 removeidx = found_index;
00363
00364 m_pQueueValue[removeidx] = NULL;
00365 m_iQueueNextElement[last_index] = m_iQueueNextElement[removeidx];
00366 m_iQueueNumElements--;
00367
00368 if (m_iQueueNextElement[last_index] == -1)
00369 {
00370 m_iQueueLastElement = last_index;
00371 }
00372
00373 del = true;
00374
00375 }
00376 }
00377
00378 if (del == true) break;
00379
00380 last_index = found_index;
00381 found_index = m_iQueueNextElement[found_index];
00382 }
00383
00384 if (del == true)
00385 {
00386 retval = true;
00387 m_iLastError = lasterr = ERR_PQ_NONE;
00388 }
00389 else m_iLastError = lasterr = ERR_PQ_NOTFOUND;
00390
00391 unlock();
00392
00393 return retval;
00394 }
00395
00396
00397
00398
00399
00400
00401
00402
00403
00404
00405
00406
00407
00426 bool CPacketQueue::find_elem( UINT16 requestid, CMessage **obj, UINT32 &lasterr )
00427 {
00428 if (obj == NULL)
00429 {
00430 m_iLastError = lasterr = ERR_PQ_BADPARAM;
00431 return false;
00432 }
00433
00434 if (!lock())
00435 {
00436 m_iLastError = lasterr = ERR_PQ_LOCK;
00437 return false;
00438 }
00439
00440 INT32 it = m_iQueueFirstElement;
00441 bool retval = false;
00442
00443 m_iLastError = lasterr = ERR_PQ_NOTFOUND;
00444
00445 if (m_iQueueNumElements > 0)
00446 {
00447 while( it != -1)
00448 {
00449 CMessage *intobj = (CMessage *) m_pQueueValue[it];
00450 if (intobj->internalRequestID == requestid)
00451 {
00452 *obj = intobj;
00453 retval = true;
00454 m_iLastError = lasterr = ERR_PQ_NONE;
00455 break;
00456 }
00457
00458 it = m_iQueueNextElement[it];
00459 }
00460 }
00461
00462 unlock();
00463
00464 return retval;
00465 }
00466
00467
00468
00469
00493 bool CPacketQueue::find_elem_ack_and_signal( const CMessage &ack_packet, UINT32 &lasterr )
00494 {
00495 if (ack_packet.isAckPacket() == false)
00496 {
00497 m_iLastError = lasterr = ERR_PQ_BADPARAM;
00498 return false;
00499 }
00500
00501 if (!lock())
00502 {
00503 m_iLastError = lasterr = ERR_PQ_LOCK;
00504 return false;
00505 }
00506
00507 INT32 it = m_iQueueFirstElement;
00508 bool retval = false;
00509
00510 m_iLastError = lasterr = ERR_PQ_NOTFOUND;
00511
00512 if (m_iQueueNumElements > 0)
00513 {
00514 while( it != -1)
00515 {
00516 CMessage *intobj = (CMessage *) m_pQueueValue[it];
00517 if (intobj->matchAckPacket( ack_packet ) == true )
00518 {
00519 bool signalAckSemaphoreSuccessful = platformSignalSemaphore( intobj->notifySemaphoreOnReceiveAck );
00520 assert( signalAckSemaphoreSuccessful == true );
00521 signalAckSemaphoreSuccessful=signalAckSemaphoreSuccessful;
00522
00523 retval = true;
00524 m_iLastError = lasterr = ERR_PQ_NONE;
00525 break;
00526 }
00527
00528 it = m_iQueueNextElement[it];
00529 }
00530 }
00531
00532 unlock();
00533
00534 return retval;
00535 }
00536
00537
00538
00539
00540
00562 bool CPacketQueue::find_and_remove_passed_elem( CMessage *obj, UINT32 &lasterr )
00563 {
00564 if (obj == NULL)
00565 {
00566 m_iLastError = lasterr = ERR_PQ_BADPARAM;
00567 return false;
00568 }
00569
00570 if (!lock())
00571 {
00572 m_iLastError = lasterr = ERR_PQ_LOCK;
00573 return false;
00574 }
00575
00576 INT32 found_index = m_iQueueFirstElement;
00577 INT32 last_index = -1;
00578 bool del = false;
00579 bool retval = false;
00580
00581 while( found_index != -1)
00582 {
00583 CMessage *intobj = (CMessage *) m_pQueueValue[found_index];
00584
00585 if (intobj == obj)
00586 {
00587 if (last_index == -1)
00588 {
00589 INT32 removeidx = m_iQueueFirstElement;
00590
00591 m_pQueueValue[removeidx] = NULL;
00592 m_iQueueFirstElement = m_iQueueNextElement[removeidx];
00593 m_iQueueNumElements--;
00594
00595 if (m_iQueueNumElements == 0)
00596 {
00597 assert( m_iQueueFirstElement == -1 );
00598 m_iQueueLastElement = -1;
00599 }
00600
00601 del = true;
00602 }
00603 else
00604 {
00605 INT32 removeidx = found_index;
00606
00607 m_pQueueValue[removeidx] = NULL;
00608 m_iQueueNextElement[last_index] = m_iQueueNextElement[removeidx];
00609 m_iQueueNumElements--;
00610
00611 if (m_iQueueNextElement[last_index] == -1)
00612 {
00613 m_iQueueLastElement = last_index;
00614 }
00615
00616 del = true;
00617
00618 }
00619 }
00620
00621 if (del == true) break;
00622
00623 last_index = found_index;
00624 found_index = m_iQueueNextElement[found_index];
00625 }
00626
00627 if (del == true)
00628 {
00629 retval = true;
00630 m_iLastError = lasterr = ERR_PQ_NONE;
00631 }
00632 else m_iLastError = lasterr = ERR_PQ_NOTFOUND;
00633
00634 unlock();
00635
00636 return retval;
00637
00638 }
00639
00640
00641
00642
00664 bool CPacketQueue::find_and_remove_elem( UINT16 requestid, CMessage **obj, UINT32 &lasterr )
00665 {
00666 if (obj == NULL)
00667 {
00668 m_iLastError = lasterr = ERR_PQ_BADPARAM;
00669 return false;
00670 }
00671
00672 if (!lock())
00673 {
00674 m_iLastError = lasterr = ERR_PQ_LOCK;
00675 return false;
00676 }
00677
00678 INT32 found_index = m_iQueueFirstElement;
00679 INT32 last_index = -1;
00680 bool del = false;
00681 bool retval = false;
00682
00683 while( found_index != -1)
00684 {
00685 CMessage *intobj = (CMessage *) m_pQueueValue[found_index];
00686
00687 if (intobj->internalRequestID == requestid)
00688 {
00689 if (last_index == -1)
00690 {
00691 INT32 removeidx = m_iQueueFirstElement;
00692 *obj = intobj;
00693 m_pQueueValue[removeidx] = NULL;
00694 m_iQueueFirstElement = m_iQueueNextElement[removeidx];
00695 m_iQueueNumElements--;
00696
00697 if (m_iQueueNumElements == 0)
00698 {
00699 assert( m_iQueueFirstElement == -1 );
00700 m_iQueueLastElement = -1;
00701 }
00702
00703 del = true;
00704 }
00705 else
00706 {
00707 INT32 removeidx = found_index;
00708
00709 *obj = intobj;
00710 m_pQueueValue[removeidx] = NULL;
00711 m_iQueueNextElement[last_index] = m_iQueueNextElement[removeidx];
00712 m_iQueueNumElements--;
00713
00714 if (m_iQueueNextElement[last_index] == -1)
00715 {
00716 m_iQueueLastElement = last_index;
00717 }
00718
00719 del = true;
00720
00721 }
00722 }
00723
00724 if (del == true) break;
00725
00726 last_index = found_index;
00727 found_index = m_iQueueNextElement[found_index];
00728 }
00729
00730 if (del == true)
00731 {
00732 retval = true;
00733 m_iLastError = lasterr = ERR_PQ_NONE;
00734 }
00735 else m_iLastError = lasterr = ERR_PQ_NOTFOUND;
00736
00737 unlock();
00738
00739 return retval;
00740
00741 }
00742
00743
00744
00745
00746
00754 int CPacketQueue::size()
00755 {
00756 return (m_iQueueNumElements);
00757 }
00758
00766 UINT32 CPacketQueue::getLastError()
00767 {
00768
00769 return( m_iLastError );
00770 }