Main Page   Namespace List   Class Hierarchy   Alphabetical List   Compound List   File List   Namespace Members   Compound Members   File Members   Related Pages  

DomainC.i

Go to the documentation of this file.
00001 // -*- C++ -*-
00002 //
00003 // $Id: DomainC.i,v 1.1.1.4 2003/02/21 18:36:44 chad Exp $
00004 
00005 // ****  Code generated by the The ACE ORB (TAO) IDL Compiler ****
00006 // TAO and the TAO IDL Compiler have been developed by:
00007 //       Center for Distributed Object Computing
00008 //       Washington University
00009 //       St. Louis, MO
00010 //       USA
00011 //       http://www.cs.wustl.edu/~schmidt/doc-center.html
00012 // and
00013 //       Distributed Object Computing Laboratory
00014 //       University of California at Irvine
00015 //       Irvine, CA
00016 //       USA
00017 //       http://doc.ece.uci.edu/
00018 //
00019 // Information about TAO is available at:
00020 //     http://www.cs.wustl.edu/~schmidt/TAO.html
00021 
00022 
00023 #if !defined (_CORBA_DOMAINMANAGER___CI_)
00024 #define _CORBA_DOMAINMANAGER___CI_
00025 
00026 ACE_INLINE
00027 CORBA::DomainManager::DomainManager (
00028     TAO_Stub *objref,
00029     CORBA::Boolean _tao_collocated,
00030     TAO_Abstract_ServantBase *servant
00031   )
00032   : CORBA_Object (objref, _tao_collocated, servant)
00033 {
00034   this->CORBA_DomainManager_setup_collocation (_tao_collocated);
00035 }
00036 
00037 
00038 #endif /* end #if !defined */
00039 
00040 
00041 #if !defined (_CORBA_CONSTRUCTIONPOLICY___CI_)
00042 #define _CORBA_CONSTRUCTIONPOLICY___CI_
00043 
00044 ACE_INLINE
00045 CORBA::ConstructionPolicy::ConstructionPolicy (
00046     TAO_Stub *objref,
00047     CORBA::Boolean _tao_collocated,
00048     TAO_Abstract_ServantBase *servant
00049   )
00050   : CORBA_Object (objref, _tao_collocated, servant)
00051 {
00052   this->CORBA_ConstructionPolicy_setup_collocation (_tao_collocated);
00053 }
00054 
00055 
00056 #endif /* end #if !defined */
00057 
00058 
00059 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
00060 
00061 #if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_DOMAINMANAGERLIST_CI_)
00062 #define __TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_DOMAINMANAGERLIST_CI_
00063 
00064 ACE_INLINE CORBA::DomainManager **
00065 CORBA::_TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList::allocbuf (CORBA::ULong nelems)
00066 {
00067   CORBA::DomainManager **buf = 0;
00068   
00069   ACE_NEW_RETURN (buf, CORBA::DomainManager*[nelems], 0);
00070   
00071   for (CORBA::ULong i = 0; i < nelems; i++)
00072     {
00073       buf[i] = CORBA::DomainManager::_nil ();
00074     }
00075   
00076   return buf;
00077 }
00078 
00079 ACE_INLINE void 
00080 CORBA::_TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList::freebuf (CORBA::DomainManager **buffer)
00081 {
00082   if (buffer == 0)
00083     return;
00084   delete[] buffer;
00085 }
00086 
00087 ACE_INLINE
00088 CORBA::_TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList::_TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList (void)
00089 {
00090 }
00091 
00092 ACE_INLINE
00093 CORBA::_TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList::_TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList (CORBA::ULong maximum)
00094   : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList::allocbuf (maximum))
00095 {
00096 }
00097 
00098 ACE_INLINE
00099 CORBA::_TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList::_TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList (CORBA::ULong maximum,
00100   CORBA::ULong length,
00101   CORBA::DomainManager* *value,
00102   CORBA::Boolean release)
00103 : TAO_Unbounded_Base_Sequence (maximum, length, value, release)
00104 {
00105 }
00106 
00107 ACE_INLINE
00108 CORBA::_TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList::_TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList(const _TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList &rhs)
00109   : TAO_Unbounded_Base_Sequence (rhs)
00110 {
00111   if (rhs.buffer_ != 0)
00112   {
00113     CORBA::DomainManager **tmp1 = _TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList::allocbuf (this->maximum_);
00114     CORBA::DomainManager ** const tmp2 = ACE_reinterpret_cast (CORBA::DomainManager ** ACE_CAST_CONST, rhs.buffer_);
00115     
00116     for (CORBA::ULong i = 0; i < rhs.length_; ++i)
00117       {
00118         tmp1[i] = CORBA::DomainManager::_duplicate (tmp2[i]);
00119       }
00120     
00121     this->buffer_ = tmp1;
00122   }
00123   else
00124   {
00125     this->buffer_ = 0;
00126   }
00127 }
00128 
00129 ACE_INLINE CORBA::_TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList &
00130 CORBA::_TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList::operator= (const _TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList &rhs)
00131 {
00132   if (this == &rhs)
00133     return *this;
00134   
00135   if (this->release_)
00136   {
00137     CORBA::DomainManager **tmp = ACE_reinterpret_cast (CORBA::DomainManager **, this->buffer_);
00138     
00139     for (CORBA::ULong i = 0; i < this->length_; ++i)
00140     {
00141       CORBA::release (tmp[i]);
00142       tmp[i] = CORBA::DomainManager::_nil ();
00143     }
00144     if (this->maximum_ < rhs.maximum_)
00145     {
00146       _TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList::freebuf (tmp);
00147       this->buffer_ = _TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList::allocbuf (rhs.maximum_);
00148     }
00149   }
00150   else
00151     this->buffer_ = _TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList::allocbuf (rhs.maximum_);
00152   
00153   TAO_Unbounded_Base_Sequence::operator= (rhs);
00154   
00155   CORBA::DomainManager **tmp1 = ACE_reinterpret_cast (CORBA::DomainManager **, this->buffer_);
00156   CORBA::DomainManager ** const tmp2 = ACE_reinterpret_cast (CORBA::DomainManager ** ACE_CAST_CONST, rhs.buffer_);
00157   
00158   for (CORBA::ULong i = 0; i < rhs.length_; ++i)
00159     {
00160       tmp1[i] = CORBA::DomainManager::_duplicate (tmp2[i]);
00161     }
00162   
00163   return *this;
00164 }
00165 
00166 ACE_INLINE TAO_Object_Manager<CORBA::DomainManager,CORBA::DomainManager_var>
00167 CORBA::_TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList::operator[] (CORBA::ULong index) const
00168 // read-write accessor
00169 {
00170   ACE_ASSERT (index < this->maximum_);
00171   CORBA::DomainManager ** const tmp = ACE_reinterpret_cast (CORBA::DomainManager ** ACE_CAST_CONST, this->buffer_);
00172   return TAO_Object_Manager<CORBA::DomainManager,CORBA::DomainManager_var> (tmp + index, this->release_);
00173 }
00174 
00175 ACE_INLINE CORBA::DomainManager* *
00176 CORBA::_TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList::get_buffer (CORBA::Boolean orphan)
00177 {
00178   CORBA::DomainManager **result = 0;
00179   if (orphan == 0)
00180   {
00181     // We retain ownership.
00182     if (this->buffer_ == 0)
00183     {
00184       result = _TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList::allocbuf (this->maximum_);
00185       this->buffer_ = result;
00186       this->release_ = 1;
00187     }
00188     else
00189     {
00190       result = ACE_reinterpret_cast (CORBA::DomainManager**, this->buffer_);
00191     }
00192   }
00193   else // if (orphan == 1)
00194   {
00195     if (this->release_ != 0)
00196     {
00197       // We set the state back to default and relinquish
00198       // ownership.
00199       result = ACE_reinterpret_cast(CORBA::DomainManager**,this->buffer_);
00200       this->maximum_ = 0;
00201       this->length_ = 0;
00202       this->buffer_ = 0;
00203       this->release_ = 0;
00204     }
00205   }
00206   return result;
00207 }
00208 
00209 ACE_INLINE const CORBA::DomainManager* *
00210 CORBA::_TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList::get_buffer (void) const
00211 {
00212   return ACE_reinterpret_cast(const CORBA::DomainManager ** ACE_CAST_CONST, this->buffer_);
00213 }
00214 
00215 
00216 #endif /* end #if !defined */
00217 
00218 
00219 #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
00220 
00221 #if !defined (_CORBA_DOMAINMANAGERLIST_CI_)
00222 #define _CORBA_DOMAINMANAGERLIST_CI_
00223 
00224 // *************************************************************
00225 // Inline operations for class CORBA::DomainManagerList_var
00226 // *************************************************************
00227 
00228 ACE_INLINE
00229 CORBA::DomainManagerList_var::DomainManagerList_var (void) // default constructor
00230   : ptr_ (0)
00231 {}
00232 
00233 ACE_INLINE
00234 CORBA::DomainManagerList_var::DomainManagerList_var (DomainManagerList *p)
00235   : ptr_ (p)
00236 {}
00237 
00238 ACE_INLINE
00239 CORBA::DomainManagerList_var::DomainManagerList_var (const ::CORBA::DomainManagerList_var &p) // copy constructor
00240 {
00241   if (p.ptr_)
00242     ACE_NEW (this->ptr_, ::CORBA::DomainManagerList (*p.ptr_));
00243   else
00244     this->ptr_ = 0;
00245 }
00246 
00247 ACE_INLINE
00248 CORBA::DomainManagerList_var::~DomainManagerList_var (void) // destructor
00249 {
00250   delete this->ptr_;
00251 }
00252 
00253 ACE_INLINE CORBA::DomainManagerList_var &
00254 CORBA::DomainManagerList_var::operator= (DomainManagerList *p)
00255 {
00256   delete this->ptr_;
00257   this->ptr_ = p;
00258   return *this;
00259 }
00260 
00261 ACE_INLINE ::CORBA::DomainManagerList_var &
00262 CORBA::DomainManagerList_var::operator= (const ::CORBA::DomainManagerList_var &p)
00263 {
00264   if (this != &p)
00265     {
00266       if (p.ptr_ == 0)
00267         {
00268           delete this->ptr_;
00269           this->ptr_ = 0;
00270         }
00271       else
00272         {
00273           DomainManagerList *deep_copy =
00274             new DomainManagerList (*p.ptr_);
00275           
00276           if (deep_copy != 0)
00277             {
00278               DomainManagerList *tmp = deep_copy;
00279               deep_copy = this->ptr_;
00280               this->ptr_ = tmp;
00281               delete deep_copy;
00282             }
00283         }
00284     }
00285   
00286   return *this;
00287 }
00288 
00289 ACE_INLINE const ::CORBA::DomainManagerList *
00290 CORBA::DomainManagerList_var::operator-> (void) const
00291 {
00292   return this->ptr_;
00293 }
00294 
00295 ACE_INLINE ::CORBA::DomainManagerList *
00296 CORBA::DomainManagerList_var::operator-> (void)
00297 {
00298   return this->ptr_;
00299 }
00300 
00301 ACE_INLINE 
00302 CORBA::DomainManagerList_var::operator const ::CORBA::DomainManagerList &() const // cast
00303 {
00304   return *this->ptr_;
00305 }
00306 
00307 ACE_INLINE 
00308 CORBA::DomainManagerList_var::operator ::CORBA::DomainManagerList &() // cast 
00309 {
00310   return *this->ptr_;
00311 }
00312 
00313 ACE_INLINE 
00314 CORBA::DomainManagerList_var::operator ::CORBA::DomainManagerList &() const // cast 
00315 {
00316   return *this->ptr_;
00317 }
00318 
00319 // variable-size types only
00320 ACE_INLINE
00321 CORBA::DomainManagerList_var::operator ::CORBA::DomainManagerList *&() // cast 
00322 {
00323   return this->ptr_;
00324 }
00325 
00326 ACE_INLINE TAO_Object_Manager<CORBA::DomainManager, CORBA::DomainManager_var>
00327 CORBA::DomainManagerList_var::operator[] (CORBA::ULong index)
00328 {
00329   return this->ptr_->operator[] (index);
00330 }
00331 
00332 ACE_INLINE const ::CORBA::DomainManagerList &
00333 CORBA::DomainManagerList_var::in (void) const
00334 {
00335   return *this->ptr_;
00336 }
00337 
00338 ACE_INLINE ::CORBA::DomainManagerList &
00339 CORBA::DomainManagerList_var::inout (void)
00340 {
00341   return *this->ptr_;
00342 }
00343 
00344 // mapping for variable size 
00345 ACE_INLINE ::CORBA::DomainManagerList *&
00346 CORBA::DomainManagerList_var::out (void)
00347 {
00348   delete this->ptr_;
00349   this->ptr_ = 0;
00350   return this->ptr_;
00351 }
00352 
00353 ACE_INLINE ::CORBA::DomainManagerList *
00354 CORBA::DomainManagerList_var::_retn (void)
00355 {
00356   ::CORBA::DomainManagerList *tmp = this->ptr_;
00357   this->ptr_ = 0;
00358   return tmp;
00359 }
00360 
00361 ACE_INLINE ::CORBA::DomainManagerList *
00362 CORBA::DomainManagerList_var::ptr (void) const
00363 {
00364   return this->ptr_;
00365 }
00366 
00367 // *************************************************************
00368 // Inline operations for class CORBA::DomainManagerList_out
00369 // *************************************************************
00370 
00371 ACE_INLINE
00372 CORBA::DomainManagerList_out::DomainManagerList_out (DomainManagerList *&p)
00373   : ptr_ (p)
00374 {
00375   this->ptr_ = 0;
00376 }
00377 
00378 ACE_INLINE
00379 CORBA::DomainManagerList_out::DomainManagerList_out (DomainManagerList_var &p) // constructor from _var
00380   : ptr_ (p.out ())
00381 {
00382   delete this->ptr_;
00383   this->ptr_ = 0;
00384 }
00385 
00386 ACE_INLINE
00387 CORBA::DomainManagerList_out::DomainManagerList_out (const ::CORBA::DomainManagerList_out &p) // copy constructor
00388   : ptr_ (ACE_const_cast (DomainManagerList_out&, p).ptr_)
00389 {}
00390 
00391 ACE_INLINE ::CORBA::DomainManagerList_out &
00392 CORBA::DomainManagerList_out::operator= (const ::CORBA::DomainManagerList_out &p)
00393 {
00394   this->ptr_ = ACE_const_cast (DomainManagerList_out&, p).ptr_;
00395   return *this;
00396 }
00397 
00398 ACE_INLINE ::CORBA::DomainManagerList_out &
00399 CORBA::DomainManagerList_out::operator= (DomainManagerList *p)
00400 {
00401   this->ptr_ = p;
00402   return *this;
00403 }
00404 
00405 ACE_INLINE 
00406 CORBA::DomainManagerList_out::operator ::CORBA::DomainManagerList *&() // cast
00407 {
00408   return this->ptr_;
00409 }
00410 
00411 ACE_INLINE ::CORBA::DomainManagerList *&
00412 CORBA::DomainManagerList_out::ptr (void) // ptr
00413 {
00414   return this->ptr_;
00415 }
00416 
00417 ACE_INLINE ::CORBA::DomainManagerList *
00418 CORBA::DomainManagerList_out::operator-> (void)
00419 {
00420   return this->ptr_;
00421 }
00422 
00423 ACE_INLINE TAO_Object_Manager<CORBA::DomainManager, CORBA::DomainManager_var>
00424 CORBA::DomainManagerList_out::operator[] (CORBA::ULong index)
00425 {
00426   return this->ptr_->operator[] (index);
00427 }
00428 
00429 
00430 #endif /* end #if !defined */
00431 
00432 TAO_Export CORBA::Boolean operator<< (
00433     TAO_OutputCDR &,
00434     const CORBA::DomainManager_ptr
00435   );
00436 
00437 TAO_Export CORBA::Boolean operator>> (
00438     TAO_InputCDR &,
00439     CORBA::DomainManager_ptr &
00440   );
00441 
00442 TAO_Export CORBA::Boolean operator<< (
00443     TAO_OutputCDR &,
00444     const CORBA::ConstructionPolicy_ptr
00445   );
00446 
00447 TAO_Export CORBA::Boolean operator>> (
00448     TAO_InputCDR &,
00449     CORBA::ConstructionPolicy_ptr &
00450   );
00451 
00452 
00453 #if !defined _TAO_CDR_OP_CORBA_DomainManagerList_I_
00454 #define _TAO_CDR_OP_CORBA_DomainManagerList_I_
00455 
00456 CORBA::Boolean TAO_Export operator<< (
00457     TAO_OutputCDR &,
00458     const CORBA::DomainManagerList &
00459   );
00460 CORBA::Boolean TAO_Export operator>> (
00461     TAO_InputCDR &,
00462     CORBA::DomainManagerList &
00463   );
00464 
00465 #endif /* _TAO_CDR_OP_CORBA_DomainManagerList_I_ */
00466 

Generated on Mon Jun 16 13:48:18 2003 for TAO by doxygen1.2.14 written by Dimitri van Heesch, © 1997-2002