A |
| abort [Hydro_proxy.managed_client_t] |
Abort the client (immediate shutdown
|
| abort [Hydro_proxy.pool_t] |
Aborts all pooled clients (immediately)
|
| abort_rw [Hydro_transport.hydro_multiplex_controller] |
Aborts the current reader and/or writer forever.
|
| acall [Hydro_lm.call_suspension_t] |
Do the RPC call asynchronously.
|
| adapter_id [Hydro_oa.object_adapter_t] |
|
| add [Hydro_oa.object_adapter_t] |
add id obj: Adds the object obj under the identity id to the
adapter.
|
| alive [Hydro_transport.hydro_multiplex_controller] |
If the controller is alive, the socket is not yet completely down.
|
| available [Hydro_proxy.managed_client_t] |
available t: Says whether the client is available for new calls
at timestamp t
|
C |
| cancel_rd_polling [Hydro_transport.hydro_multiplex_controller] |
Cancels polling for the next input message.
|
| cancel_shutting_down [Hydro_transport.hydro_multiplex_controller] |
Cancels the shutdown procedure.
|
| clear_error [Hydro_proxy.managed_client_t] |
Clear all error state
|
| client [Hydro_proxy.managed_client_t] |
Return the current incarnation of the client
|
| client_connect_engine [Hydro_connector.transporter] |
An engine that is able to create and, if requested, to connect the socket
|
| client_incarnation [Hydro_proxy.managed_client_t] |
Return the incarnation number of the client just returned
|
| client_pool [Hydro_proxy.proxy_env_t] |
The pool of clients with active connections to servers
|
| context [Hydro_proxy.proxy_conf_t] |
The context of key/value parameters sent with every request.
|
| ctrl [Hydro_connector.multiplexed_descriptor] |
|
D |
| deactivate [Hydro_proxy.managed_client_t] |
Deactivate this client for the passed number of seconds
|
| deactivate_host [Hydro_proxy.pool_t] |
Deactivate the host for this number of seconds
|
| deactivate_port [Hydro_proxy.pool_t] |
Deactivate the port for this number of seconds
|
| deactivation_period [Hydro_proxy.proxy_conf_t] |
For how long endpoints are marked as "dead" when connections repeatedly
break.
|
| default_proxy_conf [Hydro_proxy.proxy_env_t] |
The default configuration for new proxies (can be changed per proxy)
|
E |
| endpoint_type [Hydro_connector.transporter] |
Every transporter is for a specific endpoint type
|
| error_count [Hydro_proxy.managed_client_t] |
Return the number of recorded errors
|
| event_system [Hydro_proxy.proxy_env_t] |
The event system
|
| event_system [Hydro_transport.hydro_multiplex_controller] |
Returns the event system
|
F |
| facets [Hydro_lm_IceObject.od_Ice_Object] |
|
| file_descr [Hydro_types.descriptor] |
|
G |
| get_identity [Hydro_oa.object_adapter_t] |
Looks the identity for the given object up, or raises
Not_found
|
| getpeername [Hydro_transport.hydro_multiplex_controller] |
The address of the peer's socket.
|
| getsockname [Hydro_transport.hydro_multiplex_controller] |
The address of this socket
|
H |
| host_port [Hydro_proxy.managed_client_t] |
Return the host and port of the server this managed client is
bound to.
|
| hydro_effective_id [Hydro_lm_IceLocalObject.oi_Ice_LocalObject] |
|
| hydro_effective_id [Hydro_lm_IceObject.oi_Ice_Object] |
|
| hydro_effective_id [Hydro_lm.interface_base] |
|
| hydro_effective_id [Hydro_lm.sliced_base] |
|
| hydro_env [Hydro_proxy.proxy_t] |
Return the proxy environment
|
| hydro_facet [Hydro_proxy.proxy_t] |
Return the facet, if used
|
| hydro_id [Hydro_proxy.proxy_t] |
Return the identity of the object the proxy represents
|
| hydro_inflate [Hydro_lm.object_base] |
|
| hydro_invoke_operation [Hydro_lm_IceLocalObject.oi_Ice_LocalObject] |
|
| hydro_invoke_operation [Hydro_lm_IceObject.oi_Ice_Object] |
|
| hydro_invoke_operation [Hydro_lm.interface_base] |
|
| hydro_invoke_operation [Hydro_lm.object_base] |
|
| hydro_proxy_conf [Hydro_proxy.proxy_t] |
Return the current proxy configuration
|
| hydro_proxy_reference [Hydro_lm_IceObject.po_Ice_Object] |
|
| hydro_reset [Hydro_proxy.proxy_t] |
Resets the internal proxy state
|
| hydro_response [Hydro_lm_IceObject.r_simple_response] |
|
| hydro_set_monitor [Hydro_proxy.proxy_t] |
hydro_set_monitor mon: The function mon is called whenever
a call is to be done.
|
| hydro_set_proxy_conf [Hydro_proxy.proxy_t] |
Sets a new proxy configuration.
|
| hydro_shutdown [Hydro_proxy.proxy_t] |
Marks the proxy as "down".
|
| hydro_slices [Hydro_lm.sliced_base] |
|
| hydro_twoway_call [Hydro_proxy.proxy_t] |
hydro_twoway_call hi name args params pass_result:
Perform a twoway call to the function name of interface hi,
and pass the arguments args as input.
|
I |
| ice_id [Hydro_lm_IceObject.oi_Ice_Object] |
|
| ice_id [Hydro_lm_IceObject.poi_Ice_Object] |
|
| ice_ids [Hydro_lm_IceObject.oi_Ice_Object] |
|
| ice_ids [Hydro_lm_IceObject.poi_Ice_Object] |
|
| ice_isA [Hydro_lm_IceObject.oi_Ice_Object] |
|
| ice_isA [Hydro_lm_IceObject.poi_Ice_Object] |
|
| ice_ping [Hydro_lm_IceObject.oi_Ice_Object] |
|
| ice_ping [Hydro_lm_IceObject.poi_Ice_Object] |
|
| inactivate [Hydro_transport.hydro_multiplex_controller] |
Inactivates the connection immediately, and releases any resources
the controller is responsible for (e.g.
|
| invoke_object [Hydro_oa.object_adapter_t] |
Looks the object for the given identity up, and returns the
corresponding facet dispatcher.
|
| is_available [Hydro_proxy.pool_t] |
This method is called by the pool implementation to check for
the availability of a service.
|
| is_master [Hydro_types.descriptor] |
|
M |
| max_reconnections [Hydro_proxy.proxy_conf_t] |
How often an endpoint can be reconnected after the first attempt,
before the endpoint is given up.
|
| mem_id [Hydro_oa.object_adapter_t] |
Tests whether the identity is added to the adapter
|
| mem_obj [Hydro_oa.object_adapter_t] |
Tests whether the object is added to the adapter
|
| multiplicity [Hydro_proxy.proxy_conf_t] |
How many connections to servers are held by every proxy.
|
P |
| params [Hydro_lm.call_suspension_t] |
Get the call parameters
|
| peer_user_name [Hydro_transport.hydro_multiplex_controller] |
If the transport mechanism provides a way to authenticate the
peer, it can return the name here.
|
| proto_type [Hydro_types.descriptor] |
|
| proxy_modes [Hydro_connector.transporter] |
Supported proxy modes
|
| proxy_resolver [Hydro_proxy.proxy_env_t] |
The resolver used to map names to addresses
|
R |
| read_eof [Hydro_transport.hydro_multiplex_controller] |
Whether the EOF marker has been read
|
| reading [Hydro_transport.hydro_multiplex_controller] |
True iff there is a reader
|
| record_error [Hydro_proxy.managed_client_t] |
Record an error situation.
|
| remove_id [Hydro_oa.object_adapter_t] |
Removes the identity from the adapter.
|
| remove_obj [Hydro_oa.object_adapter_t] |
Removes the object from the adapter.
|
| replica_group_id [Hydro_oa.object_adapter_t] |
|
| request_clients [Hydro_proxy.pool_t] |
Request clients from the pool
|
| reset [Hydro_proxy.pool_t] |
Shuts all clients down, and forget any deactivations
|
| resolution_period [Hydro_proxy.proxy_conf_t] |
How often endpoints are resolved.
|
| resolve [Hydro_proxy.proxy_resolver_t] |
resolve epa pass_result pe: Resolves the names in pa asynchronously,
and calls pass_result l with the lazy list l of connectors and
client parameters.
|
| result [Hydro_lm_IceObject.r_simple_response] |
|
S |
| scall [Hydro_lm.call_suspension_t] |
Do the RPC call synchronously.
|
| server_accept_engine [Hydro_connector.transporter] |
Accepts a new connection.
|
| server_create_engine [Hydro_connector.transporter] |
Creates a server socket.
|
| server_endpoint [Hydro_connector.transporter] |
Get the endpoint where the server is reachable
|
| server_multiplex_connection [Hydro_connector.transporter] |
Get the multiplexed connection for an existing server connection
|
| set_adapter_id [Hydro_oa.object_adapter_t] |
Get/set the adapter ID.
|
| set_esys [Hydro_proxy.pool_t] |
Tell the pool the event system.
|
| set_replica_group_id [Hydro_oa.object_adapter_t] |
Get/set the replica group ID.
|
| set_timeout [Hydro_transport.hydro_multiplex_controller] |
If there is no read or write activity for the passed number of
seconds, the notify callback is invoked.
|
| shared_connections [Hydro_proxy.proxy_conf_t] |
Whether connections to servers are shared with other proxies (true),
or are private to every proxy (false).
|
| shutdown [Hydro_proxy.pool_t] |
Shuts all pooled clients down.
|
| shutdown [Hydro_types.descriptor] |
|
| skip_message [Hydro_transport.hydro_multiplex_controller] |
Skips the current/next received message, i.e.
|
| start_reading [Hydro_transport.hydro_multiplex_controller] |
Start reading from the connection.
|
| start_shutting_down [Hydro_transport.hydro_multiplex_controller] |
Start shutting down the connection.
|
| start_writing [Hydro_transport.hydro_multiplex_controller] |
Starts writing the message.
|
| start_writing_eof [Hydro_transport.hydro_multiplex_controller] |
|
| system [Hydro_proxy.proxy_env_t] |
The ICE type system
|
T |
| transport_protocol_type [Hydro_transport.hydro_multiplex_controller] |
The transport protocol
|
| trigger_shutdown [Hydro_proxy.managed_client_t] |
Shut the client down.
|
| trigger_shutdown [Hydro_proxy.pool_t] |
Shuts all pooled clients down.
|
U |
| unused_since [Hydro_proxy.managed_client_t] |
If this object is currently unused (i.e.
|
W |
| with_params [Hydro_lm.call_suspension_t] |
Get a new call suspension with updated call parameters
|
| writing [Hydro_transport.hydro_multiplex_controller] |
True iff there is a writer
|
