Qt Cryptographic Architecture: QCA::Console Class Reference

Qt Cryptographic Architecture

- Main Page
- Related Pages
- Modules
- Namespaces
- Classes
- Files
- Examples

- Class List
- Class Hierarchy
- Class Members

Public Types | Public Member Functions | Static Public Member Functions | Friends | List of all members
QCA::Console Class Reference
QCA user API

`#include <QtCrypto>`

Collaboration diagram for QCA::Console:
[legend]

## Public Types
enum | ChannelMode { Read, ReadWrite }
enum | TerminalMode { Default, Interactive }
enum | Type { Tty, Stdio }

## Public Member Functions
QByteArray | bytesLeftToRead ()
QByteArray | bytesLeftToWrite ()
ChannelMode | channelMode () const
| Console (Type type, ChannelMode cmode, TerminalMode tmode, QObject *parent=0)
void | release ()
TerminalMode | terminalMode () const
Type | type () const

## Static Public Member Functions
static bool | isStdinRedirected ()
static bool | isStdoutRedirected ()
static Console * | stdioInstance ()
static Console * | ttyInstance ()

## Friends
class | ConsolePrivate
class | ConsoleReference

## Detailed Description

QCA Console system

QCA provides an API for asynchronous, event-based access to the console and stdin/stdout, as these facilities are otherwise not portable. The primary use of this system within QCA is for passphrase prompting in command-line applications, using the tty console type.

How it works: Create a Console object for the type of console desired, and then use ConsoleReference to act on the console. Only one ConsoleReference may operate on a Console at a time.

A Console object takes over either the physical console (Console::Tty type) or stdin/stdout (Console::Stdio type). Only one of each type may be created at a time.

Whenever code is written that needs a tty or stdio object, the code should first call one of the static methods (ttyInstance() or stdioInstance()) to see if a console object for the desired type exists already. If the object exists, use it. If it does not exist, the rule is that the relevant code should create the object, use the object, and then destroy the object when the operation is completed.

By following the above rule, you can write code that utilizes a console without the application having to create some master console object for you. Of course, if the application has created a console then it will be used.

The reason why there is a master console object is that it is not guaranteed that all I/O will survive creation and destruction of a console object. If you are using the Stdio Type, then you probably want a long-lived console object. It is possible to capture unprocessed I/O by calling bytesLeftToRead or bytesLeftToWrite. However, it is not expected that general console-needing code will call these functions when utilizing a temporary console. Thus, an application developer would need to create his own console object, invoke the console-needing code, and then do his own extraction of the unprocessed I/O if necessary. Another reason to extract unprocessed I/O is if you need to switch from Console back to standard functions (e.g. fgets() ).

## Member Enumeration Documentation

enum QCA::Console::Type

The type of console object.

Enumerator
Tty | physical console
Stdio | stdin/stdout

enum QCA::Console::ChannelMode

The type of I/O to use with the console object.

Enumerator
Read | Read only (equivalent to stdin)
ReadWrite | Read/write (equivalent to stdin and stdout)

enum QCA::Console::TerminalMode

The nature of the console operation.

Enumerator
Default | use default terminal settings
Interactive | char-by-char input, no echo

## Constructor & Destructor Documentation

QCA::Console::Console | ( | Type | type,
|  | ChannelMode | cmode,
|  | TerminalMode | tmode,
|  | QObject * | parent = `0`
| ) |  |

Standard constructor.

Note that library code should not create a new Console object without checking whether there is already a Console object of the required Type. See the main documentation for Console for the rationale for this.

Parameters

  type | the Type of Console object to create
  cmode | the ChannelMode (I/O type) to use
  tmode | the TerminalMode to use
  parent | the parent object for this object

See also
  ttyInstance() and stdioInstance for static methods that allow you to test whether there is already a Console object of the required Type, and if there is, obtain a reference to that object.

## Member Function Documentation

Type QCA::Console::type | ( |  | ) | const

The Type of this Console object.

ChannelMode QCA::Console::channelMode | ( |  | ) | const

The ChannelMode of this Console object.

TerminalMode QCA::Console::terminalMode | ( |  | ) | const

The TerminalMode of this Console object.

static bool QCA::Console::isStdinRedirected | ( |  | ) |
| static

Test whether standard input is redirected.

See also
  type() and channelMode()

static bool QCA::Console::isStdoutRedirected | ( |  | ) |
| static

Test whether standard output is redirected.

See also
  type() and channelMode()

static Console* QCA::Console::ttyInstance | ( |  | ) |
| static

The current terminal-type console object.

Returns
  null if there is no current Console of this type, otherwise the Console to use

static Console* QCA::Console::stdioInstance | ( |  | ) |
| static

The current stdio-type console object.

Returns
  null if there is no current Console of this type, otherwise the Console to use

void QCA::Console::release | ( |  | ) |

Release the Console.

This allows access to buffers containing any remaining data

QByteArray QCA::Console::bytesLeftToRead | ( |  | ) |

Obtain remaining data from the Console, awaiting a read operation.

QByteArray QCA::Console::bytesLeftToWrite | ( |  | ) |

Obtain remaining data from the Console, awaiting a write operation.

The documentation for this class was generated from the following file:

- qca_support.h