fmtd.h

Go to the documentation of this file.

#ifndef CXX_fmtd_header_included_p
#define CXX_fmtd_header_included_p

#include <iostream>
#include <portable_io.h>
#include <cxxtls/classTraits.h>

namespace cxxtls
{



namespace fmtdalgo
{
  // you can't specialize a template inside a class body, so this namespace is required 
  // to perform the specializations below.

  // helper --------------------------------------------------------------------
  inline void int2ascii(char *&scan, int d)
  {
    char buffer[26];

    char *end = &buffer[25];

    *end = 0;

    char *ptr = end;

    while(d)
    {
      *(--ptr) = '0' + (d%10);
      d /= 10;
    }

    while(ptr != end)
      *scan++ = *ptr++;


  }

  // helper --------------------------------------------------------------------
  inline void setup(char *&scan, 
                    int    fieldWidth, 
                    int    precision, 
                    bool   lJust, 
                    bool   padding, 
                    char   pad
                   )
  {
       *scan++ = '%';

       if(lJust && fieldWidth != 0)
         *scan++ = '-';

       if(!lJust && pad == '0')
         *scan++ = '0';

       if(fieldWidth)
         int2ascii(scan, fieldWidth);

       if(precision)
       {
         *scan++ = '.';
         int2ascii(scan, precision);
       }
  }

  // formatter --------------------------------------------------------------------
  template<class T, int fieldWidth, int precision, int lJust, int padding, int pad, int base, int errchr>
  struct StringFormatter
  {

    size_t operator()(std::string const &v,
                      char              *buffer,
                      int                buffsize
                     )
    {
      return (*this)(v.c_str(), buffer, buffsize);
    }


    size_t operator() (char const *v,
                     char      *buffer, 
                     int        buffsize
                    )
    {
       char cs[100];

       char *scan = &cs[0];

       setup(scan,
             fieldWidth, 
             precision, 
             lJust, 
             padding, 
             pad
            );


       *scan++ = 's';

       *scan++ = 0;

       size_t bytesWritten = snprintf(buffer, buffsize, cs, v);

       size_t errorThreshold = buffsize;

       if(fieldWidth)
         errorThreshold = fieldWidth;

       if( bytesWritten > errorThreshold)
       {
         std::fill_n(buffer, fieldWidth, errchr);
         buffer[fieldWidth] = 0;

         bytesWritten = fieldWidth;
       }

       return bytesWritten;

    }

  };



  // -------------------------------------------------------------------------
  template<class T, int fieldWidth, int precision, int lJust, int padding, int pad, int base, int errchr>
  struct FloatFormatter
  {
    size_t operator() (T const   &v, 
                     char      *buffer, 
                     int        buffsize
                    )
    {
       char cs[100];

       char *scan = &cs[0];

       setup(scan,
             fieldWidth, 
             precision, 
             lJust, 
             padding, 
             pad
            );


       *scan++ = 'L';

       if(!lJust && precision)
          *scan++ = 'f';
       else
          *scan++ = 'g';

       *scan++ = 0;

       long double x = v;

       size_t bytesWritten = snprintf(buffer, buffsize, cs, x);

       size_t errorThreshold = buffsize;

       if(fieldWidth)
         errorThreshold = fieldWidth;

       if( bytesWritten > errorThreshold)
       {
         std::fill_n(buffer, fieldWidth, errchr);
         buffer[fieldWidth] = 0;

         bytesWritten = fieldWidth;
       }

       return bytesWritten;

    }

  };

  // -------------------------------------------------------------------------
  template<class T, int fieldWidth, int precision, int lJust, int padding, int pad, int base, int errchr>
  struct IntFormatter
  {
    size_t operator() (T const  &v, 
                     char     *buffer, 
                     int       buffsize 
                    )
    {
       char cs[100];

       char *scan = &cs[0];

       setup(scan,
             fieldWidth, 
             precision, 
             lJust, 
             padding, 
             pad
            );


       *scan++ = 'l';
       *scan++ = 'l';

       if(base == 16)
         *scan++ = 'x';
       else
       if(base == 8)
         *scan++ = 'o';
       else
       if(isUnsignedType<T>::value)
         *scan++ = 'u';
       else
         *scan++ = 'd';

       *scan++ = 0;

       long long x = v;

       size_t errorThreshold = buffsize;

       if(fieldWidth)
         errorThreshold = fieldWidth;

       size_t rv;

       if( (rv = snprintf(buffer, buffsize, cs, x) ) > errorThreshold)
       {
         std::fill_n(buffer, fieldWidth, errchr);
         buffer[fieldWidth] = 0;
         rv = fieldWidth;
       }

       return rv;
    }
  };

  // =========================================================================
  template<int N, 
           class T, 
           int fieldWidth, 
           int precision, 
           int lJust, 
           int padding, 
           int pad, 
           int base, 
           int errchr
          > 
  struct algo;


  // =========================================================================
  template<class T, 
           int fieldWidth, 
           int precision, 
           int lJust, 
           int padding, 
           int pad, 
           int base, 
           int errchr
          > 
  struct algo<bctIntegralType,
              T, 
              fieldWidth, 
              precision, 
              lJust, 
              padding, 
              pad, 
              base, 
              errchr
             >
  { 
    typedef IntFormatter<T, 
                         fieldWidth, 
                         precision, 
                         lJust, 
                         padding, 
                         pad, 
                         base, 
                         errchr
                        > 
                        type;   
  };

  // ==========================================================================
  template<class T, 
           int   fieldWidth, 
           int   precision, 
           int   lJust, 
           int   padding, 
           int   pad, 
           int   base, 
           int   errchr
          > 
  struct algo<bctFloatType, 
              T, 
              fieldWidth, 
              precision, 
              lJust, 
              padding, 
              pad, 
              base, 
              errchr
             >    
  { 
    typedef FloatFormatter<T, 
                           fieldWidth, 
                           precision, 
                           lJust, 
                           padding, 
                           pad, 
                           base, 
                           errchr
                          > type; 
  };

  // -------------------------------------------------------------------------
  template<
           int   fieldWidth, 
           int   precision, 
           int   lJust, 
           int   padding, 
           int   pad, 
           int   base, 
           int   errchr
          > 
  struct algo<bctClassType,   // parm named N
              char const *,   // parm named T
              fieldWidth, 
              precision, 
              lJust, 
              padding, 
              pad, 
              base, 
              errchr
             >    
  { 
    typedef StringFormatter<std::string,  // ignored but needed
                           fieldWidth, 
                           precision, 
                           lJust, 
                           padding, 
                           pad, 
                           base, 
                           errchr
                          > type; 
  };



};


template<int WIDTH=0, int PRECISION=0, int PAD=' ', int BASE=10, int ERRCHR='@'>
struct fmtd
{
  // implementation details

  // interface -----------------------------------------------------------------
  enum constants  { MIN_WIDTH   = 25,
                    BUFF_SAFETY = 10,
                    POS_WIDTH   = (WIDTH < 0) ? -WIDTH : WIDTH,
                    FIELD_WIDTH = (PRECISION > POS_WIDTH ? PRECISION : ( (POS_WIDTH == 0) ? 0 : POS_WIDTH ) ),
                    BUFF_SIZE   = FIELD_WIDTH + BUFF_SAFETY,
                    PADDING     = (POS_WIDTH != 0) || (PRECISION != 0),
                    LJUST       = (WIDTH< 1),
                  };

private:

  char buffer_[ BUFF_SIZE ];

  size_t size_;

public:

  // interface -----------------------------------------------------------------

  template<class T>
  fmtd(T const &v)
  {
    using namespace fmtdalgo;

    typename algo< basicClassType<T>::value, T, FIELD_WIDTH, PRECISION, LJUST, PADDING, PAD, BASE, ERRCHR>::type doit;
       // If the above line of code fails to compile it is most likely
       // related to the type, T, that you are attempting to use as a 
       // parameter to ftmd<>(T)! 
       // 
       // fmtd<> only supports the same data types that sprintf supports!
       //
       // Well, ok, it supports std::string too! 

    size_ = doit(v,buffer_,BUFF_SIZE);
  }

  // interface -----------------------------------------------------------------

  fmtd(char const *s)
  {
    using namespace fmtdalgo;

    typename algo< bctClassType, char const *, FIELD_WIDTH, PRECISION, LJUST, PADDING, PAD, BASE, ERRCHR>::type doit;

    size_ = doit(s,buffer_,BUFF_SIZE);
  }

  // interface -----------------------------------------------------------------

  fmtd(std::string const &s)
  {
    using namespace fmtdalgo;

    typename algo< bctClassType, char const *, FIELD_WIDTH, PRECISION, LJUST, PADDING, PAD, BASE, ERRCHR>::type doit;

    size_ = doit(s.c_str(),buffer_,BUFF_SIZE);
  }



  // interface -----------------------------------------------------------------

  operator char const *() const { return buffer_; }

  // interface -----------------------------------------------------------------

  size_t size() const { return size_; }


  // interface -----------------------------------------------------------------

  friend std::ostream &operator<< ( std::ostream &s, fmtd const &f) 
  { 
     s << f.buffer_; 
     return s;
  }


};

} // namespace cxxtls
#endif