Text.cpp 36 KB

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