Array.h 24 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859
  1. #ifndef Array_H
  2. #define Array_H
  3. #include <functional>
  4. #include <stdexcept>
  5. #include "Errors.h"
  6. #include "ReferenceCounter.h"
  7. #include "Text.h"
  8. namespace Framework
  9. {
  10. template<class TYP>
  11. //! Ein Eintrag in einer Linked List
  12. struct ArrayEintrag
  13. {
  14. TYP var;
  15. bool set;
  16. ArrayEintrag<TYP>* next;
  17. ArrayEintrag()
  18. : var(),
  19. set(0),
  20. next(0)
  21. {}
  22. //! Setzt den Eintrag auf die Werte des anderen Eintrages
  23. ArrayEintrag& operator=(ArrayEintrag& r)
  24. {
  25. var = r.var;
  26. set = r.set;
  27. next = r.next;
  28. return *this;
  29. }
  30. //! Gibt den aktuell gespeicherten Wert zurück
  31. operator TYP()
  32. {
  33. if (!set)
  34. {
  35. Text err = "Index out of Range Exception File: ";
  36. err += __FILE__;
  37. err += " Line: ";
  38. err += __LINE__;
  39. throw std::out_of_range(err);
  40. }
  41. return var;
  42. }
  43. //! inkrementiert durch die Linked List durch
  44. ArrayEintrag<TYP>& operator++() //! prefix
  45. {
  46. if (!next)
  47. {
  48. ArrayEintrag<TYP> tmp;
  49. tmp.set = 0;
  50. tmp.next = 0;
  51. *this = tmp;
  52. return *this;
  53. }
  54. *this = *next;
  55. return *next;
  56. }
  57. //! inkrementiert durch die Linked List durch
  58. ArrayEintrag<TYP>& operator++(int) //! postfix
  59. {
  60. if (!next)
  61. {
  62. ArrayEintrag<TYP> tmp;
  63. tmp.set = 0;
  64. tmp.next = 0;
  65. *this = tmp;
  66. return *this;
  67. }
  68. *this = *next;
  69. return *next;
  70. }
  71. #ifdef WIN32
  72. # pragma warning(once : 26495)
  73. };
  74. #else
  75. };
  76. #endif
  77. template<class TYP> class Iterator
  78. {
  79. private:
  80. ArrayEintrag<TYP>* current;
  81. std::function<ArrayEintrag<TYP>*(ArrayEintrag<TYP>* removed)> onRemove;
  82. public:
  83. Iterator(ArrayEintrag<TYP>* start,
  84. std::function<ArrayEintrag<TYP>*(ArrayEintrag<TYP>* removed)>
  85. onRemove)
  86. {
  87. this->onRemove = onRemove;
  88. current = start;
  89. while (current && !current->set)
  90. {
  91. current = current->next;
  92. }
  93. }
  94. Iterator(const Iterator& it)
  95. {
  96. onRemove = it.onRemove;
  97. current = it.current;
  98. }
  99. ~Iterator()
  100. {
  101. current = 0;
  102. }
  103. Iterator<TYP>& operator=(Iterator<TYP> r)
  104. {
  105. onRemove = r.onRemove;
  106. current = r.current;
  107. return *this;
  108. }
  109. bool hasNext()
  110. {
  111. ArrayEintrag<TYP>* next = current->next;
  112. while (next && !next->set)
  113. {
  114. next = next->next;
  115. }
  116. return next != 0;
  117. }
  118. TYP operator*()
  119. {
  120. return current->var;
  121. }
  122. Iterator<TYP> next()
  123. {
  124. if (!current)
  125. {
  126. Text err = "Index out of Range Exception File: ";
  127. err += __FILE__;
  128. err += " Line: ";
  129. err += __LINE__;
  130. throw std::out_of_range(err);
  131. }
  132. return Iterator(current->next, onRemove);
  133. }
  134. operator bool()
  135. {
  136. return current != 0;
  137. }
  138. operator TYP()
  139. {
  140. if (!current || !current->set)
  141. {
  142. Text err = "Index out of Range Exception File: ";
  143. err += __FILE__;
  144. err += " Line: ";
  145. err += __LINE__;
  146. throw std::out_of_range(err);
  147. }
  148. return current->var;
  149. }
  150. Iterator<TYP>& operator++() //! prefix
  151. {
  152. do
  153. {
  154. if (current) current = current->next;
  155. } while (current && !current->set);
  156. return *this;
  157. }
  158. Iterator<TYP> operator++(int) //! postfix
  159. {
  160. Iterator<TYP> temp(*this);
  161. do
  162. {
  163. if (current) current = current->next;
  164. } while (current && !current->set);
  165. return temp;
  166. }
  167. TYP operator->()
  168. {
  169. if (!current || !current->set)
  170. {
  171. Text err = "Index out of Range Exception File: ";
  172. err += __FILE__;
  173. err += " Line: ";
  174. err += __LINE__;
  175. throw std::out_of_range(err);
  176. }
  177. return current->var;
  178. }
  179. TYP val()
  180. {
  181. if (!current || !current->set)
  182. {
  183. Text err = "Index out of Range Exception File: ";
  184. err += __FILE__;
  185. err += " Line: ";
  186. err += __LINE__;
  187. throw std::out_of_range(err);
  188. }
  189. return current->var;
  190. }
  191. void set(TYP val)
  192. {
  193. if (current)
  194. {
  195. current->var = val;
  196. current->set = true;
  197. }
  198. else
  199. {
  200. Text err = "Index out of Range Exception File: ";
  201. err += __FILE__;
  202. err += " Line: ";
  203. err += __LINE__;
  204. throw std::out_of_range(err);
  205. }
  206. }
  207. bool operator!=(Iterator<TYP>& r)
  208. {
  209. return current != r.current;
  210. }
  211. void remove()
  212. {
  213. current = onRemove(current);
  214. }
  215. };
  216. #define _ val()
  217. template<class TYP>
  218. //! Eine Linked List von Klassen, die kein Reference Counting berteiben
  219. class Array : public virtual ReferenceCounter
  220. {
  221. private:
  222. ArrayEintrag<TYP>* entries;
  223. ArrayEintrag<TYP>* last;
  224. int count;
  225. std::function<ArrayEintrag<TYP>*(ArrayEintrag<TYP>* removed)> onRemove;
  226. public:
  227. //! Erstellt eine neue Linked List
  228. Array() noexcept
  229. : ReferenceCounter()
  230. {
  231. entries = new ArrayEintrag<TYP>();
  232. entries->set = 0;
  233. entries->next = 0;
  234. last = entries;
  235. count = 0;
  236. onRemove = [this](ArrayEintrag<TYP>* entry) {
  237. if (!entry) return (ArrayEintrag<TYP>*)0;
  238. if (entry->next)
  239. {
  240. entry->var = entry->next->var;
  241. entry->set = entry->next->set;
  242. }
  243. else
  244. entry->set = 0;
  245. ArrayEintrag<TYP>* del = entry->next;
  246. if (entry->next)
  247. entry->next = entry->next->next;
  248. else
  249. entry->next = 0;
  250. if (del)
  251. {
  252. del->set = 0;
  253. del->next = 0;
  254. if (last == del) last = entry;
  255. delete del;
  256. }
  257. count--;
  258. return entry->set ? entry : 0;
  259. };
  260. }
  261. //! Kopiert eine Linked list
  262. //!
  263. Array(const Array& arr)
  264. : Array()
  265. {
  266. int anz = arr.getEintragAnzahl();
  267. for (int i = 0; i < anz; i++)
  268. add(arr.get(i));
  269. }
  270. //! Leert und löscht die Linked List
  271. ~Array()
  272. {
  273. leeren();
  274. delete entries;
  275. }
  276. //! Hängt ein Element ans Ende der Liste an
  277. //! \param t Das neue Element
  278. void add(TYP t)
  279. {
  280. if (!last->set)
  281. {
  282. last->var = t;
  283. last->set = 1;
  284. count++;
  285. return;
  286. }
  287. last->next = new ArrayEintrag<TYP>();
  288. last = last->next;
  289. last->set = 1;
  290. last->var = t;
  291. count++;
  292. }
  293. //! Fügt ein Element bei einer bestimmten Position in die Liste ein
  294. //! \param t das neue Element
  295. //! \param i Die Position, wo das Element eingefügt wird (danach der
  296. //! Index des neuen Elementes)
  297. void add(TYP t, int i)
  298. {
  299. if (i < 0 || i > count)
  300. throwOutOfRange(__FILE__, __LINE__, i, count);
  301. if (i == count)
  302. {
  303. add(t);
  304. return;
  305. }
  306. ArrayEintrag<TYP>* e = entries;
  307. for (int a = 0; a < i; ++a)
  308. e = e->next;
  309. ArrayEintrag<TYP>* ne = new ArrayEintrag<TYP>();
  310. ne->var = e->var;
  311. ne->set = e->set;
  312. ne->next = e->next;
  313. e->next = ne;
  314. e->var = t;
  315. e->set = 1;
  316. if (last->next) last = last->next;
  317. count++;
  318. }
  319. //! Setzt den Wert des i-ten Eintrags
  320. //! \param t der Neue Wert
  321. //! \param i Der Index des Eintrages der gesetzt werden soll
  322. void set(TYP t, int i)
  323. {
  324. if (i < 0 || i >= count)
  325. throwOutOfRange(__FILE__, __LINE__, i, count);
  326. ArrayEintrag<TYP>* e = entries;
  327. for (int a = 0; a < i; ++a)
  328. e = e->next;
  329. e->var = t;
  330. e->set = 1;
  331. }
  332. //! Verändert die Position des i-ten Elementes in der Liste
  333. //! \param i Der Index des Elementes, welches verschoben werden soll
  334. //! \param p Die Zielposition des Elementes (danach der neue Index des
  335. //! Elementes)
  336. void setPosition(int i, int p)
  337. {
  338. if (i == p) return;
  339. if (i < 0 || p < 0 || i >= count || p >= count)
  340. throwOutOfRange(__FILE__, __LINE__, i, count);
  341. ArrayEintrag<TYP>* e = entries;
  342. ArrayEintrag<TYP>* ve = 0;
  343. for (int a = 0; a < i; ++a)
  344. {
  345. ve = e;
  346. e = e->next;
  347. }
  348. ArrayEintrag<TYP>* e2 = entries == e ? e->next : entries;
  349. ArrayEintrag<TYP>* ve2 = 0;
  350. for (int a = 0; a < p; ++a)
  351. {
  352. ve2 = e2;
  353. if (e2->next == e)
  354. e2 = e->next;
  355. else
  356. e2 = e2->next;
  357. }
  358. if (e == last)
  359. last = e2;
  360. else if (e2 == last)
  361. last = e;
  362. if (!ve2)
  363. entries = e;
  364. else
  365. ve2->next = e;
  366. if (ve)
  367. ve->next = e->next;
  368. else
  369. entries = e->next;
  370. e->next = e2;
  371. }
  372. //! Löscht ein Bestimmtes Element
  373. //! \param i Der Index des Elementes das gelöscht werden soll
  374. void remove(int i)
  375. {
  376. if (i < 0 || i >= count)
  377. throwOutOfRange(__FILE__, __LINE__, i, count);
  378. ArrayEintrag<TYP>* e = entries;
  379. for (int a = 0; a < i; ++a)
  380. e = e->next;
  381. onRemove(e);
  382. }
  383. //! Löscht ein Bestimmtes Element
  384. //! \param i Der Index des Elementes das gelöscht werden soll
  385. void removeValue(TYP value)
  386. {
  387. ArrayEintrag<TYP>* e = entries;
  388. while (e->var != value)
  389. {
  390. if (!e->next) return;
  391. e = e->next;
  392. }
  393. if (!e) return;
  394. if (e->next)
  395. {
  396. e->var = e->next->var;
  397. e->set = e->next->set;
  398. }
  399. else
  400. e->set = 0;
  401. ArrayEintrag<TYP>* del = e->next;
  402. if (e->next)
  403. e->next = e->next->next;
  404. else
  405. e->next = 0;
  406. if (del)
  407. {
  408. del->set = 0;
  409. del->next = 0;
  410. if (last == del) last = e;
  411. delete del;
  412. }
  413. count--;
  414. }
  415. //! Vertauscht zwei Elemente in der Liste
  416. //! \param vi Der Index des ersten Elementes
  417. //! \param ni Der Index des zweiten Elementes
  418. void tausch(int vi, int ni)
  419. {
  420. TYP tmp = get(ni);
  421. set(get(vi), ni);
  422. set(tmp, vi);
  423. }
  424. //! Löscht alle Elemente der Liste
  425. void leeren()
  426. {
  427. ArrayEintrag<TYP>* e2 = 0;
  428. for (ArrayEintrag<TYP>* e = entries; e; e = e->next)
  429. {
  430. delete e2;
  431. e2 = e;
  432. }
  433. delete e2;
  434. entries = new ArrayEintrag<TYP>();
  435. entries->set = 0;
  436. entries->next = 0;
  437. last = entries;
  438. count = 0;
  439. }
  440. //! Gibt einen Iterator zurück.
  441. //! Mit ++ kann durch die Liste iteriert werden
  442. Iterator<TYP> begin() const
  443. {
  444. return Iterator<TYP>(entries, onRemove);
  445. }
  446. Iterator<TYP> end() const
  447. {
  448. return Iterator<TYP>(0, onRemove);
  449. }
  450. //! Gibt zurück, wie viele Elemente in der Liste sind
  451. int getEintragAnzahl() const
  452. {
  453. return count;
  454. }
  455. //! Gibt den Wert des i-ten Elementes zurück
  456. //! \param i Der index des gesuchten Elementes
  457. //! throws:
  458. //! \param std:out_of_range wenn i < 0 oder i >= getEintragAnzahl()
  459. TYP get(int i) const
  460. {
  461. if (i < 0 || i >= count)
  462. throwOutOfRange(__FILE__, __LINE__, i, count);
  463. ArrayEintrag<TYP>* e = entries;
  464. for (int a = 0; a < i && e; ++a)
  465. e = e->next;
  466. return e->var;
  467. }
  468. //! Überprüft, ob ein Element in der Liste enthalten ist
  469. //! \param i Der Index des gesuchten Elementes
  470. //! \return (true), wenn der Index vorhanden ist. (false) sonnst
  471. bool hat(int i) const
  472. {
  473. return i >= 0 && i < count;
  474. }
  475. //! Gibt den Index eines Wertes zurück
  476. //! \param t Der Wert, nach dem gesucht werden soll
  477. int getWertIndex(TYP t) const
  478. {
  479. int ret = 0;
  480. for (ArrayEintrag<TYP>* e = entries; e; e = e->next)
  481. {
  482. if (e->set && e->var == t) return ret;
  483. ++ret;
  484. }
  485. return -1;
  486. }
  487. Array& operator=(const Array& arr)
  488. {
  489. leeren();
  490. int anz = arr.getEintragAnzahl();
  491. for (int i = 0; i < anz; i++)
  492. add(arr.get(i));
  493. return *this;
  494. }
  495. };
  496. template<class TYP>
  497. //! Eine Linked List von Zeigern auf Zeichnunge, die Reference Counting
  498. //! berteiben
  499. class RCArray : public virtual ReferenceCounter
  500. {
  501. private:
  502. ArrayEintrag<TYP*>* entries;
  503. ArrayEintrag<TYP*>* last;
  504. int count;
  505. std::function<ArrayEintrag<TYP*>*(ArrayEintrag<TYP*>* removed)>
  506. onRemove;
  507. public:
  508. //! Erstellt eine neue Linked List
  509. RCArray() noexcept
  510. : ReferenceCounter()
  511. {
  512. entries = new ArrayEintrag<TYP*>();
  513. entries->var = 0;
  514. entries->set = 0;
  515. entries->next = 0;
  516. last = entries;
  517. count = 0;
  518. onRemove = [this](ArrayEintrag<TYP*>* entry) {
  519. if (!entry) return (ArrayEintrag<TYP*>*)0;
  520. if (entry->next)
  521. {
  522. if (entry->set && entry->var) entry->var->release();
  523. entry->var = entry->next->var;
  524. entry->set = entry->next->set;
  525. }
  526. else
  527. {
  528. if (entry->set && entry->var) entry->var->release();
  529. entry->set = 0;
  530. }
  531. ArrayEintrag<TYP*>* del = entry->next;
  532. if (entry->next)
  533. entry->next = entry->next->next;
  534. else
  535. entry->next = 0;
  536. if (del)
  537. {
  538. del->var = 0;
  539. del->set = 0;
  540. del->next = 0;
  541. if (last == del) last = entry;
  542. delete del;
  543. }
  544. count--;
  545. return entry->set ? entry : 0;
  546. };
  547. }
  548. //! Kopiert eine Linked list
  549. RCArray(const RCArray& arr)
  550. : RCArray()
  551. {
  552. int anz = arr.getEintragAnzahl();
  553. for (int i = 0; i < anz; i++)
  554. add(arr.get(i));
  555. }
  556. //! Leert und löscht die Linked List
  557. ~RCArray()
  558. {
  559. leeren();
  560. delete entries;
  561. }
  562. //! Hängt ein Element ans Ende der Liste an
  563. //! \param t Das neue Element
  564. void add(TYP* t)
  565. {
  566. count++;
  567. if (!last->set)
  568. {
  569. last->var = t;
  570. last->set = 1;
  571. return;
  572. }
  573. last->next = new ArrayEintrag<TYP*>();
  574. last = last->next;
  575. last->var = t;
  576. last->set = 1;
  577. }
  578. //! Fügt ein Element bei einer bestimmten Position in die Liste ein
  579. //! \param t das neue Element
  580. //! \param i Die Position, wo das Element eingefügt wird (danach der
  581. //! Index des neuen Elementes)
  582. void add(TYP* t, int i)
  583. {
  584. if (i < 0 || i > count)
  585. throwOutOfRange(__FILE__, __LINE__, i, count);
  586. if (i == count)
  587. {
  588. add(t);
  589. return;
  590. }
  591. ArrayEintrag<TYP*>* e = entries;
  592. for (int a = 0; a < i; ++a)
  593. e = e->next;
  594. ArrayEintrag<TYP*>* ne = new ArrayEintrag<TYP*>();
  595. ne->var = e->var;
  596. ne->set = e->set;
  597. ne->next = e->next;
  598. e->next = ne;
  599. e->var = t;
  600. e->set = 1;
  601. if (last->next) last = last->next;
  602. count++;
  603. }
  604. //! Setzt den Wert des i-ten Eintrags
  605. //! \param t der Neue Wert
  606. //! \param i Der Index des Eintrages der gesetzt werden soll
  607. void set(TYP* t, int i)
  608. {
  609. if (i < 0 || i >= count)
  610. throwOutOfRange(__FILE__, __LINE__, i, count);
  611. ArrayEintrag<TYP*>* e = entries;
  612. for (int a = 0; a < i; ++a)
  613. e = e->next;
  614. if (e->set && e->var) e->var->release();
  615. e->var = t;
  616. e->set = 1;
  617. }
  618. //! Verändert die Position des i-ten Elementes in der Liste
  619. //! \param i Der Index des Elementes, welches verschoben werden soll
  620. //! \param p Die Zielposition des Elementes (danach der neue Index des
  621. //! Elementes)
  622. void setPosition(int i, int p)
  623. {
  624. if (i == p) return;
  625. if (i < 0 || p < 0 || i >= count || p >= count)
  626. throwOutOfRange(__FILE__, __LINE__, i, count);
  627. ArrayEintrag<TYP*>* ve = 0;
  628. ArrayEintrag<TYP*>* e = entries;
  629. for (int a = 0; a < i; ++a)
  630. {
  631. ve = e;
  632. e = e->next;
  633. }
  634. ArrayEintrag<TYP*>* e2 = entries == e ? e->next : entries;
  635. ArrayEintrag<TYP*>* ve2 = 0;
  636. for (int a = 0; a < p; ++a)
  637. {
  638. ve2 = e2;
  639. if (e2->next == e)
  640. e2 = e->next;
  641. else
  642. e2 = e2->next;
  643. }
  644. if (last == e)
  645. last = e2;
  646. else if (last == e2)
  647. last = e;
  648. if (!ve2)
  649. entries = e;
  650. else
  651. ve2->next = e;
  652. if (ve)
  653. ve->next = e->next;
  654. else
  655. entries = e->next;
  656. e->next = e2;
  657. }
  658. //! Löscht ein Bestimmtes Element
  659. //! \param i Der Index des Elementes das gelöscht werden soll
  660. void remove(int i)
  661. {
  662. if (i < 0 || i >= count)
  663. throwOutOfRange(__FILE__, __LINE__, i, count);
  664. ArrayEintrag<TYP*>* e = entries;
  665. for (int a = 0; a < i; ++a)
  666. e = e->next;
  667. if (e->next)
  668. {
  669. if (e->set && e->var) e->var->release();
  670. e->var = e->next->var;
  671. e->set = e->next->set;
  672. }
  673. else
  674. {
  675. if (e->set && e->var) e->var->release();
  676. e->set = 0;
  677. }
  678. ArrayEintrag<TYP*>* del = e->next;
  679. if (e->next)
  680. e->next = e->next->next;
  681. else
  682. e->next = 0;
  683. if (del)
  684. {
  685. del->set = 0;
  686. del->next = 0;
  687. if (last == del) last = e;
  688. delete del;
  689. }
  690. count--;
  691. }
  692. //! Vertauscht zwei Elemente in der Liste
  693. //! \param vi Der Index des ersten Elementes
  694. //! \param ni Der Index des zweiten Elementes
  695. void tausch(int vi, int ni)
  696. {
  697. if (vi < 0 || ni < 0) return;
  698. TYP* tmp = get(ni);
  699. set(get(vi), ni);
  700. set(tmp, vi);
  701. }
  702. //! Löscht alle Elemente der Liste
  703. void leeren()
  704. {
  705. for (ArrayEintrag<TYP*>* e = entries; e;)
  706. {
  707. if (e && e->var && e->set) e->var->release();
  708. auto tmp = e->next;
  709. delete e;
  710. e = tmp;
  711. }
  712. entries = new ArrayEintrag<TYP*>();
  713. entries->set = 0;
  714. entries->next = 0;
  715. last = entries;
  716. count = 0;
  717. }
  718. //! Gibt einen Iterator zurück.
  719. //! Mit ++ kann durch die Liste iteriert werden
  720. Iterator<TYP*> begin() const
  721. {
  722. return Iterator<TYP*>(entries, onRemove);
  723. }
  724. Iterator<TYP*> end() const
  725. {
  726. return Iterator<TYP*>(0, onRemove);
  727. }
  728. //! Gibt zurück, wie viele Elemente in der Liste sind
  729. int getEintragAnzahl() const
  730. {
  731. return count;
  732. }
  733. int getLastIndex() const
  734. {
  735. return count - 1;
  736. }
  737. //! Gibt den Wert des i-ten Elementes zurück mit erhöhtem Reference
  738. //! Counter \param i Der index des gesuchten Elementes, (0) wenn der
  739. //! Index nicht existiert
  740. TYP* get(int i) const
  741. {
  742. if (i < 0 || i >= count)
  743. throwOutOfRange(__FILE__, __LINE__, i, count);
  744. ArrayEintrag<TYP*>* e = entries;
  745. for (int a = 0; a < i && e; ++a)
  746. e = e->next;
  747. if (e && e->set && e->var)
  748. return dynamic_cast<TYP*>(e->var->getThis());
  749. return (TYP*)0;
  750. }
  751. //! Gibt den Wert des i-ten Elementes zurück ohne erhöhten Reference
  752. //! Counter \param i Der index des gesuchten Elementes, (0) wenn der
  753. //! Index nicht existiert
  754. TYP* z(int i) const //! gibt den index - ten T zurück
  755. {
  756. if (i < 0 || i >= count)
  757. throwOutOfRange(__FILE__, __LINE__, i, count);
  758. ArrayEintrag<TYP*>* e = entries;
  759. for (int a = 0; a < i && e; ++a)
  760. e = e->next;
  761. if (e && e->set && e->var) return (TYP*)e->var;
  762. return (TYP*)0;
  763. }
  764. //! Überprüft, ob ein Element in der Liste enthalten ist
  765. //! \param i Der Index des gesuchten Elementes
  766. //! \return (true), wenn der Index vorhanden ist. (false) sonnst
  767. bool hat(int i) const
  768. {
  769. return i >= 0 && i < count;
  770. }
  771. //! returns the index of the first element that matches zT or -1 if not found
  772. int indexOf(TYP* zT) const
  773. {
  774. int i = 0;
  775. for (TYP* t : *this)
  776. {
  777. if (t == zT)
  778. return i;
  779. ++i;
  780. }
  781. return -1;
  782. }
  783. RCArray& operator=(const RCArray& arr)
  784. {
  785. leeren();
  786. int anz = arr.getEintragAnzahl();
  787. for (int i = 0; i < anz; i++)
  788. add(arr.get(i));
  789. return *this;
  790. }
  791. };
  792. } // namespace Framework
  793. #endif