KSGTDatei.cpp 5.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252
  1. #include "KSGTDatei.h"
  2. #include "Datei.h"
  3. #include "Text.h"
  4. using namespace Framework;
  5. // Inhalt der KSGTDatei Klasse aus KSGTDatei.h
  6. // Konstruktor
  7. KSGTDatei::KSGTDatei()
  8. : ReferenceCounter(),
  9. pfad(new Text()),
  10. data(new RCArray<RCArray<Text>>())
  11. {}
  12. KSGTDatei::KSGTDatei(const char* pfad)
  13. : ReferenceCounter(),
  14. pfad(new Text()),
  15. data(new RCArray<RCArray<Text>>())
  16. {
  17. setPfad(pfad);
  18. }
  19. KSGTDatei::KSGTDatei(Text* pfad)
  20. : ReferenceCounter(),
  21. pfad(new Text()),
  22. data(new RCArray<RCArray<Text>>())
  23. {
  24. setPfad(pfad);
  25. }
  26. // Destruktor
  27. KSGTDatei::~KSGTDatei()
  28. {
  29. pfad->release();
  30. data->release();
  31. }
  32. // nicht constant
  33. void KSGTDatei::setPfad(const char* pfad)
  34. {
  35. this->pfad->setText(pfad);
  36. }
  37. void KSGTDatei::setPfad(Text* pfad)
  38. {
  39. this->pfad->setText(pfad);
  40. }
  41. bool KSGTDatei::laden()
  42. {
  43. std::ifstream inf;
  44. inf.open(pfad->getText(), std::ios::binary);
  45. if (!inf.good() || !inf.is_open()) return 0;
  46. data->leeren();
  47. inf.seekg(0, std::ios::end);
  48. __int64 gr = inf.tellg();
  49. __int64 pos = 0;
  50. int zeilenPos = 0;
  51. int feldPos = 0;
  52. while (pos < gr)
  53. {
  54. inf.seekg(pos, std::ios::beg);
  55. char c = 1;
  56. int len = 0;
  57. do
  58. {
  59. inf.read(&c, 1);
  60. ++len;
  61. } while (c != 0 && c != '\n' && pos + len < gr);
  62. if (pos + len == gr) ++len;
  63. inf.seekg(pos, std::ios::beg);
  64. char* v = new char[len];
  65. v[len - 1] = 0;
  66. if (len > 1) inf.read(v, len - 1);
  67. pos += len;
  68. if (zeilenPos > data->getLastIndex()) data->add(new RCArray<Text>);
  69. auto line = data->z(zeilenPos);
  70. if (feldPos > line->getLastIndex())
  71. line->add(new Text(v));
  72. else
  73. line->z(feldPos)->setText(v);
  74. delete[] v;
  75. if (c == 0)
  76. ++feldPos;
  77. else if (c == '\n')
  78. {
  79. ++zeilenPos;
  80. feldPos = 0;
  81. }
  82. else
  83. break;
  84. }
  85. inf.close();
  86. return 1;
  87. }
  88. bool KSGTDatei::addZeile(int feldAnzahl, RCArray<Text>* zWert)
  89. {
  90. auto line = new RCArray<Text>();
  91. data->add(line);
  92. for (Text* t : *zWert)
  93. line->add((Text*)t ? new Text(t->getText()) : 0);
  94. return 1;
  95. }
  96. bool KSGTDatei::setZeile(int zeile, int feldAnzahl, RCArray<Text>* zWert)
  97. {
  98. int zA = getZeilenAnzahl();
  99. if (zeile >= zA) return 0;
  100. auto line = new RCArray<Text>();
  101. data->set(line, zeile);
  102. for (Text* t : *zWert)
  103. line->add(t ? new Text(t->getText()) : 0);
  104. return 1;
  105. }
  106. bool KSGTDatei::removeZeile(int zeile)
  107. {
  108. int zA = getZeilenAnzahl();
  109. if (zeile >= zA) return 0;
  110. data->remove(zeile);
  111. return 1;
  112. }
  113. bool KSGTDatei::addFeld(int zeile, int pos, Text* wert)
  114. {
  115. int zA = getZeilenAnzahl();
  116. if (zeile >= zA)
  117. {
  118. wert->release();
  119. return 0;
  120. }
  121. int fA = getFeldAnzahl(zeile);
  122. if (pos > fA)
  123. {
  124. wert->release();
  125. return 0;
  126. }
  127. data->z(zeile)->add(new Text(wert->getText()), pos);
  128. wert->release();
  129. return 1;
  130. }
  131. bool KSGTDatei::addFeld(int zeile, int pos, const char* wert)
  132. {
  133. return addFeld(zeile, pos, new Text(wert));
  134. }
  135. bool KSGTDatei::addFeld(int zeile, Text* wert)
  136. {
  137. int zA = getZeilenAnzahl();
  138. if (zeile >= zA)
  139. {
  140. wert->release();
  141. return 0;
  142. }
  143. data->z(zeile)->add(new Text(wert->getText()));
  144. wert->release();
  145. return 1;
  146. }
  147. bool KSGTDatei::addFeld(int zeile, const char* wert)
  148. {
  149. return addFeld(zeile, new Text(wert));
  150. }
  151. bool KSGTDatei::setFeld(int zeile, int feld, Text* wert)
  152. {
  153. int zA = getZeilenAnzahl();
  154. if (zeile >= zA)
  155. {
  156. wert->release();
  157. return 0;
  158. }
  159. int fA = getFeldAnzahl(zeile);
  160. if (feld >= fA)
  161. {
  162. wert->release();
  163. return 0;
  164. }
  165. data->z(zeile)->set(new Text(wert->getText()), feld);
  166. wert->release();
  167. return 1;
  168. }
  169. bool KSGTDatei::setFeld(int zeile, int feld, const char* wert)
  170. {
  171. return setFeld(zeile, feld, new Text(wert));
  172. }
  173. bool KSGTDatei::removeFeld(int zeile, int feld)
  174. {
  175. int zA = getZeilenAnzahl();
  176. if (zeile >= zA) return 0;
  177. int fA = getFeldAnzahl(zeile);
  178. if (feld >= fA) return 0;
  179. data->z(zeile)->remove(feld);
  180. return 1;
  181. }
  182. bool KSGTDatei::speichern()
  183. {
  184. if (!pfad->getLength()) return 0;
  185. if (!DateiExistiert(pfad->getText())) DateiPfadErstellen(pfad->getText());
  186. std::ofstream of(pfad->getText(), std::ios::binary);
  187. if (!of.good() || !of.is_open()) return 0;
  188. int i = 0;
  189. for (auto line = data->begin(); line; line++, i++)
  190. {
  191. if (i) of.write("\n", 1);
  192. int f = 0;
  193. for (auto field = line->begin(); field; field++, f++)
  194. {
  195. if (f) of.write("\0", 1);
  196. if ((Text*)field) of.write(field->getText(), field->getLength());
  197. }
  198. }
  199. of.close();
  200. return 1;
  201. }
  202. // constant
  203. int KSGTDatei::getZeilenAnzahl() const
  204. {
  205. return data->getEintragAnzahl();
  206. }
  207. int KSGTDatei::getFeldAnzahl(int zeile) const
  208. {
  209. int zA = getZeilenAnzahl();
  210. if (zeile >= zA) return 0;
  211. return data->z(zeile)->getEintragAnzahl();
  212. }
  213. Text* KSGTDatei::getFeld(int zeile, int feld) const
  214. {
  215. int zA = getZeilenAnzahl();
  216. if (zeile >= zA) return 0;
  217. int fA = getFeldAnzahl(zeile);
  218. if (feld >= fA) return 0;
  219. return data->z(zeile)->get(feld);
  220. }
  221. Text* KSGTDatei::zFeld(int zeile, int feld) const
  222. {
  223. int zA = getZeilenAnzahl();
  224. if (zeile >= zA) return 0;
  225. int fA = getFeldAnzahl(zeile);
  226. if (feld >= fA) return 0;
  227. return data->z(zeile)->z(feld);
  228. }