source: orxonox.OLD/trunk/src/util/loading/load_param.cc @ 5420

/*
   orxonox - the future of 3D-vertical-scrollers

   Copyright (C) 2004 orx

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2, or (at your option)
   any later version.

   ### File Specific:
   main-programmer: Benjamin Grauer
   co-programmer: ...
*/

#include "functor_list.h"

#include "load_param.h"

#include "list.h"
#include "base_object.h"

#include <stdarg.h>

/**
 * @param object The object this Parameter is loaded too.
 * @param root: the XML-element to load this option from.
 * @param paramName: The name of the parameter loaded.
 * @param paramCount: how many parameters this loading-function takes
 * @param multi: if false LoadParam assumes only one occurence of this parameter in root, if true it assumes multiple occurences.
 * @param ...: the parameter information (1. Parameter, 2. Default Value for the Parameter, ...)
*/
BaseLoadParam::BaseLoadParam(const TiXmlElement* root, BaseObject* object, const char* paramName,
                             int paramCount, bool multi, const void* pointerToParam, ...)
{
  this->setClassID(CL_LOAD_PARAM, "LoadParam");

  this->loadString = NULL;
  this->pointerToParam = pointerToParam;

  if (paramCount == 0 || this->pointerToParam)
    this->loadString = "none";
  else
    {
      if (likely(!multi))
        this->loadString = grabParameter(root, paramName);
      else
        {
          if (!strcmp(root->Value(), paramName))
            {
              const TiXmlNode* val = root->FirstChild();
              if( val->ToText())
                this->loadString = val->Value();
            }
        }
    }

  this->paramDesc = NULL;
  if (LoadClassDescription::parametersDescription)
  {
    // locating the class
    this->classDesc = LoadClassDescription::addClass(object->getClassName());

    if ((this->paramDesc = this->classDesc->addParam(paramName)) != NULL)
    {

      this->paramDesc->paramCount = paramCount;
      this->paramDesc->types = new int[paramCount];
      this->paramDesc->defaultValues = new char*[paramCount];

      va_list types;
      va_start (types, pointerToParam);
      char defaultVal[512];
      for(int i = 0; i < paramCount; i++)
      {
        defaultVal[0] = '\0';
          // parameters parsed
        int tmpType = va_arg (types, int);
        this->paramDesc->types[i] = tmpType;
        switch (tmpType)
        {
          case ParameterInt:
            sprintf(defaultVal, "%d", va_arg(types, int));
            break;
          case ParameterLong:
            sprintf(defaultVal, "%0.3f", va_arg(types, l_LONG_TYPE));
            break;
          case ParameterFloat:
            sprintf(defaultVal, "%0.3f", va_arg(types, double));
            break;
          case ParameterString:
            sprintf(defaultVal, "%s", va_arg(types, l_STRING_TYPE));
            break;
          case ParameterXML:
            sprintf(defaultVal, "");
            break;
        }
        this->paramDesc->defaultValues[i] = new char[strlen(defaultVal)+1];
        strcpy(this->paramDesc->defaultValues[i], defaultVal);
      }
      va_end(types);

      int argCount = 0;
    }
  }
}

/**
 * @param descriptionText The text to set as a description for this Parameter
 * @returns a pointer to itself.
*/
BaseLoadParam* BaseLoadParam::describe(const char* descriptionText)
{
  if (LoadClassDescription::parametersDescription && this->paramDesc && !this->paramDesc->getDescription())
    {
      this->paramDesc->setDescription(descriptionText);
    }
  return this;
}

/**
 * @param paramName the name of the parameter to load
*/
LoadParamDescription::LoadParamDescription(const char* paramName)
{
  this->types = NULL;
  this->description = NULL;
  this->defaultValues = NULL;
  this->paramName = new char[strlen(paramName)+1];
  strcpy(this->paramName, paramName);
}

/**
 *  removes all the alocated memory
*/
LoadParamDescription::~LoadParamDescription()
{
  if (this->defaultValues != NULL)
  {
    for(int i = 0; i < this->paramCount; i++)
    {
      delete[] this->defaultValues[i];
    }
  }

  delete[] this->types;
  delete[] this->defaultValues;
  delete[] this->paramName;
  delete[] this->description;
}

/**
 * @param descriptionText The text to set as a description for this Parameter
*/
void LoadParamDescription::setDescription(const char* descriptionText)
{
  this->description = new char[strlen(descriptionText)+1];
  strcpy(this->description, descriptionText);
}

/**
 *  prints out this parameter, its input method and the description (if availiable)
*/
void LoadParamDescription::print() const
{
  PRINT(3)(" <%s>", this->paramName);
  for (int i = 0; i < this->paramCount; i++)
    {
      if (i > 0)
        PRINT(3)(",");
      switch (this->types[i])
      {
        default:
          PRINTF(3)("none");
          break;
        case ParameterBool:
          PRINT(3)("bool");
          break;
        case ParameterChar:
          PRINT(3)("char");
          break;
        case ParameterString:
          PRINT(3)("string");
          break;
        case ParameterInt:
          PRINT(3)("int");
          break;
        case ParameterUInt:
          PRINT(3)("Uint");
          break;
        case ParameterFloat:
          PRINT(3)("float");
          break;
        case ParameterLong:
          PRINT(3)("long");
          break;
        case ParameterXML:
          PRINT(3)("XML");
          break;
      }
    }
  PRINT(3)("</%s>", this->paramName);
  if (this->description)
    PRINT(3)(" -- %s", this->description);
  // default values
  if (this->paramCount > 0)
  {
    PRINT(3)(" (Default: ");
    for (int i = 0; i < this->paramCount; i++)
    {
      if (i > 0)
        PRINT(3)(", ");
      if (this->types[i] & ParameterString)
      { // leave brackets !!
        PRINT(3)("\"%s\"", this->defaultValues[i]);
      }
      else
      {
        PRINT(3)("%s", this->defaultValues[i]);
      }
    }
    PRINT(3)(")");
  }
  PRINT(3)("\n");
}

/**
 *  A list, that holds all the classes that are loadable (classes not objects!!)
*/
tList<LoadClassDescription>* LoadClassDescription::classList = NULL;

/**
 *  if the description of Parameters should be executed
*/
bool LoadClassDescription::parametersDescription = true;

/**
 * @param className the name of the class to be loadable
*/
LoadClassDescription::LoadClassDescription(const char* className)
{
  this->className = new char[strlen(className)+1];
  strcpy(this->className, className);

  if (LoadClassDescription::classList == NULL)
    LoadClassDescription::classList = new tList<LoadClassDescription>;

  LoadClassDescription::classList->add(this);

  this->paramList = new tList<LoadParamDescription>;
}

/**
 *  deletes a classDescription (deletes all the parameterDescriptions as well
*/
LoadClassDescription::~LoadClassDescription()
{
  tIterator<LoadParamDescription>* iterator = this->paramList->getIterator();
  LoadParamDescription* enumParamDesc = iterator->firstElement();
  while (enumParamDesc)
    {
      delete enumParamDesc;
      enumParamDesc = iterator->nextElement();
    }
  delete iterator;
  delete this->paramList;

  delete[] this->className;
}

void LoadClassDescription::deleteAllDescriptions()
{
  if (LoadClassDescription::classList != NULL)
  {
    tIterator<LoadClassDescription>* iterator = LoadClassDescription::classList->getIterator();
    LoadClassDescription* delElem = iterator->firstElement();
    while (delElem != NULL)
    {
      delete delElem;
      delElem = iterator->nextElement();
    }
    delete iterator;
    delete LoadClassDescription::classList;
  }
  LoadClassDescription::classList = NULL;
}


/**
 *  adds a class to the list of loadable classes
 * @param className The name of the class to add

   this function searches for the className string, and if found just returns the appropriate Class.
   Otherwise it returns a new classDescription
*/
LoadClassDescription* LoadClassDescription::addClass(const char* className)
{
  if (LoadClassDescription::classList != NULL)
  {
    tIterator<LoadClassDescription>* iterator = LoadClassDescription::classList->getIterator();
   LoadClassDescription* enumClassDesc = iterator->firstElement();
   while (enumClassDesc)
     {
       if (!strcmp(enumClassDesc->className, className))
         {
           delete iterator;
           return enumClassDesc;
         }
       enumClassDesc = iterator->nextElement();
     }
   delete iterator;
  }
  return new LoadClassDescription(className);
}

/**
 *  does the same as addClass(const char* className), but with params
 * @param paramName the name of the parameter to add.
*/
LoadParamDescription* LoadClassDescription::addParam(const char* paramName)
{
  tIterator<LoadParamDescription>* iterator = this->paramList->getIterator();
  LoadParamDescription* enumParamDesc = iterator->firstElement();
  while (enumParamDesc)
    {
      if (!strcmp(enumParamDesc->paramName, paramName))
        {
          delete iterator;
          //return enumParamDesc;
          return NULL;
        }
      enumParamDesc = iterator->nextElement();
    }
  delete iterator;

  LoadParamDescription* newParam = new LoadParamDescription(paramName);

  this->paramList->add(newParam);
  return newParam;
}

/**
 *  prints out all loadable Classes, and their parameters
 * @param fileName prints the output to a File
 * @todo implement it
*/
void LoadClassDescription::printAll(const char* fileName)
{
  PRINT(3)("===============================================================\n");
  PRINT(3)(" Listing all the Loadable Options (loaded since Game started).\n\n");
  if (LoadClassDescription::classList != NULL)
  {
    tIterator<LoadClassDescription>* classIT = LoadClassDescription::classList->getIterator();
    LoadClassDescription* enumClassDesc = classIT->firstElement();
    while (enumClassDesc)
     {
       PRINT(3)("<%s>\n", enumClassDesc->className);
       tIterator<LoadParamDescription>* paramIT = enumClassDesc->paramList->getIterator();
       LoadParamDescription* enumParamDesc = paramIT->firstElement();
       while (enumParamDesc)
         {
           enumParamDesc->print();
           enumParamDesc = paramIT->nextElement();
         }
       delete paramIT;

       PRINT(3)("</%s>\n\n", enumClassDesc->className);
       enumClassDesc = classIT->nextElement();
     }
    delete classIT;
  }
  else
    PRINT(3)("no Classes defined so far\n");
  PRINT(3)("===============================================================\n");
}

/**
 * searches for classes, which beginn with classNameBegin
 * @param classNameBegin the beginning string of a Class
 * @return a NEW char-array with ClassNames. The LIST should be deleted afterwards,
 * !! The strings MUST NOT be deleted !!
 */
tList<const char>* LoadClassDescription::searchClassWithShort(const char* classNameBegin)
{
  unsigned int searchLength = strlen(classNameBegin);
  tList<const char>* retVal = new tList<const char>;

  tIterator<LoadClassDescription>* iterator = LoadClassDescription::classList->getIterator();
  LoadClassDescription* enumClassDesc = iterator->firstElement();
  while (enumClassDesc)
  {
    if (strlen(enumClassDesc->className)>searchLength+1 &&
        !strncasecmp(enumClassDesc->className, classNameBegin, searchLength))
    {
      retVal->add(enumClassDesc->className);
    }
    enumClassDesc = iterator->nextElement();
  }
  delete iterator;

  return retVal;
}

// const LoadParamDescription* LoadParamDescription::getClass(const char* className)
// {
//   tIterator<LoadClassDescription>* iterator = LoadClassDescription::classList->getIterator();
//   LoadClassDescription* enumClassDesc = iterator->firstElement();
//   while (enumClassDesc)
//   {
//     if (!strcmp(enumClassDesc->className, classNameBegin, className))
//     {
//       delete iterator;
//       return enumClassDesc;
//     }
//     enumClassDesc = iterator->nextElement();
//   }
//   delete iterator;
//
//   return NULL;
// }

/**
 * @param root: The XML-element to grab a parameter from
 * @param parameterName: the parameter to grab
 * @returns the Value of the parameter if found, NULL otherwise
*/
const char* grabParameter(const TiXmlElement* root, const char* parameterName)
{
  const TiXmlElement* element;
  const TiXmlNode* node;

  if (root == NULL)
    return NULL;
  assert( parameterName != NULL);

  element = root->FirstChildElement( parameterName);
  if( element == NULL) return NULL;

  node = element->FirstChild();
  while( node != NULL)
    {
      if( node->ToText()) return node->Value();
      node = node->NextSibling();
    }
  return NULL;
}