CDR.h
Go to the documentation of this file.
00001 // -*- C++ -*- 00002 00003 //============================================================================= 00004 /** 00005 * @file CDR.h 00006 * 00007 * $Id: CDR.h 90586 2010-06-14 13:48:01Z parsons $ 00008 * 00009 * Common Data Representation (CDR) marshaling streams. 00010 * 00011 * This implementation assumes that the native numeric 00012 * representation is two's complement for integers, IEEE 00013 * single/double for floats. Also that characters are in ISO 00014 * Latin/1. 00015 * 00016 * Note that CDR itself makes no such assumptions, but this 00017 * implementation makes such assumptions for reasons of 00018 * efficiency. Careful enhancements could preserve that 00019 * efficiency where the assumptions are true, yet still allow the 00020 * code to work when they aren't true. 00021 * 00022 * The implementation expects that buffers are aligned according 00023 * to the strongest CDR alignment restriction. 00024 * 00025 * NOTE: this does everything "CDR 1.1" does ... that is, it 00026 * supports the five extended OMG-IDL data types in UNO Appendix 00027 * A, which provide richer arithmetic types (64 bit integers, 00028 * "quad precision" FP) and UNICODE-based characters and strings. 00029 * Those types are not standard parts of OMG-IDL at this time. 00030 * 00031 * THREADING NOTE: CDR data structures must be protected against 00032 * concurrent access by their owning thread. 00033 * 00034 * 00035 * @author Copyright 1994-1995 by Sun Microsystems Inc. 00036 * @author Aniruddha Gokhale 00037 * @author Carlos O'Ryan 00038 */ 00039 //============================================================================= 00040 00041 00042 #ifndef TAO_CDR_H 00043 #define TAO_CDR_H 00044 00045 #include /**/ "ace/pre.h" 00046 00047 #include "tao/orbconf.h" 00048 00049 #if !defined (ACE_LACKS_PRAGMA_ONCE) 00050 # pragma once 00051 #endif /* ACE_LACKS_PRAGMA_ONCE */ 00052 00053 #include /**/ "tao/TAO_Export.h" 00054 #include "tao/Basic_Types.h" 00055 #include "tao/GIOP_Message_Version.h" 00056 #include "tao/Message_Semantics.h" 00057 #include "tao/Intrusive_Ref_Count_Handle_T.h" 00058 #include "tao/Intrusive_Ref_Count_Object_T.h" 00059 00060 #include "ace/CDR_Stream.h" 00061 #include "ace/SString.h" 00062 #include "ace/Hash_Map_Manager_T.h" 00063 #include "ace/Null_Mutex.h" 00064 00065 #include <string> 00066 00067 TAO_BEGIN_VERSIONED_NAMESPACE_DECL 00068 00069 class TAO_ORB_Core; 00070 class TAO_GIOP_Fragmentation_Strategy; 00071 class TAO_Stub; 00072 00073 /** 00074 * @class TAO_OutputCDR 00075 * 00076 * @brief A CDR stream for writing, i.e. for marshalling. 00077 * 00078 * This class is based on the the CORBA spec for Java (98-02-29), 00079 * java class omg.org.CORBA.portable.OutputStream. 00080 * It diverts in a few ways: 00081 * + Operations taking arrays don't have offsets, because in C++ 00082 * it is easier to describe an array starting from x+offset. 00083 * + Operations return an error status, because exceptions are 00084 * not widely available in C++ (yet). 00085 * A particularly useful static member function for this buffer is 00086 * an interpretive encoding routine, usable as a typecode 00087 * interpreter callback. Ditto for decoding. These are used to 00088 * support all OMG-IDL datatypes, even those not supported 00089 * directly by put/get primitives. 00090 */ 00091 class TAO_Export TAO_OutputCDR : public ACE_OutputCDR 00092 { 00093 public: 00094 /// For reading from a output CDR stream. 00095 friend class TAO_InputCDR; 00096 typedef ACE_Hash_Map_Manager<ACE_CString, char*, ACE_Null_Mutex> Repo_Id_Map; 00097 typedef Repo_Id_Map Codebase_URL_Map; 00098 typedef ACE_Hash_Map_Manager<void*, char*, ACE_Null_Mutex> Value_Map; 00099 00100 typedef TAO_Intrusive_Ref_Count_Object<Repo_Id_Map, ACE_Null_Mutex> RC_Repo_Id_Map; 00101 typedef TAO_Intrusive_Ref_Count_Object<Codebase_URL_Map, ACE_Null_Mutex> RC_Codebase_URL_Map; 00102 typedef TAO_Intrusive_Ref_Count_Object<Value_Map, ACE_Null_Mutex> RC_Value_Map; 00103 00104 typedef TAO_Intrusive_Ref_Count_Handle<RC_Repo_Id_Map> Repo_Id_Map_Handle; 00105 typedef TAO_Intrusive_Ref_Count_Handle<RC_Codebase_URL_Map> Codebase_URL_Map_Handle; 00106 typedef TAO_Intrusive_Ref_Count_Handle<RC_Value_Map> Value_Map_Handle; 00107 00108 // The default values for the allocators and memcpy_tradeoff 00109 // in these constructors are not 0, but are generated by the 00110 // ORB. Refer to the constructor bodies in CDR.cpp for the 00111 // code that supplies these values to the base class constructor. 00112 00113 /// Default constructor, allocates @a size bytes in the internal 00114 /// buffer, if @a size == 0 it allocates the default size. 00115 TAO_OutputCDR (size_t size = 0, 00116 int byte_order = ACE_CDR_BYTE_ORDER, 00117 ACE_Allocator* buffer_allocator = 0, 00118 ACE_Allocator* data_block_allocator = 0, 00119 ACE_Allocator* message_block_allocator = 0, 00120 size_t memcpy_tradeoff = 0, 00121 ACE_CDR::Octet major_version = TAO_DEF_GIOP_MAJOR, 00122 ACE_CDR::Octet minor_version = TAO_DEF_GIOP_MINOR); 00123 00124 /// Build a CDR stream with an initial buffer, it will *not* remove 00125 /// @a data, since it did not allocated it. 00126 TAO_OutputCDR (char *data, 00127 size_t size, 00128 int byte_order = ACE_CDR_BYTE_ORDER, 00129 ACE_Allocator* buffer_allocator = 0, 00130 ACE_Allocator* data_block_allocator = 0, 00131 ACE_Allocator* message_block_allocator = 0, 00132 size_t memcpy_tradeoff = 0, 00133 ACE_CDR::Octet major_version = TAO_DEF_GIOP_MAJOR, 00134 ACE_CDR::Octet minor_version = TAO_DEF_GIOP_MINOR); 00135 00136 /// Build a CDR stream with an initial buffer, it will *not* remove 00137 /// @a data since it did not allocated it, and enable fragmentation 00138 /// support. 00139 TAO_OutputCDR (char *data, 00140 size_t size, 00141 int byte_order, 00142 ACE_Allocator* buffer_allocator, 00143 ACE_Allocator* data_block_allocator, 00144 ACE_Allocator* message_block_allocator, 00145 size_t memcpy_tradeoff, 00146 TAO_GIOP_Fragmentation_Strategy * fs, 00147 ACE_CDR::Octet major_version, 00148 ACE_CDR::Octet minor_version); 00149 00150 /// Build a CDR stream with an initial Message_Block chain, it will *not* 00151 /// remove @a data, since it did not allocate it. 00152 TAO_OutputCDR (ACE_Message_Block *data, 00153 int byte_order = ACE_CDR_BYTE_ORDER, 00154 size_t memcpy_tradeoff = 0, 00155 ACE_CDR::Octet major_version = TAO_DEF_GIOP_MAJOR, 00156 ACE_CDR::Octet minor_version = TAO_DEF_GIOP_MINOR); 00157 00158 /// Build a CDR stream with an initial data block, it will *not* remove 00159 /// @a data, since it did not allocated it. 00160 TAO_OutputCDR (ACE_Data_Block *data, 00161 int byte_order = ACE_CDR_BYTE_ORDER, 00162 ACE_Allocator* message_block_allocator = 0, 00163 size_t memcpy_tradeoff = 0, 00164 TAO_GIOP_Fragmentation_Strategy * fs = 0, 00165 ACE_CDR::Octet major_version = TAO_DEF_GIOP_MAJOR, 00166 ACE_CDR::Octet minor_version = TAO_DEF_GIOP_MINOR); 00167 00168 /// Destructor. 00169 ~TAO_OutputCDR (void); 00170 00171 // @todo do we want a special method to write an array of 00172 // strings and wstrings? 00173 00174 // = TAO specific methods. 00175 static void throw_stub_exception (int error_num); 00176 static void throw_skel_exception (int error_num); 00177 00178 void get_version (TAO_GIOP_Message_Version& giop_version); 00179 00180 /** 00181 * @name Outgoing GIOP Fragment Related Methods 00182 * 00183 * These methods are only used when fragmenting outgoing GIOP 00184 * requests and replies. 00185 */ 00186 //@{ 00187 /// Fragment this output CDR stream if necessary. 00188 /** 00189 * Fragmentation will done through GIOP fragments when the length of 00190 * the CDR stream length will exceed the configured threshold. 00191 */ 00192 bool fragment_stream (ACE_CDR::ULong pending_alignment, 00193 ACE_CDR::ULong pending_length); 00194 00195 /// Are there more data fragments to come? 00196 bool more_fragments (void) const; 00197 00198 /// Specify whether there are more data fragments to come. 00199 void more_fragments (bool more); 00200 00201 /// Set fragmented message attributes. 00202 void message_attributes (CORBA::ULong request_id, 00203 TAO_Stub * stub, 00204 TAO_Message_Semantics message_semantics, 00205 ACE_Time_Value * timeout); 00206 00207 /// Fragmented message request ID. 00208 CORBA::ULong request_id (void) const; 00209 00210 /// Stub object associated with the request. 00211 TAO_Stub * stub (void) const; 00212 00213 /// Message semantics (twoway, oneway, reply) 00214 TAO_Message_Semantics message_semantics (void) const; 00215 00216 /// Maximum time to wait for outgoing message to be sent. 00217 ACE_Time_Value * timeout (void) const; 00218 //@} 00219 00220 /// These methods are used by valuetype indirection support. 00221 /// Accessor to the indirect maps. 00222 Repo_Id_Map_Handle& get_repo_id_map (); 00223 #ifdef TAO_HAS_VALUETYPE_CODEBASE 00224 Codebase_URL_Map_Handle& get_codebase_url_map (); 00225 #endif 00226 Value_Map_Handle& get_value_map (); 00227 00228 /// Updater of the maps. 00229 /// These updaters are used to make indirect maps in original stream 00230 /// take effect even during marshalling/demarshalling a redirected stream. 00231 void set_repo_id_map (Repo_Id_Map_Handle& map); 00232 #ifdef TAO_HAS_VALUETYPE_CODEBASE 00233 Codebase_URL_Map_Handle& get_codebase_url_map (); 00234 void set_codebase_url_map (Codebase_URL_Map_Handle& map); 00235 #endif 00236 void set_value_map (Value_Map_Handle& map); 00237 00238 /// If indirect map is not nil and not empty, unbind all entries. 00239 /// Called after marshalling. 00240 void reset_vt_indirect_maps (); 00241 00242 /// Calculate the offset between pos and current wr_ptr. 00243 int offset (char* pos); 00244 00245 private: 00246 00247 // disallow copying... 00248 TAO_OutputCDR (const TAO_OutputCDR& rhs); 00249 TAO_OutputCDR& operator= (const TAO_OutputCDR& rhs); 00250 00251 private: 00252 00253 /** 00254 * @name Outgoing GIOP Fragment Related Attributes 00255 * 00256 * These attributes are only used when fragmenting outgoing GIOP 00257 * requests and replies. 00258 */ 00259 //@{ 00260 /// Strategy that sends data currently marshaled into this 00261 /// TAO_OutputCDR stream if necessary. 00262 TAO_GIOP_Fragmentation_Strategy * const fragmentation_strategy_; 00263 00264 /// Are there more data fragments to come? 00265 bool more_fragments_; 00266 00267 /// Request ID for the request currently being marshaled. 00268 CORBA::ULong request_id_; 00269 00270 /// Stub object associated with the request. 00271 TAO_Stub * stub_; 00272 00273 /// Twoway, oneway, reply? 00274 /** 00275 * @see TAO_Transport 00276 */ 00277 TAO_Message_Semantics message_semantics_; 00278 00279 /// Request/reply send timeout. 00280 ACE_Time_Value * timeout_; 00281 //@} 00282 00283 /// These maps are used by valuetype indirection support. 00284 Repo_Id_Map_Handle repo_id_map_; 00285 #ifdef TAO_HAS_VALUETYPE_CODEBASE 00286 Codebase_URL_Map_Handle codebase_map_; 00287 #endif 00288 Value_Map_Handle value_map_; 00289 }; 00290 00291 /** 00292 * @class TAO_InputCDR 00293 * 00294 * @brief A CDR stream for reading, i.e. for demarshalling. 00295 * 00296 * This class is based on the the CORBA spec for Java (98-02-29), 00297 * java class omg.org.CORBA.portable.InputStream. 00298 * It diverts in a few ways: 00299 * + Operations to retrieve basic types take parameters by 00300 * reference. 00301 * + Operations taking arrays don't have offsets, because in C++ 00302 * it is easier to describe an array starting from x+offset. 00303 * + Operations return an error status, because exceptions are 00304 * not widely available in C++ (yet). 00305 * A particularly useful static member function for this buffer is 00306 * an interpretive encoding routine, usable as a typecode 00307 * interpreter callback. Ditto for decoding. These are used to 00308 * support all OMG-IDL datatypes, even those not supported 00309 * directly by put/get primitives. 00310 */ 00311 class TAO_Export TAO_InputCDR : public ACE_InputCDR 00312 { 00313 public: 00314 typedef ACE_Hash_Map_Manager<void*, ACE_CString, ACE_Null_Mutex> Repo_Id_Map; 00315 typedef Repo_Id_Map Codebase_URL_Map; 00316 typedef ACE_Hash_Map_Manager<void*, void*, ACE_Null_Mutex> Value_Map; 00317 00318 typedef TAO_Intrusive_Ref_Count_Object<Repo_Id_Map, ACE_Null_Mutex> RC_Repo_Id_Map; 00319 typedef TAO_Intrusive_Ref_Count_Object<Codebase_URL_Map, ACE_Null_Mutex> RC_Codebase_URL_Map; 00320 typedef TAO_Intrusive_Ref_Count_Object<Value_Map, ACE_Null_Mutex> RC_Value_Map; 00321 00322 typedef TAO_Intrusive_Ref_Count_Handle<RC_Repo_Id_Map> Repo_Id_Map_Handle; 00323 typedef TAO_Intrusive_Ref_Count_Handle<RC_Codebase_URL_Map> Codebase_URL_Map_Handle; 00324 typedef TAO_Intrusive_Ref_Count_Handle<RC_Value_Map> Value_Map_Handle; 00325 00326 /** 00327 * Create an input stream from an arbitrary buffer, care must be 00328 * exercised wrt alignment, because this contructor will *not* work 00329 * if the buffer is unproperly aligned. 00330 */ 00331 TAO_InputCDR (const char* buf, 00332 size_t bufsiz, 00333 int byte_order = ACE_CDR_BYTE_ORDER, 00334 ACE_CDR::Octet major_version = TAO_DEF_GIOP_MAJOR, 00335 ACE_CDR::Octet minor_version = TAO_DEF_GIOP_MINOR, 00336 TAO_ORB_Core* orb_core = 0); 00337 00338 /// Create an empty input stream. The caller is responsible for 00339 /// putting the right data and providing the right alignment. 00340 TAO_InputCDR (size_t bufsiz, 00341 int byte_order = ACE_CDR_BYTE_ORDER, 00342 ACE_CDR::Octet major_version = TAO_DEF_GIOP_MAJOR, 00343 ACE_CDR::Octet minor_version = TAO_DEF_GIOP_MINOR, 00344 TAO_ORB_Core* orb_core = 0); 00345 00346 /// Create an input stream from an ACE_Message_Block 00347 TAO_InputCDR (const ACE_Message_Block *data, 00348 int byte_order = ACE_CDR_BYTE_ORDER, 00349 ACE_CDR::Octet major_version = TAO_DEF_GIOP_MAJOR, 00350 ACE_CDR::Octet minor_version = TAO_DEF_GIOP_MINOR, 00351 TAO_ORB_Core* orb_core = 0); 00352 00353 /// Create an input stream from an ACE_Message_Block with an optional lock 00354 /// used to protect the data. 00355 TAO_InputCDR (const ACE_Message_Block *data, 00356 ACE_Lock* lock, 00357 int byte_order = ACE_CDR_BYTE_ORDER, 00358 ACE_CDR::Octet major_version = TAO_DEF_GIOP_MAJOR, 00359 ACE_CDR::Octet minor_version = TAO_DEF_GIOP_MINOR, 00360 TAO_ORB_Core* orb_core = 0); 00361 00362 00363 /// Create an input stream from an ACE_Data_Block 00364 TAO_InputCDR (ACE_Data_Block *data, 00365 ACE_Message_Block::Message_Flags flag = 0, 00366 int byte_order = ACE_CDR_BYTE_ORDER, 00367 ACE_CDR::Octet major_version = TAO_DEF_GIOP_MAJOR, 00368 ACE_CDR::Octet minor_version = TAO_DEF_GIOP_MINOR, 00369 TAO_ORB_Core* orb_core = 0); 00370 00371 /// Create an input stream from an ACE_Data_Block 00372 TAO_InputCDR (ACE_Data_Block *data, 00373 ACE_Message_Block::Message_Flags flag, 00374 size_t read_pointer_position, 00375 size_t write_pointer_position, 00376 int byte_order = ACE_CDR_BYTE_ORDER, 00377 ACE_CDR::Octet major_version = TAO_DEF_GIOP_MAJOR, 00378 ACE_CDR::Octet minor_version = TAO_DEF_GIOP_MINOR, 00379 TAO_ORB_Core* orb_core = 0); 00380 00381 /** 00382 * Make a copy of the current stream state, but does not copy the 00383 * internal buffer; so the same stream can be read multiple times 00384 * efficiently. 00385 */ 00386 TAO_InputCDR (const TAO_InputCDR& rhs); 00387 00388 /// When interpreting indirected TypeCodes it is useful to make a 00389 /// "copy" of the stream starting in the new position. 00390 TAO_InputCDR (const TAO_InputCDR& rhs, 00391 size_t size, 00392 ACE_CDR::Long offset); 00393 /** 00394 * This creates an encapsulated stream, the first byte must be (per 00395 * the spec) the byte order of the encapsulation. The default 00396 * values for the allocators in this constructor are not 0, but are 00397 * generated by the ORB. Refer to the constructor body in CDR.cpp 00398 * for the code that supplies these values to the base class 00399 * constructor. 00400 */ 00401 TAO_InputCDR (const TAO_InputCDR& rhs, 00402 size_t size); 00403 00404 /// Create an input CDR from an output CDR. 00405 TAO_InputCDR (const TAO_OutputCDR& rhs, 00406 ACE_Allocator* buffer_allocator = 0, 00407 ACE_Allocator* data_block_allocator = 0, 00408 ACE_Allocator* message_block_allocator = 0, 00409 TAO_ORB_Core* orb_core = 0); 00410 00411 /// Initialize the contents of one CDR from another, without data 00412 /// copying and with minimimum locking overhead. 00413 TAO_InputCDR (ACE_InputCDR::Transfer_Contents rhs, 00414 TAO_ORB_Core* orb_core = 0); 00415 00416 /// Destructor 00417 ~TAO_InputCDR (void); 00418 00419 // = TAO specific methods. 00420 00421 /// Accessor 00422 TAO_ORB_Core *orb_core (void) const; 00423 00424 ACE_Message_Block::Message_Flags 00425 clr_mb_flags( ACE_Message_Block::Message_Flags less_flags ); 00426 00427 // = TAO specific methods. 00428 static void throw_stub_exception (int error_num); 00429 static void throw_skel_exception (int error_num); 00430 00431 /// These methods are used by valuetype indirection support. 00432 /// Accessor to the indirect maps. 00433 Repo_Id_Map_Handle& get_repo_id_map (); 00434 Codebase_URL_Map_Handle& get_codebase_url_map (); 00435 Value_Map_Handle& get_value_map (); 00436 00437 /// Updater of the maps. 00438 /// These updaters are used to make indirect maps in original stream 00439 /// take effect even during marshalling/demarshalling a redirected stream. 00440 void set_repo_id_map (Repo_Id_Map_Handle& map); 00441 void set_codebase_url_map (Codebase_URL_Map_Handle& map); 00442 void set_value_map (Value_Map_Handle& map); 00443 00444 /// If indirect map is not nil and not empty, unbind all entries. 00445 /// Called after demarshalling. 00446 void reset_vt_indirect_maps (); 00447 00448 private: 00449 /// The ORB_Core, required to extract object references. 00450 TAO_ORB_Core* orb_core_; 00451 00452 /// These maps are used by valuetype indirection support. 00453 Repo_Id_Map_Handle repo_id_map_; 00454 Codebase_URL_Map_Handle codebase_map_; 00455 Value_Map_Handle value_map_; 00456 }; 00457 00458 TAO_END_VERSIONED_NAMESPACE_DECL 00459 00460 #if defined(__ACE_INLINE__) 00461 # include "tao/CDR.inl" 00462 #else 00463 00464 TAO_BEGIN_VERSIONED_NAMESPACE_DECL 00465 00466 // CDR output operators for CORBA types 00467 00468 TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &os, 00469 CORBA::Short x); 00470 TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &os, 00471 CORBA::UShort x); 00472 TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &os, 00473 CORBA::Long x); 00474 TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &os, 00475 CORBA::ULong x); 00476 TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &os, 00477 CORBA::LongLong x); 00478 TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &os, 00479 CORBA::ULongLong x); 00480 TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR& os, 00481 CORBA::LongDouble x); 00482 TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &os, 00483 CORBA::Float x); 00484 TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &os, 00485 CORBA::Double x); 00486 TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &os, 00487 const CORBA::Char* x); 00488 TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &os, 00489 const CORBA::WChar* x); 00490 TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &os, 00491 ACE_OutputCDR::from_string x); 00492 TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &os, 00493 ACE_OutputCDR::from_wstring x); 00494 TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &os, 00495 const std::string &x); 00496 00497 // CDR input operators for CORBA types 00498 00499 TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &is, 00500 CORBA::Short &x); 00501 TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &is, 00502 CORBA::UShort &x); 00503 TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &is, 00504 CORBA::Long &x); 00505 TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &is, 00506 CORBA::ULong &x); 00507 TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &is, 00508 CORBA::LongLong &x); 00509 TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &is, 00510 CORBA::ULongLong &x); 00511 TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &is, 00512 CORBA::LongDouble &x); 00513 TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &is, 00514 CORBA::Float &x); 00515 TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &is, 00516 CORBA::Double &x); 00517 TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &is, 00518 CORBA::Char* &x); 00519 TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &is, 00520 CORBA::WChar* &x); 00521 TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &os, 00522 ACE_InputCDR::to_string x); 00523 TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &os, 00524 ACE_InputCDR::to_wstring x); 00525 TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &os, 00526 std::string &x); 00527 00528 TAO_END_VERSIONED_NAMESPACE_DECL 00529 00530 #endif /* __ACE_INLINE */ 00531 00532 #include /**/ "ace/post.h" 00533 #endif /* TAO_CDR_H */
