helpers.h

Go to the documentation of this file.

#pragma once

#ifdef max                      // If this was defined, e.g. in windef.h without NOMINMAX undefine it!
#define max
#endif
#ifdef min
#define min
#endif

template<class T> T Signum(const T& _v) { return (std::abs(_v) == _v)?1:0; }

#define LODWORD32(l)           ((DWORD32)(((ULONG64)(l)) & 0xffffffff))

#define HIDWORD32(l)           ((DWORD32)((((ULONG64)(l)) >> 32) & 0xffffffff))

template<class Interface>
void SafeRelease(Interface **ppInterfaceToRelease) {
    if (*ppInterfaceToRelease != nullptr) {
        (*ppInterfaceToRelease)->Release();
        (*ppInterfaceToRelease) = nullptr;
    }
}

inline double round(const double& v) { return floor(v+0.5); }
inline uint64_t round2ui64(const double& v) { return static_cast<uint64_t>(floor(v+0.5)); }
inline uint32_t round2ui32(const double& v) { return static_cast<uint32_t>(floor(v+0.5)); }
inline uint16_t round2ui16(const double& v) { return static_cast<uint16_t>(floor(v+0.5)); }
inline uint8_t round2ui8(const double& v) { return static_cast<uint8_t>(floor(v+0.5)); }
inline int64_t round2i64(const double& v) { return static_cast<int64_t>(floor(v+0.5)); }
inline int32_t round2i32(const double& v) { return static_cast<int32_t>(floor(v+0.5)); }
inline int16_t round2i16(const double& v) { return static_cast<int16_t>(floor(v+0.5)); }
inline int8_t round2i8(const double& v) { return static_cast<int8_t>(floor(v+0.5)); }

template<class T>
T round2(const double& v) { return static_cast<T>(floor(v+0.5)); }
std::wstring GetCurrentDateString();

std::wstring GetCurrentTimeString(const bool& _filenamecompatible = true);
enum class ScopeMessageTag { nothing, abort };

template<class T>
class ScopeMessage {
public:
    ScopeMessageTag tag;

    T cargo;

    ScopeMessage()
        : tag(ScopeMessageTag::nothing)
        , cargo() {
    }

    ScopeMessage(const ScopeMessageTag& _tag, const T& _cargo)
        : tag(_tag)
        , cargo(_cargo) {
    }
};

class StopCondition {

private:
    mutable std::atomic_bool stop;

private:
    StopCondition(StopCondition& ac);

    StopCondition& operator=(StopCondition&  ac);

public:
    StopCondition(const bool& _init = false) { stop.store(_init); }

    bool IsSet() const { return stop; }

    void Set(const bool& _a = true) { stop.store(_a); }
};

template<class T>
struct Scaler {
    Scaler(const double& _minin, const double& _maxin)  
        : minin(_minin)
        , maxin(_maxin)
        , maxout(static_cast<double>(std::numeric_limits<T>::max()))
        , minout(static_cast<double>(std::numeric_limits<T>::min()))
        , rangerelation( static_cast<double>(std::numeric_limits<T>::max()-std::numeric_limits<T>::min()) / (_maxin-_minin) ) {
        assert(std::numeric_limits<T>::is_specialized);
        assert(std::numeric_limits<T>::is_integer);
    }

    T operator() (const double& v) const { return round2<T>((v-minin)*rangerelation+minout); }

    const double minin;

    const double maxin;

    const double maxout;

    const double minout;

    const double rangerelation;
};

#ifdef _DEBUG
#define DBOUT(s) \
{ \
std::wostringstream os_; \
os_ << s << std::endl; \
ATLTRACE2( os_.str().c_str() ); \
}
#else
#define DBOUT(s)
#endif