Skip to content
Permalink
Browse files

Convert TNode / TElement to use self methods rather than &self

  • Loading branch information
Cameron Zwarich
Cameron Zwarich committed Oct 1, 2014
1 parent 6331420 commit 79b4ec99b453011781c13d401514377be9b6f3cd
Showing with 69 additions and 69 deletions.
  1. +18 −18 components/layout/wrapper.rs
  2. +16 −16 components/script/dom/element.rs
  3. +17 −17 components/script/dom/node.rs
  4. +18 −18 components/style/node.rs
@@ -247,33 +247,33 @@ impl<'ln> LayoutNode<'ln> {
}

impl<'ln> TNode<'ln, LayoutElement<'ln>> for LayoutNode<'ln> {
fn parent_node(&self) -> Option<LayoutNode<'ln>> {
fn parent_node(self) -> Option<LayoutNode<'ln>> {
unsafe {
self.node.parent_node_ref().map(|node| self.new_with_this_lifetime(&node))
}
}

fn first_child(&self) -> Option<LayoutNode<'ln>> {
fn first_child(self) -> Option<LayoutNode<'ln>> {
unsafe {
self.node.first_child_ref().map(|node| self.new_with_this_lifetime(&node))
}
}

fn prev_sibling(&self) -> Option<LayoutNode<'ln>> {
fn prev_sibling(self) -> Option<LayoutNode<'ln>> {
unsafe {
self.node.prev_sibling_ref().map(|node| self.new_with_this_lifetime(&node))
}
}

fn next_sibling(&self) -> Option<LayoutNode<'ln>> {
fn next_sibling(self) -> Option<LayoutNode<'ln>> {
unsafe {
self.node.next_sibling_ref().map(|node| self.new_with_this_lifetime(&node))
}
}

/// If this is an element, accesses the element data. Fails if this is not an element node.
#[inline]
fn as_element(&self) -> LayoutElement<'ln> {
fn as_element(self) -> LayoutElement<'ln> {
unsafe {
assert!(self.node.is_element_for_layout());
let elem: JS<Element> = self.node.transmute_copy();
@@ -284,15 +284,15 @@ impl<'ln> TNode<'ln, LayoutElement<'ln>> for LayoutNode<'ln> {
}
}

fn is_element(&self) -> bool {
fn is_element(self) -> bool {
self.node_is_element()
}

fn is_document(&self) -> bool {
fn is_document(self) -> bool {
self.node_is_document()
}

fn match_attr(&self, attr: &AttrSelector, test: |&str| -> bool) -> bool {
fn match_attr(self, attr: &AttrSelector, test: |&str| -> bool) -> bool {
assert!(self.is_element())
let name = if self.is_html_element_in_html_document() {
attr.lower_name.as_slice()
@@ -310,7 +310,7 @@ impl<'ln> TNode<'ln, LayoutElement<'ln>> for LayoutNode<'ln> {
}
}

fn is_html_element_in_html_document(&self) -> bool {
fn is_html_element_in_html_document(self) -> bool {
unsafe {
self.is_element() && {
let element: JS<Element> = self.node.transmute_copy();
@@ -395,21 +395,21 @@ impl<'le> LayoutElement<'le> {

impl<'le> TElement<'le> for LayoutElement<'le> {
#[inline]
fn get_local_name(&self) -> &'le Atom {
fn get_local_name(self) -> &'le Atom {
&self.element.local_name
}

#[inline]
fn get_namespace(&self) -> &'le Namespace {
fn get_namespace(self) -> &'le Namespace {
&self.element.namespace
}

#[inline]
fn get_attr(&self, namespace: &Namespace, name: &str) -> Option<&'le str> {
fn get_attr(self, namespace: &Namespace, name: &str) -> Option<&'le str> {
unsafe { self.element.get_attr_val_for_layout(namespace, name) }
}

fn get_link(&self) -> Option<&'le str> {
fn get_link(self) -> Option<&'le str> {
// FIXME: This is HTML only.
match self.element.node.type_id_for_layout() {
// http://www.whatwg.org/specs/web-apps/current-work/multipage/selectors.html#
@@ -423,30 +423,30 @@ impl<'le> TElement<'le> for LayoutElement<'le> {
}
}

fn get_hover_state(&self) -> bool {
fn get_hover_state(self) -> bool {
unsafe {
self.element.node.get_hover_state_for_layout()
}
}

#[inline]
fn get_id(&self) -> Option<Atom> {
fn get_id(self) -> Option<Atom> {
unsafe { self.element.get_attr_atom_for_layout(&ns!(""), "id") }
}

fn get_disabled_state(&self) -> bool {
fn get_disabled_state(self) -> bool {
unsafe {
self.element.node.get_disabled_state_for_layout()
}
}

fn get_enabled_state(&self) -> bool {
fn get_enabled_state(self) -> bool {
unsafe {
self.element.node.get_enabled_state_for_layout()
}
}

fn has_class(&self, name: &str) -> bool {
fn has_class(self, name: &str) -> bool {
unsafe {
self.element.has_class_for_layout(name)
}
@@ -948,14 +948,14 @@ impl<'a> VirtualMethods for JSRef<'a, Element> {
}

impl<'a> style::TElement<'a> for JSRef<'a, Element> {
fn get_attr(&self, namespace: &Namespace, attr: &str) -> Option<&'a str> {
fn get_attr(self, namespace: &Namespace, attr: &str) -> Option<&'a str> {
self.get_attribute(namespace.clone(), attr).root().map(|attr| {
unsafe { mem::transmute(attr.deref().value().as_slice()) }
})
}
fn get_link(&self) -> Option<&'a str> {
fn get_link(self) -> Option<&'a str> {
// FIXME: This is HTML only.
let node: JSRef<Node> = NodeCast::from_ref(*self);
let node: JSRef<Node> = NodeCast::from_ref(self);
match node.type_id() {
// http://www.whatwg.org/specs/web-apps/current-work/multipage/selectors.html#
// selector-link
@@ -965,29 +965,29 @@ impl<'a> style::TElement<'a> for JSRef<'a, Element> {
_ => None,
}
}
fn get_local_name(&self) -> &'a Atom {
fn get_local_name(self) -> &'a Atom {
// FIXME(zwarich): Remove this when UFCS lands and there is a better way
// of disambiguating methods.
fn get_local_name<'a, T: ElementHelpers<'a>>(this: T) -> &'a Atom {
this.get_local_name()
}

get_local_name(*self)
get_local_name(self)
}
fn get_namespace(&self) -> &'a Namespace {
fn get_namespace(self) -> &'a Namespace {
// FIXME(zwarich): Remove this when UFCS lands and there is a better way
// of disambiguating methods.
fn get_namespace<'a, T: ElementHelpers<'a>>(this: T) -> &'a Namespace {
this.get_namespace()
}

get_namespace(*self)
get_namespace(self)
}
fn get_hover_state(&self) -> bool {
let node: JSRef<Node> = NodeCast::from_ref(*self);
fn get_hover_state(self) -> bool {
let node: JSRef<Node> = NodeCast::from_ref(self);
node.get_hover_state()
}
fn get_id<'a>(&self) -> Option<Atom> {
fn get_id<'a>(self) -> Option<Atom> {
self.get_attribute(ns!(""), "id").map(|attr| {
let attr = attr.root();
match *attr.value() {
@@ -996,21 +996,21 @@ impl<'a> style::TElement<'a> for JSRef<'a, Element> {
}
})
}
fn get_disabled_state(&self) -> bool {
let node: JSRef<Node> = NodeCast::from_ref(*self);
fn get_disabled_state(self) -> bool {
let node: JSRef<Node> = NodeCast::from_ref(self);
node.get_disabled_state()
}
fn get_enabled_state(&self) -> bool {
let node: JSRef<Node> = NodeCast::from_ref(*self);
fn get_enabled_state(self) -> bool {
let node: JSRef<Node> = NodeCast::from_ref(self);
node.get_enabled_state()
}
fn has_class(&self, name: &str) -> bool {
fn has_class(self, name: &str) -> bool {
// FIXME(zwarich): Remove this when UFCS lands and there is a better way
// of disambiguating methods.
fn has_class<T: AttributeHandlers>(this: T, name: &str) -> bool {
this.has_class(name)
}

has_class(*self, name)
has_class(self, name)
}
}
@@ -2035,73 +2035,73 @@ impl<'a> VirtualMethods for JSRef<'a, Node> {
}

impl<'a> style::TNode<'a, JSRef<'a, Element>> for JSRef<'a, Node> {
fn parent_node(&self) -> Option<JSRef<'a, Node>> {
fn parent_node(self) -> Option<JSRef<'a, Node>> {
// FIXME(zwarich): Remove this when UFCS lands and there is a better way
// of disambiguating methods.
fn parent_node<'a, 'b, T: NodeHelpers<'a, 'b>>(this: T) -> Option<Temporary<Node>> {
this.parent_node()
}

parent_node(*self).map(|node| *node.root())
parent_node(self).map(|node| *node.root())
}

fn first_child(&self) -> Option<JSRef<'a, Node>> {
fn first_child(self) -> Option<JSRef<'a, Node>> {
// FIXME(zwarich): Remove this when UFCS lands and there is a better way
// of disambiguating methods.
fn first_child<'a, 'b, T: NodeHelpers<'a, 'b>>(this: T) -> Option<Temporary<Node>> {
this.first_child()
}

first_child(*self).map(|node| *node.root())
first_child(self).map(|node| *node.root())
}

fn prev_sibling(&self) -> Option<JSRef<'a, Node>> {
fn prev_sibling(self) -> Option<JSRef<'a, Node>> {
// FIXME(zwarich): Remove this when UFCS lands and there is a better way
// of disambiguating methods.
fn prev_sibling<'a, 'b, T: NodeHelpers<'a, 'b>>(this: T) -> Option<Temporary<Node>> {
this.prev_sibling()
}

prev_sibling(*self).map(|node| *node.root())
prev_sibling(self).map(|node| *node.root())
}

fn next_sibling(&self) -> Option<JSRef<'a, Node>> {
fn next_sibling(self) -> Option<JSRef<'a, Node>> {
// FIXME(zwarich): Remove this when UFCS lands and there is a better way
// of disambiguating methods.
fn next_sibling<'a, 'b, T: NodeHelpers<'a, 'b>>(this: T) -> Option<Temporary<Node>> {
this.next_sibling()
}

next_sibling(*self).map(|node| *node.root())
next_sibling(self).map(|node| *node.root())
}

fn is_document(&self) -> bool {
fn is_document(self) -> bool {
// FIXME(zwarich): Remove this when UFCS lands and there is a better way
// of disambiguating methods.
fn is_document<'a, 'b, T: NodeHelpers<'a, 'b>>(this: T) -> bool {
this.is_document()
}

is_document(*self)
is_document(self)
}

fn is_element(&self) -> bool {
fn is_element(self) -> bool {
// FIXME(zwarich): Remove this when UFCS lands and there is a better way
// of disambiguating methods.
fn is_element<'a, 'b, T: NodeHelpers<'a, 'b>>(this: T) -> bool {
this.is_element()
}

is_element(*self)
is_element(self)
}

fn as_element(&self) -> JSRef<'a, Element> {
let elem: Option<JSRef<'a, Element>> = ElementCast::to_ref(*self);
fn as_element(self) -> JSRef<'a, Element> {
let elem: Option<JSRef<'a, Element>> = ElementCast::to_ref(self);
assert!(elem.is_some());
elem.unwrap()
}

fn match_attr(&self, attr: &style::AttrSelector, test: |&str| -> bool) -> bool {
fn match_attr(self, attr: &style::AttrSelector, test: |&str| -> bool) -> bool {
let name = {
if self.is_html_element_in_html_document() {
attr.lower_name.as_slice()
@@ -2119,8 +2119,8 @@ impl<'a> style::TNode<'a, JSRef<'a, Element>> for JSRef<'a, Node> {
}
}

fn is_html_element_in_html_document(&self) -> bool {
let elem: Option<JSRef<'a, Element>> = ElementCast::to_ref(*self);
fn is_html_element_in_html_document(self) -> bool {
let elem: Option<JSRef<'a, Element>> = ElementCast::to_ref(self);
assert!(elem.is_some());
elem.unwrap().html_element_in_html_document()
}
@@ -10,25 +10,25 @@ use string_cache::{Atom, Namespace};


pub trait TNode<'a, E: TElement<'a>> : Clone + Copy {
fn parent_node(&self) -> Option<Self>;
fn first_child(&self) -> Option<Self>;
fn prev_sibling(&self) -> Option<Self>;
fn next_sibling(&self) -> Option<Self>;
fn is_document(&self) -> bool;
fn is_element(&self) -> bool;
fn as_element(&self) -> E;
fn match_attr(&self, attr: &AttrSelector, test: |&str| -> bool) -> bool;
fn is_html_element_in_html_document(&self) -> bool;
fn parent_node(self) -> Option<Self>;
fn first_child(self) -> Option<Self>;
fn prev_sibling(self) -> Option<Self>;
fn next_sibling(self) -> Option<Self>;
fn is_document(self) -> bool;
fn is_element(self) -> bool;
fn as_element(self) -> E;
fn match_attr(self, attr: &AttrSelector, test: |&str| -> bool) -> bool;
fn is_html_element_in_html_document(self) -> bool;
}

pub trait TElement<'a> : Copy {
fn get_attr(&self, namespace: &Namespace, attr: &str) -> Option<&'a str>;
fn get_link(&self) -> Option<&'a str>;
fn get_local_name(&self) -> &'a Atom;
fn get_namespace(&self) -> &'a Namespace;
fn get_hover_state(&self) -> bool;
fn get_id(&self) -> Option<Atom>;
fn get_disabled_state(&self) -> bool;
fn get_enabled_state(&self) -> bool;
fn has_class(&self, name: &str) -> bool;
fn get_attr(self, namespace: &Namespace, attr: &str) -> Option<&'a str>;
fn get_link(self) -> Option<&'a str>;
fn get_local_name(self) -> &'a Atom;
fn get_namespace(self) -> &'a Namespace;
fn get_hover_state(self) -> bool;
fn get_id(self) -> Option<Atom>;
fn get_disabled_state(self) -> bool;
fn get_enabled_state(self) -> bool;
fn has_class(self, name: &str) -> bool;
}

0 comments on commit 79b4ec9

Please sign in to comment.
You can’t perform that action at this time.