home *** CD-ROM | disk | FTP | other *** search
/ Supercompiler 1997 / SUPERCOMPILER97.iso / MS_DAO.SDK / DISK4 / DAOSDK.1 / _dbdao.h next >
Encoding:
C/C++ Source or Header  |  1996-02-08  |  11.4 KB  |  519 lines
  1. /************************************************************************
  2. **    _ D B D A O . H                                                    *
  3. **                                                                        *
  4. *************************************************************************
  5. ** Copyright (C) 1995 by Microsoft Corporation                     *
  6. **           All Rights Reserved                                             *
  7. ************************************************************************/
  8. /*
  9.     _DBDAO.H
  10.  
  11.     Internal definitions and prototypes for dbdao C++ classes
  12. */
  13. #ifndef __DBDAO_H_
  14. #define __DBDAO_H_
  15.  
  16.  
  17. class CdbBStr;
  18.  
  19. /*****************************************************************************
  20. * DAO runtime key
  21. */
  22. const char szKEY[] = "mjgcqcejfchcijecpdhckcdjqigdejfccjri";
  23.  
  24. /*****************************************************************************
  25. * Miscellaneous defines
  26. */
  27. #define DAO_MAXSEEKFIELDS 13
  28.  
  29.  
  30. /*****************************************************************************
  31. * CdbBSTR (OLE BSTR helper)
  32. */
  33. class DLLEXPORT CdbBSTR
  34.     {
  35.     public:
  36.     CONSTRUCTOR            CdbBSTR                (BSTR=NULL);
  37.     DESTRUCTOR            ~CdbBSTR            (VOID);
  38.  
  39.     operator            BSTR *                (VOID);
  40.     operator            LPCTSTR                (VOID);
  41.  
  42.     private:
  43.     BSTR                m_bstr;
  44.     };
  45.  
  46. /*****************************************************************************
  47. * CdbVariant (OLE Variant helper)
  48. */
  49. class CdbVariant : public COleVariant
  50.     {
  51.     public:
  52.     CONSTRUCTOR                        CdbVariant                        (LONG l);
  53.     CONSTRUCTOR                     CdbVariant                      (VOID);
  54.     CONSTRUCTOR                     CdbVariant                      (LPCTSTR pstr);
  55.     CONSTRUCTOR                     CdbVariant                      (SHORT s, BOOL bIsBool = FALSE);
  56.     CONSTRUCTOR                     CdbVariant                      (LPVARIANT pv);
  57.     CONSTRUCTOR                     CdbVariant                      (LPSAFEARRAY psa);
  58.  
  59.     VOID                            operator =                      (LPVARIANT pv);
  60.     VOID                            operator =                      (LPCTSTR pstr);
  61.     VOID                            operator =                      (SHORT s);
  62.     VOID                            operator =                      (const int i);
  63.     VOID                            operator =                      (LONG l);
  64.     };
  65.  
  66. inline CONSTRUCTOR    CdbVariant::CdbVariant(
  67.     VOID) : COleVariant()
  68.     {
  69.     vt        = VT_ERROR;
  70.     scode    = DISP_E_PARAMNOTFOUND;
  71.     }
  72.  
  73. inline CdbVariant::CdbVariant (LONG l)
  74. {
  75.         if (l == -1)        
  76.             {    
  77.             vt        = VT_ERROR;
  78.             scode    = DISP_E_PARAMNOTFOUND;
  79.             }
  80.         else
  81.             {
  82.             vt        = VT_I4;
  83.             lVal    = l;
  84.             }
  85. }
  86.  
  87.  
  88. inline CONSTRUCTOR    CdbVariant::CdbVariant(
  89.     LPCTSTR pstr): COleVariant(pstr,VT_BSTRT)
  90.     {
  91.     if (!pstr)
  92.         {
  93.         VariantClear(this);
  94.         vt        = VT_ERROR;
  95.         scode    = DISP_E_PARAMNOTFOUND;
  96.         }
  97.     }
  98.  
  99.  
  100. inline CONSTRUCTOR    CdbVariant::CdbVariant(
  101.     SHORT s, BOOL bIsBool) : COleVariant(s)
  102.     {
  103.     if (bIsBool)
  104.         {
  105.         vt        = VT_BOOL;
  106.         boolVal    = s;
  107.         }
  108.     else if (s==-1)
  109.         {
  110.         vt        = VT_ERROR;
  111.         scode    = DISP_E_PARAMNOTFOUND;
  112.         }
  113.     }
  114.  
  115. inline CONSTRUCTOR    CdbVariant::CdbVariant(
  116.     LPVARIANT    pv)
  117.     {
  118.     if (!pv)
  119.         {
  120.         vt        = VT_ERROR;
  121.         scode    = DISP_E_PARAMNOTFOUND;
  122.         }
  123.     else
  124.         VariantCopy(this, pv);
  125.     }
  126.  
  127. inline CONSTRUCTOR    CdbVariant::CdbVariant(
  128.     LPSAFEARRAY psa)
  129.     {
  130.     if (!psa)
  131.         {
  132.         vt        = VT_ERROR;
  133.         scode    = DISP_E_PARAMNOTFOUND;
  134.         }
  135.     else
  136.         {
  137.         vt        = VT_ARRAY|VT_UI1;
  138.         parray    = psa;
  139.         }
  140.     }
  141.  
  142. inline VOID    CdbVariant::operator =(
  143.     LPVARIANT pv)
  144.     {
  145.     if (!pv)
  146.         {
  147.         vt        = VT_ERROR;
  148.         scode    = DISP_E_PARAMNOTFOUND;
  149.         }
  150.     else
  151.         VariantCopy(this, pv);
  152.     }
  153.  
  154. inline VOID    CdbVariant::operator =(
  155.     LPCTSTR pstr) 
  156.     {
  157.     if (!pstr)
  158.         {
  159.         VariantClear(this);
  160.         vt        = VT_ERROR;
  161.         scode    = DISP_E_PARAMNOTFOUND;
  162.         }
  163.     else
  164.         {
  165. #ifdef UNICODE
  166.         bstrVal = SysAllocString(pstr);
  167. #else
  168.         bstrVal = SysAllocStringByteLen(pstr, strlen(pstr));
  169. #endif
  170.         vt = VT_BSTR;
  171.         }
  172.     }
  173.  
  174.  
  175. inline VOID    CdbVariant::operator =(
  176.     SHORT s)
  177.     {
  178.     if (s==-1)
  179.         {
  180.         vt        = VT_ERROR;
  181.         scode    = DISP_E_PARAMNOTFOUND;
  182.         }
  183.     else
  184.         {
  185.         vt        = VT_I2;
  186.         iVal    = s;
  187.         }
  188.     }
  189.  
  190. inline VOID    CdbVariant::operator =(
  191.     const int i)
  192.     {
  193.     if (i==-1)
  194.         {
  195.         vt        = VT_ERROR;
  196.         scode    = DISP_E_PARAMNOTFOUND;
  197.         }
  198.     else
  199.         {
  200.         vt        = VT_I2;
  201.         iVal    = (SHORT)i;
  202.         }
  203.     }
  204.  
  205.  
  206. inline VOID    CdbVariant::operator =(
  207.     LONG     l)
  208.     {
  209.     if (l==-1)
  210.         {
  211.         vt         = VT_ERROR;
  212.         scode    = DISP_E_PARAMNOTFOUND;
  213.         }
  214.     else
  215.         {
  216.         vt        = VT_I4;
  217.         lVal    = l;
  218.         }
  219.     }
  220.  
  221.  
  222. /*****************************************************************************
  223. * CdbWide
  224. */
  225. HRESULT    CdbWideFromAnsi(LPSTR, unsigned int, BSTR *);
  226.  
  227. class CdbWide
  228.     {
  229.     public:
  230.     CONSTRUCTOR            CdbWide                (LPSTR pstr, unsigned int cb=0)
  231.         {
  232.         CdbWideFromAnsi(pstr, (pstr ? (cb==0 ? strlen(pstr) : cb) : 0), &m_bstr);
  233.         }
  234.     DESTRUCTOR            ~CdbWide            ()
  235.         {
  236.         SysFreeString(m_bstr);
  237.         }
  238.  
  239.     operator            LPWSTR                    ()
  240.         {
  241.         return (LPWSTR)m_bstr;
  242.         }
  243.     operator            LPSTR                    ()
  244.         {
  245.         return (LPSTR)m_bstr;
  246.         }
  247.  
  248.     ULONG                cBytes                    ()
  249.         {
  250.         return SysStringByteLen(m_bstr);
  251.         }
  252.  
  253.     private:
  254.     BSTR                m_bstr;
  255.     };
  256.  
  257. /*****************************************************************************
  258. * Helper macros
  259. */
  260.  
  261. //Initialize a variant
  262. #define DAOVINIT(var)                        \
  263.     do                                        \
  264.         {                                    \
  265.         (var).vt    = VT_ERROR;                \
  266.         (var).scode    = DISP_E_PARAMNOTFOUND;    \
  267.         }                                    \
  268.     while (0)
  269.  
  270.  
  271. // LPTSTR to VARIANT
  272. #define STV(pstr)    CdbVariant(pstr)
  273.  
  274. // LPTSTR to BSTR
  275. #define STB(pstr)    V_BSTR(((LPVARIANT)STV(pstr)))
  276.  
  277. // LONG to VARIANT
  278. #define LTV(l)        CdbVariant(l)
  279.  
  280. // Optional LONG to VARIANT
  281. #define OLTV(l)        CdbVariant((l))
  282.  
  283. // C/C++ bool to DAO bool
  284. #define BTB(b)        ((VARIANT_BOOL)(b?-1:0))
  285.  
  286. // C/C++ bool to VARIANT
  287. #define BTV(b)        CdbVariant(BTB(b), TRUE)
  288.  
  289. // C/C++ short to VARIANT
  290. #define SHTV(s)        CdbVariant((SHORT)s)
  291.  
  292. // OLE variant to VARIANT
  293. #define VTV(pv)        CdbVariant(pv)
  294.  
  295. // SAFEARRAY to VARIANT
  296. #define ATV(psa, var)                                \
  297.     do                                                \
  298.         {                                            \
  299.         if (!psa)                                    \
  300.             {                                        \
  301.             var.vt        = VT_ERROR;                    \
  302.             var.scode    = DISP_E_PARAMNOTFOUND;        \
  303.             }                                        \
  304.         else                                        \
  305.             {                                        \
  306.             var.vt        = VT_ARRAY|VT_UI1;            \
  307.             var.parray    = psa;                        \
  308.             }                                        \
  309.         }                                            \
  310.     while (0)
  311.  
  312. #if !defined(DAOMFC_DONT_THROW_EXCEPTIONS)
  313.  
  314. #define DAOMFC_CALL(hr)                        \
  315.     do \
  316.     { \
  317.     HRESULT  hresult = (hr);           \
  318.         if(FAILED(hresult)) \
  319.         { \
  320.             TRACE0("\nDBDAO Call Failed.\n\t"); \
  321.             TRACE2("\nIn file %s on line %d\n", _T("DBDAO.CPP"), __LINE__); \
  322.             TRACE1("hResult = %X\n", hresult); \
  323.             if (GetScode(hresult) == E_OUTOFMEMORY) \
  324.                 AfxThrowMemoryException(); \
  325.             else \
  326.                 throw CdbException(hresult); \
  327.         } \
  328.     } while (0)
  329.  
  330. #else
  331.  
  332. #define DAOMFC_CALL(hr)        (hr)
  333.  
  334. #endif // DAOMFC_THROW_EXCEPTIONS
  335.  
  336.  
  337. /*****************************************************************************
  338. * Property Set/Get helper macros
  339. */
  340.  
  341. // Get a LONG property
  342. #define LPROPGET(intDAO, meth)                        \
  343.     do                                                \
  344.         {                                            \
  345.         intDAO *    p    = (intDAO *)GetInterface();    \
  346.         LONG        l    = 0;                        \
  347.                                                     \
  348.         DAOMFC_CALL(p->meth(&l));                    \
  349.                                                     \
  350.         return l;                                    \
  351.         }                                            \
  352.     while (0)
  353.  
  354. // Set a LONG property
  355. #define LPROPSET(intDAO, meth, l)                    \
  356.     do                                                \
  357.         {                                            \
  358.         intDAO *    p = (intDAO *)GetInterface();    \
  359.                                                     \
  360.         DAOMFC_CALL(p->meth(l));                    \
  361.         }                                            \
  362.     while(0)
  363.  
  364. // Get a SHORT property
  365. #define WPROPGET(intDAO, meth)                        \
  366.     do                                                \
  367.         {                                            \
  368.         intDAO *    p    = (intDAO *)GetInterface();    \
  369.         SHORT        s    = 0;                        \
  370.                                                     \
  371.         DAOMFC_CALL(p->meth(&s));                    \
  372.                                                     \
  373.         return s;                                    \
  374.         }                                            \
  375.     while (0)
  376.  
  377. // Set a SHORT property
  378. #define WPROPSET(intDAO, meth, s)                    \
  379.     do                                                \
  380.         {                                            \
  381.         intDAO *    p = (intDAO *)GetInterface();    \
  382.                                                     \
  383.         DAOMFC_CALL(p->meth(s));                    \
  384.         }                                            \
  385.     while(0)
  386.  
  387. // Get a STRING property
  388. #define SPROPGET(intDAO, meth)                        \
  389.     do                                                \
  390.         {                                            \
  391.         intDAO *    p    = (intDAO *)GetInterface();    \
  392.         CdbBSTR        bstr;                            \
  393.                                                     \
  394.         DAOMFC_CALL(p->meth(bstr));                    \
  395.                                                     \
  396.         return bstr;                                \
  397.         }                                            \
  398.     while (0)
  399.  
  400. // Set a STRING property
  401. #define SPROPSET(intDAO, meth, s)                    \
  402.     do                                                \
  403.         {                                            \
  404.         intDAO *    p = (intDAO *)GetInterface();    \
  405.                                                     \
  406.         DAOMFC_CALL(p->meth(STB(s)));                \
  407.         }                                            \
  408.     while(0)
  409.  
  410. // Get a DATETIME property
  411. #define DPROPGET(intDAO, meth)                        \
  412.     do                                                \
  413.         {                                            \
  414.         intDAO *    p    = (intDAO *)GetInterface();    \
  415.         VARIANT     Var;                                \
  416.                                                     \
  417.         VariantInit(&Var);                            \
  418.         DAOMFC_CALL(p->meth(&Var));                    \
  419.         return Var;                                    \
  420.         }                                            \
  421.     while (0)
  422.  
  423. // Set a DATETIME property
  424. #define DPROPSET(intDAO, meth, pv)                    \
  425.     do                                                \
  426.         {                                            \
  427.         intDAO *    p = (intDAO *)GetInterface();    \
  428.                                                     \
  429.         DAOMFC_CALL(p->meth(*pv));                    \
  430.         }                                            \
  431.     while(0)
  432.  
  433. // Get a BOOLEAN property
  434. #define BPROPGET(intDAO, meth)                            \
  435.     do                                                    \
  436.         {                                                \
  437.         intDAO *        p    = (intDAO *)GetInterface();    \
  438.         VARIANT_BOOL    vb    = 0;                        \
  439.                                                         \
  440.         DAOMFC_CALL(p->meth(&vb));                        \
  441.                                                         \
  442.         return (BOOL)vb;                                \
  443.         }                                                \
  444.     while (0)
  445.  
  446. // Set a BOOLEAN property
  447. #define BPROPSET(intDAO, meth, b)                        \
  448.     do                                                    \
  449.         {                                                \
  450.         intDAO *    p = (intDAO *)GetInterface();        \
  451.                                                         \
  452.         DAOMFC_CALL(p->meth(BTB(b)));                    \
  453.         }                                                \
  454.     while(0)
  455.  
  456. // Get a VARIANT property
  457. #define VPROPGET(intDAO, meth)                        \
  458.     do                                                \
  459.         {                                            \
  460.         intDAO *    p    = (intDAO *)GetInterface();    \
  461.         COleVariant     v;                                \
  462.                                                     \
  463.         VariantInit(&v);                            \
  464.         DAOMFC_CALL(p->meth(&v));                    \
  465.                                                     \
  466.         return &v;                                    \
  467.         }                                            \
  468.     while (0)
  469.  
  470. // Set a VARIANT property
  471. #define VPROPSET(intDAO, meth, pv)                    \
  472.     do                                                \
  473.         {                                            \
  474.         intDAO *    p = (intDAO *)GetInterface();    \
  475.                                                     \
  476.         DAOMFC_CALL(p->meth(*pv));                    \
  477.         }                                            \
  478.     while(0)
  479.  
  480. // Get a DWORD property
  481. #define DWPROPGET(intDAO, meth)                        \
  482.     do                                                \
  483.         {                                            \
  484.         intDAO *    p    = (intDAO *)GetInterface();    \
  485.         DWORD        dw    = 0;                        \
  486.                                                     \
  487.         DAOMFC_CALL(p->meth(&dw));                    \
  488.                                                     \
  489.         return dw;                                    \
  490.         }                                            \
  491.     while (0)
  492.  
  493.  
  494. #define DAOMFC_STATIC_COLLECTION_IMPL(objColl, objSingle, intColl, intSingle)                                                     \
  495.         objSingle            objColl::Item                (LONG i)         { return (intSingle *)(ObItem(i).GetInterface(TRUE)); }     \
  496.         objSingle            objColl::Item                (LPCTSTR pstr)    { return (intSingle *)(ObItem(pstr).GetInterface(TRUE)); } \
  497.         objSingle            objColl::operator[]            (LONG i)        { return (intSingle *)(Item(i).GetInterface(TRUE)); } \
  498.         objSingle            objColl::operator[]            (LPCTSTR pstr)    { return (intSingle *)(Item(pstr).GetInterface(TRUE)); }
  499.  
  500. #define DAOMFC_DYNAMIC_COLLECTION_IMPL(objColl, objSingle, intColl, intSingle)                                                     \
  501.         objSingle            objColl::Item                (LONG i)         { return (intSingle *)(ObItem(i).GetInterface(TRUE)); }     \
  502.         objSingle            objColl::Item                (LPCTSTR pstr)    { return (intSingle *)(ObItem(pstr).GetInterface(TRUE)); } \
  503.         VOID                objColl::Append                (objSingle &o)    { ObAppend(o); } \
  504.         objSingle            objColl::operator[]            (LONG i)        { return (intSingle *)(Item(i).GetInterface(TRUE)); } \
  505.         objSingle            objColl::operator[]            (LPCTSTR pstr)    { return (intSingle *)(Item(pstr).GetInterface(TRUE)); }
  506.  
  507. DECLARE_INTERFACE_(DAOMFCSCollection, _DAOCollection)
  508. {
  509. STDMETHOD(get_Item)        (VARIANT index, LPUNKNOWN *ppunk);
  510. };
  511.  
  512. DECLARE_INTERFACE_(DAOMFCDCollection, _DAODynaCollection)
  513. {
  514. STDMETHOD(get_Item)        (VARIANT index, LPUNKNOWN *ppunk);
  515. };
  516.  
  517.  
  518. #endif // __DBDAO_H_ 
  519.