bool TypeMatchExpression::matches(const MatchableDocument* doc, MatchDetails* details) const {
    MatchableDocument::IteratorHolder cursor(doc, &_elementPath);
    while (cursor->more()) {
        ElementIterator::Context e = cursor->next();

        // In the case where _elementPath is referring to an array,
        // $type should match elements of that array only.
        // outerArray() helps to identify elements of the array
        // and the containing array itself.
        // This matters when we are looking for {$type: Array}.
        // Example (_elementPath refers to field 'a' and _type is Array):
        // a : [        // outer array. should not match
        //     123,     // inner array
        //     [ 456 ], // inner array. should match
        //     ...
        // ]
        if (_type == mongo::Array && e.outerArray()) {
            continue;
        }

        if (!matchesSingleElement(e.element())) {
            continue;
        }

        if (details && details->needRecord() && !e.arrayOffset().eoo()) {
            details->setElemMatchKey(e.arrayOffset().fieldName());
        }
        return true;
    }
    return false;
}

TEST(SingleElementElementIterator, Simple1) {
    BSONObj obj = BSON("x" << 3 << "y" << 5);
    SingleElementElementIterator i(obj["y"]);

    ASSERT(i.more());
    ElementIterator::Context e = i.next();
    ASSERT_EQUALS(5, e.element().numberInt());

    ASSERT(!i.more());
}

 bool AllElemMatchOp::matches( const MatchableDocument* doc, MatchDetails* details ) const {
     boost::scoped_ptr<ElementIterator> cursor( doc->getIterator( _elementPath ) );
     while ( cursor->more() ) {
         ElementIterator::Context e = cursor->next();
         if ( e.element().type() != Array )
             continue;
         if ( _allMatch( e.element().Obj() ) )
             return true;
     }
     return false;
 }

 bool AllElemMatchOp::matches( const MatchableDocument* doc, MatchDetails* details ) const {
     MatchableDocument::IteratorHolder cursor( doc, &_elementPath );
     while ( cursor->more() ) {
         ElementIterator::Context e = cursor->next();
         if ( e.element().type() != Array )
             continue;
         if ( _allMatch( e.element().Obj() ) )
             return true;
     }
     return false;
 }

        virtual bool matches(const MatchableDocument* doc, MatchDetails* details = 0) const {
            MatchableDocument::IteratorHolder cursor(doc, &_elementPath);

            while (cursor->more()) {
                ElementIterator::Context e = cursor->next();
                if (matchesSingleElement(e.element())) {
                    return true;
                }
            }

            return false;
        }

TEST(Path, Root1) {
    ElementPath p;
    ASSERT(p.init("a").isOK());

    BSONObj doc = BSON("x" << 4 << "a" << 5);

    BSONElementIterator cursor(&p, doc);
    ASSERT(cursor.more());
    ElementIterator::Context e = cursor.next();
    ASSERT_EQUALS((string) "a", e.element().fieldName());
    ASSERT_EQUALS(5, e.element().numberInt());
    ASSERT(!cursor.more());
}