>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

XabslBooleanExpression.cpp

Go to the documentation of this file.
00001 /** 
00002 * @file XabslBooleanExpression.cpp
00003 *
00004 * Implementation of BooleanExpression and derivates
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 "XabslBooleanExpression.h"
00011 #include "XabslOption.h"
00012 
00013 namespace xabsl 
00014 {
00015   
00016 BooleanExpression::~BooleanExpression()
00017 {
00018 }
00019 
00020 BooleanExpression* BooleanExpression::create(InputSource& input, 
00021                                                          ErrorHandler& errorHandler,
00022                                                          Symbols& symbols,
00023                                                          Option& option,
00024                                                          State& state)
00025 {
00026   char c[100];
00027   BooleanExpression* booleanOperand = 0;
00028   DecimalExpression* decimalOperand1 = 0;
00029   DecimalExpression* decimalOperand2 = 0;
00030   RelationalAndEqualityOperator* relationalAndEqualityOperator = 0;
00031   input.readString(c,1);
00032   
00033   switch (*c)
00034   {
00035   case 'v':
00036     return new BooleanValue(input,errorHandler);
00037   case 'p':
00038     return new BooleanOptionParameterRef(input,errorHandler,option);
00039   case 'i':
00040     return new BooleanInputSymbolRef(input,errorHandler,symbols,option,state);
00041   case 'o':
00042     return new BooleanOutputSymbolRef(input,errorHandler,symbols);
00043   case 't':
00044     return new SubsequentOptionReachedTargetStateCondition(errorHandler, state);
00045   case 'c':
00046     return new EnumeratedInputSymbolComparison(input, errorHandler, symbols, option, state);
00047   case '&':
00048     {
00049       XABSL_DEBUG_INIT(errorHandler.message("creating and operator"));
00050       
00051       int numberOfOperands = (int)input.readValue();
00052       
00053       AndOperator* andOperator = new AndOperator();
00054       
00055       for (int i=0; i<numberOfOperands; i++)
00056       {
00057         if (!BooleanExpression::createOperand(booleanOperand, input, errorHandler, symbols, option, state))
00058         {
00059           delete andOperator;
00060           return 0;
00061         }
00062         
00063         andOperator->addOperand(booleanOperand);
00064       }
00065       
00066       return andOperator;
00067     }
00068   case '|':
00069     {
00070       XABSL_DEBUG_INIT(errorHandler.message("creating or operator"));
00071       
00072       int numberOfOperands = (int)input.readValue();
00073       
00074       OrOperator* orOperator = new OrOperator();
00075       
00076       for (int i=0; i<numberOfOperands; i++)
00077       {
00078         if (!BooleanExpression::createOperand(booleanOperand, input, errorHandler, symbols, option, state))
00079         {
00080           delete orOperator;
00081           return 0;
00082         }
00083         orOperator->addOperand(booleanOperand);
00084       }
00085       
00086       return orOperator;
00087     }
00088   case '!':
00089     XABSL_DEBUG_INIT(errorHandler.message("creating not operator"));
00090     
00091     if (!BooleanExpression::createOperand(booleanOperand, input, errorHandler, symbols, option, state))
00092       return 0;
00093     
00094     return new NotOperator(booleanOperand);
00095   case '=':
00096     XABSL_DEBUG_INIT(errorHandler.message("creating == operator"));
00097     
00098     if (!DecimalExpression::createOperand(decimalOperand1,input, errorHandler, symbols, option, state))
00099       return 0;
00100     
00101     if (!DecimalExpression::createOperand(decimalOperand2,input, errorHandler, symbols, option, state))
00102       return 0;
00103     
00104     relationalAndEqualityOperator = new EqualToOperator();
00105     relationalAndEqualityOperator->create(decimalOperand1,decimalOperand2);
00106     return relationalAndEqualityOperator;
00107   case 'n':
00108     XABSL_DEBUG_INIT(errorHandler.message("creating != operator"));
00109     
00110     if (!DecimalExpression::createOperand(decimalOperand1,input,errorHandler,symbols,option,state))
00111       return 0;
00112     
00113     if (!DecimalExpression::createOperand(decimalOperand2,input,errorHandler,symbols,option,state))
00114       return 0;
00115     
00116     relationalAndEqualityOperator = new NotEqualToOperator();
00117     relationalAndEqualityOperator->create(decimalOperand1,decimalOperand2);
00118     return relationalAndEqualityOperator;
00119   case '<':
00120     XABSL_DEBUG_INIT(errorHandler.message("creating < operator"));
00121     
00122     if (!DecimalExpression::createOperand(decimalOperand1,input,errorHandler,symbols,option,state))
00123       return 0;
00124     
00125     if (!DecimalExpression::createOperand(decimalOperand2,input,errorHandler,symbols,option,state))
00126       return 0;
00127     
00128     relationalAndEqualityOperator = new LessThanOperator();
00129     relationalAndEqualityOperator->create(decimalOperand1,decimalOperand2);
00130     return relationalAndEqualityOperator;
00131   case 'l':
00132     XABSL_DEBUG_INIT(errorHandler.message("creating <= operator"));
00133     
00134     if (!DecimalExpression::createOperand(decimalOperand1,input,errorHandler, symbols, option, state))
00135       return 0;
00136     
00137     if (!DecimalExpression::createOperand(decimalOperand2,input,errorHandler, symbols, option, state))
00138       return 0;
00139     
00140     relationalAndEqualityOperator = new LessThanOrEqualToOperator();
00141     relationalAndEqualityOperator->create(decimalOperand1,decimalOperand2);
00142     return relationalAndEqualityOperator;
00143   case '>':
00144     XABSL_DEBUG_INIT(errorHandler.message("creating > operator"));
00145     
00146     if (!DecimalExpression::createOperand(decimalOperand1,input,errorHandler, symbols, option, state))
00147       return 0;
00148     
00149     if (!DecimalExpression::createOperand(decimalOperand2,input,errorHandler, symbols, option, state))
00150       return 0;
00151     
00152     relationalAndEqualityOperator = new GreaterThanOperator();
00153     relationalAndEqualityOperator->create(decimalOperand1,decimalOperand2);
00154     return relationalAndEqualityOperator;
00155   case 'g':
00156     XABSL_DEBUG_INIT(errorHandler.message("creating >= operator"));
00157     
00158     if (!DecimalExpression::createOperand(decimalOperand1,input,errorHandler, symbols, option, state))
00159       return 0;
00160     
00161     if (!DecimalExpression::createOperand(decimalOperand2,input,errorHandler, symbols, option, state))
00162       return 0;
00163     
00164     relationalAndEqualityOperator = new GreaterThanOrEqualToOperator();
00165     relationalAndEqualityOperator->create(decimalOperand1,decimalOperand2);
00166     return relationalAndEqualityOperator;
00167   case 'x':
00168     return new ConflictCondition(errorHandler, state);
00169   default:
00170     errorHandler.error("XabslBooleanExpression::create(): unknown expression type \"%c\"",*c);
00171   }
00172   return 0;
00173 }
00174 
00175 bool BooleanExpression::createOperand(BooleanExpression*& operand,
00176                                             InputSource& input, 
00177                                             ErrorHandler& errorHandler,
00178                                             Symbols& symbols,
00179                                             Option& option,
00180                                             State& state)
00181 {
00182   operand = BooleanExpression::create(input,errorHandler,symbols,option,state);
00183   
00184   if (operand == 0) 
00185   {
00186     errorHandler.error("XabslBooleanExpression::createOperand(): created operand is 0");
00187     return false;
00188   }
00189   
00190   if (errorHandler.errorsOccurred)
00191   {
00192     errorHandler.error("XabslBooleanExpression::createOperand(): could not create operand");
00193     if (operand != 0) delete operand;
00194     return false;
00195   }
00196   
00197   return true;
00198 }
00199 
00200 BooleanValue::BooleanValue(InputSource& input, 
00201                                        ErrorHandler& errorHandler)
00202 {
00203   char buf[6];
00204   input.readString(buf,5);
00205 
00206   value = (strcmp("true",buf) == 0);
00207   
00208   XABSL_DEBUG_INIT(errorHandler.message("created boolean value: \"%s\"",value?"true":"false"));
00209 }
00210 
00211 bool BooleanValue::getValue() const
00212 {
00213   return value;
00214 }
00215 
00216 BooleanOptionParameterRef::BooleanOptionParameterRef(InputSource& input, 
00217                                                    ErrorHandler& errorHandler,
00218                                                    Option& option)
00219 {
00220   char buf[100];
00221   input.readString(buf,99);
00222   
00223   XABSL_DEBUG_INIT(errorHandler.message("creating a reference to boolean option parameter \"%s\"",buf));
00224   
00225   if (!option.parameters->boolean.exists(buf))
00226   {
00227     errorHandler.error("XabslBooleanOptionParameterRef::BooleanOptionParameterRef(): boolean option parameter \"%s\" does not exist",buf);
00228     return;
00229   }
00230   
00231   parameter = option.parameters->boolean.getPElement(buf)->e;
00232 }
00233 
00234 bool BooleanOptionParameterRef::getValue() const
00235 {
00236   return *parameter;
00237 }
00238 
00239 AndOperator::AndOperator() 
00240 {
00241   operands.clear();
00242 }
00243 
00244 AndOperator::~AndOperator()
00245 {
00246   for (int i=0; i< operands.getSize(); i++)
00247   {
00248     if (operands[i]!=0) delete operands[i];
00249   }
00250 }
00251 
00252 bool AndOperator::getValue() const
00253 {
00254   for (int i=0; i< operands.getSize(); i++)
00255   {
00256     if (operands[i]->getValue() == false) return false;
00257   }
00258   return true;
00259 }
00260 
00261 void AndOperator::addOperand(BooleanExpression* operand)
00262 {
00263   operands.append(operand);
00264 }
00265 
00266 OrOperator::OrOperator() 
00267 {
00268   operands.clear();
00269 }
00270 
00271 OrOperator::~OrOperator()
00272 {
00273   for (int i=0; i< operands.getSize(); i++)
00274   {
00275     if (operands[i]!=0) delete operands[i];
00276   }
00277 }
00278 
00279 bool OrOperator::getValue() const
00280 {
00281   for (int i=0; i< operands.getSize(); i++)
00282   {
00283     if (operands[i]->getValue() == true) return true;
00284   }
00285   return false;
00286 }
00287 
00288 void OrOperator::addOperand(BooleanExpression* operand)
00289 {
00290   operands.append(operand);
00291 }
00292 
00293 NotOperator::NotOperator(BooleanExpression* operand1) :
00294 operand1(operand1)
00295 {
00296 }
00297 
00298 NotOperator::~NotOperator()
00299 {
00300   if (operand1!=0) delete operand1;
00301 }
00302 
00303 bool NotOperator::getValue() const
00304 {
00305   return !(operand1->getValue());
00306 }
00307 
00308 BooleanInputSymbolRef::BooleanInputSymbolRef(InputSource& input, 
00309                                                                ErrorHandler& errorHandler,
00310                                                                Symbols& symbols,
00311                                                                Option& option,
00312                                                                State& state) :
00313   symbol(0), parameters(0)
00314 {
00315   char buf[100];
00316   input.readString(buf,99);
00317   
00318   XABSL_DEBUG_INIT(errorHandler.message("creating reference to boolean input symbol \"%s\"",buf));
00319   
00320   if (!symbols.booleanInputSymbols.exists(buf))
00321   {
00322     errorHandler.error("XabslBooleanInputSymbolRef::XabslBooleanInputSymbolRef(): boolean input symbol \"%s\" was not registered at the engine",buf);
00323     return;
00324   }
00325   
00326   symbol = symbols.booleanInputSymbols[buf];
00327 
00328   parameters = new ParameterAssignment(&symbol->parameters, errorHandler);
00329 
00330   parameters->create(input, symbols, option, state);
00331 }
00332   
00333 BooleanInputSymbolRef::~BooleanInputSymbolRef()
00334 {
00335   if (parameters != 0)
00336     delete parameters;
00337 }
00338 
00339 bool BooleanInputSymbolRef::getValue() const
00340 {
00341   // set the symbol parameters
00342   if (parameters->set())
00343     symbol->parametersChanged();
00344 
00345   return symbol->getValue();
00346 }
00347 
00348 BooleanOutputSymbolRef::BooleanOutputSymbolRef(InputSource& input, 
00349                                                                ErrorHandler& errorHandler,
00350                                                                Symbols& symbols)
00351 {
00352   char buf[100];
00353   input.readString(buf,99);
00354   
00355   XABSL_DEBUG_INIT(errorHandler.message("creating a reference to a boolean output symbol \"%s\"",buf));
00356   
00357   if (!symbols.booleanOutputSymbols.exists(buf))
00358   {
00359     errorHandler.error("XabslBooleanOutputSymbolRef::BooleanOutputSymbolRef(): boolean output symbol \"%s\" was not registered",buf);
00360     return;
00361   }
00362   
00363   symbol = symbols.booleanOutputSymbols[buf];
00364 }
00365 
00366 bool BooleanOutputSymbolRef::getValue() const
00367 {
00368   return symbol->getValue();
00369 }
00370 
00371 SubsequentOptionReachedTargetStateCondition::SubsequentOptionReachedTargetStateCondition(
00372                                                    ErrorHandler& errorHandler,
00373                                                    State& state)
00374                                                    : state(state)
00375 {
00376   XABSL_DEBUG_INIT(errorHandler.message("creating a \"subsequent-option-reached-target-state\" element"));
00377 }
00378 
00379 bool SubsequentOptionReachedTargetStateCondition::getValue() const
00380 {
00381   bool anySubsequentBehaviorReachedTargetState = false;
00382   for (int i = 0; i < state.actions.getSize(); i++)
00383     if (ActionOption* subsequentAction = dynamic_cast<ActionOption*>(state.actions[i]))
00384       if (subsequentAction->option->getOptionReachedATargetState())
00385         anySubsequentBehaviorReachedTargetState = true;
00386   return anySubsequentBehaviorReachedTargetState;
00387 }
00388 
00389 ConflictCondition::ConflictCondition(
00390                                    ErrorHandler& errorHandler,
00391                                    State& state)
00392                                    : state(state)
00393 {
00394   XABSL_DEBUG_INIT(errorHandler.message("creating a \"conflict\" element"));
00395 }
00396 
00397 bool ConflictCondition::getValue() const
00398 {
00399   return state.getConflict();
00400 }
00401 
00402 EnumeratedInputSymbolComparison::EnumeratedInputSymbolComparison(InputSource& input,
00403   ErrorHandler& errorHandler,
00404   Symbols& symbols,
00405   Option& option,
00406   State& state)
00407 {
00408   if (!EnumeratedExpression::createOperand(operand1,NULL,input,errorHandler,symbols,option,state))
00409   {
00410     errorHandler.error("XabslEnumeratedInputSymbolComparison::EnumeratedInputSymbolComparison(): could not create enumerated expression");
00411     operand1 = operand2 = 0;
00412     return;
00413   }
00414   if (!EnumeratedExpression::createOperand(operand2,operand1->enumeration,input,errorHandler,symbols,option,state))
00415   {
00416     errorHandler.error("XabslEnumeratedInputSymbolComparison::EnumeratedInputSymbolComparison(): could not create enumerated expression");
00417     operand2 = 0;
00418     return;
00419   }
00420 }
00421 
00422 EnumeratedInputSymbolComparison::~EnumeratedInputSymbolComparison()
00423 {
00424   if (operand1!=0) delete operand1;
00425   if (operand2!=0) delete operand2;
00426 }
00427 
00428 bool EnumeratedInputSymbolComparison::getValue() const
00429 {
00430   return (operand1->getValue() == operand2->getValue());
00431 }
00432 
00433 void RelationalAndEqualityOperator::create(DecimalExpression* operand1,
00434                                                  DecimalExpression* operand2)
00435 {
00436   this->operand1 = operand1;
00437   this->operand2 = operand2;
00438 }
00439 
00440 RelationalAndEqualityOperator ::~RelationalAndEqualityOperator ()
00441 {
00442   if (operand1!=0) delete operand1;
00443   if (operand2!=0) delete operand2;
00444 }
00445 
00446 bool EqualToOperator::getValue() const
00447 {
00448   return (operand1->getValue() == operand2->getValue());
00449 }
00450 
00451 bool NotEqualToOperator::getValue() const
00452 {
00453   return (operand1->getValue() != operand2->getValue());
00454 }
00455 
00456 bool LessThanOperator::getValue() const
00457 {
00458   return (operand1->getValue() < operand2->getValue());
00459 }
00460 
00461 bool LessThanOrEqualToOperator::getValue() const
00462 {
00463   return (operand1->getValue() <= operand2->getValue());
00464 }
00465 
00466 bool GreaterThanOperator::getValue() const
00467 {
00468   return (operand1->getValue() > operand2->getValue());
00469 }
00470 
00471 bool GreaterThanOrEqualToOperator::getValue() const
00472 {
00473   return (operand1->getValue() >= operand2->getValue());
00474 }
00475 
00476 } // namespace
00477

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

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