Text.cpp 42 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648
  1. //---Include---
  2. #include "Text.h"
  3. #include <sstream>
  4. #include <iomanip>
  5. #include <math.h>
  6. #ifndef WIN32
  7. #include <string.h>
  8. #endif
  9. using namespace Framework;
  10. // inhalt der Text Klasse aus Text.h
  11. // Konstruktor
  12. Text::Text()
  13. : ReferenceCounter(),
  14. txt( 0 ),
  15. suchGBeg( 0 ),
  16. suchGEnd( 0 ),
  17. precision( 0 )
  18. {
  19. setText( "" );
  20. }
  21. Text::Text( const Text &txt )
  22. : Text()
  23. {
  24. setText( txt );
  25. }
  26. Text::Text( const char *t )
  27. : Text()
  28. {
  29. setText( t ); // Text setzen
  30. }
  31. Text::Text( int zahl )
  32. : Text()
  33. {
  34. *this = zahl;
  35. }
  36. // Erstellt ein neues Text Objekt mit einer zahl als text
  37. // num: Die Zahl, die im Text sein soll
  38. Text::Text( double num )
  39. : Text()
  40. {
  41. *this = num;
  42. }
  43. // Erstellt ein neues Text Objekt mit einer zahl als text
  44. // num: Die Zahl, die im Text sein soll
  45. Text::Text( float num )
  46. : Text()
  47. {
  48. *this = num;
  49. }
  50. // Destruktor
  51. Text::~Text()
  52. {
  53. delete[]txt;
  54. }
  55. void Text::toUpperCase()
  56. {
  57. if( !txt )
  58. return;
  59. int len = textLength( txt );
  60. for( int i = 0; i < len; i++ )
  61. {
  62. if( txt[ i ] >= 'a' && txt[ i ] <= 'z' )
  63. txt[ i ] = (char)( txt[ i ] - 32 );
  64. switch( txt[ i ] )
  65. {
  66. case 'ü':
  67. txt[ i ] = 'Ü';
  68. break;
  69. case 'ö':
  70. txt[ i ] = 'Ö';
  71. break;
  72. case 'ä':
  73. txt[ i ] = 'Ä';
  74. break;
  75. }
  76. }
  77. }
  78. void Text::toLowerCase()
  79. {
  80. if( !txt )
  81. return;
  82. int len = textLength( txt );
  83. for( int i = 0; i < len; i++ )
  84. {
  85. if( txt[ i ] >= 'A' && txt[ i ] <= 'Z' )
  86. txt[ i ] = (char)( txt[ i ] + 32 );
  87. switch( txt[ i ] )
  88. {
  89. case 'Ü':
  90. txt[ i ] = 'ü';
  91. break;
  92. case 'Ö':
  93. txt[ i ] = 'ö';
  94. break;
  95. case 'Ä':
  96. txt[ i ] = 'ä';
  97. break;
  98. }
  99. }
  100. }
  101. // nicht constant
  102. void Text::setSuchGrenzen( char gBeg, char gEnd ) // sucht bei jeder suchfunktion nicht zwischen den Zeichen gBeg und gEnd
  103. {
  104. suchGBeg = gBeg;
  105. suchGEnd = gEnd;
  106. }
  107. void Text::setText( const char *t ) // ersetzt den Text
  108. {
  109. delete[]txt; // alter Text löschen
  110. int l = (int)textLength( t ); // Länge des neuen Textes ermitteln
  111. txt = new char[ (__int64)l + 1 ]; // neuen Text erstellen
  112. for( int i = 0; i < l; ++i ) // Text befüllen
  113. txt[ i ] = t[ i ];
  114. txt[ l ] = '\0'; // Textende Festlegen
  115. }
  116. // unconstant
  117. void Text::setText( const char *t, int l ) // ersetzt den Text
  118. {
  119. delete[]txt; // alter Text löschen
  120. txt = new char[ (__int64)l + 1 ]; // neuen Text erstellen
  121. for( int i = 0; i < l; ++i ) // Text befüllen
  122. txt[ i ] = t[ i ];
  123. txt[ l ] = '\0'; // Textende Festlegen
  124. }
  125. void Text::setText( Text *t )
  126. {
  127. setText( t->getText() ); // Text setzen
  128. t->release(); // übergabe loslassen
  129. }
  130. void Text::append( char c ) // hängt an den Text an
  131. {
  132. append( &c, 1 );
  133. }
  134. void Text::append( const char *t ) // hängt an den Text an
  135. {
  136. int tl = (int)textLength( t ); // länge der übergabe
  137. int txl = getLength(); // länge des Textes
  138. char *res = new char[ (__int64)tl + txl + 1 ]; // neuen Text erstellen
  139. for( int i = 0; i < txl; ++i ) // mit jetzigem Text füllen
  140. res[ i ] = txt[ i ];
  141. for( int i = 0; i < tl; ++i ) // Übergabe anhängen
  142. res[ txl + i ] = t[ i ];
  143. res[ txl + tl ] = '\0'; // Textende festlegen
  144. setText( res ); // Test setzen
  145. delete[] res; // Speicher freigeben
  146. }
  147. void Text::appendHex( int num ) // hängt die zahl in hex anden Text an
  148. {
  149. int l = getLength();
  150. char *res = new char[ (__int64)l + 9 ];
  151. for( int i = 0; i < l; ++i )
  152. res[ i ] = txt[ i ];
  153. std::stringstream stream;
  154. stream << std::setfill( '0' ) << std::setw( (int)sizeof( int ) * 2 ) << std::hex << num;
  155. std::string str = stream.str();
  156. for( int i = l; i < l + 8; ++i )
  157. res[ i ] = str.c_str()[ i - l ];
  158. res[ l + 8 ] = 0;
  159. setText( res );
  160. delete[] res;
  161. }
  162. void Text::append( const char *t, int l ) // hängt an den Text an
  163. {
  164. int txl = getLength(); // länge des Textes
  165. char *res = new char[ (__int64)l + txl + 1 ]; // neuen Text erstellen
  166. for( int i = 0; i < txl; ++i ) // mit jetzigem Text füllen
  167. res[ i ] = txt[ i ];
  168. for( int i = 0; i < l; ++i ) // Übergabe anhängen
  169. res[ txl + i ] = t[ i ];
  170. res[ txl + l ] = '\0'; // Textende festlegen
  171. setText( res, txl + l ); // Test setzen
  172. delete[] res; // Speicher freigeben
  173. }
  174. void Text::append( Text *t )
  175. {
  176. if( t->getLength() > 0 ) // Auf unsinnige übergabe prüfen
  177. append( t->getText() ); // Text anhängen
  178. t->release(); // Übergabe loslassen
  179. }
  180. void Text::append( int num )
  181. {
  182. std::stringstream ss;
  183. ss << num;
  184. append( ss.str().c_str() );
  185. }
  186. // Hängt eine Zahl ans Ende Des Textes an
  187. // num: Die Zahl, die in einen Text umgewandelt und am Ende angehängt werden soll
  188. void Text::append( __int64 num )
  189. {
  190. std::stringstream ss;
  191. ss << num;
  192. append( ss.str().c_str() );
  193. }
  194. void Text::append( unsigned int num )
  195. {
  196. std::stringstream ss;
  197. ss << num;
  198. append( ss.str().c_str() );
  199. }
  200. void Text::append( double num )
  201. {
  202. std::stringstream ss;
  203. ss.precision( precision );
  204. ss << std::fixed << num;
  205. append( ss.str().c_str() );
  206. }
  207. void Text::append( float num )
  208. {
  209. std::stringstream ss;
  210. ss.precision( precision );
  211. ss << std::fixed << num;
  212. append( ss.str().c_str() );
  213. }
  214. void Text::insert( int p, char c ) // Fügt an stelle p ein
  215. {
  216. if( p > getLength() || p < 0 ) // Auf unsinnige übergabe prüfen
  217. return;
  218. int txl = getLength(); // Länge des Textes
  219. char *res = new char[ (__int64)txl + 2 ]; // neuer Text erstellen
  220. for( int i = 0; i < p; ++i ) // Text füllen
  221. res[ i ] = txt[ i ];
  222. res[ p ] = c;
  223. for( int i = p; i < txl; ++i ) // Text füllen
  224. res[ i + 1 ] = txt[ i ];
  225. res[ txl + 1 ] = '\0'; // Text ende festlegen
  226. setText( res ); // Text setzen
  227. delete[] res; // Speicher freigeben
  228. }
  229. void Text::insert( int p, const char *t ) // Fügt an stelle p ein
  230. {
  231. if( p > getLength() || p < 0 || textLength( t ) <= 0 ) // Auf unsinnige übergabe prüfen
  232. return;
  233. int tl = (int)textLength( t ); // Länge der übergabe
  234. int txl = getLength(); // Länge des Textes
  235. char *res = new char[ (__int64)tl + txl + 1 ]; // neuer Text erstellen
  236. for( int i = 0; i < p; ++i ) // Text füllen
  237. res[ i ] = txt[ i ];
  238. for( int i = 0; i < tl; ++i ) // Text einfügen
  239. res[ i + p ] = t[ i ];
  240. for( int i = p; i < txl; ++i ) // Text füllen
  241. res[ i + tl ] = txt[ i ];
  242. res[ tl + txl ] = '\0'; // Text ende festlegen
  243. setText( res ); // Text setzen
  244. delete[] res; // Speicher freigeben
  245. }
  246. void Text::insert( int p, Text *t )
  247. {
  248. if( t->getLength() > 0 ) // Auf unsinnige übergabe prüfen
  249. insert( p, t->getText() ); // Text einfügen
  250. t->release(); // Übergabe loslassen
  251. }
  252. void Text::ersetzen( int p1, int p2, const char *t ) // Ersetzt den Text von p1 bis p2
  253. {
  254. if( p1 > p2 )
  255. {
  256. int x = p1; // p1 und p2 tauschen
  257. p1 = p2;
  258. p2 = x;
  259. }
  260. remove( p1, p2 ); // Textabschnitt von p1 zu p2 löschen
  261. insert( p1, t ); // Übergabe bei p1 einfügen
  262. }
  263. void Text::ersetzen( int p1, int p2, Text *t )
  264. {
  265. if( t->getLength() >= 0 ) // Auf unsinnige übergabe prüfen
  266. ersetzen( p1, p2, t->getText() ); // Text ersetzen
  267. t->release(); // Übergabe loslassen
  268. }
  269. void Text::ersetzen( char c1, char c2 ) // ersetzt jedes c1 durch c2
  270. {
  271. if( c1 == '\0' || c2 == '\0' ) // Auf unsinnige übergabe prüfen
  272. return;
  273. if( !hat( c1 ) ) // prüfen ob c1 vorhanden
  274. return;
  275. int l = getLength(); // Text Länge
  276. int suchGCount = 0;
  277. for( int i = 0; i < l; ++i ) // Text durchsuchen
  278. {
  279. bool b = suchGCount != 0;
  280. if( txt[ i ] == c1 && !suchGCount )
  281. txt[ i ] = c2; // Text ersetzen
  282. if( txt[ i ] == suchGBeg )
  283. ++suchGCount;
  284. if( txt[ i ] == suchGEnd )
  285. --suchGCount;
  286. if( txt[ i ] == c1 && !suchGCount && b )
  287. txt[ i ] = c2; // Text ersetzen
  288. }
  289. }
  290. void Text::ersetzen( const char *t1, const char *t2 ) // ersetzt jedes t1 durch t2
  291. {
  292. int txl = getLength(); // Text Länge
  293. int t1l = (int)textLength( t1 ); // Länge der Übergaben
  294. int t2l = (int)textLength( t2 );
  295. if( t1l > txl || t1l <= 0 ) // Auf unsinnige übergabe prüfen
  296. return;
  297. if( !hat( t1 ) ) // prüfen ob t1 vorhanden
  298. return;
  299. int anz = anzahlVon( t1 ); // Anzahl von t1 im Text
  300. int *begin = new int[ anz ];
  301. int *end = new int[ anz ];
  302. for( int i = 0; i < anz; ++i ) // Positionen von t1 speichern
  303. {
  304. begin[ i ] = positionVon( t1, i );
  305. end[ i ] = begin[ i ] + t1l;
  306. }
  307. int resl = ( txl - ( anz * t1l ) ) + ( anz * t2l ) + 1; // Länge des Ergebneses
  308. char *res = new char[ resl ]; // neuer Text erstellen
  309. int rep = 0; // Speichert bei welchen t1 man sich befindet
  310. int last = 0; // Füllposition von txt
  311. int neu = 0; // Füllporition von res
  312. for( ; neu < resl; ++neu ) // Text befüllen
  313. {
  314. if( rep < anz && last == begin[ rep ] ) // Text ersetzen
  315. {
  316. last = end[ rep ];
  317. ++rep;
  318. for( int ii = 0; ii < t2l; ++ii )
  319. {
  320. if( neu >= resl )
  321. break;
  322. res[ neu ] = t2[ ii ];
  323. ++neu;
  324. }
  325. if( neu >= resl )
  326. break;
  327. --neu;
  328. }
  329. else // Text Kopieren
  330. {
  331. res[ neu ] = txt[ last ];
  332. ++last;
  333. }
  334. }
  335. res[ resl - 1 ] = '\0'; // Textende festlegen
  336. setText( res ); // Text setzen
  337. delete[]begin; // Speicher freigeben
  338. delete[]end;
  339. delete[] res;
  340. }
  341. void Text::ersetzen( Text *t1, const char *t2 )
  342. {
  343. if( t1->getLength() > 0 ) // Auf unsinnige übergabe prüfen
  344. ersetzen( t1->getText(), t2 ); // ersetzen
  345. t1->release(); // Übergabe loslassen
  346. }
  347. void Text::ersetzen( const char *t1, Text *t2 )
  348. {
  349. if( t2->getLength() >= 0 ) // Auf unsinnige übergabe prüfen
  350. ersetzen( t1, t2->getText() ); // ersetzen
  351. t2->release(); // Übergabe loslassen
  352. }
  353. void Text::ersetzen( Text *t1, Text *t2 )
  354. {
  355. if( t1->getLength() > 0 && t2->getLength() >= 0 ) // Auf unsinnige übergabe prüfen
  356. ersetzen( t1->getText(), t2->getText() ); // ersetzen
  357. t1->release(); // Übergaben loslassen
  358. t2->release();
  359. }
  360. void Text::ersetzen( int index, char c1, char c2 ) // ersetzt das i-te c1 durch c2
  361. {
  362. if( c1 == '\0' || c2 == '\0' || index < 0 ) // Auf unsinnige übergabe prüfen
  363. return;
  364. if( !hat( c1 ) ) // prüfen ob c1 vorhanden
  365. return;
  366. int anz = anzahlVon( c1 );
  367. if( index >= anz ) // prüfen ob es ein i-tes c1 gibt
  368. return;
  369. txt[ positionVon( c1, index ) ] = c2;
  370. }
  371. void Text::ersetzen( int index, const char *t1, const char *t2 ) // ersetzt das i-te t1 durch t2
  372. {
  373. int txl = getLength(); // Text Länge
  374. int t1l = (int)textLength( t1 ); // Länge der Übergaben
  375. if( t1l >= txl || t1l <= 0 || index < 0 ) // Auf unsinnige übergabe prüfen
  376. return;
  377. if( !hat( t1 ) ) // prüfen ob t1 vorhanden
  378. return;
  379. int anz = anzahlVon( t1 ); // Anzahl von t1 im Text
  380. if( index >= anz ) // prüfen ob es ein i-tes t1 gibt
  381. return;
  382. int begin = positionVon( t1, index );
  383. int end = begin + t1l;
  384. ersetzen( begin, end, t2 ); // ersetzen
  385. }
  386. void Text::ersetzen( int i, Text *t1, const char *t2 )
  387. {
  388. if( t1->getLength() > 0 ) // Auf unsinnige übergabe prüfen
  389. ersetzen( i, t1->getText(), t2 ); // ersetzen
  390. t1->release(); // Übergabe loslassen
  391. }
  392. void Text::ersetzen( int i, const char *t1, Text *t2 )
  393. {
  394. if( t2->getLength() >= 0 ) // Auf unsinnige übergabe prüfen
  395. ersetzen( i, t1, t2->getText() ); // ersetzen
  396. t2->release(); // Übergabe loslassen
  397. }
  398. void Text::ersetzen( int i, Text *t1, Text *t2 )
  399. {
  400. if( t1->getLength() > 0 || t2->getLength() >= 0 ) // Auf unsinnige übergabe prüfen
  401. ersetzen( i, t1->getText(), t2->getText() ); // ersetzen
  402. t1->release(); // Übergaben loslassen
  403. t2->release();
  404. }
  405. void Text::fillText( char c, int len ) // setzt den Text zu so vielen c wie län groß ist
  406. {
  407. char *res = new char[ (__int64)len + 1 ];
  408. for( int i = 0; i < len; ++i )
  409. res[ i ] = c;
  410. res[ len ] = '\0';
  411. setText( res );
  412. delete[] res;
  413. }
  414. void Text::remove( int p ) // löscht p
  415. {
  416. int l = getLength(); // Text Länge
  417. if( p < 0 || p >= l ) // Auf unsinnige übergabe prüfen
  418. return;
  419. char *res = new char[ l ]; // neuen Text anlegen
  420. for( int i = 0; i < p && i < l; ++i ) // Text befüllen
  421. res[ i ] = txt[ i ];
  422. for( int i = p + 1; i < l; ++i )
  423. res[ i - 1 ] = txt[ i ];
  424. res[ l - 1 ] = 0;
  425. setText( res ); // Text setzen
  426. delete[] res; // Speicher freigeben
  427. }
  428. void Text::remove( int p1, int p2 ) // löscht von p1 zu p2 ( p2 bleibt )
  429. {
  430. if( p1 == p2 )
  431. return;
  432. if( p1 > p2 ) // p1 und p2 tauschen
  433. {
  434. int x = p1;
  435. p1 = p2;
  436. p2 = x;
  437. }
  438. int l = getLength(); // Länge des Testes
  439. if( p1 < 0 ) // Auf unsinnige übergabe prüfen
  440. p1 = 0;
  441. if( p2 > l )
  442. p2 = l;
  443. int resl = l - ( p2 - p1 ); // Länge vom Ergebnis
  444. char *res = new char[ (__int64)resl + 1 ]; // Neuen Text erstellen
  445. for( int i = 0; i < p1; ++i ) // Text füllen
  446. res[ i ] = txt[ i ];
  447. for( int i = p2; i < l; ++i )
  448. res[ i - ( p2 - p1 ) ] = txt[ i ];
  449. res[ resl ] = '\0'; // Testende festlegen
  450. setText( res ); // Text setzen
  451. delete[] res; // Speicher freigeben
  452. }
  453. void Text::remove( char c ) // löscht jetes c
  454. {
  455. if( !hat( c ) ) // prüfen ob c vorhanden
  456. return;
  457. int l = getLength(); // Länge des Textes
  458. int anz = anzahlVon( c ); // Anzahl von c
  459. char *res = new char[ (__int64)l - anz + 1 ]; // neuen Text erstellen
  460. int anz2 = 0;
  461. int suchGCount = 0;
  462. for( int i = 0; i < l; ++i ) // Text befüllen
  463. {
  464. bool b = suchGCount != 0;
  465. if( txt[ i ] == c && !suchGCount )
  466. ++anz2;
  467. else
  468. res[ i - anz2 ] = txt[ i ];
  469. if( txt[ i ] == suchGBeg )
  470. ++suchGCount;
  471. if( txt[ i ] == suchGEnd )
  472. --suchGCount;
  473. if( b )
  474. {
  475. if( txt[ i ] == c && !suchGCount )
  476. ++anz2;
  477. else
  478. res[ i - anz2 ] = txt[ i ];
  479. }
  480. }
  481. res[ l - anz ] = '\0'; // Textende festlegen
  482. setText( res ); // Text setzen
  483. delete[] res; // Speicher freigeben
  484. }
  485. void Text::remove( const char *t ) // löscht jetes t
  486. {
  487. int tl = (int)textLength( t ); // Länge der Übergabe
  488. int txl = getLength(); // Länge des Textes
  489. if( tl <= 0 || tl > txl ) // Auf unsinnige übergabe prüfen
  490. return;
  491. if( !hat( t ) ) // prüfen ob Text ein t enthält
  492. return;
  493. int anz = anzahlVon( t ); // anzahl von t
  494. int *begin = new int[ anz ];
  495. for( int i = 0; i < anz; ++i ) // begin aller t-s finden
  496. begin[ i ] = positionVon( t, i );
  497. int resl = txl - ( anz * tl ); // Länge vom Ergebnes
  498. char *res = new char[ (__int64)resl + 1 ]; // neuen Text erzeugen
  499. int del = 0;
  500. for( int i = 0; i < txl; ++i ) // Text befüllen
  501. {
  502. if( del < anz && i == begin[ del ] ) // Text auslassen
  503. {
  504. i += tl - 1;
  505. ++del;
  506. }
  507. else
  508. res[ i - ( del * tl ) ] = txt[ i ]; // Text befüllen
  509. }
  510. res[ resl ] = '\0'; // Text ende festlegen
  511. setText( res ); // Text setzen
  512. delete[]begin;
  513. delete[] res; // Speicher freigeben
  514. }
  515. void Text::remove( Text *t )
  516. {
  517. if( t->getLength() > 0 ) // Auf unsinnige übergabe prüfen
  518. remove( t->getText() ); // löschen
  519. t->release(); // Übergabe loslassen
  520. }
  521. void Text::remove( int index, char c )
  522. {
  523. if( index < 0 || !hat( c ) ) // Auf unsinnige übergabe prüfen
  524. return;
  525. int anz = anzahlVon( c ); // anzahl der i-s
  526. if( index >= anz ) // prüfen ob ein i-tes c vorhanden ist
  527. return;
  528. int pos = positionVon( c, index ); // Position vom i-ten c
  529. if( pos < 0 )
  530. return;
  531. int l = getLength(); // Länge des Textes
  532. if( !l )
  533. return;
  534. char *res = new char[ l ]; // neuen Text erzeugen
  535. for( int i = 0; i < pos && i < l; ++i ) // Text befüllen
  536. res[ i ] = txt[ i ];
  537. for( int i = pos + 1; i < l; ++i )
  538. res[ i - 1 ] = txt[ i ];
  539. res[ l - 1 ] = '\0'; // Text ende festlegen
  540. setText( res ); // Text setzen
  541. delete[] res; // Speicher freigeben
  542. }
  543. void Text::remove( int index, const char *t ) // löscht das i-te t
  544. {
  545. int tl = (int)textLength( t ); // Länge der Übergabe
  546. if( index < 0 || !hat( t ) || tl <= 0 ) // Auf unsinnige übergabe prüfen
  547. return;
  548. int anz = anzahlVon( t ); // anzahl der i-s
  549. if( index >= anz ) // prüfen ob ein i-tes c vorhanden ist
  550. return;
  551. int pos = positionVon( t, index ); // Position vom i-ten c
  552. if( pos < 0 )
  553. return;
  554. int l = getLength(); // Länge des Textes
  555. if( !l )
  556. return;
  557. char *res = new char[ (__int64)l - tl + 1 ]; // neuen Text erzeugen
  558. for( int i = 0; i < pos && i < l - tl + 1; ++i ) // Text befüllen
  559. res[ i ] = txt[ i ];
  560. for( int i = pos + tl; i < l; ++i )
  561. res[ i - tl ] = txt[ i ];
  562. res[ l - tl ] = '\0'; // Text ende festlegen
  563. setText( res ); // Text setzen
  564. delete[] res; // Speicher freigeben
  565. }
  566. void Text::remove( int i, Text *t )
  567. {
  568. if( t->getLength() > 0 ) // Auf unsinnige übergabe prüfen
  569. remove( i, t->getText() ); // löschen
  570. t->release(); // Übergabe loslassen
  571. }
  572. // Löscht alle ' ', '\n', '\r', '\t' bis zu einem anderen buchstaben
  573. // pos: Die Position des ersten zeichens
  574. void Text::removeWhitespaceAfter( int pos )
  575. {
  576. int length = 0;
  577. int len = textLength( txt );
  578. for( int i = pos; i < len; i++ )
  579. {
  580. if( txt[ i ] == ' ' || txt[ i ] == '\n' || txt[ i ] == '\r' || txt[ i ] == '\t' )
  581. length++;
  582. else
  583. break;
  584. }
  585. remove( pos, pos + length );
  586. }
  587. // Löscht alle ' ', '\n', '\r', '\t' bis zu einem anderen buchstaben
  588. // pos: Die Position des ersten zeichens (beginnt bei pos-1)
  589. void Text::removeWhitespaceBefore( int pos )
  590. {
  591. int length = 0;
  592. for( int i = pos - 1; i >= 0; i-- )
  593. {
  594. if( txt[ i ] == ' ' || txt[ i ] == '\n' || txt[ i ] == '\r' || txt[ i ] == '\t' )
  595. length++;
  596. else
  597. break;
  598. }
  599. remove( pos - length, pos );
  600. }
  601. void Text::setPrecision( int p ) // setzt die Anzahl der Nachkommastellen bei doubles
  602. {
  603. precision = p;
  604. }
  605. // constant
  606. int Text::getLength() const // gibt die Text länge zurück
  607. {
  608. if( !txt )
  609. return -1;
  610. return textLength( txt );
  611. }
  612. int Text::getLKick( int pos ) const
  613. {
  614. if( txt[ pos - 1 ] == ' ' )
  615. {
  616. int ret = 1;
  617. for( ; ret < pos && txt[ pos - ret - 1 ] == ' ' && txt[ pos - ret - 1 ] != '\n'; ++ret );
  618. return pos - ret;
  619. }
  620. else
  621. {
  622. int ret = 1;
  623. for( ; ret < pos && txt[ pos - ret - 1 ] != ' ' && txt[ pos - ret - 1 ] != '\n'; ++ret );
  624. return pos - ret;
  625. }
  626. }
  627. int Text::getOKick( int pos ) const
  628. {
  629. if( !hat( '\n' ) )
  630. return 0;
  631. int lpos = 0;
  632. while( pos - lpos - 1 > 0 && txt[ pos - lpos - 1 ] != '\n' )
  633. ++lpos;
  634. int vllen = 1;
  635. while( pos - lpos - vllen - 1 >= 0 && txt[ pos - lpos - vllen - 1 ] != '\n' )
  636. ++vllen;
  637. if( vllen > lpos )
  638. return pos - vllen;
  639. else
  640. return pos - lpos - 1;
  641. }
  642. int Text::getRKick( int pos ) const
  643. {
  644. int tl = getLength();
  645. if( txt[ pos ] == ' ' )
  646. {
  647. int ret = 1;
  648. for( ; ret + pos < tl && txt[ pos + ret ] == ' ' && txt[ pos + ret ] != '\n'; ++ret );
  649. return pos + ret;
  650. }
  651. else
  652. {
  653. int ret = 1;
  654. for( ; ret + pos < tl && txt[ pos + ret ] != ' ' && txt[ pos + ret ] != '\n'; ++ret );
  655. return pos + ret;
  656. }
  657. }
  658. int Text::getUKick( int pos ) const
  659. {
  660. if( !hat( '\n' ) )
  661. return getLength();
  662. int lpos = 0;
  663. while( pos - lpos > 0 && txt[ pos - lpos - 1 ] != '\n' )
  664. ++lpos;
  665. int llen = 1;
  666. while( pos + llen - 1 < getLength() && txt[ pos + llen - 1 ] != '\n' )
  667. ++llen;
  668. int vllen = 1;
  669. while( pos + llen + vllen - 1 < getLength() && txt[ pos + llen + vllen - 1 ] != '\n' )
  670. ++vllen;
  671. if( vllen == 1 )
  672. return pos + llen < getLength() ? pos + llen : getLength();
  673. if( vllen < lpos )
  674. return pos + llen + vllen - 1;
  675. return pos + llen + lpos;
  676. }
  677. bool Text::hat( Text *t ) const // enthält der Text t
  678. {
  679. bool ret = 0;
  680. if( t->getLength() > 0 ) // Auf unsinnige übergabe prüfen
  681. ret = hat( t->getText() ); // prüfen
  682. t->release(); // Übergabe loslassen
  683. return ret;
  684. }
  685. bool Text::hat( const char *t ) const
  686. {
  687. int tl = (int)textLength( t ); // Länge der Übergabe
  688. int txl = getLength(); // Länge des Textes
  689. if( tl <= 0 || tl > txl ) // Auf unsinnige übergabe prüfen
  690. return 0;
  691. int suchGCount = 0;
  692. for( int i = 0; i + tl <= txl; ++i ) // Text durchsuchen
  693. {
  694. if( !suchGCount )
  695. {
  696. bool b = 1;
  697. for( int ii = 0; ii < tl; ++ii ) // Text überprüfen
  698. b &= txt[ i + ii ] == t[ ii ];
  699. if( b )
  700. return 1;
  701. }
  702. if( txt[ i ] == suchGBeg )
  703. ++suchGCount;
  704. if( txt[ i ] == suchGEnd )
  705. --suchGCount;
  706. if( !suchGCount )
  707. {
  708. bool b = 1;
  709. for( int ii = 0; ii < tl; ++ii ) // Text überprüfen
  710. b &= txt[ i + ii ] == t[ ii ];
  711. if( b )
  712. return 1;
  713. }
  714. }
  715. return 0;
  716. }
  717. // Überprüft, ob im Text der Inhalt eines anderen Textes vorkommt
  718. // t: Der Text, nach dessen Inhalt gesucht werden soll
  719. // return: (true), wenn der Inhalt des Textes vorkommt. (false) sonnst
  720. // pos: die position an der die zeichenkette im string beginnen soll
  721. bool Text::hatAt( int pos, Text *t ) const
  722. {
  723. bool ret = 0;
  724. if( t->getLength() > 0 ) // Auf unsinnige übergabe prüfen
  725. ret = hatAt( pos, t->getText() ); // prüfen
  726. t->release(); // Übergabe loslassen
  727. return ret;
  728. }
  729. // Überprüft, ob im Text eine bestimmte Zeichenkette vorkommt
  730. // t: Die Zeichenkette, nach der gesucht werden soll
  731. // return: (true), wenn die Zeichenkette vorkommt. (false) sonnst
  732. // pos: die position an der die zeichenkette im string beginnen soll
  733. bool Text::hatAt( int pos, const char *t ) const
  734. {
  735. int tl = (int)textLength( t ); // Länge der Übergabe
  736. int txl = getLength(); // Länge des Textes
  737. if( tl <= 0 || tl + pos > txl ) // Auf unsinnige übergabe prüfen
  738. return 0;
  739. bool b = 1;
  740. for( int i = 0; i < tl; ++i ) // Text überprüfen
  741. b &= txt[ pos + i ] == t[ i ];
  742. return b;
  743. }
  744. bool Text::hat( char c ) const // enthält c
  745. {
  746. int l = getLength(); // Text Länge
  747. bool ret = 0;
  748. int suchGCount = 0;
  749. for( int i = 0; i < l; ++i ) // suchen
  750. {
  751. bool b = suchGCount != 0;
  752. if( !suchGCount ) // überprüfen
  753. ret |= txt[ i ] == c;
  754. if( txt[ i ] == suchGBeg )
  755. ++suchGCount;
  756. if( txt[ i ] == suchGEnd )
  757. --suchGCount;
  758. if( !suchGCount && b ) // überprüfen
  759. ret |= txt[ i ] == c;
  760. }
  761. return ret;
  762. }
  763. bool Text::istGleich( const char *t ) const // prüft ob det Text gleich t ist
  764. {
  765. int txl = getLength(); // Text Länge
  766. int tl = (int)textLength( t ); // Länge der Übergabe
  767. if( txl != tl ) // Auf unsinniege Übergabe prüfen
  768. return 0;
  769. if( txl == -1 )
  770. return 1;
  771. bool ret = true;
  772. for( int i = 0; i < tl; ++i ) // prüfen
  773. ret &= txt[ i ] == t[ i ];
  774. return ret;
  775. }
  776. bool Text::istGleich( Text *t ) const
  777. {
  778. bool ret = istGleich( t->getText() ); // prüfen
  779. t->release(); // Übergabe loslassen
  780. return ret;
  781. }
  782. char *Text::getText() const // gibt Text zurück
  783. {
  784. return txt;
  785. }
  786. int Text::anzahlVon( char c ) const // gibt die Anzahl von c im Text zurück
  787. {
  788. int ret = 0;
  789. int l = getLength(); // Text Länge
  790. int suchGCount = 0;
  791. for( int i = 0; i < l; ++i ) // suchen
  792. {
  793. bool b = suchGCount != 0;
  794. ret += txt[ i ] == c && !suchGCount; // zählen
  795. if( txt[ i ] == suchGBeg )
  796. ++suchGCount;
  797. if( txt[ i ] == suchGEnd )
  798. --suchGCount;
  799. ret += txt[ i ] == c && !suchGCount && b; // zählen
  800. }
  801. return ret;
  802. }
  803. int Text::anzahlVon( const char *t ) const // gibt die Anzahl von t im Text zurück
  804. {
  805. int tl = (int)textLength( t ); // Länge der Übergabe
  806. int txl = getLength(); // Länge des Textes
  807. if( tl <= 0 || tl > txl ) // Auf unsinnige übergabe prüfen
  808. return 0;
  809. int ret = 0;
  810. int suchGCount = 0;
  811. for( int i = 0; i + tl <= txl; ++i ) // suchen
  812. {
  813. bool b = suchGCount != 0;
  814. if( !suchGCount )
  815. {
  816. bool b = 1;
  817. for( int ii = 0; ii < tl; ++ii ) // überprüfen
  818. b &= txt[ i + ii ] == t[ ii ];
  819. if( b )
  820. ++ret; // zählen
  821. }
  822. if( txt[ i ] == suchGBeg )
  823. ++suchGCount;
  824. if( txt[ i ] == suchGEnd )
  825. --suchGCount;
  826. if( !suchGCount && b )
  827. {
  828. bool b = 1;
  829. for( int ii = 0; ii < tl; ++ii ) // überprüfen
  830. b &= txt[ i + ii ] == t[ ii ];
  831. if( b )
  832. ++ret; // zählen
  833. }
  834. }
  835. return ret;
  836. }
  837. int Text::anzahlVon( Text *t ) const
  838. {
  839. int ret = 0;
  840. if( t->getLength() > 0 ) // Auf unsinnige übergabe prüfen
  841. ret = anzahlVon( t->getText() ); // zählen
  842. t->release(); // Übergabe loslassen
  843. return ret;
  844. }
  845. int Text::positionVon( char c ) const // gibt die Position des ersten c zurück
  846. {
  847. int l = getLength(); // Text Länge
  848. int suchGCount = 0;
  849. for( int i = 0; i < l; ++i ) // suchen
  850. {
  851. bool b = suchGCount != 0;
  852. if( txt[ i ] == c && !suchGCount ) // überprüfen
  853. return i;
  854. if( txt[ i ] == suchGBeg )
  855. ++suchGCount;
  856. if( txt[ i ] == suchGEnd )
  857. --suchGCount;
  858. if( txt[ i ] == c && !suchGCount && b ) // überprüfen
  859. return i;
  860. }
  861. return -1;
  862. }
  863. int Text::positionVon( const char *t ) const // gibt die Position des ersten t zurück
  864. {
  865. int tl = (int)textLength( t ); // Länge der Übergabe
  866. int txl = getLength(); // Länge des Textes
  867. if( tl <= 0 || tl > txl ) // Auf unsinnige übergabe prüfen
  868. return -1;
  869. int suchGCount = 0;
  870. for( int i = 0; i + tl <= txl; ++i ) // suchen
  871. {
  872. bool b = suchGCount != 0;
  873. if( !suchGCount )
  874. {
  875. bool b = 1;
  876. for( int ii = 0; ii < tl; ++ii ) // überprüfen
  877. b &= txt[ i + ii ] == t[ ii ];
  878. if( b )
  879. return i;
  880. }
  881. if( txt[ i ] == suchGBeg )
  882. ++suchGCount;
  883. if( txt[ i ] == suchGEnd )
  884. --suchGCount;
  885. if( !suchGCount && b )
  886. {
  887. bool b = 1;
  888. for( int ii = 0; ii < tl; ++ii ) // überprüfen
  889. b &= txt[ i + ii ] == t[ ii ];
  890. if( b )
  891. return i;
  892. }
  893. }
  894. return -1;
  895. }
  896. int Text::positionVon( Text *t ) const
  897. {
  898. int ret = 0;
  899. if( t->getLength() > 0 ) // Auf unsinnige übergabe prüfen
  900. ret = positionVon( t->getText() ); // position ermitteln
  901. t->release(); // Übergabe loslassen
  902. return ret;
  903. }
  904. int Text::positionVon( char c, int index ) const // gibt die Position des i-ten c zurück
  905. {
  906. int l = getLength(); // Text Länge
  907. int ii = 0;
  908. int suchGCount = 0;
  909. for( int i = 0; i < l; ++i ) // suchen
  910. {
  911. bool b = suchGCount != 0;
  912. if( txt[ i ] == c && !suchGCount ) // überprüfen
  913. {
  914. if( ii == index )
  915. return i;
  916. else
  917. ++ii;
  918. }
  919. if( txt[ i ] == suchGBeg )
  920. ++suchGCount;
  921. if( txt[ i ] == suchGEnd )
  922. --suchGCount;
  923. if( txt[ i ] == c && !suchGCount && b ) // überprüfen
  924. {
  925. if( ii == index )
  926. return i;
  927. else
  928. ++ii;
  929. }
  930. }
  931. return -1;
  932. }
  933. int Text::positionVon( const char *t, int index ) const // gibt die Position des i-ten t zurück
  934. {
  935. int tl = (int)textLength( t ); // Länge der Übergabe
  936. int txl = getLength(); // Länge des Textes
  937. if( tl <= 0 || tl > txl ) // Auf unsinnige übergabe prüfen
  938. return 0;
  939. int i2 = 0;
  940. int suchGCount = 0;
  941. for( int i = 0; i + tl <= txl; ++i ) // suchen
  942. {
  943. bool b = suchGCount != 0;
  944. if( !suchGCount )
  945. {
  946. bool b = 1;
  947. for( int ii = 0; ii < tl; ++ii ) // überprüfen
  948. b &= txt[ i + ii ] == t[ ii ];
  949. if( b )
  950. {
  951. if( i2 == index )
  952. return i;
  953. else
  954. ++i2;
  955. }
  956. }
  957. if( txt[ i ] == suchGBeg )
  958. ++suchGCount;
  959. if( txt[ i ] == suchGEnd )
  960. --suchGCount;
  961. if( !suchGCount && b )
  962. {
  963. bool b = 1;
  964. for( int ii = 0; ii < tl; ++ii ) // überprüfen
  965. b &= txt[ i + ii ] == t[ ii ];
  966. if( b )
  967. {
  968. if( i2 == index )
  969. return i;
  970. else
  971. ++i2;
  972. }
  973. }
  974. }
  975. return -1;
  976. }
  977. int Text::positionVon( Text *t, int i ) const
  978. {
  979. int ret = 0;
  980. if( t->getLength() > 0 ) // Auf unsinnige übergabe prüfen
  981. ret = positionVon( t->getText(), i ); // position ermitteln
  982. t->release(); // Übergabe loslassen
  983. return ret;
  984. }
  985. Text *Text::getTeilText( int p1, int p2 ) const // gibt den Text von p1 bis p2 zurück
  986. {
  987. if( p1 > p2 ) // p1 und p2 tauschen
  988. {
  989. int x = p1;
  990. p1 = p2;
  991. p2 = x;
  992. }
  993. int l = getLength(); // Text Länge
  994. if( p1 < 0 || p2 > l ) // Auf unsinnige übergabe prüfen
  995. return new Text( "" );
  996. char *cp = new char[ (__int64)p2 - p1 + 1 ]; // neuen Text erstellen
  997. for( int i = p1; i < p2; ++i ) // Text befüllen
  998. {
  999. cp[ i - p1 ] = txt[ i ];
  1000. }
  1001. cp[ p2 - p1 ] = '\0';
  1002. Text *t = new Text( cp ); // Text zurückgeben
  1003. delete[]cp;
  1004. return t;
  1005. }
  1006. Text *Text::getTeilText( int p ) const // gibt den Text von p bis zum Ende zurück
  1007. {
  1008. return getTeilText( p, getLength() ); // Text zurückgeben
  1009. }
  1010. // berechnet den Hash code des textes
  1011. int Text::hashCode() const
  1012. {
  1013. int result = 0;
  1014. int len = getLength();
  1015. for( int i = 0; i < len; i++ )
  1016. result += (int)pow( txt[ i ] * 31, len - 1 - i );
  1017. return result;
  1018. }
  1019. // Operatoren
  1020. Text &Text::operator+=( const int num )
  1021. {
  1022. append( num );
  1023. return *this;
  1024. }
  1025. // Hängt eine Zahl ans Ende des Textes an
  1026. Text &Text::operator+=( const __int64 num )
  1027. {
  1028. append( num );
  1029. return *this;
  1030. }
  1031. Text &Text::operator+=( const double num )
  1032. {
  1033. append( num );
  1034. return *this;
  1035. }
  1036. Text &Text::operator+=( const float num )
  1037. {
  1038. append( num );
  1039. return *this;
  1040. }
  1041. Text &Text::operator+=( const char *txt )
  1042. {
  1043. append( txt );
  1044. return *this;
  1045. }
  1046. Text &Text::operator+=( const Text &txt )
  1047. {
  1048. append( txt.getText() );
  1049. return *this;
  1050. }
  1051. Text &Text::operator=( const int num )
  1052. {
  1053. setText( "" );
  1054. append( num );
  1055. return *this;
  1056. }
  1057. Text &Text::operator=( const double num )
  1058. {
  1059. setText( "" );
  1060. append( num );
  1061. return *this;
  1062. }
  1063. Text &Text::operator=( const float num )
  1064. {
  1065. setText( "" );
  1066. append( num );
  1067. return *this;
  1068. }
  1069. Text &Text::operator=( const char *txt )
  1070. {
  1071. setText( txt );
  1072. return *this;
  1073. }
  1074. Text &Text::operator=( const Text &txt )
  1075. {
  1076. setText( txt.getText() );
  1077. return *this;
  1078. }
  1079. Text::operator char *( ) const
  1080. {
  1081. return txt;
  1082. }
  1083. Text::operator int() const
  1084. {
  1085. if( getLength() > 2 && txt[ 0 ] == '0' && txt[ 1 ] == 'x' )
  1086. return TextZuInt( ( txt + 2 ), 16 );
  1087. return TextZuInt( txt, 10 );
  1088. }
  1089. Text::operator __int64() const
  1090. {
  1091. if( getLength() > 2 && txt[ 0 ] == '0' && txt[ 1 ] == 'x' )
  1092. return TextZuInt64( ( txt + 2 ), 16 );
  1093. return TextZuInt64( txt, 10 );
  1094. }
  1095. Text::operator double() const
  1096. {
  1097. return TextZuDouble( txt );
  1098. }
  1099. Text::operator float() const
  1100. {
  1101. return TextZuFloat( txt );
  1102. }
  1103. bool Text::operator>( Text &t ) const
  1104. {
  1105. int len1 = getLength();
  1106. int len2 = t.getLength();
  1107. char *txt2 = t;
  1108. for( int i = 0; i < len1 && i < len2; ++i )
  1109. {
  1110. if( txt[ i ] > txt2[ i ] )
  1111. return 1;
  1112. if( txt[ i ] < txt2[ i ] )
  1113. return 0;
  1114. }
  1115. if( len1 > len2 )
  1116. return 1;
  1117. return 0;
  1118. }
  1119. bool Text::operator<( Text &t ) const
  1120. {
  1121. int len1 = getLength();
  1122. int len2 = t.getLength();
  1123. char *txt2 = t;
  1124. for( int i = 0; i < len1 && i < len2; ++i )
  1125. {
  1126. if( txt[ i ] < txt2[ i ] )
  1127. return 1;
  1128. if( txt[ i ] > txt2[ i ] )
  1129. return 0;
  1130. }
  1131. if( len1 < len2 )
  1132. return 1;
  1133. return 0;
  1134. }
  1135. // Erstellt einen neuen Text bestehend aus diesem und t2
  1136. Text Text::operator+( const Text &t2 ) const
  1137. {
  1138. return Text( *this ) += t2;
  1139. }
  1140. // Erstellt einen neuen Text bestehend aus diesem und t2
  1141. Text Text::operator+( const char *t2 ) const
  1142. {
  1143. return Text( *this ) += t2;
  1144. }
  1145. // Erstellt einen neuen Text bestehend aus diesem und num
  1146. Text Text::operator+( const int num ) const
  1147. {
  1148. return Text( *this ) += num;
  1149. }
  1150. // Erstellt einen neuen Text bestehend aus diesem und num
  1151. Text Text::operator+( const __int64 num ) const
  1152. {
  1153. return Text( *this ) += num;
  1154. }
  1155. // Erstellt einen neuen Text bestehend aus diesem und num
  1156. Text Text::operator+( const double num ) const
  1157. {
  1158. return Text( *this ) += num;
  1159. }
  1160. // Erstellt einen neuen Text bestehend aus diesem und num
  1161. Text Text::operator+( const float num ) const
  1162. {
  1163. return Text( *this ) += num;
  1164. }
  1165. bool Text::operator==( const Text &right ) const
  1166. {
  1167. return istGleich( right );
  1168. }
  1169. // Inhalt der TextReader Klasse
  1170. // Konstructor
  1171. // txt: Der Text der gelesen werden soll. Er wird nicht kopiert sondern direkt gelesen.
  1172. TextReader::TextReader( Text *txt )
  1173. : ReferenceCounter()
  1174. {
  1175. this->txt = txt;
  1176. lPos = 0;
  1177. }
  1178. // Destructor
  1179. TextReader::~TextReader()
  1180. {
  1181. txt->release();
  1182. }
  1183. // Setzt die Position des Bytes, das als nächstes gelesen werden soll
  1184. // pos: Der Index des Bytes
  1185. // ende: 1, wenn der Index vom ende des Textes zählt. 0, wenn der Index vom Beginn des Textes zählt
  1186. void TextReader::setLPosition( __int64 pos, bool ende )
  1187. {
  1188. int l = txt->getLength();
  1189. lPos = ende ? l - pos : pos;
  1190. if( lPos < 0 )
  1191. lPos = 0;
  1192. if( lPos > l )
  1193. lPos = l;
  1194. }
  1195. // Ließt aus der Datei
  1196. // bytes: Ein Array, der mit Bytes aus dem Text gefüllt werden soll
  1197. // len: Wie viele Bytes aus dem Text gelesen werden sollen
  1198. void TextReader::lese( char *bytes, int len )
  1199. {
  1200. int l = txt->getLength();
  1201. len = (int)MIN( l - lPos, len );
  1202. for( __int64 i = lPos; i < lPos + len; i++ )
  1203. bytes[ i - lPos ] = txt->getText()[ i ];
  1204. lPos += len;
  1205. }
  1206. // Ließt die nächste zeile des Textes ein
  1207. // return: Die gelesene Zeile als Text mit zeilenumbruch
  1208. Text *TextReader::leseZeile()
  1209. {
  1210. if( istEnde() )
  1211. return 0;
  1212. Text *ret = new Text( "" );
  1213. __int64 len = txt->getLength();
  1214. for( char c = 0; c != '\n' && lPos < len; )
  1215. {
  1216. lese( &c, 1 );
  1217. if( c )
  1218. ret->append( (const char *)&c, 1 );
  1219. }
  1220. return ret;
  1221. }
  1222. // Prüft, ob die Resource vollständig gelesen wurde
  1223. // return 1, wenn die Resource vollständig gelesen wurde. 0, sonst
  1224. bool TextReader::istEnde() const
  1225. {
  1226. return lPos >= txt->getLength();
  1227. }
  1228. // Gibt den Index des Bytes aus dem Text zurück, welches als nächstes gelesen werden würde
  1229. // return -1, falls ein Fehler aufgetreten ist. Sonst die Position des Lesezeigers
  1230. __int64 TextReader::getLPosition() const
  1231. {
  1232. return lPos;
  1233. }
  1234. //! Gibt die Anzahl der zu lesenden Bytes zurück
  1235. __int64 TextReader::getSize() const
  1236. {
  1237. return txt->getLength();
  1238. }
  1239. // char* operationen
  1240. int Framework::stringPositionVonChar( char *string, char c, int num ) // sucht die position des num-ten c-s in string, -1 bei nicht gefunden
  1241. {
  1242. int gef = 0;
  1243. int p = 0;
  1244. for( char cc = *string; *string; ++string )
  1245. {
  1246. if( cc == c )
  1247. {
  1248. if( gef == num )
  1249. return p;
  1250. else
  1251. ++gef;
  1252. }
  1253. ++p;
  1254. }
  1255. return -1;
  1256. }
  1257. int Framework::stringPositionVonString( char *string, char *suche, int sBegPos ) // sucht die position von 'suche' in 'string' ab der Position 'sBegPos', -1 bei nicht gefunden
  1258. {
  1259. for( int i = 0; i < sBegPos; ++i )
  1260. {
  1261. if( !*string )
  1262. return -1;
  1263. ++string;
  1264. }
  1265. int tl = textLength( suche ); // Länge der Übergabe
  1266. int txl = textLength( string ); // Länge des Textes
  1267. if( tl <= 0 || tl > txl ) // Auf unsinnige übergabe prüfen
  1268. return -1;
  1269. for( int i = 0; i + tl <= txl; ++i ) // suchen
  1270. {
  1271. bool b = 1;
  1272. for( int ii = 0; ii < tl; ++ii ) // überprüfen
  1273. if( b )
  1274. b = string[ i + ii ] == suche[ ii ];
  1275. if( b )
  1276. return i + sBegPos;
  1277. }
  1278. return -1;
  1279. }
  1280. //---Andere Funktionen---
  1281. void Framework::TextKopieren( const char *txt ) // kopiert den Text in den Zwischenspeicher
  1282. {
  1283. #ifdef WIN32
  1284. int län = textLength( txt ) + 1;
  1285. if( län == 1 )
  1286. return;
  1287. HGLOBAL hMem = GlobalAlloc( GMEM_MOVEABLE, län );
  1288. if( !hMem )
  1289. return;
  1290. memcpy( GlobalLock( hMem ), txt, län );
  1291. GlobalUnlock( hMem );
  1292. OpenClipboard( 0 );
  1293. EmptyClipboard();
  1294. SetClipboardData( CF_TEXT, hMem );
  1295. CloseClipboard();
  1296. #endif
  1297. }
  1298. char *Framework::TextInsert() // gibt den Text aus der Zwischenablage zurück
  1299. {
  1300. #ifdef WIN32
  1301. if( !OpenClipboard( 0 ) )
  1302. return "";
  1303. HANDLE hClipData = GetClipboardData( CF_TEXT );
  1304. char *cBuffer = (char *)GlobalLock( hClipData );
  1305. GlobalUnlock( hClipData );
  1306. CloseClipboard();
  1307. return cBuffer;
  1308. #else
  1309. return 0;
  1310. #endif
  1311. }
  1312. char Framework::smallOrBig( char c, bool gr )
  1313. {
  1314. int ret = c;
  1315. if( gr )
  1316. {
  1317. if( c >= 'a' && c <= 'z' )
  1318. ret -= 32;
  1319. else
  1320. {
  1321. switch( c )
  1322. {
  1323. case '^':
  1324. return '°';
  1325. case '1':
  1326. return '!';
  1327. case '<':
  1328. return '>';
  1329. case '2':
  1330. return '\"';
  1331. case '3':
  1332. return '§';
  1333. case '4':
  1334. return '$';
  1335. case '5':
  1336. return '%';
  1337. case '6':
  1338. return '&';
  1339. case '7':
  1340. return '/';
  1341. case '8':
  1342. return '(';
  1343. case '9':
  1344. return ')';
  1345. case '0':
  1346. return '=';
  1347. case ',':
  1348. return ';';
  1349. case '.':
  1350. return ':';
  1351. case 'ß':
  1352. return '?';
  1353. case '-':
  1354. return '_';
  1355. case '´':
  1356. return '`';
  1357. case '+':
  1358. return '*';
  1359. case '#':
  1360. return '\'';
  1361. case 'ü':
  1362. return 'Ü';
  1363. case 'ö':
  1364. return 'Ö';
  1365. case 'ä':
  1366. return 'Ä';
  1367. }
  1368. }
  1369. }
  1370. else
  1371. {
  1372. if( c >= 'A' && c <= 'Z' )
  1373. ret += 32;
  1374. else
  1375. {
  1376. switch( c )
  1377. {
  1378. case '°':
  1379. return '^';
  1380. case '!':
  1381. return '1';
  1382. case '>':
  1383. return '<';
  1384. case '\"':
  1385. return '2';
  1386. case '§':
  1387. return '3';
  1388. case '$':
  1389. return '4';
  1390. case '%':
  1391. return '5';
  1392. case '&':
  1393. return '6';
  1394. case '/':
  1395. return '7';
  1396. case '(':
  1397. return '8';
  1398. case ')':
  1399. return '9';
  1400. case '=':
  1401. return '0';
  1402. case ';':
  1403. return ',';
  1404. case ':':
  1405. return '.';
  1406. case '?':
  1407. return 'ß';
  1408. case '_':
  1409. return '-';
  1410. case '`':
  1411. return '´';
  1412. case '*':
  1413. return '+';
  1414. case '\'':
  1415. return '#';
  1416. case 'Ü':
  1417. return 'ü';
  1418. case 'Ö':
  1419. return 'ö';
  1420. case 'Ä':
  1421. return 'ä';
  1422. }
  1423. }
  1424. }
  1425. return (char)ret;
  1426. }
  1427. bool Framework::istSchreibbar( unsigned char zeichen ) // prüft, ob zeichen ein Schreibbarer Buchstabe ist
  1428. {
  1429. if( zeichen > 32 && zeichen < 127 )
  1430. return 1;
  1431. if( zeichen == 128 || zeichen == 181 || zeichen == 178 || zeichen == 179 )
  1432. return 1;
  1433. if( zeichen > 191 && zeichen < 198 )
  1434. return 1;
  1435. if( zeichen > 199 && zeichen < 208 )
  1436. return 1;
  1437. if( zeichen > 209 && zeichen < 215 )
  1438. return 1;
  1439. if( zeichen > 216 && zeichen < 221 )
  1440. return 1;
  1441. if( zeichen > 222 && zeichen < 230 )
  1442. return 1;
  1443. if( zeichen > 231 && zeichen < 240 )
  1444. return 1;
  1445. if( zeichen > 241 && zeichen < 247 )
  1446. return 1;
  1447. if( zeichen > 248 && zeichen < 253 )
  1448. return 1;
  1449. if( zeichen == ' ' || zeichen == '\t' )
  1450. return 1;
  1451. return 0;
  1452. }
  1453. unsigned int Framework::TextZuInt( char *c, int system ) // Konvertiert c zu int
  1454. {
  1455. if( system == 16 )
  1456. return (unsigned int)strtoul( c, 0, system );
  1457. return (unsigned int)strtol( c, 0, system );
  1458. }
  1459. unsigned int Framework::TextZuInt( char *c, char **c_ende, int system )
  1460. {
  1461. if( system == 16 )
  1462. return (unsigned int)strtoul( c, c_ende, system );
  1463. return (unsigned int)strtol( c, c_ende, system );
  1464. }
  1465. unsigned __int64 Framework::TextZuInt64( char *c, int system )
  1466. {
  1467. if( system == 16 )
  1468. return strtoull( c, 0, system );
  1469. return (unsigned __int64)strtoll( c, 0, system );
  1470. }
  1471. unsigned __int64 Framework::TextZuInt64( char *c, char **c_ende, int system )
  1472. {
  1473. if( system == 16 )
  1474. return strtoull( c, c_ende, system );
  1475. return (unsigned __int64)strtoll( c, c_ende, system );
  1476. }
  1477. double Framework::TextZuDouble( char *c ) // Konvertiert c zu double
  1478. {
  1479. return strtod( c, 0 );
  1480. }
  1481. float Framework::TextZuFloat( char *c ) // Konvertiert c zu double
  1482. {
  1483. return strtof( c, 0 );
  1484. }
  1485. double Framework::TextZuDouble( char *c, char **c_ende )
  1486. {
  1487. return strtod( c, c_ende );
  1488. }
  1489. float Framework::TextZuFloat( char *c, char **c_ende )
  1490. {
  1491. return strtof( c, c_ende );
  1492. }
  1493. int Framework::textLength( const char *txt ) // gibt die Länge von txt zurück
  1494. {
  1495. if( !txt )
  1496. return 0;
  1497. int ret = 0;
  1498. for( ; ; ++ret )
  1499. {
  1500. bool br = 0;
  1501. switch( txt[ ret ] )
  1502. {
  1503. case 0:
  1504. br = 1;
  1505. break;
  1506. case 2:
  1507. case 6:
  1508. ++ret;
  1509. break;
  1510. case 3:
  1511. case 4:
  1512. case 5:
  1513. ret += 4;
  1514. break;
  1515. case 8:
  1516. ret += 4;
  1517. break;
  1518. }
  1519. if( br )
  1520. break;
  1521. }
  1522. return ret;
  1523. }