home *** CD-ROM | disk | FTP | other *** search
/ Mastering MFC Development / MMD.ISO / labs / c10 / lab01 / ex03 / vardecoder.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1997-02-20  |  6.4 KB  |  323 lines
  1. #include "stdafx.h"
  2. #include "VarDecoder.h"
  3.  
  4.  
  5.  
  6. LPCTSTR strFieldType(short sType)
  7. {
  8.     switch(sType){
  9.         case (dbBoolean):
  10.             return _T("Bool");
  11.         case (dbByte):
  12.             return _T("Byte");
  13.         case (dbInteger):
  14.             return _T("Integer");
  15.         case (dbLong):
  16.             return _T("Long");
  17.         case (dbCurrency):
  18.             return _T("Currency");
  19.         case (dbSingle):
  20.             return _T("Single");
  21.         case (dbDouble):
  22.             return _T("Double");
  23.         case (dbDate):
  24.             return _T("Date");
  25.         case (dbText):
  26.             return _T("Text");
  27.         case (dbLongBinary):
  28.             return _T("Long Binary");
  29.         case (dbMemo):
  30.             return _T("Memo");
  31.         case (dbGUID):
  32.             return _T("GUID");
  33.     }
  34.     return _T("Unknown");
  35. }
  36.  
  37. LPCTSTR strQueryDefType(short sType)
  38. {
  39.     switch(sType){
  40.         case (dbQSelect):
  41.             return _T("Select");
  42.         case (dbQAction):
  43.             return _T("Action");
  44.         case (dbQCrosstab):
  45.             return _T("Crosstab");
  46.         case (dbQDelete):
  47.             return _T("Delete");
  48.         case (dbQUpdate):
  49.             return _T("Update");
  50.         case (dbQAppend):
  51.             return _T("Append");
  52.         case (dbQMakeTable):
  53.             return _T("MakeTable");
  54.         case (dbQDDL):
  55.             return _T("DDL");
  56.         case (dbQSQLPassThrough):
  57.             return _T("SQLPassThrough");
  58.         case (dbQSetOperation):
  59.             return _T("Set Operation");
  60.         case (dbQSPTBulk):
  61.             return _T("SPTBulk");
  62.     }
  63.     return _T("Unknown");
  64. }
  65.  
  66. LPCTSTR strBOOL(BOOL bFlag)
  67. {
  68.     return bFlag ? _T("TRUE") : _T("FALSE");
  69. }
  70.  
  71. CString strVARIANT( const COleVariant & var )
  72. {
  73.     CString strRet;
  74.     strRet = _T("Dummy");
  75.     switch(var.vt){
  76.         case VT_EMPTY:
  77.         case VT_NULL:
  78.             strRet = _T("");
  79.             break;
  80.         case VT_I2:
  81.             strRet.Format(_T("%hd"),V_I2(&var));
  82.             break;
  83.         case VT_I4:
  84.             strRet.Format(_T("%d"),V_I4(&var));
  85.             break;
  86.         case VT_R4:
  87.             strRet.Format(_T("%g"),(double)V_R4(&var));
  88.             break;
  89.         case VT_R8:
  90.             strRet.Format(_T("%g"),V_R8(&var));
  91.             break;
  92.         case VT_CY:
  93.             strRet = COleCurrency(var).Format();
  94.             break;
  95.         case VT_DATE:
  96.             strRet = COleDateTime(var).Format(_T("%m/%d/%y"));
  97.             break;
  98.         case VT_BSTR:
  99.             strRet = V_BSTRT(&var);
  100.             break;
  101.         case VT_DISPATCH:
  102.             strRet = _T("VT_DISPATCH");
  103.             break;
  104.         case VT_ERROR:
  105.             strRet = _T("VT_ERROR");
  106.             break;
  107.         case VT_BOOL:
  108.             return strBOOL(V_BOOL(&var));
  109.         case VT_VARIANT:
  110.             strRet = _T("VT_VARIANT");
  111.             break;
  112.         case VT_UNKNOWN:
  113.             strRet = _T("VT_UNKNOWN");
  114.             break;
  115.         case VT_I1:
  116.             strRet = _T("VT_I1");
  117.             break;
  118.         case VT_UI1:
  119.             strRet.Format(_T("0x%02hX"),(unsigned short)V_UI1(&var));
  120.             break;
  121.         case VT_UI2:
  122.             strRet = _T("VT_UI2");
  123.             break;
  124.         case VT_UI4:
  125.             strRet = _T("VT_UI4");
  126.             break;
  127.         case VT_I8:
  128.             strRet = _T("VT_I8");
  129.             break;
  130.         case VT_UI8:
  131.             strRet = _T("VT_UI8");
  132.             break;
  133.         case VT_INT:
  134.             strRet = _T("VT_INT");
  135.             break;
  136.         case VT_UINT:
  137.             strRet = _T("VT_UINT");
  138.             break;
  139.         case VT_VOID:
  140.             strRet = _T("VT_VOID");
  141.             break;
  142.         case VT_HRESULT:
  143.             strRet = _T("VT_HRESULT");
  144.             break;
  145.         case VT_PTR:
  146.             strRet = _T("VT_PTR");
  147.             break;
  148.         case VT_SAFEARRAY:
  149.             strRet = _T("VT_SAFEARRAY");
  150.             break;
  151.         case VT_CARRAY:
  152.             strRet = _T("VT_CARRAY");
  153.             break;
  154.         case VT_USERDEFINED:
  155.             strRet = _T("VT_USERDEFINED");
  156.             break;
  157.         case VT_LPSTR:
  158.             strRet = _T("VT_LPSTR");
  159.             break;
  160.         case VT_LPWSTR:
  161.             strRet = _T("VT_LPWSTR");
  162.             break;
  163.         case VT_FILETIME:
  164.             strRet = _T("VT_FILETIME");
  165.             break;
  166.         case VT_BLOB:
  167.             strRet = _T("VT_BLOB");
  168.             break;
  169.         case VT_STREAM:
  170.             strRet = _T("VT_STREAM");
  171.             break;
  172.         case VT_STORAGE:
  173.             strRet = _T("VT_STORAGE");
  174.             break;
  175.         case VT_STREAMED_OBJECT:
  176.             strRet = _T("VT_STREAMED_OBJECT");
  177.             break;
  178.         case VT_STORED_OBJECT:
  179.             strRet = _T("VT_STORED_OBJECT");
  180.             break;
  181.         case VT_BLOB_OBJECT:
  182.             strRet = _T("VT_BLOB_OBJECT");
  183.             break;
  184.         case VT_CF:
  185.             strRet = _T("VT_CF");
  186.             break;
  187.         case VT_CLSID:
  188.             strRet = _T("VT_CLSID");
  189.             break;
  190.     }
  191.     WORD vt = var.vt;
  192.     if(vt & VT_ARRAY){
  193.         vt = vt & ~VT_ARRAY;
  194.         strRet = _T("Array of ");
  195.     }
  196.     if(vt & VT_BYREF){
  197.         vt = vt & ~VT_BYREF;
  198.         strRet += _T("Pointer to ");
  199.     }
  200.     if(vt != var.vt){
  201.         switch(vt){
  202.             case VT_EMPTY:
  203.                 strRet += _T("VT_EMPTY");
  204.                 break;
  205.             case VT_NULL:
  206.                 strRet += _T("VT_NULL");
  207.                 break;
  208.             case VT_I2:
  209.                 strRet += _T("VT_I2");
  210.                 break;
  211.             case VT_I4:
  212.                 strRet += _T("VT_I4");
  213.                 break;
  214.             case VT_R4:
  215.                 strRet += _T("VT_R4");
  216.                 break;
  217.             case VT_R8:
  218.                 strRet += _T("VT_R8");
  219.                 break;
  220.             case VT_CY:
  221.                 strRet += _T("VT_CY");
  222.                 break;
  223.             case VT_DATE:
  224.                 strRet += _T("VT_DATE");
  225.                 break;
  226.             case VT_BSTR:
  227.                 strRet += _T("VT_BSTR");
  228.                 break;
  229.             case VT_DISPATCH:
  230.                 strRet += _T("VT_DISPATCH");
  231.                 break;
  232.             case VT_ERROR:
  233.                 strRet += _T("VT_ERROR");
  234.                 break;
  235.             case VT_BOOL:
  236.                 strRet += _T("VT_BOOL");
  237.                 break;
  238.             case VT_VARIANT:
  239.                 strRet += _T("VT_VARIANT");
  240.                 break;
  241.             case VT_UNKNOWN:
  242.                 strRet += _T("VT_UNKNOWN");
  243.                 break;
  244.             case VT_I1:
  245.                 strRet += _T("VT_I1");
  246.                 break;
  247.             case VT_UI1:
  248.                 strRet += _T("VT_UI1");
  249.                 break;
  250.             case VT_UI2:
  251.                 strRet += _T("VT_UI2");
  252.                 break;
  253.             case VT_UI4:
  254.                 strRet += _T("VT_UI4");
  255.                 break;
  256.             case VT_I8:
  257.                 strRet += _T("VT_I8");
  258.                 break;
  259.             case VT_UI8:
  260.                 strRet += _T("VT_UI8");
  261.                 break;
  262.             case VT_INT:
  263.                 strRet += _T("VT_INT");
  264.                 break;
  265.             case VT_UINT:
  266.                 strRet += _T("VT_UINT");
  267.                 break;
  268.             case VT_VOID:
  269.                 strRet += _T("VT_VOID");
  270.                 break;
  271.             case VT_HRESULT:
  272.                 strRet += _T("VT_HRESULT");
  273.                 break;
  274.             case VT_PTR:
  275.                 strRet += _T("VT_PTR");
  276.                 break;
  277.             case VT_SAFEARRAY:
  278.                 strRet += _T("VT_SAFEARRAY");
  279.                 break;
  280.             case VT_CARRAY:
  281.                 strRet += _T("VT_CARRAY");
  282.                 break;
  283.             case VT_USERDEFINED:
  284.                 strRet += _T("VT_USERDEFINED");
  285.                 break;
  286.             case VT_LPSTR:
  287.                 strRet += _T("VT_LPSTR");
  288.                 break;
  289.             case VT_LPWSTR:
  290.                 strRet += _T("VT_LPWSTR");
  291.                 break;
  292.             case VT_FILETIME:
  293.                 strRet += _T("VT_FILETIME");
  294.                 break;
  295.             case VT_BLOB:
  296.                 strRet += _T("VT_BLOB");
  297.                 break;
  298.             case VT_STREAM:
  299.                 strRet += _T("VT_STREAM");
  300.                 break;
  301.             case VT_STORAGE:
  302.                 strRet += _T("VT_STORAGE");
  303.                 break;
  304.             case VT_STREAMED_OBJECT:
  305.                 strRet += _T("VT_STREAMED_OBJECT");
  306.                 break;
  307.             case VT_STORED_OBJECT:
  308.                 strRet += _T("VT_STORED_OBJECT");
  309.                 break;
  310.             case VT_BLOB_OBJECT:
  311.                 strRet += _T("VT_BLOB_OBJECT");
  312.                 break;
  313.             case VT_CF:
  314.                 strRet += _T("VT_CF");
  315.                 break;
  316.             case VT_CLSID:
  317.                 strRet += _T("VT_CLSID");
  318.                 break;
  319.         }
  320.     }
  321.     return strRet;
  322. }
  323.