## NAME

ACE_Synch_Options - Contains the values of options used to determine the synchronous and asynchronous behavior.

## SYNOPSIS

    #include <ace/ACE_Synch_Options.h>

    class ACE_Synch_Options
    {
      public:
        enum{ USE_REACTOR = 01, USE_TIMEOUT = 02 };
        ACE_Synch_Options (
            u_long options = 0,
            const ACE_Time_Value &timeout = ACE_Time_Value::zero,
            const void *arg = 0
            );
        ~ACE_Synch_Options (void);
        void set (
            u_long options = 0,
            const ACE_Time_Value &timeout = ACE_Time_Value::zero,
            const void *arg = 0
            );
        int operator[] (u_long option) const;
        void operator= (u_long option);
        const void *arg (void) const;
        void arg (const void *);
        const ACE_Time_Value &timeout (void) const;
        void timeout (ACE_Time_Value &tv);
        const ACE_Time_Value *time_value (void) const;
        static ACE_Synch_Options defaults;
        static ACE_Synch_Options synch;
        static ACE_Synch_Options asynch;
        void dump (void) const;
        ACE_ALLOC_HOOK_DECLARE;
      private:
        u_long options_;
        ACE_Time_Value timeout_;
        const void *arg_;
    };

## DESCRIPTION

Values support the following behavior (TV == "timeout" and UR == "use ACE_Reactor"):

         Parameters      | Description
                         |
         TV   |  UR      |
         -----|----------|-------------------------------
              |          |
         NULL | yes      | infinite timeout (using ACE_Reactor)
              |          |
         time | yes      | try asynch transaction for
              |          | the specified time (using ACE_Reactor)
              |          |
         0,0  | yes      | poll; try, if EWOULDBLOCK,
              |          |       then return immediately
              |          |       (using ACE_Reactor)
              |          |
         NULL | no       | block forever (don't use ACE_Reactor)
              |          |
         time | no       | do a blocking transaction
              |          | for the specified time
              |          | (don't use ACE_Reactor)
              |          |
         0,0  | no       | poll; but do not initiate a
              |          | nonblocking transaction
              |          | (don't use ACE_Reactor)

## Options flags for controlling synchronization. Note that these

flags can be bit-wise "or'd" together if both options are desired.

## Initialization methods.

    ACE_Synch_Options (
        u_long options = 0,
        const ACE_Time_Value &timeout = ACE_Time_Value::zero,
        const void *arg = 0
        );

Initialize the Synch_Options based on parameters.

    ~ACE_Synch_Options (void);

Default dtor.

    void set (
        u_long options = 0,
        const ACE_Time_Value &timeout = ACE_Time_Value::zero,
        const void *arg = 0
        );

Initialize the Synch_Options based on parameters.

    int operator[] (u_long option) const;

Get method for determining which options are enabled.

    void operator= (u_long option);

Set method for enabling certain options.

    const void *arg (void) const;

Returns the "magic cookie" argument.

    void arg (const void *);

Set the "magic cookie" argument.

    const ACE_Time_Value &timeout (void) const;

Returns a reference to the `Time_Value`. This value only makes sense if (*this)[USE_TIMEOUT] is true.

    void timeout (ACE_Time_Value &tv);

Set the `Time_Value`.

    const ACE_Time_Value *time_value (void) const;

Returns the address of the timeout `Time_Value` if (*this)[USE_TIMEOUT] is true, else 0. This should be used with care, e.g., the timeout pointer should not be stored in a manner that will lead to dangling pointers...

## Static data members (singletons)

    static ACE_Synch_Options defaults;

This is the default setting for options, which will block synchronously.

    static ACE_Synch_Options synch;

This is the default synchronous setting.

    static ACE_Synch_Options asynch;

This is the default asynchronous setting.

    void dump (void) const;

Dump the state of an object.

    ACE_ALLOC_HOOK_DECLARE;

Declare the dynamic allocation hooks.

## AUTHOR

Doug Schmidt

## LIBRARY

ace