Array.h 24 KB

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