Excel.cpp

#ifndef   UNICODE
    #define   UNICODE
#endif
#ifndef   _UNICODE
    #define   _UNICODE
#endif
#include <windows.h>
#include <stdio.h>
#include <optional>
#include <regex>
#include <exception>
#include "Excel.h"
#include <Foundation/SafeArrayWrapper.h>
#include <Foundation/Logger.h>
#include <comutil.h>
#include <comdef.h>

namespace
{

void logException(const Foundation::LoggerPtr& logCategory, const EXCEPINFO& excepInfo, const char* context)
{
    LOG4CXX_WARN(logCategory, "Exception: " << (const char*)_bstr_t(excepInfo.bstrDescription) << " accessing " << context);
    SysFreeString(excepInfo.bstrDescription);
    SysFreeString(excepInfo.bstrSource);
    SysFreeString(excepInfo.bstrHelpFile);
}

void logMembers(const Foundation::LoggerPtr& log, IDispatch* pObj, LCID lcid)
{
    struct GUIDComparer
    {
        bool operator()(const GUID& left, const GUID& right) const
        {
            return memcmp(&left, &right, sizeof(right)) < 0;
        }
    };
    static std::map<GUID, int, GUIDComparer> alreadyLogged;
    UINT tinfoCount = 0;
    if (!log->isDebugEnabled() || FAILED(pObj->GetTypeInfoCount(&tinfoCount)))
        return;
    while (0 < tinfoCount)
    {
        --tinfoCount;
        ITypeInfo* pTInfo;
        if (FAILED(pObj->GetTypeInfo(tinfoCount, lcid, &pTInfo)))
            continue;
        TYPEATTR* pTypeAttr = 0;
        if (FAILED(pTInfo->GetTypeAttr(&pTypeAttr)))
            continue;
        if (!alreadyLogged[pTypeAttr->guid])
        {
            BSTR guidString;
            if (SUCCEEDED(StringFromCLSID(pTypeAttr->guid, &guidString)))
            {
                LOG4CXX_DEBUG(log, (const char*)_bstr_t(guidString));
                CoTaskMemFree(guidString);
            }
            for (int i = 0; i < pTypeAttr->cFuncs; ++i)
            {
                FUNCDESC* pDesc;
                if (FAILED(pTInfo->GetFuncDesc(i, &pDesc)))
                    continue;
                const char* invokeType =
                    (INVOKE_FUNC == pDesc->invkind ? "call" :
                    (INVOKE_PROPERTYGET == pDesc->invkind ? "get" :
                    (INVOKE_PROPERTYPUT == pDesc->invkind ? "put" :
                    (INVOKE_PROPERTYPUTREF == pDesc->invkind ? "putRef" :
                    "???"
                    ))));
                BSTR wName = 0;
                DWORD helpId;
                if (SUCCEEDED(pTInfo->GetDocumentation(pDesc->memid, &wName, 0, &helpId, 0)))
                {
                    LOG4CXX_DEBUG(log, invokeType
                        << " " << (const char*)_bstr_t(wName)
                        << "=" << std::dec << pDesc->memid
                        << "=0x" << std::hex << pDesc->memid
                        << " paramCount " << std::dec << pDesc->cParams
                    );
                    SysFreeString(wName);
                }
                pTInfo->ReleaseFuncDesc(pDesc);
            }
            ++alreadyLogged[pTypeAttr->guid];
        }
        pTInfo->ReleaseTypeAttr(pTypeAttr);
    }
}

HRESULT SetHidden(IDispatch* pObject, LCID lcid)
{
    VARIANT      vArgArray[1];
    VARIANT      vResult;
    VariantInit(&vArgArray[0]);
    VariantInit(&vResult);
    vArgArray[0].vt      = VT_BOOL;
    vArgArray[0].boolVal = FALSE;

    DISPID          dispidNamed   = DISPID_PROPERTYPUT;
    DISPPARAMS      dispParams;
    dispParams.rgvarg             = vArgArray;
    dispParams.rgdispidNamedArgs  = &dispidNamed;
    dispParams.cArgs              = 1;
    dispParams.cNamedArgs         = 1;
    return pObject->Invoke(0x22e, IID_NULL, lcid, DISPATCH_PROPERTYPUT, &dispParams, &vResult, NULL,NULL);
}

IDispatch* GetDispatchObject(IDispatch* pObject, DISPID dispid, WORD wFlags, LCID lcid, const std::string& objectName)
{
    DISPPARAMS   NoArgs = {NULL,NULL,0,0};
    VARIANT      vResult;
    VariantInit(&vResult);
    if (FAILED(pObject->Invoke(dispid, IID_NULL, lcid, wFlags, &NoArgs, &vResult, NULL, NULL)))
        return NULL;
    logMembers(Foundation::GetLogger("OLE." + objectName), vResult.pdispVal, lcid);
    return vResult.pdispVal;
}

struct excelInstance
{
    LCID lcid;
    IDispatch* pXLApp;
    IDispatch* pXLWorkBooks;
    excelInstance() : lcid(GetUserDefaultLCID()), pXLApp(NULL), pXLWorkBooks(NULL)
    {
        if (FAILED(CoInitialize(NULL)))
            throw std::runtime_error("Failed to initialize COM Subsystem");
        const CLSID  CLSID_XLApplication = {0x00024500,0x0000,0x0000,{0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}};
        const IID    IID_Application     = {0x000208D5,0x0000,0x0000,{0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}};
        HRESULT      hr                  = CoCreateInstance
            ( CLSID_XLApplication
            , NULL
            , CLSCTX_LOCAL_SERVER
            , IID_Application
            , (void**)&this->pXLApp
            );
        if (SUCCEEDED(hr) && this->pXLApp)
        {
            logMembers(Foundation::GetLogger("OLE.Excel"), pXLApp, this->lcid);
            SetHidden(pXLApp, this->lcid);
            this->pXLWorkBooks = GetDispatchObject(this->pXLApp, 572, DISPATCH_PROPERTYGET, this->lcid, "Workbooks");
        }
    }
    ~excelInstance()
    {
        if (this->pXLWorkBooks)
        {
            this->pXLWorkBooks->Release();
            this->pXLWorkBooks = NULL;
        }
        if (pXLApp)
        {
            DISPPARAMS NoArgs = {NULL,NULL,0,0};
            this->pXLApp->Invoke(0x12e, IID_NULL, this->lcid ,DISPATCH_METHOD ,&NoArgs ,NULL,NULL,NULL); // pXLApp->Quit()
            this->pXLApp->Release();
            this->pXLApp = NULL;
        }
        CoUninitialize();
    }
};

excelInstance& GetInstance()
{
    static excelInstance instance;
    return instance;
}

IDispatch* GetNamedDispatchObject(IDispatch* pObject, DISPID dispid, LCID lcid, const _bstr_t& name, const std::string& objectName)
{
    VARIANT         vArgArray[1];
    VARIANT         vResult;
    DISPPARAMS      DispParams;

    VariantInit(&vResult);
    vArgArray[0].vt                = VT_BSTR,
    vArgArray[0].bstrVal           = SysAllocString(name);
    DispParams.rgvarg              = vArgArray;
    DispParams.rgdispidNamedArgs   = 0;
    DispParams.cArgs               = 1;
    DispParams.cNamedArgs          = 0;
    HRESULT hr = pObject->Invoke
    (
        dispid,
        IID_NULL,
        lcid,
        DISPATCH_PROPERTYGET,
        &DispParams,
        &vResult,
        NULL,
        NULL
    );
    SysFreeString(vArgArray[0].bstrVal);
    if(FAILED(hr))
        return NULL;
    logMembers(Foundation::GetLogger("OLE." + objectName), vResult.pdispVal, lcid);
    return vResult.pdispVal;
}

int GetDispatchCount(IDispatch* pObject, LCID lcid)
{
    DISPPARAMS   NoArgs = {NULL,NULL,0,0};
    _variant_t   vResult;
    VariantInit(&vResult);
    if (FAILED(pObject->Invoke(118, IID_NULL, lcid,DISPATCH_PROPERTYGET, &NoArgs, &vResult, NULL, NULL)))
        return 0;
    else
        return vResult;
}

// The number for \c methodName to use in Invoke calls
DISPID GetMethodId(IDispatch* pObject, const _bstr_t& methodName, LCID lcid, const std::string& objectName)
{
    LPOLESTR itemMethodName = SysAllocString(methodName);
    DISPID   dispidItem;
    HRESULT hr = pObject->GetIDsOfNames(IID_NULL, &itemMethodName, 1, lcid, &dispidItem);
    SysFreeString(itemMethodName);
    if (FAILED(hr))
    {
        LOG4CXX_WARN(Foundation::GetLogger("OLE." + objectName),
                     "GetIDsOfNames failed for " << (const char*)itemMethodName << ": 0x" << std::hex << hr);
        return 0;
    }
    return dispidItem;
}

// Member Get Item <170> (In Index As Variant<0>) As IDispatch
IDispatch* GetDispatchItem(IDispatch* pObject, int item, LCID lcid, const std::string& objectName)
{
    VARIANT         vResult;
    VARIANT         vArgArray[1];
    DISPPARAMS      DispParams;
    DISPID          dispidNamed;
    VariantInit(&vResult);
    VariantInit(&vArgArray[0]);
    vArgArray[0].vt                = VT_I4;
    vArgArray[0].lVal              = item;
    DispParams.rgvarg              = vArgArray;
    DispParams.rgdispidNamedArgs   = &dispidNamed;
    DispParams.cArgs               = 1;
    DispParams.cNamedArgs          = 0;
    if (FAILED(pObject->Invoke(0xAA, IID_NULL, lcid, DISPATCH_PROPERTYGET, &DispParams, &vResult, NULL, NULL)))
        return NULL;
    logMembers(Foundation::GetLogger("OLE." + objectName), vResult.pdispVal, lcid);
    return vResult.pdispVal;
}


// Member gt \c item As IDispatch using Item
// In VBA, Collection(index) with parentheses calls DISPID_VALUE (0).
IDispatch* GetDispatchItem(IDispatch* pObject, const _bstr_t& item, LCID lcid, const std::string& objectName)
{
    VARIANT         vResult;
    VARIANT         vArgArray[1];
    DISPPARAMS      DispParams;
    EXCEPINFO       excepInfo;
    UINT            argErr = 0;

    VariantInit(&vResult);
    memset(&excepInfo, 0, sizeof(excepInfo));

    VariantInit(&vArgArray[0]);
    vArgArray[0].vt = VT_BSTR;
    vArgArray[0].bstrVal = SysAllocString(item);

    DispParams.rgvarg            = vArgArray;
    DispParams.rgdispidNamedArgs = NULL;
    DispParams.cArgs             = 1;
    DispParams.cNamedArgs        = 0;

    HRESULT hr = pObject->Invoke(DISPID_VALUE, IID_NULL, lcid,
                                 DISPATCH_METHOD | DISPATCH_PROPERTYGET,
                                 &DispParams, &vResult, &excepInfo, &argErr);
    SysFreeString(vArgArray[0].bstrVal);

    auto logCategory = Foundation::GetLogger("OLE." + objectName);
    if (FAILED(hr))
    {
        if (hr == DISP_E_EXCEPTION && excepInfo.bstrDescription)
            logException(logCategory, excepInfo, item);
        else
        {
            LOG4CXX_WARN(logCategory, "Invoke failed with HRESULT: 0x" << std::hex << hr);
        }
        return NULL;
    }

    logMembers(logCategory, vResult.pdispVal, lcid);
    return vResult.pdispVal;
}

auto GetDispatchString(IDispatch* pObject, DISPID dispid, LCID lcid) -> std::string
{
    std::string result;
    DISPPARAMS   NoArgs = {NULL,NULL,0,0};
    _variant_t   vResult;
    if (SUCCEEDED(pObject->Invoke(dispid, IID_NULL, lcid, DISPATCH_PROPERTYGET, &NoArgs, &vResult, NULL, NULL)))
        result = (_bstr_t)vResult;
    return result;
}

auto GetDispatchVariant(IDispatch* pObject, DISPID dispid, LCID lcid, VARIANT* vResult) -> bool
{
    DISPPARAMS   NoArgs = {NULL,NULL,0,0};
    return SUCCEEDED(pObject->Invoke(dispid, IID_NULL, lcid, DISPATCH_PROPERTYGET, &NoArgs, vResult, NULL, NULL));
}

} // anonymous namespace

namespace Excel
{

struct Book::Impl
{
    IDispatch* pXLWorkBook;
    IDispatch* pXLWorkSheets;
    IDispatch* pXLNames;
    Impl()
        : pXLWorkBook(NULL)
        , pXLWorkSheets(NULL)
        , pXLNames(NULL)
    {
    }
    ~Impl()
    {
        if (pXLNames) pXLNames->Release();
        if (pXLWorkSheets) pXLWorkSheets->Release();
        if (pXLWorkBook)
        {
            // Call WorkBook::Close(SaveChanges=False)
            VARIANT      vArgArray[1];
            VariantInit(&vArgArray[0]);
            vArgArray[0].vt      = VT_BOOL;
            vArgArray[0].boolVal = FALSE;
            DISPID     dispidNamed;
            DISPPARAMS dispParams;
            dispParams.rgvarg              = vArgArray;
            dispParams.rgdispidNamedArgs   = &dispidNamed;
            dispParams.cArgs               = 1;
            dispParams.cNamedArgs          = 0;
            pXLWorkBook->Invoke(277, IID_NULL, GetInstance().lcid, DISPATCH_METHOD, &dispParams ,NULL,NULL,NULL);
            pXLWorkBook->Release();
        }
    }
};

Book::Book()
{
}

Book::~Book()
{
}

auto Book::CanLoad() const -> bool
{
    return !!GetInstance().pXLWorkBooks;
}

auto Book::Load(const fs::path& path) -> bool
{
    // Call WorkBooks::Open(FileName, UpdateLinks=False, ReadOnly=True)
    VARIANT      vArgArray[3];
    vArgArray[2].vt                = VT_BSTR;
    vArgArray[2].bstrVal           = SysAllocString(path.wstring().c_str());
    vArgArray[1].vt                = VT_BOOL; // UpdateLinks
    vArgArray[1].boolVal           = FALSE;
    vArgArray[0].vt                = VT_BOOL; // ReadOnly
    vArgArray[0].boolVal           = TRUE;
    DISPID     dispidNamed;
    DISPPARAMS dispParams;
    dispParams.rgvarg              = vArgArray;
    dispParams.rgdispidNamedArgs   = &dispidNamed;
    dispParams.cArgs               = 3;
    dispParams.cNamedArgs          = 0;
    VARIANT      vResult;
    VariantInit(&vResult);
    HRESULT hr = GetInstance().pXLWorkBooks->Invoke(1923, IID_NULL, GetInstance().lcid, DISPATCH_METHOD, &dispParams, &vResult, NULL,NULL);
    SysFreeString(vArgArray[2].bstrVal);
    bool result = false;
    if (!FAILED(hr) && vResult.pdispVal)
    {
        // Get pXLWorkSheets
        m_impl = std::make_shared<Impl>();
        m_impl->pXLWorkBook = vResult.pdispVal;
        logMembers(Foundation::GetLogger("OLE.Workbook"), m_impl->pXLWorkBook, GetInstance().lcid);
        m_impl->pXLWorkSheets = GetDispatchObject(m_impl->pXLWorkBook, 494, DISPATCH_PROPERTYGET, GetInstance().lcid, "Worksheets");
        result = !!m_impl->pXLWorkSheets;
        m_impl->pXLNames = GetDispatchObject(m_impl->pXLWorkBook, 442, DISPATCH_PROPERTYGET, GetInstance().lcid, "Names");
        result = !!m_impl->pXLNames;
    }
    return result;
}

auto Book::IsValid() const -> bool
{
    return m_impl && m_impl->pXLWorkSheets;
}

auto Book::GetSheetCount() const -> int
{
    return IsValid() ? GetDispatchCount(m_impl->pXLWorkSheets, GetInstance().lcid) : 0;
}

auto Book::GetNameCount() const -> int
{
    return m_impl->pXLNames ? GetDispatchCount(m_impl->pXLNames, GetInstance().lcid) : 0;
}

void Book::Unload()
{
    m_impl.reset();
}

struct Sheet::Impl
{
    IDispatch* pXLWorkSheet;
    std::string name;
    Impl(IDispatch* pObj = NULL)
        : pXLWorkSheet(pObj)
    {
    }
    ~Impl()
    {
        if (pXLWorkSheet) pXLWorkSheet->Release();
    }
};

auto Book::GetSheet(int item) const -> Sheet
{
    Sheet result;
    if (result.m_impl->pXLWorkSheet = GetDispatchItem(m_impl->pXLWorkSheets, item, GetInstance().lcid, "Worksheet"))
    {
        result.m_impl->name = GetDispatchString(result.m_impl->pXLWorkSheet, 110, GetInstance().lcid);
    }
    return result;
}

auto Book::GetSheet(const std::regex& selector, int afterItem) const -> SheetPosition
{
    SheetPosition result;
    auto sheetCount = GetSheetCount();
    for (result.second = afterItem + 1; result.second <= sheetCount; ++result.second)
    {
        auto item = GetSheet(result.second);
        if (item.IsValid())
        {
            if (std::regex_match(item.GetName(), selector))
            {
                result.first = item;
                break;
            }
        }
    }
    return result;
}

struct Name::Impl
{
    IDispatch* pXLName;
    std::string name;
    Impl(IDispatch* pObj = NULL)
        : pXLName(pObj)
    {
    }
    ~Impl()
    {
        if (pXLName) pXLName->Release();
    }
};

auto Book::GetName(int item) const -> Name
{
    Name result;
    if (result.m_impl->pXLName = GetDispatchItem(m_impl->pXLNames, item, GetInstance().lcid, "Name"))
    {
        result.m_impl->name = GetDispatchString(result.m_impl->pXLName, 110, GetInstance().lcid);
    }
    return result;
}

auto Book::GetName(const std::string& item) const -> Name
{
    Name result;
    if (result.m_impl->pXLName = GetDispatchItem(m_impl->pXLNames, item.c_str(), GetInstance().lcid, "Name"))
    {
        result.m_impl->name = GetDispatchString(result.m_impl->pXLName, 110, GetInstance().lcid);
    }
    return result;
}

auto Book::GetName(const std::regex& selector, int afterItem) const -> NamePosition
{
    NamePosition result;
    auto nameCount = GetNameCount();
    for (result.second = afterItem + 1; result.second <= nameCount; ++result.second)
    {
        auto item = GetName(result.second);
        if (item.IsValid())
        {
            if (std::regex_match(item.GetName(), selector))
            {
                result.first = item;
                break;
            }
        }
    }
    return result;
}

Name::Name() : m_impl(std::make_shared<Impl>())
{
}

Name::~Name()
{
}

auto Name::operator==(const Name& other) const -> bool
{
    return m_impl && other.m_impl && other.m_impl->pXLName == m_impl->pXLName;
}

bool Name::IsValid() const
{
    return m_impl && m_impl->pXLName;
}

auto Name::GetName() const -> std::string
{
    return m_impl->name;
}

Sheet::Sheet() : m_impl(std::make_shared<Impl>())
{
}

Sheet::~Sheet()
{
}

auto Sheet::operator==(const Sheet& other) const -> bool
{
    return m_impl && other.m_impl && other.m_impl->pXLWorkSheet == m_impl->pXLWorkSheet;
}

bool Sheet::IsValid() const
{
    return m_impl && m_impl->pXLWorkSheet;
}

auto Sheet::GetName() const -> std::string
{
    return m_impl->name;
}

struct Rows::Impl
{
    Sheet clx;
    IDispatch* pXLRows;
    Impl(const Sheet& parent)
        : clx(parent)
        , pXLRows(NULL)
    {
    }
    ~Impl()
    {
        if (pXLRows) pXLRows->Release();
    }
};

auto Sheet::GetRows() const -> Rows
{
    Rows result(*this);
    result.m_impl->pXLRows = GetDispatchObject(m_impl->pXLWorkSheet, 258, DISPATCH_PROPERTYGET, GetInstance().lcid, "Rows");
    return result;
}

auto Sheet::GetRows(const std::regex& selector) const -> RowsPosition
{
    return RowsPosition(GetRows(), 0);
}

struct Sheet::Iterator::Impl
{
    Book clx;
    std::optional<std::regex> selector;
    SheetPosition current;
	Foundation::LoggerPtr log = Foundation::GetLogger("Excel.Sheet.Iterator");
};

Sheet::Iterator::Iterator() : m_impl(std::make_shared<Impl>())
{
}

Sheet::Iterator::~Iterator()
{
}

// Is this iterator beyond the end or before the start?
    bool
Sheet::Iterator::Off() const
{
    return !m_impl->current.first.IsValid();
}

// Move to the first sheet in \c book matching \c sheetPattern
    void
Sheet::Iterator::Start(const Book& book, const std::string& sheetPattern)
{
	LOG4CXX_DEBUG(m_impl->log, "Start:" << " sheetPattern " << sheetPattern);
    m_impl->clx = book;
    if (sheetPattern.empty())
        m_impl->selector.reset();
    else
        m_impl->selector = sheetPattern;
    Start();
}

// Move to the first sheet
    void
Sheet::Iterator::Start()
{
    if (m_impl->selector)
        m_impl->current = m_impl->clx.GetSheet(m_impl->selector.value());
    else
    {
        m_impl->current.second = 1;
        m_impl->current.first = m_impl->clx.GetSheet(1);
    }
    m_item = m_impl->current.first;
	if (m_item.IsValid())
		LOG4CXX_DEBUG(m_impl->log, "At: " << m_item.GetName());
}

// Move to the next sheet. Precondition: !Off()
    void
Sheet::Iterator::Forth()
{
    ++m_impl->current.second;
    if (m_impl->selector)
        m_impl->current = m_impl->clx.GetSheet(m_impl->selector.value(), m_impl->current.second);
    else
        m_impl->current.first = m_impl->clx.GetSheet(m_impl->current.second);
    m_item = m_impl->current.first;
	if (m_item.IsValid())
		LOG4CXX_DEBUG(m_impl->log, "At: " << m_item.GetName());
}

Rows::Rows()
{
}

Rows::Rows(const Sheet& parent) : m_impl(std::make_shared<Impl>(parent))
{
}

Rows::~Rows()
{
}

auto Rows::operator==(const Rows& other) const -> bool
{
    return other.m_impl && m_impl && other.m_impl->pXLRows == m_impl->pXLRows;
}

auto Rows::IsValid() const -> bool
{
    return m_impl && m_impl->pXLRows;
}

void Rows::Reset()
{
    m_impl.reset();
}

struct Rows::Iterator::Impl
{
    RowsPosition current;
	Foundation::LoggerPtr log = Foundation::GetLogger("Excel.Rows.Iterator");
    Impl(const Sheet& sheet)
        : current(sheet.GetRows(), 0)
    {
    }
};

Rows::Iterator::Iterator()
{
}

Rows::Iterator::Iterator(const Sheet& sheet)
    : m_impl{ std::make_shared<Impl>(sheet) }
{
    Start();
}

Rows::Iterator::~Iterator()
{
}

// Is this iterator beyond the end or before the start?
    bool
Rows::Iterator::Off() const
{
    return m_item.empty();
}

// Move to the first row in \c sheet
    void
Rows::Iterator::Start(const Sheet& sheet)
{
    m_impl = std::make_shared<Impl>(sheet);
    Start();
}

// Move to the first row
    void
Rows::Iterator::Start()
{
    m_impl->current.second = 1;
    m_item = m_impl->current.first.GetCells(1).GetData();
}


// Move to the next row. Precondition: !Off()
    void
Rows::Iterator::Forth()
{
    ++m_impl->current.second;
    m_item = m_impl->current.first.GetCells(m_impl->current.second).GetData();
    if (Off())
        m_impl->current.first.Reset();
}

struct Cells::Impl
{
    IDispatch* pXLCells;
    CellRow data;
    Impl() : pXLCells(NULL)
    {
    }
    ~Impl()
    {
        if (pXLCells) pXLCells->Release();
    }
    Foundation::LoggerPtr log = Foundation::GetLogger("OLE.Cells");
};

auto Rows::GetCells(int row) const -> Cells
{
    Cells result;
    result.m_impl->pXLCells = GetDispatchItem(m_impl->pXLRows, row, GetInstance().lcid, "Cells");
    return result;
}

Cells::Cells() : m_impl(std::make_shared<Impl>())
{
}

Cells::~Cells()
{
}

auto Cells::operator==(const Cells& other) const -> bool
{
    return other.m_impl->pXLCells == m_impl->pXLCells;
}

auto Cells::IsValid() const -> bool
{
    return !!m_impl->pXLCells;
}

auto Cells::GetData() const -> CellRow
{
    if (m_impl->data.empty())
    {
        auto pItem = GetDispatchItem(m_impl->pXLCells, 1, GetInstance().lcid, "Cells");
        _variant_t itemData;
        if (!pItem || !GetDispatchVariant(pItem, 6, GetInstance().lcid, &itemData))
            ;
        else if ((VT_ARRAY|VT_VARIANT) == itemData.vt)
        {
            SafeArrayData sa(itemData.parray);
            m_impl->data.resize(sa.DimensionSize(1));
            sa.GetStringVector(m_impl->data.begin(), m_impl->data.end());
        }
        else try
        {
            m_impl->data.push_back((const char*)_bstr_t(itemData));
        }
        catch (const _com_error& ex)
        {
            LOG4CXX_WARN(m_impl->log, "Not convertable to string: 0x" << std::hex << ex.Error());
        }
        while (!m_impl->data.empty())
        {
            if (!m_impl->data.back().empty())
                break;
            m_impl->data.pop_back();
        }
    }
    return m_impl->data;
}

struct Range::Impl
{
    Name name;
    IDispatch* pXLRange;
    _variant_t var;
    SafeArrayData data;
    Impl(const Name& parent)
        : name(parent)
        , pXLRange(NULL)
    {
    }
    ~Impl()
    {
        if (pXLRange) pXLRange->Release();
    }
    Foundation::LoggerPtr log = Foundation::GetLogger("OLE.Range");

    void setData()
    {
        if (!this->pXLRange)
            ;
        else if (!GetDispatchVariant(this->pXLRange, 6, GetInstance().lcid, &this->var))
            LOG4CXX_WARN(this->log, "Failed to get data");
        else if ((VT_ARRAY|VT_VARIANT) == this->var.vt)
           this->data = this->var.parray;
    }
};

auto Name::GetRange() const -> Range
{
    static const int RefersToRange = 1160;
    Range result(*this);
    result.m_impl->pXLRange = GetDispatchObject(m_impl->pXLName, RefersToRange, DISPATCH_PROPERTYGET, GetInstance().lcid, "Range");
    return result;
}

Range::Range()
{
}

Range::Range(const Name& parent) : m_impl(std::make_shared<Impl>(parent))
{
}

Range::~Range()
{
}

auto Range::operator==(const Range& other) const -> bool
{
    return other.m_impl && m_impl && other.m_impl->pXLRange == m_impl->pXLRange;
}

auto Range::IsValid() const -> bool
{
    return m_impl && m_impl->pXLRange;
}

void Range::Reset()
{
    m_impl.reset();
}

auto Range::GetRowCount() const -> int
{
    if (VT_EMPTY == m_impl->var.vt)
        m_impl->setData();
    return m_impl->data.IsValid()
        ? m_impl->data.DimensionSize(1)
        : VT_EMPTY == m_impl->var.vt
        ? 0
        : 1;
}

auto Range::GetRow(int row) const -> CellRow
{
    if (VT_EMPTY == m_impl->var.vt)
        m_impl->setData();
    CellRow result;
    if (m_impl->data.IsValid())
    {
        result.resize(m_impl->data.DimensionSize(1));
        m_impl->data.GetStringVector(row, result.begin(), result.end());
    }
    else try
    {
        result.push_back((const char*)_bstr_t(m_impl->var));
    }
    catch (const _com_error& ex)
    {
        LOG4CXX_WARN(m_impl->log, "Not convertable to string: 0x" << std::hex << ex.Error());
    }
    return result;
}

struct Range::Iterator::Impl
{
    RangePosition current;
	Foundation::LoggerPtr log = Foundation::GetLogger("Excel.Range.Iterator");
    Impl(const Name& name)
        : current(name.GetRange(), 0)
    {
    }
};

Range::Iterator::Iterator()
{
}

Range::Iterator::Iterator(const Name& name)
    : m_impl{ std::make_shared<Impl>(name) }
{
    Start();
}

Range::Iterator::~Iterator()
{
}

// Is this iterator beyond the end or before the start?
    bool
Range::Iterator::Off() const
{
    return !m_impl->current.first.IsValid() || m_impl->current.first.GetRowCount() < m_impl->current.second;
}

// Move to the first row in \c name
    void
Range::Iterator::Start(const Name& name)
{
    m_impl = std::make_shared<Impl>(name);
    Start();
}

// Move to the first row
    void
Range::Iterator::Start()
{
    m_impl->current.second = 1;
    m_item = m_impl->current.first.GetRow(1);
}


// Move to the next row. Precondition: !Off()
    void
Range::Iterator::Forth()
{
    ++m_impl->current.second;
    m_item = m_impl->current.first.GetRow(m_impl->current.second);
    if (Off())
        m_impl->current.first.Reset();
}

} // namespace Excel