wytimespec_mkstr.cpp

一个不错

#define WYLIB_SOURCE
#include "wytimespec.h"
#include <new>

// [Internal] Make str in float notation [-]ddd.ddd
static WyRet wy___ms_float(WyStr &str,const WyTimeSpec& num,int radix,size_t frdig)
{
 const Wy_Second tm_secs=num.second();
 const Wy_Nano tm_nano=num.nano();

 WyRet r;
 WyStr str_1;

 if(tm_nano==0) {
   if((r=Wy::_catstr(str_1,tm_secs,radix))!=Ok) {
     WY_RETURN(r);
   }
   if(frdig==0) {
     WY_RETURN( str.reset(str_1) );
     return(Ok);
   }
   if((r=str_1.append('.'))!=Ok) {
     WY_RETURN(r);
   }
   if((r=str_1.append(frdig,'0'))!=Ok) {
     WY_RETURN(r);
   }
   WY_RETURN( str.reset(str_1) );
 }

 WyStr str_2,str_tmp;

 // Make str_1 the representation of tv_sec
 //      str_2 the representation of tv_nsec/GiGa
 //
 if(tm_nano<0) {
   if(tm_secs<0) {
     if((r=Wy::_catstr(str_1,tm_secs,radix))!=Ok) {
       WY_RETURN(r);
     }
   } else {
     if(tm_secs!=0) {
       // assertion(tv_sec==0) failed
       WY_THROW( WyRet(Wym_ERANGE) );
     }
     str_1.reset("-0");  // min_capacity>2
   }
   if((r=Wy::_catstr(str_tmp,-tm_nano,radix))!=Ok) {
     WY_RETURN(r);
   }
 } else {
   if((r=Wy::_catstr(str_1,tm_secs,radix))!=Ok) {
     WY_RETURN(r);
   }
   if((r=Wy::_catstr(str_tmp,tm_nano,radix))!=Ok) {
     WY_RETURN(r);
   }
 }

 if(frdig>0) {
   // assert( str_tmp[0]!=0 )
   const int lz=WyTimeSpec::_GigaDigit10-(int)str_tmp.size();
   if(lz<0) {
     // assertion failure: 
     // str_tmp.size() should be 1-9
     WY_THROW( WyRet(Wym_ERANGE) );
   }
   if((r=str_2.append('.'))!=Ok) {
     WY_RETURN(r);
   }
   if((r=str_2.append(lz,'0'))!=Ok) {  // prepend leading zero's
     WY_RETURN(r);
   }
   if((r=str_2.append(str_tmp))!=Ok) {
     WY_RETURN(r);
   }
   if((r=str_2.resize(frdig+1,'0'))!=Ok) { // one '.' already in str_2
     WY_RETURN(r);
   }
   if((str_1.append(str_2))!=Ok) {
     WY_RETURN(r);
   }
 }
 WY_RETURN( str.reset(str_1) );
};

WyRet Wy::_mkstr(WyStr &str,const WyTimeSpec& num,int radix,size_t frdig)
try {
 if(radix==10) {
   WY_RETURN(wy___ms_float(str,num,radix,frdig));
 } else if(radix!=0) {
   WY_RETURN(Wym_EINVAL);
 } else {
   // FALLTHROGH (radix==0)
 }

 const int Radix=10;                 // float type always uses radix 10
 const Wy_Second tm_secs=num.second();
 const Wy_Nano tm_nano=num.nano();
 WyRet r;

 if(tm_secs==0) {
   WyStr str1,str2;
   if(tm_nano==0) {
     if(frdig==0) {
       WY_RETURN( str.reset("0e+0") );   // WY__EToken
     }
     str1.append("0.");
     str1.append(frdig,'0');
     str1+="e+0";   // WY__EToken
     WY_RETURN(str.reset(str1));
   }
   if(tm_nano<0) {
     str1="-";
     if((r=_mkstr(str2,-tm_nano,Radix))!=Ok) {
       WY_RETURN(r);
     }
   } else {
     if((r=_mkstr(str2,tm_nano,Radix))!=Ok) {
       WY_RETURN(r);
     }
   }
   int exp=str2.size()-WyTimeSpec::_GigaDigit10-1;
   if(exp>=0) {
     // ttv_nsec has more than 9 digits
     WY_THROW( WyRet(Wym_ERANGE) );
   }
   str1+=str2[0];
   if(frdig>0) {
     if((r=str2.resize(frdig+1,'0'))!=Ok) {
       WY_RETURN(r);
     }
     str1+='.';
     if((r=str1.append(str2.cseg(1,str2.size())))!=Ok) {
       WY_RETURN(r);
     }
   }

   str1+='e';         // WY__EToken (strange? compiler complains)
   if((r=_mkstr(str2,exp,Radix))!=Ok) {
     WY_RETURN(r);
   }
   str1+=str2;
   WY_RETURN(str.reset(str1));
 } else {
   WyStr str1,str2;
   if((r=_mkstr(str1,tm_secs,Radix))!=Ok) {
     WY_RETURN(r);
   }
   // insert '.' to str1 right after the first digit
   size_t dig0_idx;
   for(dig0_idx=0; dig0_idx<str1.size(); ++dig0_idx) {
     const char dch=str1[dig0_idx];
     if((dch>='0')&&(dch<='9')) {
       break;
     }
   }
   if(dig0_idx>=str1.size()) {
     WY_THROW( WyRet(Wym_ERANGE) );
   }
   size_t exp=str1.size()-dig0_idx-1;
   if(frdig>0) {
     if((r=str1.insert(dig0_idx+1,1,'.'))!=Ok) {
       WY_RETURN(r);
     }
     // make the fraction
     if((r=_mkstr(str2,(tm_nano<0)?-tm_nano:tm_nano,Radix))!=Ok) {
       WY_RETURN(r);
     }
     {
       const int apz=WyTimeSpec::_GigaDigit10-(int)str2.size();
       if(apz<0) {
         WY_THROW( WyRet(Wym_ERANGE) );
       }
       if((r=str2.insert(0,apz,'0'))!=Ok) {
         WY_RETURN(r);
       }
     }
     str1+=str2;
     dig0_idx+=frdig+2;   // total length str1 should be
     if((r=str1.resize(dig0_idx,'0'))!=Ok) {
       WY_RETURN(r);
     }
   }

   str2.reset("e+");   // WY__EToken
   if((r=_catstr(str2,exp,Radix))!=Ok) {
     WY_RETURN(r);
   }
   str1+=str2;
   WY_RETURN(str.reset(str1));
 }
}
catch(const WyStr::Reply& e) {
  return(e);
}
catch(const std::bad_alloc&) {
  WY_RETURN(Wym_ENOMEM); 
};

WyStr Wy::wrd(const WyTimeSpec& tm)
{
 WyStr str;
 WyRet r( Wy::_mkstr(str,tm,10,WyTimeSpec::_GigaDigit10) );
 if(r!=Ok) {
   WY_THROW( WyStr::Reply(r) );
 }
 // remove trailing zero
 for(int i=(int)str.size()-1; i>=0; --i) {
   if(str[i]!='0') {
     if(str[i]=='.') {
       i+=2;
     } else {
       ++i;
     }
     if((r=str.resize(i))!=Ok) {
       WY_THROW( WyStr::Reply(r) );
     }
     break;
   }
 }
 return(str);
};

WyStr Wy::wrd(const WyTimeSpec& num, int radix, size_t frdig)
{
 WyStr str;
 const WyRet r( Wy::_mkstr(str,num,radix,frdig) );
 if(r!=Ok) {
   WY_THROW( WyStr::Reply(r) );
 }
 return(str);
};