IModelIterator ::GetNext, méthode (dbgmodel.h)

La méthode GetNext déplace l’itérateur vers l’avant et récupère l’élément itéré suivant. Si l’objet est indexable en plus d’être itérable et qu’il est indiqué par l’argument GetDefaultIndexDimensionality retournant une valeur non nulle, cette méthode peut éventuellement renvoyer les index par défaut pour revenir à la valeur produite à partir de l’indexeur. Notez qu’un appelant peut choisir de passer 0/nullptr et de ne pas récupérer d’index. Il est considéré comme illégal pour l’appelant de demander des indices partiels (par exemple, inférieur au nombre produit par GetDefaultIndexDimensionality).

Si l’itérateur a réussi à avancer, mais qu’une erreur s’est produite lors de la lecture de la valeur de l’élément itéré, la méthode peut renvoyer une erreur AND remplir « objet » avec un objet d’erreur. À la fin de l’itération des éléments contenus, l’itérateur retourne E_BOUNDS à partir de la méthode GetNext. Tout appel ultérieur (sauf s’il y a eu un appel de réinitialisation intermédiaire) retourne également E_BOUNDS.

Syntaxe

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

Paramètres

object

L’objet produit à partir de l’itérateur est retourné ici.

dimensions

Nombre de dimensions de l’index par défaut demandé par l’appelant. S’il s’agit de zéro, l’appelant ne souhaite pas que l’index par défaut soit retourné. S’il n’est pas égal à zéro, il doit être au moins aussi élevé que la dimensionnalité de l’index par défaut.

indexers

Mémoire tampon de dimensions de taille qui sera renseignée avec les index par défaut pour revenir à l’élément retourné à partir de l’indexeur.

metadata

S’il existe des métadonnées associées à l’élément itéré, elle est retournée (éventuellement) dans cet argument.

Valeur de retour

Cette méthode retourne HRESULT.

Remarques

exemple de code

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

};

Exigences

Exigence	Valeur
d’en-tête	dbgmodel.h

Voir aussi

interface IModelIterator