ACE_Synch_Options(3)

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 (const 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 (const 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