>xabsl   The Extensible Agent Behavior Specification Language
   start  | team  | language reference  | tools  | xabsl engine  | download  | licence 

XabslEngine Class Library Reference

 
Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | File List | Namespace Members | Class Members | File Members

XabslSymbols.cpp

Go to the documentation of this file.
00001 /**
00002 * @file XabslSymbols.cpp
00003 *
00004 * Implementation of class Symbols and helper classes
00005 *
00006 * @author <a href="http://www.martin-loetzsch.de">Martin Loetzsch</a>
00007 * @author <a href="http://www.sim.informatik.tu-darmstadt.de/pers/card/risler.html">Max Risler</a>
00008 */
00009 
00010 #include "XabslSymbols.h"
00011 
00012 namespace xabsl 
00013 {
00014 
00015 Enumeration::~Enumeration()
00016 {
00017   int i;
00018   for (i=0; i< enumElements.getSize(); i++)
00019   {
00020     delete enumElements[i];
00021   }
00022 }
00023 
00024 Symbols::~Symbols()
00025 {
00026   int i;
00027   for (i=0; i< enumerations.getSize(); i++) delete enumerations[i];
00028   for (i=0; i< decimalInputSymbols.getSize(); i++) delete decimalInputSymbols[i];
00029   for (i=0; i< booleanInputSymbols.getSize(); i++) delete booleanInputSymbols[i];
00030   for (i=0; i< enumeratedInputSymbols.getSize(); i++) delete enumeratedInputSymbols[i];
00031   for (i=0; i< decimalOutputSymbols.getSize(); i++) delete decimalOutputSymbols[i];
00032   for (i=0; i< booleanOutputSymbols.getSize(); i++) delete booleanOutputSymbols[i];
00033   for (i=0; i< enumeratedOutputSymbols.getSize(); i++) delete enumeratedOutputSymbols[i];
00034 }
00035 
00036 void Symbols::registerEnumElement(const char* symbolName, const char* name, int value)
00037 {
00038   XABSL_DEBUG_INIT(errorHandler.message("registering enum element \"%s\" for enumeration \"%s\"",name, symbolName));
00039 
00040   if (!enumerations.exists(symbolName))
00041   {
00042     enumerations.append(symbolName, new Enumeration(symbolName, enumerations.getSize()));
00043   }
00044   if (enumerations[symbolName]->enumElements.exists(name))
00045   {
00046     errorHandler.error("registerEnumElement(): enum element \"%s\" for enumeration \"%s\" was already registered.", name, symbolName);
00047     return;
00048   }
00049   enumerations[symbolName]->enumElements.append(name, new EnumElement(name,value));
00050 }
00051 
00052 void Symbols::registerDecimalInputSymbol(const char* name, const double* pVariable)
00053 {
00054   XABSL_DEBUG_INIT(errorHandler.message("registering decimal input symbol \"%s\"",name));
00055   
00056   if (decimalInputSymbols.exists(name))
00057   {
00058     errorHandler.error("registerDecimalInputSymbol(): symbol \"%s\" was already registered",name);
00059     return;
00060   }
00061   decimalInputSymbols.append(name,new DecimalInputSymbol(name, pVariable, errorHandler, decimalInputSymbols.getSize()));
00062 }
00063 
00064 
00065 void Symbols::registerDecimalInputSymbol
00066 (const char* name,
00067  double (*pFunction)())
00068 {
00069   XABSL_DEBUG_INIT(errorHandler.message("registering decimal input symbol \"%s\"",name));
00070   
00071   if (decimalInputSymbols.exists(name))
00072   {
00073     errorHandler.error("registerDecimalInputSymbol(): symbol \"%s\" was already registered",name);
00074     return;
00075   }
00076   decimalInputSymbols.append(name,new DecimalInputSymbol(name, pFunction, errorHandler, decimalInputSymbols.getSize()));
00077 }
00078 
00079 void Symbols::registerDecimalInputSymbolParametersChanged(const char* name,
00080     void (*pFunction)())
00081 {
00082   XABSL_DEBUG_INIT(errorHandler.message("registering parameter change notification for decimal input symbol\"%s\"",name));
00083 
00084   if (!decimalInputSymbols.exists(name))
00085   {
00086     errorHandler.error("registerDecimalInputSymbolParametersChanged(): symbol \"%s\" was not registered",name);
00087     return;
00088   }
00089 
00090   decimalInputSymbols[name]->pParametersChanged = pFunction;
00091 }
00092 
00093 void Symbols::registerDecimalInputSymbolDecimalParameter(const char* symbolName, 
00094     const char* name, double* pParam)
00095 {
00096   XABSL_DEBUG_INIT(errorHandler.message("registering decimal parameter \"%s\" for decimal input symbol\"%s\"",name, symbolName));
00097 
00098   if (!decimalInputSymbols.exists(symbolName))
00099   {
00100     errorHandler.error("registerDecimalInputSymbolDecimalParameter(): symbol \"%s\" was not registered",symbolName);
00101     return;
00102   }
00103   if (decimalInputSymbols[symbolName]->parameters.decimal.exists(name))
00104   {
00105     errorHandler.error("registerDecimalInputSymbolDecimalParameter(): parameter \"%s\" was already registered",name);
00106     return;
00107   }
00108 
00109   decimalInputSymbols[symbolName]->parameters.decimal.append(name,pParam);
00110 }
00111 
00112 void Symbols::registerDecimalInputSymbolBooleanParameter(const char* symbolName, 
00113     const char* name, bool* pParam)
00114 {
00115   XABSL_DEBUG_INIT(errorHandler.message("registering boolean parameter \"%s\" for decimal input symbol\"%s\"",name, symbolName));
00116 
00117   if (!decimalInputSymbols.exists(symbolName))
00118   {
00119     errorHandler.error("registerDecimalInputSymbolBooleanParameter(): symbol \"%s\" was not registered",symbolName);
00120     return;
00121   }
00122   if (decimalInputSymbols[symbolName]->parameters.boolean.exists(name))
00123   {
00124     errorHandler.error("registerDecimalInputSymbolBooleanParameter(): parameter \"%s\" was already registered",name);
00125     return;
00126   }
00127 
00128   decimalInputSymbols[symbolName]->parameters.boolean.append(name,pParam);
00129 }
00130 
00131 void Symbols::registerDecimalInputSymbolEnumeratedParameter(const char* symbolName, 
00132     const char* name, const char* enumName, int* pParam)
00133 {
00134   XABSL_DEBUG_INIT(errorHandler.message("registering enumerated parameter \"%s\" for decimal input symbol\"%s\"",name, symbolName));
00135 
00136   if (!decimalInputSymbols.exists(symbolName))
00137   {
00138     errorHandler.error("registerDecimalInputSymbolEnumeratedParameter(): symbol \"%s\" was not registered",symbolName);
00139     return;
00140   }
00141   if (decimalInputSymbols[symbolName]->parameters.enumerated.exists(name))
00142   {
00143     errorHandler.error("registerDecimalInputSymbolEnumeratedParameter(): parameter \"%s\" was already registered",name);
00144     return;
00145   }
00146 
00147   if (!enumerations.exists(enumName))
00148   {
00149     enumerations.append(enumName, new Enumeration(enumName, enumerations.getSize()));
00150   }
00151   decimalInputSymbols[symbolName]->parameters.enumerations.append(name,enumerations.getElement(enumName));
00152   decimalInputSymbols[symbolName]->parameters.enumerated.append(name,pParam);
00153 }
00154 
00155 void Symbols::registerBooleanInputSymbol(const char* name, const bool* pVariable)
00156 {
00157   XABSL_DEBUG_INIT(errorHandler.message("registering boolean input symbol \"%s\"",name));
00158   
00159   if (booleanInputSymbols.exists(name))
00160   {
00161     errorHandler.error("registerBooleanInputSymbol(): symbol \"%s\" was already registered",name);
00162     return;
00163   }
00164   booleanInputSymbols.append(name,new BooleanInputSymbol(name, pVariable, errorHandler, booleanInputSymbols.getSize()));
00165 }
00166 
00167 
00168 void Symbols::registerBooleanInputSymbol(const char* name,
00169                                                bool (*pFunction)())
00170 {
00171   XABSL_DEBUG_INIT(errorHandler.message("registering boolean input symbol \"%s\"",name));
00172   
00173   if (booleanInputSymbols.exists(name))
00174   {
00175     errorHandler.error("registerBooleanInputSymbol(): symbol \"%s\" was already registered",name);
00176     return;
00177   }
00178   booleanInputSymbols.append(name,new BooleanInputSymbol(name, pFunction, errorHandler, booleanInputSymbols.getSize()));
00179 }
00180 
00181 void Symbols::registerBooleanInputSymbolParametersChanged(const char* name,
00182     void (*pFunction)())
00183 {
00184   XABSL_DEBUG_INIT(errorHandler.message("registering parameter change notification for boolean input symbol\"%s\"",name));
00185 
00186   if (!booleanInputSymbols.exists(name))
00187   {
00188     errorHandler.error("registerBooleanInputSymbolParametersChanged(): symbol \"%s\" was not registered",name);
00189     return;
00190   }
00191 
00192   booleanInputSymbols[name]->pParametersChanged = pFunction;
00193 }
00194 
00195 void Symbols::registerBooleanInputSymbolDecimalParameter(const char* symbolName, 
00196     const char* name, double* pParam)
00197 {
00198   XABSL_DEBUG_INIT(errorHandler.message("registering decimal parameter \"%s\" for boolean input symbol\"%s\"",name, symbolName));
00199 
00200   if (!booleanInputSymbols.exists(symbolName))
00201   {
00202     errorHandler.error("registerBooleanInputSymbolDecimalParameter(): symbol \"%s\" was not registered",symbolName);
00203     return;
00204   }
00205   if (booleanInputSymbols[symbolName]->parameters.decimal.exists(name))
00206   {
00207     errorHandler.error("registerBooleanInputSymbolDecimalParameter(): parameter \"%s\" was already registered",name);
00208     return;
00209   }
00210 
00211   booleanInputSymbols[symbolName]->parameters.decimal.append(name,pParam);
00212 }
00213 
00214 void Symbols::registerBooleanInputSymbolBooleanParameter(const char* symbolName, 
00215     const char* name, bool* pParam)
00216 {
00217   XABSL_DEBUG_INIT(errorHandler.message("registering boolean parameter \"%s\" for boolean input symbol\"%s\"",name, symbolName));
00218 
00219   if (!booleanInputSymbols.exists(symbolName))
00220   {
00221     errorHandler.error("registerBooleanInputSymbolBooleanParameter(): symbol \"%s\" was not registered",symbolName);
00222     return;
00223   }
00224   if (booleanInputSymbols[symbolName]->parameters.boolean.exists(name))
00225   {
00226     errorHandler.error("registerBooleanInputSymbolBooleanParameter(): parameter \"%s\" was already registered",name);
00227     return;
00228   }
00229 
00230   booleanInputSymbols[symbolName]->parameters.boolean.append(name,pParam);
00231 }
00232 
00233 void Symbols::registerBooleanInputSymbolEnumeratedParameter(const char* symbolName, 
00234     const char* name, const char* enumName, int* pParam)
00235 {
00236   XABSL_DEBUG_INIT(errorHandler.message("registering enumerated parameter \"%s\" for boolean input symbol\"%s\"",name, symbolName));
00237 
00238   if (!booleanInputSymbols.exists(symbolName))
00239   {
00240     errorHandler.error("registerBooleanInputSymbolEnumeratedParameter(): symbol \"%s\" was not registered",symbolName);
00241     return;
00242   }
00243   if (booleanInputSymbols[symbolName]->parameters.enumerated.exists(name))
00244   {
00245     errorHandler.error("registerBooleanInputSymbolEnumeratedParameter(): parameter \"%s\" was already registered",name);
00246     return;
00247   }
00248   if (!enumerations.exists(enumName))
00249   {
00250     enumerations.append(enumName, new Enumeration(enumName, enumerations.getSize()));
00251   }
00252   booleanInputSymbols[symbolName]->parameters.enumerations.append(name,enumerations.getElement(enumName));
00253   booleanInputSymbols[symbolName]->parameters.enumerated.append(name,pParam);
00254 }
00255 
00256 void Symbols::registerEnumeratedInputSymbol(const char* name, const char* enumName, const int* pVariable)
00257 {
00258   XABSL_DEBUG_INIT(errorHandler.message("registering enumerated input symbol \"%s\"",name));
00259   
00260   if (enumeratedInputSymbols.exists(name))
00261   {
00262     errorHandler.error("registerEnumeratedInputSymbol(): symbol \"%s\" was already registered",name);
00263     return;
00264   }
00265   if (!enumerations.exists(enumName))
00266   {
00267     enumerations.append(enumName, new Enumeration(enumName, enumerations.getSize()));
00268   }
00269   enumeratedInputSymbols.append(name,new EnumeratedInputSymbol(name, enumerations[enumName], pVariable, errorHandler, enumeratedInputSymbols.getSize()));
00270 }
00271 
00272 void Symbols::registerEnumeratedInputSymbol(const char* name, const char* enumName,
00273     int (*pFunction)())
00274 {
00275   XABSL_DEBUG_INIT(errorHandler.message("registering enumerated input symbol \"%s\"",name));
00276   
00277   if (enumeratedInputSymbols.exists(name))
00278   {
00279     errorHandler.error("registerEnumeratedInputSymbol(): symbol \"%s\" was already registered",name);
00280     return;
00281   }
00282   if (!enumerations.exists(enumName))
00283   {
00284     enumerations.append(enumName, new Enumeration(enumName, enumerations.getSize()));
00285   }
00286   enumeratedInputSymbols.append(name,new EnumeratedInputSymbol(name, enumerations[enumName], pFunction, errorHandler, enumeratedInputSymbols.getSize()));
00287 }
00288 
00289 void Symbols::registerEnumeratedInputSymbolParametersChanged(const char* name,
00290     void (*pFunction)())
00291 {
00292   XABSL_DEBUG_INIT(errorHandler.message("registering parameter change notification for enumerated input symbol\"%s\"",name));
00293 
00294   if (!enumeratedInputSymbols.exists(name))
00295   {
00296     errorHandler.error("registerEnumeratedInputSymbolParametersChanged(): symbol \"%s\" was not registered",name);
00297     return;
00298   }
00299 
00300   enumeratedInputSymbols[name]->pParametersChanged = pFunction;
00301 }
00302 
00303 void Symbols::registerEnumeratedInputSymbolDecimalParameter(const char* symbolName, 
00304     const char* name, double* pParam)
00305 {
00306   XABSL_DEBUG_INIT(errorHandler.message("registering decimal parameter \"%s\" for enumerated input symbol\"%s\"",name, symbolName));
00307 
00308   if (!enumeratedInputSymbols.exists(symbolName))
00309   {
00310     errorHandler.error("registerEnumeratedInputSymbolDecimalParameter(): symbol \"%s\" was not registered",symbolName);
00311     return;
00312   }
00313   if (enumeratedInputSymbols[symbolName]->parameters.decimal.exists(name))
00314   {
00315     errorHandler.error("registerEnumeratedInputSymbolDecimalParameter(): parameter \"%s\" was already registered",name);
00316     return;
00317   }
00318 
00319   enumeratedInputSymbols[symbolName]->parameters.decimal.append(name,pParam);
00320 }
00321 
00322 void Symbols::registerEnumeratedInputSymbolBooleanParameter(const char* symbolName, 
00323     const char* name, bool* pParam)
00324 {
00325   XABSL_DEBUG_INIT(errorHandler.message("registering boolean parameter \"%s\" for enumerated input symbol\"%s\"",name, symbolName));
00326 
00327   if (!enumeratedInputSymbols.exists(symbolName))
00328   {
00329     errorHandler.error("registerEnumeratedInputSymbolBooleanParameter(): symbol \"%s\" was not registered",symbolName);
00330     return;
00331   }
00332   if (enumeratedInputSymbols[symbolName]->parameters.boolean.exists(name))
00333   {
00334     errorHandler.error("registerEnumeratedInputSymbolBooleanParameter(): parameter \"%s\" was already registered",name);
00335     return;
00336   }
00337 
00338   enumeratedInputSymbols[symbolName]->parameters.boolean.append(name,pParam);
00339 }
00340 
00341 void Symbols::registerEnumeratedInputSymbolEnumeratedParameter(const char* symbolName, 
00342     const char* name, const char* enumName, int* pParam)
00343 {
00344   XABSL_DEBUG_INIT(errorHandler.message("registering enumerated parameter \"%s\" for enumerated input symbol\"%s\"",name, symbolName));
00345 
00346   if (!enumeratedInputSymbols.exists(symbolName))
00347   {
00348     errorHandler.error("registerEnumeratedInputSymbolEnumeratedParameter(): symbol \"%s\" was not registered",symbolName);
00349     return;
00350   }
00351   if (enumeratedInputSymbols[symbolName]->parameters.enumerated.exists(name))
00352   {
00353     errorHandler.error("registerEnumeratedInputSymbolEnumeratedParameter(): parameter \"%s\" was already registered",name);
00354     return;
00355   }
00356   if (!enumerations.exists(enumName))
00357   {
00358     enumerations.append(enumName, new Enumeration(enumName, enumerations.getSize()));
00359   }
00360   enumeratedInputSymbols[symbolName]->parameters.enumerations.append(name,enumerations.getElement(enumName));
00361   enumeratedInputSymbols[symbolName]->parameters.enumerated.append(name,pParam);
00362 }
00363 
00364 void Symbols::registerDecimalOutputSymbol(const char* name, double* pVariable)
00365 {
00366   XABSL_DEBUG_INIT(errorHandler.message("registering decimal output symbol \"%s\"",name));
00367   
00368   if (decimalOutputSymbols.exists(name))
00369   {
00370     errorHandler.error("registerDcimalOutputSymbol(): symbol \"%s\" was already registered",name);
00371     return;
00372   }
00373   decimalOutputSymbols.append(name,new DecimalOutputSymbol(name, pVariable, decimalOutputSymbols.getSize()));
00374 }
00375 
00376 void Symbols::registerDecimalOutputSymbol(const char* name, 
00377   void (*pSetFunction)(double),
00378   double (*pGetFunction)()
00379 )
00380 {
00381   XABSL_DEBUG_INIT(errorHandler.message("registering decimal output symbol \"%s\"",name));
00382   
00383   if (decimalOutputSymbols.exists(name))
00384   {
00385     errorHandler.error("registerDecimalOutputSymbol(): symbol \"%s\" was already registered",name);
00386     return;
00387   }
00388   decimalOutputSymbols.append(name,new DecimalOutputSymbol(name, pSetFunction, pGetFunction, decimalOutputSymbols.getSize()));
00389 }
00390 
00391 void Symbols::registerBooleanOutputSymbol(const char* name, bool* pVariable)
00392 {
00393   XABSL_DEBUG_INIT(errorHandler.message("registering boolean output symbol \"%s\"",name));
00394   
00395   if (booleanOutputSymbols.exists(name))
00396   {
00397     errorHandler.error("registerBooleanOutputSymbol(): symbol \"%s\" was already registered",name);
00398     return;
00399   }
00400   booleanOutputSymbols.append(name,new BooleanOutputSymbol(name, pVariable, booleanOutputSymbols.getSize()));
00401 }
00402 
00403 void Symbols::registerBooleanOutputSymbol(const char* name,
00404   void (*pSetFunction)(bool),
00405   bool (*pGetFunction)()
00406 )
00407 {
00408   XABSL_DEBUG_INIT(errorHandler.message("registering boolean output symbol \"%s\"",name));
00409   
00410   if (booleanOutputSymbols.exists(name))
00411   {
00412     errorHandler.error("registerBooleanOutputSymbol(): symbol \"%s\" was already registered",name);
00413     return;
00414   }
00415   booleanOutputSymbols.append(name,new BooleanOutputSymbol(name, pSetFunction, pGetFunction, booleanOutputSymbols.getSize()));
00416 }
00417 
00418 void Symbols::registerEnumeratedOutputSymbol(const char* name, const char* enumName, int* pVariable)
00419 {
00420   XABSL_DEBUG_INIT(errorHandler.message("registering enumerated output symbol \"%s\"",name));
00421   
00422   if (enumeratedOutputSymbols.exists(name))
00423   {
00424     errorHandler.error("registerEnumeratedOutputSymbol(): symbol \"%s\" was already registered",name);
00425     return;
00426   }
00427   if (!enumerations.exists(enumName))
00428   {
00429     enumerations.append(enumName, new Enumeration(enumName, enumerations.getSize()));
00430   }
00431   enumeratedOutputSymbols.append(name,new EnumeratedOutputSymbol(name, enumerations[enumName], pVariable, enumeratedOutputSymbols.getSize()));
00432 }
00433 
00434 void Symbols::registerEnumeratedOutputSymbol(const char* name, const char* enumName,
00435   void (*pSetFunction)(int),
00436   int (*pGetFunction)()
00437 )
00438 {
00439   XABSL_DEBUG_INIT(errorHandler.message("registering enumerated output symbol \"%s\"",name));
00440   
00441   if (enumeratedOutputSymbols.exists(name))
00442   {
00443     errorHandler.error("registerEnumeratedOutputSymbol(): symbol \"%s\" was already registered",name);
00444     return;
00445   }
00446   if (!enumerations.exists(enumName))
00447   {
00448     enumerations.append(enumName, new Enumeration(enumName, enumerations.getSize()));
00449   }
00450   enumeratedOutputSymbols.append(name,new EnumeratedOutputSymbol(name, enumerations[enumName], pSetFunction, pGetFunction, enumeratedOutputSymbols.getSize()));
00451 }
00452 
00453 void Symbols::resetOutputSymbols()
00454 {
00455   for (int i=0;i<decimalOutputSymbols.getSize();i++)
00456     decimalOutputSymbols[i]->activeValueWasSet = false;
00457   for (int i=0;i<booleanOutputSymbols.getSize();i++)
00458     booleanOutputSymbols[i]->activeValueWasSet = false;
00459   for (int i=0;i<enumeratedOutputSymbols.getSize();i++)
00460     enumeratedOutputSymbols[i]->activeValueWasSet = false;
00461 }
00462 
00463 } // namespace
00464

Up | Main Page | Generated at Wed Aug 19 17:32:29 2009.

 
Copyright 2002 - 2009 by the XABSL developer team. See the licence for details.