/**
*  Copyright Mikael Högdahl - triyana@users.sourceforge.net
*
*  This source is distributed under the terms of the Q Public License version 1.0,
*  created by Trolltech (www.trolltech.com).
*/

#ifndef MHUtil_h
#define MHUtil_h

#include <time.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <math.h>
#include <ctype.h>

#ifdef WIN32
    #ifdef DM
        #include <fstream.h>
        #include <sys/timeb.h>
        #include <dos.h>
        #include <io.h>

        #define SLEEP(a)            usleep(a * 1000000);
        #define snprintf            _snprintf
        #define vsnprintf           _vsnprintf
        #define strncasecmp         strncmpi
        #define strcasecmp          strcmpi
    #else
        #include <sys/time.h>
        #include <sys/timeb.h>
        #include <io.h>
        #define SLEEP(a) _sleep(a * 100);
        #define unlink _unlink
    #endif
#else
    #include <unistd.h>
    #include <sys/time.h>
    #include <sys/timeb.h>

    #define SLEEP(a)            usleep(int(a * 1000000));
#endif

#define ALLOCATE(a,b)       char* a = new char[b]; *a = '\0';
#define STRNCPY(a,b,c)      {strncpy (a, b, c);a[c]='\0';}
#define STRLEN(sss)         (sss && *sss) ? (strlen(sss)) : 0
#define CHECK_STRING(sss)   (sss && *sss) ? sss : ""



/**
*  Utility methods. All methods are static.
*/
class MHUtil {
public:
    enum ALIGN {
                            LEFT = 1,
                            RIGHT,
                            CENTER,
    };

    static char**           Allocate (int rows, int size);
    static char*            Allocate (char* old, int& size);
    static char*            AppendString (char* s1, const char* s2, int& len1);
    static char*            AppendChar (char* s1, char s2, int& len1);
    static double           BondValue (double interest_value, double interest, double maturity, int years_maturity);
    static double           Change (double a, double b);
    static double           ChangeVal (double a, double b);
    static void             Delete (char** s, int rows);
    static bool             Equal1 (double d1, double d2);
    static bool             Equal2 (double d1, double d2);
    static bool             Equal3 (double d1, double d2);
    static bool             Equal4 (double d1, double d2);
    static bool             Equal5 (double d1, double d2);
    static int              GetFractionSize (double d);
    static int              GetIntegerSize (double d);
    static double           Interest (const char* d1, const char* d2, double nInterest);
    static double           Interest (const char* d1, const char* d2, double nValue, double nInterest);
    static int              IntHash (int key, int size);
    static double           PercentOf (double a, double b);
    static double           Round (int in, int fr, double d);
    static void             Sleep (double sec);
    static int              StringHash (const char* key, int size);
    static double           Time ();
};




/**
*  Return change of value
*  @param double  - value
*  @param double  - percent
*/
inline double MHUtil::ChangeVal (double val, double per) {
    return ((per / 100) + 1) * val;

}



/**
*  Compare two doubles with 1 decimal
*  @param double - First double number
*  @param double - Second double number
*  @return bool  - true if number is inside 0.1 range
*/
inline bool MHUtil::Equal1 (double n1, double n2) {
    return (fabs(n1 - n2) < 0.1) ? true : false;
}



/**
*  Compare two doubles with 2 decimals
*  @param double - First double number
*  @param double - Second double number
*  @return bool  - true if number is inside 0.01 range
*/
inline bool MHUtil::Equal2 (double n1, double n2) {
    return (fabs(n1 - n2) < 0.01) ? true : false;
}



/**
*  Compare two doubles with 3 decimals
*  @param double - First double number
*  @param double - Second double number
*  @return bool  - true if number is inside 0.001 range
*/
inline bool MHUtil::Equal3 (double n1, double n2) {
    return (fabs(n1 - n2) < 0.001) ? true : false;
}



/**
*  Compare two doubles with 4 decimals
*  @param double - First double number
*  @param double - Second double number
*  @return bool  - true if number is inside 0.01 range
*/
inline bool MHUtil::Equal4 (double n1, double n2) {
    return (fabs(n1 - n2) < 0.0001) ? true : false;
}



/**
*  Compare two doubles with 5 decimals
*  @param double - First double number
*  @param double - Second double number
*  @return bool  - true if number is inside 0.00001 range
*/
inline bool MHUtil::Equal5 (double n1, double n2) {
    return (fabs(n1 - n2) < 0.00001) ? true : false;
}



/**
* Sleep
* @param double - Number of seconds
*/
inline void MHUtil::Sleep (double sec) {
    SLEEP((unsigned long)sec);
}

#endif