00001
00019 #ifndef CORBA_Util_h
00020 #define CORBA_Util_h
00021
00022 #include <rtm/RTC.h>
00023 #include <ace/Guard_T.h>
00024 #include <ace/Thread_Mutex.h>
00025 #include <ace/Recursive_Thread_Mutex.h>
00026
00027
00028 typedef ACE_Guard<ACE_Thread_Mutex> Guard;
00029 typedef ACE_Read_Guard<ACE_Thread_Mutex> Read_Guard;
00030 typedef ACE_Write_Guard<ACE_Thread_Mutex> Write_Guard;
00031
00032 typedef ACE_Guard<ACE_Recursive_Thread_Mutex> Guard_r;
00033 typedef ACE_Read_Guard<ACE_Recursive_Thread_Mutex> Read_Guard_r;
00034 typedef ACE_Write_Guard<ACE_Recursive_Thread_Mutex> Write_Guard_r;
00035
00036
00050 namespace CORBA_Sequence_Util
00051 {
00078 template <class CorbaSequence, class Functor>
00079 Functor for_each(const CorbaSequence& seq, Functor f)
00080 {
00081 CORBA::ULong len;
00082 len = seq.length();
00083 for (CORBA::ULong i = 0; i < len; ++i)
00084 {
00085 f(seq[i]);
00086 }
00087 return f;
00088 }
00089
00090
00123 template <class CorbaSequence, class Functor>
00124 CORBA::Long find(const CorbaSequence& seq, Functor f)
00125 {
00126 CORBA::ULong len(seq.length());
00127 for (CORBA::ULong i = 0; i < len; ++i)
00128 {
00129 if (f(seq[i])) return (CORBA::Long)i;
00130 }
00131 return -1;
00132 }
00133
00156 template <class CorbaSequence, class SequenceElement>
00157 void push_back(CorbaSequecne& seq, SequenceElement elem)
00158 {
00159 CORBA::ULong len(seq.length());
00160 seq.length(len + 1);
00161 seq[len] = item;
00162 }
00163
00164
00193 template <class CorbaSequence, class SequenceElement>
00194 void insert(CorbaSequence& seq, SequenceElement& elem, CORBA::ULong index)
00195 {
00196 CORBA::ULong len(seq.length());
00197 if (index > len) push_back(seq, elem);
00198
00199 seq.length(len + 1);
00200 for (CORBA::ULong i = len; i >= index; --i)
00201 {
00202 seq[i + 1] = seq[i];
00203 }
00204 seq[index] = elem;
00205 }
00206
00207
00228 template <class CorbaSequence, class SequenceElement>
00229 SequenceElement& front(CorbaSequence& seq)
00230 {
00231 return seq[0];
00232 }
00233
00234
00255 template <class CorbaSequence, class SequenceElement>
00256 SequenceElement& back(CorbaSequence& seq)
00257 {
00258 return seq[seq.length() - 1];
00259 }
00260
00261
00284 template <class CorbaSequence>
00285 void erase(CorbaSequence& seq, CORBA::ULong index)
00286 {
00287 CORBA::ULong len(seq.length());
00288 if (index > len) return;
00289
00290 for (CORBA::ULong i = index; i < len - 1; ++i)
00291 {
00292 seq[i] = seq[i + 1];
00293 }
00294 seq.length(len - 1);
00295 }
00296
00312 template <class CorbaSequence>
00313 void clear(CorbaSequence& seq)
00314 {
00315 seq.length(0);
00316 }
00317
00318
00319
00320
00321
00322
00323
00324
00332 template <class T>
00333 struct LockedStruct
00334 {
00335 ACE_Thread_Mutex lock;
00336 T data;
00337 };
00338
00367 template <class CorbaSequence, class SequenceItem, class Mutex>
00368 class SequenceEx
00369 : public CorbaSequence
00370 {
00371 public:
00389 SequenceEx(): CorbaSequence(0) {};
00390
00391
00413 SequenceEx(const CorbaSequence& _sq)
00414 : CorbaSequence(0)
00415 {
00416 this->length(_sq.length());
00417 CORBA::ULong len(this->length());
00418 for (CORBA::ULong i = 0; i < len; ++i)
00419 (*this)[i] = _sq[i];
00420 };
00421
00422
00438 SequenceEx(const SequenceEx& _sq)
00439 : CorbaSequence(0)
00440 {
00441 this->length(_sq.length());
00442 CORBA::ULong len(this->length());
00443 for (CORBA::ULong i = 0; i < len; ++i)
00444 (*this)[i] = _sq[i];
00445 };
00446
00447
00467 SequenceEx& operator=(const SequenceEx& _sq)
00468 {
00469 this->length(_sq.length());
00470 CORBA::ULong len(this->length());
00471 for (CORBA::ULong i = 0; i < len; ++i)
00472 (*this)[i] = _sq[i];
00473 return *this;
00474 };
00475
00476
00496 SequenceEx& operator=(const CorbaSequence& _sq)
00497 {
00498 this->length(_sq.length());
00499 CORBA::ULong len(this->length());
00500 for (CORBA::ULong i = 0; i < len; ++i)
00501 (*this)[i] = _sq[i];
00502 return *this;
00503 };
00504
00505
00517 virtual ~SequenceEx()
00518 {
00519 this->length(0);
00520 };
00521
00522
00544 inline CORBA::ULong size() { return this->length(); }
00545
00546
00568 inline CORBA::ULong max_size() { return this->maximum(); }
00569
00570
00593 inline bool empty() { return (this->length() == 0) ? true : false; }
00594
00595
00626 void resize(CORBA::ULong new_size, SequenceItem& item)
00627 {
00628 ACE_Write_Guard<Mutex> gaurd(lock);
00629 CORBA::ULong len(this->length);
00630 if (new_size > len)
00631 {
00632 this->length(new_size);
00633 for (CORBA::ULong i = len; i < new_size; ++i)
00634 (*this)[i] = item;
00635 }
00636 else if (new_size < len)
00637 {
00638 this->length(new_size);
00639 }
00640 }
00641
00642
00666 void insert(CORBA::ULong position, const SequenceItem& item)
00667 {
00668 ACE_Write_Guard<Mutex> gaurd(lock);
00669 CORBA::ULong len(this->length());
00670
00671 if (position > len) throw;
00672
00673
00674 this->length(len + 1);
00675
00676 for (CORBA::ULong i = (len - 1); i > position; --i)
00677 {
00678 (*this)[i] = (*this)[i-1];
00679 }
00680 (*this)[position] = item;
00681 }
00682
00683
00708 SequenceItem erase(CORBA::ULong position)
00709 {
00710 ACE_Write_Guard<Mutex> gaurd(lock);
00711 CORBA::ULong len(this->length());
00712
00713 if (position > (len - 1)) throw;
00714
00715
00716 SequenceItem erased((*this)[position]);
00717
00718 for (CORBA::ULong i = position; i < (len - 1); ++i)
00719 {
00720 (*this)[i] = (*this)[i+1];
00721 }
00722
00723 this->length(len - 1);
00724 return erased;
00725 }
00726
00751 template <class Predicate>
00752 SequenceItem erase_if(Predicate f)
00753 {
00754 ACE_Write_Guard<Mutex> gaurd(lock);
00755 CORBA::ULong len(this->length());
00756 for (CORBA::ULong i = 0; i < len; ++i)
00757 if (f((*this)[i]))
00758 return erase(i);
00759 throw;
00760 }
00761
00762
00784 void push_back(const SequenceItem& item)
00785 {
00786 ACE_Write_Guard<Mutex> gaurd(lock);
00787 CORBA::ULong len(this->length());
00788 this->length(len + 1);
00789 (*this)[len] = item;
00790 }
00791
00809 void pop_back()
00810 {
00811 ACE_Write_Guard<Mutex> gaurd(lock);
00812 CORBA::ULong len(this->length());
00813 this->len(len - 1);
00814 }
00815
00823 template <class F>
00824 SequenceItem find(F f) const
00825 {
00826 ACE_Read_Guard<Mutex> guard(lock);
00827 CORBA::ULong len(this->length());
00828 for (CORBA::ULong i = 0; i < len; ++i)
00829 if (f((*this)[i]))
00830 return (*this)[i];
00831 throw;
00832 }
00833
00841 mutable Mutex lock;
00842 };
00843
00844
00845 };
00846
00847 #endif // CORBA_Util_h