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

#ifndef __gen_nsIVariant_h__
#define __gen_nsIVariant_h__


#ifndef __gen_nsISupports_h__
#include "nsISupports.h"
#endif

#include "js/Value.h"

/* For IDL files that don't want to include root IDL files. */
#ifndef NS_NO_VTABLE
#define NS_NO_VTABLE
#endif

/* starting interface:    nsIDataType */
#define NS_IDATATYPE_IID_STR "4d12e540-83d7-11d5-90ed-0010a4e73d9a"

#define NS_IDATATYPE_IID \
  {0x4d12e540, 0x83d7, 0x11d5, \
    { 0x90, 0xed, 0x00, 0x10, 0xa4, 0xe7, 0x3d, 0x9a }}

class NS_NO_VTABLE nsIDataType : public nsISupports {
 public:

  NS_DECLARE_STATIC_IID_ACCESSOR(NS_IDATATYPE_IID)

  enum {
    VTYPE_INT8 = 0U,
    VTYPE_INT16 = 1U,
    VTYPE_INT32 = 2U,
    VTYPE_INT64 = 3U,
    VTYPE_UINT8 = 4U,
    VTYPE_UINT16 = 5U,
    VTYPE_UINT32 = 6U,
    VTYPE_UINT64 = 7U,
    VTYPE_FLOAT = 8U,
    VTYPE_DOUBLE = 9U,
    VTYPE_BOOL = 10U,
    VTYPE_CHAR = 11U,
    VTYPE_WCHAR = 12U,
    VTYPE_VOID = 13U,
    VTYPE_ID = 14U,
    VTYPE_DOMSTRING = 15U,
    VTYPE_CHAR_STR = 16U,
    VTYPE_WCHAR_STR = 17U,
    VTYPE_INTERFACE = 18U,
    VTYPE_INTERFACE_IS = 19U,
    VTYPE_ARRAY = 20U,
    VTYPE_STRING_SIZE_IS = 21U,
    VTYPE_WSTRING_SIZE_IS = 22U,
    VTYPE_UTF8STRING = 23U,
    VTYPE_CSTRING = 24U,
    VTYPE_ASTRING = 25U,
    VTYPE_EMPTY_ARRAY = 254U,
    VTYPE_EMPTY = 255U
  };

};

  NS_DEFINE_STATIC_IID_ACCESSOR(nsIDataType, NS_IDATATYPE_IID)

/* Use this macro when declaring classes that implement this interface. */
#define NS_DECL_NSIDATATYPE \

/* Use this macro when declaring the members of this interface when the
   class doesn't implement the interface. This is useful for forwarding. */
#define NS_DECL_NON_VIRTUAL_NSIDATATYPE \

/* Use this macro to declare functions that forward the behavior of this interface to another object. */
#define NS_FORWARD_NSIDATATYPE(_to) \

/* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
#define NS_FORWARD_SAFE_NSIDATATYPE(_to) \

#if 0
/* Use the code below as a template for the implementation class for this interface. */

/* Header file */
class nsDataType : public nsIDataType
{
public:
  NS_DECL_ISUPPORTS
  NS_DECL_NSIDATATYPE

  nsDataType();

private:
  ~nsDataType();

protected:
  /* additional members */
};

/* Implementation file */
NS_IMPL_ISUPPORTS(nsDataType, nsIDataType)

nsDataType::nsDataType()
{
  /* member initializers and constructor code */
}

nsDataType::~nsDataType()
{
  /* destructor code */
}

/* End of implementation class template. */
#endif


/* starting interface:    nsIVariant */
#define NS_IVARIANT_IID_STR "81e4c2de-acac-4ad6-901a-b5fb1b851a0d"

#define NS_IVARIANT_IID \
  {0x81e4c2de, 0xacac, 0x4ad6, \
    { 0x90, 0x1a, 0xb5, 0xfb, 0x1b, 0x85, 0x1a, 0x0d }}

class NS_NO_VTABLE nsIVariant : public nsISupports {
 public:

  NS_DECLARE_STATIC_IID_ACCESSOR(NS_IVARIANT_IID)

  /* [noscript] readonly attribute uint16_t dataType; */
  NS_IMETHOD GetDataType(uint16_t *aDataType) = 0;

  /* [noscript] uint8_t getAsInt8 (); */
  NS_IMETHOD GetAsInt8(uint8_t *_retval) = 0;

  /* [noscript] int16_t getAsInt16 (); */
  NS_IMETHOD GetAsInt16(int16_t *_retval) = 0;

  /* [noscript] int32_t getAsInt32 (); */
  NS_IMETHOD GetAsInt32(int32_t *_retval) = 0;

  /* [noscript] int64_t getAsInt64 (); */
  NS_IMETHOD GetAsInt64(int64_t *_retval) = 0;

  /* [noscript] uint8_t getAsUint8 (); */
  NS_IMETHOD GetAsUint8(uint8_t *_retval) = 0;

  /* [noscript] uint16_t getAsUint16 (); */
  NS_IMETHOD GetAsUint16(uint16_t *_retval) = 0;

  /* [noscript] uint32_t getAsUint32 (); */
  NS_IMETHOD GetAsUint32(uint32_t *_retval) = 0;

  /* [noscript] uint64_t getAsUint64 (); */
  NS_IMETHOD GetAsUint64(uint64_t *_retval) = 0;

  /* [noscript] float getAsFloat (); */
  NS_IMETHOD GetAsFloat(float *_retval) = 0;

  /* [noscript] double getAsDouble (); */
  NS_IMETHOD GetAsDouble(double *_retval) = 0;

  /* [noscript] boolean getAsBool (); */
  NS_IMETHOD GetAsBool(bool *_retval) = 0;

  /* [noscript] char getAsChar (); */
  NS_IMETHOD GetAsChar(char *_retval) = 0;

  /* [noscript] wchar getAsWChar (); */
  NS_IMETHOD GetAsWChar(char16_t *_retval) = 0;

  /* [notxpcom] nsresult getAsID (out nsID retval); */
  NS_IMETHOD_(nsresult) GetAsID(nsID *retval) = 0;

  /* [noscript] AString getAsAString (); */
  NS_IMETHOD GetAsAString(nsAString & _retval) = 0;

  /* [noscript] DOMString getAsDOMString (); */
  NS_IMETHOD GetAsDOMString(nsAString & _retval) = 0;

  /* [noscript] ACString getAsACString (); */
  NS_IMETHOD GetAsACString(nsACString & _retval) = 0;

  /* [noscript] AUTF8String getAsAUTF8String (); */
  NS_IMETHOD GetAsAUTF8String(nsACString & _retval) = 0;

  /* [noscript] string getAsString (); */
  NS_IMETHOD GetAsString(char * *_retval) = 0;

  /* [noscript] wstring getAsWString (); */
  NS_IMETHOD GetAsWString(char16_t * *_retval) = 0;

  /* [noscript] nsISupports getAsISupports (); */
  NS_IMETHOD GetAsISupports(nsISupports * *_retval) = 0;

  /* [noscript] jsval getAsJSVal (); */
  NS_IMETHOD GetAsJSVal(JS::MutableHandleValue _retval) = 0;

  /* [noscript] void getAsInterface (out nsIIDPtr iid, [iid_is (iid), retval] out nsQIResult iface); */
  NS_IMETHOD GetAsInterface(nsIID **iid, void **iface) = 0;

  /* [notxpcom] nsresult getAsArray (out uint16_t type, out nsIID iid, out uint32_t count, out voidPtr ptr); */
  NS_IMETHOD_(nsresult) GetAsArray(uint16_t *type, nsIID *iid, uint32_t *count, void **ptr) = 0;

  /* [noscript] void getAsStringWithSize (out uint32_t size, [size_is (size), retval] out string str); */
  NS_IMETHOD GetAsStringWithSize(uint32_t *size, char * *str) = 0;

  /* [noscript] void getAsWStringWithSize (out uint32_t size, [size_is (size), retval] out wstring str); */
  NS_IMETHOD GetAsWStringWithSize(uint32_t *size, char16_t * *str) = 0;

};

  NS_DEFINE_STATIC_IID_ACCESSOR(nsIVariant, NS_IVARIANT_IID)

/* Use this macro when declaring classes that implement this interface. */
#define NS_DECL_NSIVARIANT \
  NS_IMETHOD GetDataType(uint16_t *aDataType) override; \
  NS_IMETHOD GetAsInt8(uint8_t *_retval) override; \
  NS_IMETHOD GetAsInt16(int16_t *_retval) override; \
  NS_IMETHOD GetAsInt32(int32_t *_retval) override; \
  NS_IMETHOD GetAsInt64(int64_t *_retval) override; \
  NS_IMETHOD GetAsUint8(uint8_t *_retval) override; \
  NS_IMETHOD GetAsUint16(uint16_t *_retval) override; \
  NS_IMETHOD GetAsUint32(uint32_t *_retval) override; \
  NS_IMETHOD GetAsUint64(uint64_t *_retval) override; \
  NS_IMETHOD GetAsFloat(float *_retval) override; \
  NS_IMETHOD GetAsDouble(double *_retval) override; \
  NS_IMETHOD GetAsBool(bool *_retval) override; \
  NS_IMETHOD GetAsChar(char *_retval) override; \
  NS_IMETHOD GetAsWChar(char16_t *_retval) override; \
  NS_IMETHOD_(nsresult) GetAsID(nsID *retval) override; \
  NS_IMETHOD GetAsAString(nsAString & _retval) override; \
  NS_IMETHOD GetAsDOMString(nsAString & _retval) override; \
  NS_IMETHOD GetAsACString(nsACString & _retval) override; \
  NS_IMETHOD GetAsAUTF8String(nsACString & _retval) override; \
  NS_IMETHOD GetAsString(char * *_retval) override; \
  NS_IMETHOD GetAsWString(char16_t * *_retval) override; \
  NS_IMETHOD GetAsISupports(nsISupports * *_retval) override; \
  NS_IMETHOD GetAsJSVal(JS::MutableHandleValue _retval) override; \
  NS_IMETHOD GetAsInterface(nsIID **iid, void **iface) override; \
  NS_IMETHOD_(nsresult) GetAsArray(uint16_t *type, nsIID *iid, uint32_t *count, void **ptr) override; \
  NS_IMETHOD GetAsStringWithSize(uint32_t *size, char * *str) override; \
  NS_IMETHOD GetAsWStringWithSize(uint32_t *size, char16_t * *str) override; 

/* Use this macro when declaring the members of this interface when the
   class doesn't implement the interface. This is useful for forwarding. */
#define NS_DECL_NON_VIRTUAL_NSIVARIANT \
  NS_METHOD GetDataType(uint16_t *aDataType); \
  NS_METHOD GetAsInt8(uint8_t *_retval); \
  NS_METHOD GetAsInt16(int16_t *_retval); \
  NS_METHOD GetAsInt32(int32_t *_retval); \
  NS_METHOD GetAsInt64(int64_t *_retval); \
  NS_METHOD GetAsUint8(uint8_t *_retval); \
  NS_METHOD GetAsUint16(uint16_t *_retval); \
  NS_METHOD GetAsUint32(uint32_t *_retval); \
  NS_METHOD GetAsUint64(uint64_t *_retval); \
  NS_METHOD GetAsFloat(float *_retval); \
  NS_METHOD GetAsDouble(double *_retval); \
  NS_METHOD GetAsBool(bool *_retval); \
  NS_METHOD GetAsChar(char *_retval); \
  NS_METHOD GetAsWChar(char16_t *_retval); \
  NS_METHOD_(nsresult) GetAsID(nsID *retval); \
  NS_METHOD GetAsAString(nsAString & _retval); \
  NS_METHOD GetAsDOMString(nsAString & _retval); \
  NS_METHOD GetAsACString(nsACString & _retval); \
  NS_METHOD GetAsAUTF8String(nsACString & _retval); \
  NS_METHOD GetAsString(char * *_retval); \
  NS_METHOD GetAsWString(char16_t * *_retval); \
  NS_METHOD GetAsISupports(nsISupports * *_retval); \
  NS_METHOD GetAsJSVal(JS::MutableHandleValue _retval); \
  NS_METHOD GetAsInterface(nsIID **iid, void **iface); \
  NS_METHOD_(nsresult) GetAsArray(uint16_t *type, nsIID *iid, uint32_t *count, void **ptr); \
  NS_METHOD GetAsStringWithSize(uint32_t *size, char * *str); \
  NS_METHOD GetAsWStringWithSize(uint32_t *size, char16_t * *str); 

/* Use this macro to declare functions that forward the behavior of this interface to another object. */
#define NS_FORWARD_NSIVARIANT(_to) \
  NS_IMETHOD GetDataType(uint16_t *aDataType) override { return _to GetDataType(aDataType); } \
  NS_IMETHOD GetAsInt8(uint8_t *_retval) override { return _to GetAsInt8(_retval); } \
  NS_IMETHOD GetAsInt16(int16_t *_retval) override { return _to GetAsInt16(_retval); } \
  NS_IMETHOD GetAsInt32(int32_t *_retval) override { return _to GetAsInt32(_retval); } \
  NS_IMETHOD GetAsInt64(int64_t *_retval) override { return _to GetAsInt64(_retval); } \
  NS_IMETHOD GetAsUint8(uint8_t *_retval) override { return _to GetAsUint8(_retval); } \
  NS_IMETHOD GetAsUint16(uint16_t *_retval) override { return _to GetAsUint16(_retval); } \
  NS_IMETHOD GetAsUint32(uint32_t *_retval) override { return _to GetAsUint32(_retval); } \
  NS_IMETHOD GetAsUint64(uint64_t *_retval) override { return _to GetAsUint64(_retval); } \
  NS_IMETHOD GetAsFloat(float *_retval) override { return _to GetAsFloat(_retval); } \
  NS_IMETHOD GetAsDouble(double *_retval) override { return _to GetAsDouble(_retval); } \
  NS_IMETHOD GetAsBool(bool *_retval) override { return _to GetAsBool(_retval); } \
  NS_IMETHOD GetAsChar(char *_retval) override { return _to GetAsChar(_retval); } \
  NS_IMETHOD GetAsWChar(char16_t *_retval) override { return _to GetAsWChar(_retval); } \
  NS_IMETHOD_(nsresult) GetAsID(nsID *retval) override { return _to GetAsID(retval); } \
  NS_IMETHOD GetAsAString(nsAString & _retval) override { return _to GetAsAString(_retval); } \
  NS_IMETHOD GetAsDOMString(nsAString & _retval) override { return _to GetAsDOMString(_retval); } \
  NS_IMETHOD GetAsACString(nsACString & _retval) override { return _to GetAsACString(_retval); } \
  NS_IMETHOD GetAsAUTF8String(nsACString & _retval) override { return _to GetAsAUTF8String(_retval); } \
  NS_IMETHOD GetAsString(char * *_retval) override { return _to GetAsString(_retval); } \
  NS_IMETHOD GetAsWString(char16_t * *_retval) override { return _to GetAsWString(_retval); } \
  NS_IMETHOD GetAsISupports(nsISupports * *_retval) override { return _to GetAsISupports(_retval); } \
  NS_IMETHOD GetAsJSVal(JS::MutableHandleValue _retval) override { return _to GetAsJSVal(_retval); } \
  NS_IMETHOD GetAsInterface(nsIID **iid, void **iface) override { return _to GetAsInterface(iid, iface); } \
  NS_IMETHOD_(nsresult) GetAsArray(uint16_t *type, nsIID *iid, uint32_t *count, void **ptr) override { return _to GetAsArray(type, iid, count, ptr); } \
  NS_IMETHOD GetAsStringWithSize(uint32_t *size, char * *str) override { return _to GetAsStringWithSize(size, str); } \
  NS_IMETHOD GetAsWStringWithSize(uint32_t *size, char16_t * *str) override { return _to GetAsWStringWithSize(size, str); } 

/* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
#define NS_FORWARD_SAFE_NSIVARIANT(_to) \
  NS_IMETHOD GetDataType(uint16_t *aDataType) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetDataType(aDataType); } \
  NS_IMETHOD GetAsInt8(uint8_t *_retval) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetAsInt8(_retval); } \
  NS_IMETHOD GetAsInt16(int16_t *_retval) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetAsInt16(_retval); } \
  NS_IMETHOD GetAsInt32(int32_t *_retval) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetAsInt32(_retval); } \
  NS_IMETHOD GetAsInt64(int64_t *_retval) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetAsInt64(_retval); } \
  NS_IMETHOD GetAsUint8(uint8_t *_retval) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetAsUint8(_retval); } \
  NS_IMETHOD GetAsUint16(uint16_t *_retval) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetAsUint16(_retval); } \
  NS_IMETHOD GetAsUint32(uint32_t *_retval) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetAsUint32(_retval); } \
  NS_IMETHOD GetAsUint64(uint64_t *_retval) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetAsUint64(_retval); } \
  NS_IMETHOD GetAsFloat(float *_retval) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetAsFloat(_retval); } \
  NS_IMETHOD GetAsDouble(double *_retval) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetAsDouble(_retval); } \
  NS_IMETHOD GetAsBool(bool *_retval) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetAsBool(_retval); } \
  NS_IMETHOD GetAsChar(char *_retval) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetAsChar(_retval); } \
  NS_IMETHOD GetAsWChar(char16_t *_retval) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetAsWChar(_retval); } \
  NS_IMETHOD_(nsresult) GetAsID(nsID *retval) override; \
  NS_IMETHOD GetAsAString(nsAString & _retval) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetAsAString(_retval); } \
  NS_IMETHOD GetAsDOMString(nsAString & _retval) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetAsDOMString(_retval); } \
  NS_IMETHOD GetAsACString(nsACString & _retval) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetAsACString(_retval); } \
  NS_IMETHOD GetAsAUTF8String(nsACString & _retval) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetAsAUTF8String(_retval); } \
  NS_IMETHOD GetAsString(char * *_retval) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetAsString(_retval); } \
  NS_IMETHOD GetAsWString(char16_t * *_retval) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetAsWString(_retval); } \
  NS_IMETHOD GetAsISupports(nsISupports * *_retval) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetAsISupports(_retval); } \
  NS_IMETHOD GetAsJSVal(JS::MutableHandleValue _retval) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetAsJSVal(_retval); } \
  NS_IMETHOD GetAsInterface(nsIID **iid, void **iface) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetAsInterface(iid, iface); } \
  NS_IMETHOD_(nsresult) GetAsArray(uint16_t *type, nsIID *iid, uint32_t *count, void **ptr) override; \
  NS_IMETHOD GetAsStringWithSize(uint32_t *size, char * *str) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetAsStringWithSize(size, str); } \
  NS_IMETHOD GetAsWStringWithSize(uint32_t *size, char16_t * *str) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetAsWStringWithSize(size, str); } 

#if 0
/* Use the code below as a template for the implementation class for this interface. */

/* Header file */
class nsVariant : public nsIVariant
{
public:
  NS_DECL_ISUPPORTS
  NS_DECL_NSIVARIANT

  nsVariant();

private:
  ~nsVariant();

protected:
  /* additional members */
};

/* Implementation file */
NS_IMPL_ISUPPORTS(nsVariant, nsIVariant)

nsVariant::nsVariant()
{
  /* member initializers and constructor code */
}

nsVariant::~nsVariant()
{
  /* destructor code */
}

/* [noscript] readonly attribute uint16_t dataType; */
NS_IMETHODIMP nsVariant::GetDataType(uint16_t *aDataType)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* [noscript] uint8_t getAsInt8 (); */
NS_IMETHODIMP nsVariant::GetAsInt8(uint8_t *_retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* [noscript] int16_t getAsInt16 (); */
NS_IMETHODIMP nsVariant::GetAsInt16(int16_t *_retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* [noscript] int32_t getAsInt32 (); */
NS_IMETHODIMP nsVariant::GetAsInt32(int32_t *_retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* [noscript] int64_t getAsInt64 (); */
NS_IMETHODIMP nsVariant::GetAsInt64(int64_t *_retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* [noscript] uint8_t getAsUint8 (); */
NS_IMETHODIMP nsVariant::GetAsUint8(uint8_t *_retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* [noscript] uint16_t getAsUint16 (); */
NS_IMETHODIMP nsVariant::GetAsUint16(uint16_t *_retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* [noscript] uint32_t getAsUint32 (); */
NS_IMETHODIMP nsVariant::GetAsUint32(uint32_t *_retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* [noscript] uint64_t getAsUint64 (); */
NS_IMETHODIMP nsVariant::GetAsUint64(uint64_t *_retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* [noscript] float getAsFloat (); */
NS_IMETHODIMP nsVariant::GetAsFloat(float *_retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* [noscript] double getAsDouble (); */
NS_IMETHODIMP nsVariant::GetAsDouble(double *_retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* [noscript] boolean getAsBool (); */
NS_IMETHODIMP nsVariant::GetAsBool(bool *_retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* [noscript] char getAsChar (); */
NS_IMETHODIMP nsVariant::GetAsChar(char *_retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* [noscript] wchar getAsWChar (); */
NS_IMETHODIMP nsVariant::GetAsWChar(char16_t *_retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* [notxpcom] nsresult getAsID (out nsID retval); */
NS_IMETHODIMP_(nsresult) nsVariant::GetAsID(nsID *retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* [noscript] AString getAsAString (); */
NS_IMETHODIMP nsVariant::GetAsAString(nsAString & _retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* [noscript] DOMString getAsDOMString (); */
NS_IMETHODIMP nsVariant::GetAsDOMString(nsAString & _retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* [noscript] ACString getAsACString (); */
NS_IMETHODIMP nsVariant::GetAsACString(nsACString & _retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* [noscript] AUTF8String getAsAUTF8String (); */
NS_IMETHODIMP nsVariant::GetAsAUTF8String(nsACString & _retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* [noscript] string getAsString (); */
NS_IMETHODIMP nsVariant::GetAsString(char * *_retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* [noscript] wstring getAsWString (); */
NS_IMETHODIMP nsVariant::GetAsWString(char16_t * *_retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* [noscript] nsISupports getAsISupports (); */
NS_IMETHODIMP nsVariant::GetAsISupports(nsISupports * *_retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* [noscript] jsval getAsJSVal (); */
NS_IMETHODIMP nsVariant::GetAsJSVal(JS::MutableHandleValue _retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* [noscript] void getAsInterface (out nsIIDPtr iid, [iid_is (iid), retval] out nsQIResult iface); */
NS_IMETHODIMP nsVariant::GetAsInterface(nsIID **iid, void **iface)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* [notxpcom] nsresult getAsArray (out uint16_t type, out nsIID iid, out uint32_t count, out voidPtr ptr); */
NS_IMETHODIMP_(nsresult) nsVariant::GetAsArray(uint16_t *type, nsIID *iid, uint32_t *count, void **ptr)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* [noscript] void getAsStringWithSize (out uint32_t size, [size_is (size), retval] out string str); */
NS_IMETHODIMP nsVariant::GetAsStringWithSize(uint32_t *size, char * *str)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* [noscript] void getAsWStringWithSize (out uint32_t size, [size_is (size), retval] out wstring str); */
NS_IMETHODIMP nsVariant::GetAsWStringWithSize(uint32_t *size, char16_t * *str)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* End of implementation class template. */
#endif


/* starting interface:    nsIWritableVariant */
#define NS_IWRITABLEVARIANT_IID_STR "5586a590-8c82-11d5-90f3-0010a4e73d9a"

#define NS_IWRITABLEVARIANT_IID \
  {0x5586a590, 0x8c82, 0x11d5, \
    { 0x90, 0xf3, 0x00, 0x10, 0xa4, 0xe7, 0x3d, 0x9a }}

class NS_NO_VTABLE nsIWritableVariant : public nsIVariant {
 public:

  NS_DECLARE_STATIC_IID_ACCESSOR(NS_IWRITABLEVARIANT_IID)

  /* attribute boolean writable; */
  NS_IMETHOD GetWritable(bool *aWritable) = 0;
  NS_IMETHOD SetWritable(bool aWritable) = 0;

  /* void setAsInt8 (in uint8_t aValue); */
  NS_IMETHOD SetAsInt8(uint8_t aValue) = 0;

  /* void setAsInt16 (in int16_t aValue); */
  NS_IMETHOD SetAsInt16(int16_t aValue) = 0;

  /* void setAsInt32 (in int32_t aValue); */
  NS_IMETHOD SetAsInt32(int32_t aValue) = 0;

  /* void setAsInt64 (in int64_t aValue); */
  NS_IMETHOD SetAsInt64(int64_t aValue) = 0;

  /* void setAsUint8 (in uint8_t aValue); */
  NS_IMETHOD SetAsUint8(uint8_t aValue) = 0;

  /* void setAsUint16 (in uint16_t aValue); */
  NS_IMETHOD SetAsUint16(uint16_t aValue) = 0;

  /* void setAsUint32 (in uint32_t aValue); */
  NS_IMETHOD SetAsUint32(uint32_t aValue) = 0;

  /* void setAsUint64 (in uint64_t aValue); */
  NS_IMETHOD SetAsUint64(uint64_t aValue) = 0;

  /* void setAsFloat (in float aValue); */
  NS_IMETHOD SetAsFloat(float aValue) = 0;

  /* void setAsDouble (in double aValue); */
  NS_IMETHOD SetAsDouble(double aValue) = 0;

  /* void setAsBool (in boolean aValue); */
  NS_IMETHOD SetAsBool(bool aValue) = 0;

  /* void setAsChar (in char aValue); */
  NS_IMETHOD SetAsChar(char aValue) = 0;

  /* void setAsWChar (in wchar aValue); */
  NS_IMETHOD SetAsWChar(char16_t aValue) = 0;

  /* void setAsID (in nsIDRef aValue); */
  NS_IMETHOD SetAsID(const nsID & aValue) = 0;

  /* void setAsAString (in AString aValue); */
  NS_IMETHOD SetAsAString(const nsAString & aValue) = 0;

  /* void setAsDOMString (in DOMString aValue); */
  NS_IMETHOD SetAsDOMString(const nsAString & aValue) = 0;

  /* void setAsACString (in ACString aValue); */
  NS_IMETHOD SetAsACString(const nsACString & aValue) = 0;

  /* void setAsAUTF8String (in AUTF8String aValue); */
  NS_IMETHOD SetAsAUTF8String(const nsACString & aValue) = 0;

  /* void setAsString (in string aValue); */
  NS_IMETHOD SetAsString(const char * aValue) = 0;

  /* void setAsWString (in wstring aValue); */
  NS_IMETHOD SetAsWString(const char16_t * aValue) = 0;

  /* void setAsISupports (in nsISupports aValue); */
  NS_IMETHOD SetAsISupports(nsISupports *aValue) = 0;

  /* void setAsInterface (in nsIIDRef iid, [iid_is (iid)] in nsQIResult iface); */
  NS_IMETHOD SetAsInterface(const nsIID & iid, void *iface) = 0;

  /* [noscript] void setAsArray (in uint16_t type, in nsIIDPtr iid, in uint32_t count, in voidPtr ptr); */
  NS_IMETHOD SetAsArray(uint16_t type, const nsIID *iid, uint32_t count, void *ptr) = 0;

  /* void setAsStringWithSize (in uint32_t size, [size_is (size)] in string str); */
  NS_IMETHOD SetAsStringWithSize(uint32_t size, const char * str) = 0;

  /* void setAsWStringWithSize (in uint32_t size, [size_is (size)] in wstring str); */
  NS_IMETHOD SetAsWStringWithSize(uint32_t size, const char16_t * str) = 0;

  /* void setAsVoid (); */
  NS_IMETHOD SetAsVoid(void) = 0;

  /* void setAsEmpty (); */
  NS_IMETHOD SetAsEmpty(void) = 0;

  /* void setAsEmptyArray (); */
  NS_IMETHOD SetAsEmptyArray(void) = 0;

  /* void setFromVariant (in nsIVariant aValue); */
  NS_IMETHOD SetFromVariant(nsIVariant *aValue) = 0;

};

  NS_DEFINE_STATIC_IID_ACCESSOR(nsIWritableVariant, NS_IWRITABLEVARIANT_IID)

/* Use this macro when declaring classes that implement this interface. */
#define NS_DECL_NSIWRITABLEVARIANT \
  NS_IMETHOD GetWritable(bool *aWritable) override; \
  NS_IMETHOD SetWritable(bool aWritable) override; \
  NS_IMETHOD SetAsInt8(uint8_t aValue) override; \
  NS_IMETHOD SetAsInt16(int16_t aValue) override; \
  NS_IMETHOD SetAsInt32(int32_t aValue) override; \
  NS_IMETHOD SetAsInt64(int64_t aValue) override; \
  NS_IMETHOD SetAsUint8(uint8_t aValue) override; \
  NS_IMETHOD SetAsUint16(uint16_t aValue) override; \
  NS_IMETHOD SetAsUint32(uint32_t aValue) override; \
  NS_IMETHOD SetAsUint64(uint64_t aValue) override; \
  NS_IMETHOD SetAsFloat(float aValue) override; \
  NS_IMETHOD SetAsDouble(double aValue) override; \
  NS_IMETHOD SetAsBool(bool aValue) override; \
  NS_IMETHOD SetAsChar(char aValue) override; \
  NS_IMETHOD SetAsWChar(char16_t aValue) override; \
  NS_IMETHOD SetAsID(const nsID & aValue) override; \
  NS_IMETHOD SetAsAString(const nsAString & aValue) override; \
  NS_IMETHOD SetAsDOMString(const nsAString & aValue) override; \
  NS_IMETHOD SetAsACString(const nsACString & aValue) override; \
  NS_IMETHOD SetAsAUTF8String(const nsACString & aValue) override; \
  NS_IMETHOD SetAsString(const char * aValue) override; \
  NS_IMETHOD SetAsWString(const char16_t * aValue) override; \
  NS_IMETHOD SetAsISupports(nsISupports *aValue) override; \
  NS_IMETHOD SetAsInterface(const nsIID & iid, void *iface) override; \
  NS_IMETHOD SetAsArray(uint16_t type, const nsIID *iid, uint32_t count, void *ptr) override; \
  NS_IMETHOD SetAsStringWithSize(uint32_t size, const char * str) override; \
  NS_IMETHOD SetAsWStringWithSize(uint32_t size, const char16_t * str) override; \
  NS_IMETHOD SetAsVoid(void) override; \
  NS_IMETHOD SetAsEmpty(void) override; \
  NS_IMETHOD SetAsEmptyArray(void) override; \
  NS_IMETHOD SetFromVariant(nsIVariant *aValue) override; 

/* Use this macro when declaring the members of this interface when the
   class doesn't implement the interface. This is useful for forwarding. */
#define NS_DECL_NON_VIRTUAL_NSIWRITABLEVARIANT \
  NS_METHOD GetWritable(bool *aWritable); \
  NS_METHOD SetWritable(bool aWritable); \
  NS_METHOD SetAsInt8(uint8_t aValue); \
  NS_METHOD SetAsInt16(int16_t aValue); \
  NS_METHOD SetAsInt32(int32_t aValue); \
  NS_METHOD SetAsInt64(int64_t aValue); \
  NS_METHOD SetAsUint8(uint8_t aValue); \
  NS_METHOD SetAsUint16(uint16_t aValue); \
  NS_METHOD SetAsUint32(uint32_t aValue); \
  NS_METHOD SetAsUint64(uint64_t aValue); \
  NS_METHOD SetAsFloat(float aValue); \
  NS_METHOD SetAsDouble(double aValue); \
  NS_METHOD SetAsBool(bool aValue); \
  NS_METHOD SetAsChar(char aValue); \
  NS_METHOD SetAsWChar(char16_t aValue); \
  NS_METHOD SetAsID(const nsID & aValue); \
  NS_METHOD SetAsAString(const nsAString & aValue); \
  NS_METHOD SetAsDOMString(const nsAString & aValue); \
  NS_METHOD SetAsACString(const nsACString & aValue); \
  NS_METHOD SetAsAUTF8String(const nsACString & aValue); \
  NS_METHOD SetAsString(const char * aValue); \
  NS_METHOD SetAsWString(const char16_t * aValue); \
  NS_METHOD SetAsISupports(nsISupports *aValue); \
  NS_METHOD SetAsInterface(const nsIID & iid, void *iface); \
  NS_METHOD SetAsArray(uint16_t type, const nsIID *iid, uint32_t count, void *ptr); \
  NS_METHOD SetAsStringWithSize(uint32_t size, const char * str); \
  NS_METHOD SetAsWStringWithSize(uint32_t size, const char16_t * str); \
  NS_METHOD SetAsVoid(void); \
  NS_METHOD SetAsEmpty(void); \
  NS_METHOD SetAsEmptyArray(void); \
  NS_METHOD SetFromVariant(nsIVariant *aValue); 

/* Use this macro to declare functions that forward the behavior of this interface to another object. */
#define NS_FORWARD_NSIWRITABLEVARIANT(_to) \
  NS_IMETHOD GetWritable(bool *aWritable) override { return _to GetWritable(aWritable); } \
  NS_IMETHOD SetWritable(bool aWritable) override { return _to SetWritable(aWritable); } \
  NS_IMETHOD SetAsInt8(uint8_t aValue) override { return _to SetAsInt8(aValue); } \
  NS_IMETHOD SetAsInt16(int16_t aValue) override { return _to SetAsInt16(aValue); } \
  NS_IMETHOD SetAsInt32(int32_t aValue) override { return _to SetAsInt32(aValue); } \
  NS_IMETHOD SetAsInt64(int64_t aValue) override { return _to SetAsInt64(aValue); } \
  NS_IMETHOD SetAsUint8(uint8_t aValue) override { return _to SetAsUint8(aValue); } \
  NS_IMETHOD SetAsUint16(uint16_t aValue) override { return _to SetAsUint16(aValue); } \
  NS_IMETHOD SetAsUint32(uint32_t aValue) override { return _to SetAsUint32(aValue); } \
  NS_IMETHOD SetAsUint64(uint64_t aValue) override { return _to SetAsUint64(aValue); } \
  NS_IMETHOD SetAsFloat(float aValue) override { return _to SetAsFloat(aValue); } \
  NS_IMETHOD SetAsDouble(double aValue) override { return _to SetAsDouble(aValue); } \
  NS_IMETHOD SetAsBool(bool aValue) override { return _to SetAsBool(aValue); } \
  NS_IMETHOD SetAsChar(char aValue) override { return _to SetAsChar(aValue); } \
  NS_IMETHOD SetAsWChar(char16_t aValue) override { return _to SetAsWChar(aValue); } \
  NS_IMETHOD SetAsID(const nsID & aValue) override { return _to SetAsID(aValue); } \
  NS_IMETHOD SetAsAString(const nsAString & aValue) override { return _to SetAsAString(aValue); } \
  NS_IMETHOD SetAsDOMString(const nsAString & aValue) override { return _to SetAsDOMString(aValue); } \
  NS_IMETHOD SetAsACString(const nsACString & aValue) override { return _to SetAsACString(aValue); } \
  NS_IMETHOD SetAsAUTF8String(const nsACString & aValue) override { return _to SetAsAUTF8String(aValue); } \
  NS_IMETHOD SetAsString(const char * aValue) override { return _to SetAsString(aValue); } \
  NS_IMETHOD SetAsWString(const char16_t * aValue) override { return _to SetAsWString(aValue); } \
  NS_IMETHOD SetAsISupports(nsISupports *aValue) override { return _to SetAsISupports(aValue); } \
  NS_IMETHOD SetAsInterface(const nsIID & iid, void *iface) override { return _to SetAsInterface(iid, iface); } \
  NS_IMETHOD SetAsArray(uint16_t type, const nsIID *iid, uint32_t count, void *ptr) override { return _to SetAsArray(type, iid, count, ptr); } \
  NS_IMETHOD SetAsStringWithSize(uint32_t size, const char * str) override { return _to SetAsStringWithSize(size, str); } \
  NS_IMETHOD SetAsWStringWithSize(uint32_t size, const char16_t * str) override { return _to SetAsWStringWithSize(size, str); } \
  NS_IMETHOD SetAsVoid(void) override { return _to SetAsVoid(); } \
  NS_IMETHOD SetAsEmpty(void) override { return _to SetAsEmpty(); } \
  NS_IMETHOD SetAsEmptyArray(void) override { return _to SetAsEmptyArray(); } \
  NS_IMETHOD SetFromVariant(nsIVariant *aValue) override { return _to SetFromVariant(aValue); } 

/* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
#define NS_FORWARD_SAFE_NSIWRITABLEVARIANT(_to) \
  NS_IMETHOD GetWritable(bool *aWritable) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetWritable(aWritable); } \
  NS_IMETHOD SetWritable(bool aWritable) override { return !_to ? NS_ERROR_NULL_POINTER : _to->SetWritable(aWritable); } \
  NS_IMETHOD SetAsInt8(uint8_t aValue) override { return !_to ? NS_ERROR_NULL_POINTER : _to->SetAsInt8(aValue); } \
  NS_IMETHOD SetAsInt16(int16_t aValue) override { return !_to ? NS_ERROR_NULL_POINTER : _to->SetAsInt16(aValue); } \
  NS_IMETHOD SetAsInt32(int32_t aValue) override { return !_to ? NS_ERROR_NULL_POINTER : _to->SetAsInt32(aValue); } \
  NS_IMETHOD SetAsInt64(int64_t aValue) override { return !_to ? NS_ERROR_NULL_POINTER : _to->SetAsInt64(aValue); } \
  NS_IMETHOD SetAsUint8(uint8_t aValue) override { return !_to ? NS_ERROR_NULL_POINTER : _to->SetAsUint8(aValue); } \
  NS_IMETHOD SetAsUint16(uint16_t aValue) override { return !_to ? NS_ERROR_NULL_POINTER : _to->SetAsUint16(aValue); } \
  NS_IMETHOD SetAsUint32(uint32_t aValue) override { return !_to ? NS_ERROR_NULL_POINTER : _to->SetAsUint32(aValue); } \
  NS_IMETHOD SetAsUint64(uint64_t aValue) override { return !_to ? NS_ERROR_NULL_POINTER : _to->SetAsUint64(aValue); } \
  NS_IMETHOD SetAsFloat(float aValue) override { return !_to ? NS_ERROR_NULL_POINTER : _to->SetAsFloat(aValue); } \
  NS_IMETHOD SetAsDouble(double aValue) override { return !_to ? NS_ERROR_NULL_POINTER : _to->SetAsDouble(aValue); } \
  NS_IMETHOD SetAsBool(bool aValue) override { return !_to ? NS_ERROR_NULL_POINTER : _to->SetAsBool(aValue); } \
  NS_IMETHOD SetAsChar(char aValue) override { return !_to ? NS_ERROR_NULL_POINTER : _to->SetAsChar(aValue); } \
  NS_IMETHOD SetAsWChar(char16_t aValue) override { return !_to ? NS_ERROR_NULL_POINTER : _to->SetAsWChar(aValue); } \
  NS_IMETHOD SetAsID(const nsID & aValue) override { return !_to ? NS_ERROR_NULL_POINTER : _to->SetAsID(aValue); } \
  NS_IMETHOD SetAsAString(const nsAString & aValue) override { return !_to ? NS_ERROR_NULL_POINTER : _to->SetAsAString(aValue); } \
  NS_IMETHOD SetAsDOMString(const nsAString & aValue) override { return !_to ? NS_ERROR_NULL_POINTER : _to->SetAsDOMString(aValue); } \
  NS_IMETHOD SetAsACString(const nsACString & aValue) override { return !_to ? NS_ERROR_NULL_POINTER : _to->SetAsACString(aValue); } \
  NS_IMETHOD SetAsAUTF8String(const nsACString & aValue) override { return !_to ? NS_ERROR_NULL_POINTER : _to->SetAsAUTF8String(aValue); } \
  NS_IMETHOD SetAsString(const char * aValue) override { return !_to ? NS_ERROR_NULL_POINTER : _to->SetAsString(aValue); } \
  NS_IMETHOD SetAsWString(const char16_t * aValue) override { return !_to ? NS_ERROR_NULL_POINTER : _to->SetAsWString(aValue); } \
  NS_IMETHOD SetAsISupports(nsISupports *aValue) override { return !_to ? NS_ERROR_NULL_POINTER : _to->SetAsISupports(aValue); } \
  NS_IMETHOD SetAsInterface(const nsIID & iid, void *iface) override { return !_to ? NS_ERROR_NULL_POINTER : _to->SetAsInterface(iid, iface); } \
  NS_IMETHOD SetAsArray(uint16_t type, const nsIID *iid, uint32_t count, void *ptr) override { return !_to ? NS_ERROR_NULL_POINTER : _to->SetAsArray(type, iid, count, ptr); } \
  NS_IMETHOD SetAsStringWithSize(uint32_t size, const char * str) override { return !_to ? NS_ERROR_NULL_POINTER : _to->SetAsStringWithSize(size, str); } \
  NS_IMETHOD SetAsWStringWithSize(uint32_t size, const char16_t * str) override { return !_to ? NS_ERROR_NULL_POINTER : _to->SetAsWStringWithSize(size, str); } \
  NS_IMETHOD SetAsVoid(void) override { return !_to ? NS_ERROR_NULL_POINTER : _to->SetAsVoid(); } \
  NS_IMETHOD SetAsEmpty(void) override { return !_to ? NS_ERROR_NULL_POINTER : _to->SetAsEmpty(); } \
  NS_IMETHOD SetAsEmptyArray(void) override { return !_to ? NS_ERROR_NULL_POINTER : _to->SetAsEmptyArray(); } \
  NS_IMETHOD SetFromVariant(nsIVariant *aValue) override { return !_to ? NS_ERROR_NULL_POINTER : _to->SetFromVariant(aValue); } 

#if 0
/* Use the code below as a template for the implementation class for this interface. */

/* Header file */
class nsWritableVariant : public nsIWritableVariant
{
public:
  NS_DECL_ISUPPORTS
  NS_DECL_NSIWRITABLEVARIANT

  nsWritableVariant();

private:
  ~nsWritableVariant();

protected:
  /* additional members */
};

/* Implementation file */
NS_IMPL_ISUPPORTS(nsWritableVariant, nsIWritableVariant)

nsWritableVariant::nsWritableVariant()
{
  /* member initializers and constructor code */
}

nsWritableVariant::~nsWritableVariant()
{
  /* destructor code */
}

/* attribute boolean writable; */
NS_IMETHODIMP nsWritableVariant::GetWritable(bool *aWritable)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP nsWritableVariant::SetWritable(bool aWritable)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void setAsInt8 (in uint8_t aValue); */
NS_IMETHODIMP nsWritableVariant::SetAsInt8(uint8_t aValue)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void setAsInt16 (in int16_t aValue); */
NS_IMETHODIMP nsWritableVariant::SetAsInt16(int16_t aValue)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void setAsInt32 (in int32_t aValue); */
NS_IMETHODIMP nsWritableVariant::SetAsInt32(int32_t aValue)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void setAsInt64 (in int64_t aValue); */
NS_IMETHODIMP nsWritableVariant::SetAsInt64(int64_t aValue)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void setAsUint8 (in uint8_t aValue); */
NS_IMETHODIMP nsWritableVariant::SetAsUint8(uint8_t aValue)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void setAsUint16 (in uint16_t aValue); */
NS_IMETHODIMP nsWritableVariant::SetAsUint16(uint16_t aValue)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void setAsUint32 (in uint32_t aValue); */
NS_IMETHODIMP nsWritableVariant::SetAsUint32(uint32_t aValue)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void setAsUint64 (in uint64_t aValue); */
NS_IMETHODIMP nsWritableVariant::SetAsUint64(uint64_t aValue)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void setAsFloat (in float aValue); */
NS_IMETHODIMP nsWritableVariant::SetAsFloat(float aValue)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void setAsDouble (in double aValue); */
NS_IMETHODIMP nsWritableVariant::SetAsDouble(double aValue)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void setAsBool (in boolean aValue); */
NS_IMETHODIMP nsWritableVariant::SetAsBool(bool aValue)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void setAsChar (in char aValue); */
NS_IMETHODIMP nsWritableVariant::SetAsChar(char aValue)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void setAsWChar (in wchar aValue); */
NS_IMETHODIMP nsWritableVariant::SetAsWChar(char16_t aValue)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void setAsID (in nsIDRef aValue); */
NS_IMETHODIMP nsWritableVariant::SetAsID(const nsID & aValue)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void setAsAString (in AString aValue); */
NS_IMETHODIMP nsWritableVariant::SetAsAString(const nsAString & aValue)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void setAsDOMString (in DOMString aValue); */
NS_IMETHODIMP nsWritableVariant::SetAsDOMString(const nsAString & aValue)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void setAsACString (in ACString aValue); */
NS_IMETHODIMP nsWritableVariant::SetAsACString(const nsACString & aValue)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void setAsAUTF8String (in AUTF8String aValue); */
NS_IMETHODIMP nsWritableVariant::SetAsAUTF8String(const nsACString & aValue)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void setAsString (in string aValue); */
NS_IMETHODIMP nsWritableVariant::SetAsString(const char * aValue)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void setAsWString (in wstring aValue); */
NS_IMETHODIMP nsWritableVariant::SetAsWString(const char16_t * aValue)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void setAsISupports (in nsISupports aValue); */
NS_IMETHODIMP nsWritableVariant::SetAsISupports(nsISupports *aValue)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void setAsInterface (in nsIIDRef iid, [iid_is (iid)] in nsQIResult iface); */
NS_IMETHODIMP nsWritableVariant::SetAsInterface(const nsIID & iid, void *iface)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* [noscript] void setAsArray (in uint16_t type, in nsIIDPtr iid, in uint32_t count, in voidPtr ptr); */
NS_IMETHODIMP nsWritableVariant::SetAsArray(uint16_t type, const nsIID *iid, uint32_t count, void *ptr)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void setAsStringWithSize (in uint32_t size, [size_is (size)] in string str); */
NS_IMETHODIMP nsWritableVariant::SetAsStringWithSize(uint32_t size, const char * str)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void setAsWStringWithSize (in uint32_t size, [size_is (size)] in wstring str); */
NS_IMETHODIMP nsWritableVariant::SetAsWStringWithSize(uint32_t size, const char16_t * str)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void setAsVoid (); */
NS_IMETHODIMP nsWritableVariant::SetAsVoid()
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void setAsEmpty (); */
NS_IMETHODIMP nsWritableVariant::SetAsEmpty()
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void setAsEmptyArray (); */
NS_IMETHODIMP nsWritableVariant::SetAsEmptyArray()
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void setFromVariant (in nsIVariant aValue); */
NS_IMETHODIMP nsWritableVariant::SetFromVariant(nsIVariant *aValue)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* End of implementation class template. */
#endif

// The contractID for the generic implementation built in to xpcom.
#define NS_VARIANT_CONTRACTID "@mozilla.org/variant;1"

#endif /* __gen_nsIVariant_h__ */
