File: INCLUDE\UTILS\U_VALUES.H
1 //#############################################################################
2 // //
3 // U_VALUES.H //
4 // Subsystem: Utilities - Tools für Zahlen und Strings //
5 // Benutzung durch andere Subsysteme erforderlich: JA //
6 // Implementation: U_VALUES.CPP //
7 //---------------------------------------------------------------------------//
8 // Autoren: Thomas Kullmann, Günther Reinecker //
9 // Stand: 07.11.2002 //
10 // //
11 //#############################################################################
12
13 #ifndef __U_VALUES_H
14 #define __U_VALUES_H
15
16 #if defined (Build_Library)
18 #elif defined(Use_Library)
20 #else
21 #define _CURVECLASS
22 #endif
23
24 #define STRICT
25 #ifdef __cplusplus
26 #include <windows.h>
27 #include <string.h>
28 #include <windowsx.h>
29 #include <mmsystem.h>
30 #include <stdio.h>
31 #include <math.h>
32 #include <dos.h>
33 #include <string.h>
34 #include <string>
35 typedef std::string string;
36 #include <stdlib.h>
37 #include <stdarg.h>
38 #endif
39
40 //--||--\\--||--//--||--\\--||--//--||--\\--||--//--||--\\--||--//--||--\\--||--
41
42 //#############################################################################
43 // globale Typ- und Konstantendeklarationen
44 //#############################################################################
45
46 //gibt <toFree> frei und setzt <toFree> 0
47 #define _FREEOBJ(toFree) { if (toFree) { delete toFree; toFree= 0; }; }
48
49 //gibt das Feld <toFree> frei und setzt <toFree> 0
50 #define _FREELIST(toFree) { if (toFree) { delete []toFree; toFree= 0; }; }
51
52 const UINT _MAXLENDOUBLE= 50; // 50 Zeichen für Double-Werte sollte bei weitem reichen
53
54 // TMemoryPolice-Objekt nach einer Felddeklaration (array) erzeugen
55 // wird der letzte Index des Feldes überschritten, liefert CheckStillContant des TMemoryPolice-Objekts FALSE, weil der Inhalt seines Members überschrieben wurde
56 // Realisierung einmal im Steak und Heap möglich - TStackPolice bzw. THeapPolice
57 class _CURVECLASS TMemoryPolice {
58 private:
59 TMemoryPolice(const TMemoryPolice& aList) {}; // kein Copy-Konstruktor
60 TMemoryPolice &operator= (const TMemoryPolice&) { return *this; }; // kein Zuweisungsoperator
61 public:
62 TMemoryPolice() {};
63 protected:
64 virtual bool CheckStillConstant()=0;
65 };
66
67 #ifdef _DEBUG
68
69 const char DEFENDSTR[]= "This line should stay as it is. Supervise this by a CheckStillConstant to proof that nobody exceedes his memory and overwrites your personal data.";
70
71 class _CURVECLASS THeapPolice : protected TMemoryPolice {
72 public:
73 THeapPolice() : m_ToDefend(0) {
74 m_ToDefend= new char[strlen(DEFENDSTR)+1];
75 strcpy(m_ToDefend, DEFENDSTR);
76 }
77 ~THeapPolice() {
78 _FREELIST(m_ToDefend);
79 }
80
81 virtual bool CheckStillConstant() {
82 return ( strcmp(m_ToDefend, DEFENDSTR)==0 );
83 }
84
85 private:
86 char *m_ToDefend;
87 };
88 class _CURVECLASS TStackPolice : protected TMemoryPolice {
89 public:
90 TStackPolice() {
91 strcpy(m_ToDefend, DEFENDSTR);
92 }
93
94 virtual bool CheckStillConstant() {
95 return ( strcmp(m_ToDefend, DEFENDSTR)==0 );
96 }
97
98 private:
99 char m_ToDefend[147];
100 };
101
102 // Klassen, von denen Objekte als Memoryleak zurückbleiben könnten, von TLeakPolice ableiten
103 // in der DEBUG-Version wird bei Programmbeendigung 'LEAKPOLICE #<x>' ausgegeben, wenn wirklich noch Objekte dieses Typs im Speicher liegen
104 // <x> gibt dann die Nummer an, wann das Objekt erzeugt wurde - Breakpoints im Konstruktor (Bedingung m_Counter==<x>) kann dann die Aufrufbedingung des Leak-Objekts über die Steakaufrufliste analysiert werden
105 class _CURVECLASS TLeakPolice {
106 char m_LeakName[30];
107 UINT m_Counter;
108 static UINT s_Counter;
109
110 public:
111 TLeakPolice(LPCSTR aName="") : m_Counter(s_Counter++) {
112 if ( !aName || strlen(aName)==0 ) sprintf(m_LeakName, "LEAKPOLICE #%d", aName, m_Counter);
113 else sprintf(m_LeakName, "%s #%d", aName, m_Counter);
114 }
115 ~TLeakPolice() {
116 }
117 };
118 119 #else
120
121 class _CURVECLASS THeapPolice : protected TMemoryPolice {
122 public:
123 virtual bool CheckStillConstant() {
124 return true;
125 }
126 };
127 class _CURVECLASS TStackPolice : protected TMemoryPolice {
128 public:
129 virtual bool CheckStillConstant() {
130 return true;
131 }
132 };
133
134 class _CURVECLASS TLeakPolice {
135 public:
136 TLeakPolice(LPCSTR aName= "") {}
137 };
138
139 #endif
140
141 ////////////////////////////////////////////////////////////////////////////////
142 // Trace
143 ////////////////////////////////////////////////////////////////////////////////
144
145 // Signatur: TraceMsg( in aStr )
146 // gibt <aStr> in einer MessageBox mit dem Titel "Trace" aus
147 void _CURVECLASS WINAPI TraceMsg ( LPCSTR );
148
149 // Signatur: TraceMsg( in aDouble )
150 // gibt <aDouble> mit der Nachkommastellenganauigkeit von 1 in einer MessageBox mit dem Titel "Trace" aus
151 void _CURVECLASS WINAPI TraceMsg ( const double );
152
153 // Signatur: Trace( in aStr ) bzw. TraceErr( in aStr )
154 // NUR DEBUG-VERSION: sendet <aStr> an den aktuellen Debugger, um dort angezeigt zu werden (funktioniert erst ab BC 5.02)
155 void _CURVECLASS WINAPI Trace ( LPCSTR aStr ); // für kurzfristiges Degugging, im CVS sollte also nie eine Trace-Benutzung auftauchen
156 void _CURVECLASS WINAPI TraceErr ( LPCSTR aStr ); // für dauerhafte Warnungen für DEBUG-Anwender
157
158 // Signatur: Trace( in aDouble )
159 // NUR DEBUG-VERSION: sendet <aDouble> mit der Nachkommastellenganauigkeit von 1 an den aktuellen Debuffer, um dort angezeigt zu werden (funktioniert erst ab BC 5.02)
160 void _CURVECLASS WINAPI Trace ( const double aDouble );
161
162 ////////////////////////////////////////////////////////////////////////////////
163 // Runden, Abrunden von Double-Werten
164 ////////////////////////////////////////////////////////////////////////////////
165
166 // Signatur: DoubleRound( in aDouble, in aDigits )
167 // ==> <aDouble> gerundet auf <aDigits> Nachkommastellen
168 double _CURVECLASS WINAPI DoubleRound ( const double, const UINT );
169
170 // Signatur: DoubleRoundUp( in aDouble, in aDigits )
171 // ==> <aDouble> mit <aDigits> Nachkommastellen (AUFGERUNDET)
172 double _CURVECLASS WINAPI DoubleRoundUp ( const double, const UINT );
173
174 // Signatur: DoubleRoundOff( in aDouble, in aDigits )
175 // ==> <aDouble> mit <aDigits> Nachkommastellen, nachfolgende werden verworfen (ABRUNDEN)
176 double _CURVECLASS WINAPI DoubleRoundOff ( const double, const UINT );
177
178 // Signatur: Double2Float( in aDouble, in aDigits )
179 // ==> <aDouble> als Float-Wert mit <aDigits> Nachkommastellen (ohne das blöde Ungenauigkeitsphänomen), nachfolgende werden verworfen (ABRUNDEN)
180 // ACHTUNG: Die Genauigkeit von Float ist geringer als von Double!!!
181 float _CURVECLASS WINAPI Double2Float ( const double, const UINT );
182
183 // Signatur: Float2Double( in aFloat, in aDigits )
184 // ==> <aFloat> als Double-Wert mit <aDigits> Nachkommastellen (ohne das blöde Ungenauigkeitsphänomen), nachfolgende werden verworfen (ABRUNDEN)
185 double _CURVECLASS WINAPI Float2Double ( const float, const UINT );
186
187
188 ////////////////////////////////////////////////////////////////////////////////
189 // Stringmanipulation
190 ////////////////////////////////////////////////////////////////////////////////
191 // *** der Aufrufer ist dafür zuständig, dass der zurückgegebene String freigegeben wird !!!
192
193 // siehe GetFormatedStringMaxLen mit <aMaxLen>= 1024
194 // ==> formatierter Text ***
195 LPSTR _CURVECLASS WINAPI GetFormatedString( LPCSTR, ... );
196 LPSTR _CURVECLASS WINAPI GetFormatedString( LPCSTR, va_list& ) ;
197
198 // Signatur: GetFormatedStringMaxLen( in aFormat, in aMaxLen, ... )
199 // reserviert soviel Speicher, dass sprintf den in <aFormat> angegebenen String
200 // mit der variablen Parameterliste ausgeben kann (max. jedoch <aMaxLen> Zeichen)
201 // ==> formatierter Text ***
202 LPSTR _CURVECLASS WINAPI GetFormatedStringMaxLen( LPCSTR aFormat, const UINT aMaxLen, ... );
203 LPSTR _CURVECLASS WINAPI GetFormatedStringMaxLen( LPCSTR aFormat, const UINT aMaxLen, va_list& );
204
205 ////////////////////////////////////////////////////////////////////////////////
206 // Stringmanipulation
207 ////////////////////////////////////////////////////////////////////////////////
208
209 // Signatur: StringReplace( in/out aString, in aOld, in aNew )
210 // ersetzt <aOld> durch <aNew> in <aString> und gibt das Ergebnis wieder in <aString> zurück
211 void _CURVECLASS WINAPI StringReplace ( char*, const char, const char );
212
213 // Signatur: StringIgnore( in/out aString, in aIgnore )
214 // entfernt alle <aIgnore>-Zeichen aus <aString> und gibt das Ergebnis wieder in <aString> zurück
215 // ist <aIgnore> die Nullterminierung, wird nichts geändert
216 void _CURVECLASS WINAPI StringIgnore ( char *, const char );
217
218 // Signatur: DoubleErr( in aString, in aDecimal, in aThousand )
219 // prüft ob <aString> in eine Double-Wert konvertiert werden kann
220 // <aDecimal> ist das Kommazeichen (falls abweichend von '.')
221 // Als Tausendertrennzeichen wird <aThousand> verwendet. Ist dieses Zeichen die Nullterminierung, wird kein Tausendertrennzeichen verwendet.
222 // ==> -1 wenn Konvertierung möglich, SONST erste Position in <aString>, die die Konvertierung verhindert
223 int _CURVECLASS WINAPI DoubleErr ( LPCSTR, const char= '.', const char= '\0' );
224
225 // Signatur: IsDouble( in aString, in aDecimal, in aThousand )
226 // <aDecimal> ist das Kommazeichen (falls abweichend von '.')
227 // Als Tausendertrennzeichen wird <aThousand> verwendet. Ist dieses Zeichen die Nullterminierung, wird kein Tausendertrennzeichen verwendet.
228 // ==> TRUE <--> Konvertierung von <aString> in einen Double-Wert möglich
229 BOOL _CURVECLASS WINAPI IsDouble ( LPCSTR, const char= '.', const char= '\0' );
230
231 ////////////////////////////////////////////////////////////////////////////////
232 // Konvertierung zwischen String und Double
233 ////////////////////////////////////////////////////////////////////////////////
234
235 // Signatur: String2Double( in aString, in aDigits, in aRound, in aDecimal, in aThousand )
236 // ==> <aString> konvertiert in einen Double-Wert - gerundet bzw. abgerundet auf <aDigits> Nachkommastellen (<aRound>==TRUE bzw. <aRound>==FALSE)
237 // Das zur Markierung der Kommastelle verwendete Zeichen, steht in <aDecimal>.
238 // Als Tausendertrennzeichen wird <aThousand> verwendet. Ist dieses Zeichen die Nullterminierung, wird kein Tausendertrennzeichen verwendet.
239 double _CURVECLASS WINAPI String2Double ( LPCSTR, const UINT, const BOOL= TRUE, const char= '.', const char= '\0' );
240
241 const UINT NKAUTO= 1000;
242
243 //### Statt der Nachkommastellengenauigkeit kann auch NKAUTO+<x> angegeben werden. Dann wird die Genauigkeit anhand des Zahlenwertes berechnet, per <x> kann man die Genauigkeit weiter vergrößern.
244 // Signatur: Double2String( out aReturn, in aDouble, in aDigits###, in aRound, in aDecimal, in aThousand )
245 // konvertiert <aDouble> in einen String-Wert und gibt das Ergebnis
246 // auf <aDigits> Nachkommastellen gerundet bzw. abgerundet (<aRound>==TRUE bzw. <aRound>==FALSE)
247 // in <aReturn> zurück
248 // Das zur Markierung der Kommastelle verwendete Zeichen, steht in <aDecimal>.
249 // Als Tausendertrennzeichen wird <aThousand> verwendet. Ist dieses Zeichen die Nullterminierung, wird kein Tausendertrennzeichen verwendet.
250 void _CURVECLASS WINAPI Double2String ( char*, const double, UINT, const BOOL= TRUE, const char= '.', const char= '\0' );
251
252 ////////////////////////////////////////////////////////////////////////////////
253 // Formatierte Zeitausgabe HH:MM:SS bei Eingabe in Millisekunden
254 ////////////////////////////////////////////////////////////////////////////////
255
256 void _CURVECLASS WINAPI GetTimeString( char*, long );
257
258 ////////////////////////////////////////////////////////////////////////////////
259 // Min, Max
260 ////////////////////////////////////////////////////////////////////////////////
261
262 // Signatur: SetInRange( in/out aValue, in aBorder1, in aBorder2 )
263 // passt <aValue> in das Intervall [aBorder1, aBorder2]
264 // es ist dabei egal ob <aBorder1> kleiner als <aBorder2> oder umgekehrt
265 // <aValue> wird bei Überschreitung auf die jeweils überschrittete Grenze korrigiert
266 // das Ergebnis ist TRUE, wenn keine Anpassung nötig war, ansonsten FALSE
267 BOOL _CURVECLASS WINAPI SetInRange ( double&, double, double );
268 BOOL _CURVECLASS WINAPI SetInRange ( long&, long, long );
269
270 //Datum: 16.08.2002
271 /*
272 int WINAPI maxi( int, int );
273 long WINAPI maxl( long, long );
274 float WINAPI maxf( float, float );
275 double WINAPI maxd( double, double );
276 int WINAPI mini( int, int );
277 long WINAPI minl( long, long );
278 float WINAPI minf( float, float );
279 double WINAPI mind( double, double );
280 */
281
282 #endif // __U_VALUES_H
283