PC Format (South-Africa) 2001 June/PCFJune.iso/Xenon/C++/FreeCommandLineTools.exe/Include/t_safevector.h

C/C++ Source or Header | 2000-01-31 | 11.4 KB | 486 lines

//-------------------------------------------------------------------------------------
// T_SafeVector.h
//
//  The follwing template classes provide a way of creating and accessing SafeArrays.
//  They are derived from the C++ standard library (STL) vector class and can be used
//  the same way. They can be accessed just like an array (with the [] operator).
//
//  Use the constructors or assignment operators to extract the SafeArray from a
//  SAFEARRAY* or array variant (VARIANT or _variant_t). The elements will be
//  copied into the vector.  Use the GetSafeArray() or GetVariant() methods to pack
//  the elements back into a SafeArray.
//
//  To create a new SafeArray, declare a varaible of the appropriate type and call
//  resize() to set the size, or push_back() to grow the array. Call GetSafeArray()
//  or GetVariant() to produce a SafeArray.
//
//  See the T_SafeVector2 class at the bottom of this file for more information
//  about the constructors, extractors, and assignment operators.
//
//  Use the following pre-defined array types:
//
//           Array Type              -    Element Type
//    -----------------------------------------------------------------------------
//       _bstr_tSafeVector           -    BSTR (uses _bstr_t)
//       longSafeVector              -    long
//       shortSafeVector             -    short
//       byteSafeVector              -    byte
//       boolSafeVector              -    bool
//       CWbemClassObjectSafeVector  -    IWbemClassObject (uses CWbemClassObject)
//
//  Copyright (c)1997-99 Microsoft Corporation, All Rights Reserved
//------------------------------------------------------------------------------------

#if !defined(__T_SafeVector_H)
#pragma option push -b -a8 -pc -A- /*P_O_Push*/
#define      __T_SafeVector_H
#pragma once

#pragma warning( disable : 4786) // identifier was truncated to 'number' characters in the debug information
#pragma warning( disable : 4503) // decorated name length exceeded, name was truncated


typedef std::vector<_bstr_t>            _bstr_tVec;
typedef std::vector<long>               longVec;
typedef std::vector<short>              shortVec;
typedef std::vector<unsigned char>      byteVec;
typedef std::vector<bool>               boolVec;

#if !defined(NO_WBEM)
typedef std::vector<CWbemClassObject>   coVec;
#endif



template<typename TNContainer,typename TNDataType>
class T_SAExtractScaler
{
    public:
         void SetToContainer(TNContainer& _cont,void * pData,int l,int u)
         {
             TNDataType * pWalk = reinterpret_cast<TNDataType *>(pData);

             for(;l < (u+1);l++,pWalk++)
             {
                 _cont.push_back( *pWalk);
             }
         }

         void GetFromContainer
             (
             TNContainer& _cont,
             void * pData,
             TNContainer::iterator walk,
             TNContainer::iterator finish
             )
         {
             TNDataType * pWalk = reinterpret_cast<TNDataType *>(pData);

             for(;walk != finish;walk++,pWalk++)
             {
                 *pWalk = *walk;
             }
         }

         _bstr_t FormatDebugOutput
             (
             TNContainer::iterator first,
             TNContainer::iterator item,
             TNContainer::iterator last
             )
         {
             _bstr_t sRet;

             try
             {
                 _variant_t v;

                 v = v.operator=(TNDataType(*item));

                 v.ChangeType(VT_BSTR);

                 sRet = (_bstr_t) v;

                 if( (item+1)!=last )
                 {
                     sRet += ", ";
                 }
             }
             catch(_com_error&)
             {
                 sRet = "Not supported";
             }

             return sRet;
         }
};





template<typename TNContainer>
class T_Extract_bstr_t
{
    public:
         T_Extract_bstr_t()
         {
         }

         void SetToContainer(TNContainer& _cont,void * pData,int l,int u)
         {
             BSTR * pWalk = reinterpret_cast<BSTR*>(pData);

             for(;l < (u+1);l++,pWalk++)
             {
                 _cont.push_back( _bstr_t(*pWalk,true) );
             }
         }

         void GetFromContainer
             (
             TNContainer& _cont,
             void * pData,
             TNContainer::iterator walk,
             TNContainer::iterator finish
             )
         {
             BSTR * pWalk = reinterpret_cast<BSTR*>(pData);

             for(;walk != finish;walk++,pWalk++)
             {
                 *pWalk = (*walk).copy();
             }
         }

         _bstr_t FormatDebugOutput
             (
             TNContainer::iterator first,
             TNContainer::iterator item,
             TNContainer::iterator last
             )
         {
             _bstr_t sRet;

             sRet += "\"";
             sRet += (*item);
             sRet += "\"";

             if( (item+1)!=last )
             {
                 sRet += ", ";
             }

             return sRet;
         }

};



#if !defined(NO_WBEM)

template<typename TNContainer>
class T_Extract_IUnknown
{
    public:
         T_Extract_IUnknown()
         {
         }

         void SetToContainer(TNContainer& _cont,void * pData,int l,int u)
         {
             IUnknown ** pWalk = reinterpret_cast<IUnknown **>(pData);

             for(;l< (u+1);l++,pWalk++)
             {
                 _cont.push_back( CWbemClassObject((IWbemClassObject*)*pWalk) );
             }
         }

         void GetFromContainer
             (
             TNContainer& _cont,
             void * pData,
             TNContainer::iterator walk,
             TNContainer::iterator finish
             )
         {
             IUnknown ** pWalk = reinterpret_cast<IUnknown **>(pData);

             for(;walk != finish;walk++,pWalk++)
             {
                 (*walk)->AddRef();
                 *pWalk = (*walk);
             }
         }

         _bstr_t FormatDebugOutput
             (
             TNContainer::iterator   first,
             TNContainer::iterator   item,
             TNContainer::iterator   last
             )
         {
             _bstr_t sRet;

             try
             {
                 _variant_t v( long(item -first) );
                 v.ChangeType(VT_BSTR);
                 _variant_t v2( long(last-first-1) );
                 v2.ChangeType(VT_BSTR);

                 sRet += "Object [";
                 sRet += (_bstr_t)v;
                 sRet += " of ";
                 sRet += (_bstr_t)v2;
                 sRet += "]\n";

                 sRet += (*item).GetObjectText();

                 if( (item+1) != last )
                 {
                     sRet += "\n";
                 }
             }
             catch(_com_error&)
             {
                 sRet = "Not supported";
             }

             return sRet;
         }

};

#endif


typedef T_SAExtractScaler<longVec,long>             __exptExtractlong;
typedef T_SAExtractScaler<shortVec,short>           __exptExtractshort;
typedef T_SAExtractScaler<byteVec,unsigned char>    __exptExtractbyte;
typedef T_SAExtractScaler<boolVec,bool>             __exptExtractbool;
typedef T_Extract_bstr_t<_bstr_tVec>                __exptExtract_bstr_t;

#if !defined(NO_WBEM)
typedef T_Extract_IUnknown<coVec>                   __exptExtractco;
#endif


template<typename TNContainer,typename TNExtractor>
class T_SafeArrayImp
{
    public:
         void ConstructContainerFromSafeArray
             (
             TNExtractor&  _extract,
             TNContainer& _cont,
             SAFEARRAY * _pSA
             )
         {
             long l = 0;
             long u = 0;

             HRESULT hr;
             void * pData;

             hr = SafeArrayGetLBound(_pSA,1,&l);
             hr = SafeArrayGetUBound(_pSA,1,&u);

             hr = SafeArrayAccessData(_pSA,&pData);

             if(hr == S_OK)
             {
                 _extract.SetToContainer(_cont,pData,l,u);

                 SafeArrayUnaccessData(_pSA);
             }
         }

         SAFEARRAY * ConstructSafeArrayFromConatiner
             (
             TNExtractor&            _extract,
             VARTYPE                 _vt,
             TNContainer&            _cont,
             TNContainer::iterator   start,
             TNContainer::iterator   finish
             )
         {
             HRESULT         hr   = S_OK;
             SAFEARRAY *     pRet = NULL;
             SAFEARRAYBOUND  rgsabound[1];
             void * pData;

             rgsabound[0].lLbound    = 0;
             rgsabound[0].cElements  = _cont.size();

             pRet = SafeArrayCreate(_vt,1,rgsabound);

             if(pRet)
             {
                 hr = SafeArrayAccessData(pRet,&pData);

                 if(hr == S_OK)
                 {
                     _extract.GetFromContainer(_cont,pData,start,finish);

                     SafeArrayUnaccessData(pRet);
                 }
             }

             return pRet;
         }
};

///////////////////////////////////////////////////////////////////////////
// T_SafeVector2
//
// Derived from TNContainer which should be a type of STL vector.
// Provides for the conversion between vector and SafeArray.
//

template
<
VARTYPE TNVariant,
typename TNDataType,
typename TNContainer = std::vector<TNDataType>,
typename TNExtractor = T_SAExtractScaler<TNContainer,TNDataType>
>
class T_SafeVector2 : public TNContainer
{
    private:
         T_SafeArrayImp<TNContainer,TNExtractor> m_Array;
    protected:
    public:

         T_SafeVector2()
         {
         }

         // copy constructor
         T_SafeVector2(const TNContainer& _copy) : TNContainer(_copy)
         {
         }


         // Construct vector from array variant, extracts elements
         T_SafeVector2(_variant_t& _ValueArray)
         {
             if(_ValueArray.vt & VT_ARRAY)
             {
                 m_Array.ConstructContainerFromSafeArray(TNExtractor(),*this,_ValueArray.parray);
             }
         }

         // Construct vector from SAFEARRAY, extracts elements
         T_SafeVector2(SAFEARRAY * _pArray)
         {
             m_Array.ConstructContainerFromSafeArray(TNExtractor(),*this,_pArray);
         }

         // assign vector from array variant, extracts elements
         T_SafeVector2& operator=(_variant_t& _ValueArray)
         {
             clear();

             if(_ValueArray.vt & VT_ARRAY)
             {
                 m_Array.ConstructContainerFromSafeArray(TNExtractor(),*this,_ValueArray.parray);
             }

             return *this;
         }

         // assign vector from SAFEARRAY, extracts elements
         T_SafeVector2& operator=(SAFEARRAY * _pArray)
         {
             clear();
             m_Array.ConstructContainerFromSafeArray(TNExtractor(),*this,_pArray);
             return *this;
         }

         // assign vector from another vector, copies elements
         T_SafeVector2& operator=(const TNContainer& _copy)
         {
             TNContainer::operator=(_copy);
             return *this;
         }

         ~T_SafeVector2()
         {
         }

         // create SafeArray from a portion of the vector elements and return a SAFEARRAY*
         SAFEARRAY *  GetSafeArray(TNContainer::iterator start,TNContainer::iterator finish)
         {
             return m_Array.ConstructSafeArrayFromConatiner(TNExtractor(),TNVariant,*this,start,finish);
         }

         // create SafeArray from the vector elements and return a SAFEARRAY*
       SAFEARRAY * GetSafeArray()
         {
             return GetSafeArray(begin(),end());
         }

       // create SafeArray from a portion of the vector elements and return as an array variant
       _variant_t GetVariant(TNContainer::iterator start,TNContainer::iterator finish)
         {
             _variant_t vRet;

             vRet.vt        = TNVariant|VT_ARRAY;
             vRet.parray    = GetSafeArray(start,finish);

             return vRet;
         }

       // create SafeArray from the vector elements and return as an array variant
       _variant_t GetVariant()
         {
             return GetVariant(begin(),end());
         }

         _bstr_t FormatDebugOutput()
         {
             _bstr_t sOutput;

             for(iterator walk = begin();walk != end();walk++)
             {
                 sOutput += TNExtractor().FormatDebugOutput(begin(),walk,end());
             }

             return sOutput;
         }
};



typedef T_SafeVector2
<
VT_BSTR,
_bstr_t,
_bstr_tVec,
T_Extract_bstr_t<_bstr_tVec>
>
_bstr_tSafeVector;


typedef T_SafeVector2<VT_I4,long>           longSafeVector;
typedef T_SafeVector2<VT_I2,short>          shortSafeVector;
typedef T_SafeVector2<VT_UI1,unsigned char> byteSafeVector;
typedef T_SafeVector2<VT_BOOL,bool>         boolSafeVector;

#if !defined(NO_WBEM)
typedef T_SafeVector2
<
VT_UNKNOWN,
CWbemClassObject,
std::vector<CWbemClassObject>,
T_Extract_IUnknown<std::vector<CWbemClassObject> >
>
CWbemClassObjectSafeVector;
#endif


#pragma option pop /*P_O_Pop*/
#endif // __T_SafeVector_H