ObjList.pas 19 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698
  1. unit ObjList;
  2. {
  3. Unit ObjList
  4. Copyright (c) 2000-2001 Sebastian Reichelt
  5. Objekt-Listen für Objektorientierte Programmierung nach den Regeln des
  6. Software Engineering
  7. TObjectList
  8. TObjectList ist die Basisklasse für Objektlisten. Sie stellt alle
  9. Eigenschaften und Methoden für eine abstrakte Liste von Objekten zur
  10. Verfügung. Sie ähnelt TList, wobei statt Zeigern Objekte eingefügt
  11. werden können.
  12. TObjectList sollte nur zum akuten Abspeichern einer bestimmten Auswahl
  13. an Objekten benutzt werden. Für alle weiteren Aufgaben stehen die
  14. anderen Listen zur Verfügung.
  15. TObjectContainer
  16. Jedes Objekt, das parallel zu anderen gleichartigen Objekten dynamisch
  17. erzeugt wird, benötigt ein übergeordnetes Objekt (Owner), das sämtliche
  18. dynamischen Objekte verwaltet.
  19. Ein solches übergeordnetes Objekt sollte ein Objekt der Klasse
  20. TObjectContainer oder einer davon abgeleiteten Klasse sein. Die
  21. dynamischen Objekte müssen dann von TContainerItem abgeleitet und beim
  22. Erstellen der übergeordnete Container als Parameter an den Constructor
  23. Create übergeben werden.
  24. Beim Freigeben oder Leeren (Clear) des Containers werden dann alle
  25. untergeordneten Objekte aus dem Speicher entfernt. Ebenso wird beim
  26. Freigeben eines untergeordneten Objektes dieses aus dem Container
  27. gelöscht.
  28. Um bei einem untergeordneten Objekt den Container zu wechseln, müssen
  29. Sie einfach der Eigenschaft Owner einen neuen Wert zuweisen. Der Owner
  30. kann auch NIL sein, dann handelt es sich um ein ganz normales Objekt.
  31. Mit PerformItemAction kann eine Integer-Konstante als Aktion an alle
  32. untergeordneten Objekte übergeben werden. Dort wird dann die virtuelle
  33. Methode PerformAction aufgerufen, die das Ereignis OnAction auslöst.
  34. Da diese Klasse von TCollection abgeleitet wurde, wird das Objekt in
  35. die Stream-Komponentenspeicherung mit einbezogen.
  36. TConnectionList
  37. Um ein Objekt auf bestimmte Weise mit einem oder mehreren anderen zu
  38. verbinden, muß jedem der Objekte eine TConnectionList hinzugefügt werden.
  39. Die Verbindung zwischen zwei Objekten kann dann hergestellt werden,
  40. indem man die Klassenmethode ConnectLists mit den beiden Listen der
  41. Objekte als Parameter aufruft. Mit DisconnectLists läßt sich die
  42. Verbindung wieder aufheben. Alternativ dazu kann man auch die Methode
  43. ConnectTo bzw. DisconnectFrom einer der beiden Listen verwenden.
  44. Auch bei dieser Klasse gibt es eine Methode PerformItemAction, die bei
  45. allen verknüpften Listen ein OnAction-Ereignis auslöst (s.o.).
  46. Auch diese Klasse wurde in die Stream-Speicherung einbezogen.
  47. TReferenceList
  48. Bei TReferenceList handelt es sich um eine spezielle Form der akuten
  49. Objektliste. Sie wird benutzt, wenn ein Objekt, das sich in einem
  50. Container befindet, genau ein Objekt eines bestimmten Typs referenzieren
  51. muß, dieses eine Objekt aber beliebig viele andere referenzieren kann.
  52. Dieses Objekt muß dann selbstverständlich an den Konstruktor des
  53. ContainerItem übergeben und dann in das private Symbol einer
  54. Eigenschaft eingetragen werden. Außerdem muß das erstellte ContainerItem
  55. mit der Methode Add in eine Liste des Typs TReferenceList des zu
  56. referenzierenden Objekts eingetragen werden. Ebenso muß es beim
  57. Entfernen mit Delete wieder ausgetragen werden. Das funktioniert auch
  58. mit akuten Listen, aber bei TReferenceList ergeben sich einige Vorteile.
  59. Neu ist, daß beim Entfernen eines Objekts mit Referenzliste(n) alle
  60. referenzierten Objekte (die ContainerItems irgendeines beliebigen
  61. Containers sind) gelöscht werden. Das gleiche geschieht beim Aufruf von
  62. Clear.
  63. Auch neu ist der gewohnte Einsatz von PerformItemAction bei einer
  64. Referenzliste.
  65. TReferenceList wird nicht automatisch gespeichert. Die Instanzen sollten
  66. daher automatisch verwaltet werden.
  67. }
  68. {$WEAKPACKAGEUNIT}
  69. interface
  70. uses
  71. Classes;
  72. type
  73. TObjectNotifyEvent = procedure(Sender, Item: TObject) of object;
  74. TOwnedPersistent = class(TPersistent)
  75. private
  76. FOwner: TPersistent;
  77. protected
  78. procedure SetOwner(const Value: TPersistent); virtual;
  79. function GetOwner: TPersistent; override;
  80. public
  81. constructor Create(AOwner: TPersistent); virtual;
  82. destructor Destroy; override;
  83. property Owner: TPersistent read FOwner write SetOwner;
  84. published
  85. end;
  86. TObjectList = class(TList)
  87. private
  88. FOwner: TObject;
  89. protected
  90. function Get(Index: Integer): TObject;
  91. procedure Put(Index: Integer; Item: TObject);
  92. public
  93. constructor Create(AOwner: TObject);
  94. function Add(Item: TObject): Integer;
  95. procedure Insert(Index: Integer; Item: TObject);
  96. procedure Delete(Index: Integer); overload;
  97. procedure Delete(Item: TObject); overload;
  98. procedure Remove(Item: TObject);
  99. function IndexOf(Item: TObject): Integer;
  100. function First: TObject;
  101. function Last: TObject;
  102. property Items[Index: Integer]: TObject read Get write Put; default;
  103. property Owner: TObject read FOwner;
  104. end;
  105. TContainerItem = class;
  106. TActionNotifyEvent = procedure(Sender: TObject; Action: Integer; Obj: TObject) of object;
  107. TSubItemNotifyEvent = procedure(Sender: TObject; Item: TContainerItem) of object;
  108. TReferenceList = class(TObjectList)
  109. private
  110. FOnAdd: TSubItemNotifyEvent;
  111. FOnDelete: TSubItemNotifyEvent;
  112. function Get(Index: Integer): TContainerItem;
  113. protected
  114. public
  115. destructor Destroy; override;
  116. procedure Clear; override;
  117. procedure Add(Item: TContainerItem);
  118. procedure Delete(Item: TContainerItem);
  119. procedure PerformItemAction(Action: Integer; Obj: TObject = nil); virtual;
  120. function IndexOf(Item: TContainerItem): Integer;
  121. property Items[Index: Integer]: TContainerItem read Get; default;
  122. property OnAdd: TSubItemNotifyEvent read FOnAdd write FOnAdd;
  123. property OnDelete: TSubItemNotifyEvent read FOnDelete write FOnDelete;
  124. end;
  125. TObjectContainer = class(TOwnedCollection)
  126. private
  127. protected
  128. public
  129. procedure PerformItemAction(Action: Integer; Obj: TObject = nil); virtual;
  130. end;
  131. TContainerItem = class(TCollectionItem)
  132. private
  133. FOnAction: TActionNotifyEvent;
  134. function GetItemOwner: TObjectContainer;
  135. procedure SetItemOwner(const Value: TObjectContainer);
  136. protected
  137. procedure PerformAction(Action: Integer; Obj: TObject); virtual;
  138. public
  139. property Owner: TObjectContainer read GetItemOwner write SetItemOwner;
  140. property OnAction: TActionNotifyEvent read FOnAction write FOnAction;
  141. end;
  142. TFastContainerItem = class;
  143. TFastContainerItemClass = class of TFastContainerItem;
  144. TFastObjectContainer = class(TObject)
  145. private
  146. FOwner: TPersistent;
  147. FItems: TObjectList;
  148. FCount: Integer;
  149. FItemClass: TFastContainerItemClass;
  150. protected
  151. procedure InsertItem(Item: TFastContainerItem);
  152. procedure RemoveItem(Item: TFastContainerItem);
  153. function GetItem(Index: Integer): TFastContainerItem;
  154. public
  155. constructor Create(AOwner: TPersistent; ItemClass: TFastContainerItemClass);
  156. destructor Destroy; override;
  157. property Owner: TPersistent read FOwner;
  158. function Add: TFastContainerItem;
  159. procedure Clear;
  160. function Insert(Index: Integer): TFastContainerItem;
  161. property Count: Integer read FCount;
  162. property ItemClass: TFastContainerItemClass read FItemClass;
  163. property Items[Index: Integer]: TFastContainerItem read GetItem;
  164. procedure PerformItemAction(Action: Integer; Obj: TObject = nil); virtual;
  165. end;
  166. TFastContainerItem = class(TPersistent)
  167. private
  168. FOnAction: TActionNotifyEvent;
  169. FCollection: TFastObjectContainer;
  170. function GetIndex: Integer;
  171. procedure SetIndex(const Value: Integer);
  172. procedure SetCollection(const Value: TFastObjectContainer);
  173. protected
  174. procedure PerformAction(Action: Integer; Obj: TObject); virtual;
  175. public
  176. constructor Create(Collection: TFastObjectContainer); virtual;
  177. destructor Destroy; override;
  178. property Owner: TFastObjectContainer read FCollection write SetCollection;
  179. property Collection: TFastObjectContainer read FCollection write SetCollection;
  180. property Index: Integer read GetIndex write SetIndex;
  181. property OnAction: TActionNotifyEvent read FOnAction write FOnAction;
  182. end;
  183. TConnectionList = class;
  184. TConItem = class(TCollectionItem)
  185. private
  186. function GetOtherItem: TConItem;
  187. protected
  188. FConList: TConnectionList;
  189. FOtherItem: TConItem;
  190. procedure SetConList(const Value: TConnectionList); virtual;
  191. public
  192. destructor Destroy; override;
  193. property OtherItem: TConItem read GetOtherItem;
  194. //published
  195. property ConList: TConnectionList read FConList write SetConList;
  196. end;
  197. {$WARNINGS OFF}
  198. TConCollection = class(TOwnedCollection)
  199. private
  200. function GetNewOwner: TConnectionList;
  201. public
  202. function SearchForList(List: TConnectionList): TConItem;
  203. property Owner: TConnectionList read GetNewOwner;
  204. end;
  205. {$WARNINGS ON}
  206. TConnectionNotifyEvent = procedure(Sender: TObject; Item: TConnectionList) of object;
  207. TConnectionList = class(TOwnedPersistent)
  208. private
  209. FCollection: TConCollection;
  210. FOnConnect: TConnectionNotifyEvent;
  211. FOnDisconnect: TConnectionNotifyEvent;
  212. FOnAction: TActionNotifyEvent;
  213. function GetCount: Integer;
  214. procedure SetCollection(const Value: TConCollection);
  215. protected
  216. procedure CreateCollection(AItemClass: TCollectionItemClass); virtual;
  217. procedure Add(Item: TConnectionList);
  218. procedure Delete(Item: TConnectionList);
  219. procedure PerformAction(Action: Integer; Obj: TObject = nil); virtual;
  220. public
  221. class procedure ConnectLists(List1, List2: TConnectionList);
  222. class procedure DisconnectLists(List1, List2: TConnectionList);
  223. constructor Create(AOwner: TPersistent); override;
  224. constructor CreateSpecial(AOwner: TPersistent; AItemClass: TCollectionItemClass); virtual;
  225. destructor Destroy; override;
  226. procedure Clear;
  227. procedure PerformItemAction(Action: Integer; Obj: TObject); virtual;
  228. procedure ConnectTo(List: TConnectionList);
  229. procedure DisconnectFrom(List: TConnectionList);
  230. function IsConnectedTo(List: TConnectionList): Boolean;
  231. property Count: Integer read GetCount;
  232. property OnConnect: TConnectionNotifyEvent read FOnConnect write FOnConnect;
  233. property OnDisconnect: TConnectionNotifyEvent read FOnDisconnect write FOnDisconnect;
  234. property OnAction: TActionNotifyEvent read FOnAction write FOnAction;
  235. published
  236. property Collection: TConCollection read FCollection write SetCollection;
  237. end;
  238. implementation
  239. { TObjectList }
  240. function TObjectList.Add(Item: TObject): Integer;
  241. begin
  242. Result := inherited Add (Pointer (Item));
  243. end;
  244. procedure TObjectList.Delete(Index: Integer);
  245. begin
  246. inherited Delete (Index);
  247. end;
  248. procedure TObjectList.Delete(Item: TObject);
  249. begin
  250. if Count > 0 then begin
  251. if Item = Last then
  252. inherited Delete (Count - 1)
  253. else
  254. inherited Delete (IndexOf (Item));
  255. end;
  256. end;
  257. function TObjectList.Get(Index: Integer): TObject;
  258. begin
  259. Result := TObject (inherited Get (Index));
  260. end;
  261. function TObjectList.IndexOf(Item: TObject): Integer;
  262. begin
  263. Result := inherited IndexOf (Pointer (Item));
  264. end;
  265. procedure TObjectList.Insert(Index: Integer; Item: TObject);
  266. begin
  267. inherited Insert (Index, Pointer (Item));
  268. end;
  269. procedure TObjectList.Put(Index: Integer; Item: TObject);
  270. begin
  271. inherited Put (Index, Pointer (Item));
  272. end;
  273. constructor TObjectList.Create(AOwner: TObject);
  274. begin
  275. inherited Create;
  276. FOwner := AOwner;
  277. end;
  278. function TObjectList.First: TObject;
  279. begin
  280. Result := Get (0);
  281. end;
  282. function TObjectList.Last: TObject;
  283. begin
  284. Result := Get (Count - 1);
  285. end;
  286. procedure TObjectList.Remove(Item: TObject);
  287. begin
  288. Delete (Item);
  289. end;
  290. { TReferenceList }
  291. procedure TReferenceList.Add(Item: TContainerItem);
  292. begin
  293. if IndexOf (Item) < 0 then begin
  294. if Assigned (FOnAdd) then
  295. FOnAdd (Self, Item);
  296. inherited Add (Item);
  297. end;
  298. end;
  299. procedure TReferenceList.Clear;
  300. var
  301. I: Integer;
  302. begin
  303. for I := Count - 1 downto 0 do
  304. Items[I].Free;
  305. inherited;
  306. end;
  307. procedure TReferenceList.Delete(Item: TContainerItem);
  308. begin
  309. if Assigned (FOnDelete) then
  310. FOnDelete (Self, Item);
  311. inherited Delete (Item);
  312. end;
  313. destructor TReferenceList.Destroy;
  314. begin
  315. Clear;
  316. inherited;
  317. end;
  318. function TReferenceList.Get(Index: Integer): TContainerItem;
  319. begin
  320. Result := TContainerItem (inherited Get (Index));
  321. end;
  322. function TReferenceList.IndexOf(Item: TContainerItem): Integer;
  323. begin
  324. Result := inherited IndexOf (Item);
  325. end;
  326. procedure TReferenceList.PerformItemAction(Action: Integer; Obj: TObject);
  327. var
  328. I: Integer;
  329. begin
  330. for I := Count - 1 downto 0 do
  331. Items[I].PerformAction(Action, Obj);
  332. end;
  333. { TContainerItem }
  334. function TContainerItem.GetItemOwner: TObjectContainer;
  335. begin
  336. Result := TObjectContainer (Collection);
  337. end;
  338. procedure TContainerItem.PerformAction(Action: Integer; Obj: TObject);
  339. begin
  340. if Assigned (FOnAction) then
  341. FOnAction (Self, Action, Obj);
  342. end;
  343. procedure TContainerItem.SetItemOwner(const Value: TObjectContainer);
  344. begin
  345. Collection := Value;
  346. end;
  347. { TConnectionList }
  348. procedure TConnectionList.Add(Item: TConnectionList);
  349. begin
  350. if not Assigned (FCollection.SearchForList (Item)) then begin
  351. with TConItem(FCollection.Add) do
  352. ConList := Item;
  353. end;
  354. end;
  355. procedure TConnectionList.Clear;
  356. var
  357. I: Integer;
  358. begin
  359. for I := Count - 1 downto 0 do
  360. DisconnectFrom (TConItem(FCollection.Items[I]).ConList);
  361. FCollection.Clear;
  362. end;
  363. class procedure TConnectionList.ConnectLists(List1, List2: TConnectionList);
  364. begin
  365. List1.Add (List2);
  366. List2.Add (List1);
  367. end;
  368. procedure TConnectionList.ConnectTo(List: TConnectionList);
  369. begin
  370. ConnectLists (Self, List);
  371. end;
  372. constructor TConnectionList.Create(AOwner: TPersistent);
  373. begin
  374. inherited;
  375. CreateCollection (TConItem);
  376. end;
  377. procedure TConnectionList.CreateCollection(AItemClass:
  378. TCollectionItemClass);
  379. begin
  380. FCollection := TConCollection.Create (Self, AItemClass);
  381. end;
  382. constructor TConnectionList.CreateSpecial(AOwner: TPersistent;
  383. AItemClass: TCollectionItemClass);
  384. begin
  385. inherited Create (AOwner);
  386. CreateCollection (AItemClass);
  387. end;
  388. procedure TConnectionList.Delete(Item: TConnectionList);
  389. var
  390. I: TConItem;
  391. begin
  392. I := FCollection.SearchForList (Item);
  393. if Assigned (I) then
  394. I.Free;
  395. end;
  396. destructor TConnectionList.Destroy;
  397. begin
  398. Clear;
  399. FCollection.Free;
  400. inherited;
  401. end;
  402. procedure TConnectionList.DisconnectFrom(List: TConnectionList);
  403. begin
  404. DisconnectLists (Self, List);
  405. end;
  406. class procedure TConnectionList.DisconnectLists(List1, List2: TConnectionList);
  407. begin
  408. List1.Delete (List2);
  409. List2.Delete (List1);
  410. end;
  411. function TConnectionList.GetCount: Integer;
  412. begin
  413. Result := FCollection.Count;
  414. end;
  415. function TConnectionList.IsConnectedTo(List: TConnectionList): Boolean;
  416. begin
  417. Result := Assigned (Collection.SearchForList (List));
  418. end;
  419. procedure TConnectionList.PerformAction(Action: Integer; Obj: TObject);
  420. begin
  421. if Assigned (FOnAction) then
  422. FOnAction (Self, Action, Obj);
  423. end;
  424. procedure TConnectionList.PerformItemAction(Action: Integer; Obj: TObject);
  425. var
  426. I: Integer;
  427. begin
  428. for I := Count - 1 downto 0 do
  429. TConItem(FCollection.Items[I]).ConList.PerformAction(Action, Obj);
  430. end;
  431. procedure TConnectionList.SetCollection(const Value: TConCollection);
  432. begin
  433. FCollection.Assign (Value);
  434. end;
  435. { TObjectContainer }
  436. procedure TObjectContainer.PerformItemAction(Action: Integer; Obj: TObject);
  437. var
  438. I: Integer;
  439. begin
  440. for I := Count - 1 downto 0 do
  441. TContainerItem(Items[I]).PerformAction(Action, Obj);
  442. end;
  443. { TOwnedPersistent }
  444. constructor TOwnedPersistent.Create(AOwner: TPersistent);
  445. begin
  446. inherited Create;
  447. SetOwner (AOwner);
  448. end;
  449. destructor TOwnedPersistent.Destroy;
  450. begin
  451. SetOwner (nil);
  452. inherited;
  453. end;
  454. function TOwnedPersistent.GetOwner: TPersistent;
  455. begin
  456. Result := FOwner;
  457. end;
  458. procedure TOwnedPersistent.SetOwner(const Value: TPersistent);
  459. begin
  460. FOwner := Value;
  461. end;
  462. { TConItem }
  463. destructor TConItem.Destroy;
  464. begin
  465. SetConList (nil);
  466. inherited;
  467. end;
  468. function TConItem.GetOtherItem: TConItem;
  469. begin
  470. if (not Assigned (FOtherItem)) and Assigned (ConList) then
  471. FOtherItem := ConList.Collection.SearchForList ((Collection as TConCollection).Owner);
  472. Result := FOtherItem;
  473. end;
  474. procedure TConItem.SetConList(const Value: TConnectionList);
  475. begin
  476. if Assigned (FConList) and Assigned (FConList.FOnDisconnect) then
  477. with TConCollection(Collection).GetOwner as TConnectionList do
  478. FOnDisconnect (FConList, TConnectionList(TConCollection(Collection).GetOwner));
  479. FConList := Value;
  480. if Assigned (FConList) and Assigned (FConList.FOnConnect) then
  481. with TConCollection(Collection).GetOwner as TConnectionList do
  482. FOnConnect (FConList, TConnectionList(TConCollection(Collection).GetOwner));
  483. end;
  484. { TConCollection }
  485. function TConCollection.GetNewOwner: TConnectionList;
  486. begin
  487. Result := GetOwner as TConnectionList;
  488. end;
  489. function TConCollection.SearchForList(List: TConnectionList): TConItem;
  490. var
  491. I: Integer;
  492. Res: TConItem;
  493. begin
  494. Result := nil;
  495. for I := 0 to Count - 1 do begin
  496. Res := TConItem (Items [I]);
  497. if Res.ConList = List then begin
  498. Result := Res;
  499. Break;
  500. end;
  501. end;
  502. end;
  503. { TFastContainerItem }
  504. constructor TFastContainerItem.Create(Collection: TFastObjectContainer);
  505. begin
  506. inherited Create;
  507. SetCollection (Collection);
  508. end;
  509. destructor TFastContainerItem.Destroy;
  510. begin
  511. SetCollection (nil);
  512. inherited;
  513. end;
  514. function TFastContainerItem.GetIndex: Integer;
  515. begin
  516. if Assigned (FCollection) then
  517. Result := Collection.FItems.IndexOf (Self)
  518. else
  519. Result := -1;
  520. end;
  521. procedure TFastContainerItem.PerformAction(Action: Integer; Obj: TObject);
  522. begin
  523. if Assigned (FOnAction) then
  524. FOnAction (Self, Action, Obj);
  525. end;
  526. procedure TFastContainerItem.SetCollection(const Value: TFastObjectContainer);
  527. begin
  528. if FCollection <> Value then begin
  529. if Assigned (FCollection) then
  530. FCollection.RemoveItem (Self);
  531. if Assigned (Value) then
  532. Value.InsertItem (Self);
  533. end;
  534. end;
  535. procedure TFastContainerItem.SetIndex(const Value: Integer);
  536. var
  537. CurIndex: Integer;
  538. begin
  539. CurIndex := GetIndex;
  540. if (CurIndex >= 0) and (CurIndex <> Value) then
  541. FCollection.FItems.Move (CurIndex, Value);
  542. end;
  543. { TFastObjectContainer }
  544. function TFastObjectContainer.Add: TFastContainerItem;
  545. begin
  546. Result := FItemClass.Create (Self);
  547. end;
  548. procedure TFastObjectContainer.Clear;
  549. begin
  550. while Count > 0 do
  551. FItems.Last.Free;
  552. end;
  553. constructor TFastObjectContainer.Create(AOwner: TPersistent; ItemClass: TFastContainerItemClass);
  554. begin
  555. inherited Create;
  556. FItemClass := ItemClass;
  557. FItems := TObjectList.Create (Self);
  558. FOwner := AOwner;
  559. end;
  560. destructor TFastObjectContainer.Destroy;
  561. begin
  562. if Assigned (FItems) then begin
  563. Clear;
  564. FItems.Free;
  565. end;
  566. inherited;
  567. end;
  568. function TFastObjectContainer.GetItem(Index: Integer): TFastContainerItem;
  569. begin
  570. Result := TFastContainerItem (FItems [Index]);
  571. end;
  572. function TFastObjectContainer.Insert(Index: Integer): TFastContainerItem;
  573. begin
  574. Result := Add;
  575. Result.Index := Index;
  576. end;
  577. procedure TFastObjectContainer.InsertItem(Item: TFastContainerItem);
  578. begin
  579. FItems.Add (Item);
  580. Item.FCollection := Self;
  581. Inc (FCount);
  582. end;
  583. procedure TFastObjectContainer.PerformItemAction(Action: Integer; Obj: TObject);
  584. var
  585. I: Integer;
  586. begin
  587. for I := Count - 1 downto 0 do
  588. TContainerItem(Items[I]).PerformAction(Action, Obj);
  589. end;
  590. procedure TFastObjectContainer.RemoveItem(Item: TFastContainerItem);
  591. begin
  592. FItems.Delete (Item);
  593. Item.FCollection := nil;
  594. Dec (FCount);
  595. end;
  596. end.