src/TagValue.cpp

#include "FCam/TagValue.h"

#include <sstream>
#include <iomanip>
#include <iostream>

namespace FCam {

    TagValue::TagValue() : type(Null), data(NULL) {

    }

    TagValue::~TagValue() {
        nullify();
    }

    void TagValue::nullify() {
        switch (type) {
        case Null:
            break;
        case Int:
            delete (int *)data;
            break;
        case Float:
            delete (float *)data;
            break;
        case Double:
            delete (double *)data;
            break;
        case String:
            delete (std::string *)data;
            break;
        case Time:
            delete (FCam::Time *)data;
            break;
        case IntVector:
            delete (std::vector<int> *)data;
            break;
        case FloatVector:
            delete (std::vector<float> *)data;
            break;
        case DoubleVector:
            delete (std::vector<double> *)data;
            break;
        case StringVector:
            delete (std::vector<std::string> *)data;
            break;
        case TimeVector:
            delete (std::vector<FCam::Time> *)data;
            break;
        }
        type = Null;
        data = NULL;
    }

    TagValue::TagValue(int x) {
        type = Int;
        int *ptr = new int;
        *ptr = x;
        data = (void *)ptr;
    }

    TagValue::TagValue(float x) {
        type = Float;
        float *ptr = new float;
        *ptr = x;
        data = (void *)ptr;
    }

    TagValue::TagValue(double x) {
        type = Double;
        double *ptr = new double;
        *ptr = x;
        data = (void *)ptr;
    }

    TagValue::TagValue(std::string x) {
        type = String;
        std::string *ptr = new std::string;
        *ptr = x;
        data = (void *)ptr;
    }

    TagValue::TagValue(FCam::Time x) {
        type = Time;
        FCam::Time *ptr = new FCam::Time;
        *ptr = x;
        data = (void *)ptr;
    }

    TagValue::TagValue(std::vector<int> x) {
        type = IntVector;
        std::vector<int> *ptr = new std::vector<int>;
        *ptr = x;
        data = (void *)ptr;
    }

    TagValue::TagValue(std::vector<float> x) {
        type = FloatVector;
        std::vector<float> *ptr = new std::vector<float>;
        *ptr = x;
        data = (void *)ptr;
    }

    TagValue::TagValue(std::vector<double> x) {
        type = DoubleVector;
        std::vector<double> *ptr = new std::vector<double>;
        *ptr = x;
        data = (void *)ptr;
    }

    TagValue::TagValue(std::vector<std::string> x) {
        type = StringVector;
        std::vector<std::string> *ptr = new std::vector<std::string>;
        *ptr = x;
        data = (void *)ptr;
    }

    TagValue::TagValue(std::vector<FCam::Time> x) {
        type = TimeVector;
        std::vector<FCam::Time> *ptr = new std::vector<FCam::Time>;
        *ptr = x;
        data = (void *)ptr;
    }

    const TagValue &TagValue::operator=(const int &x) {
        if (type == Int) {
            ((int *)data)[0] = x;
        } else {
            nullify();
            type = Int;
            int *ptr = new int;
            ptr[0] = x;
            data = (void *)ptr;
        }
        return *this;
    }

    const TagValue &TagValue::operator=(const float &x) {
        if (type == Float) {
            ((float *)data)[0] = x;
        } else {
            nullify();
            type = Float;
            float *ptr = new float;
            ptr[0] = x;
            data = (void *)ptr;
        }
        return *this;
    }

    const TagValue &TagValue::operator=(const double &x) {
        if (type == Double) {
            ((double *)data)[0] = x;
        } else {
            nullify();
            type = Double;
            double *ptr = new double;
            ptr[0] = x;
            data = (void *)ptr;
        }
        return *this;
    }

    const TagValue &TagValue::operator=(const std::string &x) {
        if (type == String) {
            ((std::string *)data)[0] = x;
        } else {
            nullify();
            type = String;
            std::string *ptr = new std::string;
            ptr[0] = x;
            data = (void *)ptr;
        }
        return *this;
    }

    const TagValue &TagValue::operator=(const FCam::Time &x) {
        if (type == Time) {
            ((FCam::Time *)data)[0] = x;
        } else {
            nullify();
            type = Time;
            FCam::Time *ptr = new FCam::Time;
            ptr[0] = x;
            data = (void *)ptr;
        }
        return *this;
    }

    const TagValue &TagValue::operator=(const std::vector<int> &x) {
        if (type == IntVector) {
            ((std::vector<int> *)data)[0] = x;
        } else {
            nullify();
            type = IntVector;
            std::vector<int> *ptr = new std::vector<int>;
            ptr[0] = x;
            data = (void *)ptr;
        }
        return *this;
    }

    const TagValue &TagValue::operator=(const std::vector<float> &x) {
        if (type == FloatVector) {
            ((std::vector<float> *)data)[0] = x;
        } else {
            nullify();
            type = FloatVector;
            std::vector<float> *ptr = new std::vector<float>;
            ptr[0] = x;
            data = (void *)ptr;
        }
        return *this;
    }

    const TagValue &TagValue::operator=(const std::vector<double> &x) {
        if (type == DoubleVector) {
            ((std::vector<double> *)data)[0] = x;
        } else {
            nullify();
            type = DoubleVector;
            std::vector<double> *ptr = new std::vector<double>;
            ptr[0] = x;
            data = (void *)ptr;
        }
        return *this;
    }

    const TagValue &TagValue::operator=(const std::vector<std::string> &x) {
        if (type == StringVector) {
            ((std::vector<std::string> *)data)[0] = x;
        } else {
            nullify();
            type = StringVector;
            std::vector<std::string> *ptr = new std::vector<std::string>;
            ptr[0] = x;
            data = (void *)ptr;
        }
        return *this;
    }

    const TagValue &TagValue::operator=(const std::vector<FCam::Time> &x) {
        if (type == TimeVector) {
            ((std::vector<FCam::Time> *)data)[0] = x;
        } else {
            nullify();
            type = TimeVector;
            std::vector<FCam::Time> *ptr = new std::vector<FCam::Time>;
            ptr[0] = x;
            data = (void *)ptr;
        }
        return *this;
    }

    const TagValue &TagValue::operator=(const TagValue &other) {
        switch(other.type) {
        case Null:
            nullify();
            return *this;
        case Int:
            *this = (int)other;
            return *this;
        case Float:
            *this = (float)other;
            return *this;
        case Double:
            *this = (double)other;
            return *this;
        case String:
            *this = (std::string)other;
            return *this;
        case Time:
            *this = (FCam::Time)other;
            return *this;
        case IntVector: {
            std::vector<int> temp = other;
            *this = temp;
            return *this;
        }
        case FloatVector: {
            std::vector<float> temp = other;
            *this = temp;
            return *this;
        }
        case DoubleVector: {
            std::vector<double> temp = other;
            *this = temp;
            return *this;
        }
        case StringVector: {
            std::vector<std::string> temp = other;
            *this = temp;
            return *this;
        }
        case TimeVector: {
            std::vector<FCam::Time> temp = other;
            *this = temp;
            return *this;
        }
        }
        return *this;
    }

    TagValue::TagValue(const TagValue &other) : type(Null), data(NULL) {
        *this = other;
    }

    TagValue::operator int &() const {
        switch (type) {
        case Null:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a null to an int");
            dummyInt = 0; return dummyInt;
        case Int:
            return ((int *)data)[0];
        case Float:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a float to an int");
            dummyInt = 0; return dummyInt;
        case Double:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a double to an int");
            dummyInt = 0; return dummyInt;
        case String:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a string to an int");
            dummyInt = 0; return dummyInt;
        case Time:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a time to an int");
            dummyInt = 0; return dummyInt;
        case IntVector:
            postEvent(Event::Error, Event::BadCast, "Cannot cast an int vector to an int");
            dummyInt = 0; return dummyInt;
        case FloatVector:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a float vector to an int");
            dummyInt = 0; return dummyInt;
        case DoubleVector:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a double vector to an int");
            dummyInt = 0; return dummyInt;
        case StringVector:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a string vector to an int");
            dummyInt = 0; return dummyInt;
        case TimeVector:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a time vector to an int");
            dummyInt = 0; return dummyInt;
        }
        dummyInt = 0; return dummyInt;
    }

    TagValue::operator float &() const {
        switch (type) {
        case Null:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a null to a float");
            dummyFloat = 0; return dummyFloat;
        case Int:
            postEvent(Event::Error, Event::BadCast, "Cannot cast an int to a float");
            dummyFloat = 0; return dummyFloat;
        case Float:
            return (((float *)data)[0]);
        case Double:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a double to a float");
            dummyFloat = 0; return dummyFloat;
        case String:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a string to a float");
            dummyFloat = 0; return dummyFloat;
        case Time:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a time to a float");
            dummyFloat = 0; return dummyFloat;
        case IntVector:
            postEvent(Event::Error, Event::BadCast, "Cannot cast an int vector to a float");
            dummyFloat = 0; return dummyFloat;
        case FloatVector:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a float vector to a float");
            dummyFloat = 0; return dummyFloat;
        case DoubleVector:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a double vector to a float");
            dummyFloat = 0; return dummyFloat;
        case StringVector:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a string vector to a float");
            dummyFloat = 0; return dummyFloat;
        case TimeVector:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a time vector to a float");
            dummyFloat = 0; return dummyFloat;
        }
        dummyFloat = 0; return dummyFloat;
    }

    TagValue::operator double &() const {
        switch (type) {
        case Null:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a null to a double");
            dummyDouble = 0; return dummyDouble;
        case Int:
            postEvent(Event::Error, Event::BadCast, "Cannot cast an int to a double");
            dummyDouble = 0; return dummyDouble;
        case Float:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a float to a double");
            dummyDouble = 0; return dummyDouble;
        case Double:
            return (((double *)data)[0]);
        case String:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a string to a double");
            dummyDouble = 0; return dummyDouble;
        case Time:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a time to a double");
            dummyDouble = 0; return dummyDouble;
        case IntVector:
            postEvent(Event::Error, Event::BadCast, "Cannot cast an int vector to a double");
            dummyDouble = 0; return dummyDouble;
        case FloatVector:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a float vector to a double");
            dummyDouble = 0; return dummyDouble;
        case DoubleVector:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a double vector to a double");
            dummyDouble = 0; return dummyDouble;
        case StringVector:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a string vector to a double");
            dummyDouble = 0; return dummyDouble;
        case TimeVector:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a time vector to a double");
            dummyDouble = 0; return dummyDouble;
        }
        dummyDouble = 0; return dummyDouble;
    }

    TagValue::operator std::string &() const {
        switch (type) {
        case Null:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a null to a string");
            dummyString.clear(); return dummyString;
        case Int:
            postEvent(Event::Error, Event::BadCast, "Cannot cast an int to a string");
            dummyString.clear(); return dummyString;
        case Float:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a float to a string");
            dummyString.clear(); return dummyString;
        case Double:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a double to a string");
            dummyString.clear(); return dummyString;
        case String:
            return ((std::string *)data)[0];
        case Time:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a time to a string");
            dummyString.clear(); return dummyString;
        case IntVector:
            postEvent(Event::Error, Event::BadCast, "Cannot cast an int vector to a string");
            dummyString.clear(); return dummyString;
        case FloatVector:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a float vector to a string");
            dummyString.clear(); return dummyString;
        case DoubleVector:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a double vector to a string");
            dummyString.clear(); return dummyString;
        case StringVector:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a string vector to a string");
            dummyString.clear(); return dummyString;
        case TimeVector:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a time vector to a string");
            dummyString.clear(); return dummyString;
        }
        dummyString.clear(); return dummyString;
    }

    TagValue::operator FCam::Time &() const {
        switch (type) {
        case Null:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a null to a time");
            dummyTime = FCam::Time(0, 0); return dummyTime;
        case Int:
            postEvent(Event::Error, Event::BadCast, "Cannot cast an int to a time");
            dummyTime = FCam::Time(0, 0); return dummyTime;
        case Float:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a float to a time");
            dummyTime = FCam::Time(0, 0); return dummyTime;
        case Double:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a double to a time");
            dummyTime = FCam::Time(0, 0); return dummyTime;
        case String:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a string to a time");
            dummyTime = FCam::Time(0, 0); return dummyTime;
        case Time:
            return ((FCam::Time *)data)[0];
        case IntVector:
            postEvent(Event::Error, Event::BadCast, "Cannot cast an int vector to a time");
            dummyTime = FCam::Time(0, 0); return dummyTime;
        case FloatVector:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a float vector to a time");
            dummyTime = FCam::Time(0, 0); return dummyTime;
        case DoubleVector:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a double vector to a time");
            dummyTime = FCam::Time(0, 0); return dummyTime;
        case StringVector:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a string vector to a time");
            dummyTime = FCam::Time(0, 0); return dummyTime;
        case TimeVector:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a time vector to a time");
            dummyTime = FCam::Time(0, 0); return dummyTime;
        }
        dummyTime = FCam::Time(0, 0); return dummyTime;
    }

    TagValue::operator std::vector<int> &() const {
        switch (type) {
        case Null:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a null to an int vector");
            dummyIntVector.clear(); return dummyIntVector;
        case Int:
            postEvent(Event::Error, Event::BadCast, "Cannot cast an int to an int vector");
            dummyIntVector.clear(); return dummyIntVector;
        case Float:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a float to an int vector");
            dummyIntVector.clear(); return dummyIntVector;
        case Double:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a double to an int vector");
            dummyIntVector.clear(); return dummyIntVector;
        case String:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a string to an int vector");
            dummyIntVector.clear(); return dummyIntVector;
        case Time:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a time to an int vector");
            dummyIntVector.clear(); return dummyIntVector;
        case IntVector:
            return ((std::vector<int> *)data)[0];
        case FloatVector:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a float vector to an int vector");
            dummyIntVector.clear(); return dummyIntVector;
        case DoubleVector:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a double vector to an int vector");
            dummyIntVector.clear(); return dummyIntVector;
        case StringVector:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a string vector to an int vector");
            dummyIntVector.clear(); return dummyIntVector;
        case TimeVector:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a time vector to an int vector");
            dummyIntVector.clear(); return dummyIntVector;
        }
        dummyIntVector.clear(); return dummyIntVector;
    }


    TagValue::operator std::vector<float> &() const {
        switch (type) {
        case Null:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a null to a float vector");
            dummyFloatVector.clear(); return dummyFloatVector;
        case Int:
            postEvent(Event::Error, Event::BadCast, "Cannot cast an int to a float vector");
            dummyFloatVector.clear(); return dummyFloatVector;
        case Float:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a float to a float vector");
            dummyFloatVector.clear(); return dummyFloatVector;
        case Double:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a double to a float vector");
            dummyFloatVector.clear(); return dummyFloatVector;
        case String:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a string to a float vector");
            dummyFloatVector.clear(); return dummyFloatVector;
        case Time:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a time to a float vector");
            dummyFloatVector.clear(); return dummyFloatVector;
        case IntVector:
            postEvent(Event::Error, Event::BadCast, "Cannot cast an int vector to a float vector");
            dummyFloatVector.clear(); return dummyFloatVector;
        case FloatVector:
            return ((std::vector<float> *)data)[0];
        case DoubleVector:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a double vector to a float vector");
            dummyFloatVector.clear(); return dummyFloatVector;
        case StringVector:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a string vector to a float vector");
            dummyFloatVector.clear(); return dummyFloatVector;
        case TimeVector:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a time vector to a float vector");
            dummyFloatVector.clear(); return dummyFloatVector;
        }
        dummyFloatVector.clear(); return dummyFloatVector;
    }

    TagValue::operator std::vector<double> &() const {
        switch (type) {
        case Null:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a null to a double vector");
            dummyDoubleVector.clear(); return dummyDoubleVector;
        case Int:
            postEvent(Event::Error, Event::BadCast, "Cannot cast an int to a double vector");
            dummyDoubleVector.clear(); return dummyDoubleVector;
        case Float:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a float to a double vector");
            dummyDoubleVector.clear(); return dummyDoubleVector;
        case Double:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a double to a double vector");
            dummyDoubleVector.clear(); return dummyDoubleVector;
        case String:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a string to a double vector");
            dummyDoubleVector.clear(); return dummyDoubleVector;
        case Time:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a time to a double vector");
            dummyDoubleVector.clear(); return dummyDoubleVector;
        case IntVector:
            postEvent(Event::Error, Event::BadCast, "Cannot cast an int vector to a double vector");
            dummyDoubleVector.clear(); return dummyDoubleVector;
        case FloatVector:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a float vector to a double vector");
            dummyDoubleVector.clear(); return dummyDoubleVector;
        case DoubleVector:
            return ((std::vector<double> *)data)[0];
        case StringVector:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a string vector to a double vector");
            dummyDoubleVector.clear(); return dummyDoubleVector;
        case TimeVector:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a time vector to a double vector");
            dummyDoubleVector.clear(); return dummyDoubleVector;
        }
        dummyDoubleVector.clear(); return dummyDoubleVector;
    }



    TagValue::operator std::vector<std::string> &() const {
        switch (type) {
        case Null:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a null to a string vector");
            dummyStringVector.clear(); return dummyStringVector;
        case Int:
            postEvent(Event::Error, Event::BadCast, "Cannot cast an int to a string vector");
            dummyStringVector.clear(); return dummyStringVector;
        case Float:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a float to a string vector");
            dummyStringVector.clear(); return dummyStringVector;
        case Double:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a double to a string vector");
            dummyStringVector.clear(); return dummyStringVector;
        case String:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a string to a string vector");
            dummyStringVector.clear(); return dummyStringVector;
        case Time:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a time to a string vector");
            dummyStringVector.clear(); return dummyStringVector;
        case IntVector:
            postEvent(Event::Error, Event::BadCast, "Cannot cast an int vector to a string vector");
            dummyStringVector.clear(); return dummyStringVector;
        case FloatVector:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a float vector to a string vector");
            dummyStringVector.clear(); return dummyStringVector;
        case DoubleVector:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a double vector to a string vector");
            dummyStringVector.clear(); return dummyStringVector;
        case StringVector:
            return ((std::vector<std::string> *)data)[0];
        case TimeVector:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a time vector to a string vector");
            dummyStringVector.clear(); return dummyStringVector;
        }
        dummyStringVector.clear(); return dummyStringVector;
    }

    TagValue::operator std::vector<FCam::Time> &() const {
        switch (type) {
        case Null:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a null to a time vector");
            dummyTimeVector.clear(); return dummyTimeVector;
        case Int:
            postEvent(Event::Error, Event::BadCast, "Cannot cast an int to a time vector");
            dummyTimeVector.clear(); return dummyTimeVector;
        case Float:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a float to a time vector");
            dummyTimeVector.clear(); return dummyTimeVector;
        case Double:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a double to a time vector");
            dummyTimeVector.clear(); return dummyTimeVector;
        case String:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a string to a time vector");
            dummyTimeVector.clear(); return dummyTimeVector;
        case Time:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a time to a time vector");
            dummyTimeVector.clear(); return dummyTimeVector;
        case IntVector:
            postEvent(Event::Error, Event::BadCast, "Cannot cast an int vector to a time vector");
            dummyTimeVector.clear(); return dummyTimeVector;
        case FloatVector:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a float vector to a time vector");
            dummyTimeVector.clear(); return dummyTimeVector;
        case DoubleVector:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a double vector to a time vector");
            dummyTimeVector.clear(); return dummyTimeVector;
        case StringVector:
            postEvent(Event::Error, Event::BadCast, "Cannot cast a string vector to a time vector");
            dummyTimeVector.clear(); return dummyTimeVector;
        case TimeVector:
            return ((std::vector<FCam::Time> *)data)[0];
        }
        dummyTimeVector.clear(); return dummyTimeVector;
    }

    std::string TagValue::toString() const {
        std::ostringstream sstr;
        sstr << *this;
        return sstr.str();
    }

    TagValue TagValue::fromString(const std::string &str) {
        TagValue t;
        std::istringstream sstr(str);
        sstr >> t;
        return t;
    }

    std::string TagValue::toBlob() {
        std::string str;
        switch(type) {
        case Null:
        {
            str.resize(2);
            str[0] = 'b';
            str[1] = (char)type;
            return str;
        }
        case Int:
        {
            str.resize(4 + sizeof(int));
            str[0] = 'b';
            str[1] = (char)type;
            int *ptr = (int *)(&(str[4]));
            ptr[0] = (int)(*this);
            return str;
        }
        case Float:
        {
            str.resize(4 + sizeof(float));
            str[0] = 'b';
            str[1] = (char)type;
            float *ptr = (float *)(&(str[4]));
            ptr[0] = (float)(*this);
            return str;
        }
        case Double:
        {
            str.resize(4 + sizeof(double));
            str[0] = 'b';
            str[1] = (char)type;
            double *ptr = (double *)(&(str[4]));
            ptr[0] = (double)(*this);
            return str;
        }
        case String: {
            std::string &x = *this;
            str.resize(8 + x.size());
            str[0] = 'b';
            str[1] = (char)type;
            int *ptr = (int *)(&(str[4]));
            ptr[0] = x.size();
            for (size_t i = 0; i < x.size(); i++) {
                str[i+8] = x[i];
            }
            return str;
        }
        case Time: {
            str.resize(4 + sizeof(int)*2);
            str[0] = 'b';
            str[1] = (char)type;
            int *ptr = (int *)(&(str[4]));
            FCam::Time time = *this;
            ptr[0] = time.s();
            ptr[1] = time.us();
            return str;
        }
        case IntVector: {
            std::vector<int> &x = *this;
            str.resize(4 + (1+x.size())*sizeof(int));
            str[0] = 'b';
            str[1] = (char)type;
            int *ptr = (int *)(&(str[4]));
            ptr[0] = x.size();
            for (size_t i = 0; i < x.size(); i++) {
                ptr[i+1] = x[i];
            }
            return str;
        }
        case FloatVector: {
            std::vector<float> &x = *this;
            str.resize(4 + sizeof(int) + x.size()*sizeof(float));
            str[0] = 'b';
            str[1] = (char)type;
            int *iptr = (int *)(&(str[4]));
            float *fptr = (float *)(&(str[4 + sizeof(int)]));
            iptr[0] = x.size();
            for (size_t i = 0; i < x.size(); i++) {
                fptr[i] = x[i];
            }
            return str;
        }
        case DoubleVector: {
            std::vector<double> &x = *this;
            str.resize(4 + (1+x.size())*sizeof(double));
            str[0] = 'b';
            str[1] = (char)type;
            int *iptr = (int *)(&(str[4]));
            double *fptr = (double *)(&(str[4 + sizeof(int)]));
            iptr[0] = x.size();
            for (size_t i = 0; i < x.size(); i++) {
                fptr[i] = x[i];
            }
            return str;
        }
        case StringVector: {
            std::vector<std::string> &x = *this;
            size_t total = 0;
            for (size_t i = 0; i < x.size(); i++) {
                total += x[i].size();
            }
            str.resize(4 + sizeof(int)*(1+x.size()) + total);
            str[0] = 'b';
            str[1] = (char)type;
            int *ptr = (int *)(&(str[4]));
            ptr[0] = x.size();
            for (size_t i = 0; i < x.size(); i++) {
                ptr[i+1] = x[i].size();
            }
            int idx = 4 + sizeof(int)*(1+x.size());
            for (size_t i = 0; i < x.size(); i++) {
                for (size_t j = 0; j < x[i].size(); j++) {
                    str[idx+j] = x[i][j];
                }
                idx += x[i].size();
            }
            return str;
        }

        case TimeVector:
            std::vector<FCam::Time> &x = *this;
            str.resize(4 + sizeof(int)*(1+2*x.size()));
            str[0] = 'b';
            str[1] = (char)type;
            int *ptr = (int *)(&(str[4]));
            ptr[0] = x.size();
            for (size_t i = 0; i < x.size(); i++) {
                ptr[i*2+1] = x[i].s();
                ptr[i*2+2] = x[i].us();
            }
            return str;
        }
        return "";
    }

    std::ostream & operator<<(std::ostream& out, const TagValue &t) {
        out << std::scientific;
        switch (t.type) {
        case TagValue::Null: {
            return (out << "None");
        }

        case TagValue::Int: {
            int contents = t;
            return (out << contents);
        }

        case TagValue::Float: {
            out.precision(8);
            float contents = t;
            return (out << contents << 'f');
        }

        case TagValue::Double: {
            out.precision(16);
            double contents = t;
            return (out << contents);
        }

        case TagValue::String: {
            std::string contents = t;
            out << '"';
            for (size_t j = 0; j < contents.size(); j++) {
                char c = contents[j];
                if (isprint(c) && c != '"' && c != '\\') {
                    out << c;
                } else {
                    int x = (int)c;
                    if (x < 16) {
                        out << "\\x0" << std::hex << x << std::dec;
                    } else {
                        out << "\\x" << std::hex << x << std::dec;
                    }
                }
            }
            out << '"';
            return out;
        }

        case TagValue::Time: {
            Time contents = t;
            return (out << "(" << contents.s() << ", " << contents.us() << ")");
        }

        case TagValue::IntVector: {
            std::vector<int> &contents = t;
            out << "[";
            if (contents.size() > 0) {
                for (size_t i = 0; i < contents.size()-1; i++) {
                    out << contents[i] << ", ";
                }
                out << contents[contents.size()-1];
            }
            out << "]";
            return out;
        }

        case TagValue::FloatVector: {
            out.precision(8);
            std::vector<float> &contents = t;
            out << "[";
            if (contents.size() > 0) {
                for (size_t i = 0; i < contents.size()-1; i++) {
                    out << contents[i] << "f, ";
                }
                out << contents[contents.size()-1];
            }
            out << "]";
            return out;
        }

        case TagValue::DoubleVector: {
            out.precision(16);
            std::vector<double> &contents = t;
            out << "[";
            if (contents.size() > 0) {
                for (size_t i = 0; i < contents.size()-1; i++) {
                    out << contents[i] << ", ";
                }
                out << contents[contents.size()-1];
            }
            out << "]";
            return out;
        }

        case TagValue::StringVector: {
            std::vector<std::string> &contents = t;
            out << "[";
            if (contents.size() > 0) {
                for (size_t i = 0; i < contents.size(); i++) {
                    if (i) out << ", ";
                    out << '"';
                    for (size_t j = 0; j < contents[i].size(); j++) {
                        char c = contents[i][j];
                        if (isprint(c) && c != '"' && c != '\\') {
                            out << c;
                        } else {
                            int x = (int)c;
                            if (x < 16) {
                                out << "\\x0" << std::hex << x << std::dec;
                            } else {
                                out << "\\x" << std::hex << x << std::dec;
                            }
                        }
                    }
                    out << '"';
                }
            }
            out << "]";
            return out;
        }

        case TagValue::TimeVector: {
            std::vector<FCam::Time> &contents = t;
            out << "[";
            if (contents.size() > 0) {
                for (size_t i = 0; i < contents.size(); i++) {
                    if (i) out << ", ";
                    out << "(" << contents[i].s() << ", " << contents[i].us() << ")";
                }
            }
            out << "]";
            return out;
        }

        }
        return out;
    }

    TagValue::Type readType(int x) {
        switch (x) {
        case TagValue::Null:
            return TagValue::Null;
        case TagValue::Int:
            return TagValue::Int;
        case TagValue::Float:
            return TagValue::Float;
        case TagValue::Double:
            return TagValue::Double;
        case TagValue::String:
            return TagValue::String;
        case TagValue::Time:
            return TagValue::Time;
        case TagValue::IntVector:
            return TagValue::IntVector;
        case TagValue::FloatVector:
            return TagValue::FloatVector;
        case TagValue::DoubleVector:
            return TagValue::DoubleVector;
        case TagValue::StringVector:
            return TagValue::StringVector;
        case TagValue::TimeVector:
            return TagValue::TimeVector;
        default:
            error(Event::ParseError, "Invalid type for tag value: %d", x);
            return TagValue::Null;
        }
    }

    std::istream & operator>>(std::istream& in, TagValue &t) {
        switch (in.peek()) {
        case 'b':
            // binary blob
        {
            in.get();
            TagValue::Type type = readType(in.get());
            // skip the next two chars (they are for word-alignment and future proofing)
            if (in.get() != 0 || in.get() != 0) {
                goto error;
            }
            switch (type) {
            case TagValue::Null: {
                TagValue nullTag;
                t = nullTag;
                return in;
            }
            case TagValue::Int: {
                int x;
                in.read((char *)&x, sizeof(int));
                t = x;
                return in;
            }
            case TagValue::Float: {
                float x;
                in.read((char *)&x, sizeof(float));
                t = x;
                return in;
            }
            case TagValue::Double: {
                double x;
                in.read((char *)&x, sizeof(double));
                t = x;
                return in;
            }
            case TagValue::Time: {
                int x[2];
                in.read((char *)x, sizeof(int)*2);
                t = FCam::Time(x[0], x[1]);
                return in;
            }
            case TagValue::String: {
                int size;
                std::string x;
                in.read((char *)&size, sizeof(int));
                x.resize(size);
                in.read((char *)(&(x[0])), size);
                t = x;
                return in;
            }
            case TagValue::IntVector: {
                int size;
                std::vector<int> v;
                t = v;
                std::vector<int> &x = t;
                in.read((char *)&size, sizeof(int));
                x.resize(size);
                in.read((char *)(&(x[0])), sizeof(int)*size);
                return in;
            }
            case TagValue::FloatVector: {
                int size;
                std::vector<float> v;
                t = v;
                std::vector<float> &x = t;
                in.read((char *)&size, sizeof(int));
                x.resize(size);
                in.read((char *)(&(x[0])), sizeof(float)*size);
                return in;
            }
            case TagValue::DoubleVector: {
                int size;
                std::vector<double> v;
                t = v;
                std::vector<double> &x = t;
                in.read((char *)&size, sizeof(int));
                x.resize(size);
                in.read((char *)(&(x[0])), sizeof(double)*size);
                return in;
            }
            case TagValue::StringVector: {
                int size;
                std::vector<std::string> v;
                t = v;
                std::vector<std::string> &x = t;
                in.read((char *)&size, sizeof(int));
                x.resize(size);
                for (size_t i = 0; i < x.size(); i++) {
                    in.read((char *)&size, sizeof(int));
                    x[i].resize(size);
                }
                for (size_t i = 0; i < x.size(); i++) {
                    in.read((char *)(&(x[i][0])), x[i].size());
                }
                return in;
            }
            case TagValue::TimeVector: {
                int size;
                std::vector<FCam::Time> v;
                t = v;
                std::vector<FCam::Time> &x = t;
                in.read((char *)&size, sizeof(int));
                x.resize(size);
                for (size_t i = 0; i < x.size(); i++) {
                    int time[2];
                    in.read((char *)time, sizeof(int)*2);
                    x[i] = FCam::Time(time[0], time[1]);
                }
                return in;
            }
            default:
                goto error;
            }
        }
        case '-': case '0': case '1': case '2': case '3': case '4':
        case '5': case '6': case '7': case '8': case '9':
            // numeric
        {
            // suck it into a string
            std::ostringstream osstr;

            bool floating = false;
            if (in.peek() == '-') {
                osstr << char(in.get());
                if (!isdigit(in.peek())) {
                    // oops
                    in.putback('-');
                    goto error;
                }
            }
            while (isdigit(in.peek())) osstr << char(in.get());
            if (in.peek() == '.') {
                floating = true;
                osstr << char(in.get());
                if (!isdigit(in.peek())) {
                    // oops!
                    in.putback('.');
                    floating = false;
                    goto done;
                }
            }
            while (isdigit(in.peek())) osstr << char(in.get());
            if (in.peek() == 'e') osstr << char(in.get());
            else goto done;
            if (in.peek() == '+') osstr << char(in.get());
            else if (in.peek() == '-') osstr << char(in.get());
            else {
                // oops!
                in.putback('e');
                goto done;
            }
            while (isdigit(in.peek())) osstr << char(in.get());

          done:
            std::istringstream isstr(osstr.str());
            if (floating && in.peek() == 'f') {
                in.get();
                float x;
                isstr >> x;
                t = x;
            } else if (floating) {
                double x;
                isstr >> x;
                t = x;
            } else {
                int x;
                isstr >> x;
                t = x;
            }
            return in;
        }
        case 'N':
        {
            in.get();
            if (in.peek() != 'o') {
                in.putback('N');
                goto error;
            }
            in.get();
            if (in.peek() != 'n') {
                in.putback('o');
                in.putback('N');
                goto error;
            }
            in.get();
            if (in.peek() != 'e') {
                in.putback('n');
                in.putback('o');
                in.putback('N');
                goto error;
            }
            in.get();
            // None
            TagValue null;
            t = null;
            return in;
        }
        case '(':
        {
            in.get();
            timeval tv;
            in >> tv.tv_sec;
            in >> std::ws;
            if (in.peek() != ',') goto error;
            in.get();
            in >> std::ws;
            in >> tv.tv_usec;
            if (in.peek() != ')') goto error;
            in.get();
            FCam::Time time(tv);
            t = time;
            return in;
        }
        case '"':
        {
            // string
            in.get();
            std::ostringstream osstr;
            while (in.peek() != '"') {
                if (in.peek() < 0) {
                    t = osstr.str();
                    goto error;
                } else if (in.peek() == '\\') {
                    in.get();
                    switch(in.get()) {
                    case '0':
                        osstr << '\0';
                        break;
                    case 'n':
                        osstr << '\n';
                        break;
                    case 'r':
                        osstr << '\r';
                        break;
                    case 'x': {
                        int v = 0;
                        char c1 = in.get();
                        char c2 = in.get();
                        if (c1 >= '0' && c1 <= '9') {
                            v = (c1 - '0');
                        } else if (c1 >= 'a' && c1 <= 'f') {
                            v = (c1 - 'a' + 10);
                        } else {
                            in.putback(c2);
                            in.putback(c1);
                            t = osstr.str();
                            goto error;
                        }
                        v = v << 4;
                        if (c2 >= '0' && c2 <= '9') {
                            v += (c2 - '0');
                        } else if (c2 >= 'a' && c2 <= 'f') {
                            v += (c2 - 'a' + 10);
                        } else {
                            in.putback(c2);
                            in.putback(c1);
                            t = osstr.str();
                            goto error;
                        }
                        osstr << (char)v;
                        break;
                    }
                    case '"':
                        osstr << '"';
                        break;
                    case '\\':
                        osstr << '\\';
                        break;
                    case 'a':
                        osstr << '\a';
                        break;
                    case 'b':
                        osstr << '\b';
                        break;
                    case 'v':
                        osstr << '\v';
                        break;
                    case '\'':
                        osstr << '\'';
                        break;
                    case 'f':
                        osstr << '\f';
                        break;
                    case 't':
                        osstr << '\t';
                        break;
                    default:
                        t = osstr.str();
                        goto error;
                    }
                } else {
                    osstr << (char)in.get();
                }
            }
            in.get();
            t = osstr.str();
            return in;
        }
        case '[':
        {
            // an array
            in.get();

            // consume whitespace
            in >> std::ws;
            // check it's not a list of lists
            if (in.peek() == '[') goto error;
            // recursively parse the first entry
            TagValue first;
            in >> first;
            switch (first.type) {
            case TagValue::Int:
            {
                std::vector<int> v;
                t = v;
                std::vector<int> &l = t;
                l.push_back(first);
                in >> std::ws;
                while (in.peek() != ']') {
                    int x;
                    if (in.peek() != ',') goto error;
                    in.get();
                    in >> std::ws >> x >> std::ws;
                    l.push_back(x);
                }
                in.get();
                return in;
            }
            case TagValue::Float:
            {
                std::vector<float> v;
                t = v;
                std::vector<float> &l = t;
                l.push_back(first);
                in >> std::ws;
                while (in.peek() != ']') {
                    float x;
                    if (in.peek() != ',') goto error;
                    in.get();
                    in >> std::ws >> x;
                    if (in.peek() == 'f') in.get();
                    in >> std::ws;
                    l.push_back(x);
                }
                in.get();
                return in;
            }
            case TagValue::Double:
            {
                std::vector<double> v;
                t = v;
                std::vector<double> &l = t;
                l.push_back(first);
                in >> std::ws;
                while (in.peek() != ']') {
                    double x;
                    if (in.peek() != ',') goto error;
                    in.get();
                    in >> std::ws >> x >> std::ws;
                    l.push_back(x);
                }
                in.get();
                return in;
            }
            case TagValue::Time:
            {
                std::vector<FCam::Time> v;
                t = v;
                std::vector<FCam::Time> &l = t;
                l.push_back(first);
                in >> std::ws;
                while (in.peek() != ']') {
                    TagValue x;
                    if (in.peek() != ',') goto error;
                    in.get();
                    in >> std::ws >> x >> std::ws;
                    if (x.type != TagValue::Time) goto error;
                    l.push_back((FCam::Time)x);
                }
                in.get();
                return in;
            }
            case TagValue::String:
            {
                std::vector<std::string> v;
                t = v;
                std::vector<std::string> &l = t;
                l.push_back(first);
                in >> std::ws;
                while (in.peek() != ']') {
                    TagValue x;
                    if (in.peek() != ',') goto error;
                    in.get();
                    in >> std::ws >> x >> std::ws;
                    if (x.type != TagValue::String) goto error;
                    l.push_back((std::string)x);
                }
                in.get();
                return in;
            }
            default:
                goto error;
            }
            if (first.type == TagValue::Null) {
                goto error;
            }

            return in;
        }
        case EOF:
            // the stream eof bit is now set
            t = TagValue();
            return in;
        default:
            goto error;
        }

        return in;
      error:
        error(Event::ParseError, "Could not parse TagValue");
        return in;
    }

    int TagValue::dummyInt;
    float TagValue::dummyFloat;
    double TagValue::dummyDouble;
    std::string TagValue::dummyString;
    FCam::Time TagValue::dummyTime;
    std::vector<int> TagValue::dummyIntVector;
    std::vector<float> TagValue::dummyFloatVector;
    std::vector<double> TagValue::dummyDoubleVector;
    std::vector<std::string> TagValue::dummyStringVector;
    std::vector<FCam::Time> TagValue::dummyTimeVector;

}