U_VALUES.H

gehe zur Dokumentation dieser Datei

//#############################################################################
//                                                                           //
// U_VALUES.H                                                                //
// Subsystem: Utilities - Tools für Zahlen und Strings                       //
// Benutzung durch andere Subsysteme erforderlich: JA                         //
// Implementation: U_VALUES.CPP                                              //
//---------------------------------------------------------------------------//
// Autoren: Thomas Kullmann, Günther Reinecker                               //
// Stand:   07.11.2002                                                       //
//                                                                           //
//#############################################################################

#ifndef __U_VALUES_H
#define __U_VALUES_H

#if defined (Build_Library)
#define _CURVECLASS __declspec(dllexport)
#elif defined(Use_Library)
#define _CURVECLASS __declspec(dllimport)
#else
#define _CURVECLASS
#endif

#define STRICT
#ifdef __cplusplus
        #include <windows.h>
        #include <string.h>
        #include <windowsx.h>
        #include <mmsystem.h>
        #include <stdio.h>
        #include <math.h>
        #include <dos.h>
        #include <string.h>
        #include <string>
        typedef std::string string;
#endif

//--||--\\--||--//--||--\\--||--//--||--\\--||--//--||--\\--||--//--||--\\--||--

//#############################################################################
// globale Typ- und Konstantendeklarationen
//#############################################################################

//gibt <toFree> frei und setzt <toFree> 0
#define _FREEOBJ(toFree) { if (toFree) { delete toFree; toFree= 0; }; }

//gibt das Feld <toFree> frei und setzt <toFree> 0
#define _FREELIST(toFree) { if (toFree) { delete []toFree; toFree= 0; }; }

const UINT _MAXLENDOUBLE= 50; // 50 Zeichen für Double-Werte sollte bei weitem reichen

// Trace

// Signatur: TraceMsg( in aStr )
// gibt <aStr> in einer MessageBox mit dem Titel "Trace" aus
void _CURVECLASS WINAPI TraceMsg ( LPCSTR );

// Signatur: TraceMsg( in aDouble )
// gibt <aDouble> mit der Nachkommastellenganauigkeit von 1 in einer MessageBox mit dem Titel "Trace" aus
void _CURVECLASS WINAPI TraceMsg ( const double );

// Signatur: Trace( in aStr ) bzw. TraceErr( in aStr )
// NUR DEBUG-VERSION: sendet <aStr> an den aktuellen Debugger, um dort angezeigt zu werden (funktioniert erst ab BC 5.02)
void _CURVECLASS WINAPI Trace ( LPCSTR aStr ); // für kurzfristiges Degugging, im CVS sollte also nie eine Trace-Benutzung auftauchen
void _CURVECLASS WINAPI TraceErr ( LPCSTR aStr ); // für dauerhafte Warnungen für DEBUG-Anwender

// Signatur: Trace( in aDouble )
// 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)
void _CURVECLASS WINAPI Trace ( const double aDouble );

// Runden, Abrunden von Double-Werten

// Signatur: DoubleRound( in aDouble, in aDigits )
// ==> <aDouble> gerundet auf <aDigits> Nachkommastellen
double _CURVECLASS WINAPI DoubleRound ( const double, const UINT );

// Signatur: DoubleRoundOff( in aDouble, in aDigits )
// ==> <aDouble> mit <aDigits> Nachkommastellen, nachfolgende werden verworfen (ABRUNDEN)
double _CURVECLASS WINAPI DoubleRoundOff ( const double, const UINT );

// Signatur: Double2Float( in aDouble, in aDigits )
// ==> <aDouble> als Float-Wert mit <aDigits> Nachkommastellen (ohne das blöde Ungenauigkeitsphänomen), nachfolgende werden verworfen (ABRUNDEN)
// ACHTUNG: Die Genauigkeit von Float ist geringer als von Double!!!
float _CURVECLASS WINAPI Double2Float ( const double, const UINT );

// Signatur: Float2Double( in aFloat, in aDigits )
// ==> <aFloat> als Double-Wert mit <aDigits> Nachkommastellen (ohne das blöde Ungenauigkeitsphänomen), nachfolgende werden verworfen (ABRUNDEN)
double _CURVECLASS WINAPI Float2Double ( const float, const UINT );

// Stringmanipulation

// Signatur: StringReplace( in/out aString, in aOld, in aNew )
// ersetzt <aOld> durch <aNew> in <aString> und gibt das Ergebnis wieder in <aString> zurück
void _CURVECLASS WINAPI StringReplace ( char*, const char, const char );

// Signatur: DoubleErr( in aString, in aDecimal )
// prüft ob <aString> in eine Double-Wert konvertiert werden kann
// ==> -1 wenn Konvertierung möglich, SONST erste Position in <aString>, die die Konvertierung verhindert
int _CURVECLASS WINAPI DoubleErr ( LPCSTR, const char= '.' );

// Signatur: IsDouble( in aString, in aDecimal )
// ==> TRUE <--> Konvertierung von <aString> in einen Double-Wert möglich
BOOL _CURVECLASS WINAPI IsDouble ( LPCSTR, const char= '.' );

// Konvertierung zwischen String und Double

// Signatur: String2Double( in aString, in aDigits, in aRound, in aDecimal )
// ==> <aString> konvertiert in einen Double-Wert - gerundet bzw. abgerundet auf <aDigits> Nachkommastellen (<aRound>==TRUE bzw. <aRound>==FALSE)
// Das zur Markierung der Kommastelle verwendete Zeichen, steht in <aDecimal>.
double _CURVECLASS WINAPI String2Double ( LPCSTR, const UINT, const BOOL= TRUE, const char= '.' );

// Signatur: Double2String( out aReturn, in aDouble, in aDigits, in aRound, in aDecimal )
// konvertiert <aDouble> in einen String-Wert und gibt das Ergebnis
// auf <aDigits> Nachkommastellen gerundet bzw. abgerundet (<aRound>==TRUE bzw. <aRound>==FALSE)
// in <aReturn> zurück
// Das zur Markierung der Kommastelle verwendete Zeichen, steht in <aDecimal>.
void _CURVECLASS WINAPI Double2String ( char*, const double, const UINT, const BOOL= TRUE, const char= '.' );

// Formatierte Zeitausgabe HH:MM:SS bei Eingabe in Millisekunden

void _CURVECLASS WINAPI GetTimeString( char*, long );

// Min, Max

// Signatur: SetInRange( in/out aValue, in aBorder1, in aBorder2 )
// passt <aValue> in das Intervall [aBorder1, aBorder2]
// es ist dabei egal ob <aBorder1> kleiner als <aBorder2> oder umgekehrt
// <aValue> wird bei Überschreitung auf die jeweils überschrittete Grenze korrigiert
// das Ergebnis ist TRUE, wenn keine Anpassung nötig war, ansonsten FALSE
BOOL _CURVECLASS WINAPI SetInRange ( double&, double, double );
BOOL _CURVECLASS WINAPI SetInRange ( long&, long, long );

//Datum: 16.08.2002
/*
int        WINAPI maxi( int, int );
long       WINAPI maxl( long, long );
float      WINAPI maxf( float, float );
double     WINAPI maxd( double, double );
int        WINAPI mini( int, int );
long       WINAPI minl( long, long );
float      WINAPI minf( float, float );
double     WINAPI mind( double, double );
*/

#endif // __U_VALUES_H

---