initial commit

third-party/JsonQt/lib/JsonToVariant.h

@@ -0,0 +1,160 @@
+/* LICENSE NOTICE
+	Copyright (c) 2008, Frederick Emmott <mail@fredemmott.co.uk>
+
+	Permission to use, copy, modify, and/or distribute this software for any
+	purpose with or without fee is hereby granted, provided that the above
+	copyright notice and this permission notice appear in all copies.
+
+	THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+	WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+	MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+	ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+	WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+	ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+	OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+#ifndef _JSONQT_JSON_TO_VARIANT_H
+#define _JSONQT_JSON_TO_VARIANT_H
+
+#include "ParseException.h"
+
+#include "JsonQtExport.h"
+
+#include <QList>
+#include <QPair>
+#include <QString>
+#include <QVariant>
+
+/** Qt-based JSON handling.
+ * This is based on a recursive descent parser with 1-character lookahed,
+ * and follows the structure of the grammar presented on json.org as closely
+ * as possible, to avoid mistakes, and hopefully to make the code more readable.
+ *
+ * @author Fred Emmott <mail@fredemmott.co.uk>
+ */
+namespace JsonQt
+{
+	/** Class for converting JSON strings to QVariant-based structures.
+	 *
+	 * @author Fred Emmott <mail@fredemmott.co.uk>
+	 */
+	class JSONQT_EXPORT JsonToVariant
+	{
+		public:
+			/** Main parsing function.
+			 *
+			 * @param json is a string containing JSON text.
+			 * @returns A QVariant-representation of the JSON
+			 * 	structure.
+			 * @throws ParseException if the string provided is not
+			 * 	valid JSON (or at least this parser thinks it
+			 * 	isn't ;) )
+			 */
+			static QVariant parse(const QString& json) throw (ParseException);
+
+			/** Parse multiple objects in one string.
+			 * This is useful when working on streams where
+			 * one-chunk-per-json-object is not guaranteed.
+			 */
+			static QList<QVariantMap> multiParse(const QString& json) throw(ParseException);
+		private:
+			JsonToVariant();
+			// Parsers for types given on JSON.org
+			QVariantMap parseObject();
+			QVariantMap parseMembers();
+			QPair<QString, QVariant> parsePair();
+			QVariantList parseArray();
+			QVariantList parseElements();
+			QVariant parseValue();
+			QString parseString();
+			QString parseChars();
+			QChar parseChar();
+			QVariant parseNumber();
+			QString parseInt();
+			QString parseFrac();
+			QString parseExp();
+			QString parseDigits();
+			QString parseE();
+
+			// Parsers for types implied on JSON.org
+			QChar parseDigit();
+			QChar parseHexDigit();
+			bool parseBool();
+			QVariant parseNull();
+
+			// Internal functions
+			/// The unparsed part of the input string.
+			inline QString remaining();
+
+			/** Consume the next character.
+			 * Advances m_sym to the next character, and returns it.
+			 * Optionally skips over whitespace.
+			 *
+			 * @param skipWhitespace controls if whitespace is
+			 * 	ignored.
+			 * @returns *m_sym
+			 * @throws ParseException if the end of the string is
+			 *	reached.
+			 */
+			QChar consume(bool skipWhitespace = true)
+				throw(ParseException);
+
+			/** Consume the next character, and check for equality
+			 * with the specified character.
+			 *
+			 * @param wanted is the character to compare to.
+			 * @throws ParseException if the end of the string is
+			 * 	reached, or the characaters are not equal.
+			 */
+			void consume(QChar wanted) throw(ParseException);
+
+			/// Convenience function for consume(QChar).
+			void consume(char wanted) throw(ParseException);
+
+			/** Attempt to consume the specified string.
+			 * This attempts to consume length(wanted) characters,
+			 * including whitespace, and checks that they are equal
+			 * to the characters in the same position in the
+			 * specified string.
+			 *
+			 * @param wanted is the string to attempt to consume.
+			 * @throws ParseException if the end of the string is
+			 * 	reached, or the string comparisson fails.
+			 */
+			void consume(QString wanted) throw(ParseException);
+
+			/** Try to consume a single character, without throw.
+			 * This will try to read a single character, and
+			 * compares to the specified character.
+			 *
+			 * @param wanted is the character to compare to.
+			 * @returns true if the character specified was
+			 * 	successfully consumed.
+			 * @returns false if the end of the string was reached,
+			 * 	or the characters were not equal.
+			 */
+			bool tryConsume(QChar wanted) throw();
+
+			/** Return the next symbol.
+			 * Optionally skips whitespace.
+			 * 
+			 * @param skipWhitespace sets the whitespace handling.
+			 * @returns the next symbol.
+			 * @throws ParseException if the end of the string is
+			 * 	reached.
+			 */
+			QChar peekNext(bool skipWhitespace = true)
+				throw(ParseException);
+
+			// Variables
+
+			/// Iterator pointing at the current symbol.
+			QString::ConstIterator m_sym;
+			/// Iterator pointing at the next symbol.
+			QString::ConstIterator m_next;
+			/// Iterator pointing at the end of the string.
+			QString::ConstIterator m_end;
+	};
+}
+
+#endif