kcron/ctunit.cpp

   1 /***************************************************************************
   2  *   CT Unit of Time Interval Implementation                               *
   3  *   --------------------------------------------------------------------  *
   4  *   Copyright (C) 1999, Gary Meyer <gary@meyer.net>                       *
   5  *   --------------------------------------------------------------------  *
   6  *   This program is free software; you can redistribute it and/or modify  *
   7  *   it under the terms of the GNU General Public License as published by  *
   8  *   the Free Software Foundation; either version 2 of the License, or     *
   9  *   (at your option) any later version.                                   *
  10  ***************************************************************************/
  11
  12 // Do not introduce any Qt or KDE dependencies into the "CT"-prefixed classes.
  13 // I want to be able to reuse these classes with another GUI toolkit. -GM 11/99
  14
  15 #include "cti18n.h"
  16 #include <vector>
  17 #include <string>
  18 #include <stdio.h>    // sprintf
  19 #include <ctype.h>    // tolower
  20 #include <stdlib.h>
  21
  22 using namespace std;
  23
  24 template<int min, int max>
  25 CTUnit<min, max>::CTUnit(const string &tokStr)
  26 {
  27   initialize(tokStr);
  28 }
  29
  30 template<int min, int max>
  31 CTUnit<min, max>::CTUnit(const CTUnit& source)
  32 {
  33   for (int i = 0; i <= max; i++)
  34   {
  35     initialEnabled[i] = 0;
  36     enabled[i] = source.enabled[i];
  37   }
  38   initialTokStr = "";
  39   isDirty = true;
  40 }
  41
  42 template<int min, int max>
  43 CTUnit<min, max>::~CTUnit()
  44 {
  45 }
  46
  47 template<int min, int max>
  48 void CTUnit<min, max>::operator = (const CTUnit<min,max>& unit)
  49 {
  50   for (int i = 0; i <= max; i++)
  51     enabled[i] = unit.enabled[i];
  52   isDirty = true;
  53   return;
  54 }
  55
  56 template<int min, int max>
  57 void CTUnit<min, max>::initialize(const string &tokStr)
  58 {
  59   for (int i = 0; i <= max; i++)
  60     enabled[i] = 0;
  61
  62   parse(tokStr);
  63
  64   for (int i = min; i <= max; i++)
  65     initialEnabled[i] = enabled[i];
  66
  67   initialTokStr = tokStr;
  68   isDirty = false;
  69
  70   return;
  71 }
  72
  73 template<int min, int max>
  74 void CTUnit<min, max>::parse(string tokStr)
  75 {
  76   // subelement is that which is between commas
  77   string subelement;
  78   int commapos, slashpos, dashpos;
  79   int beginat, endat, step;
  80
  81   // loop through each subelement
  82   tokStr += ",";
  83   while ((commapos = tokStr.find(",")) > 0)
  84   {
  85     subelement = tokStr.substr(0,commapos);
  86
  87     // find "/" to determine step
  88     slashpos = subelement.find("/");
  89     if (slashpos == -1)
  90     {
  91       step = 1;
  92       slashpos = subelement.length();
  93     }
  94     else
  95     {
  96       step = fieldToValue(subelement.substr(slashpos+1,
  97         subelement.length()-slashpos-1));
  98       if (step < 1)
  99         step = 1;
 100     }
 101
 102     // find "=" to determine range
 103     dashpos = subelement.find("-");
 104     if (dashpos == -1)
 105     {
 106       // deal with "*"
 107       if (subelement.substr(0,slashpos) == "*")
 108       {
 109         beginat = min;
 110         endat = max;
 111       }
 112       else
 113       {
 114         beginat = fieldToValue(subelement.substr(0,slashpos));
 115         endat = beginat;
 116       }
 117     }
 118     else
 119     {
 120       beginat = fieldToValue(subelement.substr(0,dashpos));
 121       endat = fieldToValue(subelement.substr(dashpos+1,slashpos-dashpos-1));
 122     }
 123
 124     // ignore out of range
 125     if (beginat < 0)
 126       beginat = 0;
 127     if (endat > max)
 128       endat = max;
 129
 130     // setup enabled
 131     for (int i = beginat; i <= endat; i+=step)
 132       enabled[i] = 1;
 133
 134     tokStr = tokStr.substr(commapos+1, tokStr.length()-commapos-1);
 135   }
 136   return;
 137 }
 138
 139 template<int min, int max>
 140 string CTUnit<min, max>::tokenize() const
 141 {
 142   if (!isDirty)
 143   {
 144     return initialTokStr;
 145   }
 146   else
 147   {
 148     int total(count());
 149     int count(0);
 150     int num(min);
 151     string tmpStr;
 152
 153     while (num <= max)
 154     {
 155       if (enabled[num])
 156       {
 157         char cnum[3];
 158         sprintf(cnum, "%u", num);
 159         tmpStr += cnum;
 160         if (++count < total)
 161           tmpStr += ",";
 162       }
 163       num++;
 164     }
 165     if (count == (max - min + 1))
 166       tmpStr = "*";
 167     return tmpStr;
 168   }
 169 }
 170
 171 template<int min, int max>
 172 string CTUnit<min, max>::describe(const string *label) const
 173 {
 174   int total(count());
 175   int count(0);
 176   string tmpStr;
 177   for (int i = min; i <= max; i++)
 178   {
 179     if (enabled[i])
 180     {
 181       tmpStr += label[i];
 182       count++;
 183       switch (total - count)
 184       {
 185         case 0:  break;
 186         case 1:  if (total > 2) tmpStr += (const char *)i18n(",").toLocal8Bit();
 187                  tmpStr += (const char *)i18n(" and ").toLocal8Bit();
 188                  break;
 189         default: tmpStr += (const char *)i18n(", ").toLocal8Bit();
 190                  break;
 191       }
 192     }
 193   }
 194   return tmpStr;
 195 }
 196
 197 template<int min, int max>
 198 int CTUnit<min, max>::begin()
 199 {
 200   return min;
 201 }
 202
 203 template<int min, int max>
 204 int CTUnit<min, max>::end()
 205 {
 206   return max;
 207 }
 208
 209 template<int min, int max>
 210 bool CTUnit<min, max>::get(int pos) const
 211 {
 212   return enabled[pos];
 213 }
 214
 215 template<int min, int max>
 216 void CTUnit<min, max>::set(int pos, bool value)
 217 {
 218   enabled[pos] = value;
 219   isDirty = true;
 220   return;
 221 }
 222
 223 template<int min, int max>
 224 void CTUnit<min, max>::enable(int pos)
 225 {
 226   enabled[pos] = true;
 227   isDirty = true;
 228   return;
 229 }
 230
 231 template<int min, int max>
 232 void CTUnit<min, max>::disable(int pos)
 233 {
 234   enabled[pos] = false;
 235   isDirty = true;
 236   return;
 237 }
 238
 239 template<int min, int max>
 240 bool CTUnit<min, max>::dirty() const
 241 {
 242   return isDirty;
 243 }
 244
 245 template<int min, int max>
 246 int CTUnit<min, max>::count() const
 247 {
 248   int total(0);
 249   for (int i = min; i <= max; i++)
 250     total += (enabled[i] == true);
 251   return total;
 252 }
 253
 254 template<int min, int max>
 255 void CTUnit<min, max>::apply()
 256 {
 257   initialTokStr = tokenize();
 258   for (int i = min; i <= max; i++)
 259     initialEnabled[i] = enabled[i];
 260   isDirty = false;
 261   return;
 262 }
 263
 264 template<int min, int max>
 265 void CTUnit<min, max>::cancel()
 266 {
 267   for (int i = min; i <= max; i++)
 268     enabled[i] = initialEnabled[i];
 269   isDirty = false;
 270   return;
 271 }
 272
 273 template<int min, int max>
 274 int CTUnit<min, max>::fieldToValue(string entry) const
 275 {
 276   // GNU C++ STL has no String::toLower() so we have to lower
 277   // by hand.
 278
 279   string lower("");
 280   int length = entry.length();
 281   for (int i = 0; i < length; i++)
 282     lower += tolower(*(entry.substr(i, 1).c_str()));
 283
 284   // check for days
 285   string days[7] =
 286   {
 287     "sun", "mon", "tue", "wed", "thu", "fri", "sat"
 288   };
 289
 290   for (int day = 0; day < 7; day++)
 291   {
 292     if (lower == days[day])
 293     {
 294       char cnum[3];
 295       sprintf(cnum, "%u", day);
 296       entry = cnum;
 297     }
 298   }
 299
 300   // check for months
 301   string months[13] =
 302   {
 303     "",
 304     "jan", "feb", "mar", "apr", "may", "jun",
 305     "jul", "aug", "sep", "oct", "nov", "dec"
 306   };
 307
 308   for (int month = 1; month < 13; month++)
 309   {
 310     if (lower == months[month])
 311     {
 312       char cnum[3];
 313       sprintf(cnum, "%u", month);
 314       entry = cnum;
 315     }
 316   }
 317
 318   return atoi(entry.c_str());
 319 }