extensions/mono/test/test.h

   1 /*
   2  * DO NOT EDIT.  THIS FILE IS GENERATED FROM test.idl
   3  */
   4
   5 #ifndef __gen_test_h__
   6 #define __gen_test_h__
   7
   8
   9 #ifndef __gen_nsISupports_h__
  10 #include "nsISupports.h"
  11 #endif
  12
  13 /* For IDL files that don't want to include root IDL files. */
  14 #ifndef NS_NO_VTABLE
  15 #define NS_NO_VTABLE
  16 #endif
  17
  18 /* starting interface:    testCallback */
  19 #define TESTCALLBACK_IID_STR "75d2225d-0a67-4dbc-91de-78319594cce8"
  20
  21 #define TESTCALLBACK_IID \
  22   {0x75d2225d, 0x0a67, 0x4dbc, \
  23     { 0x91, 0xde, 0x78, 0x31, 0x95, 0x94, 0xcc, 0xe8 }}
  24
  25 class NS_NO_VTABLE testCallback : public nsISupports {
  26  public:
  27
  28   NS_DEFINE_STATIC_IID_ACCESSOR(TESTCALLBACK_IID)
  29
  30   /* void call (); */
  31   NS_IMETHOD Call(void) = 0;
  32
  33 };
  34
  35 /* Use this macro when declaring classes that implement this interface. */
  36 #define NS_DECL_TESTCALLBACK \
  37   NS_IMETHOD Call(void);
  38
  39 /* Use this macro to declare functions that forward the behavior of this interface to another object. */
  40 #define NS_FORWARD_TESTCALLBACK(_to) \
  41   NS_IMETHOD Call(void) { return _to Call(); }
  42
  43 /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
  44 #define NS_FORWARD_SAFE_TESTCALLBACK(_to) \
  45   NS_IMETHOD Call(void) { return !_to ? NS_ERROR_NULL_POINTER : _to->Call(); }
  46
  47 #if 0
  48 /* Use the code below as a template for the implementation class for this interface. */
  49
  50 /* Header file */
  51 class _MYCLASS_ : public testCallback
  52 {
  53 public:
  54   NS_DECL_ISUPPORTS
  55   NS_DECL_TESTCALLBACK
  56
  57   _MYCLASS_();
  58   virtual ~_MYCLASS_();
  59   /* additional members */
  60 };
  61
  62 /* Implementation file */
  63 NS_IMPL_ISUPPORTS1(_MYCLASS_, testCallback)
  64
  65 _MYCLASS_::_MYCLASS_()
  66 {
  67   /* member initializers and constructor code */
  68 }
  69
  70 _MYCLASS_::~_MYCLASS_()
  71 {
  72   /* destructor code */
  73 }
  74
  75 /* void call (); */
  76 NS_IMETHODIMP _MYCLASS_::Call()
  77 {
  78     return NS_ERROR_NOT_IMPLEMENTED;
  79 }
  80
  81 /* End of implementation class template. */
  82 #endif
  83
  84
  85 /* starting interface:    test */
  86 #define TEST_IID_STR "1afbcf6a-e23f-4e12-b191-4c0a76cd9cec"
  87
  88 #define TEST_IID \
  89   {0x1afbcf6a, 0xe23f, 0x4e12, \
  90     { 0xb1, 0x91, 0x4c, 0x0a, 0x76, 0xcd, 0x9c, 0xec }}
  91
  92 class NS_NO_VTABLE test : public nsISupports {
  93  public:
  94
  95   NS_DEFINE_STATIC_IID_ACCESSOR(TEST_IID)
  96
  97   /* void say (in string sayIt); */
  98   NS_IMETHOD Say(const char *sayIt) = 0;
  99
 100   /* void shout (in string shoutIt); */
 101   NS_IMETHOD Shout(const char *shoutIt) = 0;
 102
 103   /* void poke (in string with); */
 104   NS_IMETHOD Poke(const char *with) = 0;
 105
 106   /* PRInt32 add (in PRInt32 a, in PRInt32 b); */
 107   NS_IMETHOD Add(PRInt32 a, PRInt32 b, PRInt32 *_retval) = 0;
 108
 109   /* string peek (); */
 110   NS_IMETHOD Peek(char **_retval) = 0;
 111
 112   /* void callback (in testCallback cb); */
 113   NS_IMETHOD Callback(testCallback *cb) = 0;
 114
 115   /* attribute PRInt32 intProp; */
 116   NS_IMETHOD GetIntProp(PRInt32 *aIntProp) = 0;
 117   NS_IMETHOD SetIntProp(PRInt32 aIntProp) = 0;
 118
 119   /* readonly attribute PRInt32 roIntProp; */
 120   NS_IMETHOD GetRoIntProp(PRInt32 *aRoIntProp) = 0;
 121
 122 };
 123
 124 /* Use this macro when declaring classes that implement this interface. */
 125 #define NS_DECL_TEST \
 126   NS_IMETHOD Say(const char *sayIt); \
 127   NS_IMETHOD Shout(const char *shoutIt); \
 128   NS_IMETHOD Poke(const char *with); \
 129   NS_IMETHOD Add(PRInt32 a, PRInt32 b, PRInt32 *_retval); \
 130   NS_IMETHOD Peek(char **_retval); \
 131   NS_IMETHOD Callback(testCallback *cb); \
 132   NS_IMETHOD GetIntProp(PRInt32 *aIntProp); \
 133   NS_IMETHOD SetIntProp(PRInt32 aIntProp); \
 134   NS_IMETHOD GetRoIntProp(PRInt32 *aRoIntProp);
 135
 136 /* Use this macro to declare functions that forward the behavior of this interface to another object. */
 137 #define NS_FORWARD_TEST(_to) \
 138   NS_IMETHOD Say(const char *sayIt) { return _to Say(sayIt); } \
 139   NS_IMETHOD Shout(const char *shoutIt) { return _to Shout(shoutIt); } \
 140   NS_IMETHOD Poke(const char *with) { return _to Poke(with); } \
 141   NS_IMETHOD Add(PRInt32 a, PRInt32 b, PRInt32 *_retval) { return _to Add(a, b, _retval); } \
 142   NS_IMETHOD Peek(char **_retval) { return _to Peek(_retval); } \
 143   NS_IMETHOD Callback(testCallback *cb) { return _to Callback(cb); } \
 144   NS_IMETHOD GetIntProp(PRInt32 *aIntProp) { return _to GetIntProp(aIntProp); } \
 145   NS_IMETHOD SetIntProp(PRInt32 aIntProp) { return _to SetIntProp(aIntProp); } \
 146   NS_IMETHOD GetRoIntProp(PRInt32 *aRoIntProp) { return _to GetRoIntProp(aRoIntProp); }
 147
 148 /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
 149 #define NS_FORWARD_SAFE_TEST(_to) \
 150   NS_IMETHOD Say(const char *sayIt) { return !_to ? NS_ERROR_NULL_POINTER : _to->Say(sayIt); } \
 151   NS_IMETHOD Shout(const char *shoutIt) { return !_to ? NS_ERROR_NULL_POINTER : _to->Shout(shoutIt); } \
 152   NS_IMETHOD Poke(const char *with) { return !_to ? NS_ERROR_NULL_POINTER : _to->Poke(with); } \
 153   NS_IMETHOD Add(PRInt32 a, PRInt32 b, PRInt32 *_retval) { return !_to ? NS_ERROR_NULL_POINTER : _to->Add(a, b, _retval); } \
 154   NS_IMETHOD Peek(char **_retval) { return !_to ? NS_ERROR_NULL_POINTER : _to->Peek(_retval); } \
 155   NS_IMETHOD Callback(testCallback *cb) { return !_to ? NS_ERROR_NULL_POINTER : _to->Callback(cb); } \
 156   NS_IMETHOD GetIntProp(PRInt32 *aIntProp) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetIntProp(aIntProp); } \
 157   NS_IMETHOD SetIntProp(PRInt32 aIntProp) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetIntProp(aIntProp); } \
 158   NS_IMETHOD GetRoIntProp(PRInt32 *aRoIntProp) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetRoIntProp(aRoIntProp); }
 159
 160 #if 0
 161 /* Use the code below as a template for the implementation class for this interface. */
 162
 163 /* Header file */
 164 class _MYCLASS_ : public test
 165 {
 166 public:
 167   NS_DECL_ISUPPORTS
 168   NS_DECL_TEST
 169
 170   _MYCLASS_();
 171   virtual ~_MYCLASS_();
 172   /* additional members */
 173 };
 174
 175 /* Implementation file */
 176 NS_IMPL_ISUPPORTS1(_MYCLASS_, test)
 177
 178 _MYCLASS_::_MYCLASS_()
 179 {
 180   /* member initializers and constructor code */
 181 }
 182
 183 _MYCLASS_::~_MYCLASS_()
 184 {
 185   /* destructor code */
 186 }
 187
 188 /* void say (in string sayIt); */
 189 NS_IMETHODIMP _MYCLASS_::Say(const char *sayIt)
 190 {
 191     return NS_ERROR_NOT_IMPLEMENTED;
 192 }
 193
 194 /* void shout (in string shoutIt); */
 195 NS_IMETHODIMP _MYCLASS_::Shout(const char *shoutIt)
 196 {
 197     return NS_ERROR_NOT_IMPLEMENTED;
 198 }
 199
 200 /* void poke (in string with); */
 201 NS_IMETHODIMP _MYCLASS_::Poke(const char *with)
 202 {
 203     return NS_ERROR_NOT_IMPLEMENTED;
 204 }
 205
 206 /* PRInt32 add (in PRInt32 a, in PRInt32 b); */
 207 NS_IMETHODIMP _MYCLASS_::Add(PRInt32 a, PRInt32 b, PRInt32 *_retval)
 208 {
 209     return NS_ERROR_NOT_IMPLEMENTED;
 210 }
 211
 212 /* string peek (); */
 213 NS_IMETHODIMP _MYCLASS_::Peek(char **_retval)
 214 {
 215     return NS_ERROR_NOT_IMPLEMENTED;
 216 }
 217
 218 /* void callback (in testCallback cb); */
 219 NS_IMETHODIMP _MYCLASS_::Callback(testCallback *cb)
 220 {
 221     return NS_ERROR_NOT_IMPLEMENTED;
 222 }
 223
 224 /* attribute PRInt32 intProp; */
 225 NS_IMETHODIMP _MYCLASS_::GetIntProp(PRInt32 *aIntProp)
 226 {
 227     return NS_ERROR_NOT_IMPLEMENTED;
 228 }
 229 NS_IMETHODIMP _MYCLASS_::SetIntProp(PRInt32 aIntProp)
 230 {
 231     return NS_ERROR_NOT_IMPLEMENTED;
 232 }
 233
 234 /* readonly attribute PRInt32 roIntProp; */
 235 NS_IMETHODIMP _MYCLASS_::GetRoIntProp(PRInt32 *aRoIntProp)
 236 {
 237     return NS_ERROR_NOT_IMPLEMENTED;
 238 }
 239
 240 /* End of implementation class template. */
 241 #endif
 242
 243
 244 /* starting interface:    testString */
 245 #define TESTSTRING_IID_STR "5a1f21a2-8aa3-4147-a808-1e1a422dcb76"
 246
 247 #define TESTSTRING_IID \
 248   {0x5a1f21a2, 0x8aa3, 0x4147, \
 249     { 0xa8, 0x08, 0x1e, 0x1a, 0x42, 0x2d, 0xcb, 0x76 }}
 250
 251 class NS_NO_VTABLE testString : public nsISupports {
 252  public:
 253
 254   NS_DEFINE_STATIC_IID_ACCESSOR(TESTSTRING_IID)
 255
 256   /* void say (in string sayIt); */
 257   NS_IMETHOD Say(const char *sayIt) = 0;
 258
 259 };
 260
 261 /* Use this macro when declaring classes that implement this interface. */
 262 #define NS_DECL_TESTSTRING \
 263   NS_IMETHOD Say(const char *sayIt);
 264
 265 /* Use this macro to declare functions that forward the behavior of this interface to another object. */
 266 #define NS_FORWARD_TESTSTRING(_to) \
 267   NS_IMETHOD Say(const char *sayIt) { return _to Say(sayIt); }
 268
 269 /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
 270 #define NS_FORWARD_SAFE_TESTSTRING(_to) \
 271   NS_IMETHOD Say(const char *sayIt) { return !_to ? NS_ERROR_NULL_POINTER : _to->Say(sayIt); }
 272
 273 #if 0
 274 /* Use the code below as a template for the implementation class for this interface. */
 275
 276 /* Header file */
 277 class _MYCLASS_ : public testString
 278 {
 279 public:
 280   NS_DECL_ISUPPORTS
 281   NS_DECL_TESTSTRING
 282
 283   _MYCLASS_();
 284   virtual ~_MYCLASS_();
 285   /* additional members */
 286 };
 287
 288 /* Implementation file */
 289 NS_IMPL_ISUPPORTS1(_MYCLASS_, testString)
 290
 291 _MYCLASS_::_MYCLASS_()
 292 {
 293   /* member initializers and constructor code */
 294 }
 295
 296 _MYCLASS_::~_MYCLASS_()
 297 {
 298   /* destructor code */
 299 }
 300
 301 /* void say (in string sayIt); */
 302 NS_IMETHODIMP _MYCLASS_::Say(const char *sayIt)
 303 {
 304     return NS_ERROR_NOT_IMPLEMENTED;
 305 }
 306
 307 /* End of implementation class template. */
 308 #endif
 309
 310
 311 /* starting interface:    testInt */
 312 #define TESTINT_IID_STR "5a1f21a2-8aa3-4147-a808-1e1a422dcb77"
 313
 314 #define TESTINT_IID \
 315   {0x5a1f21a2, 0x8aa3, 0x4147, \
 316     { 0xa8, 0x08, 0x1e, 0x1a, 0x42, 0x2d, 0xcb, 0x77 }}
 317
 318 class NS_NO_VTABLE testInt : public nsISupports {
 319  public:
 320
 321   NS_DEFINE_STATIC_IID_ACCESSOR(TESTINT_IID)
 322
 323   /* void add (in PRInt32 a, in PRInt32 b); */
 324   NS_IMETHOD Add(PRInt32 a, PRInt32 b) = 0;
 325
 326 };
 327
 328 /* Use this macro when declaring classes that implement this interface. */
 329 #define NS_DECL_TESTINT \
 330   NS_IMETHOD Add(PRInt32 a, PRInt32 b);
 331
 332 /* Use this macro to declare functions that forward the behavior of this interface to another object. */
 333 #define NS_FORWARD_TESTINT(_to) \
 334   NS_IMETHOD Add(PRInt32 a, PRInt32 b) { return _to Add(a, b); }
 335
 336 /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
 337 #define NS_FORWARD_SAFE_TESTINT(_to) \
 338   NS_IMETHOD Add(PRInt32 a, PRInt32 b) { return !_to ? NS_ERROR_NULL_POINTER : _to->Add(a, b); }
 339
 340 #if 0
 341 /* Use the code below as a template for the implementation class for this interface. */
 342
 343 /* Header file */
 344 class _MYCLASS_ : public testInt
 345 {
 346 public:
 347   NS_DECL_ISUPPORTS
 348   NS_DECL_TESTINT
 349
 350   _MYCLASS_();
 351   virtual ~_MYCLASS_();
 352   /* additional members */
 353 };
 354
 355 /* Implementation file */
 356 NS_IMPL_ISUPPORTS1(_MYCLASS_, testInt)
 357
 358 _MYCLASS_::_MYCLASS_()
 359 {
 360   /* member initializers and constructor code */
 361 }
 362
 363 _MYCLASS_::~_MYCLASS_()
 364 {
 365   /* destructor code */
 366 }
 367
 368 /* void add (in PRInt32 a, in PRInt32 b); */
 369 NS_IMETHODIMP _MYCLASS_::Add(PRInt32 a, PRInt32 b)
 370 {
 371     return NS_ERROR_NOT_IMPLEMENTED;
 372 }
 373
 374 /* End of implementation class template. */
 375 #endif
 376
 377
 378 #endif /* __gen_test_h__ */