JsonParser.cpp

00001 /*
00002  *
00003  *  Compact JSON format parsing lib (native cross-platform c++)
00004  *
00005  *  Copyright (C) 2013 Victor Laskin (victor.laskin@gmail.com)
00006  *  Details: http://vitiy.info/?p=102
00007  *
00008  *  Redistribution and use in source and binary forms, with or without
00009  *  modification, are permitted provided that the following conditions
00010  *  are met:
00011  *  1. Redistributions of source code must retain the above copyright
00012  *    notice, this list of conditions and the following disclaimer.
00013  *  2. Redistributions in binary form must reproduce the above copyright
00014  *    notice, this list of conditions and the following disclaimer in
00015  *    the documentation and/or other materials provided with the
00016  *    distribution.
00017  *  3. The names of the authors may not be used to endorse or promote
00018  *    products derived from this software without specific prior
00019  *    written permission.
00020  *
00021  *  THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS
00022  *  OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
00023  *  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
00024  *  ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY
00025  *  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
00026  *  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
00027  *  GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
00028  *  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
00029  *  IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
00030  *  OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
00031  *  IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
00032  *
00033  */
00034 
00035 #include "JsonParser.h"
00036 
00037 namespace JSON {
00038 
00039 
00040 MVJSONReader::MVJSONReader(const string & source) {
00041     root = parse(source);
00042 }
00043 
00044 MVJSONReader::~MVJSONReader() {
00045     if (root != NULL)
00046         delete root;
00047 }
00048 
00049 MVJSONNode::~MVJSONNode() {
00050     if (values.size() > 0)
00051         for (int i = 0; i < values.size(); i++)
00052             delete values.at(i);
00053 }
00054 
00055 
00056 
00057 MVJSONNode* MVJSONReader::parse(string text)
00058 {
00059     string s = trim(text);
00060     if (s.length() < 2) return NULL;
00061 
00062     // object
00063     if ((s[0] == '{') && (s[s.length() - 1] == '}'))
00064     {
00065         // erase last and first symbols
00066         s.erase(0, 1);
00067         s.erase(s.length() - 1, 1);
00068 
00069         vector<string> parts;
00070         splitList(s, parts);
00071 
00072         MVJSONNode* node = new MVJSONNode();
00073 
00074         for (int i = 0; i < parts.size(); i++)
00075             node->values.push_back(parseValue(parts.at(i), false));
00076 
00077         return node;
00078     }
00079 
00080     return NULL;
00081 }
00082 
00083 
00084 
00085 
00086 MVJSONValue* MVJSONReader::parseValue(string text, bool hasNoName)
00087 {
00088     string key;
00089     string s;
00090     splitInHalf(text, ":", key, s);
00091     key = trim(key);
00092     s = trim(s);
00093     if (key.length() > 2)
00094     {
00095         // strip "
00096         key.erase(0, 1);
00097         key.erase(key.length() - 1, 1);
00098     }
00099 
00100     if (hasNoName)
00101     {
00102         s = text;
00103         key = "";
00104     }
00105 
00106 
00107     if (s == "false") // bool
00108         return new MVJSONValue(key, false);
00109 
00110     if (s == "true")  // bool
00111         return new MVJSONValue(key, true);
00112 
00113     if (s == "null") // null
00114         return new MVJSONValue(key, MVJSON_TYPE_NULL);
00115 
00116     char first = s[0];
00117 
00118     if (first == '"') // string
00119         return new MVJSONValue(key, s.substr(1, s.length() - 2));
00120 
00121     if (first == '{') // object
00122         return new MVJSONValue(key, parse(s));
00123 
00124     if (first == '[') // array
00125     {
00126         s.erase(0, 1);
00127         s.erase(s.length() - 1, 1);
00128         vector<string> parts;
00129         splitList(s, parts);
00130 
00131         MVJSONValue* val = new MVJSONValue(key, MVJSON_TYPE_ARRAY);
00132         for (int i = 0; i < parts.size(); i++)
00133             val->arrayValue.push_back(parseValue(parts.at(i), true));
00134         return val;
00135     }
00136 
00137     // else its number!
00138     if (s.find(".") == string::npos)
00139         return new MVJSONValue(key, stringToInt(s));
00140     else
00141         return new MVJSONValue(key, stringToDouble(s));
00142 
00143 }
00144 
00145 MVJSONValue::~MVJSONValue()
00146 {
00147     if (objValue != NULL)
00148         delete objValue;
00149     if (arrayValue.size() > 0)
00150         for (int i = 0; i < arrayValue.size(); i++)
00151             delete arrayValue.at(i);
00152 }
00153 
00154 void MVJSONValue::init(MVJSON_TYPE valueType)
00155 {
00156     this->valueType = valueType;
00157     objValue = NULL;
00158     name = "";
00159 }
00160 
00161 MVJSONValue::MVJSONValue(string name, MVJSON_TYPE valueType)
00162 {
00163     init(valueType);
00164     this->name = name;
00165 }
00166 
00167 MVJSONValue::MVJSONValue(string name, bool value)
00168 {
00169     init(MVJSON_TYPE_BOOL);
00170     this->name = name;
00171     boolValue = value;
00172 }
00173 
00174 MVJSONValue::MVJSONValue(string name, string value)
00175 {
00176     init(MVJSON_TYPE_STRING);
00177     this->name = name;
00178 
00179     stringValue = value;
00180 
00181     // here we switch back special chars
00182     //  \"  \\  \/  \b  \f  \n  \r  \t  \u four-hex-digits
00183     replace(stringValue, "\\\"", "\"");
00184     replace(stringValue, "\\\\", "\\");
00185     replace(stringValue, "\\/", "/");
00186     replace(stringValue, "\\b", "\b");
00187     replace(stringValue, "\\f", "\f");
00188     replace(stringValue, "\\n", "\n");
00189     replace(stringValue, "\\r", "\r");
00190     replace(stringValue, "\\t", "\t");
00191 
00192     // TODO - \u four-hex-digits
00193     // SS::replace(stringValue, "\\\\", "\\");
00194 
00195 }
00196 
00197 MVJSONValue::MVJSONValue(string name, int value)
00198 {
00199     init(MVJSON_TYPE_INT);
00200     this->name = name;
00201     intValue = value;
00202 }
00203 
00204 MVJSONValue::MVJSONValue(string name, double value)
00205 {
00206     init(MVJSON_TYPE_DOUBLE);
00207     this->name = name;
00208     doubleValue = value;
00209 }
00210 
00211 MVJSONValue::MVJSONValue(string name, MVJSONNode* value)
00212 {
00213     init(MVJSON_TYPE_OBJECT);
00214     this->name = name;
00215     objValue = value;
00216 }
00217 
00218 bool MVJSONNode::hasField(string name)
00219 {
00220     if (values.size() == 0) return false;
00221     for (int i = 0; i < values.size(); i++)
00222         if (values.at(i)->name == name)
00223             return true;
00224     return false;
00225 }
00226 
00227 MVJSONValue* MVJSONNode::getField(string name)
00228 {
00229     if (values.size() == 0) return NULL;
00230     for (int i = 0; i < values.size(); i++)
00231         if (values.at(i)->name == name)
00232             return values.at(i);
00233     return NULL;
00234 }
00235 
00236 
00237 double MVJSONNode::getFieldDouble(string name)
00238 {
00239     MVJSONValue* value = getField(name);
00240     if (value == NULL) return 0;
00241     if (value->valueType == MVJSON_TYPE_INT) return value->intValue;
00242     if (value->valueType == MVJSON_TYPE_DOUBLE) return value->doubleValue;
00243     return 0;
00244 }
00245 
00246 int MVJSONNode::getFieldInt(string name)
00247 {
00248     MVJSONValue* value = getField(name);
00249     if (value == NULL) return 0;
00250     if (value->valueType == MVJSON_TYPE_INT) return value->intValue;
00251     return 0;
00252 }
00253 
00254 string MVJSONNode::getFieldString(string name)
00255 {
00256     MVJSONValue* value = getField(name);
00257     if (value == NULL) return "";
00258     if (value->valueType == MVJSON_TYPE_STRING) return value->stringValue;
00259     return "";
00260 }
00261 
00262 bool MVJSONNode::getFieldBool(string name)
00263 {
00264     MVJSONValue* value = getField(name);
00265     if (value == NULL) return false;
00266     if (value->valueType == MVJSON_TYPE_INT) return (bool)value->intValue;
00267     if (value->valueType == MVJSON_TYPE_BOOL) return value->boolValue;
00268     return false;
00269 }
00270 
00271 double MVJSONValue::getFieldDouble(string name)
00272 {
00273     if (objValue == NULL) return 0;
00274     return objValue->getFieldDouble(name);
00275 }
00276 
00277 int MVJSONValue::getFieldInt(string name)
00278 {
00279     if (objValue == NULL) return 0;
00280     return objValue->getFieldInt(name);
00281 }
00282 
00283 string MVJSONValue::getFieldString(string name)
00284 {
00285     if (objValue == NULL) return "";
00286     return objValue->getFieldString(name);
00287 }
00288 
00289 bool MVJSONValue::getFieldBool(string name)
00290 {
00291     if (objValue == NULL) return false;
00292     return objValue->getFieldBool(name);
00293 }
00294 
00295 
00296 } /* namespace F2 */
00297