base::win::EnumVariant Class Reference

#include <enum_variant.h>

Inheritance diagram for base::win::EnumVariant:

Public Member Functions
	EnumVariant (ULONG count)
IFACEMETHODIMP	Next (ULONG requested_count, VARIANT *out_elements, ULONG *out_elements_received) override
IFACEMETHODIMP	Skip (ULONG skip_count) override
IFACEMETHODIMP	Reset () override
IFACEMETHODIMP	Clone (IEnumVARIANT **out_cloned_object) override
VARIANT *	ItemAt (ULONG index)

Detailed Description

Definition at line 19 of file enum_variant.h.

Constructor & Destructor Documentation

EnumVariant()

base::win::EnumVariant::EnumVariant ( ULONG  count )

explicit

Definition at line 16 of file enum_variant.cc.

                                    : current_index_(0) {
  for (ULONG i = 0; i < count; ++i)
    items_.emplace_back(ScopedVariant::kEmptyVariant);
}

Member Function Documentation

Clone()

HRESULT base::win::EnumVariant::Clone ( IEnumVARIANT **  out_cloned_object )

override

Definition at line 66 of file enum_variant.cc.

                                                           {
  if (!out_cloned_object)
    return E_INVALIDARG;
 
  size_t count = items_.size();
  Microsoft::WRL::ComPtr<EnumVariant> other =
      Microsoft::WRL::Make<EnumVariant>(static_cast<ULONG>(count));
  for (size_t i = 0; i < count; ++i)
    other->items_[i] = static_cast<const VARIANT&>(items_[i]);
 
  other->Skip(current_index_);
  return other.CopyTo(IID_PPV_ARGS(out_cloned_object));
}

ItemAt()

VARIANT * base::win::EnumVariant::ItemAt

(

ULONG

index

)

Definition at line 23 of file enum_variant.cc.

                                        {
  BASE_DCHECK(index < items_.size());
  // This is a hack to return a mutable pointer to the ScopedVariant, even
  // though the original intent of the AsInput method was to allow only readonly
  // access to the wrapped variant.
  return items_[index].AsInput();
}

Next()

HRESULT base::win::EnumVariant::Next ( ULONG  requested_count, VARIANT *  out_elements, ULONG *  out_elements_received  )

override

Definition at line 31 of file enum_variant.cc.

                                                        {
  if (!out_elements)
    return E_INVALIDARG;
 
  BASE_DCHECK(current_index_ <= items_.size());
  ULONG available_count = static_cast<ULONG>(items_.size()) - current_index_;
  ULONG count = std::min(requested_count, available_count);
  for (ULONG i = 0; i < count; ++i)
    out_elements[i] = items_[current_index_ + i].Copy();
  current_index_ += count;
 
  // The caller can choose not to get the number of received elements by setting
  // |out_elements_received| to nullptr.
  if (out_elements_received)
    *out_elements_received = count;
 
  return (count == requested_count ? S_OK : S_FALSE);
}

Reset()

HRESULT base::win::EnumVariant::Reset ( )

override

Definition at line 61 of file enum_variant.cc.

                           {
  current_index_ = 0;
  return S_OK;
}

Skip()

HRESULT base::win::EnumVariant::Skip ( ULONG  skip_count )

override

Definition at line 52 of file enum_variant.cc.

                                          {
  ULONG count = skip_count;
  if (current_index_ + count > static_cast<ULONG>(items_.size()))
    count = static_cast<ULONG>(items_.size()) - current_index_;
 
  current_index_ += count;
  return (count == skip_count ? S_OK : S_FALSE);
}

---

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

• third_party/accessibility/base/win/enum_variant.h
• third_party/accessibility/base/win/enum_variant.cc