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

DomainC.cpp File Reference

#include "tao_pch.h"
#include "DomainC.h"
#include "tao/Stub.h"
#include "tao/Invocation.h"
#include "tao/PortableInterceptor.h"
#include "tao/RequestInfo_Util.h"
#include "tao/ClientRequestInfo_i.h"
#include "tao/ClientInterceptorAdapter.h"
#include "tao/IFR_Client_Adapter.h"
#include "ace/Dynamic_Service.h"
#include "DomainC.i"

Include dependency graph for DomainC.cpp:

Include dependency graph

Go to the source code of this file.

Defines

#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_DOMAINMANAGERLIST_CS_
#define _CORBA_DOMAINMANAGERLIST_CS_

Functions

CORBA::DomainManager_ptr tao_CORBA_DomainManager_duplicate (CORBA::DomainManager_ptr p)
void tao_CORBA_DomainManager_release (CORBA::DomainManager_ptr p)
CORBA::DomainManager_ptr tao_CORBA_DomainManager_nil (void)
CORBA::DomainManager_ptr tao_CORBA_DomainManager_narrow (CORBA::Object *p ACE_ENV_ARG_DECL)
CORBA::Objecttao_CORBA_DomainManager_upcast (void *src)
CORBA::TypeCode _tc_TAO_tc_CORBA_DomainManager (CORBA::tk_objref, sizeof(_oc_CORBA_DomainManager),(char *)&_oc_CORBA_DomainManager, 0, sizeof(CORBA::DomainManager))
CORBA::ConstructionPolicy_ptr tao_CORBA_ConstructionPolicy_duplicate (CORBA::ConstructionPolicy_ptr p)
void tao_CORBA_ConstructionPolicy_release (CORBA::ConstructionPolicy_ptr p)
CORBA::ConstructionPolicy_ptr tao_CORBA_ConstructionPolicy_nil (void)
CORBA::ConstructionPolicy_ptr tao_CORBA_ConstructionPolicy_narrow (CORBA::Object *p ACE_ENV_ARG_DECL)
CORBA::Objecttao_CORBA_ConstructionPolicy_upcast (void *src)
CORBA::TypeCode _tc_TAO_tc_CORBA_ConstructionPolicy (CORBA::tk_objref, sizeof(_oc_CORBA_ConstructionPolicy),(char *)&_oc_CORBA_ConstructionPolicy, 0, sizeof(CORBA::ConstructionPolicy))
CORBA::TypeCode _tc_TAO_tc_CORBA_DomainManagerList (CORBA::tk_alias, sizeof(_oc_CORBA_DomainManagerList),(char *)&_oc_CORBA_DomainManagerList, 0, sizeof(CORBA::DomainManagerList))
TAO_NAMESPACE_END void operator<<= (CORBA::Any &_tao_any, CORBA::DomainManager_ptr _tao_elem)
void operator<<= (CORBA::Any &_tao_any, CORBA::DomainManager_ptr *_tao_elem)
CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::DomainManager_ptr &_tao_elem)
void operator<<= (CORBA::Any &_tao_any, CORBA::ConstructionPolicy_ptr _tao_elem)
void operator<<= (CORBA::Any &_tao_any, CORBA::ConstructionPolicy_ptr *_tao_elem)
CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ConstructionPolicy_ptr &_tao_elem)
void operator<<= (CORBA::Any &_tao_any, const CORBA::DomainManagerList &_tao_elem)
void operator<<= (CORBA::Any &_tao_any, CORBA::DomainManagerList *_tao_elem)
CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::DomainManagerList *&_tao_elem)
CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::DomainManagerList *&_tao_elem)
CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA::DomainManager_ptr _tao_objref)
CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA::DomainManager_ptr &_tao_objref)
CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA::ConstructionPolicy_ptr _tao_objref)
CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA::ConstructionPolicy_ptr &_tao_objref)
CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA::DomainManagerList &_tao_sequence)
CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA::DomainManagerList &_tao_sequence)

Variables

CORBA::_TAO_DomainManager_Proxy_Broker *(* CORBA__TAO_DomainManager_Proxy_Broker_Factory_function_pointer )(CORBA::Object_ptr obj)=0
const CORBA::Long _oc_CORBA_DomainManager []
CORBA::_TAO_ConstructionPolicy_Proxy_Broker *(* CORBA__TAO_ConstructionPolicy_Proxy_Broker_Factory_function_pointer )(CORBA::Object_ptr obj)=0
const CORBA::Long _oc_CORBA_ConstructionPolicy []
const CORBA::Long _oc_CORBA_DomainManagerList []


Define Documentation

#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_DOMAINMANAGERLIST_CS_
 

Definition at line 1616 of file DomainC.cpp.

#define _CORBA_DOMAINMANAGERLIST_CS_
 

Definition at line 1707 of file DomainC.cpp.


Function Documentation

CORBA::TypeCode _tc_TAO_tc_CORBA_ConstructionPolicy CORBA::tk_objref   ,
sizeof(_oc_CORBA_ConstructionPolicy  ,
(char *)&    _oc_CORBA_ConstructionPolicy,
 ,
sizeof(CORBA::ConstructionPolicy  
[static]
 

CORBA::TypeCode _tc_TAO_tc_CORBA_DomainManager CORBA::tk_objref   ,
sizeof(_oc_CORBA_DomainManager  ,
(char *)&    _oc_CORBA_DomainManager,
 ,
sizeof(CORBA::DomainManager  
[static]
 

CORBA::TypeCode _tc_TAO_tc_CORBA_DomainManagerList CORBA::tk_alias   ,
sizeof(_oc_CORBA_DomainManagerList  ,
(char *)&    _oc_CORBA_DomainManagerList,
 ,
sizeof(CORBA::DomainManagerList  
[static]
 

CORBA::Boolean operator<< TAO_OutputCDR   strm,
const CORBA::DomainManagerList   _tao_sequence
 

Definition at line 2210 of file DomainC.cpp.

References TAO_Unbounded_Base_Sequence::length.

02214 {
02215   if (strm << _tao_sequence.length ())
02216   {
02217     // encode all elements
02218     CORBA::Boolean _tao_marshal_flag = 1;
02219     for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
02220     {
02221       _tao_marshal_flag = (strm << _tao_sequence[i].in ());
02222     }
02223     return _tao_marshal_flag;
02224   }
02225   return 0; // error
02226 }

TAO_Export CORBA::Boolean operator<< TAO_OutputCDR   strm,
const CORBA::ConstructionPolicy_ptr    _tao_objref
 

Definition at line 2174 of file DomainC.cpp.

02178 {
02179   CORBA::Object_ptr _tao_corba_obj = _tao_objref;
02180   return (strm << _tao_corba_obj);
02181 }

CORBA::Boolean operator<< TAO_OutputCDR   strm,
const CORBA::DomainManager_ptr    _tao_objref
 

Definition at line 2138 of file DomainC.cpp.

02142 {
02143   CORBA::Object_ptr _tao_corba_obj = _tao_objref;
02144   return (strm << _tao_corba_obj);
02145 }

void operator<<= CORBA::Any   _tao_any,
CORBA::DomainManagerList   _tao_elem
 

Definition at line 2033 of file DomainC.cpp.

References CORBA::DomainManagerList::_tao_any_destructor, ACE_OutputCDR::begin, and TAO_ENCAP_BYTE_ORDER.

02037 {
02038   TAO_OutputCDR stream;
02039   
02040   if (stream << *_tao_elem)
02041     {
02042       _tao_any._tao_replace (
02043           CORBA::_tc_DomainManagerList,
02044           TAO_ENCAP_BYTE_ORDER,
02045           stream.begin (),
02046           1,
02047           _tao_elem,
02048           CORBA::DomainManagerList::_tao_any_destructor
02049         );
02050     }
02051 }

void operator<<= CORBA::Any   _tao_any,
const CORBA::DomainManagerList   _tao_elem
 

Definition at line 2015 of file DomainC.cpp.

References ACE_OutputCDR::begin, and TAO_ENCAP_BYTE_ORDER.

02019 {
02020   TAO_OutputCDR stream;
02021   
02022   if (stream << _tao_elem)
02023     {
02024       _tao_any._tao_replace (
02025           CORBA::_tc_DomainManagerList,
02026           TAO_ENCAP_BYTE_ORDER,
02027           stream.begin ()
02028         );
02029     }
02030 }

void operator<<= CORBA::Any   _tao_any,
CORBA::ConstructionPolicy_ptr   _tao_elem
 

Definition at line 1935 of file DomainC.cpp.

References CORBA::ConstructionPolicy::_tao_any_destructor, ACE_OutputCDR::begin, and TAO_ENCAP_BYTE_ORDER.

01939 {
01940   TAO_OutputCDR stream;
01941   
01942   if (stream << *_tao_elem)
01943     {
01944       _tao_any._tao_replace (
01945           CORBA::_tc_ConstructionPolicy, 
01946           TAO_ENCAP_BYTE_ORDER,
01947           stream.begin (),
01948           1,
01949           *_tao_elem,
01950           CORBA::ConstructionPolicy::_tao_any_destructor
01951         );
01952     }
01953 }

TAO_Export void operator<<= CORBA::Any   _tao_any,
CORBA::ConstructionPolicy_ptr    _tao_elem
 

Definition at line 1915 of file DomainC.cpp.

References CORBA::ConstructionPolicy::_duplicate, CORBA::ConstructionPolicy::_tao_any_destructor, ACE_OutputCDR::begin, and TAO_ENCAP_BYTE_ORDER.

01919 {
01920   TAO_OutputCDR stream;
01921   
01922   if (stream << _tao_elem)
01923     {
01924       _tao_any._tao_replace (
01925           CORBA::_tc_ConstructionPolicy, 
01926           TAO_ENCAP_BYTE_ORDER,
01927           stream.begin (),
01928           1,
01929           CORBA::ConstructionPolicy::_duplicate (_tao_elem),
01930           CORBA::ConstructionPolicy::_tao_any_destructor
01931         );
01932     }
01933 }

void operator<<= CORBA::Any   _tao_any,
CORBA::DomainManager_ptr   _tao_elem
 

Definition at line 1836 of file DomainC.cpp.

References CORBA::DomainManager::_tao_any_destructor, ACE_OutputCDR::begin, and TAO_ENCAP_BYTE_ORDER.

01840 {
01841   TAO_OutputCDR stream;
01842   
01843   if (stream << *_tao_elem)
01844     {
01845       _tao_any._tao_replace (
01846           CORBA::_tc_DomainManager, 
01847           TAO_ENCAP_BYTE_ORDER,
01848           stream.begin (),
01849           1,
01850           *_tao_elem,
01851           CORBA::DomainManager::_tao_any_destructor
01852         );
01853     }
01854 }

TAO_NAMESPACE_END void operator<<= CORBA::Any   _tao_any,
CORBA::DomainManager_ptr    _tao_elem
 

Definition at line 1816 of file DomainC.cpp.

References CORBA::DomainManager::_duplicate, CORBA::DomainManager::_tao_any_destructor, ACE_OutputCDR::begin, and TAO_ENCAP_BYTE_ORDER.

01820 {
01821   TAO_OutputCDR stream;
01822   
01823   if (stream << _tao_elem)
01824     {
01825       _tao_any._tao_replace (
01826           CORBA::_tc_DomainManager, 
01827           TAO_ENCAP_BYTE_ORDER,
01828           stream.begin (),
01829           1,
01830           CORBA::DomainManager::_duplicate (_tao_elem),
01831           CORBA::DomainManager::_tao_any_destructor
01832         );
01833     }
01834 }

CORBA::Boolean operator>> TAO_InputCDR   strm,
CORBA::DomainManagerList   _tao_sequence
 

Definition at line 2228 of file DomainC.cpp.

References TAO_Unbounded_Base_Sequence::length, and ACE_InputCDR::length.

02232 {
02233   CORBA::ULong _tao_seq_len;
02234   if (strm >> _tao_seq_len)
02235   {
02236     // Add a check to the length of the sequence
02237     // to make sure it does not exceed the length
02238     // of the stream. (See bug 1159.)
02239     if (_tao_seq_len > strm.length())
02240       return 0;
02241     // set the length of the sequence
02242     _tao_sequence.length (_tao_seq_len);
02243     // If length is 0 we return true.
02244     if (0 >= _tao_seq_len) 
02245       return 1;
02246     // retrieve all the elements
02247     CORBA::Boolean _tao_marshal_flag = 1;
02248     for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
02249     {
02250       _tao_marshal_flag = (strm >> _tao_sequence[i].out ());
02251     }
02252     return _tao_marshal_flag;
02253   }
02254   return 0; // error
02255 }

CORBA::Boolean operator>> TAO_InputCDR   strm,
CORBA::ConstructionPolicy_ptr   _tao_objref
 

Definition at line 2183 of file DomainC.cpp.

References CORBA::ConstructionPolicy::_unchecked_narrow, ACE_CATCHANY, ACE_ENDTRY, ACE_ENV_ARG_PARAMETER, ACE_TRY_CHECK, and ACE_TRY_NEW_ENV.

02187 {
02188   ACE_TRY_NEW_ENV
02189   {
02190     CORBA::Object_var obj;
02191     if ((strm >> obj.inout ()) == 0)
02192       return 0;
02193     // narrow to the right type
02194     _tao_objref =
02195       CORBA::ConstructionPolicy::_unchecked_narrow (
02196           obj.in ()
02197           ACE_ENV_ARG_PARAMETER
02198         );
02199     ACE_TRY_CHECK;
02200     return 1;
02201   }
02202   ACE_CATCHANY
02203   {
02204     // do nothing
02205   }
02206   ACE_ENDTRY;
02207   return 0;
02208 }

CORBA::Boolean operator>> TAO_InputCDR   strm,
CORBA::DomainManager_ptr   _tao_objref
 

Definition at line 2147 of file DomainC.cpp.

References CORBA::DomainManager::_unchecked_narrow, ACE_CATCHANY, ACE_ENDTRY, ACE_ENV_ARG_PARAMETER, ACE_TRY_CHECK, and ACE_TRY_NEW_ENV.

02151 {
02152   ACE_TRY_NEW_ENV
02153   {
02154     CORBA::Object_var obj;
02155     if ((strm >> obj.inout ()) == 0)
02156       return 0;
02157     // narrow to the right type
02158     _tao_objref =
02159       CORBA::DomainManager::_unchecked_narrow (
02160           obj.in ()
02161           ACE_ENV_ARG_PARAMETER
02162         );
02163     ACE_TRY_CHECK;
02164     return 1;
02165   }
02166   ACE_CATCHANY
02167   {
02168     // do nothing
02169   }
02170   ACE_ENDTRY;
02171   return 0;
02172 }

CORBA::Boolean operator>>= const CORBA::Any   _tao_any,
const CORBA::DomainManagerList *&    _tao_elem
 

Definition at line 2066 of file DomainC.cpp.

References CORBA::DomainManagerList::_tao_any_destructor, ACE_CATCHANY, ACE_ENDTRY, ACE_ENV_ARG_PARAMETER, ACE_NEW_RETURN, ACE_TRY_CHECK, and ACE_TRY_NEW_ENV.

02070 {
02071   _tao_elem = 0;
02072   
02073   ACE_TRY_NEW_ENV
02074   {
02075     CORBA::TypeCode_var type = _tao_any.type ();
02076     
02077     CORBA::Boolean result =
02078       type->equivalent (
02079           CORBA::_tc_DomainManagerList
02080           ACE_ENV_ARG_PARAMETER
02081         );
02082     ACE_TRY_CHECK;
02083     
02084     if (!result)
02085       {
02086         return 0; // not equivalent
02087       }
02088     
02089     if (_tao_any.any_owns_data ())
02090       {
02091         _tao_elem = ACE_static_cast(
02092             const CORBA::DomainManagerList*,
02093             _tao_any.value ()
02094           );
02095         
02096         return 1;
02097       }
02098     else
02099       {
02100         CORBA::DomainManagerList *tmp = 0;
02101         ACE_NEW_RETURN (
02102             tmp,
02103             CORBA::DomainManagerList,
02104             0
02105           );
02106         
02107         TAO_InputCDR stream (
02108             _tao_any._tao_get_cdr (),
02109             _tao_any._tao_byte_order ()
02110           );
02111         
02112         if (stream >> *tmp)
02113           {
02114             ((CORBA::Any *)&_tao_any)->_tao_replace (
02115                 CORBA::_tc_DomainManagerList,
02116                 1,
02117                 ACE_static_cast (void *, tmp),
02118                 CORBA::DomainManagerList::_tao_any_destructor
02119               );
02120             
02121             _tao_elem = tmp;
02122             return 1;
02123           }
02124         else
02125           {
02126             delete tmp;
02127           }
02128       }
02129   }
02130   ACE_CATCHANY
02131   {
02132   }
02133   ACE_ENDTRY;
02134   
02135   return 0;
02136 }

CORBA::Boolean operator>>= const CORBA::Any   _tao_any,
CORBA::DomainManagerList *&    _tao_elem
 

Definition at line 2054 of file DomainC.cpp.

02058 {
02059   return _tao_any >>= ACE_const_cast(
02060       const CORBA::DomainManagerList*&,
02061       _tao_elem
02062     );
02063 }

CORBA::Boolean operator>>= const CORBA::Any   _tao_any,
CORBA::ConstructionPolicy_ptr   _tao_elem
 

Definition at line 1955 of file DomainC.cpp.

References CORBA::ConstructionPolicy::_nil, CORBA::ConstructionPolicy::_tao_any_destructor, ACE_CATCHANY, ACE_ENDTRY, ACE_ENV_ARG_PARAMETER, ACE_TRY_CHECK, and ACE_TRY_NEW_ENV.

01959 {
01960   ACE_TRY_NEW_ENV
01961   {
01962     _tao_elem = CORBA::ConstructionPolicy::_nil ();
01963     CORBA::TypeCode_var type = _tao_any.type ();
01964     
01965     CORBA::Boolean result =
01966       type->equivalent (
01967           CORBA::_tc_ConstructionPolicy
01968           ACE_ENV_ARG_PARAMETER
01969         );
01970     ACE_TRY_CHECK;
01971     
01972     if (!result)
01973       {
01974         return 0; // not equivalent
01975       }
01976     
01977     TAO_InputCDR stream (
01978         _tao_any._tao_get_cdr (),
01979         _tao_any._tao_byte_order ()
01980       );
01981     
01982     if (stream >> _tao_elem)
01983       {
01984         ((CORBA::Any *)&_tao_any)->_tao_replace (
01985             CORBA::_tc_ConstructionPolicy,
01986             1,
01987             _tao_elem,
01988             CORBA::ConstructionPolicy::_tao_any_destructor
01989           );
01990         
01991         return 1;
01992       }
01993   }
01994   ACE_CATCHANY
01995   {
01996   }
01997   ACE_ENDTRY;
01998   
01999   _tao_elem = CORBA::ConstructionPolicy::_nil ();
02000   return 0;
02001 }

CORBA::Boolean operator>>= const CORBA::Any   _tao_any,
CORBA::DomainManager_ptr   _tao_elem
 

Definition at line 1856 of file DomainC.cpp.

References CORBA::DomainManager::_nil, CORBA::DomainManager::_tao_any_destructor, ACE_CATCHANY, ACE_ENDTRY, ACE_ENV_ARG_PARAMETER, ACE_TRY_CHECK, and ACE_TRY_NEW_ENV.

01860 {
01861   ACE_TRY_NEW_ENV
01862   {
01863     _tao_elem = CORBA::DomainManager::_nil ();
01864     CORBA::TypeCode_var type = _tao_any.type ();
01865     
01866     CORBA::Boolean result =
01867       type->equivalent (
01868           CORBA::_tc_DomainManager
01869           ACE_ENV_ARG_PARAMETER
01870         );
01871     ACE_TRY_CHECK;
01872     
01873     if (!result)
01874       {
01875         return 0; // not equivalent
01876       }
01877     
01878     TAO_InputCDR stream (
01879         _tao_any._tao_get_cdr (),
01880         _tao_any._tao_byte_order ()
01881       );
01882     
01883     if (stream >> _tao_elem)
01884       {
01885         ((CORBA::Any *)&_tao_any)->_tao_replace (
01886             CORBA::_tc_DomainManager,
01887             1,
01888             _tao_elem,
01889             CORBA::DomainManager::_tao_any_destructor
01890           );
01891         
01892         return 1;
01893       }
01894   }
01895   ACE_CATCHANY
01896   {
01897   }
01898   ACE_ENDTRY;
01899   
01900   _tao_elem = CORBA::DomainManager::_nil ();
01901   return 0;
01902 }

CORBA::ConstructionPolicy_ptr tao_CORBA_ConstructionPolicy_duplicate CORBA::ConstructionPolicy_ptr    p
 

Definition at line 831 of file DomainC.cpp.

References CORBA::ConstructionPolicy::_duplicate.

00834 {
00835   return CORBA::ConstructionPolicy::_duplicate (p);
00836 }

CORBA::ConstructionPolicy_ptr tao_CORBA_ConstructionPolicy_narrow CORBA::Object *p    ACE_ENV_ARG_DECL
 

Definition at line 855 of file DomainC.cpp.

References CORBA::ConstructionPolicy::_narrow, ACE_ENV_ARG_DECL, and ACE_ENV_ARG_PARAMETER.

CORBA::ConstructionPolicy_ptr tao_CORBA_ConstructionPolicy_nil void   
 

Definition at line 847 of file DomainC.cpp.

References CORBA::ConstructionPolicy::_nil.

00850 {
00851   return CORBA::ConstructionPolicy::_nil ();
00852 }

void tao_CORBA_ConstructionPolicy_release CORBA::ConstructionPolicy_ptr    p
 

Definition at line 839 of file DomainC.cpp.

References CORBA::release.

00842 {
00843   CORBA::release (p);
00844 }

CORBA::Object* tao_CORBA_ConstructionPolicy_upcast void *    src
 

Definition at line 864 of file DomainC.cpp.

00867 {
00868   CORBA::ConstructionPolicy **tmp =
00869     ACE_static_cast (CORBA::ConstructionPolicy **, src);
00870   return *tmp;
00871 }

CORBA::DomainManager_ptr tao_CORBA_DomainManager_duplicate CORBA::DomainManager_ptr    p
 

Definition at line 53 of file DomainC.cpp.

References CORBA::DomainManager::_duplicate.

00056 {
00057   return CORBA::DomainManager::_duplicate (p);
00058 }

CORBA::DomainManager_ptr tao_CORBA_DomainManager_narrow CORBA::Object *p    ACE_ENV_ARG_DECL
 

Definition at line 77 of file DomainC.cpp.

References CORBA::DomainManager::_narrow, ACE_ENV_ARG_DECL, and ACE_ENV_ARG_PARAMETER.

00081 {
00082   return CORBA::DomainManager::_narrow (p ACE_ENV_ARG_PARAMETER);
00083 }

CORBA::DomainManager_ptr tao_CORBA_DomainManager_nil void   
 

Definition at line 69 of file DomainC.cpp.

References CORBA::DomainManager::_nil.

00072 {
00073   return CORBA::DomainManager::_nil ();
00074 }

void tao_CORBA_DomainManager_release CORBA::DomainManager_ptr    p
 

Definition at line 61 of file DomainC.cpp.

References CORBA::release.

00064 {
00065   CORBA::release (p);
00066 }

CORBA::Object* tao_CORBA_DomainManager_upcast void *    src
 

Definition at line 86 of file DomainC.cpp.

00089 {
00090   CORBA::DomainManager **tmp =
00091     ACE_static_cast (CORBA::DomainManager **, src);
00092   return *tmp;
00093 }


Variable Documentation

const CORBA::Long _oc_CORBA_ConstructionPolicy[] [static]
 

Initial value:

{
  TAO_ENCAP_BYTE_ORDER, 
  41,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x434f5242), 
  ACE_NTOHL (0x412f436f), 
  ACE_NTOHL (0x6e737472), 
  ACE_NTOHL (0x75637469), 
  ACE_NTOHL (0x6f6e506f), 
  ACE_NTOHL (0x6c696379), 
  ACE_NTOHL (0x3a312e30), 
  ACE_NTOHL (0x0),  
  19,
  ACE_NTOHL (0x436f6e73), 
  ACE_NTOHL (0x74727563), 
  ACE_NTOHL (0x74696f6e), 
  ACE_NTOHL (0x506f6c69), 
  ACE_NTOHL (0x63790000),  
}

Definition at line 1576 of file DomainC.cpp.

const CORBA::Long _oc_CORBA_DomainManager[] [static]
 

Initial value:

{
  TAO_ENCAP_BYTE_ORDER, 
  36,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x434f5242), 
  ACE_NTOHL (0x412f446f), 
  ACE_NTOHL (0x6d61696e), 
  ACE_NTOHL (0x4d616e61), 
  ACE_NTOHL (0x6765723a), 
  ACE_NTOHL (0x312e3000),  
  14,
  ACE_NTOHL (0x446f6d61), 
  ACE_NTOHL (0x696e4d61), 
  ACE_NTOHL (0x6e616765), 
  ACE_NTOHL (0x72000000),  
}

Definition at line 787 of file DomainC.cpp.

const CORBA::Long _oc_CORBA_DomainManagerList[] [static]
 

Definition at line 1753 of file DomainC.cpp.

CORBA::_TAO_ConstructionPolicy_Proxy_Broker*(* CORBA__TAO_ConstructionPolicy_Proxy_Broker_Factory_function_pointer)( CORBA::Object_ptr obj ) = 0
 

Definition at line 1358 of file DomainC.cpp.

Referenced by CORBA::ConstructionPolicy::_unchecked_narrow.

CORBA::_TAO_DomainManager_Proxy_Broker*(* CORBA__TAO_DomainManager_Proxy_Broker_Factory_function_pointer)( CORBA::Object_ptr obj ) = 0
 

Definition at line 586 of file DomainC.cpp.

Referenced by CORBA::DomainManager::_unchecked_narrow.


Generated on Mon Jun 16 14:04:33 2003 for TAO by doxygen1.2.14 written by Dimitri van Heesch, © 1997-2002