openrtm_aist_python: RingBuffer.py Source File

Go to the documentation of this file.
00001 #!/usr/bin/env python
00002 # -*- coding: euc-jp -*-
00003 
00004 ##
00005 # @file RingBuffer.py
00006 # @brief Defautl Buffer class
00007 # @date $Date: 2007/09/12 $
00008 # @author Noriaki Ando <n-ando@aist.go.jp> and Shinji Kurihara
00009 #
00010 # Copyright (C) 2006-2008
00011 #     Noriaki Ando
00012 #     Task-intelligence Research Group,
00013 #     Intelligent Systems Research Institute,
00014 #     National Institute of
00015 #         Advanced Industrial Science and Technology (AIST), Japan
00016 #     All rights reserved.
00017 
00018 import threading
00019 import OpenRTM_aist
00020 
00021 
00022 ##
00023 # @if jp
00024 # @class RingBuffer
00025 # @brief リングバッファ実装クラス
00026 # 
00027 # 指定した長さのリング状バッファを持つバッファ実装クラス。
00028 # バッファ全体にデータが格納された場合、以降のデータは古いデータから
00029 # 順次上書きされる。
00030 # 従って、バッファ内には直近のバッファ長分のデータのみ保持される。
00031 #
00032 # 注)現在の実装では、一番最後に格納したデータのみバッファから読み出し可能
00033 #
00034 # @param DataType バッファに格納するデータ型
00035 #
00036 # @since 0.4.0
00037 #
00038 # @else
00039 #
00040 # @endif
00041 class RingBuffer(OpenRTM_aist.BufferBase):
00042   """
00043   """
00044 
00045   RINGBUFFER_DEFAULT_LENGTH = 8
00046 
00047   ##
00048   # @if jp
00049   #
00050   # @brief コンストラクタ
00051   # 
00052   # コンストラクタ
00053   # 指定されたバッファ長でバッファを初期化する。
00054   #
00055   # @param length バッファ長
00056   # 
00057   # @else
00058   #
00059   # @brief Constructor
00060   # 
00061   # Constructor.
00062   # Initialize the buffer by specified buffer length.
00063   # However, if the specified length is less than two, the buffer should
00064   # be initialized by two in length.
00065   #
00066   # @param length Buffer length
00067   # 
00068   # @endif
00069   #
00070   # @endif
00071   def __init__(self, length=RINGBUFFER_DEFAULT_LENGTH):
00072     self._overwrite = True
00073     self._readback = True
00074     self._timedwrite = False
00075     self._timedread  = False
00076     self._wtimeout = OpenRTM_aist.TimeValue(1,0)
00077     self._rtimeout = OpenRTM_aist.TimeValue(1,0)
00078     self._length   = length
00079     self._wpos = 0
00080     self._rpos = 0
00081     self._fillcount = 0
00082     self._wcount = 0
00083     self._buffer = [None for i in range(self._length)]
00084     self._pos_mutex = threading.RLock()
00085     self._full_mutex = threading.RLock()
00086     self._empty_mutex = threading.RLock()
00087     self._full_cond = threading.Condition(self._full_mutex)
00088     self._empty_cond = threading.Condition(self._empty_mutex)
00089 
00090 
00091     self.reset()
00092 
00093 
00094   ##
00095   # @if jp
00096   # @brief バッファの設定
00097   #
00098   # Properties で与えられるプロパティにより、
00099   # バッファの設定を初期化する。
00100   # 使用できるオプションと意味は以下の通り
00101   #
00102   # - buffer.length:
00103   #     バッファの長さ。自然数以外の数値が指定されても無視される。す
00104   #     でにバッファが使用状態でも、長さが再設定されたのち、すべての
00105   #     ポインタが初期化される。
00106   #
00107   # - buffer.write.full_policy:
00108   #     上書きするかどうかのポリシー。
00109   #     overwrite (上書き), do_nothing (何もしない), block (ブロックする)
00110   #     block を指定した場合、次の timeout 値を指定すれば、指定時間後
00111   #     書き込み不可能であればタイムアウトする。
00112   #     デフォルトは  overwrite (上書き)。
00113   #
00114   # - buffer.write.timeout:
00115   #     タイムアウト時間を [sec] で指定する。デフォルトは 1.0 [sec]。
00116   #     1 sec -> 1.0, 1 ms -> 0.001, タイムアウトしない -> 0.0
00117   #
00118   # - buffer.read.empty_policy:
00119   #     バッファが空のときの読み出しポリシー。
00120   #     readback (最後の要素), do_nothing (何もしない), block (ブロックする)
00121   #     block を指定した場合、次の timeout 値を指定すれば、指定時間後
00122   #     読み出し不可能であればタイムアウトする。
00123   #     デフォルトは readback (最後の要素)。
00124   #
00125   # - buffer.read.timeout:
00126   #     タイムアウト時間 [sec] で指定する。デフォルトは 1.0 [sec]。
00127   #     1sec -> 1.0, 1ms -> 0.001, タイムアウトしない -> 0.0
00128   #
00129   # @else
00130   #
00131   # @endif
00132   #
00133   # void init(const coil::Properties& prop)
00134   def init(self, prop):
00135     self.__initLength(prop)
00136     self.__initWritePolicy(prop)
00137     self.__initReadPolicy(prop)
00138 
00139 
00140   ##
00141   # @if jp
00142   #
00143   # @brief バッファ長を取得する
00144   # 
00145   # バッファ長を取得する。
00146   #
00147   # @param self
00148   # 
00149   # @return バッファ長
00150   # 
00151   # @else
00152   #
00153   # @brief Get the buffer length
00154   #
00155   # @endif
00156   #
00157   # size_t length(void) const
00158   def length(self, n = None):
00159     if n is None:
00160       guard = OpenRTM_aist.ScopedLock(self._pos_mutex)
00161       return self._length
00162 
00163     if n < 1:
00164       return OpenRTM_aist.BufferStatus.NOT_SUPPORTED
00165 
00166     self._buffer = [None for i in range(n)]
00167     self._length = n
00168     self.reset()
00169     return OpenRTM_aist.BufferStatus.BUFFER_OK
00170 
00171   
00172   ##
00173   # @if jp
00174   #
00175   # @brief バッファの状態をリセットする
00176   # 
00177   # バッファの読み出しポインタと書き込みポインタの位置をリセットする。
00178   # この実装では BUFFER_OK しか返さない。
00179   # 
00180   # @return BUFFER_OK: 正常終了
00181   #         NOT_SUPPORTED: リセット不可能
00182   #         BUFFER_ERROR: 異常終了
00183   # 
00184   # @else
00185   #
00186   # @brief Get the buffer length
00187   #
00188   # Pure virtual function to get the buffer length.
00189   #
00190   # @return buffer length
00191   # 
00192   # @endif
00193   # 
00194   # ReturnCode reset()
00195   def reset(self):
00196     guard = OpenRTM_aist.ScopedLock(self._pos_mutex)
00197     self._fillcount = 0
00198     self._wcount = 0
00199     self._wpos = 0
00200     self._rpos = 0
00201     return OpenRTM_aist.BufferStatus.BUFFER_OK
00202 
00203 
00204   ##
00205   # @if jp
00206   #
00207   # @brief バッファの現在の書込み要素のポインタ
00208   # 
00209   # バッファの現在の書込み要素のポインタまたは、n個先のポインタを返す
00210   # 
00211   # @param  n 書込みポインタ + n の位置のポインタ 
00212   # @return 書込み位置のポインタ
00213   # 
00214   # @else
00215   #
00216   # @brief Get the buffer length
00217   #
00218   # Pure virtual function to get the buffer length.
00219   #
00220   # @return buffer length
00221   # 
00222   # @endif
00223   # 
00224   # DataType* wptr(long int n = 0) 
00225   def wptr(self, n = 0):
00226     guard = OpenRTM_aist.ScopedLock(self._pos_mutex)
00227     return self._buffer[(self._wpos + n + self._length) % self._length]
00228 
00229     
00230   ##
00231   # @if jp
00232   #
00233   # @brief 書込みポインタを進める
00234   # 
00235   # 現在の書き込み位置のポインタを n 個進める。
00236   # 書き込み可能な要素数以上の数値を指定した場合、PRECONDITION_NOT_MET
00237   # を返す。
00238   # 
00239   # @param  n 書込みポインタ + n の位置のポインタ 
00240   # @return BUFFER_OK:            正常終了
00241   #         PRECONDITION_NOT_MET: n > writable()
00242   # 
00243   # @else
00244   #
00245   # @brief Get the buffer length
00246   #
00247   # Pure virtual function to get the buffer length.
00248   #
00249   # @return buffer length
00250   # 
00251   # @endif
00252   # 
00253   # ReturnCode advanceWptr(long int n = 1)
00254   def advanceWptr(self, n = 1):
00255     # n > 0 :
00256     #     n satisfies n <= writable elements
00257     #                 n <= m_length - m_fillcout
00258     # n < 0 : -n = n'
00259     #     n satisfies n'<= readable elements
00260     #                 n'<= m_fillcount
00261     #                 n >= - m_fillcount
00262     guard = OpenRTM_aist.ScopedLock(self._pos_mutex)
00263     if (n > 0 and n > (self._length - self._fillcount)) or \
00264           (n < 0 and n < (-self._fillcount)):
00265       return OpenRTM_aist.BufferStatus.PRECONDITION_NOT_MET
00266 
00267     self._wpos = (self._wpos + n + self._length) % self._length
00268     self._fillcount += n
00269     return OpenRTM_aist.BufferStatus.BUFFER_OK
00270 
00271 
00272   ##
00273   # @if jp
00274   #
00275   # @brief バッファにデータを書き込む
00276   # 
00277   # バッファにデータを書き込む。書き込みポインタの位置は変更されない。
00278   # この実装では常に BUFFER_OK を返す。
00279   # 
00280   # @param value 書き込み対象データ
00281   #
00282   # @return BUFFER_OK: 正常終了
00283   #         BUFFER_ERROR: 異常終了
00284   # 
00285   # @else
00286   #
00287   # @brief Write data into the buffer
00288   #
00289   # Pure virtual function to write data into the buffer.
00290 
00291   #
00292   # @param value Target data to write.
00293   #
00294   # @return BUFFER_OK:    Successful
00295   #         BUFFER_ERROR: Failed
00296   #
00297   # @endif
00298   #
00299   # ReturnCode put(const DataType& value)
00300   def put(self, value):
00301     guard = OpenRTM_aist.ScopedLock(self._pos_mutex)
00302     self._buffer[self._wpos] = value
00303     return OpenRTM_aist.BufferStatus.BUFFER_OK
00304     
00305   ##
00306   # @if jp
00307   #
00308   # @brief バッファに書き込む
00309   # 
00310   # 引数で与えられたデータをバッファに書き込む。
00311   #
00312   # 第2引数(sec)、第3引数(nsec)が指定されていない場合、バッファフル
00313   # 時の書込みモード (overwrite, do_nothing, block) は init() で設定
00314   # されたモードに従う。
00315   #
00316   # 第2引数(sec) に引数が指定された場合は、init() で設定されたモード
00317   # に関わらず、block モードとなり、バッファがフル状態であれば指定時
00318   # 間まち、タイムアウトする。第3引数(nsec)は指定されない場合0として
00319   # 扱われる。タイムアウト待ち中に、読み出しスレッド側でバッファから
00320   # 読み出せば、ブロッキングは解除されデータが書き込まれる。
00321   #
00322   # 書き込み時にバッファが空(empty)状態で、別のスレッドがblockモード
00323   # で読み出し待ちをしている場合、signalを発行して読み出し側のブロッ
00324   # キングが解除される。
00325   # 
00326   # @param value 書き込み対象データ
00327   # @param sec   タイムアウト時間 sec  (default -1: 無効)
00328   # @param nsec  タイムアウト時間 nsec (default 0)
00329   # @return BUFFER_OK            正常終了
00330   #         BUFFER_FULL          バッファがフル状態
00331   #         TIMEOUT              書込みがタイムアウトした
00332   #         PRECONDITION_NOT_MET 設定異常
00333   # 
00334   # @else
00335   #
00336   # @brief Write data into the buffer
00337   # 
00338   # Write data which is given argument into the buffer.
00339   #
00340   # @param value Target data for writing
00341   #
00342   # @return Writing result (Always true: writing success is returned)
00343   # 
00344   # @endif
00345   # 
00346   # ReturnCode write(const DataType& value,
00347   #                  long int sec = -1, long int nsec = 0)
00348   def write(self, value, sec = -1, nsec = 0):
00349     try:
00350       self._full_cond.acquire()
00351       if self.full():
00352         timedwrite = self._timedwrite # default is False
00353         overwrite  = self._overwrite  # default is True
00354 
00355         if not (sec < 0): # if second arg is set -> block mode
00356           timedwrite = True
00357           overwrite  = False
00358 
00359         if overwrite and not timedwrite:       # "overwrite" mode
00360           self.advanceRptr()
00361 
00362         elif not overwrite and not timedwrite: # "do_nothiong" mode
00363           self._full_cond.release()
00364           return OpenRTM_aist.BufferStatus.BUFFER_FULL
00365 
00366         elif not overwrite and timedwrite:     # "block" mode
00367 
00368           if sec < 0:
00369             sec = self._wtimeout.sec()
00370             nsec = self._wtimeout.usec() * 1000
00371 
00372           # true: signaled, false: timeout
00373           if not self._full_cond.wait(sec + (nsec/1000000000.0)):
00374             self._full_cond.release()
00375             return OpenRTM_aist.BufferStatus.TIMEOUT
00376 
00377         else: # unknown condition
00378           self._full_cond.release()
00379           return OpenRTM_aist.BufferStatus.PRECONDITION_NOT_MET
00380       
00381       self._full_cond.release()
00382 
00383       self.put(value)
00384       
00385       self._empty_cond.acquire()
00386       empty = self.empty()
00387       if empty:
00388         self.advanceWptr(1)
00389         self._empty_cond.notify()
00390       else:
00391         self.advanceWptr(1)
00392       self._empty_cond.release()
00393 
00394       return OpenRTM_aist.BufferStatus.BUFFER_OK
00395     except:
00396       return OpenRTM_aist.BufferStatus.BUFFER_OK
00397 
00398     
00399   ##
00400   # @if jp
00401   #
00402   # @brief バッファに書込み可能な要素数
00403   # 
00404   # バッファに書込み可能な要素数を返す。
00405   # 
00406   # @return 書き込み可能な要素数
00407   # 
00408   # @else
00409   #
00410   # @brief Write data into the buffer
00411   #
00412   # Pure virtual function to write data into the buffer.
00413   #
00414   # @param value Target data to write.
00415   #
00416   # @return Result of having written in data (true:Successful, false:Failed)
00417   #
00418   # @endif
00419   #
00420   # size_t writable() const
00421   def writable(self):
00422     guard = OpenRTM_aist.ScopedLock(self._pos_mutex)
00423     return self._length - self._fillcount
00424     
00425 
00426   ##
00427   # @if jp
00428   #
00429   # @brief バッファfullチェック
00430   # 
00431   # バッファfullチェック用純粋仮想関数
00432   #
00433   # @return fullチェック結果(true:バッファfull，false:バッファ空きあり)
00434   # 
00435   # @else
00436   #
00437   # @brief Check on whether the buffer is full.
00438   #
00439   # Pure virtual function to check on whether the buffer is full.
00440   #
00441   # @return True if the buffer is full, else false.
00442   #
00443   # @endif
00444   #
00445   # bool full(void) const
00446   def full(self):
00447     guard = OpenRTM_aist.ScopedLock(self._pos_mutex)
00448     return self._length == self._fillcount
00449     
00450 
00451   ##
00452   # @if jp
00453   #
00454   # @brief バッファの現在の読み出し要素のポインタ
00455   # 
00456   # バッファの現在の読み出し要素のポインタまたは、n個先のポインタを返す
00457   # 
00458   # @param  n 読み出しポインタ + n の位置のポインタ 
00459   # @return 読み出し位置のポインタ
00460   # 
00461   # @else
00462   #
00463   # @brief Get the buffer length
00464   #
00465   # Pure virtual function to get the buffer length.
00466   #
00467   # @return buffer length
00468   # 
00469   # @endif
00470   def rptr(self, n = 0):
00471     guard = OpenRTM_aist.ScopedLock(self._pos_mutex)
00472     return self._buffer[(self._rpos + n + self._length) % self._length]
00473 
00474     
00475   ##
00476   # @if jp
00477   #
00478   # @brief 読み出しポインタを進める
00479   # 
00480   # 現在の読み出し位置のポインタを n 個進める。
00481   # 
00482   # @param  n 読み出しポインタ + n の位置のポインタ 
00483   # @return BUFFER_OK: 正常終了
00484   #         BUFFER_ERROR: 異常終了
00485   # 
00486   # @else
00487   #
00488   # @brief Get the buffer length
00489   #
00490   # Pure virtual function to get the buffer length.
00491   #
00492   # @return buffer length
00493   # 
00494   # @endif
00495   # 
00496   # DataType* rptr(long int n = 0)
00497   def advanceRptr(self, n = 1):
00498     # n > 0 :
00499     #     n satisfies n <= readable elements
00500     #                 n <= m_fillcout 
00501     # n < 0 : -n = n'
00502     #     n satisfies n'<= m_length - m_fillcount
00503     #                 n >= m_fillcount - m_length
00504     guard = OpenRTM_aist.ScopedLock(self._pos_mutex)
00505     if (n > 0 and n > self._fillcount) or \
00506           (n < 0 and n < (self._fillcount - self._length)):
00507       return OpenRTM_aist.BufferStatus.PRECONDITION_NOT_MET
00508 
00509     self._rpos = (self._rpos + n + self._length) % self._length
00510     self._fillcount -= n
00511     return OpenRTM_aist.BufferStatus.BUFFER_OK
00512 
00513 
00514     
00515   ##
00516   # @if jp
00517   #
00518   # @brief バッファからデータを読み出す
00519   # 
00520   # バッファからデータを読みだす。読み出しポインタの位置は変更されない。
00521   # 
00522   # @param value 読み出しデータ
00523   #
00524   # @return BUFFER_OK: 正常終了
00525   #         BUFFER_ERROR: 異常終了
00526   # 
00527   # @else
00528   #
00529   # @brief Write data into the buffer
00530   #
00531   # Pure virtual function to write data into the buffer.
00532   #
00533   # @param value Target data to write.
00534   #
00535   # @return Result of having written in data (true:Successful, false:Failed)
00536   #
00537   # @endif
00538   #
00539   # ReturnCode get(DataType& value)
00540   def get(self, value=None):
00541     guard = OpenRTM_aist.ScopedLock(self._pos_mutex)
00542     if value is None:
00543       return self._buffer[self._rpos]
00544 
00545     value[0] = self._buffer[self._rpos]
00546     return OpenRTM_aist.BufferStatus.BUFFER_OK
00547     
00548     
00549   ##
00550   # @if jp
00551   #
00552   # @brief バッファから読み出す
00553   # 
00554   # バッファに格納されたデータを読み出す。
00555   #
00556   # 第2引数(sec)、第3引数(nsec)が指定されていない場合、バッファ空状
00557   # 態での読み出しモード (readback, do_nothing, block) は init() で設
00558   # 定されたモードに従う。
00559   #
00560   # 第2引数(sec) に引数が指定された場合は、init() で設定されたモード
00561   # に関わらず、block モードとなり、バッファが空状態であれば指定時間
00562   # 待ち、タイムアウトする。第3引数(nsec)は指定されない場合0として扱
00563   # われる。タイムアウト待ち中に、書込みスレッド側でバッファへ書込み
00564   # があれば、ブロッキングは解除されデータが読みだされる。
00565   #
00566   # 読み出し時にバッファが空(empty)状態で、別のスレッドがblockモード
00567   # で書込み待ちをしている場合、signalを発行して書込み側のブロッキン
00568   # グが解除される。
00569   # 
00570   # @param value(list) 読み出し対象データ
00571   # @param sec   タイムアウト時間 sec  (default -1: 無効)
00572   # @param nsec  タイムアウト時間 nsec (default 0)
00573   # @return BUFFER_OK            正常終了
00574   #         BUFFER_EMPTY         バッファがフル状態
00575   #         TIMEOUT              書込みがタイムアウトした
00576   #         PRECONDITION_NOT_MET 設定異常
00577   # 
00578   # @else
00579   #
00580   # @brief Readout data from the buffer
00581   # 
00582   # Readout data stored into the buffer.
00583   # 
00584   # @param value(list) Readout data
00585   #
00586   # @return Readout result (Always true: readout success is returned)
00587   # 
00588   # @endif
00589   #
00590   # ReturnCode read(DataType& value,
00591   #                 long int sec = -1, long int nsec = 0)
00592   def read(self, value, sec = -1, nsec = 0):
00593     self._empty_cond.acquire()
00594       
00595     if self.empty():
00596       timedread = self._timedread
00597       readback  = self._readback
00598 
00599       if not (sec < 0):  # if second arg is set -> block mode
00600         timedread = True
00601         readback  = False
00602         sec = self._rtimeout.sec()
00603         nsec = self._rtimeout.usec() * 1000
00604 
00605       if readback and  not timedread:      # "readback" mode
00606         if not self._wcount > 0:
00607           self._empty_cond.release()
00608           return OpenRTM_aist.BufferStatus.BUFFER_EMPTY
00609         self.advanceRptr(-1)
00610 
00611       elif not readback and not timedread: # "do_nothiong" mode
00612         self._empty_cond.release()
00613         return OpenRTM_aist.BufferStatus.BUFFER_EMPTY
00614 
00615       elif not readback and timedread:     # "block" mode
00616         if sec < 0:
00617           sec = self._rtimeout.sec()
00618           nsec = self._rtimeout.usec() * 1000
00619         #  true: signaled, false: timeout
00620         if not self._empty_cond.wait(sec + (nsec/1000000000.0)):
00621           self._empty_cond.release()
00622           return OpenRTM_aist.BufferStatus.TIMEOUT
00623 
00624       else:                              # unknown condition
00625         self._empty_cond.release()
00626         return OpenRTM_aist.BufferStatus.PRECONDITION_NOT_MET
00627       
00628     self._empty_cond.release()
00629 
00630     val = self.get()
00631 
00632     if len(value) > 0:
00633       value[0] = val
00634     else:
00635       value.append(val)
00636 
00637     self._full_cond.acquire()
00638     full_ = self.full()
00639 
00640     if full_:
00641       self.advanceRptr()
00642       self._full_cond.notify()
00643     else:
00644       self.advanceRptr()
00645 
00646     self._full_cond.release()
00647 
00648 
00649     return OpenRTM_aist.BufferStatus.BUFFER_OK
00650 
00651     
00652   ##
00653   # @if jp
00654   #
00655   # @brief バッファから読み出し可能な要素数
00656   # 
00657   # バッファから読み出し可能な要素数を返す。
00658   # 
00659   # @return 読み出し可能な要素数
00660   #
00661   # @return BUFFER_OK: 正常終了
00662   #         BUFFER_ERROR: 異常終了
00663   # 
00664   # @else
00665   #
00666   # @brief Write data into the buffer
00667   #
00668   # Pure virtual function to write data into the buffer.
00669   #
00670   # @param value Target data to write.
00671   #
00672   # @return Result of having written in data (true:Successful, false:Failed)
00673   #
00674   # @endif
00675   #
00676   # size_t readable() const
00677   def readable(self):
00678     guard = OpenRTM_aist.ScopedLock(self._pos_mutex)
00679     return self._fillcount
00680     
00681 
00682   ##
00683   # @if jp
00684   #
00685   # @brief バッファemptyチェック
00686   # 
00687   # バッファemptyチェック用純粋仮想関数
00688   #
00689   # @return emptyチェック結果(true:バッファempty，false:バッファデータあり)
00690   # 
00691   # @else
00692   #
00693   # @brief Check on whether the buffer is empty.
00694   #
00695   # Pure virtual function to check on whether the buffer is empty.
00696   #
00697   # @return True if the buffer is empty, else false.
00698   #
00699   # @endif
00700   #
00701   # bool empty(void) const
00702   def empty(self):
00703     guard = OpenRTM_aist.ScopedLock(self._pos_mutex)
00704     return self._fillcount == 0
00705 
00706     
00707   ## void initLength(const coil::Properties& prop)
00708   def __initLength(self, prop):
00709     if prop.getProperty("length"):
00710       n = [0]
00711       if OpenRTM_aist.stringTo(n, prop.getProperty("length")):
00712         n = n[0]
00713         if n > 0:
00714           self.length(n)
00715 
00716     
00717   ## void initWritePolicy(const coil::Properties& prop)
00718   def __initWritePolicy(self, prop):
00719     policy = OpenRTM_aist.normalize([prop.getProperty("write.full_policy")])
00720 
00721     if policy == "overwrite":
00722       self._overwrite  = True
00723       self._timedwrite = False
00724     
00725     elif policy == "do_nothing":
00726       self._overwrite  = False
00727       self._timedwrite = False
00728 
00729     elif policy == "block":
00730       self._overwrite  = False
00731       self._timedwrite = True
00732 
00733       tm = [0.0]
00734       if OpenRTM_aist.stringTo(tm, prop.getProperty("write.timeout")):
00735         tm = tm[0]
00736         if not (tm < 0):
00737           self._wtimeout.set_time(tm)
00738 
00739     
00740   ## void initReadPolicy(const coil::Properties& prop)
00741   def __initReadPolicy(self, prop):
00742     policy = prop.getProperty("read.empty_policy")
00743 
00744     if policy == "readback":
00745       self._readback  = True
00746       self._timedread = False
00747 
00748     elif policy == "do_nothing":
00749       self._readback  = False
00750       self._timedread = False
00751 
00752     elif policy == "block":
00753       self._readback  = False
00754       self._timedread = True
00755       tm = [0.0]
00756       if OpenRTM_aist.stringTo(tm, prop.getProperty("read.timeout")):
00757         self._rtimeout.set_time(tm[0])