/*---------------------------------------------------------------------------*

  Copyright (C) 2009-2013 Nintendo.  All rights reserved.

  These coded instructions, statements, and computer programs contain
  proprietary information of Nintendo of America Inc. and/or Nintendo
  Company Ltd., and are protected by Federal copyright law.  They may
  not be disclosed to third parties or copied or duplicated in any form,
  in whole or in part, without the prior written consent of Nintendo.

 *---------------------------------------------------------------------------*/
template <Result::LegacyLevel TLevel, Result::Summary TSummary, Result::Module TModule, int TDescription>
struct Result::Const : public Result
{
    static const Result::LegacyLevel Level = TLevel;
    static const Result::Summary Summary = TSummary;
    static const Result::Module Module = TModule;
    static const int Description = TDescription;

    static const bit32 Value = TemplateMakeLegacyResult<TLevel, TSummary, TModule, TDescription>::Value;

    Const() : Result(Value) {}

    static bool Includes(Result result) { return result.GetValue() == Value; }
    friend bool operator<=(Result lhs, const Const<TLevel, TSummary, TModule, TDescription>& rhs) { return Includes(lhs); }
    friend bool operator>=(const Const<TLevel, TSummary, TModule, TDescription>, Result rhs) { return Includes(rhs); }
};

template <Result::LegacyLevel TLevel, Result::Summary TSummary, Result::Module TModule>
struct Result::Const_LSM : public Result
{
    static const Result::LegacyLevel Level = TLevel;
    static const Result::Summary Summary = TSummary;
    static const Result::Module Module = TModule;

    template <int TDescription>
    struct Const : public Result::Const<TLevel, TSummary, TModule, TDescription> {};

    Const_LSM(int description) : Result(TLevel, TSummary, TModule, description) {}

    bool Includes(Result result) { return result == *this; }
    friend bool operator<=(Result lhs, const Const_LSM<TLevel, TSummary, TModule>&) { return Includes(lhs); }
    friend bool operator>=(const Const_LSM<TLevel, TSummary, TModule>&, Result rhs) { return Includes(rhs); }
};

template <Result::LegacyLevel TLevel, Result::Module TModule>
struct Result::Const_LM : public Result
{
    static const Result::LegacyLevel Level = TLevel;
    static const Result::Module Module = TModule;

    template <Result::Summary TSummary, int TDescription>
    struct Const : public Result::Const<TLevel, TSummary, TModule, TDescription> {};

    Const_LM(Result::Summary summary, int description) : Result(TLevel, summary, TModule, description) {}

    bool Includes(Result result) { return result == *this; }
    friend bool operator<=(Result lhs, const Const_LM<TLevel, TModule>&) { return Includes(lhs); }
    friend bool operator>=(const Const_LM<TLevel, TModule>&, Result rhs) { return Includes(rhs); }
};

template <Result::LegacyLevel TLevel>
struct Result::Const_L : public Result
{
    static const Result::LegacyLevel Level = TLevel;

    template <Result::Summary TSummary, Result::Module TModule, int TDescription>
    struct Const : public Result::Const<TLevel, TSummary, TModule, TDescription> {};

    Const_L(Result::Summary summary, Result::Module module, int description) : Result(TLevel, summary, module, description) {}

    bool Includes(Result result) { return result == *this; }
    friend bool operator<=(Result lhs, const Const_L<TLevel>&) { return Includes(lhs); }
    friend bool operator>=(const Const_L<TLevel>&, Result rhs) { return Includes(rhs); }
};

#define NN_DEFINE_RESULT_CONST(name, level, summary, module, description) \
    typedef ::nn::Result::Const<(level), (summary), (module), (description)> name

#define NN_DEFINE_RESULT_FUNC_LSM(name, level, summary, module) \
    typedef ::nn::Result::Const_LSM<(level), (summary), (module)> name

#define NN_DEFINE_RESULT_CONST_LSM(name, f, description) \
    typedef f::Const<(description)> name

#define NN_DEFINE_RESULT_FUNC_LM(name, level, module) \
    typedef ::nn::Result::Const_LM<(level), (module)> name

#define NN_DEFINE_RESULT_CONST_LM(name, f, summary, description) \
    typedef f::Const<(summary), (description)> name

#define NN_DEFINE_RESULT_FUNC_L(name, level) \
    typedef ::nn::Result::Const_L<(level)> name

#define NN_DEFINE_RESULT_CONST_L(name, f, summary, module, description) \
    typedef f::Const<(summary), (module), (description)> name

inline Result MakeInfoResult(Result::Summary summary, Result::Module module, int description)
    { return Result(Result::LEVEL_INFO, summary, module, description); }
inline Result MakeFatalResult(Result::Summary summary, Result::Module module, int description)
    { return Result(Result::LEVEL_FATAL, summary, module, description); }
inline Result MakeResetResult(Result::Summary summary, Result::Module module, int description)
    { return Result(Result::LEVEL_RESET, summary, module, description); }
inline Result MakeReInitResult(Result::Summary summary, Result::Module module, int description)
    { return Result(Result::LEVEL_REINIT, summary, module, description); }
inline Result MakeUsageResult(Result::Summary summary, Result::Module module, int description)
    { return Result(Result::LEVEL_USAGE, summary, module, description); }
inline Result MakePermanentResult(Result::Summary summary, Result::Module module, int description)
    { return Result(Result::LEVEL_PERMANENT, summary, module, description); }
inline Result MakeTemporaryResult(Result::Summary summary, Result::Module module, int description)
    { return Result(Result::LEVEL_TEMPORARY, summary, module, description); }
inline Result MakeStatusResult(Result::Summary summary, Result::Module module, int description)
    { return Result(Result::LEVEL_STATUS, summary, module, description); }