base::win::ScopedSafearray Class Reference

#include <scoped_safearray.h>

Classes
class	LockScope

Public Member Functions
	ScopedSafearray (SAFEARRAY *safearray=nullptr)
	ScopedSafearray (ScopedSafearray &&r) noexcept
ScopedSafearray &	operator= (ScopedSafearray &&rvalue)
	~ScopedSafearray ()
template<VARTYPE ElementVartype>
std::optional< LockScope< ElementVartype > >	CreateLockScope () const
void	Destroy ()
void	Reset (SAFEARRAY *safearray=nullptr)
SAFEARRAY *	Release ()
SAFEARRAY **	Receive ()
size_t	GetCount (UINT dimension=0) const
SAFEARRAY *	Get () const
bool	operator== (const ScopedSafearray &safearray2) const =delete
bool	operator!= (const ScopedSafearray &safearray2) const =delete

Detailed Description

Definition at line 22 of file scoped_safearray.h.

Constructor & Destructor Documentation

ScopedSafearray() [1/2]

base::win::ScopedSafearray::ScopedSafearray ( SAFEARRAY *  safearray = nullptr )

inlineexplicit

Definition at line 119 of file scoped_safearray.h.

      : safearray_(safearray) {}

ScopedSafearray() [2/2]

base::win::ScopedSafearray::ScopedSafearray ( ScopedSafearray &&  r )

inlinenoexcept

Definition at line 123 of file scoped_safearray.h.

                                                : safearray_(r.safearray_) {
    r.safearray_ = nullptr;
  }

~ScopedSafearray()

base::win::ScopedSafearray::~ScopedSafearray ( )

inline

Definition at line 133 of file scoped_safearray.h.

{ Destroy(); }

Member Function Documentation

CreateLockScope()

template<VARTYPE ElementVartype>

std::optional< LockScope< ElementVartype > > base::win::ScopedSafearray::CreateLockScope ( ) const

inline

Definition at line 138 of file scoped_safearray.h.

                                                                 {
    if (!safearray_ || SafeArrayGetDim(safearray_) != 1)
      return std::nullopt;
 
    VARTYPE vartype;
    HRESULT hr = SafeArrayGetVartype(safearray_, &vartype);
    if (FAILED(hr) ||
        !internal::VariantUtil<ElementVartype>::IsConvertibleTo(vartype)) {
      return std::nullopt;
    }
 
    typename LockScope<ElementVartype>::pointer array = nullptr;
    hr = SafeArrayAccessData(safearray_, reinterpret_cast<void**>(&array));
    if (FAILED(hr))
      return std::nullopt;
 
    const size_t array_size = GetCount();
    return LockScope<ElementVartype>(safearray_, vartype, array, array_size);
  }

Destroy()

void base::win::ScopedSafearray::Destroy ( )

inline

Definition at line 158 of file scoped_safearray.h.

                 {
    if (safearray_) {
      HRESULT hr = SafeArrayDestroy(safearray_);
      BASE_DCHECK(S_OK == hr);
      safearray_ = nullptr;
    }
  }

Get()

SAFEARRAY * base::win::ScopedSafearray::Get ( ) const

inline

Definition at line 209 of file scoped_safearray.h.

{ return safearray_; }

GetCount()

size_t base::win::ScopedSafearray::GetCount ( UINT  dimension = 0 ) const

inline

Definition at line 193 of file scoped_safearray.h.

                                            {
    BASE_DCHECK(safearray_);
    // Initialize |lower| and |upper| so this method will return zero if either
    // SafeArrayGetLBound or SafeArrayGetUBound returns failure because they
    // only write to the output parameter when successful.
    LONG lower = 0;
    LONG upper = -1;
    BASE_DCHECK(dimension < SafeArrayGetDim(safearray_));
    HRESULT hr = SafeArrayGetLBound(safearray_, dimension + 1, &lower);
    BASE_DCHECK(SUCCEEDED(hr));
    hr = SafeArrayGetUBound(safearray_, dimension + 1, &upper);
    BASE_DCHECK(SUCCEEDED(hr));
    return (upper - lower + 1);
  }

operator!=()

bool base::win::ScopedSafearray::operator!= ( const ScopedSafearray &  safearray2 ) const

delete

operator=()

ScopedSafearray & base::win::ScopedSafearray::operator= ( ScopedSafearray &&  rvalue )

inline

Definition at line 128 of file scoped_safearray.h.

                                                       {
    Reset(rvalue.Release());
    return *this;
  }

operator==()

bool base::win::ScopedSafearray::operator== ( const ScopedSafearray &  safearray2 ) const

delete

Receive()

SAFEARRAY ** base::win::ScopedSafearray::Receive ( )

inline

Definition at line 187 of file scoped_safearray.h.

                        {
    Destroy();
    return &safearray_;
  }

Release()

SAFEARRAY * base::win::ScopedSafearray::Release ( )

inline

Definition at line 176 of file scoped_safearray.h.

                       {
    SAFEARRAY* safearray = safearray_;
    safearray_ = nullptr;
    return safearray;
  }

Reset()

void base::win::ScopedSafearray::Reset ( SAFEARRAY *  safearray = nullptr )

inline

Definition at line 168 of file scoped_safearray.h.

                                             {
    if (safearray != safearray_) {
      Destroy();
      safearray_ = safearray;
    }
  }

---

The documentation for this class was generated from the following file:

• third_party/accessibility/base/win/scoped_safearray.h