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

El método GetNext mueve el iterador hacia delante y captura el siguiente elemento iterado. Si el objeto es indizable además de que se puede iterar y esto se indica mediante el argumento GetDefaultIndexDimensionality que devuelve un valor distinto de cero, este método puede devolver opcionalmente los índices predeterminados para volver al valor generado del indexador. Tenga en cuenta que un llamador puede optar por pasar 0/nullptr y no recuperar índices. Se considera ilegal que el autor de la llamada solicite índices parciales (por ejemplo: menor que el número generado por GetDefaultIndexDimensionality).

Si el iterador avanza correctamente, pero se produjo un error al leer el valor del elemento iterado, el método puede devolver un error Y rellenar "objeto" con un objeto de error. Al final de la iteración de los elementos contenidos, el iterador devolverá E_BOUNDS desde el método GetNext. Cualquier llamada posterior (a menos que haya habido una llamada reset intermedia) también devolverá E_BOUNDS.

Sintaxis

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

Parámetros

object

El objeto generado a partir del iterador se devuelve aquí.

dimensions

Número de dimensiones del índice predeterminado que solicita el autor de la llamada. Si es cero, el autor de la llamada no desea que se devuelva el índice predeterminado. Si no es cero, debe ser al menos tan alto como la dimensionalidad del índice predeterminado.

indexers

Búfer de dimensiones de tamaño que se rellenarán con los índices predeterminados para volver al elemento devuelto del indexador.

metadata

Si hay algún metadato asociado al elemento iterado, se devuelve (opcionalmente) en este argumento.

Valor devuelto

Este método devuelve HRESULT.

Comentarios

Código de ejemplo

// 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
Header	dbgmodel.h

Consulte también

Interfaz IModelIterator