Datei.cpp 21 KB

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