wy__rdbuf.cpp

一个不错

/* Copyright is licensed under GNU LGPL.                 by I.J.Wang 2005
*/
#define WYLIB_SOURCE
#include "wy__rdbuf.h"
#include <limits.h>     // for PIPE_BUF
#include "wy_atdestroy.h"

const char Wy__RdBuf::class_name[]="Wy__RdBuf";

WyRet Wy__RdBuf::_init_dtsize(const WyByteFlow& bf)
{
 WyFileStat stt;
 const WyRet r( bf.stat(stt) );
 if(r!=Ok) {
   WY_RETURN(r);
 }
 if(stt.is_fifo()) {
   _dtsize=PIPE_BUF;
 } else {
   _dtsize=stt.sf_mode();
 }
 if(_dtsize<512) {
   _dtsize=512;  // in case unknown
 }
 return(Ok);
};

void Wy__RdBuf::_set_dtsize(Wy__RdBuf& rdq, size_t size)
{
 rdq._dtsize=size;
};

Wy__RdBuf::Wy__RdBuf(WyByteFlow* bfp)
 : _fptr(bfp), _rqbuf(), _cidx(0), _dtsize(512), _lgch((unsigned int)-1)
{
 if(bfp==NULL) {
   return;
 }
 WyRet r( _init_dtsize(*bfp) );
 if(r!=Ok) {
   WY_THROW( Reply(r) );
 }
 if((r=_rqbuf._reserve(_dtsize<<1) )!=Ok) {
   // _reserve for default _rdbuf won't have Wym_EFBIG
   WY_THROW( Reply(r) ); 
 }
};

Wy__RdBuf::~Wy__RdBuf() WY__TSPC()
{};

WyCSeg Wy__RdBuf::data(void) const WY__TSPC()
{
 return _rqbuf.cseg(_cidx);
};

WyByteFlow* Wy__RdBuf::rf_ptr(void) const WY__TSPC()
{
 return _fptr;
};

WyRet Wy__RdBuf::reset(WyByteFlow* bfp)
try {
 if(bfp==NULL) {
   _fptr=bfp;
   _rqbuf.reset();
   _cidx=0;
   _dtsize=512;
   _lgch=(unsigned int)(-1);
   return(Ok);
 }
 Wy_AtDestroy2<void,Wy__RdBuf&,size_t> 
                               rrad(Wy__RdBuf::_set_dtsize,*this,_dtsize);
 WyRet r( _init_dtsize(*bfp) );
 if(r!=Ok) {
   WY_RETURN(r);
 }
 // for now, _rqbuf capacity is only shrinked by this member
 //
 WyStr tmp;
 if((r=tmp._reserve(_dtsize<<1) )!=Ok) {
   // _reserve for default _rdbuf won't have Wym_EFBIG
   WY_RETURN(r);
 }
 rrad.release();
 _rqbuf.swap(tmp);
 _fptr=bfp;
 _cidx=0;
 _lgch=(unsigned int)(-1);
 return(Ok);
}
catch(const WyStr::Reply& e) {
 WY_RETURN(e);
}
catch(const WyRet& e) {
 WY_THROW( WyRet(e) );
};

WyRet Wy__RdBuf::getch(char& chr)
try {
 if(_fptr==NULL) {
   WY_RETURN( Wym_EFAULT);
 }
 if(_cidx>=_rqbuf.size()) {
   _cidx=0;
   _rqbuf.reset();

   // Read and append _dtsize data to _rqbuf
   //
   WyRet r;
   size_t n_rd;
   if((r=_fptr->read(_rqbuf,_dtsize,n_rd))!=Ok) {
      WY_RETURN(r);
   }
   if(n_rd==0) {
     WY_RETURN( Wym_ENOENT );
   }
 }
 chr=_rqbuf[_cidx++];
 _lgch=chr;
 return(Ok);
}
catch(const WyRet& e) {
 WY_THROW( WyRet(e) );
};

WyRet Wy__RdBuf::unget(void)
try {
 if(_fptr==NULL) {
   WY_RETURN( Wym_EFAULT);
 }
 if(_lgch==(unsigned int)-1) {
   WY_RETURN( Wym_ENOENT);
 }
 if(_cidx!=0) {
   --_cidx;
   _rqbuf[_cidx]=_lgch;
 } else {
   const WyRet r( _rqbuf.insert(0,1,_lgch) );
   if(r!=Ok) {
     WY_RETURN(r);
   }
 }
 _lgch=(unsigned int)(-1);
 return(Ok);
}
catch(const WyRet& e) {
 WY_THROW( WyRet(e) );
};

WyRet Wy__RdBuf::getdata(WyCSeg& peek, size_t count)
try {
 if(_fptr==NULL) {
   WY_RETURN( Wym_EFAULT);
 }
 WyRet r;
 size_t nlen;

 peek.reset();
 if(_cidx>=_rqbuf.size()) {
   _cidx=0;
   _rqbuf.reset();
 }
 nlen=_rqbuf.size()-_cidx;   // size of available data in the buffer
 if(nlen>=count) {
   peek.reset(_rqbuf.cseg(_cidx,count));
   _cidx+=count;
   _lgch=(unsigned int)(-1);
   return(Ok);
 }
 _rqbuf.erase(0,_cidx);
 _cidx=0;

 // Read and append max(_dtsize,count) data to _rqbuf
 //
 if((r=_fptr->read(_rqbuf,_dtsize>count?_dtsize:count,nlen))!=Ok) {
    WY_RETURN(r);
 }
 nlen=_rqbuf.size()-_cidx;   // size of available data in the buffer
 if(nlen>=count) {
   peek.reset(_rqbuf.cseg(_cidx,count));
   _cidx+=count;
 } else {
   peek.reset(_rqbuf.cseg(_cidx));
   _cidx=_rqbuf.size();
 }
 _lgch=(unsigned int)(-1);
 return(Ok);
}
catch(const WyRet& e) {
 WY_THROW( WyRet(e) );
};

WyRet Wy__RdBuf::getdata(WyCSeg& peek, size_t count, char term)
try {
 if(_fptr==NULL) {
   WY_RETURN( Wym_EFAULT);
 }
 WyRet r;
 size_t nlen;

 peek.reset();
 if(_cidx>=_rqbuf.size()) {
   _cidx=0;
   _rqbuf.reset();
 }
 if(_rqbuf.cseg().findc(&nlen,_cidx,term)==true) {
   peek.reset(_rqbuf.cseg(_cidx,nlen-_cidx+1));
   _cidx=nlen+1;
   _lgch=(unsigned int)(-1);
   return(Ok);
 }

 _rqbuf.erase(0,_cidx);
 _cidx=0;

 // Read and append max(_dtsize,count) data to _rqbuf
 //
 if((r=_fptr->read(_rqbuf,_dtsize>count?_dtsize:count,nlen))!=Ok) {
    WY_RETURN(r);
 }
 if(_rqbuf.cseg().findc(&nlen,_cidx,term)==true) {
   nlen-=_cidx;
   ++nlen;
 } else {
   nlen=_rqbuf.size()-_cidx;
 }
 if(nlen>count) {
   peek.reset(_rqbuf.cseg(_cidx,count));
   _cidx+=count;
 } else {
   peek.reset(_rqbuf.cseg(_cidx,nlen));
   _cidx+=nlen;
 }
 _lgch=(unsigned int)(-1);
 return(Ok);
}
catch(const WyRet& e) {
 WY_THROW( WyRet(e) );
};

void Wy__RdBuf::flush(size_t count)
{
 size_t nleft( _rqbuf.size()-_cidx );
 if(count<nleft) {
   _cidx+=count;
 } else {
   _cidx=0;
   _rqbuf.reset();
 }
 _lgch=(unsigned int)(-1);
};

size_t Wy__RdBuf::_rdsize(void) const WY__TSPC()
{
 return _dtsize;
};

// Note: The upper limit is detected while reading (getdata, _feed)
//
void Wy__RdBuf::_rdsize(size_t count) WY__TSPC()
{
 if(count<=0) {
   return;
 }
 _dtsize=count;
};

WyRet Wy__RdBuf::_feed(void)
{
 if(_fptr==NULL) {
   WY_RETURN( Wym_EFAULT);
 }
 if(_cidx!=0) {
   _rqbuf.erase(0,_cidx);
   _cidx=0;
 }

 // Read and append _dtsize bytes to _rqbuf
 //
 size_t n_rd;
 const WyRet r( _fptr->read(_rqbuf,_dtsize,n_rd) );
 if(r!=Ok) {
    WY_RETURN(r);
 }
 return(Ok);
};

WyRet Wy__RdBuf::_feed(size_t nbytes)
{
 if(_fptr==NULL) {
   WY_RETURN( Wym_EFAULT);
 }
 if(_cidx!=0) {
   _rqbuf.erase(0,_cidx);
   _cidx=0;
 }

 // Read and append _dtsize bytes to _rqbuf
 //
 size_t n_rd;
 const WyRet r( _fptr->read(_rqbuf,nbytes,n_rd) );
 if(r!=Ok) {
    WY_RETURN(r);
 }
 return(Ok);
};