wycseg.3wy

一个不错

.\"
.\" Edited by I.J.Wang, 2004
.\"
.TH WyCSeg 3wy "libwy v0.31"
.SH NAME
WyCSeg \- class pointing to contiguous characters in an array
.SH SYNOPSIS
.B #include <wycseg.h>
.PP
WyCSeg is a discardable class for representing range of contiguous characters.

The pointed target character array is not modified by WyCSeg members.
However, modification of the pointed target array can be done in other ways and 
affects WyCSeg behaviors implicitly.
.SH "PUBLIC MEMBERS"
 class \fBReply\fP : public WyRet
 \fBWyCSeg\fP() throw()
 \fBWyCSeg\fP(const WyCSeg&) throw()
 \fBWyCSeg\fP(const char*)
 \fBWyCSeg\fP(const char*,size_t) throw(Reply)
 \fBWyCSeg\fP(const char*,const char*) throw(Reply)
 \fBWyCSeg\fP(WyCSeg&, Wy::ByMove_t) throw()
 bool \fBis_default\fP(void) const throw()
 const char* \fBbegin\fP(void) const throw()
 const char* \fBend\fP(void) const throw()
 size_t \fBsize\fP(void) const throw()
 const char& \fBfront\fP(void) const throw(Reply)
 const char& \fBback\fP(void) const throw(Reply)
 void \fBreset\fP(void) throw()
 void \fBreset\fP(const WyCSeg&) throw()
 WyRet \fBreset\fP(const char*)
 WyRet \fBreset\fP(const char*,size_t) throw()
 WyRet \fBreset\fP(const char*,const char*) throw()
 const WyCSeg& \fBoperator =\fP(const WyCSeg&) throw()
 const WyCSeg& \fBoperator =\fP(const char*)
 void \fBswap\fP(WyCSeg&) throw()
 const char* \fB_move_begin\fP(ptrdiff_t) throw(Reply)
 const char* \fB_move_end\fP(ptrdiff_t) throw(Reply)
 const char& \fBoperator []\fP(size_t) const throw(Reply)
 const WyCSeg \fBcseg\fP(size_t) const throw(Reply)
 const WyCSeg \fBcseg\fP(size_t,size_t) const throw(Reply)
 bool \fBfind\fP(size_t*,size_t,const WyCSeg&) const throw()
 bool \fBfindc\fP(size_t*,size_t,char) const throw()
 bool \fBfindc\fP(size_t*,size_t,const WyCSeg&) const throw()
 bool \fBfindc_not\fP(size_t*,size_t,char) const throw()
 bool \fBfindc_not\fP(size_t*,size_t,const WyCSeg&) const throw()
 bool \fBrfind\fP(size_t*,size_t,const WyCSeg&) const throw()
 bool \fBrfindc\fP(size_t*,size_t,char) const throw()
 bool \fBrfindc\fP(size_t*,size_t,const WyCSeg&) const throw()
 bool \fBrfindc_not\fP(size_t*,size_t,char) const throw()
 bool \fBrfindc_not\fP(size_t*,size_t,const WyCSeg&) const throw()
 bool \fBis_overlap\fP(const WyCSeg&) const throw()
 int \fB_strcmp\fP(const WyCSeg&) const throw()
 int \fB_strcmp\fP(const char*) const
 bool \fBoperator ==\fP(const WyCSeg&) const throw()
 bool \fBoperator !=\fP(const WyCSeg&) const throw()
 bool \fBoperator ==\fP(const char*) const
 bool \fBoperator !=\fP(const char*) const
.\"--------------------------------------------
.SH "AUXILIARY FUNCTIONS"
 bool \fBoperator ==\fP(const char*, const WyCSeg&) const
 bool \fBoperator !=\fP(const char*, const WyCSeg&) const
.SH "DESCRIPTION"
.\"--------------------------------------------
.PP
.BI "class Reply : public WyRet
.PP
    Class specific throw type
.\"--------------------------------------------
.PP
.BI "WyCSeg() throw()"
.PP
    Construct default object

     size() = 0
     begin()= None NULL value
     end()  = begin()

    Note: Any WyCSeg object of zero size is default
.\"--------------------------------------------
.PP
.BI "WyCSeg(const WyCSeg& " "cs" ") throw()"
.PP
    Construct object from \fIcs\fP

     size() = \fIcs\fP.size()
     begin()= \fIcs\fP.begin()
     end()  = \fIcs\fP.end()
.\"--------------------------------------------
.PP
.BI "WyCSeg(const char* " "cstr" ")"
.PP
    Construct object to point to the zero terminated character
    array pointed by \fIcstr\fP, not including the trailing zero

     size() = ::strlen(\fIcstr\fP)
     begin()= \fIcstr\fP
     end()  = begin()+size()

    Note: Be sure \fIcstr\fP pointed array terminates with char(0)
.PP
    [\fBThrow\fP] Reply
            Wym_EFAULT      \fIcstr\fP is NULL
.\"--------------------------------------------
.PP
.BI "WyCSeg(const char* " "buf" ", size_t " "blen" ") throw(Reply)"
.PP
    Construct object to point to the \fIblen\fP characters pointed by
    \fIbuf\fP

     size() = \fIblen\fP
     begin()= \fIbuf\fP
     end()  = begin()+size()
.PP
    [\fBThrow\fP] Reply
            Wym_EFAULT      \fIbuf\fP is NULL
.\"--------------------------------------------
.PP
.BI "WyCSeg(const char* " "head" ", const char* " "trail" ") throw(Reply)"
.PP
    Construct object to point to the character array pointed
    by \fIhead\fP and the one-past-the-last value \fItrail\fP

     size() = \fItrail\fP-\fIhead\fP
     begin()= \fIhead\fP
     end()  = \fItrail\fP

    Note: If \fIhead\fP and \fItrail\fP are not pointing to the same array 
          ,behavior is undefined.
.PP
    [\fBThrow\fP] Reply
            Wym_EFAULT      \fIhead\fP or \fItrail\fP is NULL
            Wym_ERANGE      \fIhead\fP>\fItrail\fP
.\"--------------------------------------------
.PP
.BI "WyCSeg(WyCSeg& " "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

    Note: All WyCSeg object of zero size is default.
.PP
    [\fBRet\fP] true= object is equivalent to WyCSeg()
         false= otherwise
.\"--------------------------------------------
.PP
.BI "const char* begin(void) const throw()"
.PP
    Get the begining address of the pointed target array
.PP
    [\fBRet\fP] pointer to the begining address of the target array
.\"--------------------------------------------
.PP
.BI "const char* end(void) const throw()"
.PP
    Get the one-past-the-last address of pointed target array

    For any WyCSeg object cs, cs.end()==cs.begin()+cs.size()
.PP
    [\fBRet\fP] Pointer to the one-past-the-last address
.\"--------------------------------------------
.PP
.BI "size_t size(void) const throw()"
.PP
    Get size of the array *this points
.PP
    [\fBRet\fP] size of array *this points
.\"--------------------------------------------
.PP
.BI "const char& front(void) const throw(Reply)"
.PP
    Get reference of the first character of the target array
.PP
    [\fBThrow\fP] Reply
            Wym_ENOENT      this->size()==0
.PP
    [\fBRet\fP] Reference of the character at position 0.
.\"--------------------------------------------
.PP
.BI "const char& back(void) const throw(Reply)"
.PP
    Get reference of the last character of the target array 
.PP
    [\fBThrow\fP] Reply
            Wym_ENOENT      this->size()==0
.PP
    [\fBRet\fP] Reference of the character at position size()-1
.\"--------------------------------------------
.PP
.BI "void reset(void) throw()" 
.PP
    Reconstruct *this to the state as WyCSeg()
.\"--------------------------------------------
.PP
.BI "void reset(const WyCSeg& " "cs" ") throw()"
.PP
    Reconstruct *this to the state as WyCSeg(\fIcs\fP)
.\"--------------------------------------------
.PP
.BI "WyRet reset(const char* " "cstr" ")"
.PP
    Reconstruct *this to the state as WyCSeg(\fIcstr\fP)

    Note: Be sure \fIcstr\fP pointed array terminates with char(0)
.PP
    [\fBRet\fP] Ok              Succeed
          Wym_EFAULT      \fIcstr\fP is NULL
.\"--------------------------------------------
.PP
.BI "WyRet reset(const char* " "buf" ", size_t " "blen" ") throw()"
.PP
    Reconstruct *this to the state as WyCSeg(\fIbuf\fP,\fIblen\fP)
.PP
    [\fBRet\fP] Ok              Succeed
          Wym_EFAULT      \fIbuf\fP is NULL
.\"--------------------------------------------
.PP
.BI "WyRet reset(const char* " "head" ", const char* " "trail" ") throw()"
.PP
    Reconstruct *this to the state as WyCSeg(\fIhead\fP,\fItrail\fP)

    Note: If \fIhead\fP and \fItrail\fP are not pointing to the same array
          ,behavior is undefined.
.PP
    [\fBRet\fP] Ok              Succeed
          Wym_EFAULT      \fIhead\fP or \fItrail\fP is NULL
          Wym_ERANGE      \fIhead\fP>\fItrail\fP
.\"--------------------------------------------
.PP
.BI "const WyCSeg& operator =(const WyCSeg& " "rhs" ") throw()"
.PP
    Reconstruct *this to the state as WyCSeg(\fIrhs\fP)
.PP
    [\fBRet\fP] const reference of *this
.\"--------------------------------------------
.PP
.BI "const WyCSeg& operator =(const char* " "cstr" ")"
.PP
    Reconstruct *this to the state as WyCSeg(\fIcstr\fP)

    Note: Be sure \fIcstr\fP pointed array terminates with char(0)
.PP
    [\fBThrow\fP] Reply
            Wym_EFAULT      \fIcstr\fP is NULL
.PP
    [\fBRet\fP] const reference of *this
.\"--------------------------------------------
.PP
.BI "void swap(WyCSeg& " "cs" ") throw()"
.PP
    Interchange state of *this with that of \fIcs\fP
.\"--------------------------------------------
.PP
.BI "const char* _move_begin(ptrdiff_t " "off" ") throw(Reply)"
.PP
    Move the begin pointer by adding offset \fIoff\fP to it
.PP
    [\fBThrow\fP] Reply
            Wym_EINVAL      \fIoff\fP > this->size(), or the result
                            would not be representable
.PP
    [\fBRet\fP] this->begin()
.\"--------------------------------------------
.PP
.BI "const char* _move_end(ptrdiff_t " "off" ") throw(Reply)"