// Copyright 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

// This file has been auto-generated by code_generator_v8.py. DO NOT MODIFY!

#include "config.h"
#include "bindings/core/v8/UnionTypesCore.h"

#include "bindings/core/v8/V8Node.h"
#include "bindings/core/v8/V8NodeList.h"
#include "bindings/core/v8/V8TestDictionary.h"
#include "bindings/core/v8/V8TestInterface.h"
#include "bindings/core/v8/V8TestInterfaceEmpty.h"
#include "bindings/core/v8/V8TestInterfaceGarbageCollected.h"
#include "bindings/core/v8/V8TestInterfaceWillBeGarbageCollected.h"
#include "bindings/tests/idls/core/TestImplements2.h"
#include "bindings/tests/idls/core/TestImplements3Implementation.h"
#include "bindings/tests/idls/core/TestPartialInterface.h"
#include "bindings/tests/idls/core/TestPartialInterfaceImplementation.h"
#include "core/dom/NameNodeList.h"
#include "core/dom/NodeList.h"
#include "core/dom/StaticNodeList.h"
#include "core/html/LabelsNodeList.h"

namespace blink {

BooleanOrStringOrUnrestrictedDouble::BooleanOrStringOrUnrestrictedDouble()
    : m_type(SpecificTypeNone)
{
}

bool BooleanOrStringOrUnrestrictedDouble::getAsBoolean()
{
    ASSERT(isBoolean());
    return m_boolean;
}

void BooleanOrStringOrUnrestrictedDouble::setBoolean(bool value)
{
    ASSERT(isNull());
    m_boolean = value;
    m_type = SpecificTypeBoolean;
}

String BooleanOrStringOrUnrestrictedDouble::getAsString()
{
    ASSERT(isString());
    return m_string;
}

void BooleanOrStringOrUnrestrictedDouble::setString(String value)
{
    ASSERT(isNull());
    m_string = value;
    m_type = SpecificTypeString;
}

double BooleanOrStringOrUnrestrictedDouble::getAsUnrestrictedDouble()
{
    ASSERT(isUnrestrictedDouble());
    return m_unrestrictedDouble;
}

void BooleanOrStringOrUnrestrictedDouble::setUnrestrictedDouble(double value)
{
    ASSERT(isNull());
    m_unrestrictedDouble = value;
    m_type = SpecificTypeUnrestrictedDouble;
}

void V8BooleanOrStringOrUnrestrictedDouble::toImpl(v8::Isolate* isolate, v8::Handle<v8::Value> v8Value, BooleanOrStringOrUnrestrictedDouble& impl, ExceptionState& exceptionState)
{
    if (v8Value.IsEmpty())
        return;

    if (v8Value->IsBoolean()) {
        impl.setBoolean(v8Value->ToBoolean()->Value());
        return;
    }

    if (v8Value->IsNumber()) {
        TONATIVE_VOID_EXCEPTIONSTATE(double, cppValue, toDouble(v8Value, exceptionState), exceptionState);
        impl.setUnrestrictedDouble(cppValue);
        return;
    }

    {
        TOSTRING_VOID_EXCEPTIONSTATE(V8StringResource<>, cppValue, v8Value, exceptionState);
        impl.setString(cppValue);
        return;
    }

    exceptionState.throwTypeError("Not a valid union member.");
}

v8::Handle<v8::Value> toV8(BooleanOrStringOrUnrestrictedDouble& impl, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate)
{
    if (impl.isNull())
        return v8::Null(isolate);

    if (impl.isBoolean())
        return v8Boolean(impl.getAsBoolean(), isolate);

    if (impl.isString())
        return v8String(isolate, impl.getAsString());

    if (impl.isUnrestrictedDouble())
        return v8::Number::New(isolate, impl.getAsUnrestrictedDouble());

    ASSERT_NOT_REACHED();
    return v8::Handle<v8::Value>();
}

NodeOrNodeList::NodeOrNodeList()
    : m_type(SpecificTypeNone)
{
}

PassRefPtrWillBeRawPtr<Node> NodeOrNodeList::getAsNode()
{
    ASSERT(isNode());
    return m_node;
}

void NodeOrNodeList::setNode(PassRefPtrWillBeRawPtr<Node> value)
{
    ASSERT(isNull());
    m_node = value;
    m_type = SpecificTypeNode;
}

PassRefPtrWillBeRawPtr<NodeList> NodeOrNodeList::getAsNodeList()
{
    ASSERT(isNodeList());
    return m_nodeList;
}

void NodeOrNodeList::setNodeList(PassRefPtrWillBeRawPtr<NodeList> value)
{
    ASSERT(isNull());
    m_nodeList = value;
    m_type = SpecificTypeNodeList;
}

void NodeOrNodeList::trace(Visitor* visitor)
{
    visitor->trace(m_node);
    visitor->trace(m_nodeList);
}

void V8NodeOrNodeList::toImpl(v8::Isolate* isolate, v8::Handle<v8::Value> v8Value, NodeOrNodeList& impl, ExceptionState& exceptionState)
{
    if (v8Value.IsEmpty())
        return;

    if (V8Node::hasInstance(v8Value, isolate)) {
        RefPtrWillBeRawPtr<Node> cppValue = V8Node::toImpl(v8::Handle<v8::Object>::Cast(v8Value));
        impl.setNode(cppValue);
        return;
    }

    if (V8NodeList::hasInstance(v8Value, isolate)) {
        RefPtrWillBeRawPtr<NodeList> cppValue = V8NodeList::toImpl(v8::Handle<v8::Object>::Cast(v8Value));
        impl.setNodeList(cppValue);
        return;
    }

    exceptionState.throwTypeError("Not a valid union member.");
}

v8::Handle<v8::Value> toV8(NodeOrNodeList& impl, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate)
{
    if (impl.isNull())
        return v8::Null(isolate);

    if (impl.isNode())
        return toV8(impl.getAsNode(), creationContext, isolate);

    if (impl.isNodeList())
        return toV8(impl.getAsNodeList(), creationContext, isolate);

    ASSERT_NOT_REACHED();
    return v8::Handle<v8::Value>();
}

StringOrDouble::StringOrDouble()
    : m_type(SpecificTypeNone)
{
}

String StringOrDouble::getAsString()
{
    ASSERT(isString());
    return m_string;
}

void StringOrDouble::setString(String value)
{
    ASSERT(isNull());
    m_string = value;
    m_type = SpecificTypeString;
}

double StringOrDouble::getAsDouble()
{
    ASSERT(isDouble());
    return m_double;
}

void StringOrDouble::setDouble(double value)
{
    ASSERT(isNull());
    m_double = value;
    m_type = SpecificTypeDouble;
}

void V8StringOrDouble::toImpl(v8::Isolate* isolate, v8::Handle<v8::Value> v8Value, StringOrDouble& impl, ExceptionState& exceptionState)
{
    if (v8Value.IsEmpty())
        return;

    if (v8Value->IsNumber()) {
        TONATIVE_VOID_EXCEPTIONSTATE(double, cppValue, toDouble(v8Value, exceptionState), exceptionState);
        impl.setDouble(cppValue);
        return;
    }

    {
        TOSTRING_VOID_EXCEPTIONSTATE(V8StringResource<>, cppValue, v8Value, exceptionState);
        impl.setString(cppValue);
        return;
    }

    exceptionState.throwTypeError("Not a valid union member.");
}

v8::Handle<v8::Value> toV8(StringOrDouble& impl, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate)
{
    if (impl.isNull())
        return v8::Null(isolate);

    if (impl.isString())
        return v8String(isolate, impl.getAsString());

    if (impl.isDouble())
        return v8::Number::New(isolate, impl.getAsDouble());

    ASSERT_NOT_REACHED();
    return v8::Handle<v8::Value>();
}

TestInterfaceGarbageCollectedOrString::TestInterfaceGarbageCollectedOrString()
    : m_type(SpecificTypeNone)
{
}

RawPtr<TestInterfaceGarbageCollected> TestInterfaceGarbageCollectedOrString::getAsTestInterfaceGarbageCollected()
{
    ASSERT(isTestInterfaceGarbageCollected());
    return m_testInterfaceGarbageCollected;
}

void TestInterfaceGarbageCollectedOrString::setTestInterfaceGarbageCollected(RawPtr<TestInterfaceGarbageCollected> value)
{
    ASSERT(isNull());
    m_testInterfaceGarbageCollected = value;
    m_type = SpecificTypeTestInterfaceGarbageCollected;
}

String TestInterfaceGarbageCollectedOrString::getAsString()
{
    ASSERT(isString());
    return m_string;
}

void TestInterfaceGarbageCollectedOrString::setString(String value)
{
    ASSERT(isNull());
    m_string = value;
    m_type = SpecificTypeString;
}

void TestInterfaceGarbageCollectedOrString::trace(Visitor* visitor)
{
    visitor->trace(m_testInterfaceGarbageCollected);
}

void V8TestInterfaceGarbageCollectedOrString::toImpl(v8::Isolate* isolate, v8::Handle<v8::Value> v8Value, TestInterfaceGarbageCollectedOrString& impl, ExceptionState& exceptionState)
{
    if (v8Value.IsEmpty())
        return;

    if (V8TestInterfaceGarbageCollected::hasInstance(v8Value, isolate)) {
        RawPtr<TestInterfaceGarbageCollected> cppValue = V8TestInterfaceGarbageCollected::toImpl(v8::Handle<v8::Object>::Cast(v8Value));
        impl.setTestInterfaceGarbageCollected(cppValue);
        return;
    }

    {
        TOSTRING_VOID_EXCEPTIONSTATE(V8StringResource<>, cppValue, v8Value, exceptionState);
        impl.setString(cppValue);
        return;
    }

    exceptionState.throwTypeError("Not a valid union member.");
}

v8::Handle<v8::Value> toV8(TestInterfaceGarbageCollectedOrString& impl, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate)
{
    if (impl.isNull())
        return v8::Null(isolate);

    if (impl.isTestInterfaceGarbageCollected())
        return toV8(impl.getAsTestInterfaceGarbageCollected(), creationContext, isolate);

    if (impl.isString())
        return v8String(isolate, impl.getAsString());

    ASSERT_NOT_REACHED();
    return v8::Handle<v8::Value>();
}

TestInterfaceOrLong::TestInterfaceOrLong()
    : m_type(SpecificTypeNone)
{
}

PassRefPtr<TestInterfaceImplementation> TestInterfaceOrLong::getAsTestInterface()
{
    ASSERT(isTestInterface());
    return m_testInterface;
}

void TestInterfaceOrLong::setTestInterface(PassRefPtr<TestInterfaceImplementation> value)
{
    ASSERT(isNull());
    m_testInterface = value;
    m_type = SpecificTypeTestInterface;
}

int TestInterfaceOrLong::getAsLong()
{
    ASSERT(isLong());
    return m_long;
}

void TestInterfaceOrLong::setLong(int value)
{
    ASSERT(isNull());
    m_long = value;
    m_type = SpecificTypeLong;
}

void V8TestInterfaceOrLong::toImpl(v8::Isolate* isolate, v8::Handle<v8::Value> v8Value, TestInterfaceOrLong& impl, ExceptionState& exceptionState)
{
    if (v8Value.IsEmpty())
        return;

    if (V8TestInterface::hasInstance(v8Value, isolate)) {
        RefPtr<TestInterfaceImplementation> cppValue = V8TestInterface::toImpl(v8::Handle<v8::Object>::Cast(v8Value));
        impl.setTestInterface(cppValue);
        return;
    }

    if (v8Value->IsNumber()) {
        TONATIVE_VOID_EXCEPTIONSTATE(int, cppValue, toInt32(v8Value, exceptionState), exceptionState);
        impl.setLong(cppValue);
        return;
    }

    {
        TONATIVE_VOID_EXCEPTIONSTATE(int, cppValue, toInt32(v8Value, exceptionState), exceptionState);
        impl.setLong(cppValue);
        return;
    }

    exceptionState.throwTypeError("Not a valid union member.");
}

v8::Handle<v8::Value> toV8(TestInterfaceOrLong& impl, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate)
{
    if (impl.isNull())
        return v8::Null(isolate);

    if (impl.isTestInterface())
        return toV8(impl.getAsTestInterface(), creationContext, isolate);

    if (impl.isLong())
        return v8::Integer::New(isolate, impl.getAsLong());

    ASSERT_NOT_REACHED();
    return v8::Handle<v8::Value>();
}

TestInterfaceOrTestInterfaceEmpty::TestInterfaceOrTestInterfaceEmpty()
    : m_type(SpecificTypeNone)
{
}

PassRefPtr<TestInterfaceImplementation> TestInterfaceOrTestInterfaceEmpty::getAsTestInterface()
{
    ASSERT(isTestInterface());
    return m_testInterface;
}

void TestInterfaceOrTestInterfaceEmpty::setTestInterface(PassRefPtr<TestInterfaceImplementation> value)
{
    ASSERT(isNull());
    m_testInterface = value;
    m_type = SpecificTypeTestInterface;
}

PassRefPtr<TestInterfaceEmpty> TestInterfaceOrTestInterfaceEmpty::getAsTestInterfaceEmpty()
{
    ASSERT(isTestInterfaceEmpty());
    return m_testInterfaceEmpty;
}

void TestInterfaceOrTestInterfaceEmpty::setTestInterfaceEmpty(PassRefPtr<TestInterfaceEmpty> value)
{
    ASSERT(isNull());
    m_testInterfaceEmpty = value;
    m_type = SpecificTypeTestInterfaceEmpty;
}

void V8TestInterfaceOrTestInterfaceEmpty::toImpl(v8::Isolate* isolate, v8::Handle<v8::Value> v8Value, TestInterfaceOrTestInterfaceEmpty& impl, ExceptionState& exceptionState)
{
    if (v8Value.IsEmpty())
        return;

    if (V8TestInterface::hasInstance(v8Value, isolate)) {
        RefPtr<TestInterfaceImplementation> cppValue = V8TestInterface::toImpl(v8::Handle<v8::Object>::Cast(v8Value));
        impl.setTestInterface(cppValue);
        return;
    }

    if (V8TestInterfaceEmpty::hasInstance(v8Value, isolate)) {
        RefPtr<TestInterfaceEmpty> cppValue = V8TestInterfaceEmpty::toImpl(v8::Handle<v8::Object>::Cast(v8Value));
        impl.setTestInterfaceEmpty(cppValue);
        return;
    }

    exceptionState.throwTypeError("Not a valid union member.");
}

v8::Handle<v8::Value> toV8(TestInterfaceOrTestInterfaceEmpty& impl, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate)
{
    if (impl.isNull())
        return v8::Null(isolate);

    if (impl.isTestInterface())
        return toV8(impl.getAsTestInterface(), creationContext, isolate);

    if (impl.isTestInterfaceEmpty())
        return toV8(impl.getAsTestInterfaceEmpty(), creationContext, isolate);

    ASSERT_NOT_REACHED();
    return v8::Handle<v8::Value>();
}

TestInterfaceWillBeGarbageCollectedOrTestDictionary::TestInterfaceWillBeGarbageCollectedOrTestDictionary()
    : m_type(SpecificTypeNone)
{
}

PassRefPtrWillBeRawPtr<TestInterfaceWillBeGarbageCollected> TestInterfaceWillBeGarbageCollectedOrTestDictionary::getAsTestInterfaceWillBeGarbageCollected()
{
    ASSERT(isTestInterfaceWillBeGarbageCollected());
    return m_testInterfaceWillBeGarbageCollected;
}

void TestInterfaceWillBeGarbageCollectedOrTestDictionary::setTestInterfaceWillBeGarbageCollected(PassRefPtrWillBeRawPtr<TestInterfaceWillBeGarbageCollected> value)
{
    ASSERT(isNull());
    m_testInterfaceWillBeGarbageCollected = value;
    m_type = SpecificTypeTestInterfaceWillBeGarbageCollected;
}

TestDictionary TestInterfaceWillBeGarbageCollectedOrTestDictionary::getAsTestDictionary()
{
    ASSERT(isTestDictionary());
    return m_testDictionary;
}

void TestInterfaceWillBeGarbageCollectedOrTestDictionary::setTestDictionary(TestDictionary value)
{
    ASSERT(isNull());
    m_testDictionary = value;
    m_type = SpecificTypeTestDictionary;
}

void TestInterfaceWillBeGarbageCollectedOrTestDictionary::trace(Visitor* visitor)
{
    visitor->trace(m_testInterfaceWillBeGarbageCollected);
}

void V8TestInterfaceWillBeGarbageCollectedOrTestDictionary::toImpl(v8::Isolate* isolate, v8::Handle<v8::Value> v8Value, TestInterfaceWillBeGarbageCollectedOrTestDictionary& impl, ExceptionState& exceptionState)
{
    if (v8Value.IsEmpty())
        return;

    if (V8TestInterfaceWillBeGarbageCollected::hasInstance(v8Value, isolate)) {
        RefPtrWillBeRawPtr<TestInterfaceWillBeGarbageCollected> cppValue = V8TestInterfaceWillBeGarbageCollected::toImpl(v8::Handle<v8::Object>::Cast(v8Value));
        impl.setTestInterfaceWillBeGarbageCollected(cppValue);
        return;
    }

    if (isUndefinedOrNull(v8Value) || v8Value->IsObject()) {
        TestDictionary cppValue = V8TestDictionary::toImpl(isolate, v8Value, exceptionState);
        if (!exceptionState.hadException())
            impl.setTestDictionary(cppValue);
        return;
    }

    exceptionState.throwTypeError("Not a valid union member.");
}

v8::Handle<v8::Value> toV8(TestInterfaceWillBeGarbageCollectedOrTestDictionary& impl, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate)
{
    if (impl.isNull())
        return v8::Null(isolate);

    if (impl.isTestInterfaceWillBeGarbageCollected())
        return toV8(impl.getAsTestInterfaceWillBeGarbageCollected(), creationContext, isolate);

    if (impl.isTestDictionary())
        return toV8(impl.getAsTestDictionary(), creationContext, isolate);

    ASSERT_NOT_REACHED();
    return v8::Handle<v8::Value>();
}

} // namespace blink