home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Windows Gam…ming Gurus (2nd Edition) / Disc2.iso / msdn_vcb / samples / vc98 / com / allinone / server / stlcoll_.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1998-04-03  |  10.9 KB  |  597 lines
  1. // Copyright (C) 1992-1998 Microsoft Corporation
  2. // All rights reserved.
  3. //
  4. // This source code is only intended as a supplement to the
  5. // Microsoft Visual C++ Language  Reference and related
  6. // electronic documentation provided with Microsoft Visual C++.
  7. // See these sources for detailed information regarding the
  8. // Microsoft Visual C++ product.
  9.  
  10. #include "stdafx.h"
  11. #include "stlcoll_.h"
  12. #include <algorithm>
  13.  
  14.  
  15. // Maps
  16. STDMETHODIMP CStlMapStringToMyObject::get_Map(BSTR str, IMyStruct** obj)
  17. {
  18.     *obj = static_cast<IMyStruct*> (m_map[str]);
  19.     return S_OK;
  20. }
  21.  
  22. STDMETHODIMP CStlMapStringToMyObject::put_Map(BSTR str, IMyStruct* obj)
  23. {
  24.     m_map[str] = static_cast<CMyObject*> (obj);
  25.     return S_OK;
  26. }
  27.  
  28. STDMETHODIMP CStlMapStringToMyObject::Lookup(BSTR str, IMyStruct** obj, VARIANT_BOOL* b)
  29. {
  30.     m_mapiter = m_map.find(str);
  31.     if (m_mapiter == m_map.end())
  32.         *b = VARIANT_FALSE;
  33.     else
  34.     {
  35.         *b = VARIANT_TRUE;
  36.         *obj = static_cast<IMyStruct*> (m_mapiter->second);
  37.     }
  38.  
  39.     return S_OK;
  40. }
  41.  
  42. STDMETHODIMP CStlMapStringToMyObject::First()
  43. {
  44.     m_mapiter = m_map.begin();
  45.     return S_OK;
  46. }
  47.  
  48. STDMETHODIMP CStlMapStringToMyObject::Next(BSTR* str, IMyStruct** obj, VARIANT_BOOL* b)
  49. {
  50.     if (m_mapiter == m_map.end())
  51.         *b = VARIANT_FALSE;
  52.     else
  53.     {
  54.         *str = m_mapiter->first.AllocSysString();
  55.         *obj = static_cast<IMyStruct*> (m_mapiter->second);
  56.         ++m_mapiter;
  57.         *b = VARIANT_TRUE;
  58.     }
  59.     return S_OK;
  60. }
  61.  
  62. STDMETHODIMP CStlMapStringToMyObject::get_Remove(BSTR* str)
  63. {
  64.     *str = m_mapiter->first.AllocSysString();
  65.     m_map.erase(m_mapiter);
  66.     return S_OK;
  67. }
  68.  
  69. STDMETHODIMP CStlMapStringToMyObject::RemoveAll()
  70. {
  71.     m_map.clear();
  72.     return S_OK;
  73. }
  74.  
  75. STDMETHODIMP CStlMapStringToMyObject::get_Count(UINT* dw)
  76. {
  77.     *dw = m_map.size();
  78.     return S_OK;
  79. }
  80.  
  81.  
  82. STDMETHODIMP CStlMapDWordToMyStruct::get_Map(DWORD dw, IMyStruct** str)
  83. {
  84.     m_mapiter = m_map.find(dw);
  85.     if (m_mapiter == m_map.end())
  86.     {
  87.         *str = NULL;
  88.         m_map.insert(pair<const DWORD, CMyStruct*>(dw, static_cast<CMyStruct*> (*str)));
  89.     }
  90.     else
  91.         *str = m_mapiter->second;
  92.     return S_OK;
  93. }
  94.  
  95. STDMETHODIMP CStlMapDWordToMyStruct::put_Map(DWORD dw, IMyStruct* str)
  96. {
  97.     m_mapiter = m_map.find(dw);
  98.     if (m_mapiter == m_map.end())
  99.         m_map.insert(pair<const DWORD, CMyStruct*>(dw, static_cast<CMyStruct*> (str)));
  100.     else
  101.         m_mapiter->second = static_cast<CMyStruct*> (str);
  102.     return S_OK;
  103. }
  104.  
  105. STDMETHODIMP CStlMapDWordToMyStruct::Lookup(DWORD dw, IMyStruct** str, VARIANT_BOOL* b)
  106. {
  107.     m_mapiter = m_map.find(dw);
  108.     if (m_mapiter == m_map.end())
  109.         *b = VARIANT_FALSE;
  110.     else
  111.     {
  112.         *b = VARIANT_TRUE;
  113.         *str = m_mapiter->second;
  114.     }
  115.  
  116.     return S_OK;
  117. }
  118.  
  119. STDMETHODIMP CStlMapDWordToMyStruct::First()
  120. {
  121.     m_mapiter = m_map.begin();
  122.     return S_OK;
  123. }
  124.  
  125. STDMETHODIMP CStlMapDWordToMyStruct::Next(DWORD* dw, IMyStruct** str, VARIANT_BOOL* b)
  126. {
  127.     if (m_mapiter == m_map.end())
  128.         *b = VARIANT_FALSE;
  129.     else
  130.     {
  131.         *dw = m_mapiter->first;
  132.         *str = m_mapiter->second;
  133.         ++m_mapiter;
  134.         *b = VARIANT_TRUE;
  135.     }
  136.     return S_OK;
  137. }
  138.  
  139. STDMETHODIMP CStlMapDWordToMyStruct::get_Remove(DWORD* dw)
  140. {
  141.     *dw = m_mapiter->first;
  142.     m_map.erase(m_mapiter);
  143.     return S_OK;
  144. }
  145.  
  146. STDMETHODIMP CStlMapDWordToMyStruct::RemoveAll()
  147. {
  148.     m_map.clear();
  149.     return S_OK;
  150. }
  151.  
  152. STDMETHODIMP CStlMapDWordToMyStruct::get_Count(UINT* dw)
  153. {
  154.     *dw = m_map.size();
  155.     return S_OK;
  156. }
  157.  
  158.  
  159. STDMETHODIMP CStlMapStringToString::get_Map(BSTR str1, BSTR* str2)
  160. {
  161.     *str2 = m_map[str1].AllocSysString();
  162.     return S_OK;
  163. }
  164.  
  165. STDMETHODIMP CStlMapStringToString::put_Map(BSTR str1, BSTR str2)
  166. {
  167.     m_map[str1] = str2;
  168.     return S_OK;
  169. }
  170.  
  171. STDMETHODIMP CStlMapStringToString::Lookup(BSTR str1, BSTR* str2, VARIANT_BOOL* b)
  172. {
  173.     m_mapiter = m_map.find(str1);
  174.     if (m_mapiter == m_map.end())
  175.         *b = VARIANT_FALSE;
  176.     else
  177.     {
  178.         *b = VARIANT_TRUE;
  179.         *str2 = m_mapiter->second.AllocSysString();
  180.     }
  181.  
  182.     return S_OK;
  183. }
  184.  
  185. STDMETHODIMP CStlMapStringToString::First()
  186. {
  187.     m_mapiter = m_map.begin();
  188.     return S_OK;
  189. }
  190.  
  191. STDMETHODIMP CStlMapStringToString::Next(BSTR* str1, BSTR* str2, VARIANT_BOOL* b)
  192. {
  193.     if (m_mapiter == m_map.end())
  194.         *b = VARIANT_FALSE;
  195.     else
  196.     {
  197.         *str1 = m_mapiter->first.AllocSysString();
  198.         *str2 = m_mapiter->second.AllocSysString();
  199.         ++m_mapiter;
  200.         *b = VARIANT_TRUE;
  201.     }
  202.     return S_OK;
  203. }
  204.  
  205. STDMETHODIMP CStlMapStringToString::get_Remove(BSTR* str)
  206. {
  207.     *str = m_mapiter->first.AllocSysString();
  208.     m_map.erase(m_mapiter);
  209.     return S_OK;
  210. }
  211.  
  212. STDMETHODIMP CStlMapStringToString::RemoveAll()
  213. {
  214.     m_map.clear();
  215.     return S_OK;
  216. }
  217.  
  218. STDMETHODIMP CStlMapStringToString::get_Count(UINT* dw)
  219. {
  220.     *dw = m_map.size();
  221.     return S_OK;
  222. }
  223.  
  224.  
  225. // Lists
  226. STDMETHODIMP CStlStringList::Find(BSTR str, VARIANT_BOOL* b)
  227. {
  228.     m_listiter = find(m_list.begin(), m_list.end(), str);
  229.     if (m_listiter == m_list.end())
  230.         *b = VARIANT_FALSE;
  231.     else
  232.         *b = VARIANT_TRUE;
  233.     return S_OK;
  234. }
  235.  
  236. STDMETHODIMP CStlStringList::put_SetAt(BSTR str)
  237. {
  238.     *m_listiter = str;
  239.     return S_OK;
  240. }
  241.  
  242. STDMETHODIMP CStlStringList::put_Add(BSTR str)
  243. {
  244.     m_list.push_back(str);
  245.     return S_OK;
  246. }
  247.  
  248. STDMETHODIMP CStlStringList::put_InsertBefore(BSTR str)
  249. {
  250.     m_list.insert(m_listiter, str);
  251.     return S_OK;
  252. }
  253.  
  254. STDMETHODIMP CStlStringList::get_Remove(BSTR* str)
  255. {
  256.     *str = m_listiter->AllocSysString();
  257.     m_list.erase(m_listiter);
  258.     return S_OK;
  259. }
  260.  
  261. STDMETHODIMP CStlStringList::RemoveAll()
  262. {
  263.     m_list.clear();
  264.     return S_OK;
  265. }
  266.  
  267. STDMETHODIMP CStlStringList::First()
  268. {
  269.     m_listiter = m_list.begin();
  270.     return S_OK;
  271. }
  272.  
  273. STDMETHODIMP CStlStringList::Next(BSTR* str, VARIANT_BOOL* b)
  274. {
  275.     if (m_listiter == m_list.end())
  276.         *b = VARIANT_FALSE;
  277.     else
  278.     {
  279.         *str = m_listiter->AllocSysString();
  280.         ++m_listiter;
  281.         *b = VARIANT_TRUE;
  282.     }
  283.     return S_OK;
  284. }
  285.  
  286. STDMETHODIMP CStlStringList::get_Count(UINT* dw)
  287. {
  288.     *dw = m_list.size();
  289.     return S_OK;
  290. }
  291.  
  292.  
  293. STDMETHODIMP CStlLists::Find(IMyStruct* str, VARIANT_BOOL* b)
  294. {
  295.     m_listiter = find(m_list.begin(), m_list.end(), str);
  296.     if (m_listiter == m_list.end())
  297.         *b = VARIANT_FALSE;
  298.     else
  299.         *b = VARIANT_TRUE;
  300.     return S_OK;
  301. }
  302.  
  303. STDMETHODIMP CStlLists::put_SetAt(IMyStruct* str)
  304. {
  305.     *m_listiter = static_cast<CMyStruct*> (str);
  306.     return S_OK;
  307. }
  308.  
  309. STDMETHODIMP CStlLists::put_Add(IMyStruct* str)
  310. {
  311.     m_list.push_back(static_cast<CMyStruct*> (str));
  312.     return S_OK;
  313. }
  314.  
  315. STDMETHODIMP CStlLists::put_InsertBefore(IMyStruct* str)
  316. {
  317.     m_list.insert(m_listiter, static_cast<CMyStruct*> (str));
  318.     return S_OK;
  319. }
  320.  
  321. STDMETHODIMP CStlLists::get_Remove(IMyStruct** str)
  322. {
  323.     *str = *m_listiter;
  324.     m_list.erase(m_listiter);
  325.     return S_OK;
  326. }
  327.  
  328. STDMETHODIMP CStlLists::RemoveAll()
  329. {
  330.     m_list.clear();
  331.     return S_OK;
  332. }
  333.  
  334. STDMETHODIMP CStlLists::First()
  335. {
  336.     m_listiter = m_list.begin();
  337.     return S_OK;
  338. }
  339.  
  340. STDMETHODIMP CStlLists::Next(IMyStruct** str, VARIANT_BOOL* b)
  341. {
  342.     if (m_listiter == m_list.end())
  343.         *b = VARIANT_FALSE;
  344.     else
  345.     {
  346.         *str = *m_listiter;
  347.         ++m_listiter;
  348.         *b = VARIANT_TRUE;
  349.     }
  350.     return S_OK;
  351. }
  352.  
  353. STDMETHODIMP CStlLists::get_Count(UINT* dw)
  354. {
  355.     *dw = m_list.size();
  356.     return S_OK;
  357. }
  358.  
  359.  
  360. STDMETHODIMP CStlintList::Find(long n, VARIANT_BOOL* b)
  361. {
  362.     m_listiter = find(m_list.begin(), m_list.end(), n);
  363.     if (m_listiter == m_list.end())
  364.         *b = VARIANT_FALSE;
  365.     else
  366.         *b = VARIANT_TRUE;
  367.     return S_OK;
  368. }
  369.  
  370. STDMETHODIMP CStlintList::put_SetAt(long n)
  371. {
  372.     *m_listiter = n;
  373.     return S_OK;
  374. }
  375.  
  376. STDMETHODIMP CStlintList::put_Add(long n)
  377. {
  378.     m_list.push_back(n);
  379.     return S_OK;
  380. }
  381.  
  382. STDMETHODIMP CStlintList::put_InsertBefore(long n)
  383. {
  384.     m_list.insert(m_listiter, n);
  385.     return S_OK;
  386. }
  387.  
  388. STDMETHODIMP CStlintList::get_Remove(long* n)
  389. {
  390.     *n = *m_listiter;
  391.     m_list.erase(m_listiter);
  392.     return S_OK;
  393. }
  394.  
  395. STDMETHODIMP CStlintList::RemoveAll()
  396. {
  397.     m_list.clear();
  398.     return S_OK;
  399. }
  400.  
  401. STDMETHODIMP CStlintList::First()
  402. {
  403.     m_listiter = m_list.begin();
  404.     return S_OK;
  405. }
  406.  
  407. STDMETHODIMP CStlintList::Next(long* n, VARIANT_BOOL* b)
  408. {
  409.     if (m_listiter == m_list.end())
  410.         *b = VARIANT_FALSE;
  411.     else
  412.     {
  413.         *n = *m_listiter;
  414.         ++m_listiter;
  415.         *b = VARIANT_TRUE;
  416.     }
  417.     return S_OK;
  418. }
  419.  
  420. STDMETHODIMP CStlintList::get_Count(UINT* dw)
  421. {
  422.     *dw = m_list.size();
  423.     return S_OK;
  424. }
  425.  
  426.  
  427. // Arrays
  428. STDMETHODIMP CStlDWordArray::get_Array(long idx, DWORD* dw)
  429. {
  430.     *dw = m_array[idx];
  431.     return S_OK;
  432. }
  433.  
  434. STDMETHODIMP CStlDWordArray::put_Array(long idx, DWORD dw)
  435. {
  436.     m_array[idx] = dw;
  437.     return S_OK;
  438. }
  439.  
  440. STDMETHODIMP CStlDWordArray::put_Add(DWORD dw)
  441. {
  442.     m_array.push_back(dw);
  443.     return S_OK;
  444. }
  445.  
  446. STDMETHODIMP CStlDWordArray::get_Remove(long idx, DWORD* dw)
  447. {
  448.     *dw = *(m_array.begin() + idx);
  449.     m_array.erase(m_array.begin() + idx);
  450.     return S_OK;
  451. }
  452.  
  453. STDMETHODIMP CStlDWordArray::RemoveAll()
  454. {
  455.     m_array.clear();
  456.     return S_OK;
  457. }
  458.  
  459. STDMETHODIMP CStlDWordArray::First()
  460. {
  461.     m_arrayiter = m_array.begin();
  462.     return S_OK;
  463. }
  464.  
  465. STDMETHODIMP CStlDWordArray::Next(DWORD* dw, VARIANT_BOOL* b)
  466. {
  467.     if (m_arrayiter == m_array.end())
  468.         *b = VARIANT_FALSE;
  469.     else
  470.     {
  471.         *dw = *m_arrayiter;
  472.         ++m_arrayiter;
  473.         *b = VARIANT_TRUE;
  474.     }
  475.     return S_OK;
  476. }
  477.  
  478. STDMETHODIMP CStlDWordArray::get_Count(UINT* dw)
  479. {
  480.     *dw = m_array.size();
  481.     return S_OK;
  482. }
  483.  
  484.  
  485. STDMETHODIMP CStlMyObjectArray::get_Array(long idx, IMyStruct** str)
  486. {
  487.     *str = static_cast<IMyStruct*> (m_array[idx]);
  488.     return S_OK;
  489. }
  490.  
  491. STDMETHODIMP CStlMyObjectArray::put_Array(long idx, IMyStruct* str)
  492. {
  493.     m_array[idx] = static_cast<CMyObject*> (str);
  494.     return S_OK;
  495. }
  496.  
  497. STDMETHODIMP CStlMyObjectArray::put_Add(IMyStruct* str)
  498. {
  499.     m_array.push_back(static_cast<CMyObject*> (str));
  500.     return S_OK;
  501. }
  502.  
  503. STDMETHODIMP CStlMyObjectArray::get_Remove(long idx, IMyStruct** str)
  504. {
  505.     *str = static_cast<IMyStruct*> (*(m_array.begin() + idx));
  506.     m_array.erase(m_array.begin() + idx);
  507.     return S_OK;
  508. }
  509.  
  510. STDMETHODIMP CStlMyObjectArray::RemoveAll()
  511. {
  512.     m_array.clear();
  513.     return S_OK;
  514. }
  515.  
  516. STDMETHODIMP CStlMyObjectArray::First()
  517. {
  518.     m_arrayiter = m_array.begin();
  519.     return S_OK;
  520. }
  521.  
  522. STDMETHODIMP CStlMyObjectArray::Next(IMyStruct** str, VARIANT_BOOL* b)
  523. {
  524.     if (m_arrayiter == m_array.end())
  525.         *b = VARIANT_FALSE;
  526.     else
  527.     {
  528.         *str = *m_arrayiter;
  529.         ++m_arrayiter;
  530.         *b = VARIANT_TRUE;
  531.     }
  532.     return S_OK;
  533. }
  534.  
  535. STDMETHODIMP CStlMyObjectArray::get_Count(UINT* dw)
  536. {
  537.     *dw = m_array.size();
  538.     return S_OK;
  539. }
  540.  
  541.  
  542. STDMETHODIMP CStlPointArray::get_Array(long idx, POINT* pt)
  543. {
  544.     *pt = m_array[idx];
  545.     return S_OK;
  546. }
  547.  
  548. STDMETHODIMP CStlPointArray::put_Array(long idx, POINT pt)
  549. {
  550.     m_array[idx] = pt;
  551.     return S_OK;
  552. }
  553.  
  554. STDMETHODIMP CStlPointArray::put_Add(POINT pt)
  555. {
  556.     m_array.push_back(pt);
  557.     return S_OK;
  558. }
  559.  
  560. STDMETHODIMP CStlPointArray::get_Remove(long idx, POINT* pt)
  561. {
  562.     *pt = *(m_array.begin() + idx);
  563.     m_array.erase(m_array.begin() + idx);
  564.     return S_OK;
  565. }
  566.  
  567. STDMETHODIMP CStlPointArray::RemoveAll()
  568. {
  569.     m_array.clear();
  570.     return S_OK;
  571. }
  572.  
  573. STDMETHODIMP CStlPointArray::First()
  574. {
  575.     m_arrayiter = m_array.begin();
  576.     return S_OK;
  577. }
  578.  
  579. STDMETHODIMP CStlPointArray::Next(POINT* pt, VARIANT_BOOL* b)
  580. {
  581.     if (m_arrayiter == m_array.end())
  582.         *b = VARIANT_FALSE;
  583.     else
  584.     {
  585.         *pt = *m_arrayiter;
  586.         ++m_arrayiter;
  587.         *b = VARIANT_TRUE;
  588.     }
  589.     return S_OK;
  590. }
  591.  
  592. STDMETHODIMP CStlPointArray::get_Count(UINT* dw)
  593. {
  594.     *dw = m_array.size();
  595.     return S_OK;
  596. }
  597.