home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Windows Gam…ming Gurus (2nd Edition) / Disc2.iso / msdn_vcb / samples / vc98 / sdk / netds / adsi / sampprov / smpoper.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1997-07-29  |  13.1 KB  |  665 lines
  1. /*++
  2.  
  3. Copyright (c) 1996 Microsoft Corporation
  4.  
  5. Module Name:
  6.  
  7.     SmpOper.cpp
  8.  
  9. Abstract:
  10.  
  11.     SampleDS DataType Operation routines 
  12.     
  13. Author:
  14.  
  15. Environment:
  16.  
  17.     User mode
  18.  
  19. Revision History :
  20.  
  21. --*/
  22. #include "adssmp.h"
  23. #pragma hdrstop
  24.  
  25.  
  26. HRESULT
  27. SampleDSTypeFreeSampleDSSynId1(
  28.     PSampleDSOBJECT lpSampleDSDestObject
  29.     )
  30. {
  31.     HRESULT hr = S_OK;
  32.  
  33.     FreeProvStr(lpSampleDSDestObject->SampleDSValue.value_1.DNString);
  34.  
  35.     RRETURN(hr);
  36. }
  37.  
  38. HRESULT
  39. SampleDSTypeFreeSampleDSSynId2(
  40.     PSampleDSOBJECT lpSampleDSDestObject
  41.     )
  42. {
  43.     HRESULT hr = S_OK;
  44.  
  45.     //
  46.     // Do nothing - Integer
  47.     //
  48.  
  49.     RRETURN(hr);
  50.  
  51. }
  52.  
  53. HRESULT
  54. SampleDSTypeClear(
  55.     PSampleDSOBJECT lpSampleDSDestObject
  56.     )
  57. {
  58.     HRESULT hr = S_OK;
  59.     switch (lpSampleDSDestObject->SampleDSType) {
  60.     case 1:
  61.         hr = SampleDSTypeFreeSampleDSSynId1(
  62.                 lpSampleDSDestObject
  63.                 );
  64.         break;
  65.     case 2:
  66.         hr = SampleDSTypeFreeSampleDSSynId2(
  67.                 lpSampleDSDestObject
  68.                 );
  69.         break;
  70.  
  71.  
  72.     default:
  73.         hr = E_FAIL;
  74.         break;
  75.     }
  76.  
  77.     RRETURN(hr);
  78. }
  79.  
  80. void
  81. SampleDSTypeFreeSampleDSObjects(
  82.     PSampleDSOBJECT pSampleDSObject,
  83.     DWORD dwNumValues
  84.     )
  85. {
  86.     DWORD i = 0;
  87.  
  88.     for (i = 0; i < dwNumValues; i++ ) {
  89.          SampleDSTypeClear(pSampleDSObject + i);
  90.     }
  91.  
  92.     FreeProvMem(pSampleDSObject);
  93.  
  94.     return;
  95. }
  96.  
  97.  
  98. HRESULT
  99. SampleDSTypeCopySampleDSSynId1(
  100.     PSampleDSOBJECT lpSampleDSSrcObject,
  101.     PSampleDSOBJECT lpSampleDSDestObject
  102.     )
  103. {
  104.     HRESULT hr = S_OK;
  105.  
  106.     lpSampleDSDestObject->SampleDSType = lpSampleDSSrcObject->SampleDSType;
  107.  
  108.     lpSampleDSDestObject->SampleDSValue.value_1.DNString =
  109.                     (LPWSTR)AllocProvStr(
  110.                             lpSampleDSSrcObject->SampleDSValue.value_1.DNString
  111.                             );
  112.     RRETURN(hr);
  113. }
  114.  
  115. HRESULT
  116. SampleDSTypeCopySampleDSSynId2(
  117.     PSampleDSOBJECT lpSampleDSSrcObject,
  118.     PSampleDSOBJECT lpSampleDSDestObject
  119.     )
  120. {
  121.     HRESULT hr = S_OK;
  122.  
  123.     lpSampleDSDestObject->SampleDSType = lpSampleDSSrcObject->SampleDSType;
  124.  
  125.  
  126.     lpSampleDSDestObject->SampleDSValue.value_2.Integer =
  127.                         lpSampleDSSrcObject->SampleDSValue.value_2.Integer;
  128.  
  129.     RRETURN(hr);
  130.  
  131. }
  132.  
  133. HRESULT
  134. SampleDSTypeCopy(
  135.     PSampleDSOBJECT lpSampleDSSrcObject,
  136.     PSampleDSOBJECT lpSampleDSDestObject
  137.     )
  138. {
  139.     HRESULT hr = S_OK;
  140.     switch (lpSampleDSSrcObject->SampleDSType) {
  141.     case 1:
  142.         hr = SampleDSTypeCopySampleDSSynId1(
  143.                 lpSampleDSSrcObject,
  144.                 lpSampleDSDestObject
  145.                 );
  146.         break;
  147.     case 2:
  148.         hr = SampleDSTypeCopySampleDSSynId2(
  149.                 lpSampleDSSrcObject,
  150.                 lpSampleDSDestObject
  151.                 );
  152.         break;
  153.  
  154.  
  155.     default:
  156.         hr = E_FAIL;
  157.         break;
  158.     }
  159.  
  160.     RRETURN(hr);
  161. }
  162.  
  163.  
  164.  
  165. HRESULT
  166. SampleDSTypeCopyConstruct(
  167.     LPSampleDSOBJECT pSampleDSSrcObjects,
  168.     DWORD dwNumObjects,
  169.     LPSampleDSOBJECT * ppSampleDSDestObjects
  170.     )
  171. {
  172.  
  173.     DWORD i = 0;
  174.     LPSampleDSOBJECT pSampleDSDestObjects = NULL;
  175.     HRESULT hr = S_OK;
  176.  
  177.     pSampleDSDestObjects = (LPSampleDSOBJECT)AllocProvMem(
  178.                                     dwNumObjects * sizeof(SampleDSOBJECT)
  179.                                     );
  180.  
  181.     if (!pSampleDSDestObjects) {
  182.         RRETURN(E_FAIL);
  183.     }
  184.  
  185.      for (i = 0; i < dwNumObjects; i++ ) {
  186.          hr = SampleDSTypeCopy(pSampleDSSrcObjects + i, 
  187.                                pSampleDSDestObjects + i
  188.                                );
  189.      }
  190.  
  191.      *ppSampleDSDestObjects = pSampleDSDestObjects;
  192.  
  193.      RRETURN(S_OK);
  194.  
  195. }
  196.  
  197. HRESULT
  198. UnMarshallSampleDSToSampleDSSynId(
  199.     DWORD dwSyntaxId,
  200.     DWORD dwNumValues,
  201.     LPBYTE lpValue,
  202.     PSampleDSOBJECT * ppSampleDSObject
  203.     )
  204. {
  205.     LPBYTE lpByte = lpValue;
  206.     DWORD  i = 0;
  207.     PSampleDSOBJECT pSampleDSObject = NULL;
  208.  
  209.     pSampleDSObject = (PSampleDSOBJECT)AllocProvMem(
  210.                             dwNumValues * sizeof(SampleDSOBJECT)
  211.                             );
  212.  
  213.     if (!pSampleDSObject) {
  214.         RRETURN(E_FAIL);
  215.     }
  216.  
  217.  
  218.     for (i = 0; i < dwNumValues; i++) {
  219.  
  220.         lpByte = CopySampleDSToSampleDSSynId(
  221.                          dwSyntaxId,
  222.                          lpByte,
  223.                          (pSampleDSObject + i)
  224.                          );
  225.  
  226.     }
  227.  
  228.     *ppSampleDSObject = pSampleDSObject;
  229.  
  230.     RRETURN(S_OK);
  231. }
  232.  
  233. LPBYTE
  234. CopySampleDS1ToSampleDSSynId1(
  235.     LPBYTE lpByte,
  236.     PSampleDSOBJECT lpSampleDSObject
  237.     )
  238. {
  239.     LPSampleDS_TYPE_1 lpData_1 = (LPSampleDS_TYPE_1) lpByte;
  240.  
  241.     lpSampleDSObject->SampleDSType = 1;
  242.  
  243.     lpSampleDSObject->SampleDSValue.value_1.DNString =
  244.                     (LPWSTR)AllocProvStr(lpData_1->DNString);
  245.  
  246.     lpByte = (LPBYTE ) lpData_1 + sizeof(SampleDS_TYPE_1);
  247.  
  248.     return(lpByte);
  249. }
  250.        
  251. LPBYTE
  252. CopySampleDS2ToSampleDSSynId2(
  253.     LPBYTE lpByte,
  254.     PSampleDSOBJECT lpSampleDSObject
  255.     )
  256.  
  257. {
  258.     LPSampleDS_TYPE_2 lpData_2 = (LPSampleDS_TYPE_2) lpByte;
  259.  
  260.     lpSampleDSObject->SampleDSType = 2;
  261.  
  262.     lpSampleDSObject->SampleDSValue.value_2.Integer = lpData_2->Integer;
  263.  
  264.     lpByte = (LPBYTE ) lpData_2 + sizeof(SampleDS_TYPE_2);
  265.  
  266.     return(lpByte);
  267. }
  268.  
  269. LPBYTE
  270. CopySampleDSToSampleDSSynId(
  271.     DWORD dwSyntaxId,
  272.     LPBYTE lpByte,
  273.     PSampleDSOBJECT lpSampleDSObject
  274.     )
  275. {
  276.     switch (dwSyntaxId) {
  277.     case 1:
  278.         lpByte = CopySampleDS1ToSampleDSSynId1(
  279.                          lpByte,
  280.                          lpSampleDSObject
  281.                          );
  282.         break;
  283.     case 2:
  284.         lpByte = CopySampleDS2ToSampleDSSynId2(
  285.                          lpByte,
  286.                          lpSampleDSObject
  287.                          );
  288.         break;
  289.  
  290.     default:
  291.         break;
  292.  
  293.     }
  294.  
  295.     return(lpByte);
  296. }
  297.  
  298. HRESULT
  299. MarshallSampleDSSynIdToSampleDS(
  300.     DWORD dwSyntaxId,
  301.     PSampleDSOBJECT pSampleDSObject,
  302.     DWORD dwNumValues,
  303.     LPBYTE lpValue
  304.     )
  305. {
  306.  
  307.     DWORD  i = 0;
  308.  
  309.  
  310.     for (i = 0; i < dwNumValues; i++) {
  311.  
  312.         lpValue = CopySampleDSSynIdToSampleDS(
  313.                          dwSyntaxId,
  314.                          lpValue,
  315.                          (pSampleDSObject + i)
  316.                          );
  317.  
  318.     }
  319.  
  320.     RRETURN(S_OK);
  321. }
  322.  
  323. LPBYTE
  324. CopySampleDSSynId1ToSampleDS1(
  325.     LPBYTE lpByte,
  326.     PSampleDSOBJECT lpSampleDSObject
  327.     )
  328. {
  329.     LPSampleDS_TYPE_1 lpData_1 = (LPSampleDS_TYPE_1) lpByte;
  330.  
  331.     lpData_1->DNString =
  332.                 (LPWSTR)AllocProvStr(
  333.                         lpSampleDSObject->SampleDSValue.value_1.DNString
  334.                         );
  335.  
  336.     lpByte = (LPBYTE ) lpData_1 + sizeof(SampleDS_TYPE_1);
  337.  
  338.     return(lpByte);
  339.  
  340. }
  341.  
  342. LPBYTE
  343. CopySampleDSSynId2ToSampleDS2(
  344.     LPBYTE lpByte,
  345.     PSampleDSOBJECT lpSampleDSObject
  346.     )
  347.  
  348. {
  349.     LPSampleDS_TYPE_2 lpData_2 = (LPSampleDS_TYPE_2) lpByte;
  350.  
  351.  
  352.     lpData_2->Integer = lpSampleDSObject->SampleDSValue.value_2.Integer;
  353.  
  354.     lpByte = (LPBYTE ) lpData_2 + sizeof(SampleDS_TYPE_2);
  355.  
  356.     return(lpByte);
  357. }
  358.  
  359.  
  360. LPBYTE
  361. CopySampleDSSynIdToSampleDS(
  362.     DWORD dwSyntaxId,
  363.     LPBYTE lpByte,
  364.     PSampleDSOBJECT lpSampleDSObject
  365.     )
  366. {
  367.     switch (dwSyntaxId) {
  368.     case 1:
  369.         lpByte = CopySampleDSSynId1ToSampleDS1(
  370.                          lpByte,
  371.                          lpSampleDSObject
  372.                          );
  373.         break;
  374.  
  375.     case 2:
  376.         lpByte = CopySampleDSSynId2ToSampleDS2(
  377.                          lpByte,
  378.                          lpSampleDSObject
  379.                          );
  380.         break;
  381.  
  382.     default:
  383.         break;
  384.  
  385.     }
  386.  
  387.     return(lpByte);
  388. }
  389.  
  390.  
  391. void
  392. VarTypeFreeVarObjects(
  393.     VARIANT *pVarObject,
  394.     DWORD dwNumValues
  395.     )
  396. {
  397.     DWORD i = 0;
  398.  
  399.     for (i = 0; i < dwNumValues; i++ ) {
  400.          VariantClear(pVarObject + i);
  401.     }
  402.  
  403.     FreeProvMem(pVarObject);
  404.  
  405.     return;
  406. }
  407.  
  408.  
  409. HRESULT
  410. SampleDSTypeToVarTypeCopySampleDSSynId1(
  411.     PSampleDSOBJECT lpSampleDSSrcObject,
  412.     VARIANT *lpVarDestObject
  413.     )
  414. {
  415.     HRESULT hr = S_OK;
  416.  
  417.     lpVarDestObject->vt = VT_BSTR;
  418.  
  419.     hr = ProvAllocString(
  420.             lpSampleDSSrcObject->SampleDSValue.value_1.DNString,
  421.             &(lpVarDestObject->bstrVal)
  422.             );
  423.  
  424.     RRETURN(hr);
  425. }
  426.  
  427. HRESULT
  428. SampleDSTypeToVarTypeCopySampleDSSynId2(
  429.     PSampleDSOBJECT lpSampleDSSrcObject,
  430.     PVARIANT lpVarDestObject
  431.     )
  432. {
  433.     HRESULT hr = S_OK;
  434.  
  435.     lpVarDestObject->vt = VT_I4;
  436.  
  437.     lpVarDestObject->lVal =
  438.                 lpSampleDSSrcObject->SampleDSValue.value_2.Integer;
  439.  
  440.     RRETURN(hr);
  441.  
  442. }
  443.  
  444.  
  445. HRESULT
  446. SampleDSTypeToVarTypeCopy(
  447.     PSampleDSOBJECT lpSampleDSSrcObject,
  448.     VARIANT* lpVarDestObject
  449.     )
  450. {
  451.     HRESULT hr = S_OK;
  452.     switch (lpSampleDSSrcObject->SampleDSType) {
  453.     case 1:
  454.         hr = SampleDSTypeToVarTypeCopySampleDSSynId1(
  455.                 lpSampleDSSrcObject,
  456.                 lpVarDestObject
  457.                 );
  458.         break;
  459.     case 2:
  460.         hr = SampleDSTypeToVarTypeCopySampleDSSynId2(
  461.                 lpSampleDSSrcObject,
  462.                 lpVarDestObject
  463.                 );
  464.         break;
  465.  
  466.  
  467.     default:
  468.         hr = E_FAIL;
  469.         break;
  470.     }
  471.  
  472.     RRETURN(hr);
  473. }
  474.  
  475. HRESULT
  476. SampleDSTypeToVarTypeCopyConstruct(
  477.     LPSampleDSOBJECT pSampleDSSrcObjects,
  478.     DWORD dwNumObjects,
  479.     VARIANT *pVarDestObjects
  480.     )
  481. {
  482.     long i = 0;
  483.     HRESULT hr = S_OK;
  484.  
  485.     VariantInit(pVarDestObjects);
  486.  
  487.     if ( dwNumObjects == 1 )
  488.     {
  489.         hr = SampleDSTypeToVarTypeCopy( pSampleDSSrcObjects,
  490.                                    pVarDestObjects );
  491.  
  492.         RRETURN(hr);
  493.     }
  494.  
  495.     //
  496.     // The following are for handling are multi-value properties
  497.     //
  498.  
  499.     SAFEARRAY *aList = NULL;
  500.     SAFEARRAYBOUND aBound;
  501.  
  502.     aBound.lLbound = 0;
  503.     aBound.cElements = dwNumObjects;
  504.  
  505.     aList = SafeArrayCreate( VT_VARIANT, 1, &aBound );
  506.  
  507.     if ( aList == NULL )
  508.     {
  509.         hr = E_OUTOFMEMORY;
  510.         BAIL_ON_FAILURE(hr);
  511.     }
  512.  
  513.     for ( i = 0; i < (long) dwNumObjects; i++ )
  514.     {
  515.         VARIANT v;
  516.  
  517.         VariantInit(&v);
  518.         hr = SampleDSTypeToVarTypeCopy( pSampleDSSrcObjects + i,
  519.                                    &v );
  520.         BAIL_ON_FAILURE(hr);
  521.  
  522.         hr = SafeArrayPutElement( aList, &i, &v );
  523.         BAIL_ON_FAILURE(hr);
  524.     }
  525.  
  526.     V_VT(pVarDestObjects) = VT_ARRAY | VT_VARIANT;
  527.     V_ARRAY(pVarDestObjects) = aList;
  528.  
  529.     RRETURN(S_OK);
  530.  
  531. error:
  532.  
  533.     if ( aList )
  534.         SafeArrayDestroy( aList );
  535.  
  536.     RRETURN(hr);
  537. }
  538.  
  539. HRESULT
  540. VarTypeToSampleDSTypeCopySampleDSSynId1(
  541.     PVARIANT lpVarSrcObject,
  542.     PSampleDSOBJECT lpSampleDSDestObject
  543.     )
  544. {
  545.     HRESULT hr = S_OK;
  546.  
  547.     if(lpVarSrcObject->vt != VT_BSTR){
  548.         RRETURN(hr = E_ADS_CANT_CONVERT_DATATYPE);
  549.     }
  550.  
  551.     lpSampleDSDestObject->SampleDSType = 1;
  552.  
  553.     lpSampleDSDestObject->SampleDSValue.value_1.DNString =
  554.                         AllocProvStr(
  555.                             lpVarSrcObject->bstrVal
  556.                         );
  557.  
  558.     RRETURN(hr);
  559. }
  560.  
  561. HRESULT
  562. VarTypeToSampleDSTypeCopySampleDSSynId2(
  563.     PVARIANT lpVarSrcObject,
  564.     PSampleDSOBJECT lpSampleDSDestObject
  565.     )
  566. {
  567.     HRESULT hr = S_OK;
  568.  
  569.     if(lpVarSrcObject->vt != VT_I4){
  570.         RRETURN(hr = E_ADS_CANT_CONVERT_DATATYPE);
  571.     }
  572.  
  573.     lpSampleDSDestObject->SampleDSType = 2;
  574.  
  575.     lpSampleDSDestObject->SampleDSValue.value_2.Integer =
  576.                         lpVarSrcObject->lVal;
  577.  
  578.     RRETURN(hr);
  579. }
  580.  
  581. HRESULT
  582. VarTypeToSampleDSTypeCopy(
  583.     DWORD dwSampleDSType,
  584.     PVARIANT lpVarSrcObject,
  585.     PSampleDSOBJECT lpSampleDSDestObject
  586.     )
  587. {
  588.     HRESULT hr = S_OK;
  589.     switch (dwSampleDSType){
  590.     case 1:
  591.         hr = VarTypeToSampleDSTypeCopySampleDSSynId1(
  592.                 lpVarSrcObject,
  593.                 lpSampleDSDestObject
  594.                 );
  595.         break;
  596.  
  597.     case 2:
  598.         hr = VarTypeToSampleDSTypeCopySampleDSSynId2(
  599.                 lpVarSrcObject,
  600.                 lpSampleDSDestObject
  601.                 );
  602.         break;
  603.     default:
  604.         hr = E_FAIL;
  605.         break;
  606.     }
  607.  
  608.     RRETURN(hr);
  609. }
  610.  
  611.  
  612.  
  613. HRESULT
  614. VarTypeToSampleDSTypeCopyConstruct(
  615.     DWORD dwSampleDSType,
  616.     LPVARIANT pVarSrcObjects,
  617.     DWORD dwNumObjects,
  618.     LPSampleDSOBJECT * ppSampleDSDestObjects
  619.     )
  620. {
  621.  
  622.     DWORD i = 0;
  623.     LPSampleDSOBJECT pSampleDSDestObjects = NULL;
  624.     HRESULT hr = S_OK;
  625.  
  626.     pSampleDSDestObjects = (LPSampleDSOBJECT)AllocProvMem(
  627.                                     dwNumObjects * sizeof(SampleDSOBJECT)
  628.                                     );
  629.  
  630.     if (!pSampleDSDestObjects) {
  631.         RRETURN(E_FAIL);
  632.     }
  633.  
  634.      for (i = 0; i < dwNumObjects; i++ ) {
  635.          hr = VarTypeToSampleDSTypeCopy(
  636.                     dwSampleDSType,
  637.                     pVarSrcObjects + i,
  638.                     pSampleDSDestObjects + i
  639.                     );
  640.          BAIL_ON_FAILURE(hr);
  641.  
  642.      }
  643.  
  644.      *ppSampleDSDestObjects = pSampleDSDestObjects;
  645.  
  646.      RRETURN(S_OK);
  647.  
  648. error:
  649.  
  650.      if (pSampleDSDestObjects) {
  651.  
  652.         SampleDSTypeFreeSampleDSObjects(
  653.                 pSampleDSDestObjects,
  654.                 dwNumObjects
  655.                 );
  656.      }
  657.  
  658.      *ppSampleDSDestObjects = NULL;
  659.  
  660.      RRETURN(hr);
  661. }
  662.  
  663.  
  664.  
  665.