/Users/paul/Documents/phlogo/core/Thing.cpp

/*
 *  Thing.cpp
 *
 *  Author: Paul Hamilton
 *      Date: 8 Jun 2011
 *
 */

#include "Thing.h"

#include "Exceptions.h"
#include "List.h"
#include "Array.h"

#include <boost/lexical_cast.hpp>

using namespace std;
using namespace boost;

namespace phlogo {

Thing::Thing(const std::string &s) {
    string s1 = s;
    _data = s1; 
}

void Thing::set(pThing thing) {
        _data = thing->_data;
}

void Thing::set(const string &s) { 
        _data = s;
}

void Thing::set(long num) { 
        _data = num;
}

void Thing::set(double num) { 
    _data = num;
}

List Thing::allocList() {
        _data = make_tuple(false, tListArray());
        return List(&(get<tListData>(_data).get<1>()));
}

Array Thing::allocArray(int size) {
        _data = make_tuple(true, tListArray());
        return Array(&(get<tListData>(_data).get<1>()), size);
}

List Thing::allocList(const tListArray &list) {
        _data = make_tuple(false, list);
        return List(&(get<tListData>(_data).get<1>()));
}

Array Thing::allocArray(const tListArray &array) {
        _data = make_tuple(true, array);
        return Array(&(get<tListData>(_data).get<1>()));
}

std::string Thing::type() {
    
    if (isWord())
       return "word";
    else if (isList())
        return "list";
    else if (isArray())
        return "array";
    else if (isLong())
        return "long";
    else if (isDouble())
        return "double";
    else
        return "unknown";

}

bool Thing::isWord() { 
        try {
                get<string>(_data);
                return true;
        }
        catch (bad_get &x) {
        }
        return false;
}

bool Thing::isLong() { 
        try {
                get<long>(_data);
                return true;
        }
        catch (bad_get &x) {
        }
        return false;
}

bool Thing::isDouble() { 
    try {
        get<double>(_data);
        return true;
    }
    catch (bad_get &x) {
    }
    return false;
}

bool Thing::isList() { 
        try {
                tListData &d = get<tListData>(_data);
                return !d.get<0>();
        }
        catch (bad_get &x) {
        }
        return false;
}

bool Thing::isArray() { 
        try {
                tListData &d = get<tListData>(_data);
                return d.get<0>();
        }
        catch (bad_get &x) {
        }
        return false;
}

string Thing::getWord()  { 

        try {
                return get<string>(_data);
        }
        catch (bad_get &x) {
                BOOST_THROW_EXCEPTION( no_word_in_thing_exception() );
        }
}

long Thing::getLong()  { 

        try {
                return get<long>(_data);
        }
        catch (bad_get &x) {
                BOOST_THROW_EXCEPTION( no_word_in_thing_exception() );
        }
}

double Thing::getDouble()  { 
    
    try {
        return get<double>(_data);
    }
    catch (bad_get &x) {
        BOOST_THROW_EXCEPTION( no_word_in_thing_exception() );
    }
}

List Thing::getList() {

        try {
                tListData &d = get<tListData>(_data);
                if (d.get<0>())
                        BOOST_THROW_EXCEPTION( no_list_in_thing_exception() );
                
                return List(&d.get<1>());
        }
        catch (bad_get &x) {
                BOOST_THROW_EXCEPTION( no_list_in_thing_exception() );
        }
        
}

Array Thing::getArray() {

        try {
                tListData &d = get<tListData>(_data);
                if (!d.get<0>())
                        BOOST_THROW_EXCEPTION( no_array_in_thing_exception() );
                
                return Array(&d.get<1>());
        }
        catch (bad_get &x) {
                BOOST_THROW_EXCEPTION( no_array_in_thing_exception() );
        }

}

string Thing::str() {

        if (isWord())
                return getWord();
        else if (isList())
                return getList().str();
        else if (isLong())
        return lexical_cast<string>(getLong());
        else if (isDouble())
        return lexical_cast<string>(getDouble());
    else
                return getArray().str();

}

long Thing::asLong() {
    
    if (isWord())
        return lexical_cast<long>(getWord());
    else if (isLong())
        return getLong();
    else
        BOOST_THROW_EXCEPTION( bad_cast() );

}

double Thing::asDouble() {
    
    if (isWord())
        return lexical_cast<double>(getWord());
    else if (isLong())
        return (double)getLong();
    else if (isDouble())
        return getDouble();
    else
        BOOST_THROW_EXCEPTION( bad_cast() );
}

}