/** \file
  * SafeArray wrapper implementation.
  */
/*
 * Copyright © 2000, 2001, 2002 Sofus Mortensen, Michael Geddes
 * Copyright © 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