• Main Page
  • Related Pages
  • Namespaces
  • Classes
  • Files
  • File List
  • File Members

src/TagValue.cpp

00001 #include "FCam/TagValue.h"
00002 
00003 #include <sstream>
00004 #include <iomanip>
00005 #include <iostream>
00006 
00007 namespace FCam {
00008 
00009     TagValue::TagValue() : type(Null), data(NULL) {
00010 
00011     }
00012 
00013     TagValue::~TagValue() {
00014         nullify();
00015     }
00016 
00017     void TagValue::nullify() {
00018         switch (type) {
00019         case Null:
00020             break;
00021         case Int:
00022             delete (int *)data;
00023             break;
00024         case Float:
00025             delete (float *)data;
00026             break;
00027         case Double:
00028             delete (double *)data;
00029             break;
00030         case String:
00031             delete (std::string *)data;
00032             break;
00033         case Time:
00034             delete (FCam::Time *)data;
00035             break;
00036         case IntVector:
00037             delete (std::vector<int> *)data;
00038             break;
00039         case FloatVector:
00040             delete (std::vector<float> *)data;
00041             break;
00042         case DoubleVector:
00043             delete (std::vector<double> *)data;
00044             break;
00045         case StringVector:
00046             delete (std::vector<std::string> *)data;
00047             break;
00048         case TimeVector:
00049             delete (std::vector<FCam::Time> *)data;
00050             break;
00051         }
00052         type = Null;
00053         data = NULL;
00054     }
00055 
00056     TagValue::TagValue(int x) {
00057         type = Int;
00058         int *ptr = new int;
00059         *ptr = x;
00060         data = (void *)ptr;
00061     }
00062 
00063     TagValue::TagValue(float x) {
00064         type = Float;
00065         float *ptr = new float;
00066         *ptr = x;
00067         data = (void *)ptr;
00068     }
00069 
00070     TagValue::TagValue(double x) {
00071         type = Double;
00072         double *ptr = new double;
00073         *ptr = x;
00074         data = (void *)ptr;
00075     }
00076 
00077     TagValue::TagValue(std::string x) {
00078         type = String;
00079         std::string *ptr = new std::string;
00080         *ptr = x;
00081         data = (void *)ptr;
00082     }
00083 
00084     TagValue::TagValue(FCam::Time x) {
00085         type = Time;
00086         FCam::Time *ptr = new FCam::Time;
00087         *ptr = x;
00088         data = (void *)ptr;
00089     }
00090 
00091     TagValue::TagValue(std::vector<int> x) {
00092         type = IntVector;
00093         std::vector<int> *ptr = new std::vector<int>;
00094         *ptr = x;
00095         data = (void *)ptr;
00096     }
00097 
00098     TagValue::TagValue(std::vector<float> x) {
00099         type = FloatVector;
00100         std::vector<float> *ptr = new std::vector<float>;
00101         *ptr = x;
00102         data = (void *)ptr;
00103     }
00104 
00105     TagValue::TagValue(std::vector<double> x) {
00106         type = DoubleVector;
00107         std::vector<double> *ptr = new std::vector<double>;
00108         *ptr = x;
00109         data = (void *)ptr;
00110     }
00111 
00112     TagValue::TagValue(std::vector<std::string> x) {
00113         type = StringVector;
00114         std::vector<std::string> *ptr = new std::vector<std::string>;
00115         *ptr = x;
00116         data = (void *)ptr;
00117     }
00118 
00119     TagValue::TagValue(std::vector<FCam::Time> x) {
00120         type = TimeVector;
00121         std::vector<FCam::Time> *ptr = new std::vector<FCam::Time>;
00122         *ptr = x;
00123         data = (void *)ptr;
00124     }
00125 
00126     const TagValue &TagValue::operator=(const int &x) {
00127         if (type == Int) {
00128             ((int *)data)[0] = x;
00129         } else {
00130             nullify();
00131             type = Int;
00132             int *ptr = new int;
00133             ptr[0] = x;
00134             data = (void *)ptr;
00135         }
00136         return *this;
00137     }
00138 
00139     const TagValue &TagValue::operator=(const float &x) {
00140         if (type == Float) {
00141             ((float *)data)[0] = x;
00142         } else {
00143             nullify();
00144             type = Float;
00145             float *ptr = new float;
00146             ptr[0] = x;
00147             data = (void *)ptr;
00148         }
00149         return *this;
00150     }
00151 
00152     const TagValue &TagValue::operator=(const double &x) {
00153         if (type == Double) {
00154             ((double *)data)[0] = x;
00155         } else {
00156             nullify();
00157             type = Double;
00158             double *ptr = new double;
00159             ptr[0] = x;
00160             data = (void *)ptr;
00161         }
00162         return *this;
00163     }
00164 
00165     const TagValue &TagValue::operator=(const std::string &x) {
00166         if (type == String) {
00167             ((std::string *)data)[0] = x;
00168         } else {
00169             nullify();
00170             type = String;
00171             std::string *ptr = new std::string;
00172             ptr[0] = x;
00173             data = (void *)ptr;
00174         }
00175         return *this;
00176     }
00177 
00178     const TagValue &TagValue::operator=(const FCam::Time &x) {
00179         if (type == Time) {
00180             ((FCam::Time *)data)[0] = x;
00181         } else {
00182             nullify();
00183             type = Time;
00184             FCam::Time *ptr = new FCam::Time;
00185             ptr[0] = x;
00186             data = (void *)ptr;
00187         }
00188         return *this;
00189     }
00190 
00191     const TagValue &TagValue::operator=(const std::vector<int> &x) {
00192         if (type == IntVector) {
00193             ((std::vector<int> *)data)[0] = x;
00194         } else {
00195             nullify();
00196             type = IntVector;
00197             std::vector<int> *ptr = new std::vector<int>;
00198             ptr[0] = x;
00199             data = (void *)ptr;
00200         }
00201         return *this;
00202     }
00203 
00204     const TagValue &TagValue::operator=(const std::vector<float> &x) {
00205         if (type == FloatVector) {
00206             ((std::vector<float> *)data)[0] = x;
00207         } else {
00208             nullify();
00209             type = FloatVector;
00210             std::vector<float> *ptr = new std::vector<float>;
00211             ptr[0] = x;
00212             data = (void *)ptr;
00213         }
00214         return *this;
00215     }
00216 
00217     const TagValue &TagValue::operator=(const std::vector<double> &x) {
00218         if (type == DoubleVector) {
00219             ((std::vector<double> *)data)[0] = x;
00220         } else {
00221             nullify();
00222             type = DoubleVector;
00223             std::vector<double> *ptr = new std::vector<double>;
00224             ptr[0] = x;
00225             data = (void *)ptr;
00226         }
00227         return *this;
00228     }
00229 
00230     const TagValue &TagValue::operator=(const std::vector<std::string> &x) {
00231         if (type == StringVector) {
00232             ((std::vector<std::string> *)data)[0] = x;
00233         } else {
00234             nullify();
00235             type = StringVector;
00236             std::vector<std::string> *ptr = new std::vector<std::string>;
00237             ptr[0] = x;
00238             data = (void *)ptr;
00239         }
00240         return *this;
00241     }
00242 
00243     const TagValue &TagValue::operator=(const std::vector<FCam::Time> &x) {
00244         if (type == TimeVector) {
00245             ((std::vector<FCam::Time> *)data)[0] = x;
00246         } else {
00247             nullify();
00248             type = TimeVector;
00249             std::vector<FCam::Time> *ptr = new std::vector<FCam::Time>;
00250             ptr[0] = x;
00251             data = (void *)ptr;
00252         }
00253         return *this;
00254     }
00255 
00256     const TagValue &TagValue::operator=(const TagValue &other) {
00257         switch(other.type) {
00258         case Null:
00259             nullify();
00260             return *this;
00261         case Int:
00262             *this = (int)other;
00263             return *this;
00264         case Float:
00265             *this = (float)other;
00266             return *this;
00267         case Double:
00268             *this = (double)other;
00269             return *this;
00270         case String:
00271             *this = (std::string)other;
00272             return *this;
00273         case Time:
00274             *this = (FCam::Time)other;
00275             return *this;
00276         case IntVector: {
00277             std::vector<int> temp = other;
00278             *this = temp;
00279             return *this;
00280         }
00281         case FloatVector: {
00282             std::vector<float> temp = other;
00283             *this = temp;
00284             return *this;
00285         }
00286         case DoubleVector: {
00287             std::vector<double> temp = other;
00288             *this = temp;
00289             return *this;
00290         }
00291         case StringVector: {
00292             std::vector<std::string> temp = other;
00293             *this = temp;
00294             return *this;
00295         }
00296         case TimeVector: {
00297             std::vector<FCam::Time> temp = other;
00298             *this = temp;
00299             return *this;
00300         }
00301         }
00302         return *this;
00303     }
00304 
00305     TagValue::TagValue(const TagValue &other) : type(Null), data(NULL) {
00306         *this = other;
00307     }
00308 
00309     TagValue::operator int &() const {
00310         switch (type) {
00311         case Null:
00312             postEvent(Event::Error, Event::BadCast, "Cannot cast a null to an int");
00313             dummyInt = 0; return dummyInt;
00314         case Int:
00315             return ((int *)data)[0];
00316         case Float:
00317             postEvent(Event::Error, Event::BadCast, "Cannot cast a float to an int");
00318             dummyInt = 0; return dummyInt;
00319         case Double:
00320             postEvent(Event::Error, Event::BadCast, "Cannot cast a double to an int");
00321             dummyInt = 0; return dummyInt;
00322         case String:
00323             postEvent(Event::Error, Event::BadCast, "Cannot cast a string to an int");
00324             dummyInt = 0; return dummyInt;
00325         case Time:
00326             postEvent(Event::Error, Event::BadCast, "Cannot cast a time to an int");
00327             dummyInt = 0; return dummyInt;
00328         case IntVector:
00329             postEvent(Event::Error, Event::BadCast, "Cannot cast an int vector to an int");
00330             dummyInt = 0; return dummyInt;
00331         case FloatVector:
00332             postEvent(Event::Error, Event::BadCast, "Cannot cast a float vector to an int");
00333             dummyInt = 0; return dummyInt;
00334         case DoubleVector:
00335             postEvent(Event::Error, Event::BadCast, "Cannot cast a double vector to an int");
00336             dummyInt = 0; return dummyInt;
00337         case StringVector:
00338             postEvent(Event::Error, Event::BadCast, "Cannot cast a string vector to an int");
00339             dummyInt = 0; return dummyInt;
00340         case TimeVector:
00341             postEvent(Event::Error, Event::BadCast, "Cannot cast a time vector to an int");
00342             dummyInt = 0; return dummyInt;
00343         }
00344         dummyInt = 0; return dummyInt;
00345     }
00346 
00347     TagValue::operator float &() const {
00348         switch (type) {
00349         case Null:
00350             postEvent(Event::Error, Event::BadCast, "Cannot cast a null to a float");
00351             dummyFloat = 0; return dummyFloat;
00352         case Int:
00353             postEvent(Event::Error, Event::BadCast, "Cannot cast an int to a float");
00354             dummyFloat = 0; return dummyFloat;
00355         case Float:
00356             return (((float *)data)[0]);
00357         case Double:
00358             postEvent(Event::Error, Event::BadCast, "Cannot cast a double to a float");
00359             dummyFloat = 0; return dummyFloat;
00360         case String:
00361             postEvent(Event::Error, Event::BadCast, "Cannot cast a string to a float");
00362             dummyFloat = 0; return dummyFloat;
00363         case Time:
00364             postEvent(Event::Error, Event::BadCast, "Cannot cast a time to a float");
00365             dummyFloat = 0; return dummyFloat;
00366         case IntVector:
00367             postEvent(Event::Error, Event::BadCast, "Cannot cast an int vector to a float");
00368             dummyFloat = 0; return dummyFloat;
00369         case FloatVector:
00370             postEvent(Event::Error, Event::BadCast, "Cannot cast a float vector to a float");
00371             dummyFloat = 0; return dummyFloat;
00372         case DoubleVector:
00373             postEvent(Event::Error, Event::BadCast, "Cannot cast a double vector to a float");
00374             dummyFloat = 0; return dummyFloat;
00375         case StringVector:
00376             postEvent(Event::Error, Event::BadCast, "Cannot cast a string vector to a float");
00377             dummyFloat = 0; return dummyFloat;
00378         case TimeVector:
00379             postEvent(Event::Error, Event::BadCast, "Cannot cast a time vector to a float");
00380             dummyFloat = 0; return dummyFloat;
00381         }
00382         dummyFloat = 0; return dummyFloat;
00383     }
00384 
00385     TagValue::operator double &() const {
00386         switch (type) {
00387         case Null:
00388             postEvent(Event::Error, Event::BadCast, "Cannot cast a null to a double");
00389             dummyDouble = 0; return dummyDouble;
00390         case Int:
00391             postEvent(Event::Error, Event::BadCast, "Cannot cast an int to a double");
00392             dummyDouble = 0; return dummyDouble;
00393         case Float:
00394             postEvent(Event::Error, Event::BadCast, "Cannot cast a float to a double");
00395             dummyDouble = 0; return dummyDouble;
00396         case Double:
00397             return (((double *)data)[0]);
00398         case String:
00399             postEvent(Event::Error, Event::BadCast, "Cannot cast a string to a double");
00400             dummyDouble = 0; return dummyDouble;
00401         case Time:
00402             postEvent(Event::Error, Event::BadCast, "Cannot cast a time to a double");
00403             dummyDouble = 0; return dummyDouble;
00404         case IntVector:
00405             postEvent(Event::Error, Event::BadCast, "Cannot cast an int vector to a double");
00406             dummyDouble = 0; return dummyDouble;
00407         case FloatVector:
00408             postEvent(Event::Error, Event::BadCast, "Cannot cast a float vector to a double");
00409             dummyDouble = 0; return dummyDouble;
00410         case DoubleVector:
00411             postEvent(Event::Error, Event::BadCast, "Cannot cast a double vector to a double");
00412             dummyDouble = 0; return dummyDouble;
00413         case StringVector:
00414             postEvent(Event::Error, Event::BadCast, "Cannot cast a string vector to a double");
00415             dummyDouble = 0; return dummyDouble;
00416         case TimeVector:
00417             postEvent(Event::Error, Event::BadCast, "Cannot cast a time vector to a double");
00418             dummyDouble = 0; return dummyDouble;
00419         }
00420         dummyDouble = 0; return dummyDouble;
00421     }
00422 
00423     TagValue::operator std::string &() const {
00424         switch (type) {
00425         case Null:
00426             postEvent(Event::Error, Event::BadCast, "Cannot cast a null to a string");
00427             dummyString.clear(); return dummyString;
00428         case Int:
00429             postEvent(Event::Error, Event::BadCast, "Cannot cast an int to a string");
00430             dummyString.clear(); return dummyString;
00431         case Float:
00432             postEvent(Event::Error, Event::BadCast, "Cannot cast a float to a string");
00433             dummyString.clear(); return dummyString;
00434         case Double:
00435             postEvent(Event::Error, Event::BadCast, "Cannot cast a double to a string");
00436             dummyString.clear(); return dummyString;
00437         case String:
00438             return ((std::string *)data)[0];
00439         case Time:
00440             postEvent(Event::Error, Event::BadCast, "Cannot cast a time to a string");
00441             dummyString.clear(); return dummyString;
00442         case IntVector:
00443             postEvent(Event::Error, Event::BadCast, "Cannot cast an int vector to a string");
00444             dummyString.clear(); return dummyString;
00445         case FloatVector:
00446             postEvent(Event::Error, Event::BadCast, "Cannot cast a float vector to a string");
00447             dummyString.clear(); return dummyString;
00448         case DoubleVector:
00449             postEvent(Event::Error, Event::BadCast, "Cannot cast a double vector to a string");
00450             dummyString.clear(); return dummyString;
00451         case StringVector:
00452             postEvent(Event::Error, Event::BadCast, "Cannot cast a string vector to a string");
00453             dummyString.clear(); return dummyString;
00454         case TimeVector:
00455             postEvent(Event::Error, Event::BadCast, "Cannot cast a time vector to a string");
00456             dummyString.clear(); return dummyString;
00457         }
00458         dummyString.clear(); return dummyString;
00459     }
00460 
00461     TagValue::operator FCam::Time &() const {
00462         switch (type) {
00463         case Null:
00464             postEvent(Event::Error, Event::BadCast, "Cannot cast a null to a time");
00465             dummyTime = FCam::Time(0, 0); return dummyTime;
00466         case Int:
00467             postEvent(Event::Error, Event::BadCast, "Cannot cast an int to a time");
00468             dummyTime = FCam::Time(0, 0); return dummyTime;
00469         case Float:
00470             postEvent(Event::Error, Event::BadCast, "Cannot cast a float to a time");
00471             dummyTime = FCam::Time(0, 0); return dummyTime;
00472         case Double:
00473             postEvent(Event::Error, Event::BadCast, "Cannot cast a double to a time");
00474             dummyTime = FCam::Time(0, 0); return dummyTime;
00475         case String:
00476             postEvent(Event::Error, Event::BadCast, "Cannot cast a string to a time");
00477             dummyTime = FCam::Time(0, 0); return dummyTime;
00478         case Time:
00479             return ((FCam::Time *)data)[0];
00480         case IntVector:
00481             postEvent(Event::Error, Event::BadCast, "Cannot cast an int vector to a time");
00482             dummyTime = FCam::Time(0, 0); return dummyTime;
00483         case FloatVector:
00484             postEvent(Event::Error, Event::BadCast, "Cannot cast a float vector to a time");
00485             dummyTime = FCam::Time(0, 0); return dummyTime;
00486         case DoubleVector:
00487             postEvent(Event::Error, Event::BadCast, "Cannot cast a double vector to a time");
00488             dummyTime = FCam::Time(0, 0); return dummyTime;
00489         case StringVector:
00490             postEvent(Event::Error, Event::BadCast, "Cannot cast a string vector to a time");
00491             dummyTime = FCam::Time(0, 0); return dummyTime;
00492         case TimeVector:
00493             postEvent(Event::Error, Event::BadCast, "Cannot cast a time vector to a time");
00494             dummyTime = FCam::Time(0, 0); return dummyTime;
00495         }
00496         dummyTime = FCam::Time(0, 0); return dummyTime;
00497     }
00498 
00499     TagValue::operator std::vector<int> &() const {
00500         switch (type) {
00501         case Null:
00502             postEvent(Event::Error, Event::BadCast, "Cannot cast a null to an int vector");
00503             dummyIntVector.clear(); return dummyIntVector;
00504         case Int:
00505             postEvent(Event::Error, Event::BadCast, "Cannot cast an int to an int vector");
00506             dummyIntVector.clear(); return dummyIntVector;
00507         case Float:
00508             postEvent(Event::Error, Event::BadCast, "Cannot cast a float to an int vector");
00509             dummyIntVector.clear(); return dummyIntVector;
00510         case Double:
00511             postEvent(Event::Error, Event::BadCast, "Cannot cast a double to an int vector");
00512             dummyIntVector.clear(); return dummyIntVector;
00513         case String:
00514             postEvent(Event::Error, Event::BadCast, "Cannot cast a string to an int vector");
00515             dummyIntVector.clear(); return dummyIntVector;
00516         case Time:
00517             postEvent(Event::Error, Event::BadCast, "Cannot cast a time to an int vector");
00518             dummyIntVector.clear(); return dummyIntVector;
00519         case IntVector:
00520             return ((std::vector<int> *)data)[0];
00521         case FloatVector:
00522             postEvent(Event::Error, Event::BadCast, "Cannot cast a float vector to an int vector");
00523             dummyIntVector.clear(); return dummyIntVector;
00524         case DoubleVector:
00525             postEvent(Event::Error, Event::BadCast, "Cannot cast a double vector to an int vector");
00526             dummyIntVector.clear(); return dummyIntVector;
00527         case StringVector:
00528             postEvent(Event::Error, Event::BadCast, "Cannot cast a string vector to an int vector");
00529             dummyIntVector.clear(); return dummyIntVector;
00530         case TimeVector:
00531             postEvent(Event::Error, Event::BadCast, "Cannot cast a time vector to an int vector");
00532             dummyIntVector.clear(); return dummyIntVector;
00533         }
00534         dummyIntVector.clear(); return dummyIntVector;
00535     }
00536 
00537 
00538     TagValue::operator std::vector<float> &() const {
00539         switch (type) {
00540         case Null:
00541             postEvent(Event::Error, Event::BadCast, "Cannot cast a null to a float vector");
00542             dummyFloatVector.clear(); return dummyFloatVector;
00543         case Int:
00544             postEvent(Event::Error, Event::BadCast, "Cannot cast an int to a float vector");
00545             dummyFloatVector.clear(); return dummyFloatVector;
00546         case Float:
00547             postEvent(Event::Error, Event::BadCast, "Cannot cast a float to a float vector");
00548             dummyFloatVector.clear(); return dummyFloatVector;
00549         case Double:
00550             postEvent(Event::Error, Event::BadCast, "Cannot cast a double to a float vector");
00551             dummyFloatVector.clear(); return dummyFloatVector;
00552         case String:
00553             postEvent(Event::Error, Event::BadCast, "Cannot cast a string to a float vector");
00554             dummyFloatVector.clear(); return dummyFloatVector;
00555         case Time:
00556             postEvent(Event::Error, Event::BadCast, "Cannot cast a time to a float vector");
00557             dummyFloatVector.clear(); return dummyFloatVector;
00558         case IntVector:
00559             postEvent(Event::Error, Event::BadCast, "Cannot cast an int vector to a float vector");
00560             dummyFloatVector.clear(); return dummyFloatVector;
00561         case FloatVector:
00562             return ((std::vector<float> *)data)[0];
00563         case DoubleVector:
00564             postEvent(Event::Error, Event::BadCast, "Cannot cast a double vector to a float vector");
00565             dummyFloatVector.clear(); return dummyFloatVector;
00566         case StringVector:
00567             postEvent(Event::Error, Event::BadCast, "Cannot cast a string vector to a float vector");
00568             dummyFloatVector.clear(); return dummyFloatVector;
00569         case TimeVector:
00570             postEvent(Event::Error, Event::BadCast, "Cannot cast a time vector to a float vector");
00571             dummyFloatVector.clear(); return dummyFloatVector;
00572         }
00573         dummyFloatVector.clear(); return dummyFloatVector;
00574     }
00575 
00576     TagValue::operator std::vector<double> &() const {
00577         switch (type) {
00578         case Null:
00579             postEvent(Event::Error, Event::BadCast, "Cannot cast a null to a double vector");
00580             dummyDoubleVector.clear(); return dummyDoubleVector;
00581         case Int:
00582             postEvent(Event::Error, Event::BadCast, "Cannot cast an int to a double vector");
00583             dummyDoubleVector.clear(); return dummyDoubleVector;
00584         case Float:
00585             postEvent(Event::Error, Event::BadCast, "Cannot cast a float to a double vector");
00586             dummyDoubleVector.clear(); return dummyDoubleVector;
00587         case Double:
00588             postEvent(Event::Error, Event::BadCast, "Cannot cast a double to a double vector");
00589             dummyDoubleVector.clear(); return dummyDoubleVector;
00590         case String:
00591             postEvent(Event::Error, Event::BadCast, "Cannot cast a string to a double vector");
00592             dummyDoubleVector.clear(); return dummyDoubleVector;
00593         case Time:
00594             postEvent(Event::Error, Event::BadCast, "Cannot cast a time to a double vector");
00595             dummyDoubleVector.clear(); return dummyDoubleVector;
00596         case IntVector:
00597             postEvent(Event::Error, Event::BadCast, "Cannot cast an int vector to a double vector");
00598             dummyDoubleVector.clear(); return dummyDoubleVector;
00599         case FloatVector:
00600             postEvent(Event::Error, Event::BadCast, "Cannot cast a float vector to a double vector");
00601             dummyDoubleVector.clear(); return dummyDoubleVector;
00602         case DoubleVector:
00603             return ((std::vector<double> *)data)[0];
00604         case StringVector:
00605             postEvent(Event::Error, Event::BadCast, "Cannot cast a string vector to a double vector");
00606             dummyDoubleVector.clear(); return dummyDoubleVector;
00607         case TimeVector:
00608             postEvent(Event::Error, Event::BadCast, "Cannot cast a time vector to a double vector");
00609             dummyDoubleVector.clear(); return dummyDoubleVector;
00610         }
00611         dummyDoubleVector.clear(); return dummyDoubleVector;
00612     }
00613 
00614 
00615 
00616     TagValue::operator std::vector<std::string> &() const {
00617         switch (type) {
00618         case Null:
00619             postEvent(Event::Error, Event::BadCast, "Cannot cast a null to a string vector");
00620             dummyStringVector.clear(); return dummyStringVector;
00621         case Int:
00622             postEvent(Event::Error, Event::BadCast, "Cannot cast an int to a string vector");
00623             dummyStringVector.clear(); return dummyStringVector;
00624         case Float:
00625             postEvent(Event::Error, Event::BadCast, "Cannot cast a float to a string vector");
00626             dummyStringVector.clear(); return dummyStringVector;
00627         case Double:
00628             postEvent(Event::Error, Event::BadCast, "Cannot cast a double to a string vector");
00629             dummyStringVector.clear(); return dummyStringVector;
00630         case String:
00631             postEvent(Event::Error, Event::BadCast, "Cannot cast a string to a string vector");
00632             dummyStringVector.clear(); return dummyStringVector;
00633         case Time:
00634             postEvent(Event::Error, Event::BadCast, "Cannot cast a time to a string vector");
00635             dummyStringVector.clear(); return dummyStringVector;
00636         case IntVector:
00637             postEvent(Event::Error, Event::BadCast, "Cannot cast an int vector to a string vector");
00638             dummyStringVector.clear(); return dummyStringVector;
00639         case FloatVector:
00640             postEvent(Event::Error, Event::BadCast, "Cannot cast a float vector to a string vector");
00641             dummyStringVector.clear(); return dummyStringVector;
00642         case DoubleVector:
00643             postEvent(Event::Error, Event::BadCast, "Cannot cast a double vector to a string vector");
00644             dummyStringVector.clear(); return dummyStringVector;
00645         case StringVector:
00646             return ((std::vector<std::string> *)data)[0];
00647         case TimeVector:
00648             postEvent(Event::Error, Event::BadCast, "Cannot cast a time vector to a string vector");
00649             dummyStringVector.clear(); return dummyStringVector;
00650         }
00651         dummyStringVector.clear(); return dummyStringVector;
00652     }
00653 
00654     TagValue::operator std::vector<FCam::Time> &() const {
00655         switch (type) {
00656         case Null:
00657             postEvent(Event::Error, Event::BadCast, "Cannot cast a null to a time vector");
00658             dummyTimeVector.clear(); return dummyTimeVector;
00659         case Int:
00660             postEvent(Event::Error, Event::BadCast, "Cannot cast an int to a time vector");
00661             dummyTimeVector.clear(); return dummyTimeVector;
00662         case Float:
00663             postEvent(Event::Error, Event::BadCast, "Cannot cast a float to a time vector");
00664             dummyTimeVector.clear(); return dummyTimeVector;
00665         case Double:
00666             postEvent(Event::Error, Event::BadCast, "Cannot cast a double to a time vector");
00667             dummyTimeVector.clear(); return dummyTimeVector;
00668         case String:
00669             postEvent(Event::Error, Event::BadCast, "Cannot cast a string to a time vector");
00670             dummyTimeVector.clear(); return dummyTimeVector;
00671         case Time:
00672             postEvent(Event::Error, Event::BadCast, "Cannot cast a time to a time vector");
00673             dummyTimeVector.clear(); return dummyTimeVector;
00674         case IntVector:
00675             postEvent(Event::Error, Event::BadCast, "Cannot cast an int vector to a time vector");
00676             dummyTimeVector.clear(); return dummyTimeVector;
00677         case FloatVector:
00678             postEvent(Event::Error, Event::BadCast, "Cannot cast a float vector to a time vector");
00679             dummyTimeVector.clear(); return dummyTimeVector;
00680         case DoubleVector:
00681             postEvent(Event::Error, Event::BadCast, "Cannot cast a double vector to a time vector");
00682             dummyTimeVector.clear(); return dummyTimeVector;
00683         case StringVector:
00684             postEvent(Event::Error, Event::BadCast, "Cannot cast a string vector to a time vector");
00685             dummyTimeVector.clear(); return dummyTimeVector;
00686         case TimeVector:
00687             return ((std::vector<FCam::Time> *)data)[0];
00688         }
00689         dummyTimeVector.clear(); return dummyTimeVector;
00690     }
00691 
00692     std::string TagValue::toString() const {
00693         std::ostringstream sstr;
00694         sstr << *this;
00695         return sstr.str();
00696     }
00697 
00698     TagValue TagValue::fromString(const std::string &str) {
00699         TagValue t;
00700         std::istringstream sstr(str);
00701         sstr >> t;
00702         return t;
00703     }
00704 
00705     std::string TagValue::toBlob() const {
00706         std::string str;
00707         switch(type) {
00708         case Null:
00709         {
00710             str.resize(2);
00711             str[0] = 'b';
00712             str[1] = (char)type;
00713             return str;
00714         }
00715         case Int:
00716         {
00717             str.resize(4 + sizeof(int));
00718             str[0] = 'b';
00719             str[1] = (char)type;
00720             int *ptr = (int *)(&(str[4]));
00721             ptr[0] = (int)(*this);
00722             return str;
00723         }
00724         case Float:
00725         {
00726             str.resize(4 + sizeof(float));
00727             str[0] = 'b';
00728             str[1] = (char)type;
00729             float *ptr = (float *)(&(str[4]));
00730             ptr[0] = (float)(*this);
00731             return str;
00732         }
00733         case Double:
00734         {
00735             str.resize(4 + sizeof(double));
00736             str[0] = 'b';
00737             str[1] = (char)type;
00738             double *ptr = (double *)(&(str[4]));
00739             ptr[0] = (double)(*this);
00740             return str;
00741         }
00742         case String: {
00743             std::string &x = *this;
00744             str.resize(8 + x.size());
00745             str[0] = 'b';
00746             str[1] = (char)type;
00747             int *ptr = (int *)(&(str[4]));
00748             ptr[0] = x.size();
00749             for (size_t i = 0; i < x.size(); i++) {
00750                 str[i+8] = x[i];
00751             }
00752             return str;
00753         }
00754         case Time: {
00755             str.resize(4 + sizeof(int)*2);
00756             str[0] = 'b';
00757             str[1] = (char)type;
00758             int *ptr = (int *)(&(str[4]));
00759             FCam::Time time = *this;
00760             ptr[0] = time.s();
00761             ptr[1] = time.us();
00762             return str;
00763         }
00764         case IntVector: {
00765             std::vector<int> &x = *this;
00766             str.resize(4 + (1+x.size())*sizeof(int));
00767             str[0] = 'b';
00768             str[1] = (char)type;
00769             int *ptr = (int *)(&(str[4]));
00770             ptr[0] = x.size();
00771             for (size_t i = 0; i < x.size(); i++) {
00772                 ptr[i+1] = x[i];
00773             }
00774             return str;
00775         }
00776         case FloatVector: {
00777             std::vector<float> &x = *this;
00778             str.resize(4 + sizeof(int) + x.size()*sizeof(float));
00779             str[0] = 'b';
00780             str[1] = (char)type;
00781             int *iptr = (int *)(&(str[4]));
00782             float *fptr = (float *)(&(str[4 + sizeof(int)]));
00783             iptr[0] = x.size();
00784             for (size_t i = 0; i < x.size(); i++) {
00785                 fptr[i] = x[i];
00786             }
00787             return str;
00788         }
00789         case DoubleVector: {
00790             std::vector<double> &x = *this;
00791             str.resize(4 + (1+x.size())*sizeof(double));
00792             str[0] = 'b';
00793             str[1] = (char)type;
00794             int *iptr = (int *)(&(str[4]));
00795             double *fptr = (double *)(&(str[4 + sizeof(int)]));
00796             iptr[0] = x.size();
00797             for (size_t i = 0; i < x.size(); i++) {
00798                 fptr[i] = x[i];
00799             }
00800             return str;
00801         }
00802         case StringVector: {
00803             std::vector<std::string> &x = *this;
00804             size_t total = 0;
00805             for (size_t i = 0; i < x.size(); i++) {
00806                 total += x[i].size();
00807             }
00808             str.resize(4 + sizeof(int)*(1+x.size()) + total);
00809             str[0] = 'b';
00810             str[1] = (char)type;
00811             int *ptr = (int *)(&(str[4]));
00812             ptr[0] = x.size();
00813             for (size_t i = 0; i < x.size(); i++) {
00814                 ptr[i+1] = x[i].size();
00815             }
00816             int idx = 4 + sizeof(int)*(1+x.size());
00817             for (size_t i = 0; i < x.size(); i++) {
00818                 for (size_t j = 0; j < x[i].size(); j++) {
00819                     str[idx+j] = x[i][j];
00820                 }
00821                 idx += x[i].size();
00822             }
00823             return str;
00824         }
00825 
00826         case TimeVector:
00827             std::vector<FCam::Time> &x = *this;
00828             str.resize(4 + sizeof(int)*(1+2*x.size()));
00829             str[0] = 'b';
00830             str[1] = (char)type;
00831             int *ptr = (int *)(&(str[4]));
00832             ptr[0] = x.size();
00833             for (size_t i = 0; i < x.size(); i++) {
00834                 ptr[i*2+1] = x[i].s();
00835                 ptr[i*2+2] = x[i].us();
00836             }
00837             return str;
00838         }
00839         return "";
00840     }
00841 
00842     std::ostream & operator<<(std::ostream& out, const TagValue &t) {
00843         out << std::scientific;
00844         switch (t.type) {
00845         case TagValue::Null: {
00846             return (out << "None");
00847         }
00848 
00849         case TagValue::Int: {
00850             int contents = t;
00851             return (out << contents);
00852         }
00853 
00854         case TagValue::Float: {
00855             out.precision(8);
00856             float contents = t;
00857             return (out << contents << 'f');
00858         }
00859 
00860         case TagValue::Double: {
00861             out.precision(16);
00862             double contents = t;
00863             return (out << contents);
00864         }
00865 
00866         case TagValue::String: {
00867             std::string contents = t;
00868             out << '"';
00869             for (size_t j = 0; j < contents.size(); j++) {
00870                 char c = contents[j];
00871                 if (isprint(c) && c != '"' && c != '\\') {
00872                     out << c;
00873                 } else {
00874                     int x = (int)c;
00875                     if (x < 16) {
00876                         out << "\\x0" << std::hex << x << std::dec;
00877                     } else {
00878                         out << "\\x" << std::hex << x << std::dec;
00879                     }
00880                 }
00881             }
00882             out << '"';
00883             return out;
00884         }
00885 
00886         case TagValue::Time: {
00887             Time contents = t;
00888             return (out << "(" << contents.s() << ", " << contents.us() << ")");
00889         }
00890 
00891         case TagValue::IntVector: {
00892             std::vector<int> &contents = t;
00893             out << "[";
00894             if (contents.size() > 0) {
00895                 for (size_t i = 0; i < contents.size()-1; i++) {
00896                     out << contents[i] << ", ";
00897                 }
00898                 out << contents[contents.size()-1];
00899             }
00900             out << "]";
00901             return out;
00902         }
00903 
00904         case TagValue::FloatVector: {
00905             out.precision(8);
00906             std::vector<float> &contents = t;
00907             out << "[";
00908             if (contents.size() > 0) {
00909                 for (size_t i = 0; i < contents.size()-1; i++) {
00910                     out << contents[i] << "f, ";
00911                 }
00912                 out << contents[contents.size()-1];
00913             }
00914             out << "]";
00915             return out;
00916         }
00917 
00918         case TagValue::DoubleVector: {
00919             out.precision(16);
00920             std::vector<double> &contents = t;
00921             out << "[";
00922             if (contents.size() > 0) {
00923                 for (size_t i = 0; i < contents.size()-1; i++) {
00924                     out << contents[i] << ", ";
00925                 }
00926                 out << contents[contents.size()-1];
00927             }
00928             out << "]";
00929             return out;
00930         }
00931 
00932         case TagValue::StringVector: {
00933             std::vector<std::string> &contents = t;
00934             out << "[";
00935             if (contents.size() > 0) {
00936                 for (size_t i = 0; i < contents.size(); i++) {
00937                     if (i) out << ", ";
00938                     out << '"';
00939                     for (size_t j = 0; j < contents[i].size(); j++) {
00940                         char c = contents[i][j];
00941                         if (isprint(c) && c != '"' && c != '\\') {
00942                             out << c;
00943                         } else {
00944                             int x = (int)c;
00945                             if (x < 16) {
00946                                 out << "\\x0" << std::hex << x << std::dec;
00947                             } else {
00948                                 out << "\\x" << std::hex << x << std::dec;
00949                             }
00950                         }
00951                     }
00952                     out << '"';
00953                 }
00954             }
00955             out << "]";
00956             return out;
00957         }
00958 
00959         case TagValue::TimeVector: {
00960             std::vector<FCam::Time> &contents = t;
00961             out << "[";
00962             if (contents.size() > 0) {
00963                 for (size_t i = 0; i < contents.size(); i++) {
00964                     if (i) out << ", ";
00965                     out << "(" << contents[i].s() << ", " << contents[i].us() << ")";
00966                 }
00967             }
00968             out << "]";
00969             return out;
00970         }
00971 
00972         }
00973         return out;
00974     }
00975 
00976     TagValue::Type readType(int x) {
00977         switch (x) {
00978         case TagValue::Null:
00979             return TagValue::Null;
00980         case TagValue::Int:
00981             return TagValue::Int;
00982         case TagValue::Float:
00983             return TagValue::Float;
00984         case TagValue::Double:
00985             return TagValue::Double;
00986         case TagValue::String:
00987             return TagValue::String;
00988         case TagValue::Time:
00989             return TagValue::Time;
00990         case TagValue::IntVector:
00991             return TagValue::IntVector;
00992         case TagValue::FloatVector:
00993             return TagValue::FloatVector;
00994         case TagValue::DoubleVector:
00995             return TagValue::DoubleVector;
00996         case TagValue::StringVector:
00997             return TagValue::StringVector;
00998         case TagValue::TimeVector:
00999             return TagValue::TimeVector;
01000         default:
01001             error(Event::ParseError, "Invalid type for tag value: %d", x);
01002             return TagValue::Null;
01003         }
01004     }
01005 
01006     std::istream & operator>>(std::istream& in, TagValue &t) {
01007         switch (in.peek()) {
01008         case 'b':
01009             // binary blob
01010         {
01011             in.get();
01012             TagValue::Type type = readType(in.get());
01013             // skip the next two chars (they are for word-alignment and future proofing)
01014             if (in.get() != 0 || in.get() != 0) {
01015                 goto error;
01016             }
01017             switch (type) {
01018             case TagValue::Null: {
01019                 TagValue nullTag;
01020                 t = nullTag;
01021                 return in;
01022             }
01023             case TagValue::Int: {
01024                 int x;
01025                 in.read((char *)&x, sizeof(int));
01026                 t = x;
01027                 return in;
01028             }
01029             case TagValue::Float: {
01030                 float x;
01031                 in.read((char *)&x, sizeof(float));
01032                 t = x;
01033                 return in;
01034             }
01035             case TagValue::Double: {
01036                 double x;
01037                 in.read((char *)&x, sizeof(double));
01038                 t = x;
01039                 return in;
01040             }
01041             case TagValue::Time: {
01042                 int x[2];
01043                 in.read((char *)x, sizeof(int)*2);
01044                 t = FCam::Time(x[0], x[1]);
01045                 return in;
01046             }
01047             case TagValue::String: {
01048                 int size;
01049                 std::string x;
01050                 in.read((char *)&size, sizeof(int));
01051                 x.resize(size);
01052                 in.read((char *)(&(x[0])), size);
01053                 t = x;
01054                 return in;
01055             }
01056             case TagValue::IntVector: {
01057                 int size;
01058                 std::vector<int> v;
01059                 t = v;
01060                 std::vector<int> &x = t;
01061                 in.read((char *)&size, sizeof(int));
01062                 x.resize(size);
01063                 in.read((char *)(&(x[0])), sizeof(int)*size);
01064                 return in;
01065             }
01066             case TagValue::FloatVector: {
01067                 int size;
01068                 std::vector<float> v;
01069                 t = v;
01070                 std::vector<float> &x = t;
01071                 in.read((char *)&size, sizeof(int));
01072                 x.resize(size);
01073                 in.read((char *)(&(x[0])), sizeof(float)*size);
01074                 return in;
01075             }
01076             case TagValue::DoubleVector: {
01077                 int size;
01078                 std::vector<double> v;
01079                 t = v;
01080                 std::vector<double> &x = t;
01081                 in.read((char *)&size, sizeof(int));
01082                 x.resize(size);
01083                 in.read((char *)(&(x[0])), sizeof(double)*size);
01084                 return in;
01085             }
01086             case TagValue::StringVector: {
01087                 int size;
01088                 std::vector<std::string> v;
01089                 t = v;
01090                 std::vector<std::string> &x = t;
01091                 in.read((char *)&size, sizeof(int));
01092                 x.resize(size);
01093                 for (size_t i = 0; i < x.size(); i++) {
01094                     in.read((char *)&size, sizeof(int));
01095                     x[i].resize(size);
01096                 }
01097                 for (size_t i = 0; i < x.size(); i++) {
01098                     in.read((char *)(&(x[i][0])), x[i].size());
01099                 }
01100                 return in;
01101             }
01102             case TagValue::TimeVector: {
01103                 int size;
01104                 std::vector<FCam::Time> v;
01105                 t = v;
01106                 std::vector<FCam::Time> &x = t;
01107                 in.read((char *)&size, sizeof(int));
01108                 x.resize(size);
01109                 for (size_t i = 0; i < x.size(); i++) {
01110                     int time[2];
01111                     in.read((char *)time, sizeof(int)*2);
01112                     x[i] = FCam::Time(time[0], time[1]);
01113                 }
01114                 return in;
01115             }
01116             default:
01117                 goto error;
01118             }
01119         }
01120         case '-': case '0': case '1': case '2': case '3': case '4':
01121         case '5': case '6': case '7': case '8': case '9':
01122             // numeric
01123         {
01124             // suck it into a string
01125             std::ostringstream osstr;
01126 
01127             bool floating = false;
01128             if (in.peek() == '-') {
01129                 osstr << char(in.get());
01130                 if (!isdigit(in.peek())) {
01131                     // oops
01132                     in.putback('-');
01133                     goto error;
01134                 }
01135             }
01136             while (isdigit(in.peek())) osstr << char(in.get());
01137             if (in.peek() == '.') {
01138                 floating = true;
01139                 osstr << char(in.get());
01140                 if (!isdigit(in.peek())) {
01141                     // oops!
01142                     in.putback('.');
01143                     floating = false;
01144                     goto done;
01145                 }
01146             }
01147             while (isdigit(in.peek())) osstr << char(in.get());
01148             if (in.peek() == 'e') osstr << char(in.get());
01149             else goto done;
01150             if (in.peek() == '+') osstr << char(in.get());
01151             else if (in.peek() == '-') osstr << char(in.get());
01152             else {
01153                 // oops!
01154                 in.putback('e');
01155                 goto done;
01156             }
01157             while (isdigit(in.peek())) osstr << char(in.get());
01158 
01159           done:
01160             std::istringstream isstr(osstr.str());
01161             if (floating && in.peek() == 'f') {
01162                 in.get();
01163                 float x;
01164                 isstr >> x;
01165                 t = x;
01166             } else if (floating) {
01167                 double x;
01168                 isstr >> x;
01169                 t = x;
01170             } else {
01171                 int x;
01172                 isstr >> x;
01173                 t = x;
01174             }
01175             return in;
01176         }
01177         case 'N':
01178         {
01179             in.get();
01180             if (in.peek() != 'o') {
01181                 in.putback('N');
01182                 goto error;
01183             }
01184             in.get();
01185             if (in.peek() != 'n') {
01186                 in.putback('o');
01187                 in.putback('N');
01188                 goto error;
01189             }
01190             in.get();
01191             if (in.peek() != 'e') {
01192                 in.putback('n');
01193                 in.putback('o');
01194                 in.putback('N');
01195                 goto error;
01196             }
01197             in.get();
01198             // None
01199             TagValue null;
01200             t = null;
01201             return in;
01202         }
01203         case '(':
01204         {
01205             in.get();
01206             timeval tv;
01207             in >> tv.tv_sec;
01208             in >> std::ws;
01209             if (in.peek() != ',') goto error;
01210             in.get();
01211             in >> std::ws;
01212             in >> tv.tv_usec;
01213             if (in.peek() != ')') goto error;
01214             in.get();
01215             FCam::Time time(tv);
01216             t = time;
01217             return in;
01218         }
01219         case '"':
01220         {
01221             // string
01222             in.get();
01223             std::ostringstream osstr;
01224             while (in.peek() != '"') {
01225                 if (in.peek() < 0) {
01226                     t = osstr.str();
01227                     goto error;
01228                 } else if (in.peek() == '\\') {
01229                     in.get();
01230                     switch(in.get()) {
01231                     case '0':
01232                         osstr << '\0';
01233                         break;
01234                     case 'n':
01235                         osstr << '\n';
01236                         break;
01237                     case 'r':
01238                         osstr << '\r';
01239                         break;
01240                     case 'x': {
01241                         int v = 0;
01242                         char c1 = in.get();
01243                         char c2 = in.get();
01244                         if (c1 >= '0' && c1 <= '9') {
01245                             v = (c1 - '0');
01246                         } else if (c1 >= 'a' && c1 <= 'f') {
01247                             v = (c1 - 'a' + 10);
01248                         } else {
01249                             in.putback(c2);
01250                             in.putback(c1);
01251                             t = osstr.str();
01252                             goto error;
01253                         }
01254                         v = v << 4;
01255                         if (c2 >= '0' && c2 <= '9') {
01256                             v += (c2 - '0');
01257                         } else if (c2 >= 'a' && c2 <= 'f') {
01258                             v += (c2 - 'a' + 10);
01259                         } else {
01260                             in.putback(c2);
01261                             in.putback(c1);
01262                             t = osstr.str();
01263                             goto error;
01264                         }
01265                         osstr << (char)v;
01266                         break;
01267                     }
01268                     case '"':
01269                         osstr << '"';
01270                         break;
01271                     case '\\':
01272                         osstr << '\\';
01273                         break;
01274                     case 'a':
01275                         osstr << '\a';
01276                         break;
01277                     case 'b':
01278                         osstr << '\b';
01279                         break;
01280                     case 'v':
01281                         osstr << '\v';
01282                         break;
01283                     case '\'':
01284                         osstr << '\'';
01285                         break;
01286                     case 'f':
01287                         osstr << '\f';
01288                         break;
01289                     case 't':
01290                         osstr << '\t';
01291                         break;
01292                     default:
01293                         t = osstr.str();
01294                         goto error;
01295                     }
01296                 } else {
01297                     osstr << (char)in.get();
01298                 }
01299             }
01300             in.get();
01301             t = osstr.str();
01302             return in;
01303         }
01304         case '[':
01305         {
01306             // an array
01307             in.get();
01308 
01309             // consume whitespace
01310             in >> std::ws;
01311             // check it's not a list of lists
01312             if (in.peek() == '[') goto error;
01313             // recursively parse the first entry
01314             TagValue first;
01315             in >> first;
01316             switch (first.type) {
01317             case TagValue::Int:
01318             {
01319                 std::vector<int> v;
01320                 t = v;
01321                 std::vector<int> &l = t;
01322                 l.push_back(first);
01323                 in >> std::ws;
01324                 while (in.peek() != ']') {
01325                     int x;
01326                     if (in.peek() != ',') goto error;
01327                     in.get();
01328                     in >> std::ws >> x >> std::ws;
01329                     l.push_back(x);
01330                 }
01331                 in.get();
01332                 return in;
01333             }
01334             case TagValue::Float:
01335             {
01336                 std::vector<float> v;
01337                 t = v;
01338                 std::vector<float> &l = t;
01339                 l.push_back(first);
01340                 in >> std::ws;
01341                 while (in.peek() != ']') {
01342                     float x;
01343                     if (in.peek() != ',') goto error;
01344                     in.get();
01345                     in >> std::ws >> x;
01346                     if (in.peek() == 'f') in.get();
01347                     in >> std::ws;
01348                     l.push_back(x);
01349                 }
01350                 in.get();
01351                 return in;
01352             }
01353             case TagValue::Double:
01354             {
01355                 std::vector<double> v;
01356                 t = v;
01357                 std::vector<double> &l = t;
01358                 l.push_back(first);
01359                 in >> std::ws;
01360                 while (in.peek() != ']') {
01361                     double x;
01362                     if (in.peek() != ',') goto error;
01363                     in.get();
01364                     in >> std::ws >> x >> std::ws;
01365                     l.push_back(x);
01366                 }
01367                 in.get();
01368                 return in;
01369             }
01370             case TagValue::Time:
01371             {
01372                 std::vector<FCam::Time> v;
01373                 t = v;
01374                 std::vector<FCam::Time> &l = t;
01375                 l.push_back(first);
01376                 in >> std::ws;
01377                 while (in.peek() != ']') {
01378                     TagValue x;
01379                     if (in.peek() != ',') goto error;
01380                     in.get();
01381                     in >> std::ws >> x >> std::ws;
01382                     if (x.type != TagValue::Time) goto error;
01383                     l.push_back((FCam::Time)x);
01384                 }
01385                 in.get();
01386                 return in;
01387             }
01388             case TagValue::String:
01389             {
01390                 std::vector<std::string> v;
01391                 t = v;
01392                 std::vector<std::string> &l = t;
01393                 l.push_back(first);
01394                 in >> std::ws;
01395                 while (in.peek() != ']') {
01396                     TagValue x;
01397                     if (in.peek() != ',') goto error;
01398                     in.get();
01399                     in >> std::ws >> x >> std::ws;
01400                     if (x.type != TagValue::String) goto error;
01401                     l.push_back((std::string)x);
01402                 }
01403                 in.get();
01404                 return in;
01405             }
01406             default:
01407                 goto error;
01408             }
01409             if (first.type == TagValue::Null) {
01410                 goto error;
01411             }
01412 
01413             return in;
01414         }
01415         case EOF:
01416             // the stream eof bit is now set
01417             t = TagValue();
01418             return in;
01419         default:
01420             goto error;
01421         }
01422 
01423         return in;
01424       error:
01425         error(Event::ParseError, "Could not parse TagValue");
01426         return in;
01427     }
01428 
01429     int TagValue::dummyInt;
01430     float TagValue::dummyFloat;
01431     double TagValue::dummyDouble;
01432     std::string TagValue::dummyString;
01433     FCam::Time TagValue::dummyTime;
01434     std::vector<int> TagValue::dummyIntVector;
01435     std::vector<float> TagValue::dummyFloatVector;
01436     std::vector<double> TagValue::dummyDoubleVector;
01437     std::vector<std::string> TagValue::dummyStringVector;
01438     std::vector<FCam::Time> TagValue::dummyTimeVector;
01439 
01440 }

Generated on Mon Aug 16 2010 14:25:45 for FCam by  doxygen 1.7.1