Чтение/запись в Excel с COM OLE C++

#ifndef EXCELREADERWRITER_HPP
#define EXCELREADERWRITER_HPP
 
//---------------------------------------------------------------------------
#include <ole2.h> 
#include <string>
#include <vector>
#include <algorithm>
#include <stdexcept>
#include <sstream>
 
 
namespace ecm // excel common methods
{
    //-------------------------------------------------------------------------------
    std::string CalcEndLetters(int const colCount)
    {
        int integer = colCount / 26;
        int rem = colCount % 26;
        if (!rem) integer -= 1;
        char first = 'a' - 1;
        for (int i = 0; i < integer; ++i)
        {
            ++first;
        }
        char second = 'a' - 1;
        for (int i = 0; i < rem; ++i)
        {
            ++second;
        }
        if ('a' - 1 == second) second = 'z';
        std::string str;
        if ('a' - 1 != first) str += first;
        str += second;
 
        return str;
    }
    //---------------------------------------------------------------------------
 
    // AutoWrap() - Automation helper function...
    HRESULT AutoWrap(int autoType, VARIANT *pvResult, IDispatch *pDisp, LPOLESTR ptName, int cArgs...)
    {
        HRESULT hr = 0;
        std::vector<VARIANT> pArgs;
        try {
            // Begin variable-argument list...
            va_list marker;
            va_start(marker, cArgs);
 
            if (!pDisp) throw std::runtime_error("NULL IDispatch passed to AutoWrap");
 
            // Variables used...
            DISPPARAMS dp = { NULL, NULL, 0, 0 };
            DISPID dispidNamed = DISPID_PROPERTYPUT;
            DISPID dispID;
            char buf[200];
            char szName[200];
 
            // Convert down to ANSI
            WideCharToMultiByte(CP_ACP, 0, ptName, -1, szName, 256, NULL, NULL);
 
            // Get DISPID for name passed...
            hr = pDisp->GetIDsOfNames(IID_NULL, &ptName, 1, LOCALE_USER_DEFAULT, &dispID);
            if (FAILED(hr)) {
                sprintf(buf, "IDispatch::GetIDsOfNames(\"%s\") failed w/err 0x%08lx", szName, hr);
                throw std::runtime_error(buf);
            }
 
            // Allocate memory for arguments...
            pArgs.resize(cArgs + 1);
            // Extract arguments...
            for (int i = 0; i < cArgs; ++i) {
                pArgs[i] = va_arg(marker, VARIANT);
            }
 
            // Build DISPPARAMS
            dp.cArgs = cArgs;
            dp.rgvarg = pArgs.data();
 
            // Handle special-case for property-puts!
            if (autoType & DISPATCH_PROPERTYPUT) {
                dp.cNamedArgs = 1;
                dp.rgdispidNamedArgs = &dispidNamed;
            }
 
            // Make the call!
            hr = pDisp->Invoke(dispID, IID_NULL, LOCALE_SYSTEM_DEFAULT, autoType, &dp, pvResult, NULL, NULL);
            if (FAILED(hr)) {
                sprintf(buf, "IDispatch::Invoke(\"%s\"=%08lx) failed w/err 0x%08lx", szName, dispID, hr);
                throw std::runtime_error(buf);
            }
            // End variable-argument section...
            va_end(marker);
 
        }
        catch (std::exception const& exc) {
            throw std::runtime_error(std::string("AutoWrap exception: ") + exc.what());
        }
 
        return hr;
    }
};
 
//---------------------------------------------------------------------------
// Get cell value from excel file
VARIANT GetCell(IDispatch* pXlSheet, IDispatch* pXlRange)
{
    VARIANT parm1;
    parm1.vt = VT_I4;
    parm1.lVal = 2; // column B
 
    VARIANT parm2;
    parm2.vt = VT_I4;
    parm2.lVal = 1;
 
    // Get cell "B1" from sheet
    {
        VARIANT result;
        VariantInit(&result);
        ecm::AutoWrap(DISPATCH_PROPERTYGET, &result, pXlSheet, L"Cells", 2, parm1, parm2);
        VariantClear(&parm1);
        VariantClear(&parm2);
        pXlRange = result.pdispVal;
    }
 
    VARIANT rVal;
    VariantInit(&rVal);
    ecm::AutoWrap(DISPATCH_PROPERTYGET, &rVal, pXlRange, L"Value", 0);
    //ShowMessage(IntToStr(rVal.vt));
    pXlRange->Release(); pXlRange = 0;
    return rVal;
}
 
//------------------------------------------------------------------------------
 
class ExcelReader
{
public:
    // _firstRow = 1 - highest row (0 - prohibited)
    ExcelReader(std::string const& _FileOpenName, int const _colCount, int const _firstRow = 1) : pXlApp(0), pXlBooks(0), pXlBook(0),
        pXlSheet(0), pXlRange(0), FileOpenName(_FileOpenName), colCount(_colCount), psa(0), step(1000),
        pBegVar(0), rows(0), eof(true), pCurVar(0), curGetRangeRow(_firstRow)
    {
        try {
 
            if (_colCount > 702) throw std::runtime_error("Amount of columns greater than 702");
 
            // Initialize COM for this thread...
            CoInitialize(NULL);
 
            // Get CLSID for our server...
            CLSID clsid;
            HRESULT hr = CLSIDFromProgID(L"Excel.Application", &clsid);
 
            if (FAILED(hr)) throw std::runtime_error("CLSIDFromProgID() failed");
 
            // Start server and get IDispatch...
            hr = CoCreateInstance(clsid, NULL, CLSCTX_LOCAL_SERVER, IID_IDispatch, (void **)&pXlApp);
 
            if (FAILED(hr)) throw std::runtime_error("CoCreateInstance failed : Excel not registered properly");
 
            // Make it visible (i.e. app.visible = 1)
            {
                VARIANT x;
                x.vt = VT_I4;
                x.lVal = 1;
                //AutoWrap(DISPATCH_PROPERTYPUT, NULL, pXlApp, L"Visible", 1, x);
            }
 
            // Get Workbooks collection
            {
                VARIANT result;
                VariantInit(&result);
                ecm::AutoWrap(DISPATCH_PROPERTYGET, &result, pXlApp, L"Workbooks", 0);
                pXlBooks = result.pdispVal;
            }
 
            /*// = "c:\\RZMsk25.DBF";
            if(OpenDialog1->Execute())
            {
            FileOpenName = OpenDialog1->FileName;
            //ShowMessage(FileOpenName);
            }
            else return;*/
 
            // Open file
            {
                OLECHAR *sOleText = new OLECHAR[FileOpenName.size() + 1];
                char buf[4096];
                CharToOemA(FileOpenName.c_str(), buf);
                MultiByteToWideChar(CP_OEMCP, MB_ERR_INVALID_CHARS, buf,
                    -1, sOleText, FileOpenName.size() + 1);
                VARIANT result;
                VariantInit(&result);
                VARIANT fname;
                fname.vt = VT_BSTR;
                fname.bstrVal = ::SysAllocString(sOleText);
                ecm::AutoWrap(DISPATCH_METHOD, &result, pXlBooks, L"Open", 1, fname);
                pXlBook = result.pdispVal;
                ::SysFreeString(fname.bstrVal);
                delete sOleText;
            }
 
            // Get ActiveSheet object
            {
                VARIANT result;
                VariantInit(&result);
                ecm::AutoWrap(DISPATCH_PROPERTYGET, &result, pXlApp, L"ActiveSheet", 0);
                pXlSheet = result.pdispVal;
            }
            //step = 20000;
            //curGetRangeRow = 2;
 
            // Get matrix from file into rVal
            GetMatrix();
        }
        catch (std::exception const& exc) {
            Release();
            throw std::runtime_error(std::string("ExcelReader constructor exception: ") + exc.what());
        }
 
    }// Constructor
 
     //-------------------------------------------------------------------------------
     // Read cell value from matrix
    char* ReadAsString()
    {
        memset(classBuf, 0, sizeof(classBuf));
        switch (pCurVar->vt)
        {
        case VT_EMPTY:
        {
            //ShowMessage("VT_EMPTY");
            break;
        }
        case VT_BSTR:
        {
            WideCharToMultiByte(CP_ACP, 0, pCurVar->bstrVal, -1, classBuf, sizeof(classBuf), 0, 0);
            //ShowMessage("VT_BSTR");
            break;
        }
        case VT_DATE:
        {
            SYSTEMTIME sysTime;
            VariantTimeToSystemTime(pCurVar->date, &sysTime);
            sprintf(classBuf, "%.2u.%.2u.%u", sysTime.wDay, sysTime.wMonth, sysTime.wYear);
            //ShowMessage(classBuf);
            break;
        }
        case VT_I2:
        {
            sprintf(classBuf, "%d", pCurVar->iVal);
            //ShowMessage("VT_I2");
            break;
        }
        case VT_I4:
        {
            sprintf(classBuf, "%d", pCurVar->lVal);
            //ShowMessage("VT_I4");
            break;
        }
        case VT_R4:
        {
            sprintf(classBuf, "%f", pCurVar->fltVal);
            char* p = 0, *p1 = 0;
            if (p = strchr(classBuf, '.'))
            {
                for (p1 = p + 1; *p1; ++p1)
                {
                    if (*p1 != '0') break;
                }
                if (!*p1) *p = 0;
            }
            //ShowMessage("VT_R4");
            break;
        }
        case VT_R8:
        {
            sprintf(classBuf, "%lf", pCurVar->dblVal);
            char* p = 0, *p1 = 0;
            if (p = strchr(classBuf, '.'))
            {
                for (p1 = p + 1; *p1; ++p1)
                {
                    if (*p1 != '0') break;
                }
                if (!*p1) *p = 0;
            }
            //ShowMessage("VT_R8");
            break;
        }
        default:
        {
            std::ostringstream oss;
            oss << pCurVar->vt;
            throw std::runtime_error("ReadAsString exception: Cell variable has other type: " + oss.str());
            oss.clear();
            oss.str("");
        }
        }
 
        //ShowMessage(classBuf);
 
        // Step onto next cell in the current row
        pCurVar += rows;
 
        // if we get out of matrix
        if (pCurVar >= pBegVar + rows * colCount)
        {
            //ShowMessage("back");
            pCurVar -= rows * colCount;
            ++pCurVar;
            if (pCurVar == pBegVar + rows)
            {
                GetMatrix();
            }
            else // if(pCurVar->vt == VT_EMPTY && (pCurVar + rows)->vt == VT_EMPTY)
            {
                eof = true;
                for (int i = 0; i < colCount; ++i)
                {
                    if ((pCurVar + i * rows)->vt != VT_EMPTY)
                    {
                        eof = false;
                        break;
                    }
                }
                //eof = true;//====================================== vtoroy eof nizhe===================================================
                if (eof) VariantClear(&rVal);
                //ShowMessage(classBuf);
            }
        }
        return classBuf;
    }
    //------------------------------------------------------------------------------
 
    ~ExcelReader()
    {
        Release();
    }
 
    //--------------------------------------------------------------------------------
    bool Eof()
    {
        return eof;
    }
 
private:
 
    void Release()
    {
        try { ecm::AutoWrap(DISPATCH_METHOD, NULL, pXlApp, L"Quit", 0); }
        catch (...) {}
        // Release references...
        if (pXlRange) pXlRange->Release(); pXlRange = 0;
        if (pXlSheet) pXlSheet->Release(); pXlSheet = 0;
        if (pXlBook) pXlBook->Release(); pXlBook = 0;
        if (pXlBooks) pXlBooks->Release(); pXlBooks = 0;
        if (pXlApp) pXlApp->Release(); pXlApp = 0;
 
        // Uninitialize COM for this thread...
        CoUninitialize();
    }
    //--------------------------------------------------------------------------------
 
    // Get 2D-array from excel file into rVal
    void GetMatrix()
    {
        VariantClear(&rVal);
        // Get location for matrix
        std::ostringstream oss;
        oss << curGetRangeRow;
        std::string location = "a" + oss.str();
        oss.clear();
        oss.str("");
        std::string end = std::string(":") + ecm::CalcEndLetters(colCount);
        curGetRangeRow += step;
        oss << curGetRangeRow;
        location += end + oss.str();
        oss.clear();
        oss.str("");
        //ShowMessage(location.c_str());
 
        OLECHAR *sOleText = new OLECHAR[location.size() + 1];
        mbstowcs(sOleText, location.c_str(), location.size() + 1);
 
        VARIANT parm;
        parm.vt = VT_BSTR;
        parm.bstrVal = ::SysAllocString(sOleText);
 
        //IDispatch *pXlRange; // Get Range from Sheet
        {
            VARIANT result;
            VariantInit(&result);
            ecm::AutoWrap(DISPATCH_PROPERTYGET, &result, pXlSheet, L"Range", 1, parm);
            VariantClear(&parm);
            pXlRange = result.pdispVal;
        }
 
        ecm::AutoWrap(DISPATCH_PROPERTYGET, &rVal, pXlRange, L"Value", 0);
 
        pXlRange->Release(); pXlRange = 0;
        delete sOleText;
 
        psa = rVal.parray;
        long startIndex = 0, endIndex = 0;
        rows = 0;
        SafeArrayGetLBound(psa, 1, &startIndex);
        SafeArrayGetUBound(psa, 1, &endIndex);
        rows = endIndex - startIndex + 1;
        //ShowMessage(IntToStr(rows));
 
        pBegVar = 0;
        if (FAILED(SafeArrayAccessData(psa, (void **)&pBegVar)))
        {
            throw std::runtime_error("failed SafeArrayAccessData");
        }
        SafeArrayUnaccessData(psa);
        //ShowMessage(IntToStr(pVar->vt));
 
        pCurVar = pBegVar;
        ++curGetRangeRow;
        //eof = ((pBegVar->vt == VT_EMPTY && ((pBegVar + rows)->vt == VT_EMPTY)) ? true : false); // ================================perviy eof vishe========================================
        eof = true;
        for (int i = 0; i < colCount; ++i)
        {
            if ((pBegVar + i * rows)->vt != VT_EMPTY)
            {
                eof = false;
                break;
            }
        }
        if (eof) VariantClear(&rVal);
 
    }
 
    ExcelReader(ExcelReader const&) = delete;
    ExcelReader& operator=(ExcelReader const&) = delete;
 
    //-------------------------------------------------------------------------------
    // Variables
 
    IDispatch *pXlApp, *pXlBooks, *pXlBook, *pXlSheet, *pXlRange;
    std::string FileOpenName;
    int colCount, step, curGetRangeRow, rows;
    char classBuf[2048];
    VARIANT rVal, *pBegVar, *pCurVar;
    SAFEARRAY* psa;
    bool eof;
};
//---------------------------------------------------------------------------
 
//-------------------------------------ExcelWriter class--------------------------------------
 
//---------------------------------------------------------------------------
// If str is float number that replaces dot with comma
void ReplaceDotCommaFloat(std::string& str)
{
    bool allDotsDigits = true;
    int dotCount = 0, dotIndex = 0;
    try {
        //StrToFloat(str);
        for (int i = 1; i < str.size(); ++i)
        {
            if (str[i] == '.')
            {
                ++dotCount;
                dotIndex = i;
            }
            if (!isdigit((unsigned char)str[i]) && str[i] != '.')
            {
                allDotsDigits = false;
                break;
            }
        }
        if (allDotsDigits && dotCount == 1)
        {
            str[dotIndex] = ',';
        }
    }
    catch (std::exception const& exc) {}
}
//---------------------------------------------------------------------------
 
void WriteIntToVar(VARIANT& var, int const val)
{
    var.vt = VT_I4;
    var.lVal = val;
}
 
//---------------------------------------------------------------------------
 
void WriteStringToVar(VARIANT& var, std::string str)
{
    ReplaceDotCommaFloat(str);
    int const wBufSize = str.size() + 1;
    wchar_t* wBuf = new wchar_t[wBufSize];
    memset(wBuf, 0, wBufSize * sizeof(*wBuf));
    MultiByteToWideChar(CP_ACP, 0, str.c_str(), str.size(), wBuf, wBufSize);
    var.vt = VT_BSTR;
    var.bstrVal = ::SysAllocString(wBuf);
    // ::SysFreeString(var.bstrVal);
    delete[] wBuf;
}
 
//-----------------------------------------------------------------------
 
class ExcelWriter
{
private:
    VARIANT parm_col;
    VARIANT parm_row;
    VARIANT frmt_cell;
    VARIANT format_num;
    VARIANT result_cells;
 
public:
    ExcelWriter(int const _colCount, bool _visible = true) : rowCount(1024), curArrRow(0), curRangeCntr(0), colCount(_colCount),
        pXlApp(0), pXlBooks(0), pXlBook(0), pXlSheet(0), pXlRange(0), visible(_visible)
    {
        try {
            if (_colCount > 256) // otherwise crashes
                throw std::runtime_error("_colCount > 256");
 
            // Initialize COM for this thread...
            CoInitialize(NULL);
 
            // Get CLSID for our server...
            CLSID clsid;
            HRESULT hr = CLSIDFromProgID(L"Excel.Application", &clsid);
 
            if (FAILED(hr)) throw std::runtime_error("CLSIDFromProgID() failed");
 
            // Start server and get IDispatch...
            hr = CoCreateInstance(clsid, NULL, CLSCTX_LOCAL_SERVER, IID_IDispatch, (void **)&pXlApp);
            if (FAILED(hr)) throw std::runtime_error("Excel not registered properly");
 
            if (visible)
            {
                // Make it visible (i.e. app.visible = 1)
                {
                    VARIANT x;
                    x.vt = VT_I4;
                    x.lVal = 1;
                    ecm::AutoWrap(DISPATCH_PROPERTYPUT, NULL, pXlApp, L"Visible", 1, x);
                }
            }
 
 
            // Get Workbooks collection
            {
                VARIANT result;
                VariantInit(&result);
                ecm::AutoWrap(DISPATCH_PROPERTYGET, &result, pXlApp, L"Workbooks", 0);
                pXlBooks = result.pdispVal;
            }
 
            // Call Workbooks.Add() to get a new workbook...
            {
                VARIANT result;
                VariantInit(&result);
                ecm::AutoWrap(DISPATCH_PROPERTYGET, &result, pXlBooks, L"Add", 0);
                pXlBook = result.pdispVal;
            }
            /*
            // Save to file
            {
            std::string FileOpenName = "c:\\111";
            OLECHAR *sOleText=new OLECHAR[FileOpenName.size()+1];
            char buf[4096];
            CharToOem(FileOpenName.c_str(), buf);
            MultiByteToWideChar(CP_OEMCP, MB_ERR_INVALID_CHARS, buf,
            -1, sOleText, FileOpenName.size() + 1);
            VARIANT fname;
            fname.vt = VT_BSTR;
            fname.bstrVal=::SysAllocString(sOleText);
            ecm::AutoWrap(DISPATCH_METHOD, 0, pXlBook, L"SaveAs", 1, fname);
            }
 
            // Set .Saved property of workbook to TRUE so we aren't prompted
            // to save when we tell Excel to quit...
            {
            VARIANT x;
            x.vt = VT_I4;
            x.lVal = 1;
            ecm::AutoWrap(DISPATCH_PROPERTYPUT, NULL, pXlBook, L"Saved", 1, x);
            }*/
 
            // Get ActiveSheet object
            {
                VARIANT result;
                VariantInit(&result);
                ecm::AutoWrap(DISPATCH_PROPERTYGET, &result, pXlApp, L"ActiveSheet", 0);
                pXlSheet = result.pdispVal;
            }
 
            AllocArray();
            GetRange();
        }
        catch (std::exception const& exc) {
            Release();
            throw std::runtime_error(std::string("ExcelWriter constructor exception: ") + exc.what());
        }
    }// Constructor
 
    void AllocArray()
    {
        VariantClear(&arr);
        // Create a rowCount x colCount safearray of variants...
        arr.vt = VT_ARRAY | VT_VARIANT;
        {
            SAFEARRAYBOUND sab[2];
            sab[0].lLbound = 1; sab[0].cElements = rowCount;
            sab[1].lLbound = 1; sab[1].cElements = colCount;
            arr.parray = SafeArrayCreate(VT_VARIANT, 2, sab);
        }
        curArrRow = 1;
    }
 
    void GetRange()
    {
        // Get location string
        int numBeg = curRangeCntr * rowCount + 1;
        int numEnd = numBeg + rowCount - 1;
        std::ostringstream oss;
        oss << numBeg;
        std::string beg = "a" + oss.str();
        oss.clear();
        oss.str("");
        std::string letterEnd = ecm::CalcEndLetters(colCount).c_str();
        oss << numEnd;
        std::string end = ":" + letterEnd + oss.str();
        oss.clear();
        oss.str("");
        std::string location = beg + end;
        //ShowMessage(location.c_str());
        wchar_t wLocation[256];
        mbstowcs(wLocation, location.c_str(), sizeof(wLocation) / sizeof(*wLocation));
 
        // Get Range object for wLocation
        {
            VARIANT parm;
            parm.vt = VT_BSTR;
            parm.bstrVal = ::SysAllocString(wLocation);
 
            VARIANT result;
            VariantInit(&result);
            ecm::AutoWrap(DISPATCH_PROPERTYGET, &result, pXlSheet, L"Range", 1, parm);
            VariantClear(&parm);
 
            if (pXlRange) pXlRange->Release(); pXlRange = 0;
            pXlRange = result.pdispVal;
        }
        {
            VARIANT frmt;
            frmt.vt = VT_BSTR;
            frmt.bstrVal = ::SysAllocString(L"@");
            VARIANT result;
            VariantInit(&result);
            ecm::AutoWrap(DISPATCH_PROPERTYPUT, &result, pXlRange, L"NumberFormat", 1, frmt);
        }
        ++curRangeCntr;
    }
 
    void Write(VARIANT* pArr)
    {
        for (int j = 0; j < colCount; j++) {
            long indices[] = { curArrRow,j + 1 };
            SafeArrayPutElement(arr.parray, indices, (void*)&pArr[j]);
            VariantClear(&pArr[j]);
        }
        ++curArrRow;
        if (curArrRow > rowCount)
        {
            Flush();
            AllocArray();
            GetRange();
        }
    }// Write
 
    void Write(VARIANT* pArr, std::vector<int> const& formats)
    {
        for (int j = 0; j < colCount; j++) {
            long indices[] = { curArrRow, j + 1 };
            SafeArrayPutElement(arr.parray, indices, (void*)&pArr[j]);
            VariantClear(&pArr[j]);
        }
 
        std::vector<int>::const_iterator cur = formats.begin();
        for (int j = 1; j <= colCount; j++)
        {
 
            parm_col.vt = VT_I4;
            parm_col.lVal = j;
 
            parm_row.vt = VT_I4;
            parm_row.lVal = (curRangeCntr - 1) * rowCount + curArrRow;
 
            VariantInit(&result_cells);
            ecm::AutoWrap(DISPATCH_PROPERTYGET, &result_cells, pXlSheet, L"Cells", 2, parm_col, parm_row);
            VariantClear(&parm_col);
            VariantClear(&parm_row);
 
            frmt_cell.vt = VT_BSTR;
 
            if (*cur == 0 || !(*cur))
                frmt_cell.bstrVal = ::SysAllocString(L"@");
 
            else if (*cur == 1)
                frmt_cell.bstrVal = ::SysAllocString(L"0,00");
 
            else if (*cur == 2)
                frmt_cell.bstrVal = ::SysAllocString(L"0");
 
            else if (*cur == 3)
                frmt_cell.bstrVal = ::SysAllocString(L"ДД ММ ГГГГ");
 
            ecm::AutoWrap(DISPATCH_PROPERTYPUT, &format_num, result_cells.pdispVal, L"NumberFormat", 1, frmt_cell);
 
            VariantClear(&result_cells);
            VariantClear(&frmt_cell);
 
            ++cur;
        }
 
 
        ++curArrRow;
        if (curArrRow > rowCount)
        {
            Flush();
            AllocArray();
            GetRange();
        }
 
    }// Write
 
     //
    void Save(std::string const& savePath)
    {
        // Save to file
        {
            OLECHAR *sOleText = new OLECHAR[savePath.size() + 1];
            char buf[4096];
            CharToOemA(savePath.c_str(), buf);
            MultiByteToWideChar(CP_OEMCP, MB_ERR_INVALID_CHARS, buf, -1, sOleText, savePath.size() + 1);
            VARIANT fname;
            fname.vt = VT_BSTR;
            fname.bstrVal = ::SysAllocString(sOleText);
            ecm::AutoWrap(DISPATCH_METHOD, 0, pXlBook, L"SaveAs", 1, fname);
            VariantClear(&fname);
        }
        // Set .Saved property of workbook to TRUE so we aren't prompted
        // to save when we tell Excel to quit...
        {
            VARIANT x;
            x.vt = VT_I4;
            x.lVal = 1;
            ecm::AutoWrap(DISPATCH_PROPERTYPUT, NULL, pXlBook, L"Saved", 1, x);
        }
 
        //ecm::AutoWrap(DISPATCH_METHOD, NULL, pXlBook, L"Close", 0);
        //ecm::AutoWrap(DISPATCH_METHOD, NULL, pXlBooks, L"Close", 0);
 
        ecm::AutoWrap(DISPATCH_METHOD, NULL, pXlApp, L"Quit", 0);
    } // Save
 
 
    void Flush()
    {
        // Set range with our safearray...
        ecm::AutoWrap(DISPATCH_PROPERTYPUT, NULL, pXlRange, L"Value", 1, arr);
    }
 
    ~ExcelWriter()
    {
        //Flush();
        Release();
    }
 
    void Release()
    {
 
        // Release references...
        if (pXlRange)
            pXlRange->Release();
        pXlRange = 0;
        if (pXlSheet)
            pXlSheet->Release();
        pXlSheet = 0;
        if (pXlBook)
            pXlBook->Release();
        pXlBook = 0;
        if (pXlBooks)
            pXlBooks->Release();
        pXlBooks = 0;
        if (pXlApp)
            pXlApp->Release();
        pXlApp = 0;
        VariantClear(&arr);
        VariantClear(&parm_col);
        VariantClear(&parm_row);
        VariantClear(&frmt_cell);
        VariantClear(&format_num);
        VariantClear(&result_cells);
 
        // Uninitialize COM for this thread...
        CoUninitialize();
    }
 
    bool visible;
 
    ExcelWriter(ExcelWriter const&) = delete;
    ExcelWriter& operator=(ExcelWriter const&) = delete;
 
private:
    IDispatch* pXlRange, *pXlSheet, *pXlBook, *pXlBooks, *pXlApp;
    VARIANT arr;
    int rowCount, colCount, curArrRow, curRangeCntr;
};
 
#endif // EXCELREADERWRITER_HPP
//---------------------------------------------------------------------------
/*
 
lVal    VT_I4
bVal    VT_UI1
iVal    VT_I2
fltVal  VT_R4.
dblVal  VT_R8.
boolVal VT_BOOL.
bool
scode   VT_ERROR.
cyVal   VT_CY.
date    VT_DATE.
bstrVal VT_BSTR.
punkVal VT_UNKNOWN.
pdispVal    VT_DISPATCH.
parray  VT_ARRAY | *.
pbVal   VT_BYREF | VT_UI1.
piVal   VT_BYREF | VT_I2. For more information, see Remarks.
plVal   VT_BYREF | VT_I4. For more information, see Remarks.
pfltVal VT_BYREF | VT_R4. For more information, see Remarks.
pdblVal VT_BYREF | VT_R8. For more information, see Remarks.
pboolVal    VT_BYREF | VT_BOOL. For more information, see Remarks.
pbool   For more information, see Remarks.
pscode  VT_BYREF | VT_ERROR. For more information, see Remarks.
pcyVal  VT_BYREF | VT_CY. For more information, see Remarks.
pdate   VT_BYREF | VT_DATE. For more information, see Remarks.
pbstrVal    VT_BYREF | VT_BSTR. For more information, see Remarks.
ppunkVal    VT_BYREF | VT_UNKNOWN. For more information, see Remarks.
ppdispVal   VT_BYREF | VT_DISPATCH. For more information, see Remarks.
pparray VT_ARRAY | *. For more information, see Remarks.
pvarVal VT_BYREF | VT_VARIANT. For more information, see Remarks.
byref   Generic reference pointer.
cVal    VT_I1. For more information, see Remarks.
uiVal   VT_UI2. For more information, see Remarks.
ulVal   VT_UI4. For more information, see Remarks.
intVal  VT_INT. For more information, see Remarks.
uintVal VT_UINT. For more information, see Remarks.
pdecVal VT_DECIMAL | VT_BYREF. For more information, see Remarks.
pcVal   VT_I1 | VT_BYREF. For more information, see Remarks.
puiVal  VT_UI2 | VT_BYREF. For more information, see Remarks.
pulVal  VT_UI4 | VT_BYREF. For more information, see Remarks.
pintVal VT_INT | VT_BYREF. For more information, see Remarks.
puintVal    VT_UINT | VT_BYREF. For more information, see Remarks.
 
*/