//
// DO NOT EDIT.  THIS FILE IS GENERATED FROM ../../../dist/idl/nsISAXAttributes.idl
//


/// `interface nsISAXAttributes : nsISupports`
///

/// ```text
/// /**
///  * Interface for a list of XML attributes.
///  *
///  * This interface allows access to a list of attributes in
///  * three different ways:
///  *
///  * 1.) by attribute index;
///  * 2.) by Namespace-qualified name; or
///  * 3.) by XML qualified name.
///  *
///  * The list will not contain attributes that were declared #IMPLIED
///  * but not specified in the start tag.  It will also not contain
///  * attributes used as Namespace declarations (xmlns*) unless the
///  * http://xml.org/sax/features/namespace-prefixes feature
///  * is set to true (it is false by default).
///  *
///  * The order of attributes in the list is unspecified.
///  */
/// ```
///

// The actual type definition for the interface. This struct has methods
// declared on it which will call through its vtable. You never want to pass
// this type around by value, always pass it behind a reference.

#[repr(C)]
pub struct nsISAXAttributes {
vtable: *const nsISAXAttributesVTable,

/// This field is a phantomdata to ensure that the VTable type and any
/// struct containing it is not safe to send across threads, as XPCOM is
/// generally not threadsafe.
///
/// XPCOM interfaces in general are not safe to send across threads.
__nosync: ::std::marker::PhantomData<::std::rc::Rc<u8>>,
}

// Implementing XpCom for an interface exposes its IID, which allows for easy
// use of the `.query_interface<T>` helper method. This also defines that
// method for nsISAXAttributes.
unsafe impl XpCom for nsISAXAttributes {
const IID: nsIID = nsID(0xe347005e, 0x6cd0, 0x11da,
[0xbe, 0x43, 0x00, 0x14, 0x22, 0x10, 0x69, 0x90]);
}

// We need to implement the RefCounted trait so we can be used with `RefPtr`.
// This trait teaches `RefPtr` how to manage our memory.
unsafe impl RefCounted for nsISAXAttributes {
#[inline]
unsafe fn addref(&self) {
self.AddRef();
}
#[inline]
unsafe fn release(&self) {
self.Release();
}
}

// This trait is implemented on all types which can be coerced to from nsISAXAttributes.
// It is used in the implementation of `fn coerce<T>`. We hide it from the
// documentation, because it clutters it up a lot.
#[doc(hidden)]
pub trait nsISAXAttributesCoerce {
/// Cheaply cast a value of this type from a `nsISAXAttributes`.
fn coerce_from(v: &nsISAXAttributes) -> &Self;
}

// The trivial implementation: We can obviously coerce ourselves to ourselves.
impl nsISAXAttributesCoerce for nsISAXAttributes {
#[inline]
fn coerce_from(v: &nsISAXAttributes) -> &Self {
v
}
}

impl nsISAXAttributes {
/// Cast this `nsISAXAttributes` to one of its base interfaces.
#[inline]
pub fn coerce<T: nsISAXAttributesCoerce>(&self) -> &T {
T::coerce_from(self)
}
}

// Every interface struct type implements `Deref` to its base interface. This
// causes methods on the base interfaces to be directly avaliable on the
// object. For example, you can call `.AddRef` or `.QueryInterface` directly
// on any interface which inherits from `nsISupports`.
impl ::std::ops::Deref for nsISAXAttributes {
type Target = nsISupports;
#[inline]
fn deref(&self) -> &nsISupports {
unsafe {
::std::mem::transmute(self)
}
}
}

// Ensure we can use .coerce() to cast to our base types as well. Any type which
// our base interface can coerce from should be coercable from us as well.
impl<T: nsISupportsCoerce> nsISAXAttributesCoerce for T {
#[inline]
fn coerce_from(v: &nsISAXAttributes) -> &Self {
T::coerce_from(v)
}
}

// This struct represents the interface's VTable. A pointer to a statically
// allocated version of this struct is at the beginning of every nsISAXAttributes
// object. It contains one pointer field for each method in the interface. In
// the case where we can't generate a binding for a method, we include a void
// pointer.
#[doc(hidden)]
#[repr(C)]
pub struct nsISAXAttributesVTable {
/// We need to include the members from the base interface's vtable at the start
/// of the VTable definition.
pub __base: nsISupportsVTable,

/* long getIndexFromName (in AString uri, in AString localName); */
pub GetIndexFromName: unsafe extern "system" fn (this: *const nsISAXAttributes, uri: &::nsstring::nsAString, localName: &::nsstring::nsAString, _retval: *mut libc::int32_t) -> nsresult,

/* long getIndexFromQName (in AString qName); */
pub GetIndexFromQName: unsafe extern "system" fn (this: *const nsISAXAttributes, qName: &::nsstring::nsAString, _retval: *mut libc::int32_t) -> nsresult,

/* readonly attribute long length; */
pub GetLength: unsafe extern "system" fn (this: *const nsISAXAttributes, aLength: *mut libc::int32_t) -> nsresult,

/* AString getLocalName (in unsigned long index); */
pub GetLocalName: unsafe extern "system" fn (this: *const nsISAXAttributes, index: libc::uint32_t, _retval: &mut ::nsstring::nsAString) -> nsresult,

/* AString getQName (in unsigned long index); */
pub GetQName: unsafe extern "system" fn (this: *const nsISAXAttributes, index: libc::uint32_t, _retval: &mut ::nsstring::nsAString) -> nsresult,

/* AString getType (in unsigned long index); */
pub GetType: unsafe extern "system" fn (this: *const nsISAXAttributes, index: libc::uint32_t, _retval: &mut ::nsstring::nsAString) -> nsresult,

/* AString getTypeFromName (in AString uri, in AString localName); */
pub GetTypeFromName: unsafe extern "system" fn (this: *const nsISAXAttributes, uri: &::nsstring::nsAString, localName: &::nsstring::nsAString, _retval: &mut ::nsstring::nsAString) -> nsresult,

/* AString getTypeFromQName (in AString qName); */
pub GetTypeFromQName: unsafe extern "system" fn (this: *const nsISAXAttributes, qName: &::nsstring::nsAString, _retval: &mut ::nsstring::nsAString) -> nsresult,

/* AString getURI (in unsigned long index); */
pub GetURI: unsafe extern "system" fn (this: *const nsISAXAttributes, index: libc::uint32_t, _retval: &mut ::nsstring::nsAString) -> nsresult,

/* AString getValue (in unsigned long index); */
pub GetValue: unsafe extern "system" fn (this: *const nsISAXAttributes, index: libc::uint32_t, _retval: &mut ::nsstring::nsAString) -> nsresult,

/* AString getValueFromName (in AString uri, in AString localName); */
pub GetValueFromName: unsafe extern "system" fn (this: *const nsISAXAttributes, uri: &::nsstring::nsAString, localName: &::nsstring::nsAString, _retval: &mut ::nsstring::nsAString) -> nsresult,

/* AString getValueFromQName (in AString qName); */
pub GetValueFromQName: unsafe extern "system" fn (this: *const nsISAXAttributes, qName: &::nsstring::nsAString, _retval: &mut ::nsstring::nsAString) -> nsresult,
}


// The implementations of the function wrappers which are exposed to rust code.
// Call these methods rather than manually calling through the VTable struct.
impl nsISAXAttributes {

/// ```text
/// /**
///    * Look up the index of an attribute by Namespace name.
///    * @param uri The Namespace URI, or the empty string
///    *            if the name has no Namespace URI.
///    * @param localName The attribute's local name.
///    * @return The index of the attribute, or -1
///    *         if it does not appear in the list.
///    */
/// ```
///

/// `long getIndexFromName (in AString uri, in AString localName);`
#[inline]
pub unsafe fn GetIndexFromName(&self, uri: &::nsstring::nsAString, localName: &::nsstring::nsAString, _retval: *mut libc::int32_t) -> nsresult {
((*self.vtable).GetIndexFromName)(self, uri, localName, _retval)
}


/// ```text
/// /**
///    * Look up the index of an attribute by XML qualified name.
///    * @param qName The qualified name.
///    * @return The index of the attribute, or -1
///    *         if it does not appear in the list.
///    */
/// ```
///

/// `long getIndexFromQName (in AString qName);`
#[inline]
pub unsafe fn GetIndexFromQName(&self, qName: &::nsstring::nsAString, _retval: *mut libc::int32_t) -> nsresult {
((*self.vtable).GetIndexFromQName)(self, qName, _retval)
}


/// ```text
/// /**
///    * Return the number of attributes in the list. Once you know the
///    * number of attributes, you can iterate through the list.
///    *
///    * @return The number of attributes in the list.
///    */
/// ```
///

/// `readonly attribute long length;`
#[inline]
pub unsafe fn GetLength(&self, aLength: *mut libc::int32_t) -> nsresult {
((*self.vtable).GetLength)(self, aLength)
}


/// ```text
/// /**
///    * Look up an attribute's local name by index.
///    * @param index The attribute index (zero-based).
///    * @return The local name, or null if the index is out of range.
///    */
/// ```
///

/// `AString getLocalName (in unsigned long index);`
#[inline]
pub unsafe fn GetLocalName(&self, index: libc::uint32_t, _retval: &mut ::nsstring::nsAString) -> nsresult {
((*self.vtable).GetLocalName)(self, index, _retval)
}


/// ```text
/// /**
///    * Look up an attribute's XML qualified name by index.
///    * @param index The attribute index (zero-based).
///    * @return The XML qualified name, or the empty string if none is
///    *         available, or null if the index is out of range.
///    */
/// ```
///

/// `AString getQName (in unsigned long index);`
#[inline]
pub unsafe fn GetQName(&self, index: libc::uint32_t, _retval: &mut ::nsstring::nsAString) -> nsresult {
((*self.vtable).GetQName)(self, index, _retval)
}


/// ```text
/// /**
///    * Look up an attribute's type by index. The attribute type is one
///    * of the strings "CDATA", "ID", "IDREF", "IDREFS", "NMTOKEN",
///    * "NMTOKENS", "ENTITY", "ENTITIES", or "NOTATION" (always in upper
///    * case). If the parser has not read a declaration for the
///    * attribute, or if the parser does not report attribute types, then
///    * it must return the value "CDATA" as stated in the XML 1.0
///    * Recommendation (clause 3.3.3, "Attribute-Value
///    * Normalization"). For an enumerated attribute that is not a
///    * notation, the parser will report the type as "NMTOKEN".
///    *
///    * @param index The attribute index (zero-based).
///    * @return The attribute's type as a string, or null if the index is
///    *         out of range.
///    */
/// ```
///

/// `AString getType (in unsigned long index);`
#[inline]
pub unsafe fn GetType(&self, index: libc::uint32_t, _retval: &mut ::nsstring::nsAString) -> nsresult {
((*self.vtable).GetType)(self, index, _retval)
}


/// ```text
/// /**
///    * Look up an attribute's type by Namespace name.
///    * @param uri The Namespace URI, or the empty string
///    *             if the name has no Namespace URI.
///    * @param localName The attribute's local name.
///    * @return The attribute type as a string, or null if the attribute
///    *         is not in the list.
///    */
/// ```
///

/// `AString getTypeFromName (in AString uri, in AString localName);`
#[inline]
pub unsafe fn GetTypeFromName(&self, uri: &::nsstring::nsAString, localName: &::nsstring::nsAString, _retval: &mut ::nsstring::nsAString) -> nsresult {
((*self.vtable).GetTypeFromName)(self, uri, localName, _retval)
}


/// ```text
/// /**
///    * Look up an attribute's type by XML qualified name.
///    * @param qName The qualified name.
///    * @return The attribute type as a string, or null if the attribute
///    *         is not in the list.
///    */
/// ```
///

/// `AString getTypeFromQName (in AString qName);`
#[inline]
pub unsafe fn GetTypeFromQName(&self, qName: &::nsstring::nsAString, _retval: &mut ::nsstring::nsAString) -> nsresult {
((*self.vtable).GetTypeFromQName)(self, qName, _retval)
}


/// ```text
/// /**
///    * Look up an attribute's Namespace URI by index.
///    * @param index The attribute index (zero-based).
///    * @return The Namespace URI, or the empty string if none is available,
///    *         or null if the index is out of range.
///    */
/// ```
///

/// `AString getURI (in unsigned long index);`
#[inline]
pub unsafe fn GetURI(&self, index: libc::uint32_t, _retval: &mut ::nsstring::nsAString) -> nsresult {
((*self.vtable).GetURI)(self, index, _retval)
}


/// ```text
/// /**
///    * Look up an attribute's value by index.  If the attribute value is
///    * a list of tokens (IDREFS, ENTITIES, or NMTOKENS), the tokens will
///    * be concatenated into a single string with each token separated by
///    * a single space.
///    *
///    * @param index The attribute index (zero-based).
///    * @return The attribute's value as a string, or null if the index is
///    *         out of range.
///    */
/// ```
///

/// `AString getValue (in unsigned long index);`
#[inline]
pub unsafe fn GetValue(&self, index: libc::uint32_t, _retval: &mut ::nsstring::nsAString) -> nsresult {
((*self.vtable).GetValue)(self, index, _retval)
}


/// ```text
/// /**
///    * Look up an attribute's value by Namespace name.  If the attribute
///    * value is a list of tokens (IDREFS, ENTITIES, or NMTOKENS), the
///    * tokens will be concatenated into a single string with each token
///    * separated by a single space.
///    *
///    * @param uri The Namespace URI, or the empty string
///    *             if the name has no Namespace URI.
///    * @param localName The attribute's local name.
///    * @return The attribute's value as a string, or null if the attribute is
///    *         not in the list.
///    */
/// ```
///

/// `AString getValueFromName (in AString uri, in AString localName);`
#[inline]
pub unsafe fn GetValueFromName(&self, uri: &::nsstring::nsAString, localName: &::nsstring::nsAString, _retval: &mut ::nsstring::nsAString) -> nsresult {
((*self.vtable).GetValueFromName)(self, uri, localName, _retval)
}


/// ```text
/// /**
///    * Look up an attribute's value by XML qualified (prefixed) name.
///    * If the attribute value is a list of tokens (IDREFS, ENTITIES, or
///    * NMTOKENS), the tokens will be concatenated into a single string
///    * with each token separated by a single space.
///    *
///    * @param qName The qualified (prefixed) name.
///    * @return The attribute's value as a string, or null if the attribute is
///    *         not in the list.
///    */
/// ```
///

/// `AString getValueFromQName (in AString qName);`
#[inline]
pub unsafe fn GetValueFromQName(&self, qName: &::nsstring::nsAString, _retval: &mut ::nsstring::nsAString) -> nsresult {
((*self.vtable).GetValueFromQName)(self, qName, _retval)
}


}