winrt::single_threaded_observable_vector 関数テンプレート (C++/WinRT)

[アーティクル]
07/20/2023

監視可能なコレクションを実装する型のオブジェクトを作成して返す関数テンプレート。オブジェクトは IObservableVector として返され、返されたオブジェクトの関数とプロパティを呼び出すインターフェイスです。

必要に応じて、既存の std::vectorrvalue を関数に渡すことができます。一時オブジェクトを渡すか、左辺値で std::move を呼び出します。

詳細とコード例については、「 C++/WinRT を使用したコレクション」を参照してください。

構文

template <typename T, typename Allocator = std::allocator<T>>
winrt::Windows::Foundation::Collections::IObservableVector<T> single_threaded_observable_vector(std::vector<T, Allocator>&& values = {})

テンプレートパラメーター

typename T コレクションの要素の型。

typename Allocator コレクションを初期化するベクターのアロケーターの型。渡す場合は既定のアロケーター。

パラメーター

valuesコレクションオブジェクトの要素を初期化する std::vector 型の右辺値への省略可能な参照。

戻り値

新しいコレクションオブジェクトを表す IObservableVector 。

必要条件

サポートされている最小 SDK: Windows SDK バージョン 10.0.17763.0 (Windows 10 Version 1809)

名前空間: winrt

ヘッダー: %WindowsSdkDir%IncludeWindowsTargetPlatformVersion<>\cppwinrt\winrt\base.h (既定で含まれています)

Windows SDK の古いバージョンをお持ちの場合

Windows SDK バージョン 10.0.17763.0 (Windows 10 Version 1809) 以降がない場合は、IObservableVectorT<> の便利な汎用実装として機能するために、独自の監視可能なベクターテンプレートを実装する必要があります。 single_threaded_observable_vector T というクラスの一覧を次に<示します。> 以下の種類から winrt::single_threaded_observable_vector に切り替えるには、それを含む Windows SDK のバージョンを使用している場合に簡単に切り替えることができます。

// single_threaded_observable_vector.h
#pragma once

namespace winrt::Bookstore::implementation
{
    using namespace Windows::Foundation::Collections;

    template <typename T>
    struct single_threaded_observable_vector : implements<single_threaded_observable_vector<T>,
        IObservableVector<T>,
        IVector<T>,
        IVectorView<T>,
        IIterable<T>>
    {
        event_token VectorChanged(VectorChangedEventHandler<T> const& handler)
        {
            return m_changed.add(handler);
        }

        void VectorChanged(event_token const cookie)
        {
            m_changed.remove(cookie);
        }

        T GetAt(uint32_t const index) const
        {
            if (index >= m_values.size())
            {
                throw hresult_out_of_bounds();
            }

            return m_values[index];
        }

        uint32_t Size() const noexcept
        {
            return static_cast<uint32_t>(m_values.size());
        }

        IVectorView<T> GetView()
        {
            return *this;
        }

        bool IndexOf(T const& value, uint32_t& index) const noexcept
        {
            index = static_cast<uint32_t>(std::find(m_values.begin(), m_values.end(), value) - m_values.begin());
            return index < m_values.size();
        }

        void SetAt(uint32_t const index, T const& value)
        {
            if (index >= m_values.size())
            {
                throw hresult_out_of_bounds();
            }

            ++m_version;
            m_values[index] = value;
            m_changed(*this, make<args>(CollectionChange::ItemChanged, index));
        }

        void InsertAt(uint32_t const index, T const& value)
        {
            if (index > m_values.size())
            {
                throw hresult_out_of_bounds();
            }

            ++m_version;
            m_values.insert(m_values.begin() + index, value);
            m_changed(*this, make<args>(CollectionChange::ItemInserted, index));
        }

        void RemoveAt(uint32_t const index)
        {
            if (index >= m_values.size())
            {
                throw hresult_out_of_bounds();
            }

            ++m_version;
            m_values.erase(m_values.begin() + index);
            m_changed(*this, make<args>(CollectionChange::ItemRemoved, index));
        }

        void Append(T const& value)
        {
            ++m_version;
            m_values.push_back(value);
            m_changed(*this, make<args>(CollectionChange::ItemInserted, Size() - 1));
        }

        void RemoveAtEnd()
        {
            if (m_values.empty())
            {
                throw hresult_out_of_bounds();
            }

            ++m_version;
            m_values.pop_back();
            m_changed(*this, make<args>(CollectionChange::ItemRemoved, Size()));
        }

        void Clear() noexcept
        {
            ++m_version;
            m_values.clear();
            m_changed(*this, make<args>(CollectionChange::Reset, 0));
        }

        uint32_t GetMany(uint32_t const startIndex, array_view<T> values) const
        {
            if (startIndex >= m_values.size())
            {
                return 0;
            }

            uint32_t actual = static_cast<uint32_t>(m_values.size() - startIndex);

            if (actual > values.size())
            {
                actual = values.size();
            }

            std::copy_n(m_values.begin() + startIndex, actual, values.begin());
            return actual;
        }

        void ReplaceAll(array_view<T const> value)
        {
            ++m_version;
            m_values.assign(value.begin(), value.end());
            m_changed(*this, make<args>(CollectionChange::Reset, 0));
        }

        IIterator<T> First()
        {
            return make<iterator>(this);
        }

    private:

        std::vector<T> m_values;
        event<VectorChangedEventHandler<T>> m_changed;
        uint32_t m_version{};

        struct args : implements<args, IVectorChangedEventArgs>
        {
            args(CollectionChange const change, uint32_t const index) :
                m_change(change),
                m_index(index)
            {
            }

            CollectionChange CollectionChange() const
            {
                return m_change;
            }

            uint32_t Index() const
            {
                return m_index;
            }

        private:

            Windows::Foundation::Collections::CollectionChange const m_change{};
            uint32_t const m_index{};
        };

        struct iterator : implements<iterator, IIterator<T>>
        {
            explicit iterator(single_threaded_observable_vector<T>* owner) noexcept :
            m_version(owner->m_version),
                m_current(owner->m_values.begin()),
                m_end(owner->m_values.end())
            {
                m_owner.copy_from(owner);
            }

            void abi_enter() const
            {
                if (m_version != m_owner->m_version)
                {
                    throw hresult_changed_state();
                }
            }

            T Current() const
            {
                if (m_current == m_end)
                {
                    throw hresult_out_of_bounds();
                }

                return*m_current;
            }

            bool HasCurrent() const noexcept
            {
                return m_current != m_end;
            }

            bool MoveNext() noexcept
            {
                if (m_current != m_end)
                {
                    ++m_current;
                }

                return HasCurrent();
            }

            uint32_t GetMany(array_view<T> values)
            {
                uint32_t actual = static_cast<uint32_t>(std::distance(m_current, m_end));

                if (actual > values.size())
                {
                    actual = values.size();
                }

                std::copy_n(m_current, actual, values.begin());
                std::advance(m_current, actual);
                return actual;
            }

        private:

            com_ptr<single_threaded_observable_vector<T>> m_owner;
            uint32_t const m_version;
            typename std::vector<T>::const_iterator m_current;
            typename std::vector<T>::const_iterator const m_end;
        };
    };
}

Append 関数は、IObservableVector<T>:: VectorChanged イベントを発生させる方法を示しています。

m_changed(*this, make<args>(CollectionChange::ItemInserted, Size() - 1));

イベントの引数は、要素が挿入されていることと、そのインデックスが何であるか (ここでは最後の要素) を示します。これらの引数は、最適な方法で XAML アイテムコントロールがイベントに応答し、それ自体を更新できるようにします。

これは、上記で定義した型のインスタンスを作成する方法です。 winrt::single_threaded_observable_vector ファクトリ関数テンプレートを呼び出す代わりに、winrt::make を呼び出してコレクションオブジェクトを作成します。

#include "single_threaded_observable_vector.h"
...
winrt::Windows::Foundation::Collections::IVector<winrt::Windows::Foundation::IInspectable> m_bookSkus;
...
m_bookSkus = winrt::make<winrt::Bookstore::implementation::single_threaded_observable_vector<winrt::Windows::Foundation::IInspectable>>();

winrt::single_threaded_observable_vector 関数テンプレート (C++/WinRT)

構文

テンプレートパラメーター

パラメーター

戻り値

必要条件

Windows SDK の古いバージョンをお持ちの場合

こちらもご覧ください

フィードバック

フィードバック

その他のリソース

winrt::single_threaded_observable_vector 関数テンプレート (C++/WinRT)

構文

テンプレート パラメーター

パラメーター

戻り値

必要条件

Windows SDK の古いバージョンをお持ちの場合

こちらもご覧ください

フィードバック

フィードバック

その他のリソース

テンプレートパラメーター