safearray.h

Go to the documentation of this file.

#if !defined(_SAFEARRAY_H)
#define _SAFEARRAY_H
 
#if !defined(_OLE2_H_)
# include <ocf/autodefs.h>
#endif
 
//
// Class VarType
// ~~~~~ ~~~~~~~
// VarType provides OLE interpretations to C++ basic types.
//
template<class T>
class VarType {
  public:
    virtual VARTYPE OLEType() = 0;
};
class VarType {…};
 
template<>
class VarType<bool> {
  public:
    VARTYPE OLEType()
    {
      return VT_BOOL;
    }
    VARTYPE OLEType() {…}
};
class VarType<bool> {…};
 
template<>
class VarType<char> {
  public:
    VARTYPE OLEType()
    {
      return VT_I1;
    }
    VARTYPE OLEType() {…}
};
class VarType<char> {…};
 
template<>
class VarType<double> {
  public:
    VARTYPE OLEType()
    {
      return VT_R8;
    }
    VARTYPE OLEType() {…}
};
class VarType<double> {…};
 
template<>
class VarType<float> {
  public:
    VARTYPE OLEType()
    {
      return VT_R4;
    }
    VARTYPE OLEType() {…}
};
class VarType<float> {…};
 
template<>
class VarType<int> {
  public:
    VARTYPE OLEType()
    {
      return VT_INT;
    }
    VARTYPE OLEType() {…}
};
class VarType<int> {…};
 
template<>
class VarType<long> {
  public:
    VARTYPE OLEType()
    {
      return VT_I4;
    }
    VARTYPE OLEType() {…}
};
class VarType<long> {…};
 
template<>
class VarType<short> {
  public:
    VARTYPE OLEType()
    {
      return VT_I2;
    }
    VARTYPE OLEType() {…}
};
class VarType<short> {…};
 
template<>
class VarType<unsigned char> {
  public:
    VARTYPE OLEType()
    {
      return VT_UI1;
    }
    VARTYPE OLEType() {…}
};
class VarType<unsigned char> {…};
 
template<>
class VarType<unsigned int> {
  public:
    VARTYPE OLEType()
    {
      return VT_UINT;
    }
    VARTYPE OLEType() {…}
};
class VarType<unsigned int> {…};
 
template<>
class VarType<unsigned long> {
  public:
    VARTYPE OLEType()
    {
      return VT_UI4;
    }
    VARTYPE OLEType() {…}
};
class VarType<unsigned long> {…};
 
template<>
class VarType<unsigned short> {
  public:
    VARTYPE OLEType()
    {
      return VT_UI2;
    }
    VARTYPE OLEType() {…}
};
class VarType<unsigned short> {…};
 
//
// Class TSafeArray
// ~~~~~ ~~~~~~~~~~
// TSafeArray encapsulates the properties of OLE's SAFEARRAY and
// provides easy access to individual members of it.
//
template<class T>
class TSafeArray : public TAutoVal {
  public:
    TSafeArray(int n);
   ~TSafeArray();
 
    // Indexing operator
    //
    T& operator[](int index);
};
class TSafeArray : public TAutoVal {…};
 
// TSafeArray inline functions
//
template<class T>
inline
TSafeArray<T>::TSafeArray(int n)
:
 TAutoVal()
{
  SAFEARRAYBOUND bound;
  bound.lLbound   = 0;
  bound.cElements = n;
 
  VARTYPE varType = VarType<T>().OLEType();
 
  ((VARIANT*)this)->vt     = (VARTYPE)(varType | VT_ARRAY);
  ((VARIANT*)this)->parray = ::SafeArrayCreate(varType, 1, &bound);
}
TSafeArray<T>::TSafeArray(int n) {…}
 
template<class T>
inline
TSafeArray<T>::~TSafeArray()
{
  // TAutoVal::~Clear() takes care of freeing the array!
}
TSafeArray<T>::~TSafeArray() {…}
 
template<class T>
T&
TSafeArray<T>::operator[](int index)
{
  T* tmp = (T*)(GetArray()->pvData);
  return tmp[index];
}
TSafeArray<T>::operator[](int index) {…}
 
#endif  // _SAFEARRAY_H