Shamusworld >> Repos - architektonas/blob - src/base/rs_variabledict.cpp

   1 // rs_variabledict.cpp
   2 //
   3 // Part of the Architektonas Project
   4 // Originally part of QCad Community Edition by Andrew Mustun
   5 // Extensively rewritten and refactored by James L. Hammons
   6 // (C) 2010 Underground Software
   7 //
   8 // JLH = James L. Hammons <jlhamm@acm.org>
   9 //
  10 // Who  When        What
  11 // ---  ----------  -----------------------------------------------------------
  12 // JLH  05/12/2010  Created this file. :-)
  13 //
  14
  15 #include "rs_variabledict.h"
  16
  17 /**
  18  * Constructor.
  19  */
  20 RS_VariableDict::RS_VariableDict()
  21 {
  22 #warning "!!! Need to deal with setAutoDelete() Qt3->Qt4 !!!"
  23 //      variables.setAutoDelete(true);
  24 }
  25
  26 /*virtual*/ RS_VariableDict::~RS_VariableDict()
  27 {
  28 }
  29
  30 /**
  31  * Removes all variables in the blocklist.
  32  */
  33 void RS_VariableDict::clear()
  34 {
  35         variables.clear();
  36 }
  37
  38 /**
  39  * @return Number of variables available.
  40  */
  41 int RS_VariableDict::count()
  42 {
  43         return variables.count();
  44 }
  45
  46 /**
  47  * Activates the given block.
  48  * Listeners are notified.
  49  */
  50 //void RS_VariableDict::activateBlock(const QString& name) {
  51 //      activateBlock(findBlock(name));
  52 //}
  53
  54 /**
  55  * Activates the given block.
  56  * Listeners are notified.
  57  */
  58 /*void RS_VariableDict::activateBlock(RS_Block* block) {
  59         activeBlock = block;
  60
  61         for (uint i=0; i<blockListListeners.count(); ++i) {
  62                 RS_VariableDictListener* l = blockListListeners.at(i);
  63
  64                 l->blockActivated(activeBlock);
  65         }
  66 }*/
  67
  68 /**
  69  * Adds a variable to the variable dictionary. If a variable with the
  70  * same name already exists, is will be overwritten.
  71  */
  72 void RS_VariableDict::add(const QString & key, const QString & value, int code)
  73 {
  74         RS_DEBUG->print("RS_VariableDict::addVariable()");
  75
  76         if (key.isEmpty())
  77         {
  78                 RS_DEBUG->print("RS_VariableDict::addVariable(): No empty keys allowed.", RS_Debug::D_WARNING);
  79                 return;
  80         }
  81
  82         variables.replace(key, new RS_Variable(value, code));
  83 }
  84
  85 /**
  86  * Adds a variable to the variable dictionary. If a variable with the
  87  * same name already exists, is will be overwritten.
  88  */
  89 void RS_VariableDict::add(const QString & key, int value, int code)
  90 {
  91         RS_DEBUG->print("RS_VariableDict::addVariable()");
  92
  93         if (key.isEmpty())
  94         {
  95                 RS_DEBUG->print("RS_VariableDict::addVariable(): No empty keys allowed.", RS_Debug::D_WARNING);
  96                 return;
  97         }
  98
  99         variables.replace(key, new RS_Variable(value, code));
 100 }
 101
 102 /**
 103  * Adds a variable to the variable dictionary. If a variable with the
 104  * same name already exists, is will be overwritten.
 105  */
 106 void RS_VariableDict::add(const QString & key, double value, int code)
 107 {
 108         RS_DEBUG->print("RS_VariableDict::addVariable()");
 109
 110         if (key.isEmpty())
 111         {
 112                 RS_DEBUG->print("RS_VariableDict::addVariable(): No empty keys allowed.", RS_Debug::D_WARNING);
 113                 return;
 114         }
 115
 116         variables.replace(key, new RS_Variable(value, code));
 117 }
 118
 119 /**
 120  * Adds a variable to the variable dictionary. If a variable with the
 121  * same name already exists, is will be overwritten.
 122  */
 123 void RS_VariableDict::add(const QString & key, const Vector & value, int code)
 124 {
 125         RS_DEBUG->print("RS_VariableDict::addVariable()");
 126
 127         if (key.isEmpty())
 128         {
 129                 RS_DEBUG->print("RS_VariableDict::addVariable(): No empty keys allowed.", RS_Debug::D_WARNING);
 130                 return;
 131         }
 132
 133         variables.replace(key, new RS_Variable(value, code));
 134 }
 135
 136 /**
 137  * Gets the value for the given variable.
 138  *
 139  * @param key Key of the variable.
 140  * @param def Default value.
 141  *
 142  * @return The value for the given variable or the given default value
 143  * if the variable couldn't be found.
 144  */
 145 Vector RS_VariableDict::getVector(const QString & key, const Vector & def)
 146 {
 147         Vector ret;
 148 //      RS_Variable * ptr = variables.find(key);
 149         RS_Variable * ptr = variables.value(key);
 150
 151         if (ptr == NULL || ptr->getType() != RS2::VariableVector)
 152                 ret = def;
 153         else
 154                 ret = ptr->getVector();
 155
 156         return ret;
 157 }
 158
 159 /**
 160  * Gets the value for the given variable.
 161  *
 162  * @param key Key of the variable.
 163  * @param def Default value.
 164  *
 165  * @return The value for the given variable or the given default value
 166  * if the variable couldn't be found.
 167  */
 168 QString RS_VariableDict::getString(const QString & key, const QString & def)
 169 {
 170         QString ret;
 171
 172         RS_DEBUG->print("RS_VariableDict::getString: 001");
 173         RS_DEBUG->print("RS_VariableDict::getString: key: '%s'", key.toLatin1().data());
 174
 175 //      RS_Variable * ptr = variables.find(key);
 176         RS_Variable * ptr = variables.value(key);
 177         RS_DEBUG->print("RS_VariableDict::getString: 002");
 178
 179         if (ptr == NULL)
 180         {
 181                 RS_DEBUG->print("RS_VariableDict::getString: 003");
 182                 ret = def;
 183         }
 184         else if (ptr->getType() != RS2::VariableString)
 185         {
 186                 RS_DEBUG->print("RS_VariableDict::getString: 004");
 187                 ret = def;
 188         }
 189         else
 190         {
 191                 RS_DEBUG->print("RS_VariableDict::getString: 005");
 192                 ret = ptr->getString();
 193         }
 194
 195         RS_DEBUG->print("RS_VariableDict::getString: 006");
 196
 197         return ret;
 198 }
 199
 200 /**
 201  * Gets the value as int for the given variable.
 202  *
 203  * @param key Key of the variable.
 204  * @param def Default value.
 205  *
 206  * @return The value for the given variable or the given default value
 207  * if the variable couldn't be found.
 208  */
 209 int RS_VariableDict::getInt(const QString & key, int def)
 210 {
 211         int ret;
 212 //      RS_Variable * ptr = variables.find(key);
 213         RS_Variable * ptr = variables.value(key);
 214
 215         if (ptr == NULL || ptr->getType() != RS2::VariableInt)
 216                 ret = def;
 217         else
 218                 ret = ptr->getInt();
 219
 220         return ret;
 221 }
 222
 223 /**
 224  * Gets the value as double for the given variable.
 225  *
 226  * @param key Key of the variable.
 227  * @param def Default value.
 228  *
 229  * @return The value for the given variable or the given default value
 230  * if the variable couldn't be found.
 231  */
 232 double RS_VariableDict::getDouble(const QString & key, double def)
 233 {
 234         double ret;
 235 //      RS_Variable * ptr = variables.find(key);
 236         RS_Variable * ptr = variables.value(key);
 237
 238         if (ptr == NULL || ptr->getType() != RS2::VariableDouble)
 239                 ret = def;
 240         else
 241                 ret = ptr->getDouble();
 242
 243         return ret;
 244 }
 245
 246 /**
 247  * Notifies the listeners about layers that were added. This can be
 248  * used after adding a lot of variables without auto-update.
 249  */
 250 /*
 251 void RS_VariableDict::addBlockNotification() {
 252     for (uint i=0; i<blockListListeners.count(); ++i) {
 253         RS_VariableDictListener* l = blockListListeners.at(i);
 254         l->blockAdded(NULL);
 255     }
 256 }
 257 */
 258
 259 /**
 260  * Removes a variable from the list.
 261  * TODO: Listeners are notified after the block was removed from
 262  * the list but before it gets deleted.
 263  */
 264 void RS_VariableDict::remove(const QString & key)
 265 {
 266         RS_DEBUG->print("RS_VariableDict::removeVariable()");
 267
 268         // here the block is removed from the list but not deleted
 269         variables.remove(key);
 270 }
 271
 272 //Q3Dict<RS_Variable> & RS_VariableDict::getVariableDict()
 273 QMultiHash<QString, RS_Variable *> & RS_VariableDict::getVariableDict()
 274 {
 275         return variables;
 276 }
 277
 278 /**
 279  * Dumps the variables to stdout.
 280  */
 281 std::ostream & operator<<(std::ostream & os, RS_VariableDict & d)
 282 {
 283         os << "Variables: \n";
 284 //      Q3DictIterator<RS_Variable> it(d.variables);
 285         QHashIterator<QString, RS_Variable *> it(d.variables);
 286
 287 //      for(; it.current(); ++it)
 288         while (it.hasNext())
 289         {
 290                 it.next();
 291 //Hmm, not sure about this...
 292 #warning "Not sure if this is correct usage (.toAscii().data())... !!! FIX !!!"
 293                 os << it.key().toAscii().data() << ": ";
 294                 switch (it.value()->getType())
 295                 {
 296                 case RS2::VariableVoid:
 297                         os << "void\n";
 298                         break;
 299                 case RS2::VariableInt:
 300                         os << "int " << it.value()->getInt() << "\n";
 301                         break;
 302                 case RS2::VariableDouble:
 303                         os << "double " << it.value()->getDouble() << "\n";
 304                         break;
 305                 case RS2::VariableVector:
 306                         os << "vector " << it.value()->getVector() << "\n";
 307                         break;
 308                 case RS2::VariableString:
 309                         os << "string " << it.value()->getString().toAscii().data() << "\n";
 310                         break;
 311                 }
 312         }
 313         os << std::endl;
 314
 315         return os;
 316 }