FeliCaId.h

[詳解]

/// @file
/// @brief FeliCa IDm/PMm をラップする構造体 FeliCaId のヘッダ。
///
/// Copyright(C)SEGA

#ifndef AMDAEMON_FELICAID_H
#define AMDAEMON_FELICAID_H

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

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

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

    //--------------------
    // FeliCaId 構造体定義
    //--------------------

    /// @brief FeliCa IDm/PMm をラップする構造体。
    /// @note memcpy 可能。
    ///
    /// AiMeLibの AiMeDef::FeliCaID 構造体とバイナリ互換である。
    ///
    /// @internal ライブラリ実装メモ: この型を直接共有メモリに配置する。
    struct FeliCaId
    {
        /// 製造ID(IDm)構造体。
        struct IDm
        {
            std::uint16_t product;  ///< 製造者コード。
            std::uint16_t machine;  ///< 製造機器コード。
            std::uint16_t days;     ///< 2000年1月1日からの経過日数。
            std::uint16_t serial;   ///< シリアル番号。
        };

        /// 製造パラメータ(PMm)構造体。
        struct PMm
        {
            std::uint8_t rom;           ///< ROM種別値。
            std::uint8_t ic;            ///< IC種別値。
            std::uint8_t response[6];   ///< 最大応答時間パラメータ。
        };

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

        /// 内部値。 IDm と PMm をコピーしたバイナリ値。AiMeLib互換。
        std::uint8_t values[Size];

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

        /// @brief バイナリ値から FeliCaId 値を作成する。
        /// @param[in] values バイナリ値。
        /// @return 作成された FeliCaId 値。
        static FeliCaId make(const std::uint8_t (&values)[Size]);

        /// @brief IDm 値と PMm 値から FeliCaId 値を作成する。
        /// @param[in] idm IDm 値。
        /// @param[in] pmm PMm 値。
        /// @return 作成された FeliCaId 値。
        static FeliCaId make(const IDm& idm, const PMm& pmm);

        /// @brief IDm バイナリ値と PMm バイナリ値から FeliCaId 値を作成する。
        /// @param[in] idm IDm バイナリ値。
        /// @param[in] pmm PMm バイナリ値。
        /// @return 作成された FeliCaId 値。
        static FeliCaId make(
            const std::uint8_t (&idm)[sizeof(IDm)],
            const std::uint8_t (&pmm)[sizeof(PMm)]);

        /// @brief IDm 値を取得する。
        /// @return IDm 値。
        const IDm& getIDm() const;

        /// @brief PMm 値を取得する。
        /// @return PMm 値。
        const PMm& getPMm() const;

        /// @brief 文字列表現値を作成する。
        /// @return 文字列表現値。
        ///
        /// 内部データを16進数文字列に変換して返す。
        std::wstring toString() const;
    };

/// @}

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

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

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

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

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

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

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

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

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

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

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

#endif // AMDAEMON_FELICAID_H