home *** CD-ROM | disk | FTP | other *** search
/ QBasic & Borland Pascal & C / Delphi5.iso / C / BC_502 / SRCBDTO.PAK / PARAM.CPP < prev    next >
Encoding:
C/C++ Source or Header  |  1997-05-06  |  9.0 KB  |  522 lines
  1. //-----------------------------------------------------------------------------
  2. // Visual Database Tools
  3. // Copyright (c) 1996 by Borland International, All Rights Reserved
  4. //
  5. // param.cpp
  6. // TParam and TParams 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. void TParam::SetTParam( PIUnknown p )
  19. {
  20.     param = 0;
  21.     if (p)
  22.         p->QueryInterface( IID_ITParam, (void**) ¶m );
  23. }
  24.  
  25. void TParam::ClearTParam( void )
  26. {
  27.     if (param)
  28.     {
  29.         param->Release();
  30.         param = 0;
  31.     }
  32. }
  33.  
  34. TParam::TParam( PTParams AParamList, TParamType AParamType )
  35. {
  36.     param = CreateITParam( AParamList ? AParamList->GetPITParams() : 0, AParamType );
  37. }
  38.  
  39. TParam::TParam( void )
  40. {
  41.     param = CreateITParam( 0, ptUnknown );
  42. }
  43.  
  44. TParam::TParam( PITParam p )
  45. {
  46.     SetTParam( p );
  47. }
  48.  
  49. TParam::TParam( const TParam& p )
  50. {
  51.     SetTParam( p.param );
  52. }
  53.  
  54. TParam::TParam( PTParam p )
  55. {
  56.     SetTParam( p ? p->param : 0 );
  57. }
  58.  
  59. TParam& TParam::operator=( PITParam p )
  60. {
  61.     ClearTParam();
  62.     SetTParam( p );
  63.     return *this;
  64. }
  65.  
  66. TParam& TParam::operator=( const TParam& p )
  67. {
  68.     if (this != &p)
  69.     {
  70.         ClearTParam();
  71.         SetTParam( p.param );
  72.     }
  73.     return *this;
  74. }
  75.  
  76. int TParam::operator==( const TParam& p ) const
  77. {
  78.     if (this == &p)
  79.         return true;
  80.     if (param == p.param)
  81.         return true;
  82.     return false;
  83. }
  84.  
  85. int TParam::operator!=( const TParam& p ) const
  86. {
  87.     return ! operator==(p);
  88. }
  89.  
  90. TParam::~TParam()
  91. {
  92.     ClearTParam();
  93. }
  94.  
  95. void TParam::SetPIT( PIUnknown p )
  96. {
  97.     ClearTParam();
  98.     SetTParam( p );
  99. }
  100.  
  101. void TParam::Detach( void )
  102. {
  103.     if (param)
  104.         param->Detach();
  105. }
  106.  
  107. void TParam::Assign( TParam& p )
  108. {
  109.     if (param)
  110.         param->Assign( p.GetPITParam() );
  111. }
  112.  
  113. void TParam::AssignField( TField& f )
  114. {
  115.     if (param)
  116.         param->AssignField( f.GetPITField() );
  117. }
  118.  
  119. void TParam::GetData( LPVOID buffer )
  120. {
  121.     if (param)
  122.         param->GetData( buffer );
  123. }
  124.  
  125. uint16 TParam::GetDataSize( void )
  126. {
  127.     if (param)
  128.         return param->GetDataSize();
  129.     return 0;
  130. }
  131.  
  132. void TParam::SetData( LPVOID buffer )
  133. {
  134.     if (param)
  135.         param->SetData( buffer );
  136. }
  137.  
  138. void TParam::Clear( void )
  139. {
  140.     if (param)
  141.         param->Clear();
  142. }
  143.  
  144. DEFINE_BDTO_OBJECTPROP_RW( TParam, string, Name );
  145. DEFINE_BDTO_PROP_RW( TParam, TFieldType, DataType );
  146. DEFINE_BDTO_PROP_RW( TParam, bool, AsBoolean );
  147. DEFINE_BDTO_PROP_RW( TParam, double, AsFloat );
  148. DEFINE_BDTO_PROP_RW( TParam, int32, AsInteger );
  149. DEFINE_BDTO_OBJECTPROP_RW( TParam, string, AsString );
  150. DEFINE_BDTO_PROP_RW( TParam, DATE, AsDate );
  151. DEFINE_BDTO_PROP_RW( TParam, DATE, AsTime );
  152. DEFINE_BDTO_PROP_RW( TParam, DATE, AsDateTime );
  153. DEFINE_BDTO_PROP_RW( TParam, int32, AsSmallInt );
  154. DEFINE_BDTO_PROP_RW( TParam, int32, AsWord );
  155. DEFINE_BDTO_PROP_RW( TParam, double, AsCurrency );
  156. DEFINE_BDTO_PROP_RW( TParam, double, AsBCD );
  157. DEFINE_BDTO_PROP_RO( TParam, bool, IsNull );
  158. DEFINE_BDTO_PROP_RW( TParam, TParamType, ParamType );
  159. DEFINE_BDTO_PROP_RW( TParam, bool, Bound );
  160. DEFINE_BDTO_OBJECTPROP_RW( TParam, string, Text );
  161.  
  162. void TParam::GetName( string& s )
  163. {
  164.     if (param)
  165.         AnyString( param->get_Name() ).GetString( s );
  166. }
  167.  
  168. void TParam::SetName( const string& n )
  169. {
  170.     if (param)
  171.         param->put_Name( AnyString(n).GetPITAnyString() );
  172. }
  173.  
  174. void TParam::GetDataType( TFieldType& t )
  175. {
  176.     if (param)
  177.         t = param->get_DataType();
  178. }
  179.  
  180. void TParam::SetDataType( TFieldType t )
  181. {
  182.     if (param)
  183.         param->put_DataType( t );
  184. }
  185.  
  186. void TParam::GetAsBoolean( bool& b )
  187. {
  188.     if (param)
  189.         b = MakeBool( param->get_AsBoolean() );
  190. }
  191.  
  192. void TParam::SetAsBoolean( bool b )
  193. {
  194.     if (param)
  195.         param->put_AsBoolean( MakeVariantBool( b ) );
  196. }
  197.  
  198. void TParam::GetAsFloat( double& f )
  199. {
  200.     if (param)
  201.         f = param->get_AsFloat();
  202. }
  203.  
  204. void TParam::SetAsFloat( double f )
  205. {
  206.     if (param)
  207.         param->put_AsFloat( f );
  208. }
  209.  
  210. void TParam::GetAsInteger( int32& i )
  211. {
  212.     if (param)
  213.         i = param->get_AsInteger();
  214. }
  215.  
  216. void TParam::SetAsInteger( int32 i )
  217. {
  218.     if (param)
  219.         param->put_AsInteger( i );
  220. }
  221.  
  222. void TParam::GetAsString( string& s )
  223. {
  224.     if (param)
  225.         AnyString( param->get_AsString() ).GetString( s );
  226. }
  227.  
  228. void TParam::SetAsString( const string& s )
  229. {
  230.     if (param)
  231.         param->put_AsString( AnyString(s).GetPITAnyString() );
  232. }
  233.  
  234. void TParam::GetAsDate( DATE& d )
  235. {
  236.     if (param)
  237.         d = param->get_AsDate();
  238. }
  239.  
  240. void TParam::SetAsDate( DATE d )
  241. {
  242.     if (param)
  243.         param->put_AsDate( d );
  244. }
  245.  
  246. void TParam::GetAsTime( DATE& t )
  247. {
  248.     if (param)
  249.         t = param->get_AsTime();
  250. }
  251.  
  252. void TParam::SetAsTime( DATE t )
  253. {
  254.     if (param)
  255.         param->put_AsTime( t );
  256. }
  257.  
  258. void TParam::GetAsDateTime( DATE& dt )
  259. {
  260.     if (param)
  261.         dt = param->get_AsDateTime();
  262. }
  263.  
  264. void TParam::SetAsDateTime( DATE dt )
  265. {
  266.     if (param)
  267.         param->put_AsDateTime( dt );
  268. }
  269.  
  270. void TParam::GetAsSmallInt( int32& si )
  271. {
  272.     if (param)
  273.         si = param->get_AsSmallInt();
  274. }
  275.  
  276. void TParam::SetAsSmallInt( int32 si )
  277. {
  278.     if (param)
  279.         param->put_AsSmallInt( si );
  280. }
  281.  
  282. void TParam::GetAsWord( int32& w )
  283. {
  284.     if (param)
  285.         w = param->get_AsWord();
  286. }
  287.  
  288. void TParam::SetAsWord( int32 w )
  289. {
  290.     if (param)
  291.         param->put_AsWord( w );
  292. }
  293.  
  294. void TParam::GetAsCurrency( double& c )
  295. {
  296.     if (param)
  297.         c = param->get_AsCurrency();
  298. }
  299.  
  300. void TParam::SetAsCurrency( double c )
  301. {
  302.     if (param)
  303.         param->put_AsCurrency( c );
  304. }
  305.  
  306. void TParam::GetAsBCD( double& b )
  307. {
  308.     if (param)
  309.         b = param->get_AsBCD();
  310. }
  311.  
  312. void TParam::SetAsBCD( double b )
  313. {
  314.     if (param)
  315.         param->put_AsBCD( b );
  316. }
  317.  
  318. void TParam::GetIsNull( bool& i )
  319. {
  320.     if (param)
  321.         i = MakeBool( param->get_IsNull() );
  322. }
  323.  
  324. void TParam::GetParamType( TParamType& t )
  325. {
  326.     if (param)
  327.         t = param->get_ParamType();
  328. }
  329.  
  330. void TParam::SetParamType( TParamType t )
  331. {
  332.     if (param)
  333.         param->put_ParamType( t );
  334. }
  335.  
  336. void TParam::GetBound( bool& b )
  337. {
  338.     if (param)
  339.         b = MakeBool( param->get_Bound() );
  340. }
  341.  
  342. void TParam::SetBound( bool b )
  343. {
  344.     if (param)
  345.         param->put_Bound( MakeVariantBool( b ) );
  346. }
  347.  
  348. void TParam::GetText( string& t )
  349. {
  350.     if (param)
  351.         AnyString( param->get_Text() ).GetString( t );
  352. }
  353.  
  354. void TParam::SetText( const string& t )
  355. {
  356.     if (param)
  357.         param->put_Text( AnyString(t).GetPITAnyString() );
  358. }
  359.  
  360. //-----------------------------------------------------------------------------
  361.  
  362. void TParams::SetTParams( PIUnknown p )
  363. {
  364.     params = 0;
  365.     if (p)
  366.         p->QueryInterface( IID_ITParams, (void**) ¶ms );
  367. }
  368.  
  369. void TParams::ClearTParams( void )
  370. {
  371.     if (params)
  372.     {
  373.         params->Release();
  374.         params = 0;
  375.     }
  376. }
  377.  
  378. TParams::TParams( void ) : TBDTObject()
  379. {
  380.     params = CreateITParams();
  381.     TBDTObject::SetPIT( params );
  382. }
  383.  
  384. TParams::TParams( PITParams p ) : TBDTObject( p )
  385. {
  386.     SetTParams( p );
  387. }
  388.  
  389. TParams::TParams( const TParams& p ) : TBDTObject( p )
  390. {
  391.     SetTParams( p.params );
  392. }
  393.  
  394. TParams::TParams( PTParams p ) : TBDTObject( p )
  395. {
  396.     SetTParams( p ? p->params : 0 );
  397. }
  398.  
  399. TParams& TParams::operator=( PITParams p )
  400. {
  401.     TBDTObject::operator=(p);
  402.     ClearTParams();
  403.     SetTParams( p );
  404.     return *this;
  405. }
  406.  
  407. TParams& TParams::operator=( const TParams& p )
  408. {
  409.     if (this != &p)
  410.     {
  411.         TBDTObject::operator=(p);
  412.         ClearTParams();
  413.         SetTParams( p.params );
  414.     }
  415.     return *this;
  416. }
  417.  
  418. int TParams::operator==( const TParams& p ) const
  419. {
  420.     if (this == &p)
  421.         return true;
  422.     if (params == p.params)
  423.         return true;
  424.     return false;
  425. }
  426.  
  427. int TParams::operator!=( const TParams& p ) const
  428. {
  429.     return ! operator==(p);
  430. }
  431.  
  432. TParams::~TParams()
  433. {
  434.     ClearTParams();
  435. }
  436.  
  437. void TParams::SetPIT( PIUnknown p )
  438. {
  439.     ClearTParams();
  440.     SetTParams( p );
  441.     TBDTObject::SetPIT( p );
  442. }
  443.  
  444. void TParams::AssignValues( TParams& p )
  445. {
  446.     if (params)
  447.         params->AssignValues( p.GetPITParams() );
  448. }
  449.  
  450. void TParams::AddParam( TParam& p )
  451. {
  452.     if (params)
  453.         params->AddParam( p.GetPITParam() );
  454. }
  455.  
  456. void TParams::RemoveParam( TParam& p )
  457. {
  458.     if (params)
  459.         params->RemoveParam( p.GetPITParam() );
  460. }
  461.  
  462. DEFINE_BDTO_OBJECTMETHOD3( TParams, TParam, PITParam, CreateParam, TFieldType, string&, TParamType );
  463.  
  464. void TParams::CallCreateParam( TFieldType fldType, string& name, TParamType paramType, TParam& p )
  465. {
  466.     if (params)
  467.     {
  468.         PITParam pit = params->CreateParam( fldType, AnyString(name).GetPITAnyString(), paramType );
  469.         if (pit)
  470.         {
  471.             p.SetPIT( pit );
  472.             pit->Release();
  473.         }
  474.     }
  475. }
  476.  
  477. DEFINE_BDTO_PROP_RO( TParams, int, Count );
  478.  
  479. void TParams::GetCount( int& c )
  480. {
  481.     if (params)
  482.         c = params->get_Count();
  483.     else
  484.         c = 0;
  485. }
  486.  
  487. void TParams::Clear( void )
  488. {
  489.     if (params)
  490.         params->Clear();
  491. }
  492.  
  493. DEFINE_BDTO_OBJECTMETHOD1( TParams, TParam, PITParam, ParamByName, string& );
  494.  
  495. void TParams::CallParamByName( string& value, TParam& p )
  496. {
  497.     if (params)
  498.     {
  499.         PITParam pit = params->ParamByName( AnyString(value).GetPITAnyString() );
  500.         if (pit)
  501.         {
  502.             p.SetPIT( pit );
  503.             pit->Release();
  504.         }
  505.     }
  506. }
  507.  
  508. DEFINE_BDTO_ARRAYOBJECTPROP_RO_FAST( TParams, TParam, PITParam, Items, uint16 );
  509.  
  510. void TParams::GetItems( uint16 i, TParam& p )
  511. {
  512.     if (params)
  513.     {
  514.         PITParam pit = params->get_Items( i );
  515.         if (pit)
  516.         {
  517.             p.SetPIT( pit );
  518.             pit->Release();
  519.         }
  520.     }
  521. }
  522.