Text.h 28 KB

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