QVdt.cc

Go to the documentation of this file.

#include "QVdt.hh"
 
#include <sstream>
#include <iterator>
#include <ctype.h>
#include <stdlib.h>
#include <string.h>
#include "QError.hh"
 
QVdt::QVdt_type QVdt::SearchType (const std::string& str) 
{
    // empty string
    if (!str.size ()) return String_QVdt;
 
    // vector first since are simple
    if (str[0] == '{' && str[str.size () - 1] == '}') return Vector_QVdt;
 
    // check for bool
    if(str == "false" || str == "true" || 
            str == "FALSE" || str == "TRUE"||
            str == "f" || str == "t") return Int_QVdt;
 
    // then check for number (int or float)
    char *error_ptr1 = 0,*error_ptr2 = 0;
    ::strtod (str.c_str (), &error_ptr1);
    if (error_ptr1 && *error_ptr1) return String_QVdt;  // not a number then is a string
 
    // then check for float
    *error_ptr1 = 0;
    ::strtol (str.c_str (), &error_ptr1, 10);
    ::strtol (str.c_str (), &error_ptr2, 16);
    if (error_ptr1 && *error_ptr1 && error_ptr2 && *error_ptr2) return Double_QVdt;  // not integer then is a float
 
    // last is integer
    return Int_QVdt;
}
 
void QVdt::AssignValue (const std::string& str) 
{
    //  bx_message msg(bx_message::critic, "QVdt: ");
    //  if (name_s.size ()) msg << "\"" << name_s << "\" ";
 
    char *error_ptr = NULL;
    value_s = str;
    QError err;
    switch (type_internal) {
        case QVdt::String_QVdt:
            value_s = str;
            break;
        case QVdt::Double_QVdt:
            value_f = ::strtod (str.c_str (), &error_ptr);
            {
                std::string msg = std::string("float conversion failed for ") + str;
                if (value_f == 0 && error_ptr && *error_ptr) {
                    err = QERR_TYPE_CONVERSION;     
                    err.SetDescription(msg);
                    {DianaThrow(err)};
                }
            }
            break;
        case QVdt::Int_QVdt:
            if(str == "true" || str == "TRUE" || str == "t") value_i = 1;
            else if(str == "false" || str == "FALSE" || str == "f") value_i = 0;
            else if(strncmp("0x", &(str.c_str()[str.find_first_not_of(" \t")]), 2) == 0)
               value_i = ::strtol (str.c_str (), &error_ptr, 16);  // 16 means force base 16
            else value_i = ::strtol (str.c_str (), &error_ptr, 10);  // 10 force base 10, 0 means autodetect the base, which is fine for 0x starting hex
            if (value_i == 0 && error_ptr && *error_ptr) {
                std::string msg = std::string("integer conversion failed for ") + str;
                err = QERR_TYPE_CONVERSION;     
                err.SetDescription(msg);
                {DianaThrow(err)};
            }
            break;
        case QVdt::Vector_QVdt:
            do {
                // Fill the vector
                std::string sub_str;
                if(str.size() > 1 && str[1] == '{') 
                    sub_str = str.substr (2, str.size () - 4);      // copy to local (modificable) discarding '{{' and '}}'
                else
                    sub_str = str.substr (1, str.size () - 2);      // copy to local (modificable) discarding '{' and '}'
                std::string::size_type colon = 0;
                while (sub_str.size ()) {
                    colon = sub_str.find (',', 0);              // Find first ',' (since string is erased from previous fields)
 
                    if (colon == std::string::npos) colon = sub_str.size ();    // If no more ',' are present sub_str is the last field
 
                    std::string::size_type start_field = 0;         // look for spaces around the element like " 12 ,"
                    for (; start_field < colon; start_field++) if (!isspace (sub_str[start_field])) break;
                    std::string::size_type end_field = colon - 1;
                    for (; end_field > start_field; end_field--) if (!isspace (sub_str[end_field])) break;
 
                    std::string value = sub_str.substr (start_field, end_field - start_field + 1); // Copy the value
 
                    if (!value.size ()) break;                  // Stop on last void element
 
                    value_v.push_back (QVdt (value, name_s));           // Fill the vector
 
                    sub_str.erase (0, colon + 1);               // Move forward
                }   
            } while (0); // This do while is present to allow the declaration of variables
            break;
        default:
           err.Set(QERR_UNKNOWN_ERR, __FILE__, __LINE__,
                   "internal QVdt error: cannot call AssignValue with an "
                   "undefined type value: \"" + str + "\"");
            {DianaThrow(err)};
    }
} 
 
std::string QVdt::ToString() const
{
    std::stringstream s;
    switch(type_internal) 
    {
        case Int_QVdt:
            s<<value_i;
            break;
        case Double_QVdt:
            s<<value_f;
            break;
        case String_QVdt:
            s<<value_s;
            break;
        case Vector_QVdt:
            {
                s<<"{";
                QVdt_vector::const_iterator viter = value_v.begin(); 
                while(viter != value_v.end()) {
                    s<<viter->GetString()<<",";
                    viter++;
                }
                s<<"}";
            }
            break;
        case Unassigned_QVdt:
        default:
            {
                QError err;
                err = QERR_UNKNOWN_ERR;
                err.SetDescription("internal QVdt error: cannot convert to string with an undefined type value");
                {DianaThrow(err)};
            }
            break;
    }
    return s.str();
}
 
QVdt::QVdt (const std::string& value, const std::string& name, QVdt_type type): name_s(name) 
{
    QVdt_type tmp_type = SearchType (value);
    type_internal = tmp_type;
    if( type != Unassigned_QVdt) {
        CheckType(type);
        type_internal = type;
    }
    AssignValue (value);
    fBuiltFromString = true;
}
 
const QVdt& QVdt::operator= (const std::string& value) 
{
    QVdt_type tmp_type = SearchType (value);
 
    if (type_internal != Unassigned_QVdt) CheckType (tmp_type);
 
    type_internal = tmp_type;
    AssignValue (value);
 
    fBuiltFromString = true;
    return *this;
}
 
const QVdt& QVdt::operator= (long int value) 
{
    if (type_internal != Unassigned_QVdt) CheckType (QVdt::Int_QVdt);
 
    type_internal = Int_QVdt; 
    value_i = value; 
 
    fBuiltFromString = false;
    return *this; 
}
 
const QVdt& QVdt::operator= (double value) 
{
    if (type_internal != Unassigned_QVdt) CheckType (QVdt::Double_QVdt);
 
    type_internal = Double_QVdt; 
    value_f = value; 
 
    fBuiltFromString = false;
    return *this; 
}
 
const QVdt& QVdt::operator=(const QVdt& other) 
{
    // if this is a string
    if (type_internal != Unassigned_QVdt && type_internal != String_QVdt) {
        CheckType (other.GetType());
    } 
    if( type_internal == Unassigned_QVdt) type_internal = other.GetType();
    value_i = other.value_i; 
    value_f = other.value_f; 
    value_v = other.value_v; 
    value_s = other.GetString();
    fBuiltFromString = other.fBuiltFromString;
    if(name_s == "") name_s = other.name_s;
    return *this;
}
 
 
long int QVdt::GetInt () const 
{
    CheckType (QVdt::Int_QVdt);
    return value_i;
}
 
double QVdt::GetDouble () const 
{
    CheckType (QVdt::Double_QVdt);
    return (type_internal == Double_QVdt) ? value_f : value_i;  // int->float cast always allowed
}
 
const std::string& QVdt::GetString () const 
{
    // always allow reading a parameter as string
    if(type_internal != String_QVdt && !fBuiltFromString)
        value_s = ToString();
    return value_s;
}
 
const QVdt::QVdt_vector& QVdt::GetVector () const 
{
    CheckType (QVdt::Vector_QVdt);
    return value_v;
}
 
void QVdt::CheckType (QVdt_type new_type) const 
{
    if (type_internal == new_type) return; 
 
    if (new_type == Double_QVdt && type_internal == Int_QVdt) return;   // int->float cast always allowed
    QError err = QERR_TYPE_CONVERSION;
    std::stringstream msg;
    if (name_s.size ()) msg << "\"" << name_s << "\" ";
    msg << "requested " << char(new_type) << " while current type is " << char(type_internal) << " (" << *this << "); cast not allowed";
    err.SetDescription(msg.str());
    {DianaThrow(err)};
}
 
 
std::ostream& operator<< (std::ostream& out, const QVdt& v) {
    switch (v.GetType ()) {
        case QVdt::Int_QVdt:
            out << v.GetInt ();
            break;
        case QVdt::Double_QVdt:
            out << v.GetDouble ();
            break;
        case QVdt::String_QVdt:
            out << v.GetString ();
            break;
        case QVdt::Vector_QVdt:
            out << "{ ";
            if (v.GetVector ().size ()) {
                std::copy (v.GetVector ().begin (), v.GetVector ().end () - 1, std::ostream_iterator<QVdt>(out, ", "));
                out << *(v.GetVector ().end () - 1) << " ";
            }
            out << "}";
            break;
        default:
          out << "unknown type (" << v.GetName() << ")"; 
    }
    return out;
}
 
template <> int QVdt::Get<int>() const
{
    return GetInt();
}
 
template <> double QVdt::Get<double>() const
{
    return GetDouble();
}
 
template <> bool QVdt::Get<bool>() const
{
    return GetBool();
}
 
template <> std::string QVdt::Get<std::string>() const
{
    return GetString();
}