extensions/test/ole/OleConverterVar1/smartarray.h

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: smartarray.h,v $
  10  * $Revision: 1.3 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30 #ifndef _SMARTARRAY_H
  31 #define _SMARTARRAY_H
  32
  33
  34 template< class sourceType>
  35 class SmartArray
  36 {
  37     SAFEARRAY *m_array;
  38 public:
  39
  40     SmartArray( sourceType * parParams, int count, VARTYPE destVartype): m_array(NULL)
  41     {
  42         HRESULT hr= S_OK;
  43         SAFEARRAYBOUND rgsabound[1];
  44         rgsabound[0].cElements= count;
  45         rgsabound[0].lLbound= 0;
  46         m_array= SafeArrayCreate( destVartype, 1, rgsabound);
  47         SafeArrayLock( m_array);
  48
  49         void* pData;
  50         if( m_array && (SUCCEEDED( SafeArrayAccessData( m_array, (void**)&pData)) ) )
  51         {
  52
  53             for( int i=0; i< count; i++)
  54             {
  55                 CComVariant varSource( parParams[i]);
  56                 switch (destVartype)
  57                 {
  58                 case VT_I1:
  59                     {
  60                         char* p= (char*) pData;
  61                         if( SUCCEEDED( hr= varSource.ChangeType( destVartype)))
  62                             p[i]= V_I1( &varSource);
  63                         break;
  64                     }
  65                 case VT_I2:
  66                     {
  67                         short* p= (short*) pData;
  68                         if( SUCCEEDED( hr=varSource.ChangeType( destVartype)))
  69                             p[i]= V_I2( &varSource);
  70                         break;
  71                     }
  72                 case VT_UI2:
  73                     {
  74                         unsigned short* p= (unsigned short*) pData;
  75                         if( SUCCEEDED( hr=varSource.ChangeType( destVartype)))
  76                             p[i]= V_UI2( &varSource);
  77                         break;
  78                     }
  79                 case VT_I4:
  80                     {
  81                         long* p= (long*)pData;
  82                     if( SUCCEEDED( hr=varSource.ChangeType( destVartype)))
  83                         p[i]= V_I4( &varSource);
  84                     break;
  85                     }
  86                 case VT_UI4:
  87                     {
  88                         unsigned long* p= (unsigned long*)pData;
  89                         if( SUCCEEDED( hr=varSource.ChangeType( destVartype)))
  90                         p[i]= V_UI4( &varSource);
  91                         break;
  92                     }
  93                 case VT_R4:
  94                     {
  95                         float* p= (float*)pData;
  96                     if( SUCCEEDED( hr=varSource.ChangeType( destVartype)))
  97                         p[i]= V_R4( &varSource);
  98                         break;
  99                     }
 100                 case VT_R8:
 101                     {
 102                         double* p= (double*)pData;
 103                         if( SUCCEEDED( hr=varSource.ChangeType( destVartype)))
 104                         p[i]= V_R8( &varSource);
 105                         break;
 106                     }
 107                 case VT_BOOL:
 108                     {
 109                         VARIANT_BOOL* p= (VARIANT_BOOL*)pData;
 110                         if( SUCCEEDED( hr=varSource.ChangeType( destVartype)))
 111                         p[i]= V_BOOL( &varSource);
 112                         break;
 113                     }
 114                 case VT_BSTR:
 115                     {
 116                     BSTR* pBstr= ( BSTR*)pData;
 117                     if( SUCCEEDED( hr=varSource.ChangeType( destVartype)))
 118                         pBstr[i]= SysAllocString(V_BSTR( &varSource));
 119                     break;
 120                     }
 121                 case VT_VARIANT:
 122                     {
 123                         VARIANT *pVariant= (VARIANT*)pData;
 124                         hr= VariantCopy( &pVariant[i], &varSource); break;
 125                     }
 126 //                              case VT_UNKNOWN:
 127 //                                      {
 128 //                                              long* pUnk= (long*)pData;
 129 //                                              pUnk[i]= reinterpret_cast<long>(parParams[i]);
 130 //                                              ((IUnknown*)pUnk[i])->AddRef(); break;
 131 //                                      }
 132 //                              case VT_DISPATCH:
 133 //                                      {
 134 //                                              long* pDisp= (long*)pData;
 135 //                                              pDisp[i]= (long)parParams[i];
 136 //                                              ((IDispatch*)pDisp[i])->AddRef(); break;
 137 //                                      }
 138                 default:
 139                     hr= E_FAIL;
 140                 }
 141             }
 142             if( FAILED( hr))
 143             {
 144                 SafeArrayDestroy( m_array);
 145                 m_array= NULL;
 146             }
 147         }
 148         SafeArrayUnaccessData( m_array);
 149     }
 150     ~SmartArray(){
 151         SafeArrayUnlock( m_array);
 152         SafeArrayDestroy( m_array );
 153     }
 154
 155     operator bool (){ return m_array == NULL ?  false : true; }
 156
 157     operator SAFEARRAY* (){ return m_array;}
 158
 159 };
 160
 161 template<>
 162 class SmartArray<IUnknown*>
 163 {
 164     SAFEARRAY *m_array;
 165 public:
 166
 167     SmartArray( sourceType * parParams, int count, VARTYPE destVartype);
 168 //      {
 169 //              ATLTRACE("SmartArray<IUnknown>");
 170 //              HRESULT hr= S_OK;
 171 //              SAFEARRAYBOUND rgsabound[1];
 172 //              rgsabound[0].cElements= count;
 173 //              rgsabound[0].lLbound= 0;
 174 //              m_array= SafeArrayCreateVector( VT_UNKNOWN, 0, count);
 175 //              SafeArrayLock( m_array);
 176 //
 177 //              IUnknown* *pData;
 178 //              if( m_array && (SUCCEEDED( SafeArrayAccessData( m_array, (void**)&pData)) ) )
 179 //              {
 180 //
 181 //                      for( int i=0; i< count; i++)
 182 //                      {
 183 //                              CComVariant varSource( parParams[i]);
 184 //                              switch (destVartype)
 185 //                              {
 186 //
 187 //                              case VT_UNKNOWN:
 188 //                                      {
 189 //                                              pData[i]= parParams[i];
 190 //                                              pData[i]->AddRef();
 191 //                                      }
 192 //                              default:
 193 //                                      hr= E_FAIL;
 194 //                              }
 195 //                      }
 196 //                      if( FAILED( hr))
 197 //                      {
 198 //                              SafeArrayDestroy( m_array);
 199 //                              m_array= NULL;
 200 //                      }
 201 //              }
 202 //              SafeArrayUnaccessData( m_array);
 203 //      }
 204     ~SmartArray(){
 205         SafeArrayUnlock( m_array);
 206         SafeArrayDestroy( m_array );
 207     }
 208
 209     operator bool (){ return m_array == NULL ?  false : true; }
 210
 211     operator SAFEARRAY* (){ return m_array;}
 212
 213 };
 214
 215 template <> SmartArray <IUnknown*>::SmartArray(sourceType * parParams, int count, VARTYPE destVartype):m_array(NULL)
 216 {
 217     ATLTRACE("SmartArray<IUnknown>");
 218     HRESULT hr= S_OK;
 219     SAFEARRAYBOUND rgsabound[1];
 220     rgsabound[0].cElements= count;
 221     rgsabound[0].lLbound= 0;
 222     m_array= SafeArrayCreateVector( VT_UNKNOWN, 0, count);
 223     SafeArrayLock( m_array);
 224
 225     IUnknown* *pData;
 226     if( m_array && (SUCCEEDED( SafeArrayAccessData( m_array, (void**)&pData)) ) )
 227     {
 228         for( int i=0; i< count; i++)
 229         {
 230             pData[i]= parParams[i];
 231             pData[i]->AddRef();
 232         }
 233     }
 234     SafeArrayUnaccessData( m_array);
 235 };
 236 #endif