wycseg.h

一个不错

/* Copyright is licensed by GNU LGPL.                 by I.J.Wang 2004

   .One intent of WyCSeg is for checking null pointer once for all.
    Another is for simplying function argument, hence member function overloads
    for indicating char array.
*/
#ifndef WYCSEG_H__
#define WYCSEG_H__
#define WYCSEG_VERSION 31

#include "wyret.h"
#include <cstring>    // for std::strlen
#include <cstddef>    // for ptrdiff_t
#include <string.h>   // for memmem,memrchr

class WyCSeg {
    typedef char ValueType;
    typedef size_t SizeType;
  public:
    typedef SizeType size_type;
    typedef const ValueType value_type;
  private:
    inline WyCSeg(const ValueType* p,SizeType s1, SizeType s2)
          : _pa(p), _pz(p+ ((s1<s2)? s1:s2))
         {};
    static const ValueType* DefaultAddr;

    const ValueType* _pa;  // begin of the sub-array 
    const ValueType* _pz;  // end of the sub-array (one-past-the-last value)

  public:
    WY_THROW_REPLY;

    WyCSeg() WY__TSPC()
          : _pa(DefaultAddr), _pz(DefaultAddr) {};

    WyCSeg(const WyCSeg& s) WY__TSPC()
          : _pa(s._pa), _pz(s._pz) {};

    // Note: the trailing zero is not counted for C-type string
    WyCSeg(const ValueType* cstr)
          : _pa(cstr),_pz(cstr)
         {
           if(cstr==NULL) {
             WY_THROW( Reply(Wym_EFAULT) );
           }
           _pz=cstr+std::strlen(cstr);
         };

    WyCSeg(const ValueType* p,SizeType s) WY__TSPC(Reply)
          : _pa(p), _pz(p+s)
         {
           if(p==NULL) {
             WY_THROW( Reply(Wym_EFAULT) ); 
           }
         };

    WyCSeg(const ValueType* head, const ValueType* tail) WY__TSPC(Reply)
          : _pa(head), _pz(tail)
         {
           if((head==NULL)||(tail==NULL)) {
             WY_THROW( Reply(Wym_EFAULT) );
           }
           if(ptrdiff_t(tail-head)<(ptrdiff_t)0) {
             WY_THROW( Reply(Wym_ERANGE) );
           }
         };

    WyCSeg(WyCSeg& s, Wy::ByMove_t) WY__TSPC()
          : _pa(s._pa), _pz(s._pz) {
           #ifndef NDEBUG
            s._pa=s._pz=NULL; 
           #endif
         };

    bool is_default(void) WY__TSPC()
         {
           return _pa==_pz;
         };
    const ValueType* begin(void) const WY__TSPC()
         { return(_pa); };
    const ValueType* end(void) const WY__TSPC()
         { return _pz; };
    SizeType size(void) const WY__TSPC()
         { return(_pz-_pa); };
    const ValueType& front(void) const WY__TSPC(Reply)
         {
           if((_pz-_pa)<1) {
             WY_THROW( Reply(Wym_ENOENT) );
           }
           return *_pa; 
         };
    const ValueType& back(void) const WY__TSPC(Reply)
         {
           if((_pz-_pa)<1) {
             WY_THROW( Reply(Wym_ENOENT) );
           }
           return *(_pz-1); 
         };
    const ValueType* _move_begin(ptrdiff_t off) WY__TSPC(Reply)
         {
           const ValueType* const ptr( _pa+off );
           if(ptr>_pz) {
             WY_THROW( Reply(Wym_EINVAL) );
           }
           return _pa=ptr;
         };
    const ValueType* _move_end(ptrdiff_t off) WY__TSPC(Reply)
         {
           const ValueType* const ptr( _pz+off );
           if(ptr<_pa) {
             WY_THROW( Reply(Wym_EINVAL) );
           }
           return _pz=ptr;
         };

    void reset() WY__TSPC()
         { _pa=DefaultAddr; _pz=DefaultAddr; };
    void reset(const WyCSeg& s) WY__TSPC()
         { _pa=s._pa; _pz=s._pz; };
    WyRet reset(const ValueType* cstr)
         {
           if(cstr==NULL) {
             WY_RETURN(Wym_EFAULT);
           }
           _pa=cstr;
           _pz=cstr+std::strlen(cstr);
           return(Ok);
         };
    WyRet reset(const ValueType* p,SizeType s) WY__TSPC()
         {
           if(p==NULL) {
             WY_RETURN(Wym_EFAULT);
           }
           _pa=p;
           _pz=p+s; 
           return(Ok);
         };
    WyRet reset(const ValueType* head, const ValueType* tail) WY__TSPC()
         {
           if((head==NULL)||(tail==NULL)) {
             WY_RETURN( Wym_EFAULT );
           }
           if(tail<head) {
             WY_RETURN( Wym_ERANGE );
           }
           _pa=head;
           _pz=tail;
           return(Ok);
         };

    const WyCSeg& operator =(const WyCSeg& rhs) WY__TSPC()
         { _pa=rhs._pa; _pz=rhs._pz; return(*this); };

    const WyCSeg& operator =(const ValueType* cstr)
         {
           if(cstr==NULL) {
             WY_THROW( Reply(Wym_EFAULT) );
           }
           _pa=cstr;
           _pz=cstr+std::strlen(cstr);
           return(*this);
         };

    void swap(WyCSeg& ano) WY__TSPC()
         {
           Wy__Base::vswap(_pa,ano._pa);
           Wy__Base::vswap(_pz,ano._pz);
         };

    const ValueType& operator[](SizeType idx) const WY__TSPC(Reply)
         {
           if(idx>=(SizeType)(_pz-_pa)) {
             WY_THROW( Reply(Wym_EINVAL) );
           }
           return _pa[idx]; 
         };

    const WyCSeg cseg(SizeType idx) const WY__TSPC(Reply)
         {
           if(idx>static_cast<SizeType>(_pz-_pa)) {
             WY_THROW( Reply(Wym_EINVAL) );
           }
           return WyCSeg(_pa+idx,_pz);
         };
    const WyCSeg cseg(SizeType idx, SizeType s) const WY__TSPC(Reply)
         {
           const SizeType seg_len(_pz-_pa);
           if(idx>seg_len) {
             WY_THROW( Reply(Wym_EINVAL) );
           }
           return WyCSeg(_pa+idx,seg_len-idx,s);
         };

    bool find(SizeType* res,SizeType idx,const WyCSeg& cs) const WY__TSPC();
    bool findc(SizeType* res,SizeType idx,ValueType ch) const WY__TSPC();
    bool findc(SizeType* res,SizeType idx,const WyCSeg& cs) const WY__TSPC();
    bool findc_not(SizeType* res,SizeType idx,ValueType ch) const WY__TSPC();
    bool findc_not(SizeType* res,SizeType idx,const WyCSeg& cs) const WY__TSPC();

    bool rfind(SizeType* res,SizeType idx,const WyCSeg& cs) const WY__TSPC();
    bool rfindc(SizeType* res,SizeType idx,ValueType ch) const WY__TSPC();
    bool rfindc(SizeType* res,SizeType idx,const WyCSeg& cs) const WY__TSPC();
    bool rfindc_not(SizeType* res,SizeType idx,ValueType ch) const WY__TSPC();
    bool rfindc_not(SizeType* res,SizeType idx,const WyCSeg& cs) const WY__TSPC();
         
    bool is_overlap(const WyCSeg& s) const WY__TSPC()
         {
           if((_pa==_pz)||(s._pa==s._pz)) {
             return(false);
           }
           if(_pa<s._pa) {
             return(_pz>s._pa);
           } else if(_pa>s._pa) {
             return(_pa<s._pz);
           } else {
             return(true);
           }
         };

    int _strcmp(const WyCSeg& cs) const WY__TSPC()
         {
           const WyCSeg::size_type Lft(this->size());
           const WyCSeg::size_type Rit(cs.size());
           if(Lft<Rit) {
             return std::memcmp(this->begin(),cs.begin(),Lft)<=0 ? -1: 1;
           } else if(Lft>Rit) {
             return std::memcmp(this->begin(),cs.begin(),Rit)>=0 ?  1:-1;
           } else {
             return std::memcmp(this->begin(),cs.begin(),Lft);
           }
         };
    int _strcmp(const char* cstr) const
         {
           if(cstr==NULL) {
             WY_THROW( Reply(Wym_EFAULT) );
           }
           const WyCSeg::size_type Lft(this->size());
           const WyCSeg::size_type Rit(std::strlen(cstr));
           if(Lft<Rit) {
             return std::memcmp(this->begin(),cstr,Lft)<=0 ? -1: 1;
           } else if(Lft>Rit) {
             return std::memcmp(this->begin(),cstr,Rit)>=0 ?  1:-1;
           } else {
             return std::memcmp(this->begin(),cstr,Lft);
           }
         };

    bool operator ==(const WyCSeg& rhs) const WY__TSPC()
         {
           if((_pz-_pa)!=(rhs._pz-rhs._pa)) {
             return(false);
           }
           return std::memcmp(_pa,rhs._pa,_pz-_pa)==0;
         };
    bool operator !=(const WyCSeg& rhs) const WY__TSPC()
         {
           if((_pz-_pa)!=(rhs._pz-rhs._pa)) {
             return(true);
           }
           return std::memcmp(_pa,rhs._pa,_pz-_pa)!=0;
         };
    bool operator ==(const ValueType* cstr) const
         {
           if(cstr==NULL) {
             WY_THROW( Reply(Wym_EFAULT) );
           }
           const SizeType clen( std::strlen(cstr) );
           if(clen!=(SizeType)(_pz-_pa)) {
             return(false);
           }
           return std::memcmp(_pa,cstr,clen)==0;
         };
    bool operator !=(const ValueType* cstr) const
         { return !this->operator==(cstr); };
};

inline bool operator==(const char* lhs, const WyCSeg& rhs)
 { return rhs==lhs; };

inline bool operator!=(const char* lhs, const WyCSeg& rhs)
 { return rhs!=lhs; };

namespace Wy {

 // Note: This function is in case source code really uses two pointers to save
 //       two explicit calls strlen(..).
 //       Functionality simulates Wy::_strcmp(const WyCSeg&,const WyCSeg&)
 //
 inline int _strcmp(const char* s1, const char* s2)
 {
   return WyCSeg(s1)._strcmp(s2);
 };

 inline int _strcmp(const char* s1, const WyCSeg& s2)
 { return WyCSeg(s1)._strcmp(s2); };
 inline int _strcmp(const WyCSeg& s1, const WyCSeg& s2) WY__TSPC()
 { return s1._strcmp(s2); };
 inline int _strcmp(const WyCSeg& s1, const char* cstr)
 { return s1._strcmp(cstr); };

 inline void _strcpy(char* dest, WyCSeg src)
 { std::memcpy(dest,src.begin(),src.size()); };

 inline void _strmove(char* dest, char* src, size_t n)
 { std::memmove(dest,src,n); };

 inline const char* _strchr(const WyCSeg& s, char c) WY__TSPC()
 { return static_cast<const char*>(std::memchr(s.begin(), c, s.size())); };

#ifdef _GNU_SOURCE
 inline const char* _strrchr(const WyCSeg& s, char c) WY__TSPC()
 { return static_cast<const char*>(::memrchr(s.begin(), c, s.size())); };

 inline const char* _strstr(const WyCSeg& hstk, const WyCSeg& ndl) WY__TSPC()
 { return static_cast<const char*>(::memmem(hstk.begin(),hstk.size(), ndl.begin(), ndl.size())); };
#endif

};

#endif   // End WYCSEG_H__