Método IModelIterator::GetNext (dbgmodel.h)

O método GetNext move o iterador para frente e busca o próximo elemento iterado. Se o objeto for indexável além de ser iterável e isso for indicado pelo argumento GetDefaultIndexDimensionality retornando um valor diferente de zero, esse método poderá retornar opcionalmente os índices padrão para voltar ao valor produzido do indexador. Observe que um chamador pode optar por passar 0/nullptr e não recuperar nenhum índice. É considerado inválido que o chamador solicite índices parciais (por exemplo: menor que o número produzido por GetDefaultIndexDimensionality).

Se o iterador avançou com êxito, mas houve um erro ao ler o valor do elemento iterado, o método poderá retornar um erro E preencher "objeto" com um objeto de erro. No final da iteração dos elementos contidos, o iterador retornará E_BOUNDS do método GetNext. Qualquer chamada subsequente (a menos que tenha havido uma chamada de redefinição intervindo) também retornará E_BOUNDS.

Sintaxe

HRESULT GetNext(
  _COM_Errorptr_ IModelObject **object,
  ULONG64                     dimensions,
  IModelObject                **indexers,
  IKeyStore                   **metadata
);

Parâmetros

object

O objeto produzido do iterador é retornado aqui.

dimensions

O número de dimensões do índice padrão que o chamador está solicitando. Se isso for zero, o chamador não desejará que o índice padrão seja retornado. Se não for zero, ele deverá ser pelo menos tão alto quanto a dimensionalidade do índice padrão.

indexers

Um buffer de dimensões de tamanho que será preenchido com os índices padrão para voltar ao elemento retornado do indexador.

metadata

Se houver metadados associados ao elemento iterado, ele será retornado (opcionalmente) nesse argumento.

Retornar valor

Esse método retorna HRESULT.

Comentários

Código de exemplo

// The full class is shown here for clarity on the iterator!  For the sake 
// of example, this iterator produces integers from 10 to 
// 10 + <value of 'NumElements' key> which are indexed by a linear 0-based index.
class MyObjectIterator :
    public Microsoft::WRL::RuntimeClass<
        Microsoft::WRL::RuntimeClassFlags<
            Microsoft::WRL::RuntimeClassType::ClassicCom
            >,
        IModelIterator
        >
{
public:

    IFACEMETHOD(Reset)()
    {
        m_position = m_numElements = 0;

        ComPtr<IModelObject> spNumElements;
        HRESULT hr = m_spContextObject->GetKeyValue(L"NumElements", 
                                                    &spNumElements, 
                                                    nullptr);
        if (SUCCEEDED(hr))
        {
            VARIANT vtVal;
            if (SUCCEEDED(spNumElements->GetIntrinsicValueAs(VT_UI8, &vtVal)))
            {
                m_numElements = vtVal.ullVal;
            }
        }
    
        return hr;
    }

    IFACEMETHOD(GetNext)(_COM_Errorptr_ IModelObject **ppValue, 
                         _In_ ULONG64 dimensions, 
                         _Out_writes_(dimensions) IModelObject **ppIndexers,
                         _COM_Outptr_opt_result_maybe_null_ IKeyStore *ppMetadata)
    {
        HRESULT hr = S_OK;
        *ppMetadata = nullptr;
        for (ULONG64 i = 0; i < dimensions; ++i)
        {
            ppIndexers[i] = nullptr;
        }

        // We are indexable in one dimension.  Verify the call is valid.  
        // The caller either doesn't care (dimensions == 0) or passes the number 
         // of dimensions we indicate (dimensions == 1)
        if (dimensions != 0 && dimensions != 1)
        {
            return E_INVALIDARG; 
        }

        // E_BOUNDS indicates the end of the iteration
        if (m_position >= m_numElements)
        {
            return E_BOUNDS;
        }

        ComPtr<IModelObject> spValue; 
        ComPtr<IModelObject> spIndex;

        VARAINT vtValue;
        vtValue.vt = VT_UI8;
        vtValue.ullVal = m_position + 10; // Just as example.  We produce 
                                          // values from 10 -> 10 + 'NumElements'
        hr = GetManager()->CreateIntrinsicObject(ObjectIntrinsic, &vtValue, &spValue);
        if (SUCCEEDED(hr))
        {
            if (dimensions == 1)
            {
                VARIANT vtIdx;
                vtIdx.vt = VT_UI8;
                vtIdx.ullVal = m_position;
                hr = GetManager()->CreateIntrinsicObject(ObjectIntrinsic, 
                                                         &vtIdx, 
                                                         &spIndex);
            }
        }

        if (SUCCEEDED(hr))
        {
            *ppValue = spValue.Detach();
            if (dimensions == 1)
            {
                ppIndexers[0] = spIndex.Detach();
            }

            ++m_position;
        }

        return hr;
    }

    HRESULT RuntimeClassInitialize(_In_ IModelObject *pContextObject)
    {
        m_spContextObject = pContextObject;
        return Reset();
    }

private:

    ULONG64 m_position;
    ULONG64 m_numElements;
    ComPtr<IModelObject> m_spContextObject;

};

Requisitos

Requisito	Valor
Cabeçalho	dbgmodel.h

Confira também

Interface IModelIterator