openrtm_aist_python: CorbaNaming.py Source File

Go to the documentation of this file.
00001 #!/usr/bin/env python
00002 # -*- coding: euc-jp -*-
00003 
00004 
00005 ##
00006 # \file CorbaNaming.py
00007 # \brief CORBA naming service helper class
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 omniORB.CORBA as CORBA
00019 import CosNaming
00020 import string
00021 import sys
00022 import traceback
00023 
00024 ##
00025 # @if jp
00026 # @class CorbaNaming
00027 # @brief CORBA Naming Service ヘルパークラス
00028 #
00029 # このクラスは、CosNaming::NamingContext に対するラッパークラスである。
00030 # CosNaming::NamingContext が持つオペレーションとほぼ同じ機能の
00031 # オペレーションを提供するとともに、ネームコンポーネント CosNaming::Name
00032 # の代わりに文字列による名前表現を受け付けるオペレーションも提供する。
00033 #
00034 # オブジェクトは生成時、あるいは生成直後に CORBA ネームサーバに接続し
00035 # 以後、このネームサーバのルートコンテキストに対して種々のオペレーション
00036 # を処理する。
00037 # 深い階層のネーミングコンテキストの作成やオブジェクトのバインドにおいて、
00038 # 途中のコンテキストが存在しない場合でも、強制的にコンテキストをバインド
00039 # し目的のコンテキストやオブジェクトのバインドを行うこともできる。
00040 #
00041 # @since 0.4.0
00042 #
00043 # @else
00044 # @class CorbaNaming
00045 # @brief CORBA Naming Service helper class
00046 #
00047 # This class is a wrapper class of CosNaming::NamingContext.
00048 # Almost the same operations which CosNaming::NamingContext has are
00049 # provided, and some operation allows string naming representation of
00050 # context and object instead of CosNaming::Name.
00051 #
00052 # The object of the class would connect to a CORBA naming server at
00053 # the instantiation or immediately after instantiation.
00054 # After that the object invokes operations to the root context of it.
00055 # This class realizes forced binding to deep NamingContext, without binding
00056 # intermediate NamingContexts explicitly.
00057 #
00058 # @since 0.4.0
00059 #
00060 # @endif
00061 class CorbaNaming:
00062   """
00063   """
00064 
00065 
00066 
00067   ##
00068   # @if jp
00069   #
00070   # @brief コンストラクタ
00071   #
00072   # @param self
00073   # @param orb ORB
00074   # @param name_server ネームサーバの名称(デフォルト値:None)
00075   #
00076   # @else
00077   #
00078   # @brief Consructor
00079   #
00080   # @endif
00081   def __init__(self, orb, name_server=None):
00082     self._orb = orb
00083     self._nameServer = ""
00084     self._rootContext = CosNaming.NamingContext._nil
00085     self._blLength = 100
00086 
00087     if name_server:
00088       self._nameServer = "corbaloc::" + name_server + "/NameService"
00089       try:
00090         obj = orb.string_to_object(self._nameServer)
00091         self._rootContext = obj._narrow(CosNaming.NamingContext)
00092         if CORBA.is_nil(self._rootContext):
00093           print "CorbaNaming: Failed to narrow the root naming context."
00094 
00095       except CORBA.ORB.InvalidName:
00096         self.__print_exception()
00097         print "Service required is invalid [does not exist]."
00098 
00099     return
00100   
00101 
00102   ##
00103   # @if jp
00104   #
00105   # @brief デストラクタ
00106   # 
00107   # @param self
00108   # 
00109   # @else
00110   # 
00111   # @brief destructor
00112   # 
00113   # @endif
00114   def __del__(self):
00115     return
00116 
00117 
00118   ##
00119   # @if jp
00120   #
00121   # @brief ネーミングサービスの初期化
00122   # 
00123   # 指定されたネームサーバ上のネーミングサービスを初期化します。
00124   # 
00125   # @param self
00126   # @param name_server ネームサーバの名称
00127   # 
00128   # @else
00129   # 
00130   # @endif
00131   def init(self, name_server):
00132     self._nameServer = "corbaloc::" + name_server + "/NameService"
00133     obj = self._orb.string_to_object(self._nameServer)
00134     self._rootContext = obj._narrow(CosNaming.NamingContext)
00135     if CORBA.is_nil(self._rootContext):
00136       raise MemoryError
00137 
00138     return
00139 
00140 
00141   ##
00142   # @if jp
00143   #
00144   # @brief ルートコンテキストが生存しているかを返す。
00145   # 
00146   # ルートコンテキストが生存しているかのチェックを行う。
00147   # 
00148   # @param self
00149   # @else
00150   # @brief Check on whether the root context is alive.
00151   # Check on whether the root context is alive.
00152   # @param self
00153   # @endif
00154   # bool CorbaNaming::isAlive()
00155   def isAlive(self):
00156     try:
00157       if self._rootContext._non_existent():
00158         return False
00159       return True
00160     except:
00161       self.__print_exception()
00162       return False
00163 
00164     return False
00165 
00166 
00167   ##
00168   # @if jp
00169   #
00170   # @brief Object を bind する
00171   #
00172   # CosNaming::bind() とほぼ同等の働きをするが、常に与えられたネームサーバの
00173   # ルートコンテキストに対してbind()が呼び出される点が異なる。
00174   #
00175   # Name <name> と Object <obj> を当該 NamingContext 上にバインドする。
00176   # c_n が n 番目の NameComponent をあらわすとすると、
00177   # name が n 個の NameComponent から成るとき、以下のように扱われる。
00178   #
00179   # cxt->bind(<c_1, c_2, ... c_n>, obj) は以下の操作と同等である。
00180   # cxt->resolve(<c_1, ... c_(n-1)>)->bind(<c_n>, obj)
00181   #
00182   # すなわち、1番目からn-1番目のコンテキストを解決し、n-1番目のコンテキスト
00183   # 上に name <n> として　obj を bind する。
00184   # 名前解決に参加する <c_1, ... c_(n-1)> の NemingContext は、
00185   # bindContext() や rebindContext() で既にバインド済みでなければならない。
00186   # もし <c_1, ... c_(n-1)> の NamingContext が存在しない場合には、
00187   # NotFound 例外が発生する。
00188   #
00189   # ただし、強制バインドフラグ force が true の時は、<c_1, ... c_(n-1)>
00190   # が存在しない場合にも、再帰的にコンテキストをバインドしながら、
00191   # 最終的に obj を名前 name <c_n> にバインドする。
00192   #
00193   # いずれの場合でも、n-1番目のコンテキスト上に name<n> のオブジェクト
00194   # (Object あるいは コンテキスト) がバインドされていれば
00195   # AlreadyBound 例外が発生する。
00196   #
00197   # @param self
00198   # @param name_list オブジェクトに付ける名前の NameComponent
00199   # @param obj 関連付けられる Object
00200   # @param force trueの場合、途中のコンテキストを強制的にバインドする
00201   #              (デフォルト値:None)
00202   #
00203   # @exception NotFound 途中の <c_1, c_2, ..., c_(n-1)> が存在しない。
00204   # @exception CannotProceed 何らかの理由で処理を継続できない。
00205   # @exception InvalidName 引数 name_list の名前が不正。
00206   # @exception AlreadyBound name <c_n> の Object がすでにバインドされている。
00207   #
00208   # @else
00209   #
00210   # @brief
00211   #
00212   # @endif
00213   def bind(self, name_list, obj, force=None):
00214     if force is None :
00215       force = True
00216 
00217     try:
00218       self._rootContext.bind(name_list, obj)
00219     except CosNaming.NamingContext.NotFound:
00220       if force:
00221         self.bindRecursive(self._rootContext, name_list, obj)
00222       else:
00223         raise
00224     except CosNaming.NamingContext.CannotProceed, err:
00225       if force:
00226         self.bindRecursive(err.cxt, err.rest_of_name, obj)
00227       else:
00228         raise
00229     except CosNaming.NamingContext.AlreadyBound:
00230       self._rootContext.rebind(name_list, obj)
00231 
00232 
00233   ##
00234   # @if jp
00235   #
00236   # @brief Object を bind する
00237   #
00238   # Object を bind する際に与える名前が文字列表現であること以外は、bind()
00239   # と同じである。bind(toName(string_name), obj) と等価。
00240   #
00241   # @param self
00242   # @param string_name オブジェクトに付ける名前の文字列表現
00243   # @param obj 関連付けられるオブジェクト
00244   # @param force trueの場合、途中のコンテキストを強制的にバインドする
00245   #              (デフォルト値:true)
00246   #
00247   # @exception NotFound 途中の <c_1, c_2, ..., c_(n-1)> が存在しない。
00248   # @exception CannotProceed 何らかの理由で処理を継続できない。
00249   # @exception InvalidName 引数 string_name の名前が不正。
00250   # @exception AlreadyBound name <n> の Object がすでにバインドされている。
00251   #
00252   # @else
00253   #
00254   # @brief
00255   #
00256   # @endif
00257   def bindByString(self, string_name, obj, force=True):
00258     self.bind(self.toName(string_name), obj, force)
00259 
00260 
00261   ##
00262   # @if jp
00263   #
00264   # @brief 途中のコンテキストを bind しながら Object を bind する
00265   #
00266   # context で与えられた NamingContext に対して、name で指定された
00267   # ネームコンポーネント <c_1, ... c_(n-1)> を NamingContext として
00268   # 解決しながら、名前 <c_n> に対して obj を bind する。
00269   # もし、<c_1, ... c_(n-1)> に対応する NamingContext がない場合には
00270   # 新たな NamingContext をバインドする。
00271   #
00272   # 最終的に <c_1, c_2, ..., c_(n-1)> に対応する NamingContext が生成
00273   # または解決された上で、CosNaming::bind(<c_n>, object) が呼び出される。
00274   # このとき、すでにバインディングが存在すれば AlreadyBound例外が発生する。
00275   #
00276   # 途中のコンテキストを解決する過程で、解決しようとするコンテキストと
00277   # 同じ名前の NamingContext ではない Binding が存在する場合、
00278   # CannotProceed 例外が発生し処理を中止する。
00279   #
00280   # @param self
00281   # @param context bind を開始する　NamingContext
00282   # @param name_list オブジェクトに付ける名前のネームコンポーネント
00283   # @param obj 関連付けられるオブジェクト
00284   #
00285   # @exception CannotProceed <c_1, ..., c_(n-1)> に対応する NamingContext 
00286   #            のうちひとつが、すでに NamingContext 以外の object にバインド
00287   #            されており、処理を継続できない。
00288   # @exception InvalidName 名前 name_list が不正
00289   # @exception AlreadyBound name <c_n> にすでに何らかの object がバインド
00290   #            されている。
00291   # @else
00292   #
00293   # @brief
00294   #
00295   # @endif
00296   def bindRecursive(self, context, name_list, obj):
00297     length = len(name_list)
00298     cxt = context
00299     for i in range(length):
00300       if i == length -1:
00301         try:
00302           cxt.bind(self.subName(name_list, i, i), obj)
00303         except CosNaming.NamingContext.AlreadyBound:
00304           cxt.rebind(self.subName(name_list, i, i), obj)
00305         return
00306       else:
00307         if self.objIsNamingContext(cxt):
00308           cxt = self.bindOrResolveContext(cxt,self.subName(name_list, i, i))
00309         else:
00310           raise CosNaming.NamingContext.CannotProceed(cxt, self.subName(name_list, i))
00311     return
00312 
00313 
00314   ##
00315   # @if jp
00316   #
00317   # @brief Object を rebind する
00318   #
00319   # name_list で指定された Binding がすでに存在する場合を除いて bind() と同じ
00320   # である。バインディングがすでに存在する場合には、新しいバインディングに
00321   # 置き換えられる。
00322   #
00323   # @param self
00324   # @param name_list オブジェクトに付ける名前の NameComponent
00325   # @param obj 関連付けられるオブジェクト
00326   # @param force trueの場合、途中のコンテキストを強制的にバインドする
00327   #              (デフォルト値:true)
00328   #
00329   # @exception NotFound 途中の <c_1, c_2, ..., c_(n-1)> が存在しない。
00330   # @exception CannotProceed 何らかの理由で処理を継続できない。
00331   # @exception InvalidName 名前 name_list が不正
00332   #
00333   # @else
00334   #
00335   # @brief
00336   #
00337   # @endif
00338   def rebind(self, name_list, obj, force=True):
00339     if force is None:
00340       force = True
00341       
00342     try:
00343       self._rootContext.rebind(name_list, obj)
00344 
00345     except CosNaming.NamingContext.NotFound:
00346       if force:
00347         self.rebindRecursive(self._rootContext, name_list, obj)
00348       else:
00349         self.__print_exception()
00350         raise
00351 
00352     except CosNaming.NamingContext.CannotProceed, err:
00353       if force:
00354         self.rebindRecursive(err.cxt, err,rest_of_name, obj)
00355       else:
00356         self.__print_exception()
00357         raise
00358       
00359     return
00360 
00361 
00362   ##
00363   # @if jp
00364   #
00365   # @brief Object を rebind する
00366   #
00367   # Object を rebind する際に与える名前が文字列表現であること以外は rebind()
00368   # と同じである。rebind(toName(string_name), obj) と等価。
00369   #
00370   # @param self
00371   # @param string_name オブジェクトに付ける名前の文字列表現
00372   # @param obj 関連付けられるオブジェクト
00373   # @param force trueの場合、途中のコンテキストを強制的にバインドする
00374   #              (デフォルト値:true)
00375   #
00376   # @exception NotFound 途中の <c_1, c_2, ..., c_(n-1)> が存在しない。
00377   # @exception CannotProceed 何らかの理由で処理を継続できない。
00378   # @exception InvalidName 引数 string_name の名前が不正。
00379   #
00380   # @else
00381   #
00382   # @brief
00383   #
00384   # @endif
00385   def rebindByString(self, string_name, obj, force=True):
00386     self.rebind(self.toName(string_name), obj, force)
00387 
00388     return
00389 
00390 
00391   ##
00392   # @if jp
00393   #
00394   # @brief 途中のコンテキストを bind しながら Object を rebind する
00395   #
00396   # name_list <c_n> で指定された NamingContext もしくは Object がすでに存在する
00397   # 場合を除いて bindRecursive() と同じである。
00398   #
00399   # name_list <c_n> で指定されたバインディングがすでに存在する場合には、
00400   # 新しいバインディングに置き換えられる。
00401   #
00402   # @param self
00403   # @param context bind を開始する　NamingContext
00404   # @param name_list オブジェクトに付ける名前の NameComponent
00405   # @param obj 関連付けられるオブジェクト
00406   #
00407   # @exception CannotProceed 途中のコンテキストが解決できない。
00408   # @exception InvalidName 与えられた name_list が不正。
00409   #
00410   # @else
00411   #
00412   # @brief
00413   #
00414   # @endif
00415   def rebindRecursive(self, context, name_list, obj):
00416     length = len(name_list)
00417     for i in range(length):
00418       if i == length - 1:
00419         context.rebind(self.subName(name_list, i, i), obj)
00420         return
00421       else:
00422         if self.objIsNamingContext(context):
00423           try:
00424             context = context.bind_new_context(self.subName(name_list, i, i))
00425           except CosNaming.NamingContext.AlreadyBound:
00426             obj_ = context.resolve(self.subName(name_list, i, i))
00427             context = obj_._narrow(CosNaming.NamingContext)
00428         else:
00429           raise CosNaming.NamingContext.CannotProceed(context, self.subName(name_list, i))
00430     return
00431 
00432 
00433   ##
00434   # @if jp
00435   #
00436   # @brief NamingContext を bind する
00437   #
00438   # bind 対象として指定された引数 name が文字列の場合は bindByString() と、
00439   # それ以外の場合は bind() と同じである。
00440   #
00441   # @param self
00442   # @param name オブジェクトに付ける名前
00443   # @param name_cxt 関連付けられる NamingContext
00444   # @param force trueの場合、途中のコンテキストを強制的にバインドする
00445   #              (デフォルト値:True)
00446   #
00447   # @exception NotFound 途中の <c_1, c_2, ..., c_(n-1)> が存在しない。
00448   # @exception CannotProceed 何らかの理由で処理を継続できない。
00449   # @exception InvalidName 引数 name の名前が不正。
00450   # @exception AlreadyBound name <c_n> の Object がすでにバインドされている。
00451   #
00452   # @else
00453   #
00454   # @brief
00455   #
00456   # @endif
00457   def bindContext(self, name, name_cxt, force=True):
00458     if isinstance(name, basestring):
00459       self.bind(self.toName(name), name_cxt, force)
00460     else:
00461       self.bind(name, name_cxt, force)
00462     return
00463 
00464 
00465   ##
00466   # @if jp
00467   #
00468   # @brief NamingContext を bind する
00469   #
00470   # bind されるオブジェクトが NamingContext であることを除いて
00471   # bindRecursive() と同じである。
00472   #
00473   # @param self
00474   # @param context bind を開始する　NamingContext
00475   # @param name_list オブジェクトに付ける名前のネームコンポーネント
00476   # @param name_cxt 関連付けられる NamingContext
00477   #
00478   # @else
00479   #
00480   # @brief
00481   #
00482   # @endif
00483   def bindContextRecursive(self, context, name_list, name_cxt):
00484     self.bindRecursive(context, name_list, name_cxt)
00485     return
00486 
00487 
00488   ##
00489   # @if jp
00490   #
00491   # @brief NamingContext を rebind する
00492   #
00493   # bind 対象として指定された引数 name が文字列の場合は rebindByString() と、
00494   # それ以外の場合は rebind() と同じである。
00495   # どちらの場合もバインディングがすでに存在する場合には、
00496   # 新しいバインディングに置き換えられる。
00497   #
00498   # @param self
00499   # @param name オブジェクトに付ける名前のネームコンポーネント
00500   # @param name_cxt 関連付けられる NamingContext
00501   # @param force trueの場合、途中のコンテキストを強制的にバインドする
00502   #              (デフォルト値:true)
00503   #
00504   # @exception NotFound 途中の <c_1, c_2, ..., c_(n-1)> が存在しない。
00505   # @exception CannotProceed 何らかの理由で処理を継続できない。
00506   # @exception InvalidName 引数 name の名前が不正。
00507   #
00508   # @else
00509   #
00510   # @endif
00511   def rebindContext(self, name, name_cxt, force=True):
00512     if isinstance(name, basestring):
00513       self.rebind(self.toName(name), name_cxt, force)
00514     else:
00515       self.rebind(name, name_cxt, force)
00516     return
00517 
00518 
00519   ##
00520   # @if jp
00521   #
00522   # @brief 途中のコンテキストを再帰的に rebind し NamingContext を rebind する    #
00523   # bind されるオブジェクトが NamingContext であることを除いて
00524   # rebindRecursive() と同じである。
00525   #
00526   # @param self
00527   # @param context bind を開始する　NamingContext
00528   # @param name_list オブジェクトに付ける名前の NameComponent
00529   # @param name_cxt 関連付けられる NamingContext
00530   #
00531   # @else
00532   #
00533   # @brief
00534   #
00535   # @endif
00536   def rebindContextRecursive(self, context, name_list, name_cxt):
00537     self.rebindRecursive(context, name_list, name_cxt)
00538     return
00539 
00540 
00541   ##
00542   # @if jp
00543   #
00544   # @brief Object を name から解決する
00545   #
00546   # name に bind されているオブジェクト参照を返す。
00547   # ネームコンポーネント <c_1, c_2, ... c_n> は再帰的に解決される。
00548   # 
00549   # 引数 name に与えられた値が文字列の場合にはまず最初に toName() によって
00550   # NameComponent に変換される。
00551   # 
00552   # CosNaming::resolve() とほぼ同等の働きをするが、常に与えられた
00553   # ネームサーバのルートコンテキストに対して resolve() が呼び出される点が
00554   # 異なる。
00555   #
00556   # @param self
00557   # @param name 解決すべきオブジェクトの名前のネームコンポーネント
00558   #
00559   # @return 解決されたオブジェクト参照
00560   #
00561   # @exception NotFound 途中の <c_1, c_2, ..., c_(n-1)> が存在しない。
00562   # @exception CannotProceed 何らかの理由で処理を継続できない。
00563   # @exception InvalidName 引数 name の名前が不正。
00564   #
00565   # @else
00566   #
00567   # @endif
00568   def resolve(self, name):
00569     if isinstance(name, basestring):
00570       name_ = self.toName(name)
00571     else:
00572       name_ = name
00573       
00574     try:
00575       obj = self._rootContext.resolve(name_)
00576       return obj
00577     except CosNaming.NamingContext.NotFound, ex:
00578       self.__print_exception()
00579       return None
00580 
00581 
00582   ##
00583   # @if jp
00584   #
00585   # @brief 指定された名前のオブジェクトの bind を解除する
00586   #
00587   # name に bind されているオブジェクト参照を解除する。
00588   # ネームコンポーネント <c_1, c_2, ... c_n> は再帰的に解決される。
00589   # 
00590   # 引数 name に与えられた値が文字列の場合にはまず最初に toName() によって
00591   # NameComponent に変換される。
00592   # 
00593   # CosNaming::unbind() とほぼ同等の働きをするが、常に与えられた
00594   # ネームサーバのルートコンテキストに対して unbind() が呼び出される点が
00595   # 異なる。
00596   #
00597   # @param self
00598   # @param name 削除するオブジェクトのネームコンポーネント
00599   #
00600   # @exception NotFound 途中の <c_1, c_2, ..., c_(n-1)> が存在しない。
00601   # @exception CannotProceed 何らかの理由で処理を継続できない。
00602   # @exception InvalidName 引数 name の名前が不正。
00603   #
00604   # @else
00605   #
00606   # @endif
00607   # void unbind(const CosNaming::Name& name)
00608   #   throw(NotFound, CannotProceed, InvalidName);
00609   def unbind(self, name):
00610     if isinstance(name, basestring):
00611       name_ = self.toName(name)
00612     else:
00613       name_ = name
00614 
00615     try:
00616       self._rootContext.unbind(name_)
00617     except:
00618       self.__print_exception()
00619 
00620     return
00621 
00622 
00623   ##
00624   # @if jp
00625   #
00626   # @brief 新しいコンテキストを生成する
00627   #
00628   # 与えられたネームサーバ上で生成された NamingContext を返す。
00629   # 返された NamingContext は bind されていない。
00630   # 
00631   # @param self
00632   # 
00633   # @return 生成された新しい NamingContext
00634   #
00635   # @else
00636   #
00637   # @endif
00638   def newContext(self):
00639     return self._rootContext.new_context()
00640 
00641 
00642   ##
00643   # @if jp
00644   #
00645   # @brief 新しいコンテキストを bind する
00646   #
00647   # 与えられた name に対して新しいコンテキストをバインドする。
00648   # 生成された　NamingContext はネームサーバ上で生成されたものである。
00649   # 
00650   # 引数 name に与えられた値が文字列の場合にはまず最初に toName() によって
00651   # NameComponent に変換される。
00652   # 
00653   # @param self
00654   # @param name NamingContextに付ける名前のネームコンポーネント
00655   # @param force trueの場合、途中のコンテキストを強制的にバインドする
00656   #              (デフォルト値:true)
00657   #
00658   # @return 生成された新しい NamingContext
00659   #
00660   # @exception NotFound 途中の <c_1, c_2, ..., c_(n-1)> が存在しない。
00661   # @exception CannotProceed 何らかの理由で処理を継続できない。
00662   # @exception InvalidName 引数 name の名前が不正。
00663   # @exception AlreadyBound name <n> の Object がすでにバインドされている。
00664   #
00665   # @else
00666   #
00667   # @endif
00668   def bindNewContext(self, name, force=True):
00669     if force is None:
00670       force = True
00671       
00672     if isinstance(name, basestring):
00673       name_ = self.toName(name)
00674     else:
00675       name_ = name
00676 
00677     try:
00678       return self._rootContext.bind_new_context(name_)
00679     except CosNaming.NamingContext.NotFound:
00680       if force:
00681         self.bindRecursive(self._rootContext, name_, self.newContext())
00682       else:
00683         self.__print_exception()
00684         raise
00685     except CosNaming.NamingContext.CannotProceed, err:
00686       if force:
00687         self.bindRecursive(err.cxt, err.rest_of_name, self.newContext())
00688       else:
00689         self.__print_exception()
00690         raise
00691     return None
00692 
00693 
00694   ##
00695   # @if jp
00696   #
00697   # @brief NamingContext を非アクティブ化する
00698   #
00699   # context で指定された NamingContext を非アクティブ化する。
00700   # context に他のコンテキストがバインドされている場合は NotEmpty 例外が
00701   # 発生する。
00702   # 
00703   # @param self
00704   # @param context 非アクティブ化する NamingContext
00705   #
00706   # @exception NotEmpty 対象context に他のコンテキストがバインドされている。
00707   #
00708   # @else
00709   #
00710   # @else
00711   #
00712   # @brief Destroy the naming context
00713   #
00714   # Delete the specified naming context.
00715   # any bindings should be <unbind> in which the given context is bound to
00716   # some names before invoking <destroy> operation on it. 
00717   #
00718   # @param context NamingContext which is destroied.
00719   #     
00720   # @exception NotEmpty 
00721   #
00722   # @else
00723   #
00724   # @endif
00725   def destroy(self, context):
00726     context.destroy()
00727 
00728 
00729   ##
00730   # @if jp
00731   # @brief NamingContext を再帰的に下って非アクティブ化する
00732   #
00733   # context で与えられた NamingContext に対して、name で指定された
00734   # ネームコンポーネント <c_1, ... c_(n-1)> を NamingContext として
00735   # 解決しながら、名前 <c_n> に対して 非アクティブ化を行う。
00736   #
00737   # @param self
00738   # @param context 非アクティブ化する NamingContext
00739   #
00740   # @exception NotEmpty 対象context に他のコンテキストがバインドされている。
00741   # @exception NotFound 途中の <c_1, c_2, ..., c_(n-1)> が存在しない。
00742   # @exception CannotProceed 何らかの理由で処理を継続できない。
00743   # @exception InvalidName 引数 name の名前が不正。
00744   #
00745   # @else
00746   # @brief Destroy the naming context recursively
00747   # @endif
00748   def destroyRecursive(self, context):
00749     cont = True
00750     bl = []
00751     bi = 0
00752     bl, bi = context.list(self._blLength)
00753     while cont:
00754       for i in range(len(bl)):
00755         if bl[i].binding_type == CosNaming.ncontext:
00756           obj = context.resolve(bl[i].binding_name)
00757           next_context = obj._narrow(CosNaming.NamingContext)
00758 
00759           self.destroyRecursive(next_context)
00760           context.unbind(bl[i].binding_name)
00761           next_context.destroy()
00762         elif bl[i].binding_type == CosNaming.nobject:
00763           context.unbind(bl[i].binding_name)
00764         else:
00765           assert(0)
00766       if CORBA.is_nil(bi):
00767         cont = False
00768       else:
00769         bi.next_n(self._blLength, bl)
00770 
00771     if not (CORBA.is_nil(bi)):
00772       bi.destroy()
00773     return
00774 
00775 
00776   ##
00777   # @if jp
00778   # @brief すべての Binding を削除する
00779   #
00780   # 登録されている全てのBinding を削除する。
00781   #
00782   # @param self
00783   #
00784   # @else
00785   # @brief Destroy all binding
00786   # @endif
00787   def clearAll(self):
00788     self.destroyRecursive(self._rootContext)
00789     return
00790 
00791 
00792   ##
00793   # @if jp
00794   # @brief 与えられた NamingContext の Binding を取得する
00795   #
00796   # 指定された NamingContext の Binding を取得する。
00797   #
00798   # @param self
00799   # @param name_cxt Binding 取得対象 NamingContext
00800   # @param how_many Binding を取得する階層の深さ
00801   # @param rbl 取得した Binding を保持するホルダ
00802   # @param rbi 取得した Binding をたどるためのイテレータ
00803   #
00804   # @else
00805   # @endif
00806   def list(self, name_cxt, how_many, rbl, rbi):
00807     bl, bi = name_cxt.list(how_many)
00808 
00809     for i in bl:
00810       rbl.append(bl)
00811 
00812     rbi.append(bi)
00813   
00814 
00815   #============================================================
00816   # interface of NamingContext
00817   #============================================================
00818 
00819   ##
00820   # @if jp
00821   # @brief 与えられた NameComponent の文字列表現を返す
00822   #
00823   # 指定された NameComponent を文字に変換する。
00824   #
00825   # @param self
00826   # @param name_list 変換対象 NameComponent
00827   #
00828   # @return 文字列変換結果
00829   #
00830   # @exception InvalidName 引数 name_list の名前が不正。
00831   #
00832   # @else
00833   # @brief Get string representation of given NameComponent
00834   # @endif
00835   def toString(self, name_list):
00836     if len(name_list) == 0:
00837       raise CosNaming.NamingContext.InvalidName
00838 
00839     slen = self.getNameLength(name_list)
00840     string_name = [""]
00841     self.nameToString(name_list, string_name, slen)
00842 
00843     return string_name[0]
00844 
00845 
00846   ##
00847   # @if jp
00848   # @brief 与えられた文字列表現を NameComponent に分解する
00849   #
00850   # 指定された文字列を NameComponent に変換する。
00851   #
00852   # @param self
00853   # @param sname 変換対象文字列
00854   #
00855   # @return NameComponent 変換結果
00856   #
00857   # @exception InvalidName 引数 sname が不正。
00858   #
00859   # @else
00860   # @brief Get NameComponent from gien string name representation
00861   # @endif
00862   def toName(self, sname):
00863     if not sname:
00864       raise CosNaming.NamingContext.InvalidName
00865 
00866     string_name = sname
00867     name_comps = []
00868 
00869     nc_length = 0
00870     nc_length = self.split(string_name, "/", name_comps)
00871 
00872     if not (nc_length > 0):
00873       raise CosNaming.NamingContext.InvalidName
00874 
00875     name_list = [CosNaming.NameComponent("","") for i in range(nc_length)]
00876 
00877     for i in range(nc_length):
00878       pos = string.rfind(name_comps[i][0:],".")
00879       if pos == -1:
00880         name_list[i].id   = name_comps[i]
00881         name_list[i].kind = ""
00882       else:
00883         name_list[i].id   = name_comps[i][0:pos]
00884         name_list[i].kind = name_comps[i][(pos+1):]
00885 
00886     return name_list
00887 
00888 
00889   ##
00890   # @if jp
00891   # @brief 与えられた addr と string_name から URL表現を取得する
00892   #
00893   # 指定されたアドレスと名称をURLに変換する。
00894   #
00895   # @param self
00896   # @param addr 変換対象アドレス
00897   # @param string_name 変換対象名称
00898   #
00899   # @return URL 変換結果
00900   #
00901   # @exception InvalidAddress 引数 addr が不正。
00902   # @exception InvalidName 引数 string_name が不正。
00903   #
00904   # @else
00905   # @brief Get URL representation from given addr and string_name
00906   # @endif
00907   def toUrl(self, addr, string_name):
00908     return self._rootContext.to_url(addr, string_name)
00909 
00910 
00911   ##
00912   # @if jp
00913   # @brief 与えられた文字列表現を resolve しオブジェクトを返す
00914   #
00915   # 指定された文字列表現をresolveし，オブジェクトを取得する。
00916   #
00917   # @param self
00918   # @param string_name 取得対象オブジェクト文字列表現
00919   #
00920   # @return 解決されたオブジェクト
00921   #
00922   # @exception NotFound 途中の <c_1, c_2, ..., c_(n-1)> が存在しない。
00923   # @exception CannotProceed 何らかの理由で処理を継続できない。
00924   # @exception InvalidName 引数 name の名前が不正。
00925   # @exception AlreadyBound name <n> の Object がすでにバインドされている。
00926   #
00927   # @else
00928   # @brief Resolve from name of string representation and get object 
00929   # @endif
00930   def resolveStr(self, string_name):
00931     return self.resolve(self.toName(string_name))
00932 
00933 
00934   #============================================================
00935   # Find functions
00936   #============================================================
00937 
00938   ##
00939   # @if jp
00940   #
00941   # @brief オブジェクトの名前をバインドまたは解決する
00942   #
00943   # 指定されたコンテキストに対してオブジェクトを NameComponent で指定された
00944   # 位置にバインドする。
00945   # 同一箇所に既に他の要素がバインド済みの場合は、既存のバインド済み要素を
00946   # 取得する。
00947   #
00948   # @param self
00949   # @param context bind もしくは resole 対象コンテキスト
00950   # @param name_list オブジェクトに付ける名前の NameComponent
00951   # @param obj 関連付けられる Object
00952   #
00953   # @return NameComponent で指定された位置にバインドされているオブジェクト
00954   #
00955   # @else
00956   # @brief Bind of resolve the given name component
00957   # @endif
00958   def bindOrResolve(self, context, name_list, obj):
00959     try:
00960       context.bind_context(name_list, obj)
00961       return obj
00962     except CosNaming.NamingContext.AlreadyBound:
00963       obj = context.resolve(name_list)
00964       return obj
00965     return CORBA.Object._nil
00966 
00967 
00968   ##
00969   # @if jp
00970   #
00971   # @brief コンテキストの名前をバインドまたは解決する
00972   #
00973   # 指定されたコンテキストに対して Contextを NameComponent で指定された位置に
00974   # バインドする。
00975   # Context が空の場合は新規コンテキストを生成してバインドする。
00976   # 同一箇所に既に他の要素がバインド済みの場合は、既存のバインド済み要素を
00977   # 取得する。
00978   #
00979   # @param self
00980   # @param context bind もしくは resole 対象コンテキスト
00981   # @param name_list コンテキストに付ける名前の NameComponent
00982   # @param new_context 関連付けられる Context(デフォルト値:None)
00983   #
00984   # @return NameComponent で指定された位置にバインドされているContext
00985   #
00986   # @else
00987   # @brief Bind of resolve the given name component
00988   # @endif
00989   def bindOrResolveContext(self, context, name_list, new_context=None):
00990     if new_context is None:
00991       new_cxt = self.newContext()
00992     else:
00993       new_cxt = new_context
00994 
00995     obj = self.bindOrResolve(context, name_list, new_cxt)
00996     return obj._narrow(CosNaming.NamingContext)
00997 
00998 
00999   ##
01000   # @if jp
01001   # @brief ネームサーバの名前を取得する
01002   #
01003   # 設定したネームサーバの名前を取得する。
01004   #
01005   # @param self
01006   #
01007   # @return ネームサーバの名前
01008   #
01009   # @else
01010   # @brief Get the name of naming server
01011   # @endif
01012   def getNameServer(self):
01013     return self._nameServer
01014 
01015 
01016   ##
01017   # @if jp
01018   # @brief ルートコンテキストを取得する
01019   #
01020   # 設定したネームサーバのルートコンテキストを取得する。
01021   #
01022   # @param self
01023   #
01024   # @return ネームサーバのルートコンテキスト
01025   #
01026   # @else
01027   # @brief Get the root context
01028   # @endif
01029   def getRootContext(self):
01030     return self._rootContext
01031 
01032 
01033   ##
01034   # @if jp
01035   # @brief オブジェクトがネーミングコンテキストか判別する
01036   #
01037   # 指定した要素がネーミングコンテキストか判別する
01038   #
01039   # @param self
01040   # @param obj 判別対象要素
01041   #
01042   # @return 判別結果(ネーミングコンテキスト:true、それ以外:false)
01043   #
01044   # @else
01045   # @brief Whether the object is NamingContext
01046   # @endif
01047   def objIsNamingContext(self, obj):
01048     nc = obj._narrow(CosNaming.NamingContext)
01049     if CORBA.is_nil(nc):
01050       return False
01051     else:
01052       return True
01053 
01054 
01055   ##
01056   # @if jp
01057   # @brief 与えられた名前がネーミングコンテキストかどうか判別する
01058   #
01059   # NameComponent もしくは文字列で指定した要素がネーミングコンテキストか
01060   # 判別する
01061   #
01062   # @param self
01063   # @param name_list 判別対象
01064   #
01065   # @return 判別結果(ネーミングコンテキスト:true、それ以外:false)
01066   #
01067   # @else
01068   # @brief Whether the given name component is NamingContext
01069   # @endif
01070   def nameIsNamingContext(self, name_list):
01071     return self.objIsNamingContext(self.resolve(name_list))
01072 
01073 
01074   ##
01075   # @if jp
01076   # @brief ネームコンポーネントの部分を返す
01077   #
01078   # 指定された範囲のネームコンポーネントを取得する。
01079   # 終了位置が指定されていない場合は、最後の要素を除いたネームコンポーネント
01080   # を返す。
01081   #
01082   # @param self
01083   # @param name_list 検索対象NameComponent
01084   # @param begin 取得範囲開始位置
01085   # @param end 取得範囲終了位置(デフォルト値:None)
01086   #
01087   # @return NameComponent 取得結果
01088   #
01089   # @else
01090   # @brief Get subset of given name component
01091   # @endif
01092   def subName(self, name_list, begin, end = None):
01093     if end is None or end < 0:
01094       end = len(name_list) - 1
01095 
01096     sub_len = end - (begin -1)
01097     objId = ""
01098     kind  = ""
01099     
01100     sub_name = []
01101     for i in range(sub_len):
01102       sub_name.append(name_list[begin + i])
01103 
01104     return sub_name
01105 
01106 
01107   ##
01108   # @if jp
01109   # @brief ネームコンポーネントの文字列表現を取得する
01110   #
01111   # 指定した範囲のネームコンポーネントの文字列表現を取得する。
01112   # 文字列表現は、NameComponentの構成が{Nc[0],Nc[1],Nc[2]･･･}の場合、
01113   #   Nc[0]id.Nc[0].kind/Nc[1]id.Nc[1].kind/Nc[2].id/Nc[2].kind･･･
01114   # という形式で取得できる。
01115   # 取得した文字列の長さが指定した長さ以上の場合は、
01116   # 指定した長さで切り捨てられる。
01117   #
01118   # @param self
01119   # @param name_list 取得対象NameComponent
01120   # @param string_name 取得結果文字列
01121   # @param slen 取得対象文字列最大値
01122   #
01123   # @else
01124   # @brief Get string representation of name component
01125   # @endif
01126   def nameToString(self, name_list, string_name, slen):
01127     for i in range(len(name_list)):
01128       for id_ in name_list[i].id:
01129         if id_ == "/" or id_ == "." or id_ == "\\":
01130           string_name[0] += "\\"
01131         string_name[0] += id_
01132 
01133       if name_list[i].id == "" or name_list[i].kind != "":
01134         string_name[0] += "."
01135 
01136       for kind_ in name_list[i].kind:
01137         if kind_ == "/" or kind_ == "." or kind_ == "\\":
01138           string_name[0] += "\\"
01139         string_name[0] += kind_
01140 
01141       string_name[0] += "/"
01142 
01143 
01144   ##
01145   # @if jp
01146   # @brief ネームコンポーネントの文字列表現時の文字長を取得する
01147   #
01148   # 指定したネームコンポーネントを文字列で表現した場合の長さを取得する。
01149   # 文字列表現は、NameComponentの構成が{Nc[0],Nc[1],Nc[2]・・・}の場合、
01150   #   Nc[0]id.Nc[0].kind/Nc[1]id.Nc[1].kind/Nc[2].id/Nc[2].kind・・・
01151   # という形式で取得できる。
01152   #
01153   # @param self
01154   # @param name_list 取得対象NameComponent
01155   #
01156   # @return 指定したネームコンポーネントの文字列長さ
01157   #
01158   # @else
01159   # @brief Get string length of the name component's string representation
01160   # @endif
01161   def getNameLength(self, name_list):
01162     slen = 0
01163 
01164     for i in range(len(name_list)):
01165       for id_ in name_list[i].id:
01166         if id_ == "/" or id_ == "." or id_ == "\\":
01167           slen += 1
01168         slen += 1
01169       if name_list[i].id == "" or name_list[i].kind == "":
01170         slen += 1
01171 
01172       for kind_ in name_list[i].kind:
01173         if kind_ == "/" or kind_ == "." or kind_ == "\\":
01174           slen += 1
01175         slen += 1
01176 
01177       slen += 1
01178 
01179     return slen
01180 
01181 
01182   ##
01183   # @if jp
01184   # @brief 文字列の分割
01185   #
01186   # 文字列を指定したデリミタで分割する。
01187   #
01188   # @param self
01189   # @param input 分割対象文字列
01190   # @param delimiter 分割用デリミタ
01191   # @param results 分割結果
01192   #
01193   # @return 分割した文字列の要素数
01194   #
01195   # @else
01196   # @brief Split of string
01197   # @endif
01198   def split(self, input, delimiter, results):
01199     delim_size = len(delimiter)
01200     found_pos = 0
01201     begin_pos = 0
01202     pre_pos = 0
01203     substr_size = 0
01204 
01205     if input[0:delim_size] == delimiter:
01206       begin_pos = delim_size
01207       pre_pos = delim_size
01208 
01209     while 1:
01210       found_pos = string.find(input[begin_pos:],delimiter)
01211       if found_pos == -1:
01212         results.append(input[pre_pos:])
01213         break
01214 
01215       if found_pos > 0 and input[found_pos + begin_pos - 1] == "\\":
01216         begin_pos += found_pos + delim_size
01217       else:
01218         substr_size = found_pos + (begin_pos - pre_pos)
01219         if substr_size > 0:
01220           results.append(input[pre_pos:(pre_pos+substr_size)])
01221         begin_pos += found_pos + delim_size
01222         pre_pos   = begin_pos
01223 
01224     return len(results)
01225 
01226 
01227   ##
01228   # @if jp
01229   #
01230   # @brief 例外情報出力
01231   #  例外情報を出力する。
01232   #
01233   # @else
01234   #
01235   # @brief Print exception information 
01236   #  Print exception information 
01237   # @endif
01238   def __print_exception(self):
01239     if sys.version_info[0:3] >= (2, 4, 0):
01240       print traceback.format_exc()
01241     else:
01242       _exc_list = traceback.format_exception(*sys.exc_info())
01243       _exc_str = "".join(_exc_list)
01244       print _exc_str
01245 
01246     return