Datei.cpp 21 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851
  1. #include "Datei.h"
  2. #include "Key.h"
  3. #include "Text.h"
  4. #include "Zeit.h"
  5. #ifdef WIN32
  6. # include <direct.h>
  7. # include <Shlwapi.h>
  8. # pragma comment(lib, "Shlwapi.lib")
  9. #else
  10. # include <dirent.h>
  11. # include <stdio.h>
  12. # include <sys/stat.h>
  13. #endif
  14. using namespace Framework;
  15. using namespace Encryption;
  16. // Inhalt der Datei Klasse aus Datei.h
  17. // Konstruktor
  18. Datei::Datei()
  19. : ReferenceCounter(),
  20. stream(0),
  21. pfad(0),
  22. gr(0),
  23. tmpLByte(0),
  24. tmpLBPos(7),
  25. tmpSByte(0),
  26. tmpSBPos(-1),
  27. key(0)
  28. {}
  29. //! Konstruktor
  30. Datei::Datei(const char* pfad)
  31. : Datei()
  32. {
  33. setDatei(pfad);
  34. }
  35. //! Konstruktor
  36. Datei::Datei(Text* pfad)
  37. : Datei()
  38. {
  39. setDatei(pfad);
  40. }
  41. // Destruktor
  42. Datei::~Datei()
  43. {
  44. if (key) key->release();
  45. if (stream) delete stream;
  46. if (pfad) pfad->release();
  47. }
  48. // nicht constant
  49. void Datei::setDatei(const char* pfad) // setzt die Datei
  50. {
  51. if (istOffen()) close();
  52. if (!this->pfad) this->pfad = new Text();
  53. this->pfad->setText(pfad);
  54. gr = 0;
  55. }
  56. void Datei::setDatei(Text* pfad)
  57. {
  58. if (istOffen()) close();
  59. if (!this->pfad) this->pfad = new Text();
  60. this->pfad->setText(pfad);
  61. gr = 0;
  62. }
  63. bool Datei::umbenennen(
  64. const char* pfad) // benennt die Datei um und verschiebt sie eventuell
  65. {
  66. if (!pfad) return 0;
  67. if (DateiUmbenennen(this->pfad->getText(), pfad))
  68. {
  69. this->pfad->setText(pfad);
  70. return 1;
  71. }
  72. return 0;
  73. }
  74. bool Datei::umbenennen(Text* pfad)
  75. {
  76. if (!this->pfad)
  77. {
  78. pfad->release();
  79. return 0;
  80. }
  81. if (DateiUmbenennen(this->pfad->getText(), pfad->getText()))
  82. {
  83. this->pfad->setText(pfad);
  84. return 1;
  85. }
  86. pfad->release();
  87. return 0;
  88. }
  89. bool Datei::remove() // löscht die Datei
  90. {
  91. if (!pfad) return 0;
  92. return DateiRemove(dynamic_cast<Text*>(pfad->getThis()));
  93. }
  94. bool Datei::erstellen() // erstellt die Datei
  95. {
  96. if (!pfad) return 0;
  97. return DateiPfadErstellen(dynamic_cast<Text*>(pfad->getThis()));
  98. }
  99. bool Datei::open(int style) // öffnet die Datei
  100. {
  101. if (!pfad) return 0;
  102. if (stream) delete stream;
  103. stream = new std::fstream();
  104. std::ios_base::openmode om = std::ios::binary;
  105. if ((style | Style::lesen) == style) om |= std::ios::in;
  106. if ((style | Style::schreiben) == style) om |= std::ios::out;
  107. stream->open(pfad->getText(), om);
  108. if ((style | Style::ende) == style)
  109. {
  110. if ((style | Style::lesen) == style) stream->seekg(0, std::ios::end);
  111. if ((style | Style::schreiben) == style)
  112. stream->seekp(0, std::ios::end);
  113. }
  114. if (!stream->is_open() || !stream->good())
  115. {
  116. delete stream;
  117. stream = 0;
  118. return 0;
  119. }
  120. tmpLBPos = 7;
  121. tmpSBPos = -1;
  122. return 1;
  123. }
  124. void Datei::setLPosition(__int64 pos, bool ende) // setzt die Leseposition
  125. {
  126. if (!pfad) return;
  127. if (stream)
  128. {
  129. if (ende)
  130. stream->seekg(pos, std::ios::end);
  131. else
  132. stream->seekg(pos, std::ios::beg);
  133. }
  134. tmpLBPos = 7;
  135. }
  136. void Datei::setSPosition(__int64 pos, bool ende) // setzt die Schreibeposition
  137. {
  138. if (!pfad) return;
  139. if (stream)
  140. {
  141. if (ende)
  142. stream->seekp(pos, std::ios::end);
  143. else
  144. stream->seekp(pos, std::ios::beg);
  145. }
  146. tmpSBPos = -1;
  147. }
  148. void Datei::schreibe(const char* bytes, int len) // schreibt bytes in datei
  149. {
  150. if (!pfad || !stream) return;
  151. if (tmpSBPos >= 0)
  152. {
  153. tmpSBPos = -1;
  154. stream->write(&tmpSByte, 1);
  155. tmpSByte = 0;
  156. }
  157. if (key)
  158. {
  159. key->setPos(getSPosition());
  160. Bytes* n = new Bytes(bytes, len);
  161. key->codieren(dynamic_cast<Bytes*>(n->getThis()));
  162. stream->write(n->getBytes(), len);
  163. n->release();
  164. }
  165. else
  166. stream->write(bytes, len);
  167. }
  168. void Datei::lese(char* bytes, int len) // ließt bytes aus datei
  169. {
  170. if (!pfad) return;
  171. if (stream)
  172. {
  173. __int64 tmp = getLPosition();
  174. stream->read(bytes, len);
  175. if (key)
  176. {
  177. key->setPos(tmp);
  178. Bytes* n = new Bytes();
  179. n->setBytesZ(bytes, len);
  180. key->decodieren(n);
  181. }
  182. }
  183. tmpLBPos = 7;
  184. tmpSBPos = -1;
  185. }
  186. Text* Datei::leseZeile() // ließt eine zeile
  187. {
  188. if (!pfad || !stream) return 0;
  189. if (istEnde()) return 0;
  190. Text* ret = new Text("");
  191. __int64 len = getSize();
  192. for (char c = 0; c != '\n' && stream->tellg() < len;)
  193. {
  194. __int64 tmp = getLPosition();
  195. stream->read(&c, 1);
  196. if (key)
  197. {
  198. key->setPos(tmp);
  199. Bytes* n = new Bytes();
  200. n->setBytesZ(&c, 1);
  201. key->decodieren(n);
  202. }
  203. if (c) ret->append(&c, 1);
  204. }
  205. tmpSBPos = 7;
  206. tmpSBPos = -1;
  207. return ret;
  208. }
  209. void Datei::close() // schließt die Datei
  210. {
  211. if (!pfad || !stream) return;
  212. if (tmpSBPos >= 0)
  213. {
  214. if (key)
  215. {
  216. key->setPos(getSPosition());
  217. Bytes* n = new Bytes(&tmpSByte, 1);
  218. key->codieren(dynamic_cast<Bytes*>(n->getThis()));
  219. stream->write(n->getBytes(), 1);
  220. n->release();
  221. }
  222. else
  223. stream->write(&tmpSByte, 1);
  224. }
  225. stream->close();
  226. delete stream;
  227. stream = 0;
  228. }
  229. #ifdef WIN32
  230. bool Datei::setLetzteÄnderung(Zeit* zeit) // setzt das änderungsdatum der Datei
  231. {
  232. if (!pfad)
  233. {
  234. zeit->release();
  235. return 0;
  236. }
  237. HANDLE hFile = CreateFile(pfad->getText(),
  238. GENERIC_READ,
  239. FILE_SHARE_READ,
  240. NULL,
  241. OPEN_EXISTING,
  242. 0,
  243. NULL);
  244. if (hFile == INVALID_HANDLE_VALUE)
  245. {
  246. zeit->release();
  247. return 0;
  248. }
  249. FILETIME ftCreate, ftAccess, ftWrite;
  250. if (!GetFileTime(hFile, &ftCreate, &ftAccess, &ftWrite))
  251. {
  252. CloseHandle(hFile);
  253. zeit->release();
  254. return 0;
  255. }
  256. SYSTEMTIME stUTC, stLocal;
  257. stLocal.wMilliseconds = 0;
  258. stLocal.wSecond = zeit->zUhrzeit()->getSekunde();
  259. stLocal.wMinute = zeit->zUhrzeit()->getMinute();
  260. stLocal.wHour = zeit->zUhrzeit()->getStunde();
  261. stLocal.wDay = zeit->zDatum()->getTag();
  262. stLocal.wMonth = zeit->zDatum()->getMonat();
  263. stLocal.wYear = zeit->zDatum()->getJahr();
  264. zeit->release();
  265. if (!TzSpecificLocalTimeToSystemTime(NULL, &stLocal, &stUTC))
  266. {
  267. CloseHandle(hFile);
  268. return 0;
  269. }
  270. if (!SystemTimeToFileTime(&stUTC, &ftWrite))
  271. {
  272. CloseHandle(hFile);
  273. return 0;
  274. }
  275. if (!SetFileTime(hFile, &ftCreate, &ftAccess, &ftWrite))
  276. {
  277. CloseHandle(hFile);
  278. return 0;
  279. }
  280. CloseHandle(hFile);
  281. return 1;
  282. }
  283. #endif
  284. bool Datei::getNextBit(bool& bit) // Datei Bitweise auslesen
  285. {
  286. if (!pfad || !stream) return 0;
  287. if (tmpLBPos == 7)
  288. {
  289. tmpLBPos = -1;
  290. __int64 tmp = getLPosition();
  291. stream->read(&tmpLByte, 1);
  292. if (key)
  293. {
  294. key->setPos(tmp);
  295. Bytes* n = new Bytes();
  296. n->setBytesZ(&tmpLByte, 1);
  297. key->decodieren(n);
  298. }
  299. }
  300. tmpLBPos++;
  301. bit = (tmpLByte >> (7 - tmpLBPos)) & 1;
  302. return 1;
  303. }
  304. bool Datei::setNextBit(bool bit) // Datei Bitweise speichern
  305. {
  306. if (!pfad || !stream) return 0;
  307. tmpSBPos++;
  308. tmpSByte |= (char)(((char)bit << (7 - tmpSBPos)) & (1 << (7 - tmpSBPos)));
  309. if (tmpSBPos == 7)
  310. {
  311. tmpSBPos = -1;
  312. if (key)
  313. {
  314. key->setPos(getSPosition());
  315. Bytes* n = new Bytes(&tmpSByte, 1);
  316. key->codieren(dynamic_cast<Bytes*>(n->getThis()));
  317. stream->write(n->getBytes(), 1);
  318. n->release();
  319. }
  320. else
  321. stream->write(&tmpSByte, 1);
  322. tmpSByte = 0;
  323. }
  324. return 1;
  325. }
  326. // Setzt den Schlüssel für die Datei
  327. void Datei::setKey(char* s, int l)
  328. {
  329. if (l == 0)
  330. {
  331. key = (Key*)key->release();
  332. return;
  333. }
  334. if (key)
  335. key->setKey(s, l);
  336. else
  337. key = new Key(s, l);
  338. }
  339. // constant
  340. bool Datei::istOrdner() const // prüft, ob die Datei ein Ordner ist
  341. {
  342. if (!pfad) return 0;
  343. return DateiIstVerzeichnis(dynamic_cast<Text*>(pfad->getThis()));
  344. }
  345. bool Datei::istOffen() const // prüft, ob die Datei geöffnet ist
  346. {
  347. if (!pfad) return 0;
  348. if (stream) return stream->is_open() && stream->good();
  349. return 0;
  350. }
  351. int Datei::getUnterdateiAnzahl() const // gibt die Anzahl der unterdateien an
  352. {
  353. #ifdef WIN32
  354. if (!pfad) return 0;
  355. if (!DateiIstVerzeichnis(dynamic_cast<Text*>(pfad->getThis()))) return 0;
  356. int ret = 0;
  357. HANDLE fHandle;
  358. WIN32_FIND_DATA wfd;
  359. Text stxt = pfad->getText();
  360. stxt.ersetzen('/', '\\');
  361. if (stxt.positionVon('\\') == stxt.getLength() - 1)
  362. stxt.append("*");
  363. else
  364. stxt.append("\\*");
  365. fHandle = FindFirstFile(stxt.getText(), &wfd);
  366. FindNextFile(fHandle, &wfd);
  367. while (FindNextFile(fHandle, &wfd))
  368. ++ret;
  369. FindClose(fHandle);
  370. return ret;
  371. #else
  372. if (!pfad) return 0;
  373. if (!DateiIstVerzeichnis(dynamic_cast<Text*>(pfad->getThis()))) return 0;
  374. int ret = 0;
  375. Text stxt = pfad->getText();
  376. stxt.ersetzen('\\', '/');
  377. if (stxt.positionVon('/') == stxt.getLength() - 1)
  378. stxt.remove(stxt.getLength() - 1);
  379. DIR* hdir;
  380. hdir = opendir(stxt.getText());
  381. for (dirent* entry = readdir(hdir); entry; entry = readdir(hdir))
  382. {
  383. if (entry && entry->d_name[0] != '.') ++ret;
  384. }
  385. closedir(hdir);
  386. return ret;
  387. #endif
  388. }
  389. RCArray<Text>*
  390. Datei::getDateiListe() const // gibt eine Liste mit unterdateien zurück
  391. {
  392. #ifdef WIN32
  393. if (!pfad) return 0;
  394. if (!DateiIstVerzeichnis(dynamic_cast<Text*>(pfad->getThis()))) return 0;
  395. HANDLE fHandle;
  396. WIN32_FIND_DATA wfd;
  397. Text stxt = pfad->getText();
  398. stxt.ersetzen('/', '\\');
  399. if (stxt.positionVon('\\') == stxt.getLength() - 1)
  400. stxt.append("*");
  401. else
  402. stxt.append("\\*");
  403. fHandle = FindFirstFile(stxt.getText(), &wfd);
  404. FindNextFile(fHandle, &wfd);
  405. RCArray<Text>* ret = new RCArray<Text>();
  406. int count = 0;
  407. while (FindNextFile(fHandle, &wfd))
  408. {
  409. Text* txt = new Text(wfd.cFileName);
  410. ret->add(txt, count);
  411. ++count;
  412. }
  413. FindClose(fHandle);
  414. return ret;
  415. #else
  416. if (!pfad) return 0;
  417. if (!DateiIstVerzeichnis(dynamic_cast<Text*>(pfad->getThis()))) return 0;
  418. Text stxt = pfad->getText();
  419. stxt.ersetzen('\\', '/');
  420. if (stxt.positionVon('/') == stxt.getLength() - 1)
  421. stxt.remove(stxt.getLength() - 1);
  422. DIR* hdir;
  423. hdir = opendir(stxt.getText());
  424. if (hdir)
  425. {
  426. RCArray<Text>* ret = new RCArray<Text>();
  427. int count = 0;
  428. for (dirent* entry = readdir(hdir); entry; entry = readdir(hdir))
  429. {
  430. if (entry && entry->d_name[0] != '.')
  431. {
  432. ret->add(new Text(entry->d_name), count);
  433. ++count;
  434. }
  435. }
  436. closedir(hdir);
  437. return ret;
  438. }
  439. return 0;
  440. #endif
  441. }
  442. __int64 Datei::getSize() const // gibt die Größe der Datei zurück
  443. {
  444. if (!pfad) return 0;
  445. if (gr) return gr;
  446. if (!stream || !istOffen())
  447. {
  448. std::fstream* stream = new std::fstream();
  449. stream->open(pfad->getText(), std::ios::binary | std::ios::in);
  450. __int64 tmp = stream->tellg();
  451. stream->seekg(0, std::ios::end);
  452. __int64 ret = stream->tellg();
  453. stream->seekg(tmp, std::ios::beg);
  454. stream->close();
  455. delete stream;
  456. __int64* size = (__int64*)&gr;
  457. *size = ret;
  458. return ret;
  459. }
  460. __int64 tmp = stream->tellg();
  461. stream->seekg(0, std::ios::end);
  462. __int64 ret = stream->tellg();
  463. stream->seekg(tmp, std::ios::beg);
  464. __int64* size = (__int64*)&gr;
  465. *size = ret;
  466. return ret;
  467. }
  468. Zeit* Datei::getLastChange() const // gibt das Datum der letzten Änderung
  469. {
  470. if (!pfad) return 0;
  471. #ifdef WIN32
  472. HANDLE hFile = CreateFile(pfad->getText(),
  473. GENERIC_READ,
  474. FILE_SHARE_READ,
  475. NULL,
  476. OPEN_EXISTING,
  477. 0,
  478. NULL);
  479. if (hFile == INVALID_HANDLE_VALUE) return 0;
  480. FILETIME ftCreate, ftAccess, ftWrite;
  481. SYSTEMTIME stUTC, stLocal;
  482. if (!GetFileTime(hFile, &ftCreate, &ftAccess, &ftWrite))
  483. {
  484. CloseHandle(hFile);
  485. return 0;
  486. }
  487. CloseHandle(hFile);
  488. if (!FileTimeToSystemTime(&ftWrite, &stUTC)) return 0;
  489. if (!SystemTimeToTzSpecificLocalTime(NULL, &stUTC, &stLocal)) return 0;
  490. Zeit* ret = new Zeit();
  491. ret->setZeit(stLocal.wYear,
  492. stLocal.wMonth,
  493. stLocal.wDay,
  494. stLocal.wHour,
  495. stLocal.wMinute,
  496. stLocal.wSecond);
  497. return ret;
  498. #else
  499. struct stat attrib;
  500. if (stat(pfad->getText(), &attrib) != 0) return 0;
  501. tm* clock = gmtime(&(attrib.st_mtime));
  502. Zeit* ret = new Zeit();
  503. ret->setZeit(clock->tm_year + 1900,
  504. clock->tm_mon + 1,
  505. clock->tm_mday,
  506. clock->tm_hour,
  507. clock->tm_min,
  508. clock->tm_sec);
  509. return ret;
  510. #endif
  511. }
  512. bool Datei::existiert() const // prüft, ob die Datei existiert
  513. {
  514. if (!pfad) return 0;
  515. return DateiExistiert(dynamic_cast<Text*>(pfad->getThis()));
  516. }
  517. __int64 Datei::getLPosition() const // gibt die Leseposition zurück
  518. {
  519. if (!stream) return 0;
  520. return stream->tellg();
  521. }
  522. __int64 Datei::getSPosition() const // gibt die Schreibeposition zurück
  523. {
  524. if (!stream) return 0;
  525. return stream->tellp();
  526. }
  527. bool Datei::istEnde() const // prüft, ob die Datei zu ende ist
  528. {
  529. if (!stream || stream->tellg() < 0) return 1;
  530. __int64 i = getSize();
  531. return stream->tellg() >= i;
  532. }
  533. Text* Datei::getPfad() const // gibt den Dateipfad zurück
  534. {
  535. return pfad ? dynamic_cast<Text*>(pfad->getThis()) : 0;
  536. }
  537. Text* Datei::zPfad() const
  538. {
  539. return pfad;
  540. }
  541. // Datei Funktionen
  542. void Framework::GetFreePfad(Text* zPfad) // Sucht einen unbenutzten Dateinamen
  543. {
  544. Text txt = zPfad->getText();
  545. for (int i = 0; DateiExistiert(txt); i++)
  546. {
  547. txt = zPfad->getText();
  548. txt.append(i);
  549. }
  550. zPfad->setText(txt);
  551. }
  552. bool Framework::DateiPfadErstellen(
  553. Text* pfad) // Erstellt eine Datei in dem Pfad
  554. {
  555. bool ret = DateiPfadErstellen(pfad->getText());
  556. pfad->release();
  557. return ret;
  558. }
  559. bool Framework::DateiRemove(Text* pfad) // Löscht die angegebene Datei
  560. {
  561. bool ret = DateiRemove(pfad->getText());
  562. pfad->release();
  563. return ret;
  564. }
  565. bool Framework::DateiUmbenennen(
  566. Text* pfad_alt, Text* pfad_neu) // Benennt die Datei um
  567. {
  568. bool ret = DateiUmbenennen(pfad_alt->getText(), pfad_neu->getText());
  569. pfad_alt->release();
  570. pfad_neu->release();
  571. return ret;
  572. }
  573. bool Framework::DateiExistiert(Text* pfad) // Prüft, ob Datei existiert
  574. {
  575. bool ret = DateiExistiert(pfad->getText());
  576. pfad->release();
  577. return ret;
  578. }
  579. bool Framework::DateiIstVerzeichnis(
  580. Text* pfad) // prüft, ob pfad ein Verzeichnis ist
  581. {
  582. bool ret = DateiIstVerzeichnis(pfad->getText());
  583. pfad->release();
  584. return ret;
  585. }
  586. bool Framework::DateiPfadErstellen(
  587. const char* pfad) // Erstellt eine Datei in dem Pfad
  588. {
  589. Text pf = pfad;
  590. bool erst = 1;
  591. #ifdef WIN32
  592. pf.ersetzen("//", "\\"); // Pfadangaben korrigieren
  593. pf.ersetzen("/", "\\");
  594. for (int i = 0; i < pf.anzahlVon("\\");
  595. ++i) // Jeden ordner erstellen wenn er nicht existiert
  596. {
  597. Text* t = pf.getTeilText(0, pf.positionVon("\\", i));
  598. if (!t || !t->getLength())
  599. {
  600. if (t) t->release();
  601. continue;
  602. }
  603. if (!DateiExistiert(dynamic_cast<Text*>(t->getThis())))
  604. # pragma warning(suppress : 6031)
  605. _mkdir(t->getText());
  606. t->release();
  607. if (pf.positionVon("\\", i) == pf.getLength() - 1) erst = 0;
  608. }
  609. #else
  610. pf.ersetzen("\\", "/"); // Pfadangaben korrigieren
  611. for (int i = 0; i < pf.anzahlVon("/");
  612. ++i) // Jeden ordner erstellen wenn er nicht existiert
  613. {
  614. Text* t = pf.getTeilText(0, pf.positionVon("/", i));
  615. if (!t || !t->getLength())
  616. {
  617. if (t) t->release();
  618. continue;
  619. }
  620. if (!DateiExistiert(dynamic_cast<Text*>(t->getThis())))
  621. mkdir(t->getText(), 0777);
  622. t->release();
  623. if (pf.positionVon("\\", i) == pf.getLength() - 1) erst = 0;
  624. }
  625. #endif
  626. if (erst)
  627. {
  628. std::ofstream f(pf, std::ios::binary); // Datei erstellen
  629. f.close();
  630. }
  631. return DateiExistiert(pf);
  632. }
  633. bool Framework::DateiRemove(const char* pfad) // Löscht die angegebene Datei
  634. {
  635. Text pfa = pfad;
  636. #ifdef WIN32
  637. pfa.ersetzen('\\', '/');
  638. bool ret = 0;
  639. // prüfen ob Datei existiert
  640. if (!DateiIstVerzeichnis(dynamic_cast<Text*>(pfa.getThis())))
  641. ret = DeleteFile(pfa.getText()) == 1; // Datei löschen
  642. else
  643. {
  644. ret = 1;
  645. Datei* dat = new Datei();
  646. dat->setDatei(dynamic_cast<Text*>(pfa.getThis()));
  647. int anz = dat->getUnterdateiAnzahl();
  648. RCArray<Text>* liste = dat->getDateiListe();
  649. for (int i = 0; i < anz; ++i)
  650. {
  651. Text* pf = new Text(pfa.getText());
  652. if (pf->getText()[pf->getLength() - 1] != '/') pf->append("/");
  653. pf->append(liste->get(i));
  654. if (ret)
  655. ret = DateiRemove(pf);
  656. else
  657. DateiRemove(pf);
  658. }
  659. liste->release();
  660. dat->release();
  661. if (ret)
  662. ret = RemoveDirectory(pfa.getText()) == 1;
  663. else
  664. RemoveDirectory(pfa.getText());
  665. }
  666. return ret;
  667. #else
  668. pfa.ersetzen('\\', '/');
  669. bool ret = 0;
  670. // pruefen ob Datei existiert
  671. if (!DateiIstVerzeichnis(dynamic_cast<Text*>(pfa.getThis())))
  672. ret = std::remove(pfa.getText()) == 0; // Datei loeschen
  673. else
  674. {
  675. ret = 1;
  676. Datei* dat = new Datei();
  677. dat->setDatei(dynamic_cast<Text*>(pfa.getThis()));
  678. int anz = dat->getUnterdateiAnzahl();
  679. RCArray<Text>* liste = dat->getDateiListe();
  680. for (int i = 0; i < anz; ++i)
  681. {
  682. Text* pf = new Text(pfa.getText());
  683. if (pf->getText()[pf->getLength() - 1] != '/') pf->append("/");
  684. pf->append(liste->get(i));
  685. if (ret)
  686. ret = DateiRemove(pf);
  687. else
  688. DateiRemove(pf);
  689. }
  690. liste->release();
  691. dat->release();
  692. if (ret)
  693. ret = std::remove(pfa.getText()) == 0;
  694. else
  695. std::remove(pfa.getText());
  696. }
  697. return ret;
  698. #endif
  699. }
  700. bool Framework::DateiUmbenennen(
  701. const char* pfad_alt, const char* pfad_neu) // Benennt die Datei um
  702. {
  703. #ifdef WIN32
  704. if (pfad_alt && pfad_neu && DateiExistiert(pfad_alt))
  705. {
  706. bool ret = 1;
  707. if (DateiIstVerzeichnis(pfad_alt))
  708. {
  709. if (!DateiExistiert(pfad_neu))
  710. {
  711. Text tmp = pfad_neu;
  712. tmp += "/a";
  713. DateiPfadErstellen(tmp);
  714. DateiRemove(tmp);
  715. }
  716. Datei d;
  717. d.setDatei(pfad_alt);
  718. RCArray<Text>* list = d.getDateiListe();
  719. int anz = list->getEintragAnzahl();
  720. for (int i = 0; i < anz; i++)
  721. {
  722. Text pf = pfad_neu;
  723. pf += "/";
  724. pf += list->z(i)->getText();
  725. Text pf_a = pfad_alt;
  726. pf_a += "/";
  727. pf_a += list->z(i)->getText();
  728. ret |= DateiUmbenennen(pf_a, pf);
  729. }
  730. d.remove();
  731. }
  732. else
  733. {
  734. if (DateiExistiert(pfad_neu)) return 0;
  735. }
  736. ret |= MoveFile(pfad_alt, pfad_neu) == 1; // Datei umbenennen
  737. return ret;
  738. }
  739. return 0;
  740. #else
  741. if (pfad_alt && pfad_neu && DateiExistiert(pfad_alt))
  742. {
  743. bool ret = 1;
  744. if (DateiIstVerzeichnis(pfad_alt))
  745. {
  746. if (!DateiExistiert(pfad_neu))
  747. {
  748. Text tmp = pfad_neu;
  749. tmp += "/a";
  750. DateiPfadErstellen(tmp);
  751. DateiRemove(tmp);
  752. }
  753. Datei d;
  754. d.setDatei(pfad_alt);
  755. RCArray<Text>* list = d.getDateiListe();
  756. int anz = list->getEintragAnzahl();
  757. for (int i = 0; i < anz; i++)
  758. {
  759. Text pf = pfad_neu;
  760. pf += "/";
  761. pf += list->z(i)->getText();
  762. Text pf_a = pfad_alt;
  763. pf_a += "/";
  764. pf_a += list->z(i)->getText();
  765. ret |= DateiUmbenennen(pf_a, pf);
  766. }
  767. d.remove();
  768. }
  769. else
  770. {
  771. if (DateiExistiert(pfad_neu)) return 0;
  772. }
  773. ret |= rename(pfad_alt, pfad_neu) == 1; // Datei umbenennen
  774. return ret;
  775. }
  776. return 0;
  777. #endif
  778. }
  779. bool Framework::DateiExistiert(const char* pfad) // Prüft, ob Datei existiert
  780. {
  781. #ifdef WIN32
  782. bool ret = PathFileExists(pfad) != 0;
  783. return ret;
  784. #else
  785. std::ifstream file(pfad);
  786. if (file.good()) return 1;
  787. return 0;
  788. #endif
  789. }
  790. bool Framework::DateiIstVerzeichnis(
  791. const char* pfad) // prüft, ob pfad ein Verzeichnis ist
  792. {
  793. #ifdef WIN32
  794. WIN32_FIND_DATA wfd;
  795. HANDLE handle = FindFirstFile(pfad, &wfd);
  796. if (handle == INVALID_HANDLE_VALUE) return 0;
  797. FindClose(handle);
  798. return (wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0;
  799. #else
  800. struct stat path_stat;
  801. if (stat(pfad, &path_stat) != 0) return 0;
  802. if (S_ISDIR(path_stat.st_mode)) return 1;
  803. return 0;
  804. #endif
  805. }