wystr.3wy

一个不错

.PP
    Find the maximum position of occurrence of the sub-string
    pointed by \fIcs\fP, and reset *\fIres\fP with the position found
    if \fIres\fP is not NULL.
.PP
    [\fBRet\fP] true = found, *\fIres\fP contains the position found
          false= otherwise, *\fIres\fP intact.
.\"--------------------------------------------
.PP
.BI "bool rfind(size_t* " "res" ", size_t " "idx" ", char " "ch" ") const throw()"
.PP
    Find the maximum position of occurrence \fIch\fP in the range
    from 0 to \fIidx\fP, reset *\fIres\fP with the position found 
    if \fIres\fP is not NULL.
.PP
    [\fBRet\fP] true = found, *\fIres\fP contains the position found
          false= otherwise, *\fIres\fP intact.
.\"--------------------------------------------
.PP
.BI "bool rfind(size_t* " "res" ", size_t " "idx" ", const WyCSeg& " "cs" ") const throw()"
.PP
    Find the maximum position of occurrence of the sub-string
    pointed by \fIcs\fP in the range from 0 to \fIidx\fP, reset *\fIres\fP with 
    the position found if \fIres\fP is not NULL.
.PP
    [\fBRet\fP] true = found, *\fIres\fP contains the position found
          false= otherwise, *\fIres\fP intact.
.\"--------------------------------------------
./.PP
./.BI "bool find_in(size_t* " "res" ", size_t " "idx" ", const WyCSeg& " "cs" ") const throw()"
./.PP
./    Find the minimal position from \fIidx\fP to this->size()-1, for
./    the character which is in those pointed by \fIcs\fP. If \fIres\fP
./    is not NULL, *\fIres\fP is reset with the position of the character
./    which is found in \fIcs\fP.
./.PP
./    [\fBRet\fP] true = found, *\fIres\fP contains the position found
./          false= otherwise, *\fIres\fP intact.
.\"--------------------------------------------
.PP
.BI "bool find_not(size_t* " "res" ", size_t " "idx" ", char " "ch" ") const throw()"
.PP
    Find the minimal position from \fIidx\fP to this->size()-1, for
    the character which is not \fIch\fP, reset *\fIres\fP with the position
    found if \fIres\fP is not NULL.
.PP
    [\fBRet\fP] true = found, *\fIres\fP contains the position found
          false= otherwise, *\fIres\fP intact.
.\"--------------------------------------------
./.PP
./.BI "bool find_not(size_t* " "res" ", size_t " "idx" ", const WyCSeg& " "cs" ") const throw()"
./.PP
./    Find the minimal position from \fIidx\fP to this->size()-1, for
./    the character which is not those pointed by \fIcs\fP. If \fIres\fP
./    is not NULL, *\fIres\fP is reset with the position of the character
./    which is found not in \fIcs\fP.
./.PP
./    [\fBRet\fP] true = found, *\fIres\fP contains the position found
./          false= otherwise, *\fIres\fP intact.
./.\"--------------------------------------------
./.PP
./.BI "bool rfind_in(size_t* " "res" ", size_t " "idx" ", const WyCSeg& " "cs" ") const throw()"
./.PP
./    Find the maximal position from \fIidx\fP to 0, for the character
./    which is in those pointed by \fIcs\fP. If \fIres\fP is not NULL,
./    *\fIres\fP is reset with the position of the character which is 
./    found in \fIcs\fP.
./.PP
./    [\fBRet\fP] true = found, *\fIres\fP contains the position found
./          false= otherwise, *\fIres\fP intact.
.\"--------------------------------------------
.PP
.BI "bool rfind_not(size_t* " "res" ", size_t " "idx" ", char " "ch" ") const throw()"
.PP
    Find the maximum position from \fIidx\fP to 0, for of the character
    which is not \fIch\fP, reset *\fIres\fP with the position found if \fIres\fP
    is not NULL.
.PP
    [\fBRet\fP] true = found, *\fIres\fP contains the position found
          false= otherwise, *\fIres\fP intact.
.\"--------------------------------------------
./.PP
./.BI "bool rfind_not(size_t* " "res" ", size_t " "idx" ", const WyCSeg& " "cs" ") const throw()"
./.PP
./    Find the maximal position from \fIidx\fP to 0, for the character
./    which is not those pointed by \fIcs\fP. If \fIres\fP is not NULL,
./    *\fIres\fP is reset with the position of the character which is
./    found not in \fIcs\fP.
./.PP
./    [\fBRet\fP] true = found, *\fIres\fP contains the position found
./          false= otherwise, *\fIres\fP intact.
./.\"--------------------------------------------
.PP
.BI "WyCSeg cseg(void) const throw()"
.PP
    Get WyCSeg object pointing to the data

    Note: Non-const members may cause reallocation. Reallocation
          invalidates dereference of the returned WyCSeg.
.PP
    [\fBRet\fP] WyCSeg object pointing to the data
.\"--------------------------------------------
.PP
.BI "WyCSeg cseg(size_t " "idx" ") const throw(Reply)"
.PP
.BI "WyCSeg cseg(size_t " "idx" ", size_t " "num" ") const throw(Reply)"
.PP
    Get WyCSeg object pointing sub-array of the data from
    position \fIidx\fP to the last or at most \fInum\fP characters

    Note: Non-const members may cause reallocation. Reallocation
          invalidates dereference of the returned WyCSeg.
.PP
    [\fBThrow\fP] Reply
            Wym_EINVAL      \fIidx\fP > this->size()
.PP
    [\fBRet\fP] WyCSeg object pointing sub-array of the data
.\"--------------------------------------------
.PP
.BI "bool operator ==(const WyStr& " "rhs" ") const throw()"
.PP
.BI "bool operator !=(const WyStr& " "rhs" ") const throw()"
.PP
.BI "bool operator ==(const WyCSeg& " "rhs" ") const throw()"
.PP
.BI "bool operator !=(const WyCSeg& " "rhs" ") const throw()"
.PP
    Test equivalence of *this with \fIrhs\fP or \fIrhs\fP pointed 
    data.

    *this and \fIrhs\fP are equivalent iff both have the same size and
    for all valid position i, (*this)[i]==\fIrhs\fP[i] yields true.

    Equivalent objects do not mean data address and capacity are
    equal. For example, the value returned from members \fBdata\fP(),
    \fBc_str\fP(), \fBbegin\fP(), and by &\fBat\fP(0), &\fBoperator[]\fP(0) are not
    necessarily equal for equivalent WyStr objects.
.PP
    [\fBRet\fP] true= relation holds
          false= otherwise
.PP 
    [\fBRefer\fP] ::memcmp(void*,void*,size_t)
.\"--------------------------------------------
.PP
.BI "bool operator ==(const char* " "cstr" ") const throw(WyCSeg::Reply)"
.PP
.BI "bool operator !=(const char* " "cstr" ") const throw(WyCSeg::Reply)"
.PP
    Test equivalence of *this with WyCSeg(\fIcstr\fP) pointed data

   Note: These are function overloads, documented for reference.
         See operator ==(const WyCSeg&). and
             operator !=(const WyCSeg&)
.\"--------------------------------------------
.PP
.BI "int _strcmp(const WyStr& " "str" ") const throw()"
.PP
    Compare data lexicographical order of *this against \fIstr\fP
.PP
    [\fBRet\fP]  0, data is equal to \fIstr\fP
          >0, data is greater than \fIstr\fP
          <0, data is lesser than \fIstr\fP
.PP 
    [\fBRefer\fP] ::memcmp(void*,void*,size_t)
.\"--------------------------------------------
.PP
.BI "int _strcmp(const WyCSeg& " "cs" ") const throw()"
.PP
    Compare data lexicographical order of *this against the string
    pointed by \fIcs\fP.
.PP
.PP
    [\fBRet\fP]  0, data is equal to \fIcs\fP
          >0, data is greater than \fIcs\fP
          <0, data is lesser than \fIcs\fP
.PP 
    [\fBRefer\fP] ::memcmp(void*,void*,size_t)
.\"--------------------------------------------
.PP
.BI "int _strcmp(const char* " "cstr" ") const throw(WyCSeg::Reply)"
.PP
    Compare data lexicographical order of *this against the string
    pointed by WyCSeg(\fIcstr\fP).

   Note: This is a function overload, documented for reference.
         See Wy::_strcmp(const WyCSeg&).
.\"--------------------------------------------
.PP
.BI "size_t _capacity(void) const throw()"
.PP
    Get the character capacity of *this for data

    For any given WyStr object str, the following equations hold:

     1. str.size()<=str._capacity()
     2. WyStr::min_capacity()<=str._capacity()<=WyStr::max_capacity()
.PP
    [\fBRet\fP] Capacity of the store for data.
.\"--------------------------------------------
.PP
.BI "WyRet _reserve(size_t " "num" ") throw()"
.PP
    Reserve at least \fInum\fP characters of capacity for data

    Capacity for data never shrink by this function.
    Use WyStr(str).swap(str) to shrink capacity of str to
    currently needed minimum(throw may occur from reallocation)
.PP
    [\fBRet\fP] Ok              Succeed
          Wym_EFBIG       \fInum\fP > max_capacity()
          Wym_ENOMEM      Not enough memory
.\"--------------------------------------------
.PP
.BI "WyRet _setsize(size_t " "nsize" ") throw()"
.PP
    Set the data size to \fInsize\fP.

    Existing characters with position less than \fInsize\fP is intact.
    
    Note: This member does not reallocate the array, 
          Application should make sure \fInsize\fP<= this->_capacity().
.PP
    [\fBRet\fP] Ok              Succeed
          Wym_EFBIG       \fInsize\fP > this->_capacity()
.\"--------------------------------------------
.PP
.BI "static size_t max_capacity(void) throw()"
.PP
    Get the maximal capacity of WyStr
.PP
    [\fBRet\fP] The maximal capacity of WyStr
.\"--------------------------------------------
.PP
.BI "static size_t min_capacity(void) throw()"
.PP
    Get the minimal capacity of WyStr
.PP
    [\fBRet\fP] The minimal capacity of WyStr
.\"--------------------------------------------
.SH "AUXILIARY FUNCTIONS"
.PP
.BI "WyStr operator +(const WyStr& " "l" ", const WyStr& " "r" ") throw(WyStr::Reply)"
.PP
    Concatenate \fIl\fP and \fIr\fP
.PP
    [\fBThrow\fP] WyStr::Reply
            Wym_EFBIG       Size of result exceeds the maximum
            Wym_ENOMEM      Not enough memory
.PP 
    [\fBRet\fP] WyStr, the concatenation of \fIl\fP and \fIr\fP
.\"--------------------------------------------
.PP
.BI "WyStr operator +(const WyStr& " "str" ", const WyCSeg& " "cs" ") throw(WyStr::Reply)"
.PP
.BI "WyStr operator +(const WyCSeg& " "cs" ", const WyStr& " "str" ") throw(WyStr::Reply)"
.PP
    Concatenate \fIstr\fP and the string pointed by \fIcs\fP
.PP
    [\fBThrow\fP] WyStr::Reply
            Wym_EFBIG       Size of result exceeds the maximum
            Wym_ENOMEM      Not enough memory
.PP 
    [\fBRet\fP] WyStr, the concatenation of \fIstr\fP,\fIcs\fP or \fIcs\fP,\fIstr\fP
.\"--------------------------------------------
.PP
.BI "WyStr operator +(const WyStr& " "str" ", char " "ch" ") throw(WyStr::Reply)"
.PP
.BI "WyStr operator +(char " "ch" ", const WyStr& " "str" ") throw(WyStr::Reply)"
.PP
    Concatenate \fIstr\fP and \fIch\fP
.PP
    [\fBThrow\fP] WyStr::Reply
            Wym_EFBIG       Size of result exceeds the maximum
            Wym_ENOMEM      Not enough memory
.PP 
    [\fBRet\fP] WyStr, the concatenation of \fIstr\fP,\fIch\fP or \fIch\fP,\fIstr\fP
.\"--------------------------------------------
.PP
.BI "bool operator ==(const WyCSeg& " "cs" ", const WyStr& " "str" ") throw()"
.PP
.BI "bool operator !=(const WyCSeg& " "cs" ", const WyStr& " "str" ") throw()"
.PP
    Test equivalence of string pointed by \fIcs\fP with \fIstr\fP
.PP
    [\fBRet\fP] true= relation holds
          false= otherwise
.PP 
    [\fBRefer\fP] ::memcmp(void*,void*,size_t)
.\"--------------------------------------------
.PP
.BI "bool operator ==(const char* " "cstr" ", const WyStr& " "str" ") throw(WyCSeg::Reply)"
.PP
.BI "bool operator !=(const char* " "cstr" ", const WyStr& " "str" ") throw(WyCSeg::Reply)"
.PP
   Test equivalence of string pointed by WyCSeg(\fIcstr\fP) with \fIstr\fP

   Note: These are function overloads, documented for reference.
         See operator ==(const WyCSeg&,const WyStr&) and
             operator !=(const WyCSeg&,const WyStr&)
.\"--------------------------------------------
.SH "SEE ALSO"
.BR wy
.BR wyret
.BR wycseg
.BR wyfilehandle
.BR wyregfile
.BR wychrfile
.BR wy_thread
.BR wytimespec
.SH NOTE
Project is in development, http://sourceforge.net/projects/libwx