Main Page   Class Hierarchy   Alphabetical List   Compound List   File List   Compound Members   File Members   Related Pages  

Connector.h

Go to the documentation of this file.
00001 // -*- C++ -*-
00002 
00003 //=============================================================================
00004 /**
00005  *  @file    Connector.h
00006  *
00007  *  $Id: Connector.h,v 1.1.1.4 2003/02/21 18:36:32 chad Exp $
00008  *
00009  *  @author Douglas C. Schmidt <schmidt@cs.wustl.edu>
00010  */
00011 //=============================================================================
00012 
00013 #ifndef ACE_CONNECTOR_H
00014 #define ACE_CONNECTOR_H
00015 
00016 #include "ace/pre.h"
00017 
00018 #include "ace/Service_Config.h"
00019 
00020 #if !defined (ACE_LACKS_PRAGMA_ONCE)
00021 # pragma once
00022 #endif /* ACE_LACKS_PRAGMA_ONCE */
00023 
00024 #include "ace/Service_Object.h"
00025 #include "ace/Map_Manager.h"
00026 #include "ace/Svc_Handler.h"
00027 #include "ace/Strategies_T.h"
00028 
00029 /**
00030  * @class ACE_Svc_Tuple
00031  *
00032  * @brief Holds the ACE_Svc_Handler and its argument and
00033  * <ACE_Timer_Handle> until an asynchronous connection completes.
00034  *
00035  * This is a no-brainer...
00036  */
00037 template <class SVC_HANDLER>
00038 class ACE_Svc_Tuple
00039 {
00040 public:
00041 
00042   // = Initialization methods.
00043   ACE_Svc_Tuple (SVC_HANDLER *,
00044                  ACE_HANDLE,
00045                  const void * = 0,
00046                  long timer_id = -1);
00047 
00048   /// Get SVC_HANDLER.
00049   SVC_HANDLER *svc_handler (void);
00050 
00051   // = Get/set handle.
00052   /// Get handle.
00053   ACE_HANDLE handle (void);
00054 
00055   /// Set handle.
00056   void handle (ACE_HANDLE);
00057 
00058   // = Get/set argument.
00059   /// Get argument.
00060   const void *arg (void);
00061 
00062   /// Set argument.
00063   void arg (const void *);
00064 
00065   // = Set/get timer cancellation handle.
00066   /// Get cancellation id.
00067   long cancellation_id (void);
00068 
00069   /// Set cancellation id.
00070   void cancellation_id (long timer_id);
00071 
00072   /// Increment and decrement refcount within the context of the lock
00073   /// on the ACE_Connector
00074   long incr_refcount (void);
00075 
00076   long decr_refcount (void);
00077 
00078   /// Dump the state of an object.
00079   void dump (void) const;
00080 
00081   /// Declare the dynamic allocation hooks.
00082   ACE_ALLOC_HOOK_DECLARE;
00083 
00084 protected:
00085   /// Prevent direct deletion
00086   ~ACE_Svc_Tuple (void);
00087 
00088 private:
00089   /// Associated SVC_HANDLER.
00090   SVC_HANDLER *svc_handler_;
00091 
00092   /// IPC <HANDLE> that we are trying to connect.
00093   ACE_HANDLE handle_;
00094 
00095   /// Associated argument.
00096   const void *arg_;
00097 
00098   /// Associated cancellation id.
00099   long cancellation_id_;
00100 
00101   /// Reference count manipulated within the context of the connector
00102   /// lock.
00103   /// @@ TODO: Things will change after 5.3 goes out of the way.
00104   long refcount_;
00105 };
00106 
00107 /**
00108  * @class ACE_Connector
00109  *
00110  * @brief Generic factory for actively connecting clients and creating
00111  * service handlers (SVC_HANDLERs).
00112  *
00113  * Implements the strategy for actively establishing connections
00114  * with clients.  An ACE_Connector is parameterized by concrete
00115  * types that conform to the interfaces of PEER_CONNECTOR and
00116  * SVC_HANDLER.  The PEER_CONNECTOR is instantiated with a
00117  * transport mechanism that passively establishes connections.
00118  * The SVC_HANDLER is instantiated with a concrete type that
00119  * performs the application-specific service.  An ACE_Connector
00120  * inherits from ACE_Service_Object, which in turn inherits from
00121  * ACE_Event_Handler.  This enables the ACE_Reactor to dispatch
00122  * the ACE_Connector's handle_output method when connections
00123  * complete asynchronously.  The handle_output method performs
00124  * the connector's active connection establishment and service
00125  * activation strategy.
00126  */
00127 template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1>
00128 class ACE_Connector : public ACE_Service_Object
00129 {
00130 public:
00131 
00132   // Useful STL-style traits.
00133   typedef ACE_TYPENAME SVC_HANDLER::addr_type    addr_type;
00134   typedef ACE_PEER_CONNECTOR                     connector_type;
00135   typedef SVC_HANDLER                            handler_type;
00136   typedef ACE_TYPENAME SVC_HANDLER::stream_type  stream_type;
00137 
00138 
00139   // typedef ACE_TYPENAME ACE_PEER_CONNECTOR_ADDR PEER_ADDR;
00140 #if defined (ACE_HAS_TYPENAME_KEYWORD)
00141   typedef ACE_PEER_CONNECTOR_ADDR ACE_PEER_ADDR_TYPEDEF;
00142 #endif /* ACE_HAS_TYPENAME_KEYWORD */
00143 
00144   typedef ACE_TYPENAME _ACE_PEER_CONNECTOR::PEER_ADDR
00145           ACE_TYPENAME_ACE_PEER_CONNECTOR_PEER_ADDR;
00146 
00147   /**
00148    * Initialize a connector.  @a flags indicates how <SVC_HANDLER>'s
00149    * should be initialized prior to being activated.  Right now, the
00150    * only flag that is processed is <ACE_NONBLOCK>, which enabled
00151    * non-blocking I/O on the <SVC_HANDLER> when it is opened.
00152    */
00153   ACE_Connector (ACE_Reactor *r = ACE_Reactor::instance (),
00154                  int flags = 0);
00155 
00156   /**
00157    * Initialize a connector.  @a flags indicates how <SVC_HANDLER>'s
00158    * should be initialized prior to being activated.  Right now, the
00159    * only flag that is processed is <ACE_NONBLOCK>, which enabled
00160    * non-blocking I/O on the <SVC_HANDLER> when it is opened.
00161    */
00162   virtual int open (ACE_Reactor *r = ACE_Reactor::instance (),
00163                     int flags = 0);
00164 
00165   /// Shutdown a connector and release resources.
00166   virtual ~ACE_Connector (void);
00167 
00168   // = Connection establishment methods.
00169 
00170   /**
00171    * Initiate connection of <svc_handler> to peer at <remote_addr>
00172    * using <synch_options>.  If the caller wants to designate the
00173    * selected <local_addr> they can (and can also insist that the
00174    * <local_addr> be reused by passing a value <reuse_addr> ==
00175    * 1). <flags> and <perms> can be used to pass any flags that are
00176    * needed to perform specific operations such as opening a file
00177    * within connect with certain permissions.  If the connection fails
00178    * the <close> hook on the <svc_handler> will be called
00179    * automatically to prevent resource leaks.
00180    */
00181   virtual int connect (SVC_HANDLER *&svc_handler,
00182                        const ACE_PEER_CONNECTOR_ADDR &remote_addr,
00183                        const ACE_Synch_Options &synch_options = ACE_Synch_Options::defaults,
00184                        const ACE_PEER_CONNECTOR_ADDR &local_addr
00185                          = (ACE_TYPENAME_ACE_PEER_CONNECTOR_PEER_ADDR &) ACE_PEER_CONNECTOR_ADDR_ANY,
00186                        int reuse_addr = 0,
00187                        int flags = O_RDWR,
00188                        int perms = 0);
00189 
00190   /**
00191    * This is a variation on the previous <connect> method.  On cached
00192    * connectors the <svc_handler_hint> variable can be used as a hint
00193    * for future lookups.  Since this variable is modified in the
00194    * context of the internal cache its use is thread-safe.  But the
00195    * actual svc_handler for the current connection is returned in the
00196    * second parameter <svc_handler>.  If the connection fails the
00197    * <close> hook on the <svc_handler> will be called automatically to
00198    * prevent resource leaks.
00199    */
00200   virtual int connect (SVC_HANDLER *&svc_handler_hint,
00201                        SVC_HANDLER *&svc_handler,
00202                        const ACE_PEER_CONNECTOR_ADDR &remote_addr,
00203                        const ACE_Synch_Options &synch_options = ACE_Synch_Options::defaults,
00204                        const ACE_PEER_CONNECTOR_ADDR &local_addr
00205                          = (ACE_TYPENAME_ACE_PEER_CONNECTOR_PEER_ADDR &) ACE_PEER_CONNECTOR_ADDR_ANY,
00206                        int reuse_addr = 0,
00207                        int flags = O_RDWR,
00208                        int perms = 0);
00209 
00210   /**
00211    * Initiate connection of <n> <svc_handlers> to peers at
00212    * <remote_addrs> using <synch_options>.  Returns -1 if failure
00213    * occurs and 0 otherwise.  If <failed_svc_handlers> is non-NULL, a
00214    * 1 is placed in the corresponding index of <failed_svc_handler>
00215    * for each <svc_handlers[i]> that failed to connect, else a 0 is
00216    * placed in that index.
00217    */
00218   virtual int connect_n (size_t n,
00219                          SVC_HANDLER *svc_handlers[],
00220                          ACE_PEER_CONNECTOR_ADDR remote_addrs[],
00221                          ACE_TCHAR *failed_svc_handlers = 0,
00222                          const ACE_Synch_Options &synch_options =
00223                          ACE_Synch_Options::defaults);
00224 
00225   /**
00226    * Cancel a <svc_handler> that was started asynchronously. Note that
00227    * this is the only case when the Connector does not actively close
00228    * the <svc_handler>. It is left up to the caller of <cancel> to
00229    * decide the fate of the <svc_handler>.
00230    */
00231   virtual int cancel (SVC_HANDLER *svc_handler);
00232 
00233   /// Close down the Connector
00234   virtual int close (void);
00235 
00236   /// Return the underlying PEER_CONNECTOR object.
00237   virtual ACE_PEER_CONNECTOR &connector (void) const;
00238 
00239   /// Dump the state of an object.
00240   void dump (void) const;
00241 
00242   /// Declare the dynamic allocation hooks.
00243   ACE_ALLOC_HOOK_DECLARE;
00244 
00245 protected:
00246   // = Helpful typedefs.
00247 
00248   typedef ACE_Svc_Tuple<SVC_HANDLER>
00249           AST;
00250 
00251   typedef ACE_Map_Manager<ACE_HANDLE, ACE_Svc_Tuple<SVC_HANDLER> *, ACE_SYNCH_RW_MUTEX>
00252           MAP_MANAGER;
00253   typedef ACE_Map_Iterator<ACE_HANDLE, ACE_Svc_Tuple<SVC_HANDLER> *, ACE_SYNCH_RW_MUTEX>
00254           MAP_ITERATOR;
00255   typedef ACE_Map_Entry<ACE_HANDLE, ACE_Svc_Tuple<SVC_HANDLER> *>
00256           MAP_ENTRY;
00257 
00258   // = The following two methods define the Connector's strategies for
00259   // creating, connecting, and activating SVC_HANDLER's, respectively.
00260 
00261   /**
00262    * Bridge method for creating a SVC_HANDLER.  The default is to
00263    * create a new SVC_HANDLER only if <sh> == 0, else <sh> is
00264    * unchanged.  However, subclasses can override this policy to
00265    * perform SVC_HANDLER creation in any way that they like (such as
00266    * creating subclass instances of SVC_HANDLER, using a singleton,
00267    * dynamically linking the handler, etc.).  Returns -1 if failure,
00268    * else 0.
00269    */
00270   virtual int make_svc_handler (SVC_HANDLER *&sh);
00271 
00272   /**
00273    * Bridge method for connecting the <svc_handler> to the
00274    * <remote_addr>.  The default behavior delegates to the
00275    * <PEER_CONNECTOR::connect>.
00276    */
00277   virtual int connect_svc_handler (SVC_HANDLER *&svc_handler,
00278                                    const ACE_PEER_CONNECTOR_ADDR &remote_addr,
00279                                    ACE_Time_Value *timeout,
00280                                    const ACE_PEER_CONNECTOR_ADDR &local_addr,
00281                                    int reuse_addr,
00282                                    int flags,
00283                                    int perms);
00284   virtual int connect_svc_handler (SVC_HANDLER *&svc_handler,
00285                                    SVC_HANDLER *&sh_copy,
00286                                    const ACE_PEER_CONNECTOR_ADDR &remote_addr,
00287                                    ACE_Time_Value *timeout,
00288                                    const ACE_PEER_CONNECTOR_ADDR &local_addr,
00289                                    int reuse_addr,
00290                                    int flags,
00291                                    int perms);
00292 
00293   /**
00294    * Bridge method for activating a <svc_handler> with the appropriate
00295    * concurrency strategy.  The default behavior of this method is to
00296    * activate the SVC_HANDLER by calling its <open> method (which
00297    * allows the SVC_HANDLER to define its own concurrency strategy).
00298    * However, subclasses can override this strategy to do more
00299    * sophisticated concurrency activations (such as creating the
00300    * SVC_HANDLER as an "active object" via multi-threading or
00301    * multi-processing).
00302    */
00303   virtual int activate_svc_handler (SVC_HANDLER *svc_handler);
00304 
00305   /// Called by ACE_Reactor when asynchronous connections fail.
00306   virtual int handle_input (ACE_HANDLE);
00307 
00308   /// Called by ACE_Reactor when asynchronous connections succeed.
00309   virtual int handle_output (ACE_HANDLE);
00310 
00311   virtual int resume_handler (void);
00312 
00313   /// Called by ACE_Reactor when asynchronous connections complete (on
00314   /// some platforms only).
00315   virtual int handle_exception (ACE_HANDLE fd = ACE_INVALID_HANDLE);
00316 
00317   // = Dynamic linking hooks.
00318   /// Default version does no work and returns -1.  Must be overloaded
00319   /// by application developer to do anything meaningful.
00320   virtual int init (int argc, ACE_TCHAR *argv[]);
00321 
00322   /// Calls <handle_close> to shutdown the Connector gracefully.
00323   virtual int fini (void);
00324 
00325   /// Default version returns address info in <buf>.
00326   virtual int info (ACE_TCHAR **, size_t) const;
00327 
00328   // = Demultiplexing hooks.
00329   /**
00330    * Terminate the Client ACE_Connector by iterating over any
00331    * unconnected ACE_Svc_Handler's and removing them from the
00332    * ACE_Reactor.
00333    */
00334   virtual int handle_close (ACE_HANDLE = ACE_INVALID_HANDLE,
00335                             ACE_Reactor_Mask = ACE_Event_Handler::ALL_EVENTS_MASK);
00336 
00337   /// This method is called if a connection times out before
00338   /// completing.
00339   virtual int handle_timeout (const ACE_Time_Value &tv,
00340                               const void *arg);
00341 
00342   // = Service management hooks.
00343   /// Default version does no work and returns -1.  Must be overloaded
00344   /// by application developer to do anything meaningful.
00345   virtual int suspend (void);
00346 
00347   /// Default version does no work and returns -1.  Must be overloaded
00348   /// by application developer to do anything meaningful.
00349   virtual int resume (void);
00350 
00351   /// Creates and inserts an ACE_Svc_Tuple into the <handler_map_>.
00352   /// so that we can continue accepting this connection asynchronously.
00353   int create_AST (SVC_HANDLER *,
00354                   const ACE_Synch_Options &);
00355 
00356   /// Cleanup the <handler_map_> and returns the appropriate
00357   /// ACE_Svc_Tuple (which is 0 if there is no associated tuple).
00358   int cleanup_AST (ACE_HANDLE handle, AST *&ast);
00359 
00360   /// Implementation the <connect> methods.
00361   virtual int connect_i (SVC_HANDLER *&svc_handler,
00362                          SVC_HANDLER **sh_copy,
00363                          const ACE_PEER_CONNECTOR_ADDR &remote_addr,
00364                          const ACE_Synch_Options &synch_options,
00365                          const ACE_PEER_CONNECTOR_ADDR &local_addr,
00366                          int reuse_addr,
00367                          int flags,
00368                          int perms);
00369 
00370 
00371   /// Helper method for manipulating the refcount on AST. It holds the
00372   /// lock before manipulating the refcount on AST.
00373   /// @@ TODO: Needs to be out after 5.3
00374   long incr_ast_refcount (AST *ast);
00375   long decr_ast_refcount (AST *ast);
00376 
00377   /// Lookup table that maps an I/O handle to a SVC_HANDLER *.
00378   MAP_MANAGER handler_map_;
00379 private:
00380   /// This is the concrete connector factory (it keeps no state so the
00381   /// <ACE_Connector> is reentrant).
00382   ACE_PEER_CONNECTOR connector_;
00383 
00384   /// Keeps track of whether we are in the process of closing (required
00385   /// to avoid circular calls to <handle_close>).
00386   char closing_;
00387 
00388   /**
00389    * Flags that indicate how <SVC_HANDLER>'s should be initialized
00390    * prior to being activated.  Right now, the only flag that is
00391    * processed is <ACE_NONBLOCK>, which enabled non-blocking I/O on
00392    * the <SVC_HANDLER> when it is opened.
00393    */
00394   int flags_;
00395 
00396   /// Lock to synchronize access to the internal state of the
00397   /// connector.
00398   /// @@TODO: This needs to go after 1.3
00399   ACE_SYNCH_MUTEX mutex_;
00400 };
00401 
00402 /**
00403  * @class ACE_Strategy_Connector
00404  *
00405  * @brief Abstract factory for creating a service handler
00406  * (SVC_HANDLER), connecting the SVC_HANDLER, and activating the
00407  * SVC_HANDLER.
00408  *
00409  * Implements a flexible and extensible set of strategies for
00410  * actively establishing connections with clients.  There are
00411  * three main strategies: (1) creating a SVC_HANDLER, (2)
00412  * actively initiating a new connection from the client,
00413  * and (3) activating the SVC_HANDLER with a
00414  * particular concurrency mechanism after the connection is established.
00415  */
00416 template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1>
00417 class ACE_Strategy_Connector
00418   : public ACE_Connector <SVC_HANDLER, ACE_PEER_CONNECTOR_2>
00419 {
00420 public:
00421 
00422   // Useful STL-style traits.
00423   typedef ACE_Creation_Strategy<SVC_HANDLER>
00424           creation_strategy_type;
00425   typedef ACE_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2>
00426           connect_strategy_type;
00427   typedef ACE_Concurrency_Strategy<SVC_HANDLER>
00428           concurrency_strategy_type;
00429   typedef ACE_Connector <SVC_HANDLER, ACE_PEER_CONNECTOR_2>
00430           base_type;
00431 
00432   // = Define some useful (old style) traits.
00433   typedef ACE_Creation_Strategy<SVC_HANDLER>
00434           CREATION_STRATEGY;
00435   typedef ACE_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2>
00436           CONNECT_STRATEGY;
00437   typedef ACE_Concurrency_Strategy<SVC_HANDLER>
00438           CONCURRENCY_STRATEGY;
00439   typedef ACE_Connector <SVC_HANDLER, ACE_PEER_CONNECTOR_2>
00440           SUPER;
00441 
00442   /**
00443    * Initialize a connector.  <flags> indicates how <SVC_HANDLER>'s
00444    * should be initialized prior to being activated.  Right now, the
00445    * only flag that is processed is <ACE_NONBLOCK>, which enabled
00446    * non-blocking I/O on the <SVC_HANDLER> when it is opened.
00447    */
00448   ACE_Strategy_Connector (ACE_Reactor *r = ACE_Reactor::instance (),
00449                           ACE_Creation_Strategy<SVC_HANDLER> * = 0,
00450                           ACE_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2> * = 0,
00451                           ACE_Concurrency_Strategy<SVC_HANDLER> * = 0,
00452                           int flags = 0);
00453 
00454   /**
00455    * Initialize a connector.  <flags> indicates how <SVC_HANDLER>'s
00456    * should be initialized prior to being activated.  Right now, the
00457    * only flag that is processed is <ACE_NONBLOCK>, which enabled
00458    * non-blocking I/O on the <SVC_HANDLER> when it is opened.
00459    * Default strategies would be created and used.
00460    */
00461   virtual int open (ACE_Reactor *r,
00462                     int flags);
00463 
00464   /**
00465    * Initialize a connector.  <flags> indicates how <SVC_HANDLER>'s
00466    * should be initialized prior to being activated.  Right now, the
00467    * only flag that is processed is <ACE_NONBLOCK>, which enabled
00468    * non-blocking I/O on the <SVC_HANDLER> when it is opened.
00469    */
00470   virtual int open (ACE_Reactor *r = ACE_Reactor::instance (),
00471                     ACE_Creation_Strategy<SVC_HANDLER> * = 0,
00472                     ACE_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2> * = 0,
00473                     ACE_Concurrency_Strategy<SVC_HANDLER> * = 0,
00474                     int flags = 0);
00475 
00476   /// Shutdown a connector and release resources.
00477   virtual ~ACE_Strategy_Connector (void);
00478 
00479   /// Close down the Connector
00480   virtual int close (void);
00481 
00482   // = Strategies accessors
00483   virtual ACE_Creation_Strategy<SVC_HANDLER> *creation_strategy (void) const;
00484   virtual ACE_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2> *connect_strategy (void) const;
00485   virtual ACE_Concurrency_Strategy<SVC_HANDLER> *concurrency_strategy (void) const;
00486 
00487 protected:
00488   // = The following three methods define the <Connector>'s strategies
00489   // for creating, connecting, and activating <SVC_HANDLER>'s,
00490   // respectively.
00491 
00492   /**
00493    * Bridge method for creating a <SVC_HANDLER>.  The strategy for
00494    * creating a <SVC_HANDLER> are configured into the Connector via
00495    * it's <creation_strategy_>.  The default is to create a new
00496    * <SVC_HANDLER> only if <sh> == 0, else <sh> is unchanged.
00497    * However, subclasses can override this policy to perform
00498    * <SVC_HANDLER> creation in any way that they like (such as
00499    * creating subclass instances of <SVC_HANDLER>, using a singleton,
00500    * dynamically linking the handler, etc.).  Returns -1 if failure,
00501    * else 0.
00502    */
00503   virtual int make_svc_handler (SVC_HANDLER *&sh);
00504 
00505   /**
00506    * Bridge method for connecting the new connection into the
00507    * <SVC_HANDLER>.  The default behavior delegates to the
00508    * <PEER_CONNECTOR::connect> in the <Connect_Strategy>.
00509    */
00510   virtual int connect_svc_handler (SVC_HANDLER *&sh,
00511                                    const ACE_PEER_CONNECTOR_ADDR &remote_addr,
00512                                    ACE_Time_Value *timeout,
00513                                    const ACE_PEER_CONNECTOR_ADDR &local_addr,
00514                                    int reuse_addr,
00515                                    int flags,
00516                                    int perms);
00517 
00518   /**
00519    * Bridge method for connecting the new connection into the
00520    * <SVC_HANDLER>.  The default behavior delegates to the
00521    * <PEER_CONNECTOR::connect> in the <Connect_Strategy>.
00522    * <sh_copy> is used to obtain a copy of the <sh> pointer, but that
00523    * can be kept in the stack; the motivation is a bit too long to
00524    * include here, but basically we want to modify <sh> safely, using
00525    * the internal locks in the Connect_Strategy, while saving a TSS
00526    * copy in <sh_copy>, usually located in the stack.
00527    */
00528   virtual int connect_svc_handler (SVC_HANDLER *&sh,
00529                                    SVC_HANDLER *&sh_copy,
00530                                    const ACE_PEER_CONNECTOR_ADDR &remote_addr,
00531                                    ACE_Time_Value *timeout,
00532                                    const ACE_PEER_CONNECTOR_ADDR &local_addr,
00533                                    int reuse_addr,
00534                                    int flags,
00535                                    int perms);
00536 
00537   /**
00538    * Bridge method for activating a <SVC_HANDLER> with the appropriate
00539    * concurrency strategy.  The default behavior of this method is to
00540    * activate the <SVC_HANDLER> by calling its <open> method (which
00541    * allows the <SVC_HANDLER> to define its own concurrency strategy).
00542    * However, subclasses can override this strategy to do more
00543    * sophisticated concurrency activations (such as creating the
00544    * <SVC_HANDLER> as an "active object" via multi-threading or
00545    * multi-processing).
00546    */
00547   virtual int activate_svc_handler (SVC_HANDLER *svc_handler);
00548 
00549   // = Strategy objects.
00550 
00551   /// Creation strategy for an <Connector>.
00552   CREATION_STRATEGY *creation_strategy_;
00553 
00554   /// 1 if <Connector> created the creation strategy and thus should
00555   /// delete it, else 0.
00556   int delete_creation_strategy_;
00557 
00558   /// Connect strategy for a <Connector>.
00559   CONNECT_STRATEGY *connect_strategy_;
00560 
00561   /// 1 if <Connector> created the connect strategy and thus should
00562   /// delete it, else 0.
00563   int delete_connect_strategy_;
00564 
00565   /// Concurrency strategy for an <Connector>.
00566   CONCURRENCY_STRATEGY *concurrency_strategy_;
00567 
00568   /// 1 if <Connector> created the concurrency strategy and thus should
00569   /// delete it, else 0.
00570   int delete_concurrency_strategy_;
00571 };
00572 
00573 #if defined (ACE_TEMPLATES_REQUIRE_SOURCE)
00574 #include "ace/Connector.cpp"
00575 #endif /* ACE_TEMPLATES_REQUIRE_SOURCE */
00576 
00577 #if defined (ACE_TEMPLATES_REQUIRE_PRAGMA)
00578 #pragma implementation ("Connector.cpp")
00579 #endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */
00580 
00581 #include "ace/post.h"
00582 
00583 #endif /* ACE_CONNECTOR_H */

Generated on Mon Jun 16 11:19:25 2003 for ACE by doxygen1.2.14 written by Dimitri van Heesch, © 1997-2002