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

#ifndef __gen_nsILoggingService_h__
#define __gen_nsILoggingService_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
#include "prprf.h"
#include "prinrval.h"
#include <stdio.h>
typedef PRUint32 PRIntervalTime;

class nsILog; /* forward declaration */


/* starting interface:    nsILogEventSink */
#define NS_ILOGEVENTSINK_IID_STR "28efb190-b114-11d3-93b6-00104ba0fd40"

#define NS_ILOGEVENTSINK_IID \
  {0x28efb190, 0xb114, 0x11d3, \
    { 0x93, 0xb6, 0x00, 0x10, 0x4b, 0xa0, 0xfd, 0x40 }}

class NS_NO_VTABLE nsILogEventSink : public nsISupports {
 public: 

  NS_DEFINE_STATIC_IID_ACCESSOR(NS_ILOGEVENTSINK_IID)

  /* readonly attribute string destinationName; */
  NS_IMETHOD GetDestinationName(char * *aDestinationName) = 0;

  /* void print (in nsILog log, in string msg); */
  NS_IMETHOD Print(nsILog *log, const char *msg) = 0;

  /* void flush (in nsILog log); */
  NS_IMETHOD Flush(nsILog *log) = 0;

};

/* Use this macro when declaring classes that implement this interface. */
#define NS_DECL_NSILOGEVENTSINK \
  NS_IMETHOD GetDestinationName(char * *aDestinationName); \
  NS_IMETHOD Print(nsILog *log, const char *msg); \
  NS_IMETHOD Flush(nsILog *log); 

/* Use this macro to declare functions that forward the behavior of this interface to another object. */
#define NS_FORWARD_NSILOGEVENTSINK(_to) \
  NS_IMETHOD GetDestinationName(char * *aDestinationName) { return _to ## GetDestinationName(aDestinationName); } \
  NS_IMETHOD Print(nsILog *log, const char *msg) { return _to ## Print(log, msg); } \
  NS_IMETHOD Flush(nsILog *log) { return _to ## Flush(log); } 

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

/* Header file */
class nsLogEventSink : public nsILogEventSink
{
public:
  NS_DECL_ISUPPORTS
  NS_DECL_NSILOGEVENTSINK

  nsLogEventSink();
  virtual ~nsLogEventSink();
  /* additional members */
};

/* Implementation file */
NS_IMPL_ISUPPORTS1(nsLogEventSink, nsILogEventSink)

nsLogEventSink::nsLogEventSink()
{
  NS_INIT_ISUPPORTS();
  /* member initializers and constructor code */
}

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

/* readonly attribute string destinationName; */
NS_IMETHODIMP nsLogEventSink::GetDestinationName(char * *aDestinationName)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void print (in nsILog log, in string msg); */
NS_IMETHODIMP nsLogEventSink::Print(nsILog *log, const char *msg)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void flush (in nsILog log); */
NS_IMETHODIMP nsLogEventSink::Flush(nsILog *log)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

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


/* starting interface:    nsIFileLogEventSink */
class NS_NO_VTABLE nsIFileLogEventSink : public nsILogEventSink {
 public: 

  /**
     * @param filePath - a native path to a log file,
     *                   or if "1", stdout, 
     *                   or if "2", stderr.
     */
  /* void init (in string filePath); */
  NS_IMETHOD Init(const char *filePath) = 0;

  /* [noscript] void initFromFILE (in string name, in FILE filePtr); */
  NS_IMETHOD InitFromFILE(const char *name, FILE * filePtr) = 0;

};

/* Use this macro when declaring classes that implement this interface. */
#define NS_DECL_NSIFILELOGEVENTSINK \
  NS_IMETHOD Init(const char *filePath); \
  NS_IMETHOD InitFromFILE(const char *name, FILE * filePtr); 

/* Use this macro to declare functions that forward the behavior of this interface to another object. */
#define NS_FORWARD_NSIFILELOGEVENTSINK(_to) \
  NS_IMETHOD Init(const char *filePath) { return _to ## Init(filePath); } \
  NS_IMETHOD InitFromFILE(const char *name, FILE * filePtr) { return _to ## InitFromFILE(name, filePtr); } 

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

/* Header file */
class nsFileLogEventSink : public nsIFileLogEventSink
{
public:
  NS_DECL_ISUPPORTS
  NS_DECL_NSIFILELOGEVENTSINK

  nsFileLogEventSink();
  virtual ~nsFileLogEventSink();
  /* additional members */
};

/* Implementation file */
NS_IMPL_ISUPPORTS1(nsFileLogEventSink, nsIFileLogEventSink)

nsFileLogEventSink::nsFileLogEventSink()
{
  NS_INIT_ISUPPORTS();
  /* member initializers and constructor code */
}

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

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

/* [noscript] void initFromFILE (in string name, in FILE filePtr); */
NS_IMETHODIMP nsFileLogEventSink::InitFromFILE(const char *name, FILE * filePtr)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

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

#define NS_FILELOGEVENTSINK_CID                  \
{ /* 0ebdebe0-b14a-11d3-93b6-00104ba0fd40 */         \
    0x0ebdebe0,                                      \
    0xb14a,                                          \
    0x11d3,                                          \
    {0x93, 0xb6, 0x00, 0x10, 0x4b, 0xa0, 0xfd, 0x40} \
}
#define NS_FILELOGEVENTSINK_CONTRACTID      "@mozilla.org/file-log-event-sink;1"
#define NS_FILELOGEVENTSINK_CLASSNAME       "File Log Event Sink"

/* starting interface:    nsILoggingService */
#define NS_ILOGGINGSERVICE_IID_STR "399d2370-b114-11d3-93b6-00104ba0fd40"

#define NS_ILOGGINGSERVICE_IID \
  {0x399d2370, 0xb114, 0x11d3, \
    { 0x93, 0xb6, 0x00, 0x10, 0x4b, 0xa0, 0xfd, 0x40 }}

class NS_NO_VTABLE nsILoggingService : public nsISupports {
 public: 

  NS_DEFINE_STATIC_IID_ACCESSOR(NS_ILOGGINGSERVICE_IID)

  /* nsILog getLog (in string name); */
  NS_IMETHOD GetLog(const char *name, nsILog **_retval) = 0;

  /* attribute unsigned long defaultControlFlags; */
  NS_IMETHOD GetDefaultControlFlags(PRUint32 *aDefaultControlFlags) = 0;
  NS_IMETHOD SetDefaultControlFlags(PRUint32 aDefaultControlFlags) = 0;

  /* attribute nsILogEventSink defaultLogEventSink; */
  NS_IMETHOD GetDefaultLogEventSink(nsILogEventSink * *aDefaultLogEventSink) = 0;
  NS_IMETHOD SetDefaultLogEventSink(nsILogEventSink * aDefaultLogEventSink) = 0;

  /* void describeLogs (in nsILog output); */
  NS_IMETHOD DescribeLogs(nsILog *output) = 0;

};

/* Use this macro when declaring classes that implement this interface. */
#define NS_DECL_NSILOGGINGSERVICE \
  NS_IMETHOD GetLog(const char *name, nsILog **_retval); \
  NS_IMETHOD GetDefaultControlFlags(PRUint32 *aDefaultControlFlags); \
  NS_IMETHOD SetDefaultControlFlags(PRUint32 aDefaultControlFlags); \
  NS_IMETHOD GetDefaultLogEventSink(nsILogEventSink * *aDefaultLogEventSink); \
  NS_IMETHOD SetDefaultLogEventSink(nsILogEventSink * aDefaultLogEventSink); \
  NS_IMETHOD DescribeLogs(nsILog *output); 

/* Use this macro to declare functions that forward the behavior of this interface to another object. */
#define NS_FORWARD_NSILOGGINGSERVICE(_to) \
  NS_IMETHOD GetLog(const char *name, nsILog **_retval) { return _to ## GetLog(name, _retval); } \
  NS_IMETHOD GetDefaultControlFlags(PRUint32 *aDefaultControlFlags) { return _to ## GetDefaultControlFlags(aDefaultControlFlags); } \
  NS_IMETHOD SetDefaultControlFlags(PRUint32 aDefaultControlFlags) { return _to ## SetDefaultControlFlags(aDefaultControlFlags); } \
  NS_IMETHOD GetDefaultLogEventSink(nsILogEventSink * *aDefaultLogEventSink) { return _to ## GetDefaultLogEventSink(aDefaultLogEventSink); } \
  NS_IMETHOD SetDefaultLogEventSink(nsILogEventSink * aDefaultLogEventSink) { return _to ## SetDefaultLogEventSink(aDefaultLogEventSink); } \
  NS_IMETHOD DescribeLogs(nsILog *output) { return _to ## DescribeLogs(output); } 

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

/* Header file */
class nsLoggingService : public nsILoggingService
{
public:
  NS_DECL_ISUPPORTS
  NS_DECL_NSILOGGINGSERVICE

  nsLoggingService();
  virtual ~nsLoggingService();
  /* additional members */
};

/* Implementation file */
NS_IMPL_ISUPPORTS1(nsLoggingService, nsILoggingService)

nsLoggingService::nsLoggingService()
{
  NS_INIT_ISUPPORTS();
  /* member initializers and constructor code */
}

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

/* nsILog getLog (in string name); */
NS_IMETHODIMP nsLoggingService::GetLog(const char *name, nsILog **_retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute unsigned long defaultControlFlags; */
NS_IMETHODIMP nsLoggingService::GetDefaultControlFlags(PRUint32 *aDefaultControlFlags)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP nsLoggingService::SetDefaultControlFlags(PRUint32 aDefaultControlFlags)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute nsILogEventSink defaultLogEventSink; */
NS_IMETHODIMP nsLoggingService::GetDefaultLogEventSink(nsILogEventSink * *aDefaultLogEventSink)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP nsLoggingService::SetDefaultLogEventSink(nsILogEventSink * aDefaultLogEventSink)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void describeLogs (in nsILog output); */
NS_IMETHODIMP nsLoggingService::DescribeLogs(nsILog *output)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

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

#define NS_LOGGINGSERVICE_CID                        \
{ /* 4f290320-b11c-11d3-93b6-00104ba0fd40 */         \
    0x4f290320,                                      \
    0xb11c,                                          \
    0x11d3,                                          \
    {0x93, 0xb6, 0x00, 0x10, 0x4b, 0xa0, 0xfd, 0x40} \
}
#define NS_LOGGINGSERVICE_CONTRACTID    "@mozilla.org/logging-service;1"
#define NS_LOGGINGSERVICE_CLASSNAME     "Logging Service"

/* starting interface:    nsILog */
#define NS_ILOG_IID_STR "3cddf0a0-b114-11d3-93b6-00104ba0fd40"

#define NS_ILOG_IID \
  {0x3cddf0a0, 0xb114, 0x11d3, \
    { 0x93, 0xb6, 0x00, 0x10, 0x4b, 0xa0, 0xfd, 0x40 }}

class nsILog : public nsISupports {
 public: 

  NS_DEFINE_STATIC_IID_ACCESSOR(NS_ILOG_IID)

  /* readonly attribute string name; */
  NS_IMETHOD GetName(char * *aName) = 0;

  /* boolean enabled (); */
  NS_IMETHOD Enabled(PRBool *_retval) = 0;

  /* void print (in wstring message); */
  NS_IMETHOD Print(const PRUnichar *message) = 0;

  /* void flush (); */
  NS_IMETHOD Flush(void) = 0;

  /* void increaseIndent (); */
  NS_IMETHOD IncreaseIndent(void) = 0;

  /* void decreaseIndent (); */
  NS_IMETHOD DecreaseIndent(void) = 0;

  /* readonly attribute unsigned long indentLevel; */
  NS_IMETHOD GetIndentLevel(PRUint32 *aIndentLevel) = 0;

  /* void describe (in nsILog outLog); */
  NS_IMETHOD Describe(nsILog *outLog) = 0;

  enum { DEFAULT_DISABLED = 0U };

  enum { DEFAULT_ENABLED = 2U };

  enum { PRINT_THREAD_ID = 4U };

  enum { PRINT_LOG_NAME = 8U };

  /* attribute unsigned long controlFlags; */
  NS_IMETHOD GetControlFlags(PRUint32 *aControlFlags) = 0;
  NS_IMETHOD SetControlFlags(PRUint32 aControlFlags) = 0;

  /* attribute nsILogEventSink logEventSink; */
  NS_IMETHOD GetLogEventSink(nsILogEventSink * *aLogEventSink) = 0;
  NS_IMETHOD SetLogEventSink(nsILogEventSink * aLogEventSink) = 0;

    public:
        inline PRBool Test() { return mControlFlags & DEFAULT_ENABLED; }
        NS_IMETHOD Printf(const char* format, ...) = 0;
        NS_IMETHOD Vprintf(const char* format, va_list args) = 0;
    protected:
        PRUint32 mControlFlags;
};

/* Use this macro when declaring classes that implement this interface. */
#define NS_DECL_NSILOG \
  NS_IMETHOD GetName(char * *aName); \
  NS_IMETHOD Enabled(PRBool *_retval); \
  NS_IMETHOD Print(const PRUnichar *message); \
  NS_IMETHOD Flush(void); \
  NS_IMETHOD IncreaseIndent(void); \
  NS_IMETHOD DecreaseIndent(void); \
  NS_IMETHOD GetIndentLevel(PRUint32 *aIndentLevel); \
  NS_IMETHOD Describe(nsILog *outLog); \
  NS_IMETHOD GetControlFlags(PRUint32 *aControlFlags); \
  NS_IMETHOD SetControlFlags(PRUint32 aControlFlags); \
  NS_IMETHOD GetLogEventSink(nsILogEventSink * *aLogEventSink); \
  NS_IMETHOD SetLogEventSink(nsILogEventSink * aLogEventSink); \

/* Use this macro to declare functions that forward the behavior of this interface to another object. */
#define NS_FORWARD_NSILOG(_to) \
  NS_IMETHOD GetName(char * *aName) { return _to ## GetName(aName); } \
  NS_IMETHOD Enabled(PRBool *_retval) { return _to ## Enabled(_retval); } \
  NS_IMETHOD Print(const PRUnichar *message) { return _to ## Print(message); } \
  NS_IMETHOD Flush(void) { return _to ## Flush(); } \
  NS_IMETHOD IncreaseIndent(void) { return _to ## IncreaseIndent(); } \
  NS_IMETHOD DecreaseIndent(void) { return _to ## DecreaseIndent(); } \
  NS_IMETHOD GetIndentLevel(PRUint32 *aIndentLevel) { return _to ## GetIndentLevel(aIndentLevel); } \
  NS_IMETHOD Describe(nsILog *outLog) { return _to ## Describe(outLog); } \
  NS_IMETHOD GetControlFlags(PRUint32 *aControlFlags) { return _to ## GetControlFlags(aControlFlags); } \
  NS_IMETHOD SetControlFlags(PRUint32 aControlFlags) { return _to ## SetControlFlags(aControlFlags); } \
  NS_IMETHOD GetLogEventSink(nsILogEventSink * *aLogEventSink) { return _to ## GetLogEventSink(aLogEventSink); } \
  NS_IMETHOD SetLogEventSink(nsILogEventSink * aLogEventSink) { return _to ## SetLogEventSink(aLogEventSink); } \

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

/* Header file */
class nsLog : public nsILog
{
public:
  NS_DECL_ISUPPORTS
  NS_DECL_NSILOG

  nsLog();
  virtual ~nsLog();
  /* additional members */
};

/* Implementation file */
NS_IMPL_ISUPPORTS1(nsLog, nsILog)

nsLog::nsLog()
{
  NS_INIT_ISUPPORTS();
  /* member initializers and constructor code */
}

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

/* readonly attribute string name; */
NS_IMETHODIMP nsLog::GetName(char * *aName)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* boolean enabled (); */
NS_IMETHODIMP nsLog::Enabled(PRBool *_retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void print (in wstring message); */
NS_IMETHODIMP nsLog::Print(const PRUnichar *message)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void flush (); */
NS_IMETHODIMP nsLog::Flush()
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void increaseIndent (); */
NS_IMETHODIMP nsLog::IncreaseIndent()
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void decreaseIndent (); */
NS_IMETHODIMP nsLog::DecreaseIndent()
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* readonly attribute unsigned long indentLevel; */
NS_IMETHODIMP nsLog::GetIndentLevel(PRUint32 *aIndentLevel)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void describe (in nsILog outLog); */
NS_IMETHODIMP nsLog::Describe(nsILog *outLog)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute unsigned long controlFlags; */
NS_IMETHODIMP nsLog::GetControlFlags(PRUint32 *aControlFlags)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP nsLog::SetControlFlags(PRUint32 aControlFlags)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute nsILogEventSink logEventSink; */
NS_IMETHODIMP nsLog::GetLogEventSink(nsILogEventSink * *aLogEventSink)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP nsLog::SetLogEventSink(nsILogEventSink * aLogEventSink)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

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


#endif /* __gen_nsILoggingService_h__ */
