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

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