00001 // -*- C++ -*- 00020 #ifndef Consumer_h 00021 #define Consumer_h 00022 #include <iostream> 00023 #ifdef ORB_IS_MICO 00024 #include <CORBA.h> 00025 #endif 00026 #ifdef ORB_IS_OMNIORB 00027 #ifdef WIN32 00028 #pragma warning( disable : 4267 ) 00029 #pragma warning( disable : 4290 ) 00030 #pragma warning( disable : 4311 ) 00031 #pragma warning( disable : 4312 ) 00032 #endif // WIN32 00033 #include <omniORB4/CORBA.h> 00034 #ifdef WIN32 00035 #pragma warning( default : 4267 ) 00036 #pragma warning( default : 4290 ) 00037 #pragma warning( default : 4311 ) 00038 #pragma warning( default : 4312 ) 00039 #endif // WIN32 00040 #endif 00041 #ifdef ORB_IS_ORBACUS 00042 #include <OB/CORBA.h> 00043 #endif 00044 #ifdef ORB_IS_ORBIT2 00045 #include <orbitcpp/orb-cpp/orbitcpp.h> 00046 #endif 00047 #ifdef ORB_IS_ORBIX 00048 #include <CORBA.h> 00049 #endif 00050 #ifdef ORB_IS_TAO 00051 #include <tao/corba.h> 00052 #endif 00053 00068 namespace RTC 00069 { 00093 class CorbaConsumerBase 00094 { 00095 public: 00107 CorbaConsumerBase(){}; 00108 00124 CorbaConsumerBase(const CorbaConsumerBase& x) 00125 : m_objref(CORBA::Object::_duplicate(x.m_objref)) 00126 { 00127 } 00128 00148 CorbaConsumerBase& operator=(const CorbaConsumerBase& x) 00149 { 00150 CorbaConsumerBase tmp(x); 00151 tmp.swap(*this); 00152 return *this; 00153 } 00154 00170 void swap(CorbaConsumerBase& x) 00171 { 00172 CORBA::Object_var tmpref = x.m_objref; 00173 x.m_objref = this->m_objref; 00174 this->m_objref = tmpref; 00175 } 00176 00188 virtual ~CorbaConsumerBase(void) 00189 { 00190 releaseObject(); 00191 }; 00192 00220 virtual bool setObject(CORBA::Object_ptr obj) 00221 { 00222 if (CORBA::is_nil(obj)) 00223 { 00224 return false; 00225 } 00226 m_objref = CORBA::Object::_duplicate(obj); 00227 return true; 00228 } 00229 00253 virtual CORBA::Object_ptr getObject() 00254 { 00255 return CORBA::Object::_duplicate(m_objref); 00256 } 00257 00275 virtual void releaseObject() 00276 { 00277 m_objref = CORBA::Object::_nil(); 00278 } 00279 00280 protected: 00288 CORBA::Object_var m_objref; 00289 }; 00290 00334 template <class ObjectType, 00335 typename ObjectTypePtr = typename ObjectType::_ptr_type, 00336 typename ObjectTypeVar = typename ObjectType::_var_type> 00337 class CorbaConsumer 00338 : public CorbaConsumerBase 00339 { 00340 public: 00352 CorbaConsumer(){}; 00353 00369 CorbaConsumer(const CorbaConsumer& x) 00370 : m_var(ObjectType::_duplicate(x.m_var)) 00371 { 00372 } 00373 00393 CorbaConsumer& operator=(const CorbaConsumer& x) 00394 { 00395 CorbaConsumer tmp(x); 00396 tmp.swap(*this); 00397 return *this; 00398 } 00399 00400 void swap(const CorbaConsumer& x) 00401 { 00402 CorbaConsumerBase::swap(x); 00403 ObjectTypeVar tmpref = x.m_var; 00404 x.m_var = this->m_var; 00405 this->m_var = tmpref; 00406 00407 } 00408 00420 virtual ~CorbaConsumer(void) 00421 { 00422 releaseObject(); 00423 }; 00424 00453 virtual bool setObject(CORBA::Object_ptr obj) 00454 { 00455 if (!CorbaConsumerBase::setObject(obj)) 00456 { 00457 releaseObject(); 00458 return false; // object is nil 00459 } 00460 00461 ObjectTypePtr ptr = ObjectType::_narrow(m_objref); 00462 00463 if (CORBA::is_nil(ptr)) 00464 { 00465 releaseObject(); 00466 return false; 00467 } 00468 00469 m_var = ObjectType::_duplicate(ptr); 00470 return true; 00471 } 00472 00497 inline ObjectTypePtr _ptr() 00498 { 00499 return m_var.inout(); 00500 } 00501 00526 inline ObjectTypePtr operator->() 00527 { 00528 return m_var.inout(); 00529 } 00530 00548 virtual void releaseObject() 00549 { 00550 CorbaConsumerBase::releaseObject(); 00551 m_var = ObjectType::_nil(); 00552 } 00553 00554 protected: 00562 ObjectTypeVar m_var; 00563 }; 00564 }; // namespace RTC 00565 #endif // Consumer_h