JSONDump.hpp

Go to the documentation of this file.

//----------------------------------------------------------------------------

#ifndef JSONDUMP_HPP_
#define JSONDUMP_HPP_

#include <mongotype.hpp>
#include <Parameters.hpp>
#include <IBSONRenderer.hpp>
#include <BSONObjectParser.hpp>

namespace mongotype {

class JSONDump : virtual public IBSONRenderer, virtual protected IBSONObjectVisitor {

        Parameters& params;
        string indentStr;

        function<ostream&()> getOStream; // std::function required to store a closure.

        // Output Helper Functions
        // tstr functions centralize token output primarily for debugging purposes.
        // istr emit a carriage return, indentation whitespace, and a token

        void tstr(const char* token) {
                getOStream() << token;
                if (params.isDebug()) getOStream().flush(); // "Token Buffering" on debug.
        }

        void tstr(string& token) {
                tstr(token.c_str());
        }

        void istr(const char* token, int level) {
                const string cr("\n");
                string indent;
                indent.reserve(1024);
                for (int i=0; i < level; i++) {
                        indent += indentStr;
                }
                string s(cr + indent + token);
                tstr(s);
        }

        void istr(string& token, int level) {
                istr(token.c_str(), level);
        }

        void emitComma(const BSONParserStack& stack) {
                const int ARRAY_PARENT_OFFSET = 2;
                if (stack.depth() >= ARRAY_PARENT_OFFSET) {
                        const BSONParserStackItem& parent = stack.item(-ARRAY_PARENT_OFFSET);
                        bool parentIsNotArray = parent.getType() != BSONParserStackItem::ItemType::ARRAY;
                        //if (stack.top().getElementIndex() > 0 && parentIsNotArray) {
                        if (stack.top().getElementIndex() > 0 && (parentIsNotArray || stack.top().getArrayIndex() > 0)) {
                                tstr(",");
                        }
                }
        }

        void emitKey(const BSONParserStack& stack) {
                const int ARRAY_PARENT_OFFSET = 2;
                bool parentIsNotArray = true;
                if (stack.depth() >= ARRAY_PARENT_OFFSET) {
                        const BSONParserStackItem& parent = stack.item(-ARRAY_PARENT_OFFSET);
                        parentIsNotArray = parent.getType() != BSONParserStackItem::ItemType::ARRAY;
                }
                string s;
                if (stack.depth() > 1 && parentIsNotArray) {
                        s += "\"";
                        s += stack.top().getKey();
                        s += "\" : ";
                }
                istr(s, stack.depth());
        }

        void nextLine(const BSONParserStack& stack) {
                emitComma(stack);
                if (params.isStackDebug()) {
                        tstr(string(("  ") + stack.toString()).c_str());
                }
                emitKey(stack);
        }

protected: // IBSONObjectVisitor overrides. ---------------------------------------------------------------------------

        virtual void onParseStart() {
        }

        virtual void onParseEnd() {
        }

        virtual void onObjectStart(const BSONParserStack& stack) {
                nextLine(stack);
                tstr("{"); // Begin the JSON object
        }

        virtual void onObjectEnd(const BSONParserStack& stack) {
                istr("}", stack.depth()); // End the JSON object.
        }

        virtual void onArrayStart(const BSONParserStack& stack) {
                nextLine(stack);
                tstr("["); // Begin the JSON array.
        }

        virtual void onArrayEnd(const BSONParserStack& stack) {
                istr("]", stack.depth()); // End the JSON array.
        }

        virtual void onElement(const BSONParserStack& stack) {
                nextLine(stack);
                // TODO: Some element values produced by element.toString(..) need quoting for JSON.
                string s(stack.top().getElement().toString(false,false));
                tstr(s); // Output element value.
        }

public: // User Interface ---------------------------------------------------------------------------------------------

        JSONDump(Parameters& pparams, const char *pindentStr = " ") :
                params(pparams), indentStr(pindentStr) {}

        virtual ~JSONDump() {};

        /*
         * \param[in] os The output stream to which the object(s) are rendered.
         */
        virtual void setOutputStream(std::ostream& os) {
                getOStream = [&] () -> ostream& { return os; }; // Wrap closure around ostream.
        }

        /*
         * \param[in] prefix The string to be output before the object is rendered, or NULL.
         */
        virtual void begin(const char* prefix) {
                tstr("[");
        }

        /*
         * \param[in] suffix The string to be output after the object is rendered, or NULL.
         */
        virtual void end(const char* suffix) {
                tstr("\n]");
        }

        /*
         * \param[in] pobject The BSON object to be dumped.
         * \param[in] pobject The output stream.
         */
        virtual void render(const BSONObj& object, int docIndex, int docCount) {
                if (docIndex > 0) {
                        tstr(",");
                }
                BSONObjectParser objectParser(*this); // Construct a parser around this event handler.
                objectParser.parse(object);     // !!! MAJOR ACTION HERE !!! >>> Parse the object and write to the output stream.
        }
};

} /* namespace mongotype */
#endif /* JSONDUMP_HPP_ */