Datei.cpp 21 KB

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