## NAME

ACE_Oneshot_Acceptor - Generic factory for passively connecting clients and creating exactly one service handler (SVC_HANDLER).

## SYNOPSIS

    #include <ace/Acceptor.h>

    template<class SVC_HANDLER, ACE_PEER_ACCEPTOR_1>
    class ACE_Oneshot_Acceptor : public ACE_Service_Object
    {
      public:
        ACE_Oneshot_Acceptor (void);
        ACE_Oneshot_Acceptor (
            const ACE_PEER_ACCEPTOR_ADDR &local_addr,
            ACE_Reactor *reactor = ACE_Reactor::instance (),
            ACE_Concurrency_Strategy<SVC_HANDLER> * = 0
            );
        int open (
            const ACE_PEER_ACCEPTOR_ADDR &,
            ACE_Reactor *reactor = ACE_Reactor::instance (),
            ACE_Concurrency_Strategy<SVC_HANDLER> * = 0
            );
        virtual ~ACE_Oneshot_Acceptor (void);
        virtual int accept (
            SVC_HANDLER * = 0,
            ACE_PEER_ACCEPTOR_ADDR *remote_addr = 0,
            const ACE_Synch_Options &synch_options = ACE_Synch_Options::defaults,
            int restart = 1,
            int reset_new_handle = 0
            );
        virtual int cancel (void);
        virtual operator ACE_PEER_ACCEPTOR &() const;
        virtual ACE_PEER_ACCEPTOR &acceptor (void) const;
        virtual int close (void);
        void dump (void) const;
        ACE_ALLOC_HOOK_DECLARE;
      protected:
        virtual int activate_svc_handler (SVC_HANDLER *svc_handler);
        int shared_accept (
            SVC_HANDLER *svc_handler,
            ACE_PEER_ACCEPTOR_ADDR *remote_addr,
            ACE_Time_Value *timeout,
            int restart,
            int reset_new_handle
            );
        virtual ACE_HANDLE get_handle (void) const;
        virtual int handle_close (
            ACE_HANDLE = ACE_INVALID_HANDLE,
            ACE_Reactor_Mask = ACE_Event_Handler::ALL_EVENTS_MASK
            );
        virtual int handle_input (ACE_HANDLE);
        virtual int handle_timeout (
            const ACE_Time_Value &tv,
            const void *arg
            );
        virtual int init (int argc, ASYS_TCHAR *argv[]);
        virtual int fini (void);
        virtual int info (ASYS_TCHAR **, size_t) const;
        virtual int suspend (void);
        virtual int resume (void);
      private:
        int register_handler (
            SVC_HANDLER *svc_handler,
            const ACE_Synch_Options &options,
            int restart
            );
        SVC_HANDLER *svc_handler_;
        int restart_;
        ACE_PEER_ACCEPTOR peer_acceptor_;
        ACE_Concurrency_Strategy<SVC_HANDLER> *concurrency_strategy_;
        int delete_concurrency_strategy_;
    };

## DESCRIPTION

This class works similarly to the regular `ACE_Acceptor`, with the following differences:

1. This class doesn't automagically register `this` with the `ACE_Reactor` since it expects to have its `accept` method called directly. However, it stashes the `ACE_Reactor` pointer away in case it's needed later to finish accepting a connection asynchronously.

2. The class doesn't need an `ACE_Creation_Strategy` (since the user supplies the SVC_HANDLER) or an `ACE_Accept_Strategy` (since this class only accepts one connection and then removes all traces of itself from the `ACE_Reactor` if it was registered for asynchronous accepts).

## Initialization and termination methods.

    ACE_Oneshot_Acceptor (void);

Constructor.

    ACE_Oneshot_Acceptor (
        const ACE_PEER_ACCEPTOR_ADDR &local_addr,
        ACE_Reactor *reactor = ACE_Reactor::instance (),
        ACE_Concurrency_Strategy<SVC_HANDLER> * = 0
        );

Initialize the appropriate strategies for concurrency and then open the `peer_acceptor` at the designated `local_addr`. Note that unlike the `ACE_Acceptor` and `ACE_Strategy_Acceptor`, this method does NOT register `this` acceptor with the `reactor` at this point -- it just stashes the `reactor` away in case it's needed later.

    int open (
        const ACE_PEER_ACCEPTOR_ADDR &,
        ACE_Reactor *reactor = ACE_Reactor::instance (),
        ACE_Concurrency_Strategy<SVC_HANDLER> * = 0
        );

Initialize the appropriate strategies for concurrency and then open the `peer_acceptor` at the designated `local_addr`. Note that unlike the `ACE_Acceptor` and `ACE_Strategy_Acceptor`, this method does NOT register `this` acceptor with the `reactor` at this point -- it just stashes the `reactor` away in case it's needed later.

    virtual ~ACE_Oneshot_Acceptor (void);

Close down the `Oneshot_Acceptor`.

## Explicit factory operation.

    virtual int accept (
        SVC_HANDLER * = 0,
        ACE_PEER_ACCEPTOR_ADDR *remote_addr = 0,
        const ACE_Synch_Options &synch_options = ACE_Synch_Options::defaults,
        int restart = 1,
        int reset_new_handle = 0
        );

Create a `SVC_HANDLER`, accept the connection into the `SVC_HANDLER`, and activate the `SVC_HANDLER`.

    virtual int cancel (void);

Cancel a oneshot acceptor that was started asynchronously.

    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 int close (void);

Close down the `Oneshot_Acceptor`.

    void dump (void) const;

Dump the state of an object.

    ACE_ALLOC_HOOK_DECLARE;

Declare the dynamic allocation hooks.

## Demultiplexing hooks.

    virtual ACE_HANDLE get_handle (void) const;

Returns the listening acceptor's `ACE_HANDLE`.

    virtual int handle_close (
        ACE_HANDLE = ACE_INVALID_HANDLE,
        ACE_Reactor_Mask = ACE_Event_Handler::ALL_EVENTS_MASK
        );

Perform termination activities when `this` is removed from the `reactor`.

    virtual int handle_input (ACE_HANDLE);

Accept one connection from a client and activates the SVC_HANDLER.

    virtual int handle_timeout (
        const ACE_Time_Value &tv,
        const void *arg
        );

Called when an acceptor times out...

## Dynamic linking hooks.

    virtual int init (int argc, ASYS_TCHAR *argv[]);

Default version does no work and returns -1. Must be overloaded by application developer to do anything meaningful.

    virtual int fini (void);

Default version does no work and returns -1. Must be overloaded by application developer to do anything meaningful.

    virtual int info (ASYS_TCHAR **, size_t) const;

Default version returns address info in `buf`.

## Service management hooks.

    virtual int suspend (void);

Default version does no work and returns -1. Must be overloaded by application developer to do anything meaningful.

    virtual int resume (void);

Default version does no work and returns -1. Must be overloaded by application developer to do anything meaningful.

## AUTHOR

Doug Schmidt

## LIBRARY

ace