wytermios.3wy

一个不错

.TH WyTermios 3wy "libwy v0.31"
.SH NAME
WyTermios \- class for struct termios
.SH SYNOPSIS
.B #include <wytermios.h>
.PP
WyTermios is a discardable class for \fBstruct termios\fP ,describing the controlling
characteristic of the communication port.
.SH "PUBLIC MEMBERS"
 \fBWyTermios\fP() throw()
 \fBWyTermios\fP(const WyTermios&) throw()
 \fBWyTermios\fP(WyTermios&, Wy::ByMove_t) throw()
 bool \fBis_default\fP(void) const throw()
 void \fBreset\fP(void) throw()
 void \fBreset\fP(const WyTermios&) throw()
 const WyTermios& \fBoperator =\fP(const WyTermios&) throw()
 speed_t \fBgetispeed\fP(void) const throw()
 speed_t \fBgetospeed\fP(void) const throw()
 WyRet \fBsetispeed\fP(speed_t) throw()
 WyRet \fBsetospeed\fP(speed_t) throw()
 tcflag_t \fBiflag\fP(void) const throw()
 void \fBiflag\fP(tcflag_t) throw()
 void \fBiflag_or\fP(tcflag_t) throw()
 void \fBiflag_and\fP(tcflag_t) throw()
 tcflag_t \fBoflag\fP(void) const throw()
 void \fBoflag\fP(tcflag_t) throw()
 void \fBoflag_or\fP(tcflag_t) throw()
 void \fBoflag_and\fP(tcflag_t) throw()
 tcflag_t \fBcflag\fP(void) const throw()
 void \fBcflag\fP(tcflag_t) throw()
 void \fBcflag_or\fP(tcflag_t) throw()
 void \fBcflag_and\fP(tcflag_t) throw()
 tcflag_t \fBlflag\fP(void) const throw()
 void \fBlflag\fP(tcflag_t) throw()
 void \fBlflag_or\fP(tcflag_t) throw()
 void \fBlflag_and\fP(tcflag_t) throw()
 cc_t \fBcc_VSTOP\fP(void) const throw()
 void \fBcc_VSTOP\fP(cc_t) throw()
 cc_t \fBcc_VSTART\fP(void) const throw()
 void \fBcc_VSTART\fP(cc_t) throw()
 cc_t \fBcc_VSUSP\fP(void) const throw()
 void \fBcc_VSUSP\fP(cc_t) throw()
 cc_t \fBcc_VQUIT\fP(void) const throw()
 void \fBcc_VQUIT\fP(cc_t) throw()
 cc_t \fBcc_VKILL\fP(void) const throw()
 void \fBcc_VKILL\fP(cc_t) throw()
 cc_t \fBcc_VERASE\fP(void) const throw()
 void \fBcc_VERASE\fP(cc_t) throw()
 cc_t \fBcc_VEOL\fP(void) const throw()
 void \fBcc_VEOL\fP(cc_t) throw()
 cc_t \fBcc_VEOF\fP(void) const throw()
 void \fBcc_VEOF\fP(cc_t) throw()
 cc_t \fBcc_VINTR\fP(void) const throw()
 void \fBcc_VINTR\fP(cc_t) throw()
 cc_t \fBcc_VTIME\fP(void) const throw()
 void \fBcc_VTIME\fP(cc_t) throw()
 cc_t \fBcc_VMIN\fP(void) const throw()
 void \fBcc_VMIN\fP(cc_t) throw()
 bool \fBoperator ==\fP(const WyTermios&) const throw()
 bool \fBoperator !=\fP(const WyTermios&) const throw()
.SH "DESCRIPTION"
.\"--------------------------------------------
.PP
.BI "WyTermios() throw()"
.PP
    Construct default object. (contains nothing)

     iflag() = tcflag_t()
     oflag() = tcflag_t()
     cflag() = tcflag_t()
     lflag() = tcflag_t()
     cc_...  = cc_t()
.\"--------------------------------------------
.PP
.BI "WyTermios(const WyTermios& " "tio" ") throw()"
.PP
    Construct object by copy from \fItio\fP

     iflag() = copy from \fItio\fP
     oflag() = ditto
     cflag() = ditto
     lflag() = ditto
     cc_...  = ditto
.\"--------------------------------------------
.PP
.BI "WyTermios(WyTermios& " "src" ", Wy::ByMove_t) throw()"
.PP
    See Wy_Array(Wy_Array&, Wy::ByMove_t) in wy_array(3wy)
    for definition of the move constructor.
.\"--------------------------------------------
.PP
.BI "bool is_default(void) const throw()"
.PP
    Is *this equivalent to the default object
.PP
    [\fBRet\fP] true= object is equivalent to WyTermios()
         false= otherwise
.\"--------------------------------------------
.PP
.BI "void reset(void) throw()"
.PP
    Reconstruct *this to the state as WyTermios()
.PP
.\"--------------------------------------------
.BI "void reset(const WyTermios& " "tio" ") throw()"
.PP
    Reconstruct *this to the state as WyTermios(\fItio\fP)
.\"--------------------------------------------
.PP
.BI "const WyTermios& operator =(const WyTermios& " "tio" ") throw()"
.PP
    Assign *this to the state as WyTermios(\fItio\fP)
.PP 
    [\fBRet\fP] Const reference of *this
.\"--------------------------------------------
.PP
.BI "speed_t getispeed(void) const throw()"
.PP
    Get the input baud reate setting in *this
.PP 
    [\fBRet\fP] Code of the input baud rate.
          Refer to setispeed for the symbol of the baud rate.
.PP 
    [\fBRefer\fP] ::cfgetispeed
.\"--------------------------------------------
.PP
.BI "speed_t getospeed(void) const throw()"
.PP
    Get the output baud reate setting in *this
.PP 
    [\fBRet\fP] Code of the output baud rate
          Refer to setispeed for the symbol of the baud rate.
.PP 
    [\fBRefer\fP] ::cfgetospeed
.\"--------------------------------------------
.PP
.BI "WyRet setispeed(speed_t " "speed" ") throw()"
.PP
    Set the input baud rate of *this to \fIspeed\fP.
    \fIspeed\fP should be one of the following symbols:
.PP
        B0       terminate the connection. If there is a modem,
                 hangs up the phone.
        B50      50
        B75      75
        B134     134.5
        B150     150
        B200     200
        B300     300
        B600     600
        B1200    1200
        B1800    1800
        B2400    2400
        B4800    4800
        B9600    9600
        B19200   19200
        B38400   38400
        B57600   ...
        B115200  ...
.PP 
    [\fBRet\fP] Ok              Succeed.
          Wym_EINVAL      (document dose not indicate any errno code)
.PP 
    [\fBRefer\fP] ::cfsetispeed
.\"--------------------------------------------
.PP
.BI "WyRet setospeed(speed_t " "speed" ") throw()"
.PP
    Set the output baud rate of *this to \fIspeed\fP.
    Refer setispeed for the symbol of \fIspeed\fP
.PP 
    [\fBRet\fP] Ok              Succeed.
          Wym_EINVAL      (document dose not indicate any errno code)
.PP 
    [\fBRefer\fP] ::cfsetospeed
.\"--------------------------------------------
.PP
.BI "tcflag_t iflag(void) const throw()"
.PP
.BI "void iflag(tcflag_t " "v" ") throw()"
.PP
.BI "void iflag_or(tcflag_t " "v" ") throw()"
.PP
.BI "void iflag_and(tcflag_t " "v" ") throw()"
.PP
    Access the c_iflag settings of *this (Input flag)
    
    BRKINT  
    IGNBRK=1, BRKINT=x.  A BREAK is ignored
          =0, BRKINT=1 A BREAK flushes all data in the queue and 
                       generates a SIGINT signal for the foreground
                       process group.
              BRKINT=0 A BREAK reads as '\\0', except when PARMRK
                       is set, in which case it is converted to
                       three bytes sequence: \\377 \\0 \\0.
    IGNPAR  Ignore framing and parity errors
    PARMRK=1, IGNPAR=0 A byte with framing error or parity error is
                       given to the application as the three-byte
                       sequence: \\377 \\0 \\X where X is the byte
                       with the error
          =0, IGNPAR=0 Read the byte with parity or framing error as \\0 
    INPCK   Enable input parity checking
    ISTRIP  The valid input bytes are first stripped to seven bits.
    INLCR   Translate NL to CR on input
    IGNCR   Ignore received CR
    ICRNL   Translate CR to LF on input (unless IGNCR is set)
    IXON    Enable XON/XOFF flow control on output
    IXOFF   Enable XON/XOFF flow control on input
    ...    (other flags are system-specific)
.PP 
    [\fBRefer\fP] termios(3), POSIX Programmer's Guide,Donald Lewine,p153
            Linux Application Development, Johnson and Troan.
.\"--------------------------------------------
.PP
.BI "tcflag_t oflag(void) const throw()"
.PP
.BI "void oflag(tcflag_t " "v" ") throw()"
.PP
.BI "void oflag_or(tcflag_t " "v" ") throw()"
.PP
.BI "void oflag_and(tcflag_t " "v" ") throw()"
.PP
    Access the c_oflag settings of *this (Output flag)
    
    c_oflag is the bitwise inclusive OR of the flags:
    OPOST  Enables implementation-defined output processing
    ...    (other flags are system-specific)
    
    [\fBRefer\fP] termios(3), POSIX Programmer's Guide,Donald Lewine,p149
            Linux Application Development, Johnson and Troan.
.\"--------------------------------------------
.PP
.BI "tcflag_t cflag(void) const throw()"
.PP
.BI "void cflag(tcflag_t " "v" ") throw()"
.PP
.BI "void cflag_or(tcflag_t " "v" ") throw()"
.PP
.BI "void cflag_and(tcflag_t " "v" ") throw()"
.PP
    Access the c_cflag settings of *this (Control flag)
    c_cflag is the bitwise inclusive OR of flags:

    CLOCAL  Ignore any modem status lines
    CREAD   Enable receiver (if not set, no characters are received)
    CSTOPB  If set, two stop bits are sent; otherwise only one is sent.
    HUPCL   Hang up the modem after the last process closes the device
    PARENB  Enable parity generation and checking (output/input)
    PARODD  Set odd parity

    CRTSCTS (not in POSIX) Enables RTS/CTS flow control
    CSIZE   Character size mask. One of the following values:
    CS5     Five bits per byte 
    CS6     Six bits per byte
    CS7     Seven bits per byte
    CS8     Eight bits per byte

    ...    (other flags are system-specific)
.PP
    [\fBRefer\fP] termios(3), POSIX Programmer's Guide,Donald Lewine,p155
            Linux Application Development, Johnson and Troan.
.\"--------------------------------------------
.PP
.BI "tcflag_t lflag(void) const throw()"
.PP
.BI "void lflag(tcflag_t " "v" ") throw()"
.PP
.BI "void lflag_or(tcflag_t " "v" ") throw()"
.PP
.BI "void lflag_and(tcflag_t " "v" ") throw()"
.PP
    Access the c_lflag settings of *this (Local flag)
    c_lflag is the bitwise inclusive OR of flags:

    ECHO    Echo input character
    ECHOE   If ECHOE and ICANON are both set, the ERASE character
            causes the terminal to erase the last character from 
            the display.
    ECHOk   If ECHOk and ICANON are both set, the KILL character
            erase the current line. (if hardware suppoet)
    ECHONL  If ECHONL and ICANON are both set, the '\n' character
            is echoed even if ECHO is not set.
    ISIG    If set, any of the characters INTR,QUIT or DSUSP are 
            received, generate the corresponding signal.
    ICANON  Enable canonical input processing
    NOFLSH  Disable flushing input and output queues when generating 
            SIGINT, SIGQUIT and SIGSUSP signals
    TOSTOP  Send the SIGTTOU signal to the process group of a 
            background process which tries to write to its controlling
            terminal.
    IEXTEN  Enable implementation-defined input processing
    ...    (other flags are system-specific)
    
    [\fBRefer\fP] termios(3), POSIX Programmer's Guide,Donald Lewine,p155
            Linux Application Development, Johnson and Troan.
.\"--------------------------------------------
.PP
.BI "cc_t cc_VSTOP(void) const throw()"
.PP
.BI "void cc_VSTOP(cc_t " "v" ") throw()"
.PP
    Access the c_cc array element, index VSTOP
    
    ICANON=1  STOP character(023,DC3,Ctrl-S) stop output untill START
    ICANON=0  STOP character
.\"--------------------------------------------
.PP
.BI "cc_t cc_VSTART(void) const throw()"
.PP
.BI "void cc_VSTART(cc_t " "v" ") throw()"
.PP
    Access the c_cc array element, index VSTART
    
    ICANON=1  START character(021,DC1,Ctrl-Q) restart output stopped by STOP
    ICANON=0  START character
.\"--------------------------------------------
.PP
.BI "cc_t cc_VSUSP(void) const throw()"
.PP
.BI "void cc_VSUSP(cc_t " "v" ") throw()"
.PP
    Access the c_cc array element, index VSUSP

    ICANON=1  SUSP character(032,SUB,Ctrl-Z) send SIGTSTP signal
    ICANON=0  SUSP character
.\"--------------------------------------------
.PP
.BI "cc_t cc_VQUIT(void) const throw()"
.PP
.BI "void cc_VQUIT(cc_t " "v" ") throw()"
.PP
    Access the c_cc array element, index VQUIT

    ICANON=1  QUIT character(034, FS,Ctrl-\) send SIGQUIT signal
    ICANON=0  QUIT character
.\"--------------------------------------------
.PP
.BI "cc_t cc_VKILL(void) const throw()"
.PP
.BI "void cc_VKILL(cc_t " "v" ") throw()"
.PP
    Access the c_cc array element, index VKILL

    ICANON=1  KILL character(025, NAK,Ctrl-U or Ctrl-X) delete the entire line
.\"--------------------------------------------
.PP
.BI "cc_t cc_VERASE(void) const throw()"
.PP
.BI "void cc_VERASE(cc_t " "v" ") throw()"
.PP
    Access the c_cc array element, index VERASE

    ICANON=1  ERASE character(0177, DEL,BS,Ctrl-H) Erase the preceding character
.\"--------------------------------------------
.PP
.BI "cc_t cc_VEOL(void) const throw()"
.PP
.BI "void cc_VEOL(cc_t " "v" ") throw()"
.PP
    Access the c_cc array element, index VEOL

    ICANON=1  EOL character(0, NUL, Ctrl-J)
    ICANON=0  Not applicable
.\"--------------------------------------------
.PP
.BI "cc_t cc_VEOF(void) const throw()"
.PP
.BI "void cc_VEOF(cc_t " "v" ") throw()"
.PP
    Access the c_cc array element, index VEOF

    ICANON=1  EOF character(004, EOT, Ctrl-D)
    ICANON=0  Not applicable
.\"--------------------------------------------
.PP
.BI "cc_t cc_VINTR(void) const throw()"
.PP
.BI "void cc_VINTR(cc_t " "v" ") throw()"
.PP
    Access the c_cc array element, index VINTR

    ICANON=1  INTR character(003, ETX, Ctrl-C,DEL) interrupt character.
    ICANON=0  INTR character
.\"--------------------------------------------
.PP
.BI "cc_t cc_VTIME(void) const throw()"
.PP
.BI "void cc_VTIME(cc_t " "v" ") throw()"
.PP
    Access the c_cc array element, index VTIME

    ICANON=1  Not applicable
    ICANON=0  VTIME specifies the inter-byte time (1/10 seconds)
              between received characters. Reffer to cc_VMIN
.\"--------------------------------------------
.PP
.BI "cc_t cc_VMIN(void) const throw()"
.PP
.BI "void cc_VMIN(cc_t " "v" ") throw()"
.PP
    Access the c_cc array element, index VMIN

    ICANON=1  Not applicable
    ICANON=0, If VTIME=0, VMIN=0
                 The read returns immediately with the currently
                 received characters.
              If VTIME=0, VMIN>0
                 A read will wait until VMIN bytes has received. 
                 Zero byte is returned on End Of File.
              If VTIME>0, VMIN=0
                 A read will wait until any byte is received or
                 VTIME/10 seconds has passed
              If VTIME>0, VMIN>0
                 A read will wait until VTIME/10 seconds has passed
                 since the last character received (at least one)
                 or VMIN characters has received.
.\"--------------------------------------------
.PP
.BI "bool operator ==(const WyTermios& " "rhs" ") const throw()"
.PP
.BI "bool operator !=(const WyTermios& " "rhs" ") const throw()"
.PP 
    Test equivalence of *this with \fIrhs\fP

    this->operator==(\fIrhs\fP) yields true iff for all other
    const members \fBf\fP, this->\fBf\fP()==\fIrhs\fP.\fBf\fP()
.PP 
    [\fBRet\fP] true= relation holds
         false= otherwise
.\"--------------------------------------------
.SH "SEE ALSO"
.BR wyret
.BR wy_dirfile
.BR wychrfile
.BR wyregfile
.BR wyterminal
.BR termios(3)
.SH NOTE
Project is in development, http://sourceforge.net/projects/libwx