LCOV - code coverage report
Current view: directory - objdir/dist/include - mozIStorageStatementWrapper.h (source / functions) Found Hit Coverage
Test: app.info Lines: 3 3 100.0 %
Date: 2012-06-02 Functions: 3 3 100.0 %

       1                 : /*
       2                 :  * DO NOT EDIT.  THIS FILE IS GENERATED FROM /builds/slave/m-beta-lnx-codecoverage/build/storage/public/mozIStorageStatementWrapper.idl
       3                 :  */
       4                 : 
       5                 : #ifndef __gen_mozIStorageStatementWrapper_h__
       6                 : #define __gen_mozIStorageStatementWrapper_h__
       7                 : 
       8                 : 
       9                 : #ifndef __gen_mozIStorageStatement_h__
      10                 : #include "mozIStorageStatement.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:    mozIStorageStatementRow */
      19                 : #define MOZISTORAGESTATEMENTROW_IID_STR "02eeaf95-c3db-4182-9340-222c29f68f02"
      20                 : 
      21                 : #define MOZISTORAGESTATEMENTROW_IID \
      22                 :   {0x02eeaf95, 0xc3db, 0x4182, \
      23                 :     { 0x93, 0x40, 0x22, 0x2c, 0x29, 0xf6, 0x8f, 0x02 }}
      24                 : 
      25            2673 : class NS_NO_VTABLE NS_SCRIPTABLE mozIStorageStatementRow : public nsISupports {
      26                 :  public: 
      27                 : 
      28                 :   NS_DECLARE_STATIC_IID_ACCESSOR(MOZISTORAGESTATEMENTROW_IID)
      29                 : 
      30                 : };
      31                 : 
      32                 :   NS_DEFINE_STATIC_IID_ACCESSOR(mozIStorageStatementRow, MOZISTORAGESTATEMENTROW_IID)
      33                 : 
      34                 : /* Use this macro when declaring classes that implement this interface. */
      35                 : #define NS_DECL_MOZISTORAGESTATEMENTROW \
      36                 :   /* no methods! */
      37                 : 
      38                 : /* Use this macro to declare functions that forward the behavior of this interface to another object. */
      39                 : #define NS_FORWARD_MOZISTORAGESTATEMENTROW(_to) \
      40                 :   /* no methods! */
      41                 : 
      42                 : /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
      43                 : #define NS_FORWARD_SAFE_MOZISTORAGESTATEMENTROW(_to) \
      44                 :   /* no methods! */
      45                 : 
      46                 : #if 0
      47                 : /* Use the code below as a template for the implementation class for this interface. */
      48                 : 
      49                 : /* Header file */
      50                 : class _MYCLASS_ : public mozIStorageStatementRow
      51                 : {
      52                 : public:
      53                 :   NS_DECL_ISUPPORTS
      54                 :   NS_DECL_MOZISTORAGESTATEMENTROW
      55                 : 
      56                 :   _MYCLASS_();
      57                 : 
      58                 : private:
      59                 :   ~_MYCLASS_();
      60                 : 
      61                 : protected:
      62                 :   /* additional members */
      63                 : };
      64                 : 
      65                 : /* Implementation file */
      66                 : NS_IMPL_ISUPPORTS1(_MYCLASS_, mozIStorageStatementRow)
      67                 : 
      68                 : _MYCLASS_::_MYCLASS_()
      69                 : {
      70                 :   /* member initializers and constructor code */
      71                 : }
      72                 : 
      73                 : _MYCLASS_::~_MYCLASS_()
      74                 : {
      75                 :   /* destructor code */
      76                 : }
      77                 : 
      78                 : /* End of implementation class template. */
      79                 : #endif
      80                 : 
      81                 : 
      82                 : /* starting interface:    mozIStorageStatementParams */
      83                 : #define MOZISTORAGESTATEMENTPARAMS_IID_STR "e65fe6e2-2643-463c-97e2-27665efe2386"
      84                 : 
      85                 : #define MOZISTORAGESTATEMENTPARAMS_IID \
      86                 :   {0xe65fe6e2, 0x2643, 0x463c, \
      87                 :     { 0x97, 0xe2, 0x27, 0x66, 0x5e, 0xfe, 0x23, 0x86 }}
      88                 : 
      89           12011 : class NS_NO_VTABLE NS_SCRIPTABLE mozIStorageStatementParams : public nsISupports {
      90                 :  public: 
      91                 : 
      92                 :   NS_DECLARE_STATIC_IID_ACCESSOR(MOZISTORAGESTATEMENTPARAMS_IID)
      93                 : 
      94                 : };
      95                 : 
      96                 :   NS_DEFINE_STATIC_IID_ACCESSOR(mozIStorageStatementParams, MOZISTORAGESTATEMENTPARAMS_IID)
      97                 : 
      98                 : /* Use this macro when declaring classes that implement this interface. */
      99                 : #define NS_DECL_MOZISTORAGESTATEMENTPARAMS \
     100                 :   /* no methods! */
     101                 : 
     102                 : /* Use this macro to declare functions that forward the behavior of this interface to another object. */
     103                 : #define NS_FORWARD_MOZISTORAGESTATEMENTPARAMS(_to) \
     104                 :   /* no methods! */
     105                 : 
     106                 : /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
     107                 : #define NS_FORWARD_SAFE_MOZISTORAGESTATEMENTPARAMS(_to) \
     108                 :   /* no methods! */
     109                 : 
     110                 : #if 0
     111                 : /* Use the code below as a template for the implementation class for this interface. */
     112                 : 
     113                 : /* Header file */
     114                 : class _MYCLASS_ : public mozIStorageStatementParams
     115                 : {
     116                 : public:
     117                 :   NS_DECL_ISUPPORTS
     118                 :   NS_DECL_MOZISTORAGESTATEMENTPARAMS
     119                 : 
     120                 :   _MYCLASS_();
     121                 : 
     122                 : private:
     123                 :   ~_MYCLASS_();
     124                 : 
     125                 : protected:
     126                 :   /* additional members */
     127                 : };
     128                 : 
     129                 : /* Implementation file */
     130                 : NS_IMPL_ISUPPORTS1(_MYCLASS_, mozIStorageStatementParams)
     131                 : 
     132                 : _MYCLASS_::_MYCLASS_()
     133                 : {
     134                 :   /* member initializers and constructor code */
     135                 : }
     136                 : 
     137                 : _MYCLASS_::~_MYCLASS_()
     138                 : {
     139                 :   /* destructor code */
     140                 : }
     141                 : 
     142                 : /* End of implementation class template. */
     143                 : #endif
     144                 : 
     145                 : 
     146                 : /* starting interface:    mozIStorageStatementWrapper */
     147                 : #define MOZISTORAGESTATEMENTWRAPPER_IID_STR "eee6f7c9-5586-4eaf-b35c-dca987c4ffd1"
     148                 : 
     149                 : #define MOZISTORAGESTATEMENTWRAPPER_IID \
     150                 :   {0xeee6f7c9, 0x5586, 0x4eaf, \
     151                 :     { 0xb3, 0x5c, 0xdc, 0xa9, 0x87, 0xc4, 0xff, 0xd1 }}
     152                 : 
     153              67 : class NS_NO_VTABLE NS_SCRIPTABLE MOZ_DEPRECATED mozIStorageStatementWrapper : public nsISupports {
     154                 :  public: 
     155                 : 
     156                 :   NS_DECLARE_STATIC_IID_ACCESSOR(MOZISTORAGESTATEMENTWRAPPER_IID)
     157                 : 
     158                 :   /* void initialize (in mozIStorageStatement aStatement); */
     159                 :   NS_SCRIPTABLE NS_IMETHOD Initialize(mozIStorageStatement *aStatement) = 0;
     160                 : 
     161                 :   /* readonly attribute mozIStorageStatement statement; */
     162                 :   NS_SCRIPTABLE NS_IMETHOD GetStatement(mozIStorageStatement * *aStatement) = 0;
     163                 : 
     164                 :   /* void reset (); */
     165                 :   NS_SCRIPTABLE NS_IMETHOD Reset(void) = 0;
     166                 : 
     167                 :   /* [deprecated] boolean step (); */
     168                 :   NS_SCRIPTABLE NS_IMETHOD Step(bool *_retval NS_OUTPARAM) = 0;
     169                 : 
     170                 :   /* void execute (); */
     171                 :   NS_SCRIPTABLE NS_IMETHOD Execute(void) = 0;
     172                 : 
     173                 :   /* readonly attribute mozIStorageStatementRow row; */
     174                 :   NS_SCRIPTABLE NS_IMETHOD GetRow(mozIStorageStatementRow * *aRow) = 0;
     175                 : 
     176                 :   /* readonly attribute mozIStorageStatementParams params; */
     177                 :   NS_SCRIPTABLE NS_IMETHOD GetParams(mozIStorageStatementParams * *aParams) = 0;
     178                 : 
     179                 : };
     180                 : 
     181                 :   NS_DEFINE_STATIC_IID_ACCESSOR(mozIStorageStatementWrapper, MOZISTORAGESTATEMENTWRAPPER_IID)
     182                 : 
     183                 : /* Use this macro when declaring classes that implement this interface. */
     184                 : #define NS_DECL_MOZISTORAGESTATEMENTWRAPPER \
     185                 :   NS_SCRIPTABLE NS_IMETHOD Initialize(mozIStorageStatement *aStatement); \
     186                 :   NS_SCRIPTABLE NS_IMETHOD GetStatement(mozIStorageStatement * *aStatement); \
     187                 :   NS_SCRIPTABLE NS_IMETHOD Reset(void); \
     188                 :   NS_SCRIPTABLE NS_IMETHOD Step(bool *_retval NS_OUTPARAM); \
     189                 :   NS_SCRIPTABLE NS_IMETHOD Execute(void); \
     190                 :   NS_SCRIPTABLE NS_IMETHOD GetRow(mozIStorageStatementRow * *aRow); \
     191                 :   NS_SCRIPTABLE NS_IMETHOD GetParams(mozIStorageStatementParams * *aParams); 
     192                 : 
     193                 : /* Use this macro to declare functions that forward the behavior of this interface to another object. */
     194                 : #define NS_FORWARD_MOZISTORAGESTATEMENTWRAPPER(_to) \
     195                 :   NS_SCRIPTABLE NS_IMETHOD Initialize(mozIStorageStatement *aStatement) { return _to Initialize(aStatement); } \
     196                 :   NS_SCRIPTABLE NS_IMETHOD GetStatement(mozIStorageStatement * *aStatement) { return _to GetStatement(aStatement); } \
     197                 :   NS_SCRIPTABLE NS_IMETHOD Reset(void) { return _to Reset(); } \
     198                 :   NS_SCRIPTABLE NS_IMETHOD Step(bool *_retval NS_OUTPARAM) { return _to Step(_retval); } \
     199                 :   NS_SCRIPTABLE NS_IMETHOD Execute(void) { return _to Execute(); } \
     200                 :   NS_SCRIPTABLE NS_IMETHOD GetRow(mozIStorageStatementRow * *aRow) { return _to GetRow(aRow); } \
     201                 :   NS_SCRIPTABLE NS_IMETHOD GetParams(mozIStorageStatementParams * *aParams) { return _to GetParams(aParams); } 
     202                 : 
     203                 : /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
     204                 : #define NS_FORWARD_SAFE_MOZISTORAGESTATEMENTWRAPPER(_to) \
     205                 :   NS_SCRIPTABLE NS_IMETHOD Initialize(mozIStorageStatement *aStatement) { return !_to ? NS_ERROR_NULL_POINTER : _to->Initialize(aStatement); } \
     206                 :   NS_SCRIPTABLE NS_IMETHOD GetStatement(mozIStorageStatement * *aStatement) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetStatement(aStatement); } \
     207                 :   NS_SCRIPTABLE NS_IMETHOD Reset(void) { return !_to ? NS_ERROR_NULL_POINTER : _to->Reset(); } \
     208                 :   NS_SCRIPTABLE NS_IMETHOD Step(bool *_retval NS_OUTPARAM) { return !_to ? NS_ERROR_NULL_POINTER : _to->Step(_retval); } \
     209                 :   NS_SCRIPTABLE NS_IMETHOD Execute(void) { return !_to ? NS_ERROR_NULL_POINTER : _to->Execute(); } \
     210                 :   NS_SCRIPTABLE NS_IMETHOD GetRow(mozIStorageStatementRow * *aRow) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetRow(aRow); } \
     211                 :   NS_SCRIPTABLE NS_IMETHOD GetParams(mozIStorageStatementParams * *aParams) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetParams(aParams); } 
     212                 : 
     213                 : #if 0
     214                 : /* Use the code below as a template for the implementation class for this interface. */
     215                 : 
     216                 : /* Header file */
     217                 : class _MYCLASS_ : public mozIStorageStatementWrapper
     218                 : {
     219                 : public:
     220                 :   NS_DECL_ISUPPORTS
     221                 :   NS_DECL_MOZISTORAGESTATEMENTWRAPPER
     222                 : 
     223                 :   _MYCLASS_();
     224                 : 
     225                 : private:
     226                 :   ~_MYCLASS_();
     227                 : 
     228                 : protected:
     229                 :   /* additional members */
     230                 : };
     231                 : 
     232                 : /* Implementation file */
     233                 : NS_IMPL_ISUPPORTS1(_MYCLASS_, mozIStorageStatementWrapper)
     234                 : 
     235                 : _MYCLASS_::_MYCLASS_()
     236                 : {
     237                 :   /* member initializers and constructor code */
     238                 : }
     239                 : 
     240                 : _MYCLASS_::~_MYCLASS_()
     241                 : {
     242                 :   /* destructor code */
     243                 : }
     244                 : 
     245                 : /* void initialize (in mozIStorageStatement aStatement); */
     246                 : NS_IMETHODIMP _MYCLASS_::Initialize(mozIStorageStatement *aStatement)
     247                 : {
     248                 :     return NS_ERROR_NOT_IMPLEMENTED;
     249                 : }
     250                 : 
     251                 : /* readonly attribute mozIStorageStatement statement; */
     252                 : NS_IMETHODIMP _MYCLASS_::GetStatement(mozIStorageStatement * *aStatement)
     253                 : {
     254                 :     return NS_ERROR_NOT_IMPLEMENTED;
     255                 : }
     256                 : 
     257                 : /* void reset (); */
     258                 : NS_IMETHODIMP _MYCLASS_::Reset()
     259                 : {
     260                 :     return NS_ERROR_NOT_IMPLEMENTED;
     261                 : }
     262                 : 
     263                 : /* [deprecated] boolean step (); */
     264                 : NS_IMETHODIMP _MYCLASS_::Step(bool *_retval NS_OUTPARAM)
     265                 : {
     266                 :     return NS_ERROR_NOT_IMPLEMENTED;
     267                 : }
     268                 : 
     269                 : /* void execute (); */
     270                 : NS_IMETHODIMP _MYCLASS_::Execute()
     271                 : {
     272                 :     return NS_ERROR_NOT_IMPLEMENTED;
     273                 : }
     274                 : 
     275                 : /* readonly attribute mozIStorageStatementRow row; */
     276                 : NS_IMETHODIMP _MYCLASS_::GetRow(mozIStorageStatementRow * *aRow)
     277                 : {
     278                 :     return NS_ERROR_NOT_IMPLEMENTED;
     279                 : }
     280                 : 
     281                 : /* readonly attribute mozIStorageStatementParams params; */
     282                 : NS_IMETHODIMP _MYCLASS_::GetParams(mozIStorageStatementParams * *aParams)
     283                 : {
     284                 :     return NS_ERROR_NOT_IMPLEMENTED;
     285                 : }
     286                 : 
     287                 : /* End of implementation class template. */
     288                 : #endif
     289                 : 
     290                 : 
     291                 : #endif /* __gen_mozIStorageStatementWrapper_h__ */

Generated by: LCOV version 1.7