Public Types | Public Member Functions | Public Attributes | Protected Member Functions | Protected Attributes

ACE_Strategy_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_1 > Class Template Reference

Abstract factory for creating a service handler (SVC_HANDLER), accepting into the SVC_HANDLER, and activating the SVC_HANDLER. More...

#include <Acceptor.h>

Inheritance diagram for ACE_Strategy_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >:
Inheritance graph
[legend]
Collaboration diagram for ACE_Strategy_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >:
Collaboration graph
[legend]

List of all members.

Public Types

typedef ACE_Creation_Strategy
< SVC_HANDLER > 		creation_strategy_type
typedef ACE_Accept_Strategy
< SVC_HANDLER,
ACE_PEER_ACCEPTOR_2 > 		accept_strategy_type
typedef
ACE_Concurrency_Strategy
< SVC_HANDLER > 		concurrency_strategy_type
typedef
ACE_Scheduling_Strategy
< SVC_HANDLER > 		scheduling_strategy_type
typedef ACE_Acceptor
< SVC_HANDLER,
ACE_PEER_ACCEPTOR_2 > 		base_type
typedef ACE_Creation_Strategy
< SVC_HANDLER > 		CREATION_STRATEGY
typedef ACE_Accept_Strategy
< SVC_HANDLER,
ACE_PEER_ACCEPTOR_2 > 		ACCEPT_STRATEGY
typedef
ACE_Concurrency_Strategy
< SVC_HANDLER > 		CONCURRENCY_STRATEGY
typedef
ACE_Scheduling_Strategy
< SVC_HANDLER > 		SCHEDULING_STRATEGY

Public Member Functions

 ACE_Strategy_Acceptor (const ACE_TCHAR service_name[]=0, const ACE_TCHAR service_description[]=0, int use_select=1, int reuse_addr=1)
 Default constructor.
 ACE_Strategy_Acceptor (const ACE_PEER_ACCEPTOR_ADDR &local_addr, ACE_Reactor *=ACE_Reactor::instance(), ACE_Creation_Strategy< SVC_HANDLER > *=0, ACE_Accept_Strategy< SVC_HANDLER, ACE_PEER_ACCEPTOR_2 > *=0, ACE_Concurrency_Strategy< SVC_HANDLER > *=0, ACE_Scheduling_Strategy< SVC_HANDLER > *=0, const ACE_TCHAR service_name[]=0, const ACE_TCHAR service_description[]=0, int use_select=1, int reuse_addr=1)
virtual int open (const ACE_PEER_ACCEPTOR_ADDR &local_addr, ACE_Reactor *reactor, int flags=0, int use_select=1, int reuse_addr=1)
virtual int open (const ACE_PEER_ACCEPTOR_ADDR &, ACE_Reactor *=ACE_Reactor::instance(), ACE_Creation_Strategy< SVC_HANDLER > *=0, ACE_Accept_Strategy< SVC_HANDLER, ACE_PEER_ACCEPTOR_2 > *=0, ACE_Concurrency_Strategy< SVC_HANDLER > *=0, ACE_Scheduling_Strategy< SVC_HANDLER > *=0, const ACE_TCHAR *service_name=0, const ACE_TCHAR *service_description=0, int use_select=1, int reuse_addr=1)
virtual ~ACE_Strategy_Acceptor (void)
 Close down the Strategy_Acceptor's resources.
virtual operator ACE_PEER_ACCEPTOR & () const
 Return the underlying PEER_ACCEPTOR object.
virtual ACE_PEER_ACCEPTOR & acceptor (void) const
 Return the underlying PEER_ACCEPTOR object.
virtual ACE_HANDLE get_handle (void) const
 Returns the listening acceptor's {ACE_HANDLE}.
void dump (void) const
 Dump the state of an object.
virtual int suspend (void)
virtual int resume (void)

Public Attributes

 ACE_ALLOC_HOOK_DECLARE
 Declare the dynamic allocation hooks.

Protected Member Functions

virtual int fini (void)
 Calls {handle_close} when dynamically unlinked.
virtual int info (ACE_TCHAR **buf, size_t) const
 Default version returns address info in {buf}.
virtual int make_svc_handler (SVC_HANDLER *&)
virtual int accept_svc_handler (SVC_HANDLER *svc_handler)
virtual int activate_svc_handler (SVC_HANDLER *svc_handler)
virtual int handle_close (ACE_HANDLE=ACE_INVALID_HANDLE, ACE_Reactor_Mask=ACE_Event_Handler::ALL_EVENTS_MASK)
virtual int handle_signal (int signum, siginfo_t *, ucontext_t *)
 Handle SIGINT.

Protected Attributes

CREATION_STRATEGY * creation_strategy_
 Creation strategy for an Acceptor.
bool delete_creation_strategy_
ACCEPT_STRATEGY * accept_strategy_
 Accept strategy for an {Acceptor}.
bool delete_accept_strategy_
CONCURRENCY_STRATEGY * concurrency_strategy_
 Concurrency strategy for an {Acceptor}.
bool delete_concurrency_strategy_
SCHEDULING_STRATEGY * scheduling_strategy_
 Scheduling strategy for an {Acceptor}.
bool delete_scheduling_strategy_
ACE_TCHAR * service_name_
 Name of the service.
ACE_TCHAR * service_description_
 Description of the service.
ACE_PEER_ACCEPTOR_ADDR service_addr_

Detailed Description

template<class SVC_HANDLER, ACE_PEER_ACCEPTOR_1>
class ACE_Strategy_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >

Abstract factory for creating a service handler (SVC_HANDLER), accepting into the SVC_HANDLER, and activating the SVC_HANDLER.

Implements a flexible and extensible set of strategies for passively establishing connections with clients. There are three main strategies: (1) creating a SVC_HANDLER, (2) passively accepting a new connection from a client into the SVC_HANDLER, and (3) activating the SVC_HANDLER with a particular concurrency mechanism.

Definition at line 274 of file Acceptor.h.

Member Typedef Documentation

template<class SVC_HANDLER , ACE_PEER_ACCEPTOR_1 >
typedef ACE_Accept_Strategy<SVC_HANDLER, ACE_PEER_ACCEPTOR_2> ACE_Strategy_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >::ACCEPT_STRATEGY

Definition at line 292 of file Acceptor.h.

template<class SVC_HANDLER , ACE_PEER_ACCEPTOR_1 >
typedef ACE_Accept_Strategy<SVC_HANDLER, ACE_PEER_ACCEPTOR_2> ACE_Strategy_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >::accept_strategy_type

Definition at line 283 of file Acceptor.h.

template<class SVC_HANDLER , ACE_PEER_ACCEPTOR_1 >
typedef ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2> ACE_Strategy_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >::base_type

Definition at line 288 of file Acceptor.h.

template<class SVC_HANDLER , ACE_PEER_ACCEPTOR_1 >
typedef ACE_Concurrency_Strategy<SVC_HANDLER> ACE_Strategy_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >::CONCURRENCY_STRATEGY

Definition at line 293 of file Acceptor.h.

template<class SVC_HANDLER , ACE_PEER_ACCEPTOR_1 >
typedef ACE_Concurrency_Strategy<SVC_HANDLER> ACE_Strategy_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >::concurrency_strategy_type

Definition at line 285 of file Acceptor.h.

template<class SVC_HANDLER , ACE_PEER_ACCEPTOR_1 >
typedef ACE_Creation_Strategy<SVC_HANDLER> ACE_Strategy_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >::CREATION_STRATEGY

Definition at line 291 of file Acceptor.h.

template<class SVC_HANDLER , ACE_PEER_ACCEPTOR_1 >
typedef ACE_Creation_Strategy<SVC_HANDLER> ACE_Strategy_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >::creation_strategy_type

Definition at line 281 of file Acceptor.h.

template<class SVC_HANDLER , ACE_PEER_ACCEPTOR_1 >
typedef ACE_Scheduling_Strategy<SVC_HANDLER> ACE_Strategy_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >::SCHEDULING_STRATEGY

Definition at line 294 of file Acceptor.h.

template<class SVC_HANDLER , ACE_PEER_ACCEPTOR_1 >
typedef ACE_Scheduling_Strategy<SVC_HANDLER> ACE_Strategy_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >::scheduling_strategy_type

Definition at line 286 of file Acceptor.h.

Constructor & Destructor Documentation

template<class SVC_HANDLER , ACE_PEER_ACCEPTOR_1 >
ACE_Strategy_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >::ACE_Strategy_Acceptor ( const ACE_TCHAR  service_name[] = 0,
const ACE_TCHAR  service_description[] = 0,
int  use_select = 1,
int  reuse_addr = 1 
)

Default constructor.

Definition at line 643 of file Acceptor.cpp.

    : creation_strategy_ (0),
      delete_creation_strategy_ (false),
      accept_strategy_ (0),
      delete_accept_strategy_ (false),
      concurrency_strategy_ (0),
      delete_concurrency_strategy_ (false),
      scheduling_strategy_ (0),
      delete_scheduling_strategy_ (false),
      service_name_ (0),
      service_description_ (0)
{
  ACE_TRACE ("ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::ACE_Strategy_Acceptor");

  if (service_name != 0)
    ACE_ALLOCATOR (this->service_name_,
                   ACE_OS::strdup (service_name));
  if (service_description != 0)
    ACE_ALLOCATOR (this->service_description_,
                   ACE_OS::strdup (service_description));
  this->use_select_ = use_select;
  this->reuse_addr_ = reuse_addr;
}

template<class SVC_HANDLER , ACE_PEER_ACCEPTOR_1 >
ACE_Strategy_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >::ACE_Strategy_Acceptor ( const ACE_PEER_ACCEPTOR_ADDR &  local_addr,
ACE_Reactor *  reactor = ACE_Reactor::instance (),
ACE_Creation_Strategy< SVC_HANDLER > *  cre_s = 0,
ACE_Accept_Strategy< SVC_HANDLER, ACE_PEER_ACCEPTOR_2 > *  acc_s = 0,
ACE_Concurrency_Strategy< SVC_HANDLER > *  con_s = 0,
ACE_Scheduling_Strategy< SVC_HANDLER > *  sch_s = 0,
const ACE_TCHAR  service_name[] = 0,
const ACE_TCHAR  service_description[] = 0,
int  use_select = 1,
int  reuse_addr = 1 
)

Initialize the appropriate strategies for creation, passive connection acceptance, and concurrency, and then register {this} with the Reactor and listen for connection requests at the designated {local_addr}.

Definition at line 672 of file Acceptor.cpp.

    : creation_strategy_ (0),
      delete_creation_strategy_ (false),
      accept_strategy_ (0),
      delete_accept_strategy_ (false),
      concurrency_strategy_ (0),
      delete_concurrency_strategy_ (false),
      scheduling_strategy_ (0),
      delete_scheduling_strategy_ (false),
      service_name_ (0),
      service_description_ (0)
{
  ACE_TRACE ("ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::ACE_Strategy_Acceptor");

  if (this->open (addr,
                  reactor,
                  cre_s,
                  acc_s,
                  con_s,
                  sch_s,
                  service_name,
                  service_description,
                  use_select,
                  reuse_addr) == -1)
    ACE_ERROR ((LM_ERROR,
                ACE_TEXT ("%p\n"),
                ACE_TEXT ("ACE_Strategy_Acceptor::ACE_Strategy_Acceptor")));
}

template<class SVC_HANDLER , ACE_PEER_ACCEPTOR_1 >
ACE_Strategy_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >::~ACE_Strategy_Acceptor ( void   )  [virtual]

Close down the Strategy_Acceptor's resources.

Definition at line 803 of file Acceptor.cpp.

{
  ACE_TRACE ("ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::~ACE_Strategy_Acceptor");
  ACE_OS::free ((void *) this->service_name_);
  ACE_OS::free ((void *) this->service_description_);
  this->handle_close ();
}

Member Function Documentation

template<class SVC_HANDLER , ACE_PEER_ACCEPTOR_1 >
int ACE_Strategy_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >::accept_svc_handler ( SVC_HANDLER *  svc_handler  )  [protected, virtual]

Bridge method for accepting the new connection into the {SVC_HANDLER}. The default behavior delegates to the {PEER_ACCEPTOR::accept} in the {Acceptor_Strategy}.

Reimplemented from ACE_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_2 >.

Definition at line 778 of file Acceptor.cpp.

{
  ACE_TRACE ("ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::accept_svc_handler");
  return this->accept_strategy_->accept_svc_handler (svc_handler);
}

template<class SVC_HANDLER , ACE_PEER_ACCEPTOR_1 >
ACE_PEER_ACCEPTOR & ACE_Strategy_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >::acceptor ( void   )  const [virtual]

Return the underlying PEER_ACCEPTOR object.

Reimplemented from ACE_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_2 >.

Definition at line 504 of file Acceptor.cpp.

{
  ACE_TRACE ("ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::acceptor");
  return this->accept_strategy_->acceptor ();
}

template<class SVC_HANDLER , ACE_PEER_ACCEPTOR_1 >
int ACE_Strategy_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >::activate_svc_handler ( SVC_HANDLER *  svc_handler  )  [protected, virtual]

Bridge method for activating a {SVC_HANDLER} with the appropriate concurrency strategy. The default behavior of this method is to activate the {SVC_HANDLER} by calling its {open} method (which allows the {SVC_HANDLER} to define its own concurrency strategy). However, subclasses can override this strategy to do more sophisticated concurrency activations (such as creating the {SVC_HANDLER} as an "active object" via multi-threading or multi-processing).

Reimplemented from ACE_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_2 >.

Definition at line 794 of file Acceptor.cpp.

{
  ACE_TRACE ("ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::activate_svc_handler");
  return this->concurrency_strategy_->activate_svc_handler
    (svc_handler,
     (void *) this);
}

template<class SVC_HANDLER , ACE_PEER_ACCEPTOR_1 >
void ACE_Strategy_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >::dump ( void   )  const

Dump the state of an object.

Reimplemented from ACE_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_2 >.

Definition at line 479 of file Acceptor.cpp.

{
#if defined (ACE_HAS_DUMP)
  ACE_TRACE ("ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::dump");

  ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
  ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::dump ();
  this->creation_strategy_->dump ();
  ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("delete_creation_strategy_ = %d"), delete_creation_strategy_));
  this->accept_strategy_->dump ();
  ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("delete_accept_strategy_ = %d"), delete_accept_strategy_));
  this->concurrency_strategy_->dump ();
  ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("delete_concurrency_strategy_ = %d"), delete_concurrency_strategy_));
  this->scheduling_strategy_->dump ();
  ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("delete_scheduling_strategy_ = %d"), delete_scheduling_strategy_));
  ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\nservice_name_ = %s"),
              this->service_name_ == 0 ? ACE_TEXT ("<unknown>") : this->service_name_));
  ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\nservice_description_ = %s"),
              this->service_description_ == 0 ? ACE_TEXT ("<unknown>") : this->service_description_));
  this->service_addr_.dump ();
  ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
#endif /* ACE_HAS_DUMP */
}

template<class SVC_HANDLER , ACE_PEER_ACCEPTOR_1 >
int ACE_Strategy_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >::fini ( void   )  [protected, virtual]

Calls {handle_close} when dynamically unlinked.

Reimplemented from ACE_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_2 >.

Definition at line 855 of file Acceptor.cpp.

{
  ACE_TRACE ("ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::fini");
  return this->ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::handle_close ();
}

template<class SVC_HANDLER , ACE_PEER_ACCEPTOR_1 >
ACE_HANDLE ACE_Strategy_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >::get_handle ( void   )  const [virtual]

Returns the listening acceptor's {ACE_HANDLE}.

Reimplemented from ACE_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_2 >.

Definition at line 520 of file Acceptor.cpp.

{
  ACE_TRACE ("ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::get_handle");
  return this->accept_strategy_->get_handle ();
}

template<class SVC_HANDLER , ACE_PEER_ACCEPTOR_1 >
int ACE_Strategy_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >::handle_close ( ACE_HANDLE  = ACE_INVALID_HANDLE,
ACE_Reactor_Mask  = ACE_Event_Handler::ALL_EVENTS_MASK 
) [protected, virtual]

Perform termination activities when {this} is removed from the {Reactor}.

Reimplemented from ACE_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_2 >.

Definition at line 714 of file Acceptor.cpp.

{
  ACE_TRACE ("ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::handle_close");
  // Guard against multiple closes.
  if (this->reactor () != 0)
    {
      ACE_HANDLE handle = this->get_handle ();

      if (this->delete_creation_strategy_)
        delete this->creation_strategy_;
      this->delete_creation_strategy_ = false;
      this->creation_strategy_ = 0;

      if (this->delete_accept_strategy_)
        delete this->accept_strategy_;
      this->delete_accept_strategy_ = false;
      this->accept_strategy_ = 0;

      if (this->delete_concurrency_strategy_)
        delete this->concurrency_strategy_;
      this->delete_concurrency_strategy_ = false;
      this->concurrency_strategy_ = 0;

      if (this->delete_scheduling_strategy_)
        delete this->scheduling_strategy_;
      this->delete_scheduling_strategy_ = false;
      this->scheduling_strategy_ = 0;

      // We must use the <handle> obtained *before* we deleted the
      // accept_strategy_...

      this->reactor ()->remove_handler
        (handle,
         ACE_Event_Handler::ACCEPT_MASK | ACE_Event_Handler::DONT_CALL);

      // Set the Reactor to 0 so that we don't try to close down
      // again.
      this->reactor (0);
    }
  return 0;
}

template<class SVC_HANDLER , ACE_PEER_ACCEPTOR_1 >
int ACE_Strategy_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >::handle_signal ( int  signum,
siginfo_t *  ,
ucontext_t *   
) [protected, virtual]

Handle SIGINT.

Definition at line 814 of file Acceptor.cpp.

{
  ACE_Reactor::instance()->end_reactor_event_loop ();
  return 0;
}

template<class SVC_HANDLER , ACE_PEER_ACCEPTOR_1 >
int ACE_Strategy_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >::info ( ACE_TCHAR **  buf,
size_t  length 
) const [protected, virtual]

Default version returns address info in {buf}.

Reimplemented from ACE_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_2 >.

Definition at line 821 of file Acceptor.cpp.

{
  ACE_TRACE ("ACE_Strategy_Acceptor::info");

  ACE_TCHAR buf[BUFSIZ];
  ACE_TCHAR service_addr_str[BUFSIZ];
  ACE_PEER_ACCEPTOR_ADDR addr;

  if (this->acceptor ().get_local_addr (addr) == -1)
    return -1;
  else if (addr.addr_to_string (service_addr_str,
                                sizeof service_addr_str) == -1)
    return -1;

  // @@ Should add the protocol in...
  ACE_OS::sprintf (buf,
                   ACE_TEXT ("%s\t %s #%s\n"),
                   this->service_name_ == 0
                   ? ACE_TEXT ("<unknown>")
                   : this->service_name_,
                   service_addr_str,
                   this->service_description_ == 0
                   ? ACE_TEXT ("<unknown>")
                   : this->service_description_);

  if (*strp == 0 && (*strp = ACE_OS::strdup (buf)) == 0)
    return -1;
  else
    ACE_OS::strsncpy (*strp, buf, length);
  return static_cast<int> (ACE_OS::strlen (buf));
}

template<class SVC_HANDLER , ACE_PEER_ACCEPTOR_1 >
int ACE_Strategy_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >::make_svc_handler ( SVC_HANDLER *&  sh  )  [protected, virtual]

Bridge method for creating a {SVC_HANDLER}. The strategy for creating a {SVC_HANDLER} are configured into the Acceptor via it's {creation_strategy_}. The default is to create a new {SVC_HANDLER} if {sh} == 0, else {sh} is unchanged. However, subclasses can override this policy to perform {SVC_HANDLER} creation in any way that they like (such as creating subclass instances of {SVC_HANDLER}, using a singleton, dynamically linking the handler, etc.). Returns -1 on failure, else 0.

Reimplemented from ACE_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_2 >.

Definition at line 766 of file Acceptor.cpp.

{
  ACE_TRACE ("ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::make_svc_handler");
  return this->creation_strategy_->make_svc_handler (sh);
}

template<class SVC_HANDLER , ACE_PEER_ACCEPTOR_1 >
int ACE_Strategy_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >::open ( const ACE_PEER_ACCEPTOR_ADDR &  local_addr,
ACE_Reactor *  reactor = ACE_Reactor::instance (),
ACE_Creation_Strategy< SVC_HANDLER > *  cre_s = 0,
ACE_Accept_Strategy< SVC_HANDLER, ACE_PEER_ACCEPTOR_2 > *  acc_s = 0,
ACE_Concurrency_Strategy< SVC_HANDLER > *  con_s = 0,
ACE_Scheduling_Strategy< SVC_HANDLER > *  sch_s = 0,
const ACE_TCHAR *  service_name = 0,
const ACE_TCHAR *  service_description = 0,
int  use_select = 1,
int  reuse_addr = 1 
) [virtual]

Initialize the appropriate strategies for creation, passive connection acceptance, and concurrency, and then register {this} with the Reactor and listen for connection requests at the designated {local_addr}.

Definition at line 546 of file Acceptor.cpp.

{
  ACE_TRACE ("ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::open");

  if (this->service_name_ == 0 && service_name != 0)
    ACE_ALLOCATOR_RETURN (this->service_name_,
                          ACE_OS::strdup (service_name),
                          -1);
  if (this->service_description_ == 0 && service_description != 0)
    ACE_ALLOCATOR_RETURN (this->service_description_,
                          ACE_OS::strdup (service_description),
                          -1);
  this->reactor (reactor);

  // Must supply a valid Reactor to Acceptor::open()...
  if (reactor == 0)
    {
      errno = EINVAL;
      return -1;
    }

  // Initialize the creation strategy.

  if (cre_s == 0)
    {
      ACE_NEW_RETURN (cre_s,
                      CREATION_STRATEGY,
                      -1);
      this->delete_creation_strategy_ = true;
    }
  this->creation_strategy_ = cre_s;

  // Initialize the accept strategy.

  if (acc_s == 0)
    {
      ACE_NEW_RETURN (acc_s,
                      ACCEPT_STRATEGY (this->reactor ()),
                      -1);
      this->delete_accept_strategy_ = true;
    }
  this->accept_strategy_ = acc_s;

  if (this->accept_strategy_->open (local_addr, reuse_addr) == -1)
    return -1;

  // Set the peer acceptor's handle into non-blocking mode.  This is a
  // safe-guard against the race condition that can otherwise occur
  // between the time when <select> indicates that a passive-mode
  // socket handle is "ready" and when we call <accept>.  During this
  // interval, the client can shutdown the connection, in which case,
  // the <accept> call can hang!
  if (this->accept_strategy_->acceptor ().enable (ACE_NONBLOCK) != 0)
    return -1;

  // Initialize the concurrency strategy.

  if (con_s == 0)
    {
      ACE_NEW_RETURN (con_s,
                      CONCURRENCY_STRATEGY,
                      -1);
      this->delete_concurrency_strategy_ = true;
    }
  this->concurrency_strategy_ = con_s;

  // Initialize the scheduling strategy.

  if (sch_s == 0)
    {
      ACE_NEW_RETURN (sch_s,
                      SCHEDULING_STRATEGY,
                      -1);
      this->delete_scheduling_strategy_ = true;
    }
  this->scheduling_strategy_ = sch_s;

  this->use_select_ = use_select;

  return this->reactor ()->register_handler
    (this,
     ACE_Event_Handler::ACCEPT_MASK);
}

template<class SVC_HANDLER , ACE_PEER_ACCEPTOR_1 >
int ACE_Strategy_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >::open ( const ACE_PEER_ACCEPTOR_ADDR &  local_addr,
ACE_Reactor *  reactor,
int  flags = 0,
int  use_select = 1,
int  reuse_addr = 1 
) [virtual]

Open the contained PEER_ACCEPTOR object to begin listening, and register with the specified reactor for accept events.

The PEER_ACCEPTOR handle is put into non-blocking mode as a safeguard against the race condition that can otherwise occur between the time when the passive-mode socket handle is "ready" and when the actual accept call is made. During this interval, the client can shutdown the connection, in which case, the {accept} call can hang.

Parameters:
local_addr The address to listen at.
reactor Pointer to the ACE_Reactor instance to register this object with. The default is the singleton.
flags Flags to control what mode an accepted socket will be put into after it is accepted. The only legal value for this argument is ACE_NONBLOCK, which enables non-blocking mode on the accepted peer stream object in SVC_HANDLER. The default is 0.
use_select Affects behavior when called back by the reactor when a connection can be accepted. If non-zero, this object will accept all pending connections, instead of just the one that triggered the reactor callback. Uses ACE_OS::select() internally to detect any remaining acceptable connections. The default is 1.
reuse_addr Passed to the PEER_ACCEPTOR::open() method with local_addr. Generally used to request that the OS allow reuse of the listen port. The default is 1.
Return values:
0 Success
-1 Failure, errno contains an error code.

Reimplemented from ACE_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_2 >.

Definition at line 532 of file Acceptor.cpp.

{
  ACE_TRACE ("ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::open");
  return this->open
    (local_addr, reactor, 0, 0, 0, 0, 0, 0, use_select, reuse_addr);
}

template<class SVC_HANDLER , ACE_PEER_ACCEPTOR_1 >
ACE_Strategy_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >::operator ACE_PEER_ACCEPTOR & (  )  const [virtual]

Return the underlying PEER_ACCEPTOR object.

Reimplemented from ACE_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_2 >.

Definition at line 511 of file Acceptor.cpp.

{
  ACE_TRACE ("ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::operator ACE_PEER_ACCEPTOR &");
  return this->accept_strategy_->acceptor ();
}

template<class SVC_HANDLER , ACE_PEER_ACCEPTOR_1 >
int ACE_Strategy_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >::resume ( void   )  [virtual]

This method delegates to the {Scheduling_Strategy}'s {resume} method.

Reimplemented from ACE_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_2 >.

Definition at line 467 of file Acceptor.cpp.

{
  ACE_TRACE ("ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::resume");

  // First resume ourselves.
  if (ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::resume () == -1)
    return -1;
  else // Then resume the SVC_HANDLER's we've created.
    return this->scheduling_strategy_->resume ();
}

template<class SVC_HANDLER , ACE_PEER_ACCEPTOR_1 >
int ACE_Strategy_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >::suspend ( void   )  [virtual]

This method delegates to the {Scheduling_Strategy}'s {suspend} method.

Reimplemented from ACE_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_2 >.

Definition at line 455 of file Acceptor.cpp.

{
  ACE_TRACE ("ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::suspend");

  // First suspend the SVC_HANDLER's we've created.
  if (this->scheduling_strategy_->suspend () == -1)
    return -1;
  else   // Then suspend ourselves.
    return ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::suspend ();
}

Member Data Documentation

template<class SVC_HANDLER , ACE_PEER_ACCEPTOR_1 >
ACCEPT_STRATEGY* ACE_Strategy_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >::accept_strategy_ [protected]

Accept strategy for an {Acceptor}.

Definition at line 469 of file Acceptor.h.

template<class SVC_HANDLER , ACE_PEER_ACCEPTOR_1 >
ACE_Strategy_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >::ACE_ALLOC_HOOK_DECLARE

Declare the dynamic allocation hooks.

Reimplemented from ACE_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_2 >.

Definition at line 392 of file Acceptor.h.

template<class SVC_HANDLER , ACE_PEER_ACCEPTOR_1 >
CONCURRENCY_STRATEGY* ACE_Strategy_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >::concurrency_strategy_ [protected]

Concurrency strategy for an {Acceptor}.

Definition at line 476 of file Acceptor.h.

template<class SVC_HANDLER , ACE_PEER_ACCEPTOR_1 >
CREATION_STRATEGY* ACE_Strategy_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >::creation_strategy_ [protected]

Creation strategy for an Acceptor.

Definition at line 462 of file Acceptor.h.

template<class SVC_HANDLER , ACE_PEER_ACCEPTOR_1 >
bool ACE_Strategy_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >::delete_accept_strategy_ [protected]

true if {Acceptor} created the accept strategy and thus should delete it, else false.

Definition at line 473 of file Acceptor.h.

template<class SVC_HANDLER , ACE_PEER_ACCEPTOR_1 >
bool ACE_Strategy_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >::delete_concurrency_strategy_ [protected]

true if {Acceptor} created the concurrency strategy and thus should delete it, else false.

Definition at line 480 of file Acceptor.h.

template<class SVC_HANDLER , ACE_PEER_ACCEPTOR_1 >
bool ACE_Strategy_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >::delete_creation_strategy_ [protected]

true if {Acceptor} created the creation strategy and thus should delete it, else false.

Definition at line 466 of file Acceptor.h.

template<class SVC_HANDLER , ACE_PEER_ACCEPTOR_1 >
bool ACE_Strategy_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >::delete_scheduling_strategy_ [protected]

true if {Acceptor} created the scheduling strategy and thus should delete it, else false.

Definition at line 487 of file Acceptor.h.

template<class SVC_HANDLER , ACE_PEER_ACCEPTOR_1 >
SCHEDULING_STRATEGY* ACE_Strategy_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >::scheduling_strategy_ [protected]

Scheduling strategy for an {Acceptor}.

Definition at line 483 of file Acceptor.h.

template<class SVC_HANDLER , ACE_PEER_ACCEPTOR_1 >
ACE_PEER_ACCEPTOR_ADDR ACE_Strategy_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >::service_addr_ [protected]

Address that the {Strategy_Acceptor} uses to listen for connections.

Definition at line 499 of file Acceptor.h.

template<class SVC_HANDLER , ACE_PEER_ACCEPTOR_1 >
ACE_TCHAR* ACE_Strategy_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >::service_description_ [protected]

Description of the service.

Definition at line 495 of file Acceptor.h.

template<class SVC_HANDLER , ACE_PEER_ACCEPTOR_1 >
ACE_TCHAR* ACE_Strategy_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >::service_name_ [protected]

Name of the service.

Definition at line 492 of file Acceptor.h.

The documentation for this class was generated from the following files:
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines
Generated on Thu Dec 9 2010 11:57:56 for ACE by  doxygen 1.7.0