Text.cpp 43 KB

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