Tools/Xabsl2/Xabsl2Engine/Xabsl2Engine.cpp

Go to the documentation of this file.

/** 
* @file Xabsl2Engine.cpp
*
* Implementation of class Xabsl2Engine
*
* @author Matthias Jüngel
* @author Martin Lötzsch
*/

#include "Xabsl2Engine.h"

Xabsl2Engine::Xabsl2Engine(Xabsl2ErrorHandler& e,unsigned long (*pTimeFunction)())
: Xabsl2Symbols(e), selectedAgent(0), rootOption(0),
selectedBasicBehavior(0), errorHandler(e), initialized(false), 
pTimeFunction(pTimeFunction)
{
}

Xabsl2Engine::~Xabsl2Engine()
{
  int i;
  for (i=0; i< options.getSize(); i++)
    if (options[i]!=0) 
      delete options[i];
  for (i=0; i< agents.getSize(); i++)
    if (agents[i]!=0) 
      delete agents[i];
}

void Xabsl2Engine::execute()
{
  Xabsl2Option* currentOption = rootOption;

  int i;

  while (currentOption!=0)
  {
    currentOption->execute();
    
    Xabsl2Option* nextOption = currentOption->activeState->subsequentOption;
    if (nextOption == 0)
    {
      selectedBasicBehavior = currentOption->activeState->subsequentBasicBehavior;
    }
    currentOption = nextOption;
  }

  for (i=0; i< options.getSize(); i++)
  {
    Xabsl2Option* option = options[i];
    option->optionWasActive = option->optionIsActive;
    option->optionIsActive = false;
  }

  setOutputSymbols();

  executeSelectedBasicBehavior();
}

void Xabsl2Engine::executeSelectedBasicBehavior()
{

  selectedBasicBehavior->execute();

  for (int i=0;i<basicBehaviors.getSize();i++)
  {
    basicBehaviors[i].basicBehaviorWasActiveDuringLastExecutionOfEngine = false; 
  }
  
  selectedBasicBehavior->basicBehaviorWasActiveDuringLastExecutionOfEngine = true;
}

void Xabsl2Engine::createOptionGraph(Xabsl2InputSource& input)
{
  int i;
  char buf1[100],buf2[100];

  if (initialized)
  {
    errorHandler.error("createOptionGraph(): Don't call this function twice");
    return;
  }
  if (!input.open()) 
  {
    errorHandler.error("createOptionGraph(): Can't open input source");
    return;
  }

  // the total number of options in the intermediate code
  int numberOfOptions = (int)input.readValue(); 
  
  // create empty options
  for (i=0; i< numberOfOptions; i++)
  {
    input.readString(buf1,99);
    options.append(buf1,new Xabsl2Option(buf1,input,errorHandler,pTimeFunction));
  }
  XABSL2_DEBUG_INIT(errorHandler.message("registered %i options",numberOfOptions));

  // create the options and its states
  for (i=0; i< numberOfOptions; i++)
  {
    XABSL2_DEBUG_INIT(errorHandler.message("creating option \"%s\"",options[i]->n));
    options[i]->create(input,options,basicBehaviors,*this);
    if (errorHandler.errorsOccurred)
    {
      errorHandler.error("Xabsl2Engine::createOptionGraph(): could not create option \"%s\"",options[i]->n);
      return;
    }
  }

  // create the agents
  int numberOfAgents = (int)input.readValue();
  for (i=0; i< numberOfAgents; i++)
  {
    input.readString(buf1,99);
    input.readString(buf2,99);
    agents.append(buf1,new Xabsl2Agent(buf1,options.getElement(buf2),errorHandler));
  }

  // check for loops in the option graph
  for (i=0;i<agents.getSize();i++)
  {
    Xabsl2Option* currentOptionPath[1000];
    
    currentOptionPath[0] = agents[i]->getRootOption();

    // call recursively the checkForLoops function
    if (checkForLoops(currentOptionPath,0)) 
    {
      errorHandler.error("createOptionGraph(): The created option graph contains loops");
    };
  }


  selectedAgent = agents[0];
  selectedBasicBehavior = &basicBehaviors[0];
  rootOption = selectedAgent->getRootOption();

  XABSL2_DEBUG_INIT(errorHandler.message("selected agent: \"%s\"",selectedAgent->n));
  input.close();
  initialized = true;
}


bool Xabsl2Engine::checkForLoops(Xabsl2Option* currentOptionPath[],int currentDepth)
{
  int i,j;
  Xabsl2Option* currentOption = currentOptionPath[currentDepth];

  for (i=0; i<currentOption->states.getSize(); i++)
  {
    if (currentOption->states[i]->subsequentOption != 0)
    {
      for(j=0; j<=currentDepth; j++)
      {
        // check for the subsequent option of each state whether the referenced 
        // option is contained in the current option path
        if (currentOption->states[i]->subsequentOption == currentOptionPath[j])
        {
          errorHandler.error("checkForLoops() : state \"%s\" in option \"%s\" references subsequent option \"%s\". But option \"%s\" is also directly or indirectly referenced by option \"%s\".",
            currentOption->states[i]->n, 
            currentOption->n,
            currentOption->states[i]->subsequentOption->n,
            currentOption->n,
            currentOption->states[i]->subsequentOption->n);

          return true;
        }
      }
      
      // recursion
      currentOptionPath[currentDepth+1] = currentOption->states[i]->subsequentOption;
      if (checkForLoops(currentOptionPath,currentDepth+1))
      {
        return true;
      }
    }
  }

  return false;
}


void Xabsl2Engine::registerBasicBehavior(Xabsl2BasicBehavior& basicBehavior)
{
  XABSL2_DEBUG_INIT(errorHandler.message("registering basic behavior \"%s\"",basicBehavior.n));

  if (basicBehaviors.exists(basicBehavior.n))
  {
    errorHandler.error("registerBasicBehavior(): basic behavior \"%s\" was already registered",basicBehavior.n);
    return;
  }
  basicBehaviors.append(basicBehavior.n,basicBehavior);
}

bool Xabsl2Engine::setSelectedBasicBehavior(const char* name)
{
  if (!basicBehaviors.exists(name))
    return false;
  else
  {
    selectedBasicBehavior = &basicBehaviors.getElement(name);
    return true;
  }
}

bool Xabsl2Engine::setRootOption(const char* name)
{
  // check if the option exists
  if (!options.exists(name)) return false;

  // set the curren root option to the requested option
  rootOption = options.getElement(name);

  return true;
}

void Xabsl2Engine::setRootOption()
{
  rootOption = selectedAgent->getRootOption();
}

const Xabsl2Option* Xabsl2Engine::getRootOption() const
{
  return rootOption;
}

bool Xabsl2Engine::setBasicBehaviorParameter(const char* name, const char* param, double value)
{
  if (!basicBehaviors.exists(name)) 
  {
    return false;
  }
  else if (!basicBehaviors.getElement(name).parameters.exists(param))
  {
    return false;
  }
  else 
  { 
    basicBehaviors.getElement(name).parameters.setElement(param,value);
    return false;
  }
}

bool Xabsl2Engine::setOptionParameter(const char* name, const char* param, double value)
{
  if (!options.exists(name)) 
  {
    return false;
  }
  else if (!options.getElement(name)->parameters.exists(param))
  {
    return false;
  }
  else 
  { 
    options.getElement(name)->parameters.setElement(param,value);
    return false;
  }
}

const char* Xabsl2Engine::getSelectedAgentName()
{
  return selectedAgent->n;
}

const Xabsl2BasicBehavior* Xabsl2Engine::getSelectedBasicBehavior()
{
  return selectedBasicBehavior;
}

bool Xabsl2Engine::setSelectedAgent(const char* name)
{
  if (!agents.exists(name)) 
  {
    return false;
  }

  Xabsl2Agent* newAgent = agents.getElement(name);

  if (selectedAgent != newAgent)
  {
    selectedAgent = newAgent;
    rootOption = selectedAgent->getRootOption();
  }

  return true;
}

---