trunk/Common/dummy.h

#ifndef DUMMY_H
#define DUMMY_H

// [TODO] ĆĹŔˇé
#include <ctime>
#include <sstream>

#include "tstring.h"

Regnessem::tstring PtrToHex(const void* value);

namespace dummy_private
{
        template <typename T> struct to_string_type;
        template <> struct to_string_type<int>                { typedef long long cast_type; };
        template <> struct to_string_type<long>               { typedef long long cast_type; };
        template <> struct to_string_type<long long>          { typedef long long cast_type; };
        template <> struct to_string_type<unsigned>           { typedef unsigned long long cast_type; };
        template <> struct to_string_type<unsigned long>      { typedef unsigned long long cast_type; };
        template <> struct to_string_type<unsigned long long> { typedef unsigned long long cast_type; };
}

template <typename T>
std::string ToStringA(T val)
{
        return std::to_string(static_cast<typename dummy_private::to_string_type<T>::cast_type>(val));
}

template <typename T>
std::wstring ToStringW(T val)
{
        return std::to_wstring(static_cast<typename dummy_private::to_string_type<T>::cast_type>(val));
}

template <typename T>
Regnessem::tstring ToString(T val)
{
#ifdef UNICODE
        return ToStringW(val);
#else
        return ToStringA(val);
#endif
}

Regnessem::tstring TimeToStr(std::time_t t);

Regnessem::tstring ExtractFileName(const Regnessem::tstring &fileName);
Regnessem::tstring ExtractFilePath(const Regnessem::tstring &fileName);

bool ForceDirectories(const Regnessem::tstring &dirPath);

std:: string w2c(const std::wstring &src);
std::wstring c2w(const std:: string &src);

namespace dummy_private
{
        inline std:: string t2x(const std::wstring &str){return w2c(str);}
        inline std::wstring t2x(const std:: string &str){return c2w(str);}
}

template <typename T, typename U>
std::basic_string<typename std::enable_if<std::is_same<T, U>::value, T>::type> ConvertString(const std::basic_string<U> &str)
{
        return str;
}

template <typename T, typename U>
std::basic_string<typename std::enable_if<!std::is_same<T, U>::value, T>::type> ConvertString(const std::basic_string<U> &str)
{
        return dummy_private::t2x(str);
}

inline Regnessem::tstring w2t(const std::wstring &src){return ConvertString<Regnessem::tstring::value_type>(src);}
inline Regnessem::tstring c2t(const std:: string &src){return ConvertString<Regnessem::tstring::value_type>(src);}
inline std:: string t2c(const Regnessem::tstring &src){return ConvertString<char>(src);}
inline std::wstring t2w(const Regnessem::tstring &src){return ConvertString<wchar_t>(src);}

#if defined(WINCE)
// compatibility
#define GWLP_WNDPROC        (-4)
#define GWLP_HINSTANCE      (-6)
#define GWLP_HWNDPARENT     (-8)
#define GWLP_USERDATA       (-21)
#define GWLP_ID             (-12)

LONG_PTR GetWindowLongPtr(
                                                  HWND hWnd,  // EBhEĚnh
                                                  int nIndex  // ćžˇélĚItZbg
                                                  );
LONG_PTR SetWindowLongPtr(
                                                  HWND hWnd,           // EBhEĚnh
                                                  int nIndex,          // ĎXˇélĚItZbg
                                                  LONG_PTR dwNewLong   // Vľ˘l
                                                  );
#endif

/*
CĚsprintfĚČŐĹ
*/
Regnessem::tstring format(const TCHAR*fmt,...);
std::string formatA(const char*fmt,...);

#endif