src/defparse/defaction.hh

   1 /*
   2  * This header includes more specific functions for definition actions.
   3  * Actions are functors that are executed by the definition parser
   4  * upon recognizing valid entries.
   5  *
   6  * Copyright (C) 2008 Hermann Walth
   7  *
   8  * This file is part of OpenStranded
   9  *
  10  * OpenStranded is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation, either version 3 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * OpenStranded is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with OpenStranded. If not, see <http://www.gnu.org/licenses/>.
  22  */
  23
  24 #ifndef STRANDED_DEFACTION_HH
  25 #define STRANDED_DEFACTION_HH
  26
  27 #include "defparse.hh"
  28
  29 typedef unsigned int ID;
  30 typedef unsigned char uint8_t;
  31
  32 namespace def {
  33
  34         class Action
  35         {
  36                 protected:
  37                 // What kingdom this action is used for
  38                 ID kingdomID;
  39                 // lastID is used for some provisional error checking
  40                 ID lastType;
  41
  42                 public:
  43                         Action (ID kingdomID);
  44
  45                         virtual void
  46                         operator() (std::string rtext) =0;
  47         };
  48
  49         //typedef std::map <std::string, Action*> ActionList;
  50         class ActionList: public std::map <std::string, Action*>
  51         {
  52                 public:
  53                         ActionList ();
  54                         virtual ~ActionList ();
  55
  56                         Action*&
  57                         listItem (const char*);
  58         };
  59
  60
  61         class IDAction: public def::Action
  62         {
  63                 public:
  64                         IDAction (ID kingdomID);
  65
  66                         void
  67                         operator() (std::string rtext);
  68
  69         };
  70
  71
  72         class NameAction: public Action
  73         {
  74                 public:
  75                         NameAction (ID kingdomID);
  76
  77                         void
  78                         operator() (std::string rtext);
  79
  80         };
  81
  82
  83         class ModelAction: public Action
  84         {
  85                 public:
  86                         ModelAction (ID kingdomID);
  87
  88                         void
  89                         operator() (std::string rtext);
  90
  91         };
  92
  93
  94         class IconAction: public Action
  95         {
  96                 public:
  97                         IconAction (ID kingdomID);
  98
  99                         void
 100                         operator() (std::string rtext);
 101
 102         };
 103
 104
 105         class XAction: public Action
 106         {
 107                 public:
 108                         XAction (ID kingdomID);
 109
 110                         void
 111                         operator() (std::string rtext);
 112         };
 113
 114
 115         class YAction: public Action
 116         {
 117                 public:
 118                         YAction (ID kingdomID);
 119
 120                         void
 121                         operator() (std::string rtext);
 122 };
 123
 124
 125         class ZAction: public Action
 126         {
 127                 public:
 128                         ZAction (ID kingdomID);
 129
 130                         void
 131                         operator() (std::string rtext);
 132         };
 133
 134
 135         class ScaleAction: public Action
 136         {
 137                 public:
 138                         ScaleAction (ID kingdomID);
 139
 140                         void
 141                         operator() (std::string rtext);
 142         };
 143
 144
 145         class RAction: public Action
 146         {
 147                 public:
 148                         RAction (ID kingdomID);
 149
 150                         void
 151                         operator() (std::string rtext);
 152         };
 153
 154
 155         class GAction: public Action
 156         {
 157                 public:
 158                         GAction (ID kingdomID);
 159
 160                         void
 161                         operator() (std::string rtext);
 162         };
 163
 164
 165         class BAction: public Action
 166         {
 167                 public:
 168                         BAction (ID kingdomID);
 169
 170                         void
 171                         operator() (std::string rtext);
 172         };
 173
 174
 175         class ColorAction: public Action
 176         {
 177                 public:
 178                         ColorAction (ID kingdomID);
 179
 180                         void
 181                         operator() (std::string rtext);
 182         };
 183
 184         class AutofadeAction: public Action
 185         {
 186                 public:
 187                         AutofadeAction (ID kingdomID);
 188
 189                         void
 190                         operator() (std::string rtext);
 191         };
 192
 193         class AlphaAction: public Action
 194         {
 195                 public:
 196                         AlphaAction (ID kingdom);
 197
 198                         void
 199                         operator() (std::string rtext);
 200         };
 201
 202         class ShineAction: public Action
 203         {
 204                 public:
 205                         ShineAction (ID kingdom);
 206
 207                         void
 208                         operator() (std::string rtext);
 209         };
 210
 211
 212
 213
 214         namespace object
 215         {
 216                 //extern ActionList actionList;
 217                 class ActionList: public def::ActionList
 218                 {
 219                         public:
 220                                 ActionList ();
 221                 };
 222         }
 223
 224         namespace unit
 225         {
 226                 //extern ActionList actionList;
 227                 class ActionList: public def::ActionList
 228                 {
 229                         public:
 230                                 ActionList ();
 231                 };
 232         }
 233
 234         namespace item
 235         {
 236                 //extern ActionList actionList;
 237                 class ActionList: public def::ActionList
 238                 {
 239                         public:
 240                                 ActionList ();
 241                 };
 242         }
 243
 244 } /* namespace def */
 245
 246
 247 #endif /* STRANDED_DEFACTION_HH */