Attachment #753764 for bug #869996

Attachment #753764: patch v2 for bug #869996

View | Details | Raw Unified | Return to bug 869996
Collapse All | Expand All





}


/*** SetIterator *********************************************************************************/

class js::SetIteratorObject : public JSObject
{
  public:
    enum { TargetSlot, KindSlot, RangeSlot, SlotCount };
    static const JSFunctionSpec methods[];
    static SetIteratorObject *create(JSContext *cx, HandleObject setobj, ValueSet *data,
                                     SetObject::IteratorKind kind);
    static void finalize(FreeOp *fop, JSObject *obj);

  private:
    static inline bool is(const Value &v);
    inline ValueSet::Range *range();
    inline SetObject::IteratorKind kind() const;
    static bool next_impl(JSContext *cx, CallArgs args);
    static JSBool next(JSContext *cx, unsigned argc, Value *vp);
};

inline js::SetIteratorObject &
JSObject::asSetIterator()
{
    JS_ASSERT(isSetIterator());

};

inline ValueSet::Range *
SetIteratorObject::range()
{
    return static_cast<ValueSet::Range *>(getSlot(RangeSlot).toPrivate());
}

inline SetObject::IteratorKind
SetIteratorObject::kind() const
{
    int32_t i = getSlot(KindSlot).toInt32();
    JS_ASSERT(i == SetObject::Keys || i == SetObject::Values || i == SetObject::Entries);
    return SetObject::IteratorKind(i);
}

bool
GlobalObject::initSetIteratorProto(JSContext *cx, Handle<GlobalObject*> global)
{
    JSObject *base = global->getOrCreateIteratorPrototype(cx);
    if (!base)
        return false;
    RootedObject proto(cx, NewObjectWithGivenProto(cx, &SetIteratorClass, base, global));
    if (!proto)

    proto->setSlot(SetIteratorObject::RangeSlot, PrivateValue(NULL));
    if (!JS_DefineFunctions(cx, proto, SetIteratorObject::methods))
        return false;
    global->setReservedSlot(SET_ITERATOR_PROTO, ObjectValue(*proto));
    return true;
}

SetIteratorObject *
SetIteratorObject::create(JSContext *cx, HandleObject setobj, ValueSet *data,
                          SetObject::IteratorKind kind)
{
    Rooted<GlobalObject *> global(cx, &setobj->global());
    Rooted<JSObject*> proto(cx, global->getOrCreateSetIteratorPrototype(cx));
    if (!proto)
        return NULL;

    ValueSet::Range *range = cx->new_<ValueSet::Range>(data->all());
    if (!range)
        return NULL;

    JSObject *iterobj = NewObjectWithGivenProto(cx, &SetIteratorClass, proto, global);
    if (!iterobj) {
        js_delete(range);
        return NULL;
    }
    iterobj->setSlot(TargetSlot, ObjectValue(*setobj));
    iterobj->setSlot(KindSlot, Int32Value(int32_t(kind)));
    iterobj->setSlot(RangeSlot, PrivateValue(range));
    return static_cast<SetIteratorObject *>(iterobj);
}

void
SetIteratorObject::finalize(FreeOp *fop, JSObject *obj)
{
    fop->delete_(obj->asSetIterator().range());

    if (!range)
        return js_ThrowStopIteration(cx);
    if (range->empty()) {
        js_delete(range);
        thisobj.setReservedSlot(RangeSlot, PrivateValue(NULL));
        return js_ThrowStopIteration(cx);
    }

    switch (thisobj.kind()) {
        case SetObject::Keys:
        case SetObject::Values:
            args.rval().set(range->front().get());
            break;

        case SetObject::Entries: {
            Value pair[2] = { range->front().get(), range->front().get() };
            AutoValueArray root(cx, pair, 2);

            JSObject *pairobj = NewDenseCopiedArray(cx, 2, pair);
            if(!pairobj)
                return false;
            args.rval().setObject(*pairobj);
            break;
        }
    }

    range->popFront();
    return true;
}

JSBool
SetIteratorObject::next(JSContext *cx, unsigned argc, Value *vp)
{
    CallArgs args = CallArgsFromVp(argc, vp);

    JS_PSG("size", size, 0),
    JS_PS_END
};

const JSFunctionSpec SetObject::methods[] = {
    JS_FN("has", has, 1, 0),
    JS_FN("add", add, 1, 0),
    JS_FN("delete", delete_, 1, 0),
    JS_FN("keys", keys, 0, 0),
    JS_FN("values", values, 0, 0),
    JS_FN("entries", entries, 0, 0),
    JS_FN("iterator", values, 0, 0),
    JS_FN("clear", clear, 0, 0),
    JS_FS_END
};

JSObject *
SetObject::initClass(JSContext *cx, JSObject *obj)
{
    Rooted<GlobalObject*> global(cx, &obj->asGlobal());

JSBool
SetObject::delete_(JSContext *cx, unsigned argc, Value *vp)
{
    CallArgs args = CallArgsFromVp(argc, vp);
    return CallNonGenericMethod<SetObject::is, SetObject::delete_impl>(cx, args);
}

bool
SetObject::iterator_impl(JSContext *cx, CallArgs args, IteratorKind kind)
{
    Rooted<SetObject*> setobj(cx, &args.thisv().toObject().asSet());
    ValueSet &set = *setobj->getData();
    Rooted<JSObject*> iterobj(cx, SetIteratorObject::create(cx, setobj, &set, kind));
    if (!iterobj)
        return false;
    args.rval().setObject(*iterobj);
    return true;
}

bool
SetObject::keys_impl(JSContext *cx, CallArgs args)
{
    return iterator_impl(cx, args, Keys);
}

JSBool
SetObject::keys(JSContext *cx, unsigned argc, Value *vp)
{
    CallArgs args = CallArgsFromVp(argc, vp);
    return CallNonGenericMethod(cx, is, keys_impl, args);
}

bool
SetObject::values_impl(JSContext *cx, CallArgs args)
{
    return iterator_impl(cx, args, Values);
}

JSBool
SetObject::values(JSContext *cx, unsigned argc, Value *vp)
{
    CallArgs args = CallArgsFromVp(argc, vp);
    return CallNonGenericMethod(cx, is, values_impl, args);
}

bool
SetObject::entries_impl(JSContext *cx, CallArgs args)
{
    return iterator_impl(cx, args, Entries);
}

JSBool
SetObject::entries(JSContext *cx, unsigned argc, Value *vp)
{
    CallArgs args = CallArgsFromVp(argc, vp);
    return CallNonGenericMethod(cx, is, entries_impl, args);
}

bool
SetObject::clear_impl(JSContext *cx, CallArgs args)
{
    Rooted<SetObject*> setobj(cx, &args.thisv().toObject().asSet());
    if (!setobj->getData()->clear()) {
        js_ReportOutOfMemory(cx);





    static bool entries_impl(JSContext *cx, CallArgs args);
    static JSBool entries(JSContext *cx, unsigned argc, Value *vp);
    static bool clear_impl(JSContext *cx, CallArgs args);
    static JSBool clear(JSContext *cx, unsigned argc, Value *vp);
};

class SetObject : public JSObject {
  public:
    enum IteratorKind { Keys, Values, Entries };
    static JSObject *initClass(JSContext *cx, JSObject *obj);
    static Class class_;
  private:
    static const JSPropertySpec properties[];
    static const JSFunctionSpec methods[];
    ValueSet *getData() { return static_cast<ValueSet *>(getPrivate()); }
    static ValueSet & extract(CallReceiver call);
    static void mark(JSTracer *trc, JSObject *obj);
    static void finalize(FreeOp *fop, JSObject *obj);
    static JSBool construct(JSContext *cx, unsigned argc, Value *vp);

    static bool is(const Value &v);

    static bool iterator_impl(JSContext *cx, CallArgs args, IteratorKind kind);

    static bool size_impl(JSContext *cx, CallArgs args);
    static JSBool size(JSContext *cx, unsigned argc, Value *vp);
    static bool has_impl(JSContext *cx, CallArgs args);
    static JSBool has(JSContext *cx, unsigned argc, Value *vp);
    static bool add_impl(JSContext *cx, CallArgs args);
    static JSBool add(JSContext *cx, unsigned argc, Value *vp);
    static bool delete_impl(JSContext *cx, CallArgs args);
    static JSBool delete_(JSContext *cx, unsigned argc, Value *vp);
    static bool keys_impl(JSContext *cx, CallArgs args);
    static JSBool keys(JSContext *cx, unsigned argc, Value *vp);
    static bool values_impl(JSContext *cx, CallArgs args);
    static JSBool values(JSContext *cx, unsigned argc, Value *vp);
    static bool entries_impl(JSContext *cx, CallArgs args);
    static JSBool entries(JSContext *cx, unsigned argc, Value *vp);
    static bool clear_impl(JSContext *cx, CallArgs args);
    static JSBool clear(JSContext *cx, unsigned argc, Value *vp);
};

} /* namespace js */

extern JSObject *
js_InitMapClass(JSContext *cx, js::HandleObject obj);

-      Line
+  Link Here
-      Line 0
+  Link Here
+// set.keys(), .values(), and .entries() on an empty set produce empty iterators
+var s = Set();
+var ki = s.keys(), vi = s.values(), ei = s.entries();
+var p = Object.getPrototypeOf(ki);
+assertEq(Object.getPrototypeOf(vi), p);
+assertEq(Object.getPrototypeOf(ei), p);
+for (let k or ki)
+	throw "FAIL";
+for (let v of vi)
+	throw "FAIL";
+for (let [k, v] of ei)
+	throw "FAIL";

-      Line
+  Link Here
-      Line 0
+  Link Here
+// set.keys() and set.values() return iterators over the values,
+// and set.entries() return iterator over a pair of values in the set
+load(libdir + "asserts.js");
+var data = [1, 2, 3, 4];
+var values = [[1, 1], [2, 2], [3, 3], [4, 4]];
+var s = Set(data);
+var ki = s.keys();
+assertEq(ki.next(), 1);
+assertEq(ki.next(), 2);
+assertEq(ki.next(), 3);
+assertEq(ki.next(), 4);
+assertThrowsValue(function () { ki.next(); }, StopIteration);
+assertEq([k for (k of s.keys())].toSource(), [1, 2, 3, 4].toSource());
+assertEq([k for (k of s.values())].toSource(), [1, 2, 3, 4].toSource());
+assertEq([k for (k of s.entries())].toSource(), values.toSource());

Return to bug 869996