#include <windows.h>;
#include <ppltasks.h>;
using namespace Platform;
using namespace Windows::Storage;
using namespace Windows::Storage::Streams;
using namespace Concurrency;
StorageFile^ openFile(String^ fileName)
{
    StorageFile^ file = nullptr;
    StorageFolder^ rootFolder = Windows::Storage::ApplicationData::Current->;LocalFolder;
    task<StorageFile^>;(rootFolder->;GetFileAsync(fileName)).then([&]\(task<StorageFile^>; getFileTask\)
    {
        try
        {
            file = getFileTask.get();
        }
        catch (Platform::Exception^ e)
        {
        }
    }).wait();
    return file;
}
Array<byte>;^ getFileContent(String^ fileName)
{
    Array<byte>;^ data = nullptr;
    StorageFile^ file = openFile(fileName);
    if (file)
    {
        task<IRandomAccessStream^>;(file->;OpenAsync(FileAccessMode::Read)).then([&]
(task<IRandomAccessStream^>; getStream)
        {
            auto readStream = getStream.get();
            DataReader^ dataReader=ref new DataReader(readStream);
            int length = readStream->;Size;
            if (length >; 0)
            {
                data = ref new Array<byte>;(length);
                task<unsigned int>;(dataReader->;LoadAsync(readStream->;Size)).then([&]\(task<unsigned
int>; loadTask\) {
                    loadTask.get();
                    dataReader->;ReadBytes(data);
                }).wait();
            }
        }).wait();
    }
    return data;
}
bool setFileContent(String^ fileName, unsigned char* data, int size)
{
    size_t totalWritten = 0;
    bool complete = false;
    StorageFile^ file = openFile(fileName);
    if (file)
    {
        IRandomAccessStream^ readStream = nullptr;
        task<IRandomAccessStream^>;(file->;OpenAsync(FileAccessMode::ReadWrite)).then([&]
(task<IRandomAccessStream^>; getStream)
        {
            readStream = getStream.get();
            DataWriter^ dataWriter = ref new DataWriter(readStream);
            Array<unsigned char>;^ arr = ref new Array<unsigned char>;(data, size);
            dataWriter->;WriteBytes(arr);
            task<unsigned int>;(dataWriter->;StoreAsync()).then([&]\(task<unsigned int>; writeTask)
            {
                try
                {
                    totalWritten = writeTask.get();
                } catch (Platform::Exception^ ex) {}
            }).wait();
            task<bool>;(dataWriter->;FlushAsync()).then([&]\(task<bool>; flushTask)
            {
                try
                {
                    complete = flushTask.get();
                } catch (Platform::Exception^ ex) {}
            }).wait();
            dataWriter->;DetachStream();
        }).wait();
    }
    return complete;
}

#include <functional>;
#include <iostream>;
using namespace std;
int main(int argc, char argv[])
{
    int number = 2;
    int menber = 2;
    // []表示要使用到的作用域外的变量
    // ()传入的参数
    // mutable： 对number 来说，number是值传递，如果要修改的话,需要mutable标记，否则可以使用引用传递.
    // throw：抛出异常
    // -> 后跟返回值
    // {} 函数题
    auto f1 = [number, &menber]\(int x, int y\) mutable throw() -> int {
        ++number;
        ++menber;
        return x + y;
    };
    //Lambda表达式执行之前
    cout << "number:" << number << " menber:" << menber << endl;
    //执行Lambda表达式
    f1(3, 4);
    //Lambda表达式执行之后
    cout << "number:" << number << " menber:" << menber << endl;
    //自我执行
    cout << []\(int x, int y\) { return x + y; }(2, 3) << endl;
    // auto类型其实就是 function<int (int, int)>;.
    function<int (int, int)>; f2 = []\(int x, int y\) { return x + y; };
    cout << f2(3,4) << f1(3, 4) << endl;
    system("pause");
    return 0;
}

// Calls the provided work function and returns the number of milliseconds
// that it takes to call that function.
template <class Function>;
__int64 time_call(Function&& f)
{
    __int64 begin = GetTickCount64();
    f();
    return GetTickCount64() - begin;
}
// Use WideCharToMultiByte and MultiByteToWideChar
string WChar2Ansi(const wchar_t* pwszSrc)
{
    int nLen = WideCharToMultiByte(CP_ACP, 0, pwszSrc, -1, NULL, 0, NULL, NULL);
    if (nLen<= 0) return string("");
    char* pszDst = new char[nLen];
    if (NULL == pszDst) return string("");
    WideCharToMultiByte(CP_ACP, 0, pwszSrc, -1, pszDst, nLen, NULL, NULL);
    pszDst[nLen -1] = 0;
    string strTemp(pszDst);
    delete [] pszDst;
    return strTemp;
}
wstring Ansi2WChar(const char* pszSrc, int nLen)
{
    int nSize = MultiByteToWideChar(CP_ACP, 0, pszSrc, nLen, 0, 0);
    if(nSize <= 0) return NULL;
    wchar_t *pwszDst = new wchar_t[nSize+1];
    if( NULL == pwszDst) return NULL;
    MultiByteToWideChar(CP_ACP, 0, pszSrc, nLen, pwszDst, nSize);
    pwszDst[nSize] = 0;
    if( pwszDst[0] == 0xFEFF)                    // skip Oxfeff
        for(int i = 0; i < nSize; i ++)
            pwszDst[i] = pwszDst[i+1];
    wstring wcharString(pwszDst);
    delete pwszDst;
    return wcharString;
}
// Use wcstombs_s and mbstowcs_s
string ws2s(wstring ws)
{
    const wchar_t* Source = ws.c_str();
    size_t size = 2 * ws.size() + 1;
    char* Dest = new char[size];
    memset(Dest,0, size);
    size_t len = 0;
    wcstombs(Dest, Source, size);
    //wcstombs_s(&len, Dest, size, Source, size);
    string result = Dest;
    delete [] Dest;
    return result;
}
wstring s2ws(string s)
{
    const char* Source = s.c_str();
    size_t size = s.size() + 1;
    wchar_t* Dest = new wchar_t[size];
    wmemset(Dest, 0, size);
    size_t len = 0;
    mbstowcs(Dest, Source, size);
    //mbstowcs_s(&len, Dest, size, Source, size);
    wstring result = Dest;
    delete [] Dest;
    return result;
}
// Testing
    __int64 elapsed;
    string input = "Hello, World.\\XXX\\XXX";
    wstring winput = L"Hello, World.\\XXX\\XXX";
    wchar_t dest[1000];
    int count = 10000;
    elapsed = time_call([input, &count]
    {
        while (count)
        {
            Ansi2WChar(input.c_str(), input.length());
            count--;
        }
    });
    memset(dest, 0, 1000);
    _itow_s(elapsed, dest, 10);
    OutputDebugStringW(L"Time:");
    OutputDebugStringW(dest);
    OutputDebugStringW(L"ms\n");
    count = 10000;
    elapsed = 0;
    elapsed = time_call([input, &count]
    {
        while (count)
        {
            s2ws(input);
            count--;
        }
    });
    memset(dest, 0, 1000);
    _itow_s(elapsed, dest, 10);
    OutputDebugStringW(L"Time:");
    OutputDebugStringW(dest);
    OutputDebugStringW(L"ms\n");
    count = 10000;
    elapsed = 0;
    elapsed = time_call([winput, &count]
    {
        while (count)
        {
            WChar2Ansi(winput.c_str());
            count--;
        }
    });
    memset(dest, 0, 1000);
    _itow_s(elapsed, dest, 10);
    OutputDebugStringW(L"Time:");
    OutputDebugStringW(dest);
    OutputDebugStringW(L"ms\n");
    count = 10000;
    elapsed = 0;
    elapsed = time_call([winput, &count]
    {
        while (count)
        {
            ws2s(winput);
            count--;
        }
    });
    memset(dest, 0, 1000);
    _itow_s(elapsed, dest, 10);
    OutputDebugStringW(L"Time:");
    OutputDebugStringW(dest);
    OutputDebugStringW(L"ms\n");

class Functor
{
public:
    // The constructor.
    explicit Functor(int& evenCount)
        : _evenCount(evenCount)
    {
        //_evenCount = evenCount;
    }
    // The function-call operator prints whether the number is
    // even or odd. If the number is even, this method updates
    // the counter.
    void operator()(int n)
    {
        cout << n;
        if (n % 2 == 0)
        {
            cout << " is even " << endl;
            // Increment the counter.
            _evenCount++;
        }
        else
        {
            cout << " is odd " << endl;
        }
    }
private:
    int& _evenCount; // the number of even variables in the vector
};