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