r/sustaining_gazes
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity
sustaining_gazes/lib/local/CamCom/comet/safearray.h

1499 lines
53 KiB
C
Raw Normal View History

GUI initial work (WIP)
2016-05-20 20:48:43 +00:00
/** \file
* SafeArray wrapper implementation.
*/
/*
* Copyright <EFBFBD> 2000, 2001, 2002 Sofus Mortensen, Michael Geddes
* Copyright <EFBFBD> 2012 Alexander Lamaison
*
* This material is provided "as is", with absolutely no warranty
* expressed or implied. Any use is at your own risk. Permission to
* use or copy this software for any purpose is hereby granted without
* fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is
* granted, provided the above notices are retained, and a notice that
* the code was modified is included with the above copyright notice.
*
* This header is part of Comet version 2.
* https://github.com/alamaison/comet
*/
#ifndef COMET_SAFEARRAY_H
#define COMET_SAFEARRAY_H
#include <comet/config.h>
#include <comet/ptr.h>
#include <comet/bstr.h>
#include <comet/variant.h>
#include <comet/static_assert.h>
//#include <comet/util.h>
#include <comet/type_traits.h>
#include <comet/common.h>
#include <comet/uuid.h>
#include <iterator>
#include <limits>
#include <stdexcept>
#ifndef NDEBUG
#define COMET_ITERATOR_DEBUG
#endif
namespace comet {
namespace impl {
template <bool is_class>
struct access_operator
{
// Has operator ->
template <typename T, typename C>
struct base
{
T *operator->()
{
return &(static_cast<C *>(this)->operator*());
}
};
};
// Doesn't have operator->
template<>
struct access_operator<false>
{
template <typename T, typename C>
struct base
{
};
};
template<typename T> struct sa_traits; //Moved to common.h
template<typename T, typename TR> class sa_iterator;
template<typename T> struct const_traits {
typedef T value_type;
typedef typename sa_traits<T>::const_reference reference;
typedef const T* pointer;
};
template<typename T> struct nonconst_traits {
typedef T value_type;
typedef typename sa_traits<T>::reference reference;
typedef T* pointer;
};
template<> struct sa_traits<long> : public basic_sa_traits<long, VT_I4> {};
template<> struct sa_traits<unsigned long> : public basic_sa_traits<unsigned long, VT_UI4> {};
template<> struct sa_traits<short> : public basic_sa_traits<short, VT_I2> {};
template<> struct sa_traits<unsigned short> : public basic_sa_traits<unsigned short, VT_UI2> {};
template<> struct sa_traits<signed char> : public basic_sa_traits<signed char, VT_I1> {};
template<> struct sa_traits<unsigned char> : public basic_sa_traits<unsigned char, VT_UI1> {};
template<> struct sa_traits<char> : public basic_sa_traits<char, VT_I1> {};
template<> struct sa_traits<float> : public basic_sa_traits<float, VT_R4> {};
template<> struct sa_traits<double> : public basic_sa_traits<double, VT_R8> {};
template<> struct sa_traits<variant_t>
{
typedef VARIANT raw;
enum { vt = VT_VARIANT };
enum { check_type = impl::stct_features_ok };
enum { extras_type = stet_null };
typedef variant_t value_type;
typedef variant_t& reference;
typedef const variant_t& const_reference;
static reference create_reference(raw& x) { return *reinterpret_cast<variant_t*>(&x); }
static const_reference create_const_reference(raw& x) { return *reinterpret_cast<const variant_t*>(&x); }
typedef sa_iterator<variant_t, nonconst_traits<variant_t> > iterator;
typedef sa_iterator<variant_t, const_traits<variant_t> > const_iterator;
static bool are_features_ok(unsigned short f) { return (f & FADF_VARIANT) != 0; }
static com_ptr<IRecordInfo> get_record_info() { return 0; }
};
template<> struct sa_traits<bstr_t>
{
enum { vt = VT_BSTR };
enum { check_type = impl::stct_vt_ok };
enum { extras_type = stet_null };
typedef BSTR raw;
typedef bstr_t value_type;
typedef bstr_t& reference;
typedef const bstr_t& const_reference;
static reference create_reference(raw& x) { return *reinterpret_cast<bstr_t*>(&x); }
static const_reference create_const_reference(raw& x) { return *reinterpret_cast<const bstr_t*>(&x); }
typedef sa_iterator<bstr_t, nonconst_traits<bstr_t> > iterator;
typedef sa_iterator<bstr_t, const_traits<bstr_t> > const_iterator;
static bool are_features_ok(unsigned short f) { return (f & FADF_BSTR) != 0; }
static com_ptr<IRecordInfo> get_record_info() { return 0; }
};
template<> struct sa_traits<currency_t>
{
enum { vt = VT_CY };
enum { check_type = impl::stct_vt_ok };
enum { extras_type = impl::stet_null };
typedef CY raw;
typedef currency_t value_type;
typedef currency_t& reference;
typedef const currency_t& const_reference;
static reference create_reference(raw& x) { return *reinterpret_cast<currency_t*>(&x); }
static const_reference create_const_reference(raw& x) { return *reinterpret_cast<const currency_t*>(&x); }
typedef sa_iterator<currency_t, nonconst_traits<currency_t> > iterator;
typedef sa_iterator<currency_t, const_traits<currency_t> > const_iterator;
static bool are_features_ok(unsigned short) { return true; }
static com_ptr<IRecordInfo> get_record_info() { return 0; }
};
template<> struct sa_traits<datetime_t>
{
enum { vt = VT_DATE };
enum { check_type = impl::stct_vt_ok };
enum { extras_type = impl::stet_null };
typedef DATE raw;
typedef datetime_t value_type;
typedef datetime_t& reference;
typedef const datetime_t& const_reference;
static reference create_reference(raw& x) { return *reinterpret_cast<datetime_t*>(&x); }
static const_reference create_const_reference(raw& x) { return *reinterpret_cast<const datetime_t*>(&x); }
typedef sa_iterator<datetime_t, nonconst_traits<datetime_t> > iterator;
typedef sa_iterator<datetime_t, const_traits<datetime_t> > const_iterator;
static bool are_features_ok(unsigned short) { return true; }
static com_ptr<IRecordInfo> get_record_info() { return 0; }
};
template<> struct sa_traits<variant_bool_t>
{
enum { vt = VT_BOOL };
enum { check_type = impl::stct_vt_ok };
enum { extras_type = impl::stet_null };
typedef VARIANT_BOOL raw;
typedef variant_bool_t value_type;
typedef variant_bool_t& reference;
typedef const variant_bool_t& const_reference;
static reference create_reference(raw& x) { return *reinterpret_cast<variant_bool_t*>(&x); }
static const_reference create_const_reference(raw& x) { return *reinterpret_cast<const variant_bool_t*>(&x); }
typedef sa_iterator<variant_bool_t, nonconst_traits<variant_bool_t> > iterator;
typedef sa_iterator<variant_bool_t, const_traits<variant_bool_t> > const_iterator;
static bool are_features_ok(unsigned short) { return true; }
static com_ptr<IRecordInfo> get_record_info() { return 0; }
};
template<> struct sa_traits<bool>: sa_traits<variant_bool_t>
{
};
template<> struct sa_traits< com_ptr< ::IUnknown> >
{
enum { vt = VT_UNKNOWN };
enum { check_type = impl::stct_vt_ok };
enum { extras_type = impl::stet_iid };
typedef IUnknown* raw;
typedef com_ptr< ::IUnknown> value_type;
typedef com_ptr< ::IUnknown>& reference;
typedef const com_ptr< ::IUnknown>& const_reference;
static reference create_reference(raw& x) { return *reinterpret_cast<com_ptr< ::IUnknown>*>(&x); }
static const_reference create_const_reference(raw& x) { return *reinterpret_cast<const com_ptr< ::IUnknown>*>(&x); }
typedef sa_iterator<com_ptr< ::IUnknown >, nonconst_traits<com_ptr< ::IUnknown > > > iterator;
typedef sa_iterator<com_ptr< ::IUnknown >, const_traits<com_ptr< ::IUnknown > > > const_iterator;
static bool are_features_ok(unsigned short f) { return (f & (FADF_UNKNOWN|FADF_DISPATCH)) != 0; }
static com_ptr<IRecordInfo> get_record_info() { return 0; }
static const uuid_t& iid() { return uuid_t::create_const_reference(IID_IUnknown); }
};
template<> struct sa_traits< com_ptr< ::IDispatch> >
{
enum { vt = VT_DISPATCH };
enum { check_type = impl::stct_vt_ok };
enum { extras_type = impl::stet_iid };
typedef IDispatch* raw;
typedef com_ptr< ::IDispatch> value_type;
typedef com_ptr< ::IDispatch>& reference;
typedef const com_ptr< ::IDispatch>& const_reference;
static reference create_reference(raw& x) { return *reinterpret_cast<com_ptr< ::IDispatch>*>(&x); }
static const_reference create_const_reference(raw& x) { return *reinterpret_cast<const com_ptr< ::IDispatch>*>(&x); }
typedef sa_iterator<com_ptr< ::IDispatch>, nonconst_traits<com_ptr< ::IDispatch> > > iterator;
typedef sa_iterator<com_ptr< ::IDispatch>, const_traits<com_ptr< ::IDispatch> > > const_iterator;
static bool are_features_ok(unsigned short f) { return (f & FADF_DISPATCH) != 0; }
static com_ptr<IRecordInfo> get_record_info() { return 0; }
static const uuid_t& iid() { return uuid_t::create_const_reference(IID_IDispatch); }
};
#ifdef COMET_ITERATOR_DEBUG
#define COMET_SAIT_THIS ,this
#define COMET_SAIT_ITER(CONT_, IT_, TRAITS_) impl::sa_debug_iterator<CONT_, TRAITS_ >
template<typename TRAITS>
struct sa_debug_traits
{
typedef TRAITS traits;
typedef typename TRAITS::value_type value_type;
typedef typename TRAITS::raw raw;
typedef typename TRAITS::reference reference;
typedef typename TRAITS::iterator nonconst_iterator;
typedef typename TRAITS::iterator iterator;
typedef typename TRAITS::const_iterator const_iterator;
};
template<typename TRAITS>
struct sa_const_debug_traits
{
typedef TRAITS traits;
typedef typename TRAITS::value_type value_type;
typedef typename TRAITS::raw raw;
typedef typename TRAITS::const_reference reference;
typedef typename TRAITS::iterator nonconst_iterator;
typedef typename TRAITS::const_iterator iterator;
typedef typename TRAITS::const_iterator const_iterator;
};
template< typename CONT, typename TRAITS>
class sa_debug_iterator : public std::iterator<std::random_access_iterator_tag, typename TRAITS::value_type>,
public access_operator<type_traits::is_class_pointer<typename TRAITS::value_type>::result>::template base<typename TRAITS::raw, sa_debug_iterator<CONT,TRAITS> >
{
public:
const CONT *cont_;
typename TRAITS::iterator iter_;
template<typename IT>
sa_debug_iterator(IT ptr, const CONT *cont) : iter_(ptr), cont_(cont) {}
sa_debug_iterator( const sa_debug_iterator<CONT, impl::sa_debug_traits<typename TRAITS::traits> > &nc_it ) : iter_(nc_it.iter_), cont_(nc_it.cont_) {}
sa_debug_iterator(): cont_(NULL) {}
typename TRAITS::iterator get_raw()const { return iter_; }
typename TRAITS::const_iterator get_const_raw()const { return iter_; }
sa_debug_iterator operator++(int) {
COMET_ASSERT( cont_!=NULL);
COMET_ASSERT( get_const_raw() < cont_->end().get_raw() );
sa_debug_iterator t(*this);
++iter_;
return t;
}
sa_debug_iterator& operator++() {
COMET_ASSERT( cont_!=NULL);
COMET_ASSERT( get_const_raw() < cont_->end().get_raw() );
++iter_;
return *this;
}
sa_debug_iterator operator--(int) {
COMET_ASSERT( cont_!=NULL);
COMET_ASSERT( get_const_raw() > cont_->begin().get_raw() );
sa_debug_iterator t(*this);
--iter_;
return t;
}
sa_debug_iterator& operator--() {
COMET_ASSERT( cont_!=NULL);
COMET_ASSERT( get_const_raw() > cont_->begin().get_raw() );
--iter_;
return *this;
}
typename TRAITS::reference operator[](size_t n) {
COMET_ASSERT( cont_!=NULL);
COMET_ASSERT( (get_const_raw()+ n) >= cont_->begin().get_raw());
COMET_ASSERT( (get_const_raw()+n) < cont_->end().get_raw() );
return iter_[n];
}
sa_debug_iterator& operator+=(size_t n) {
COMET_ASSERT(cont_!=NULL);
COMET_ASSERT((get_const_raw()+ n) >= cont_->begin().get_raw());
COMET_ASSERT((get_const_raw()+n) <= cont_->end().get_raw() );
iter_ += n;
return *this;
}
sa_debug_iterator& operator-=(size_t n) {
COMET_ASSERT( cont_!=NULL);
COMET_ASSERT( (get_const_raw()- n) >= cont_->begin().get_raw());
COMET_ASSERT( (get_const_raw()- n) <= cont_->end().get_raw() );
iter_ -= n;
return *this;
}
ptrdiff_t operator-(const sa_debug_iterator& it) const {
COMET_ASSERT( cont_!=NULL);
COMET_ASSERT( cont_ == it.cont_);
return iter_ - it.iter_;
}
bool operator<(const sa_debug_iterator& it) const {
COMET_ASSERT( cont_!=NULL);
COMET_ASSERT( cont_ == it.cont_);
return iter_ < it.iter_;
}
bool operator>(const sa_debug_iterator& it) const {
COMET_ASSERT( cont_!=NULL);
COMET_ASSERT( cont_ == it.cont_);
return iter_ > it.iter_;
}
bool operator<=(const sa_debug_iterator& it) const {
COMET_ASSERT( cont_!=NULL);
COMET_ASSERT( cont_ == it.cont_);
return iter_ <= it.iter_;
}
bool operator>=(const sa_debug_iterator& it) const {
COMET_ASSERT( cont_!=NULL);
COMET_ASSERT( cont_ == it.cont_);
return iter_ >= it.iter_;
}
bool operator==(const sa_debug_iterator& it) const {
COMET_ASSERT( cont_!=NULL);
COMET_ASSERT( cont_ == it.cont_);
return iter_ == it.iter_;
}
bool operator!=(const sa_debug_iterator& it) const {
COMET_ASSERT( cont_!=NULL);
COMET_ASSERT( cont_ == it.cont_);
return iter_ != it.iter_;
}
sa_debug_iterator operator+(size_t n) const {
COMET_ASSERT( cont_!=NULL);
COMET_ASSERT( (get_const_raw() + n) >= cont_->begin().get_raw());
COMET_ASSERT( (get_const_raw() + n) <= cont_->end().get_raw() );
return sa_debug_iterator( iter_+n, cont_);
}
sa_debug_iterator operator-(size_t n) const {
COMET_ASSERT( cont_!=NULL);
COMET_ASSERT( (get_const_raw() - n) >= cont_->begin().get_raw());
COMET_ASSERT( (get_const_raw() - n) <= cont_->end().get_raw() );
return sa_debug_iterator( iter_-n, cont_);
}
typename TRAITS::reference operator*() {
COMET_ASSERT( cont_ != NULL);
COMET_ASSERT( (get_const_raw()) >= cont_->begin().get_raw());
COMET_ASSERT( (get_const_raw()) < cont_->end().get_raw() );
return *iter_;
}
};
#else // COMET_ITERATOR_DEBUG
#define COMET_IT_DBG__(x)
#define COMET_SAIT_THIS
#define COMET_SAIT_ITER(CONT_, IT_, TRAITS_) IT_
#endif // COMET_ITERATOR_DEBUG
/** \internal
*/
template<typename T, typename TR> class sa_iterator : public std::iterator<std::random_access_iterator_tag, typename TR::value_type>,
public access_operator<type_traits::is_class_pointer<T>::result>::template base< T, sa_iterator<T,TR> >
{
typedef sa_iterator<T, nonconst_traits<T> > nonconst_self;
public:
typedef sa_traits<T> traits;
typename traits::raw* ptr_;
typedef typename TR::pointer pointer;
typedef typename TR::reference reference;
typedef ptrdiff_t difference_type;
sa_iterator(const nonconst_self& it )
: ptr_(it.get_raw())
{}
explicit sa_iterator(typename traits::raw* ptr) : ptr_(ptr) {}
sa_iterator() {}
typename traits::raw* get_raw() const
{
return ptr_;
}
sa_iterator operator++(int) {
sa_iterator t(*this);
++ptr_;
return t;
}
sa_iterator& operator++() {
++ptr_;
return *this;
}
sa_iterator operator--(int) {
sa_iterator t(*this);
--ptr_;
return t;
}
sa_iterator& operator--() {
--ptr_;
return *this;
}
reference operator[](size_t n) {
return traits::create_reference(ptr_[n]);
}
sa_iterator& operator+=(size_t n) {
ptr_ += n;
return *this;
}
sa_iterator& operator-=(size_t n) {
ptr_ -= n;
return *this;
}
difference_type operator-(const sa_iterator& it) const {
return ptr_ - it.ptr_;
}
bool operator<(const sa_iterator& it) const {
return ptr_ < it.ptr_;
}
bool operator>(const sa_iterator& it) const {
return ptr_ > it.ptr_;
}
bool operator<=(const sa_iterator& it) const {
return ptr_ <= it.ptr_;
}
bool operator>=(const sa_iterator& it) const {
return ptr_ >= it.ptr_;
}
bool operator==(const sa_iterator& it) const {
return ptr_ == it.ptr_;
}
bool operator!=(const sa_iterator& it) const {
return ptr_ != it.ptr_;
}
sa_iterator operator+(size_t n) const {
return sa_iterator(ptr_ + n);
}
sa_iterator operator-(size_t n) const {
return sa_iterator(ptr_ - n);
}
template<typename T2, typename TR2> friend sa_iterator<T2, TR2> operator+(size_t n, const sa_iterator<T2, TR2>& it);
// friend sa_iterator operator+(size_t n, const sa_iterator&);
reference operator*() { return traits::create_reference(*ptr_); }
};
}
namespace impl
{
template <typename T>
class safearray_auto_ref_t;
template <typename T>
class safearray_auto_const_ref_t;
};
/*! \addtogroup COMType
*/
//@{
/**STL container compatible wrapper for a safearray.
* Provides forwards and reverse iterators.
*/
#ifdef COMET_PARTIAL_SPECIALISATION
template<typename T,enum impl::sa_traits_extras_type STET>
struct get_extras
{
static void *extras(){ return 0; }
};
template<typename T>
struct get_extras<T,impl::stet_record>
{
static void *extras(){ return impl::sa_traits<T>::get_record_info().in(); }
};
template<typename T>
struct get_extras<T,impl::stet_iid>
{
static void *extras(){ return impl::sa_traits<T>::iid().in_ptr(); }
};
template<typename T,enum impl::sa_traits_check_type STCT >
struct traits_sanity_check
{ static inline void check( const SAFEARRAY *psa) { } };
template<typename T>
struct traits_sanity_check<T,impl::stct_vt_ok>
{
static void check(SAFEARRAY *psa) {
if ((psa->fFeatures & FADF_HAVEVARTYPE)!=0)
{
VARTYPE vt;
::SafeArrayGetVartype(psa, &vt) | raise_exception ;
if(vt != impl::sa_traits<T>::vt)
throw std::runtime_error("safearray_t: VarType mismatch");
}
}
};
template<typename T>
struct traits_sanity_check<T,impl::stct_iid_ok> {
static void check(SAFEARRAY *psa)
{
uuid_t iid;
::SafeArrayGetIID(psa, &iid) | raise_exception;
if( iid != impl::sa_traits<T>::iid() )
throw std::runtime_error("safearray_t: IID mismatch");
}
};
#endif
template<typename T> class safearray_t
{
public:
typedef impl::sa_traits<T> traits;
typedef size_t size_type; ///< type for sizes (bounds etc).
typedef long index_type; ///< Type for indexing into the array
typedef ptrdiff_t difference_type; ///< Type for pointer differences
typedef typename traits::value_type value_type; ///< The type of the contained value .
typedef typename traits::reference reference; ///< Safearray reference type
typedef typename traits::const_reference const_reference; ///< Safearray const reference type
typedef typename COMET_SAIT_ITER( safearray_t, traits::iterator, impl::sa_debug_traits<traits> )
iterator; ///< Iterator type
typedef typename COMET_SAIT_ITER( safearray_t, traits::const_iterator, impl::sa_const_debug_traits<traits>)
const_iterator; ///< Const iterator type
#if defined(COMET_STD_ITERATOR)
typedef std::reverse_iterator<iterator> reverse_iterator;
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
#else
// workaround for broken reverse_iterator implementations due to no partial specialisation
typedef std::reverse_iterator<iterator,T> reverse_iterator;
typedef std::reverse_iterator<const_iterator,T> const_reverse_iterator;
#endif
//! \name Iterator functions
//@{
iterator begin() {
return iterator(get_array() COMET_SAIT_THIS );
}
iterator end() {
return iterator(get_array() + size() COMET_SAIT_THIS );
}
const_iterator begin() const {
return const_iterator(get_array() COMET_SAIT_THIS) ;
}
const_iterator end() const {
return const_iterator(get_array() + size() COMET_SAIT_THIS );
}
reverse_iterator rbegin() {
return reverse_iterator(end());
}
reverse_iterator rend() {
return reverse_iterator(begin());
}
const_reverse_iterator rbegin() const {
return const_reverse_iterator(end());
}
const_reverse_iterator rend() const {
return const_reverse_iterator(begin());
}
//@}
/// The number of elements in the array.
size_type size() const {
return psa_ ? psa_->rgsabound[0].cElements : 0;
}
/// Returns whether the array is empty.
bool is_empty() const {
return size() == 0;
}
/// Returns element n relative to lower_bound()
reference operator[](index_type n) {
COMET_ASSERT( (size_type)(n - lower_bound()) < size() );
return traits::create_reference(get_element(n));
}
/// Returns const element n relative to lower_bound()
const_reference operator[](index_type n) const {
COMET_ASSERT( (size_type)(n - lower_bound()) < size() );
return traits::create_reference(get_element(n));
}
//! Returns element n relative to lower_bound().
/*! \throw out_of_range The index is out of range.
*/
reference at(index_type n) {
range_check(n);
return traits::create_reference(get_element(n));
}
//! Returns const element n relative to lower_bound().
/*! \throw out_of_range The index is out of range.
*/
const_reference at(index_type n) const {
range_check(n);
return traits::create_reference(get_element(n));
}
//! The front element.
reference front() { return *begin(); }
//! The front element - const.
const_reference front() const { return *begin(); }
//! The back element.
reference back() { return *(end() - 1); }
//! The back element - const.
const_reference back() const { return *(end() - 1); }
private:
#ifndef COMET_PARTIAL_SPECIALISATION
template<enum impl::sa_traits_extras_type STET>
struct get_extras
{
static void *extras(){ return 0; }
};
template<>
struct get_extras<impl::stet_record>
{
static void *extras(){ return impl::sa_traits<T>::get_record_info().in(); }
};
template<>
struct get_extras<impl::stet_iid>
{
static void *extras(){ return impl::sa_traits<T>::iid().in_ptr(); }
};
#endif
public:
/// \name Constructors
//@{
/// Construct a null array.
safearray_t() : psa_(0)
{}
/*! Attach to (and take ownership of) an existing array.
\code
SAFEARRAY *psa = SafeArrayCreateVectorEx(VT_BSTR, 0, 5, NULL);
safearray_t<bstr_t> sa(auto_attach(psa));
\endcode
*/
safearray_t(const impl::auto_attach_t<SAFEARRAY*>& psa) : psa_(psa.get())
{
sanity_check(psa_);
if (psa_) try {
::SafeArrayLock(psa_) | raise_exception;
} catch (...)
{
::SafeArrayDestroy(psa_);
throw;
}
}
/// Copy from a variant, making converting if necessary.
safearray_t(const variant_t& var)
{
if(var.get_vt() == (VT_ARRAY|traits::vt))
{
SafeArrayCopy(var.in().parray, &psa_) | raise_exception;
} else {
variant_t v2(var, VT_ARRAY|traits::vt);
SafeArrayCopy(v2.in().parray, &psa_) | raise_exception;
}
if (psa_) try {
::SafeArrayLock(psa_) | raise_exception;
} catch (...)
{
::SafeArrayDestroy(psa_);
throw;
}
}
/// Copy construction
safearray_t(const safearray_t& sa)
{
::SafeArrayCopy(sa.psa_, &psa_) | raise_exception;
if (psa_) try {
::SafeArrayLock(psa_) | raise_exception;
} catch (...)
{
::SafeArrayDestroy(psa_);
throw;
}
}
/// Construct a new safearray vector.
/*! \param sz Size of the vector.
* \param lb Lower bound for the vector.
*/
explicit safearray_t(size_type sz, index_type lb)
{
if (sz > (std::numeric_limits<ULONG>::max)() ||
sz < (std::numeric_limits<ULONG>::min)())
throw std::overflow_error(
"Cannot create array of requested size");
#ifndef COMET_PARTIAL_SPECIALISATION
psa_ = ::SafeArrayCreateVectorEx(
traits::vt, lb, static_cast<ULONG>(sz),
get_extras<impl::sa_traits_extras_type(traits::extras_type)>::extras());
#else
psa_ = ::SafeArrayCreateVectorEx(
traits::vt, lb, static_cast<ULONG>(sz),
get_extras<T,impl::sa_traits_extras_type(traits::extras_type)>::extras());
#endif
if (psa_ == 0) throw std::bad_alloc();
try {
::SafeArrayLock(psa_) | raise_exception;
} catch (...)
{
::SafeArrayDestroy(psa_);
throw;
}
}
/// Construct a new safearray vector.
/*! \param sz Size of the vector.
* \param lb Lower bound for the vector.
* \param val Initial value for the elements.
*/
safearray_t(size_type sz, index_type lb, const T& val)
{
#ifndef COMET_PARTIAL_SPECIALISATION
psa_ = ::SafeArrayCreateVectorEx(traits::vt, lb, sz, get_extras<impl::sa_traits_extras_type(traits::extras_type)>::extras());
#else
psa_ = ::SafeArrayCreateVectorEx(traits::vt, lb, sz, get_extras<T,impl::sa_traits_extras_type(traits::extras_type)>::extras());
#endif // COMET_PARTIAL_SPECIALISATION
if (psa_ == 0) throw std::bad_alloc();
try {
::SafeArrayLock(psa_) | raise_exception;
for (iterator it = begin(); it != end(); ++it) *it = val;
} catch (...) {
::SafeArrayUnlock(psa_);
::SafeArrayDestroy(psa_);
throw;
}
}
/// Construct a safearray from an iterator, specifying the lower bound.
/** \param first First element of the container.
* \param last Beyond the last element of the container.
* \param lb Lower bound of the new safearray_t.
*/
template<typename InputIterator> safearray_t(InputIterator first, InputIterator last, index_type lb)
{
initialise_aux(first, last, lb, type_traits::int_holder< type_traits::is_integer<InputIterator>::result >());
}
//@}
private:
template<typename InputIterator> void initialise_aux(InputIterator first, InputIterator last, index_type lb, type_traits::int_holder<false>)
{
size_type sz = std::distance(first, last);
#ifndef COMET_PARTIAL_SPECIALISATION
psa_ = ::SafeArrayCreateVectorEx(traits::vt, lb, sz,get_extras<impl::sa_traits_extras_type(traits::extras_type)>::extras());
#else
psa_ = ::SafeArrayCreateVectorEx(traits::vt, lb, sz,get_extras<T,impl::sa_traits_extras_type(traits::extras_type)>::extras());
#endif //COMET_PARTIAL_SPECIALISATION
if (psa_ == 0) throw std::bad_alloc();
try {
::SafeArrayLock(psa_) | raise_exception;
for (iterator it = begin(); first != last; ++first, ++it) {
*it = *first;
}
} catch (...) {
::SafeArrayUnlock(psa_);
::SafeArrayDestroy(psa_);
throw;
}
}
template<typename Integer> void initialise_aux(Integer sz, Integer lb, index_type dummy, type_traits::int_holder<true>)
{
#ifndef COMET_PARTIAL_SPECIALISATION
psa_ = ::SafeArrayCreateVectorEx(traits::vt, lb, sz,get_extras<impl::sa_traits_extras_type(traits::extras_type)>::extras());
#else
psa_ = ::SafeArrayCreateVectorEx(traits::vt, lb, sz,get_extras<T,impl::sa_traits_extras_type(traits::extras_type)>::extras());
#endif // COMET_PARTIAL_SPECIALISATION
if (psa_ == 0) throw std::bad_alloc();
::SafeArrayLock(psa_) | raise_exception;
}
public:
/// Resize the array, preserving lower_bound
/** If the array is null, uses 0.
*/
void resize(size_type n)
{
resize_bound(n, (psa_==NULL)?0:lower_bound());
}
/// Resize the array, specifying the lower_bound
// This has been renamed to prevent ambiguous functions when T = size_type
void resize_bound(size_type n, size_type lb)
{
safearray_t t(n, lb);
iterator i1 = begin();
iterator i2 = t.begin();
for (;i1 != end() && i2 != t.end(); ++i1, ++i2) {
std::swap(*i1, *i2);
}
swap(t);
}
/** Resize the array, preserving lower_bound and specifying an initial
* value for uninitialised values.
*/
void resize( size_type n, const T& val) {
resize_bound(n,(psa_==NULL)?0:lower_bound(),val);
}
/** Resize the array, specifying lower_bound and specifying an initial
* value for uninitialised values.
*/
void resize_bound(size_type n, size_type lb, const T& val) {
safearray_t t(n, lb);
iterator i1 = begin();
iterator i2 = t.begin();
for (;i1 != end() && i2 != t.end(); ++i1, ++i2) {
std::swap(*i1, *i2);
}
for (;i2 != t.end(); ++i2) *i2 = val;
swap(t);
}
/// Assign the safearray to be \p v elements of \p val.
void assign(size_type n, const T& val) {
safearray_t t(n, lower_bound(), val);
swap(t);
}
/// Assign the safearray from a f \p first and \p last iterators.
template<typename InputIterator> void assign(InputIterator first, InputIterator last) {
assign_aux(first, last, type_traits::int_holder< type_traits::is_integer<InputIterator>::result >());
}
/** Return the IRecordInfo struct for the array for VT_RECORD.
*/
com_ptr<IRecordInfo> get_record_info()
{
com_ptr<IRecordInfo> rec_info;
::SafeArrayGetRecordInfo(psa_, rec_info.out()) | raise_exception;
return rec_info;
}
/** Get the Variant Type of the members of the array.
*/
VARTYPE get_vt()
{
// Something appears broken in SafeArrayGetVartype - returning VT_UNKNOWN when it has FADF_DISPATCH set.
if (psa_->fFeatures & FADF_DISPATCH) return VT_DISPATCH;
if (psa_->fFeatures & FADF_UNKNOWN) return VT_UNKNOWN;
VARTYPE retval;
::SafeArrayGetVartype(psa_, &retval) | raise_exception;
return retval;
}
/** Return interface-id of the members of the array.
*/
uuid_t get_iid()
{
uuid_t iid;
::SafeArrayGetIID(psa_, &iid) | raise_exception;
return iid;
}
private:
template<typename InputIterator> void assign_aux(InputIterator first, InputIterator last, type_traits::int_holder<false>)
{
safearray_t t( first, last, lower_bound() );
swap(t);
}
template<typename Integer> void assign_aux(Integer sz, const T& val, type_traits::int_holder<true>)
{
safearray_t t(sz, lower_bound(), val);
swap(t);
}
public:
/// Insert \p n elements of \p val at position \p pos.
void insert(iterator pos, size_type n, const T& val) {
safearray_t t(n+size(), lower_bound());
iterator i1 = t.begin();
iterator i2 = begin();
for (;i2 != pos; ++i1, ++i2) *i1 = *i2;
for (;n>0;--n, ++i1) *i1 = val;
for (;i2 != end(); ++i1, ++i2) *i1 = *i2;
swap(t);
}
/// Insert elements coppied from iterator \p first to \p last at position pos.
template<typename InputIterator> void insert(iterator pos, InputIterator first, InputIterator last) {
insert_aux(pos, first, last, type_traits::int_holder<type_traits::is_integer<InputIterator>::result >());
}
/// Push an element to the back of the list (ensure lower-bound);
void push_back( const T& val, index_type lb )
{
safearray_t t(size()+1, lb);
iterator i1 = begin(), i2 = t.begin();
for (;i1 != end() ; ++i1, ++i2)
std::swap(*i1, *i2);
*i2 = val;
swap(t);
}
/// Push an element to the back of the list.
inline void push_back( const T& val)
{
push_back(val, lower_bound());
}
/// Pop an element from the back of the list.
inline void pop_back()
{
size_type lastone = size();
if (lastone > 0)
erase(begin()+(lastone-1));
}
/// Push an element to the front of the list (ensure lower-bound).
void push_front( const T &val, index_type lb)
{
safearray_t t(size()+1, lb);
iterator i1 = begin(), i2 = t.begin();
*i2 = val;
for (++i2; i1 != end(); ++i1, ++i2)
std::swap(*i1, *i2);
swap(t);
}
/// Push an element to the front of the list.
inline void push_front( const T &val)
{
push_front(val, lower_bound());
}
/// Pop an element from the front of the list.
inline void pop_front()
{
erase(begin());
}
/// Erase a specified item.
/** \param it Item to erase
* \return Item beyond erased item.
*/
iterator erase(iterator it)
{
if (it == end())
return end();
size_type where= it-begin();
safearray_t t(size()-1, lower_bound());
iterator ret = t.end();
iterator i1 = begin(), i2 = t.begin();
// Copy up to iterator
for (; i1 != end() && i1 != it; ++i1, ++i2)
std::swap(*i1,*i2);
++i1;// Skip this one
for (; i1 != end(); ++i1, ++i2)
std::swap(*i1,*i2);
swap(t);
return begin()+where;
}
/// Erase a range of items.
/** \param first Item to erase from
* \param second Item after range to be erased.
* \return Item beyond erased range.
*/
iterator erase(iterator first, iterator second)
{
safearray_t t(size()-(second-first), lower_bound());
size_type where= first-begin();
iterator i1 = begin(), i2 = t.begin();
// Copy up to first.
for (; i1 != end() && i1 != first; ++i1, ++i2)
std::swap(*i1,*i2);
// Skip up to second
for( ; i1 != second; ++i1)
;
// skip to end.
for (; i1 != end(); ++i1, ++i2)
std::swap(*i1,*i2);
swap(t);
return begin()+where;
}
private:
template<typename InputIterator> void insert_aux(iterator pos, InputIterator first, InputIterator last, type_traits::int_holder<false>) {
size_type n = std::distance(first, last);
safearray_t t(n+size(), lower_bound());
iterator i1 = t.begin();
iterator i2 = begin();
for (;i2 != pos; ++i1, ++i2) *i1 = *i2;
for (;first != last; ++i1, ++first) *i1 = *first;
for (;i2 != end(); ++i1, ++i2) *i1 = *i2;
swap(t);
}
template<typename Integer> void insert_aux(iterator pos, Integer n, const T& val, type_traits::int_holder<true>) {
safearray_t t(n+size(), lower_bound());
iterator i1 = t.begin();
iterator i2 = begin();
for (;i2 != pos; ++i1, ++i2) *i1 = *i2;
for (;n>0;--n, ++i1) *i1 = val;
for (;i2 != end(); ++i1, ++i2) *i1 = *i2;
swap(t);
}
public:
//! \name Assignment Operators
//@{
safearray_t& operator=(const safearray_t& sa)
{
safearray_t t(sa);
swap(t);
return *this;
}
safearray_t& operator=(const variant_t& v)
{
safearray_t t(v);
swap(t);
return *this;
}
safearray_t& operator=(const impl::auto_attach_t<SAFEARRAY*>& sa)
{
safearray_t t(sa);
swap(t);
return *this;
}
//@}
private:
void destroy() {
if (psa_ != 0) {
COMET_ASSERT(psa_->cLocks == 1);
::SafeArrayUnlock(psa_);
::SafeArrayDestroy(psa_);
psa_ = 0;
}
}
public:
~safearray_t() {
destroy();
}
/// Unlock and detach a raw SAFEARRAY.
SAFEARRAY* detach() {
if (psa_) {
::SafeArrayUnlock(psa_);
}
SAFEARRAY* rv = psa_;
psa_ = 0;
return rv;
}
/*! Detach the safearray to the variant \p var.
The safearray becomes invalid after this point.
\code
safe_array_t<int> ints(2,0);
variant_t var;
ints.detach_to(var);
\endcode
*/
void detach_to( variant_t &var)
{
COMET_ASSERT(psa_->cLocks == 1);
if (psa_) ::SafeArrayUnlock(psa_) | raise_exception;
var = auto_attach( psa_ );
psa_= 0;
}
/*! Detach a safearray from the variant \p var.
An attempt is made to cast the type of the variant before attaching.
*/
void detach_from( variant_t &var)
{
if(var.get_vt()!=(VT_ARRAY|traits::vt))
{
var.change_type(VT_ARRAY|traits::vt);
}
safearray_t t(auto_attach(var.detach().parray));
swap(t);
}
/// The lower bound of the array.
/** \sa get_at
*/
index_type lower_bound() const {
return psa_ ? psa_->rgsabound[0].lLbound : 0;
}
/// Change the lower_bound of the array.
void lower_bound(index_type lb) {
psa_->rgsabound[0].lLbound = lb;
}
private:
class sa_auto_lock_t
{
SAFEARRAY** ppsa_;
// These are not available
sa_auto_lock_t();
sa_auto_lock_t(const sa_auto_lock_t&);
sa_auto_lock_t& operator=(const sa_auto_lock_t&);
public:
operator SAFEARRAY**() throw() { return ppsa_; }
sa_auto_lock_t(SAFEARRAY** ppsa) : ppsa_(ppsa) {}
~sa_auto_lock_t()
{
if (*ppsa_) {
HRESULT hr = ::SafeArrayLock(*ppsa_);
COMET_ASSERT( SUCCEEDED(hr) );
hr;
}
}
};
public:
//! \name Access converters
//@{
SAFEARRAY* in() const throw() {
return const_cast<SAFEARRAY*>(psa_);
}
SAFEARRAY** in_ptr() const throw() {
return const_cast<SAFEARRAY**>(&psa_);
}
sa_auto_lock_t inout() throw() {
if (psa_) {
::SafeArrayUnlock(psa_);
}
return &psa_;
}
sa_auto_lock_t out() throw() {
destroy();
return &psa_;
}
//@}
/*! Detach a raw SAFEARRAY pointer from a safearray_t.
*/
static SAFEARRAY* detach(safearray_t& sa)
{
return sa.detach();
}
/** Create a reference to a safearray from a raw SAFEARRAY pointer.
* Mainly used by the implementation wrappers.
*/
static const impl::safearray_auto_const_ref_t<T> create_const_reference(SAFEARRAY* const & sa);
static impl::safearray_auto_ref_t<T> create_reference(SAFEARRAY* & sa);
/** Create a reference to a safearray from a variant.
\code
function( const variant_t &var)
{
const safe_array<bstr_t> &stringarray = safe_array<bstr_t>::create_reference( var );
}
\endcode
*/
static const impl::safearray_auto_const_ref_t<T> create_const_reference(const variant_t &var);
/** Create c const reference to a safearray from a variant.
*/
static impl::safearray_auto_ref_t<T> create_reference(variant_t &var);
void swap(safearray_t& sa) throw()
{
std::swap(psa_, sa.psa_);
}
private:
void range_check(index_type n) const {
size_type m = (size_type)(n - lower_bound());
if (/*m < 0 || */ m >= size()) throw std::out_of_range("safearray_t");
}
typename traits::raw* get_array() const {
if (psa_) {
COMET_ASSERT(psa_->cLocks != 0);
return static_cast<typename traits::raw*>(psa_->pvData);
}
return NULL;
}
typename traits::raw& get_element(size_type n) const {
return get_array()[n - lower_bound()];
}
protected:
SAFEARRAY* psa_;
#ifndef COMET_PARTIAL_SPECIALISATION
template< enum impl::sa_traits_check_type STCT >
struct traits_sanity_check
{ static inline void check( const SAFEARRAY *psa) { } };
template<>
struct traits_sanity_check<impl::stct_vt_ok>
{
static void check(SAFEARRAY *psa) {
if ((psa->fFeatures & FADF_HAVEVARTYPE)!=0)
{
VARTYPE vt;
::SafeArrayGetVartype(psa, &vt) | raise_exception ;
if(vt != impl::sa_traits<T>::vt)
throw std::runtime_error("safearray_t: VarType mismatch");
}
}
};
template<>
struct traits_sanity_check<impl::stct_iid_ok> {
static void check(SAFEARRAY *psa)
{
uuid_t iid;
::SafeArrayGetIID(psa, &iid) | raise_exception;
if( iid != impl::sa_traits<T>::iid() )
throw std::runtime_error("safearray_t: IID mismatch");
}
};
#endif
/// Make sure the passed in safearray agrees with the type of the safearray_t
static void sanity_check(SAFEARRAY* psa) {
if (psa == 0) return;
if (psa->cDims != 1) throw std::runtime_error("safearray_t: Invalid dimension");
if (!traits::are_features_ok( psa->fFeatures )) throw std::runtime_error("safearray_t: fFeatures is invalid");
#ifndef COMET_PARTIAL_SPECIALISATION
traits_sanity_check< impl::sa_traits_check_type(traits::check_type)>::check(psa);
#else
traits_sanity_check<T,impl::sa_traits_check_type(traits::check_type)>::check(psa);
#endif
if (sizeof(T) != psa->cbElements) throw std::runtime_error("safearray_t: cbElements mismatch");
}
};
//@}
namespace impl {
template< typename T>
class safearray_auto_ref_t : public safearray_t<T>
{
// Don't allow any of these.
safearray_auto_ref_t();
safearray_auto_ref_t &operator=(const safearray_auto_ref_t &);
safearray_auto_ref_t &operator=(const safearray_t<T> &);
safearray_t<T>& operator=(const impl::auto_attach_t<SAFEARRAY*> &);
void swap(safearray_t<T>& sa);
// Remember where we got the original for a non-const reference
SAFEARRAY *& psa_;
public:
safearray_auto_ref_t(const safearray_auto_ref_t &sa)
: safearray_t<T>(auto_attach(sa.psa_)), psa_(sa.psa_)
{
COMET_STATIC_ASSERT(false);
}
explicit safearray_auto_ref_t(SAFEARRAY *& psa)
: safearray_t<T>(auto_attach(psa)), psa_(psa)
{
}
~safearray_auto_ref_t()
{
psa_ = this->detach();
}
};
template< typename T>
class safearray_auto_const_ref_t : public safearray_t<T>
{
// Don't allow any of these.
safearray_auto_const_ref_t();
safearray_auto_const_ref_t &operator=(const safearray_auto_const_ref_t &);
safearray_auto_const_ref_t &operator=(const safearray_t<T> &);
safearray_t<T>& operator=(const impl::auto_attach_t<SAFEARRAY*> &);
void swap(safearray_t<T>& sa);
public:
safearray_auto_const_ref_t(const safearray_auto_const_ref_t &sa)
: safearray_t<T>(auto_attach(sa.psa_))
{
COMET_STATIC_ASSERT(false);
}
explicit safearray_auto_const_ref_t(SAFEARRAY *psa)
: safearray_t<T>(auto_attach(psa))
{
}
~safearray_auto_const_ref_t()
{
this->detach();
}
};
}
template<typename T>
const impl::safearray_auto_const_ref_t<T> safearray_t<T>::create_const_reference(SAFEARRAY* const & sa)
{
return impl::safearray_auto_const_ref_t<T>(sa);
}
template<typename T>
impl::safearray_auto_ref_t<T> safearray_t<T>::create_reference(SAFEARRAY* & sa)
{
return impl::safearray_auto_ref_t<T>(sa);
}
template<typename T>
const impl::safearray_auto_const_ref_t<T> safearray_t<T>::create_const_reference(const variant_t &var)
{
if(var.get_vt()!=(VT_ARRAY|traits::vt))
throw std::exception("unexepected array type");
SAFEARRAY *sa = var.get().parray;
return impl::safearray_auto_const_ref_t<T>(sa);
}
template<typename T>
impl::safearray_auto_ref_t<T> safearray_t<T>::create_reference(variant_t &var)
{
if(var.get_vt()!=(VT_ARRAY|traits::vt))
throw std::exception("unexepected array type");
SAFEARRAY *sa = var.get().parray;
return impl::safearray_auto_ref_t<T>(sa);
}
template<typename T, typename TR> inline comet::impl::sa_iterator<T, TR> operator+(size_t n, const comet::impl::sa_iterator<T, TR>& it) {
return it + n;
}
} // namespace comet
namespace {
COMET_STATIC_ASSERT( sizeof(SAFEARRAY*) == sizeof(comet::safearray_t<long>) );
}
namespace std {
template<> inline void swap( comet::safearray_t<long>& x, comet::safearray_t<long>& y) COMET_STD_SWAP_NOTHROW;
template<> inline void swap( comet::safearray_t<unsigned long>& x, comet::safearray_t<unsigned long>& y) COMET_STD_SWAP_NOTHROW;
template<> inline void swap( comet::safearray_t<short>& x, comet::safearray_t<short>& y) COMET_STD_SWAP_NOTHROW;
template<> inline void swap( comet::safearray_t<unsigned short>& x, comet::safearray_t<unsigned short>& y) COMET_STD_SWAP_NOTHROW;
template<> inline void swap( comet::safearray_t<float>& x, comet::safearray_t<float>& y) COMET_STD_SWAP_NOTHROW;
template<> inline void swap( comet::safearray_t<double>& x, comet::safearray_t<double>& y) COMET_STD_SWAP_NOTHROW;
template<> inline void swap( comet::safearray_t<comet::bstr_t>& x, comet::safearray_t<comet::bstr_t>& y) COMET_STD_SWAP_NOTHROW;
template<> inline void swap( comet::safearray_t<comet::variant_t>& x, comet::safearray_t<comet::variant_t>& y) COMET_STD_SWAP_NOTHROW;
template<> inline void swap( comet::safearray_t<comet::com_ptr< ::IUnknown> >& x, comet::safearray_t<comet::com_ptr< ::IUnknown> >& y) COMET_STD_SWAP_NOTHROW;
template<> inline void swap( comet::safearray_t<comet::com_ptr< ::IDispatch> >& x, comet::safearray_t<comet::com_ptr< ::IDispatch> >& y) COMET_STD_SWAP_NOTHROW;
}
template<> inline void std::swap( comet::safearray_t<long>& x, comet::safearray_t<long>& y) COMET_STD_SWAP_NOTHROW { x.swap(y); }
template<> inline void std::swap( comet::safearray_t<unsigned long>& x, comet::safearray_t<unsigned long>& y) COMET_STD_SWAP_NOTHROW { x.swap(y); }
template<> inline void std::swap( comet::safearray_t<short>& x, comet::safearray_t<short>& y) COMET_STD_SWAP_NOTHROW { x.swap(y); }
template<> inline void std::swap( comet::safearray_t<unsigned short>& x, comet::safearray_t<unsigned short>& y) COMET_STD_SWAP_NOTHROW { x.swap(y); }
template<> inline void std::swap( comet::safearray_t<float>& x, comet::safearray_t<float>& y) COMET_STD_SWAP_NOTHROW { x.swap(y); }
template<> inline void std::swap( comet::safearray_t<double>& x, comet::safearray_t<double>& y) COMET_STD_SWAP_NOTHROW { x.swap(y); }
template<> inline void std::swap( comet::safearray_t<comet::bstr_t>& x, comet::safearray_t<comet::bstr_t>& y) COMET_STD_SWAP_NOTHROW { x.swap(y); }
template<> inline void std::swap( comet::safearray_t<comet::variant_t>& x, comet::safearray_t<comet::variant_t>& y) COMET_STD_SWAP_NOTHROW { x.swap(y); }
template<> inline void std::swap( comet::safearray_t<comet::com_ptr< ::IUnknown> >& x, comet::safearray_t<comet::com_ptr< ::IUnknown> >& y) COMET_STD_SWAP_NOTHROW { x.swap(y); }
template<> inline void std::swap( comet::safearray_t<comet::com_ptr< ::IDispatch> >& x, comet::safearray_t<comet::com_ptr< ::IDispatch> >& y) COMET_STD_SWAP_NOTHROW { x.swap(y); }
#endif
Reference in a new issue Copy permalink