wy__hstr.cpp

一个不错

 return(Ok);
};

bool Wy__HStr::find(size_type* res,value_type ch) const WY__TSPC()
{
 const value_type* const p=static_cast<const value_type*>(std::memchr(_data_buf(this),ch,_m_dlen));
 if(p==NULL) {
   return(false);
 }
#ifdef WY_DEBUG
   if(*p!=ch) {
     WY_TERMINATE("");
   }
#endif
 if(res!=NULL) {
   *res=p-_data_buf(this);
 }
 return(true);
};

bool Wy__HStr::rfind(size_type* res,value_type ch) const WY__TSPC()
{
 const value_type* const p=static_cast<const value_type*>( memrchr(_data_buf(this),ch,_m_dlen));
 if(p==NULL) {
   return(false);
 }
#ifdef WY_DEBUG
   if(*p!=ch) {
     WY_TERMINATE("");
   }
#endif
 if(res!=NULL) {
   *res=p-_data_buf(this);
 }
 return(true);
};

bool Wy__HStr::find(size_type* res,size_type idx,value_type ch) const WY__TSPC()
{
 if(idx>=_m_dlen) {
   return(false);
 }
 const value_type* const p=static_cast<const value_type*>( std::memchr(_data_buf(this)+idx,ch,_m_dlen-idx));
 if(p==NULL) {
   return(false);
 }
#ifdef WY_DEBUG
   if(*p!=ch) {
     WY_TERMINATE("");
   }
#endif
 if(res!=NULL) {
   *res=p-_data_buf(this);
 }
 return(true);
};

bool Wy__HStr::rfind(size_type* res,size_type idx,value_type ch) const WY__TSPC()
{
 if(_m_dlen==0) {
   return(false);
 }
 const size_type rs( (idx>=_m_dlen)? _m_dlen:idx+1 );
 const value_type* const p=static_cast<const value_type*>( memrchr(_data_buf(this),ch,rs));
 if(p==NULL) {
   return(false);
 }
#ifdef WY_DEBUG
   if(*p!=ch) {
     WY_TERMINATE("");
   }
#endif
 if(res!=NULL) {
   *res=p-_data_buf(this);
 }
 return(true);
};

bool Wy__HStr::find(size_type* res,size_type idx,const WyCSeg& cs) const WY__TSPC()
{
 if(idx>=_m_dlen) {
   return(false);
 }
 const size_type csize( cs.size() );
 if(csize<=0) {
   return(false); // note: memcmp indicates "" is found
 }

 signed int fcnt(  (signed int)_m_dlen -(signed int)idx
                  -(signed int)csize   +(signed int)1 );
 const char* const cptr( cs.begin() );
 for(size_type fidx(idx); fcnt>0; --fcnt,++fidx) {
   if(::memcmp(_data_buf(this)+fidx,cptr,csize)==0) {
     if(res!=NULL) {
       *res=fidx;
     }
     return(true);
   }
 }
 return(false);
};

bool Wy__HStr::rfind(size_type* res, const WyCSeg& cs) const WY__TSPC()
{
 const size_type csize( cs.size() );
 if(csize<=0) {
   return(false); // note: memcmp indicates "" is found
 }
 signed int fidx= (signed int)_m_dlen -(signed int)csize;
 // note: fidx may be negative

 const char* const cptr( cs.begin() );
 for( ; fidx>=0; --fidx) {
   if(::memcmp(_data_buf(this)+fidx,cptr,csize)==0) {
     if(res!=NULL) {
       *res=fidx;
     }
     return(true);
   }
 }
 return(false);
};

bool Wy__HStr::rfind(size_type* res,size_type idx,const WyCSeg& cs) const WY__TSPC()
{
 const size_type csize( cs.size() );
 if(csize<=0) {
   return(false); // note: memcmp indicates "" is found
 }
 signed int fidx= (signed int)_m_dlen -(signed int)csize;
 if(fidx>(signed int)idx) {
   fidx=idx;
 }
 // note: fidx may be negative

 const char* const cptr( cs.begin() );
 for( ; fidx>=0; --fidx) {
   if(::memcmp(_data_buf(this)+fidx,cptr,csize)==0) {
     if(res!=NULL) {
       *res=fidx;
     }
     return(true);
   }
 }
 return(false);
};

bool Wy__HStr::_find_not(size_type* res,size_type idx,value_type ch) const WY__TSPC()
{
 for( ; idx<_m_dlen; ++idx) {
   if(_data_buf(this)[idx]!=ch) {
     if(res!=NULL) {
       *res=idx;
     }
     return(true);
   }
 }
 return(false);
};

bool Wy__HStr::_find_not(size_type* res,size_type idx,const WyCSeg& cs) const WY__TSPC()
{
 for( ; idx<_m_dlen; ++idx) {
   if(std::memchr(cs.begin(),_data_buf(this)[idx],cs.size())==NULL) {
     if(res!=NULL) {
       *res=idx;
     }
     return(true);
   }
 }
 return(false);
};

bool Wy__HStr::_find_in(size_type* res,size_type idx,const WyCSeg& cs) const WY__TSPC()
{
 for( ; idx<_m_dlen; ++idx) {
   if(std::memchr(cs.begin(),_data_buf(this)[idx],cs.size())!=NULL) {
     if(res!=NULL) {
       *res=idx;
     }
     return(true);
   }
 }
 return(false);
};

bool Wy__HStr::_rfind_not(size_type* res,size_type idx,value_type ch) const WY__TSPC()
{
 if(idx>=_m_dlen) {
   if(_m_dlen<=0) {
     return(false);
   }
   idx=_m_dlen-1;
 }
 for(signed int i=idx; i>=0; --i) {
   if(_data_buf(this)[i]!=ch) {
     if(res!=NULL) {
       *res=i;
     }
     return(true);
   }
 }
 return(false);
};

bool Wy__HStr::_rfind_not(size_type* res,size_type idx, const WyCSeg& cs) const WY__TSPC()
{
 if(_m_dlen==0) {
   return(false);
 }
 if(idx>=_m_dlen) {
   idx=_m_dlen-1;
 }
 for(int i=idx ; i>=0; --i) {
   if(std::memchr(cs.begin(),_data_buf(this)[i],cs.size())==NULL) {
     if(res!=NULL) {
       *res=i;
     }
     return(true);
   }
 }
 return(false);
};

bool Wy__HStr::_rfind_in(size_type* res,size_type idx, const WyCSeg& cs) const WY__TSPC()
{
 if(_m_dlen==0) {
   return(false);
 }
 if(idx>=_m_dlen) {
   idx=_m_dlen-1;
 }
 for(int i=idx ; i>=0; --i) {
   if(std::memchr(cs.begin(),_data_buf(this)[i],cs.size())!=NULL) {
     if(res!=NULL) {
       *res=i;
     }
     return(true);
   }
 }
 return(false);
};

WyRet Wy__HStr::insert(size_type idx,const WyCSeg& cs) WY__TSPC()
{
 if(idx>_m_dlen) {
   WY_RETURN(Wym_EINVAL);
 }
 const size_type csize( cs.size() );
 const size_type rs=_m_dlen+csize;
 if(csize<6) {
   if(rs>_capacity()) {
     WY_RETURN(Wym_EFBIG);  // overflow
   }
   char* des_ptr( _data_buf(this)+idx );
   if(cs.is_overlap( WyCSeg(des_ptr,rs-idx+sizeof(value_type)) )) {
     // note: overlap is reported after EFBIG
     WY_RETURN(Wym_ELOOP);
   }
   const size_type mv_len=_m_dlen-idx;
   if(mv_len<8) {
     value_type* s_ptr(_data_buf(this)+_m_dlen-1);  // last char of src
     value_type* d_ptr(s_ptr+csize);                // last char of des

     WY__BCOPY(d_ptr,s_ptr,mv_len);
     s_ptr=const_cast<value_type*>(cs.begin());
     WY__FCOPY(des_ptr,s_ptr,csize);
   } else {
     const value_type* s_ptr(cs.begin());
     value_type* d_ptr(des_ptr+csize);
     std::memmove(d_ptr,des_ptr,mv_len);
     WY__FCOPY(des_ptr,s_ptr,csize);
   }
 } else {
   if((csize>_capacity())||(rs>_capacity())) {
     WY_RETURN(Wym_EFBIG);
   }
   char* des_ptr( _data_buf(this)+idx );
   if(cs.is_overlap( WyCSeg(des_ptr,rs-idx+sizeof(value_type)) )) {
     // note: overlap is reported after EFBIG
     WY_RETURN(Wym_ELOOP);
   }
   const size_type mv_len=_m_dlen-idx;
   if(mv_len<8) {
     value_type* s_ptr(_data_buf(this)+_m_dlen-1);  // last char of src
     value_type* d_ptr(s_ptr+csize);                // last char of des
     WY__BCOPY(d_ptr,s_ptr,mv_len);
   } else {
     std::memmove(des_ptr+csize,des_ptr,mv_len);
   }

   std::memcpy(des_ptr,cs.begin(),csize);
 }
 _m_dlen=rs;
 _data_buf(this)[rs]=EOS;
 return(Ok);
};

WyRet Wy__HStr::insert(size_type idx,const Wy__HStr& str) WY__TSPC()
{
 if(idx>_m_dlen) {
   WY_RETURN(Wym_EINVAL);
 }
 const size_type csize( str.size() );
 const size_type rs=_m_dlen+csize;
 if(csize<6) {
   if(rs>_capacity()) {
     WY_RETURN(Wym_EFBIG);  // overflow
   }
   char* des_ptr( _data_buf(this)+idx );
   if(str.cseg().is_overlap( WyCSeg(des_ptr,rs-idx+sizeof(value_type)) )) {
     // note: overlap is reported after EFBIG
     WY_RETURN(Wym_ELOOP);
   }
   const size_type mv_len=_m_dlen-idx;
   if(mv_len<8) {
     value_type* s_ptr(_data_buf(this)+_m_dlen-1);  // last char of src
     value_type* d_ptr(s_ptr+csize);                // last char of des

     WY__BCOPY(d_ptr,s_ptr,mv_len);
     s_ptr=const_cast<value_type*>(_data_buf(&str));
     WY__FCOPY(des_ptr,s_ptr,csize);
   } else {
     const value_type* s_ptr(_data_buf(&str));
     value_type* d_ptr(des_ptr+csize);
     std::memmove(d_ptr,des_ptr,mv_len);
     WY__FCOPY(des_ptr,s_ptr,csize);
   }
 } else {
   if(rs>_capacity()) {
     WY_RETURN(Wym_EFBIG);
   }
   char* des_ptr( _data_buf(this)+idx );
   if(str.cseg().is_overlap( WyCSeg(des_ptr,rs-idx+sizeof(value_type)) )) {
     // note: overlap is reported after EFBIG
     WY_RETURN(Wym_ELOOP);
   }
   const size_type mv_len=_m_dlen-idx;
   if(mv_len<8) {
     value_type* s_ptr(_data_buf(this)+_m_dlen-1);  // last char of src
     value_type* d_ptr(s_ptr+csize);                // last char of des
     WY__BCOPY(d_ptr,s_ptr,mv_len);
   } else {
     std::memmove(des_ptr+csize,des_ptr,mv_len);
   }

   std::memcpy(des_ptr,_data_buf(&str),csize);
 }
 _m_dlen=rs;
 _data_buf(this)[rs]=EOS;
 return(Ok);
};

WyRet Wy__HStr::insert(size_type idx,size_type cnum,value_type ch) WY__TSPC()
{
 if(idx>_m_dlen) {
   WY_RETURN(Wym_EINVAL);
 }
 if(cnum>_capacity()) {
   WY_RETURN(Wym_EFBIG);
 }
 const size_type rs=_m_dlen+cnum;
 if(rs>_capacity()) {
   WY_RETURN(Wym_EFBIG);  // overflow
 }
 char* des_ptr( _data_buf(this)+idx );
 const size_type mv_len=_m_dlen-idx;
 if(mv_len<8) {
   value_type* s_ptr(_data_buf(this)+_m_dlen-1);  // last char of src
   value_type* d_ptr(s_ptr+cnum);                 // last char of des
   WY__BCOPY(d_ptr,s_ptr,mv_len);
 } else {
   std::memmove(des_ptr+cnum,des_ptr,mv_len);
 }
 std::memset(des_ptr,ch,cnum);
 _m_dlen=rs;
 _data_buf(this)[rs]=EOS;
 return(Ok);
};

WyRet Wy__HStr::erase(size_type idx) WY__NOTHROW__
{
 if(idx>_m_dlen) {
   WY_RETURN(Wym_EINVAL);
 }
 _m_dlen=idx;
 _data_buf(this)[_m_dlen]=EOS;
 return(Ok);
};

WyRet Wy__HStr::erase(size_type idx,size_type len) WY__TSPC()
{
 if(idx>_m_dlen) {
   WY_RETURN(Wym_EINVAL);
 }
 const size_type zidx=idx+len;
 if(zidx>=_m_dlen) {
   _m_dlen=idx;
   _data_buf(this)[_m_dlen]=EOS;
   return(Ok);
 }
 std::memmove(_data_buf(this)+idx,_data_buf(this)+zidx,_m_dlen-zidx);
 _m_dlen-=len;
 _data_buf(this)[_m_dlen]=EOS;
 return(Ok);
};

WyRet Wy__HStr::resize(size_type num,value_type ch) WY__TSPC()
{
 // Note: Shrink should not cause error
 if(num>_capacity()) {
   WY_RETURN(Wym_EFBIG);
 }
 if(num>_m_dlen) {
   std::memset(_data_buf(this)+_m_dlen,ch,num-_m_dlen);
 }
 _m_dlen=num;
 _data_buf(this)[_m_dlen]=EOS;
 return(Ok);
};

WyRet Wy__HStr::replace(size_type idx,size_type num,const WyCSeg& cs) WY__TSPC()
{
 const size_type csize( cs.size() );
 if(csize>_capacity()) {
   WY_RETURN(Wym_EFBIG);
 }
 if(idx>_m_dlen) {
   WY_RETURN(Wym_EINVAL);
 }
 size_type idx2=idx+num;
 if(idx2>_m_dlen) {
   idx2=_m_dlen;
 }
 const size_type rsiz=((_m_dlen-idx2)+idx)+csize;
 if(rsiz>_capacity()) {
   WY_RETURN(Wym_EFBIG);
 }

 char* cptr( _data_buf(this)+idx );
 if(cs.is_overlap( WyCSeg(cptr,_m_dcap-idx+sizeof(value_type)) )) {
   // note: overlap is reported after EFBIG
   WY_RETURN(Wym_ELOOP);
 }
 std::memmove(cptr+csize,_data_buf(this)+idx2,_m_dlen-idx2);
 std::memcpy(cptr,cs.begin(),csize);
 _m_dlen=rsiz;
 _data_buf(this)[_m_dlen]=EOS;
 return(Ok);
};

WyRet Wy__HStr::replace(size_type idx,size_type num,size_type cnum,value_type ch) WY__TSPC()
{
 if(cnum>_capacity()) {
   WY_RETURN(Wym_EFBIG);
 }
 if(idx>_m_dlen) {
   WY_RETURN(Wym_EINVAL);
 }
 size_type idx2=idx+num;
 if(idx2>_m_dlen) {
   idx2=_m_dlen;
 }
 const size_type rsiz=((_m_dlen-idx2)+idx)+cnum;
 if(rsiz>_capacity()) {
   WY_RETURN(Wym_EFBIG);
 }
 char* cptr( _data_buf(this)+idx );
 std::memmove(cptr+cnum,_data_buf(this)+idx2,_m_dlen-idx2);
 std::memset(cptr,ch,cnum);
 _m_dlen=rsiz;
 _data_buf(this)[_m_dlen]=EOS;
 return(Ok);
};

int Wy__HStr::_strcmp(const Wy__HStr& str) const WY__TSPC()
{
 const int lft=_m_dlen;
 const int rit=str._m_dlen;
 if(lft<rit) {
   return std::memcmp(_data_buf(this),_data_buf(&str),lft)<=0 ? -1: 1;
 } else if(lft>rit) {
   return std::memcmp(_data_buf(this),_data_buf(&str),rit)>=0 ?  1:-1;
 } else {
   return std::memcmp(_data_buf(this),_data_buf(&str),lft);
 }
};

int Wy__HStr::_strcmp(const WyCSeg& cs) const WY__TSPC()
{
 const int lft=_m_dlen;
 const int rit=cs.size();
 if(lft<rit) {
   return std::memcmp(_data_buf(this),cs.begin(),lft)<=0 ? -1: 1;
 } else if(lft>rit) {
   return std::memcmp(_data_buf(this),cs.begin(),rit)>=0 ?  1:-1;
 } else {
   return std::memcmp(_data_buf(this),cs.begin(),lft);
 }
};

WyRet Wy__HStr::copyto(size_type* rlen,value_type* buf,size_type blen,size_type idx) const WY__TSPC()
{
 if(buf==NULL) {
   WY_RETURN(Wym_EFAULT);
 }
 if(idx>_m_dlen) {
   WY_RETURN(Wym_EINVAL);
 }
 size_type rs=_m_dlen-idx;
 if(rs>blen) {
   rs=blen;
 }
 if( WyCSeg(buf,rs).is_overlap( WyCSeg(_data_buf(this),_m_dlen+1) ) ) {
   // note: overlap is reported after EFBIG
   WY_RETURN(Wym_ELOOP);
 }
 std::memcpy(buf,_data_buf(this)+idx,rs);
 if(rlen!=NULL) {
   *rlen=rs;
 }
 return(Ok);
};

WyRet Wy__HStr::_setsize(size_t nsize) WY__NOTHROW__
{
 if(nsize>_capacity()) {
   WY_RETURN(Wym_EFBIG);
 }
 _m_dlen=nsize; 
 _data_buf(this)[_m_dlen]=EOS;
 return(Ok);
};

//---------------------------------------------------------------------------