text.H

/*
 * 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).
 */

#ifndef ARCHON_UTILITIES_TEXT_H
#define ARCHON_UTILITIES_TEXT_H

#include <string.h>
#include <string>
#include <vector>

#include <archon/util/unicode.H>

#include <archon/util/exception.H>

namespace Archon
{
  namespace Utilities
  {
    namespace Text
    {
      using namespace std;

      string toString(void *);
      string toString(bool);
      string toString(short);
      string toString(unsigned short);
      string toString(int);
      string toString(unsigned);
      string toString(long);
      string toString(unsigned long);
      string toString(float);
      string toString(double);
      string toString(long double);
      inline string toString(string v) { return v; }
      inline string toString(ustring v) { return Unicode::encodeUtf8(v); }

      bool isPrefixOf(string prefix, string, bool ignoreCase=false);
      bool isSuffixOf(string suffix, string, bool ignoreCase=false);

      string toLowerCase(string);
      string toUpperCase(string);
      string initCap(string);  // Capitalize initial character

      string trim(string);

      string lineTrim(string);

      int compareIgnoreCase(const string &a, const string &b);

      string escapeNonprintable(const string &);
      ustring escapeNonprintable(const ustring &);

      class StringTokenizer
      {
        bool returnDelims;
        char *delims;
        char *str;
        char *pos;

      public:
        StringTokenizer(string str, const char *delims,
                        bool returnDelims = false):
          returnDelims(returnDelims)
        {
          this->delims = new char[strlen(delims)+1];
          strcpy(this->delims, delims);
          const unsigned size = str.size();
          this->str = new char[size+1];
          str.copy(this->str, size);
          this->str[size] = 0;
          pos = this->str;
          if(!returnDelims) pos += strspn(pos, delims);
        }

        ~StringTokenizer()
        {{ // The extra scope is needed to work around gcc3.2 bug #8287
          delete[] str;
          delete[] delims;
        }}

        bool hasMoreElements()
        {
          return *pos;
        }

        string nextToken()
        {
          if(!*pos) return 0;
          int n = strcspn(pos, delims);
          if(n == 0) n = 1;
          string s(pos, n);
          pos += n;
          if(!returnDelims) pos += strspn(pos, delims);
          return s;
        }
      };

      string format(string, int width = 0);

      template<class T>
      class Table
      {
        vector<T> elements;
        int rows, cols;

      public:
        vector<double> columnWidthFractions;

        Table(int rows, vector<double> columnWidthFractions):
          rows(rows), cols(columnWidthFractions.size()),
          columnWidthFractions(columnWidthFractions)
        {
          if(rows < 0) ARCHON_THROW1(ArgumentException,
                                     "Number of rows out of bound");
          if(cols < 1) ARCHON_THROW1(ArgumentException,
                                     "Number of columns out of bound");
          elements = vector<T>(rows*cols);
        }

        T &operator()(int r, int c)
        {
          if(r < 0 || r >= rows) ARCHON_THROW1(ArgumentException,
                                               "Row index out of bound");
          if(c < 0 || c >= cols) ARCHON_THROW1(ArgumentException,
                                               "Column index out of bound");
          return elements[r*cols+c];
        }

        T operator()(int r, int c) const
        {
          if(r < 0 || r >= rows) ARCHON_THROW1(ArgumentException,
                                               "Row index out of bound");
          if(c < 0 || c >= cols) ARCHON_THROW1(ArgumentException,
                                               "Column index out of bound");
          return elements[r*cols+c];
        }

        int getCols() const { return cols; }
        int getRows() const { return rows; }
      };

      string format(Table<string> &table, int maxTotalWidth = 0, int columnSpacing = 2, bool header = false);
    }
  }
}

#endif // ARCHON_UTILITIES_TEXT_H

---