V8XPathResult.cpp

/*
    This file is part of the WebKit open source project.
    This file has been generated by generate-bindings.pl. DO NOT MODIFY!

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
    Boston, MA 02111-1307, USA.
*/

#include "config.h"
#include "V8XPathResult.h"

#if ENABLE(XPATH)

#include "ExceptionCode.h"
#include "RuntimeEnabledFeatures.h"
#include "V8Binding.h"
#include "V8BindingMacros.h"
#include "V8BindingState.h"
#include "V8DOMWrapper.h"
#include "V8IsolatedContext.h"
#include "V8Node.h"
#include "V8Proxy.h"

namespace WebCore {

WrapperTypeInfo V8XPathResult::info = { V8XPathResult::GetTemplate, V8XPathResult::derefObject, 0 };

namespace XPathResultInternal {

template <typename T> void V8_USE(T) { }

static v8::Handle<v8::Value> resultTypeAttrGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
{
    INC_STATS("DOM.XPathResult.resultType._get");
    XPathResult* imp = V8XPathResult::toNative(info.Holder());
    return v8::Integer::New(imp->resultType());
}

static v8::Handle<v8::Value> numberValueAttrGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
{
    INC_STATS("DOM.XPathResult.numberValue._get");
    XPathResult* imp = V8XPathResult::toNative(info.Holder());
    ExceptionCode ec = 0;
    double v = imp->numberValue(ec);
    if (UNLIKELY(ec)) {
        V8Proxy::setDOMException(ec);
        return v8::Handle<v8::Value>();
    }
    return v8::Number::New(v);
}

static v8::Handle<v8::Value> stringValueAttrGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
{
    INC_STATS("DOM.XPathResult.stringValue._get");
    XPathResult* imp = V8XPathResult::toNative(info.Holder());
    ExceptionCode ec = 0;
    String v = imp->stringValue(ec);
    if (UNLIKELY(ec)) {
        V8Proxy::setDOMException(ec);
        return v8::Handle<v8::Value>();
    }
    return v8String(v);
}

static v8::Handle<v8::Value> booleanValueAttrGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
{
    INC_STATS("DOM.XPathResult.booleanValue._get");
    XPathResult* imp = V8XPathResult::toNative(info.Holder());
    ExceptionCode ec = 0;
    bool v = imp->booleanValue(ec);
    if (UNLIKELY(ec)) {
        V8Proxy::setDOMException(ec);
        return v8::Handle<v8::Value>();
    }
    return v8Boolean(v);
}

static v8::Handle<v8::Value> singleNodeValueAttrGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
{
    INC_STATS("DOM.XPathResult.singleNodeValue._get");
    XPathResult* imp = V8XPathResult::toNative(info.Holder());
    ExceptionCode ec = 0;
    RefPtr<Node> v = imp->singleNodeValue(ec);
    if (UNLIKELY(ec)) {
        V8Proxy::setDOMException(ec);
        return v8::Handle<v8::Value>();
    }
    return toV8(v.release());
}

static v8::Handle<v8::Value> invalidIteratorStateAttrGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
{
    INC_STATS("DOM.XPathResult.invalidIteratorState._get");
    XPathResult* imp = V8XPathResult::toNative(info.Holder());
    return v8Boolean(imp->invalidIteratorState());
}

static v8::Handle<v8::Value> snapshotLengthAttrGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
{
    INC_STATS("DOM.XPathResult.snapshotLength._get");
    XPathResult* imp = V8XPathResult::toNative(info.Holder());
    ExceptionCode ec = 0;
    unsigned v = imp->snapshotLength(ec);
    if (UNLIKELY(ec)) {
        V8Proxy::setDOMException(ec);
        return v8::Handle<v8::Value>();
    }
    return v8::Integer::NewFromUnsigned(v);
}

static v8::Handle<v8::Value> iterateNextCallback(const v8::Arguments& args)
{
    INC_STATS("DOM.XPathResult.iterateNext");
    XPathResult* imp = V8XPathResult::toNative(args.Holder());
    ExceptionCode ec = 0;
    {
    RefPtr<Node> result = imp->iterateNext(ec);
    if (UNLIKELY(ec))
        goto fail;
    return toV8(result.release());
    }
    fail:
    V8Proxy::setDOMException(ec);
    return v8::Handle<v8::Value>();
}

static v8::Handle<v8::Value> snapshotItemCallback(const v8::Arguments& args)
{
    INC_STATS("DOM.XPathResult.snapshotItem");
    XPathResult* imp = V8XPathResult::toNative(args.Holder());
    ExceptionCode ec = 0;
    {
    EXCEPTION_BLOCK(unsigned, index, toUInt32(args[0]));
    RefPtr<Node> result = imp->snapshotItem(index, ec);
    if (UNLIKELY(ec))
        goto fail;
    return toV8(result.release());
    }
    fail:
    V8Proxy::setDOMException(ec);
    return v8::Handle<v8::Value>();
}

} // namespace XPathResultInternal

static const BatchedAttribute XPathResultAttrs[] = {
    // Attribute 'resultType' (Type: 'readonly attribute' ExtAttr: '')
    {"resultType", XPathResultInternal::resultTypeAttrGetter, 0, 0 /* no data */, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
    // Attribute 'numberValue' (Type: 'readonly attribute' ExtAttr: '')
    {"numberValue", XPathResultInternal::numberValueAttrGetter, 0, 0 /* no data */, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
    // Attribute 'stringValue' (Type: 'readonly attribute' ExtAttr: '')
    {"stringValue", XPathResultInternal::stringValueAttrGetter, 0, 0 /* no data */, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
    // Attribute 'booleanValue' (Type: 'readonly attribute' ExtAttr: '')
    {"booleanValue", XPathResultInternal::booleanValueAttrGetter, 0, 0 /* no data */, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
    // Attribute 'singleNodeValue' (Type: 'readonly attribute' ExtAttr: '')
    {"singleNodeValue", XPathResultInternal::singleNodeValueAttrGetter, 0, 0 /* no data */, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
    // Attribute 'invalidIteratorState' (Type: 'readonly attribute' ExtAttr: '')
    {"invalidIteratorState", XPathResultInternal::invalidIteratorStateAttrGetter, 0, 0 /* no data */, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
    // Attribute 'snapshotLength' (Type: 'readonly attribute' ExtAttr: '')
    {"snapshotLength", XPathResultInternal::snapshotLengthAttrGetter, 0, 0 /* no data */, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
};
static const BatchedCallback XPathResultCallbacks[] = {
    {"iterateNext", XPathResultInternal::iterateNextCallback},
    {"snapshotItem", XPathResultInternal::snapshotItemCallback},
};
static const BatchedConstant XPathResultConsts[] = {
    {"ANY_TYPE", static_cast<signed int>(0)},
    {"NUMBER_TYPE", static_cast<signed int>(1)},
    {"STRING_TYPE", static_cast<signed int>(2)},
    {"BOOLEAN_TYPE", static_cast<signed int>(3)},
    {"UNORDERED_NODE_ITERATOR_TYPE", static_cast<signed int>(4)},
    {"ORDERED_NODE_ITERATOR_TYPE", static_cast<signed int>(5)},
    {"UNORDERED_NODE_SNAPSHOT_TYPE", static_cast<signed int>(6)},
    {"ORDERED_NODE_SNAPSHOT_TYPE", static_cast<signed int>(7)},
    {"ANY_UNORDERED_NODE_TYPE", static_cast<signed int>(8)},
    {"FIRST_ORDERED_NODE_TYPE", static_cast<signed int>(9)},
};

COMPILE_ASSERT(0 == XPathResult::ANY_TYPE, XPathResultEnumANY_TYPEIsWrongUseDontCheckEnums);
COMPILE_ASSERT(1 == XPathResult::NUMBER_TYPE, XPathResultEnumNUMBER_TYPEIsWrongUseDontCheckEnums);
COMPILE_ASSERT(2 == XPathResult::STRING_TYPE, XPathResultEnumSTRING_TYPEIsWrongUseDontCheckEnums);
COMPILE_ASSERT(3 == XPathResult::BOOLEAN_TYPE, XPathResultEnumBOOLEAN_TYPEIsWrongUseDontCheckEnums);
COMPILE_ASSERT(4 == XPathResult::UNORDERED_NODE_ITERATOR_TYPE, XPathResultEnumUNORDERED_NODE_ITERATOR_TYPEIsWrongUseDontCheckEnums);
COMPILE_ASSERT(5 == XPathResult::ORDERED_NODE_ITERATOR_TYPE, XPathResultEnumORDERED_NODE_ITERATOR_TYPEIsWrongUseDontCheckEnums);
COMPILE_ASSERT(6 == XPathResult::UNORDERED_NODE_SNAPSHOT_TYPE, XPathResultEnumUNORDERED_NODE_SNAPSHOT_TYPEIsWrongUseDontCheckEnums);
COMPILE_ASSERT(7 == XPathResult::ORDERED_NODE_SNAPSHOT_TYPE, XPathResultEnumORDERED_NODE_SNAPSHOT_TYPEIsWrongUseDontCheckEnums);
COMPILE_ASSERT(8 == XPathResult::ANY_UNORDERED_NODE_TYPE, XPathResultEnumANY_UNORDERED_NODE_TYPEIsWrongUseDontCheckEnums);
COMPILE_ASSERT(9 == XPathResult::FIRST_ORDERED_NODE_TYPE, XPathResultEnumFIRST_ORDERED_NODE_TYPEIsWrongUseDontCheckEnums);

static v8::Persistent<v8::FunctionTemplate> ConfigureV8XPathResultTemplate(v8::Persistent<v8::FunctionTemplate> desc)
{
    v8::Local<v8::Signature> defaultSignature = configureTemplate(desc, "XPathResult", v8::Persistent<v8::FunctionTemplate>(), V8XPathResult::internalFieldCount,
        XPathResultAttrs, sizeof(XPathResultAttrs) / sizeof(*XPathResultAttrs),
        XPathResultCallbacks, sizeof(XPathResultCallbacks) / sizeof(*XPathResultCallbacks));
    v8::Local<v8::ObjectTemplate> instance = desc->InstanceTemplate();
    v8::Local<v8::ObjectTemplate> proto = desc->PrototypeTemplate();
    
    batchConfigureConstants(desc, proto, XPathResultConsts, sizeof(XPathResultConsts) / sizeof(*XPathResultConsts));

    // Custom toString template
    desc->Set(getToStringName(), getToStringTemplate());
    return desc;
}

v8::Persistent<v8::FunctionTemplate> V8XPathResult::GetRawTemplate()
{
    static v8::Persistent<v8::FunctionTemplate> V8XPathResultRawCache = createRawTemplate();
    return V8XPathResultRawCache;
}

v8::Persistent<v8::FunctionTemplate> V8XPathResult::GetTemplate()
{
    static v8::Persistent<v8::FunctionTemplate> V8XPathResultCache = ConfigureV8XPathResultTemplate(GetRawTemplate());
    return V8XPathResultCache;
}

XPathResult* V8XPathResult::toNative(v8::Handle<v8::Object> object)
{
    return reinterpret_cast<XPathResult*>(object->GetPointerFromInternalField(v8DOMWrapperObjectIndex));
}

bool V8XPathResult::HasInstance(v8::Handle<v8::Value> value)
{
    return GetRawTemplate()->HasInstance(value);
}


v8::Handle<v8::Object> V8XPathResult::wrap(XPathResult* impl)
{
    v8::Handle<v8::Object> wrapper;
    V8Proxy* proxy = 0;
        wrapper = getDOMObjectMap().get(impl);
        if (!wrapper.IsEmpty())
            return wrapper;
    wrapper = V8DOMWrapper::instantiateV8Object(proxy, &info, impl);
    if (wrapper.IsEmpty())
        return wrapper;

    impl->ref();
    getDOMObjectMap().set(impl, v8::Persistent<v8::Object>::New(wrapper));
    return wrapper;
}

v8::Handle<v8::Value> toV8(PassRefPtr<XPathResult > impl)
{
    return toV8(impl.get());
}

v8::Handle<v8::Value> toV8(XPathResult* impl)
{
    if (!impl)
        return v8::Null();
    return V8XPathResult::wrap(impl);
}

void V8XPathResult::derefObject(void* object)
{
    static_cast<XPathResult*>(object)->deref();
}

} // namespace WebCore

#endif // ENABLE(XPATH)