---
name: "ACE_Synch_Options"
section: "3"
platform: "linux"
package: "libace-doc"
version: "5.0.7-4"
release: "Debian 2.2 (Potato)"
platforms: ["linux"]
url: "https://new.carta.tech/ACE_Synch_Options"
---

# ACE\_Synch\_Options(3)

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

## 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