source: orxonox.OLD/trunk/src/lib/util/multi_type.cc @ 7193

/*
   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: ...
*/

//#define DEBUG_SPECIAL_MODULE DEBUG_MODULE_

#include "multi_type.h"

//#include "stdincl.h"
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>

#ifdef DEBUG
#include "debug.h"
#endif

using namespace std;

/**
 * creates a multiType without any stored value at all.
 */
MultiType::MultiType()
{
  this->init();
}
/**
 * creates a multiType out of a boolean
 * @param value the Value of this MulitType
 */
MultiType::MultiType(bool value)
{
  this->init();
  this->setBool(value);
}

/**
 * creates a multiType out of an integer
 * @param value the Value of this MulitType
 */
MultiType::MultiType(int value)
{
  this->init();
  this->setInt(value);
}

/**
 * creates a multiType out of a float (double)
 * @param value the Value of this MulitType
 */
MultiType::MultiType(double value)
{
  this->init();
  this->setFloat(value);
}

/**
 * creates a multiType out of a char
 * @param value the Value of this MulitType
 */
MultiType::MultiType(char value)
{
  this->init();
  this->setChar(value);
}

/**
 * creates a multiType out of a String
 * @param value the Value of this MulitType
 */
MultiType::MultiType(const char* value)
{
  this->init();
  this->setString(value);
}

MultiType::MultiType(const MultiType& multiType)
{
  this->init();
  *this = multiType;
}

/**
 * standard deconstructor
*/
MultiType::~MultiType ()
{
  if (this->storedString != NULL)
    delete[] this->storedString;
}

/**
 * copy Constructor
 * @param mt: the entity to copy
 * @returns a Copy of itself. (strings inside are copied as well)
 */
MultiType& MultiType::operator= (const MultiType& mt)
{
  this->type = mt.type;
  this->value = mt.value;
  if (mt.type == MT_STRING && mt.storedString != NULL)
  {
    this->setString(mt.storedString);
  }
  else
    this->storedString = NULL;
  return *this;
}

/**
 * @brief checks if the two Multitypes match
 * @param mt MultiType to check against this one
 * @returns true on match. false otherwise
 *
 * Two MultiType match if and only if
 *  1. the internal Type is the same
 *  2. the stored values match
 */
bool MultiType::operator==(const MultiType& mt) const
{
  if (this->type != mt.type)
    return false;

  switch (this->type)
  {
    case MT_NULL:
      return true;
    case MT_BOOL:
      return (this->value.Bool == mt.value.Bool);
    case MT_INT:
      return (this->value.Int == mt.value.Int);
    case MT_CHAR:
      return (this->value.Char == mt.value.Char);
    case MT_FLOAT:
      return (this->value.Float == mt.value.Float);
    case MT_STRING:
      if (this->value.String != NULL && mt.value.String != NULL)
        return (!strcmp(this->value.String, mt.value.String));
      else
        return (this->value.String == NULL && mt.value.String == NULL);
  }
}

/**
 * @brief checks if the internal value matches the boolean value.
 * @param value to check against this one
 * @returns true on match. false otherwise
 *
 * Two MultiType match if and only if
 *  1. the stored values match the given Value
 */
bool MultiType::operator==(const char* value) const
{
  if (this->value.String != NULL && value != NULL)
    return (!strcmp(this->value.String, value));
  else
    return (this->value.String == NULL && value == NULL);
}


/**
 * initializes the MultiType
 */
void MultiType::init()
{
  this->type = MT_NULL;
  this->storedString = NULL;
  this->value.Float = 0.0f;
}


/**
 * sets the type of this MultiType and resets to the default value
 * @param type the new Type
 */
void MultiType::setType(MT_Type type)
{
  if (this->type != type)
    this->type = type;
}

/**
 * sets a new Value to the MultiType
 * @param value the new Value as a bool
 */
void MultiType::setBool(bool value)
{
  this->type = MT_BOOL;
  this->value.Bool = value;
}

/**
 * sets a new Value to the MultiType
 * @param value the new Value as an int
 */
void MultiType::setInt(int value)
{
  this->type = MT_INT;
  this->value.Int = value;
}

/**
 * sets a new Value to the MultiType
 * @param value the new Value as a float
 */
void MultiType::setFloat(float value)
{
  this->type = MT_FLOAT;
  this->value.Float = value;
}

/**
 * sets a new Value to the MultiType
 * @param value the new Value as a char
 */
void MultiType::setChar(char value)
{
  this->type = MT_CHAR;
  this->value.Char = value;
}

/**
 * sets a new Value to the MultiType
 * @param value the new Value as a String
 */
void MultiType::setString(const char* value)
{
  this->type = MT_STRING;

  if (this->storedString != NULL)
    delete[] this->storedString;

  if (value == NULL)
  {
    this->storedString = new char[1];
    this->storedString[0] = '\0';
    this->value.String = this->storedString;
    return;
  }
  else
  {
    this->storedString = new char[strlen(value)+1];
    strcpy(storedString, value);
    this->value.String = this->storedString;
  }
}





/**
 * @returns the Value of this MultiType as a int
 */
bool MultiType::getBool() const
{
  // default case:
  if (this->type & MT_BOOL)
    return this->value.Bool;
  // Special Cases:
  else if (this->type & MT_INT) return (this->value.Int == 0)? false : true;
  else if (this->type & MT_FLOAT) return (this->value.Float == 0.0f)? false : true;
  else if (this->type & MT_CHAR) return (this->value.Char == '\0')? false : true;
  else if (this->type & MT_STRING) return (!strncmp(this->value.String, "true", 4) || !strncmp(this->value.String, "TRUE", 4) || !strncmp(this->value.String, "1", 1))? true : false; //! @TODO make this better.

  return false;
}

/**
 * @returns the Value of this MultiType as a int
 */
int MultiType::getInt() const
{
  // default case:
  if (this->type & MT_INT)
    return this->value.Int;
  if (this->type & MT_BOOL) return (this->value.Bool)? 1 : 0;
  else if (this->type & MT_FLOAT) return (int) this->value.Float;
  else if (this->type & MT_CHAR) return (int) this->value.Char;
  else if (this->type & MT_STRING) {
    char* endPtr = NULL;
    int result = strtol(this->value.String, &endPtr, 10);
    if ( endPtr >= this->value.String && endPtr < this->value.String + strlen(this->value.String))
      return 0;
    else
      return result;
  }

  return 0;
}

/**
 * @returns the Value of this MultiType as a float
 */
float MultiType::getFloat() const
{
 // default case:
  if (this->type & MT_FLOAT)
    return this->value.Float;
  if (this->type & MT_BOOL) return (this->value.Bool == true)? 1.0f : 0.0f;
  else if (this->type & MT_INT) return (float) this->value.Int;
  else if (this->type & MT_CHAR) return (float) this->value.Char;
  else if (this->type & MT_STRING) {
    char* endPtr = NULL;
    double result = strtod(this->value.String, &endPtr);
    if ( endPtr >= this->value.String && endPtr < this->value.String + strlen(this->value.String))
      return 0.0f;
    else
      return result;
  }

  return 0.0f;
}


/**
 * @returns the Value of this MultiType as a char
 */
char MultiType::getChar() const
{
 // default case:
  if (this->type & MT_INT)
    return this->value.Int;
  if (this->type & MT_BOOL) return (this->value.Bool)? 'y' : 'n';
  else if (this->type & MT_INT) return (int) this->value.Int;
  else if (this->type & MT_FLOAT) return (char) this->value.Float;
  else if (this->type & MT_STRING) return *this->value.String;

  return '\0';
}

/**
 * @returns the Value of this MultiType as a String
 */
const char* MultiType::getString()
{
 // default case:
  if (this->type & MT_STRING)
    return (this->value.String != NULL)? this->value.String : "";
  else
  {
    if (this->type & MT_BOOL) return (this->value.Bool)? "true" : "false";
    char tmpString[128];
    if (this->storedString != NULL)
    {
      delete[] this->storedString;
      this->storedString = NULL;
    }
    if (this->type & MT_CHAR)
    {
      this->storedString = new char[2];
      this->storedString[0] = this->value.Char;
      this->storedString[1] = '\0';
      return this->storedString;
    }
    else if (this->type & MT_INT)
    {
      sprintf(tmpString, "%d", this->value.Int);
      this->storedString = new char[strlen(tmpString)+1];
      strcpy (this->storedString, tmpString);
      return this->storedString;
    }
    if (this->type & MT_FLOAT)
    {
      sprintf(tmpString, "%f", this->value.Float);
      this->storedString = new char[strlen (tmpString)+1];
      strcpy (this->storedString, tmpString);
      return this->storedString;
    }
  }

  return "";
}

/**
 * prints out some nice debug output
 */
void MultiType::debug()
{
#ifdef DEBUG
  PRINT(0)
#else
  printf
#endif
      ("MultiType of Type '%s' :: Values: BOOL: '%d', INT: '%d', FLOAT: '%f', CHAR: '%c', STRING '%s'\n",
         MultiType::MultiTypeToString(this->type),
         this->getBool(),
         this->getInt(),
         this->getFloat(),
         this->getChar(),
         this->getString()
      );


}

/**
 * Resets the MultiType to default values.
 */
void MultiType::reset()
{
  switch ( this->type )
  {
    case MT_BOOL:
      this->setBool(false);
    case MT_INT:
      this->setInt(0);
      break;
    case MT_FLOAT:
      this->setFloat(0.0f);
      break;
    case MT_CHAR:
      this->setChar('\0');
      break;
    case MT_STRING:
      this->setString("");
      break;
    default:
#ifdef DEBUG
      PRINTF(2)("Unknown Type not reseting\n");
#endif
      break;
  }
}

/**
 * converts a MT_Type into a String
 * @param type: the MT_Type
 * @returns: the Type as a constant String (do not delete)
 */
const char* MultiType::MultiTypeToString(MT_Type type)
{
  switch ( type )
  {
   default:
    return "NONE";
   case MT_BOOL:
    return "bool";
   case MT_INT:
    return "int";
   case MT_FLOAT:
    return "float";
   case MT_CHAR:
    return "char";
   case MT_STRING:
    return "string";
  }
}

/**
 * converts a String into a MT_Type
 * @param type: the Type as a String
 * @returns: the Type as MT_Type
 */
MT_Type MultiType::StringToMultiType(const char* type)
{
  if (!strncmp(type, "bool", 4))
    return MT_BOOL;
  if (!strncmp(type, "int", 3))
    return MT_INT;
  if (!strncmp(type, "float", 5))
    return MT_FLOAT;
  if (!strncmp(type, "char", 4))
    return MT_CHAR;
  if (!strncmp(type, "string", 6))
    return MT_STRING;
}