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

Article
04/03/2024

La méthode GetNext déplace l’itérateur vers l’avant et extrait l’élément itéré suivant. Si l’objet est indexable en plus d’être itérable et que cela est indiqué par l’argument GetDefaultIndexDimensionality retournant une valeur autre que zéro, cette méthode peut éventuellement retourner 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 avancé avec succès, mais qu’une erreur s’est produite lors de la lecture de la valeur de l’élément itéré, la méthode peut retourner une erreur ET remplir « object » avec un objet d’erreur. À la fin de l’itération des éléments contenus, l’itérateur retourne E_BOUNDS de la méthode GetNext. Tout appel suivant (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. Si cette valeur est égale à 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 remplie avec les index par défaut pour revenir à l’élément retourné à partir de l’indexeur.

metadata

Si des métadonnées sont associées à l’élément itéré, elles sont retournées (éventuellement) dans cet argument.

Valeur retournée

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;

};

Configuration requise

Condition requise	Valeur
En-tête	dbgmodel.h

Voir aussi

Interface IModelIterator

Partager via