home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1996 February / PCWK0296.iso / po7_win / object10 / ovalue.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1995-03-20  |  9.6 KB  |  501 lines
  1. /* Copyright (c) Oracle Corporation 1994.  All Rights Reserved */
  2.  
  3. /*
  4.     This source code is provided as a debugging aid for developers
  5.     who have purchased Oracle Objects for OLE    .  Please see the
  6.     online help for documentation of these classes.
  7. */
  8.  
  9. /*
  10.     Oracle Objects for OLE     C++ Classes
  11.     
  12.     This file implements the OValue class
  13.     It also implements the internal OOLEvar class
  14.                            
  15.     CREATED    ********   11/22/94
  16.     RWOOLARD    MODIFIED    03/20/95
  17.                 bug#    260396    SetValue() does not allocate for empty string
  18.                         262214    Various GPF's when dealing with NULL pointers
  19. */
  20.  
  21. #include "windows.h"
  22. #include <ole2.h>
  23. #include <olenls.h>       
  24. #include <dispatch.h>  
  25.  
  26. #ifndef ORACL_ORACLE
  27. #include "oracl.h"
  28. #endif
  29.  
  30. #ifndef ORAOBJI_ORACLE
  31. #include "oraobji.h"
  32. #endif
  33.  
  34. #ifndef _OracleInProcServer_H_
  35. #include <oratlb.h>
  36. #endif
  37.  
  38. // ----- OValue -----------------------------------------------
  39.  
  40. OValue::OValue(void)
  41. {
  42.     m_value = new OOLEvar;
  43. }
  44.  
  45. OValue::OValue(const OValue &other)
  46. {
  47.     m_value = new OOLEvar;
  48.     Copy(other);
  49. }
  50.  
  51. OValue::OValue(int intvalue)
  52. {
  53.     m_value = new OOLEvar;
  54.     m_value->SetValue(intvalue);
  55. }
  56.  
  57. OValue::OValue(long longvalue)
  58. {
  59.     m_value = new OOLEvar;
  60.     m_value->SetValue(longvalue);
  61. }
  62.  
  63. OValue::OValue(double doublevalue)
  64. {
  65.     m_value = new OOLEvar;
  66.     m_value->SetValue(doublevalue);
  67. }
  68.  
  69. OValue::OValue(const char *tval)
  70. {
  71.     m_value = new OOLEvar;
  72.     m_value->SetValue(tval);
  73. }
  74.  
  75. OValue::~OValue(void)
  76. {
  77.     Cleanup();
  78.     
  79.     // cleanup doesn't free m_value pointer - so get rid of it
  80.     if (m_value)
  81.     {
  82.         delete m_value;
  83.     }
  84.     
  85. }
  86.  
  87. OValue &OValue::operator=(const OValue &other)
  88. {
  89.     if (&other == this)
  90.         return(*this);
  91.     
  92.     // clear current value
  93.     m_value->Clear();
  94.     
  95.     Copy(other);
  96.     
  97.     return(*this);
  98. }
  99.  
  100. int OValue::operator==(const OValue &other) const
  101. {
  102.     return(m_value->IsEqual(other.m_value));
  103. }
  104.  
  105. int OValue::operator!=(const OValue &other) const
  106. {
  107.     return(!(m_value->IsEqual(other.m_value)));
  108. }
  109.  
  110. oresult OValue::Copy(const OValue &other)
  111. { 
  112.     // we are copying only the other's value
  113.     
  114.     return(FromLocalType((void *) ((other.m_value)->GetVariant())));
  115. }
  116.  
  117. oresult OValue::Cleanup(void)
  118. {
  119.     // clean out the value (but nothing else)
  120.     return(m_value->Clear());
  121. }
  122.  
  123. oresult OValue::Clear(void)
  124. {
  125.     return(m_value->Clear());
  126. }
  127.  
  128. oresult OValue::SetValue(const OValue &val)
  129. {
  130.     // clear current value
  131.     m_value->Clear();
  132.     
  133.     return(Copy(val));
  134. }
  135.  
  136. oresult OValue::SetValue(int val)
  137. {
  138.     OOLEvar var;
  139.     var.SetValue(val);
  140.     
  141.     return(FromLocalType((void *) &var));
  142. }
  143.  
  144. oresult OValue::SetValue(long val)
  145. {   
  146.     OOLEvar var;
  147.     var.SetValue(val);
  148.     
  149.     return(FromLocalType((void *) &var));
  150. }
  151.  
  152. oresult OValue::SetValue(double val)
  153. {   
  154.     OOLEvar var;
  155.     var.SetValue(val);
  156.     
  157.     return(FromLocalType((void *) &var));
  158. }
  159.  
  160. oresult OValue::SetValue(const char *val)
  161. {
  162.     OOLEvar var;
  163.     var.SetValue(val);
  164.     
  165.     return(FromLocalType((void *) &var));
  166. }
  167.  
  168. // copy local representation (VARIANT in Windows case) to OValue
  169. oresult OValue::FromLocalType(void *localv)
  170. {
  171.     if (m_value->SetValue((VARIANT *) localv) != OSUCCESS)
  172.         return(OFAILURE);
  173.  
  174.     return(OSUCCESS);
  175. }
  176.  
  177. oboolean OValue::IsNull(void) const
  178. {
  179.     return(m_value->IsNull());
  180. }
  181.  
  182. OValue::operator long() const
  183. {
  184.     long val;
  185.     m_value->GetValue(&val);
  186.     return(val);
  187. }
  188.  
  189. OValue::operator int() const
  190. {
  191.     int val;
  192.     m_value->GetValue(&val);
  193.     return(val);
  194. }
  195.  
  196. OValue::operator double() const
  197. {
  198.     double val;
  199.     m_value->GetValue(&val);
  200.     return(val);
  201. }
  202.  
  203. OValue::operator const char *() const
  204. {
  205.     const char *val;
  206.     m_value->GetValue(&val);
  207.     return(val);
  208. }
  209.  
  210. void *OValue::Internal(void) const
  211. {
  212.     return((void *) m_value);
  213. }
  214.  
  215. // ----- OOLEvar -----------------------------------------------
  216.  
  217. OOLEvar::OOLEvar(void)
  218. {
  219.     m_pmain = &m_mainv;
  220.     m_pconv = &m_convertedv;
  221.     VariantInit(m_pmain);
  222.     VariantInit(m_pconv);
  223.     m_isconv = FALSE;
  224.  
  225.     // set to database null value
  226.     V_VT(m_pmain) = VT_NULL;
  227. }
  228.  
  229. OOLEvar::~OOLEvar(void)
  230. {
  231.     Clear();
  232. }
  233.  
  234. VARIANT *OOLEvar::GetVariant(void)
  235. {
  236.     return(m_pmain);
  237. }
  238.  
  239. void OOLEvar::HaveSetVariant(void)
  240. {
  241.     m_isconv = FALSE;  // the converted variant is no longer valid
  242.     
  243.     return;
  244. }
  245.  
  246. oresult OOLEvar::Clear(void)
  247. {
  248.     VariantClear(m_pmain);
  249.     VariantClear(m_pconv);
  250.     
  251.     // set to database null value
  252.     V_VT(m_pmain) = VT_NULL;
  253.     
  254.     m_isconv = FALSE;
  255.     
  256.     return(OSUCCESS);
  257. }
  258.  
  259. oboolean OOLEvar::IsNull(void) const
  260. {
  261.     return (V_VT(m_pmain) == VT_NULL || V_VT(m_pmain) == VT_EMPTY);
  262. }
  263.  
  264. oboolean OOLEvar::IsEqual(OOLEvar *other)
  265. { 
  266.     // handle case of NULL
  267.     if (IsNull())
  268.     {
  269.         return(other->IsNull());
  270.     }
  271.     
  272.     switch(V_VT(m_pmain))
  273.     {
  274.     case VT_I2:
  275.         int ii;
  276.         other->GetValue(&ii);
  277.         return(V_I2(m_pmain) == ii);
  278.     case VT_I4:
  279.         long ll;
  280.         other->GetValue(&ll);
  281.         return(V_I4(m_pmain) == ll);
  282.     case VT_R8:
  283.         double dd;
  284.         other->GetValue(&dd);
  285.         return(V_R8(m_pmain) == dd);
  286.     case VT_BSTR:
  287.         const char *cp;
  288.         other->GetValue(&cp);
  289.         return(0 == strcmp(V_BSTR(m_pmain), cp));
  290.     default:
  291.         // huh?
  292.         return(FALSE);
  293.     }
  294.     
  295.     return(FALSE);  // shouldn't get here
  296. }
  297.                      
  298. oresult OOLEvar::SetValue(int val)
  299. {
  300.     VariantClear(m_pmain);
  301.     m_isconv = FALSE;
  302.     V_VT(m_pmain) = VT_I2;
  303.     V_I2(m_pmain) = (short) val;
  304.     return(OSUCCESS);
  305. }
  306.  
  307. oresult OOLEvar::SetValue(long val)
  308. {
  309.     VariantClear(m_pmain);
  310.     m_isconv = FALSE;
  311.     V_VT(m_pmain) = VT_I4;
  312.     V_I4(m_pmain) = val;
  313.     return(OSUCCESS);
  314. }
  315.  
  316. oresult OOLEvar::SetValue(double val)
  317. {
  318.     VariantClear(m_pmain);
  319.     m_isconv = FALSE;
  320.     V_VT(m_pmain) = VT_R8;
  321.     V_R8(m_pmain) = val;
  322.     return(OSUCCESS);
  323. }
  324.  
  325. oresult OOLEvar::SetValue(const char *val)
  326. {
  327.     VariantClear(m_pmain);
  328.     m_isconv = FALSE;
  329.     char *cp;
  330. //BUG #262214 and 260396    
  331.     if (!val)
  332.     {
  333.         cp = SysAllocString("");
  334.         // cp = "";
  335.     }
  336.     else
  337.     {
  338.         cp = SysAllocString(val);
  339.     }
  340.     if (!cp)
  341.     {
  342.         return(OFAILURE);  // out of memory
  343.     }
  344.     
  345.     // set value
  346.     V_VT(m_pmain) = VT_BSTR;
  347.     V_BSTR(m_pmain) = cp;
  348.     return(OSUCCESS);
  349. }
  350.  
  351. oresult OOLEvar::SetValue(VARIANT *val)
  352. {
  353.     HRESULT hr = VariantCopy(m_pmain, val);
  354.     VariantClear(m_pconv);
  355.     m_isconv = FALSE;
  356.     return(FAILED(hr) ? OFAILURE : OSUCCESS);
  357. }
  358.  
  359. oresult OOLEvar::GetValue(int *val)
  360. {
  361.     oresult ores = OSUCCESS;
  362.     
  363.     if (IsNull())
  364.     {
  365.         *val = 0;
  366.         ores = OSUCCESS;
  367.     }
  368.     else if (V_VT(m_pmain) == VT_I2)
  369.         *val = V_I2(m_pmain);
  370.     else if (m_isconv && V_VT(m_pconv) == VT_I2)
  371.         *val = V_I2(m_pconv);
  372.     else
  373.     { // we need to do a conversion
  374.     
  375.         HRESULT hr = VariantChangeType(m_pconv, m_pmain, 0, VT_I2);
  376.         if (FAILED(hr))
  377.         {
  378.             ores = OFAILURE;
  379.             *val = 0;
  380.         }
  381.         else
  382.         { // succesful conversion
  383.             m_isconv = TRUE;
  384.             *val = V_I2(m_pconv);
  385.         }
  386.     }
  387.     
  388.     return(ores);
  389. }
  390.  
  391. oresult OOLEvar::GetValue(long *val)
  392. {
  393.     oresult ores = OSUCCESS;
  394.     
  395.     if (IsNull())
  396.     {
  397.         *val = 0;
  398.         ores = OSUCCESS;
  399.     }
  400.     else if (V_VT(m_pmain) == VT_I4)
  401.         *val = V_I4(m_pmain);
  402.     else if (m_isconv && V_VT(m_pconv) == VT_I4)
  403.         *val = V_I4(m_pconv);
  404.     else if (V_VT(m_pmain) == VT_I2)
  405.         *val = V_I2(m_pmain);
  406.     else if (m_isconv && V_VT(m_pconv) == VT_I2)
  407.         *val = V_I2(m_pconv);
  408.     else
  409.     { // we need to do a conversion
  410.     
  411.         HRESULT hr = VariantChangeType(m_pconv, m_pmain, 0, VT_I4);
  412.         if (FAILED(hr))
  413.         {
  414.             ores = OFAILURE;
  415.             *val = 0;
  416.         }
  417.         else
  418.         { // succesful conversion
  419.             m_isconv = TRUE;
  420.             *val = V_I4(m_pconv);
  421.         }
  422.     }
  423.     
  424.     return(ores);
  425. }
  426.  
  427. oresult OOLEvar::GetValue(double *val)
  428. {
  429.     oresult ores = OSUCCESS;
  430.     
  431.     if (IsNull())
  432.     {
  433.         *val = 0.0;
  434.         ores = OSUCCESS;
  435.     }
  436.     else if (V_VT(m_pmain) == VT_R8)
  437.         *val = V_R8(m_pmain);
  438.     else if (m_isconv && V_VT(m_pconv) == VT_R8)
  439.         *val = V_R8(m_pconv);
  440.     else
  441.     { // we need to do a conversion
  442.     
  443.         HRESULT hr = VariantChangeType(m_pconv, m_pmain, 0, VT_R8);
  444.         if (FAILED(hr))
  445.         {
  446.             ores = OFAILURE;
  447.             *val = 0;
  448.         }
  449.         else
  450.         { // succesful conversion
  451.             m_isconv = TRUE;
  452.             *val = V_R8(m_pconv);
  453.         }
  454.     }
  455.     
  456.     return(ores);
  457. }
  458.  
  459. oresult OOLEvar::GetValue(const char **val)
  460. {
  461.     oresult ores = OSUCCESS;
  462.     
  463.     if (IsNull())
  464.     {
  465.         *val = NULL;
  466.         ores = OSUCCESS;
  467.     }
  468.     else if (V_VT(m_pmain) == VT_BSTR)
  469.         *val = V_BSTR(m_pmain);
  470.     else if (m_isconv && V_VT(m_pconv) == VT_BSTR)
  471.         *val = V_BSTR(m_pconv);
  472.     else
  473.     { // we need to do a conversion
  474.     
  475.         HRESULT hr = VariantChangeType(m_pconv, m_pmain, 0, VT_BSTR);
  476.         if (FAILED(hr))
  477.         {
  478.             ores = OFAILURE;
  479.             *val = NULL;
  480.         }
  481.         else
  482.         { // succesful conversion
  483.             m_isconv = TRUE;
  484.             *val = V_BSTR(m_pconv);
  485.         }
  486.     }
  487.     
  488.     return(ores);
  489. }
  490.  
  491. unsigned int OOLEvar::GetStringLength(void) const
  492. {
  493.     if (V_VT(m_pmain) == VT_BSTR)
  494.         return(SysStringLen(V_BSTR(m_pmain)));
  495.     else if (m_isconv && V_VT(m_pconv) == VT_BSTR)
  496.         return(SysStringLen(V_BSTR(m_pconv)));
  497.     else
  498.         return(0);
  499. }
  500.  
  501.