Array.h 24 KB

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