ValueVariant.cpp

#include "ValueVariant.h"
 
#include "Foundation/Logging/Logger.h"
 
#include <glm/gtc/type_ptr.hpp>
 
#include "Parsing.h"
 
namespace
{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("ValueVariant");
}
 
Cogs::Core::ValueVariant::ValueVariant( const ValueVariant& original) : stringValue( original.stringValue ){
  type = original.type;
  memcpy(static_cast<void*>(&float4x4Value), &original.float4x4Value, sizeof(float4x4Value));
}
 
bool Cogs::Core::ValueVariant::isNumericType(ParsedDataType type) const
{
  return type == ParsedDataType::Float ||
    type == ParsedDataType::Double ||
    type == ParsedDataType::Int;
}
 
float Cogs::Core::ValueVariant::getFloat(float defaultValue) const
{
  switch (type) {
  case ParsedDataType::Float:
    return floatValue;
  default:
    return static_cast<float>(getDouble(defaultValue));
  }
}
 
double Cogs::Core::ValueVariant::getDouble(double defaultValue) const
{
  switch (type) {
  case ParsedDataType::Bool:
    return boolValue ? 1 : 0;
  case ParsedDataType::Int:
    return static_cast<double>(intValue);
  case ParsedDataType::Float:
    return floatValue;
  case ParsedDataType::Double:
    return doubleValue;
  case ParsedDataType::String:
    return parseDouble(stringValue, defaultValue);
  case ParsedDataType::Unknown:
    return defaultValue;
  default:
    LOG_WARNING(logger, "Invalid implicit conversion from type %d to numeric.", static_cast<int>(type));
    return defaultValue;
  }
}
 
bool Cogs::Core::ValueVariant::getBool(bool defaultValue) const
{
  switch (type) {
  case ParsedDataType::Bool:
    return boolValue;
  case ParsedDataType::Int:
    return intValue > 0;
  case ParsedDataType::String:
    return parseBool(stringValue, defaultValue);
  case ParsedDataType::Unknown:
    return defaultValue;
  default:
    LOG_WARNING(logger, "Invalid implicit conversion from type %d to numeric.", static_cast<int>(type));
    return defaultValue;
  }
}
 
int Cogs::Core::ValueVariant::getInt(int defaultValue) const
{
  switch (type) {
  case ParsedDataType::Bool:
    return boolValue ? 1 : 0;
  case ParsedDataType::Int:
    return intValue;
  case ParsedDataType::Float:
    return (int)floatValue;
  case ParsedDataType::Double:
    return (int)doubleValue;
  case ParsedDataType::String:
    return parseInt(stringValue, defaultValue);
  case ParsedDataType::Unknown:
    return defaultValue;
  default:
    LOG_WARNING(logger, "Invalid implicit conversion from type %d to int.", static_cast<int>(type));
    return defaultValue;
  }
}
 
glm::vec2 Cogs::Core::ValueVariant::getVec2(glm::vec2 defaultValue) const
{
  switch (type) {
  case ParsedDataType::Float2:
    return float2Value;
  case ParsedDataType::Float3:
    return glm::vec2(float3Value);
  case ParsedDataType::Float4:
    return glm::vec2(float4Value);
  case ParsedDataType::String:
  {
    glm::vec2 value = {};
    auto tokens = split(stringValue, ",[](){}");
 
    parseValues(glm::value_ptr(value), tokens, 2);
    
    return value;
  }
  default:
    return defaultValue;
  }
}
 
glm::vec3 Cogs::Core::ValueVariant::getVec3(glm::vec3 defaultValue) const
{
  switch (type) {
  case ParsedDataType::Float3:
    return float3Value;
  case ParsedDataType::Float4:
    return glm::vec3(float4Value);
  case ParsedDataType::String:
  {
    glm::vec3 value = {};
    auto tokens = split(stringValue, ",[](){}");
 
    parseValues(glm::value_ptr(value), tokens, 3);
 
    return value;
  }
  default:
    return defaultValue;
  }
}
 
glm::vec4 Cogs::Core::ValueVariant::getVec4(glm::vec4 defaultValue) const
{
  switch (type) {
  case ParsedDataType::Float3:
    return glm::vec4(float3Value, 1);
  case ParsedDataType::Float4:
    return float4Value;
  case ParsedDataType::String:
  {
    glm::vec4 value = defaultValue;
    auto tokens = split(stringValue, ",[](){}");
 
    parseValues(glm::value_ptr(value), tokens, 4);
 
    return value;
  }
  default:
    return defaultValue;
  }
}
 
Cogs::StringView Cogs::Core::ValueVariant::getString(StringView defaultValue) const
{ 
  return type == ParsedDataType::String ? stringValue : defaultValue;
}
 
Cogs::Core::ValueVariant& Cogs::Core::ValueVariant::operator =( const ValueVariant& rhs) {
  type = rhs.type;
  stringValue = rhs.stringValue;
 
  switch (type) {
    case ParsedDataType::Float:     floatValue = rhs.floatValue;        break;
    case ParsedDataType::Float2:    float2Value = rhs.float2Value;      break;
    case ParsedDataType::Float3:    float3Value = rhs.float3Value;      break;
    case ParsedDataType::Float4:    float4Value = rhs.float4Value;      break;
    case ParsedDataType::Float4x4:  float4x4Value = rhs.float4x4Value;  break;
    case ParsedDataType::Int:       intValue = rhs.intValue;            break;
    case ParsedDataType::Int2:      int2Value = rhs.int2Value;          break;
    case ParsedDataType::Int3:      int3Value = rhs.int3Value;          break;
    case ParsedDataType::Int4:      int4Value = rhs.int4Value;          break;
    case ParsedDataType::UInt:      uintValue = rhs.uintValue;          break;
    case ParsedDataType::UInt2:     uint2Value = rhs.uint2Value;        break;
    case ParsedDataType::UInt3:     uint3Value = rhs.uint3Value;        break;
    case ParsedDataType::UInt4:     uint4Value = rhs.uint4Value;        break;
    case ParsedDataType::Bool:      boolValue = rhs.boolValue;          break;
    case ParsedDataType::Double:    doubleValue = rhs.doubleValue;      break;
    default: break;
  }
  return *this;
}