mirror of
https://github.com/servo/servo.git
synced 2025-08-03 04:30:10 +01:00
Introduce trait Castable
This trait is used to hold onto the downcast and upcast functions of all castable IDL interfaces. A castable IDL interface is one which either derives from or is derived by other interfaces. The deriving relation is represented by implementations of marker trait DerivedFrom<T: Castable> generated in InheritTypes. /^[ ]*use dom::bindings::codegen::InheritTypes::.*(Base|Cast|Derived)/ { /::[a-zA-Z]+(Base|Cast|Derived);/d s/([{ ])[a-zA-Z]+(Base|Cast|Derived), /\1/g s/([{ ])[a-zA-Z]+(Base|Cast|Derived), /\1/g s/, [a-zA-Z]+(Base|Cast|Derived)([},])/\2/g s/, [a-zA-Z]+(Base|Cast|Derived)([},])/\2/g /\{([a-zA-Z]+(Base|Cast|Derived))?\};$/d s/\{([a-zA-Z_]+)\};$/\1;/ } s/([a-zA-Z]+)Cast::from_ref\(\&?\**([a-zA-Z_]+)(\.r\(\))?\)/\2.upcast::<\1>()/g s/([a-zA-Z]+)Cast::from_ref\(\&?\**([a-zA-Z_]+)(\.[a-zA-Z_]+\(\))?\)/\2\3.upcast::<\1>()/g s/\(([a-zA-Z]+)Cast::from_ref\)/\(Castable::upcast::<\1>\)/g s/([a-zA-Z]+)Cast::from_root/Root::upcast::<\1>/g s/([a-zA-Z]+)Cast::from_layout_js\(\&([a-zA-Z_.]+)\)/\2.upcast::<\1>()/g s/([a-zA-Z]+)Cast::to_ref\(\&?\**([a-zA-Z_]+)(\.r\(\))?\)/\2.downcast::<\1>()/g s/([a-zA-Z]+)Cast::to_ref\(\&?\**([a-zA-Z_]+)(\.[a-zA-Z_]+\(\))?\)/\2\3.downcast::<\1>()/g s/\(([a-zA-Z]+)Cast::to_ref\)/\(Castable::downcast::<\1>\)/g s/([a-zA-Z]+)Cast::to_root/Root::downcast::<\1>/g s/([a-zA-Z]+)Cast::to_layout_js\(&?([a-zA-Z_.]+(\(\))?)\)/\2.downcast::<\1>()/g s/\.is_document\(\)/.is::<Document>()/g s/\.is_htmlanchorelement\(\)/.is::<HTMLAnchorElement>()/g s/\.is_htmlappletelement\(\)/.is::<HTMLAppletElement>()/g s/\.is_htmlareaelement\(\)/.is::<HTMLAreaElement>()/g s/\.is_htmlbodyelement\(\)/.is::<HTMLBodyElement>()/g s/\.is_htmlembedelement\(\)/.is::<HTMLEmbedElement>()/g s/\.is_htmlfieldsetelement\(\)/.is::<HTMLFieldSetElement>()/g s/\.is_htmlformelement\(\)/.is::<HTMLFormElement>()/g s/\.is_htmlframesetelement\(\)/.is::<HTMLFrameSetElement>()/g s/\.is_htmlhtmlelement\(\)/.is::<HTMLHtmlElement>()/g s/\.is_htmlimageelement\(\)/.is::<HTMLImageElement>()/g s/\.is_htmllegendelement\(\)/.is::<HTMLLegendElement>()/g s/\.is_htmloptgroupelement\(\)/.is::<HTMLOptGroupElement>()/g s/\.is_htmloptionelement\(\)/.is::<HTMLOptionElement>()/g s/\.is_htmlscriptelement\(\)/.is::<HTMLScriptElement>()/g s/\.is_htmltabledatacellelement\(\)/.is::<HTMLTableDataCellElement>()/g s/\.is_htmltableheadercellelement\(\)/.is::<HTMLTableHeaderCellElement>()/g s/\.is_htmltablerowelement\(\)/.is::<HTMLTableRowElement>()/g s/\.is_htmltablesectionelement\(\)/.is::<HTMLTableSectionElement>()/g s/\.is_htmltitleelement\(\)/.is::<HTMLTitleElement>()/g
This commit is contained in:
parent
bd363b009d
commit
13ea3ac413
82 changed files with 1124 additions and 1148 deletions
|
@ -5824,7 +5824,7 @@ class GlobalGenRoots():
|
|||
|
||||
descriptors = config.getDescriptors(register=True, isCallback=False)
|
||||
imports = [CGGeneric("use dom::types::*;\n"),
|
||||
CGGeneric("use dom::bindings::conversions::{IDLInterface, get_dom_class};\n"),
|
||||
CGGeneric("use dom::bindings::conversions::{Castable, DerivedFrom, get_dom_class};\n"),
|
||||
CGGeneric("use dom::bindings::js::{JS, LayoutJS, Root};\n"),
|
||||
CGGeneric("use dom::bindings::trace::JSTraceable;\n"),
|
||||
CGGeneric("use dom::bindings::utils::Reflectable;\n"),
|
||||
|
@ -5839,131 +5839,24 @@ class GlobalGenRoots():
|
|||
upcast = descriptor.hasDescendants()
|
||||
downcast = len(chain) != 1
|
||||
|
||||
if upcast or downcast:
|
||||
# Define a dummy structure to hold the cast functions.
|
||||
allprotos.append(CGGeneric("pub struct %sCast;\n\n" % name))
|
||||
|
||||
if upcast and not downcast:
|
||||
topTypes.append(name)
|
||||
|
||||
if upcast:
|
||||
# Define a `FooBase` trait for subclasses to implement, as well as the
|
||||
# `FooCast::from_*` methods that use it.
|
||||
allprotos.append(CGGeneric("""\
|
||||
/// Types which are derived from `%(name)s` and can be freely converted
|
||||
/// to `%(name)s`
|
||||
pub trait %(baseTrait)s: Sized {}
|
||||
if not upcast:
|
||||
# No other interface will implement DeriveFrom<Foo> for this Foo, so avoid
|
||||
# implementing it for itself.
|
||||
chain = chain[:-1]
|
||||
|
||||
impl %(name)sCast {
|
||||
#[inline]
|
||||
/// Upcast an instance of a derived class of `%(name)s` to `%(name)s`
|
||||
pub fn from_ref<T: %(baseTrait)s + Reflectable>(derived: &T) -> &%(name)s {
|
||||
unsafe { mem::transmute(derived) }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
#[allow(unrooted_must_root)]
|
||||
pub fn from_layout_js<T: %(baseTrait)s + Reflectable>(derived: &LayoutJS<T>) -> LayoutJS<%(name)s> {
|
||||
unsafe { mem::transmute_copy(derived) }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn from_root<T: %(baseTrait)s + Reflectable>(derived: Root<T>) -> Root<%(name)s> {
|
||||
unsafe { mem::transmute(derived) }
|
||||
}
|
||||
}
|
||||
|
||||
""" % {'baseTrait': name + 'Base', 'name': name}))
|
||||
else:
|
||||
# The `FooBase` trait is not defined, so avoid implementing it by
|
||||
# removing `Foo` itself from the chain.
|
||||
chain = descriptor.prototypeChain[:-1]
|
||||
|
||||
# Implement `BarBase` for `Foo`, for all `Bar` that `Foo` inherits from.
|
||||
# Implement `DerivedFrom<Bar>` for `Foo`, for all `Bar` that `Foo` inherits from.
|
||||
if chain:
|
||||
allprotos.append(CGGeneric("impl Castable for %s {}\n" % name))
|
||||
for baseName in chain:
|
||||
allprotos.append(CGGeneric("impl %s for %s {}\n" % (baseName + 'Base', name)))
|
||||
allprotos.append(CGGeneric("impl DerivedFrom<%s> for %s {}\n" % (baseName, name)))
|
||||
if chain:
|
||||
allprotos.append(CGGeneric("\n"))
|
||||
|
||||
if downcast:
|
||||
hierarchy[descriptor.getParentName()].append(name)
|
||||
# Define a `FooDerived` trait for superclasses to implement,
|
||||
# as well as the `FooCast::to_*` methods that use it.
|
||||
baseName = descriptor.prototypeChain[0]
|
||||
args = {
|
||||
'baseName': baseName,
|
||||
'derivedTrait': name + 'Derived',
|
||||
'methodName': 'is_' + name.lower(),
|
||||
'name': name,
|
||||
}
|
||||
allprotos.append(CGGeneric("""\
|
||||
/// Types which `%(name)s` derives from
|
||||
pub trait %(derivedTrait)s: Sized {
|
||||
fn %(methodName)s(&self) -> bool;
|
||||
}
|
||||
|
||||
impl %(name)sCast {
|
||||
#[inline]
|
||||
/// Downcast an instance of a base class of `%(name)s` to an instance of
|
||||
/// `%(name)s`, if it internally is an instance of `%(name)s`
|
||||
pub fn to_ref<T: %(derivedTrait)s + Reflectable>(base: &T) -> Option<&%(name)s> {
|
||||
match base.%(methodName)s() {
|
||||
true => Some(unsafe { mem::transmute(base) }),
|
||||
false => None
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
#[allow(unrooted_must_root)]
|
||||
pub fn to_layout_js<T: %(derivedTrait)s + Reflectable>(base: &LayoutJS<T>) -> Option<LayoutJS<%(name)s>> {
|
||||
unsafe {
|
||||
match (*base.unsafe_get()).%(methodName)s() {
|
||||
true => Some(mem::transmute_copy(base)),
|
||||
false => None
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn to_root<T: %(derivedTrait)s + Reflectable>(base: Root<T>) -> Option<Root<%(name)s>> {
|
||||
match base.%(methodName)s() {
|
||||
true => Some(unsafe { mem::transmute(base) }),
|
||||
false => None
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl %(derivedTrait)s for %(baseName)s {
|
||||
fn %(methodName)s(&self) -> bool {
|
||||
let dom_class = unsafe {
|
||||
get_dom_class(self.reflector().get_jsobject().get()).unwrap()
|
||||
};
|
||||
%(name)s::derives(dom_class)
|
||||
}
|
||||
}
|
||||
|
||||
""" % args))
|
||||
|
||||
# Implement the `FooDerived` trait for non-root superclasses by deferring to
|
||||
# the direct superclass. This leaves the implementation of the `FooDerived`
|
||||
# trait for the root superclass to manual code. `FooDerived` is not
|
||||
# implemented for `Foo` itself.
|
||||
for baseName in descriptor.prototypeChain[1:-1]:
|
||||
args = {
|
||||
'baseName': baseName,
|
||||
'derivedTrait': name + 'Derived',
|
||||
'methodName': 'is_' + name.lower(),
|
||||
'parentName': config.getDescriptor(baseName).getParentName(),
|
||||
}
|
||||
allprotos.append(CGGeneric("""\
|
||||
impl %(derivedTrait)s for %(baseName)s {
|
||||
#[inline]
|
||||
fn %(methodName)s(&self) -> bool {
|
||||
%(parentName)sCast::from_ref(self).%(methodName)s()
|
||||
}
|
||||
}
|
||||
|
||||
""" % args))
|
||||
|
||||
typeIdCode = []
|
||||
topTypeVariants = [
|
||||
|
|
|
@ -55,6 +55,7 @@ use libc;
|
|||
use num::Float;
|
||||
use num::traits::{Bounded, Zero};
|
||||
use std::borrow::ToOwned;
|
||||
use std::mem;
|
||||
use std::rc::Rc;
|
||||
use std::{char, ptr, slice};
|
||||
use util::str::DOMString;
|
||||
|
@ -106,6 +107,36 @@ pub trait IDLInterface {
|
|||
fn derives(&'static DOMClass) -> bool;
|
||||
}
|
||||
|
||||
/// A trait to hold the cast functions of IDL interfaces that either derive
|
||||
/// or are derived from other interfaces.
|
||||
pub trait Castable: IDLInterface + Reflectable + Sized {
|
||||
/// Check whether a DOM object implements one of its deriving interfaces.
|
||||
fn is<T>(&self) -> bool where T: DerivedFrom<Self> {
|
||||
let class = unsafe {
|
||||
get_dom_class(self.reflector().get_jsobject().get()).unwrap()
|
||||
};
|
||||
T::derives(class)
|
||||
}
|
||||
|
||||
/// Cast a DOM object upwards to one of the interfaces it derives from.
|
||||
fn upcast<T>(&self) -> &T where T: Castable, Self: DerivedFrom<T> {
|
||||
unsafe { mem::transmute(self) }
|
||||
}
|
||||
|
||||
/// Cast a DOM object downwards to one of the interfaces it might implement.
|
||||
fn downcast<T>(&self) -> Option<&T> where T: DerivedFrom<Self> {
|
||||
if self.is::<T>() {
|
||||
Some(unsafe { mem::transmute(self) })
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// A trait to mark an IDL interface as deriving from another one.
|
||||
#[rustc_on_unimplemented = "The IDL interface `{Self}` is not derived from `{T}`."]
|
||||
pub trait DerivedFrom<T: Castable>: Castable {}
|
||||
|
||||
/// A trait to convert Rust types to `JSVal`s.
|
||||
pub trait ToJSValConvertible {
|
||||
/// Convert `self` to a `JSVal`. JSAPI failure causes a task failure.
|
||||
|
|
|
@ -24,6 +24,7 @@
|
|||
//!
|
||||
|
||||
use core::nonzero::NonZero;
|
||||
use dom::bindings::conversions::{Castable, DerivedFrom};
|
||||
use dom::bindings::trace::JSTraceable;
|
||||
use dom::bindings::trace::trace_reflector;
|
||||
use dom::bindings::utils::{Reflectable, Reflector};
|
||||
|
@ -34,6 +35,7 @@ use layout_interface::TrustedNodeAddress;
|
|||
use script_task::STACK_ROOTS;
|
||||
use std::cell::UnsafeCell;
|
||||
use std::default::Default;
|
||||
use std::mem;
|
||||
use std::ops::Deref;
|
||||
use std::ptr;
|
||||
use util::mem::HeapSizeOf;
|
||||
|
@ -119,6 +121,24 @@ pub struct LayoutJS<T> {
|
|||
ptr: NonZero<*const T>
|
||||
}
|
||||
|
||||
impl<T: Castable> LayoutJS<T> {
|
||||
/// Cast a DOM object root upwards to one of the interfaces it derives from.
|
||||
pub fn upcast<U>(&self) -> LayoutJS<U> where U: Castable, T: DerivedFrom<U> {
|
||||
unsafe { mem::transmute_copy(self) }
|
||||
}
|
||||
|
||||
/// Cast a DOM object downwards to one of the interfaces it might implement.
|
||||
pub fn downcast<U>(&self) -> Option<LayoutJS<U>> where U: DerivedFrom<T> {
|
||||
unsafe {
|
||||
if (*self.unsafe_get()).is::<U>() {
|
||||
Some(mem::transmute_copy(self))
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: Reflectable> LayoutJS<T> {
|
||||
/// Get the reflector.
|
||||
pub unsafe fn get_jsobject(&self) -> *mut JSObject {
|
||||
|
@ -447,6 +467,22 @@ pub struct Root<T: Reflectable> {
|
|||
root_list: *const RootCollection,
|
||||
}
|
||||
|
||||
impl<T: Castable> Root<T> {
|
||||
/// Cast a DOM object root upwards to one of the interfaces it derives from.
|
||||
pub fn upcast<U>(root: Root<T>) -> Root<U> where U: Castable, T: DerivedFrom<U> {
|
||||
unsafe { mem::transmute(root) }
|
||||
}
|
||||
|
||||
/// Cast a DOM object root downwards to one of the interfaces it might implement.
|
||||
pub fn downcast<U>(root: Root<T>) -> Option<Root<U>> where U: DerivedFrom<T> {
|
||||
if root.is::<U>() {
|
||||
Some(unsafe { mem::transmute(root) })
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: Reflectable> Root<T> {
|
||||
/// Create a new stack-bounded root for the provided JS-owned value.
|
||||
/// It cannot not outlive its associated `RootCollection`, and it gives
|
||||
|
|
Loading…
Add table
Add a link
Reference in a new issue