Text.cpp 43 KB

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