Work/com/hold/sarray.hpp

#ifndef _COM_SAFEARRAY_HPP_
#define _COM_SAFEARRAY_HPP_
#ifndef _COMMON_SMARTPOINTER_HPP_
#include <common/pointer.hpp>
#endif
#ifndef _COMMON_ARRAY_HPP_
#include <common/array.hpp>
#endif
#ifndef _COM_RESULT_HPP_
#include <com/result.hpp>
#endif
#ifndef _COM_OLEAUTO_HPP_
#include <com/oleauto.hpp>
#endif
#ifndef _COM_VARIANT_HPP_
#include <com/variant.hpp>
#endif
#ifndef _COM_ARRAYBOUND_HPP_
#include <com/bound.hpp>
#endif

class SafeArrayFeature
{
public:
  enum{Auto=FADF_AUTO,Static=FADF_STATIC,Embedded=FADF_EMBEDDED,FixedSize=FADF_FIXEDSIZE,BString=FADF_BSTR,Unknown=FADF_UNKNOWN,
	     Dispatch=FADF_DISPATCH,Variant=FADF_VARIANT,Reserved=FADF_RESERVED};
};

class SafeArray
{
public:
  class SafeArrayNullPointerException{};
  SafeArray(void);
	virtual ~SafeArray();
	SafeArray &operator=(const SafeArray &safeArray);
  bool create(VariantType varType,Array<ArrayBound> &arrayBounds);
	bool create(VariantType varType,ArrayBound &arrayBounds);
	bool destroy(void);
  long getUpperBound(unsigned int dimension=0);
	long getLowerBound(unsigned int dimension=0);
	UINT getDimensions(void);
	long getLockCount(void);
	bool lock(void);
	bool unlock(void);
	bool accessData(void **ppvData);
	bool unaccessData(void);
	bool setAt(Array<long> &indices,void *pData);
	bool getAt(Array<long> &indices,void *pData);
	UINT getAllocationBytes(void);
  bool getPtrOfIndex(Array<long> &indices,void **ppvData);
	bool isOkay(void)const;
private:
  long getUpperBound(unsigned int dimension,const tagSAFEARRAY &safeArray);
	long getLowerBound(unsigned int dimension,const tagSAFEARRAY &safeArray);

  SmartPointer<SAFEARRAY> mSafeArray;
};

inline
SafeArray::SafeArray(void)
{
}

inline
SafeArray::~SafeArray()
{
  destroy();
}

inline
SafeArray &SafeArray::operator=(const SafeArray &safeArray)
{
  ComResult comResult;

  if(!isOkay())return *this;
	comResult=::SafeArrayCopyData(((SafeArray&)safeArray).mSafeArray,mSafeArray);
	return *this;
}

inline
long SafeArray::getUpperBound(unsigned int dimension)
{
  if(!isOkay())throw SafeArrayNullPointerException();
  return getUpperBound(dimension,*mSafeArray);
}

inline
long SafeArray::getUpperBound(unsigned int dimension,const tagSAFEARRAY &safeArray)
{
  ComResult comResult;
  long upperBound;

  comResult=::SafeArrayGetUBound(&((tagSAFEARRAY&)safeArray),dimension,&upperBound);
	if(!comResult.success())return 0;
	return upperBound;
}

inline
long SafeArray::getLowerBound(unsigned int dimension)
{
  if(!isOkay())throw SafeArrayNullPointerException();
  return getLowerBound(dimension,*mSafeArray);
}

inline
UINT SafeArray::getDimensions(void)
{
  ComResult comResult;

  if(!isOkay())return false;
	comResult=::SafeArrayGetDim(mSafeArray);
	return comResult.success()?true:false;
}

inline
long SafeArray::getLockCount(void)
{
  if(!isOkay())return 0;
	return mSafeArray->cLocks;
}

inline
long SafeArray::getLowerBound(unsigned int dimension,const tagSAFEARRAY &safeArray)
{
  ComResult comResult;
	long lowerBound;

	comResult=::SafeArrayGetLBound(&((tagSAFEARRAY&)safeArray),dimension,&lowerBound);
	if(!comResult.success())return 0;
	return lowerBound;
}

inline
bool SafeArray::accessData(void **ppvData)
{
  ComResult comResult;

  if(!isOkay())return false;
	comResult=::SafeArrayAccessData(mSafeArray,ppvData);
	return comResult.success()?true:false;
}

inline
bool SafeArray::unaccessData(void)
{
  ComResult comResult;

  if(!isOkay())return false;
	comResult=::SafeArrayUnaccessData(mSafeArray);
	return comResult.success()?true:false;
}

inline
bool SafeArray::isOkay(void)const
{
  return mSafeArray.isOkay();
}

inline
bool SafeArray::destroy(void)
{
  ComResult comResult;

  if(!isOkay())return false;
	while(getLockCount())unlock();
	comResult=::SafeArrayDestroy(mSafeArray);
	mSafeArray.destroy();
	if(S_OK==comResult.result())return true;
	return false;
}

inline
bool SafeArray::create(VariantType type,Array<ArrayBound> &arrayBounds)
{
  destroy();
	if(!arrayBounds.size())return false;
	mSafeArray=::SafeArrayCreate(type,arrayBounds.size(),&arrayBounds[0]);
	if(!mSafeArray.isOkay())return false;
	mSafeArray.disposition(PointerDisposition::Assume);
	return true;
}

inline
bool SafeArray::create(VariantType type,ArrayBound &arrayBound)
{
  destroy();
	mSafeArray=::SafeArrayCreate(type,1,&arrayBound);
	if(!mSafeArray.isOkay())return false;
	mSafeArray.disposition(PointerDisposition::Assume);
	return true;
}

inline
bool SafeArray::unlock()
{
  ComResult comResult;

  if(!isOkay())return false;
	comResult=::SafeArrayUnlock(mSafeArray);
	return comResult.success()?true:false;
}

inline
bool SafeArray::lock(void)
{
  ComResult comResult;

  if(!isOkay())return false;
	comResult=::SafeArrayLock(mSafeArray);
	return comResult.success()?true:false;
}

inline
bool SafeArray::setAt(Array<long> &indices,void *pData)
{
  ComResult comResult;

	if(!isOkay())return false;
	comResult=::SafeArrayPutElement(mSafeArray,&indices[0],pData);
	return comResult.success()?true:false;
}

inline
bool SafeArray::getAt(Array<long> &indices,void *pData)
{
  ComResult comResult;

  if(!isOkay())return false;
	comResult=::SafeArrayGetElement(mSafeArray,&indices[0],pData);
	return comResult.success()?true:false;
}

inline
bool SafeArray::getPtrOfIndex(Array<long> &indices,void **ppvData)
{
  ComResult comResult;

	if(!isOkay())return false;
	comResult=::SafeArrayPtrOfIndex(mSafeArray,&indices[0],ppvData);
	return comResult.success()?true:false;
}

inline
UINT SafeArray::getAllocationBytes(void)
{
	if(!isOkay())return false;
	return ::SafeArrayGetElemsize(mSafeArray);
}
#endif