00001 // -*- C++ -*- 00020 /* 00021 * $Log: CorbaConsumer.h,v $ 00022 * Revision 1.5 2007/01/21 09:05:13 n-ando 00023 * Template arguments "_ptr_type" and "_var_type" are defined as typename. 00024 * The given object references are duplicated. 00025 * 00026 * Revision 1.4 2007/01/12 14:29:18 n-ando 00027 * A trivial bug fix. 00028 * 00029 * Revision 1.3 2007/01/06 17:39:33 n-ando 00030 * The copy constructor and the substitution operator were added. 00031 * 00032 * Revision 1.2 2007/01/04 00:48:20 n-ando 00033 * - Class name has changed. 00034 * - operator->() was added. 00035 * - CorbaConsumer::releaseObject() was added. 00036 * 00037 * Revision 1.1 2006/11/21 08:32:26 n-ando 00038 * ConsumerBase class and Cosnumer class were added for proxy placeholder. 00039 * 00040 */ 00041 00042 #ifndef Consumer_h 00043 #define Consumer_h 00044 #include <iostream> 00045 #ifdef ORB_IS_MICO 00046 #include <CORBA.h> 00047 #endif 00048 #ifdef ORB_IS_OMNIORB 00049 #include <omniORB4/CORBA.h> 00050 #endif 00051 #ifdef ORB_IS_ORBACUS 00052 #include <OB/CORBA.h> 00053 #endif 00054 #ifdef ORB_IS_ORBIT2 00055 #include <orbitcpp/orb-cpp/orbitcpp.h> 00056 #endif 00057 #ifdef ORB_IS_ORBIX 00058 #include <CORBA.h> 00059 #endif 00060 #ifdef ORB_IS_TAO 00061 #include <tao/corba.h> 00062 #endif 00063 00064 namespace RTC 00065 { 00075 class CorbaConsumerBase 00076 { 00077 public: 00085 CorbaConsumerBase(){}; 00086 00094 CorbaConsumerBase(const CorbaConsumerBase& x) 00095 { 00096 m_objref = x.m_objref; 00097 } 00098 00099 CorbaConsumerBase& operator=(const CorbaConsumerBase& x) 00100 { 00101 m_objref = x.m_objref; 00102 return *this; 00103 } 00104 00112 virtual ~CorbaConsumerBase(){}; 00113 00114 00137 virtual bool setObject(CORBA::Object_ptr obj) 00138 { 00139 if (CORBA::is_nil(obj)) 00140 { 00141 return false; 00142 } 00143 m_objref = CORBA::Object::_duplicate(obj); 00144 return true; 00145 } 00146 00167 virtual CORBA::Object_ptr getObject() 00168 { 00169 return m_objref; 00170 } 00171 00172 virtual void releaseObject() 00173 { 00174 m_objref = CORBA::Object::_nil(); 00175 } 00176 00177 protected: 00178 CORBA::Object_var m_objref; 00179 }; 00180 00181 00182 00222 template <class ObjectType, 00223 typename ObjectTypePtr = typename ObjectType::_ptr_type, 00224 typename ObjectTypeVar = typename ObjectType::_var_type> 00225 class CorbaConsumer 00226 : public CorbaConsumerBase 00227 { 00228 public: 00236 CorbaConsumer(){}; 00237 00238 CorbaConsumer(const CorbaConsumer& x) 00239 { 00240 m_var = x.m_var; 00241 } 00242 00243 CorbaConsumer& operator=(const CorbaConsumer& x) 00244 { 00245 m_var = x.m_var; 00246 } 00247 00255 virtual ~CorbaConsumer() 00256 { 00257 }; 00258 00278 virtual bool setObject(CORBA::Object_ptr obj) 00279 { 00280 if (CorbaConsumerBase::setObject(obj)) 00281 { 00282 m_var = ObjectType::_duplicate(ObjectType::_narrow(m_objref)); 00283 if (!CORBA::is_nil(m_var)) 00284 return true; 00285 } 00286 return false; // object is nil 00287 } 00288 00289 00314 inline ObjectTypePtr _ptr() 00315 { 00316 return m_var; 00317 } 00318 00343 inline ObjectTypePtr operator->() 00344 { 00345 return m_var; 00346 } 00347 00348 virtual void releaseObject() 00349 { 00350 CorbaConsumerBase::releaseObject(); 00351 m_var = ObjectType::_nil(); 00352 } 00353 00354 protected: 00355 ObjectTypeVar m_var; 00356 00357 }; 00358 }; // namespace RTC 00359 #endif // Consumer_h