/* THIS FILE IS AUTOGENERATED - DO NOT EDIT */

#![allow(non_camel_case_types,non_upper_case_globals,unused_imports,unused_variables,unused_assignments,unused_mut,clippy::approx_constant,clippy::let_unit_value,clippy::needless_return,clippy::too_many_arguments,clippy::unnecessary_cast,clippy::upper_case_acronyms)]

use crate::dom::bindings::import::base::*;

pub use self::DynamicModuleOwner_Binding::{Wrap, DynamicModuleOwnerMethods, GetProtoObject};
pub mod DynamicModuleOwner_Binding {
use crate::dom;
use crate::dom::bindings::import::module::*;
use crate::dom::promise::Promise;
use crate::dom::types::DynamicModuleOwner;

unsafe extern fn get_promise(cx: *mut JSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool {
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let cx = SafeJSContext::from_ptr(cx);
        let this = &*(this as *const DynamicModuleOwner);
        let result: Rc<Promise> = this.Promise();

        (result).to_jsval(*cx, MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


const promise_getterinfo: JSJitInfo = JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_promise)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::DynamicModuleOwner as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_OBJECT as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
};

unsafe extern fn _finalize(_cx: *mut GCContext, obj: *mut JSObject) {
    wrap_panic(&mut || {

        let this = native_from_object_static::<DynamicModuleOwner>(obj).unwrap();
        finalize_common(this);
    })
}

unsafe extern fn _trace(trc: *mut JSTracer, obj: *mut JSObject) {
    wrap_panic(&mut || {

        let this = native_from_object_static::<DynamicModuleOwner>(obj).unwrap();
        if this.is_null() { return; } // GC during obj creation
        (*this).trace(trc);
    })
}

static CLASS_OPS: JSClassOps = JSClassOps {
    addProperty: None,
    delProperty: None,
    enumerate: None,
    newEnumerate: None,
    resolve: None,
    mayResolve: None,
    finalize: Some(_finalize),
    call: None,
    construct: None,
    trace: Some(_trace),
};

static Class: DOMJSClass = DOMJSClass {
    base: JSClass {
        name: b"DynamicModuleOwner\0" as *const u8 as *const libc::c_char,
        flags: JSCLASS_IS_DOMJSCLASS | JSCLASS_FOREGROUND_FINALIZE |
               (((1) & JSCLASS_RESERVED_SLOTS_MASK) << JSCLASS_RESERVED_SLOTS_SHIFT)
               /* JSCLASS_HAS_RESERVED_SLOTS(1) */,
        cOps: &CLASS_OPS,
        spec: ptr::null(),
        ext: ptr::null(),
        oOps: ptr::null(),
    },
    dom_class: DOMClass {
    interface_chain: [ PrototypeList::ID::DynamicModuleOwner, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last ],
    depth: 0,
    type_id: crate::dom::bindings::codegen::InheritTypes::TopTypeId { alone: () },
    malloc_size_of: malloc_size_of_including_raw_self::<DynamicModuleOwner> as unsafe fn(&mut _, _) -> _,
    global: InterfaceObjectMap::Globals::EMPTY,
}
};

impl DynamicModuleOwner {
    fn __assert_parent_type(&self) {
        use crate::dom::bindings::inheritance::HasParent;
        // If this type assertion fails, make sure the first field of your
        // DOM struct is of the correct type -- it must be the parent class.
        let _: &Reflector = self.as_parent();
    }
}

pub unsafe fn Wrap(cx: SafeJSContext, scope: &GlobalScope, given_proto: Option<HandleObject>, object: Box<DynamicModuleOwner>) -> DomRoot<DynamicModuleOwner> {
    let raw = Root::new(MaybeUnreflectedDom::from_box(object));

    let scope = scope.reflector().get_jsobject();
    assert!(!scope.get().is_null());
    assert!(((*get_object_class(scope.get())).flags & JSCLASS_IS_GLOBAL) != 0);
    let _ac = JSAutoRealm::new(*cx, scope.get());

    rooted!(in(*cx) let mut canonical_proto = ptr::null_mut::<JSObject>());
    GetProtoObject(cx, scope, canonical_proto.handle_mut());
    assert!(!canonical_proto.is_null());


    rooted!(in(*cx) let mut proto = ptr::null_mut::<JSObject>());
    if let Some(given) = given_proto {
        *proto = *given;
        if get_context_realm(*cx) != get_object_realm(*given) {
            assert!(JS_WrapObject(*cx, proto.handle_mut()));
        }
    } else {
        *proto = *canonical_proto;
    }
    rooted!(in(*cx) let obj = JS_NewObjectWithGivenProto(
        *cx,
        &Class.base,
        proto.handle(),
    ));
    assert!(!obj.is_null());
    JS_SetReservedSlot(
        obj.get(),
        DOM_OBJECT_SLOT,
        &PrivateValue(raw.as_ptr() as *const libc::c_void),
    );

    let root = raw.reflect_with(obj.get());



    DomRoot::from_ref(&*root)
}

impl DomObjectWrap for dom::dynamicmoduleowner::DynamicModuleOwner {
    const WRAP: unsafe fn(
        SafeJSContext,
        &GlobalScope,
        Option<HandleObject>,
        Box<Self>,
    ) -> Root<Dom<Self>> = Wrap;
}

impl IDLInterface for DynamicModuleOwner {
    #[inline]
    fn derives(class: &'static DOMClass) -> bool {
        ptr::eq(class, &Class.dom_class)
    }
}

impl PartialEq for DynamicModuleOwner {
    fn eq(&self, other: &DynamicModuleOwner) -> bool {
        self as *const DynamicModuleOwner == other
    }
}

pub trait DynamicModuleOwnerMethods {
    fn Promise(&self) -> Rc<Promise>;
}
const sAttributes_specs: &[&[JSPropertySpec]] = &[
&[
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: b"promise\0" as *const u8 as *const libc::c_char },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter), info: &promise_getterinfo },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: 0 as *const JSJitInfo },
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]
,
&[
    JSPropertySpec {
                    name: JSPropertySpec_Name { symbol_: SymbolCode::toStringTag as usize + 1 },
                    attributes_: (JSPROP_READONLY),
                    kind_: (JSPropertySpec_Kind::Value),
                    u: JSPropertySpec_AccessorsOrValue {
                        value: JSPropertySpec_ValueWrapper {
                            type_: JSPropertySpec_ValueWrapper_Type::String,
                            __bindgen_anon_1: JSPropertySpec_ValueWrapper__bindgen_ty_1 {
                                string: b"DynamicModuleOwner\0" as *const u8 as *const libc::c_char,
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]

];
const sAttributes: &[Guard<&[JSPropertySpec]>] = &[
    Guard::new(Condition::Exposed(InterfaceObjectMap::Globals::WINDOW), sAttributes_specs[0]),
    Guard::new(Condition::Satisfied, sAttributes_specs[1])
];

pub fn GetProtoObject(cx: SafeJSContext, global: HandleObject, mut rval: MutableHandleObject) {
    /* Get the interface prototype object for this class.  This will create the
       object as needed. */
            get_per_interface_object_handle(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::DynamicModuleOwner), CreateInterfaceObjects, rval)

}

static PrototypeClass: JSClass = JSClass {
    name: b"DynamicModuleOwnerPrototype\0" as *const u8 as *const libc::c_char,
    flags:
        // JSCLASS_HAS_RESERVED_SLOTS(0)
        (0 ) << JSCLASS_RESERVED_SLOTS_SHIFT,
    cOps: 0 as *const _,
    spec: ptr::null(),
    ext: ptr::null(),
    oOps: ptr::null(),
};

unsafe fn CreateInterfaceObjects(cx: SafeJSContext, global: HandleObject, cache: *mut ProtoOrIfaceArray) {
    rooted!(in(*cx) let mut prototype_proto = ptr::null_mut::<JSObject>());
    prototype_proto.set(GetRealmObjectPrototype(*cx));
    assert!(!prototype_proto.is_null());

    rooted!(in(*cx) let mut prototype = ptr::null_mut::<JSObject>());
    create_interface_prototype_object(cx,
                                      global,
                                      prototype_proto.handle(),
                                      &PrototypeClass,
                                      &[],
                                      sAttributes,
                                      &[],
                                      &[],
                                      prototype.handle_mut());
    assert!(!prototype.is_null());
    assert!((*cache)[PrototypeList::ID::DynamicModuleOwner as usize].is_null());
    (*cache)[PrototypeList::ID::DynamicModuleOwner as usize] = prototype.get();
    <*mut JSObject>::post_barrier((*cache).as_mut_ptr().offset(PrototypeList::ID::DynamicModuleOwner as isize),
                                  ptr::null_mut(),
                                  prototype.get());

}
} // mod DynamicModuleOwner_Binding