Tools/Xabsl2/Xabsl2Engine/Xabsl2Symbols.cpp

Go to the documentation of this file.

/**
* @file Xabsl2Symbols.cpp
*
* Implementation of class Xabsl2Symbols and helper classes
*
* @author Martin Lötzsch
*/

#include "Xabsl2Symbols.h"

Xabsl2EnumeratedInputSymbol::~Xabsl2EnumeratedInputSymbol()
{
  int i;
  for (i=0; i< enumElements.getSize(); i++)
  {
    delete enumElements[i];
  }
}

Xabsl2EnumeratedOutputSymbol::~Xabsl2EnumeratedOutputSymbol()
{
  int i;
  for (i=0; i< enumElements.getSize(); i++)
  {
    delete enumElements[i];
  }
}

void Xabsl2EnumeratedOutputSymbol::setActiveValue()
{
  if (activeValueWasSet)
  {
    if (pF!=0) 
    {
      (pI->*pF)(activeValue);
    }
    else 
    {
      *pV=activeValue;
    }
    activeValueWasSet = false;
  }
}

Xabsl2Symbols::~Xabsl2Symbols()
{
  int i;
  for (i=0; i< decimalInputSymbols.getSize(); i++) delete decimalInputSymbols[i];
  for (i=0; i< decimalInputFunctions.getSize(); i++) delete decimalInputFunctions[i];
  for (i=0; i< booleanInputSymbols.getSize(); i++) delete booleanInputSymbols[i];
  for (i=0; i< enumeratedInputSymbols.getSize(); i++) delete enumeratedInputSymbols[i];
  for (i=0; i< enumeratedOutputSymbols.getSize(); i++) delete enumeratedOutputSymbols[i];
}

void Xabsl2Symbols::registerDecimalInputSymbol(const char* name, const double* pVariable)
{
  XABSL2_DEBUG_INIT(errorHandler.message("registering decimal input symbol \"%s\"",name));
  
  if (decimalInputSymbols.exists(name))
  {
    errorHandler.error("registerDecimalInputSymbol(): symbol \"%s\" was already registered",name);
    return;
  }
  decimalInputSymbols.append(name,new Xabsl2DecimalInputSymbol(name, pVariable));
}

void Xabsl2Symbols::registerDecimalInputSymbol
(const char* name, Xabsl2FunctionProvider* pInstance,
 double (Xabsl2FunctionProvider::*pFunction)())
{
  XABSL2_DEBUG_INIT(errorHandler.message("registering decimal input symbol \"%s\"",name));
  
  if (decimalInputSymbols.exists(name))
  {
    errorHandler.error("registerDecimalInputSymbol(): symbol \"%s\" was already registered",name);
    return;
  }
  decimalInputSymbols.append(name,new Xabsl2DecimalInputSymbol(name, pInstance,pFunction));
}

Xabsl2DecimalInputSymbol* Xabsl2Symbols::getDecimalInputSymbol(const char* name)
{
  return decimalInputSymbols.getElement(name);
}

bool Xabsl2Symbols::existsDecimalInputSymbol(const char* name)
{
  return decimalInputSymbols.exists(name);
} 

 int Xabsl2Symbols::numberOfDecimalInputSymbols()
{
  return decimalInputSymbols.getSize();
} 

const Xabsl2DecimalInputSymbol* Xabsl2Symbols::getDecimalInputSymbol(int index){
  if(index < decimalInputSymbols.getSize())
    return decimalInputSymbols.getElement(index);
  return NULL;
}


void Xabsl2Symbols::registerDecimalInputFunction(const char* name, Xabsl2FunctionProvider* pInstance,
                                                 double (Xabsl2FunctionProvider::*pFunction)())
{
  XABSL2_DEBUG_INIT(errorHandler.message("registering decimal input function\"%s\"",name));

  if (decimalInputFunctions.exists(name))
  {
    errorHandler.error("registerDecimalInputFunction(): function \"%s\" was already registered",name);
    return;
  }

  decimalInputFunctions.append(name, new Xabsl2DecimalInputFunction(name,pInstance,pFunction));
}
  
void Xabsl2Symbols::registerDecimalInputFunctionParameter(const char* functionName, 
    const char* name, double& param)
{
  XABSL2_DEBUG_INIT(errorHandler.message("registering parameter \"%s\" for decimal input function\"%s\"",name, functionName));

  if (!decimalInputFunctions.exists(functionName))
  {
    errorHandler.error("registerDecimalInputFunctionParameter(): function \"%s\" was not registered",functionName);
    return;
  }
  if (decimalInputFunctions.getElement(functionName)->parameters.exists(name))
  {
    errorHandler.error("registerDecimalInputFunctionParameter(): parameter \"%s\" was already registered",name);
    return;
  }

  decimalInputFunctions.getElement(functionName)->parameters.append(name,param);
}
  
Xabsl2DecimalInputFunction* Xabsl2Symbols::getDecimalInputFunction(const char* name)
{
  return decimalInputFunctions.getElement(name);
}
  
bool Xabsl2Symbols::existsDecimalInputFunction(const char* name)
{
  return decimalInputFunctions.exists(name);
}


void Xabsl2Symbols::registerBooleanInputSymbol(const char* name, const bool* pVariable)
{
  XABSL2_DEBUG_INIT(errorHandler.message("registering boolean input symbol \"%s\"",name));
  
  if (booleanInputSymbols.exists(name))
  {
    errorHandler.error("registerBooleanInputSymbol(): symbol \"%s\" was already registered",name);
    return;
  }
  booleanInputSymbols.append(name,new Xabsl2BooleanInputSymbol(name, pVariable));
}


void Xabsl2Symbols::registerBooleanInputSymbol(const char* name, Xabsl2FunctionProvider* pInstance,
                                               bool (Xabsl2FunctionProvider::*pFunction)())
{
  XABSL2_DEBUG_INIT(errorHandler.message("registering boolean input symbol \"%s\"",name));
  
  if (booleanInputSymbols.exists(name))
  {
    errorHandler.error("registerBooleanInputSymbol(): symbol \"%s\" was already registered",name);
    return;
  }
  booleanInputSymbols.append(name,new Xabsl2BooleanInputSymbol(name, pInstance,pFunction));
}

Xabsl2BooleanInputSymbol* Xabsl2Symbols::getBooleanInputSymbol(const char* name)
{
  return booleanInputSymbols.getElement(name);
}

bool Xabsl2Symbols::existsBooleanInputSymbol(const char* name)
{
  return booleanInputSymbols.exists(name);
}

 int Xabsl2Symbols::numberOfBooleanInputSymbols()
{
  return booleanInputSymbols.getSize();
} 

const Xabsl2BooleanInputSymbol* Xabsl2Symbols::getBooleanInputSymbol(int index){
  if(index < booleanInputSymbols.getSize())
    return booleanInputSymbols.getElement(index);
  return NULL;
}


void Xabsl2Symbols::registerEnumeratedInputSymbol(const char* name, const int* pVariable)
{
  XABSL2_DEBUG_INIT(errorHandler.message("registering enumerated input symbol \"%s\"",name));
  
  if (enumeratedInputSymbols.exists(name))
  {
    errorHandler.error("registerEnumeratedInputSymbol(): symbol \"%s\" was already registered",name);
    return;
  }
  enumeratedInputSymbols.append(name,new Xabsl2EnumeratedInputSymbol(name, pVariable));
}

void Xabsl2Symbols::registerEnumeratedInputSymbol(const char* name, Xabsl2FunctionProvider* pInstance,
    int (Xabsl2FunctionProvider::*pFunction)())
{
  XABSL2_DEBUG_INIT(errorHandler.message("registering enumerated input symbol \"%s\"",name));
  
  if (enumeratedInputSymbols.exists(name))
  {
    errorHandler.error("registerEnumeratedInputSymbol(): symbol \"%s\" was already registered",name);
    return;
  }
  enumeratedInputSymbols.append(name,new Xabsl2EnumeratedInputSymbol(name, pInstance,pFunction));
}

Xabsl2EnumeratedInputSymbol* Xabsl2Symbols::getEnumeratedInputSymbol(const char* name)
{
  return enumeratedInputSymbols.getElement(name);
}

void Xabsl2Symbols::registerEnumeratedInputSymbolEnumElement(const char* symbolName, 
    const char* name, int value)
{
  XABSL2_DEBUG_INIT(errorHandler.message("registering enum element \"%s\" for enumerated input symbol \"%s\"",name, symbolName));

  if (!enumeratedInputSymbols.exists(symbolName))
  {
    errorHandler.error("registerEnumeratedInputSymbolEnumElement(): symbol \"%s\" was not registered.", symbolName);
    return;
  }
  if (enumeratedInputSymbols.getElement(symbolName)->enumElements.exists(name))
  {
    errorHandler.error("registerEnumeratedInputSymbolEnumElement(): enum element \"%s\" for symbol \"%s\" was already registered.", name, symbolName);
    return;
  }
  enumeratedInputSymbols.getElement(symbolName)->enumElements.append(name, new Xabsl2EnumElement(name,value));
}

bool Xabsl2Symbols::existsEnumeratedInputSymbol(const char* name)
{
  return enumeratedInputSymbols.exists(name);
}

 int Xabsl2Symbols::numberOfEnumeratedInputSymbols()
{
  return enumeratedInputSymbols.getSize();
} 

const Xabsl2EnumeratedInputSymbol* Xabsl2Symbols::getEnumeratedInputSymbol(int index){
  if(index < enumeratedInputSymbols.getSize())
    return enumeratedInputSymbols.getElement(index);
  return NULL;
}


void Xabsl2Symbols::registerEnumeratedOutputSymbol(const char* name, int* pVariable)
{
  XABSL2_DEBUG_INIT(errorHandler.message("registering enumerated output symbol \"%s\"",name));
  
  if (enumeratedOutputSymbols.exists(name))
  {
    errorHandler.error("registerEnumeratedOutputSymbol(): symbol \"%s\" was already registered",name);
    return;
  }
  enumeratedOutputSymbols.append(name,new Xabsl2EnumeratedOutputSymbol(name, pVariable));
}

void Xabsl2Symbols::registerEnumeratedOutputSymbol(const char* name, Xabsl2FunctionProvider* pInstance,
    void (Xabsl2FunctionProvider::*pFunction)(int))
{
  XABSL2_DEBUG_INIT(errorHandler.message("registering enumerated output symbol \"%s\"",name));
  
  if (enumeratedOutputSymbols.exists(name))
  {
    errorHandler.error("registerEnumeratedOutputSymbol(): symbol \"%s\" was already registered",name);
    return;
  }
  enumeratedOutputSymbols.append(name,new Xabsl2EnumeratedOutputSymbol(name, pInstance,pFunction));
}

Xabsl2EnumeratedOutputSymbol* Xabsl2Symbols::getEnumeratedOutputSymbol(const char* name)
{
  return enumeratedOutputSymbols.getElement(name);
}

void Xabsl2Symbols::registerEnumeratedOutputSymbolEnumElement(const char* symbolName, 
    const char* name, int value)
{
  XABSL2_DEBUG_INIT(errorHandler.message("registering enum element \"%s\" for enumerated output symbol \"%s\"",name, symbolName));

  if (!enumeratedOutputSymbols.exists(symbolName))
  {
    errorHandler.error("registerEnumeratedOutputSymbolEnumElement(): symbol \"%s\" was not registered.", symbolName);
    return;
  }
  if (enumeratedOutputSymbols.getElement(symbolName)->enumElements.exists(name))
  {
    errorHandler.error("registerEnumeratedOutputSymbolEnumElement(): enum element \"%s\" for symbol \"%s\" was already registered.", name, symbolName);
    return;
  }
  enumeratedOutputSymbols.getElement(symbolName)->enumElements.append(name, new Xabsl2EnumElement(name,value));
}

bool Xabsl2Symbols::existsEnumeratedOutputSymbol(const char* name)
{
  return enumeratedOutputSymbols.exists(name);
}


void Xabsl2Symbols::setOutputSymbols()
{
  for (int i=0;i<enumeratedOutputSymbols.getSize();i++)
    enumeratedOutputSymbols[i]->setActiveValue();
}

---