AimeOfflineId.h

[詳解]

/// @file
/// @brief オフラインでAimeを識別するためのID値構造体 AimeOfflineId のヘッダ。
///
/// Copyright(C)SEGA

#ifndef AMDAEMON_AIMEOFFLINEID_H
#define AMDAEMON_AIMEOFFLINEID_H

#include "amdaemon/env.h"
#include "amdaemon/AccessCode.h"
#include "amdaemon/FeliCaId.h"
#include "amdaemon/util/StaticAssert.h"

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

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

    //--------------------
    // AimeOfflineId 構造体定義
    //--------------------

    /// @brief オフラインでAimeを識別するためのID値構造体。
    /// @note memcpy 可能。
    /// @internal ライブラリ実装メモ: この型を直接共有メモリに配置する。
    struct AimeOfflineId
    {
        /// 内部データ種別列挙。
        enum class Type : std::uint8_t
        {
            None = 0,   ///< なし。無効値扱いとなる。

            /// @brief アクセスコード値。
            ///
            /// Aimeカード、バナパスポートカード、キャラEdyではこちらが使われる。
            AccessCode,

            /// @brief FeliCaId 値。
            ///
            /// おサイフケータイ、共通アミューズメントICカードではこちらが使われる。
            FeliCaId,
        };

        /// 内部データ共用体。
        union DataUnion
        {
            AccessCode accessCode;  ///< アクセスコード値。
            FeliCaId feliCaId;      ///< FeliCaId 値。
        };

        /// 内部値サイズ。
        static const std::size_t Size = sizeof(Type) + sizeof(DataUnion);

        /// 内部値。種別列挙値と内部データをコピーしたバイナリ値。
        std::uint8_t values[Size];

        /// @brief ゼロ埋めされた無効な AimeOfflineId 値を取得する。
        /// @return ゼロ埋めされた無効な AimeOfflineId 値。
        static const AimeOfflineId& zero();

        /// @brief アクセスコード値から AimeOfflineId 値を作成する。
        /// @param[in] accessCode アクセスコード値。
        /// @return 作成された AimeOfflineId 値。
        ///
        /// 引数 accessCode が無効値であっても構わず作成する。
        static AimeOfflineId make(const AccessCode& accessCode);

        /// @brief FeliCaId 値から AimeOfflineId 値を作成する。
        /// @param[in] feliCaId FeliCaId 値。
        /// @return 作成された AimeOfflineId 値。
        static AimeOfflineId make(const FeliCaId& feliCaId);

        /// @brief 有効な値であるか否かを取得する。
        /// @retval true  有効な値である場合。
        /// @retval false 無効な値である場合。
        bool valid() const;

        /// @brief 内部データ種別値を取得する。
        /// @return 内部データ種別値。
        ///
        /// 無効値であっても保持している値をそのまま返すため、
        /// 列挙値として定義されていない値を返す場合がある。
        ///
        /// この値でAime種別を一意に判別することはできない。
        Type getType() const;

        /// @brief 内部データ値を取得する。
        /// @return 内部データ値。
        /// @see getType
        ///
        /// 内部データ種別によって参照すべきデータが異なる。
        /// 参照すべきデータ以外を参照した場合の値は不定値となる。
        const DataUnion& getData() const;

        /// @brief 文字列表現値を作成する。
        /// @return 文字列表現値。
        ///
        /// 内部データ種別と内部データの文字列表現値を文字 ':' で連結して返す。
        /// 内部データ種別が無効値である場合は空文字列を返す。
        std::wstring toString() const;
    };

/// @}

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

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

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

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

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

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

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

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

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

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

        /// @brief 引数のハッシュ値を取得する。
        /// @param[in] id 引数。
        /// @return ハッシュ値。
        result_type operator()(const argument_type& id) const
        {
            // 先頭から sizeof(result_type) バイトを用いる
            AMDAEMON_STATIC_ASSERT(sizeof(id.values) >= sizeof(result_type));
            return *reinterpret_cast<const result_type*>(id.values);
        }
    };
} // namespace std

#endif // AMDAEMON_AIMEOFFLINEID_H