CORBA_SeqEx.h

説明を見る。
00001 // -*- C++ -*-
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   // End of CORBA sequence helper functions
00318 
00319 
00320 
00321   //============================================================
00322   // CORBA sequence extention class
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) // Widen sequence
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) // shorten sequence
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       // allowed position: [0, len]
00671       if (position > len) throw; // InvalidParameter("Invalid index");
00672       
00673       // widen sequence
00674       this->length(len + 1);
00675       // shift items
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       // allowed position: [0, len)
00713       if (position > (len - 1)) throw; // InvalidParameter("Invalid index");
00714       
00715       // keep erased item
00716       SequenceItem erased((*this)[position]);
00717       // shift remaining items
00718       for (CORBA::ULong i = position; i < (len - 1); ++i)
00719         {
00720           (*this)[i] = (*this)[i+1];
00721         }
00722       // shorten sequence
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; // InvalidParameter("Not found.");
00832     }
00833 
00841     mutable Mutex lock;
00842   }; // class SequenceEx
00843   
00844   
00845 }; // namespace CORBA_Sequence_Util
00846 
00847 #endif // CORBA_Util_h

OpenRTMに対してThu May 29 15:03:26 2008に生成されました。  doxygen 1.5.3