Text.h 29 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548
  1. #ifndef Text_H
  2. #define Text_H
  3. #include <functional>
  4. #include <sstream>
  5. #include "Reader.h"
  6. #include "ReferenceCounter.h"
  7. namespace Framework
  8. {
  9. class Text; //! aus dieser Datei
  10. class DynamicBuffer : public std::stringbuf
  11. {
  12. private:
  13. std::function<int(std::stringbuf&)> onAppend;
  14. public:
  15. DLLEXPORT DynamicBuffer(std::function<int(std::stringbuf&)> onAppend);
  16. DLLEXPORT virtual int sync() override;
  17. };
  18. class FlushingOStream : public std::ostream
  19. {
  20. private:
  21. std::function<void()> onDestroy;
  22. public:
  23. DLLEXPORT FlushingOStream(
  24. DynamicBuffer* buffer, std::function<void()> onDestroy = []() {});
  25. DLLEXPORT FlushingOStream(const Framework::FlushingOStream& stream);
  26. DLLEXPORT ~FlushingOStream();
  27. };
  28. //! Ein ersatz für String
  29. class Text : public virtual ReferenceCounter
  30. {
  31. private:
  32. char* txt;
  33. char suchGBeg;
  34. char suchGEnd;
  35. int precision;
  36. DynamicBuffer stringWriter;
  37. public:
  38. //! Erstellt ein neues Text Objekt mit dem Wert ""
  39. DLLEXPORT Text();
  40. //! Erstellt ein neues Text Objekt indem der Wert aus (txt) kopiert wird
  41. //! \param txt Der Text, der kopiert werden soll
  42. DLLEXPORT Text(const Text& txt);
  43. //! Erstellt ein neues Text Objekt indem der Wert aus (txt) kopiert wird
  44. //! \param txt Die Zeichenkette, die kopiert werden soll
  45. DLLEXPORT Text(const char* txt);
  46. //! Erstellt ein neues Text Objekt mit einer zahl als text
  47. //! \param zahl Die Zahl, die im Text sein soll
  48. DLLEXPORT Text(int zahl);
  49. //! Erstellt ein neues Text Objekt mit einer zahl als text
  50. //! \param num Die Zahl, die im Text sein soll
  51. DLLEXPORT Text(double num);
  52. //! Erstellt ein neues Text Objekt mit einer zahl als text
  53. //! \param num Die Zahl, die im Text sein soll
  54. DLLEXPORT Text(float num);
  55. //! Löscht den Text
  56. DLLEXPORT ~Text();
  57. //! Wandelt alle buchstaben in großbuchstaben um
  58. DLLEXPORT void toUpperCase();
  59. //! Wandelt alle buchstaben in kleinbuchstaben um
  60. DLLEXPORT void toLowerCase();
  61. //! Legt die Suchgrenzen fest, die von den Suchfunktionen verwendet
  62. //! werden. \param gBeg Das Zeichen, bei dem die Suche beginnen soll
  63. //! \param gEnd Das Zeichen, bei dem die Suche enden soll
  64. DLLEXPORT void setSuchGrenzen(char gBeg, char gEnd);
  65. //! Setzt den Text, den das Zeichnung speichert
  66. //! \param t Eine Zeichenkette, deren Inhalt kopiert wird
  67. DLLEXPORT void setText(const char* t);
  68. //! Setzt den Text, den das Zeichnung speichert
  69. //! \param t Eine Zeichenkette, deren Inhalt kopiert wird
  70. //! \param l Die Länge des Textes, der aus (t) kopiert werden soll
  71. DLLEXPORT void setText(const char* t, int l);
  72. //! Setzt den Text, den das Zeichnung speichert
  73. //! \param t Das TextZeichnung, dessen Inahlt kopiert werden soll
  74. DLLEXPORT void setText(Text* t);
  75. //! Hängt die übergebene Zahl als Hex Text (0-F) ans Ende des Textes an.
  76. //! \param num Die Zahl, die ins Hex System umgewandelt und angehängt
  77. //! werden soll
  78. DLLEXPORT void appendHex(int num);
  79. //! Hängt die übergebene Zahl als Hex Text (0-F) ans Ende des Textes an.
  80. //! \param num Die Zahl, die ins Hex System umgewandelt und angehängt
  81. //! werden soll
  82. DLLEXPORT void appendHex(__int64 num);
  83. //! Fügt den übergebenen Buchtaben der Zeichenkette hinzu
  84. //! \param c Der Buchstabe, der angehängt werden soll
  85. DLLEXPORT void append(char c);
  86. //! Hängt die übergebene Zeichenkette ans Ende des Textes an
  87. //! \param t Die Zeichenkette, deren Kopie ans Ende des Textes angehängt
  88. //! werden soll
  89. DLLEXPORT void append(const char* t);
  90. //! Hängt einen Teil der übergebenen Zeichenkette ans Ende des Textes an
  91. //! \param t Die Zeichenkette, deren Kopie angehängt werden soll
  92. //! \param l Die Länge des Textabschnittes der angehängt werden soll
  93. DLLEXPORT void append(const char* t, int l);
  94. //! Hängt den Inhalt des eines Textes ans Ende des Textes an
  95. //! \param t Der Text, dessen Kopie ans Ende des Textes angehängt werden
  96. //! soll
  97. DLLEXPORT void append(Text* t);
  98. //! Hängt eine Zahl ans Ende Des Textes an
  99. //! \param num Die Zahl, die in einen Text umgewandelt und am Ende
  100. //! angehängt werden soll
  101. DLLEXPORT void append(int num);
  102. //! Hängt eine Zahl ans Ende Des Textes an
  103. //! \param num Die Zahl, die in einen Text umgewandelt und am Ende
  104. //! angehängt werden soll
  105. DLLEXPORT void append(__int64 num);
  106. //! Hängt eine Zahl ohne Vorzeichenbit am Ende des Textes an
  107. //! \param num Die Zahl, die in einen Text umgewandelt und am Ende
  108. //! angehängt werden soll
  109. DLLEXPORT void append(unsigned int num);
  110. //! Hängt eine Kommazahl am Ende des Textes an
  111. //! \param num Die Kommazahl, die am Ende des Textes angehängt werden
  112. //! soll
  113. DLLEXPORT void append(double num);
  114. //! Hängt eine Kommazahl am Ende des Textes an
  115. //! \param num Die Kommazahl, die am Ende des Textes angehängt werden
  116. //! soll
  117. DLLEXPORT void append(float num);
  118. //! Gibt einen ostream zurück, der alle ausgaben an diesen Text anhängt
  119. DLLEXPORT FlushingOStream append();
  120. //! Fügt an einer Bestimmten Stelle ein Zeichen in den Text ein
  121. //! \param p Die position im Text bei der das Zeichen eingefügt werden
  122. //! soll \param c Das Zeichen, das eingefügt werden soll
  123. DLLEXPORT void insert(int p, char c);
  124. //! Fügt an einer Bestimmten Stelle im Text eine Zeichenkette ein
  125. //! \param p Die position im Text bei der die Zeichenkette eingefügt
  126. //! werden soll \param t Die Zeichenkette, deren Kopie an eingefügt
  127. //! werden soll
  128. DLLEXPORT void insert(int p, const char* t);
  129. //! Fügt den Inhalt eines Textes an einer Bestimmten Stelle im Text ein
  130. //! \param p Die Position im Text, bei der der inhalt des Textest
  131. //! eingefügt werden soll \param t Der Text, dessen Kopie an der Stelle
  132. //! eingefügt werden soll
  133. DLLEXPORT void insert(int p, Text* t);
  134. //! Ersetzt einen bestimmten Textabschnitt mit einer anderen
  135. //! Zeichenkette
  136. //! p1: Die Startposition des zu ersetzenden Textabschnittes
  137. //! p2: Die Endposition des zu ersetzenden Textabschnittes
  138. //! \param t Die Zeichenkette, die an die entsprechende Stelle kopiert
  139. //! werden soll Beispiel: ( "Hallo Welt" ).ersetzen( 2, 5, "lt" );
  140. //! ergibt: "Halt Welt"
  141. DLLEXPORT void ersetzen(int p1, int p2, const char* t);
  142. //! Ersetzt einen bestimmten Textabschnitt mit dem Inhalt eines anderen
  143. //! Textes
  144. //! p1: Die Startposition des zu ersetzenden Textabschnittes
  145. //! p2: Die Endposition des zu ersetzenden Textabschnittes
  146. //! \param t Der Text, dessen Inhalt an die entsprechende Stelle kopiert
  147. //! werden soll Beispiel: ( "Hallo Welt" ).ersetzen( 2, 5, new Text(
  148. //! "lt" ) ); ergibt: "Halt Welt"
  149. DLLEXPORT void ersetzen(int p1, int p2, Text* t);
  150. //! Sucht und erstetzt jedes Vorkommen eines bestimmten Buchstaben durch
  151. //! einen anderen
  152. //! c1: Der Buchstabe der ersetzt werden soll
  153. //! c2: Der Buchstabe, durch den der Andere ersetzt werden soll
  154. DLLEXPORT void ersetzen(char c1, char c2);
  155. //! Sucht und erstetzt jedes Vorkommen einer bestimmten Zeichenkette
  156. //! durch eine andere
  157. //! t1: Die Zeichenkette, die ersetzt werden soll
  158. //! t2: Die Zeichenkette, durch welche die Andere ersetzt werden soll
  159. DLLEXPORT void ersetzen(const char* t1, const char* t2);
  160. //! Sucht und erstetzt jedes Vorkommen des Inhalts eines Textes durch
  161. //! eine andere Zeichenkette
  162. //! t1: Der Text, dessen Inhalt gesucht und ersetzt wird
  163. //! t2: Die Zeichenkette, durch welche das Vorkommen des Textes ersetzt
  164. //! werden soll
  165. DLLEXPORT void ersetzen(Text* t1, const char* t2);
  166. //! Sucht und erstetzt jedes Vorkommen einer Zeichenkette durch den
  167. //! Inhalt eines Textes
  168. //! t1: Die Zeichenkette, die ersetzt werden soll
  169. //! t2: Der Text, dessen Inhalt das Vorkommen der Zeichenkette
  170. //! ersetzten soll
  171. DLLEXPORT void ersetzen(const char* t1, Text* t2);
  172. //! Sucht und erstetzt jedes Vorkommen des Inhalts eines Textes durch
  173. //! den Inhalt eines anderen Textes
  174. //! t1: Der Text, dessen Vorkommen ersetzt werden sollen
  175. //! t2: Der Text, dessen Inhalt das Vorkommen der Zeichenkette
  176. //! ersetzten soll
  177. DLLEXPORT void ersetzen(Text* t1, Text* t2);
  178. //! Ersetzt das i-te auftreten eines bestimmten Buchstaben mit einem
  179. //! anderen Buchstaben \param i Das wie vielte Auftreten des Buchstabens
  180. //! ersetzt werden soll
  181. //! c1: Der Buchstabe, dessen i-tes Auftreten erstetzt werden soll
  182. //! c2: Der Buchstabe, der das i-te Auftreten des anderen Buchstabens
  183. //! ersetzen soll
  184. DLLEXPORT void ersetzen(int i, char c1, char c2);
  185. //! Ersetzt das i-te auftreten einer bestimmten Zeichenkette mit einer
  186. //! anderen Zeichenkette \param i Das wie vielte Auftreten der
  187. //! Zeichenkette ersetzt werden soll
  188. //! c1: Die Zeichenkette, dessen i-tes Auftreten erstetzt werden soll
  189. //! c2: Die Zeichenkette, die das i-te Auftreten der anderen
  190. //! Zeichenkette ersetzen soll
  191. DLLEXPORT void ersetzen(int i, const char* t1, const char* t2);
  192. //! Ersetzt das i-te auftreten des Inhalts eines Textes mit einer
  193. //! Zeichenkette \param i Das wie vielte Auftreten des Textes ersetzt
  194. //! werden soll
  195. //! c1: Der Text, dessen i-tes Auftreten erstetzt werden soll
  196. //! c2: Die Zeichenkette, die das i-te Auftreten des Textes ersetzen
  197. //! soll
  198. DLLEXPORT void ersetzen(int i, Text* t1, const char* t2);
  199. //! Ersetzt das i-te auftreten einer bestimmten Zeichenkette mit dem
  200. //! Inhalt eines Textes \param i Das wie vielte Auftreten der
  201. //! Zeichenkette ersetzt werden soll
  202. //! c1: Die Zeichenkette, dessen i-tes Auftreten erstetzt werden soll
  203. //! c2: Der Text, dessen Inhalt das i-te Auftreten der Zeichenkette
  204. //! ersetzen soll
  205. DLLEXPORT void ersetzen(int i, const char* t1, Text* t2);
  206. //! Ersetzt das i-te auftreten eines bestimmten Textes mit dem Inhalt
  207. //! eines anderen Textes \param i Das wie vielte Auftreten des Textes
  208. //! ersetzt werden soll
  209. //! c1: Der Text, dessen i-tes Auftreten erstetzt werden soll
  210. //! c2: Der Text, dessen Inhalt das i-te Auftreten des anderen Textes
  211. //! ersetzen soll
  212. DLLEXPORT void ersetzen(int i, Text* t1, Text* t2);
  213. //! Löscht den bisherigen Text und erzeugt einen Text, der aus einem
  214. //! Bestimten Buchstaben besteht, mit einer bestimmten Länge \param c
  215. //! Der Buchstabe, aus dem der Text bestehen soll \param length Die
  216. //! Länge des Textes
  217. DLLEXPORT void fillText(char c, int length);
  218. //! Löscht ein Bestimmtes Zeichen aus dem Text
  219. //! \param p Die Position des zu löschenden Zeichens
  220. DLLEXPORT void remove(int p);
  221. //! Löscht einen Bestimmten Textabschnitt
  222. //! p1: Die Startposition des zu löschenden Abschnittes
  223. //! p2: Die Endposition des zu löschenden Abschnittes (Das Zeichen bei
  224. //! p2 bleibt erhalten)
  225. DLLEXPORT void remove(int p1, int p2);
  226. //! Löscht jedes Vorkommen eines bestimmten Buchsaben
  227. //! \param c Der Buchstabe, dessen Vorkommen gelöscht werden soll
  228. DLLEXPORT void remove(char c);
  229. //! Löscht jedes Vorkommen einer bestimmten Zeichenkette
  230. //! \param t Die Zeichenkette, deren Vorkommen entfernt werden sollen
  231. DLLEXPORT void remove(const char* t);
  232. //! Löscht jedes Vorkommen des Inhalts eines Textes
  233. //! \param t Der text, dessen Inhalt gelöscht werden soll
  234. DLLEXPORT void remove(Text* t);
  235. //! Löscht das i-te Vorkommen eines bestimmten Buchstaben
  236. //! \param i Das wie vielte Vorkommen des Buchstabens gelöscht werden
  237. //! soll \param c Der Buchstabe, dessen i-tes Vorkommen gelöscht werden
  238. //! soll
  239. DLLEXPORT void remove(int i, char c);
  240. //! Löscht das i-te Vorkommen einer bestimmten Zechenkette
  241. //! \param i Das wie vielte Vorkommen der Zeichenkette gelöscht werden
  242. //! soll \param t Die Zeichenkette, dessen i-tes Vorkommen gelöscht
  243. //! werden soll
  244. DLLEXPORT void remove(int i, const char* t);
  245. //! Löscht das i-te Vorkommen eines bestimmten Textinhaltes
  246. //! \param i Das wie vielte Vorkommen des Textinhaltes gelöscht werden
  247. //! soll \param t Der Text, dessen i-tes Vorkommen gelöscht werden soll
  248. DLLEXPORT void remove(int i, Text* t);
  249. //! Löscht alle ' ', '\n', '\r', '\t' bis zu einem anderen buchstaben
  250. //! \param pos Die Position des ersten zeichens
  251. DLLEXPORT void removeWhitespaceAfter(int pos);
  252. //! Löscht alle ' ', '\n', '\r', '\t' bis zu einem anderen buchstaben
  253. //! \param pos Die Position des ersten zeichens (beginnt bei pos-1)
  254. DLLEXPORT void removeWhitespaceBefore(int pos);
  255. //! Setzt die Anzahl der Nachkommastellen beim Anhängen von Kommazahlen
  256. //! \param p Die Anzahl der Stellen nach dem Komma
  257. DLLEXPORT void setPrecision(int p);
  258. //! Gibt die Länge des Textes zurück
  259. DLLEXPORT int getLength() const;
  260. //! Ermittelt die neue Curserposition nachdem Drücken der 'Links'
  261. //! Pfeiltaste \param pos Die alte Curserposition
  262. DLLEXPORT int getLKick(int pos) const;
  263. //! Ermittelt die neue Curserposition nachdem Drücken der 'Oben'
  264. //! Pfeiltaste \param pos Die alte Curserposition
  265. DLLEXPORT int getOKick(int pos) const;
  266. //! Ermittelt die neue Curserposition nachdem Drücken der 'Rechts'
  267. //! Pfeiltaste \param pos Die alte Curserposition
  268. DLLEXPORT int getRKick(int pos) const;
  269. //! Ermittelt die neue Curserposition nachdem Drücken der 'Unten'
  270. //! Pfeiltaste \param pos Die alte Curserposition
  271. DLLEXPORT int getUKick(int pos) const;
  272. //! Überprüft, ob im Text der Inhalt eines anderen Textes vorkommt
  273. //! \param t Der Text, nach dessen Inhalt gesucht werden soll
  274. //! \return (true), wenn der Inhalt des Textes vorkommt. (false) sonnst
  275. DLLEXPORT bool hat(Text* t) const;
  276. //! Überprüft, ob im Text eine bestimmte Zeichenkette vorkommt
  277. //! \param t Die Zeichenkette, nach der gesucht werden soll
  278. //! \return (true), wenn die Zeichenkette vorkommt. (false) sonnst
  279. DLLEXPORT bool hat(const char* t) const;
  280. //! Überprüft, ob im Text der Inhalt eines anderen Textes vorkommt
  281. //! \param t Der Text, nach dessen Inhalt gesucht werden soll
  282. //! \return (true), wenn der Inhalt des Textes vorkommt. (false) sonnst
  283. //! \param pos die position an der die zeichenkette im string beginnen
  284. //! soll
  285. DLLEXPORT bool hatAt(int pos, Text* t) const;
  286. //! Überprüft, ob im Text eine bestimmte Zeichenkette vorkommt
  287. //! \param t Die Zeichenkette, nach der gesucht werden soll
  288. //! \return (true), wenn die Zeichenkette vorkommt. (false) sonnst
  289. //! \param pos die position an der die zeichenkette im string beginnen
  290. //! soll
  291. DLLEXPORT bool hatAt(int pos, const char* t) const;
  292. //! Überprüft, ob im Text ein bestimmtes Zeichen vorkommt
  293. //! \param c Das Zeichen, nach dem gesucht werden soll
  294. //! \return (true), wenn das Zeichen vorkommt. (false) sonnst
  295. DLLEXPORT bool hat(char c) const;
  296. //! Überprft, ob der Text den selben Inhalt wie eine Zeichenkette hat
  297. //! \param t Die Zeichenkette, die verglichen werden soll
  298. //! \return (true), wenn der Inhalt des Textes gleich der Zeichenkette
  299. //! ist. (false) sonst
  300. DLLEXPORT bool istGleich(const char* t) const;
  301. //! Überprft, ob der Text den selben Inhalt wie ein anderer Text hat
  302. //! \param t Der Text, dessen Inhalt verglichen werden soll
  303. //! \return (true), wenn die Inhalte der Texte übereinstimmen. (false)
  304. //! sonst
  305. DLLEXPORT bool istGleich(Text* t) const;
  306. //! Gibt den Inhalt des Textes als Zeichenkette zurück
  307. DLLEXPORT const char* getText() const;
  308. //! Zählt, wie oft ein bestimmter Buchstabe im Text vorkomt
  309. //! \param c Der Buchstabe, der gezählt werden soll
  310. //! \return Die Anzahl des Buchstabens im Text
  311. DLLEXPORT int anzahlVon(char c) const;
  312. //! Zählt, wie oft eine bestimmte Zeichenkette im Text vorkommt
  313. //! \param t Die Zeichenkette, die gezählt werden soll
  314. //! \return Die Anzahl der Zeichenkette im Text
  315. DLLEXPORT int anzahlVon(const char* t) const;
  316. //! Zählt, wie oft der Inhalt eines Textest im Text vorkommt
  317. //! \param t Der Text, dessen Inhalt gezählt werden soll
  318. //! \return Die Anzahl des Textinhaltes im Text
  319. DLLEXPORT int anzahlVon(Text* t) const;
  320. //! Gibt die erste Position eines bestimmten Buchstabens im Text zurück
  321. //! \param c Der Buchstabe, der gefunden werden soll
  322. //! \return Die Position des ersten Vorkommens des Buchstabens
  323. DLLEXPORT int positionVon(char c) const;
  324. //! Gibt die erste Position einer bestimmten Zeichenkette im Text zurück
  325. //! \param t Die Zeichenkette, die gefunden werden soll
  326. //! \return Die Position des ersten Vorkommens der Zeichenkette
  327. DLLEXPORT int positionVon(const char* t) const;
  328. //! Gibt die erste Position eines Textinhaltes im Text zurück
  329. //! \param t Der Text, dessen Inhalt gefunden werden soll
  330. //! \return Die Position des ersten Vorkommens des Textinhaltes
  331. DLLEXPORT int positionVon(Text* t) const;
  332. //! Gibt die i-te Position eines bestimmten Buchstabens im Text zurück
  333. //! \param c Der Buchstabe, der gefunden werden soll
  334. //! \param i Das wievielte Vorkommen gefunden werden soll
  335. //! \return Die Position des i-ten Vorkommens des Buchstabens
  336. DLLEXPORT int positionVon(char c, int i) const;
  337. //! Gibt die i-te Position einer bestimmten Zeichenkette im Text zurück
  338. //! \param t Die Zeichenkette, die gefunden werden soll
  339. //! \param i Das wievielte Vorkommen gefunden werden soll
  340. //! \return Die Position des i-ten Vorkommens der Zeichenkette
  341. DLLEXPORT int positionVon(const char* t, int i) const;
  342. //! Gibt die i-te Position eines Textinhaltes im Text zurück
  343. //! \param t Der Text, dessen Inhalt gefunden werden soll
  344. //! \param i Das wievielte Vorkommen gefunden werden soll
  345. //! \return Die Position des i-ten Vorkommens des Textinhaltes
  346. DLLEXPORT int positionVon(Text* t, int i) const;
  347. //! Gibt einen Text zurück, der eine Kopie eines bestimmten
  348. //! Textabschnittes enthält
  349. //! p1: Die Startposition des Textabschnittes
  350. //! p2: Die Endposition des Textabschnittes (nicht enthalten)
  351. DLLEXPORT Text* getTeilText(int p1, int p2) const;
  352. //! Gibt einen Text zurück, der eine Kopie eines bestimmten
  353. //! Textabschnittes enthält
  354. //! p1: Die Startposition des Textabschnittes (Der Textabschnitt geht
  355. //! bis ans Ende des Textes)
  356. DLLEXPORT Text* getTeilText(int p) const;
  357. //! berechnet den Hash code des textes
  358. DLLEXPORT int hashCode() const;
  359. //! Hängt eine Zahl ans Ende des Textes an
  360. DLLEXPORT Text& operator+=(const int num);
  361. //! Hängt eine Zahl ans Ende des Textes an
  362. DLLEXPORT Text& operator+=(const __int64 num);
  363. //! Hängt eine Kommazahl ans Ende des Textes an
  364. DLLEXPORT Text& operator+=(const double num);
  365. //! Hängt eine Kommazahl ans Ende des Textes an
  366. DLLEXPORT Text& operator+=(const float num);
  367. //! Hängt eine Zeichenkette ans Ende des Textes an
  368. DLLEXPORT Text& operator+=(const char* txt);
  369. //! Hängt eine Kopie des Inhalts eines Textes ans Ende des Textes an
  370. DLLEXPORT Text& operator+=(const Text& txt);
  371. //! Setzt den Inhalt des Textes gleich einer Zahl
  372. DLLEXPORT Text& operator=(const int num);
  373. //! Setzt den Inhalt des Textes gleich einer Kommazahl
  374. DLLEXPORT Text& operator=(const double num);
  375. //! Setzt den Inhalt des Textes gleich einer Kommazahl
  376. DLLEXPORT Text& operator=(const float num);
  377. //! Setzt den Inahlt des Textes gleich einer Zeichenkette
  378. DLLEXPORT Text& operator=(const char* txt);
  379. //! Setzt den Inhalt des Textes gleich einer Kopie des Inhalts eines
  380. //! anderen Textes
  381. DLLEXPORT Text& operator=(const Text& txt);
  382. //! Gibt den Inhalt des Textes als Zeichenkette zurück
  383. DLLEXPORT operator const char*() const;
  384. //! Konviertiert den Inhalt des Textes zu einer Zahl
  385. DLLEXPORT explicit operator int() const;
  386. //! Konviertiert den Inhalt des Textes zu einer Zahl
  387. DLLEXPORT explicit operator __int64() const;
  388. //! Konviertiert den Inhalt des Textes zu einer Kommazahl
  389. DLLEXPORT explicit operator double() const;
  390. //! Konviertiert den Inhalt des Textes zu einer Kommazahl
  391. DLLEXPORT explicit operator float() const;
  392. //! Prüft, ob der Inhalt des Textes nach alphabetischer Ordnung später
  393. //! kommt als der Inhalt eines anderen Textes
  394. DLLEXPORT bool operator>(Text& t) const;
  395. //! Prüft, ob der Inhalt des Textes nach alphabetischer Ordnung früher
  396. //! kommt als der Inhalt eines anderen Textes
  397. DLLEXPORT bool operator<(Text& t) const;
  398. //! Erstellt einen neuen Text bestehend aus diesem und t2
  399. DLLEXPORT Text operator+(const Text& t2) const;
  400. //! Erstellt einen neuen Text bestehend aus diesem und t2
  401. DLLEXPORT Text operator+(const char* t2) const;
  402. //! Erstellt einen neuen Text bestehend aus diesem und num
  403. DLLEXPORT Text operator+(const int num) const;
  404. //! Erstellt einen neuen Text bestehend aus diesem und num
  405. DLLEXPORT Text operator+(const __int64 num) const;
  406. //! Erstellt einen neuen Text bestehend aus diesem und num
  407. DLLEXPORT Text operator+(const double num) const;
  408. //! Erstellt einen neuen Text bestehend aus diesem und num
  409. DLLEXPORT Text operator+(const float num) const;
  410. //! Prüft ob der Text mit dem anderen Text übereinstimmt
  411. DLLEXPORT bool operator==(const Text& right) const;
  412. };
  413. class TextReader : public Reader,
  414. public virtual ReferenceCounter
  415. {
  416. private:
  417. Text* txt;
  418. __int64 lPos;
  419. public:
  420. //! Konstructor
  421. //! \param txt Der Text der gelesen werden soll. Er wird nicht kopiert
  422. //! sondern direkt gelesen.
  423. DLLEXPORT TextReader(Text* txt);
  424. //! Destructor
  425. DLLEXPORT virtual ~TextReader();
  426. //! Setzt die Position des Bytes, das als nächstes gelesen werden soll
  427. //! \param pos Der Index des Bytes
  428. //! \param ende 1, wenn der Index vom ende des Textes zählt. 0, wenn der
  429. //! Index vom Beginn des Textes zählt
  430. DLLEXPORT void setLPosition(__int64 pos, bool ende) override;
  431. //! Ließt aus der Datei
  432. //! \param bytes Ein Array, der mit Bytes aus dem Text gefüllt werden
  433. //! soll \param len Wie viele Bytes aus dem Text gelesen werden sollen
  434. DLLEXPORT void lese(char* bytes, int len) override;
  435. //! Ließt die nächste zeile des Textes ein
  436. //! \return Die gelesene Zeile als Text mit zeilenumbruch
  437. DLLEXPORT Text* leseZeile() override;
  438. //! Prüft, ob die Resource vollständig gelesen wurde
  439. //! return 1, wenn die Resource vollständig gelesen wurde. 0, sonst
  440. DLLEXPORT bool istEnde() const override;
  441. //! Gibt den Index des Bytes aus dem Text zurück, welches als nächstes
  442. //! gelesen werden würde return -1, falls ein Fehler aufgetreten ist.
  443. //! Sonst die Position des Lesezeigers
  444. DLLEXPORT __int64 getLPosition() const override;
  445. //! Gibt die Anzahl der zu lesenden Bytes zurück
  446. DLLEXPORT __int64 getSize() const override;
  447. };
  448. //! Durchsucht eine Zeichenkette nach dem num-ten Vorkommen eines bestimmten
  449. //! Buchstabens \param string Die zu durchsuchende Zeichenkette \param c Der
  450. //! zu suchende Buchstabe \param num Das wievielte Vorkommen des Buchtaben
  451. //! gefunden werden soll \return (-1), wenn es kein num-tes Vorkommen des
  452. //! Buchstaben gibt. Sonst die Position des num-ten Vorkommens in der
  453. //! Zeichenkette
  454. DLLEXPORT int stringPositionVonChar(const char* string,
  455. char c,
  456. int num); //! sucht die position des num-ten c-s in string, -1 bei nicht
  457. //! gefunden
  458. //! Durchsucht eine Zeichenkette nach einer Anderen Zeichenkette
  459. //! \param string Die zu durchsuchende Zeichenkette
  460. //! \param suche Die Zeichenkette, nach der gesucht werden soll
  461. //! \param sBegPos Die Position, ab der die Suche begonnen werden soll
  462. //! \return Die Position, an der die zu suchende Zeichenkette erstmals
  463. //! gefunden wurde. (-1) Wenn nichts gefunden wurde.
  464. DLLEXPORT int stringPositionVonString(
  465. const char* string, char* suche, int sBegPos);
  466. //! Kopiert eine bestimmte Zeichenkette in die Zwischenablage des
  467. //! Betriebssystems \param txt Die Zeichenkette, die kopiert werden soll
  468. DLLEXPORT void TextKopieren(const char* txt);
  469. //! Ermittelt, ob in der Zwischenablage des Betriebssystems eine
  470. //! Zeichenkette steht. \return Die Zeichenkette aus der Zwischenablage.
  471. //! Wenn keine Zeichenkette kopiert wurde, wird eine lehre Zeichenkette
  472. //! zurückgegeben.
  473. DLLEXPORT const char* TextInsert();
  474. //! Wandelt einen bestimmten schreibbaren Buchstaben in einen Groß- oder
  475. //! Kleinbuchstaben um \param c Der Buchstabe, der umgewandelt werden soll
  476. //! \param groß Wenn (true), so wird der Buchstabe in einen Großbuchstaben
  477. //! umgewandelt. Wenn (false), wird er in einen Kleinbuchstaben umgewandelt.
  478. //! \return Den umgewandelten Buchstaben
  479. DLLEXPORT char smallOrBig(char c, bool big);
  480. //! Ermittelt, ob ein Buchstabe ein schreibbares Zeichen ist
  481. //! \param zeichen Der Buchstabe, der geprüft werden soll
  482. //! \return (true), wenn der Buchstabe gezeichnet werden kann. (false)
  483. //! sonnst
  484. DLLEXPORT bool istSchreibbar(unsigned char zeichen);
  485. //! Konvertiert eine Zahl aus einer Zeichenkette in belibiger Basis zu einer
  486. //! Zahl \param c Die Zeichenkette, in der Die Zahl steht \param system Die
  487. //! Basis der Zahl \return Die Zahl, die im Text stand
  488. DLLEXPORT unsigned int TextZuInt(const char* c, int system);
  489. //! Konvertiert eine Zahl aus einer Zeichenkette in belibiger Basis zu einer
  490. //! Zahl \param c Die Zeichenkette, in der Die Zahl steht
  491. //! c_ende: Wird duch die Funktion gesetzt und darf 0 sein. Zeigt auf das
  492. //! nächste Zeichen in der Zeichenkette, das nach der Zah steht
  493. //! \param system Die Basis der Zahl
  494. //! \return Die Zahl, die im Text stand
  495. DLLEXPORT unsigned int TextZuInt(const char* c, char** c_ende, int system);
  496. //! Konvertiert eine Zahl aus einer Zeichenkette in belibiger Basis zu einer
  497. //! Zahl \param c Die Zeichenkette, in der Die Zahl steht \param system Die
  498. //! Basis der Zahl \return Die Zahl, die im Text stand
  499. DLLEXPORT unsigned __int64 TextZuInt64(const char* c, int system);
  500. //! Konvertiert eine Zahl aus einer Zeichenkette in belibiger Basis zu einer
  501. //! Zahl \param c Die Zeichenkette, in der Die Zahl steht
  502. //! c_ende: Wird duch die Funktion gesetzt und darf 0 sein. Zeigt auf das
  503. //! nächste Zeichen in der Zeichenkette, das nach der Zah steht
  504. //! \param system Die Basis der Zahl
  505. //! \return Die Zahl, die im Text stand
  506. DLLEXPORT unsigned __int64 TextZuInt64(
  507. const char* c, char** c_ende, int system);
  508. //! Konvertiert eine Zeichenkette zu einem Double
  509. //! \param c Die Zeichenkette, die konvertiert werden soll
  510. //! \return Das double, was in der Zeichenkette stand
  511. DLLEXPORT double TextZuDouble(const char* c);
  512. //! Konvertiert eine Zeichenkette zu einem Float
  513. //! \param c Die Zeichenkette, die konvertiert werden soll
  514. //! \return Das float, was in der Zeichenkette stand
  515. DLLEXPORT float TextZuFloat(const char* c);
  516. //! Konvertiert eine Zeichenkette zu einem Double
  517. //! \param c Die Zeichenkette, die konvertiert werden soll
  518. //! c_ende: Wird duch die Funktion gesetzt und darf 0 sein. Ein Zeiger auf
  519. //! das nächste Zeichen nach dem Double in der Zeichenkette
  520. //! \return Das double, was in der Zeichenkette stand
  521. DLLEXPORT double TextZuDouble(const char* c, char** c_ende);
  522. //! Konvertiert eine Zeichenkette zu einem float
  523. //! \param c Die Zeichenkette, die konvertiert werden soll
  524. //! c_ende: Wird duch die Funktion gesetzt und darf 0 sein. Ein Zeiger auf
  525. //! das nächste Zeichen nach dem float in der Zeichenkette
  526. //! \return Das float, was in der Zeichenkette stand
  527. DLLEXPORT float TextZuFloat(const char* c, char** c_ende);
  528. //! Ermittelt die Länge einer bestimmten Zeichenkette
  529. //! \param txt Die Zeichenkette, deren Länge ermittelt werden soll
  530. //! \return Die Länge der Zeichenkette
  531. DLLEXPORT int textLength(const char* txt);
  532. } // namespace Framework
  533. #endif