include/FCam/TagValue.h

Go to the documentation of this file.

#ifndef FCAM_TAGVALUE_H
#define FCAM_TAGVALUE_H

#include <string>
#include <vector>

#include "Time.h"
#include "Event.h"

namespace FCam {

    class TagValue {

    public:
        enum Type {
            Null = 0, 
            Int,      
            Float,    
            Double,   
            String,   
            Time,     
            IntVector,    
            FloatVector,  
            DoubleVector, 
            StringVector, 
            TimeVector    
        };

        ~TagValue();


        TagValue(); 
        TagValue(int);
        TagValue(float);
        TagValue(double);
        TagValue(std::string);
        TagValue(FCam::Time);
        TagValue(std::vector<int>);
        TagValue(std::vector<float>);
        TagValue(std::vector<double>);
        TagValue(std::vector<std::string>);
        TagValue(std::vector<FCam::Time>);
        TagValue(const TagValue &);

        const TagValue &operator=(const int &);
        const TagValue &operator=(const float &);
        const TagValue &operator=(const double &);
        const TagValue &operator=(const std::string &);
        const TagValue &operator=(const FCam::Time &);
        const TagValue &operator=(const std::vector<int> &);
        const TagValue &operator=(const std::vector<float> &);
        const TagValue &operator=(const std::vector<double> &);
        const TagValue &operator=(const std::vector<std::string> &);
        const TagValue &operator=(const std::vector<FCam::Time> &);
        const TagValue &operator=(const TagValue &);
        
        operator int &() const;
        operator float &() const;
        operator double &() const;
        operator std::string &() const;
        operator FCam::Time &() const;
        operator std::vector<int> &() const; 
        operator std::vector<float> &() const;
        operator std::vector<double> &() const;
        operator std::vector<std::string> &() const;
        operator std::vector<FCam::Time> &() const;

       
        int &asInt() {return *this;}
        float &asFloat() {return *this;}
        double &asDouble() {return *this;}
        std::string &asString() {return *this;}
        FCam::Time &asTime() {return *this;}
        std::vector<int> &asIntVector() {return *this;}
        std::vector<float> &asFloatVector() {return *this;}
        std::vector<double> &asDoubleVector() {return *this;}
        std::vector<std::string> &asStringVector() {return *this;}
        std::vector<FCam::Time> &asTimeVector() {return *this;}

 

        bool valid() { return type != Null; }

        std::string toString() const;

        std::string toBlob();

        static TagValue fromString(const std::string &);

        Type type;

        void *data;

    private:
        void nullify();


        // Dummy objects to return references to. Set them to zero or
        // clear them before returning a reference to them.
        static int dummyInt;
        static float dummyFloat;
        static double dummyDouble;
        static std::string dummyString;
        static FCam::Time dummyTime;
        static std::vector<int> dummyIntVector;
        static std::vector<float> dummyFloatVector;
        static std::vector<double> dummyDoubleVector;
        static std::vector<std::string> dummyStringVector;
        static std::vector<FCam::Time> dummyTimeVector;

    };

    std::ostream & operator<<(std::ostream& out, const TagValue &t);

    std::istream & operator>>(std::istream& in, TagValue &t);

}
    
#endif