Metodo IModelIterator::GetNext (dbgmodel.h)

Il metodo GetNext sposta l'iteratore in avanti e recupera l'elemento iterato successivo. Se l'oggetto è indicizzato oltre a essere iterabile ed è indicato dall'argomento GetDefaultIndexDimensionality che restituisce un valore diverso da zero, questo metodo può facoltativamente restituire gli indici predefiniti per tornare al valore prodotto dall'indicizzatore. Si noti che un chiamante può scegliere di passare 0/nullptr e non recuperare indici. È considerato illegale per il chiamante richiedere indici parziali (ad esempio, minore del numero prodotto da GetDefaultIndexDimensionality).

Se l'iteratore è stato spostato in avanti ma si è verificato un errore durante la lettura del valore dell'elemento iterato, il metodo può restituire un errore E riempire "oggetto" con un oggetto errore. Al termine dell'iterazione degli elementi contenuti, l'iteratore restituirà E_BOUNDS dal metodo GetNext. Qualsiasi chiamata successiva (a meno che non sia stata eseguita una chiamata reimpostata) restituirà anche E_BOUNDS.

Sintassi

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

Parametri

object

L'oggetto prodotto dall'iteratore viene restituito qui.

dimensions

Numero di dimensioni dell'indice predefinito richiesto dal chiamante. Se è zero, il chiamante non desidera che venga restituito l'indice predefinito. Se è diverso da zero, deve essere almeno uguale alla dimensionalità dell'indice predefinito.

indexers

Buffer di dimensioni che verranno riempite con gli indici predefiniti per tornare all'elemento restituito dall'indicizzatore.

metadata

Se all'elemento iterato sono associati metadati, viene restituito (facoltativamente) in questo argomento.

Valore restituito

Questo metodo restituisce HRESULT.

Commenti

Codice di esempio

// 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;

};

Requisiti

Requisito	Valore
Intestazione	dbgmodel.h

Vedi anche

Interfaccia IModelIterator