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 | 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 | 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 | 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_object_reference_sequence |
| class | bounded_string_sequence |
| class | bounded_value_sequence |
| class | bounded_wstring_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 | Objref_Traits< ::CORBA::Current > |
| class | Arg_Traits< CORBA::Policy > |
| class | Arg_Traits< CORBA::InterfaceDef > |
| struct | Objref_Traits< ::CORBA::DomainManager > |
| struct | Objref_Traits< ::CORBA::ConstructionPolicy > |
| 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 | 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 | 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 | FlResource_Factory |
| TAO_GUI_Resource_Factory for creating FlReactor. More... | |
| class | FlResource_Loader |
| Loads TAO resources related with Fl. More... | |
| class | GUIResource_Factory |
| struct | IIOP_Endpoint_Info |
| Stores information for a single IIOP endpoint. More... | |
| class | IIOPEndpointSequence |
| 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 > |
| class | In_Object_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 |
| struct | Objref_Traits< ::CORBA::Policy > |
| struct | Objref_Traits< ::CORBA::PolicyCurrent > |
| struct | Objref_Traits< ::CORBA::PolicyManager > |
| 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 | QtResource_Factory |
| TAO_GUI_Resource_Factory for creating QtReactor. More... | |
| class | QtResource_Loader |
| Loads TAO resources related with Qt. 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 | 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... | |
| struct | BufferingConstraint |
| interface | BufferingConstraintPolicy |
| struct | Objref_Traits< ::TAO::BufferingConstraintPolicy > |
| class | TkResource_Factory |
| TAO_GUI_Resource_Factory for creating TkReactor. More... | |
| class | TkResource_Loader |
| Loads TAO resources related with Tk. 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 | Default_Transport_Queueing_Strategy |
| class | Flush_Transport_Queueing_Strategy |
| class | Eager_Transport_Queueing_Strategy |
| class | Delayed_Transport_Queueing_Strategy |
| Delay the buffering decision until the transport blocks. More... | |
| class | In_UB_String_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_object_reference_sequence |
| class | unbounded_value_sequence< CORBA::Octet > |
| class | unbounded_string_sequence |
| class | unbounded_value_sequence |
| class | unbounded_wstring_sequence |
| class | In_Var_Array_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 | 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 |
| class | XtResource_Factory |
| TAO_GUI_Resource_Factory for creating XtReactor. More... | |
| class | XtResource_Loader |
| Loads TAO resources related with Xt. More... | |
| 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 TAO_Var_Var_T< IIOP_Endpoint_Info > | IIOP_Endpoint_Info_var |
| typedef TAO_Out_T< IIOP_Endpoint_Info > | IIOP_Endpoint_Info_out |
| typedef TAO_VarSeq_Var_T< IIOPEndpointSequence > | IIOPEndpointSequence_var |
| typedef TAO_Seq_Out_T< IIOPEndpointSequence > | IIOPEndpointSequence_out |
| 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 unsigned short | BufferingConstraintMode |
| typedef CORBA::UShort_out | BufferingConstraintMode_out |
| typedef TAO_Fixed_Var_T< BufferingConstraint > | BufferingConstraint_var |
| typedef BufferingConstraint & | BufferingConstraint_out |
| typedef BufferingConstraintPolicy * | BufferingConstraintPolicy_ptr |
| typedef TAO_Objref_Var_T< BufferingConstraintPolicy > | BufferingConstraintPolicy_var |
| typedef TAO_Objref_Out_T< BufferingConstraintPolicy > | BufferingConstraintPolicy_out |
| 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_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 } |
| 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::details::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::details::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) |
| template<> CORBA::Boolean | In_Object_Argument_T< CORBA::InterfaceDef_ptr, TAO::Any_Insert_Policy_IFR_Client_Adapter< CORBA::InterfaceDef_ptr > >::marshal (TAO_OutputCDR &cdr) |
| TAO_Export CORBA::SystemException * | create_system_exception (const char *id) |
| Create a CORBA::SystemException given the interface repository ID. | |
| 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) |
| 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::details::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::details::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 BufferingConstraintMode | BUFFER_FLUSH = 0x00 |
| const BufferingConstraintMode | BUFFER_TIMEOUT = 0x01 |
| const BufferingConstraintMode | BUFFER_MESSAGE_COUNT = 0x02 |
| const BufferingConstraintMode | BUFFER_MESSAGE_BYTES = 0x04 |
| const CORBA::PolicyType | BUFFERING_CONSTRAINT_POLICY_TYPE = 0x54410001 |
| const Messaging::SyncScope | SYNC_EAGER_BUFFERING = Messaging::SYNC_NONE |
| const Messaging::SyncScope | SYNC_DELAYED_BUFFERING = -2 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Definition at line 135 of file TAOC.h. Referenced by TAO::BufferingConstraintPolicy::_duplicate(), TAO::BufferingConstraintPolicy::_nil(), and TAO::BufferingConstraintPolicy::_tao_release(). |
|
|
Definition at line 141 of file TAOC.h. Referenced by TAO::Eager_Transport_Queueing_Strategy::buffering_constraints_reached(). |
|
|
|
Definition at line 55 of file SystemException.h. |
|
|
Definition at line 89 of file IIOP_EndpointsC.h. |
|
|
Definition at line 83 of file IIOP_EndpointsC.h. |
|
|
Stores information for a collection of IIOP endpoints.
Definition at line 49 of file IIOP_Endpoints.pidl. |
|
|
Definition at line 123 of file IIOP_EndpointsC.h. |
|
|
Definition at line 117 of file IIOP_EndpointsC.h. |
|
|
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 46 of file IORInterceptor_Adapter.h. |
|
|
Definition at line 42 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. @todo: A lifecycle needs to be designed. It can wait for sometime.
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 /// Unknown state.
00057 ENTRY_UNKNOWN
00058 };
|
|
|
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 57 of file Transport.h.
00058 {
00059 TAO_UNSPECIFIED_ROLE = 0,
00060 TAO_SERVER_ROLE = 1,
00061 TAO_CLIENT_ROLE = 2
00062 };
|
|
|
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 };
|
|
|
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 98 of file objectid.h.
00099 {
00100 MCAST_NAMESERVICE,
00101 MCAST_TRADINGSERVICE,
00102 MCAST_IMPLREPOSERVICE,
00103 MCAST_INTERFACEREPOSERVICE
00104 };
|
|
|
Create a CORBA::SystemException given the interface repository ID.
Definition at line 939 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().
00940 {
00941 for (CORBA::ULong i = 0; i < array_sz; ++i)
00942 {
00943 if (ACE_OS::strcmp (id, repo_id_array[i]) == 0)
00944 return (*(excp_array[i])) ();
00945 }
00946
00947 return 0;
00948 }
|
|
||||||||||||||||
|
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::details::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 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 }
|
|
||||||||||||||||
|
Definition at line 311 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().
00311 {
00312 typedef typename TAO::bounded_object_reference_sequence<object_t, object_t_var, MAX> sequence;
00313 ::CORBA::ULong new_length = 0;
00314 if (!(strm >> new_length)) {
00315 return false;
00316 }
00317 if ((new_length > strm.length()) || (new_length > target.maximum ())) {
00318 return false;
00319 }
00320 sequence tmp;
00321 tmp.length(new_length);
00322 typename sequence::value_type * buffer = tmp.get_buffer();
00323 for(CORBA::ULong i = 0; i < new_length; ++i) {
00324 if (!(strm >> buffer[i])) {
00325 return false;
00326 }
00327 }
00328 tmp.swap(target);
00329 return true;
00330 }
|
|
||||||||||||||||
|
Definition at line 285 of file Bounded_Sequence_CDR_T.h. References TAO::details::bounded_basic_string_sequence< charT, MAX >::length(), and TAO::details::bounded_basic_string_sequence< charT, MAX >::maximum().
00285 {
00286 typedef typename TAO::details::bounded_basic_string_sequence <charT, MAX> sequence;
00287 typedef typename sequence::element_traits::string_var string_var;
00288 ::CORBA::ULong new_length = 0;
00289 if (!(strm >> new_length)) {
00290 return false;
00291 }
00292 if ((new_length > strm.length()) || (new_length > target.maximum ())) {
00293 return false;
00294 }
00295 sequence tmp;
00296 tmp.length(new_length);
00297 for(CORBA::ULong i = 0; i < new_length; ++i) {
00298 string_var string;
00299 if (!(strm >> string.inout ())) {
00300 return false;
00301 }
00302 else {
00303 tmp[i] = string._retn ();
00304 }
00305 }
00306 tmp.swap(target);
00307 return true;
00308 }
|
|
||||||||||||||||
|
Definition at line 263 of file Bounded_Sequence_CDR_T.h. References TAO::bounded_value_sequence< T, MAX >::length(), and TAO::bounded_value_sequence< T, MAX >::maximum().
00263 {
00264 typedef TAO::bounded_value_sequence <value_t, 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 for(CORBA::ULong i = 0; i < new_length; ++i) {
00276 if (!(strm >> buffer[i])) {
00277 return false;
00278 }
00279 }
00280 tmp.swap(target);
00281 return true;
00282 }
|
|
||||||||||||||||
|
Definition at line 243 of file Bounded_Sequence_CDR_T.h. References TAO::bounded_value_sequence< T, MAX >::length(), and TAO::bounded_value_sequence< T, MAX >::maximum().
00243 {
00244 typedef TAO::bounded_value_sequence <CORBA::Boolean, 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_boolean_array (buffer, new_length)) {
00256 return false;
00257 }
00258 tmp.swap(target);
00259 return true;
00260 }
|
|
||||||||||||||||
|
Definition at line 223 of file Bounded_Sequence_CDR_T.h. References TAO::bounded_value_sequence< T, MAX >::length(), and TAO::bounded_value_sequence< T, MAX >::maximum().
00223 {
00224 typedef TAO::bounded_value_sequence <CORBA::LongDouble, 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_longdouble_array (buffer, new_length)) {
00236 return false;
00237 }
00238 tmp.swap(target);
00239 return true;
00240 }
|
|
||||||||||||||||
|
Definition at line 203 of file Bounded_Sequence_CDR_T.h. References TAO::bounded_value_sequence< T, MAX >::length(), and TAO::bounded_value_sequence< T, MAX >::maximum().
00203 {
00204 typedef TAO::bounded_value_sequence <CORBA::ULongLong, 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_ulonglong_array (buffer, new_length)) {
00216 return false;
00217 }
00218 tmp.swap(target);
00219 return true;
00220 }
|
|
||||||||||||||||
|
Definition at line 183 of file Bounded_Sequence_CDR_T.h. References TAO::bounded_value_sequence< T, MAX >::length(), and TAO::bounded_value_sequence< T, MAX >::maximum().
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 }
|
|
||||||||||||||||
|
Definition at line 163 of file Bounded_Sequence_CDR_T.h. References TAO::bounded_value_sequence< T, MAX >::length(), and TAO::bounded_value_sequence< T, MAX >::maximum().
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 }
|
|
||||||||||||||||
|
Definition at line 142 of file Bounded_Sequence_CDR_T.h. References TAO::bounded_value_sequence< T, MAX >::length(), and TAO::bounded_value_sequence< T, MAX >::maximum().
00142 {
00143 typedef TAO::bounded_value_sequence <CORBA::WChar, MAX> sequence;
00144 ::CORBA::ULong new_length = 0;
00145 if (!(strm >> new_length)) {
00146 return false;
00147 }
00148 if ((new_length > strm.length()) || (new_length > target.maximum ())) {
00149 return false;
00150 }
00151 sequence tmp;
00152 tmp.length(new_length);
00153 typename sequence::value_type * buffer = tmp.get_buffer();
00154 if (!strm.read_wchar_array (buffer, new_length)) {
00155 return false;
00156 }
00157 tmp.swap(target);
00158 return true;
00159 }
|
|
||||||||||||||||
|
Definition at line 121 of file Bounded_Sequence_CDR_T.h. References TAO::bounded_value_sequence< T, MAX >::length(), and TAO::bounded_value_sequence< T, MAX >::maximum().
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 }
|
|
||||||||||||||||
|
Definition at line 101 of file Bounded_Sequence_CDR_T.h. References TAO::bounded_value_sequence< T, MAX >::length(), and TAO::bounded_value_sequence< T, MAX >::maximum().
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 }
|
|
||||||||||||||||
|
Definition at line 81 of file Bounded_Sequence_CDR_T.h. References TAO::bounded_value_sequence< T, MAX >::length(), and TAO::bounded_value_sequence< T, MAX >::maximum().
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 }
|
|
||||||||||||||||
|
Definition at line 61 of file Bounded_Sequence_CDR_T.h. References TAO::bounded_value_sequence< T, MAX >::length(), and TAO::bounded_value_sequence< T, MAX >::maximum().
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 }
|
|
||||||||||||||||
|
Definition at line 41 of file Bounded_Sequence_CDR_T.h. References TAO::bounded_value_sequence< T, MAX >::length(), and TAO::bounded_value_sequence< T, MAX >::maximum().
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 }
|
|
||||||||||||||||
|
Definition at line 21 of file Bounded_Sequence_CDR_T.h. References TAO::bounded_value_sequence< T, MAX >::length(), and TAO::bounded_value_sequence< T, MAX >::maximum().
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 }
|
|
||||||||||||||||
|
Definition at line 95 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>>().
00095 {
00096 typedef typename TAO::bounded_array_sequence<T_array, T_slice, T_tag, MAX> sequence;
00097 typedef TAO_Array_Forany_T<T_array, T_slice, T_tag> forany;
00098 typedef TAO::Array_Traits<forany> array_traits;
00099
00100 ::CORBA::ULong new_length = 0;
00101 if (!(strm >> new_length)) {
00102 return false;
00103 }
00104 if ((new_length > strm.length()) || (new_length > target.maximum ())) {
00105 return false;
00106 }
00107 sequence tmp;
00108 tmp.length(new_length);
00109 typename sequence::value_type * buffer = tmp.get_buffer();
00110 for(CORBA::ULong i = 0; i < new_length; ++i) {
00111 forany tmp (array_traits::alloc ());
00112 bool const _tao_marshal_flag = (strm >> tmp);
00113 if (_tao_marshal_flag) {
00114 array_traits::copy (buffer[i], tmp.in ());
00115 }
00116 array_traits::free (tmp.inout ());
00117 if (!_tao_marshal_flag) {
00118 return false;
00119 }
00120 }
00121 tmp.swap(target);
00122 return true;
00123 }
|
|
||||||||||
|
Definition at line 78 of file DomainC.cpp. References ACE_Dynamic_Service< TYPE >::instance(), and TAO_IFR_Client_Adapter::interfacedef_cdr_insert().
00079 {
00080 TAO_IFR_Client_Adapter *adapter =
00081 ACE_Dynamic_Service<TAO_IFR_Client_Adapter>::instance (
00082 TAO_ORB_Core::ifr_client_adapter_name ()
00083 );
00084
00085 return adapter->interfacedef_cdr_insert (cdr, this->x_);
00086 }
|
|
||||||||||||||||
|
Definition at line 552 of file Unbounded_Sequence_CDR_T.h. References ACE_THROW_RETURN, and TAO::unbounded_object_reference_sequence< object_t, object_t_var >::length().
00552 {
00553 typedef typename TAO::unbounded_object_reference_sequence<object_t, object_t_var>::object_type objec_t;
00554 if (0 == &source)
00555 ACE_THROW_RETURN (::CORBA::BAD_PARAM(0, CORBA::COMPLETED_MAYBE), false);
00556 ::CORBA::ULong const length = source.length ();
00557 if (!(strm << length)) {
00558 return false;
00559 }
00560 for(CORBA::ULong i = 0; i < length; ++i) {
00561 if (!TAO::Objref_Traits<objec_t>::marshal (source[i], strm)) {
00562 return false;
00563 }
00564 }
00565 return true;
00566 }
|
|
||||||||||||||||
|
Definition at line 536 of file Unbounded_Sequence_CDR_T.h. References ACE_THROW_RETURN, and TAO::details::unbounded_basic_string_sequence< charT >::length().
00536 {
00537 if (0 == &source)
00538 ACE_THROW_RETURN (::CORBA::BAD_PARAM(0, CORBA::COMPLETED_MAYBE), false);
00539 ::CORBA::ULong const length = source.length ();
00540 if (!(strm << length)) {
00541 return false;
00542 }
00543 for(CORBA::ULong i = 0; i < length; ++i) {
00544 if (!(strm << source[i])) {
00545 return false;
00546 }
00547 }
00548 return true;
00549 }
|
|
||||||||||||||||
|
Definition at line 520 of file Unbounded_Sequence_CDR_T.h. References ACE_THROW_RETURN, and TAO::unbounded_value_sequence< T >::length().
00520 {
00521 if (0 == &source)
00522 ACE_THROW_RETURN (::CORBA::BAD_PARAM(0, CORBA::COMPLETED_MAYBE), false);
00523 ::CORBA::ULong const length = source.length ();
00524 if (!(strm << length)) {
00525 return false;
00526 }
00527 for(CORBA::ULong i = 0; i < length; ++i) {
00528 if (!(strm << source[i])) {
00529 return false;
00530 }
00531 }
00532 return true;
00533 }
|
|
||||||||||||||||
|
Definition at line 509 of file Unbounded_Sequence_CDR_T.h. References ACE_THROW_RETURN, TAO::unbounded_value_sequence< T >::get_buffer(), and TAO::unbounded_value_sequence< T >::length().
00509 {
00510 if (0 == &source)
00511 ACE_THROW_RETURN (::CORBA::BAD_PARAM(0, CORBA::COMPLETED_MAYBE), false);
00512 ::CORBA::ULong const length = source.length ();
00513 if (!(strm << length)) {
00514 return false;
00515 }
00516 return strm.write_boolean_array (source.get_buffer (), length);
00517 }
|
|
||||||||||||||||
|
Definition at line 498 of file Unbounded_Sequence_CDR_T.h. References ACE_THROW_RETURN, TAO::unbounded_value_sequence< T >::get_buffer(), and TAO::unbounded_value_sequence< T >::length().
00498 {
00499 if (0 == &source)
00500 ACE_THROW_RETURN (::CORBA::BAD_PARAM(0, CORBA::COMPLETED_MAYBE), false);
00501 ::CORBA::ULong const length = source.length ();
00502 if (!(strm << length)) {
00503 return false;
00504 }
00505 return strm.write_longdouble_array (source.get_buffer (), length);
00506 }
|
|
||||||||||||||||
|
Definition at line 487 of file Unbounded_Sequence_CDR_T.h. References ACE_THROW_RETURN, TAO::unbounded_value_sequence< T >::get_buffer(), and TAO::unbounded_value_sequence< T >::length().
00487 {
00488 if (0 == &source)
00489 ACE_THROW_RETURN (::CORBA::BAD_PARAM(0, CORBA::COMPLETED_MAYBE), false);
00490 ::CORBA::ULong const length = source.length ();
00491 if (!(strm << length)) {
00492 return false;
00493 }
00494 return strm.write_ulonglong_array (source.get_buffer (), length);
00495 }
|
|
||||||||||||||||
|
Definition at line 476 of file Unbounded_Sequence_CDR_T.h. References ACE_THROW_RETURN, TAO::unbounded_value_sequence< T >::get_buffer(), and TAO::unbounded_value_sequence< T >::length().
00476 {
00477 if (0 == &source)
00478 ACE_THROW_RETURN (::CORBA::BAD_PARAM(0, CORBA::COMPLETED_MAYBE), false);
00479 ::CORBA::ULong const length = source.length ();
00480 if (!(strm << length)) {
00481 return false;
00482 }
00483 return strm.write_double_array (source.get_buffer (), length);
00484 }
|
|
||||||||||||||||
|
Definition at line 465 of file Unbounded_Sequence_CDR_T.h. References ACE_THROW_RETURN, TAO::unbounded_value_sequence< T >::get_buffer(), and TAO::unbounded_value_sequence< T >::length().
00465 {
00466 if (0 == &source)
00467 ACE_THROW_RETURN (::CORBA::BAD_PARAM(0, CORBA::COMPLETED_MAYBE), false);
00468 ::CORBA::ULong const length = source.length ();
00469 if (!(strm << length)) {
00470 return false;
00471 }
00472 return strm.write_float_array (source.get_buffer (), length);
00473 }
|
|
||||||||||||||||
|
Definition at line 453 of file Unbounded_Sequence_CDR_T.h. References ACE_THROW_RETURN, TAO::unbounded_value_sequence< T >::get_buffer(), and TAO::unbounded_value_sequence< T >::length().
00453 {
00454 if (0 == &source)
00455 ACE_THROW_RETURN (::CORBA::BAD_PARAM(0, CORBA::COMPLETED_MAYBE), false);
00456 ::CORBA::ULong const length = source.length ();
00457 if (!(strm << length)) {
00458 return false;
00459 }
00460 return strm.write_wchar_array (source.get_buffer (), length);
00461 }
|
|
||||||||||||||||
|
Definition at line 441 of file Unbounded_Sequence_CDR_T.h. References ACE_THROW_RETURN, TAO::unbounded_value_sequence< T >::get_buffer(), and TAO::unbounded_value_sequence< T >::length().
00441 {
00442 if (0 == &source)
00443 ACE_THROW_RETURN (::CORBA::BAD_PARAM(0, CORBA::COMPLETED_MAYBE), false);
00444 ::CORBA::ULong const length = source.length ();
00445 if (!(strm << length)) {
00446 return false;
00447 }
00448 return strm.write_char_array (source.get_buffer (), length);
00449 }
|
|
||||||||||||||||
|
Definition at line 415 of file Unbounded_Sequence_CDR_T.h. References ACE_THROW_RETURN, TAO::unbounded_value_sequence< T >::get_buffer(), and TAO::unbounded_value_sequence< T >::length().
00415 {
00416 if (0 == &source)
00417 ACE_THROW_RETURN (::CORBA::BAD_PARAM(0, CORBA::COMPLETED_MAYBE), false);
00418 ::CORBA::ULong const length = source.length ();
00419 if (!(strm << length)) {
00420 return false;
00421 }
00422 if (source.mb ()) {
00423 return strm.write_octet_array_mb (source.mb ());
00424 }
00425 return strm.write_octet_array (source.get_buffer (), length);
00426 }
|
|
||||||||||||||||
|
Definition at line 403 of file Unbounded_Sequence_CDR_T.h. References ACE_THROW_RETURN, TAO::unbounded_value_sequence< T >::get_buffer(), and TAO::unbounded_value_sequence< T >::length().
00403 {
00404 if (0 == &source)
00405 ACE_THROW_RETURN (::CORBA::BAD_PARAM(0, CORBA::COMPLETED_MAYBE), false);
00406 ::CORBA::ULong const length = source.length ();
00407 if (!(strm << length)) {
00408 return false;
00409 }
00410 return strm.write_ushort_array (source.get_buffer (), length);
00411 }
|
|
||||||||||||||||
|
Definition at line 392 of file Unbounded_Sequence_CDR_T.h. References ACE_THROW_RETURN, TAO::unbounded_value_sequence< T >::get_buffer(), and TAO::unbounded_value_sequence< T >::length().
00392 {
00393 if (0 == &source)
00394 ACE_THROW_RETURN (::CORBA::BAD_PARAM(0, CORBA::COMPLETED_MAYBE), false);
00395 ::CORBA::ULong const length = source.length ();
00396 if (!(strm << length)) {
00397 return false;
00398 }
00399 return strm.write_ulong_array (source.get_buffer (), length);
00400 }
|
|
||||||||||||||||
|
Definition at line 381 of file Unbounded_Sequence_CDR_T.h. References ACE_THROW_RETURN, TAO::unbounded_value_sequence< T >::get_buffer(), and TAO::unbounded_value_sequence< T >::length().
00381 {
00382 if (0 == &source)
00383 ACE_THROW_RETURN (::CORBA::BAD_PARAM(0, CORBA::COMPLETED_MAYBE), false);
00384 ::CORBA::ULong const length = source.length ();
00385 if (!(strm << length)) {
00386 return false;
00387 }
00388 return strm.write_long_array (source.get_buffer (), length);
00389 }
|
|
||||||||||||||||
|
Definition at line 370 of file Unbounded_Sequence_CDR_T.h. References ACE_THROW_RETURN, TAO::unbounded_value_sequence< T >::get_buffer(), and TAO::unbounded_value_sequence< T >::length().
00370 {
00371 if (0 == &source)
00372 ACE_THROW_RETURN (::CORBA::BAD_PARAM(0, CORBA::COMPLETED_MAYBE), false);
00373 ::CORBA::ULong const length = source.length ();
00374 if (!(strm << length)) {
00375 return false;
00376 }
00377 return strm.write_short_array (source.get_buffer (), length);
00378 }
|
|
||||||||||||||||
|
Definition at line 132 of file Unbounded_Array_Sequence_T.h. References ACE_THROW_RETURN, and TAO::unbounded_array_sequence< T_array, T_slice, T_tag >::length().
00132 {
00133 if (0 == &source)
00134 ACE_THROW_RETURN (::CORBA::BAD_PARAM(0, CORBA::COMPLETED_MAYBE), false);
00135 typedef TAO_FixedArray_Var_T <T_array, T_slice, T_tag> fixed_array;
00136 typedef TAO_Array_Forany_T <T_array, T_slice, T_tag> forany;
00137 typedef TAO::Array_Traits<forany> array_traits;
00138 ::CORBA::ULong const length = source.length ();
00139 if (!(strm << length)) {
00140 return false;
00141 }
00142 for(CORBA::ULong i = 0; i < length; ++i) {
00143 fixed_array tmp_array = array_traits::dup (source[i]);
00144 forany const tmp (tmp_array.inout ());
00145 if (!(strm << tmp)) {
00146 return false;
00147 }
00148 }
00149 return true;
00150 }
|
|
||||||||||||||||
|
Definition at line 501 of file Bounded_Sequence_CDR_T.h. References ACE_THROW_RETURN, and TAO::bounded_object_reference_sequence< object_t, object_t_var, MAX >::length().
00501 {
00502 typedef typename TAO::bounded_object_reference_sequence<object_t, object_t_var, MAX>::object_type object_type;
00503 if (0 == &source)
00504 ACE_THROW_RETURN (::CORBA::BAD_PARAM(0, CORBA::COMPLETED_MAYBE), false);
00505 ::CORBA::ULong const length = source.length ();
00506 if (!(strm << length)) {
00507 return false;
00508 }
00509 for(CORBA::ULong i = 0; i < length; ++i) {
00510 if (!TAO::Objref_Traits<object_type>::marshal (source[i], strm)) {
00511 return false;
00512 }
00513 }
00514 return true;
00515 }
|
|
||||||||||||||||
|
Definition at line 485 of file Bounded_Sequence_CDR_T.h. References ACE_THROW_RETURN, and TAO::details::bounded_basic_string_sequence< charT, MAX >::length().
00485 {
00486 if (0 == &source)
00487 ACE_THROW_RETURN (::CORBA::BAD_PARAM(0, CORBA::COMPLETED_MAYBE), false);
00488 ::CORBA::ULong const length = source.length ();
00489 if (!(strm << length)) {
00490 return false;
00491 }
00492 for(CORBA::ULong i = 0; i < length; ++i) {
00493 if (!(strm << source[i])) {
00494 return false;
00495 }
00496 }
00497 return true;
00498 }
|
|
||||||||||||||||
|
Definition at line 469 of file Bounded_Sequence_CDR_T.h. References ACE_THROW_RETURN, and TAO::bounded_value_sequence< T, MAX >::length().
00469 {
00470 if (0 == &source)
00471 ACE_THROW_RETURN (::CORBA::BAD_PARAM(0, CORBA::COMPLETED_MAYBE), false);
00472 ::CORBA::ULong const length = source.length ();
00473 if (!(strm << length)) {
00474 return false;
00475 }
00476 for(CORBA::ULong i = 0; i < length; ++i) {
00477 if (!(strm << source[i])) {
00478 return false;
00479 }
00480 }
00481 return true;
00482 }
|
|
||||||||||||||||
|
Definition at line 458 of file Bounded_Sequence_CDR_T.h. References ACE_THROW_RETURN, TAO::bounded_value_sequence< T, MAX >::get_buffer(), and TAO::bounded_value_sequence< T, MAX >::length().
00458 {
00459 if (0 == &source)
00460 ACE_THROW_RETURN (::CORBA::BAD_PARAM(0, CORBA::COMPLETED_MAYBE), false);
00461 ::CORBA::ULong const length = source.length ();
00462 if (!(strm << length)) {
00463 return false;
00464 }
00465 return strm.write_boolean_array (source.get_buffer (), length);
00466 }
|
|
||||||||||||||||
|
Definition at line 447 of file Bounded_Sequence_CDR_T.h. References ACE_THROW_RETURN, TAO::bounded_value_sequence< T, MAX >::get_buffer(), and TAO::bounded_value_sequence< T, MAX >::length().
00447 {
00448 if (0 == &source)
00449 ACE_THROW_RETURN (::CORBA::BAD_PARAM(0, CORBA::COMPLETED_MAYBE), false);
00450 ::CORBA::ULong const length = source.length ();
00451 if (!(strm << length)) {
00452 return false;
00453 }
00454 return strm.write_longdouble_array (source.get_buffer (), length);
00455 }
|
|
||||||||||||||||
|
Definition at line 436 of file Bounded_Sequence_CDR_T.h. References ACE_THROW_RETURN, TAO::bounded_value_sequence< T, MAX >::get_buffer(), and TAO::bounded_value_sequence< T, MAX >::length().
00436 {
00437 if (0 == &source)
00438 ACE_THROW_RETURN (::CORBA::BAD_PARAM(0, CORBA::COMPLETED_MAYBE), false);
00439 ::CORBA::ULong const length = source.length ();
00440 if (!(strm << length)) {
00441 return false;
00442 }
00443 return strm.write_ulonglong_array (source.get_buffer (), length);
00444 }
|
|
||||||||||||||||
|
Definition at line 425 of file Bounded_Sequence_CDR_T.h. References ACE_THROW_RETURN, TAO::bounded_value_sequence< T, MAX >::get_buffer(), and TAO::bounded_value_sequence< T, MAX >::length().
00425 {
00426 if (0 == &source)
00427 ACE_THROW_RETURN (::CORBA::BAD_PARAM(0, CORBA::COMPLETED_MAYBE), false);
00428 ::CORBA::ULong const length = source.length ();
00429 if (!(strm << length)) {
00430 return false;
00431 }
00432 return strm.write_double_array (source.get_buffer (), length);
00433 }
|
|
||||||||||||||||
|
Definition at line 414 of file Bounded_Sequence_CDR_T.h. References ACE_THROW_RETURN, TAO::bounded_value_sequence< T, MAX >::get_buffer(), and TAO::bounded_value_sequence< T, MAX >::length().
00414 {
00415 if (0 == &source)
00416 ACE_THROW_RETURN (::CORBA::BAD_PARAM(0, CORBA::COMPLETED_MAYBE), false);
00417 ::CORBA::ULong const length = source.length ();
00418 if (!(strm << length)) {
00419 return false;
00420 }
00421 return strm.write_float_array (source.get_buffer (), length);
00422 }
|
|
||||||||||||||||
|
Definition at line 402 of file Bounded_Sequence_CDR_T.h. References ACE_THROW_RETURN, TAO::bounded_value_sequence< T, MAX >::get_buffer(), and TAO::bounded_value_sequence< T, MAX >::length().
00402 {
00403 if (0 == &source)
00404 ACE_THROW_RETURN (::CORBA::BAD_PARAM(0, CORBA::COMPLETED_MAYBE), false);
00405 ::CORBA::ULong const length = source.length ();
00406 if (!(strm << length)) {
00407 return false;
00408 }
00409 return strm.write_wchar_array (source.get_buffer (), length);
00410 }
|
|
||||||||||||||||
|
Definition at line 390 of file Bounded_Sequence_CDR_T.h. References ACE_THROW_RETURN, TAO::bounded_value_sequence< T, MAX >::get_buffer(), and TAO::bounded_value_sequence< T, MAX >::length().
00390 {
00391 if (0 == &source)
00392 ACE_THROW_RETURN (::CORBA::BAD_PARAM(0, CORBA::COMPLETED_MAYBE), false);
00393 ::CORBA::ULong const length = source.length ();
00394 if (!(strm << length)) {
00395 return false;
00396 }
00397 return strm.write_char_array (source.get_buffer (), length);
00398 }
|
|
||||||||||||||||
|
Definition at line 379 of file Bounded_Sequence_CDR_T.h. References ACE_THROW_RETURN, TAO::bounded_value_sequence< T, MAX >::get_buffer(), and TAO::bounded_value_sequence< T, MAX >::length().
00379 {
00380 if (0 == &source)
00381 ACE_THROW_RETURN (::CORBA::BAD_PARAM(0, CORBA::COMPLETED_MAYBE), false);
00382 ::CORBA::ULong const length = source.length ();
00383 if (!(strm << length)) {
00384 return false;
00385 }
00386 return strm.write_octet_array (source.get_buffer (), length);
00387 }
|
|
||||||||||||||||
|
Definition at line 368 of file Bounded_Sequence_CDR_T.h. References ACE_THROW_RETURN, TAO::bounded_value_sequence< T, MAX >::get_buffer(), and TAO::bounded_value_sequence< T, MAX >::length().
00368 {
00369 if (0 == &source)
00370 ACE_THROW_RETURN (::CORBA::BAD_PARAM(0, CORBA::COMPLETED_MAYBE), false);
00371 ::CORBA::ULong const length = source.length ();
00372 if (!(strm << length)) {
00373 return false;
00374 }
00375 return strm.write_ushort_array (source.get_buffer (), length);
00376 }
|
|
||||||||||||||||
|
Definition at line 357 of file Bounded_Sequence_CDR_T.h. References ACE_THROW_RETURN, TAO::bounded_value_sequence< T, MAX >::get_buffer(), and TAO::bounded_value_sequence< T, MAX >::length().
00357 {
00358 if (0 == &source)
00359 ACE_THROW_RETURN (::CORBA::BAD_PARAM(0, CORBA::COMPLETED_MAYBE), false);
00360 ::CORBA::ULong const length = source.length ();
00361 if (!(strm << length)) {
00362 return false;
00363 }
00364 return strm.write_ulong_array (source.get_buffer (), length);
00365 }
|
|
||||||||||||||||
|
Definition at line 346 of file Bounded_Sequence_CDR_T.h. References ACE_THROW_RETURN, TAO::bounded_value_sequence< T, MAX >::get_buffer(), and TAO::bounded_value_sequence< T, MAX >::length().
00346 {
00347 if (0 == &source)
00348 ACE_THROW_RETURN (::CORBA::BAD_PARAM(0, CORBA::COMPLETED_MAYBE), false);
00349 ::CORBA::ULong const length = source.length ();
00350 if (!(strm << length)) {
00351 return false;
00352 }
00353 return strm.write_long_array (source.get_buffer (), length);
00354 }
|
|
||||||||||||||||
|
Definition at line 335 of file Bounded_Sequence_CDR_T.h. References ACE_THROW_RETURN, TAO::bounded_value_sequence< T, MAX >::get_buffer(), and TAO::bounded_value_sequence< T, MAX >::length().
00335 {
00336 if (0 == &source)
00337 ACE_THROW_RETURN (::CORBA::BAD_PARAM(0, CORBA::COMPLETED_MAYBE), false);
00338 ::CORBA::ULong const length = source.length ();
00339 if (!(strm << length)) {
00340 return false;
00341 }
00342 return strm.write_short_array (source.get_buffer (), length);
00343 }
|
|
||||||||||||||||
|
Definition at line 126 of file Bounded_Array_Sequence_T.h. References ACE_THROW_RETURN, and TAO::bounded_array_sequence< T_array, T_slice, T_tag, MAX >::length(). Referenced by operator<<().
00126 {
00127 if (0 == &source)
00128 ACE_THROW_RETURN (::CORBA::BAD_PARAM(0, CORBA::COMPLETED_MAYBE), false);
00129 typedef TAO_Array_Forany_T<T_array, T_slice, T_tag> forany;
00130 typedef TAO_FixedArray_Var_T <T_array, T_slice, T_tag> fixed_array;
00131 typedef TAO::Array_Traits<forany> array_traits;
00132 ::CORBA::ULong const length = source.length ();
00133 if (!(strm << length)) {
00134 return false;
00135 }
00136 for(CORBA::ULong i = 0; i < length; ++i) {
00137 fixed_array tmp_array = array_traits::dup (source[i]);
00138 forany tmp (tmp_array.inout ());
00139 if (!(strm << tmp)) {
00140 return false;
00141 }
00142 }
00143 return true;
00144 }
|
|
|
Definition at line 992 of file Object.cpp. References CORBA::Object::_duplicate(), and CORBA::Object_ptr.
00993 {
00994 return CORBA::Object::_duplicate (p);
00995 }
|
|
||||||||||||
|
Definition at line 1010 of file Object.cpp. References CORBA::Object::marshal(), and CORBA::Object_ptr.
01012 {
01013 return p->marshal (cdr);
01014 }
|
|
|
Definition at line 1004 of file Object.cpp. References CORBA::Object::_nil().
01005 {
01006 return CORBA::Object::_nil ();
01007 }
|
|
|
Definition at line 998 of file Object.cpp. References CORBA::Object_ptr.
00999 {
01000 ::CORBA::release (p);
01001 }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
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