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_object_reference_sequence |
| class | bounded_value_sequence |
| class | TAO_Buffer_Allocator |
| Generic buffer allocator for TAO. More... | |
| class | Cache_IntId |
| Helper class for TAO_Transport_Cache_Manager. More... | |
| class | Cache_ExtId |
| Helper class for TAO_Transport_Cache_Manager: unifies several data items, so they can be stored together as a for a 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 |
| struct | IIOP_Endpoint_Info |
| Stores information for a single IIOP endpoint. More... | |
| 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 | 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 |
| 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_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 |
| struct | Array_Traits |
| Specialized for each array in generated code. More... | |
| struct | TAO |
| class | ORB_Table_Ref_Counter |
| Class contained by ORB_Table's Unbounded_Set. More... | |
| class | TAO_Wait_On_LF_No_Upcall |
| Wait according to the Leader-Follower model (like TAO_Wait_On_Leader_Follower), but do not allow nested upcalls. More... | |
Typedefs | |
| typedef String_Manager_T< CORBA::Char > | String_Manager |
| typedef String_Manager_T< CORBA::WChar > | WString_Manager |
| typedef CORBA::Exception *(* | TAO_Exception_Alloc )(void) |
| typedef sequence< IIOP_Endpoint_Info > | IIOPEndpointSequence |
| Stores information for a collection of IIOP endpoints. | |
| typedef ACE_Array_Base< ::PortableInterceptor::ObjectReferenceTemplate * > | ObjectReferenceTemplate_Array |
| typedef sequence< octet > | ObjectKey |
| typedef TAO_FixedSeq_Var_T< ObjectKey > | ObjectKey_var |
| typedef TAO_Seq_Out_T< ObjectKey > | ObjectKey_out |
| typedef Collocation_Proxy_Broker *(* | Proxy_Broker_Factory )(CORBA::Object_ptr) |
| typedef CORBA::SystemException *(* | excp_factory )(void) |
| typedef ACE_Unbounded_Set< TAO_Connection_Handler * > | Connection_Handler_Set |
Enumerations | |
| enum | Cache_Entries_State { ENTRY_IDLE_AND_PURGABLE, ENTRY_IDLE_BUT_NOT_PURGABLE, ENTRY_PURGABLE_BUT_NOT_IDLE, ENTRY_BUSY, ENTRY_CLOSED, ENTRY_CONNECTING, ENTRY_UNKNOWN } |
| enum | Collocation_Strategy { TAO_CS_REMOTE_STRATEGY, TAO_CS_THRU_POA_STRATEGY, TAO_CS_DIRECT_STRATEGY, TAO_CS_LAST } |
| enum | Invocation_Status { TAO_INVOKE_START = 0, TAO_INVOKE_RESTART, TAO_INVOKE_SUCCESS, TAO_INVOKE_USER_EXCEPTION, TAO_INVOKE_SYSTEM_EXCEPTION, TAO_INVOKE_FAILURE } |
| enum | Invocation_Type { TAO_ONEWAY_INVOCATION, TAO_TWOWAY_INVOCATION } |
| Enums for invocation types. More... | |
| enum | Invocation_Mode { TAO_SYNCHRONOUS_INVOCATION, TAO_ASYNCHRONOUS_CALLBACK_INVOCATION, TAO_ASYNCHRONOUS_POLLER_INVOCATION, TAO_DII_INVOCATION, TAO_DII_DEFERRED_INVOCATION, TAO_DII_ASYNCH_INVOCATION } |
| Enum for invocation modes. More... | |
| enum | MCAST_SERVICEID { MCAST_NAMESERVICE, MCAST_TRADINGSERVICE, MCAST_IMPLREPOSERVICE, MCAST_INTERFACEREPOSERVICE } |
| enum | Connection_Role { TAO_UNSPECIFIED_ROLE = 0, TAO_SERVER_ROLE = 1, TAO_CLIENT_ROLE = 2 } |
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::WChar, 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::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 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::WChar, 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::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 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. | |
| void | In_Object_Argument_Cloner_T< CORBA::InterfaceDef_ptr >::duplicate (CORBA::InterfaceDef_ptr) |
| void | In_Object_Argument_Cloner_T< CORBA::InterfaceDef_ptr >::release (CORBA::InterfaceDef_ptr) |
| CORBA::Object_ptr | Objref_Traits< CORBA::Object >::duplicate (CORBA::Object_ptr p) |
| void | Objref_Traits< CORBA::Object >::release (CORBA::Object_ptr p) |
| CORBA::Object_ptr | Objref_Traits< CORBA::Object >::nil (void) |
| CORBA::Boolean | Objref_Traits< CORBA::Object >::marshal (const CORBA::Object_ptr p, TAO_OutputCDR &cdr) |
| bool | parse_orb_opt (ACE_Argv_Type_Converter &command_line, const ACE_TCHAR *orb_opt, ACE_CString &opt_arg) |
| 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::WChar > &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::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 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::WChar > &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::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 object_t, typename object_t_var> bool | marshal_sequence (stream &strm, const TAO::unbounded_object_reference_sequence< object_t, object_t_var > &source) |
Variables | |
| const CORBA::ULong | VMCID = 0x54410000U |
| TAO Vendor Minor Codeset ID (VMCID). | |
| const CORBA::ULong | MAX_MINOR_CODE = VMCID | 0xfffU |
| Maximum allowed TAO system exception minor code. | |
| const CORBA::ULong | VPVID = VMCID |
TAO Vendor PolicyType Valueset ID (VPVID). | |
| const Messaging::SyncScope | SYNC_DELAYED_BUFFERING = -2 |
This file contains idl definition for data structures used to encapsulate data in TAO_TAG_ENDPOINTS tagged component. This TAO-specific component is used for transmission of multiple endpoints per single profile. Data structures defined here are used for transmission of IIOP endpoints. See IIOP_Profile.* for more details.
This file was used to generate the code in IIOP_EndpointsC.* The command used to generate code is:
tao_idl -o orig -GA -Sci \ -Wb,export_macro=TAO_Export \ -Wb,export_include="tao/TAO_Export.h" \ -Wb,pre_include="ace/pre.h" \ -Wb,post_include="ace/post.h" \ IIOP_Endpoints.pidl
|
|
|
Definition at line 64 of file SystemException.h. |
|
|
Stores information for a collection of IIOP endpoints.
Definition at line 39 of file IIOP_Endpoints.pidl. Referenced by TAO_IIOP_Profile::decode_endpoints(), and TAO_IIOP_Profile::encode_endpoints(). |
|
|
Definition at line 21 of file Object_Key.pidl. |
|
|
Definition at line 90 of file Object_KeyC.h. |
|
|
Definition at line 84 of file Object_KeyC.h. |
|
|
Definition at line 47 of file IORInterceptor_Adapter.h. |
|
|
Definition at line 41 of file Object_T.h. Referenced by TAO::Narrow_Utils< T >::narrow(), and TAO::Narrow_Utils< T >::unchecked_narrow(). |
|
|
Definition at line 37 of file CORBA_String.h. |
|
|
Definition at line 38 of file Exception_Data.h. |
|
|
Definition at line 38 of file CORBA_String.h. |
|
|
States of a recyclable object.
Definition at line 39 of file Cache_Entries.h. Referenced by TAO::Transport_Cache_Manager::is_entry_idle().
00040 {
00041 /// Idle and can be purged.
00042 ENTRY_IDLE_AND_PURGABLE,
00043
00044 /// Idle but cannot be purged.
00045 ENTRY_IDLE_BUT_NOT_PURGABLE,
00046
00047 /// Can be purged, but is not idle (mostly for debugging).
00048 ENTRY_PURGABLE_BUT_NOT_IDLE,
00049
00050 /// Busy (i.e., cannot be recycled or purged).
00051 ENTRY_BUSY,
00052
00053 /// Closed.
00054 ENTRY_CLOSED,
00055
00056 /// Connection in process, but not complete
00057 ENTRY_CONNECTING,
00058
00059 /// Unknown state.
00060 ENTRY_UNKNOWN
00061 };
|
|
|
Definition at line 25 of file Collocation_Strategy.h. Referenced by TAO::Invocation_Adapter::invoke_i().
00026 {
00027 /// i.e no collocation.
00028 TAO_CS_REMOTE_STRATEGY,
00029
00030 /// Calls to the collocated object are forwarded by the POA.
00031 TAO_CS_THRU_POA_STRATEGY,
00032
00033 /// Calls to the collocated object are made directly to its
00034 /// servant.
00035 TAO_CS_DIRECT_STRATEGY,
00036
00037 /// This value should always be the last value in the enumeration.
00038 /// It provides the count for the number of collocation
00039 /// strategies.
00040 TAO_CS_LAST
00041 };
|
|
|
Definition at line 58 of file Transport.h.
00059 {
00060 TAO_UNSPECIFIED_ROLE = 0,
00061 TAO_SERVER_ROLE = 1,
00062 TAO_CLIENT_ROLE = 2
00063 };
|
|
|
Enum for invocation modes.
Definition at line 58 of file Invocation_Utils.h.
00058 {
00059 /// Standard synchronous twoway
00060 TAO_SYNCHRONOUS_INVOCATION,
00061 /// Asynchronous twoway with callback model for collecting the
00062 /// replies.
00063 TAO_ASYNCHRONOUS_CALLBACK_INVOCATION,
00064 /// Asynchronous twoway with poller model for collecting the
00065 /// replies.
00066 /// @note This is not supported in TAO now
00067 TAO_ASYNCHRONOUS_POLLER_INVOCATION,
00068 /// Types of DII
00069 TAO_DII_INVOCATION,
00070 TAO_DII_DEFERRED_INVOCATION,
00071 TAO_DII_ASYNCH_INVOCATION
00072 };
|
|
|
Definition at line 30 of file Invocation_Utils.h. Referenced by TAO::Synch_Twoway_Invocation::check_reply_status(), TAO::Synch_Twoway_Invocation::handle_system_exception(), TAO::LocateRequest_Invocation_Adapter::invoke(), TAO::LocateRequest_Invocation::invoke(), TAO::Collocated_Invocation::invoke(), TAO::Invocation_Adapter::invoke_oneway(), TAO::Invocation_Adapter::invoke_twoway(), TAO::Synch_Oneway_Invocation::remote_oneway(), and TAO::Synch_Twoway_Invocation::remote_twoway().
00031 {
00032 /// Initial state of the FSM in the invocation class.
00033 TAO_INVOKE_START = 0,
00034 /// The request must be restarted, a temporary failure has
00035 /// occured.
00036 TAO_INVOKE_RESTART,
00037 /// invoke() call successful. Final state of the FSM.
00038 TAO_INVOKE_SUCCESS,
00039 /// Received a user exception from the remote object, and this
00040 /// is one of the final states.
00041 TAO_INVOKE_USER_EXCEPTION,
00042 /// Received a system exception from the remote object or the
00043 /// PI and it is one of the final states
00044 TAO_INVOKE_SYSTEM_EXCEPTION,
00045 /// Invocation failed. It is a final state.
00046 TAO_INVOKE_FAILURE
00047 };
|
|
|
Enums for invocation types.
Definition at line 50 of file Invocation_Utils.h.
00050 {
00051 /// A simple oneway invocation
00052 TAO_ONEWAY_INVOCATION,
00053 /// A simple twoway invocation
00054 TAO_TWOWAY_INVOCATION
00055 };
|
|
|
Definition at line 100 of file objectid.h.
00101 {
00102 MCAST_NAMESERVICE,
00103 MCAST_TRADINGSERVICE,
00104 MCAST_IMPLREPOSERVICE,
00105 MCAST_INTERFACEREPOSERVICE
00106 };
|
|
|
Create a CORBA::SystemException given the interface repository ID.
Definition at line 935 of file SystemException.cpp. References array_sz, excp_array, repo_id_array, and ACE_OS::strcmp(). Referenced by TAO::Synch_Twoway_Invocation::handle_system_exception().
00936 {
00937 for (CORBA::ULong i = 0; i < array_sz; ++i)
00938 {
00939 if (ACE_OS::strcmp (id, repo_id_array[i]) == 0)
00940 return (*(excp_array[i])) ();
00941 }
00942
00943 return 0;
00944 }
|
|
||||||||||||||||
|
Definition at line 346 of file Unbounded_Sequence_CDR_T.h.
00346 {
00347 typedef TAO::unbounded_object_reference_sequence<object_t, object_t_var> sequence;
00348 ::CORBA::ULong new_length = 0;
00349 if (!(strm >> new_length)) {
00350 return false;
00351 }
00352 if (new_length > strm.length()) {
00353 return false;
00354 }
00355 sequence tmp(new_length);
00356 tmp.length(new_length);
00357 typename sequence::value_type * buffer = tmp.get_buffer();
00358 for(CORBA::ULong i = 0; i < new_length; ++i) {
00359 if (!(strm >> buffer[i])) {
00360 return false;
00361 }
00362 }
00363 tmp.swap(target);
00364 return true;
00365 }
|
|
||||||||||||||||
|
Definition at line 320 of file Unbounded_Sequence_CDR_T.h.
00320 {
00321 typedef TAO::unbounded_basic_string_sequence <charT> sequence;
00322 typedef typename sequence::element_traits::string_var string_var;
00323 ::CORBA::ULong new_length = 0;
00324 if (!(strm >> new_length)) {
00325 return false;
00326 }
00327 if (new_length > strm.length()) {
00328 return false;
00329 }
00330 sequence tmp(new_length);
00331 tmp.length(new_length);
00332 for(CORBA::ULong i = 0; i < new_length; ++i) {
00333 string_var string;
00334 if (!(strm >> string.inout ())) {
00335 return false;
00336 }
00337 else {
00338 tmp[i] = string._retn ();
00339 }
00340 }
00341 tmp.swap(target);
00342 return true;
00343 }
|
|
||||||||||||||||
|
Definition at line 298 of file Unbounded_Sequence_CDR_T.h.
00298 {
00299 typedef TAO::unbounded_value_sequence <value_t> sequence;
00300 ::CORBA::ULong new_length = 0;
00301 if (!(strm >> new_length)) {
00302 return false;
00303 }
00304 if (new_length > strm.length()) {
00305 return false;
00306 }
00307 sequence tmp(new_length);
00308 tmp.length(new_length);
00309 typename sequence::value_type * buffer = tmp.get_buffer();
00310 for(CORBA::ULong i = 0; i < new_length; ++i) {
00311 if (!(strm >> buffer[i])) {
00312 return false;
00313 }
00314 }
00315 tmp.swap(target);
00316 return true;
00317 }
|
|
||||||||||||||||
|
Definition at line 278 of file Unbounded_Sequence_CDR_T.h.
00278 {
00279 typedef TAO::unbounded_value_sequence <CORBA::Boolean> sequence;
00280 ::CORBA::ULong new_length = 0;
00281 if (!(strm >> new_length)) {
00282 return false;
00283 }
00284 if (new_length > strm.length()) {
00285 return false;
00286 }
00287 sequence tmp(new_length);
00288 tmp.length(new_length);
00289 typename sequence::value_type * buffer = tmp.get_buffer();
00290 if (!strm.read_boolean_array (buffer, new_length)) {
00291 return false;
00292 }
00293 tmp.swap(target);
00294 return true;
00295 }
|
|
||||||||||||||||
|
Definition at line 258 of file Unbounded_Sequence_CDR_T.h.
00258 {
00259 typedef TAO::unbounded_value_sequence <CORBA::LongDouble> sequence;
00260 ::CORBA::ULong new_length = 0;
00261 if (!(strm >> new_length)) {
00262 return false;
00263 }
00264 if (new_length > strm.length()) {
00265 return false;
00266 }
00267 sequence tmp(new_length);
00268 tmp.length(new_length);
00269 typename sequence::value_type * buffer = tmp.get_buffer();
00270 if (!strm.read_longdouble_array (buffer, new_length)) {
00271 return false;
00272 }
00273 tmp.swap(target);
00274 return true;
00275 }
|
|
||||||||||||||||
|
Definition at line 238 of file Unbounded_Sequence_CDR_T.h.
00238 {
00239 typedef TAO::unbounded_value_sequence <CORBA::ULongLong> sequence;
00240 ::CORBA::ULong new_length = 0;
00241 if (!(strm >> new_length)) {
00242 return false;
00243 }
00244 if (new_length > strm.length()) {
00245 return false;
00246 }
00247 sequence tmp(new_length);
00248 tmp.length(new_length);
00249 typename sequence::value_type * buffer = tmp.get_buffer();
00250 if (!strm.read_ulonglong_array (buffer, new_length)) {
00251 return false;
00252 }
00253 tmp.swap(target);
00254 return true;
00255 }
|
|
||||||||||||||||
|
Definition at line 218 of file Unbounded_Sequence_CDR_T.h.
00218 {
00219 typedef TAO::unbounded_value_sequence <CORBA::Double> sequence;
00220 ::CORBA::ULong new_length = 0;
00221 if (!(strm >> new_length)) {
00222 return false;
00223 }
00224 if (new_length > strm.length()) {
00225 return false;
00226 }
00227 sequence tmp(new_length);
00228 tmp.length(new_length);
00229 typename sequence::value_type * buffer = tmp.get_buffer();
00230 if (!strm.read_double_array (buffer, new_length)) {
00231 return false;
00232 }
00233 tmp.swap(target);
00234 return true;
00235 }
|
|
||||||||||||||||
|
Definition at line 198 of file Unbounded_Sequence_CDR_T.h.
00198 {
00199 typedef TAO::unbounded_value_sequence <CORBA::Float> sequence;
00200 ::CORBA::ULong new_length = 0;
00201 if (!(strm >> new_length)) {
00202 return false;
00203 }
00204 if (new_length > strm.length()) {
00205 return false;
00206 }
00207 sequence tmp(new_length);
00208 tmp.length(new_length);
00209 typename sequence::value_type * buffer = tmp.get_buffer();
00210 if (!strm.read_float_array (buffer, new_length)) {
00211 return false;
00212 }
00213 tmp.swap(target);
00214 return true;
00215 }
|
|
||||||||||||||||
|
Definition at line 177 of file Unbounded_Sequence_CDR_T.h.
00177 {
00178 typedef TAO::unbounded_value_sequence <CORBA::WChar> sequence;
00179 ::CORBA::ULong new_length = 0;
00180 if (!(strm >> new_length)) {
00181 return false;
00182 }
00183 if (new_length > strm.length()) {
00184 return false;
00185 }
00186 sequence tmp(new_length);
00187 tmp.length(new_length);
00188 typename sequence::value_type * buffer = tmp.get_buffer();
00189 if (!strm.read_wchar_array (buffer, new_length)) {
00190 return false;
00191 }
00192 tmp.swap(target);
00193 return true;
00194 }
|
|
||||||||||||||||
|
Definition at line 156 of file Unbounded_Sequence_CDR_T.h.
00156 {
00157 typedef TAO::unbounded_value_sequence <CORBA::Char> sequence;
00158 ::CORBA::ULong new_length = 0;
00159 if (!(strm >> new_length)) {
00160 return false;
00161 }
00162 if (new_length > strm.length()) {
00163 return false;
00164 }
00165 sequence tmp(new_length);
00166 tmp.length(new_length);
00167 typename sequence::value_type * buffer = tmp.get_buffer();
00168 if (!strm.read_char_array (buffer, new_length)) {
00169 return false;
00170 }
00171 tmp.swap(target);
00172 return true;
00173 }
|
|
||||||||||||||||
|
Definition at line 102 of file Unbounded_Sequence_CDR_T.h. References ACE_BIT_DISABLED, and TAO_ORB_Core::resource_factory().
00102 {
00103 typedef TAO::unbounded_value_sequence <CORBA::Octet> sequence;
00104 ::CORBA::ULong new_length = 0;
00105 if (!(strm >> new_length)) {
00106 return false;
00107 }
00108 if (new_length > strm.length()) {
00109 return false;
00110 }
00111 sequence tmp(new_length);
00112 tmp.length(new_length);
00113 if (ACE_BIT_DISABLED (strm.start ()->flags (), ACE_Message_Block::DONT_DELETE))
00114 {
00115 TAO_ORB_Core* orb_core = strm.orb_core ();
00116 if (orb_core != 0 && strm.orb_core ()->resource_factory ()->
00117 input_cdr_allocator_type_locked () == 1)
00118 {
00119 tmp.replace (new_length, strm.start ());
00120 tmp.mb ()->wr_ptr (tmp.mb()->rd_ptr () + new_length);
00121 strm.skip_bytes (new_length);
00122 tmp.swap(target);
00123 return true;
00124 }
00125 }
00126 typename sequence::value_type * buffer = tmp.get_buffer();
00127 if (!strm.read_octet_array (buffer, new_length)) {
00128 return false;
00129 }
00130 tmp.swap(target);
00131 return true;
00132 }
|
|
||||||||||||||||
|
Definition at line 81 of file Unbounded_Sequence_CDR_T.h.
00081 {
00082 typedef TAO::unbounded_value_sequence <CORBA::UShort> sequence;
00083 ::CORBA::ULong new_length = 0;
00084 if (!(strm >> new_length)) {
00085 return false;
00086 }
00087 if (new_length > strm.length()) {
00088 return false;
00089 }
00090 sequence tmp(new_length);
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 }
|
|
||||||||||||||||
|
Definition at line 61 of file Unbounded_Sequence_CDR_T.h.
00061 {
00062 typedef TAO::unbounded_value_sequence <CORBA::ULong> sequence;
00063 ::CORBA::ULong new_length = 0;
00064 if (!(strm >> new_length)) {
00065 return false;
00066 }
00067 if (new_length > strm.length()) {
00068 return false;
00069 }
00070 sequence tmp(new_length);
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 }
|
|
||||||||||||||||
|
Definition at line 41 of file Unbounded_Sequence_CDR_T.h.
00041 {
00042 typedef TAO::unbounded_value_sequence <CORBA::Long> sequence;
00043 ::CORBA::ULong new_length = 0;
00044 if (!(strm >> new_length)) {
00045 return false;
00046 }
00047 if (new_length > strm.length()) {
00048 return false;
00049 }
00050 sequence tmp(new_length);
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 }
|
|
||||||||||||||||
|
Definition at line 21 of file Unbounded_Sequence_CDR_T.h.
00021 {
00022 typedef TAO::unbounded_value_sequence <CORBA::Short> sequence;
00023 ::CORBA::ULong new_length = 0;
00024 if (!(strm >> new_length)) {
00025 return false;
00026 }
00027 if (new_length > strm.length()) {
00028 return false;
00029 }
00030 sequence tmp(new_length);
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 }
|
|
||||||||||||||||
|
Definition at line 100 of file Unbounded_Array_Sequence_T.h.
00100 {
00101 typedef TAO::unbounded_array_sequence<T_array, T_slice, T_tag> sequence;
00102 typedef TAO_Array_Forany_T <T_array, T_slice, T_tag> forany;
00103 typedef TAO::Array_Traits<forany> array_traits;
00104
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 typename sequence::value_type * buffer = tmp.get_buffer();
00115 for(CORBA::ULong i = 0; i < new_length; ++i) {
00116 forany tmp (array_traits::alloc ());
00117 bool const _tao_marshal_flag = (strm >> tmp);
00118 if (_tao_marshal_flag) {
00119 array_traits::copy (buffer[i], tmp.in ());
00120 }
00121 array_traits::free (tmp.inout ());
00122 if (!_tao_marshal_flag) {
00123 return false;
00124 }
00125 }
00126 tmp.swap(target);
00127 return true;
00128 }
|
|
||||||||||||||||
|
Definition at line 310 of file Bounded_Sequence_CDR_T.h. References TAO::bounded_object_reference_sequence< object_t, object_t_var, MAX >::length(), and TAO::bounded_object_reference_sequence< object_t, object_t_var, MAX >::maximum().
00310 {
00311 typedef typename TAO::bounded_object_reference_sequence<object_t, object_t_var, MAX> sequence;
00312 ::CORBA::ULong new_length = 0;
00313 if (!(strm >> new_length)) {
00314 return false;
00315 }
00316 if ((new_length > strm.length()) || (new_length > target.maximum ())) {
00317 return false;
00318 }
00319 sequence tmp;
00320 tmp.length(new_length);
00321 typename sequence::value_type * buffer = tmp.get_buffer();
00322 for(CORBA::ULong i = 0; i < new_length; ++i) {
00323 if (!(strm >> buffer[i])) {
00324 return false;
00325 }
00326 }
00327 tmp.swap(target);
00328 return true;
00329 }
|
|
||||||||||||||||
|
Definition at line 284 of file Bounded_Sequence_CDR_T.h. References TAO::bounded_basic_string_sequence< charT, MAX >::length(), and TAO::bounded_basic_string_sequence< charT, MAX >::maximum().
00284 {
00285 typedef typename TAO::bounded_basic_string_sequence <charT, MAX> sequence;
00286 typedef typename sequence::element_traits::string_var string_var;
00287 ::CORBA::ULong new_length = 0;
00288 if (!(strm >> new_length)) {
00289 return false;
00290 }
00291 if ((new_length > strm.length()) || (new_length > target.maximum ())) {
00292 return false;
00293 }
00294 sequence tmp;
00295 tmp.length(new_length);
00296 for(CORBA::ULong i = 0; i < new_length; ++i) {
00297 string_var string;
00298 if (!(strm >> string.inout ())) {
00299 return false;
00300 }
00301 else {
00302 tmp[i] = string._retn ();
00303 }
00304 }
00305 tmp.swap(target);
00306 return true;
00307 }
|
|
||||||||||||||||
|
Definition at line 262 of file Bounded_Sequence_CDR_T.h. References TAO::bounded_value_sequence< T, MAX >::length(), and TAO::bounded_value_sequence< T, MAX >::maximum().
00262 {
00263 typedef TAO::bounded_value_sequence <value_t, MAX> sequence;
00264 ::CORBA::ULong new_length = 0;
00265 if (!(strm >> new_length)) {
00266 return false;
00267 }
00268 if ((new_length > strm.length()) || (new_length > target.maximum ())) {
00269 return false;
00270 }
00271 sequence tmp;
00272 tmp.length(new_length);
00273 typename sequence::value_type * buffer = tmp.get_buffer();
00274 for(CORBA::ULong i = 0; i < new_length; ++i) {
00275 if (!(strm >> buffer[i])) {
00276 return false;
00277 }
00278 }
00279 tmp.swap(target);
00280 return true;
00281 }
|
|
||||||||||||||||
|
Definition at line 242 of file Bounded_Sequence_CDR_T.h. References TAO::bounded_value_sequence< T, MAX >::length(), and TAO::bounded_value_sequence< T, MAX >::maximum().
00242 {
00243 typedef TAO::bounded_value_sequence <CORBA::Boolean, MAX> sequence;
00244 ::CORBA::ULong new_length = 0;
00245 if (!(strm >> new_length)) {
00246 return false;
00247 }
00248 if ((new_length > strm.length()) || (new_length > target.maximum ())) {
00249 return false;
00250 }
00251 sequence tmp;
00252 tmp.length(new_length);
00253 typename sequence::value_type * buffer = tmp.get_buffer();
00254 if (!strm.read_boolean_array (buffer, new_length)) {
00255 return false;
00256 }
00257 tmp.swap(target);
00258 return true;
00259 }
|
|
||||||||||||||||
|
Definition at line 222 of file Bounded_Sequence_CDR_T.h. References TAO::bounded_value_sequence< T, MAX >::length(), and TAO::bounded_value_sequence< T, MAX >::maximum().
00222 {
00223 typedef TAO::bounded_value_sequence <CORBA::LongDouble, MAX> sequence;
00224 ::CORBA::ULong new_length = 0;
00225 if (!(strm >> new_length)) {
00226 return false;
00227 }
00228 if ((new_length > strm.length()) || (new_length > target.maximum ())) {
00229 return false;
00230 }
00231 sequence tmp;
00232 tmp.length(new_length);
00233 typename sequence::value_type * buffer = tmp.get_buffer();
00234 if (!strm.read_longdouble_array (buffer, new_length)) {
00235 return false;
00236 }
00237 tmp.swap(target);
00238 return true;
00239 }
|
|
||||||||||||||||
|
Definition at line 202 of file Bounded_Sequence_CDR_T.h. References TAO::bounded_value_sequence< T, MAX >::length(), and TAO::bounded_value_sequence< T, MAX >::maximum().
00202 {
00203 typedef TAO::bounded_value_sequence <CORBA::ULongLong, MAX> sequence;
00204 ::CORBA::ULong new_length = 0;
00205 if (!(strm >> new_length)) {
00206 return false;
00207 }
00208 if ((new_length > strm.length()) || (new_length > target.maximum ())) {
00209 return false;
00210 }
00211 sequence tmp;
00212 tmp.length(new_length);
00213 typename sequence::value_type * buffer = tmp.get_buffer();
00214 if (!strm.read_ulonglong_array (buffer, new_length)) {
00215 return false;
00216 }
00217 tmp.swap(target);
00218 return true;
00219 }
|
|
||||||||||||||||
|
Definition at line 182 of file Bounded_Sequence_CDR_T.h. References TAO::bounded_value_sequence< T, MAX >::length(), and TAO::bounded_value_sequence< T, MAX >::maximum().
00182 {
00183 typedef TAO::bounded_value_sequence <CORBA::Double, MAX> sequence;
00184 ::CORBA::ULong new_length = 0;
00185 if (!(strm >> new_length)) {
00186 return false;
00187 }
00188 if ((new_length > strm.length()) || (new_length > target.maximum ())) {
00189 return false;
00190 }
00191 sequence tmp;
00192 tmp.length(new_length);
00193 typename sequence::value_type * buffer = tmp.get_buffer();
00194 if (!strm.read_double_array (buffer, new_length)) {
00195 return false;
00196 }
00197 tmp.swap(target);
00198 return true;
00199 }
|
|
||||||||||||||||
|
Definition at line 162 of file Bounded_Sequence_CDR_T.h. References TAO::bounded_value_sequence< T, MAX >::length(), and TAO::bounded_value_sequence< T, MAX >::maximum().
00162 {
00163 typedef TAO::bounded_value_sequence <CORBA::Float, MAX> sequence;
00164 ::CORBA::ULong new_length = 0;
00165 if (!(strm >> new_length)) {
00166 return false;
00167 }
00168 if ((new_length > strm.length()) || (new_length > target.maximum ())) {
00169 return false;
00170 }
00171 sequence tmp;
00172 tmp.length(new_length);
00173 typename sequence::value_type * buffer = tmp.get_buffer();
00174 if (!strm.read_float_array (buffer, new_length)) {
00175 return false;
00176 }
00177 tmp.swap(target);
00178 return true;
00179 }
|
|
||||||||||||||||
|
Definition at line 141 of file Bounded_Sequence_CDR_T.h. References TAO::bounded_value_sequence< T, MAX >::length(), and TAO::bounded_value_sequence< T, MAX >::maximum().
00141 {
00142 typedef TAO::bounded_value_sequence <CORBA::WChar, MAX> sequence;
00143 ::CORBA::ULong new_length = 0;
00144 if (!(strm >> new_length)) {
00145 return false;
00146 }
00147 if ((new_length > strm.length()) || (new_length > target.maximum ())) {
00148 return false;
00149 }
00150 sequence tmp;
00151 tmp.length(new_length);
00152 typename sequence::value_type * buffer = tmp.get_buffer();
00153 if (!strm.read_wchar_array (buffer, new_length)) {
00154 return false;
00155 }
00156 tmp.swap(target);
00157 return true;
00158 }
|
|
||||||||||||||||
|
Definition at line 120 of file Bounded_Sequence_CDR_T.h. References TAO::bounded_value_sequence< T, MAX >::length(), and TAO::bounded_value_sequence< T, MAX >::maximum().
00120 {
00121 typedef TAO::bounded_value_sequence <CORBA::Char, MAX> sequence;
00122 ::CORBA::ULong new_length = 0;
00123 if (!(strm >> new_length)) {
00124 return false;
00125 }
00126 if ((new_length > strm.length()) || (new_length > target.maximum ())) {
00127 return false;
00128 }
00129 sequence tmp;
00130 tmp.length(new_length);
00131 typename sequence::value_type * buffer = tmp.get_buffer();
00132 if (!strm.read_char_array (buffer, new_length)) {
00133 return false;
00134 }
00135 tmp.swap(target);
00136 return true;
00137 }
|
|
||||||||||||||||
|
Definition at line 100 of file Bounded_Sequence_CDR_T.h. References TAO::bounded_value_sequence< T, MAX >::length(), and TAO::bounded_value_sequence< T, MAX >::maximum().
00100 {
00101 typedef TAO::bounded_value_sequence <CORBA::Octet, MAX> sequence;
00102 ::CORBA::ULong new_length = 0;
00103 if (!(strm >> new_length)) {
00104 return false;
00105 }
00106 if ((new_length > strm.length()) || (new_length > target.maximum ())) {
00107 return false;
00108 }
00109 sequence tmp;
00110 tmp.length(new_length);
00111 typename sequence::value_type * buffer = tmp.get_buffer();
00112 if (!strm.read_octet_array (buffer, new_length)) {
00113 return false;
00114 }
00115 tmp.swap(target);
00116 return true;
00117 }
|
|
||||||||||||||||
|
Definition at line 80 of file Bounded_Sequence_CDR_T.h. References TAO::bounded_value_sequence< T, MAX >::length(), and TAO::bounded_value_sequence< T, MAX >::maximum().
00080 {
00081 typedef TAO::bounded_value_sequence <CORBA::UShort, MAX> sequence;
00082 ::CORBA::ULong new_length = 0;
00083 if (!(strm >> new_length)) {
00084 return false;
00085 }
00086 if ((new_length > strm.length()) || (new_length > target.maximum ())) {
00087 return false;
00088 }
00089 sequence tmp;
00090 tmp.length(new_length);
00091 typename sequence::value_type * buffer = tmp.get_buffer();
00092 if (!strm.read_ushort_array (buffer, new_length)) {
00093 return false;
00094 }
00095 tmp.swap(target);
00096 return true;
00097 }
|
|
||||||||||||||||
|
Definition at line 60 of file Bounded_Sequence_CDR_T.h. References TAO::bounded_value_sequence< T, MAX >::length(), and TAO::bounded_value_sequence< T, MAX >::maximum().
00060 {
00061 typedef TAO::bounded_value_sequence <CORBA::ULong, MAX> sequence;
00062 ::CORBA::ULong new_length = 0;
00063 if (!(strm >> new_length)) {
00064 return false;
00065 }
00066 if ((new_length > strm.length()) || (new_length > target.maximum ())) {
00067 return false;
00068 }
00069 sequence tmp;
00070 tmp.length(new_length);
00071 typename sequence::value_type * buffer = tmp.get_buffer();
00072 if (!strm.read_ulong_array (buffer, new_length)) {
00073 return false;
00074 }
00075 tmp.swap(target);
00076 return true;
00077 }
|
|
||||||||||||||||
|
Definition at line 40 of file Bounded_Sequence_CDR_T.h. References TAO::bounded_value_sequence< T, MAX >::length(), and TAO::bounded_value_sequence< T, MAX >::maximum().
00040 {
00041 typedef TAO::bounded_value_sequence <CORBA::Long, MAX> sequence;
00042 ::CORBA::ULong new_length = 0;
00043 if (!(strm >> new_length)) {
00044 return false;
00045 }
00046 if ((new_length > strm.length()) || (new_length > target.maximum ())) {
00047 return false;
00048 }
00049 sequence tmp;
00050 tmp.length(new_length);
00051 typename sequence::value_type * buffer = tmp.get_buffer();
00052 if (!strm.read_long_array (buffer, new_length)) {
00053 return false;
00054 }
00055 tmp.swap(target);
00056 return true;
00057 }
|
|
||||||||||||||||
|
Definition at line 20 of file Bounded_Sequence_CDR_T.h. References TAO::bounded_value_sequence< T, MAX >::length(), and TAO::bounded_value_sequence< T, MAX >::maximum().
00020 {
00021 typedef TAO::bounded_value_sequence <CORBA::Short, MAX> sequence;
00022 ::CORBA::ULong new_length = 0;
00023 if (!(strm >> new_length)) {
00024 return false;
00025 }
00026 if ((new_length > strm.length()) || (new_length > target.maximum ())) {
00027 return false;
00028 }
00029 sequence tmp;
00030 tmp.length(new_length);
00031 typename sequence::value_type * buffer = tmp.get_buffer();
00032 if (!strm.read_short_array (buffer, new_length)) {
00033 return false;
00034 }
00035 tmp.swap(target);
00036 return true;
00037 }
|
|
||||||||||||||||
|
Definition at line 94 of file Bounded_Array_Sequence_T.h. References TAO::bounded_array_sequence< T_array, T_slice, T_tag, MAX >::length(), and TAO::bounded_array_sequence< T_array, T_slice, T_tag, MAX >::maximum(). Referenced by operator>>().
00094 {
00095 typedef typename TAO::bounded_array_sequence<T_array, T_slice, T_tag, MAX> sequence;
00096 typedef TAO_Array_Forany_T<T_array, T_slice, T_tag> forany;
00097 typedef TAO::Array_Traits<forany> array_traits;
00098
00099 ::CORBA::ULong new_length = 0;
00100 if (!(strm >> new_length)) {
00101 return false;
00102 }
00103 if ((new_length > strm.length()) || (new_length > target.maximum ())) {
00104 return false;
00105 }
00106 sequence tmp;
00107 tmp.length(new_length);
00108 typename sequence::value_type * buffer = tmp.get_buffer();
00109 for(CORBA::ULong i = 0; i < new_length; ++i) {
00110 forany tmp (array_traits::alloc ());
00111 bool const _tao_marshal_flag = (strm >> tmp);
00112 if (_tao_marshal_flag) {
00113 array_traits::copy (buffer[i], tmp.in ());
00114 }
00115 array_traits::free (tmp.inout ());
00116 if (!_tao_marshal_flag) {
00117 return false;
00118 }
00119 }
00120 tmp.swap(target);
00121 return true;
00122 }
|
|
|
Definition at line 949 of file Object.cpp. References CORBA::InterfaceDef_ptr.
00950 {
00951 }
|
|
|
Definition at line 954 of file Object.cpp. References CORBA::InterfaceDef_ptr.
00955 {
00956 }
|
|
||||||||||||||||
|
Definition at line 522 of file Unbounded_Sequence_CDR_T.h. References TAO::unbounded_object_reference_sequence< object_t, object_t_var >::length().
00522 {
00523 typedef typename TAO::unbounded_object_reference_sequence<object_t, object_t_var>::object_type objec_t;
00524 ::CORBA::ULong const length = source.length ();
00525 if (!(strm << length)) {
00526 return false;
00527 }
00528 for(CORBA::ULong i = 0; i < length; ++i) {
00529 if (!TAO::Objref_Traits<objec_t>::marshal (source[i], strm)) {
00530 return false;
00531 }
00532 }
00533 return true;
00534 }
|
|
||||||||||||||||
|
Definition at line 508 of file Unbounded_Sequence_CDR_T.h. References TAO::unbounded_basic_string_sequence< charT >::length().
00508 {
00509 ::CORBA::ULong const length = source.length ();
00510 if (!(strm << length)) {
00511 return false;
00512 }
00513 for(CORBA::ULong i = 0; i < length; ++i) {
00514 if (!(strm << source[i])) {
00515 return false;
00516 }
00517 }
00518 return true;
00519 }
|
|
||||||||||||||||
|
Definition at line 494 of file Unbounded_Sequence_CDR_T.h. References TAO::unbounded_value_sequence< T >::length().
00494 {
00495 ::CORBA::ULong const length = source.length ();
00496 if (!(strm << length)) {
00497 return false;
00498 }
00499 for(CORBA::ULong i = 0; i < length; ++i) {
00500 if (!(strm << source[i])) {
00501 return false;
00502 }
00503 }
00504 return true;
00505 }
|
|
||||||||||||||||
|
Definition at line 485 of file Unbounded_Sequence_CDR_T.h. References TAO::unbounded_value_sequence< T >::get_buffer(), and TAO::unbounded_value_sequence< T >::length().
00485 {
00486 ::CORBA::ULong const length = source.length ();
00487 if (!(strm << length)) {
00488 return false;
00489 }
00490 return strm.write_boolean_array (source.get_buffer (), length);
00491 }
|
|
||||||||||||||||
|
Definition at line 476 of file Unbounded_Sequence_CDR_T.h. References TAO::unbounded_value_sequence< T >::get_buffer(), and TAO::unbounded_value_sequence< T >::length().
00476 {
00477 ::CORBA::ULong const length = source.length ();
00478 if (!(strm << length)) {
00479 return false;
00480 }
00481 return strm.write_longdouble_array (source.get_buffer (), length);
00482 }
|
|
||||||||||||||||
|
Definition at line 467 of file Unbounded_Sequence_CDR_T.h. References TAO::unbounded_value_sequence< T >::get_buffer(), and TAO::unbounded_value_sequence< T >::length().
00467 {
00468 ::CORBA::ULong const length = source.length ();
00469 if (!(strm << length)) {
00470 return false;
00471 }
00472 return strm.write_ulonglong_array (source.get_buffer (), length);
00473 }
|
|
||||||||||||||||
|
Definition at line 458 of file Unbounded_Sequence_CDR_T.h. References TAO::unbounded_value_sequence< T >::get_buffer(), and TAO::unbounded_value_sequence< T >::length().
00458 {
00459 ::CORBA::ULong const length = source.length ();
00460 if (!(strm << length)) {
00461 return false;
00462 }
00463 return strm.write_double_array (source.get_buffer (), length);
00464 }
|
|
||||||||||||||||
|
Definition at line 449 of file Unbounded_Sequence_CDR_T.h. References TAO::unbounded_value_sequence< T >::get_buffer(), and TAO::unbounded_value_sequence< T >::length().
00449 {
00450 ::CORBA::ULong const length = source.length ();
00451 if (!(strm << length)) {
00452 return false;
00453 }
00454 return strm.write_float_array (source.get_buffer (), length);
00455 }
|
|
||||||||||||||||
|
Definition at line 439 of file Unbounded_Sequence_CDR_T.h. References TAO::unbounded_value_sequence< T >::get_buffer(), and TAO::unbounded_value_sequence< T >::length().
00439 {
00440 ::CORBA::ULong const length = source.length ();
00441 if (!(strm << length)) {
00442 return false;
00443 }
00444 return strm.write_wchar_array (source.get_buffer (), length);
00445 }
|
|
||||||||||||||||
|
Definition at line 429 of file Unbounded_Sequence_CDR_T.h. References TAO::unbounded_value_sequence< T >::get_buffer(), and TAO::unbounded_value_sequence< T >::length().
00429 {
00430 ::CORBA::ULong const length = source.length ();
00431 if (!(strm << length)) {
00432 return false;
00433 }
00434 return strm.write_char_array (source.get_buffer (), length);
00435 }
|
|
||||||||||||||||
|
Definition at line 407 of file Unbounded_Sequence_CDR_T.h. References TAO::unbounded_value_sequence< T >::get_buffer(), and TAO::unbounded_value_sequence< T >::length().
00407 {
00408 ::CORBA::ULong const length = source.length ();
00409 if (!(strm << length)) {
00410 return false;
00411 }
00412 if (source.mb ()) {
00413 return strm.write_octet_array_mb (source.mb ());
00414 }
00415 return strm.write_octet_array (source.get_buffer (), length);
00416 }
|
|
||||||||||||||||
|
Definition at line 397 of file Unbounded_Sequence_CDR_T.h. References TAO::unbounded_value_sequence< T >::get_buffer(), and TAO::unbounded_value_sequence< T >::length().
00397 {
00398 ::CORBA::ULong const length = source.length ();
00399 if (!(strm << length)) {
00400 return false;
00401 }
00402 return strm.write_ushort_array (source.get_buffer (), length);
00403 }
|
|
||||||||||||||||
|
Definition at line 388 of file Unbounded_Sequence_CDR_T.h. References TAO::unbounded_value_sequence< T >::get_buffer(), and TAO::unbounded_value_sequence< T >::length().
00388 {
00389 ::CORBA::ULong const length = source.length ();
00390 if (!(strm << length)) {
00391 return false;
00392 }
00393 return strm.write_ulong_array (source.get_buffer (), length);
00394 }
|
|
||||||||||||||||
|
Definition at line 379 of file Unbounded_Sequence_CDR_T.h. References TAO::unbounded_value_sequence< T >::get_buffer(), and TAO::unbounded_value_sequence< T >::length().
00379 {
00380 ::CORBA::ULong const length = source.length ();
00381 if (!(strm << length)) {
00382 return false;
00383 }
00384 return strm.write_long_array (source.get_buffer (), length);
00385 }
|
|
||||||||||||||||
|
Definition at line 370 of file Unbounded_Sequence_CDR_T.h. References TAO::unbounded_value_sequence< T >::get_buffer(), and TAO::unbounded_value_sequence< T >::length().
00370 {
00371 ::CORBA::ULong const length = source.length ();
00372 if (!(strm << length)) {
00373 return false;
00374 }
00375 return strm.write_short_array (source.get_buffer (), length);
00376 }
|
|
||||||||||||||||
|
Definition at line 131 of file Unbounded_Array_Sequence_T.h. References TAO::unbounded_array_sequence< T_array, T_slice, T_tag >::length().
00131 {
00132 typedef TAO_FixedArray_Var_T <T_array, T_slice, T_tag> fixed_array;
00133 typedef TAO_Array_Forany_T <T_array, T_slice, T_tag> forany;
00134 typedef TAO::Array_Traits<forany> array_traits;
00135 ::CORBA::ULong const length = source.length ();
00136 if (!(strm << length)) {
00137 return false;
00138 }
00139 for(CORBA::ULong i = 0; i < length; ++i) {
00140 fixed_array tmp_array = array_traits::dup (source[i]);
00141 forany const tmp (tmp_array.inout ());
00142 if (!(strm << tmp)) {
00143 return false;
00144 }
00145 }
00146 return true;
00147 }
|
|
||||||||||||||||
|
Definition at line 472 of file Bounded_Sequence_CDR_T.h. References TAO::bounded_object_reference_sequence< object_t, object_t_var, MAX >::length().
00472 {
00473 typedef typename TAO::bounded_object_reference_sequence<object_t, object_t_var, MAX>::object_type object_type;
00474 ::CORBA::ULong const length = source.length ();
00475 if (!(strm << length)) {
00476 return false;
00477 }
00478 for(CORBA::ULong i = 0; i < length; ++i) {
00479 if (!TAO::Objref_Traits<object_type>::marshal (source[i], strm)) {
00480 return false;
00481 }
00482 }
00483 return true;
00484 }
|
|
||||||||||||||||
|
Definition at line 458 of file Bounded_Sequence_CDR_T.h. References TAO::bounded_basic_string_sequence< charT, MAX >::length().
00458 {
00459 ::CORBA::ULong const length = source.length ();
00460 if (!(strm << length)) {
00461 return false;
00462 }
00463 for(CORBA::ULong i = 0; i < length; ++i) {
00464 if (!(strm << source[i])) {
00465 return false;
00466 }
00467 }
00468 return true;
00469 }
|
|
||||||||||||||||
|
Definition at line 444 of file Bounded_Sequence_CDR_T.h. References TAO::bounded_value_sequence< T, MAX >::length().
00444 {
00445 ::CORBA::ULong const length = source.length ();
00446 if (!(strm << length)) {
00447 return false;
00448 }
00449 for(CORBA::ULong i = 0; i < length; ++i) {
00450 if (!(strm << source[i])) {
00451 return false;
00452 }
00453 }
00454 return true;
00455 }
|
|
||||||||||||||||
|
Definition at line 435 of file Bounded_Sequence_CDR_T.h. References TAO::bounded_value_sequence< T, MAX >::get_buffer(), and TAO::bounded_value_sequence< T, MAX >::length().
00435 {
00436 ::CORBA::ULong const length = source.length ();
00437 if (!(strm << length)) {
00438 return false;
00439 }
00440 return strm.write_boolean_array (source.get_buffer (), length);
00441 }
|
|
||||||||||||||||
|
Definition at line 426 of file Bounded_Sequence_CDR_T.h. References TAO::bounded_value_sequence< T, MAX >::get_buffer(), and TAO::bounded_value_sequence< T, MAX >::length().
00426 {
00427 ::CORBA::ULong const length = source.length ();
00428 if (!(strm << length)) {
00429 return false;
00430 }
00431 return strm.write_longdouble_array (source.get_buffer (), length);
00432 }
|
|
||||||||||||||||
|
Definition at line 417 of file Bounded_Sequence_CDR_T.h. References TAO::bounded_value_sequence< T, MAX >::get_buffer(), and TAO::bounded_value_sequence< T, MAX >::length().
00417 {
00418 ::CORBA::ULong const length = source.length ();
00419 if (!(strm << length)) {
00420 return false;
00421 }
00422 return strm.write_ulonglong_array (source.get_buffer (), length);
00423 }
|
|
||||||||||||||||
|
Definition at line 408 of file Bounded_Sequence_CDR_T.h. References TAO::bounded_value_sequence< T, MAX >::get_buffer(), and TAO::bounded_value_sequence< T, MAX >::length().
00408 {
00409 ::CORBA::ULong const length = source.length ();
00410 if (!(strm << length)) {
00411 return false;
00412 }
00413 return strm.write_double_array (source.get_buffer (), length);
00414 }
|
|
||||||||||||||||
|
Definition at line 399 of file Bounded_Sequence_CDR_T.h. References TAO::bounded_value_sequence< T, MAX >::get_buffer(), and TAO::bounded_value_sequence< T, MAX >::length().
00399 {
00400 ::CORBA::ULong const length = source.length ();
00401 if (!(strm << length)) {
00402 return false;
00403 }
00404 return strm.write_float_array (source.get_buffer (), length);
00405 }
|
|
||||||||||||||||
|
Definition at line 389 of file Bounded_Sequence_CDR_T.h. References TAO::bounded_value_sequence< T, MAX >::get_buffer(), and TAO::bounded_value_sequence< T, MAX >::length().
00389 {
00390 ::CORBA::ULong const length = source.length ();
00391 if (!(strm << length)) {
00392 return false;
00393 }
00394 return strm.write_wchar_array (source.get_buffer (), length);
00395 }
|
|
||||||||||||||||
|
Definition at line 379 of file Bounded_Sequence_CDR_T.h. References TAO::bounded_value_sequence< T, MAX >::get_buffer(), and TAO::bounded_value_sequence< T, MAX >::length().
00379 {
00380 ::CORBA::ULong const length = source.length ();
00381 if (!(strm << length)) {
00382 return false;
00383 }
00384 return strm.write_char_array (source.get_buffer (), length);
00385 }
|
|
||||||||||||||||
|
Definition at line 370 of file Bounded_Sequence_CDR_T.h. References TAO::bounded_value_sequence< T, MAX >::get_buffer(), and TAO::bounded_value_sequence< T, MAX >::length().
00370 {
00371 ::CORBA::ULong const length = source.length ();
00372 if (!(strm << length)) {
00373 return false;
00374 }
00375 return strm.write_octet_array (source.get_buffer (), length);
00376 }
|
|
||||||||||||||||
|
Definition at line 361 of file Bounded_Sequence_CDR_T.h. References TAO::bounded_value_sequence< T, MAX >::get_buffer(), and TAO::bounded_value_sequence< T, MAX >::length().
00361 {
00362 ::CORBA::ULong const length = source.length ();
00363 if (!(strm << length)) {
00364 return false;
00365 }
00366 return strm.write_ushort_array (source.get_buffer (), length);
00367 }
|
|
||||||||||||||||
|
Definition at line 352 of file Bounded_Sequence_CDR_T.h. References TAO::bounded_value_sequence< T, MAX >::get_buffer(), and TAO::bounded_value_sequence< T, MAX >::length().
00352 {
00353 ::CORBA::ULong const length = source.length ();
00354 if (!(strm << length)) {
00355 return false;
00356 }
00357 return strm.write_ulong_array (source.get_buffer (), length);
00358 }
|
|
||||||||||||||||
|
Definition at line 343 of file Bounded_Sequence_CDR_T.h. References TAO::bounded_value_sequence< T, MAX >::get_buffer(), and TAO::bounded_value_sequence< T, MAX >::length().
00343 {
00344 ::CORBA::ULong const length = source.length ();
00345 if (!(strm << length)) {
00346 return false;
00347 }
00348 return strm.write_long_array (source.get_buffer (), length);
00349 }
|
|
||||||||||||||||
|
Definition at line 334 of file Bounded_Sequence_CDR_T.h. References TAO::bounded_value_sequence< T, MAX >::get_buffer(), and TAO::bounded_value_sequence< T, MAX >::length().
00334 {
00335 ::CORBA::ULong const length = source.length ();
00336 if (!(strm << length)) {
00337 return false;
00338 }
00339 return strm.write_short_array (source.get_buffer (), length);
00340 }
|
|
||||||||||||||||
|
Definition at line 125 of file Bounded_Array_Sequence_T.h. References TAO::bounded_array_sequence< T_array, T_slice, T_tag, MAX >::length(). Referenced by operator<<().
00125 {
00126 typedef TAO_Array_Forany_T<T_array, T_slice, T_tag> forany;
00127 typedef TAO_FixedArray_Var_T <T_array, T_slice, T_tag> fixed_array;
00128 typedef TAO::Array_Traits<forany> array_traits;
00129 ::CORBA::ULong const length = source.length ();
00130 if (!(strm << length)) {
00131 return false;
00132 }
00133 for(CORBA::ULong i = 0; i < length; ++i) {
00134 fixed_array tmp_array = array_traits::dup (source[i]);
00135 forany tmp (tmp_array.inout ());
00136 if (!(strm << tmp)) {
00137 return false;
00138 }
00139 }
00140 return true;
00141 }
|
|
|
Definition at line 959 of file Object.cpp. References CORBA::Object::_duplicate(), and CORBA::Object_ptr.
00960 {
00961 return CORBA::Object::_duplicate (p);
00962 }
|
|
||||||||||||
|
Definition at line 977 of file Object.cpp. References CORBA::Object::marshal(), and CORBA::Object_ptr.
00979 {
00980 return p->marshal (cdr);
00981 }
|
|
|
Definition at line 971 of file Object.cpp. References CORBA::Object::_nil().
00972 {
00973 return CORBA::Object::_nil ();
00974 }
|
|
|
Definition at line 965 of file Object.cpp. References CORBA::Object_ptr.
00966 {
00967 ::CORBA::release (p);
00968 }
|
|
||||||||||||||||
|
Definition at line 1092 of file ORB.cpp. References ACE_Arg_Shifter, ACE_TCHAR, ACE_TEXT_ALWAYS_CHAR, ACE_Argv_Type_Converter::get_argc(), ACE_Argv_Type_Converter::get_TCHAR_argv(), parse_orb_opt(), ACE_OS::strcasecmp(), ACE_OS::strlen(), and ACE_OS::strncasecmp(). Referenced by CORBA::ORB_init(), and parse_orb_opt().
01095 {
01096
01097 if (opt_arg.length () > 0)
01098 return false;
01099
01100 ACE_Arg_Shifter arg_shifter (command_line.get_argc (),
01101 command_line.get_TCHAR_argv ());
01102
01103 size_t opt_len = ACE_OS::strlen (orb_opt);
01104
01105 bool found = false;
01106 while (arg_shifter.is_anything_left ())
01107 {
01108 const ACE_TCHAR *current_arg = arg_shifter.get_current ();
01109
01110 if (ACE_OS::strcasecmp (current_arg,
01111 orb_opt) == 0)
01112 {
01113 found = true;
01114 arg_shifter.consume_arg ();
01115 if (arg_shifter.is_parameter_next ())
01116 {
01117 opt_arg =
01118 ACE_TEXT_ALWAYS_CHAR (arg_shifter.get_current ());
01119 arg_shifter.consume_arg ();
01120 }
01121 }
01122 else if (ACE_OS::strncasecmp (current_arg, orb_opt,
01123 opt_len) == 0)
01124 {
01125 arg_shifter.consume_arg ();
01126 // The rest of the argument is the ORB id...
01127 // but we should skip an optional space...
01128 if (current_arg[opt_len] == ' ')
01129 opt_arg =
01130 ACE_TEXT_ALWAYS_CHAR (current_arg + opt_len + 1);
01131 else
01132 opt_arg = ACE_TEXT_ALWAYS_CHAR (current_arg + opt_len);
01133 }
01134 else
01135 arg_shifter.ignore_arg ();
01136 }
01137 return found;
01138 }
|
|
|
Maximum allowed TAO system exception minor code.
Vendors are only allowed to use the lower order 12 bits of their when defining vendor-specific exception minor codes.
Definition at line 86 of file ORB_Constants.h. |
|
|
|
|
|
TAO Vendor Minor Codeset ID (VMCID).
TAO Vendor Minor Codeset ID (VMCID) assigned by the OMG. Do *NOT* change at random. The TAO VMCID is an ASCII representation of
Definition at line 74 of file ORB_Constants.h. |
|
|
TAO Vendor
TAO Vendor
As with TAO-specific system exception minor codes, the TAO-specific
For example, TAO-specific
Definition at line 108 of file ORB_Constants.h. |
1.3.6