home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1998 May / Pcwk5b98.iso / Borland / Cplus45 / BC45 / OCFSRC.PAK / AUTOVAL.CPP < prev    next >
C/C++ Source or Header  |  1995-08-29  |  19KB  |  463 lines
  1. //
  2. //----------------------------------------------------------------------------
  3. // ObjectComponents
  4. // (C) Copyright 1994 by Borland International, All Rights Reserved
  5. //
  6. // TAutoVal implementation
  7. //----------------------------------------------------------------------------
  8. #include <ocf/ocfpch.h>
  9. #include <ocf/autodefs.h>
  10.  
  11. //____________________________________________________________________________
  12. //
  13. // TAutoVal assignment operators (others are inline)
  14. //____________________________________________________________________________
  15.  
  16. void TAutoVal::operator =(TAutoString s)
  17. {
  18.   vt = atString;
  19.   bstrVal = ::SysAllocString((const OLECHAR far*)s);
  20.   SetLocale(s.GetLangId() ? s.GetLangId() : TLocaleString::NativeLangId);
  21. }
  22.  
  23. void TAutoVal::operator =(const string& s)
  24. {
  25.   vt = atString;
  26.   bstrVal = ::SysAllocString(s.c_str());
  27.   SetLocale(TLocaleString::NativeLangId);
  28. }
  29.  
  30. //
  31. // should add operator==(TLocaleString) which translates to proper LangId
  32. // this requires Set/GetLocale to be used for atVoid initialized variants
  33. //
  34.  
  35. //____________________________________________________________________________
  36. //
  37. // TAutoVal conversion operators
  38. //____________________________________________________________________________
  39.  
  40. void TAutoVal::SetLocale(TLocaleId locale)
  41. {
  42.   switch (vt) {
  43.   case atVoid:
  44.   case atString:
  45.   case atObject:
  46.     p.Locale = locale;
  47.   };
  48. }
  49.  
  50. TLocaleId TAutoVal::GetLocale() const
  51. {
  52.   switch (vt) {
  53.   case atVoid:
  54.   case atString:
  55.   case atObject:
  56.     return p.Locale;
  57.   };
  58.   return 0;
  59. }
  60.  
  61. TLangId TAutoVal::GetLanguage() const
  62. {
  63.   switch (vt) {
  64.   case atVoid:
  65.   case atString:
  66.   case atObject:
  67.     return LANGIDFROMLCID(p.Locale);
  68.   };
  69.   return 0;
  70. }
  71.  
  72. TAutoVal::operator unsigned char()
  73. {
  74.   unsigned char v;
  75.   switch(vt) {
  76.   case atByte:    return bVal;
  77.   case atShort:   if(::VarUI1FromI2(iVal,  &v)) break; return v;
  78.   case atLong:    if(::VarUI1FromI4(lVal,  &v)) break; return v;
  79.   case atFloat:   if(::VarUI1FromR4(fltVal,&v)) break; return v;
  80.   case atDouble:  if(::VarUI1FromR8(dblVal,&v)) break; return v;
  81.   case atCurrency:if(::VarUI1FromCy(cyVal, &v)) break; return v;
  82.   case atDatetime:if(::VarUI1FromDate(date,&v)) break; return v;
  83.   case atString:  if(::VarUI1FromStr(bstrVal,GetLocale(),0L,&v)) break; return v;
  84.   case atObject:  if(::VarUI1FromDisp(pdispVal,GetLocale(),&v)) break; return v;
  85.   case atBool:    return (unsigned char)(boolVal ? 1 : 0);
  86.   case atByRef+atByte:    return *pbVal;
  87.   case atByRef+atShort:   if(::VarUI1FromI2(*piVal,  &v)) break; return v;
  88.   case atByRef+atLong:    if(::VarUI1FromI4(*plVal,  &v)) break; return v;
  89.   case atByRef+atFloat:   if(::VarUI1FromR4(*pfltVal,&v)) break; return v;
  90.   case atByRef+atDouble:  if(::VarUI1FromR8(*pdblVal,&v)) break; return v;
  91.   case atByRef+atCurrency:if(::VarUI1FromCy(*pcyVal, &v)) break; return v;
  92.   case atByRef+atDatetime:if(::VarUI1FromDate(*pdate,&v)) break; return v;
  93.   case atByRef+atString:  if(::VarUI1FromStr(*pbstrVal,GetLocale(),0L,&v)) break; return v;
  94.   case atByRef+atBool:    return (unsigned char)(*pbool ? 1 : 0);
  95.   }
  96.   throw TXAuto(TXAuto::xConversionFailure);
  97. }
  98.  
  99. TAutoVal::operator short()
  100. {
  101.   short v;
  102.   switch(vt) {
  103.   case atByte:    return (short)bVal;
  104.   case atShort:   return iVal;
  105.   case atLong:    if (lVal>0x7FFFL || lVal <0xFFFF8000L) break; return (short)lVal;
  106.   case atFloat:   if(::VarI2FromR4(fltVal,&v)) break; return v;
  107.   case atDouble:  if(::VarI2FromR8(dblVal,&v)) break; return v;
  108.   case atCurrency:if(::VarI2FromCy(cyVal, &v)) break; return v;
  109.   case atDatetime:if(::VarI2FromDate(date,&v)) break; return v;
  110.   case atString:  if(::VarI2FromStr(bstrVal,GetLocale(),0L,&v)) break; return v;
  111.   case atObject:  if(::VarI2FromDisp(pdispVal,GetLocale(),&v)) break; return v;
  112.   case atBool:    return short(boolVal ? 1 : 0);
  113.   case atByRef+atByte:    return (short)*pbVal;
  114.   case atByRef+atShort:   return *piVal;
  115.   case atByRef+atLong:    if (*plVal>0x7FFFL || *plVal <0xFFFF8000L) break; return (short)*plVal;
  116.   case atByRef+atFloat:   if(::VarI2FromR4(*pfltVal,&v)) break; return v;
  117.   case atByRef+atDouble:  if(::VarI2FromR8(*pdblVal,&v)) break; return v;
  118.   case atByRef+atCurrency:if(::VarI2FromCy(*pcyVal, &v)) break; return v;
  119.   case atByRef+atDatetime:if(::VarI2FromDate(*pdate,&v)) break; return v;
  120.   case atByRef+atString:  if(::VarI2FromStr(*pbstrVal,GetLocale(),0L,&v)) break; return v;
  121.   case atByRef+atBool:    return short(*pbool ? 1 : 0);
  122.   }
  123.   throw TXAuto(TXAuto::xConversionFailure);
  124. }
  125.  
  126. TAutoVal::operator long()
  127. {
  128.   long v;
  129.   switch(vt) {
  130.   case atByte:    return (long)bVal;
  131.   case atShort:   return (long)iVal;
  132.   case atLong:    return lVal;
  133.   case atFloat:   if(::VarI4FromR4(fltVal,&v)) break; return v;
  134.   case atDouble:  if(::VarI4FromR8(dblVal,&v)) break; return v;
  135.   case atCurrency:if(::VarI4FromCy(cyVal, &v)) break; return v;
  136.   case atDatetime:if(::VarI4FromDate(date,&v)) break; return v;
  137.   case atString:  if(::VarI4FromStr(bstrVal,GetLocale(),0L,&v)) break; return v;
  138.   case atObject:  if(::VarI4FromDisp(pdispVal,GetLocale(),&v)) break; return v;
  139.   case atBool:    return boolVal ? 1L : 0L;
  140.   case atByRef+atByte:    return (long)*pbVal;
  141.   case atByRef+atShort:   return (long)*piVal;
  142.   case atByRef+atLong:    return *plVal;
  143.   case atByRef+atFloat:   if(::VarI4FromR4(*pfltVal,&v)) break; return v;
  144.   case atByRef+atDouble:  if(::VarI4FromR8(*pdblVal,&v)) break; return v;
  145.   case atByRef+atCurrency:if(::VarI4FromCy(*pcyVal, &v)) break; return v;
  146.   case atByRef+atDatetime:if(::VarI4FromDate(*pdate,&v)) break; return v;
  147.   case atByRef+atString:  if(::VarI4FromStr(*pbstrVal,GetLocale(),0L,&v)) break; return v;
  148.   case atByRef+atBool:    return *pbool ? 1L : 0L;
  149.   }
  150.   throw TXAuto(TXAuto::xConversionFailure);
  151. }
  152.  
  153. TAutoVal::operator TBool()
  154. {
  155.   switch(vt) {
  156.   case atByte:    return static_cast<TBool>(bVal != 0);
  157.   case atShort:   return static_cast<TBool>(iVal != 0);
  158.   case atLong:    return static_cast<TBool>(lVal != 0);
  159.   case atFloat:   return static_cast<TBool>(fltVal != 0);
  160.   case atDouble:  return static_cast<TBool>(dblVal != 0);
  161.   case atCurrency:return static_cast<TBool>(cyVal.Lo!=0 || cyVal.Hi != 0);
  162.   case atDatetime:return static_cast<TBool>(date != 0);
  163.   case atString:  {short v; if(::VarBoolFromStr(bstrVal,GetLocale(),0L,&v)) break; return static_cast<TBool>(v!=0);}
  164.   case atObject:  {short v; if(::VarBoolFromDisp(pdispVal,GetLocale(),&v)) break; return static_cast<TBool>(v!=0);}
  165.   case atBool:    return static_cast<TBool>(boolVal != 0);  // note: VARIANT bool TRUE is -1
  166.   case atByRef+atByte:    return static_cast<TBool>(*pbVal != 0);
  167.   case atByRef+atShort:   return static_cast<TBool>(*piVal != 0);
  168.   case atByRef+atLong:    return static_cast<TBool>(*plVal != 0);
  169.   case atByRef+atFloat:   return static_cast<TBool>(*pfltVal != 0);
  170.   case atByRef+atDouble:  return static_cast<TBool>(*pdblVal != 0);
  171.   case atByRef+atCurrency:return static_cast<TBool>(pcyVal->Lo != 0 || pcyVal->Hi != 0);
  172.   case atByRef+atDatetime:return static_cast<TBool>(*pdate != 0);
  173.   case atByRef+atString:  {short v; if(::VarBoolFromStr(*pbstrVal,GetLocale(),0L,&v)) break; return static_cast<TBool>(v!=0);}
  174.   case atByRef+atBool:    return static_cast<TBool>(*pbool != 0);
  175.   }
  176.   throw TXAuto(TXAuto::xConversionFailure);
  177. }
  178.  
  179. TAutoVal::operator float()
  180. {
  181.   float v;
  182.   switch(vt) {
  183.   case atByte:     if(::VarR4FromUI1(bVal,&v)) break; return v;
  184.   case atShort:    if(::VarR4FromI2(iVal, &v)) break; return v;
  185.   case atLong:     if(::VarR4FromI4(lVal, &v)) break; return v;
  186.   case atFloat:    return fltVal;
  187.   case atDouble:   if(::VarR4FromR8(dblVal,&v)) break; return v;
  188.   case atCurrency: if(::VarR4FromCy(cyVal, &v)) break; return v;
  189.   case atDatetime: if(::VarR4FromDate(date,&v)) break; return v;
  190.   case atString:   if(::VarR4FromStr(bstrVal,GetLocale(),0L,&v)) break; return v;
  191.   case atObject:   if(::VarR4FromDisp(pdispVal,GetLocale(),&v)) break; return v;
  192.   case atBool:     if(::VarR4FromBool(boolVal,&v)) break; return v;
  193.   case atByRef+atByte:    if(::VarR4FromUI1(*pbVal,&v)) break; return v;
  194.   case atByRef+atShort:   if(::VarR4FromI2(*piVal, &v)) break; return v;
  195.   case atByRef+atLong:    if(::VarR4FromI4(*plVal, &v)) break; return v;
  196.   case atByRef+atFloat:   return *pfltVal;
  197.   case atByRef+atDouble:  if(::VarR4FromR8(*pdblVal,&v)) break; return v;
  198.   case atByRef+atCurrency:if(::VarR4FromCy(*pcyVal, &v)) break; return v;
  199.   case atByRef+atDatetime:if(::VarR4FromDate(*pdate,&v)) break; return v;
  200.   case atByRef+atString:  if(::VarR4FromStr(*pbstrVal,GetLocale(),0L,&v)) break; return v;
  201.   case atByRef+atBool:    if(::VarR4FromBool(*pbool,&v)) break; return v;
  202.   }
  203.   throw TXAuto(TXAuto::xConversionFailure);
  204. }
  205.  
  206. TAutoVal::operator double()
  207. {
  208.   double v;
  209.   switch(vt) {
  210.   case atByte:    if(::VarR8FromUI1(bVal,&v)) break; return v;
  211.   case atShort:   if(::VarR8FromI2(iVal, &v)) break; return v;
  212.   case atLong:    if(::VarR8FromI4(lVal, &v)) break; return v;
  213.   case atFloat:   if(::VarR8FromR4(fltVal,&v)) break; return v;
  214.   case atDouble:  return dblVal;
  215.   case atCurrency:if(::VarR8FromCy(cyVal, &v)) break; return v;
  216.   case atDatetime:if(::VarR8FromDate(date,&v)) break; return v;
  217.   case atString:  if(::VarR8FromStr(bstrVal,GetLocale(),0L,&v)) break; return v;
  218.   case atObject:  if(::VarR8FromDisp(pdispVal,GetLocale(),&v)) break; return v;
  219.   case atBool:    if(::VarR8FromBool(boolVal,&v)) break; return v;
  220.   case atByRef+atByte:    if(::VarR8FromUI1(*pbVal,&v)) break; return v;
  221.   case atByRef+atShort:   if(::VarR8FromI2(*piVal, &v)) break; return v;
  222.   case atByRef+atLong:    if(::VarR8FromI4(*plVal, &v)) break; return v;
  223.   case atByRef+atFloat:   if(::VarR8FromR4(*pfltVal,&v)) break; return v;
  224.   case atByRef+atDouble:  return *pdblVal;
  225.   case atByRef+atCurrency:if(::VarR8FromCy(*pcyVal, &v)) break; return v;
  226.   case atByRef+atDatetime:if(::VarR8FromDate(*pdate,&v)) break; return v;
  227.   case atByRef+atString:  if(::VarR8FromStr(*pbstrVal,GetLocale(),0L,&v)) break; return v;
  228.   case atByRef+atBool:    if(::VarR8FromBool(*pbool,&v)) break; return v;
  229.   }
  230.   throw TXAuto(TXAuto::xConversionFailure);
  231. }
  232.  
  233. TAutoVal::operator TAutoDate()
  234. {
  235.   DATE v;
  236.   switch(vt) {
  237.   case atByte:     if(::VarDateFromUI1(bVal,&v)) break; return v;
  238.   case atShort:    if(::VarDateFromI2(iVal, &v)) break; return v;
  239.   case atLong:     if(::VarDateFromI4(lVal, &v)) break; return v;
  240.   case atFloat:    if(::VarDateFromR4(fltVal,&v)) break; return v;
  241.   case atDouble:   if(::VarDateFromR8(dblVal,&v)) break; return v;
  242.   case atDatetime: return date;
  243.   case atString:   if(::VarDateFromStr(bstrVal,GetLocale(),0L,&v)) break; return v;
  244.   case atObject:   if(::VarDateFromDisp(pdispVal,GetLocale(),&v)) break; return v;
  245.   case atBool:     if(::VarDateFromBool(boolVal,&v)) break; return v;
  246.   case atByRef+atByte:    if(::VarDateFromUI1(*pbVal,&v)) break; return v;
  247.   case atByRef+atShort:   if(::VarDateFromI2(*piVal, &v)) break; return v;
  248.   case atByRef+atLong:    if(::VarDateFromI4(*plVal, &v)) break; return v;
  249.   case atByRef+atFloat:   if(::VarDateFromR4(*pfltVal,&v)) break; return v;
  250.   case atByRef+atDouble:  if(::VarDateFromR8(*pdblVal,&v)) break; return v;
  251.   case atByRef+atDatetime:return date;
  252.   case atByRef+atString:  if(::VarDateFromStr(*pbstrVal,GetLocale(),0L,&v)) break; return v;
  253.   case atByRef+atBool:    if(::VarDateFromBool(*pbool,&v)) break; return v;
  254.   }
  255.   throw TXAuto(TXAuto::xConversionFailure);
  256. }
  257.  
  258. TAutoVal::operator TAutoCurrency()
  259. {
  260.   TAutoCurrency v;
  261.   HRESULT stat = HR_NOERROR;
  262.   switch(vt) {
  263.   case atByte:     stat = ::VarCyFromUI1(bVal, &v); break;
  264.   case atShort:    stat = ::VarCyFromI2(iVal,  &v); break;
  265.   case atLong:     stat = ::VarCyFromI4(lVal,  &v); break;
  266.   case atFloat:    stat = ::VarCyFromR4(fltVal,&v); break;
  267.   case atDouble:   stat = ::VarCyFromR8(dblVal,&v); break;
  268.   case atCurrency: break;
  269.   case atString:   stat = ::VarCyFromStr(bstrVal,GetLocale(),0L,&v); break;
  270.   case atObject:   stat = ::VarCyFromDisp(pdispVal,GetLocale(),&v); break;
  271.   case atBool:     stat = ::VarCyFromBool(boolVal,&v); break;
  272.   case atByRef+atByte:    stat = ::VarCyFromUI1(*pbVal, &v); break;
  273.   case atByRef+atShort:   stat = ::VarCyFromI2(*piVal,  &v); break;
  274.   case atByRef+atLong:    stat = ::VarCyFromI4(*plVal,  &v); break;
  275.   case atByRef+atFloat:   stat = ::VarCyFromR4(*pfltVal,&v); break;
  276.   case atByRef+atDouble:  stat = ::VarCyFromR8(*pdblVal,&v); break;
  277.   case atByRef+atCurrency:break;
  278.   case atByRef+atString:  stat = ::VarCyFromStr(*pbstrVal,GetLocale(),0L,&v); break;
  279.   case atByRef+atBool:    stat = ::VarCyFromBool(*pbool,&v); break;
  280.   default:         stat = (HRESULT)-1;
  281.   }
  282.   if (stat != HR_NOERROR)
  283.     throw TXAuto(TXAuto::xConversionFailure);
  284.   return v;
  285. }
  286.  
  287. //
  288. // Convert TAutoVal to TUString, used by TAutoString contructor and assignment
  289. //
  290. TAutoVal::operator TUString*()
  291. {
  292.   BSTR v;
  293.   HRESULT stat;
  294. #if defined(BI_PLAT_WIN32)
  295.   LCID lcid = MAKELCID(LangUserDefault, SORT_DEFAULT);
  296. #else
  297.   LCID lcid = MAKELCID(LangUserDefault);
  298. #endif
  299.  
  300.   switch (vt) {
  301.   case atByte:     stat = ::VarBstrFromUI1(bVal, lcid,0, &v); break;
  302.   case atShort:    stat = ::VarBstrFromI2(iVal,  lcid,0, &v); break;
  303.   case atLong:     stat = ::VarBstrFromI4(lVal,  lcid,0, &v); break;
  304.   case atFloat:    stat = ::VarBstrFromR4(fltVal,lcid,0, &v); break;
  305.   case atDouble:   stat = ::VarBstrFromR8(dblVal,lcid,0, &v); break;
  306.   case atCurrency: stat = ::VarBstrFromCy(cyVal ,lcid,0, &v); break;
  307.   case atDatetime: stat = ::VarBstrFromDate(date,lcid,0, &v); break;
  308.   case atString:   if (bstrVal) vt = atLoanedBSTR;
  309.              return (s.Holder=TUString::Create(bstrVal, true, GetLanguage()));
  310.   case atObject:   stat = ::VarBstrFromDisp(pdispVal,GetLocale(),0, &v); break;
  311.   case atBool:     stat = ::VarBstrFromBool(boolVal,lcid,0, &v); break;
  312.   case atByRef+atByte:     stat = ::VarBstrFromUI1(*pbVal, lcid,0, &v); break;
  313.   case atByRef+atShort:    stat = ::VarBstrFromI2(*piVal,  lcid,0, &v); break;
  314.   case atByRef+atLong:     stat = ::VarBstrFromI4(*plVal,  lcid,0, &v); break;
  315.   case atByRef+atFloat:    stat = ::VarBstrFromR4(*pfltVal,lcid,0, &v); break;
  316.   case atByRef+atDouble:   stat = ::VarBstrFromR8(*pdblVal,lcid,0, &v); break;
  317.   case atByRef+atCurrency: stat = ::VarBstrFromCy(*pcyVal ,lcid,0, &v); break;
  318.   case atByRef+atDatetime: stat = ::VarBstrFromDate(*pdate,lcid,0, &v); break;
  319.   case atByRef+atString:   if (*pbstrVal) vt = atByRef+atLoanedBSTR;
  320.            return (s.Holder=TUString::Create(*pbstrVal, true, GetLanguage()));
  321.   case atByRef+atBool:     stat = ::VarBstrFromBool(*pbool,lcid,0,&v);break;
  322.   default:         stat = (HRESULT)-1;
  323.   }
  324.   if (stat != HR_NOERROR)
  325.     throw TXAuto(TXAuto::xConversionFailure);
  326.   return TUString::Create(v, false, LANGIDFROMLCID(lcid));
  327. }
  328.  
  329. //
  330. // Convert TAutoVal to string, high performance if already of string type
  331. //
  332. TAutoVal::operator string()
  333. {
  334.   BSTR v;
  335.   HRESULT stat;
  336. #if defined(BI_PLAT_WIN32)
  337.   LCID lcid = MAKELCID(LangUserDefault, SORT_DEFAULT);
  338. #else
  339.   LCID lcid = MAKELCID(LangUserDefault);
  340. #endif
  341.  
  342.   switch (vt) {
  343.   case atByte:     stat = ::VarBstrFromUI1(bVal, lcid,0, &v); break;
  344.   case atShort:    stat = ::VarBstrFromI2(iVal,  lcid,0, &v); break;
  345.   case atLong:     stat = ::VarBstrFromI4(lVal,  lcid,0, &v); break;
  346.   case atFloat:    stat = ::VarBstrFromR4(fltVal,lcid,0, &v); break;
  347.   case atDouble:   stat = ::VarBstrFromR8(dblVal,lcid,0, &v); break;
  348.   case atCurrency: stat = ::VarBstrFromCy(cyVal ,lcid,0, &v); break;
  349.   case atDatetime: stat = ::VarBstrFromDate(date,lcid,0, &v); break;
  350. #if defined(BI_OLECHAR_WIDE)
  351.   case atString:   return string(TString(bstrVal));
  352. #else
  353.   case atString:   return string(bstrVal);
  354. #endif
  355.   case atObject:   stat = ::VarBstrFromDisp(pdispVal,GetLocale(),0, &v); break;
  356.   case atBool:     stat = ::VarBstrFromBool(boolVal,lcid,0, &v); break;
  357.   case atByRef+atByte:     stat = ::VarBstrFromUI1(*pbVal, lcid,0, &v); break;
  358.   case atByRef+atShort:    stat = ::VarBstrFromI2(*piVal,  lcid,0, &v); break;
  359.   case atByRef+atLong:     stat = ::VarBstrFromI4(*plVal,  lcid,0, &v); break;
  360.   case atByRef+atFloat:    stat = ::VarBstrFromR4(*pfltVal,lcid,0, &v); break;
  361.   case atByRef+atDouble:   stat = ::VarBstrFromR8(*pdblVal,lcid,0, &v); break;
  362.   case atByRef+atCurrency: stat = ::VarBstrFromCy(*pcyVal ,lcid,0, &v); break;
  363.   case atByRef+atDatetime: stat = ::VarBstrFromDate(*pdate,lcid,0, &v); break;
  364. #if defined(BI_OLECHAR_WIDE)
  365.   case atByRef+atString:   return string(TString(*pbstrVal));
  366. #else
  367.   case atByRef+atString:   return string(*pbstrVal);
  368. #endif
  369.   case atByRef+atBool:     stat = ::VarBstrFromBool(*pbool,lcid,0,&v); break;
  370.   default:         stat = (HRESULT)-1;
  371.   }
  372.   if (stat != HR_NOERROR)
  373.     throw TXAuto(TXAuto::xConversionFailure);
  374. #if defined(BI_OLECHAR_WIDE)
  375.   string s((TString)v);
  376. #else
  377.   string s(v);
  378. #endif
  379.   ::SysFreeString(v);
  380.   return s;
  381. }
  382.  
  383. TAutoVal::operator unsigned short()
  384. {
  385.   long temp = operator long();
  386.   if (temp < 0 || temp > 65535L)
  387.     throw TXAuto(TXAuto::xConversionFailure);
  388.   return (unsigned short)temp;
  389. }
  390.  
  391. //
  392. // Pointer data type conversion operators
  393. //
  394. TAutoVal::operator unsigned char far*() {ConvRef(atByte); return pbVal;}
  395. TAutoVal::operator short  far*() {ConvRef(atShort);  return piVal;}
  396. TAutoVal::operator unsigned short far*()
  397.        {ConvRef(atShort); return (unsigned short far*)piVal;} // may overflow!
  398. TAutoVal::operator long   far*() {ConvRef(atLong);   return plVal;}
  399. TAutoVal::operator unsigned long far*()
  400.        {ConvRef(atLong); return (unsigned long far*)plVal;}  // may overflow!
  401. TAutoVal::operator TBool   far*() {ConvRef(atBool); return (TBool far*)pbool;}
  402. TAutoVal::operator float  far*() {ConvRef(atFloat);  return pfltVal;}
  403. TAutoVal::operator double far*() {ConvRef(atDouble); return pdblVal;}
  404. TAutoVal::operator TAutoDate far*() {ConvRef(atDatetime); return (TAutoDate far*)pdate;}
  405. TAutoVal::operator TAutoCurrency far*() {ConvRef(atDatetime); return pcyVal;}
  406.  
  407. void TAutoVal::ConvRef(int type)
  408. {
  409.   if (type != (vt | atByRef)) {
  410.     throw TXAuto(TXAuto::xConversionFailure);
  411.   }
  412. }
  413.  
  414. TAutoVal::operator IDispatch*()
  415. {
  416.   if (vt == atObject) {
  417.     if (pdispVal)
  418.       pdispVal->AddRef();
  419.     return pdispVal;
  420.   }
  421.   if (vt == (atObject | atByRef)) {
  422.     if (*ppdispVal)
  423.       (*ppdispVal)->AddRef();
  424.     return *ppdispVal;
  425.   }
  426.   throw TXAuto(TXAuto::xConversionFailure);
  427. }
  428.  
  429. TAutoVal::operator IUnknown*()
  430. {
  431.   if (vt == atUnknown) {
  432.     if (punkVal)
  433.       punkVal->AddRef();
  434.     return punkVal;
  435.   }
  436.   if (vt == (atUnknown | atByRef)) {
  437.     if (*ppunkVal)
  438.       (*ppunkVal)->AddRef();
  439.     return *ppunkVal;
  440.   }
  441.   throw TXAuto(TXAuto::xConversionFailure);
  442. }
  443.  
  444.  
  445. TAutoVal::operator IDispatch&()
  446. {
  447.   if (vt == atObject && pdispVal)
  448.     return *pdispVal;
  449.   if (vt == (atObject | atByRef) && *ppdispVal)
  450.     return **ppdispVal;
  451.   throw TXAuto(TXAuto::xConversionFailure);
  452. }
  453.  
  454. TAutoVal::operator IUnknown&()
  455. {
  456.   if (vt == atUnknown && punkVal)
  457.     return *punkVal;
  458.   if (vt == (atUnknown | atByRef) && *ppunkVal)
  459.     return **ppunkVal;
  460.   throw TXAuto(TXAuto::xConversionFailure);
  461. }
  462.  
  463.