Text.h 29 KB

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