fmtio.h

Go to the documentation of this file.

#ifndef format_h_header_included_p
#define format_h_header_included_p


#include <portable_io.h>

#include <iostream>
#include <string>
#include <sstream>
#include <iomanip>

// ========================================================================================

namespace fmtio
{

// ========================================================================================

namespace printableType
{
  
// ========================================================================================

  //
  //  The following struct declarations are unique to the style of printing of the data
  //  associated with the struct names.
  //

  struct Integral      {};  
  struct String        {};  
  struct StlString     {};  
  struct Float         {};  
  struct DoubleFloat   {};  
  struct UserDefined   {};  
  struct Unsigned      {};  
  struct Char          {};  


// ========================================================================================

  //
  // The printability of types does not depend on its constness, so we need a way
  // to eliminate const from type signatures.  Ditto for volatile.
  //



  template<class T> struct devolify             { typedef T type; };  
  template<class T> struct devolify<T volatile> { typedef T type; };  

  template<class T> struct deconstify           { typedef typename devolify<T>::type type; }; 
  template<class T> struct deconstify<T const>  { typedef typename devolify<T>::type type; }; 

// ========================================================================================

  template<int N> struct typeDetector;  

  template<> struct typeDetector<1> { typedef UserDefined type; }; // class objects
  template<> struct typeDetector<0> { typedef Integral    type; }; // enums

  template<class Type>
  struct isClassType
  {
    
    template <typename ClassType>
    static short fun(void (ClassType::*)());
    
    template <typename NonClassType>   // this has to be a template
    static char fun(...);
  
    enum { value = sizeof(fun<Type>(0)) == sizeof(short) };
  };



  template<class T>
  struct classification
  {
    typedef typename typeDetector< isClassType< typename deconstify<T>::type >::value >::type  printableClass;
  };



// ========================================================================================


  template<class T>
  typename classification< typename deconstify<T>::type >::printableClass 
  classifier(T const &t) 
    









  { 
    return typename classification< typename deconstify<T>::type >::printableClass(); 
  }

// ========================================================================================

  template<class T> struct classification<T *>    { typedef Integral printableClass; }; 


// ========================================================================================

  template<> struct classification<int>           { typedef Integral printableClass; };  
  template<> struct classification<short>         { typedef Integral printableClass; };  
  template<> struct classification<long>          { typedef Integral printableClass; };  
  template<> struct classification<long long>     { typedef Integral printableClass; };  

  template<> struct classification<unsigned int>           { typedef Unsigned printableClass; };  
  template<> struct classification<unsigned short>         { typedef Unsigned printableClass; };  
  template<> struct classification<unsigned long>          { typedef Unsigned printableClass; };  
  template<> struct classification<unsigned long long>     { typedef Unsigned printableClass; };  


// ========================================================================================

  template<> struct classification<char>          { typedef Char     printableClass; };  
  template<> struct classification<unsigned char> { typedef Char     printableClass; };  

// ========================================================================================

  template<> struct classification<float>         { typedef Float       printableClass; }; 
  template<> struct classification<double>        { typedef DoubleFloat printableClass; }; 
  
// ========================================================================================

  // note:  g++ is weird about quoted strings -- they don't seem to match template name<char const *>
  // and they don't seem to match template name< char const (&)[N] >, so I have worked around this
  // in the cs class by making operator% handle char const * as a special case.  See below.

  template<> struct classification<char*>                { typedef String       printableClass; }; 
  template<> struct classification<unsigned char*>       { typedef String       printableClass; }; 
  template<> struct classification<unsigned char const *>{ typedef String       printableClass; }; 
  template<> struct classification<std::string>          { typedef StlString    printableClass; }; 

// ========================================================================================

  struct Exception
  {
     char expectedFormat_;

     char const *foundType_;

     Exception(char e, char const *found)
     : expectedFormat_(e)
     , foundType_(found)
     {
     }

  };
};

// ========================================================================================

class cs
{
    // ---------------------------------------------------------------------------------------

     mutable char expectedFormat_;  // %<expectedFormat_> in control string language

     mutable char const *cs_;

     mutable std::string buffer_;

     mutable int fieldWidth_;
     mutable int fillChar_;
     mutable int precision_;
     mutable int left_;

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

     void reset() const
     {
       left_       = 0;
       fieldWidth_ = 0;
       fillChar_   = 0;
       precision_  = 0;
     }


public:

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

     operator std::string const &() const { return buffer_; }

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

     cs(char const *cs)
     : expectedFormat_(*cs)
     , cs_(cs)
     {
       advanceFormat(); 
     }

     ~cs()
     {
       if(expectedFormat_ != '?' )
       {
         // should have been out of formatting directives by now

         throw  printableType::Exception(expectedFormat_, "<EXPECTED END OF FORMAT STRING>");  

       }
     }

private:

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

     void advanceFormat() const
     {
       reset();  // field formatting options

       // skip non-format text before % and handle %%

       while(*cs_)                     // outer loop to handle repeats after %%
       {

         while(*cs_ && *cs_ != '%')   // normal case -- just print anything not a % spec
           buffer_ += *cs_++;
  
         if(*cs_ == '%')              // ignore the % of a spec
           ++cs_;

         if(*cs_ == '%')
         {
           buffer_ += '%';
           ++cs_;
         }
         else
           break;
       }

       // the leading % is already removed before we get here

       expectedFormat_ = '?';  // set up an invalid format as the norm -- superseed
                               // the invalid state only if a properly formatted
                               // control string is found.

       if(*cs_ == '-')
       {
         left_ = 1;            // handle left justification
         ++cs_;
       }

       if(*cs_ == '0')
       {
         fillChar_ = '0';      // handle leading zeros
         ++cs_;
       }

       if(*cs_ >= '0' && *cs_ <='9')
       {
         fieldWidth_ = 0;                    // handle field widths 

         while(*cs_ >= '0' && *cs_ <= '9')
         {
           fieldWidth_ *= 10;
           fieldWidth_ += *cs_++ -'0';
         }
       }

       if(*cs_ == '.')
       {
         ++cs_;                             // handle precision

         precision_ = 0;

         while(*cs_ >= '0' && *cs_ <= '9')
         {
           precision_ *= 10;
           precision_ += *cs_++ -'0';
         }

       }

       // now, handle the formatting character:  u, x, d, o, s, c, U (U is user defined)

       if(*cs_)
       {
         expectedFormat_ = *cs_++;
       }
       
     }


    // ---------------------------------------------------------------------------------------
     void outputIntegral( long long t ) const
     {
         char b[100];

         char cs[40];

         char *scan = &cs[0];

         {
  
           *scan++ = '%';  // setup control string for converison
  
           if(left_)
             *scan++ = '-';

           if(fillChar_ == '0')
             *scan++ = '0';

           if(fieldWidth_)
           {
             char buffer[40];

             snprintf(buffer, 40, "%d", fieldWidth_);

             char *input = &buffer[0];

             while(*input)
               *scan++ = *input++;

           }

           if(precision_)
           {
             *scan++ = '.';

             char buffer[40];

             snprintf(buffer, 40, "%d", precision_);

             char *input = &buffer[0];

             while(*input)
               *scan++ = *input++;

           }
         }

         *scan++ = 'l';                  // always use long long output data (see cast below)
         *scan++ = 'l';
         *scan++ = expectedFormat_;
         *scan++ = 0;


         snprintf(b, sizeof(b), cs, (long long)t);

         buffer_ += b;

     }

    // ---------------------------------------------------------------------------------------
     bool isIntegralFormat() const
     {
       return    expectedFormat_ == 'd'
              || expectedFormat_ == 'u'
              || expectedFormat_ == 'o'
              || expectedFormat_ == 'x'
              ;
     }

    // ---------------------------------------------------------------------------------------
     template<class T>  void output(T const &t, printableType::Integral) const

     { 
         if( !isIntegralFormat() )
         {
           throw  printableType::Exception(expectedFormat_, "Integral");  
         }

         outputIntegral((long long)t);

     }

    // ---------------------------------------------------------------------------------------
     template<class T>  void output(T const &t, printableType::Unsigned)    const 
     { 
         if( !isIntegralFormat() )
         {
           throw  printableType::Exception(expectedFormat_, "Unsigned");  
         }

         outputIntegral((long long)t);

     }

    // ---------------------------------------------------------------------------------------
     template<class T>  void output(T const &t, printableType::Char)        const 
     {
         if(expectedFormat_ == 'c')
         {
              buffer_ += (t);
         }
         else
         if( !isIntegralFormat() )
         {
           throw  printableType::Exception(expectedFormat_, "Char");
         }
         else
           outputIntegral(t);
     }


    // ---------------------------------------------------------------------------------------
     template<class T>  void output(T const &t, printableType::String)      const 
     { 
         if(   expectedFormat_ != 's'
           )
         {
           throw  printableType::Exception(expectedFormat_, "String");
         }

       
         buffer_ += (char const *)(t);
     }

    // ---------------------------------------------------------------------------------------
     template<class T>  void output(T const &t, printableType::StlString)   const 
     { 
         if(   expectedFormat_ != 's'
           )
         {
           throw  printableType::Exception(expectedFormat_, "std::string");
         }


         buffer_ += t;

     }

    // ---------------------------------------------------------------------------------------
     void outputFloat(double d) const
     {
         std::stringstream tmp;

         if(left_)
         {
           tmp << std::left;
         }

         if(fillChar_)
         {
           tmp << std::setfill(char(fillChar_));
         }

         if(fieldWidth_)
         {
             tmp << std::setw(fieldWidth_);
         }

         if(precision_)
         {
             tmp << std::setprecision(precision_);
         }
         
         tmp << d;

         buffer_ +=tmp.str();
     }

    // ---------------------------------------------------------------------------------------
     template<class T>  void output(T const &t, printableType::Float)       const 
     { 
         if(   expectedFormat_ != 'f'
           )
         {
           throw  printableType::Exception(expectedFormat_, "Float");
         }

         outputFloat(t);

     }

    // ---------------------------------------------------------------------------------------
     template<class T>  void output(T const &t, printableType::DoubleFloat) const 
     { 
         if(   expectedFormat_ != 'f'
           )
         {
           throw  printableType::Exception(expectedFormat_, "DoubleFloat");
         }

         outputFloat(t);

     }

    // ---------------------------------------------------------------------------------------
     template<class T>  void output(T const &t, printableType::UserDefined) const 
     { 
         if(   expectedFormat_ != 'U'
           )
         {
           throw  printableType::Exception(expectedFormat_, "UserDefined");
         }

         std::stringstream tmp;

         if(left_)
         {
           tmp << std::left;
         }

         if(fillChar_)
         {
           tmp << std::setfill(char(fillChar_));
         }

         tmp << std::setw(fieldWidth_) << std::setprecision(precision_) << t;

         buffer_ += tmp.str();
     }

public:

    // ---------------------------------------------------------------------------------------
     template< class T >
     cs const &operator% ( T const &rhs ) const

     {
        output(rhs, printableType::classifier(rhs));

        advanceFormat();

        return *this;
     }

    // ---------------------------------------------------------------------------------------
     cs const &operator% ( char const *rhs ) const

     {
        output(rhs, printableType::String() );

        advanceFormat();

        return *this;
     }

    // ---------------------------------------------------------------------------------------
     template<class T, int N>
     cs const &operator% ( T const (&rhs)[N] ) const

     {
        output(rhs, printableType::Integral() );

        advanceFormat();

        return *this;
     }


    size_t size() const { return buffer_.size(); }

private:

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

    cs(cs const &);  // not implemented:  If you get an error on this line of code, 
                     // you probably wrote code that looks like this:  
                     //
                     //     cout << cs("...") << something << endl;
                     //                             ^^^^
                     //  No can do big guy!  Use %, not <<



     template< class T > void operator<< ( T & ) const;   // not implemented

};

// ===========================================================================================

inline std::ostream &operator<< (std::ostream &s, cs const &fmt)
{
   if(s.good())
   {
   
      s << (std::string const &) fmt;

   }

   return s;
}

// ===========================================================================================
// ===========================================================================================

}
#endif