AimeId.h

[詳解]

/// @file
/// @brief AimeのUID値を保持する構造体 AimeId のヘッダ。
///
/// Copyright(C)SEGA

#ifndef AMDAEMON_AIMEID_H
#define AMDAEMON_AIMEID_H

#include "amdaemon/env.h"

#include <string>
#include <cstdint>
#include <cstddef>

namespace amdaemon
{
/// @addtogroup g_aime
/// @{

    //--------------------
    // AimeId 構造体定義
    //--------------------

    /// @brief AimeのUID値を保持する構造体。
    /// @note memcpy 可能。
    /// @internal ライブラリ実装メモ: この型を直接共有メモリに配置する。
    struct AimeId
    {
        /// 内部値の表現型。
        typedef std::uint32_t value_type;

        /// UID値。
        value_type value;

        /// @brief AimeId 値を作成する。
        /// @param[in] value UID値。
        /// @return 作成された AimeId 値。
        static AimeId make(value_type value)
        {
            AimeId result = { value };
            return result;
        }

        /// @brief ゼロ値の AimeId 値を作成する。
        /// @return ゼロ値の AimeId 値。
        static AimeId zero()
        {
            return make(0);
        }

        /// @brief 無効な AimeId 値を作成する。
        /// @return 無効な AimeId 値。
        static AimeId makeInvalid()
        {
            return make(UINT32_MAX);
        }

        /// @brief 有効な値であるか否かを取得する。
        /// @retval true  有効な値である場合。
        /// @retval false 無効な値である場合。
        ///
        /// 内部値が 0 でも UINT32_MAX でもなければ true を返す。
        ///
        /// AiMeLibの規定する無効なUID値は UINT32_MAX のみだが、
        /// 実際のアプリではゼロ埋め初期化する実装もよくあるため、 0 も無効値として扱う。
        ///
        /// 一般に開放されているAimeのUID値は 10000 以上であるため、
        /// 0 を無効値として扱うことにより実店舗で問題となることはない。
        bool valid() const
        {
            return (value != 0 && value != UINT32_MAX);
        }

        /// @brief 文字列表現値を作成する。
        /// @return 文字列表現値。
        ///
        /// UID値を文字列化して返す。
        std::wstring toString() const
        {
            return std::to_wstring(value);
        }
    };

/// @}

    //--------------------
    // インライン関数定義
    //--------------------

    /// @brief 等価比較演算子のオーバロード。
    /// @param[in] l 左辺値。
    /// @param[in] r 右辺値。
    /// @return 比較結果値。
    /// @relatesalso AimeId
    inline bool operator==(const AimeId& l, const AimeId& r)
    {
        return (l.value == r.value);
    }

    /// @brief 非等価比較演算子のオーバロード。
    /// @param[in] l 左辺値。
    /// @param[in] r 右辺値。
    /// @return 比較結果値。
    /// @relatesalso AimeId
    inline bool operator!=(const AimeId& l, const AimeId& r)
    {
        return !(l == r);
    }

    /// @brief 小なり比較演算子のオーバロード。
    /// @param[in] l 左辺値。
    /// @param[in] r 右辺値。
    /// @return 比較結果値。
    /// @relatesalso AimeId
    inline bool operator<(const AimeId& l, const AimeId& r)
    {
        return (l.value < r.value);
    }

    /// @brief 大なり比較演算子のオーバロード。
    /// @param[in] l 左辺値。
    /// @param[in] r 右辺値。
    /// @return 比較結果値。
    /// @relatesalso AimeId
    inline bool operator>(const AimeId& l, const AimeId& r)
    {
        return (r < l);
    }

    /// @brief 小なり等価比較演算子のオーバロード。
    /// @param[in] l 左辺値。
    /// @param[in] r 右辺値。
    /// @return 比較結果値。
    /// @relatesalso AimeId
    inline bool operator<=(const AimeId& l, const AimeId& r)
    {
        return !(r < l);
    }

    /// @brief 大なり等価比較演算子のオーバロード。
    /// @param[in] l 左辺値。
    /// @param[in] r 右辺値。
    /// @return 比較結果値。
    /// @relatesalso AimeId
    inline bool operator>=(const AimeId& l, const AimeId& r)
    {
        return !(l < r);
    }
} // namespace amdaemon

namespace std
{
    // 前方宣言
    template<class T> struct hash;

    /// @brief ハッシュ値を求めるファンクタ構造体。
    ///
    /// std::hash クラステンプレートの amdaemon::AimeId 構造体に対する特殊化。
    template<>
    struct hash< ::amdaemon::AimeId >
    {
        /// 戻り値の型。
        typedef size_t result_type;

        /// 引数の型。
        typedef ::amdaemon::AimeId argument_type;

        /// @brief 引数のハッシュ値を取得する。
        /// @param[in] id 引数。
        /// @return ハッシュ値。
        result_type operator()(argument_type id) const
        {
            return static_cast<result_type>(id.value);
        }
    };
} // namespace std

#endif // AMDAEMON_AIMEID_H