container.h

[詳解]

/// @file
/// @brief コンテナクラス関連の便利処理を提供するヘッダ。
///
/// Copyright(C)SEGA

#ifndef AMDAEMON_UTIL_CONTAINER_H
#define AMDAEMON_UTIL_CONTAINER_H

#include "amdaemon/env.h"

#include <algorithm>
#include <utility>
#include <type_traits>
#include <iterator>
#include <vector>
#include <bitset>

namespace amdaemon
{
namespace util
{
/// @addtogroup g_util
/// @{

    namespace detail
    {
        /// @brief toContainer 関数の実処理を行うヘルパクラステンプレート。
        /// @note 部分特殊化のためのクラス。
        template<class DestContainer, class SrcContainer>
        struct ContainerToContainer
        {
            template<class TheSrcContainer>
            DestContainer operator()(TheSrcContainer&& src) const
            {
                using std::begin;   // for ADL
                using std::end;     // for ADL

                return
                    DestContainer(
                        begin(std::forward<TheSrcContainer>(src)),
                        end(std::forward<TheSrcContainer>(src)));
            }
        };

        /// @brief toContainer 関数の実処理を行うヘルパクラステンプレート。
        /// @note 同一コンテナ型用の部分特殊化。
        template<class Container>
        struct ContainerToContainer<Container, Container>
        {
            template<class TheSrcContainer>
            Container operator()(TheSrcContainer&& src) const
            {
                return src;
            }
        };

        /// @brief toContainer 関数の実処理を行うヘルパクラステンプレート。
        /// @note 部分特殊化のためのクラス。
        template<class Container, class SizeType, class Getter>
        struct GetterToContainer
        {
            /// @brief toContainer 関数の実処理を行う。
            /// @param[in] count 要素数。
            /// @param[in] getter インデックス値を引数に取る関数。
            /// @return 作成されたコンテナ。
            Container operator()(SizeType count, Getter&& getter) const
            {
                Container c;

                SizeType i = SizeType();
                std::generate_n(
                    std::back_inserter(c),
                    count,
                    [&]() -> decltype(getter(i)) { return getter(i++); });

                return c;
            }
        };

        /// @brief toContainer 関数の実処理を行うヘルパクラステンプレート。
        /// @note std::vector 型用の部分特殊化。
        template<class T, class SizeType, class Getter>
        struct GetterToContainer<std::vector<T>, SizeType, Getter>
        {
            /// @brief toContainer 関数の実処理を行う。
            /// @param[in] count 要素数。
            /// @param[in] getter インデックス値を引数に取る関数。
            /// @return 作成されたコンテナ。
            std::vector<T> operator()(SizeType count, Getter&& getter) const
            {
                std::vector<T> c;
                c.reserve(count);

                SizeType i = SizeType();
                std::generate_n(
                    std::back_inserter(c),
                    count,
                    [&]() -> decltype(getter(i)) { return getter(i++); });

                return c;
            }
        };
    } // namespace detail

    /// @brief コンテナから指定した値を検索し、そのインデックスを返す。
    /// @tparam Container 検索対象のコンテナ型。
    /// @tparam T 検索する値の型。
    /// @param[in] container 検索対象のコンテナ。
    /// @param[in] target 検索する値。
    /// @return インデックス。見つからなければ -1 。
    template<class Container, class T>
    std::ptrdiff_t findIndex(Container& container, const T& target)
    {
        using std::begin;   // for ADL
        using std::end;     // for ADL

        const auto itrBegin = begin(container);
        const auto itrEnd = end(container);
        const auto itr = std::find(itrBegin, itrEnd, target);

        return static_cast<std::ptrdiff_t>((itr == itrEnd) ? -1 : std::distance(itrBegin, itr));
    }

    /// @brief コンテナを別のコンテナ型に変換する。
    /// @tparam DestContainer
    ///     変換先のコンテナ型。
    ///     SrcContainer と同じ型であるか、
    ///     イテレータ範囲を受け取るコンストラクタが定義されていなければならない。
    /// @tparam SrcContainer 変換元のコンテナ型。引数から推論される。
    /// @param[in] src 変換元のコンテナ。
    /// @return 変換されたコンテナ。
    template<class DestContainer, class SrcContainer>
    inline DestContainer toContainer(SrcContainer&& src)
    {
        return
            ::amdaemon::util::detail::ContainerToContainer<DestContainer, SrcContainer>()(
                std::forward<SrcContainer>(src));
    }

    /// @brief インデックス値を引数に取る関数から得た値をコンテナに格納して返す。
    /// @tparam Container
    ///     変換先のコンテナ型。
    ///     std::back_insert_iterator による末尾への要素追加が可能でなければならない。
    /// @tparam SizeType
    ///     要素数を表す型。引数から推論される。
    ///     一般的な整数型の要件を満たしていなければならない。
    /// @tparam Getter
    ///     SizeType 型のインデックス値を引数に取る関数型。引数から推論される。
    ///     戻り値の型を Container の要素型に変換可能でなければならない。
    /// @param[in] count 要素数。
    /// @param[in] getter インデックス値を引数に取る関数。
    /// @return 作成されたコンテナ。
    template<class Container, class SizeType, class Getter>
    Container toContainer(SizeType count, Getter&& getter)
    {
        return
            ::amdaemon::util::detail::GetterToContainer<Container, SizeType, Getter>()(
                count,
                std::forward<Getter>(getter));
    }

    /// @brief 引数値を std::bitset 型に変換する。
    /// @tparam N ビット数。
    /// @tparam T
    ///     引数の型。引数から推論される。
    ///     std::bitset<N> 型のコンストラクタに受け渡し可能でなければならない。
    /// @param[in] value 引数値。
    /// @return std::bitset<N> 型の値。
    template<std::size_t N, class T>
    inline std::bitset<N> toBitset(T&& value)
    {
        return std::bitset<N>(std::forward<T>(value));
    }

    /// @brief 数値を std::bitset 型に変換する。
    /// @tparam Integer 数値型。引数から推論される。組み込みの整数型でなければならない。
    /// @param[in] value 数値。
    /// @return std::bitset<sizeof(Integer) * 8> 型の値。
    template<class Integer>
    inline auto toBitset(Integer value)
        ->
        typename std::enable_if<
            std::is_integral<Integer>::value,
            std::bitset<sizeof(Integer) * 8>>::type
    {
        return toBitset<sizeof(Integer) * 8>(value);
    }

/// @}
} // namespace util
} // namespace amdaemon

#endif // AMDAEMON_UTIL_CONTAINER_H