BSONObjectParser.hpp

Go to the documentation of this file.

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

#ifndef BSONOBJECTPARSER_HPP_
#define BSONOBJECTPARSER_HPP_

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

#include <mongotype.hpp>

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

namespace mongotype {

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

class BSONParserStackItem {
public:
        enum ItemType {
                OBJECT,         
                ARRAY,          
                ELEMENT         
        };

private:
        ItemType type;

        union Item {
                const BSONObj* object;
                Item(const BSONObj* pobject) : object(pobject) {}
                const BSONElement* element;
                Item(const BSONElement* pelement) : element(pelement) {}
        } item;

        const string& key;

        int elementIndex;

        int elementCount;

        int arrayIndex;

        int arrayCount;

private:
        void validate(ItemType t) const {
                if (t != type) {
                        throw std::logic_error( string("Illegal Stack Item Type Access: ") + (t == OBJECT ? string("OBJECT") : string("ELEMENT")) );
                }
        }

public:
        BSONParserStackItem(const BSONObj* object, const string& pkey, int pelementIndex, int pelementCount, int parrayIndex, int parrayCount)
                : type(OBJECT), item(object), key(pkey), elementIndex(pelementIndex), elementCount(pelementCount), arrayIndex(parrayIndex), arrayCount(parrayCount) {}
        BSONParserStackItem(ItemType ptype, const BSONElement* element, const string& pkey, int pelementIndex, int pelementCount, int parrayIndex, int parrayCount)
                : type(ptype), item(element), key(pkey), elementIndex(pelementIndex), elementCount(pelementCount), arrayIndex(parrayIndex), arrayCount(parrayCount) {}

        ItemType getType() const {
                return type;
        }

        const BSONObj& getObject() const {
                validate(OBJECT);
                return *item.object;
        }

        const BSONElement& getElement() const {
                validate(ELEMENT);
                return *item.element;
        }

        const BSONElement& getArray() const {
                validate(ARRAY);
                return *item.element;
        }

        const string& getKey() const {
                return key;
        }

        int getElementIndex() const {
                return elementIndex;
        }

        int getElementCount() const {
                return elementCount;
        }

        int getArrayIndex() const {
                return arrayIndex;
        }

        int getArrayCount() const {
                return arrayCount;
        }

        string toString() const {
                string s("{");
                switch (type) {
                case OBJECT:
                        s += "OBJECT";
                        break;
                case ARRAY:
                        s += "ARRAY";
                        break;
                case ELEMENT:
                        s += "ELEMENT";
                        break;
                default:
                        throw std::logic_error(string("toString Undefined ItemType!"));
                }
                s += ",\"" + key + "\"",
                s += "," + to_string(elementIndex);
                s += "," + to_string(elementCount);
                s += "," + to_string(arrayIndex);
                s += "," + to_string(arrayCount);
                s += "}";
                return s;
        }
};

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

class BSONParserStack {
        typedef std::deque<std::unique_ptr<const BSONParserStackItem>> Stack;

        Stack stack;

public:
        int depth() const { return stack.size(); }

private:
        void throwCount(int count) const {
                if (depth() < count) {
                        throw std::logic_error( string("ISE: Insufficient BSONParserStack Stack Entries:(" + to_string(count)) + "," + to_string(depth()) + ")" );
                }
        }

protected:

        const BSONParserStackItem* pop() {
                throwCount(1);
                const BSONParserStackItem* rv = stack.back().release();
                stack.pop_back();
                return rv;
        }

        void push(const BSONParserStackItem* item) {
                stack.push_back(unique_ptr<const BSONParserStackItem>(item));
        }

public:
        const BSONParserStackItem& item(int index) const {
                if (index >= 0) {
                        throwCount(index+1);
                        return *(stack[index].get());
                } else {
                        int i = depth() + index;
                        return item(i);
                }
        }

        const BSONParserStackItem& top() const { // Item ownership unaffected.
                return item(depth()-1);
        }

        void push(const BSONObj& object, const string& key = string(), int elementIndex=0, int elementCount=1, int arrayIndex=-1, int arrayCount=0) {
                push(new BSONParserStackItem(&object, key, elementIndex, elementCount, arrayIndex, arrayCount));
        }

        void push(BSONParserStackItem::ItemType type, const BSONElement& element, const string& key = string(), int elementIndex=0, int elementCount=1, int arrayIndex=-1, int arrayCount=0) {
                push(new BSONParserStackItem(type, &element, key, elementIndex, elementCount, arrayIndex, arrayCount));
        }

        void drop() {
                delete pop();
        }

        string toString() const {
                string s("<<");
                for (int i=0; i < depth(); i++) {
                        if (i > 0) s += ",";
                        s += item(i).toString();
                }
                s += ">>";
                return s;
        }
};

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

class IBSONObjectVisitor {
public:
        virtual ~IBSONObjectVisitor() {}

        virtual void onParseStart() = 0;
        virtual void onParseEnd() = 0;

        virtual void onObjectStart(const BSONParserStack& stack) = 0;
        virtual void onObjectEnd(const BSONParserStack& stack) = 0;

        virtual void onArrayStart(const BSONParserStack& stack) = 0;
        virtual void onArrayEnd(const BSONParserStack& stack) = 0;

        virtual void onElement(const BSONParserStack& stack) = 0;
};

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

class BSONObjectParser {

protected:
        IBSONObjectVisitor& visitor;
        BSONParserStack stack;

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

        virtual void parseElementRecursive(const BSONElement& element, string& key, int elementIndex=0, int elementCount=1, int arrayIndex = -1, int arrayCount = 0) {
                BSONType btype = element.type();
                switch (btype) {
                case BSONType::Object:
                        {
                                const BSONObj& bobj = element.Obj();
                                string k(element.fieldName());
                                parseObjectRecursive(bobj, k, elementIndex, elementCount, arrayIndex, arrayCount);
                        }
                        break;
                case BSONType::Array:
                        {
                                stack.push(BSONParserStackItem::ItemType::ARRAY, element, key, elementIndex, elementCount, arrayIndex, arrayCount);
                                std::vector<BSONElement> elementArray = element.Array();
                                int elementArrayCount = elementArray.size();
                                visitor.onArrayStart(stack);
                                int elementArrayIndex = 0;
                                for (BSONElement e : elementArray) {
                                        string k(e.fieldName());
                                        parseElementRecursive(e, k, elementIndex, elementCount, elementArrayIndex++, elementArrayCount);
                                }
                                visitor.onArrayEnd(stack);
                                stack.drop();
                        }
                        break;
                default:
                        {
                                stack.push(BSONParserStackItem::ItemType::ELEMENT, element, key, elementIndex, elementCount, arrayIndex, arrayCount);
                                visitor.onElement(stack);
                                stack.drop();
                        }
                        break;
                }
        }

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

        virtual void parseObjectRecursive(const BSONObj& object, string& key, int elementIndex=0, int elementCount=1, int arrayIndex = -1, int arrayCount = 0) {
                stack.push(object, key, elementIndex, elementCount, arrayIndex, arrayCount);
                visitor.onObjectStart(stack);
                set<string> keys;
                object.getFieldNames(keys); // Get the key names of the BSON object.
                int ei = 0;
                int ec = keys.size();
                for (string key : keys) {
                        BSONElement e = object.getField(key);
                        parseElementRecursive(e, key, ei++, ec, arrayIndex);
                }
                visitor.onObjectEnd(stack);
                stack.drop();
        }

public:
        //----------------------------------------------------------------------------

        BSONObjectParser(IBSONObjectVisitor& pvisitor) : visitor(pvisitor) {}
        virtual ~BSONObjectParser() {}

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

        virtual void parse(const BSONObj& object) {
                visitor.onParseStart();
                string emptyString("");
                parseObjectRecursive(object, emptyString);
                visitor.onParseEnd();
        }

        //----------------------------------------------------------------------------
};

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

} /* namespace mongotype */

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

#endif /* BSONOBJECTPARSER_HPP_ */