text.C

/*
 * This file is part of the "Archon" framework.
 * (http://files3d.sourceforge.net)
 *
 * Copyright © 2002 by Kristian Spangsege and Brian Kristiansen.
 *
 * Permission to use, copy, modify, and distribute this software and
 * its documentation under the terms of the GNU General Public License is
 * hereby granted. No representations are made about the suitability of
 * this software for any purpose. It is provided "as is" without express
 * or implied warranty. See the GNU General Public License
 * (http://www.gnu.org/copyleft/gpl.html) for more details.
 *
 * The characters in this file are ISO8859-1 encoded.
 *
 * The documentation in this file is in "Doxygen" style
 * (http://www.doxygen.org).
 */

#include <float.h>
#include <ctype.h>
#include <stdio.h>

#include <vector>
#include <string>
#include <iostream>

#include <archon/util/text.H>

using namespace std;

namespace Archon
{
  namespace Utilities
  {
    namespace Text
    {
      string toString(void *v)
      {
        char buf[100];
        sprintf(buf, "%p", v);
        return buf;
      }

      string toString(bool v)
      {
        return v ? "true" : "false";
      }

      string toString(short v)
      {
        char buf[100];
        sprintf(buf, "%hd", v);
        return buf;
      }

      string toString(unsigned short v)
      {
        char buf[100];
        sprintf(buf, "%hu", v);
        return buf;
      }

      string toString(int v)
      {
        char buf[100];
        sprintf(buf, "%d", v);
        return buf;
      }

      string toString(unsigned v)
      {
        char buf[100];
        sprintf(buf, "%u", v);
        return buf;
      }

      string toString(long v)
      {
        char buf[100];
        sprintf(buf, "%ld", v);
        return buf;
      }

      string toString(unsigned long v)
      {
        char buf[100];
        sprintf(buf, "%lu", v);
        return buf;
      }

      string toString(float v)
      {
        char buf[100];
        sprintf(buf, "%g", static_cast<double>(v));
        return buf;
      }

      string toString(double v)
      {
        char buf[100];
        sprintf(buf, "%.10g", v);
        return buf;
      }

      string toString(long double v)
      {
        char buf[100];
        sprintf(buf, "%.15Lg", v);
        return buf;
      }


      bool isPrefixOf(string prefix, string s, bool ignoreCase)
      {
        return ignoreCase ?
          compareIgnoreCase(prefix, s.substr(0, prefix.size())) == 0 :
          s.compare(0, prefix.size(), prefix) == 0;
      }

      bool isSuffixOf(string suffix, string s, bool ignoreCase)
      {
        return s.size() >= suffix.size() &&
          (ignoreCase ?
           compareIgnoreCase(suffix, s.substr(s.size()-suffix.size())) == 0 :
           s.compare(s.size()-suffix.size(), string::npos, suffix) == 0);
      }

      string toLowerCase(string s)
      {
        string::iterator i = s.begin();
        while(i != s.end())
        {
          *i = static_cast<char>(tolower(*i));
          ++i;
        }
        return s;
      }

      string toUpperCase(string s)
      {
        string::iterator i = s.begin();
        while(i != s.end())
        {
          *i = static_cast<char>(toupper(*i));
          ++i;
        }
        return s;
      }

      string initCap(string s)
      {
        if(s.size())
          s[0] = static_cast<char>(toupper(s[0]));
        return s;
      }

      string trim(string s)
      {
        string::iterator i = s.begin();
        while(i != s.end() && isspace(static_cast<unsigned char>(*i))) ++i;
        string::iterator j = s.end();
        while(i != j && isspace(static_cast<unsigned char>(*(j-1)))) --j;
        return string(i, j);
      }

      string lineTrim(string s)
      {
        string::iterator i = s.begin();
        string::iterator f = i;
        while(i != s.end() && isspace(static_cast<unsigned char>(*i)))
        {
          char c = *i++;
          if(c == '\n' || c == '\r') f = i;
        }
        string::iterator j = s.end();
        while(i != j && isspace(static_cast<unsigned char>(*(j-1)))) --j;
        return i == j ? "" : string(f, j);
      }

      int compareIgnoreCase(const string &a, const string &b)
      {
        string::const_iterator i = a.begin();
        string::const_iterator j = b.begin();
        while(i != a.end() && j != b.end())
        {
          const int ca = toupper(static_cast<unsigned char>(*i));
          const int cb = toupper(static_cast<unsigned char>(*j));
          if(ca != cb) return ca - cb;
          ++i;
          ++j;
        }
        return a.size() - b.size();
      }

      string escapeNonprintable(const string &s)
      {
        string t;
        t+='"';
        t.reserve(s.size()+2);
        for(unsigned i=0; i<s.size(); ++i)
        {
          const int ch = static_cast<unsigned char>(s[i]);
          switch(ch)
          {
          case '\n': t+="\\n";  break;
          case '\t': t+="\\t";  break;
          case '\v': t+="\\v";  break;
          case '\b': t+="\\b";  break;
          case '\r': t+="\\r";  break;
          case '\f': t+="\\f";  break;
          case '\a': t+="\\a";  break;
          case '\\': t+="\\\\"; break;
          case '"' : t+="\\\""; break;
          default:
            if(ch <= 0x1f || ch >= 0x7f && ch <= 0xa0 || ch == 0xad)
            {
              char buffer[8];
              sprintf(buffer, "\\x%02x", ch);
              t+=buffer;
            }
            else t+=ch;
          }
        }
        t+='"';
        return t;
      }

      ustring escapeNonprintable(const ustring &s)
      {
        ustring t;
        t+='"';
        t.reserve(s.size()+2);
        for(unsigned i=0; i<s.size(); ++i)
        {
          const uchar ch = s[i];
          switch(ch)
          {
          case '\n': t+=Unicode::decodeUtf8("\\n");  break;
          case '\t': t+=Unicode::decodeUtf8("\\t");  break;
          case '\v': t+=Unicode::decodeUtf8("\\v");  break;
          case '\b': t+=Unicode::decodeUtf8("\\b");  break;
          case '\r': t+=Unicode::decodeUtf8("\\r");  break;
          case '\f': t+=Unicode::decodeUtf8("\\f");  break;
          case '\a': t+=Unicode::decodeUtf8("\\a");  break;
          case '\\': t+=Unicode::decodeUtf8("\\\\"); break;
          case '"' : t+=Unicode::decodeUtf8("\\\""); break;
          default:
            if(ch <= 0x1f || ch >= 0x7f && ch <= 0xa0 || ch == 0xad)
            {
              char buffer[8];
              sprintf(buffer, "\\x%02x", ch);
              t+=Unicode::decodeUtf8(buffer);
            }
            else t+=ch;
          }
        }
        t+='"';
        return t;
      }

      string format(string value, int width)
      {
        string buffer;
        StringTokenizer tokenizer(value, " \t\r\n", true);

        int position = 0; // Number of characters already put into the current line
        int pendingNewlines = 0; // Number of consecutive empty lines needing to be appended if something follows them

        while(tokenizer.hasMoreElements())
        {
          string word = tokenizer.nextToken();

          if(word == " " || word  == "\t" || word  == "\r") continue;

          if(word == "\n")
          {
            if(width < 0) continue;
            ++pendingNewlines;
            position = 0;
            continue;
          }

          if(pendingNewlines > 0)
          {
            for(int i=0; i<pendingNewlines; ++i) buffer += "\n";
            pendingNewlines = 0;
          }

          if(width > 0)
          {
            // Break line if next word exceeds max. width (never applies to the first word on a line)
            if(position > 0 && int(word.length()) + position >= width)
            {
              buffer += "\n";
              position = 0;
            }

            // Break word if it is wider than max. width (only applies to the first word on a line)
            while(position == 0 && int(word.length()) > width)
            {
              buffer += string(word, 0, width);
              buffer += "\n";
              word = string(word, width);
            }
          }

          if(position > 0)
          {
            buffer += " ";
            ++position;
          }
          buffer += word;
          position += word.length();
        }

        return buffer;
      }

      int width(string s)
      {
        int w = 0;
        unsigned p = 0;
        do
        {
          unsigned _p = s.find('\n', p);
          if(_p == string::npos) _p = s.length();
          int _w = _p - p;
          if(_w > w) w = _w;
          p = _p + 1;
        }
        while(p <= s.size());
        return w;
      }

      int height(string s)
      {
        int h = 0;
        unsigned p = 0;
        for(;;)
        {
          const unsigned _p = s.find('\n', p);
          if(_p == string::npos)
          {
            if(s.size() - p > 0) ++h;
            break;
          }
          ++h;
          p = _p + 1;
        }

        return h;
      }

      string extractLine(string s, int i)
      {
        if(i<0) return ""; // Actually we should throw an exception
        unsigned p = 0;
        while(i>0)
        {
          const unsigned _p = s.find('\n', p);
          if(_p == string::npos) return ""; // Actually we should throw an exception
          p = _p + 1;
          --i;
        }
        unsigned q = s.find('\n', p);
        if(q == string::npos) q = s.size();
        if(p == s.size()) return ""; // Actually we should throw an exception
        return s.substr(p, q-p);
      }

      string format(Table<string> &table, int maxTotalWidth, int columnSpacing, bool header)
      {
        if(!table.getRows()) return "";

        // Calculate column widths
        vector<int> columnWidths(table.getCols());
        for(int i=0; i<table.getRows(); ++i)
          for(int j=0; j<table.getCols(); ++j)
          {
            const int w = width(table(i, j));
            if(w > columnWidths[j]) columnWidths[j] = w;
          }

        // Calculate total width
        int totalWidth = 0;
        for(int i=0; i<table.getCols(); ++i)
        {
          totalWidth += columnWidths[i];
          if(i<table.getCols()-1) totalWidth += columnSpacing;
        }

        if(maxTotalWidth > 0 && totalWidth > maxTotalWidth)
        {
          // Calculate column excesses
          const int netWidth = maxTotalWidth - (table.getCols()-1) * columnSpacing;
          vector<double> excess(table.getCols());
          for(int i=0; i<table.getCols(); ++i)
            excess[i] = columnWidths[i] - netWidth * table.columnWidthFractions[i];
          while(totalWidth > maxTotalWidth)
          {
            // Find column with greatest excess
            double e = DBL_MIN;
            int j = -1;
            for(int i=0; i<table.getCols(); ++i)
              if(excess[i] > e) e = excess[j = i];
            // Reduce column with by one character
            if(columnWidths[j] > 1) --columnWidths[j];
            excess[j] -= 1;
            --totalWidth;
          }

          // Reformat cells
          for(int i=0; i<table.getRows(); ++i)
            for(int j=0; j<table.getCols(); ++j)
              table(i, j) = format(table(i, j), columnWidths[j]);
        }

        // Render table
        string buffer;
        for(int i=0; i<table.getRows(); ++i)
        {
          int h = 0;
          for(int j=0; j<table.getCols(); ++j)
          {
            int _h = height(table(i, j));
            if(_h > h) h = _h;
          }

          for(int l=0; l<h; ++l)
          {
            for(int j=0; j<table.getCols(); ++j)
            {
              string cellLine = extractLine(table(i, j), l);
              buffer += cellLine;
              if(j<table.getCols()-1)
              {
                int w = cellLine.length();
                while(w<columnWidths[j]+columnSpacing)
                {
                  buffer += " ";
                  ++w;
                }
              }
            }

            buffer += "\n";
          }

          if(header && i == 0)
          {
            for(int j=0; j<totalWidth; ++j) buffer += "-";
            buffer += "\n";
          }
        }

        return buffer;
      }
    }
  }
}

---