openrtm_aist_python: StringUtil.py Source File

Go to the documentation of this file.
00001 #!/usr/bin/env python
00002 # -*- coding: euc-jp -*-
00003 
00004 ##
00005 # @file StringUtil.py
00006 # @brief String operation utility
00007 # @date $Date: $
00008 # @author Noriaki Ando <n-ando@aist.go.jp> and Shinji Kurihara
00009 #
00010 # Copyright (C) 2003-2008
00011 #     Task-intelligence Research Group,
00012 #     Intelligent Systems Research Institute,
00013 #     National Institute of
00014 #         Advanced Industrial Science and Technology (AIST), Japan
00015 #     All rights reserved.
00016 
00017 
00018 
00019 import string
00020 
00021 ##
00022 # @if jp
00023 # @brief 文字列がエスケープされているか判断する
00024 #
00025 # 指定された文字がエスケープされているかどうかを判断する。
00026 #
00027 # @param _str エスケープされているかどうか判断する文字を含む文字列
00028 # @param pos エスケープされているかどうか判断する文字の位置
00029 #
00030 # @return 指定した文字がエスケープされていれば true, それ以外は false
00031 #
00032 # @else
00033 # @brief Whether the character is escaped or not
00034 #
00035 # This operation returns true if the specified character is escaped, and
00036 # if the specified character is not escaped, it returns false
00037 #
00038 # @param str The string thath includes the character to be investigated.
00039 # @param pos The position of the character to be investigated.
00040 #
00041 # @return true: the character is escaped, false: the character is not escaped.
00042 #
00043 # @endif
00044 def isEscaped(_str, pos):
00045   pos -= 1
00046 
00047   i = 0
00048   while pos >= 0 and _str[pos] == "\\":
00049     i += 1
00050     pos -= 1
00051 
00052   return i % 2 == 1
00053 
00054 
00055 ##
00056 # @if jp
00057 # @class escape_functor
00058 # @brief  文字列エスケープ処理用functor
00059 # @else
00060 #
00061 # @endif
00062 class escape_functor:
00063   def __init__(self):
00064     self._str = ""
00065 
00066   def __call__(self,c):
00067     if   c == '\t':
00068       self._str += "\\t"
00069     elif c == '\n':
00070       self._str += "\\n"
00071     elif c == '\f':
00072       self._str += "\\f"
00073     elif c == '\r':
00074       self._str += "\\r"
00075     elif c == '\\':
00076       self._str += "\\\\"
00077     else:
00078       self._str += c
00079 
00080 
00081 ##
00082 # @if jp
00083 # @class unescape_functor
00084 # @brief  文字列アンエスケープ処理用functor
00085 # @else
00086 #
00087 # @endif
00088 class unescape_functor:
00089   def __init__(self):
00090     self.count = 0
00091     self._str = ""
00092 
00093   def __call__(self,c):
00094     if c == "\\":
00095       self.count += 1
00096       if not (self.count % 2):
00097         self._str += c
00098     else:
00099       if self.count > 0 and (self.count % 2):
00100         self.count = 0
00101         if c == 't':
00102           self._str+='\t'
00103         elif c == 'n':
00104           self._str+='\n'
00105         elif c == 'f':
00106           self._str+='\f'
00107         elif c == 'r':
00108           self._str+='\r'
00109         elif c == '\"':
00110           self._str+='\"'
00111         elif c == '\'':
00112           self._str+='\''
00113         else:
00114           self._str+=c
00115       else:
00116         self.count = 0
00117         self._str+=c
00118 
00119 
00120 ##
00121 # @if jp
00122 # @class unique_strvec
00123 # @brief  重複文字削除処理用functor
00124 # @else
00125 #
00126 # @endif
00127 class unique_strvec:
00128   def __init__(self):
00129     self._str = []
00130 
00131   def __call__(self,s):
00132     if self._str.count(s) == 0:
00133       return self._str.append(s)
00134 
00135 
00136 ##
00137 # @if jp
00138 # @brief  インスタンス生成用functor
00139 # @else
00140 #
00141 # @endif
00142 def for_each(_str, instance):
00143   for i in _str:
00144     instance(i)
00145 
00146   return instance
00147 
00148 
00149 ##
00150 # @if jp
00151 # @brief 文字列をエスケープする
00152 # 
00153 # 次の文字をエスケープシーケンスに変換する。<br>
00154 # HT -> "\t" <br>
00155 # LF -> "\n" <br>
00156 # CR -> "\r" <br>
00157 # FF -> "\f" <br>
00158 # シングルクオート、ダブルクオートについてはとくに処理はしない。
00159 # 
00160 # @else
00161 # 
00162 # @brief Escape string
00163 # 
00164 # The following characters are converted. <br>
00165 # HT -> "\t" <br>
00166 # LF -> "\n" <br>
00167 # CR -> "\r" <br>
00168 # FF -> "\f" <br>
00169 # Single quote and dobule quote are not processed.
00170 # 
00171 # @endif
00172 def escape(_str):
00173   return for_each(_str, escape_functor())._str
00174 
00175 
00176 ##
00177 # @if jp
00178 # @brief 文字列のエスケープを戻す
00179 # 
00180 # 次のエスケープシーケンスを文字に変換する。<br>
00181 # "\t" -> HT <br>
00182 # "\n" -> LF <br>
00183 # "\r" -> CR <br>
00184 # "\f" -> FF <br>
00185 # "\"" -> "  <br>
00186 # "\'" -> '  <br>
00187 # 
00188 # @else
00189 # 
00190 # @brief Unescape string
00191 # 
00192 # The following characters are converted. <br>
00193 # "\t" -> HT <br>
00194 # "\n" -> LF <br>
00195 # "\r" -> CR <br>
00196 # "\f" -> FF <br>
00197 # "\'" -> '  <br>
00198 # "\"" -> "  <br>
00199 # @endif
00200 def unescape(_str):
00201   return for_each(_str, unescape_functor())._str
00202 
00203 
00204 ##
00205 # @if jp
00206 # @brief 文字列の空白文字を削除する
00207 #
00208 # 与えられた文字列の空白文字を削除する。
00209 # 空白文字として扱うのは' '(スペース)と'\\t'(タブ)。
00210 #
00211 # @param str(list) 空白文字削除処理文字列のリスト
00212 #
00213 # @else
00214 # @brief Erase blank characters of string
00215 #
00216 # Erase blank characters that exist at the head of the given string.
00217 # Space ' 'and tab '\\t' are supported as the blank character.
00218 #
00219 # @param str The target blank characters of string for the erase
00220 #
00221 # @endif
00222 #
00223 def eraseBlank(str):
00224     if len(str) == 0:
00225         return
00226     str[0] = str[0].strip(" ")
00227     l_str = str[0].split(" ")
00228     tmp_str = ""
00229     for s in l_str:
00230         if s:
00231             tmp_str+=s.strip(" ")
00232 
00233     tmp_str = tmp_str.strip('\t')
00234     l_str = tmp_str.split('\t')
00235     tmp_str = ""
00236     for s in l_str:
00237         if s:
00238             tmp_str+=s.strip('\t')
00239 
00240     str[0] = tmp_str
00241 
00242 
00243 ##
00244 # @if jp
00245 # @brief 文字列の先頭の空白文字を削除する
00246 #
00247 # 与えられた文字列の先頭に存在する空白文字を削除する。
00248 # 空白文字として扱うのは' '(スペース)と'\\t'(タブ)。
00249 #
00250 # @param _str 先頭空白文字削除処理文字列
00251 #
00252 # @else
00253 # @brief Erase the head blank characters of string
00254 # @endif
00255 def eraseHeadBlank(_str):
00256   _str[0] = _str[0].lstrip('\t ')
00257 
00258 
00259 ##
00260 # @if jp
00261 # @brief 文字列の末尾の空白文字を削除する
00262 #
00263 # 与えられた文字列の末尾に存在する空白文字を削除する。
00264 # 空白文字として扱うのは' '(スペース)と'\\t'(タブ)。
00265 #
00266 # @param _str 末尾空白文字削除処理文字列
00267 #
00268 # @else
00269 # @brief Erase the tail blank characters of string
00270 # @endif
00271 def eraseTailBlank(_str):
00272   #_str[0] = _str[0].rstrip('\t ')
00273   if _str[0] == "":
00274     return
00275 
00276   while (_str[0][-1] == " " or _str[0][-1] == '\t') and not isEscaped(_str[0], len(_str[0]) - 1):
00277     _str[0] = _str[0][:-1]
00278 
00279 
00280 #
00281 # @if jp
00282 # @brief 文字列を正規化する
00283 # @else
00284 # @brief Erase the head/tail blank and replace upper case to lower case
00285 # @endif
00286 #
00287 def normalize(_str):
00288   _str[0] = _str[0].strip().lower()
00289   return _str[0]
00290 
00291 
00292 ##
00293 # @if jp
00294 # @brief 文字列を置き換える
00295 #
00296 # 与えられた文字列に対して、指定した文字の置き換えを行う。
00297 #
00298 # @param str 置き換え処理対象文字列
00299 # @param _from 置換元文字
00300 # @param _to 置換先文字
00301 #
00302 # @else
00303 # @brief Replace string
00304 # @endif
00305 def replaceString(str, _from, _to):
00306   str[0] = str[0].replace(_from, _to)
00307 
00308 
00309 ##
00310 # @if jp
00311 # @brief 文字列を分割文字で分割する
00312 # 
00313 # 設定された文字列を与えられたデリミタで分割する。
00314 #
00315 # @param input 分割対象文字列
00316 # @param delimiter 分割文字列(デリミタ)
00317 #
00318 # @return 文字列分割結果リスト
00319 #
00320 # @else
00321 # @brief Split string by delimiter
00322 # @endif
00323 def split(input, delimiter):
00324   if not input:
00325     return []
00326 
00327   del_result = input.split(delimiter)
00328 
00329   len_ = len(del_result)
00330 
00331   result = []
00332   for i in range(len_):
00333     if del_result[i] == "" or del_result[i] == " ":
00334       continue
00335       
00336     str_ = [del_result[i]]
00337     eraseHeadBlank(str_)
00338     eraseTailBlank(str_)
00339     result.append(str_[0])
00340     
00341   return result
00342 
00343 
00344 ##
00345 # @if jp
00346 # @brief 与えられた文字列をbool値に変換する
00347 # 
00348 # 指定された文字列を、true表現文字列、false表現文字列と比較し、その結果を
00349 # bool値として返す。
00350 # 比較の結果、true表現文字列、false表現文字列のどちらとも一致しない場合は、
00351 # 与えられたデフォルト値を返す。
00352 #
00353 # @param _str 判断対象文字列
00354 # @param yes true表現文字列
00355 # @param no false表現文字列
00356 # @param default_value デフォルト値(デフォルト値:None)
00357 # @else
00358 # @brief Convert given string to bool value
00359 # @endif
00360 def toBool(_str, yes, no, default_value=None):
00361   if default_value is None:
00362     default_value = True
00363 
00364   _str = _str.upper()
00365   yes  = yes.upper()
00366   no   = no.upper()
00367 
00368   if _str.find(yes) != -1:
00369     return True
00370   elif (_str.find(no)) != -1:
00371     return False
00372   else:
00373     return default_value
00374 
00375 ##
00376 # @if jp
00377 # @brief 文字列リスト中にある文字列が含まれるかどうか
00378 # 
00379 # 第1引数にカンマ区切りのリストを、第2引数に探索対象文字列を指定し、
00380 # その文字列が第1引数の中に含まれるかを判断する。
00381 #
00382 # @param list 対象リスト
00383 # @param value 探索文字列
00384 # @return true: 含まれる、false: 含まれない
00385 #
00386 # @else
00387 # @brief Include if a string is included in string list
00388 # 
00389 # if the second argument is included in the comma separated string
00390 # list of the first argument, This operation returns "true value".
00391 #
00392 # @param list The target comma separated string
00393 # @param value The searched string
00394 # @return true: included, false: not included
00395 #
00396 # @endif
00397 #
00398 #  bool includes(const vstring& list, std::string value,
00399 #                bool ignore_case = true);
00400 def includes(_list, value, ignore_case = True):
00401   if not (type(_list) == list or type(_list) == str):
00402     return False
00403 
00404   if type(_list) == str:
00405     _list = _list.split(",")
00406 
00407   tmp_list = _list
00408   if ignore_case:
00409     value = value.lower()
00410     tmp_list = map((lambda x: x.lower()),_list)
00411     
00412   if tmp_list.count(value) > 0:
00413     return True
00414 
00415   return False
00416     
00417 
00418 
00419 ##
00420 # @if jp
00421 # @brief 与えられた文字列が絶対パスかどうかを判断する
00422 #
00423 # 与えられた文字列が絶対パス表現であるかどうかを判断する。
00424 # 文字列が以下の場合には絶対パスとして判断する。
00425 #  - 先頭文字が'/' (UNIXの場合)
00426 #  - 先頭３文字がアルファベット＋'/'＋'\\' (Windowsの場合)
00427 #  - 先頭２文字が'\\\\' (Windowsネットワークパスの場合)
00428 #
00429 # @param str 判定対象文字列
00430 #
00431 # @return 絶対パス判定結果
00432 #
00433 # @else
00434 # @brief Investigate whether the given string is absolute path or not
00435 # @endif
00436 def isAbsolutePath(str):
00437   if str[0] == "/":
00438     return True
00439   if str[0].isalpha() and str[1] == ":" and str[2] == "\\":
00440     return True
00441   if str[0] == "\\" and str[1] == "\\":
00442     return True
00443 
00444   return False
00445 
00446 
00447 ##
00448 # @if jp
00449 # @brief 与えられた文字列がURLかどうかを判断する
00450 #
00451 # 与えられた文字列がURL表現かどうかを判断する。
00452 # 与えられた文字列中に、'://'という文字列が含まれている場合には
00453 # URL表現として判断する。
00454 #
00455 # @param str 判定対象文字列
00456 #
00457 # @return URL判定結果
00458 #
00459 # @else
00460 # @brief Investigate whether the given string is URL or not
00461 # @endif
00462 def isURL(str):
00463   pos = 0
00464   if str == "":
00465     return False
00466 
00467   pos = str.find(":")
00468   if pos != 0 and pos != -1 and str[pos+1] == "/" and str[pos+2] == "/":
00469     return True
00470 
00471   return False
00472 
00473 
00474 ##
00475 # @if jp
00476 # @brief 与えられたオブジェクトを文字列に変換
00477 #
00478 # 引数で指定されたオブジェクトを文字列に変換する。
00479 #
00480 # @param n 変換対象オブジェクト
00481 #
00482 # @return 文字列変換結果
00483 #
00484 # @else
00485 # @brief Convert the given object to st::string.
00486 # @endif
00487 def otos(n):
00488   if type(n) == int or type(n) == str or type(n) == long or type(n) == float:
00489     return str(n)
00490 
00491 
00492 
00493 ##
00494 # @if jp
00495 # @brief 与えられた文字列をリストに変換
00496 #
00497 # 引数で指定された文字列を｢,｣で分割し、リストに変換する。
00498 #
00499 # @param _type 変換結果リスト
00500 # @param _str 変換元文字列
00501 #
00502 # @return リスト変換処理結果
00503 #
00504 # @else
00505 # 
00506 # @endif
00507 def _stringToList(_type, _str):
00508   list_ = split(_str,",")
00509   len_ = len(list_)
00510 
00511   if len(_type[0]) < len(list_):
00512     sub = len(list_) - len(_type[0])
00513     for i in range(sub):
00514       _type[0].append(_type[0][0])
00515   elif len(_type[0]) > len(list_):
00516     sub = len(_type[0]) - len(list_)
00517     for i in range(sub):
00518       del _type[0][-1]
00519 
00520   for i in range(len_):
00521     str_ = [list_[i]]
00522     eraseHeadBlank(str_)
00523     eraseTailBlank(str_)
00524     list_[i] = str_[0]
00525 
00526   for i in range(len(list_)):
00527     if type(_type[0][i]) == int:
00528       _type[0][i] = int(list_[i])
00529     elif type(_type[0][i]) == long:
00530       _type[0][i] = long(list_[i])
00531     elif type(_type[0][i]) == float:
00532       _type[0][i] = float(list_[i])
00533     elif type(_type[0][i]) == str:
00534       _type[0][i] = str(list_[i])
00535     else:
00536       return False
00537 
00538   return True
00539 
00540 
00541 ##
00542 # @if jp
00543 # @brief 与えられた文字列をオブジェクトに変換
00544 #
00545 # 引数で与えられた文字列を指定されたオブジェクトに変換する。
00546 #
00547 # @param _type 変換先オブジェクト
00548 # @param _str 変換元文字列
00549 #
00550 # @return 変換処理実行結果
00551 #
00552 # @else
00553 # @brief Convert the given object to st::string.
00554 # @endif
00555 def stringTo(_type, _str):
00556   if not _str:
00557     return False
00558 
00559   if type(_type[0]) == int:
00560     _type[0] = int(_str)
00561     return True
00562   elif type(_type[0]) == long:
00563     _type[0] = long(_str)
00564     return True
00565   elif type(_type[0]) == float:
00566     _type[0] = float(_str)
00567     return True
00568   elif type(_type[0]) == list:
00569     return _stringToList(_type, _str)
00570   elif type(_type[0]) == str:
00571     _type[0] = str(_str)
00572     return True
00573   
00574   return False
00575 
00576 
00577 ##
00578 # @if jp
00579 # @brief 与えられた文字列リストから重複を削除
00580 #
00581 # 引数で与えられた文字列リストから重複を削除したリストを作成する。
00582 #
00583 # @param sv 確認元文字列リスト
00584 #
00585 # @return 重複削除処理結果リスト
00586 #
00587 # @else
00588 #
00589 # @endif
00590 def unique_sv(sv):
00591   return for_each(sv, unique_strvec())._str
00592 
00593 
00594 ##
00595 # @if jp
00596 # @brief 与えられた文字列リストからCSVを生成
00597 #
00598 # 引数で与えられた文字列リストの各要素を並べたCSVを生成する。
00599 # 文字列リストが空の場合には空白文字を返す。
00600 #
00601 # @param sv CSV変換対象文字列リスト
00602 #
00603 # @return CSV変換結果文字列
00604 #
00605 # @else
00606 #
00607 # @endif
00608 def flatten(sv):
00609   if len(sv) == 0:
00610     return ""
00611 
00612   _str = ", ".join(sv)
00613 
00614   return _str
00615 
00616 
00617 ##
00618 # @if jp
00619 # @brief 与えられた文字列リストを引数リストに変換
00620 #
00621 # 引数で与えられた文字列リストの各要素末尾に'\\0'を加え、
00622 # 引数リストに変換する。<br>
00623 # ※本モジュールでは引数をそのまま返す
00624 #
00625 # @param args 変換対象文字列リスト
00626 #
00627 # @return 引数変換結果文字列
00628 #
00629 # @else
00630 #
00631 # @endif
00632 def toArgv(args):
00633   return args