src/Resource/StringUtilities.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2008 by Sverre Rabbelier                                *
   3  *   sverre@rabbelier.nl                                                   *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; either version 3 of the License, or     *
   8  *   (at your option) any later version.                                   *
   9  *                                                                         *
  10  *   This program is distributed in the hope that it will be useful,       *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15  *   You should have received a copy of the GNU General Public License     *
  16  *   along with this program; if not, write to the                         *
  17  *   Free Software Foundation, Inc.,                                       *
  18  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  19  ***************************************************************************/
  20
  21 #include <sstream>
  22 #include <algorithm>
  23 #include <cctype>
  24 #include <math.h>
  25
  26 #include "StringUtilities.h"
  27 #include "Parse.h"
  28
  29 Strings String::lines(const std::string& input, const char* separator)
  30 {
  31         Assert(separator);
  32
  33         Parse p(input, separator, 1);
  34         Strings result;
  35
  36         while(true)
  37         {
  38                 std::string line = p.getword();
  39                 if(line.size())
  40                         result.push_back(line);
  41                 else
  42                         break;
  43         }
  44
  45         return result;
  46 }
  47
  48 std::string String::unlines(const Strings& input, const char* filler, int extra)
  49 {
  50         Assert(filler);
  51
  52         std::string result;
  53         int i = 0;
  54
  55         for(Strings::const_iterator it = input.begin(); it != input.end(); it++)
  56         {
  57                 if(i != 0)
  58                 {
  59                         if(extra && i%extra == 0)
  60                                 result += "\n";
  61                         else
  62                                 result += filler;
  63                 }
  64
  65
  66                 result += (*it);
  67                 i++;
  68         }
  69
  70         return result;
  71 }
  72
  73 Strings String::unlines(const Strings& input)
  74 {
  75         Strings result;
  76
  77         for(Strings::const_iterator it = input.begin(); it != input.end(); it++)
  78         {
  79                 Parse p(*it, "\n", 1);
  80                 while(true)
  81                 {
  82                         std::string line = p.getword();
  83                         if(line.size())
  84                                 result.push_back(line);
  85                         else
  86                                 break;
  87                 }
  88         }
  89
  90         return result;
  91 }
  92
  93 size_t String::maxlength(const Strings& input)
  94 {
  95         size_t champ = 0;
  96         for(Strings::const_iterator it = input.begin(); it != input.end(); it++)
  97         {
  98                 size_t current = it->size();
  99                 if(current > champ)
 100                         champ = current;
 101         }
 102         return champ;
 103 }
 104
 105 std::string String::box(const Strings& unparsedcontent, const std::string& header)
 106 {
 107         bool useheader = (header != Global::Get()->EmptyString);
 108         Strings content = unlines(unparsedcontent);
 109
 110         size_t length = maxlength(content);
 111         if(useheader && header.size() > length)
 112                 length = header.size();
 113
 114         length += 4;
 115
 116         std::string result;
 117         std::string linefill;
 118         std::string spacefill;
 119         std::string fill;
 120
 121         linefill.assign(length, '_');
 122         spacefill.assign(length, ' ');
 123         fill.assign( (length-header.size())/2 + 2,' ');
 124
 125         std::string title;
 126         if(useheader)
 127                 title = (Global::Get()->sprintf("%s%s%s\n", fill.c_str(), header.c_str(), fill.c_str()));
 128
 129         std::string toplet(Global::Get()->sprintf("__%s__\n", linefill.c_str()));
 130         std::string top(Global::Get()->sprintf("|\\%s/|\n", linefill.c_str()));
 131         std::string body(Global::Get()->sprintf("||%s||\n", spacefill.c_str()));
 132         std::string footlet(Global::Get()->sprintf("||%s||\n", linefill.c_str()));
 133         std::string footer(Global::Get()->sprintf("|/%s\\|\n", linefill.c_str()));
 134
 135         if(useheader)
 136                 result.append(title);
 137         result.append(toplet);
 138         result.append(top);
 139         result.append(body);
 140         for(Strings::const_iterator it = content.begin(); it != content.end(); it++)
 141         {
 142                 if(!it->size())
 143                         continue;
 144
 145                 result.append(Global::Get()->sprintf("||  %s%.*s||\n",it->c_str(), length - it->size() - 2, spacefill.c_str()));
 146         }
 147         result.append(footlet);
 148         result.append(footer);
 149
 150         return result;
 151 }
 152
 153 std::string String::toupper(const std::string& input)
 154 {
 155         std::string convertToUpper = input;
 156         std::transform(convertToUpper.begin(), convertToUpper.end(), convertToUpper.begin(), (int(*)(int)) std::toupper);
 157         return convertToUpper ;
 158 }
 159
 160 std::string String::tolower(const std::string& input)
 161 {
 162         std::string convertToUpper = input;
 163         std::transform(convertToUpper.begin(), convertToUpper.end(), convertToUpper.begin(), (int(*)(int)) std::tolower);
 164         return convertToUpper ;
 165 }
 166
 167 std::string String::countWord(value_type value)
 168 {
 169         std::string result = fromInt(value);
 170
 171         switch(value)
 172         {
 173                 case 1:
 174                         result.append("st");
 175                         break;
 176
 177                 case 2:
 178                         result.append("nd");
 179                         break;
 180
 181                 case 3:
 182                         result.append("rd");
 183                         break;
 184
 185                 default:
 186                         result.append("th");
 187                         break;
 188         }
 189
 190         return result;
 191 }
 192
 193 std::string String::fromInt(value_type value)
 194 {
 195          std::ostringstream o;
 196      if(!(o << value))
 197                 return "String::fromInt(), ERROR!";
 198
 199         return o.str();
 200 }
 201
 202 std::string String::fromLong(signed long value)
 203 {
 204          std::ostringstream o;
 205      if(!(o << value))
 206                 return "String::fromLong(), ERROR!";
 207
 208         return o.str();
 209 }
 210
 211 Strings String::createTable(const std::vector<Strings>& content, const Strings& header)
 212 {
 213         Strings result;
 214
 215         const size_t maxlinesize = 80;
 216         const size_t fieldcount = header.size();
 217
 218         std::vector<int> fieldsizes = calculateMinimumFieldSizes(content, fieldcount);
 219         rebaseMinimumFieldSizes(fieldsizes, header);
 220         capFieldSize(fieldsizes, maxlinesize);
 221
 222         std::string theheader = packFields(header, fieldsizes);
 223
 224         result.push_back(theheader);
 225
 226         for(std::vector<Strings>::const_iterator it = content.begin(); it != content.end(); it++)
 227         {
 228                 Strings fields = *it;
 229                 Assert(fields.size() == fieldcount);
 230
 231                 std::string line = packFields(fields, fieldsizes);
 232                 result.push_back(line);
 233         }
 234
 235         return result;
 236 }
 237
 238 std::vector<int> String::calculateMinimumFieldSizes(const std::vector<Strings>& content, int fieldcount)
 239 {
 240         std::vector<int> result(fieldcount);
 241
 242         for(std::vector<Strings>::const_iterator it = content.begin(); it != content.end(); it++)
 243         {
 244                 Strings line = *it;
 245                 int i = 0;
 246                 for(Strings::const_iterator itl = line.begin(); itl != line.end(); itl++)
 247                 {
 248                         std::string field = *itl;
 249                         int fieldsize = field.size();
 250                         fieldsize++; // reserve space for column separator
 251
 252                         if(fieldsize > result[i])
 253                                 result[i] = fieldsize;
 254
 255                         i++;
 256                 }
 257         }
 258
 259         return result;
 260 }
 261
 262 void String::rebaseMinimumFieldSizes(std::vector<int>& sizes, const Strings& header)
 263 {
 264         int i = 0;
 265         for(Strings::const_iterator it = header.begin(); it != header.end(); it++)
 266         {
 267                 std::string field = *it;
 268                 int fieldsize = field.size();
 269
 270                 if(fieldsize > sizes[i])
 271                         sizes[i] = fieldsize;
 272
 273                 i++;
 274         }
 275 }
 276
 277 void String::capFieldSize(std::vector<int>& sizes, const int maxlinesize)
 278 {
 279         int totalsize = 0;
 280         int maxfairsize = maxlinesize / sizes.size();
 281         int unfairfields = 0;
 282         int slack = 0;
 283
 284         for(size_t i = 0; i < sizes.size(); i++)
 285         {
 286                 int size = sizes[i];
 287                 totalsize += size;
 288                 if(size > maxfairsize)
 289                         unfairfields++;
 290
 291                 if(size < maxfairsize)
 292                         slack += maxfairsize - size;
 293         }
 294
 295         if(totalsize > maxlinesize)
 296                 capUnfairFields(sizes, unfairfields, maxfairsize, slack);
 297 }
 298
 299 void String::capUnfairFields(std::vector<int>& sizes, int unfairFields, int maxFairSize, int slack)
 300 {
 301         Assert(unfairFields > 0);
 302
 303         for(size_t i = 0; i < sizes.size(); i++)
 304         {
 305                 if(sizes[i] > maxFairSize)
 306                 {
 307                         Assert(unfairFields > 0);
 308                         Assert(slack >= 0);
 309
 310                         int size = sizes[i];
 311                         int toomuch = size - maxFairSize;
 312                         int myslack = slack / unfairFields;
 313                         if(myslack > toomuch)
 314                                 myslack = toomuch;
 315
 316                         sizes[i] = maxFairSize + myslack;
 317                         slack -= myslack;
 318                         unfairFields--;
 319                 }
 320         }
 321 }
 322
 323 std::string String::packFields(const Strings& fields, const std::vector<int>& fieldsizes)
 324 {
 325         std::string result;
 326
 327         int i = 0;
 328         for(Strings::const_iterator it = fields.begin(); it != fields.end(); it++)
 329         {
 330                 result.append("|");
 331
 332                 std::string field = *it;
 333                 int fieldsize = field.size();
 334                 if(fieldsize < fieldsizes[i])
 335                 {
 336                         size_t padding = fieldsizes[i] - fieldsize;
 337                         std::string suffix(padding, ' ');
 338                         result.append(field);
 339                         result.append(suffix);
 340                 }
 341                 else if(fieldsize == fieldsizes[i])
 342                         result.append(field);
 343                 else
 344                         result.append(field.substr(0, fieldsizes[i]));
 345
 346                 i++;
 347         }
 348
 349         result.append("|");
 350
 351         return result;
 352 }
 353
 354 /**
 355         7 | 1  | 4  | 6  | 7 |  9  | 12 | 24 = 70
 356         0 | -5 | -3 | -1 | 0 |  3  |  5 | 17 = -14
 357         7 | 1  | 4  | 6  | 7 |  7  |  7 |  7 = +10
 358  */
 359
 360 /**
 361         9  | 12 | 24 = 70
 362         3  |  5 | 17 = -14
 363         9  | 11 | 11 = +0/0
 364  */