wy_uty.cpp

一个不错

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

   operators <<,>> for WyByteFlow
   Simulate std::cin/cout/cerr usage syntax
*/

#define WYLIB_SOURCE
#include "wy_uty.h"
#include <unistd.h>

WyRet Wy::full_write(WyByteFlow& bf, const void* buf, size_t blen, size_t& n_wr)
{
 WyRet r;
 const char* wr_ptr= static_cast<const char*>(buf);
 size_t btw( blen );  // byte to write

 n_wr=0;
 for(;;) {
   size_t n;
   try {
     r=bf.write(wr_ptr,btw,n);
     n_wr+=n;
   }
   catch(...) {
     n_wr+=n;
     throw;
   };
   if(r!=Ok) {
     WY_RETURN(r);
   }
   if(n==btw) {
     return(Ok);
   }

   #ifdef WY_DEBUG
   if(n>btw) {
     WY_TERMINATE("");
   }
   #endif

   wr_ptr+=n;
   btw-=n;
 }
 // UNREACHABLE
};

WyRet Wy::full_read(WyByteFlow& bf, void* buf, size_t blen, size_t& n_read)
{
 WyRet r;
 size_t btr=blen;
 char *bptr=static_cast<char*>(buf);

 n_read=0;    // n_read always reports the bytes read
 for(;;) {
   size_t n;
   try {
     r= bf.read(bptr,btr,n);
     n_read+=n;
   }
   catch(...) {
     n_read+=n;
     throw;
   };
   if(r!=Ok) {
     WY_RETURN(r);
   }
   if((n==btr)||(n==0)) {
     return(Ok);
   }
   #ifdef WY_DEBUG
   if(n>btr) {
     WY_TERMINATE("");
   }
   #endif

   bptr+=n;
   btr-=n;
 }
 // UNREACHABLE
};

WyRet Wy::full_read(WyByteFlow& bf, WyStr& buf, size_t count)
{
 WyRet r;

 if((r=buf._reserve(count))!=Ok) {
   WY_RETURN(r);
 }

 size_t n_rd=0;
 size_t btr=count;
 char *bptr=&buf[0];
 for(;;) {
   size_t n;
   try {
     r= bf.read(bptr,btr,n);
     n_rd+=n;
     buf._setsize(n_rd);   // no failure
   }
   catch(...) {
     n_rd+=n;
     buf._setsize(n_rd);   // no failure
     throw;
   };
   if(r!=Ok) {
     WY_RETURN(r);
   }
   if((n==btr)||(n==0)) {
     return(Ok);
   }
   #ifdef WY_DEBUG
   if(n>btr) {
     WY_TERMINATE("");
   }
   #endif

   bptr+=n;
   btr-=n;
 }
 // UNREACHABLE
};

WyByteFlow& operator <<(WyByteFlow& os, const WyStr& str)
{
 size_t n_wr;
 WyRet r( Wy::full_write(os,str.data(),str.size(),n_wr) );
 if(r!=Ok) {
   WY_THROW( WyByteFlow::Reply(r) );
 }
 if(n_wr!=str.size()) {
   WY_THROW( WyByteFlow::Reply(Wym_EIO) );
 }
 return(os);
};

WyByteFlow& operator <<(WyByteFlow& os, WyCSeg str)
{
 size_t n_wr;
 WyRet r( Wy::full_write(os,str.begin(),str.size(),n_wr) );
 if(r!=Ok) {
   WY_THROW( WyByteFlow::Reply(r) );
 }
 if(n_wr!=str.size()) {
   WY_THROW( WyByteFlow::Reply(Wym_EIO) );
 }
 return(os);
};

WyByteFlow& operator <<(WyByteFlow& os, const char* cstr)
{
 const size_t slen( std::strlen(cstr) );
 size_t n_wr;
 WyRet r( Wy::full_write(os,cstr,slen,n_wr) );
 if(r!=Ok) {
   WY_THROW( WyByteFlow::Reply(r) );
 }
 if(n_wr!=slen) {
   WY_THROW( WyByteFlow::Reply(Wym_EIO) );
 }
 return(os);
};

WyByteFlow& operator <<(WyByteFlow& os, char* cstr)
{
 const size_t slen( std::strlen(cstr) );
 size_t n_wr;
 WyRet r( Wy::full_write(os,cstr,slen,n_wr) );
 if(r!=Ok) {
   WY_THROW( WyByteFlow::Reply(r) );
 }
 if(n_wr!=slen) {
   WY_THROW( WyByteFlow::Reply(Wym_EIO) );
 }
 return(os);
};

WyByteFlow& operator <<(WyByteFlow& os, char ch)
{
 size_t n_wr;
 WyRet r( Wy::full_write(os,&ch,sizeof(ch),n_wr) );
 if(r!=Ok) {
   WY_THROW( WyByteFlow::Reply(r) );
 }
 if(n_wr!=1) {
   WY_THROW( WyByteFlow::Reply(Wym_EIO) );
 }
 return(os);
};

WyByteFlow& operator <<(WyByteFlow& os, const void* p)
try {
 const static WyCSeg HexHd("0x",2);
 WyRet r;
 size_t n_wr;
 WyStr str(HexHd);
 if((r=Wy::_catstr(str,(unsigned int)p,int(16)))!=Ok) {
   WY_THROW( WyByteFlow::Reply(r) );
 }
 if((r=Wy::full_write(os,str.data(),str.size(),n_wr))!=Ok) {
   WY_THROW( WyByteFlow::Reply(r) );
 }
 if(n_wr!=str.size()) {
   WY_THROW( WyByteFlow::Reply(Wym_EIO) );
 }
 return(os);
}
catch(const WyStr::Reply& e) {
 WY_THROW( WyByteFlow::Reply(e) );   // only Wym_ENOMEM possible
};

//-------------------------
template <typename NumT>
inline WyByteFlow& wy__put_value(WyByteFlow& bf, NumT num)
try {
 WyRet r;
 WyStr str;
 size_t n_wr;
 if((r=Wy::_mkstr(str,num,int(10)))!=Ok) {
   WY_THROW( WyByteFlow::Reply(r) );
 }
 if((r=Wy::full_write(bf,str.data(),str.size(),n_wr))!=Ok) {
   WY_THROW( WyByteFlow::Reply(r) );
 }
 if(n_wr!=str.size()) {
   WY_THROW( WyByteFlow::Reply(Wym_EIO) );
 }
 return(bf);
}
catch(const WyStr::Reply& e) {
 WY_THROW( WyByteFlow::Reply(e) );
};

WyByteFlow& operator <<(WyByteFlow& bf, signed char num)
{ return wy__put_value(bf,num); };
WyByteFlow& operator <<(WyByteFlow& bf, signed short num)
{ return wy__put_value(bf,num); };
WyByteFlow& operator <<(WyByteFlow& bf, signed int num)
{ return wy__put_value(bf,num); };
WyByteFlow& operator <<(WyByteFlow& bf, signed long num)
{ return wy__put_value(bf,num); };
WyByteFlow& operator <<(WyByteFlow& bf, signed long long num)
{ return wy__put_value(bf,num); };

WyByteFlow& operator <<(WyByteFlow& bf, unsigned char num)
{ return wy__put_value(bf,num); };
WyByteFlow& operator <<(WyByteFlow& bf, unsigned short num)
{ return wy__put_value(bf,num); };
WyByteFlow& operator <<(WyByteFlow& bf, unsigned int num)
{ return wy__put_value(bf,num); };
WyByteFlow& operator <<(WyByteFlow& bf, unsigned long num)
{ return wy__put_value(bf,num); };
WyByteFlow& operator <<(WyByteFlow& bf, unsigned long long num)
{ return wy__put_value(bf,num); };

WyByteFlow& operator <<(WyByteFlow& bf, float num)
{ return wy__put_value(bf,num); };
WyByteFlow& operator <<(WyByteFlow& bf, double num)
{ return wy__put_value(bf,num); };

//-------------------------
WyByteFlow& operator >>(WyByteFlow& bf, WyStr& str)
{
 str.reset();
 size_t n_rd;
 WyRet r( bf.read(str,str._capacity(),n_rd) );
 if(r!=Ok) {
   WY_THROW( WyByteFlow::Reply(r) );
 }
 if(n_rd!=str.size()) {
   WY_THROW( WyByteFlow::Reply(Wym_EIO) );
 }
 return(bf);
};

WyByteFlow& operator >>(WyByteFlow& bf, char& ch)
{
 size_t n_rd;
 WyRet r( bf.read(&ch,sizeof(ch),n_rd) );
 if(r!=Ok) {
   WY_THROW( WyByteFlow::Reply(r) );
 }
 if(n_rd!=sizeof(ch)) {
   if(n_rd==0) {
     WY_THROW( WyByteFlow::Reply(Wym_ENOENT) );
   }
   WY_THROW( WyByteFlow::Reply(Wym_EIO) );
 }
 return(bf);
};

//#include <wyiovec.h>
//WyByteFlow& operator >>(WyByteFlow& bf, WyIOVec iov)
//{
//};

WyRet Wy::gethostname(WyStr& buf)
try {
#ifndef HOST_NAME_MAX      // man. indicated this name but not found
#define HOST_NAME_MAX 128
#endif
 WyRet r;
 WyStr tmp;
 if((r=tmp.resize(HOST_NAME_MAX))!=Ok) {
   WY_RETURN(r);
 }
 const int v=::gethostname(&tmp[0],tmp.size()+1); // guess there is one extra
                                                  // byte at the end of data
 if(v!=0) {
   WY_RETURN(errno);
 }
 if((r=tmp.resize( ::strlen(tmp.data()) ))!=Ok) {
   WY_THROW(r);
 }
 buf.swap(tmp);
 return(Ok);
}
catch(const WyStr::Reply& e) {
  return(e);
};