InitDatei.cpp 8.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407
  1. #include "InitDatei.h"
  2. #include "Text.h"
  3. #include "Datei.h"
  4. using namespace Framework;
  5. // Inhalt der InitDatei Klasse aus InitDatei.h
  6. // Konstruktor
  7. InitDatei::InitDatei()
  8. : pfad( new Text() ),
  9. feldAnzahl( 0 ),
  10. name( new RCArray< Text >() ),
  11. wert( new RCArray< Text >() ),
  12. ref( 1 )
  13. {}
  14. InitDatei::InitDatei( Text *pfad )
  15. : pfad( new Text() ),
  16. feldAnzahl( 0 ),
  17. name( new RCArray< Text >() ),
  18. wert( new RCArray< Text >() ),
  19. ref( 1 )
  20. {
  21. setPfad( pfad );
  22. }
  23. InitDatei::InitDatei( const char *pfad )
  24. : pfad( new Text() ),
  25. feldAnzahl( 0 ),
  26. name( new RCArray< Text >() ),
  27. wert( new RCArray< Text >() ),
  28. ref( 1 )
  29. {
  30. setPfad( pfad );
  31. }
  32. // Destruktor
  33. InitDatei::~InitDatei()
  34. {
  35. pfad->release();
  36. name->release();
  37. wert->release();
  38. }
  39. // nicht constant
  40. void InitDatei::setPfad( Text *pfad )
  41. {
  42. this->pfad->setText( pfad );
  43. }
  44. void InitDatei::setPfad( const char *pfad )
  45. {
  46. this->pfad->setText( pfad );
  47. }
  48. bool InitDatei::laden()
  49. {
  50. Datei *dat = new Datei();
  51. dat->setDatei( pfad->getText() );
  52. if( !dat->öffnen( Datei::Style::lesen ) )
  53. {
  54. dat->release();
  55. return 0;
  56. }
  57. löscheAlle();
  58. Text *zeile = dat->leseZeile();
  59. for( int i = 0; zeile; ++i )
  60. {
  61. zeile->löschen( "\r\n" );
  62. zeile->löschen( "\n" );
  63. Text *n = zeile->getTeilText( 0, zeile->positionVon( '=' ) );
  64. Text *w = zeile->getTeilText( zeile->positionVon( '=' ) + 1 );
  65. name->set( n, i );
  66. wert->set( w, i );
  67. zeile->release();
  68. zeile = dat->leseZeile();
  69. feldAnzahl = i + 1;
  70. }
  71. dat->schließen();
  72. dat->release();
  73. return 1;
  74. }
  75. bool InitDatei::addWert( Text *name, Text *wert )
  76. {
  77. if( !wertExistiert( name->getText() ) )
  78. {
  79. this->name->set( new Text( name->getText() ), feldAnzahl );
  80. this->wert->set( new Text( wert->getText() ), feldAnzahl );
  81. ++feldAnzahl;
  82. name->release();
  83. wert->release();
  84. return 1;
  85. }
  86. name->release();
  87. wert->release();
  88. return 0;
  89. }
  90. bool InitDatei::addWert( const char *name, const char *wert )
  91. {
  92. if( !wertExistiert( name ) )
  93. {
  94. this->name->set( new Text( name ), feldAnzahl );
  95. this->wert->set( new Text( wert ), feldAnzahl );
  96. ++feldAnzahl;
  97. return 1;
  98. }
  99. return 0;
  100. }
  101. bool InitDatei::setWert( Text *name, Text *wert )
  102. {
  103. if( !wertExistiert( name->getText() ) )
  104. {
  105. name->release();
  106. wert->release();
  107. return 0;
  108. }
  109. for( int i = 0; i < feldAnzahl; ++i )
  110. {
  111. if( this->name->z( i )->istGleich( name->getText() ) )
  112. {
  113. this->wert->z( i )->setText( wert->getText() );
  114. name->release();
  115. wert->release();
  116. return 1;
  117. }
  118. }
  119. name->release();
  120. wert->release();
  121. return 0;
  122. }
  123. bool InitDatei::setWert( const char *name, const char *wert )
  124. {
  125. if( !wertExistiert( name ) )
  126. return 0;
  127. for( int i = 0; i < feldAnzahl; ++i )
  128. {
  129. if( this->name->z( i )->istGleich( name ) )
  130. {
  131. this->wert->z( i )->setText( wert );
  132. return 1;
  133. }
  134. }
  135. return 0;
  136. }
  137. bool InitDatei::setWert( int num, Text *wert )
  138. {
  139. if( num >= feldAnzahl )
  140. {
  141. wert->release();
  142. return 0;
  143. }
  144. this->wert->z( num )->setText( wert->getText() );
  145. wert->release();
  146. return 1;
  147. }
  148. bool InitDatei::setWert( int num, const char *wert )
  149. {
  150. if( num >= feldAnzahl )
  151. return 0;
  152. this->wert->z( num )->setText( wert );
  153. return 1;
  154. }
  155. bool InitDatei::löscheWert( Text *name )
  156. {
  157. if( !wertExistiert( name->getText() ) )
  158. {
  159. name->release();
  160. return 0;
  161. }
  162. for( int i = 0; i < feldAnzahl; ++i )
  163. {
  164. if( this->name->z( i )->istGleich( name->getText() ) )
  165. {
  166. this->name->lösche( i );
  167. this->wert->lösche( i );
  168. --feldAnzahl;
  169. name->release();
  170. return 1;
  171. }
  172. }
  173. name->release();
  174. return 0;
  175. }
  176. bool InitDatei::löscheWert( const char *name )
  177. {
  178. if( !wertExistiert( name ) )
  179. return 0;
  180. for( int i = 0; i < feldAnzahl; ++i )
  181. {
  182. if( this->name->z( i )->istGleich( name ) )
  183. {
  184. this->name->lösche( i );
  185. this->wert->lösche( i );
  186. --feldAnzahl;
  187. return 1;
  188. }
  189. }
  190. return 0;
  191. }
  192. bool InitDatei::löscheWert( int num )
  193. {
  194. if( num >= feldAnzahl )
  195. return 0;
  196. this->name->lösche( num );
  197. this->wert->lösche( num );
  198. --feldAnzahl;
  199. return 1;
  200. }
  201. void InitDatei::löscheAlle()
  202. {
  203. for( ; feldAnzahl > 0; --feldAnzahl )
  204. {
  205. this->name->lösche( 0 );
  206. this->wert->lösche( 0 );
  207. }
  208. }
  209. bool InitDatei::speichern()
  210. {
  211. Datei *dat = new Datei();
  212. dat->setDatei( pfad->getText() );
  213. if( !dat->existiert() )
  214. dat->erstellen();
  215. if( !dat->öffnen( Datei::Style::schreiben ) )
  216. {
  217. dat->release();
  218. return 0;
  219. }
  220. for( int i = 0; i < feldAnzahl; ++i )
  221. {
  222. Text *zeile = new Text( "" );
  223. zeile->anhängen( name->z( i )->getText() );
  224. zeile->anhängen( "=" );
  225. zeile->anhängen( wert->z( i )->getText() );
  226. zeile->anhängen( "\n" );
  227. dat->schreibe( zeile->getText(), zeile->getLänge() );
  228. zeile->release();
  229. }
  230. dat->schließen();
  231. dat->release();
  232. return 1;
  233. }
  234. // constant
  235. int InitDatei::getWertAnzahl() const
  236. {
  237. return feldAnzahl;
  238. }
  239. bool InitDatei::wertExistiert( Text *name )
  240. {
  241. for( int i = 0; i < feldAnzahl; ++i )
  242. {
  243. if( this->name->z( i )->istGleich( name->getText() ) )
  244. {
  245. name->release();
  246. return 1;
  247. }
  248. }
  249. name->release();
  250. return 0;
  251. }
  252. bool InitDatei::wertExistiert( const char *name )
  253. {
  254. for( int i = 0; i < feldAnzahl; ++i )
  255. {
  256. if( this->name->z( i )->istGleich( name ) )
  257. return 1;
  258. }
  259. return 0;
  260. }
  261. int InitDatei::getWertNummer( Text *name )
  262. {
  263. for( int i = 0; i < feldAnzahl; ++i )
  264. {
  265. if( this->name->z( i )->istGleich( name->getText() ) )
  266. {
  267. name->release();
  268. return i;
  269. }
  270. }
  271. name->release();
  272. return -1;
  273. }
  274. int InitDatei::getWertNummer( const char *name )
  275. {
  276. for( int i = 0; i < feldAnzahl; ++i )
  277. {
  278. if( this->name->z( i )->istGleich( name ) )
  279. return i;
  280. }
  281. return -1;
  282. }
  283. Text *InitDatei::getWert( Text *name )
  284. {
  285. for( int i = 0; i < feldAnzahl; ++i )
  286. {
  287. if( this->name->z( i )->istGleich( name->getText() ) )
  288. {
  289. name->release();
  290. return wert->get( i );
  291. }
  292. }
  293. name->release();
  294. return 0;
  295. }
  296. Text *InitDatei::getWert( const char *name )
  297. {
  298. for( int i = 0; i < feldAnzahl; ++i )
  299. {
  300. if( this->name->z( i )->istGleich( name ) )
  301. return wert->get( i );
  302. }
  303. return 0;
  304. }
  305. Text *InitDatei::getWert( int num )
  306. {
  307. if( num >= feldAnzahl )
  308. return 0;
  309. return wert->get( num );
  310. }
  311. Text *InitDatei::zWert( Text *name )
  312. {
  313. for( int i = 0; i < feldAnzahl; ++i )
  314. {
  315. if( this->name->z( i )->istGleich( name->getText() ) )
  316. {
  317. name->release();
  318. return wert->z( i );
  319. }
  320. }
  321. name->release();
  322. return 0;
  323. }
  324. Text *InitDatei::zWert( const char *name )
  325. {
  326. for( int i = 0; i < feldAnzahl; ++i )
  327. {
  328. if( this->name->z( i )->istGleich( name ) )
  329. return wert->z( i );
  330. }
  331. return 0;
  332. }
  333. Text *InitDatei::zWert( int num )
  334. {
  335. if( num >= feldAnzahl )
  336. return 0;
  337. return wert->z( num );
  338. }
  339. Text *InitDatei::getName( int num )
  340. {
  341. if( num >= feldAnzahl )
  342. return 0;
  343. return name->get( num );
  344. }
  345. Text *InitDatei::zName( int num )
  346. {
  347. if( num >= feldAnzahl )
  348. return 0;
  349. return name->z( num );
  350. }
  351. Text *InitDatei::getPfad() const
  352. {
  353. return pfad->getThis();
  354. }
  355. Text *InitDatei::zPfad() const
  356. {
  357. return pfad;
  358. }
  359. // reference Counting
  360. InitDatei *InitDatei::getThis()
  361. {
  362. ++ref;
  363. return this;
  364. }
  365. InitDatei *InitDatei::release()
  366. {
  367. --ref;
  368. if( !ref )
  369. delete this;
  370. return 0;
  371. }