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->next; e; e = e->next)
  377. {
  378. delete e2;
  379. e2 = e;
  380. }
  381. delete e2;
  382. entries->set = 0;
  383. entries->next = 0;
  384. last = entries;
  385. count = 0;
  386. }
  387. //! Gibt einen Iterator zurück.
  388. //! Mit ++ kann durch die Liste iteriert werden
  389. ArrayIterator<TYP> begin() const
  390. {
  391. return ArrayIterator<TYP>(entries, onRemove);
  392. }
  393. ArrayIterator<TYP> end() const
  394. {
  395. return ArrayIterator<TYP>(0, onRemove);
  396. }
  397. //! Gibt zurück, wie viele Elemente in der Liste sind
  398. int getEintragAnzahl() const
  399. {
  400. return count;
  401. }
  402. //! Gibt den Wert des i-ten Elementes zurück
  403. //! \param i Der index des gesuchten Elementes
  404. //! throws:
  405. //! \param std:out_of_range wenn i < 0 oder i >= getEintragAnzahl()
  406. TYP get(int i) const
  407. {
  408. if (i < 0 || i >= count)
  409. throwOutOfRange(__FILE__, __LINE__, i, count);
  410. ArrayEintrag<TYP>* e = entries;
  411. for (int a = 0; a < i && e; ++a)
  412. e = e->next;
  413. return e->var;
  414. }
  415. //! Überprüft, ob ein Element in der Liste enthalten ist
  416. //! \param i Der Index des gesuchten Elementes
  417. //! \return (true), wenn der Index vorhanden ist. (false) sonnst
  418. bool hat(int i) const
  419. {
  420. return i >= 0 && i < count;
  421. }
  422. //! Gibt den Index eines Wertes zurück
  423. //! \param t Der Wert, nach dem gesucht werden soll
  424. int getWertIndex(TYP t) const
  425. {
  426. int ret = 0;
  427. for (ArrayEintrag<TYP>* e = entries; e; e = e->next)
  428. {
  429. if (e->set && e->var == t) return ret;
  430. ++ret;
  431. }
  432. return -1;
  433. }
  434. bool anyMatch(std::function<bool(const TYP element)> predicate) const
  435. {
  436. for (TYP t : *this)
  437. {
  438. if (predicate(t)) return 1;
  439. }
  440. return 0;
  441. }
  442. bool allMatch(std::function<bool(const TYP element)> predicate) const
  443. {
  444. for (TYP t : *this)
  445. {
  446. if (!predicate(t)) return 0;
  447. }
  448. return 1;
  449. }
  450. int findIndex(std::function<bool(const TYP element)> predicate) const
  451. {
  452. int index = 0;
  453. for (TYP t : *this)
  454. {
  455. if (predicate(t)) return index;
  456. index++;
  457. }
  458. return -1;
  459. }
  460. Array& operator=(const Array& arr)
  461. {
  462. leeren();
  463. int anz = arr.getEintragAnzahl();
  464. for (int i = 0; i < anz; i++)
  465. add(arr.get(i));
  466. return *this;
  467. }
  468. Stream<TYP> stream()
  469. {
  470. return Stream<TYP>(new IteratorSupplier<TYP>(
  471. new ArrayIterator<TYP>(entries, onRemove)));
  472. }
  473. };
  474. template<class TYP>
  475. //! Eine Linked List von Zeigern auf Zeichnunge, die Reference Counting
  476. //! berteiben
  477. class RCArray : public virtual ReferenceCounter
  478. {
  479. private:
  480. ArrayEintrag<TYP*>* entries;
  481. ArrayEintrag<TYP*>* last;
  482. int count;
  483. std::function<ArrayEintrag<TYP*>*(ArrayEintrag<TYP*>* removed)>
  484. onRemove;
  485. public:
  486. //! Erstellt eine neue Linked List
  487. RCArray() noexcept
  488. : ReferenceCounter()
  489. {
  490. entries = new ArrayEintrag<TYP*>();
  491. entries->var = 0;
  492. entries->set = 0;
  493. entries->next = 0;
  494. last = entries;
  495. count = 0;
  496. onRemove = [this](ArrayEintrag<TYP*>* entry) {
  497. if (!entry) return (ArrayEintrag<TYP*>*)0;
  498. if (entry->next)
  499. {
  500. if (entry->set && entry->var) entry->var->release();
  501. entry->var = entry->next->var;
  502. entry->set = entry->next->set;
  503. }
  504. else
  505. {
  506. if (entry->set && entry->var) entry->var->release();
  507. entry->set = 0;
  508. }
  509. ArrayEintrag<TYP*>* del = entry->next;
  510. if (entry->next)
  511. entry->next = entry->next->next;
  512. else
  513. entry->next = 0;
  514. if (del)
  515. {
  516. del->var = 0;
  517. del->set = 0;
  518. del->next = 0;
  519. if (last == del) last = entry;
  520. delete del;
  521. }
  522. count--;
  523. return entry->set ? entry : 0;
  524. };
  525. }
  526. //! Kopiert eine Linked list
  527. RCArray(const RCArray& arr)
  528. : RCArray()
  529. {
  530. int anz = arr.getEintragAnzahl();
  531. for (int i = 0; i < anz; i++)
  532. add(arr.get(i));
  533. }
  534. //! Leert und löscht die Linked List
  535. ~RCArray()
  536. {
  537. leeren();
  538. delete entries;
  539. }
  540. //! Hängt ein Element ans Ende der Liste an
  541. //! \param t Das neue Element
  542. void add(TYP* t)
  543. {
  544. count++;
  545. if (!last->set)
  546. {
  547. last->var = t;
  548. last->set = 1;
  549. return;
  550. }
  551. last->next = new ArrayEintrag<TYP*>();
  552. last = last->next;
  553. last->var = t;
  554. last->set = 1;
  555. }
  556. //! Fügt ein Element bei einer bestimmten Position in die Liste ein
  557. //! \param t das neue Element
  558. //! \param i Die Position, wo das Element eingefügt wird (danach der
  559. //! Index des neuen Elementes)
  560. void add(TYP* t, int i)
  561. {
  562. if (i < 0 || i > count)
  563. throwOutOfRange(__FILE__, __LINE__, i, count);
  564. if (i == count)
  565. {
  566. add(t);
  567. return;
  568. }
  569. ArrayEintrag<TYP*>* e = entries;
  570. for (int a = 0; a < i; ++a)
  571. e = e->next;
  572. ArrayEintrag<TYP*>* ne = new ArrayEintrag<TYP*>();
  573. ne->var = e->var;
  574. ne->set = e->set;
  575. ne->next = e->next;
  576. e->next = ne;
  577. e->var = t;
  578. e->set = 1;
  579. if (last->next) last = last->next;
  580. count++;
  581. }
  582. //! Setzt den Wert des i-ten Eintrags
  583. //! \param t der Neue Wert
  584. //! \param i Der Index des Eintrages der gesetzt werden soll
  585. void set(TYP* t, int i)
  586. {
  587. if (i < 0 || i >= count)
  588. throwOutOfRange(__FILE__, __LINE__, i, count);
  589. ArrayEintrag<TYP*>* e = entries;
  590. for (int a = 0; a < i; ++a)
  591. e = e->next;
  592. if (e->set && e->var) e->var->release();
  593. e->var = t;
  594. e->set = 1;
  595. }
  596. //! Verändert die Position des i-ten Elementes in der Liste
  597. //! \param i Der Index des Elementes, welches verschoben werden soll
  598. //! \param p Die Zielposition des Elementes (danach der neue Index des
  599. //! Elementes)
  600. void setPosition(int i, int p)
  601. {
  602. if (i == p) return;
  603. if (i < 0 || p < 0 || i >= count || p >= count)
  604. throwOutOfRange(__FILE__, __LINE__, i, count);
  605. TYP* t = get(i);
  606. remove(i);
  607. add(t, p);
  608. }
  609. //! Löscht ein Bestimmtes Element
  610. //! \param i Der Index des Elementes das gelöscht werden soll
  611. void remove(int i)
  612. {
  613. if (i < 0 || i >= count)
  614. throwOutOfRange(__FILE__, __LINE__, i, count);
  615. ArrayEintrag<TYP*>* e = entries;
  616. for (int a = 0; a < i; ++a)
  617. e = e->next;
  618. if (e->next)
  619. {
  620. if (e->set && e->var) e->var->release();
  621. e->var = e->next->var;
  622. e->set = e->next->set;
  623. }
  624. else
  625. {
  626. if (e->set && e->var) e->var->release();
  627. e->set = 0;
  628. }
  629. ArrayEintrag<TYP*>* del = e->next;
  630. if (e->next)
  631. e->next = e->next->next;
  632. else
  633. e->next = 0;
  634. if (del)
  635. {
  636. del->set = 0;
  637. del->next = 0;
  638. if (last == del) last = e;
  639. delete del;
  640. }
  641. count--;
  642. }
  643. //! Vertauscht zwei Elemente in der Liste
  644. //! \param vi Der Index des ersten Elementes
  645. //! \param ni Der Index des zweiten Elementes
  646. void tausch(int vi, int ni)
  647. {
  648. if (vi < 0 || ni < 0) return;
  649. TYP* tmp = get(ni);
  650. set(get(vi), ni);
  651. set(tmp, vi);
  652. }
  653. //! Löscht alle Elemente der Liste
  654. void leeren()
  655. {
  656. for (ArrayEintrag<TYP*>* e = entries->next; e;)
  657. {
  658. if (e && e->var && e->set) e->var->release();
  659. auto tmp = e->next;
  660. delete e;
  661. e = tmp;
  662. }
  663. if (entries && entries->var && entries->set)
  664. entries->var->release();
  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