>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

XabslParameters.cpp

Go to the documentation of this file.
00001 /** 
00002 * @file XabslParameters.cpp
00003 *
00004 * Implementation of class Parameters 
00005 *
00006 * @author <a href="http://www.sim.informatik.tu-darmstadt.de/pers/card/risler.html">Max Risler</a>
00007 */
00008 
00009 #include "XabslParameters.h"
00010 #include "XabslSymbols.h"
00011 #include "XabslOption.h"
00012 #include "XabslDecimalExpression.h"
00013 #include "XabslBooleanExpression.h"
00014 #include "XabslEnumeratedExpression.h"
00015 
00016 namespace xabsl 
00017 {
00018 
00019 void Parameters::reset()
00020 {
00021   for (int i=0; i<decimal.getSize(); i++) *decimal[i] = 0; 
00022   for (int i=0; i<boolean.getSize(); i++) *boolean[i] = false; 
00023   for (int i=0; i<enumerated.getSize(); i++) *enumerated[i] = enumerations[i]->enumElements[0]->v; 
00024 }
00025 
00026 void Parameters::registerEnumerations(NamedArray<Enumeration*>& enumerations)
00027 {
00028   pEnumerations = &enumerations;
00029 }
00030 
00031 void Parameters::registerDecimal(const char* name, double& parameter)
00032 {
00033   XABSL_DEBUG_INIT(errorHandler.message("registering decimal parameter \"%s\"",name));
00034   
00035   if (decimal.exists(name))
00036   {
00037     errorHandler.error("registerDecimalParameter(): decimal parameter \"%s\" was already registered",name);
00038     return;
00039   }
00040   decimal.append(name,&parameter);
00041   parameter = 0;
00042 }
00043 
00044 void Parameters::registerBoolean(const char* name, bool& parameter)
00045 {
00046   XABSL_DEBUG_INIT(errorHandler.message("registering boolean parameter \"%s\"",name));
00047   
00048   if (boolean.exists(name))
00049   {
00050     errorHandler.error("registerBooleanParameter(): boolean parameter \"%s\" was already registered",name);
00051     return;
00052   }
00053   boolean.append(name,&parameter);
00054   parameter = false;
00055 }
00056 
00057 void Parameters::registerEnumerated(const char* name, const char* enumName, int& parameter)
00058 {
00059   XABSL_DEBUG_INIT(errorHandler.message("registering enumerated parameter \"%s\"",name));
00060   
00061   if (pEnumerations == 0)
00062   {
00063     errorHandler.error("XabslParameters::registerEnumerated(): call Parameters::registerEnumerations first");
00064     return;
00065   }
00066   if (enumerated.exists(name))
00067   {
00068     errorHandler.error("XabslParameters::registerEnumerated(): enumerated parameter \"%s\" was already registered",name);
00069     return;
00070   }
00071   if (!pEnumerations->exists(enumName))
00072   {
00073     errorHandler.error("XabslParameters::registerEnumerated(): enumeration \"%s\" was not registered",enumName);
00074     return;
00075   }
00076   const Enumeration* enumeration = (*pEnumerations)[enumName];
00077   if (enumeration->enumElements.getSize() == 0)
00078   {
00079     errorHandler.error("XabslParameters::registerEnumerated(): no enumeration elements for \"%s\" were registered",enumName);
00080     return;
00081   }
00082 
00083   enumerations.append(name, enumeration);
00084   enumerated.append(name,&parameter);
00085 
00086   parameter = enumeration->enumElements[0]->v;
00087 }
00088 
00089 ParameterAssignment::ParameterAssignment(
00090   Parameters* refParameters,
00091   ErrorHandler& errorHandler) :
00092     Parameters(errorHandler)
00093 {
00094   for (int i = 0; i < refParameters->decimal.getSize(); i++)
00095   {
00096     decimal.append(refParameters->decimal.getName(i), refParameters->decimal.getElement(i));
00097     decimalValues.append(refParameters->decimal.getName(i), 0);
00098     decimalExpressions.append(refParameters->decimal.getName(i), new DecimalValue(0));
00099   }
00100   for (int i = 0; i < refParameters->boolean.getSize(); i++)
00101   {
00102     boolean.append(refParameters->boolean.getName(i), refParameters->boolean.getElement(i));
00103     booleanValues.append(refParameters->boolean.getName(i), false);
00104     booleanExpressions.append(refParameters->boolean.getName(i), new BooleanValue(false));
00105   }
00106   for (int i = 0; i < refParameters->enumerated.getSize(); i++)
00107   {
00108     enumerated.append(refParameters->enumerated.getName(i), refParameters->enumerated.getElement(i));
00109     enumeratedValues.append(refParameters->enumerated.getName(i), false);
00110     enumeratedExpressions.append(refParameters->enumerated.getName(i), new EnumeratedValue(refParameters->enumerations[i], 0));
00111   }
00112 }
00113     
00114 void ParameterAssignment::create(
00115     InputSource& input,    
00116     Symbols& symbols,
00117     Option& option,
00118     State& state)
00119 {
00120   int i;
00121   // read the parameters 
00122   int numberOfParameters = (int)input.readValue();
00123   
00124   for (i = 0; i<numberOfParameters; i++)
00125   {
00126     char c[2];
00127     char buf[100];
00128     input.readString(c,1);
00129     switch(c[0])
00130     {
00131       case 'd':
00132         {
00133           input.readString(buf,99);
00134           XABSL_DEBUG_INIT(errorHandler.message("creating expession for set decimal parameter \"%s\"",buf));
00135           
00136           const DecimalExpression* exp = DecimalExpression::create(input,errorHandler,symbols,option,state);
00137           if (errorHandler.errorsOccurred)
00138           {
00139             errorHandler.error("XabslParameterAssignment::create(): could not create decimal expression for parameter \"%s\"",buf);
00140             return;
00141           }
00142           if (!setDecimalParameter(buf, exp)) return;
00143         }
00144         break;
00145       case 'b':
00146         {
00147           input.readString(buf,99);
00148           XABSL_DEBUG_INIT(errorHandler.message("creating expession for set boolean parameter \"%s\"",buf));
00149           
00150           const BooleanExpression* exp = BooleanExpression::create(input,errorHandler,symbols,option,state);
00151           if (errorHandler.errorsOccurred)
00152           {
00153             errorHandler.error("XabslParameterAssignment::create(): could not create boolean expression for parameter \"%s\"",buf);
00154             return;
00155           }
00156           if (!setBooleanParameter(buf, exp)) return;
00157         }
00158         break;
00159       case 'e':
00160         {
00161           input.readString(buf,99);
00162           if(!symbols.enumerations.exists(buf))
00163           {
00164             errorHandler.error("XabslParameterAssignment::create(): enumeration \"%s\" was not registered",buf);
00165             return;
00166           }
00167           const Enumeration* enumeration = symbols.enumerations[buf];
00168 
00169           input.readString(buf,99);
00170 
00171           XABSL_DEBUG_INIT(errorHandler.message("creating expession for set enumerated parameter \"%s\"",buf));
00172           const EnumeratedExpression* exp = EnumeratedExpression::create(enumeration,input,errorHandler,symbols,option,state);
00173           if (errorHandler.errorsOccurred)
00174           {
00175             errorHandler.error("XabslParameterAssignment::create(): could not create enumerated expression for parameter \"%s\"",buf);
00176             return;
00177           }
00178           
00179           if (!setEnumeratedParameter(buf, exp)) return;
00180         }
00181         break;
00182     }
00183   }
00184 }
00185 
00186 ParameterAssignment::~ParameterAssignment()
00187 {
00188   for (int i=0; i<decimalExpressions.getSize(); i++)
00189     delete decimalExpressions[i];
00190   for (int i=0; i<booleanExpressions.getSize(); i++)
00191     delete booleanExpressions[i];
00192   for (int i=0; i<enumeratedExpressions.getSize(); i++)
00193     delete enumeratedExpressions[i];
00194 }
00195 
00196 bool ParameterAssignment::setDecimalParameter(const char* param, const DecimalExpression* exp)
00197 {
00198   if (!decimalExpressions.exists(param))
00199   {
00200     errorHandler.error("XabslParameterAssignment::setDecimalParameter(): decimal parameter \"%s\" does not exist", param);
00201     delete exp;
00202     return false;
00203   }
00204   delete decimalExpressions[param];
00205   decimalExpressions.setElement(param, exp);
00206 
00207   return true;
00208 }
00209 
00210 bool ParameterAssignment::setBooleanParameter(const char* param, const BooleanExpression* exp)
00211 {
00212   if (!booleanExpressions.exists(param))
00213   {
00214     errorHandler.error("XabslParameterAssignment::setBooleanParameter(): boolean parameter \"%s\" does not exist",param);
00215     delete exp;
00216     return false;
00217   }
00218   delete booleanExpressions[param];
00219   booleanExpressions.setElement(param, exp);
00220 
00221   return true;
00222 }
00223 
00224 bool ParameterAssignment::setEnumeratedParameter(const char* param, const EnumeratedExpression* exp)
00225 {
00226   if (!enumeratedExpressions.exists(param))
00227   {
00228     errorHandler.error("XabslParameterAssignment::create(): enumerated parameter \"%s\" does not exist",param);
00229     delete exp;
00230     return false;
00231   }
00232   if (exp->enumeration != enumeratedExpressions[param]->enumeration)
00233   {
00234     errorHandler.error("XabslParameterAssignment::create(): type mismatch on enumerated parameter \"%s\", expected \"%s\", found \"%s\"", param, enumeratedExpressions[param]->enumeration->n, exp->enumeration->n);
00235     return false;
00236   }
00237   delete enumeratedExpressions[param];
00238   enumeratedExpressions.setElement(param, exp);
00239 
00240   return true;
00241 }
00242 
00243 bool ParameterAssignment::setDecimalParameter(const char* param, double value)
00244 {
00245   return setDecimalParameter(param, new DecimalValue(value));
00246 }
00247 
00248 bool ParameterAssignment::setBooleanParameter(const char* param, bool value)
00249 {
00250   return setBooleanParameter(param, new BooleanValue(value));
00251 }
00252 
00253 bool ParameterAssignment::setEnumeratedParameter(const char* param, const Enumeration* enumeration, int value)
00254 {
00255   return setEnumeratedParameter(param, new EnumeratedValue(enumeration, value));
00256 }
00257 
00258 bool ParameterAssignment::setEnumeratedParameter(const char* param, const char* value)
00259 {
00260   if (!enumeratedExpressions.exists(param))
00261   {
00262     return false;
00263   }
00264   else if (!enumeratedExpressions[param]->enumeration->enumElements.exists(value))
00265   {
00266     return false;
00267   }
00268   else 
00269   { 
00270     return setEnumeratedParameter(param, enumeratedExpressions[param]->enumeration, enumeratedExpressions[param]->enumeration->enumElements[value]->v);
00271   }
00272 }
00273 
00274 bool ParameterAssignment::set()
00275 {
00276   int i;
00277   bool parametersChanged = false;
00278  
00279   // Set the parameters.
00280   for (i=0; i<decimal.getSize(); i++)
00281   {
00282     decimalValues.setElement(i, decimalExpressions[i]->getValue());
00283     if (*decimal[i] != decimalValues[i])
00284     {
00285       parametersChanged = true;
00286       *decimal[i] = decimalValues[i];
00287     }
00288   }
00289   for (i=0; i<boolean.getSize(); i++)
00290   {
00291     booleanValues.setElement(i, booleanExpressions[i]->getValue());
00292     if (*boolean[i] != booleanValues[i])
00293     {
00294       parametersChanged = true;
00295       *boolean[i] = booleanValues[i];
00296     }
00297   }
00298   for (i=0; i<enumerated.getSize(); i++)
00299   {
00300     enumeratedValues.setElement(i, enumeratedExpressions[i]->getValue());
00301     if (*enumerated[i] != enumeratedValues[i])
00302     {
00303       parametersChanged = true;
00304       *enumerated[i] = enumeratedValues[i];
00305     }
00306   }
00307 
00308   return parametersChanged;
00309 }
00310 
00311 } // namespace
00312

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.