Datei.cpp 22 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862
  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. : 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. // 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( dynamic_cast<Text *>( pfad->getThis() ) );
  89. }
  90. bool Datei::erstellen() // erstellt die Datei
  91. {
  92. if( !pfad )
  93. return 0;
  94. return DateiPfadErstellen( dynamic_cast<Text *>( 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( const 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( dynamic_cast<Bytes *>( 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( dynamic_cast<Bytes *>( 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( dynamic_cast<Bytes *>( 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 *)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( dynamic_cast<Text *>( 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( dynamic_cast<Text *>( 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( dynamic_cast<Text *>( 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( dynamic_cast<Text *>( 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 ? dynamic_cast<Text *>( pfad->getThis() ) : 0;
  547. }
  548. Text *Datei::zPfad() const
  549. {
  550. return pfad;
  551. }
  552. // Datei Funktionen
  553. void Framework::GetFreePfad( Text *zPfad ) // Sucht einen unbenutzten Dateinamen
  554. {
  555. Text txt = zPfad->getText();
  556. for( int i = 0; DateiExistiert( txt ); i++ )
  557. {
  558. txt = zPfad->getText();
  559. txt.append( i );
  560. }
  561. zPfad->setText( txt );
  562. }
  563. bool Framework::DateiPfadErstellen( Text *pfad ) // Erstellt eine Datei in dem Pfad
  564. {
  565. bool ret = DateiPfadErstellen( pfad->getText() );
  566. pfad->release();
  567. return ret;
  568. }
  569. bool Framework::DateiRemove( Text *pfad ) // Löscht die angegebene Datei
  570. {
  571. bool ret = DateiRemove( pfad->getText() );
  572. pfad->release();
  573. return ret;
  574. }
  575. bool Framework::DateiUmbenennen( Text *pfad_alt, Text *pfad_neu ) // Benennt die Datei um
  576. {
  577. bool ret = DateiUmbenennen( pfad_alt->getText(), pfad_neu->getText() );
  578. pfad_alt->release();
  579. pfad_neu->release();
  580. return ret;
  581. }
  582. bool Framework::DateiExistiert( Text *pfad ) // Prüft, ob Datei existiert
  583. {
  584. bool ret = DateiExistiert( pfad->getText() );
  585. pfad->release();
  586. return ret;
  587. }
  588. bool Framework::DateiIstVerzeichnis( Text *pfad ) // prüft, ob pfad ein Verzeichnis ist
  589. {
  590. bool ret = DateiIstVerzeichnis( pfad->getText() );
  591. pfad->release();
  592. return ret;
  593. }
  594. bool Framework::DateiPfadErstellen( const char *pfad ) // Erstellt eine Datei in dem Pfad
  595. {
  596. Text pf = pfad;
  597. bool erst = 1;
  598. #ifdef WIN32
  599. pf.ersetzen( "//", "\\" ); // Pfadangaben korrigieren
  600. pf.ersetzen( "/", "\\" );
  601. for( int i = 0; i < pf.anzahlVon( "\\" ); ++i ) // Jeden ordner erstellen wenn er nicht existiert
  602. {
  603. Text *t = pf.getTeilText( 0, pf.positionVon( "\\", i ) );
  604. if( !t || !t->getLength() )
  605. {
  606. if( t )
  607. t->release();
  608. continue;
  609. }
  610. if( !DateiExistiert( dynamic_cast<Text *>( t->getThis() ) ) )
  611. #pragma warning(suppress: 6031)
  612. _mkdir( t->getText() );
  613. t->release();
  614. if( pf.positionVon( "\\", i ) == pf.getLength() - 1 )
  615. erst = 0;
  616. }
  617. #else
  618. pf.ersetzen( "\\", "/" ); // Pfadangaben korrigieren
  619. for( int i = 0; i < pf.anzahlVon( "/" ); ++i ) // Jeden ordner erstellen wenn er nicht existiert
  620. {
  621. Text *t = pf.getTeilText( 0, pf.positionVon( "/", i ) );
  622. if( !t || !t->getLength() )
  623. {
  624. if( t )
  625. t->release();
  626. continue;
  627. }
  628. if( !DateiExistiert( t->getThis() ) )
  629. mkdir( t->getText(), 0777 );
  630. t->release();
  631. if( pf.positionVon( "\\", i ) == pf.getLength() - 1 )
  632. erst = 0;
  633. }
  634. #endif
  635. if( erst )
  636. {
  637. std::ofstream f( pf, std::ios::binary ); // Datei erstellen
  638. f.close();
  639. }
  640. return DateiExistiert( pf );
  641. }
  642. bool Framework::DateiRemove( const char *pfad ) // Löscht die angegebene Datei
  643. {
  644. Text pfa = pfad;
  645. #ifdef WIN32
  646. pfa.ersetzen( '\\', '/' );
  647. bool ret = 0;
  648. // prüfen ob Datei existiert
  649. if( !DateiIstVerzeichnis( dynamic_cast<Text *>( pfa.getThis() ) ) )
  650. ret = DeleteFile( pfa.getText() ) == 1; // Datei löschen
  651. else
  652. {
  653. ret = 1;
  654. Datei *dat = new Datei();
  655. dat->setDatei( dynamic_cast<Text *>( pfa.getThis() ) );
  656. int anz = dat->getUnterdateiAnzahl();
  657. RCArray< Text > *liste = dat->getDateiListe();
  658. for( int i = 0; i < anz; ++i )
  659. {
  660. Text *pf = new Text( pfa.getText() );
  661. if( pf->getText()[ pf->getLength() - 1 ] != '/' )
  662. pf->append( "/" );
  663. pf->append( liste->get( i ) );
  664. if( ret )
  665. ret = DateiRemove( pf );
  666. else
  667. DateiRemove( pf );
  668. }
  669. liste->release();
  670. dat->release();
  671. if( ret )
  672. ret = RemoveDirectory( pfa.getText() ) == 1;
  673. else
  674. RemoveDirectory( pfa.getText() );
  675. }
  676. return ret;
  677. #else
  678. pfa.ersetzen( '\\', '/' );
  679. bool ret = 0;
  680. // pruefen ob Datei existiert
  681. if( !DateiIstVerzeichnis( pfa.getThis() ) )
  682. ret = std::remove( pfa.getText() ) == 0; // Datei loeschen
  683. else
  684. {
  685. ret = 1;
  686. Datei *dat = new Datei();
  687. dat->setDatei( pfa.getThis() );
  688. int anz = dat->getUnterdateiAnzahl();
  689. RCArray< Text > *liste = dat->getDateiListe();
  690. for( int i = 0; i < anz; ++i )
  691. {
  692. Text *pf = new Text( pfa.getText() );
  693. if( pf->getText()[ pf->getLength() - 1 ] != '/' )
  694. pf->append( "/" );
  695. pf->append( liste->get( i ) );
  696. if( ret )
  697. ret = DateiRemove( pf );
  698. else
  699. DateiRemove( pf );
  700. }
  701. liste->release();
  702. dat->release();
  703. if( ret )
  704. ret = std::remove( pfa.getText() ) == 0;
  705. else
  706. std::remove( pfa.getText() );
  707. }
  708. return ret;
  709. #endif
  710. }
  711. bool Framework::DateiUmbenennen( const char *pfad_alt, const char *pfad_neu ) // Benennt die Datei um
  712. {
  713. #ifdef WIN32
  714. if( pfad_alt && pfad_neu && DateiExistiert( pfad_alt ) )
  715. {
  716. bool ret = 1;
  717. if( DateiIstVerzeichnis( pfad_alt ) )
  718. {
  719. if( !DateiExistiert( pfad_neu ) )
  720. {
  721. Text tmp = pfad_neu;
  722. tmp += "/a";
  723. DateiPfadErstellen( tmp );
  724. DateiRemove( tmp );
  725. }
  726. Datei d;
  727. d.setDatei( pfad_alt );
  728. RCArray< Text > *list = d.getDateiListe();
  729. int anz = list->getEintragAnzahl();
  730. for( int i = 0; i < anz; i++ )
  731. {
  732. Text pf = pfad_neu;
  733. pf += "/";
  734. pf += list->z( i )->getText();
  735. Text pf_a = pfad_alt;
  736. pf_a += "/";
  737. pf_a += list->z( i )->getText();
  738. ret |= DateiUmbenennen( pf_a, pf );
  739. }
  740. d.remove();
  741. }
  742. else
  743. {
  744. if( DateiExistiert( pfad_neu ) )
  745. return 0;
  746. }
  747. ret |= MoveFile( pfad_alt, pfad_neu ) == 1; // Datei umbenennen
  748. return ret;
  749. }
  750. return 0;
  751. #else
  752. if( pfad_alt && pfad_neu && DateiExistiert( pfad_alt ) )
  753. {
  754. bool ret = 1;
  755. if( DateiIstVerzeichnis( pfad_alt ) )
  756. {
  757. if( !DateiExistiert( pfad_neu ) )
  758. {
  759. Text tmp = pfad_neu;
  760. tmp += "/a";
  761. DateiPfadErstellen( tmp );
  762. DateiRemove( tmp );
  763. }
  764. Datei d;
  765. d.setDatei( pfad_alt );
  766. RCArray< Text > *list = d.getDateiListe();
  767. int anz = list->getEintragAnzahl();
  768. for( int i = 0; i < anz; i++ )
  769. {
  770. Text pf = pfad_neu;
  771. pf += "/";
  772. pf += list->z( i )->getText();
  773. Text pf_a = pfad_alt;
  774. pf_a += "/";
  775. pf_a += list->z( i )->getText();
  776. ret |= DateiUmbenennen( pf_a, pf );
  777. }
  778. d.remove();
  779. }
  780. else
  781. {
  782. if( DateiExistiert( pfad_neu ) )
  783. return 0;
  784. }
  785. ret |= rename( pfad_alt, pfad_neu ) == 1; // Datei umbenennen
  786. return ret;
  787. }
  788. return 0;
  789. #endif
  790. }
  791. bool Framework::DateiExistiert( const char *pfad ) // Prüft, ob Datei existiert
  792. {
  793. #ifdef WIN32
  794. bool ret = PathFileExists( pfad ) != 0;
  795. return ret;
  796. #else
  797. std::ifstream file( pfad );
  798. if( file.good() )
  799. return 1;
  800. return 0;
  801. #endif
  802. }
  803. bool Framework::DateiIstVerzeichnis( const char *pfad ) // prüft, ob pfad ein Verzeichnis ist
  804. {
  805. #ifdef WIN32
  806. WIN32_FIND_DATA wfd;
  807. HANDLE handle = FindFirstFile( pfad, &wfd );
  808. if( handle == INVALID_HANDLE_VALUE )
  809. return 0;
  810. FindClose( handle );
  811. return ( wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY ) != 0;
  812. #else
  813. struct stat path_stat;
  814. stat( pfad, &path_stat );
  815. if( S_ISDIR( path_stat.st_mode ) )
  816. return 1;
  817. return 0;
  818. #endif
  819. }