home *** CD-ROM | disk | FTP | other *** search
/ QBasic & Borland Pascal & C / Delphi5.iso / C / BC_502 / SRCBDTO.PAK / VARREC.CPP < prev    next >
Encoding:
C/C++ Source or Header  |  1997-05-06  |  8.4 KB  |  549 lines
  1. //-----------------------------------------------------------------------------
  2. // Visual Database Tools
  3. // Copyright (c) 1996 by Borland International, All Rights Reserved
  4. //
  5. // varrec.cpp
  6. // TVarRec and TVarRecs wrapper classes
  7. //-----------------------------------------------------------------------------
  8.  
  9. #include <vdbt\bdto.h>
  10.  
  11. #pragma hdrstop
  12.  
  13. #include "wrapit.h"
  14. #include "misc.h"
  15.  
  16. //-----------------------------------------------------------------------------
  17.  
  18. TVarRec::TVarRec( void )
  19. {
  20.     Allocate();
  21. }
  22.  
  23. TVarRec::TVarRec( LPVARIANT p )
  24. {
  25.     Allocate();
  26.     if (lpvar && p)
  27.         VariantCopy( lpvar, p );
  28. }
  29.  
  30. TVarRec::TVarRec( const TVarRec& p )
  31. {
  32.     Allocate();
  33.     if (lpvar && p.lpvar)
  34.         VariantCopy( lpvar, p.lpvar );
  35. }
  36.  
  37. TVarRec::TVarRec( PTVarRec p )
  38. {
  39.     Allocate();
  40.     if (lpvar && p && p->lpvar)
  41.         VariantCopy( lpvar, p->lpvar );
  42. }
  43.  
  44. TVarRec::TVarRec( bool b )
  45. {
  46.     Allocate();
  47.     SetAsBoolean( b );
  48. }
  49.  
  50. #if 0
  51. TVarRec::TVarRec( DATE d )
  52. {
  53.     Allocate();
  54.     SetAsDateTime( d );
  55. }
  56. #endif
  57.  
  58. TVarRec::TVarRec( double d )
  59. {
  60.     Allocate();
  61.     SetAsFloat( d );
  62. }
  63.  
  64. TVarRec::TVarRec( float f )
  65. {
  66.     Allocate();
  67.     double d = f;
  68.     SetAsFloat( d );
  69. }
  70.  
  71. TVarRec::TVarRec( int32 l )
  72. {
  73.     Allocate();
  74.     SetAsInteger( l );
  75. }
  76.  
  77. TVarRec::TVarRec( int i )
  78. {
  79.     Allocate();
  80.     int32 l = i;
  81.     SetAsInteger( l );
  82. }
  83.  
  84. TVarRec::TVarRec( int16 s )
  85. {
  86.     Allocate();
  87.     int32 l = s;
  88.     SetAsInteger( l );
  89. }
  90.  
  91. TVarRec::TVarRec( string& s )
  92. {
  93.     Allocate();
  94.     SetAsString( s );
  95. }
  96.  
  97. TVarRec::TVarRec( LPSTR s )
  98. {
  99.     Allocate();
  100.     SetAsString( string( s ) );
  101. }
  102.  
  103. TVarRec& TVarRec::operator=( const TVarRec& p )
  104. {
  105.     if (this != &p)
  106.     {
  107.         if (lpvar)
  108.         {
  109.             if (allocated)
  110.             {
  111.                 VariantClear( lpvar );
  112.                 delete lpvar;
  113.                 allocated = false;
  114.             }
  115.             lpvar = 0;
  116.         }
  117.  
  118.         Allocate();
  119.         if (lpvar && p.lpvar)
  120.             VariantCopy( lpvar, p.lpvar );
  121.     }
  122.  
  123.     return *this;
  124. }
  125.  
  126. TVarRec::~TVarRec()
  127. {
  128.     if (lpvar)
  129.     {
  130.         if (allocated)
  131.         {
  132.             VariantClear( lpvar );
  133.             delete lpvar;
  134.             allocated = false;
  135.         }
  136.         lpvar = 0;
  137.     }
  138. }
  139.  
  140. void TVarRec::SetVariant( LPVARIANT p )
  141. {
  142.     if (lpvar)
  143.     {
  144.         if (allocated)
  145.         {
  146.             VariantClear( lpvar );
  147.             delete lpvar;
  148.             allocated = false;
  149.         }
  150.         lpvar = 0;
  151.     }
  152.  
  153.     allocated = false;
  154.     if (p)
  155.         lpvar = p;
  156.     else
  157.         Allocate();
  158. }
  159.  
  160. void TVarRec::Allocate( void )
  161. {
  162.     allocated = true;
  163.     lpvar = new VARIANT;
  164.     if (lpvar)
  165.         VariantInit( lpvar );
  166. }
  167.  
  168. DEFINE_BDTO_PROP_RW( TVarRec, bool, AsBoolean );
  169. DEFINE_BDTO_PROP_RW( TVarRec, DATE, AsDateTime );
  170. DEFINE_BDTO_PROP_RW( TVarRec, double, AsFloat );
  171. DEFINE_BDTO_PROP_RW( TVarRec, int32, AsInteger );
  172. DEFINE_BDTO_OBJECTPROP_RW( TVarRec, string, AsString );
  173.  
  174. void TVarRec::GetAsBoolean( bool& b )
  175. {
  176.     if (lpvar)
  177.     {
  178.         if (V_VT(lpvar) == VT_BOOL ||
  179.              VariantChangeType( lpvar, lpvar, 0, VT_BOOL ) == NOERROR )
  180.         {
  181.             b = MakeBool( V_BOOL(lpvar) );
  182.         }
  183.     }
  184. }
  185.  
  186. void TVarRec::SetAsBoolean( bool b )
  187. {
  188.     if (lpvar)
  189.     {
  190.         VariantClear( lpvar );
  191.         V_VT(lpvar) = VT_BOOL;
  192.         V_BOOL(lpvar) = MakeVariantBool( b );
  193.     }
  194. }
  195.  
  196. void TVarRec::GetAsDateTime( DATE& d )
  197. {
  198.     if (lpvar)
  199.     {
  200.         if (V_VT(lpvar) == VT_DATE ||
  201.              VariantChangeType( lpvar, lpvar, 0, VT_DATE ) == NOERROR )
  202.         {
  203.             d = V_DATE(lpvar);
  204.         }
  205.     }
  206. }
  207.  
  208. void TVarRec::SetAsDateTime( DATE d )
  209. {
  210.     if (lpvar)
  211.     {
  212.         VariantClear( lpvar );
  213.         V_VT(lpvar) = VT_DATE;
  214.         V_DATE(lpvar) = d;
  215.     }
  216. }
  217.  
  218. void TVarRec::GetAsFloat( double& d )
  219. {
  220.     if (lpvar)
  221.     {
  222.         if (V_VT(lpvar) == VT_R8 ||
  223.              VariantChangeType( lpvar, lpvar, 0, VT_R8 ) == NOERROR )
  224.         {
  225.             d = V_R8(lpvar);
  226.         }
  227.     }
  228. }
  229.  
  230. void TVarRec::SetAsFloat( double d )
  231. {
  232.     if (lpvar)
  233.     {
  234.         VariantClear( lpvar );
  235.         V_VT(lpvar) = VT_R8;
  236.         V_R8(lpvar) = d;
  237.     }
  238. }
  239.  
  240. void TVarRec::GetAsInteger( int32& i )
  241. {
  242.     if (lpvar)
  243.     {
  244.         if (V_VT(lpvar) == VT_I4 ||
  245.              VariantChangeType( lpvar, lpvar, 0, VT_I4 ) == NOERROR )
  246.         {
  247.             i = V_I4(lpvar);
  248.         }
  249.     }
  250. }
  251.  
  252. void TVarRec::SetAsInteger( int32 i )
  253. {
  254.     if (lpvar)
  255.     {
  256.         VariantClear( lpvar );
  257.         V_VT(lpvar) = VT_I4;
  258.         V_I4(lpvar) = i;
  259.     }
  260. }
  261.  
  262. void TVarRec::GetAsString( string& s )
  263. {
  264.     if (lpvar)
  265.     {
  266.         if (V_VT(lpvar) == VT_BSTR ||
  267.              VariantChangeType( lpvar, lpvar, 0, VT_BSTR ) == NOERROR )
  268.         {
  269. #ifdef __FLAT__
  270.             int max = SysStringLen( V_BSTR(lpvar) )+1;
  271.             LPSTR buf = new char [max];
  272.             WideCharToMultiByte( CP_ACP, 0, V_BSTR(lpvar), -1, buf, max, 0, 0 );
  273.             s = buf;
  274.             delete [] buf;
  275. #else
  276.             s = V_BSTR(lpvar);
  277. #endif
  278.         }
  279.     }
  280. }
  281.  
  282. void TVarRec::SetAsString( const string& s )
  283. {
  284.     if (lpvar)
  285.     {
  286.         VariantClear( lpvar );
  287.         V_VT(lpvar) = VT_BSTR;
  288. #ifdef __FLAT__
  289.         V_BSTR( lpvar ) = SysAllocStringLen( 0, s.length()+1 );
  290.         MultiByteToWideChar( CP_ACP, MB_PRECOMPOSED, s.c_str(), -1, V_BSTR( lpvar ), s.length()+1 );
  291. #else
  292.         V_BSTR( lpvar ) = SysAllocString( s.c_str() );
  293. #endif
  294.     }
  295. }
  296.  
  297. TVarRec::operator bool()
  298. {
  299.     bool v;
  300.     GetAsBoolean( v );
  301.     return v;
  302. }
  303.  
  304. TVarRec& TVarRec::operator=( bool v )
  305. {
  306.     SetAsBoolean( v );
  307.     return *this;
  308. }
  309.  
  310. #if 0
  311. TVarRec::operator DATE()
  312. {
  313.     DATE v;
  314.     GetAsDateTime( v );
  315.     return v;
  316. }
  317.  
  318. TVarRec& TVarRec::operator=( DATE v )
  319. {
  320.     SetAsDateTime( v );
  321.     return *this;
  322. }
  323. #endif
  324.  
  325. TVarRec::operator double()
  326. {
  327.     double v;
  328.     GetAsFloat( v );
  329.     return v;
  330. }
  331.  
  332. TVarRec& TVarRec::operator=( double v )
  333. {
  334.     SetAsFloat( v );
  335.     return *this;
  336. }
  337.  
  338. TVarRec::operator int32()
  339. {
  340.     int32 v;
  341.     GetAsInteger( v );
  342.     return v;
  343. }
  344.  
  345. TVarRec& TVarRec::operator=( int32 v )
  346. {
  347.     SetAsInteger( v );
  348.     return *this;
  349. }
  350.  
  351. TVarRec::operator string()
  352. {
  353.     string v;
  354.     GetAsString( v );
  355.     return v;
  356. }
  357.  
  358. TVarRec& TVarRec::operator=( string& v )
  359. {
  360.     SetAsString( v );
  361.     return *this;
  362. }
  363.  
  364. //-----------------------------------------------------------------------------
  365.  
  366. TVarRecs::TVarRecs( int c, LPVARIANT p )
  367. {
  368.     if (p && c)
  369.     {
  370.         count = c;
  371.         lpvar = new VARIANT [count];
  372.         int i;
  373.         for (i = 0; i < count; i++)
  374.         {
  375.             VariantInit( lpvar+i );
  376.             VariantCopy( lpvar+i, p+i );
  377.         }
  378.     }
  379.     else
  380.     {
  381.         lpvar = 0;
  382.         count = 0;
  383.     }
  384. }
  385.  
  386. TVarRecs::TVarRecs( const TVarRecs& p )
  387. {
  388.     if (p.lpvar && p.count)
  389.     {
  390.         count = p.count;
  391.         lpvar = new VARIANT [count];
  392.         int i;
  393.         for (i = 0; i < count; i++)
  394.         {
  395.             VariantInit( lpvar+i );
  396.             VariantCopy( lpvar+i, p.lpvar+i );
  397.         }
  398.     }
  399.     else
  400.     {
  401.         lpvar = 0;
  402.         count = 0;
  403.     }
  404. }
  405.  
  406. TVarRecs::TVarRecs( PTVarRecs p )
  407. {
  408.     if (p && p->lpvar && p->count)
  409.     {
  410.         count = p->count;
  411.         lpvar = new VARIANT [count];
  412.         int i;
  413.         for (i = 0; i < count; i++)
  414.         {
  415.             VariantInit( lpvar+i );
  416.             VariantCopy( lpvar+i, p->lpvar+i );
  417.         }
  418.     }
  419.     else
  420.     {
  421.         lpvar = 0;
  422.         count = 0;
  423.     }
  424. }
  425.  
  426. TVarRecs& TVarRecs::operator=( TVarRecs& p )
  427. {
  428.     if (this != &p)
  429.     {
  430.         if (lpvar)
  431.         {
  432.             int i;
  433.             for (i = 0; i < count; i++)
  434.                 VariantClear( lpvar+i );
  435.             delete [] lpvar;
  436.         }
  437.  
  438.         if (p.lpvar && p.count)
  439.         {
  440.             count = p.count;
  441.             lpvar = new VARIANT [count];
  442.             int i;
  443.             for (i = 0; i < count; i++)
  444.             {
  445.                 VariantInit( lpvar+i );
  446.                 VariantCopy( lpvar+i, p.lpvar+i );
  447.             }
  448.         }
  449.         else
  450.         {
  451.             lpvar = 0;
  452.             count = 0;
  453.         }
  454.     }
  455.  
  456.     return *this;
  457. }
  458.  
  459. TVarRecs::~TVarRecs()
  460. {
  461.     if (lpvar)
  462.     {
  463.         int i;
  464.         for (i = 0; i < count; i++)
  465.             VariantClear( lpvar+i );
  466.         delete [] lpvar;
  467.     }
  468. }
  469.  
  470. void TVarRecs::Add( void )
  471. {
  472.     int count2 = count+1;
  473.     LPVARIANT lpvar2 = new VARIANT [count2];
  474.     if (lpvar2)
  475.     {
  476.         int i;
  477.         for (i = 0; i < count; i++)
  478.         {
  479.             VariantInit( lpvar2+i );
  480.             VariantCopy( lpvar2+i, lpvar+i );
  481.         }
  482.  
  483.         VariantInit( lpvar2+count );
  484.  
  485.         if (lpvar)
  486.             delete [] lpvar;
  487.         lpvar = lpvar2;
  488.         count = count2;
  489.     }
  490. }
  491.  
  492. void TVarRecs::Add( TVarRec& v )
  493. {
  494.     int count2 = count+1;
  495.     LPVARIANT lpvar2 = new VARIANT [count2];
  496.     if (lpvar2)
  497.     {
  498.         int i;
  499.         for (i = 0; i < count; i++)
  500.         {
  501.             VariantInit( lpvar2+i );
  502.             VariantCopy( lpvar2+i, lpvar+i );
  503.         }
  504.  
  505.         VariantInit( lpvar2+count );
  506.         LPVARIANT var = v.GetVariant();
  507.         if (var)
  508.             VariantCopy( lpvar2+count, var );
  509.  
  510.         if (lpvar)
  511.             delete [] lpvar;
  512.         lpvar = lpvar2;
  513.         count = count2;
  514.     }
  515. }
  516.  
  517. void TVarRecs::Clear( void )
  518. {
  519.     if (lpvar)
  520.     {
  521.         int i;
  522.         for (i = 0; i < count; i++)
  523.             VariantClear( lpvar+i );
  524.         delete [] lpvar;
  525.         lpvar = 0;
  526.     }
  527.     count = 0;
  528. }
  529.  
  530. DEFINE_BDTO_PROP_RO( TVarRecs, int, Count );
  531. DEFINE_BDTO_PROP_RO( TVarRecs, LPVARIANT, Variants );
  532. DEFINE_BDTO_ARRAYOBJECTPROP_RO( TVarRecs, TVarRec, Items, int );
  533.  
  534. void TVarRecs::GetCount( int& c )
  535. {
  536.     c = count;
  537. }
  538.  
  539. void TVarRecs::GetVariants( LPVARIANT& v )
  540. {
  541.     v = lpvar;
  542. }
  543.  
  544. void TVarRecs::GetItems( int i, TVarRec& v )
  545. {
  546.     if (lpvar && i < count)
  547.         v.SetVariant( lpvar+i );
  548. }
  549.