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

#ifndef __gen_flockIXmlRpc_h__
#define __gen_flockIXmlRpc_h__


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

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

/* starting interface:    flockIXmlRpcValue */
#define FLOCKIXMLRPCVALUE_IID_STR "c4ef02f3-0231-471f-b0f6-c9015d09c5ff"

#define FLOCKIXMLRPCVALUE_IID \
  {0xc4ef02f3, 0x0231, 0x471f, \
    { 0xb0, 0xf6, 0xc9, 0x01, 0x5d, 0x09, 0xc5, 0xff }}

class NS_NO_VTABLE flockIXmlRpcValue : public nsISupports {
 public: 

  NS_DEFINE_STATIC_IID_ACCESSOR(FLOCKIXMLRPCVALUE_IID)

  enum { TYPE_INT = 1U };

  enum { TYPE_BOOLEAN = 2U };

  enum { TYPE_STRING = 3U };

  enum { TYPE_DOUBLE = 4U };

  enum { TYPE_DATETIME = 5U };

  enum { TYPE_ARRAY = 6U };

  enum { TYPE_STRUCT = 7U };

  enum { TYPE_BASE64 = 8U };

  /* readonly attribute unsigned long XmlRpcType; */
  NS_IMETHOD GetXmlRpcType(PRUint32 *aXmlRpcType) = 0;

  /* readonly attribute long IntValue; */
  NS_IMETHOD GetIntValue(PRInt32 *aIntValue) = 0;

  /* readonly attribute boolean BooleanValue; */
  NS_IMETHOD GetBooleanValue(PRBool *aBooleanValue) = 0;

  /* readonly attribute AString StringValue; */
  NS_IMETHOD GetStringValue(nsAString & aStringValue) = 0;

  /* readonly attribute double DoubleValue; */
  NS_IMETHOD GetDoubleValue(double *aDoubleValue) = 0;

  /* readonly attribute unsigned long DateTimeValue; */
  NS_IMETHOD GetDateTimeValue(PRUint32 *aDateTimeValue) = 0;

  /* void ArrayElements (out PRUint32 aCount, [array, size_is (aCount), retval] out flockIXmlRpcValue aElements); */
  NS_IMETHOD ArrayElements(PRUint32 *aCount, flockIXmlRpcValue ***aElements) = 0;

  /* void StructKeys (out PRUint32 aCount, [array, size_is (aCount), retval] out string aKeys); */
  NS_IMETHOD StructKeys(PRUint32 *aCount, char ***aKeys) = 0;

  /* flockIXmlRpcValue StructItem (in string aKey); */
  NS_IMETHOD StructItem(const char *aKey, flockIXmlRpcValue **_retval) = 0;

  /* readonly attribute ACString Base64Value; */
  NS_IMETHOD GetBase64Value(nsACString & aBase64Value) = 0;

};

/* Use this macro when declaring classes that implement this interface. */
#define NS_DECL_FLOCKIXMLRPCVALUE \
  NS_IMETHOD GetXmlRpcType(PRUint32 *aXmlRpcType); \
  NS_IMETHOD GetIntValue(PRInt32 *aIntValue); \
  NS_IMETHOD GetBooleanValue(PRBool *aBooleanValue); \
  NS_IMETHOD GetStringValue(nsAString & aStringValue); \
  NS_IMETHOD GetDoubleValue(double *aDoubleValue); \
  NS_IMETHOD GetDateTimeValue(PRUint32 *aDateTimeValue); \
  NS_IMETHOD ArrayElements(PRUint32 *aCount, flockIXmlRpcValue ***aElements); \
  NS_IMETHOD StructKeys(PRUint32 *aCount, char ***aKeys); \
  NS_IMETHOD StructItem(const char *aKey, flockIXmlRpcValue **_retval); \
  NS_IMETHOD GetBase64Value(nsACString & aBase64Value); 

/* Use this macro to declare functions that forward the behavior of this interface to another object. */
#define NS_FORWARD_FLOCKIXMLRPCVALUE(_to) \
  NS_IMETHOD GetXmlRpcType(PRUint32 *aXmlRpcType) { return _to GetXmlRpcType(aXmlRpcType); } \
  NS_IMETHOD GetIntValue(PRInt32 *aIntValue) { return _to GetIntValue(aIntValue); } \
  NS_IMETHOD GetBooleanValue(PRBool *aBooleanValue) { return _to GetBooleanValue(aBooleanValue); } \
  NS_IMETHOD GetStringValue(nsAString & aStringValue) { return _to GetStringValue(aStringValue); } \
  NS_IMETHOD GetDoubleValue(double *aDoubleValue) { return _to GetDoubleValue(aDoubleValue); } \
  NS_IMETHOD GetDateTimeValue(PRUint32 *aDateTimeValue) { return _to GetDateTimeValue(aDateTimeValue); } \
  NS_IMETHOD ArrayElements(PRUint32 *aCount, flockIXmlRpcValue ***aElements) { return _to ArrayElements(aCount, aElements); } \
  NS_IMETHOD StructKeys(PRUint32 *aCount, char ***aKeys) { return _to StructKeys(aCount, aKeys); } \
  NS_IMETHOD StructItem(const char *aKey, flockIXmlRpcValue **_retval) { return _to StructItem(aKey, _retval); } \
  NS_IMETHOD GetBase64Value(nsACString & aBase64Value) { return _to GetBase64Value(aBase64Value); } 

/* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
#define NS_FORWARD_SAFE_FLOCKIXMLRPCVALUE(_to) \
  NS_IMETHOD GetXmlRpcType(PRUint32 *aXmlRpcType) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetXmlRpcType(aXmlRpcType); } \
  NS_IMETHOD GetIntValue(PRInt32 *aIntValue) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetIntValue(aIntValue); } \
  NS_IMETHOD GetBooleanValue(PRBool *aBooleanValue) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetBooleanValue(aBooleanValue); } \
  NS_IMETHOD GetStringValue(nsAString & aStringValue) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetStringValue(aStringValue); } \
  NS_IMETHOD GetDoubleValue(double *aDoubleValue) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetDoubleValue(aDoubleValue); } \
  NS_IMETHOD GetDateTimeValue(PRUint32 *aDateTimeValue) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetDateTimeValue(aDateTimeValue); } \
  NS_IMETHOD ArrayElements(PRUint32 *aCount, flockIXmlRpcValue ***aElements) { return !_to ? NS_ERROR_NULL_POINTER : _to->ArrayElements(aCount, aElements); } \
  NS_IMETHOD StructKeys(PRUint32 *aCount, char ***aKeys) { return !_to ? NS_ERROR_NULL_POINTER : _to->StructKeys(aCount, aKeys); } \
  NS_IMETHOD StructItem(const char *aKey, flockIXmlRpcValue **_retval) { return !_to ? NS_ERROR_NULL_POINTER : _to->StructItem(aKey, _retval); } \
  NS_IMETHOD GetBase64Value(nsACString & aBase64Value) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetBase64Value(aBase64Value); } 

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

/* Header file */
class _MYCLASS_ : public flockIXmlRpcValue
{
public:
  NS_DECL_ISUPPORTS
  NS_DECL_FLOCKIXMLRPCVALUE

  _MYCLASS_();

private:
  ~_MYCLASS_();

protected:
  /* additional members */
};

/* Implementation file */
NS_IMPL_ISUPPORTS1(_MYCLASS_, flockIXmlRpcValue)

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

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

/* readonly attribute unsigned long XmlRpcType; */
NS_IMETHODIMP _MYCLASS_::GetXmlRpcType(PRUint32 *aXmlRpcType)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* readonly attribute long IntValue; */
NS_IMETHODIMP _MYCLASS_::GetIntValue(PRInt32 *aIntValue)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* readonly attribute boolean BooleanValue; */
NS_IMETHODIMP _MYCLASS_::GetBooleanValue(PRBool *aBooleanValue)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* readonly attribute AString StringValue; */
NS_IMETHODIMP _MYCLASS_::GetStringValue(nsAString & aStringValue)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* readonly attribute double DoubleValue; */
NS_IMETHODIMP _MYCLASS_::GetDoubleValue(double *aDoubleValue)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* readonly attribute unsigned long DateTimeValue; */
NS_IMETHODIMP _MYCLASS_::GetDateTimeValue(PRUint32 *aDateTimeValue)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void ArrayElements (out PRUint32 aCount, [array, size_is (aCount), retval] out flockIXmlRpcValue aElements); */
NS_IMETHODIMP _MYCLASS_::ArrayElements(PRUint32 *aCount, flockIXmlRpcValue ***aElements)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void StructKeys (out PRUint32 aCount, [array, size_is (aCount), retval] out string aKeys); */
NS_IMETHODIMP _MYCLASS_::StructKeys(PRUint32 *aCount, char ***aKeys)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* flockIXmlRpcValue StructItem (in string aKey); */
NS_IMETHODIMP _MYCLASS_::StructItem(const char *aKey, flockIXmlRpcValue **_retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* readonly attribute ACString Base64Value; */
NS_IMETHODIMP _MYCLASS_::GetBase64Value(nsACString & aBase64Value)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

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


/* starting interface:    flockIXmlRpcListener */
#define FLOCKIXMLRPCLISTENER_IID_STR "edf6121e-9ed5-4378-abaf-66c5e9b137c5"

#define FLOCKIXMLRPCLISTENER_IID \
  {0xedf6121e, 0x9ed5, 0x4378, \
    { 0xab, 0xaf, 0x66, 0xc5, 0xe9, 0xb1, 0x37, 0xc5 }}

class NS_NO_VTABLE flockIXmlRpcListener : public nsISupports {
 public: 

  NS_DEFINE_STATIC_IID_ACCESSOR(FLOCKIXMLRPCLISTENER_IID)

  /* void onResult (in flockIXmlRpcValue aResult); */
  NS_IMETHOD OnResult(flockIXmlRpcValue *aResult) = 0;

  /* void onFault (in long aFaultCode, in string aFaultString); */
  NS_IMETHOD OnFault(PRInt32 aFaultCode, const char *aFaultString) = 0;

  /* void onError (in string aMessage); */
  NS_IMETHOD OnError(const char *aMessage) = 0;

};

/* Use this macro when declaring classes that implement this interface. */
#define NS_DECL_FLOCKIXMLRPCLISTENER \
  NS_IMETHOD OnResult(flockIXmlRpcValue *aResult); \
  NS_IMETHOD OnFault(PRInt32 aFaultCode, const char *aFaultString); \
  NS_IMETHOD OnError(const char *aMessage); 

/* Use this macro to declare functions that forward the behavior of this interface to another object. */
#define NS_FORWARD_FLOCKIXMLRPCLISTENER(_to) \
  NS_IMETHOD OnResult(flockIXmlRpcValue *aResult) { return _to OnResult(aResult); } \
  NS_IMETHOD OnFault(PRInt32 aFaultCode, const char *aFaultString) { return _to OnFault(aFaultCode, aFaultString); } \
  NS_IMETHOD OnError(const char *aMessage) { return _to OnError(aMessage); } 

/* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
#define NS_FORWARD_SAFE_FLOCKIXMLRPCLISTENER(_to) \
  NS_IMETHOD OnResult(flockIXmlRpcValue *aResult) { return !_to ? NS_ERROR_NULL_POINTER : _to->OnResult(aResult); } \
  NS_IMETHOD OnFault(PRInt32 aFaultCode, const char *aFaultString) { return !_to ? NS_ERROR_NULL_POINTER : _to->OnFault(aFaultCode, aFaultString); } \
  NS_IMETHOD OnError(const char *aMessage) { return !_to ? NS_ERROR_NULL_POINTER : _to->OnError(aMessage); } 

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

/* Header file */
class _MYCLASS_ : public flockIXmlRpcListener
{
public:
  NS_DECL_ISUPPORTS
  NS_DECL_FLOCKIXMLRPCLISTENER

  _MYCLASS_();

private:
  ~_MYCLASS_();

protected:
  /* additional members */
};

/* Implementation file */
NS_IMPL_ISUPPORTS1(_MYCLASS_, flockIXmlRpcListener)

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

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

/* void onResult (in flockIXmlRpcValue aResult); */
NS_IMETHODIMP _MYCLASS_::OnResult(flockIXmlRpcValue *aResult)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void onFault (in long aFaultCode, in string aFaultString); */
NS_IMETHODIMP _MYCLASS_::OnFault(PRInt32 aFaultCode, const char *aFaultString)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void onError (in string aMessage); */
NS_IMETHODIMP _MYCLASS_::OnError(const char *aMessage)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

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


/* starting interface:    flockIXmlRpcServer */
#define FLOCKIXMLRPCSERVER_IID_STR "ed567267-a11a-4526-8e29-6af6001818cc"

#define FLOCKIXMLRPCSERVER_IID \
  {0xed567267, 0xa11a, 0x4526, \
    { 0x8e, 0x29, 0x6a, 0xf6, 0x00, 0x18, 0x18, 0xcc }}

class NS_NO_VTABLE flockIXmlRpcServer : public nsISupports {
 public: 

  NS_DEFINE_STATIC_IID_ACCESSOR(FLOCKIXMLRPCSERVER_IID)

  /* void init (in string aURL); */
  NS_IMETHOD Init(const char *aURL) = 0;

  /* void call (in string aMethod, in flockIXmlRpcValue aArguments, in flockIXmlRpcListener aListener); */
  NS_IMETHOD Call(const char *aMethod, flockIXmlRpcValue *aArguments, flockIXmlRpcListener *aListener) = 0;

};

/* Use this macro when declaring classes that implement this interface. */
#define NS_DECL_FLOCKIXMLRPCSERVER \
  NS_IMETHOD Init(const char *aURL); \
  NS_IMETHOD Call(const char *aMethod, flockIXmlRpcValue *aArguments, flockIXmlRpcListener *aListener); 

/* Use this macro to declare functions that forward the behavior of this interface to another object. */
#define NS_FORWARD_FLOCKIXMLRPCSERVER(_to) \
  NS_IMETHOD Init(const char *aURL) { return _to Init(aURL); } \
  NS_IMETHOD Call(const char *aMethod, flockIXmlRpcValue *aArguments, flockIXmlRpcListener *aListener) { return _to Call(aMethod, aArguments, aListener); } 

/* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
#define NS_FORWARD_SAFE_FLOCKIXMLRPCSERVER(_to) \
  NS_IMETHOD Init(const char *aURL) { return !_to ? NS_ERROR_NULL_POINTER : _to->Init(aURL); } \
  NS_IMETHOD Call(const char *aMethod, flockIXmlRpcValue *aArguments, flockIXmlRpcListener *aListener) { return !_to ? NS_ERROR_NULL_POINTER : _to->Call(aMethod, aArguments, aListener); } 

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

/* Header file */
class _MYCLASS_ : public flockIXmlRpcServer
{
public:
  NS_DECL_ISUPPORTS
  NS_DECL_FLOCKIXMLRPCSERVER

  _MYCLASS_();

private:
  ~_MYCLASS_();

protected:
  /* additional members */
};

/* Implementation file */
NS_IMPL_ISUPPORTS1(_MYCLASS_, flockIXmlRpcServer)

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

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

/* void init (in string aURL); */
NS_IMETHODIMP _MYCLASS_::Init(const char *aURL)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void call (in string aMethod, in flockIXmlRpcValue aArguments, in flockIXmlRpcListener aListener); */
NS_IMETHODIMP _MYCLASS_::Call(const char *aMethod, flockIXmlRpcValue *aArguments, flockIXmlRpcListener *aListener)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

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


#endif /* __gen_flockIXmlRpc_h__ */
