Base.hpp

Idź do dokumentacji tego pliku.

#if defined(_MSC_VER) && (_MSC_VER >= 1200)
#pragma once
#endif
#ifndef COMMON_BASE_H_
#define COMMON_BASE_H_


// Główne includy
#include <cassert>
#include <string>
#include <vector>

// Niechciane includy :(
#include <limits>
#include <cmath>

#ifdef WIN32
        #define NOMINMAX
#endif

// String chcę mieć jak typ wbudowany
using std::string;
using std::wstring;

// Niezależnie od systemu, sygnatura bieżącej funkcji będzie w makrze __FUNCSIG__
#ifndef WIN32
        #define __FUNCSIG__ __PRETTY_FUNCTION__
#endif

// Sprawy związane z Unicode
#ifdef WIN32
        #include <tchar.h>
        #include <wchar.h>
        typedef TCHAR tchar;
#else
        #define _T(x) (x)
        typedef char tchar;
#endif

#ifdef _UNICODE
        typedef std::wstring tstring;
        #define TCHAR_TO_INT(c) ( (int)(c) )
        #define INT_TO_TCHAR(i) ( (wchar_t)(i) )
#else
        typedef std::string tstring;
        #define TCHAR_TO_INT(c) ( (int)(uint1)(c) )
        #define INT_TO_TCHAR(i) ( (char)(uint1)(i) )
#endif

#define __TFILE__ _T(__FILE__)
#define __TFUNCSIG__ _T(__FUNCSIG__)

// Wyłącz głupie warningi Visual C++
#ifdef WIN32
        // ' var ' : conversion from 'size_t' to ' type ', possible loss of data
        #pragma warning(disable: 4267)
        // 'function': was declared deprecated
        #pragma warning(disable: 4996)
#endif

#ifdef WIN32
        typedef unsigned __int32 uint;
        typedef __int8 int1;
        typedef unsigned __int8 uint1;
        typedef __int16 int2;
        typedef unsigned __int16 uint2;
        typedef __int32 int4;
        typedef unsigned __int32 uint4;
        typedef __int64 int8;
        typedef unsigned __int64 uint8;
#else
        typedef unsigned int uint;
        typedef char int1;
        typedef unsigned char uint1;
        typedef short int2;
        typedef unsigned short uint2;
        typedef int int4;
        typedef unsigned int uint4;
        typedef long long int8;
        typedef unsigned long long uint8;
#endif


typedef std::vector<tstring> STRING_VECTOR;

#define SAFE_DELETE(x) { delete (x); (x) = 0; }
#define SAFE_DELARR(x) { delete [] (x); (x) = 0; }
#define SAFE_RELEASE(x) { if (x) { (x)->Release(); (x) = 0; } }


#ifdef _MSC_VER
        #define PACKED __declspec(align(1))
#else
        #define PACKED __attribute__((packed))
#endif

/* Używać na początku definicji klasy.
Na podstawie biblioteki wxWidgets. */
#define DECLARE_NO_COPY_CLASS(ClassName)        \
        private:                                    \
                ClassName(const ClassName&);            \
                ClassName& operator=(const ClassName&);

template <typename destT, typename srcT>
destT &absolute_cast(srcT &v)
{
        return reinterpret_cast<destT&>(v);
}
template <typename destT, typename srcT>
const destT &absolute_cast(const srcT &v)
{
        return reinterpret_cast<const destT&>(v);
}

// code_base

namespace common
{


//HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH

enum ORIENTATION
{
        O_NONE,
        O_VERT,
        O_HORIZ,
};


template <typename T>
inline bool IsPow2(T x)
{
        return (x & (x-1)) == 0;
}


uint4 log2u(uint4 x);

uint4 GetBitMask(uint4 n);

template <typename T>
T **new_2d(size_t cx, size_t cy)
{
        T **a = new T*[cx];
        for (size_t x = 0; x < cx; x++)
                a[x] = new T[cy];
        return a;
}

template <typename T>
void delete_2d(T **a, size_t cx)
{
        for (size_t x = 0; x < cx; x++)
                delete[] a[x];
        delete[] a;
}


inline void strcpy0(tchar* dest, const tstring &src)
{
        for (size_t i = 0; i < src.length(); i++)
                dest[i] = src[i];
        dest[src.length()] = '\0';
}


template <typename T>
class Singleton
{
public:
        static T & GetInstance()
        {
                static T Instance;
                return Instance;
        }
};

void ZeroMem(void *Data, size_t NumBytes);
void CopyMem(void *Out, const void *In, size_t NumBytes);
bool CompareMem(const void *Data1, const void *Data2, size_t NumBytes);
void FillMem(void *Data, size_t NumBytes, uint1 Byte);

template<class Iterator>
void InsertionSort(Iterator b, Iterator e)
{
        if (b == e) return;
        for (Iterator j = b + 1; j < e; j++)
        {
                typename std::iterator_traits<Iterator>::value_type key;
                key = *j;
                Iterator i = j;
                while (i > b && key < *(i-1))
                {
                        *i = *(i-1);
                        i--;
                } 
                *i = key;
        }
}

template<class Iterator, typename Compare>
void InsertionSort(Iterator b, Iterator e, Compare Comp)
{
        if (b == e) return;
        for (Iterator j = b + 1; j < e; j++)
        {
                typename std::iterator_traits<Iterator>::value_type key;
                key = *j;
                Iterator i = j;
                while (i > b && Comp(key, *(i-1)))
                {
                        *i = *(i-1);
                        i--;
                } 
                *i = key;
        }
}

//HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH

class DeletePolicy
{
public:
        template <typename T>
        static void Destroy(T *p)
        {
                // Sztuczka inspirowana Boost (checked_delete.hpp)
                typedef char type_must_be_complete[ sizeof(T)? 1: -1 ];
                (void) sizeof(type_must_be_complete);
                delete p;
        }
};
class DeleteArrayPolicy
{
public:
        template <typename T>
        static void Destroy(T *p)
        {
                // Sztuczka inspirowana Boost (checked_delete.hpp)
                typedef char type_must_be_complete[ sizeof(T)? 1: -1 ];
                (void) sizeof(type_must_be_complete);
                delete [] p;
        }
};
class ReleasePolicy
{
public:
        template <typename T>
        static void Destroy(T *p)
        {
                if (p) p->Release();
        }
};


template <typename T, typename PolicyT = DeletePolicy>
class scoped_ptr
{
    template<typename Y, typename PolicyY> friend class scoped_ptr;

private:
        T *m_Ptr;

        scoped_ptr(const scoped_ptr &);
        scoped_ptr & operator = (const scoped_ptr &);

public:
        typedef T value_type;
        typedef T *ptr_type;

        explicit scoped_ptr(T *p = NULL) : m_Ptr(p) { }
        ~scoped_ptr() { PolicyT::template Destroy<T>(m_Ptr); }
        
        T & operator * () const { assert(m_Ptr != NULL); return *m_Ptr; }
        T * operator -> () const { assert(m_Ptr != NULL); return m_Ptr; }
        T & operator [] (uint i) const { return m_Ptr[i]; }

        inline friend bool operator == (const scoped_ptr &lhs, const T *rhs) { return lhs.m_Ptr == rhs; }
        inline friend bool operator == (const T *lhs, const scoped_ptr &rhs) { return lhs == rhs.m_Ptr; }
        inline friend bool operator != (const scoped_ptr &lhs, const T *rhs) { return lhs.m_Ptr != rhs; }
        inline friend bool operator != (const T *lhs, const scoped_ptr &rhs) { return lhs != rhs.m_Ptr; }

        T * get() const { return m_Ptr; }
        void swap(scoped_ptr<T, PolicyT> &b) { T *tmp = b.m_Ptr; b.m_Ptr = m_Ptr; m_Ptr = tmp; }
        void reset(T *p = NULL) { assert(p == NULL || p != m_Ptr); scoped_ptr<T, PolicyT>(p).swap(*this); }
};


template <typename T, typename PolicyT = DeletePolicy>
class shared_ptr
{
    template<typename Y, typename PolicyY> friend class shared_ptr;

private:
        T *m_Ptr;
        unsigned *m_Counter;

public:
        typedef T value_type;
        typedef T *ptr_type;

        explicit shared_ptr(T *p = NULL) : m_Ptr(p), m_Counter(new unsigned(1)) { }
        ~shared_ptr() { if (--(*m_Counter) == 0) { delete m_Counter; PolicyT::template Destroy<T>(m_Ptr); } }
        
        shared_ptr(const shared_ptr &p) : m_Ptr(p.m_Ptr), m_Counter(p.m_Counter) { (*m_Counter)++; }
        shared_ptr & operator = (const shared_ptr &p) { reset<T>(p); return *this; }
        template <typename U, typename PolicyU> explicit shared_ptr(const shared_ptr<U, PolicyU> &p) : m_Ptr(p.m_Ptr), m_Counter(p.m_Counter) { (*m_Counter)++; }
        template <typename U, typename PolicyU> shared_ptr & operator = (const shared_ptr<U, PolicyU> &p) { reset<U, PolicyU>(p); return *this; }

        T & operator * () const { assert(m_Ptr != NULL); return *m_Ptr; }
        T * operator -> () const { assert(m_Ptr != NULL); return m_Ptr; }
        T & operator [] (uint i) const { return m_Ptr[i]; }

        inline friend bool operator == (const shared_ptr &lhs, const T *rhs) { return lhs.m_Ptr == rhs; }
        inline friend bool operator == (const T *lhs, const shared_ptr &rhs) { return lhs == rhs.m_Ptr; }
        inline friend bool operator != (const shared_ptr &lhs, const T *rhs) { return lhs.m_Ptr != rhs; }
        inline friend bool operator != (const T *lhs, const shared_ptr &rhs) { return lhs != rhs.m_Ptr; }
        template <typename U, typename PolicyU> bool operator == (const shared_ptr<U, PolicyU> &rhs) const { return m_Ptr == rhs.m_Ptr; }
        template <typename U, typename PolicyU> bool operator != (const shared_ptr<U, PolicyU> &rhs) const { return m_Ptr != rhs.m_Ptr; }

        T * get() const { return m_Ptr; }
        void swap(shared_ptr<T, PolicyT> &b) { T *tmp = b.m_Ptr; b.m_Ptr = m_Ptr; m_Ptr = tmp; unsigned *tmpc = b.m_Counter; b.m_Counter = m_Counter; m_Counter = tmpc; }
        void reset(T *p = NULL) { if (p == m_Ptr) return; shared_ptr<T, PolicyT>(p).swap(*this); }
        template <typename U, typename PolicyU> void reset(const shared_ptr<U, PolicyU> &p) { shared_ptr<U, PolicyU>(p).swap(*this); }
        bool unique() const { return *m_Counter == 1; }
};

#ifdef WIN32
        class CloseHandlePolicy  { public: template <typename T> static void Destroy(T p) { if (p != NULL) CloseHandle(p); } };
        class DeleteObjectPolicy { public: template <typename T> static void Destroy(T p) { if (p != NULL) DeleteObject(p); } };
#endif

template <typename T, typename PolicyT>
class scoped_handle
{
    template<typename Y, typename PolicyY> friend class scoped_handle;

private:
        T m_Ptr;

        scoped_handle(const scoped_handle &);
        scoped_handle & operator = (const scoped_handle &);

public:
        typedef T value_type;

        explicit scoped_handle(T p) : m_Ptr(p) { }
        ~scoped_handle() { PolicyT::template Destroy<T>(m_Ptr); }
        
        inline friend bool operator == (const scoped_handle &lhs, const T &rhs) { return lhs.m_Ptr == rhs; }
        inline friend bool operator == (const T &lhs, const scoped_handle &rhs) { return lhs == rhs.m_Ptr; }
        inline friend bool operator != (const scoped_handle &lhs, const T &rhs) { return lhs.m_Ptr != rhs; }
        inline friend bool operator != (const T &lhs, const scoped_handle &rhs) { return lhs != rhs.m_Ptr; }

        const T & get() const { return m_Ptr; }
        void swap(scoped_handle<T, PolicyT> &b) { T tmp = b.m_Ptr; b.m_Ptr = m_Ptr; m_Ptr = tmp; }
        void reset(T p) { scoped_handle<T, PolicyT>(p).swap(*this); }
};

template <typename T, typename PolicyT>
class shared_handle
{
    template<typename Y, typename PolicyY> friend class shared_handle;

private:
        T m_Ptr;
        unsigned *m_Counter;

public:
        typedef T value_type;

        explicit shared_handle(T p) : m_Ptr(p), m_Counter(new unsigned(1)) { }
        ~shared_handle() { if (--(*m_Counter) == 0) { delete m_Counter; PolicyT::template Destroy<T>(m_Ptr); } }
        
        shared_handle(const shared_handle &p) : m_Ptr(p.m_Ptr), m_Counter(p.m_Counter) { (*m_Counter)++; }
        shared_handle & operator = (const shared_handle &p) { reset<T>(p); return *this; }
        template <typename U, typename PolicyU> explicit shared_handle(const shared_handle<U, PolicyU> &p) : m_Ptr(p.m_Ptr), m_Counter(p.m_Counter) { (*m_Counter)++; }
        template <typename U, typename PolicyU> shared_handle & operator = (const shared_handle<U, PolicyU> &p) { reset<U, PolicyU>(p); return *this; }

        inline friend bool operator == (const shared_handle &lhs, const T &rhs) { return lhs.m_Ptr == rhs; }
        inline friend bool operator == (const T &lhs, const shared_handle &rhs) { return lhs == rhs.m_Ptr; }
        inline friend bool operator != (const shared_handle &lhs, const T &rhs) { return lhs.m_Ptr != rhs; }
        inline friend bool operator != (const T &lhs, const shared_handle &rhs) { return lhs != rhs.m_Ptr; }
        template <typename U, typename PolicyU> bool operator == (const shared_handle<U, PolicyU> &rhs) const { return m_Ptr == rhs.m_Ptr; }
        template <typename U, typename PolicyU> bool operator != (const shared_handle<U, PolicyU> &rhs) const { return m_Ptr != rhs.m_Ptr; }

        const T & get() const { return m_Ptr; }
        void swap(shared_handle<T, PolicyT> &b) { T tmp = b.m_Ptr; b.m_Ptr = m_Ptr; m_Ptr = tmp; unsigned *tmpc = b.m_Counter; b.m_Counter = m_Counter; m_Counter = tmpc; }
        void reset(T p) { if (p == m_Ptr) return; shared_handle<T, PolicyT>(p).swap(*this); }
        template <typename U, typename PolicyU> void reset(const shared_handle<U, PolicyU> &p) { shared_handle<U, PolicyU>(p).swap(*this); }
        bool unique() const { return *m_Counter == 1; }
};

template <typename T, typename PolicyT> void swap(scoped_ptr<T, PolicyT> &a, scoped_ptr<T, PolicyT> &b) { a.swap(b); }
template <typename T, typename PolicyT> void swap(shared_ptr<T, PolicyT> &a, shared_ptr<T, PolicyT> &b) { a.swap(b); }
template <typename T, typename PolicyT> void swap(scoped_handle<T, PolicyT> &a, scoped_handle<T, PolicyT> &b) { a.swap(b); }
template <typename T, typename PolicyT> void swap(shared_handle<T, PolicyT> &a, shared_handle<T, PolicyT> &b) { a.swap(b); }


//HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH

enum EOLMODE
{
        EOL_NONE, 
        EOL_CRLF, 
        EOL_LF,   
        EOL_CR    
};

extern const tstring EMPTY_STRING;
extern const tchar * const EOL;

enum CHARSET
{
        CHARSET_NONE = 0, 
        CHARSET_WINDOWS,  
        CHARSET_ISO,      
        CHARSET_IBM,      
        CHARSET_UTF8,     
};

bool CharIsAlphaNumeric(tchar ch);
bool CharIsAlpha(tchar ch);
inline bool CharIsDigit(tchar ch) { return (ch >= _T('0') && ch <= _T('9')); }

inline bool CharIsHexDigit(tchar ch) { return (ch >= _T('0') && ch <= _T('9')) || (ch >= _T('A') && ch <= _T('F')) || (ch >= _T('a') && ch <= _T('f')); }
bool CharIsLower(tchar ch);
bool CharIsUpper(tchar ch);

bool CharIsWhitespace(char ch);
#ifdef WIN32
bool CharIsWhitespace(wchar_t ch);
#endif

inline bool CharIsWhitespace_f(tchar ch)
{
        return (ch == _T(' ') || ch == _T('\n') || ch == _T('\r') || ch == _T('\t') || ch == _T('\v'));
}

void ReverseString(tstring *s);
void Trim(tstring *s);
void Trim(tstring *Out, const tstring &s);

// UWAGA! Z nieznanych przyczyn UpperCase i LowerCase źle konwertuje w stronie
// kodowej IBM. Lepiej najpierw zmienić wielkość liter w innej stronie a potem
// przekonwertować na IBM - wtedy działa. Kiedyś może naprawię ten bład :/


tchar CharToLower(tchar ch);

tchar CharToUpper(tchar ch);

void LowerCase(tstring *s);
inline void LowerCase(tstring *Out, const tstring &s) { *Out = s; LowerCase(Out); }

void UpperCase(tstring *s);
inline void UpperCase(tstring *Out, const tstring &s) { *Out = s; UpperCase(Out); }


bool Charset_WindowsSpecialChar(char a_c, string *a_s);

char Charset_Convert_Char(char a_c, CHARSET a_Charset1, CHARSET a_Charset2);

void Charset_Convert(string *out, const string &s, CHARSET Charset1, CHARSET Charset2);

void Rot13(tstring *InOut);
inline void Rot13(tstring *Out, const tstring &In) { *Out = In; Rot13(Out); }

void EolModeToStr(tstring *Out, EOLMODE EolMode);


void Replace(tstring *result, const tstring &s, const tstring &s1, const tstring &s2);
void Replace(tstring *Out, const tstring &s, tchar Ch1, tchar Ch2);
void Replace(tstring *InOut, tchar Ch1, tchar Ch2);

void ReplaceEOL(tstring *result, const tstring &s, EOLMODE EOLMode);

void NormalizeWhitespace(tstring *result, const tstring &s);

void DupeString(tstring *Out, const tstring &s, size_t count);

void RightStr(tstring *Out, const tstring &s, size_t Length);

size_t SubstringCount(const tstring &str, const tstring &substr);

bool StrEqualI(const tstring &s1, const tstring &s2);
bool SubStrEqual(const tstring &s1, size_t off1, const tstring &s2, size_t off2, size_t length);
bool SubStrEqualI(const tstring &s1, size_t off1, const tstring &s2, size_t off2, size_t length);

bool ContainsEOL(const tstring &s);

bool StrBegins(const tstring &s, const tstring &sub, size_t Begin = 0);
bool StrEnds(const tstring &s, const tstring &Sub);


bool Split(const tstring &s, const tstring &delimiter, tstring *out, size_t *index);
bool SplitFirstOf(const tstring &s, const tstring &delimiters, tstring *out, size_t *index);
void Split(STRING_VECTOR *Out, const tstring &s, const tstring &Delimiter);
bool SplitEOL(const tstring &s, tstring *out, size_t *index);
bool SplitQuery(const tstring &s, tstring *out, size_t *index);

bool ValidateWildcard(const tstring &Mask, const tstring &S, bool CaseSensitive = true, size_t MaskOff = 0, size_t SOff = 0);

float FineSearch(const tstring &SubStr, const tstring &Str);

size_t LevenshteinDistance(const tstring &s1, const tstring &s2);

size_t LevenshteinDistanceI(const tstring &s1, const tstring &s2);


class StringNaturalCompare
{
private:
        bool m_CaseInsensitive;

        int CompareNumbers(const tstring &s1, size_t i1, const tstring &s2, size_t i2);

public:
        StringNaturalCompare(bool CaseInsensitive) : m_CaseInsensitive(CaseInsensitive) { }
        int Compare(const tstring &s1, const tstring &s2);
};


class StringNaturalLess : public StringNaturalCompare
{
public:
        StringNaturalLess(bool CaseInsensitive = true) : StringNaturalCompare(CaseInsensitive) { }
        bool operator () (const tstring &s1, const tstring &s2) { return (Compare(s1, s2) < 0); }
};

class StringNaturalGreater : public StringNaturalCompare
{
public:
        StringNaturalGreater(bool CaseInsensitive = true) : StringNaturalCompare(CaseInsensitive) { }
        bool operator () (const tstring &s1, const tstring &s2) { return (Compare(s1, s2) > 0); }
};


class StrLessCi
{
public:
        bool operator () (const tstring &s1, const tstring &s2)
        {
                tstring u1 = s1, u2 = s2;
                UpperCase(&u1);
                UpperCase(&u2);
                return u1 < u2;
        }
};
class StrGreaterCi
{
public:
        bool operator () (const tstring &s1, const tstring &s2)
        {
                tstring u1 = s1, u2 = s2;
                UpperCase(&u1);
                UpperCase(&u2);
                return u1 > u2;
        }
};


#ifdef WIN32


bool ConvertUnicodeToChars(string *Out, const wstring &S, unsigned CodePage);
bool ConvertUnicodeToChars(string *Out, const wchar_t *S, unsigned NumChars, unsigned CodePage);

bool ConvertCharsToUnicode(wstring *Out, const string &S, unsigned CodePage);
bool ConvertCharsToUnicode(wstring *Out, const char *S, unsigned NumChars, unsigned CodePage);  


extern const char * const BOM_UTF8;
extern const char * const BOM_UTF16_LE;
extern const char * const BOM_UTF16_BE;

#endif

#ifdef _UNICODE
        bool TstringToString(string *Out, const tstring &S);
        bool StringToTstring(tstring *Out, const string &S);
        inline bool TstringToWstring(wstring *Out, const tstring &S) { *Out = S; return true; }
        inline bool WstringToTstring(tstring *Out, const wstring &S) { *Out = S; return true; }

        inline string TstringToStringR(const tstring &S) { string R;  if (!TstringToString(&R, S)) return string();  return R; }
        inline tstring StringToTstringR(const string &S) { tstring R; if (!StringToTstring(&R, S)) return tstring(); return R; }
        inline wstring TstringToWstring(const tstring &S) { return S; }
        inline tstring WstringToTstring(const wstring &S) { return S; }
#else
        inline bool TstringToString(string *Out, const tstring &S) { *Out = S; return true; }
        inline bool StringToTstring(tstring *Out, const string &S) { *Out = S; return true; }
        inline string TstringToStringR(const tstring &S) { return S; }
        inline tstring StringToTstringR(const string &S) { return S; }
        #ifdef WIN32
                bool TstringToWstring(wstring *Out, const tstring &S);
                bool WstringToTstring(tstring *Out, const wstring &S);
                inline wstring TstringToWstringR(const tstring &S) { wstring R; if (!TstringToWstring(&R, S)) return wstring(); return R; }
                inline tstring WstringToTstringR(const wstring &S) { tstring R; if (!WstringToTstring(&R, S)) return tstring(); return R; }
        #endif
#endif

// Konwersje między tstring, string, wstring

// Obsługa Unicode

// Łańcuchy

//HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH

#ifdef WIN32
        const tchar DIR_SEP = _T('\\');
#else
        const tchar DIR_SEP = _T('/');
#endif

bool PathIsAbsolute(const tstring &s);
void IncludeTrailingPathDelimiter(tstring *InOutPath);
void IncludeTrailingPathDelimiter(tstring *OutPath, const tstring &InPath);
void ExcludeTrailingPathDelimiter(tstring *InOutPath);
void ExcludeTrailingPathDelimiter(tstring *OutPath, const tstring &InPath);

void ExtractPathPrefix(tstring *OutPrefix, const tstring &s);
void ExtractFilePath(tstring *OutPath, const tstring &s);
void ExtractFileName(tstring *OutFileName, const tstring &s);
void ExtractFileExt(tstring *OutExt, const tstring &s);

void ChangeFileExt(tstring *Out, const tstring &FileName, const tstring &Ext);

void NormalizePath(tstring *OutPath, const tstring &s);

void RelativeToAbsolutePath(tstring *Out, const tstring &Base, const tstring &Path);

void AbsoluteToRelativePath(tstring *Out, const tstring &Base, const tstring &Target);

// Ścieżki do plików


//HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH

extern const tchar _DIGITS_L[];
extern const tchar _DIGITS_U[];


inline int HexDigitToNumber(char Ch)
{
        if      (Ch >= '0' && Ch <= '9') return (int)(uint1)(Ch -  '0');
        else if (Ch >= 'A' && Ch <= 'F') return (int)(uint1)(Ch - ('A' - 10));
        else if (Ch >= 'a' && Ch <= 'f') return (int)(uint1)(Ch - ('a' - 10));
        else return 0xFF;
}
#ifdef WIN32
inline int HexDigitToNumber(wchar_t Ch)
{
        if      (Ch >= L'0' && Ch <= L'9') return (int)(Ch -  L'0');
        else if (Ch >= L'A' && Ch <= L'F') return (int)(Ch - (L'A' - 10));
        else if (Ch >= L'a' && Ch <= L'f') return (int)(Ch - (L'a' - 10));
        else return 0xFF;
}
#endif


template <typename T>
void UintToStr(tstring *Out, T x, uint4 Base = 10, bool UpperCase = true)
{
        if (x == 0)
        {
                Out->assign(_T("0"));
                return;
        }

        Out->clear();
        Out->reserve(8);

        // Podstawa to potęga dwójki - będzie prościej, bo przesuwanie bitowe zamiast dzielenia
        if (IsPow2<uint4>(Base))
        {
                // O ile bitów przesuwać?
                uint4 Bits = log2u(Base);
                // Maska bitowa do &-owania
                uint4 BitMask = GetBitMask(Bits);
                // Jazda!
                if (UpperCase)
                {
                        while (x != 0)
                        {
                                *Out += _DIGITS_U[x & BitMask];
                                x = x >> Bits;
                        }
                }
                else
                {
                        while (x != 0)
                        {
                                *Out += _DIGITS_L[x & BitMask];
                                x = x >> Bits;
                        }
                }
        }
        // Podstawa to nie potęga dwójki
        else
        {
                if (UpperCase)
                {
                        while (x != 0)
                        {
                                *Out += _DIGITS_U[x % Base];
                                x /= Base;
                        }
                }
                else
                {
                        while (x != 0)
                        {
                                *Out += _DIGITS_L[x % Base];
                                x /= Base;
                        }
                }
        }

        ReverseString(Out);
}

template <typename T>
void IntToStr(tstring *Out, T x, uint4 Base = 10, bool UpperCase = true)
{
        if (x == 0)
        {
                Out->assign(_T("0"));
                return;
        }

        Out->clear();
        Out->reserve(8);

        // Liczba dodatnia - identycznie jak w UintToStr
        if (x > 0)
        {
                // Podstawa to potęga dwójki - będzie prościej, bo przesuwanie bitowe zamiast dzielenia
                if (IsPow2<uint4>(Base))
                {
                        // O ile bitów przesuwać?
                        uint4 Bits = log2u(Base);
                        // Maska bitowa do &-owania
                        uint4 BitMask = GetBitMask(Bits);
                        // Jazda!
                        if (UpperCase)
                        {
                                while (x != 0)
                                {
                                        *Out += _DIGITS_U[x & BitMask];
                                        x = x >> Bits;
                                }
                        }
                        else
                        {
                                while (x != 0)
                                {
                                        *Out += _DIGITS_L[x & BitMask];
                                        x = x >> Bits;
                                }
                        }
                }
                // Podstawa to nie potęga dwójki
                else
                {
                        if (UpperCase)
                        {
                                while (x != 0)
                                {
                                        *Out += _DIGITS_U[x % Base];
                                        x /= Base;
                                }
                        }
                        else
                        {
                                while (x != 0)
                                {
                                        *Out += _DIGITS_L[x % Base];
                                        x /= Base;
                                }
                        }
                }
        }
        // Liczba ujemna - tu będzie musiało być inaczej
        // Modulo jest UB, więc użyjemy obejścia.
        else
        {
                T x_div_base;
                if (UpperCase)
                {
                        while (x != 0)
                        {
                                x_div_base = x/(T)Base;
                                *Out += _DIGITS_U[- (x - x_div_base*(T)Base)];
                                x = x_div_base;
                        }
                }
                else
                {
                        while (x != 0)
                        {
                                x_div_base = x/(T)Base;
                                *Out += _DIGITS_L[- (x - x_div_base*(T)Base)];
                                x = x_div_base;
                        }
                }
                *Out += '-';
        }

        ReverseString(Out);
}


template <typename T>
bool _CharToDigit(T *Digit, tchar ch)
{
        if (ch >= _T('0') && ch <= _T('9'))
                *Digit = static_cast<T>(ch-_T('0'));
        else if (ch >= _T('A') && ch <= _T('Z'))
                *Digit = static_cast<T>(ch-_T('A')+10);
        else if (ch >= _T('a') && ch <= _T('z'))
                *Digit = static_cast<T>(ch-_T('a')+10);
        else
                return false;
        return true;
}


template <typename T>
int StrToUint(T *Number, const tstring &str, unsigned Base = 10)
{
        T BaseT = static_cast<T>(Base);
        if (str.empty()) return -1;
        *Number = 0;
        T Digit, LastNumber = 0, Limit = std::numeric_limits<T>::max()/BaseT;
        for (size_t i = 0; i < str.length(); ++i) {
                if (!_CharToDigit(&Digit, str[i])) return -1;
                if (Digit >= BaseT)  return -1;
                if (*Number > Limit) return -2;
                *Number = *Number * BaseT + Digit;
                if (*Number < LastNumber) return -2;
                LastNumber = *Number;
        }
        return 0;
}

template <typename T>
int StrToInt(T *Number, const tstring &str, unsigned Base = 10)
{
        T BaseT = static_cast<T>(Base);
        if (str.empty()) return -1;
        *Number = 0;
        size_t i = 0;
        int Sign = +1;
        if (str[0] == '+') i = 1;
        else if (str[0] == '-') { Sign = -1; i = 1; }
        T Digit, LastNumber = 0, Limit;
        if (Sign > 0) Limit = std::numeric_limits<T>::max()/BaseT;
        else          Limit = std::numeric_limits<T>::min()/BaseT;
        for (; i < str.length(); ++i) {
                if (!_CharToDigit(&Digit, str[i])) return -1;
                if (Digit >= BaseT) return -1;
                if (Sign > 0) { if (*Number > Limit) return -2; }
                else          { if (*Number < Limit) return -2; }
                *Number = *Number * BaseT + Digit * Sign;
                if (Sign > 0) { if (*Number < LastNumber) return -2; }
                else          { if (*Number > LastNumber) return -2; }
                LastNumber = *Number;
        }
        return 0;
}

template <typename T> inline tstring IntToStrR (T x, int base = 10, bool UpperCase = true) { tstring r; IntToStr<T> (&r, x, base, UpperCase); return r; }
template <typename T> inline tstring UintToStrR(T x, int base = 10, bool UpperCase = true) { tstring r; UintToStr<T>(&r, x, base, UpperCase); return r; }

inline void Size_tToStr(tstring *Out, size_t x, size_t Base = 10, bool UpperCase = true) { UintToStr(Out, (uint4)x, Base, UpperCase); }
inline tstring Size_tToStrR(size_t x, size_t Base = 10, bool UpperCase = true) { tstring R; Size_tToStr(&R, x, Base, UpperCase); return R; }


template <typename T>
void UintToStr2(tstring *Out, T x, unsigned Length, int base = 10)
{
        tstring Tmp;
        UintToStr(&Tmp, x, base);
        if (Tmp.length() >= Length)
                *Out = Tmp;
        else
        {
                Out->clear();
                Out->reserve(std::max(Tmp.length(), Length));
                for (size_t Left = Length - Tmp.length(); Left > 0; Left--)
                        *Out += _T('0');
                *Out += Tmp;
        }
}
template <typename T>
void IntToStr2(tstring *Out, T x, unsigned Length, int base = 10)
{
        tstring Tmp;
        IntToStr<T>(&Tmp, x, base);
        if (Tmp.length() >= Length)
                *Out = Tmp;
        else
        {
                Out->clear();
                Out->reserve(std::max(Tmp.length(), Length));
                assert(!Tmp.empty());
                if (Tmp[0] == _T('-'))
                {
                        *Out += _T('-');
                        for (size_t Left = Length - Tmp.length(); Left > 0; Left--)
                                *Out += _T('0');
                        Out->append(Tmp.begin()+1, Tmp.end());
                }
                else
                {
                        for (size_t Left = Length - Tmp.length(); Left > 0; Left--)
                                *Out += _T('0');
                        *Out += Tmp;
                }
        }
}

template <typename T> tstring UintToStr2R(T x, unsigned Length, int Base = 10) { tstring R; UintToStr2<T>(&R, x, Length, Base); return R; }
template <typename T> tstring IntToStr2R (T x, unsigned Length, int Base = 10) { tstring R; IntToStr2<T> (&R, x, Length, Base); return R; }

inline void CharToStr(tstring *Out, tchar ch) { Out->clear(); *Out += ch; }
inline tstring CharToStrR(tchar ch) { tstring s; s += ch; return s; }


void DoubleToStr(tstring *Out, double x, char Mode = 'g', int Precision = 6);
void FloatToStr(tstring *Out, float x, char Mode = 'g', int Precision = 6);

inline tstring DoubleToStrR(double x, char Mode = 'g', int Precision = 6) { tstring R; DoubleToStr(&R, x, Mode, Precision); return R; }
inline tstring FloatToStrR (float x, char Mode = 'g', int Precision = 6) { tstring R;  FloatToStr (&R, x, Mode, Precision); return R; }


int StrToDouble(double *out, const tstring &s);
int StrToFloat (float *out,  const tstring &s);


void BoolToStr(tstring *Out, bool x, char mode = 'f');
inline tstring BoolToStrR(bool x, char mode = 'f') { tstring R; BoolToStr(&R, x, mode); return R; }

bool StrToBool(bool *result, const tstring &s);

void PtrToStr(tstring *Out, const void* p);
inline tstring PtrToStrR(const void *p) { tstring R; PtrToStr(&R, p); return R; }


template <typename T>
void SizeToStr(tstring *str, T size, bool Space, int Precision)
{
        double size2 = (double)size;
        if (size2 >= 1024.0*1024.0*1024.0*1024.0)
        {
                DoubleToStr( str, size2/(1024.0*1024.0*1024.0*1024.0), 'f', Precision );
                str->append(Space ? _T(" TB") : _T("TB"));
        }
        else if (size2 >= 1024.0*1024.0*1024.0)
        {
                DoubleToStr( str, size2/(1024.0*1024.0*1024.0), 'f', Precision );
                str->append(Space ? _T(" GB") : _T("GB"));
        }
        else if (size2 >= 1024.0*1024.0)
        {
                DoubleToStr( str, size2/(1024.0*1024.0), 'f', Precision );
                str->append(Space ? _T(" MB") : _T("MB"));
        }
        else if (size2 >= 1024.0)
        {
                DoubleToStr( str, size2/1024.0, 'f', Precision );
                str->append(Space ? _T(" KB") : _T("KB"));
        }
        else
        {
                UintToStr( str, size );
                str->append(Space ? _T(" B") : _T("B"));
        }
}
template <typename T> tstring SizeToStrR(T Size, bool Space, int Precision) { tstring r; SizeToStr<T>(&r, Size, Space, Precision); return r; }

// Konwersje między łańcuchem a różnymi typami


//HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH

class TimeMeasurer
{
private:
        #ifdef WIN32
                bool m_QPF_Using;
                int8 m_QPF_TicksPerSec;
                int8 m_QPF_Start;
                uint4 m_Start;
        #else
                // w mikrosekundach
                int8 m_Start;
        #endif

public:
        TimeMeasurer();

        double GetTimeD();
        float  GetTimeF();
};

extern TimeMeasurer g_Timer;


void Wait(uint4 Miliseconds);

// Czas


//HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH

const int1 MININT1 = std::numeric_limits<int1>::min();
const int1 MAXINT1 = std::numeric_limits<int1>::max();
const int2 MININT2 = std::numeric_limits<int2>::min();
const int2 MAXINT2 = std::numeric_limits<int2>::max();
const int4 MININT4 = std::numeric_limits<int4>::min();
const int4 MAXINT4 = std::numeric_limits<int4>::max();
const int8 MININT8 = std::numeric_limits<int8>::min();
const int8 MAXINT8 = std::numeric_limits<int8>::max();
const uint1 MAXUINT1 = std::numeric_limits<uint1>::max();
const uint2 MAXUINT2 = std::numeric_limits<uint2>::max();
const uint4 MAXUINT4 = std::numeric_limits<uint4>::max();
const uint8 MAXUINT8 = std::numeric_limits<uint8>::max();
const float MINFLOAT = std::numeric_limits<float>::min();
const float MAXFLOAT = std::numeric_limits<float>::max();


#define FLOAT_ALMOST_ZERO(F) ((absolute_cast<uint4>(F) & 0x7f800000L) == 0)

const float E         = 2.71828182845904523536f;  
const float LOG2E     = 1.44269504088896340736f;  
const float LOG10E    = 0.434294481903251827651f; 
const float LN2       = 0.693147180559945309417f; 
const float LN10      = 2.30258509299404568402f;  
const float PI        = 3.14159265358979323846264338327950288419716939937510582f;  
const float PI_2      = 1.57079632679489661923f;  
const float PI_4      = 0.785398163397448309616f; 
const float PI_X_2    = 6.28318530717958647692f;  
const float _1_PI     = 0.318309886183790671538f; 
const float _2_PI     = 0.636619772367581343076f; 
const float _2_SQRTPI = 1.12837916709551257390f;  
const float SQRT2     = 1.41421356237309504880f;  
const float SQRT3     = 1.7320508075688772935274463415059f; 
const float SQRT1_2   = 0.707106781186547524401f; 


// Windows - potrzebuje float.h
#ifdef WIN32
        bool is_finite(float x);
        bool is_finite(double x);
        bool is_nan(float x);
        bool is_nan(double x);
// Linux - potrzebuje math.h
#else
        inline bool is_finite(float x)  { return (finitef(x) != 0); }
        inline bool is_finite(double x) { return (finite(x)  != 0); }
        inline bool is_nan(float x)  { return (isnanf(x) != 0); }
        inline bool is_nan(double x) { return (isnan(x)  != 0); }
#endif


template <typename T>
T safe_add(T a, T b)
{
        T R = a + b;
        if (R < std::max(a, b)) return std::numeric_limits<T>::max();
        else return R;
}


template <typename T>
T safe_sub(T a, T b)
{
        if (b > a) return T();
        else return a - b;
}


template <typename T>
T safe_mul(T a, T b)
{
        if (b == T()) return T();
        T R = a * b;
        if (R / b != a) return std::numeric_limits<T>::max();
        else return R;
}

inline float safe_acos(float x)
{
        if (x <= -1.0f) return PI;
        if (x >= 1.0f) return 0.0f;
        return acosf(x);
}


inline int round(float x)
{
        return static_cast<int>(floorf(x+0.5f));
}
inline int round(double x)
{
        return static_cast<int>(floor(x+0.5));
}


template <typename T>
inline T ceil_div(T x, T y)
{
        return (x+y-1) / y;
}

inline bool around(float x, float epsilon)
{
        return (fabsf(x) <= epsilon);
}
inline bool around(double x, double epsilon)
{
        return (fabs(x) <= epsilon);
}

inline bool around(float x, float y, float epsilon)
{
        return (fabsf(x-y) <= epsilon);
}
inline bool around(double x, double y, double epsilon)
{
        return (fabs(x-y) <= epsilon);
}


inline bool float_equal(float x, float y)
{
        float epsilon = (fabsf(x)+fabsf(y)) * 1e-4f;
        //return around(x, y, epsilon);
        return (fabsf(x-y) <= epsilon);
}
inline bool double_equal(double x, double y)
{
        double epsilon = (fabs(x)+fabs(y)) * 1e-13;
        //return around(x, y, epsilon);
        return (fabs(x-y) <= epsilon);
}


inline uint4 greater_power_of_2(uint4 x)
{
        // x & (x-1) zeruje najmłodszą jedynkę, czyli zwraca 0 wtedy i tylko wtedy, gdy x jest potęgą 2 bądź 0.
        if (!(x & (x-1))) return x;
        int R[16]={0,1,2,2,3,3,3,3,4,4,4,4,4,4,4,4};
        uint4 r=0;
        if (x&0xFFFF0000) {r|=16;x>>=16;}
        if (x&0xFF00) {r|=8;x>>=8;}
        if (x&0xF0) {r|=4;x>>=4;}
    return 1<<(r+R[x]);
}


template <typename T>
T powi(T a, uint4 b)
{
        T r = (T)1;
        T p = a;
        while (b)
        {
                if (b & 1)
                        r *= p;
                p *= p;
                b >>= 1;
        }
        return r;
}

template <typename T>
inline T max3(const T &a, const T &b, const T &c)
{
        return std::max(a, std::max(b, c));
}

template <typename T>
inline T min3(const T &a, const T &b, const T &c)
{
        return std::min(a, std::min(b, c));
}

template <typename T>
inline T minmax(const T &a, const T &x, const T &b)
{
        if (x < a) return a; else if (x > b) return b; else return x;
        //return std::min(b, std::max(a, x));
}


inline float trunc(float x)
{
        return (x < 0.0f) ? ceilf(x) : floorf(x);
}
inline double trunc(double x)
{
        return (x < 0.0) ? ceil(x) : floor(x);
}


inline float frac(float x)
{
        return x - trunc(x);
}
inline double frac(double x)
{
        return x - trunc(x);
}

inline float Lerp(float x, float y, float t)
{
        return x + t*(y-x);
}
inline float SafeLerp(float x, float y, float t)
{
        return Lerp(x, y, minmax(0.0f, t, 1.0f));
}


inline float Lerp2D(float x11, float x21, float x12, float x22, float tx, float ty)
{
        return Lerp(Lerp(x11, x21, tx), Lerp(x12, x22, tx), ty);
}

inline float NormalizeAngle(float angle)
{
        angle /= PI_X_2;
        angle = frac(angle);
        if (angle < 0.0f)
                angle += 1.0f;
        else if (angle >= 1.0f)
                angle -= 1.0f;
        return angle * PI_X_2;
}

inline float NormalizeAngle2(float Angle)
{
        Angle += PI;
        Angle -= floorf(Angle * (1.0f/PI_X_2)) * PI_X_2;
        Angle -= PI;
        return Angle;
}

inline float DegToRad(float Angle)
{
        // Angle * PI / 180
        return Angle * 0.017453292519943295769222222222222f;
}
inline float RadToDeg(float Angle)
{
        // Angle * 180 / PI
        return Angle * 57.295779513082320876846364344191f;
}


inline float AngleDiff(float A, float B)
{
        float R1 = B - A;
        float R2 = B - PI_X_2 - A;
        float R3 = B + PI_X_2 - A;

        float R1a = fabsf(R1);
        float R2a = fabsf(R2);
        float R3a = fabsf(R3);

        if (R1a < R2a && R1a < R3a)
                return R1;
        else if (R2a < R3a)
                return R2;
        else
                return R3;
}


void SmoothCD(float *InOutPos, float Dest, float *InOutVel, float SmoothTime, float TimeDelta);
void SmoothCD(float *InOutPos, float Dest, float *InOutVel, float SmoothTime, float TimeDelta, float MaxSpeed);


inline float Trapezoidal(float x, float a, float b, float c, float d)
{
        if (x < a)
                return 0.f;
        else if (x < b)
                return (x-a)/(b-a);
        else if (x < c)
                return 1.f;
        else if (x < d)
                return 1.f - (x-c)/(d-c);
        else
                return 0.f;
}
inline float Trapezoidal(float x, float a, float b, float c, float d, float min, float max)
{
        return Trapezoidal(x, a, b, c, d) * (max-min) + min;
}


int QuadraticEquation(float a, float b, float c, float *Out_x1, float *Out_x2);

float PerlinNoise1(float x);
float PerlinNoise2(float x, float y);
float PerlinNoise3(float x, float y, float z);
float BrownianNoise1(float x,                   uint i, float Persistence);
float BrownianNoise2(float x, float y,          uint i, float Persistence);
float BrownianNoise3(float x, float y, float z, uint i, float Persistence);


//HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH

/*
Funkcje zwracające różnego rodzaju przebiegi okresowe.
Domyślne (bez ustawianych własnych parametrów) mają zakres wyjściowy 0..1,
częstotliwość 1 i fazę 0.
- Base      - dolne ograniczenie
- Amplitude - pełna wysokość
*/

inline float WaveformSine(float x, float Base, float Amplitude, float Frequency, float Phase)
{
        return Base + (sinf((x + Phase) * Frequency * PI_X_2)+1.0f)*0.5f * Amplitude;
}
inline float WaveformSine(float x)
{
        return (sinf(x * PI_X_2)+1.0f)*0.5f;
}

inline float WaveformTriangle(float x, float Base, float Amplitude, float Frequency, float Phase)
{
        float Input = frac((x + Phase) * Frequency);
        float Output;
        if (Input < 0.25f)
                Output = Input * 4.0f;
        else if (Input < 0.75f)
                Output = 1.0f - ((Input - 0.25f) * 4.0f);
        else
                Output = ((Input - 0.75f) * 4.0f) - 1.0f;
        return Base + (Output+1.0f)*0.5f * Amplitude;
}
inline float WaveformTriangle(float x)
{
        float Input = frac(x);
        float Output;
        if (Input < 0.25f)
                Output = Input * 4.0f;
        else if (Input < 0.75f)
                Output = 1.0f - ((Input - 0.25f) * 4.0f);
        else
                Output = ((Input - 0.75f) * 4.0f) - 1.0f;
        return (Output+1.0f)*0.5f;
}

inline float WaveformSquare(float x, float Base, float Amplitude, float Frequency, float Phase)
{
        return Base + (frac((x + Phase) * Frequency) <= 0.5f ? 1.0f : 0.0f) * Amplitude;
}
inline float WaveformSquare(float x)
{
        return frac(x) <= 0.5f ? 1.0f : 0.0f;
}

inline float WaveformSawtooth(float x, float Base, float Amplitude, float Frequency, float Phase)
{
        return Base + frac((x + Phase) * Frequency) * Amplitude;
}
inline float WaveformSawtooth(float x)
{
        return frac(x);
}

inline float WaveformInvSawtooth(float x, float Base, float Amplitude, float Frequency, float Phase)
{
        return Base + (1.0f - frac((x + Phase) * Frequency)) * Amplitude;
}
inline float WaveformInvSawtooth(float x)
{
        return 1.0f - frac(x);
}


inline float WaveformPWM(float x, float DutyCycle, float Base, float Amplitude, float Frequency, float Phase)
{
        return Base + (frac((x + Phase) * Frequency) <= DutyCycle ? 1.0f : 0.0f) * Amplitude;
}
inline float WaveformPWM(float x, float DutyCycle)
{
        return (frac(x) <= DutyCycle ? 1.0f : 0.0f);
}

// Funkcje okresowe


//HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH

class RandomGenerator
{
private:
        // Current seed
        uint4 m_Seed;

public:
        RandomGenerator();
        RandomGenerator(uint4 seed) : m_Seed(seed) { }

        void Seed(uint4 a_Seed)
        {
                m_Seed = a_Seed;
        }


        uint4 RandUint()
        {
                return ( m_Seed = (m_Seed * 196314165 + 907633515) );
        }

        uint4 RandUint(uint4 max)
        {
                return RandUint() % max;
        }
        uint4 RandUint(uint4 min, uint4 max)
        {
                return RandUint() % (max-min) + min;
        }


        uint1 RandByte()
        {
                uint4 u = RandUint();
                return (u >> 13) ^ u;
        }


        float RandFloat()
        {
                return absolute_cast<float>(RandUint() & 0x007FFFFF | 0x3F800000) - 1.0f;
        }
        float RandFloat(float max)
        {
                return RandFloat() * max;
        }
        float RandFloat(float min, float max)
        {
                return RandFloat() * (max - min) + min;
        }

        bool RandBool()
        {
                return (RandUint() >= 0x7FFFFFFF);
        }

        int RandInt(int Min, int Max)
        {
                if (Max > Min)
                        return static_cast<int>(RandUint(Max-Min)) + Min;
                else
                        return static_cast<int>(RandUint(Min-Max)) + Max;
        }


        void RandData(void *OutData, size_t DataLength);


        float RandNormal(float sigma);
};

extern RandomGenerator g_Rand;

class UniqueGenerator
{
private:
        uint4 m_Next;

public:
        UniqueGenerator();
        UniqueGenerator(uint4 First);

        uint4 GetUint() { return m_Next++; }
        void GetString(tstring *Out);
        tstring GetString() { tstring R; GetString(&R); return R; }
        void GetString(tstring *Out, const tstring &Prefix);
        tstring GetString(const tstring &Prefix) { tstring R; GetString(&R, Prefix); return R; }
};

extern UniqueGenerator g_Unique;


// Podstawowa matematyka


//HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH
// Parser wiersza poleceń

class CmdLineParser_pimpl;

class CmdLineParser
{
private:
        scoped_ptr<CmdLineParser_pimpl> pimpl;

public:
        enum RESULT
        {
                RESULT_OPT,       
                RESULT_PARAMETER, 
                RESULT_END,       
                RESULT_ERROR,     
        };

        CmdLineParser(int argc, tchar **argv);
        CmdLineParser(const tchar *CmdLine);

        ~CmdLineParser();


        void RegisterOpt(uint Id, tchar Opt, bool Parameter);

        void RegisterOpt(uint Id, const tstring &Opt, bool Parameter);

        RESULT ReadNext();


        uint GetOptId();

        const tstring & GetParameter();
};

// code_base

} // namespace common


//HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH

template <typename T>
struct SthToStr_obj
{
        void operator () (tstring *Str, const T &Sth)
        {
                // Runtime error
                assert(0 && "SthToStr: Unsupported type.");
                // Compilation error
                // Działa tylko w Visual C++, g++ pokazuje błąd kompilacji nawet kiedy nieużyte
#ifdef WIN32
                int y = UnsupportedTypeInSthToStr;
#endif
        }
        static inline bool IsSupported() { return false; }
};

template <typename T>
inline void SthToStr(tstring *Str, const T &Sth)
{
        SthToStr_obj<T>()(Str, Sth);
}

template <typename T>
struct StrToSth_obj
{
        bool operator () (const tstring &Str, T *Sth)
        {
                // Runtime error
                assert(0 && "StrToSth: Unsupported type.");
                // Compilation error
                // Działa tylko w Visual C++, g++ pokazuje błąd kompilacji nawet kiedy nieużyte
#ifdef WIN32
                int y = UnsupportedTypeInSthToStr;
#endif
                return false;
        }
        static inline bool IsSupported() { return false; }
};

template <typename T>
inline bool StrToSth(T *Sth, const tstring &Str)
{
        return StrToSth_obj<T>()(Sth, Str);
}


namespace common
{


class Format_pimpl
{
        friend class Format;

private:
        tstring m_String;
        char m_Sep;
        size_t m_Index;

        Format_pimpl(const tstring &Fmt, char Sep) : m_String(Fmt), m_Sep(Sep), m_Index(0) { }
};


class Format
{
private:
        shared_ptr<Format_pimpl> pimpl;

public:
        Format(const tstring &Fmt, char Sep = '#') : pimpl(new Format_pimpl(Fmt, Sep)) { }

        Format(const Format &f, const tstring &Element);
        Format(const Format &f, const tchar *Element);

        operator tstring () const { return pimpl->m_String; }
        tstring str() const { return pimpl->m_String; }
};

template <typename T>
const Format operator % (const Format &fmt, const T &x)
{
        tstring s;
        SthToStr<T>(&s, x);
        return Format(fmt, s);
}

inline const Format operator % (const Format &fmt, const tchar *x)
{
        return Format(fmt, x);
}


} // namespace common



//------------------------------------------------------------------------------
// SthToStr

template <>
struct SthToStr_obj<bool>
{
        void operator () (tstring *Str, const bool &Sth)
        {
                common::BoolToStr(Str, Sth, 'f');
        }
        static inline bool IsSupported() { return true; }
};

template <>
struct SthToStr_obj<tchar>
{
        void operator () (tstring *Str, const tchar &Sth)
        {
                common::CharToStr(Str, Sth);
        }
        static inline bool IsSupported() { return true; }
};

template <>
struct SthToStr_obj<int2>
{
        void operator () (tstring *Str, const int2 &Sth)
        {
                common::IntToStr<int2>(Str, Sth);
        }
        static inline bool IsSupported() { return true; }
};

template <>
struct SthToStr_obj<int4>
{
        void operator () (tstring *Str, const int4 &Sth)
        {
                common::IntToStr<int4>(Str, Sth);
        }
        static inline bool IsSupported() { return true; }
};
template <>
struct SthToStr_obj<long>
{
        void operator () (tstring *Str, const long &Sth)
        {
                common::IntToStr<int4>(Str, Sth);
        }
        static inline bool IsSupported() { return true; }
};

template <>
struct SthToStr_obj<int8>
{
        void operator () (tstring *Str, const int8 &Sth)
        {
                common::IntToStr<int8>(Str, Sth);
        }
        static inline bool IsSupported() { return true; }
};

template <>
struct SthToStr_obj<uint1>
{
        void operator () (tstring *Str, const uint1 &Sth)
        {
                common::UintToStr<uint1>(Str, Sth);
        }
        static inline bool IsSupported() { return true; }
};

template <>
struct SthToStr_obj<uint2>
{
        void operator () (tstring *Str, const uint2 &Sth)
        {
                common::UintToStr<uint2>(Str, Sth);
        }
        static inline bool IsSupported() { return true; }
};

template <>
struct SthToStr_obj<uint4>
{
        void operator () (tstring *Str, const uint4 &Sth)
        {
                common::UintToStr<uint4>(Str, Sth);
        }
        static inline bool IsSupported() { return true; }
};
template <>
struct SthToStr_obj<unsigned long>
{
        void operator () (tstring *Str, const unsigned long &Sth)
        {
                common::UintToStr<uint4>(Str, (uint4)Sth);
        }
        static inline bool IsSupported() { return true; }
};

template <>
struct SthToStr_obj<uint8>
{
        void operator () (tstring *Str, const uint8 &Sth)
        {
                common::UintToStr<uint8>(Str, Sth);
        }
        static inline bool IsSupported() { return true; }
};

template <>
struct SthToStr_obj<float>
{
        void operator () (tstring *Str, const float &Sth)
        {
                common::FloatToStr(Str, Sth);
        }
        static inline bool IsSupported() { return true; }
};

template <>
struct SthToStr_obj<double>
{
        void operator () (tstring *Str, const double &Sth)
        {
                common::DoubleToStr(Str, Sth);
        }
        static inline bool IsSupported() { return true; }
};

template <>
struct SthToStr_obj<tstring>
{
        void operator () (tstring *Str, const tstring &Sth)
        {
                *Str = Sth;
        }
        static inline bool IsSupported() { return true; }
};

template <typename T>
struct SthToStr_obj< std::vector<T> >
{
        void operator () (tstring *Str, const std::vector<T> &Sth)
        {
                Str->clear();
                tstring Element;
                for (typename std::vector<T>::const_iterator it = Sth.begin(); it != Sth.end(); ++it)
                {
                        if (!Str->empty())
                                *Str += ',';
                        SthToStr<T>(&Element, *it);
                        *Str += Element;
                }
        }
        static inline bool IsSupported() { return true; }
};

template <>
struct SthToStr_obj<char *>
{
        void operator () (tstring *Str, tchar *Sth)
        {
                *Str = Sth;
        }
        static inline bool IsSupported() { return true; }
};

template <>
struct SthToStr_obj<const tchar *>
{
        void operator () (tstring *Str, const tchar *Sth)
        {
                *Str = Sth;
        }
        static inline bool IsSupported() { return true; }
};

template <>
struct SthToStr_obj<void *>
{
        void operator () (tstring *Str, void *Sth)
        {
                common::PtrToStr(Str, Sth);
        }
        static inline bool IsSupported() { return true; }
};

template <>
struct SthToStr_obj<const void *>
{
        void operator () (tstring *Str, const void *Sth)
        {
                common::PtrToStr(Str, Sth);
        }
        static inline bool IsSupported() { return true; }
};

//------------------------------------------------------------------------------
// SthToStr

template <>
struct StrToSth_obj<bool>
{
        bool operator () (bool *Sth, const tstring &Str)
        {
                return common::StrToBool(Sth, Str);
        }
        static inline bool IsSupported() { return true; }
};

template <>
struct StrToSth_obj<tchar>
{
        bool operator () (tchar *Sth, const tstring &Str)
        {
                if (Str.length() != 1) return false;
                *Sth = Str[0];
                return true;
        }
        static inline bool IsSupported() { return true; }
};

template <>
struct StrToSth_obj<int2>
{
        bool operator () (int2 *Sth, const tstring &Str)
        {
                return common::StrToInt<int2>(Sth, Str) == 0;
        }
        static inline bool IsSupported() { return true; }
};

template <>
struct StrToSth_obj<int4>
{
        bool operator () (int4 *Sth, const tstring &Str)
        {
                return common::StrToInt<int4>(Sth, Str) == 0;
        }
        static inline bool IsSupported() { return true; }
};
template <>
struct StrToSth_obj<long>
{
        bool operator () (long *Sth, const tstring &Str)
        {
                return common::StrToInt<int4>((int4*)Sth, Str) == 0;
        }
        static inline bool IsSupported() { return true; }
};

template <>
struct StrToSth_obj<int8>
{
        bool operator () (int8 *Sth, const tstring &Str)
        {
                return common::StrToInt<int8>(Sth, Str) == 0;
        }
        static inline bool IsSupported() { return true; }
};

template <>
struct StrToSth_obj<uint1>
{
        bool operator () (uint1 *Sth, const tstring &Str)
        {
                return common::StrToUint<uint1>(Sth, Str) == 0;
        }
        static inline bool IsSupported() { return true; }
};

template <>
struct StrToSth_obj<uint2>
{
        bool operator () (uint2 *Sth, const tstring &Str)
        {
                return common::StrToUint<uint2>(Sth, Str) == 0;
        }
        static inline bool IsSupported() { return true; }
};

template <>
struct StrToSth_obj<uint4>
{
        bool operator () (uint4 *Sth, const tstring &Str)
        {
                return common::StrToUint<uint4>(Sth, Str) == 0;
        }
        static inline bool IsSupported() { return true; }
};
template <>
struct StrToSth_obj<unsigned long>
{
        bool operator () (unsigned long *Sth, const tstring &Str)
        {
                return common::StrToUint<uint4>((uint4*)Sth, Str) == 0;
        }
        static inline bool IsSupported() { return true; }
};

template <>
struct StrToSth_obj<uint8>
{
        bool operator () (uint8 *Sth, const tstring &Str)
        {
                return common::StrToUint<uint8>(Sth, Str) == 0;
        }
        static inline bool IsSupported() { return true; }
};

template <>
struct StrToSth_obj<float>
{
        bool operator () (float *Sth, const tstring &Str)
        {
                return common::StrToFloat(Sth, Str) == 0;
        }
        static inline bool IsSupported() { return true; }
};

template <>
struct StrToSth_obj<double>
{
        bool operator () (double *Sth, const tstring &Str)
        {
                return common::StrToDouble(Sth, Str) == 0;
        }
        static inline bool IsSupported() { return true; }
};

template <>
struct StrToSth_obj<tstring>
{
        bool operator () (tstring *Sth, const tstring &Str)
        {
                *Sth = Str;
                return true;
        }
        static inline bool IsSupported() { return true; }
};

template <typename T>
struct StrToSth_obj< std::vector<T> >
{
        bool operator () (std::vector<T> *Sth, const tstring &Str)
        {
                Sth->clear();
                uint4 Index = 0;
                tstring Element;
                T Val;
                while (common::Split(Str, _T(","), &Element, &Index))
                {
                        if (!StrToSth<T>(&Val, Element)) return false;
                        Sth->push_back(Val);
                }
                return true;
        }
        static inline bool IsSupported() { return true; }
};

// code_sthtostr

#endif

---