InitDatei.cpp 6.1 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314
  1. #include "InitDatei.h"
  2. #include "Datei.h"
  3. #include "Text.h"
  4. using namespace Framework;
  5. // Inhalt der InitDatei Klasse aus InitDatei.h
  6. // Konstruktor
  7. InitDatei::InitDatei()
  8. : ReferenceCounter(),
  9. pfad(new Text()),
  10. name(new RCArray<Text>()),
  11. wert(new RCArray<Text>())
  12. {}
  13. InitDatei::InitDatei(Text* pfad)
  14. : ReferenceCounter(),
  15. pfad(new Text()),
  16. name(new RCArray<Text>()),
  17. wert(new RCArray<Text>())
  18. {
  19. setPfad(pfad);
  20. }
  21. InitDatei::InitDatei(const char* pfad)
  22. : ReferenceCounter(),
  23. pfad(new Text()),
  24. name(new RCArray<Text>()),
  25. wert(new RCArray<Text>())
  26. {
  27. setPfad(pfad);
  28. }
  29. // Destruktor
  30. InitDatei::~InitDatei()
  31. {
  32. pfad->release();
  33. name->release();
  34. wert->release();
  35. }
  36. // nicht constant
  37. void InitDatei::setPfad(Text* pfad)
  38. {
  39. this->pfad->setText(pfad);
  40. }
  41. void InitDatei::setPfad(const char* pfad)
  42. {
  43. this->pfad->setText(pfad);
  44. }
  45. bool InitDatei::laden()
  46. {
  47. Datei* dat = new Datei();
  48. dat->setDatei(pfad->getText());
  49. if (!dat->open(Datei::Style::lesen))
  50. {
  51. dat->release();
  52. return 0;
  53. }
  54. removeAlle();
  55. Text* zeile = dat->leseZeile();
  56. while (zeile)
  57. {
  58. zeile->remove("\r\n");
  59. zeile->remove("\n");
  60. Text* n = zeile->getTeilText(0, zeile->positionVon('='));
  61. Text* w = zeile->getTeilText(zeile->positionVon('=') + 1);
  62. name->add(n);
  63. wert->add(w);
  64. zeile->release();
  65. zeile = dat->leseZeile();
  66. }
  67. dat->close();
  68. dat->release();
  69. return 1;
  70. }
  71. bool InitDatei::addWert(Text* name, Text* wert)
  72. {
  73. if (!wertExistiert(name->getText()))
  74. {
  75. this->name->add(new Text(name->getText()));
  76. this->wert->add(new Text(wert->getText()));
  77. name->release();
  78. wert->release();
  79. return 1;
  80. }
  81. name->release();
  82. wert->release();
  83. return 0;
  84. }
  85. bool InitDatei::addWert(const char* name, const char* wert)
  86. {
  87. return addWert(new Text(name), new Text(wert));
  88. }
  89. bool InitDatei::setWert(Text* name, Text* wert)
  90. {
  91. if (!wertExistiert(name->getText()))
  92. {
  93. name->release();
  94. wert->release();
  95. return 0;
  96. }
  97. auto n = this->name->begin();
  98. for (auto v = this->wert->begin(); v; v++, n++)
  99. {
  100. if (n->istGleich(name->getText()))
  101. {
  102. v->setText(wert->getText());
  103. name->release();
  104. wert->release();
  105. return 1;
  106. }
  107. }
  108. name->release();
  109. wert->release();
  110. return 0;
  111. }
  112. bool InitDatei::setWert(const char* name, const char* wert)
  113. {
  114. return setWert(new Text(name), new Text(wert));
  115. }
  116. bool InitDatei::setWert(int num, Text* wert)
  117. {
  118. bool result = setWert(num, wert->getText());
  119. wert->release();
  120. return result;
  121. }
  122. bool InitDatei::setWert(int num, const char* wert)
  123. {
  124. if (num >= name->getEintragAnzahl()) return 0;
  125. this->wert->z(num)->setText(wert);
  126. return 1;
  127. }
  128. bool InitDatei::removeWert(Text* name)
  129. {
  130. bool result = removeWert(name->getText());
  131. name->release();
  132. return result;
  133. }
  134. bool InitDatei::removeWert(const char* name)
  135. {
  136. if (!wertExistiert(name)) return 0;
  137. for (int i = 0; i < wert->getEintragAnzahl(); ++i)
  138. {
  139. if (this->name->z(i)->istGleich(name))
  140. {
  141. this->name->remove(i);
  142. this->wert->remove(i);
  143. return 1;
  144. }
  145. }
  146. return 0;
  147. }
  148. bool InitDatei::removeWert(int num)
  149. {
  150. if (num >= wert->getEintragAnzahl()) return 0;
  151. this->name->remove(num);
  152. this->wert->remove(num);
  153. return 1;
  154. }
  155. void InitDatei::removeAlle()
  156. {
  157. while (wert->getEintragAnzahl() > 0)
  158. {
  159. this->name->remove(0);
  160. this->wert->remove(0);
  161. }
  162. }
  163. bool InitDatei::speichern()
  164. {
  165. Datei* dat = new Datei();
  166. dat->setDatei(pfad->getText());
  167. if (!dat->existiert()) dat->erstellen();
  168. if (!dat->open(Datei::Style::schreiben))
  169. {
  170. dat->release();
  171. return 0;
  172. }
  173. auto n = name->begin();
  174. for (auto v = wert->begin(); v; v++, n++)
  175. {
  176. Text* zeile = new Text("");
  177. zeile->append(n->getText());
  178. zeile->append("=");
  179. zeile->append(v->getText());
  180. zeile->append("\n");
  181. dat->schreibe(zeile->getText(), zeile->getLength());
  182. zeile->release();
  183. }
  184. dat->close();
  185. dat->release();
  186. return 1;
  187. }
  188. // constant
  189. int InitDatei::getWertAnzahl() const
  190. {
  191. return name->getEintragAnzahl();
  192. }
  193. bool InitDatei::wertExistiert(Text* name)
  194. {
  195. bool result = wertExistiert(name->getText());
  196. name->release();
  197. return result;
  198. }
  199. bool InitDatei::wertExistiert(const char* name)
  200. {
  201. for (Text* n : *this->name)
  202. {
  203. if (n->istGleich(name)) return 1;
  204. }
  205. return 0;
  206. }
  207. int InitDatei::getWertNummer(Text* name)
  208. {
  209. int result = getWertNummer(name->getText());
  210. name->release();
  211. return result;
  212. }
  213. int InitDatei::getWertNummer(const char* name)
  214. {
  215. int i = 0;
  216. for (Text* n : *this->name)
  217. {
  218. if (n->istGleich(name)) return i;
  219. }
  220. return -1;
  221. }
  222. Text* InitDatei::getWert(Text* name)
  223. {
  224. Text* result = getWert(name->getText());
  225. name->release();
  226. return result;
  227. }
  228. Text* InitDatei::getWert(const char* name)
  229. {
  230. auto v = wert->begin();
  231. for (auto n = this->name->begin(); n; n++, v++)
  232. {
  233. if (n->istGleich(name)) return dynamic_cast<Text*>(v->getThis());
  234. }
  235. return 0;
  236. }
  237. Text* InitDatei::getWert(int num)
  238. {
  239. if (num >= name->getEintragAnzahl()) return 0;
  240. return wert->get(num);
  241. }
  242. Text* InitDatei::zWert(Text* name)
  243. {
  244. Text* result = zWert(name->getText());
  245. name->release();
  246. return result;
  247. }
  248. Text* InitDatei::zWert(const char* name)
  249. {
  250. auto v = wert->begin();
  251. for (auto n = this->name->begin(); n; n++, v++)
  252. {
  253. if (n->istGleich(name)) return v;
  254. }
  255. return 0;
  256. }
  257. Text* InitDatei::zWert(int num)
  258. {
  259. if (num >= wert->getEintragAnzahl()) return 0;
  260. return wert->z(num);
  261. }
  262. Text* InitDatei::getName(int num)
  263. {
  264. if (num >= name->getEintragAnzahl()) return 0;
  265. return name->get(num);
  266. }
  267. Text* InitDatei::zName(int num)
  268. {
  269. if (num >= name->getEintragAnzahl()) return 0;
  270. return name->z(num);
  271. }
  272. Text* InitDatei::getPfad() const
  273. {
  274. return dynamic_cast<Text*>(pfad->getThis());
  275. }
  276. Text* InitDatei::zPfad() const
  277. {
  278. return pfad;
  279. }