home *** CD-ROM | disk | FTP | other *** search
/ Magazyn Internet 2000 May / MICD_2000_05.iso / CBuilder5 / INSTALL / DATA1.CAB / Program_Built_Files / Include / Vcl / ibservices.hpp < prev    next >
C/C++ Source or Header  |  2000-02-01  |  22KB  |  673 lines
  1. // Borland C++ Builder
  2. // Copyright (c) 1995, 1999 by Borland International
  3. // All rights reserved
  4.  
  5. // (DO NOT EDIT: machine generated header) 'IBServices.pas' rev: 5.00
  6.  
  7. #ifndef IBServicesHPP
  8. #define IBServicesHPP
  9.  
  10. #pragma delphiheader begin
  11. #pragma option push -w-
  12. #pragma option push -Vx
  13. #include <IBExternals.hpp>    // Pascal unit
  14. #include <IB.hpp>    // Pascal unit
  15. #include <IBHeader.hpp>    // Pascal unit
  16. #include <DBLogDlg.hpp>    // Pascal unit
  17. #include <Dialogs.hpp>    // Pascal unit
  18. #include <Forms.hpp>    // Pascal unit
  19. #include <Controls.hpp>    // Pascal unit
  20. #include <Graphics.hpp>    // Pascal unit
  21. #include <Classes.hpp>    // Pascal unit
  22. #include <SysUtils.hpp>    // Pascal unit
  23. #include <Messages.hpp>    // Pascal unit
  24. #include <Windows.hpp>    // Pascal unit
  25. #include <SysInit.hpp>    // Pascal unit
  26. #include <System.hpp>    // Pascal unit
  27.  
  28. //-- user supplied -----------------------------------------------------------
  29.  
  30. namespace Ibservices
  31. {
  32. //-- type declarations -------------------------------------------------------
  33. typedef AnsiString IBServices__1[12];
  34.  
  35. #pragma option push -b-
  36. enum TProtocol { TCP, SPX, NamedPipe, Local };
  37. #pragma option pop
  38.  
  39. #pragma option push -b-
  40. enum TOutputBufferOption { ByLine, ByChunk };
  41. #pragma option pop
  42.  
  43. class DELPHICLASS TIBCustomService;
  44. typedef void __fastcall (__closure *TLoginEvent)(TIBCustomService* Database, Classes::TStrings* LoginParams
  45.     );
  46.  
  47. class PASCALIMPLEMENTATION TIBCustomService : public Classes::TComponent 
  48. {
  49.     typedef Classes::TComponent inherited;
  50.     
  51. private:
  52.     bool FIBLoaded;
  53.     bool FParamsChanged;
  54.     char *FSPB;
  55.     char *FQuerySPB;
  56.     short FSPBLength;
  57.     short FQuerySPBLength;
  58.     TLoginEvent FOnLogin;
  59.     bool FLoginPrompt;
  60.     int FBufferSize;
  61.     char *FOutputBuffer;
  62.     AnsiString FQueryParams;
  63.     AnsiString FServerName;
  64.     void * *FHandle;
  65.     bool FStreamedActive;
  66.     Classes::TNotifyEvent FOnAttach;
  67.     TOutputBufferOption FOutputBufferOption;
  68.     TProtocol FProtocol;
  69.     Classes::TStrings* FParams;
  70.     bool __fastcall GetActive(void);
  71.     AnsiString __fastcall GetServiceParamBySPB(const int Idx);
  72.     void __fastcall SetActive(const bool Value);
  73.     void __fastcall SetBufferSize(const int Value);
  74.     void __fastcall SetParams(const Classes::TStrings* Value);
  75.     void __fastcall SetServerName(const AnsiString Value);
  76.     void __fastcall SetProtocol(const TProtocol Value);
  77.     void __fastcall SetServiceParamBySPB(const int Idx, const AnsiString Value);
  78.     int __fastcall IndexOfSPBConst(AnsiString st);
  79.     void __fastcall ParamsChange(System::TObject* Sender);
  80.     void __fastcall ParamsChanging(System::TObject* Sender);
  81.     void __fastcall CheckServerName(void);
  82.     int __fastcall Call(int ErrCode, bool RaiseError);
  83.     AnsiString __fastcall ParseString(int &RunLen);
  84.     int __fastcall ParseInteger(int &RunLen);
  85.     void __fastcall GenerateSPB(Classes::TStrings* sl, AnsiString &SPB, short &SPBLength);
  86.     
  87. protected:
  88.     virtual void __fastcall Loaded(void);
  89.     bool __fastcall Login(void);
  90.     void __fastcall CheckActive(void);
  91.     void __fastcall CheckInactive(void);
  92.     __property char * OutputBuffer = {read=FOutputBuffer};
  93.     __property TOutputBufferOption OutputBufferOption = {read=FOutputBufferOption, write=FOutputBufferOption
  94.         , nodefault};
  95.     __property int BufferSize = {read=FBufferSize, write=SetBufferSize, default=32000};
  96.     void __fastcall InternalServiceQuery(void);
  97.     __property AnsiString ServiceQueryParams = {read=FQueryParams, write=FQueryParams};
  98.     
  99. public:
  100.     __fastcall virtual TIBCustomService(Classes::TComponent* AOwner);
  101.     __fastcall virtual ~TIBCustomService(void);
  102.     void __fastcall Attach(void);
  103.     void __fastcall Detach(void);
  104.     __property Ibexternals::PVoid Handle = {read=FHandle};
  105.     __property AnsiString ServiceParamBySPB[int Idx] = {read=GetServiceParamBySPB, write=SetServiceParamBySPB
  106.         };
  107.     
  108. __published:
  109.     __property bool Active = {read=GetActive, write=SetActive, default=0};
  110.     __property AnsiString ServerName = {read=FServerName, write=SetServerName};
  111.     __property TProtocol Protocol = {read=FProtocol, write=SetProtocol, default=3};
  112.     __property Classes::TStrings* Params = {read=FParams, write=SetParams};
  113.     __property bool LoginPrompt = {read=FLoginPrompt, write=FLoginPrompt, default=1};
  114.     __property Classes::TNotifyEvent OnAttach = {read=FOnAttach, write=FOnAttach};
  115.     __property TLoginEvent OnLogin = {read=FOnLogin, write=FOnLogin};
  116. };
  117.  
  118.  
  119. typedef DynamicArray<AnsiString >  IBServices__3;
  120.  
  121. struct TDatabaseInfo
  122. {
  123.     int NoOfAttachments;
  124.     int NoOfDatabases;
  125.     DynamicArray<AnsiString >  DbName;
  126. } ;
  127.  
  128. typedef DynamicArray<AnsiString >  IBServices__4;
  129.  
  130. typedef DynamicArray<AnsiString >  IBServices__5;
  131.  
  132. typedef DynamicArray<AnsiString >  IBServices__6;
  133.  
  134. struct TLicenseInfo
  135. {
  136.     DynamicArray<AnsiString >  Key;
  137.     DynamicArray<AnsiString >  Id;
  138.     DynamicArray<AnsiString >  Desc;
  139.     int LicensedUsers;
  140. } ;
  141.  
  142. struct TLicenseMaskInfo
  143. {
  144.     int LicenseMask;
  145.     int CapabilityMask;
  146. } ;
  147.  
  148. typedef DynamicArray<int >  IBServices__7;
  149.  
  150. typedef DynamicArray<int >  IBServices__8;
  151.  
  152. struct TConfigFileData
  153. {
  154.     DynamicArray<int >  ConfigFileValue;
  155.     DynamicArray<int >  ConfigFileKey;
  156. } ;
  157.  
  158. typedef DynamicArray<AnsiString >  IBServices__9;
  159.  
  160. struct TConfigParams
  161. {
  162.     TConfigFileData ConfigFileData;
  163.     DynamicArray<AnsiString >  ConfigFileParams;
  164.     AnsiString BaseLocation;
  165.     AnsiString LockFileLocation;
  166.     AnsiString MessageFileLocation;
  167.     AnsiString SecurityDatabaseLocation;
  168. } ;
  169.  
  170. struct TVersionInfo
  171. {
  172.     AnsiString ServerVersion;
  173.     AnsiString ServerImplementation;
  174.     int ServiceVersion;
  175. } ;
  176.  
  177. #pragma option push -b-
  178. enum TPropertyOption { Database, License, LicenseMask, ConfigParameters, Version };
  179. #pragma option pop
  180.  
  181. typedef Set<TPropertyOption, Database, Version>  TPropertyOptions;
  182.  
  183. class DELPHICLASS TIBServerProperties;
  184. class PASCALIMPLEMENTATION TIBServerProperties : public TIBCustomService 
  185. {
  186.     typedef TIBCustomService inherited;
  187.     
  188. private:
  189.     TPropertyOptions FOptions;
  190.     TDatabaseInfo FDatabaseInfo;
  191.     TLicenseInfo FLicenseInfo;
  192.     TLicenseMaskInfo FLicenseMaskInfo;
  193.     TVersionInfo FVersionInfo;
  194.     TConfigParams FConfigParams;
  195.     void __fastcall ParseConfigFileData(int &RunLen);
  196.     
  197. public:
  198.     __fastcall virtual TIBServerProperties(Classes::TComponent* AOwner);
  199.     __fastcall virtual ~TIBServerProperties(void);
  200.     void __fastcall Fetch(void);
  201.     void __fastcall FetchDatabaseInfo(void);
  202.     void __fastcall FetchLicenseInfo(void);
  203.     void __fastcall FetchLicenseMaskInfo(void);
  204.     void __fastcall FetchConfigParams(void);
  205.     void __fastcall FetchVersionInfo(void);
  206.     __property TDatabaseInfo DatabaseInfo = {read=FDatabaseInfo};
  207.     __property TLicenseInfo LicenseInfo = {read=FLicenseInfo};
  208.     __property TLicenseMaskInfo LicenseMaskInfo = {read=FLicenseMaskInfo};
  209.     __property TVersionInfo VersionInfo = {read=FVersionInfo};
  210.     __property TConfigParams ConfigParams = {read=FConfigParams};
  211.     
  212. __published:
  213.     __property TPropertyOptions Options = {read=FOptions, write=FOptions, nodefault};
  214. };
  215.  
  216.  
  217. class DELPHICLASS TIBControlService;
  218. class PASCALIMPLEMENTATION TIBControlService : public TIBCustomService 
  219. {
  220.     typedef TIBCustomService inherited;
  221.     
  222. private:
  223.     AnsiString FStartParams;
  224.     char *FStartSPB;
  225.     int FStartSPBLength;
  226.     bool __fastcall GetIsServiceRunning(void);
  227.     
  228. protected:
  229.     __property AnsiString ServiceStartParams = {read=FStartParams, write=FStartParams};
  230.     virtual void __fastcall SetServiceStartOptions(void);
  231.     void __fastcall ServiceStartAddParam(AnsiString Value, int param)/* overload */;
  232.     void __fastcall ServiceStartAddParam(int Value, int param)/* overload */;
  233.     void __fastcall InternalServiceStart(void);
  234.     
  235. public:
  236.     __fastcall virtual TIBControlService(Classes::TComponent* AOwner);
  237.     virtual void __fastcall ServiceStart(void);
  238.     __property bool IsServiceRunning = {read=GetIsServiceRunning, nodefault};
  239. public:
  240.     #pragma option push -w-inl
  241.     /* TIBCustomService.Destroy */ inline __fastcall virtual ~TIBControlService(void) { }
  242.     #pragma option pop
  243.     
  244. };
  245.  
  246.  
  247. class DELPHICLASS TIBControlAndQueryService;
  248. class PASCALIMPLEMENTATION TIBControlAndQueryService : public TIBControlService 
  249. {
  250.     typedef TIBControlService inherited;
  251.     
  252. private:
  253.     bool FEof;
  254.     int FAction;
  255.     void __fastcall SetAction(int Value);
  256.     
  257. protected:
  258.     __property int Action = {read=FAction, write=SetAction, nodefault};
  259.     
  260. public:
  261.     __fastcall virtual TIBControlAndQueryService(Classes::TComponent* AOwner);
  262.     AnsiString __fastcall GetNextLine();
  263.     AnsiString __fastcall GetNextChunk();
  264.     __property bool Eof = {read=FEof, nodefault};
  265.     
  266. __published:
  267.     __property BufferSize ;
  268. public:
  269.     #pragma option push -w-inl
  270.     /* TIBCustomService.Destroy */ inline __fastcall virtual ~TIBControlAndQueryService(void) { }
  271.     #pragma option pop
  272.     
  273. };
  274.  
  275.  
  276. #pragma option push -b-
  277. enum TShutdownMode { Forced, DenyTransaction, DenyAttachment };
  278. #pragma option pop
  279.  
  280. class DELPHICLASS TIBConfigService;
  281. class PASCALIMPLEMENTATION TIBConfigService : public TIBControlService 
  282. {
  283.     typedef TIBControlService inherited;
  284.     
  285. private:
  286.     AnsiString FDatabaseName;
  287.     void __fastcall SetDatabaseName(const AnsiString Value);
  288.     
  289. public:
  290.     virtual void __fastcall ServiceStart(void);
  291.     void __fastcall ShutdownDatabase(TShutdownMode Options, int Wait);
  292.     void __fastcall SetSweepInterval(int Value);
  293.     void __fastcall SetPageBuffers(int Value);
  294.     void __fastcall ActivateShadow(void);
  295.     void __fastcall BringDatabaseOnline(void);
  296.     void __fastcall SetReserveSpace(bool Value);
  297.     void __fastcall SetAsyncMode(bool Value);
  298.     void __fastcall SetReadOnly(bool Value);
  299.     
  300. __published:
  301.     __property AnsiString DatabaseName = {read=FDatabaseName, write=SetDatabaseName};
  302. public:
  303.     #pragma option push -w-inl
  304.     /* TIBControlService.Create */ inline __fastcall virtual TIBConfigService(Classes::TComponent* AOwner
  305.         ) : TIBControlService(AOwner) { }
  306.     #pragma option pop
  307.     
  308. public:
  309.     #pragma option push -w-inl
  310.     /* TIBCustomService.Destroy */ inline __fastcall virtual ~TIBConfigService(void) { }
  311.     #pragma option pop
  312.     
  313. };
  314.  
  315.  
  316. #pragma option push -b-
  317. enum TLicensingAction { LicenseAdd, LicenseRemove };
  318. #pragma option pop
  319.  
  320. class DELPHICLASS TIBLicensingService;
  321. class PASCALIMPLEMENTATION TIBLicensingService : public TIBControlService 
  322. {
  323.     typedef TIBControlService inherited;
  324.     
  325. private:
  326.     AnsiString FID;
  327.     AnsiString FKey;
  328.     TLicensingAction FAction;
  329.     void __fastcall SetAction(TLicensingAction Value);
  330.     
  331. protected:
  332.     virtual void __fastcall SetServiceStartOptions(void);
  333.     
  334. public:
  335.     void __fastcall AddLicense(void);
  336.     void __fastcall RemoveLicense(void);
  337.     
  338. __published:
  339.     __property TLicensingAction Action = {read=FAction, write=SetAction, default=0};
  340.     __property AnsiString Key = {read=FKey, write=FKey};
  341.     __property AnsiString ID = {read=FID, write=FID};
  342. public:
  343.     #pragma option push -w-inl
  344.     /* TIBControlService.Create */ inline __fastcall virtual TIBLicensingService(Classes::TComponent* AOwner
  345.         ) : TIBControlService(AOwner) { }
  346.     #pragma option pop
  347.     
  348. public:
  349.     #pragma option push -w-inl
  350.     /* TIBCustomService.Destroy */ inline __fastcall virtual ~TIBLicensingService(void) { }
  351.     #pragma option pop
  352.     
  353. };
  354.  
  355.  
  356. class DELPHICLASS TIBLogService;
  357. class PASCALIMPLEMENTATION TIBLogService : public TIBControlAndQueryService 
  358. {
  359.     typedef TIBControlAndQueryService inherited;
  360.     
  361. protected:
  362.     virtual void __fastcall SetServiceStartOptions(void);
  363. public:
  364.     #pragma option push -w-inl
  365.     /* TIBControlAndQueryService.create */ inline __fastcall virtual TIBLogService(Classes::TComponent* 
  366.         AOwner) : TIBControlAndQueryService(AOwner) { }
  367.     #pragma option pop
  368.     
  369. public:
  370.     #pragma option push -w-inl
  371.     /* TIBCustomService.Destroy */ inline __fastcall virtual ~TIBLogService(void) { }
  372.     #pragma option pop
  373.     
  374. };
  375.  
  376.  
  377. #pragma option push -b-
  378. enum TStatOption { DataPages, DbLog, HeaderPages, IndexPages, SystemRelations };
  379. #pragma option pop
  380.  
  381. typedef Set<TStatOption, DataPages, SystemRelations>  TStatOptions;
  382.  
  383. class DELPHICLASS TIBStatisticalService;
  384. class PASCALIMPLEMENTATION TIBStatisticalService : public TIBControlAndQueryService 
  385. {
  386.     typedef TIBControlAndQueryService inherited;
  387.     
  388. private:
  389.     AnsiString FDatabaseName;
  390.     TStatOptions FOptions;
  391.     void __fastcall SetDatabaseName(const AnsiString Value);
  392.     
  393. protected:
  394.     virtual void __fastcall SetServiceStartOptions(void);
  395.     
  396. __published:
  397.     __property AnsiString DatabaseName = {read=FDatabaseName, write=SetDatabaseName};
  398.     __property TStatOptions Options = {read=FOptions, write=FOptions, nodefault};
  399. public:
  400.     #pragma option push -w-inl
  401.     /* TIBControlAndQueryService.create */ inline __fastcall virtual TIBStatisticalService(Classes::TComponent* 
  402.         AOwner) : TIBControlAndQueryService(AOwner) { }
  403.     #pragma option pop
  404.     
  405. public:
  406.     #pragma option push -w-inl
  407.     /* TIBCustomService.Destroy */ inline __fastcall virtual ~TIBStatisticalService(void) { }
  408.     #pragma option pop
  409.     
  410. };
  411.  
  412.  
  413. class DELPHICLASS TIBBackupRestoreService;
  414. class PASCALIMPLEMENTATION TIBBackupRestoreService : public TIBControlAndQueryService 
  415. {
  416.     typedef TIBControlAndQueryService inherited;
  417.     
  418. private:
  419.     bool FVerbose;
  420.     AnsiString FSQLRole;
  421.     
  422. __published:
  423.     __property AnsiString SQLRole = {read=FSQLRole, write=FSQLRole};
  424.     __property bool Verbose = {read=FVerbose, write=FVerbose, default=0};
  425. public:
  426.     #pragma option push -w-inl
  427.     /* TIBControlAndQueryService.create */ inline __fastcall virtual TIBBackupRestoreService(Classes::TComponent* 
  428.         AOwner) : TIBControlAndQueryService(AOwner) { }
  429.     #pragma option pop
  430.     
  431. public:
  432.     #pragma option push -w-inl
  433.     /* TIBCustomService.Destroy */ inline __fastcall virtual ~TIBBackupRestoreService(void) { }
  434.     #pragma option pop
  435.     
  436. };
  437.  
  438.  
  439. #pragma option push -b-
  440. enum TBackupOption { IgnoreChecksums, IgnoreLimbo, MetadataOnly, NoGarbageCollection, OldMetadataDesc, 
  441.     NonTransportable, ConvertExtTables };
  442. #pragma option pop
  443.  
  444. typedef Set<TBackupOption, IgnoreChecksums, ConvertExtTables>  TBackupOptions;
  445.  
  446. class DELPHICLASS TIBBackupService;
  447. class PASCALIMPLEMENTATION TIBBackupService : public TIBBackupRestoreService 
  448. {
  449.     typedef TIBBackupRestoreService inherited;
  450.     
  451. private:
  452.     AnsiString FDatabaseName;
  453.     TBackupOptions FOptions;
  454.     Classes::TStrings* FBackupFile;
  455.     int FBlockingFactor;
  456.     
  457. protected:
  458.     virtual void __fastcall SetServiceStartOptions(void);
  459.     
  460. public:
  461.     __fastcall virtual TIBBackupService(Classes::TComponent* AOwner);
  462.     __fastcall virtual ~TIBBackupService(void);
  463.     
  464. __published:
  465.     __property Classes::TStrings* BackupFile = {read=FBackupFile, write=FBackupFile};
  466.     __property int BlockingFactor = {read=FBlockingFactor, write=FBlockingFactor, nodefault};
  467.     __property AnsiString DatabaseName = {read=FDatabaseName, write=FDatabaseName};
  468.     __property TBackupOptions Options = {read=FOptions, write=FOptions, nodefault};
  469. };
  470.  
  471.  
  472. #pragma option push -b-
  473. enum TRestoreOption { DeactivateIndexes, NoShadow, NoValidityCheck, OneRelationAtATime, Replace, CreateNewDB, 
  474.     UseAllSpace };
  475. #pragma option pop
  476.  
  477. typedef Set<TRestoreOption, DeactivateIndexes, UseAllSpace>  TRestoreOptions;
  478.  
  479. class DELPHICLASS TIBRestoreService;
  480. class PASCALIMPLEMENTATION TIBRestoreService : public TIBBackupRestoreService 
  481. {
  482.     typedef TIBBackupRestoreService inherited;
  483.     
  484. private:
  485.     Classes::TStrings* FDatabaseName;
  486.     Classes::TStrings* FBackupFile;
  487.     TRestoreOptions FOptions;
  488.     int FPageSize;
  489.     int FPageBuffers;
  490.     
  491. protected:
  492.     virtual void __fastcall SetServiceStartOptions(void);
  493.     
  494. public:
  495.     __fastcall virtual TIBRestoreService(Classes::TComponent* AOwner);
  496.     __fastcall virtual ~TIBRestoreService(void);
  497.     
  498. __published:
  499.     __property Classes::TStrings* DatabaseName = {read=FDatabaseName, write=FDatabaseName};
  500.     __property Classes::TStrings* BackupFile = {read=FBackupFile, write=FBackupFile};
  501.     __property int PageSize = {read=FPageSize, write=FPageSize, nodefault};
  502.     __property int PageBuffers = {read=FPageBuffers, write=FPageBuffers, nodefault};
  503.     __property TRestoreOptions Options = {read=FOptions, write=FOptions, default=32};
  504. };
  505.  
  506.  
  507. #pragma option push -b-
  508. enum TValidateOption { LimboTransactions, CheckDB, IgnoreChecksum, KillShadows, MendDB, SweepDB, ValidateDB, 
  509.     ValidateFull };
  510. #pragma option pop
  511.  
  512. typedef Set<TValidateOption, LimboTransactions, ValidateFull>  TValidateOptions;
  513.  
  514. #pragma option push -b-
  515. enum TTransactionGlobalAction { CommitGlobal, RollbackGlobal, RecoverTwoPhaseGlobal, NoGlobalAction 
  516.     };
  517. #pragma option pop
  518.  
  519. #pragma option push -b-
  520. enum TTransactionState { LimboState, CommitState, RollbackState, UnknownState };
  521. #pragma option pop
  522.  
  523. #pragma option push -b-
  524. enum TTransactionAdvise { CommitAdvise, RollbackAdvise, UnknownAdvise };
  525. #pragma option pop
  526.  
  527. #pragma option push -b-
  528. enum TTransactionAction { CommitAction, RollbackAction };
  529. #pragma option pop
  530.  
  531. struct TLimboTransactionInfo
  532. {
  533.     bool MultiDatabase;
  534.     int ID;
  535.     AnsiString HostSite;
  536.     AnsiString RemoteSite;
  537.     AnsiString RemoteDatabasePath;
  538.     TTransactionState State;
  539.     TTransactionAdvise Advise;
  540.     TTransactionAction Action;
  541. } ;
  542.  
  543. typedef DynamicArray<TLimboTransactionInfo >  IBServices__12;
  544.  
  545. class DELPHICLASS TIBValidationService;
  546. class PASCALIMPLEMENTATION TIBValidationService : public TIBControlAndQueryService 
  547. {
  548.     typedef TIBControlAndQueryService inherited;
  549.     
  550. private:
  551.     AnsiString FDatabaseName;
  552.     TValidateOptions FOptions;
  553.     DynamicArray<TLimboTransactionInfo >  FLimboTransactionInfo;
  554.     TTransactionGlobalAction FGlobalAction;
  555.     void __fastcall SetDatabaseName(const AnsiString Value);
  556.     TLimboTransactionInfo __fastcall GetLimboTransactionInfo(int index);
  557.     
  558. protected:
  559.     virtual void __fastcall SetServiceStartOptions(void);
  560.     
  561. public:
  562.     __fastcall virtual TIBValidationService(Classes::TComponent* AOwner);
  563.     __fastcall virtual ~TIBValidationService(void);
  564.     void __fastcall FetchLimboTransactionInfo(void);
  565.     void __fastcall FixLimboTransactionErrors(void);
  566.     __property TLimboTransactionInfo LimboTransactionInfo[int Index] = {read=GetLimboTransactionInfo};
  567.     
  568. __published:
  569.     __property AnsiString DatabaseName = {read=FDatabaseName, write=SetDatabaseName};
  570.     __property TValidateOptions Options = {read=FOptions, write=FOptions, nodefault};
  571.     __property TTransactionGlobalAction GlobalAction = {read=FGlobalAction, write=FGlobalAction, nodefault
  572.         };
  573. };
  574.  
  575.  
  576. struct TUserInfo
  577. {
  578.     AnsiString UserName;
  579.     AnsiString FirstName;
  580.     AnsiString MiddleName;
  581.     AnsiString LastName;
  582.     int GroupID;
  583.     int UserID;
  584. } ;
  585.  
  586. #pragma option push -b-
  587. enum TSecurityAction { ActionAddUser, ActionDeleteUser, ActionModifyUser, ActionDisplayUser };
  588. #pragma option pop
  589.  
  590. #pragma option push -b-
  591. enum TSecurityModifyParam { ModifyFirstName, ModifyMiddleName, ModifyLastName, ModifyUserId, ModifyGroupId, 
  592.     ModifyGroupName, ModifyPassword };
  593. #pragma option pop
  594.  
  595. typedef Set<TSecurityModifyParam, ModifyFirstName, ModifyPassword>  TSecurityModifyParams;
  596.  
  597. typedef DynamicArray<TUserInfo >  IBServices__32;
  598.  
  599. class DELPHICLASS TIBSecurityService;
  600. class PASCALIMPLEMENTATION TIBSecurityService : public TIBControlAndQueryService 
  601. {
  602.     typedef TIBControlAndQueryService inherited;
  603.     
  604. private:
  605.     int FUserID;
  606.     int FGroupID;
  607.     AnsiString FFirstName;
  608.     AnsiString FGroupName;
  609.     AnsiString FUserName;
  610.     AnsiString FPassword;
  611.     AnsiString FSQLRole;
  612.     AnsiString FLastName;
  613.     AnsiString FMiddleName;
  614.     DynamicArray<TUserInfo >  FUserInfo;
  615.     TSecurityAction FSecurityAction;
  616.     TSecurityModifyParams FModifyParams;
  617.     void __fastcall ClearParams(void);
  618.     void __fastcall SetSecurityAction(TSecurityAction Value);
  619.     void __fastcall SetFirstName(AnsiString Value);
  620.     void __fastcall SetMiddleName(AnsiString Value);
  621.     void __fastcall SetLastName(AnsiString Value);
  622.     void __fastcall SetGroupName(AnsiString Value);
  623.     void __fastcall SetPassword(AnsiString Value);
  624.     void __fastcall SetUserId(int Value);
  625.     void __fastcall SetGroupId(int Value);
  626.     void __fastcall FetchUserInfo(void);
  627.     TUserInfo __fastcall GetUserInfo(int Index);
  628.     
  629. protected:
  630.     virtual void __fastcall SetServiceStartOptions(void);
  631.     
  632. public:
  633.     __fastcall virtual TIBSecurityService(Classes::TComponent* AOwner);
  634.     __fastcall virtual ~TIBSecurityService(void);
  635.     void __fastcall DisplayUsers(void);
  636.     void __fastcall DisplayUser(AnsiString UserName);
  637.     void __fastcall AddUser(void);
  638.     void __fastcall DeleteUser(void);
  639.     void __fastcall ModifyUser(void);
  640.     __property TUserInfo UserInfo[int Index] = {read=GetUserInfo};
  641.     
  642. __published:
  643.     __property TSecurityAction SecurityAction = {read=FSecurityAction, write=SetSecurityAction, nodefault
  644.         };
  645.     __property AnsiString SQlRole = {read=FSQLRole, write=FSQLRole};
  646.     __property AnsiString UserName = {read=FUserName, write=FUserName};
  647.     __property AnsiString FirstName = {read=FFirstName, write=SetFirstName};
  648.     __property AnsiString MiddleName = {read=FMiddleName, write=SetMiddleName};
  649.     __property AnsiString LastName = {read=FLastName, write=SetLastName};
  650.     __property int UserID = {read=FUserID, write=SetUserId, nodefault};
  651.     __property AnsiString GroupName = {read=FGroupName, write=SetGroupName};
  652.     __property int GroupID = {read=FGroupID, write=SetGroupId, nodefault};
  653.     __property AnsiString Password = {read=FPassword, write=SetPassword};
  654. };
  655.  
  656.  
  657. //-- var, const, procedure ---------------------------------------------------
  658. static const Word DefaultBufferSize = 0x7d00;
  659. #define SPBPrefix "isc_spb_"
  660. extern PACKAGE AnsiString SPBConstantNames[12];
  661. extern PACKAGE int SPBConstantValues[12];
  662.  
  663. }    /* namespace Ibservices */
  664. #if !defined(NO_IMPLICIT_NAMESPACE_USE)
  665. using namespace Ibservices;
  666. #endif
  667. #pragma option pop    // -w-
  668. #pragma option pop    // -Vx
  669.  
  670. #pragma delphiheader end.
  671. //-- end unit ----------------------------------------------------------------
  672. #endif    // IBServices
  673.