SafeArray.h

Go to the documentation of this file.

/*  SafeArray.h - SAFEARRAY wrapper class
    Copyright (C) 2001-2004 Mark Weaver
    Written by Mark Weaver <mark@npsl.co.uk>

    Part of the Open-Win32 library.
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public
    License along with this library; if not, write to the
    Free Software Foundation, Inc., 59 Temple Place - Suite 330,
    Boston, MA  02111-1307, USA.
*/

#ifndef OW32_SafeArray_h
#define OW32_SafeArray_h

#include <oaidl.h>
#include <OW32/OW32Libs.h>

namespace OW32
{

class OW32_LIB_EXPORT CSafeArray
{
public:
    CSafeArray(SAFEARRAY* psa, bool bTakeOwn = false) :
        m_psa(psa),
        m_bOwn(bTakeOwn),
        m_bAccessed(false)
    {
    }
    
    CSafeArray() :
        m_psa(0),
        m_bOwn(false),
        m_bAccessed(false)
    {
    }

    ~CSafeArray()
    {
        Clear();
    }

    SAFEARRAY* Copy()
    {
        if (m_bAccessed)
            UnaccessData();

        SAFEARRAY* psaout=0;
        if (FAILED(SafeArrayCopy(m_psa, &psaout))) {
            return NULL;
        }
        return psaout;
    }

    SAFEARRAY* Detach()
    {
        if (m_bAccessed)
            UnaccessData();

        SAFEARRAY* psa=m_psa;
        m_psa=0;
        m_bOwn=false;
        return psa;
    }

    void Attach(SAFEARRAY* psa, bool bTakeOwn = true)
    {
        Clear();
        m_bOwn = bTakeOwn;
        m_psa = psa;
    }

    void Clear()
    {
        if (m_psa) {
            if (m_bAccessed)
                UnaccessData();

            if (m_bOwn) {
                SafeArrayDestroy(m_psa);
                m_bOwn = false;
            }
            m_psa=0;
        }
    }

    HRESULT CreateVector(VARTYPE vt, ULONG cElements, LONG lBound=0)
    {
        Clear();
        m_psa = SafeArrayCreateVector(vt, lBound, cElements);
        if (!m_psa)
            return E_OUTOFMEMORY;
        m_bOwn = true;
        return S_OK;
    }

    HRESULT Create(VARTYPE vt, UINT cDims, SAFEARRAYBOUND *rgsabound)
    {
        Clear();
        m_psa = SafeArrayCreate(vt, cDims, rgsabound);
        if (!m_psa)
            return E_OUTOFMEMORY;
        m_bOwn = true;
        return S_OK;
    }

    HRESULT Redim(ULONG cElements, LONG lBound = 0)
    {
        SAFEARRAYBOUND sabound;
        sabound.cElements   = cElements;
        sabound.lLbound     = (long)lBound;
        return SafeArrayRedim(m_psa, &sabound);
    }

    UINT Dimensions() const
    {
        if (m_psa)
            return m_psa->cDims;
        return 0;
    }

    LONG UBound(UINT dim) const
    {
        if (!isValidDim(dim))
            return -1;
        return m_psa->rgsabound[dim].lLbound + m_psa->rgsabound[0].cElements-1;
    }

    LONG LBound(UINT dim) const
    {
        if (!isValidDim(dim))
            return -1;
        return m_psa->rgsabound[dim].lLbound;
    }

    ULONG Count(UINT dim) const
    {
        if (!isValidDim(dim))
            return 0;
        return m_psa->rgsabound[dim].cElements;
    }

    HRESULT PutElement(LONG *rgIndexes, void *elt)
    {
        if (!m_psa)
            return E_POINTER;
        return SafeArrayPutElement(m_psa, rgIndexes, elt);
    }

    HRESULT GetElement(LONG *rgIndexes, void *elt)
    {
        if (!m_psa)
            return E_POINTER;
        return SafeArrayGetElement(m_psa, rgIndexes, elt);
    }

    ULONG ElementSize() const
    {
        return m_psa->cbElements;
    }

    template <class T>
    HRESULT AccessData(T** pbData)
    {
        void *pvData;
        HRESULT hr = SafeArrayAccessData(m_psa, &pvData);
        if (FAILED(hr))
            return hr;
        *pbData = (T *)pvData;
        m_bAccessed = true;
        return hr;
    }

#define DECLARE_ACCESSOR(T) \
    T* Access##T() \
    { \
        T* pData; \
        HRESULT hr; \
        if (FAILED(hr = AccessData(&pData))) \
        { \
            ::SetLastError(hr); \
            return (T *)0; \
        } \
        return (T *)pData; \
    }

    DECLARE_ACCESSOR(CHAR);
    DECLARE_ACCESSOR(BYTE);
    DECLARE_ACCESSOR(SHORT);
    DECLARE_ACCESSOR(USHORT);
    DECLARE_ACCESSOR(LONG);
    DECLARE_ACCESSOR(ULONG);
    DECLARE_ACCESSOR(VARIANT);
    DECLARE_ACCESSOR(BSTR);
    IDispatch** AccessIDispatch()
    {
        IDispatch** pData;
        AccessData(&pData);
        return (IDispatch **)pData;
    }
    IUnknown** AccessIUnknown()
    {
        IUnknown** pData;
        AccessData(&pData);
        return (IUnknown **)pData;
    }

#undef DECLARE_ACCESSOR

    HRESULT UnaccessData()
    {
        HRESULT hr = SafeArrayUnaccessData(m_psa);
        m_bAccessed = false;
        return hr;
    }

    operator SAFEARRAY* () { return m_psa; }

private:
    bool isValidDim(UINT dim) const
    {
        return m_psa && dim < m_psa->cDims;
    }

    SAFEARRAY* m_psa;
    bool m_bOwn;
    bool m_bAccessed;
};

} // namespace OW32

#endif // OW32_SafeArray_h

---