home *** CD-ROM | disk | FTP | other *** search
/ Magazyn Internet 2000 May / MICD_2000_05.iso / CBuilder5 / INSTALL / DATA1.CAB / Program_Built_Files / Include / Vcl / mxarrays.hpp < prev    next >
C/C++ Source or Header  |  2000-02-01  |  24KB  |  652 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) 'mxarrays.pas' rev: 5.00
  6.  
  7. #ifndef mxarraysHPP
  8. #define mxarraysHPP
  9.  
  10. #pragma delphiheader begin
  11. #pragma option push -w-
  12. #pragma option push -Vx
  13. #include <mxConsts.hpp>    // Pascal unit
  14. #include <Classes.hpp>    // Pascal unit
  15. #include <Windows.hpp>    // Pascal unit
  16. #include <SysUtils.hpp>    // Pascal unit
  17. #include <SysInit.hpp>    // Pascal unit
  18. #include <System.hpp>    // Pascal unit
  19.  
  20. //-- user supplied -----------------------------------------------------------
  21.  
  22. namespace Mxarrays
  23. {
  24. //-- type declarations -------------------------------------------------------
  25. class DELPHICLASS EArrayError;
  26. class PASCALIMPLEMENTATION EArrayError : public Sysutils::Exception 
  27. {
  28.     typedef Sysutils::Exception inherited;
  29.     
  30. public:
  31.     #pragma option push -w-inl
  32.     /* Exception.Create */ inline __fastcall EArrayError(const AnsiString Msg) : Sysutils::Exception(Msg
  33.         ) { }
  34.     #pragma option pop
  35.     #pragma option push -w-inl
  36.     /* Exception.CreateFmt */ inline __fastcall EArrayError(const AnsiString Msg, const System::TVarRec 
  37.         * Args, const int Args_Size) : Sysutils::Exception(Msg, Args, Args_Size) { }
  38.     #pragma option pop
  39.     #pragma option push -w-inl
  40.     /* Exception.CreateRes */ inline __fastcall EArrayError(int Ident)/* overload */ : Sysutils::Exception(
  41.         Ident) { }
  42.     #pragma option pop
  43.     #pragma option push -w-inl
  44.     /* Exception.CreateResFmt */ inline __fastcall EArrayError(int Ident, const System::TVarRec * Args, 
  45.         const int Args_Size)/* overload */ : Sysutils::Exception(Ident, Args, Args_Size) { }
  46.     #pragma option pop
  47.     #pragma option push -w-inl
  48.     /* Exception.CreateHelp */ inline __fastcall EArrayError(const AnsiString Msg, int AHelpContext) : 
  49.         Sysutils::Exception(Msg, AHelpContext) { }
  50.     #pragma option pop
  51.     #pragma option push -w-inl
  52.     /* Exception.CreateFmtHelp */ inline __fastcall EArrayError(const AnsiString Msg, const System::TVarRec 
  53.         * Args, const int Args_Size, int AHelpContext) : Sysutils::Exception(Msg, Args, Args_Size, AHelpContext
  54.         ) { }
  55.     #pragma option pop
  56.     #pragma option push -w-inl
  57.     /* Exception.CreateResHelp */ inline __fastcall EArrayError(int Ident, int AHelpContext)/* overload */
  58.          : Sysutils::Exception(Ident, AHelpContext) { }
  59.     #pragma option pop
  60.     #pragma option push -w-inl
  61.     /* Exception.CreateResFmtHelp */ inline __fastcall EArrayError(System::PResStringRec ResStringRec, 
  62.         const System::TVarRec * Args, const int Args_Size, int AHelpContext)/* overload */ : Sysutils::Exception(
  63.         ResStringRec, Args, Args_Size, AHelpContext) { }
  64.     #pragma option pop
  65.     
  66. public:
  67.     #pragma option push -w-inl
  68.     /* TObject.Destroy */ inline __fastcall virtual ~EArrayError(void) { }
  69.     #pragma option pop
  70.     
  71. };
  72.  
  73.  
  74. class DELPHICLASS EUnsupportedTypeError;
  75. class PASCALIMPLEMENTATION EUnsupportedTypeError : public Sysutils::Exception 
  76. {
  77.     typedef Sysutils::Exception inherited;
  78.     
  79. public:
  80.     #pragma option push -w-inl
  81.     /* Exception.Create */ inline __fastcall EUnsupportedTypeError(const AnsiString Msg) : Sysutils::Exception(
  82.         Msg) { }
  83.     #pragma option pop
  84.     #pragma option push -w-inl
  85.     /* Exception.CreateFmt */ inline __fastcall EUnsupportedTypeError(const AnsiString Msg, const System::TVarRec 
  86.         * Args, const int Args_Size) : Sysutils::Exception(Msg, Args, Args_Size) { }
  87.     #pragma option pop
  88.     #pragma option push -w-inl
  89.     /* Exception.CreateRes */ inline __fastcall EUnsupportedTypeError(int Ident)/* overload */ : Sysutils::Exception(
  90.         Ident) { }
  91.     #pragma option pop
  92.     #pragma option push -w-inl
  93.     /* Exception.CreateResFmt */ inline __fastcall EUnsupportedTypeError(int Ident, const System::TVarRec 
  94.         * Args, const int Args_Size)/* overload */ : Sysutils::Exception(Ident, Args, Args_Size) { }
  95.     #pragma option pop
  96.     #pragma option push -w-inl
  97.     /* Exception.CreateHelp */ inline __fastcall EUnsupportedTypeError(const AnsiString Msg, int AHelpContext
  98.         ) : Sysutils::Exception(Msg, AHelpContext) { }
  99.     #pragma option pop
  100.     #pragma option push -w-inl
  101.     /* Exception.CreateFmtHelp */ inline __fastcall EUnsupportedTypeError(const AnsiString Msg, const System::TVarRec 
  102.         * Args, const int Args_Size, int AHelpContext) : Sysutils::Exception(Msg, Args, Args_Size, AHelpContext
  103.         ) { }
  104.     #pragma option pop
  105.     #pragma option push -w-inl
  106.     /* Exception.CreateResHelp */ inline __fastcall EUnsupportedTypeError(int Ident, int AHelpContext)/* overload */
  107.          : Sysutils::Exception(Ident, AHelpContext) { }
  108.     #pragma option pop
  109.     #pragma option push -w-inl
  110.     /* Exception.CreateResFmtHelp */ inline __fastcall EUnsupportedTypeError(System::PResStringRec ResStringRec
  111.         , const System::TVarRec * Args, const int Args_Size, int AHelpContext)/* overload */ : Sysutils::Exception(
  112.         ResStringRec, Args, Args_Size, AHelpContext) { }
  113.     #pragma option pop
  114.     
  115. public:
  116.     #pragma option push -w-inl
  117.     /* TObject.Destroy */ inline __fastcall virtual ~EUnsupportedTypeError(void) { }
  118.     #pragma option pop
  119.     
  120. };
  121.  
  122.  
  123. class DELPHICLASS ELowCapacityError;
  124. class PASCALIMPLEMENTATION ELowCapacityError : public Sysutils::Exception 
  125. {
  126.     typedef Sysutils::Exception inherited;
  127.     
  128. public:
  129.     #pragma option push -w-inl
  130.     /* Exception.Create */ inline __fastcall ELowCapacityError(const AnsiString Msg) : Sysutils::Exception(
  131.         Msg) { }
  132.     #pragma option pop
  133.     #pragma option push -w-inl
  134.     /* Exception.CreateFmt */ inline __fastcall ELowCapacityError(const AnsiString Msg, const System::TVarRec 
  135.         * Args, const int Args_Size) : Sysutils::Exception(Msg, Args, Args_Size) { }
  136.     #pragma option pop
  137.     #pragma option push -w-inl
  138.     /* Exception.CreateRes */ inline __fastcall ELowCapacityError(int Ident)/* overload */ : Sysutils::Exception(
  139.         Ident) { }
  140.     #pragma option pop
  141.     #pragma option push -w-inl
  142.     /* Exception.CreateResFmt */ inline __fastcall ELowCapacityError(int Ident, const System::TVarRec * 
  143.         Args, const int Args_Size)/* overload */ : Sysutils::Exception(Ident, Args, Args_Size) { }
  144.     #pragma option pop
  145.     #pragma option push -w-inl
  146.     /* Exception.CreateHelp */ inline __fastcall ELowCapacityError(const AnsiString Msg, int AHelpContext
  147.         ) : Sysutils::Exception(Msg, AHelpContext) { }
  148.     #pragma option pop
  149.     #pragma option push -w-inl
  150.     /* Exception.CreateFmtHelp */ inline __fastcall ELowCapacityError(const AnsiString Msg, const System::TVarRec 
  151.         * Args, const int Args_Size, int AHelpContext) : Sysutils::Exception(Msg, Args, Args_Size, AHelpContext
  152.         ) { }
  153.     #pragma option pop
  154.     #pragma option push -w-inl
  155.     /* Exception.CreateResHelp */ inline __fastcall ELowCapacityError(int Ident, int AHelpContext)/* overload */
  156.          : Sysutils::Exception(Ident, AHelpContext) { }
  157.     #pragma option pop
  158.     #pragma option push -w-inl
  159.     /* Exception.CreateResFmtHelp */ inline __fastcall ELowCapacityError(System::PResStringRec ResStringRec
  160.         , const System::TVarRec * Args, const int Args_Size, int AHelpContext)/* overload */ : Sysutils::Exception(
  161.         ResStringRec, Args, Args_Size, AHelpContext) { }
  162.     #pragma option pop
  163.     
  164. public:
  165.     #pragma option push -w-inl
  166.     /* TObject.Destroy */ inline __fastcall virtual ~ELowCapacityError(void) { }
  167.     #pragma option pop
  168.     
  169. };
  170.  
  171.  
  172. typedef int __fastcall (*TCompareProc)(void *item1, void *item2);
  173.  
  174. #pragma option push -b-
  175. enum TSortOrder { tsNone, tsAscending, tsDescending };
  176. #pragma option pop
  177.  
  178. #pragma option push -b-
  179. enum TArrayFlags { afOwnsData, afAutoSize, afCanCompare, afSortUnique };
  180. #pragma option pop
  181.  
  182. typedef Set<TArrayFlags, afOwnsData, afSortUnique>  TArrayFlagSet;
  183.  
  184. #pragma option push -b-
  185. enum TDuplicates { dupIgnore, dupAccept, dupError };
  186. #pragma option pop
  187.  
  188. struct TStringItem
  189. {
  190.     AnsiString FString;
  191.     System::TObject* FObject;
  192. } ;
  193.  
  194. class DELPHICLASS TBaseArray;
  195. class PASCALIMPLEMENTATION TBaseArray : public Classes::TPersistent 
  196. {
  197.     typedef Classes::TPersistent inherited;
  198.     
  199. private:
  200.     void *FMemory;
  201.     int FCapacity;
  202.     int FItemSize;
  203.     int FCount;
  204.     TSortOrder FSortOrder;
  205.     TArrayFlagSet FFlags;
  206.     TDuplicates FDuplicates;
  207.     TCompareProc FCompProc;
  208.     void * __fastcall GetItemPtr(int index);
  209.     void __fastcall CopyFrom(int toIndex, int numItems, void *Source);
  210.     void __fastcall SetCount(int NewCount);
  211.     int __fastcall GetLimit(void);
  212.     
  213. protected:
  214.     bool __fastcall ValidIndex(int Index);
  215.     bool __fastcall HasFlag(TArrayFlags aFlag);
  216.     void __fastcall SetFlag(TArrayFlags aFlag);
  217.     void __fastcall ClearFlag(TArrayFlags aFlag);
  218.     void __fastcall SetAutoSize(bool aSize);
  219.     void __fastcall BlockCopy(TBaseArray* Source, int fromIndex, int toIndex, int numitems);
  220.     bool __fastcall GetAutoSize(void);
  221.     bool __fastcall ValidateBounds(int atIndex, int &numItems);
  222.     void __fastcall RemoveRange(int atIndex, int numItems);
  223.     void __fastcall InternalHandleException(void);
  224.     virtual void __fastcall InvalidateItems(int atIndex, int numItems);
  225.     virtual void __fastcall SetCapacity(int NewCapacity);
  226.     virtual void __fastcall Grow(void);
  227.     
  228. public:
  229.     __fastcall virtual TBaseArray(int itemcount, int iSize);
  230.     __fastcall virtual ~TBaseArray(void);
  231.     void __fastcall Clear(void);
  232.     void __fastcall InsertAt(int Index, void *Value);
  233.     virtual void __fastcall Insert(int Index, void *Value);
  234.     void __fastcall PutItem(int index, void *Value);
  235.     void __fastcall GetItem(int index, void *Value);
  236.     void __fastcall RemoveItem(int Index);
  237.     virtual void __fastcall Delete(int Index);
  238.     virtual void __fastcall Exchange(int Index1, int Index2);
  239.     virtual int __fastcall IndexOf(void *Item);
  240.     bool __fastcall FindItem(int &Index, void *Value);
  241.     virtual void __fastcall Sort(TCompareProc Compare);
  242.     __property TCompareProc CompareProc = {read=FCompProc, write=FCompProc};
  243.     __property TDuplicates Duplicates = {read=FDuplicates, write=FDuplicates, nodefault};
  244.     __property TSortOrder SortOrder = {read=FSortOrder, write=FSortOrder, nodefault};
  245.     __property int Capacity = {read=FCapacity, write=SetCapacity, nodefault};
  246.     __property int Limit = {read=GetLimit, write=SetCapacity, nodefault};
  247.     __property int ItemSize = {read=FItemSize, nodefault};
  248.     __property bool AutoSize = {read=GetAutoSize, write=SetAutoSize, nodefault};
  249.     __property int Count = {read=FCount, write=SetCount, nodefault};
  250.     __property void * List = {read=FMemory};
  251. };
  252.  
  253.  
  254. class DELPHICLASS TSmallIntArray;
  255. class PASCALIMPLEMENTATION TSmallIntArray : public TBaseArray 
  256. {
  257.     typedef TBaseArray inherited;
  258.     
  259. public:
  260.     __fastcall virtual TSmallIntArray(int itemcount, int dummy);
  261.     HIDESBASE void __fastcall PutItem(int index, short value);
  262.     HIDESBASE short __fastcall GetItem(int index);
  263.     int __fastcall Add(short Value);
  264.     virtual void __fastcall Assign(Classes::TPersistent* Source);
  265.     __property short Items[int Index] = {read=GetItem, write=PutItem/*, default*/};
  266. public:
  267.     #pragma option push -w-inl
  268.     /* TBaseArray.Destroy */ inline __fastcall virtual ~TSmallIntArray(void) { }
  269.     #pragma option pop
  270.     
  271. };
  272.  
  273.  
  274. class DELPHICLASS TIntArray;
  275. class PASCALIMPLEMENTATION TIntArray : public TBaseArray 
  276. {
  277.     typedef TBaseArray inherited;
  278.     
  279. public:
  280.     __fastcall virtual TIntArray(int itemcount, int dummy);
  281.     HIDESBASE void __fastcall PutItem(int index, int value);
  282.     HIDESBASE int __fastcall GetItem(int index);
  283.     int __fastcall Add(int Value);
  284.     virtual void __fastcall Assign(Classes::TPersistent* Source);
  285.     bool __fastcall Find(int &Index, int Value);
  286.     __property int Items[int Index] = {read=GetItem, write=PutItem/*, default*/};
  287. public:
  288.     #pragma option push -w-inl
  289.     /* TBaseArray.Destroy */ inline __fastcall virtual ~TIntArray(void) { }
  290.     #pragma option pop
  291.     
  292. };
  293.  
  294.  
  295. class DELPHICLASS TSingleArray;
  296. class PASCALIMPLEMENTATION TSingleArray : public TBaseArray 
  297. {
  298.     typedef TBaseArray inherited;
  299.     
  300. public:
  301.     __fastcall virtual TSingleArray(int itemcount, int dummy);
  302.     HIDESBASE void __fastcall PutItem(int index, float value);
  303.     HIDESBASE float __fastcall GetItem(int index);
  304.     int __fastcall Add(float Value);
  305.     bool __fastcall Find(int &Index, float Value);
  306.     virtual int __fastcall IndexOf(void *Item);
  307.     virtual void __fastcall Assign(Classes::TPersistent* Source);
  308.     __property float Items[int Index] = {read=GetItem, write=PutItem/*, default*/};
  309. public:
  310.     #pragma option push -w-inl
  311.     /* TBaseArray.Destroy */ inline __fastcall virtual ~TSingleArray(void) { }
  312.     #pragma option pop
  313.     
  314. };
  315.  
  316.  
  317. class DELPHICLASS TDoubleArray;
  318. class PASCALIMPLEMENTATION TDoubleArray : public TBaseArray 
  319. {
  320.     typedef TBaseArray inherited;
  321.     
  322. public:
  323.     __fastcall virtual TDoubleArray(int itemcount, int dummy);
  324.     HIDESBASE void __fastcall PutItem(int index, double value);
  325.     HIDESBASE double __fastcall GetItem(int index);
  326.     int __fastcall Add(double Value);
  327.     bool __fastcall Find(int &Index, double Value);
  328.     virtual int __fastcall IndexOf(void *Item);
  329.     virtual void __fastcall Assign(Classes::TPersistent* Source);
  330.     __property double Items[int Index] = {read=GetItem, write=PutItem/*, default*/};
  331. public:
  332.     #pragma option push -w-inl
  333.     /* TBaseArray.Destroy */ inline __fastcall virtual ~TDoubleArray(void) { }
  334.     #pragma option pop
  335.     
  336. };
  337.  
  338.  
  339. class DELPHICLASS TCurrencyArray;
  340. class PASCALIMPLEMENTATION TCurrencyArray : public TBaseArray 
  341. {
  342.     typedef TBaseArray inherited;
  343.     
  344. public:
  345.     __fastcall virtual TCurrencyArray(int itemcount, int dummy);
  346.     HIDESBASE void __fastcall PutItem(int index, System::Currency value);
  347.     HIDESBASE System::Currency __fastcall GetItem(int index);
  348.     int __fastcall Add(System::Currency Value);
  349.     bool __fastcall Find(int &Index, System::Currency Value);
  350.     virtual int __fastcall IndexOf(void *Item);
  351.     virtual void __fastcall Assign(Classes::TPersistent* Source);
  352.     __property System::Currency Items[int Index] = {read=GetItem, write=PutItem/*, default*/};
  353. public:
  354.     #pragma option push -w-inl
  355.     /* TBaseArray.Destroy */ inline __fastcall virtual ~TCurrencyArray(void) { }
  356.     #pragma option pop
  357.     
  358. };
  359.  
  360.  
  361. class DELPHICLASS TWordArray;
  362. class PASCALIMPLEMENTATION TWordArray : public TBaseArray 
  363. {
  364.     typedef TBaseArray inherited;
  365.     
  366. public:
  367.     __fastcall virtual TWordArray(int itemcount, int dummy);
  368.     HIDESBASE void __fastcall PutItem(int index, Word value);
  369.     HIDESBASE Word __fastcall GetItem(int index);
  370.     int __fastcall Add(Word Value);
  371.     bool __fastcall Find(int &Index, Word Value);
  372.     virtual int __fastcall IndexOf(void *Item);
  373.     virtual void __fastcall Assign(Classes::TPersistent* Source);
  374.     __property Word Items[int Index] = {read=GetItem, write=PutItem/*, default*/};
  375. public:
  376.     #pragma option push -w-inl
  377.     /* TBaseArray.Destroy */ inline __fastcall virtual ~TWordArray(void) { }
  378.     #pragma option pop
  379.     
  380. };
  381.  
  382.  
  383. class DELPHICLASS TPointerArray;
  384. class PASCALIMPLEMENTATION TPointerArray : public TBaseArray 
  385. {
  386.     typedef TBaseArray inherited;
  387.     
  388. public:
  389.     __fastcall virtual TPointerArray(int itemcount, int dummy);
  390.     void __fastcall PutData(int index, void * value);
  391.     void * __fastcall GetData(int index);
  392.     HIDESBASE void __fastcall CopyFrom(void *Source, int toIndex, int numItems);
  393.     void __fastcall CopyTo(void *Dest, int fromIndex, int numItems);
  394.     virtual void __fastcall InvalidateItems(int atIndex, int numItems);
  395.     virtual void * __fastcall CloneItem(void * item);
  396.     virtual void __fastcall FreeItem(void * item);
  397.     __property void * AsPtr[int Index] = {read=GetData, write=PutData};
  398.     __property void * Data[int Index] = {read=GetData, write=PutData};
  399. public:
  400.     #pragma option push -w-inl
  401.     /* TBaseArray.Destroy */ inline __fastcall virtual ~TPointerArray(void) { }
  402.     #pragma option pop
  403.     
  404. };
  405.  
  406.  
  407. class DELPHICLASS TStringArray;
  408. class PASCALIMPLEMENTATION TStringArray : public TBaseArray 
  409. {
  410.     typedef TBaseArray inherited;
  411.     
  412. private:
  413.     void __fastcall ExchangeItems(int Index1, int Index2);
  414.     void __fastcall QuickSort(int L, int R);
  415.     void __fastcall InsertItem(int Index, const AnsiString S);
  416.     void __fastcall AddStrings(TStringArray* Strings);
  417.     
  418. protected:
  419.     AnsiString __fastcall GetString(int Index);
  420.     void __fastcall PutString(int Index, const AnsiString S);
  421.     System::TObject* __fastcall GetObject(int Index);
  422.     void __fastcall PutObject(int Index, System::TObject* AObject);
  423.     virtual void __fastcall InvalidateItems(int atIndex, int numItems);
  424.     virtual void __fastcall Grow(void);
  425.     
  426. public:
  427.     __fastcall virtual TStringArray(int itemcount, int dummy);
  428.     int __fastcall Add(const AnsiString S);
  429.     virtual void __fastcall Assign(Classes::TPersistent* Source);
  430.     virtual void __fastcall Exchange(int Index1, int Index2);
  431.     bool __fastcall Find(AnsiString S, int &Index);
  432.     virtual int __fastcall IndexOf(void *Item);
  433.     virtual void __fastcall Sort(TCompareProc Compare);
  434.     virtual void __fastcall Insert(int Index, void *Value);
  435.     __property AnsiString Strings[int Index] = {read=GetString, write=PutString/*, default*/};
  436. public:
  437.     #pragma option push -w-inl
  438.     /* TBaseArray.Destroy */ inline __fastcall virtual ~TStringArray(void) { }
  439.     #pragma option pop
  440.     
  441. };
  442.  
  443.  
  444. typedef int TMatrixNDX;
  445.  
  446. typedef int TDynArrayNDX;
  447.  
  448. typedef TSmallIntArray* TMatrixElements[536870911];
  449.  
  450. typedef TSmallIntArray* *PMatrixElements;
  451.  
  452. class DELPHICLASS EDynArrayRangeError;
  453. class PASCALIMPLEMENTATION EDynArrayRangeError : public Sysutils::ERangeError 
  454. {
  455.     typedef Sysutils::ERangeError inherited;
  456.     
  457. public:
  458.     #pragma option push -w-inl
  459.     /* Exception.Create */ inline __fastcall EDynArrayRangeError(const AnsiString Msg) : Sysutils::ERangeError(
  460.         Msg) { }
  461.     #pragma option pop
  462.     #pragma option push -w-inl
  463.     /* Exception.CreateFmt */ inline __fastcall EDynArrayRangeError(const AnsiString Msg, const System::TVarRec 
  464.         * Args, const int Args_Size) : Sysutils::ERangeError(Msg, Args, Args_Size) { }
  465.     #pragma option pop
  466.     #pragma option push -w-inl
  467.     /* Exception.CreateRes */ inline __fastcall EDynArrayRangeError(int Ident)/* overload */ : Sysutils::ERangeError(
  468.         Ident) { }
  469.     #pragma option pop
  470.     #pragma option push -w-inl
  471.     /* Exception.CreateResFmt */ inline __fastcall EDynArrayRangeError(int Ident, const System::TVarRec 
  472.         * Args, const int Args_Size)/* overload */ : Sysutils::ERangeError(Ident, Args, Args_Size) { }
  473.     #pragma option pop
  474.     #pragma option push -w-inl
  475.     /* Exception.CreateHelp */ inline __fastcall EDynArrayRangeError(const AnsiString Msg, int AHelpContext
  476.         ) : Sysutils::ERangeError(Msg, AHelpContext) { }
  477.     #pragma option pop
  478.     #pragma option push -w-inl
  479.     /* Exception.CreateFmtHelp */ inline __fastcall EDynArrayRangeError(const AnsiString Msg, const System::TVarRec 
  480.         * Args, const int Args_Size, int AHelpContext) : Sysutils::ERangeError(Msg, Args, Args_Size, AHelpContext
  481.         ) { }
  482.     #pragma option pop
  483.     #pragma option push -w-inl
  484.     /* Exception.CreateResHelp */ inline __fastcall EDynArrayRangeError(int Ident, int AHelpContext)/* overload */
  485.          : Sysutils::ERangeError(Ident, AHelpContext) { }
  486.     #pragma option pop
  487.     #pragma option push -w-inl
  488.     /* Exception.CreateResFmtHelp */ inline __fastcall EDynArrayRangeError(System::PResStringRec ResStringRec
  489.         , const System::TVarRec * Args, const int Args_Size, int AHelpContext)/* overload */ : Sysutils::ERangeError(
  490.         ResStringRec, Args, Args_Size, AHelpContext) { }
  491.     #pragma option pop
  492.     
  493. public:
  494.     #pragma option push -w-inl
  495.     /* TObject.Destroy */ inline __fastcall virtual ~EDynArrayRangeError(void) { }
  496.     #pragma option pop
  497.     
  498. };
  499.  
  500.  
  501. class DELPHICLASS TTwoDimArray;
  502. class PASCALIMPLEMENTATION TTwoDimArray : public System::TObject 
  503. {
  504.     typedef System::TObject inherited;
  505.     
  506. private:
  507.     TDynArrayNDX FRows;
  508.     TMatrixNDX FColumns;
  509.     int FMemAllocated;
  510.     short __fastcall GetElement(TDynArrayNDX row, TMatrixNDX column);
  511.     void __fastcall SetElement(TDynArrayNDX row, TMatrixNDX column, const short NewValue);
  512.     
  513. protected:
  514.     TSmallIntArray* *mtxElements;
  515.     
  516. public:
  517.     __fastcall TTwoDimArray(void);
  518.     __fastcall virtual ~TTwoDimArray(void);
  519.     void __fastcall SetSize(TDynArrayNDX NumRows, TMatrixNDX NumColumns);
  520.     __property TDynArrayNDX rows = {read=FRows, nodefault};
  521.     __property TMatrixNDX columns = {read=FColumns, nodefault};
  522.     __property short Element[TDynArrayNDX row][TMatrixNDX column] = {read=GetElement, write=SetElement/*
  523.         , default*/};
  524. };
  525.  
  526.  
  527. typedef int TIndexNDX;
  528.  
  529. typedef TSmallIntArray* TIndexElements[536870911];
  530.  
  531. typedef TSmallIntArray* *PIndexElements;
  532.  
  533. class DELPHICLASS TIndexArray;
  534. class PASCALIMPLEMENTATION TIndexArray : public System::TObject 
  535. {
  536.     typedef System::TObject inherited;
  537.     
  538. private:
  539.     int FMemAllocated;
  540.     int FCount;
  541.     TIndexNDX FCapacity;
  542.     bool FAutosize;
  543.     TSmallIntArray* __fastcall GetElement(TIndexNDX Element);
  544.     void __fastcall SetElement(TIndexNDX Element, const TSmallIntArray* NewValue);
  545.     
  546. protected:
  547.     TSmallIntArray* *idxElements;
  548.     
  549. public:
  550.     __fastcall TIndexArray(void);
  551.     __fastcall virtual ~TIndexArray(void);
  552.     void __fastcall SetSize(TIndexNDX Elements);
  553.     void __fastcall Expand(void);
  554.     int __fastcall Add(const TSmallIntArray* NewValue);
  555.     __property int MemoryUsage = {read=FMemAllocated, nodefault};
  556.     __property bool Autosize = {read=FAutosize, write=FAutosize, nodefault};
  557.     __property TIndexNDX Capacity = {read=FCapacity, write=SetSize, nodefault};
  558.     __property int Count = {read=FCount, nodefault};
  559.     __property TSmallIntArray* Items[TIndexNDX Element] = {read=GetElement, write=SetElement/*, default
  560.         */};
  561. };
  562.  
  563.  
  564. class DELPHICLASS TCustomArray;
  565. class PASCALIMPLEMENTATION TCustomArray : public System::TObject 
  566. {
  567.     typedef System::TObject inherited;
  568.     
  569. private:
  570.     int FDataType;
  571.     void *FArray;
  572.     AnsiString FBlankStringVal;
  573.     Variant FBlankDateVal;
  574.     Word FBlankBoolVal;
  575.     int FBlankCount;
  576.     void __fastcall UnsupportedTypeError(int vType);
  577.     
  578. protected:
  579.     Variant __fastcall GetItem(int Index);
  580.     void __fastcall SetItem(int Index, const Variant &Value);
  581.     TCompareProc __fastcall GetCompProc(void);
  582.     void __fastcall SetCompProc(TCompareProc Proc);
  583.     int __fastcall GetMemberCount(void);
  584.     bool __fastcall GetSort(void);
  585.     void __fastcall SetSort(bool Value);
  586.     TDuplicates __fastcall GetDups(void);
  587.     void __fastcall SetDups(TDuplicates Value);
  588.     
  589. public:
  590.     __fastcall TCustomArray(int Items, int VarType);
  591.     __fastcall virtual ~TCustomArray(void);
  592.     Variant __fastcall ConvertVar(const Variant &Value);
  593.     int __fastcall Add(const Variant &Value);
  594.     bool __fastcall IsBlank(int Index);
  595.     virtual int __fastcall MemoryUsage(void);
  596.     void __fastcall SetSize(int size);
  597.     int __fastcall IndexOf(const Variant &Value);
  598.     void __fastcall Assign(TCustomArray* Value, bool bSorted, bool bUnique);
  599.     double __fastcall GetDouble(int Index);
  600.     System::Currency __fastcall GetCurrency(int Index);
  601.     int __fastcall GetInteger(int Index);
  602.     __property void * List = {read=FArray};
  603.     __property TDuplicates Duplicates = {read=GetDups, write=SetDups, nodefault};
  604.     __property bool Sorted = {read=GetSort, write=SetSort, nodefault};
  605.     __property AnsiString BlankStringVal = {read=FBlankStringVal, write=FBlankStringVal};
  606.     __property Variant BlankDateVal = {read=FBlankDateVal, write=FBlankDateVal};
  607.     __property Word BlankBoolVal = {read=FBlankBoolVal, write=FBlankBoolVal, nodefault};
  608.     __property TCompareProc CompareProc = {read=GetCompProc, write=SetCompProc};
  609.     __property int MemberCount = {read=GetMemberCount, nodefault};
  610.     __property int DataType = {read=FDataType, nodefault};
  611.     __property int BlankCount = {read=FBlankCount, nodefault};
  612.     __property Variant Items[int I] = {read=GetItem, write=SetItem/*, default*/};
  613. };
  614.  
  615.  
  616. class DELPHICLASS TThreadCustomArray;
  617. class PASCALIMPLEMENTATION TThreadCustomArray : public System::TObject 
  618. {
  619.     typedef System::TObject inherited;
  620.     
  621. private:
  622.     TCustomArray* FCustomArray;
  623.     _RTL_CRITICAL_SECTION FLock;
  624.     
  625. public:
  626.     __fastcall TThreadCustomArray(int Items, int VarType);
  627.     __fastcall virtual ~TThreadCustomArray(void);
  628.     int __fastcall Add(const Variant &Item);
  629.     TCustomArray* __fastcall LockArray(void);
  630.     Variant __fastcall GetItem(int Index);
  631.     int __fastcall MemoryUsage(void);
  632.     void __fastcall UnlockArray(void);
  633. };
  634.  
  635.  
  636. //-- var, const, procedure ---------------------------------------------------
  637. static const int vMaxRow = 0x3ffffff8;
  638. static const int vMaxCol = 0x1ffffffe;
  639. extern PACKAGE void __fastcall SetMemoryCapacity(int Value);
  640. extern PACKAGE int __fastcall GetMemoryCapacity(void);
  641.  
  642. }    /* namespace Mxarrays */
  643. #if !defined(NO_IMPLICIT_NAMESPACE_USE)
  644. using namespace Mxarrays;
  645. #endif
  646. #pragma option pop    // -w-
  647. #pragma option pop    // -Vx
  648.  
  649. #pragma delphiheader end.
  650. //-- end unit ----------------------------------------------------------------
  651. #endif    // mxarrays
  652.