DecimalValue::DecimalValue(InputSource& input,
ErrorHandler& errorHandler)
{
value = input.readValue();
XABSL_DEBUG_INIT(errorHandler.message("created decimal value: \"%.2f\"",value));
}
void State::create(InputSource& input,
Array<Option*>& options,
Array<BasicBehavior*>& basicBehaviors,
Array<State*>& states,
OptionParameters& parameters,
Symbols& symbols,
unsigned& timeOfOptionExecution)
{
XABSL_DEBUG_INIT(errorHandler.message("creating state \"%s\"",n));
char c[100];
int i;
// target state or not
input.readString(c,1);
if (*c == '1')
{
targetState = true;
}
// subsequent option, basic behaviors and output symbol assignments
int numberOfActions = (int)input.readValue();
subsequentOption = 0;
for(i = 0; i< numberOfActions; i++)
{
Action* action =
Action::create(input,
options,
basicBehaviors,
parameters,
symbols,
timeOfOptionExecution,
timeOfStateExecution,
actions,
errorHandler,
pTimeFunction);
if (errorHandler.errorsOccurred)
{
errorHandler.error("XabslState::create(): could not create action for state \"%s\"",n);
return;
}
if (subsequentOption == 0)
if (ActionOption* actionOption = dynamic_cast<ActionOption*>(action))
subsequentOption = actionOption->option;
actions.append("", action);
}
// transition to state or if / else block
decisionTree = Statement::createStatement(input,actions,errorHandler,
states,parameters, symbols, timeOfOptionExecution,timeOfStateExecution);
if (errorHandler.errorsOccurred)
errorHandler.error("XabslState::create(): could not create decision tree for state \"%s\"",n);
}
void ParameterAssignment::create(
InputSource& input,
Symbols& symbols,
Option& option,
State& state)
{
int i;
// read the parameters
int numberOfParameters = (int)input.readValue();
for (i = 0; i<numberOfParameters; i++)
{
char c[2];
char buf[100];
input.readString(c,1);
switch(c[0])
{
case 'd':
{
input.readString(buf,99);
XABSL_DEBUG_INIT(errorHandler.message("creating expession for set decimal parameter \"%s\"",buf));
const DecimalExpression* exp = DecimalExpression::create(input,errorHandler,symbols,option,state);
if (errorHandler.errorsOccurred)
{
errorHandler.error("XabslParameterAssignment::create(): could not create decimal expression for parameter \"%s\"",buf);
return;
}
if (!setDecimalParameter(buf, exp)) return;
}
break;
case 'b':
{
input.readString(buf,99);
XABSL_DEBUG_INIT(errorHandler.message("creating expession for set boolean parameter \"%s\"",buf));
const BooleanExpression* exp = BooleanExpression::create(input,errorHandler,symbols,option,state);
if (errorHandler.errorsOccurred)
{
errorHandler.error("XabslParameterAssignment::create(): could not create boolean expression for parameter \"%s\"",buf);
return;
}
if (!setBooleanParameter(buf, exp)) return;
}
break;
case 'e':
{
input.readString(buf,99);
if(!symbols.enumerations.exists(buf))
{
errorHandler.error("XabslParameterAssignment::create(): enumeration \"%s\" was not registered",buf);
return;
}
const Enumeration* enumeration = symbols.enumerations[buf];
input.readString(buf,99);
XABSL_DEBUG_INIT(errorHandler.message("creating expession for set enumerated parameter \"%s\"",buf));
const EnumeratedExpression* exp = EnumeratedExpression::create(enumeration,input,errorHandler,symbols,option,state);
if (errorHandler.errorsOccurred)
{
errorHandler.error("XabslParameterAssignment::create(): could not create enumerated expression for parameter \"%s\"",buf);
return;
}
if (!setEnumeratedParameter(buf, exp)) return;
}
break;
}
}
}
void Engine::createOptionGraph(InputSource& 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;
}
// create internal enumerations
int numberOfInternalEnumerations = (int)input.readValue();
for (i=0; i < numberOfInternalEnumerations; i++)
{
input.readString(buf1, 99);
int numberOfElements = (int)input.readValue();
for (int j=0; j < numberOfElements; j++)
{
input.readString(buf2, 99);
registerEnumElement(buf1, buf2, j);
if (errorHandler.errorsOccurred)
{
errorHandler.error("XabslEngine::createOptionGraph(): could not register internal enumeration \"%s\"",buf1);
return;
}
}
}
// create internal symbols
int numberOfInternalSymbols = (int)input.readValue();
for (i=0; i < numberOfInternalSymbols; i++)
{
char c[2];
input.readString(c,1);
switch (c[0])
{
case 'd':
input.readString(buf1,99);
internalDecimalSymbols.append(buf1, 0);
registerDecimalOutputSymbol(buf1, &(internalDecimalSymbols.getElement(internalDecimalSymbols.getSize() - 1)));
if (errorHandler.errorsOccurred)
{
errorHandler.error("XabslEngine::createOptionGraph(): could not register internal decimal symbol \"%s\"",buf1);
return;
}
break;
case 'b':
input.readString(buf1,99);
internalBooleanSymbols.append(buf1, false);
registerBooleanOutputSymbol(buf1, &(internalBooleanSymbols.getElement(internalBooleanSymbols.getSize() - 1)));
if (errorHandler.errorsOccurred)
{
errorHandler.error("XabslEngine::createOptionGraph(): could not register internal boolean symbol \"%s\"",buf1);
return;
}
break;
case 'e':
input.readString(buf1,99);
if (!enumerations.exists(buf1))
{
errorHandler.error("XabslEngine::createOptionGraph(): enumeration \"%s\" was not registered",buf1);
return;
}
const Enumeration* enumeration = enumerations[buf1];
if (enumeration->enumElements.getSize() == 0)
{
errorHandler.error("XabslEngine::createOptionGraph(): no enumeration elements for \"%s\" were registered",buf1);
return;
}
input.readString(buf2,99);
internalEnumeratedSymbols.append(buf2, enumeration->enumElements[0]->v);
registerEnumeratedOutputSymbol(buf2, buf1, &(internalEnumeratedSymbols.getElement(internalEnumeratedSymbols.getSize() - 1)));
if (errorHandler.errorsOccurred)
{
errorHandler.error("XabslEngine::createOptionGraph(): could not register internal enumerated symbol \"%s\"",buf2);
return;
}
break;
}
}
// 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 Option(buf1,input,errorHandler,*this,pTimeFunction,i));
if (errorHandler.errorsOccurred)
{
errorHandler.error("XabslEngine::createOptionGraph(): could not create option \"%s\"",options[i]->n);
return;
}
}
XABSL_DEBUG_INIT(errorHandler.message("registered %i options",numberOfOptions));
// create the options and its states
for (i=0; i< numberOfOptions; i++)
{
XABSL_DEBUG_INIT(errorHandler.message("creating option \"%s\"",options[i]->n));
options[i]->create(input,options,basicBehaviors,*this,agentPriority,synchronizationTicks);
if (errorHandler.errorsOccurred)
{
errorHandler.error("XabslEngine::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 Agent(buf1,options[buf2],errorHandler, i));
}
// check for loops in the option graph
for (i=0;i<agents.getSize();i++)
{
if (Option* option = dynamic_cast<Option*>(agents[i]->getRootOption()))
{
Option* currentOptionPath[1000];
currentOptionPath[0] = option;
// call recursively the checkForLoops function
if (checkForLoops(currentOptionPath,0))
{
errorHandler.error("createOptionGraph(): The created option graph contains loops");
};
}
}
// create array of cooperating states
for (i=0;i<options.getSize();i++)
for (int j=0;j<options[i]->states.getSize();j++)
if (CoopState* state = dynamic_cast<CoopState*>(options[i]->states[j]))
coopStates.append(state);
selectedAgent = agents[0];
setRootAction();
XABSL_DEBUG_INIT(errorHandler.message("selected agent: \"%s\"",selectedAgent->n));
input.close();
initialized = true;
}
