Text.cpp 43 KB

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