TAO Namespace Reference

Define symbolic names for the ORB collocation strategies. More...

Namespaces

namespace  CSD
namespace  details
namespace  ORB
namespace  Transport
namespace  TypeCode
namespace  Utils

Classes

class  TAO_Allocator
 Abstract class for TAO allocators. This will be used for derived allocator templates that are capable of allocating a specific type of objects. More...
class  Any_Insert_Policy_Stream
class  Any_Insert_Policy_AnyTypeCode_Adapter
class  Any_Insert_Policy_IFR_Client_Adapter
class  Any_Insert_Policy_Noop
class  Any_Insert_Policy_CORBA_Object
class  Arg_Traits
 Base class for all stub arg traits specializations. More...
class  Argument
 Base class for argument class templates. More...
class  InArgument
class  InoutArgument
class  OutArgument
class  RetArgument
class  Void_Return_Argument
class  ARDB_Refcount_Functor
 Functor for refcounting of Asynch_Reply_Dispatcher_Base. More...
class  In_Basic_Argument_T
 Template class for IN stub argument of basic IDL types. More...
class  In_Basic_Clonable_Argument_T
 Template class for IN stub argument of basic IDL types. More...
class  Inout_Basic_Argument_T
 Template class for INOUT stub argument of basic IDL types. More...
class  Out_Basic_Argument_T
 Template class for OUT stub argument of basic IDL types. More...
class  Ret_Basic_Argument_T
 Template class for return stub value of basic IDL types. More...
struct  Basic_Arg_Traits_T
 Template class for stub argument traits of basic IDL types. More...
class  Arg_Traits< void >
 Specialization for void return type. More...
class  Arg_Traits< CORBA::Short >
 Specializations for basic stub arg types, except (w)char/boolean/octet. More...
class  Arg_Traits< CORBA::Long >
class  Arg_Traits< CORBA::UShort >
class  Arg_Traits< CORBA::ULong >
class  Arg_Traits< CORBA::Float >
class  Arg_Traits< CORBA::Double >
class  Arg_Traits< CORBA::LongLong >
class  Arg_Traits< CORBA::ULongLong >
class  Arg_Traits< CORBA::LongDouble >
class  In_BD_String_Argument_T
 Template class for IN bounded (w)string argument. More...
class  In_BD_String_Clonable_Argument_T
 Template class for IN bounded (w)string argument. More...
class  Inout_BD_String_Argument_T
 Template class for INOUT bounded (w)string argument. More...
class  Out_BD_String_Argument_T
 Template class for OUT bounded (w)string argument. More...
class  Ret_BD_String_Argument_T
 Template class for return stub value of bd (w)string argument. More...
struct  BD_String_Arg_Traits_T
 Template class for stub argument traits of bounded (w)strings. More...
class  bounded_array_sequence
class  bounded_basic_string_sequence
class  bounded_bd_string_sequence
class  bounded_object_reference_sequence
class  bounded_value_sequence
class  TAO_Buffer_Allocator
 Generic buffer allocator for TAO. More...
class  Cache_IntId_T
 Helper class for TAO_Transport_Cache_Manager. More...
class  Cache_ExtId_T
 Helper class for TAO_Transport_Cache_Manager: unifies several data items, so they can be stored together as a value for a key in a hash table holding the state of the Transport Cache. More...
class  ClientRequestInterceptor_Adapter
 A convenient helper class to invoke registered client request interceptors. More...
class  Collocated_Invocation
 Class for Collocated invocations. More...
class  Collocation_Proxy_Broker
class  String_var
class  String_out
 String_out. More...
struct  String_Var_Equal_To
struct  Exception_Data
 Description of a single exception. More...
class  In_Fixed_Array_Argument_T
 IN stub argument of fixed size element array. More...
class  In_Fixed_Array_Clonable_Argument_T
 IN stub argument of fixed size element array. More...
class  Inout_Fixed_Array_Argument_T
 INOUT stub argument of fixed size element array. More...
class  Out_Fixed_Array_Argument_T
 OUT stub argument of fixed size element array. More...
class  Ret_Fixed_Array_Argument_T
 Return stub value of fixed size element array. More...
struct  Fixed_Array_Arg_Traits_T
 Argument traits of fixed size element array. More...
class  In_Fixed_Size_Argument_T
 Template class for IN stub argument of fixed size IDL types. More...
class  In_Fixed_Size_Clonable_Argument_T
 Template class for IN stub argument of fixed size IDL types. More...
class  Inout_Fixed_Size_Argument_T
 Template class for INOUT stub argument of fixed size IDL types. More...
class  Out_Fixed_Size_Argument_T
 Template class for OUT stub argument of fixed size IDL types. More...
class  Ret_Fixed_Size_Argument_T
 Template class for return stub value of fixed size IDL types. More...
struct  Fixed_Size_Arg_Traits_T
 Template class for argument traits of fixed size IDL types. More...
class  GUIResource_Factory
class  Incoming_Message_Stack
 Implements stack for TAO_Queued_Data. More...
class  Invocation_Adapter
 Generic interface for the invocation object visible to the IDL compiler. More...
class  Invocation_Base
 The base class for the invocation object. More...
class  LocateRequest_Invocation
 Object created by TAO::LocateRequest_Invocation_Adapter to create and send LocateRequest invocation. More...
class  LocateRequest_Invocation_Adapter
 Adapter class for locate request invocations. More...
class  Arg_Traits< CORBA::Object >
struct  Objref_Traits< CORBA::Object >
struct  In_Object_Argument_Cloner_T< CORBA::InterfaceDef_ptr >
class  In_Object_Argument_T
 Template class for IN object argument. More...
struct  In_Object_Argument_Cloner_T
class  In_Object_Clonable_Argument_T
 Template class for IN object argument. More...
class  Inout_Object_Argument_T
 Template class for INOUT object argument. More...
class  Out_Object_Argument_T
 Template class for OUT object argument. More...
class  Ret_Object_Argument_T
 Template class for return stub value of object argument. More...
struct  Object_Arg_Traits_T
 Template class for stub argument traits of objects. More...
class  ObjectKey
class  Object_Proxy_Broker
 Object_Proxy_Broker. More...
class  Narrow_Utils
class  Less_Than_ObjectKey
 Compares the length and then the contents of ObjectKeys. More...
class  ObjectKey_Table
 Table that maintains the set of ObjectKey's seen by the ORB. More...
class  ORB_Table
 Keep a table with all the ORBs in the system. More...
class  ORB_Core_Ref_Counter
class  ORBInitializer_Registry_Adapter
class  Arg_Traits< CORBA::Policy >
struct  Objref_Traits< ::CORBA::Policy >
class  PolicyFactory_Registry_Adapter
 ORB-specific PortableInterceptor::PolicyFactory registry. More...
class  Profile_Transport_Resolver
 Chooses the profile and a transport for a target object on which an invocation can be made. More...
class  Refcounted_ObjectKey
 A wrapper class that ties together a refcount to an ObjectKey. More...
class  Remote_Invocation
 Base class for remote invocations. More...
class  Remote_Object_Proxy_Broker
 Remote_Object_Proxy_Broker. More...
class  RequestInterceptor_Adapter
 A base helper class to invoke registered request interceptors. More...
class  ServerRequestInterceptor_Adapter
class  In_Special_Basic_Argument_T
 Template class for IN stub argument of (w)char/boolean/octet. More...
class  In_Special_Basic_Clonable_Argument_T
 Template class for IN stub argument of (w)char/boolean/octet. More...
class  Inout_Special_Basic_Argument_T
 Template class for INOUT stub argument of (w)char/boolean/octet. More...
class  Out_Special_Basic_Argument_T
 Template class for OUT stub argument of (w)char/boolean/octet. More...
class  Ret_Special_Basic_Argument_T
struct  Special_Basic_Tag
 Struct for basic IDL type arguments id tag. More...
struct  Special_Basic_Arg_Traits_T
 Template class for stub argument traits of (w)char/boolean/octet. More...
class  Arg_Traits< ACE_InputCDR::to_char >
 Specializations for (w)char, octet and boolean. More...
class  Arg_Traits< ACE_InputCDR::to_wchar >
class  Arg_Traits< ACE_InputCDR::to_octet >
class  Arg_Traits< ACE_InputCDR::to_boolean >
class  String_Manager_T
class  Synch_Twoway_Invocation
 All the action for a synchronous twoway invocation happen here. More...
class  Synch_Oneway_Invocation
 All the action for a synchronous oneway invocation happen here. More...
class  Reply_Guard
 A guard class used for storing and forwarding the reply status to the portable interceptors. More...
class  Transport_Cache_Manager_T
 The Transport Cache Manager for TAO. More...
class  Transport_Queueing_Strategy
 Define the interface for the Queueing Strategy. More...
class  Flush_Transport_Queueing_Strategy
class  Transport_Selection_Guard
 Used by the Transport Current feature to keep track of which Transport is currently active. More...
class  In_UB_String_Argument_T
 Template class for IN unbounded (w)string argument. More...
class  In_UB_String_Clonable_Argument_T
 Template class for IN unbounded (w)string argument. More...
class  Inout_UB_String_Argument_T
 Template class for INOUT unbounded (w)string argument. More...
class  Out_UB_String_Argument_T
 Template class for OUT unbounded (w)string argument. More...
class  Ret_UB_String_Argument_T
 Template class for return stub value of ub (w)string argument. More...
struct  UB_String_Arg_Traits_T
 Template class for argument traits of unbounded (w)strings. More...
class  Arg_Traits< CORBA::Char * >
 Specializatons for unbounded (w)strings. More...
class  Arg_Traits< CORBA::WChar * >
class  unbounded_array_sequence
class  unbounded_basic_string_sequence
class  unbounded_bd_string_sequence
class  unbounded_object_reference_sequence
class  unbounded_value_sequence< CORBA::Octet >
class  unbounded_value_sequence
class  In_Var_Array_Argument_T
 IN stub argument of variable size element array. More...
class  In_Var_Array_Clonable_Argument_T
 IN stub argument of variable size element array. More...
class  Inout_Var_Array_Argument_T
 INOUT stub argument of variable size element array. More...
class  Out_Var_Array_Argument_T
 OUT stub argument of variable size element array. More...
class  Ret_Var_Array_Argument_T
 Return stub value of variable size element array. More...
struct  Var_Array_Arg_Traits_T
 Argument traits of variable size element array. More...
class  In_Var_Size_Argument_T
 Template class for IN stub argument of fixed size IDL types. More...
class  In_Var_Size_Clonable_Argument_T
 Template class for IN stub argument of fixed size IDL types. More...
class  Inout_Var_Size_Argument_T
 Template class for INOUT stub argument of fixed size IDL types. More...
class  Out_Var_Size_Argument_T
 Template class for OUT stub argument of fixed size IDL types. More...
class  Ret_Var_Size_Argument_T
 Template class for return stub value of fixed size IDL types. More...
struct  Var_Size_Arg_Traits_T
 Template class for stub argument traits of variable size IDL types. More...
class  Nested_Upcall_Guard
 : Magic class that sets the status of the thread in the TSS. More...
class  Wait_On_LF_No_Upcall

Functions

template<typename stream , typename T_array , typename T_slice , typename T_tag , CORBA::ULong MAX>
bool demarshal_sequence (stream &strm, TAO::bounded_array_sequence< T_array, T_slice, T_tag, MAX > &target)
template<typename stream , typename T_array , typename T_slice , typename T_tag , CORBA::ULong MAX>
bool marshal_sequence (stream &strm, const TAO::bounded_array_sequence< T_array, T_slice, T_tag, MAX > &source)
template<typename stream , CORBA::ULong MAX>
bool demarshal_sequence (stream &strm, TAO::bounded_value_sequence< CORBA::Short, MAX > &target)
template<typename stream , CORBA::ULong MAX>
bool demarshal_sequence (stream &strm, TAO::bounded_value_sequence< CORBA::Long, MAX > &target)
template<typename stream , CORBA::ULong MAX>
bool demarshal_sequence (stream &strm, TAO::bounded_value_sequence< CORBA::ULong, MAX > &target)
template<typename stream , CORBA::ULong MAX>
bool demarshal_sequence (stream &strm, TAO::bounded_value_sequence< CORBA::UShort, MAX > &target)
template<typename stream , CORBA::ULong MAX>
bool demarshal_sequence (stream &strm, TAO::bounded_value_sequence< CORBA::Octet, MAX > &target)
template<typename stream , CORBA::ULong MAX>
bool demarshal_sequence (stream &strm, TAO::bounded_value_sequence< CORBA::Char, MAX > &target)
template<typename stream , CORBA::ULong MAX>
bool demarshal_sequence (stream &strm, TAO::bounded_value_sequence< CORBA::Float, MAX > &target)
template<typename stream , CORBA::ULong MAX>
bool demarshal_sequence (stream &strm, TAO::bounded_value_sequence< CORBA::Double, MAX > &target)
template<typename stream , CORBA::ULong MAX>
bool demarshal_sequence (stream &strm, TAO::bounded_value_sequence< CORBA::LongLong, MAX > &target)
template<typename stream , CORBA::ULong MAX>
bool demarshal_sequence (stream &strm, TAO::bounded_value_sequence< CORBA::ULongLong, MAX > &target)
template<typename stream , CORBA::ULong MAX>
bool demarshal_sequence (stream &strm, TAO::bounded_value_sequence< CORBA::LongDouble, MAX > &target)
template<typename stream , CORBA::ULong MAX>
bool demarshal_sequence (stream &strm, TAO::bounded_value_sequence< CORBA::Boolean, MAX > &target)
template<typename stream , typename value_t , CORBA::ULong MAX>
bool demarshal_sequence (stream &strm, TAO::bounded_value_sequence< value_t, MAX > &target)
template<typename stream , typename charT , CORBA::ULong MAX>
bool demarshal_sequence (stream &strm, TAO::bounded_basic_string_sequence< charT, MAX > &target)
template<typename stream , typename charT , CORBA::ULong MAX, CORBA::ULong BD_STR_MAX>
bool demarshal_sequence (stream &strm, TAO::bounded_bd_string_sequence< charT, MAX, BD_STR_MAX > &target)
template<typename stream , typename object_t , typename object_t_var , CORBA::ULong MAX>
bool demarshal_sequence (stream &strm, TAO::bounded_object_reference_sequence< object_t, object_t_var, MAX > &target)
template<typename stream , CORBA::ULong MAX>
bool marshal_sequence (stream &strm, const TAO::bounded_value_sequence< CORBA::Short, MAX > &source)
template<typename stream , CORBA::ULong MAX>
bool marshal_sequence (stream &strm, const TAO::bounded_value_sequence< CORBA::Long, MAX > &source)
template<typename stream , CORBA::ULong MAX>
bool marshal_sequence (stream &strm, const TAO::bounded_value_sequence< CORBA::ULong, MAX > &source)
template<typename stream , CORBA::ULong MAX>
bool marshal_sequence (stream &strm, const TAO::bounded_value_sequence< CORBA::UShort, MAX > &source)
template<typename stream , CORBA::ULong MAX>
bool marshal_sequence (stream &strm, const TAO::bounded_value_sequence< CORBA::Octet, MAX > &source)
template<typename stream , CORBA::ULong MAX>
bool marshal_sequence (stream &strm, const TAO::bounded_value_sequence< CORBA::Char, MAX > &source)
template<typename stream , CORBA::ULong MAX>
bool marshal_sequence (stream &strm, const TAO::bounded_value_sequence< CORBA::Float, MAX > &source)
template<typename stream , CORBA::ULong MAX>
bool marshal_sequence (stream &strm, const TAO::bounded_value_sequence< CORBA::Double, MAX > &source)
template<typename stream , CORBA::ULong MAX>
bool marshal_sequence (stream &strm, const TAO::bounded_value_sequence< CORBA::LongLong, MAX > &source)
template<typename stream , CORBA::ULong MAX>
bool marshal_sequence (stream &strm, const TAO::bounded_value_sequence< CORBA::ULongLong, MAX > &source)
template<typename stream , CORBA::ULong MAX>
bool marshal_sequence (stream &strm, const TAO::bounded_value_sequence< CORBA::LongDouble, MAX > &source)
template<typename stream , CORBA::ULong MAX>
bool marshal_sequence (stream &strm, const TAO::bounded_value_sequence< CORBA::Boolean, MAX > &source)
template<typename stream , typename value_t , CORBA::ULong MAX>
bool marshal_sequence (stream &strm, const TAO::bounded_value_sequence< value_t, MAX > &source)
template<typename stream , typename charT , CORBA::ULong MAX>
bool marshal_sequence (stream &strm, const TAO::bounded_basic_string_sequence< charT, MAX > &source)
template<typename stream , typename charT , CORBA::ULong MAX, CORBA::ULong BD_STR_MAX>
bool marshal_sequence (stream &strm, const TAO::bounded_bd_string_sequence< charT, MAX, BD_STR_MAX > &source)
template<typename stream , typename object_t , typename object_t_var , CORBA::ULong MAX>
bool marshal_sequence (stream &strm, const TAO::bounded_object_reference_sequence< object_t, object_t_var, MAX > &source)
TAO_Export CORBA::SystemException * create_system_exception (const char *id)
 Create a CORBA::SystemException given the interface repository ID.
bool parse_orb_opt (ACE_Argv_Type_Converter &command_line, const ACE_TCHAR *orb_opt, ACE_TString &opt_arg)
ACE_Intrusive_Auto_Ptr
< ACE_Service_Gestalt > 		find_orb_context (const ACE_TString &orbconfig_string)
template<typename stream , typename T_array , typename T_slice , typename T_tag >
bool demarshal_sequence (stream &strm, TAO::unbounded_array_sequence< T_array, T_slice, T_tag > &target)
template<typename stream , typename T_array , typename T_slice , typename T_tag >
bool marshal_sequence (stream &strm, const TAO::unbounded_array_sequence< T_array, T_slice, T_tag > &source)
template<typename stream >
bool demarshal_sequence (stream &strm, TAO::unbounded_value_sequence< CORBA::Short > &target)
template<typename stream >
bool demarshal_sequence (stream &strm, TAO::unbounded_value_sequence< CORBA::Long > &target)
template<typename stream >
bool demarshal_sequence (stream &strm, TAO::unbounded_value_sequence< CORBA::ULong > &target)
template<typename stream >
bool demarshal_sequence (stream &strm, TAO::unbounded_value_sequence< CORBA::UShort > &target)
template<typename stream >
bool demarshal_sequence (stream &strm, TAO::unbounded_value_sequence< CORBA::Octet > &target)
template<typename stream >
bool demarshal_sequence (stream &strm, TAO::unbounded_value_sequence< CORBA::Char > &target)
template<typename stream >
bool demarshal_sequence (stream &strm, TAO::unbounded_value_sequence< CORBA::Float > &target)
template<typename stream >
bool demarshal_sequence (stream &strm, TAO::unbounded_value_sequence< CORBA::Double > &target)
template<typename stream >
bool demarshal_sequence (stream &strm, TAO::unbounded_value_sequence< CORBA::LongLong > &target)
template<typename stream >
bool demarshal_sequence (stream &strm, TAO::unbounded_value_sequence< CORBA::ULongLong > &target)
template<typename stream >
bool demarshal_sequence (stream &strm, TAO::unbounded_value_sequence< CORBA::LongDouble > &target)
template<typename stream >
bool demarshal_sequence (stream &strm, TAO::unbounded_value_sequence< CORBA::Boolean > &target)
template<typename stream , typename value_t >
bool demarshal_sequence (stream &strm, TAO::unbounded_value_sequence< value_t > &target)
template<typename stream , typename charT >
bool demarshal_sequence (stream &strm, TAO::unbounded_basic_string_sequence< charT > &target)
template<typename stream , typename charT , CORBA::ULong BD_STR_MAX>
bool demarshal_sequence (stream &strm, TAO::unbounded_bd_string_sequence< charT, BD_STR_MAX > &target)
template<typename stream , typename object_t , typename object_t_var >
bool demarshal_sequence (stream &strm, TAO::unbounded_object_reference_sequence< object_t, object_t_var > &target)
template<typename stream >
bool marshal_sequence (stream &strm, const TAO::unbounded_value_sequence< CORBA::Short > &source)
template<typename stream >
bool marshal_sequence (stream &strm, const TAO::unbounded_value_sequence< CORBA::Long > &source)
template<typename stream >
bool marshal_sequence (stream &strm, const TAO::unbounded_value_sequence< CORBA::ULong > &source)
template<typename stream >
bool marshal_sequence (stream &strm, const TAO::unbounded_value_sequence< CORBA::UShort > &source)
template<typename stream >
bool marshal_sequence (stream &strm, const TAO::unbounded_value_sequence< CORBA::Octet > &source)
template<typename stream >
bool marshal_sequence (stream &strm, const TAO::unbounded_value_sequence< CORBA::Char > &source)
template<typename stream >
bool marshal_sequence (stream &strm, const TAO::unbounded_value_sequence< CORBA::Float > &source)
template<typename stream >
bool marshal_sequence (stream &strm, const TAO::unbounded_value_sequence< CORBA::Double > &source)
template<typename stream >
bool marshal_sequence (stream &strm, const TAO::unbounded_value_sequence< CORBA::LongLong > &source)
template<typename stream >
bool marshal_sequence (stream &strm, const TAO::unbounded_value_sequence< CORBA::ULongLong > &source)
template<typename stream >
bool marshal_sequence (stream &strm, const TAO::unbounded_value_sequence< CORBA::LongDouble > &source)
template<typename stream >
bool marshal_sequence (stream &strm, const TAO::unbounded_value_sequence< CORBA::Boolean > &source)
template<typename stream , typename value_t >
bool marshal_sequence (stream &strm, const TAO::unbounded_value_sequence< value_t > &source)
template<typename stream , typename charT >
bool marshal_sequence (stream &strm, const TAO::unbounded_basic_string_sequence< charT > &source)
template<typename stream , typename charT , CORBA::ULong BD_STR_MAX>
bool marshal_sequence (stream &strm, const TAO::unbounded_bd_string_sequence< charT, BD_STR_MAX > &source)
template<typename stream , typename object_t , typename object_t_var >
bool marshal_sequence (stream &strm, const TAO::unbounded_object_reference_sequence< object_t, object_t_var > &source)

Detailed Description

Define symbolic names for the ORB collocation strategies.

Service IDs for the services that are located through Multicast.

Function Documentation

TAO_Export CORBA::SystemException* TAO::create_system_exception ( const char *  id  ) 

Create a CORBA::SystemException given the interface repository ID.

template<typename stream , typename object_t , typename object_t_var >
bool TAO::demarshal_sequence ( stream &  strm,
TAO::unbounded_object_reference_sequence< object_t, object_t_var > &  target 
) [inline]

Definition at line 401 of file Unbounded_Sequence_CDR_T.h.

00401                                                                                                                   {
00402     typedef TAO::unbounded_object_reference_sequence<object_t, object_t_var> sequence;
00403     typedef typename sequence::allocation_traits sequence_allocation_traits;
00404     ::CORBA::ULong new_length = 0;
00405     if (!(strm >> new_length)) {
00406       return false;
00407     }
00408     if (new_length > strm.length()) {
00409       return false;
00410     }
00411     sequence tmp(new_length, new_length,
00412                  sequence_allocation_traits::allocbuf_noinit(new_length),
00413                  true);
00414     typename sequence::value_type * buffer = tmp.get_buffer();
00415     for(CORBA::ULong i = 0; i < new_length; ++i) {
00416       if (!(strm >> buffer[i])) {
00417         return false;
00418       }
00419     }
00420     tmp.swap(target);
00421     return true;
00422   }

template<typename stream , typename charT , CORBA::ULong BD_STR_MAX>
bool TAO::demarshal_sequence ( stream &  strm,
TAO::unbounded_bd_string_sequence< charT, BD_STR_MAX > &  target 
) [inline]

Definition at line 369 of file Unbounded_Sequence_CDR_T.h.

00369                                                                                                        {
00370     typedef TAO::unbounded_bd_string_sequence <charT, BD_STR_MAX> sequence;
00371     typedef typename sequence::element_traits::string_var string_var;
00372     typedef typename sequence::allocation_traits sequence_allocation_traits;
00373     ::CORBA::ULong new_length = 0;
00374     if (!(strm >> new_length)) {
00375       return false;
00376     }
00377     if (new_length > strm.length()) {
00378       return false;
00379     }
00380     sequence tmp(new_length, new_length,
00381                  sequence_allocation_traits::allocbuf_noinit(new_length),
00382                  true);
00383     for(CORBA::ULong i = 0; i < new_length; ++i) {
00384       string_var string;
00385       if (!(strm >> string.inout ())) {
00386         return false;
00387       }
00388       else {
00389         if (string.in () != 0 &&
00390             ACE_OS::strlen (string.in ()) > tmp.bd_string_maximum ()) {
00391           throw ::CORBA::BAD_PARAM ();
00392         }
00393         tmp[i] = string._retn ();
00394       }
00395     }
00396     tmp.swap(target);
00397     return true;
00398   }

template<typename stream , typename charT >
bool TAO::demarshal_sequence ( stream &  strm,
TAO::unbounded_basic_string_sequence< charT > &  target 
) [inline]

Definition at line 341 of file Unbounded_Sequence_CDR_T.h.

00341                                                                                               {
00342     typedef TAO::unbounded_basic_string_sequence <charT> sequence;
00343     typedef typename sequence::element_traits::string_var string_var;
00344     typedef typename sequence::allocation_traits sequence_allocation_traits;
00345     ::CORBA::ULong new_length = 0;
00346     if (!(strm >> new_length)) {
00347       return false;
00348     }
00349     if (new_length > strm.length()) {
00350       return false;
00351     }
00352     sequence tmp(new_length, new_length,
00353                  sequence_allocation_traits::allocbuf_noinit(new_length),
00354                  true);
00355     for(CORBA::ULong i = 0; i < new_length; ++i) {
00356       string_var string;
00357       if (!(strm >> string.inout ())) {
00358         return false;
00359       }
00360       else {
00361         tmp[i] = string._retn ();
00362       }
00363     }
00364     tmp.swap(target);
00365     return true;
00366   }

template<typename stream , typename value_t >
bool TAO::demarshal_sequence ( stream &  strm,
TAO::unbounded_value_sequence< value_t > &  target 
) [inline]

Definition at line 319 of file Unbounded_Sequence_CDR_T.h.

00319                                                                                          {
00320     typedef TAO::unbounded_value_sequence <value_t> sequence;
00321     ::CORBA::ULong new_length = 0;
00322     if (!(strm >> new_length)) {
00323       return false;
00324     }
00325     if (new_length > strm.length()) {
00326       return false;
00327     }
00328     sequence tmp(new_length);
00329     tmp.length(new_length);
00330     typename sequence::value_type * buffer = tmp.get_buffer();
00331     for(CORBA::ULong i = 0; i < new_length; ++i) {
00332       if (!(strm >> buffer[i])) {
00333         return false;
00334       }
00335     }
00336     tmp.swap(target);
00337     return true;
00338   }

template<typename stream >
bool TAO::demarshal_sequence ( stream &  strm,
TAO::unbounded_value_sequence< CORBA::Boolean > &  target 
) [inline]

Definition at line 299 of file Unbounded_Sequence_CDR_T.h.

00299                                                                                               {
00300     typedef TAO::unbounded_value_sequence <CORBA::Boolean> sequence;
00301     ::CORBA::ULong new_length = 0;
00302     if (!(strm >> new_length)) {
00303       return false;
00304     }
00305     if (new_length > strm.length()) {
00306       return false;
00307     }
00308     sequence tmp(new_length);
00309     tmp.length(new_length);
00310     typename sequence::value_type * buffer = tmp.get_buffer();
00311     if (!strm.read_boolean_array (buffer, new_length)) {
00312       return false;
00313     }
00314     tmp.swap(target);
00315     return true;
00316   }

template<typename stream >
bool TAO::demarshal_sequence ( stream &  strm,
TAO::unbounded_value_sequence< CORBA::LongDouble > &  target 
) [inline]

Definition at line 279 of file Unbounded_Sequence_CDR_T.h.

00279                                                                                                  {
00280     typedef TAO::unbounded_value_sequence <CORBA::LongDouble> sequence;
00281     ::CORBA::ULong new_length = 0;
00282     if (!(strm >> new_length)) {
00283       return false;
00284     }
00285     if (new_length > strm.length()) {
00286       return false;
00287     }
00288     sequence tmp(new_length);
00289     tmp.length(new_length);
00290     typename sequence::value_type * buffer = tmp.get_buffer();
00291     if (!strm.read_longdouble_array (buffer, new_length)) {
00292       return false;
00293     }
00294     tmp.swap(target);
00295     return true;
00296   }

template<typename stream >
bool TAO::demarshal_sequence ( stream &  strm,
TAO::unbounded_value_sequence< CORBA::ULongLong > &  target 
) [inline]

Definition at line 259 of file Unbounded_Sequence_CDR_T.h.

00259                                                                                                 {
00260     typedef TAO::unbounded_value_sequence <CORBA::ULongLong> sequence;
00261     ::CORBA::ULong new_length = 0;
00262     if (!(strm >> new_length)) {
00263       return false;
00264     }
00265     if (new_length > strm.length()) {
00266       return false;
00267     }
00268     sequence tmp(new_length);
00269     tmp.length(new_length);
00270     typename sequence::value_type * buffer = tmp.get_buffer();
00271     if (!strm.read_ulonglong_array (buffer, new_length)) {
00272       return false;
00273     }
00274     tmp.swap(target);
00275     return true;
00276   }

template<typename stream >
bool TAO::demarshal_sequence ( stream &  strm,
TAO::unbounded_value_sequence< CORBA::LongLong > &  target 
) [inline]

Definition at line 239 of file Unbounded_Sequence_CDR_T.h.

00239                                                                                                {
00240     typedef TAO::unbounded_value_sequence <CORBA::LongLong> sequence;
00241     ::CORBA::ULong new_length = 0;
00242     if (!(strm >> new_length)) {
00243       return false;
00244     }
00245     if (new_length > strm.length()) {
00246       return false;
00247     }
00248     sequence tmp(new_length);
00249     tmp.length(new_length);
00250     typename sequence::value_type * buffer = tmp.get_buffer();
00251     if (!strm.read_longlong_array (buffer, new_length)) {
00252       return false;
00253     }
00254     tmp.swap(target);
00255     return true;
00256   }

template<typename stream >
bool TAO::demarshal_sequence ( stream &  strm,
TAO::unbounded_value_sequence< CORBA::Double > &  target 
) [inline]

Definition at line 219 of file Unbounded_Sequence_CDR_T.h.

00219                                                                                              {
00220     typedef TAO::unbounded_value_sequence <CORBA::Double> sequence;
00221     ::CORBA::ULong new_length = 0;
00222     if (!(strm >> new_length)) {
00223       return false;
00224     }
00225     if (new_length > strm.length()) {
00226       return false;
00227     }
00228     sequence tmp(new_length);
00229     tmp.length(new_length);
00230     typename sequence::value_type * buffer = tmp.get_buffer();
00231     if (!strm.read_double_array (buffer, new_length)) {
00232       return false;
00233     }
00234     tmp.swap(target);
00235     return true;
00236   }

template<typename stream >
bool TAO::demarshal_sequence ( stream &  strm,
TAO::unbounded_value_sequence< CORBA::Float > &  target 
) [inline]

Definition at line 199 of file Unbounded_Sequence_CDR_T.h.

00199                                                                                             {
00200     typedef TAO::unbounded_value_sequence <CORBA::Float> sequence;
00201     ::CORBA::ULong new_length = 0;
00202     if (!(strm >> new_length)) {
00203       return false;
00204     }
00205     if (new_length > strm.length()) {
00206       return false;
00207     }
00208     sequence tmp(new_length);
00209     tmp.length(new_length);
00210     typename sequence::value_type * buffer = tmp.get_buffer();
00211     if (!strm.read_float_array (buffer, new_length)) {
00212       return false;
00213     }
00214     tmp.swap(target);
00215     return true;
00216   }

template<typename stream >
bool TAO::demarshal_sequence ( stream &  strm,
TAO::unbounded_value_sequence< CORBA::Char > &  target 
) [inline]

Definition at line 157 of file Unbounded_Sequence_CDR_T.h.

00157                                                                                            {
00158     typedef TAO::unbounded_value_sequence <CORBA::Char> sequence;
00159     ::CORBA::ULong new_length = 0;
00160     if (!(strm >> new_length)) {
00161       return false;
00162     }
00163     if (new_length > strm.length()) {
00164       return false;
00165     }
00166     sequence tmp(new_length);
00167     tmp.length(new_length);
00168     typename sequence::value_type * buffer = tmp.get_buffer();
00169     if (!strm.read_char_array (buffer, new_length)) {
00170       return false;
00171     }
00172     tmp.swap(target);
00173     return true;
00174   }

template<typename stream >
bool TAO::demarshal_sequence ( stream &  strm,
TAO::unbounded_value_sequence< CORBA::Octet > &  target 
) [inline]

Definition at line 103 of file Unbounded_Sequence_CDR_T.h.

00103                                                                                             {
00104     typedef TAO::unbounded_value_sequence <CORBA::Octet> sequence;
00105     ::CORBA::ULong new_length = 0;
00106     if (!(strm >> new_length)) {
00107       return false;
00108     }
00109     if (new_length > strm.length()) {
00110       return false;
00111     }
00112     sequence tmp(new_length);
00113     tmp.length(new_length);
00114     if (ACE_BIT_DISABLED (strm.start ()->flags (), ACE_Message_Block::DONT_DELETE))
00115     {
00116       TAO_ORB_Core* orb_core = strm.orb_core ();
00117       if (orb_core != 0 && strm.orb_core ()->resource_factory ()->
00118         input_cdr_allocator_type_locked () == 1)
00119       {
00120         tmp.replace (new_length, strm.start ());
00121         tmp.mb ()->wr_ptr (tmp.mb()->rd_ptr () + new_length);
00122         strm.skip_bytes (new_length);
00123         tmp.swap(target);
00124         return true;
00125       }
00126     }
00127     typename sequence::value_type * buffer = tmp.get_buffer();
00128     if (!strm.read_octet_array (buffer, new_length)) {
00129       return false;
00130     }
00131     tmp.swap(target);
00132     return true;
00133   }

template<typename stream >
bool TAO::demarshal_sequence ( stream &  strm,
TAO::unbounded_value_sequence< CORBA::UShort > &  target 
) [inline]

Definition at line 82 of file Unbounded_Sequence_CDR_T.h.

00082                                                                                              {
00083     typedef TAO::unbounded_value_sequence <CORBA::UShort> sequence;
00084     ::CORBA::ULong new_length = 0;
00085     if (!(strm >> new_length)) {
00086       return false;
00087     }
00088     if (new_length > strm.length()) {
00089       return false;
00090     }
00091     sequence tmp(new_length);
00092     tmp.length(new_length);
00093     typename sequence::value_type * buffer = tmp.get_buffer();
00094     if (!strm.read_ushort_array (buffer, new_length)) {
00095       return false;
00096     }
00097     tmp.swap(target);
00098     return true;
00099   }

template<typename stream >
bool TAO::demarshal_sequence ( stream &  strm,
TAO::unbounded_value_sequence< CORBA::ULong > &  target 
) [inline]

Definition at line 62 of file Unbounded_Sequence_CDR_T.h.

00062                                                                                             {
00063     typedef TAO::unbounded_value_sequence <CORBA::ULong> sequence;
00064     ::CORBA::ULong new_length = 0;
00065     if (!(strm >> new_length)) {
00066       return false;
00067     }
00068     if (new_length > strm.length()) {
00069       return false;
00070     }
00071     sequence tmp(new_length);
00072     tmp.length(new_length);
00073     typename sequence::value_type * buffer = tmp.get_buffer();
00074     if (!strm.read_ulong_array (buffer, new_length)) {
00075       return false;
00076     }
00077     tmp.swap(target);
00078     return true;
00079   }

template<typename stream >
bool TAO::demarshal_sequence ( stream &  strm,
TAO::unbounded_value_sequence< CORBA::Long > &  target 
) [inline]

Definition at line 42 of file Unbounded_Sequence_CDR_T.h.

00042                                                                                            {
00043     typedef TAO::unbounded_value_sequence <CORBA::Long> sequence;
00044     ::CORBA::ULong new_length = 0;
00045     if (!(strm >> new_length)) {
00046       return false;
00047     }
00048     if (new_length > strm.length()) {
00049       return false;
00050     }
00051     sequence tmp(new_length);
00052     tmp.length(new_length);
00053     typename sequence::value_type * buffer = tmp.get_buffer();
00054     if (!strm.read_long_array (buffer, new_length)) {
00055       return false;
00056     }
00057     tmp.swap(target);
00058     return true;
00059   }

template<typename stream >
bool TAO::demarshal_sequence ( stream &  strm,
TAO::unbounded_value_sequence< CORBA::Short > &  target 
) [inline]

Definition at line 22 of file Unbounded_Sequence_CDR_T.h.

00022                                                                                             {
00023     typedef TAO::unbounded_value_sequence <CORBA::Short> sequence;
00024     ::CORBA::ULong new_length = 0;
00025     if (!(strm >> new_length)) {
00026       return false;
00027     }
00028     if (new_length > strm.length()) {
00029       return false;
00030     }
00031     sequence tmp(new_length);
00032     tmp.length(new_length);
00033     typename sequence::value_type * buffer = tmp.get_buffer();
00034     if (!strm.read_short_array (buffer, new_length)) {
00035       return false;
00036     }
00037     tmp.swap(target);
00038     return true;
00039   }

template<typename stream , typename T_array , typename T_slice , typename T_tag >
bool TAO::demarshal_sequence ( stream &  strm,
TAO::unbounded_array_sequence< T_array, T_slice, T_tag > &  target 
) [inline]

Definition at line 101 of file Unbounded_Array_Sequence_T.h.

00101                                                                                                         {
00102     typedef TAO::unbounded_array_sequence<T_array, T_slice, T_tag> sequence;
00103     typedef TAO_Array_Forany_T <T_array, T_slice, T_tag> forany;
00104     typedef TAO::Array_Traits<forany> array_traits;
00105 
00106     ::CORBA::ULong new_length = 0;
00107     if (!(strm >> new_length)) {
00108       return false;
00109     }
00110     if (new_length > strm.length()) {
00111       return false;
00112     }
00113     sequence tmp(new_length);
00114     tmp.length(new_length);
00115     typename sequence::value_type * buffer = tmp.get_buffer();
00116     for(CORBA::ULong i = 0; i < new_length; ++i) {
00117       forany tmp (array_traits::alloc ());
00118       bool const _tao_marshal_flag = (strm >> tmp);
00119       if (_tao_marshal_flag) {
00120         array_traits::copy (buffer[i], tmp.in ());
00121       }
00122       array_traits::free (tmp.inout ());
00123       if (!_tao_marshal_flag) {
00124         return false;
00125       }
00126     }
00127     tmp.swap(target);
00128     return true;
00129   }

template<typename stream , typename object_t , typename object_t_var , CORBA::ULong MAX>
bool TAO::demarshal_sequence ( stream &  strm,
TAO::bounded_object_reference_sequence< object_t, object_t_var, MAX > &  target 
) [inline]

Definition at line 365 of file Bounded_Sequence_CDR_T.h.

00365                                                                                                                      {
00366     typedef typename TAO::bounded_object_reference_sequence<object_t, object_t_var, MAX> sequence;
00367     typedef typename sequence::allocation_traits sequence_allocation_traits;
00368     ::CORBA::ULong new_length = 0;
00369     if (!(strm >> new_length)) {
00370       return false;
00371     }
00372     if ((new_length > strm.length()) || (new_length > target.maximum ())) {
00373       return false;
00374     }
00375     sequence tmp(new_length,
00376                  sequence_allocation_traits::allocbuf_noinit(new_length),
00377                  true);
00378     typename sequence::value_type * buffer = tmp.get_buffer();
00379     for(CORBA::ULong i = 0; i < new_length; ++i) {
00380       if (!(strm >> buffer[i])) {
00381         return false;
00382       }
00383     }
00384     tmp.swap(target);
00385     return true;
00386   }

template<typename stream , typename charT , CORBA::ULong MAX, CORBA::ULong BD_STR_MAX>
bool TAO::demarshal_sequence ( stream &  strm,
TAO::bounded_bd_string_sequence< charT, MAX, BD_STR_MAX > &  target 
) [inline]

Definition at line 333 of file Bounded_Sequence_CDR_T.h.

00333                                                                                                           {
00334     typedef typename TAO::bounded_bd_string_sequence <charT, MAX, BD_STR_MAX> sequence;
00335     typedef typename sequence::element_traits::string_var string_var;
00336     typedef typename sequence::allocation_traits sequence_allocation_traits;
00337     ::CORBA::ULong new_length = 0;
00338     if (!(strm >> new_length)) {
00339       return false;
00340     }
00341     if ((new_length > strm.length()) || (new_length > target.maximum ())) {
00342       return false;
00343     }
00344     sequence tmp(new_length,
00345                  sequence_allocation_traits::allocbuf_noinit(new_length),
00346                  true);
00347     for(CORBA::ULong i = 0; i < new_length; ++i) {
00348       string_var string;
00349       if (!(strm >> string.inout ())) {
00350         return false;
00351       }
00352       else {
00353         if (string.in () != 0 &&
00354             ACE_OS::strlen (string.in ()) > tmp.bd_string_maximum ()) {
00355           throw ::CORBA::BAD_PARAM ();
00356         }
00357         tmp[i] = string._retn ();
00358       }
00359     }
00360     tmp.swap(target);
00361     return true;
00362   }

template<typename stream , typename charT , CORBA::ULong MAX>
bool TAO::demarshal_sequence ( stream &  strm,
TAO::bounded_basic_string_sequence< charT, MAX > &  target 
) [inline]

Definition at line 305 of file Bounded_Sequence_CDR_T.h.

00305                                                                                                  {
00306     typedef typename TAO::bounded_basic_string_sequence <charT, MAX> sequence;
00307     typedef typename sequence::element_traits::string_var string_var;
00308     typedef typename sequence::allocation_traits sequence_allocation_traits;
00309     ::CORBA::ULong new_length = 0;
00310     if (!(strm >> new_length)) {
00311       return false;
00312     }
00313     if ((new_length > strm.length()) || (new_length > target.maximum ())) {
00314       return false;
00315     }
00316     sequence tmp(new_length,
00317                  sequence_allocation_traits::allocbuf_noinit(new_length),
00318                  true);
00319     for(CORBA::ULong i = 0; i < new_length; ++i) {
00320       string_var string;
00321       if (!(strm >> string.inout ())) {
00322         return false;
00323       }
00324       else {
00325         tmp[i] = string._retn ();
00326       }
00327     }
00328     tmp.swap(target);
00329     return true;
00330   }

template<typename stream , typename value_t , CORBA::ULong MAX>
bool TAO::demarshal_sequence ( stream &  strm,
TAO::bounded_value_sequence< value_t, MAX > &  target 
) [inline]

Definition at line 283 of file Bounded_Sequence_CDR_T.h.

00283                                                                                             {
00284     typedef TAO::bounded_value_sequence <value_t, MAX> sequence;
00285     ::CORBA::ULong new_length = 0;
00286     if (!(strm >> new_length)) {
00287       return false;
00288     }
00289     if ((new_length > strm.length()) || (new_length > target.maximum ())) {
00290       return false;
00291     }
00292     sequence tmp;
00293     tmp.length(new_length);
00294     typename sequence::value_type * buffer = tmp.get_buffer();
00295     for(CORBA::ULong i = 0; i < new_length; ++i) {
00296       if (!(strm >> buffer[i])) {
00297         return false;
00298       }
00299     }
00300     tmp.swap(target);
00301     return true;
00302   }

template<typename stream , CORBA::ULong MAX>
bool TAO::demarshal_sequence ( stream &  strm,
TAO::bounded_value_sequence< CORBA::Boolean, MAX > &  target 
) [inline]

Definition at line 263 of file Bounded_Sequence_CDR_T.h.

00263                                                                                                  {
00264     typedef TAO::bounded_value_sequence <CORBA::Boolean, MAX> sequence;
00265     ::CORBA::ULong new_length = 0;
00266     if (!(strm >> new_length)) {
00267       return false;
00268     }
00269     if ((new_length > strm.length()) || (new_length > target.maximum ())) {
00270       return false;
00271     }
00272     sequence tmp;
00273     tmp.length(new_length);
00274     typename sequence::value_type * buffer = tmp.get_buffer();
00275     if (!strm.read_boolean_array (buffer, new_length)) {
00276       return false;
00277     }
00278     tmp.swap(target);
00279     return true;
00280   }

template<typename stream , CORBA::ULong MAX>
bool TAO::demarshal_sequence ( stream &  strm,
TAO::bounded_value_sequence< CORBA::LongDouble, MAX > &  target 
) [inline]

Definition at line 243 of file Bounded_Sequence_CDR_T.h.

00243                                                                                                     {
00244     typedef TAO::bounded_value_sequence <CORBA::LongDouble, MAX> sequence;
00245     ::CORBA::ULong new_length = 0;
00246     if (!(strm >> new_length)) {
00247       return false;
00248     }
00249     if ((new_length > strm.length()) || (new_length > target.maximum ())) {
00250       return false;
00251     }
00252     sequence tmp;
00253     tmp.length(new_length);
00254     typename sequence::value_type * buffer = tmp.get_buffer();
00255     if (!strm.read_longdouble_array (buffer, new_length)) {
00256       return false;
00257     }
00258     tmp.swap(target);
00259     return true;
00260   }

template<typename stream , CORBA::ULong MAX>
bool TAO::demarshal_sequence ( stream &  strm,
TAO::bounded_value_sequence< CORBA::ULongLong, MAX > &  target 
) [inline]

Definition at line 223 of file Bounded_Sequence_CDR_T.h.

00223                                                                                                    {
00224     typedef TAO::bounded_value_sequence <CORBA::ULongLong, MAX> sequence;
00225     ::CORBA::ULong new_length = 0;
00226     if (!(strm >> new_length)) {
00227       return false;
00228     }
00229     if ((new_length > strm.length()) || (new_length > target.maximum ())) {
00230       return false;
00231     }
00232     sequence tmp;
00233     tmp.length(new_length);
00234     typename sequence::value_type * buffer = tmp.get_buffer();
00235     if (!strm.read_ulonglong_array (buffer, new_length)) {
00236       return false;
00237     }
00238     tmp.swap(target);
00239     return true;
00240   }

template<typename stream , CORBA::ULong MAX>
bool TAO::demarshal_sequence ( stream &  strm,
TAO::bounded_value_sequence< CORBA::LongLong, MAX > &  target 
) [inline]

Definition at line 203 of file Bounded_Sequence_CDR_T.h.

00203                                                                                                   {
00204     typedef TAO::bounded_value_sequence <CORBA::LongLong, MAX> sequence;
00205     ::CORBA::ULong new_length = 0;
00206     if (!(strm >> new_length)) {
00207       return false;
00208     }
00209     if ((new_length > strm.length()) || (new_length > target.maximum ())) {
00210       return false;
00211     }
00212     sequence tmp;
00213     tmp.length(new_length);
00214     typename sequence::value_type * buffer = tmp.get_buffer();
00215     if (!strm.read_longlong_array (buffer, new_length)) {
00216       return false;
00217     }
00218     tmp.swap(target);
00219     return true;
00220   }

template<typename stream , CORBA::ULong MAX>
bool TAO::demarshal_sequence ( stream &  strm,
TAO::bounded_value_sequence< CORBA::Double, MAX > &  target 
) [inline]

Definition at line 183 of file Bounded_Sequence_CDR_T.h.

00183                                                                                                 {
00184     typedef TAO::bounded_value_sequence <CORBA::Double, MAX> sequence;
00185     ::CORBA::ULong new_length = 0;
00186     if (!(strm >> new_length)) {
00187       return false;
00188     }
00189     if ((new_length > strm.length()) || (new_length > target.maximum ())) {
00190       return false;
00191     }
00192     sequence tmp;
00193     tmp.length(new_length);
00194     typename sequence::value_type * buffer = tmp.get_buffer();
00195     if (!strm.read_double_array (buffer, new_length)) {
00196       return false;
00197     }
00198     tmp.swap(target);
00199     return true;
00200   }

template<typename stream , CORBA::ULong MAX>
bool TAO::demarshal_sequence ( stream &  strm,
TAO::bounded_value_sequence< CORBA::Float, MAX > &  target 
) [inline]

Definition at line 163 of file Bounded_Sequence_CDR_T.h.

00163                                                                                                {
00164     typedef TAO::bounded_value_sequence <CORBA::Float, MAX> sequence;
00165     ::CORBA::ULong new_length = 0;
00166     if (!(strm >> new_length)) {
00167       return false;
00168     }
00169     if ((new_length > strm.length()) || (new_length > target.maximum ())) {
00170       return false;
00171     }
00172     sequence tmp;
00173     tmp.length(new_length);
00174     typename sequence::value_type * buffer = tmp.get_buffer();
00175     if (!strm.read_float_array (buffer, new_length)) {
00176       return false;
00177     }
00178     tmp.swap(target);
00179     return true;
00180   }

template<typename stream , CORBA::ULong MAX>
bool TAO::demarshal_sequence ( stream &  strm,
TAO::bounded_value_sequence< CORBA::Char, MAX > &  target 
) [inline]

Definition at line 121 of file Bounded_Sequence_CDR_T.h.

00121                                                                                               {
00122     typedef TAO::bounded_value_sequence <CORBA::Char, MAX> sequence;
00123     ::CORBA::ULong new_length = 0;
00124     if (!(strm >> new_length)) {
00125       return false;
00126     }
00127     if ((new_length > strm.length()) || (new_length > target.maximum ())) {
00128       return false;
00129     }
00130     sequence tmp;
00131     tmp.length(new_length);
00132     typename sequence::value_type * buffer = tmp.get_buffer();
00133     if (!strm.read_char_array (buffer, new_length)) {
00134       return false;
00135     }
00136     tmp.swap(target);
00137     return true;
00138   }

template<typename stream , CORBA::ULong MAX>
bool TAO::demarshal_sequence ( stream &  strm,
TAO::bounded_value_sequence< CORBA::Octet, MAX > &  target 
) [inline]

Definition at line 101 of file Bounded_Sequence_CDR_T.h.

00101                                                                                                {
00102     typedef TAO::bounded_value_sequence <CORBA::Octet, MAX> sequence;
00103     ::CORBA::ULong new_length = 0;
00104     if (!(strm >> new_length)) {
00105       return false;
00106     }
00107     if ((new_length > strm.length()) || (new_length > target.maximum ())) {
00108       return false;
00109     }
00110     sequence tmp;
00111     tmp.length(new_length);
00112     typename sequence::value_type * buffer = tmp.get_buffer();
00113     if (!strm.read_octet_array (buffer, new_length)) {
00114       return false;
00115     }
00116     tmp.swap(target);
00117     return true;
00118   }

template<typename stream , CORBA::ULong MAX>
bool TAO::demarshal_sequence ( stream &  strm,
TAO::bounded_value_sequence< CORBA::UShort, MAX > &  target 
) [inline]

Definition at line 81 of file Bounded_Sequence_CDR_T.h.

00081                                                                                                 {
00082     typedef TAO::bounded_value_sequence <CORBA::UShort, MAX> sequence;
00083     ::CORBA::ULong new_length = 0;
00084     if (!(strm >> new_length)) {
00085       return false;
00086     }
00087     if ((new_length > strm.length()) || (new_length > target.maximum ())) {
00088       return false;
00089     }
00090     sequence tmp;
00091     tmp.length(new_length);
00092     typename sequence::value_type * buffer = tmp.get_buffer();
00093     if (!strm.read_ushort_array (buffer, new_length)) {
00094       return false;
00095     }
00096     tmp.swap(target);
00097     return true;
00098   }

template<typename stream , CORBA::ULong MAX>
bool TAO::demarshal_sequence ( stream &  strm,
TAO::bounded_value_sequence< CORBA::ULong, MAX > &  target 
) [inline]

Definition at line 61 of file Bounded_Sequence_CDR_T.h.

00061                                                                                                {
00062     typedef TAO::bounded_value_sequence <CORBA::ULong, MAX> sequence;
00063     ::CORBA::ULong new_length = 0;
00064     if (!(strm >> new_length)) {
00065       return false;
00066     }
00067     if ((new_length > strm.length()) || (new_length > target.maximum ())) {
00068       return false;
00069     }
00070     sequence tmp;
00071     tmp.length(new_length);
00072     typename sequence::value_type * buffer = tmp.get_buffer();
00073     if (!strm.read_ulong_array (buffer, new_length)) {
00074       return false;
00075     }
00076     tmp.swap(target);
00077     return true;
00078   }

template<typename stream , CORBA::ULong MAX>
bool TAO::demarshal_sequence ( stream &  strm,
TAO::bounded_value_sequence< CORBA::Long, MAX > &  target 
) [inline]

Definition at line 41 of file Bounded_Sequence_CDR_T.h.

00041                                                                                               {
00042     typedef TAO::bounded_value_sequence <CORBA::Long, MAX> sequence;
00043     ::CORBA::ULong new_length = 0;
00044     if (!(strm >> new_length)) {
00045       return false;
00046     }
00047     if ((new_length > strm.length()) || (new_length > target.maximum ())) {
00048       return false;
00049     }
00050     sequence tmp;
00051     tmp.length(new_length);
00052     typename sequence::value_type * buffer = tmp.get_buffer();
00053     if (!strm.read_long_array (buffer, new_length)) {
00054       return false;
00055     }
00056     tmp.swap(target);
00057     return true;
00058   }

template<typename stream , CORBA::ULong MAX>
bool TAO::demarshal_sequence ( stream &  strm,
TAO::bounded_value_sequence< CORBA::Short, MAX > &  target 
) [inline]

Definition at line 21 of file Bounded_Sequence_CDR_T.h.

00021                                                                                                {
00022     typedef TAO::bounded_value_sequence <CORBA::Short, MAX> sequence;
00023     ::CORBA::ULong new_length = 0;
00024     if (!(strm >> new_length)) {
00025       return false;
00026     }
00027     if ((new_length > strm.length()) || (new_length > target.maximum ())) {
00028       return false;
00029     }
00030     sequence tmp;
00031     tmp.length(new_length);
00032     typename sequence::value_type * buffer = tmp.get_buffer();
00033     if (!strm.read_short_array (buffer, new_length)) {
00034       return false;
00035     }
00036     tmp.swap(target);
00037     return true;
00038   }

template<typename stream , typename T_array , typename T_slice , typename T_tag , CORBA::ULong MAX>
bool TAO::demarshal_sequence ( stream &  strm,
TAO::bounded_array_sequence< T_array, T_slice, T_tag, MAX > &  target 
) [inline]

Definition at line 99 of file Bounded_Array_Sequence_T.h.

00099                                                                                                            {
00100     typedef typename TAO::bounded_array_sequence<T_array, T_slice, T_tag, MAX> sequence;
00101     typedef TAO_Array_Forany_T<T_array, T_slice, T_tag> forany;
00102     typedef TAO::Array_Traits<forany> array_traits;
00103 
00104     ::CORBA::ULong new_length = 0;
00105     if (!(strm >> new_length)) {
00106       return false;
00107     }
00108     if ((new_length > strm.length()) || (new_length > target.maximum ())) {
00109       return false;
00110     }
00111     sequence tmp;
00112     tmp.length(new_length);
00113     typename sequence::value_type * buffer = tmp.get_buffer();
00114     for(CORBA::ULong i = 0; i < new_length; ++i) {
00115       forany tmp (array_traits::alloc ());
00116       bool const _tao_marshal_flag = (strm >> tmp);
00117       if (_tao_marshal_flag) {
00118         array_traits::copy (buffer[i], tmp.in ());
00119       }
00120       array_traits::free (tmp.inout ());
00121       if (!_tao_marshal_flag) {
00122         return false;
00123       }
00124     }
00125     tmp.swap(target);
00126     return true;
00127   }

ACE_Intrusive_Auto_Ptr<ACE_Service_Gestalt> TAO::find_orb_context ( const ACE_TString &  orbconfig_string  ) 

Definition at line 1132 of file ORB.cpp.

01133     {
01134       const ACE_TCHAR *arg = orbconfig_string.c_str ();
01135 
01136       // Need a local repo? Make one which typically should not be as
01137       // big as the default repository
01138       if  (ACE_OS::strcasecmp (arg, ACE_TEXT("LOCAL")) == 0)
01139         {
01140           ACE_Service_Gestalt* gestalt = 0;
01141           ACE_NEW_THROW_EX (gestalt,
01142                             ACE_Service_Gestalt
01143                             (ACE_Service_Gestalt::MAX_SERVICES / 4, true),
01144                             CORBA::NO_MEMORY
01145                             (CORBA::SystemException::_tao_minor_code (0,
01146                                                                       ENOMEM),
01147                              CORBA::COMPLETED_NO));
01148           return ACE_Intrusive_Auto_Ptr<ACE_Service_Gestalt> (gestalt);
01149         }
01150 
01151       if  (ACE_OS::strcasecmp (arg, ACE_TEXT("CURRENT")) == 0)
01152         {
01153           return ACE_Service_Config::current ();
01154         }
01155 
01156       // Explicit global case?
01157       if  (orbconfig_string.is_empty () || ACE_OS::strcasecmp (arg, ACE_TEXT("GLOBAL")) == 0)
01158         {
01159           return ACE_Service_Config::global ();
01160         }
01161 
01162       // Someone else's context?
01163       const ACE_TCHAR *shared = ACE_TEXT("ORB:");
01164       size_t const shared_len = ACE_OS::strlen(shared);
01165       if (ACE_OS::strncmp (arg, shared, shared_len) == 0)
01166         {
01167           ACE_TString orbid (orbconfig_string.substr (shared_len));
01168 
01169           // Get ORB Core
01170           TAO_ORB_Core_Auto_Ptr oc (TAO::ORB_Table::instance ()->find (
01171             ACE_TEXT_ALWAYS_CHAR(orbid.c_str ())));
01172           if (oc.get () != 0)
01173               return oc->configuration ();
01174 
01175           if (TAO_debug_level > 0)
01176               ACE_ERROR ((LM_ERROR,
01177               ACE_TEXT ("ERROR: Unable to find ORB: %s. Invalid shared ")
01178               ACE_TEXT ("configuration argument \"%s\"\n"),
01179                 orbid.c_str (), arg));
01180 
01181           throw ::CORBA::BAD_PARAM
01182             (CORBA::SystemException::_tao_minor_code
01183              ( TAO_ORB_CORE_INIT_LOCATION_CODE,
01184                ENOTSUP),
01185              CORBA::COMPLETED_NO);
01186         }
01187 
01188 
01189       // Unknown value
01190       if (TAO_debug_level > 0)
01191             ACE_ERROR ((LM_ERROR,
01192                         ACE_TEXT ("ERROR: -ORBGestalt unknown value <%s>\n"),
01193                         orbconfig_string.c_str()));
01194 
01195       throw ::CORBA::BAD_PARAM
01196           (CORBA::SystemException::_tao_minor_code
01197            ( TAO_ORB_CORE_INIT_LOCATION_CODE,
01198              EINVAL),
01199            CORBA::COMPLETED_NO);
01200      }

template<typename stream , typename object_t , typename object_t_var >
bool TAO::marshal_sequence ( stream &  strm,
const TAO::unbounded_object_reference_sequence< object_t, object_t_var > &  source 
) [inline]

Definition at line 606 of file Unbounded_Sequence_CDR_T.h.

00606                                                                                                                       {
00607     typedef typename TAO::unbounded_object_reference_sequence<object_t, object_t_var>::object_type objec_t;
00608     ::CORBA::ULong const length = source.length ();
00609     if (!(strm << length)) {
00610       return false;
00611     }
00612     for(CORBA::ULong i = 0; i < length; ++i) {
00613       if (!TAO::Objref_Traits<objec_t>::marshal (source[i], strm)) {
00614         return false;
00615       }
00616     }
00617     return true;
00618   }

template<typename stream , typename charT , CORBA::ULong BD_STR_MAX>
bool TAO::marshal_sequence ( stream &  strm,
const TAO::unbounded_bd_string_sequence< charT, BD_STR_MAX > &  source 
) [inline]

Definition at line 588 of file Unbounded_Sequence_CDR_T.h.

00588                                                                                                            {
00589     ::CORBA::ULong const length = source.length ();
00590     if (!(strm << length)) {
00591       return false;
00592     }
00593     for(CORBA::ULong i = 0; i < length; ++i) {
00594       if (source[i].in () != 0 &&
00595           ACE_OS::strlen (source[i]) > source.bd_string_maximum ()) {
00596         throw ::CORBA::BAD_PARAM ();
00597       }
00598       if (!(strm << source[i])) {
00599         return false;
00600       }
00601     }
00602     return true;
00603   }

template<typename stream , typename charT >
bool TAO::marshal_sequence ( stream &  strm,
const TAO::unbounded_basic_string_sequence< charT > &  source 
) [inline]

Definition at line 574 of file Unbounded_Sequence_CDR_T.h.

00574                                                                                                   {
00575     ::CORBA::ULong const length = source.length ();
00576     if (!(strm << length)) {
00577       return false;
00578     }
00579     for(CORBA::ULong i = 0; i < length; ++i) {
00580       if (!(strm << source[i])) {
00581         return false;
00582       }
00583     }
00584     return true;
00585   }

template<typename stream , typename value_t >
bool TAO::marshal_sequence ( stream &  strm,
const TAO::unbounded_value_sequence< value_t > &  source 
) [inline]

Definition at line 560 of file Unbounded_Sequence_CDR_T.h.

00560                                                                                              {
00561     ::CORBA::ULong const length = source.length ();
00562     if (!(strm << length)) {
00563       return false;
00564     }
00565     for(CORBA::ULong i = 0; i < length; ++i) {
00566       if (!(strm << source[i])) {
00567         return false;
00568       }
00569     }
00570     return true;
00571   }

template<typename stream >
bool TAO::marshal_sequence ( stream &  strm,
const TAO::unbounded_value_sequence< CORBA::Boolean > &  source 
) [inline]

Definition at line 551 of file Unbounded_Sequence_CDR_T.h.

00551                                                                                                   {
00552     ::CORBA::ULong const length = source.length ();
00553     if (!(strm << length)) {
00554       return false;
00555     }
00556     return strm.write_boolean_array (source.get_buffer (), length);
00557   }

template<typename stream >
bool TAO::marshal_sequence ( stream &  strm,
const TAO::unbounded_value_sequence< CORBA::LongDouble > &  source 
) [inline]

Definition at line 542 of file Unbounded_Sequence_CDR_T.h.

00542                                                                                                      {
00543     ::CORBA::ULong const length = source.length ();
00544     if (!(strm << length)) {
00545       return false;
00546     }
00547     return strm.write_longdouble_array (source.get_buffer (), length);
00548   }

template<typename stream >
bool TAO::marshal_sequence ( stream &  strm,
const TAO::unbounded_value_sequence< CORBA::ULongLong > &  source 
) [inline]

Definition at line 533 of file Unbounded_Sequence_CDR_T.h.

00533                                                                                                     {
00534     ::CORBA::ULong const length = source.length ();
00535     if (!(strm << length)) {
00536       return false;
00537     }
00538     return strm.write_ulonglong_array (source.get_buffer (), length);
00539   }

template<typename stream >
bool TAO::marshal_sequence ( stream &  strm,
const TAO::unbounded_value_sequence< CORBA::LongLong > &  source 
) [inline]

Definition at line 524 of file Unbounded_Sequence_CDR_T.h.

00524                                                                                                    {
00525     ::CORBA::ULong const length = source.length ();
00526     if (!(strm << length)) {
00527       return false;
00528     }
00529     return strm.write_longlong_array (source.get_buffer (), length);
00530   }

template<typename stream >
bool TAO::marshal_sequence ( stream &  strm,
const TAO::unbounded_value_sequence< CORBA::Double > &  source 
) [inline]

Definition at line 515 of file Unbounded_Sequence_CDR_T.h.

00515                                                                                                  {
00516     ::CORBA::ULong const length = source.length ();
00517     if (!(strm << length)) {
00518       return false;
00519     }
00520     return strm.write_double_array (source.get_buffer (), length);
00521   }

template<typename stream >
bool TAO::marshal_sequence ( stream &  strm,
const TAO::unbounded_value_sequence< CORBA::Float > &  source 
) [inline]

Definition at line 506 of file Unbounded_Sequence_CDR_T.h.

00506                                                                                                 {
00507     ::CORBA::ULong const length = source.length ();
00508     if (!(strm << length)) {
00509       return false;
00510     }
00511     return strm.write_float_array (source.get_buffer (), length);
00512   }

template<typename stream >
bool TAO::marshal_sequence ( stream &  strm,
const TAO::unbounded_value_sequence< CORBA::Char > &  source 
) [inline]

Definition at line 486 of file Unbounded_Sequence_CDR_T.h.

00486                                                                                                {
00487     ::CORBA::ULong const length = source.length ();
00488     if (!(strm << length)) {
00489       return false;
00490     }
00491     return strm.write_char_array (source.get_buffer (), length);
00492   }

template<typename stream >
bool TAO::marshal_sequence ( stream &  strm,
const TAO::unbounded_value_sequence< CORBA::Octet > &  source 
) [inline]

Definition at line 464 of file Unbounded_Sequence_CDR_T.h.

00464                                                                                                 {
00465     ::CORBA::ULong const length = source.length ();
00466     if (!(strm << length)) {
00467       return false;
00468     }
00469     if (source.mb ()) {
00470       return strm.write_octet_array_mb (source.mb ());
00471     }
00472     return strm.write_octet_array (source.get_buffer (), length);
00473   }

template<typename stream >
bool TAO::marshal_sequence ( stream &  strm,
const TAO::unbounded_value_sequence< CORBA::UShort > &  source 
) [inline]

Definition at line 454 of file Unbounded_Sequence_CDR_T.h.

00454                                                                                                  {
00455     ::CORBA::ULong const length = source.length ();
00456     if (!(strm << length)) {
00457       return false;
00458     }
00459     return strm.write_ushort_array (source.get_buffer (), length);
00460   }

template<typename stream >
bool TAO::marshal_sequence ( stream &  strm,
const TAO::unbounded_value_sequence< CORBA::ULong > &  source 
) [inline]

Definition at line 445 of file Unbounded_Sequence_CDR_T.h.

00445                                                                                                 {
00446     ::CORBA::ULong const length = source.length ();
00447     if (!(strm << length)) {
00448       return false;
00449     }
00450     return strm.write_ulong_array (source.get_buffer (), length);
00451   }

template<typename stream >
bool TAO::marshal_sequence ( stream &  strm,
const TAO::unbounded_value_sequence< CORBA::Long > &  source 
) [inline]

Definition at line 436 of file Unbounded_Sequence_CDR_T.h.

00436                                                                                                {
00437     ::CORBA::ULong const length = source.length ();
00438     if (!(strm << length)) {
00439       return false;
00440     }
00441     return strm.write_long_array (source.get_buffer (), length);
00442   }

template<typename stream >
bool TAO::marshal_sequence ( stream &  strm,
const TAO::unbounded_value_sequence< CORBA::Short > &  source 
) [inline]

Definition at line 427 of file Unbounded_Sequence_CDR_T.h.

00427                                                                                                 {
00428     ::CORBA::ULong const length = source.length ();
00429     if (!(strm << length)) {
00430       return false;
00431     }
00432     return strm.write_short_array (source.get_buffer (), length);
00433   }

template<typename stream , typename T_array , typename T_slice , typename T_tag >
bool TAO::marshal_sequence ( stream &  strm,
const TAO::unbounded_array_sequence< T_array, T_slice, T_tag > &  source 
) [inline]

Definition at line 132 of file Unbounded_Array_Sequence_T.h.

00132                                                                                                             {
00133     typedef TAO_FixedArray_Var_T <T_array, T_slice, T_tag> fixed_array;
00134     typedef TAO_Array_Forany_T <T_array, T_slice, T_tag> forany;
00135     typedef TAO::Array_Traits<forany> array_traits;
00136     ::CORBA::ULong const length = source.length ();
00137     if (!(strm << length)) {
00138       return false;
00139     }
00140     for(CORBA::ULong i = 0; i < length; ++i) {
00141       fixed_array tmp_array = array_traits::dup (source[i]);
00142       forany const tmp (tmp_array.inout ());
00143       if (!(strm << tmp)) {
00144         return false;
00145       }
00146     }
00147     return true;
00148   }

template<typename stream , typename object_t , typename object_t_var , CORBA::ULong MAX>
bool TAO::marshal_sequence ( stream &  strm,
const TAO::bounded_object_reference_sequence< object_t, object_t_var, MAX > &  source 
) [inline]

Definition at line 556 of file Bounded_Sequence_CDR_T.h.

00556                                                                                                                          {
00557     typedef typename TAO::bounded_object_reference_sequence<object_t, object_t_var, MAX>::object_type object_type;
00558     ::CORBA::ULong const length = source.length ();
00559     if (length > source.maximum () || !(strm << length)) {
00560       return false;
00561     }
00562     for(CORBA::ULong i = 0; i < length; ++i) {
00563       if (!TAO::Objref_Traits<object_type>::marshal (source[i], strm)) {
00564         return false;
00565       }
00566     }
00567     return true;
00568   }

template<typename stream , typename charT , CORBA::ULong MAX, CORBA::ULong BD_STR_MAX>
bool TAO::marshal_sequence ( stream &  strm,
const TAO::bounded_bd_string_sequence< charT, MAX, BD_STR_MAX > &  source 
) [inline]

Definition at line 538 of file Bounded_Sequence_CDR_T.h.

00538                                                                                                               {
00539     ::CORBA::ULong const length = source.length ();
00540     if (length > source.maximum () || !(strm << length)) {
00541       return false;
00542     }
00543     for(CORBA::ULong i = 0; i < length; ++i) {
00544       if (source[i].in () != 0 &&
00545           ACE_OS::strlen (source[i]) > source.bd_string_maximum ()) {
00546         throw ::CORBA::BAD_PARAM ();
00547       }
00548       if (!(strm << source[i])) {
00549         return false;
00550       }
00551     }
00552     return true;
00553   }

template<typename stream , typename charT , CORBA::ULong MAX>
bool TAO::marshal_sequence ( stream &  strm,
const TAO::bounded_basic_string_sequence< charT, MAX > &  source 
) [inline]

Definition at line 524 of file Bounded_Sequence_CDR_T.h.

00524                                                                                                      {
00525     ::CORBA::ULong const length = source.length ();
00526     if (length > source.maximum () || !(strm << length)) {
00527       return false;
00528     }
00529     for(CORBA::ULong i = 0; i < length; ++i) {
00530       if (!(strm << source[i])) {
00531         return false;
00532       }
00533     }
00534     return true;
00535   }

template<typename stream , typename value_t , CORBA::ULong MAX>
bool TAO::marshal_sequence ( stream &  strm,
const TAO::bounded_value_sequence< value_t, MAX > &  source 
) [inline]

Definition at line 510 of file Bounded_Sequence_CDR_T.h.

00510                                                                                                 {
00511     ::CORBA::ULong const length = source.length ();
00512     if (length > source.maximum () || !(strm << length)) {
00513       return false;
00514     }
00515     for(CORBA::ULong i = 0; i < length; ++i) {
00516       if (!(strm << source[i])) {
00517         return false;
00518       }
00519     }
00520     return true;
00521   }

template<typename stream , CORBA::ULong MAX>
bool TAO::marshal_sequence ( stream &  strm,
const TAO::bounded_value_sequence< CORBA::Boolean, MAX > &  source 
) [inline]

Definition at line 501 of file Bounded_Sequence_CDR_T.h.

00501                                                                                                      {
00502     ::CORBA::ULong const length = source.length ();
00503     if (length > source.maximum () || !(strm << length)) {
00504       return false;
00505     }
00506     return strm.write_boolean_array (source.get_buffer (), length);
00507   }

template<typename stream , CORBA::ULong MAX>
bool TAO::marshal_sequence ( stream &  strm,
const TAO::bounded_value_sequence< CORBA::LongDouble, MAX > &  source 
) [inline]

Definition at line 492 of file Bounded_Sequence_CDR_T.h.

00492                                                                                                         {
00493     ::CORBA::ULong const length = source.length ();
00494     if (length > source.maximum () || !(strm << length)) {
00495       return false;
00496     }
00497     return strm.write_longdouble_array (source.get_buffer (), length);
00498   }

template<typename stream , CORBA::ULong MAX>
bool TAO::marshal_sequence ( stream &  strm,
const TAO::bounded_value_sequence< CORBA::ULongLong, MAX > &  source 
) [inline]

Definition at line 483 of file Bounded_Sequence_CDR_T.h.

00483                                                                                                        {
00484     ::CORBA::ULong const length = source.length ();
00485     if (length > source.maximum () || !(strm << length)) {
00486       return false;
00487     }
00488     return strm.write_ulonglong_array (source.get_buffer (), length);
00489   }

template<typename stream , CORBA::ULong MAX>
bool TAO::marshal_sequence ( stream &  strm,
const TAO::bounded_value_sequence< CORBA::LongLong, MAX > &  source 
) [inline]

Definition at line 474 of file Bounded_Sequence_CDR_T.h.

00474                                                                                                       {
00475     ::CORBA::ULong const length = source.length ();
00476     if (length > source.maximum () || !(strm << length)) {
00477       return false;
00478     }
00479     return strm.write_longlong_array (source.get_buffer (), length);
00480   }

template<typename stream , CORBA::ULong MAX>
bool TAO::marshal_sequence ( stream &  strm,
const TAO::bounded_value_sequence< CORBA::Double, MAX > &  source 
) [inline]

Definition at line 465 of file Bounded_Sequence_CDR_T.h.

00465                                                                                                     {
00466     ::CORBA::ULong const length = source.length ();
00467     if (length > source.maximum () || !(strm << length)) {
00468       return false;
00469     }
00470     return strm.write_double_array (source.get_buffer (), length);
00471   }

template<typename stream , CORBA::ULong MAX>
bool TAO::marshal_sequence ( stream &  strm,
const TAO::bounded_value_sequence< CORBA::Float, MAX > &  source 
) [inline]

Definition at line 456 of file Bounded_Sequence_CDR_T.h.

00456                                                                                                    {
00457     ::CORBA::ULong const length = source.length ();
00458     if (length > source.maximum () || !(strm << length)) {
00459       return false;
00460     }
00461     return strm.write_float_array (source.get_buffer (), length);
00462   }

template<typename stream , CORBA::ULong MAX>
bool TAO::marshal_sequence ( stream &  strm,
const TAO::bounded_value_sequence< CORBA::Char, MAX > &  source 
) [inline]

Definition at line 436 of file Bounded_Sequence_CDR_T.h.

00436                                                                                                   {
00437     ::CORBA::ULong const length = source.length ();
00438     if (length > source.maximum () || !(strm << length)) {
00439       return false;
00440     }
00441     return strm.write_char_array (source.get_buffer (), length);
00442   }

template<typename stream , CORBA::ULong MAX>
bool TAO::marshal_sequence ( stream &  strm,
const TAO::bounded_value_sequence< CORBA::Octet, MAX > &  source 
) [inline]

Definition at line 427 of file Bounded_Sequence_CDR_T.h.

00427                                                                                                    {
00428     ::CORBA::ULong const length = source.length ();
00429     if (length > source.maximum () || !(strm << length)) {
00430       return false;
00431     }
00432     return strm.write_octet_array (source.get_buffer (), length);
00433   }

template<typename stream , CORBA::ULong MAX>
bool TAO::marshal_sequence ( stream &  strm,
const TAO::bounded_value_sequence< CORBA::UShort, MAX > &  source 
) [inline]

Definition at line 418 of file Bounded_Sequence_CDR_T.h.

00418                                                                                                     {
00419     ::CORBA::ULong const length = source.length ();
00420     if (length > source.maximum () || !(strm << length)) {
00421       return false;
00422     }
00423     return strm.write_ushort_array (source.get_buffer (), length);
00424   }

template<typename stream , CORBA::ULong MAX>
bool TAO::marshal_sequence ( stream &  strm,
const TAO::bounded_value_sequence< CORBA::ULong, MAX > &  source 
) [inline]

Definition at line 409 of file Bounded_Sequence_CDR_T.h.

00409                                                                                                    {
00410     ::CORBA::ULong const length = source.length ();
00411     if (length > source.maximum () || !(strm << length)) {
00412       return false;
00413     }
00414     return strm.write_ulong_array (source.get_buffer (), length);
00415   }

template<typename stream , CORBA::ULong MAX>
bool TAO::marshal_sequence ( stream &  strm,
const TAO::bounded_value_sequence< CORBA::Long, MAX > &  source 
) [inline]

Definition at line 400 of file Bounded_Sequence_CDR_T.h.

00400                                                                                                   {
00401     ::CORBA::ULong const length = source.length ();
00402     if (length > source.maximum () || !(strm << length)) {
00403       return false;
00404     }
00405     return strm.write_long_array (source.get_buffer (), length);
00406   }

template<typename stream , CORBA::ULong MAX>
bool TAO::marshal_sequence ( stream &  strm,
const TAO::bounded_value_sequence< CORBA::Short, MAX > &  source 
) [inline]

Definition at line 391 of file Bounded_Sequence_CDR_T.h.

00391                                                                                                    {
00392     ::CORBA::ULong const length = source.length ();
00393     if (length > source.maximum () || !(strm << length)) {
00394       return false;
00395     }
00396     return strm.write_short_array (source.get_buffer (), length);
00397   }

template<typename stream , typename T_array , typename T_slice , typename T_tag , CORBA::ULong MAX>
bool TAO::marshal_sequence ( stream &  strm,
const TAO::bounded_array_sequence< T_array, T_slice, T_tag, MAX > &  source 
) [inline]

Definition at line 130 of file Bounded_Array_Sequence_T.h.

00130                                                                                                                {
00131     typedef TAO_Array_Forany_T<T_array, T_slice, T_tag> forany;
00132     typedef TAO_FixedArray_Var_T <T_array, T_slice, T_tag> fixed_array;
00133     typedef TAO::Array_Traits<forany> array_traits;
00134     ::CORBA::ULong const length = source.length ();
00135     if (length > source.maximum () || !(strm << length)) {
00136       return false;
00137     }
00138     for(CORBA::ULong i = 0; i < length; ++i) {
00139       fixed_array tmp_array = array_traits::dup (source[i]);
00140       forany tmp (tmp_array.inout ());
00141       if (!(strm << tmp)) {
00142         return false;
00143       }
00144     }
00145     return true;
00146   }

bool TAO::parse_orb_opt ( ACE_Argv_Type_Converter &  command_line,
const ACE_TCHAR *  orb_opt,
ACE_TString &  opt_arg 
)

Definition at line 1085 of file ORB.cpp.

01088   {
01089 
01090     if (opt_arg.length () > 0)
01091       return false;
01092 
01093     ACE_Arg_Shifter arg_shifter (command_line.get_argc (),
01094                                  command_line.get_TCHAR_argv ());
01095 
01096     size_t opt_len = ACE_OS::strlen (orb_opt);
01097 
01098     bool found = false;
01099     while (arg_shifter.is_anything_left ())
01100       {
01101         const ACE_TCHAR *current_arg = arg_shifter.get_current ();
01102 
01103         if (ACE_OS::strcasecmp (current_arg,
01104                                 orb_opt) == 0)
01105           {
01106             found = true;
01107             arg_shifter.consume_arg ();
01108             if (arg_shifter.is_parameter_next ())
01109               {
01110                 opt_arg = arg_shifter.get_current ();
01111                 arg_shifter.consume_arg ();
01112               }
01113           }
01114         else if (ACE_OS::strncasecmp (current_arg, orb_opt,
01115                                       opt_len) == 0)
01116           {
01117             arg_shifter.consume_arg ();
01118             // The rest of the argument is the ORB id...
01119             // but we should skip an optional space...
01120             if (current_arg[opt_len] == ' ')
01121               opt_arg = current_arg + opt_len + 1;
01122             else
01123               opt_arg = current_arg + opt_len;
01124           }
01125         else
01126           arg_shifter.ignore_arg ();
01127       }
01128     return found;
01129   }

 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines
Generated on Sat Nov 21 23:30:47 2009 for TAO by  doxygen 1.6.1