result.h

Go to the documentation of this file.

#pragma once
#include <wut.h>
 
typedef struct NNResult NNResult;
 
struct NNResult
{
   int32_t value;
};
 
static inline int NNResult_IsSuccess(NNResult result)
{
   return result.value >= 0;
}
 
static inline int NNResult_IsFailure(NNResult result)
{
   return result.value < 0;
}
 
#ifdef __cplusplus
 
namespace nn
{
 
class Result
{
public:
   enum Level
   {
      LEVEL_SUCCESS                       = 0,
      LEVEL_FATAL                         = -1,
      LEVEL_USAGE                         = -2,
      LEVEL_STATUS                        = -3,
      LEVEL_END                           = -7,
   };
 
   enum LegacyLevel
   {
      LEVEL_INFO                          = 1,
      LEVEL_RESET                         = -4,
      LEVEL_REINIT                        = -5,
      LEVEL_PERMANENT                     = -6,
      LEVEL_TEMPORARY                     = -7,
   };
 
   enum Module
   {
      RESULT_MODULE_COMMON                = 0,
      RESULT_MODULE_NN_IPC                = 1,
      RESULT_MODULE_NN_BOSS               = 2,
      RESULT_MODULE_NN_ACP                = 3,
      RESULT_MODULE_NN_IOS                = 4,
      RESULT_MODULE_NN_NIM                = 5,
      RESULT_MODULE_NN_PDM                = 6,
      RESULT_MODULE_NN_ACT                = 7,
      RESULT_MODULE_NN_NGC                = 8,
      RESULT_MODULE_NN_ECA                = 9,
      RESULT_MODULE_NN_NUP                = 10,
      RESULT_MODULE_NN_NDM                = 11,
      RESULT_MODULE_NN_FP                 = 12,
      RESULT_MODULE_NN_AC                 = 13,
      RESULT_MODULE_NN_CONNTEST           = 14,
      RESULT_MODULE_NN_DRMAPP             = 15,
      RESULT_MODULE_NN_TELNET             = 16,
      RESULT_MODULE_NN_OLV                = 17,
      RESULT_MODULE_NN_VCTL               = 18,
      RESULT_MODULE_NN_NEIA               = 19,
      RESULT_MODULE_NN_SPM                = 20,
      RESULT_MODULE_NN_EMD                = 21,
      RESULT_MODULE_NN_EC                 = 22,
      RESULT_MODULE_NN_CIA                = 23,
      RESULT_MODULE_NN_SL                 = 24,
      RESULT_MODULE_NN_ECO                = 25,
      RESULT_MODULE_NN_TRIAL              = 26,
      RESULT_MODULE_NN_NFP                = 27,
      RESULT_MODULE_NN_TEST               = 125,
   };
 
   enum LegacyModule
   {
      MODULE_COMMON                       = 0,
      MODULE_NN_KERNEL                    = 1,
      MODULE_NN_UTIL                      = 2,
      MODULE_NN_FILE_SERVER               = 3,
      MODULE_NN_LOADER_SERVER             = 4,
      MODULE_NN_TCB                       = 5,
      MODULE_NN_OS                        = 6,
      MODULE_NN_DBG                       = 7,
      MODULE_NN_DMNT                      = 8,
      MODULE_NN_PDN                       = 9,
      MODULE_NN_GX                        = 0xA,
      MODULE_NN_I2C                       = 0xB,
      MODULE_NN_GPIO                      = 0xC,
      MODULE_NN_DD                        = 0xD,
      MODULE_NN_CODEC                     = 0xE,
      MODULE_NN_SPI                       = 0xF,
      MODULE_NN_PXI                       = 0x10,
      MODULE_NN_FS                        = 0x11,
      MODULE_NN_DI                        = 0x12,
      MODULE_NN_HID                       = 0x13,
      MODULE_NN_CAMERA                    = 0x14,
      MODULE_NN_PI                        = 0x15,
      MODULE_NN_PM                        = 0x16,
      MODULE_NN_PMLOW                     = 0x17,
      MODULE_NN_FSI                       = 0x18,
      MODULE_NN_SRV                       = 0x19,
      MODULE_NN_NDM                       = 0x1A,
      MODULE_NN_NWM                       = 0x1B,
      MODULE_NN_SOCKET                    = 0x1C,
      MODULE_NN_LDR                       = 0x1D,
      MODULE_NN_ACC                       = 0x1E,
      MODULE_NN_ROMFS                     = 0x1F,
      MODULE_NN_AM                        = 0x20,
      MODULE_NN_HIO                       = 0x21,
      MODULE_NN_UPDATER                   = 0x22,
      MODULE_NN_MIC                       = 0x23,
      MODULE_NN_FND                       = 0x24,
      MODULE_NN_MP                        = 0x25,
      MODULE_NN_MPWL                      = 0x26,
      MODULE_NN_AC                        = 0x27,
      MODULE_NN_HTTP                      = 0x28,
      MODULE_NN_DSP                       = 0x29,
      MODULE_NN_SND                       = 0x2A,
      MODULE_NN_DLP                       = 0x2B,
      MODULE_NN_HIOLOW                    = 0x2C,
      MODULE_NN_CSND                      = 0x2D,
      MODULE_NN_SSL                       = 0x2E,
      MODULE_NN_AMLOW                     = 0x2F,
      MODULE_NN_NEX                       = 0x30,
      MODULE_NN_FRIENDS                   = 0x31,
      MODULE_NN_RDT                       = 0x32,
      MODULE_NN_APPLET                    = 0x33,
      MODULE_NN_NIM                       = 0x34,
      MODULE_NN_PTM                       = 0x35,
      MODULE_NN_MIDI                      = 0x36,
      MODULE_NN_MC                        = 0x37,
      MODULE_NN_SWC                       = 0x38,
      MODULE_NN_FATFS                     = 0x39,
      MODULE_NN_NGC                       = 0x3A,
      MODULE_NN_CARD                      = 0x3B,
      MODULE_NN_CARDNOR                   = 0x3C,
      MODULE_NN_SDMC                      = 0x3D,
      MODULE_NN_BOSS                      = 0x3E,
      MODULE_NN_DBM                       = 0x3F,
      MODULE_NN_CFG                       = 0x40,
      MODULE_NN_PS                        = 0x41,
      MODULE_NN_CEC                       = 0x42,
      MODULE_NN_IR                        = 0x43,
      MODULE_NN_UDS                       = 0x44,
      MODULE_NN_PL                        = 0x45,
      MODULE_NN_CUP                       = 0x46,
      MODULE_NN_GYROSCOPE                 = 0x47,
      MODULE_NN_MCU                       = 0x48,
      MODULE_NN_NS                        = 0x49,
      MODULE_NN_NEWS                      = 0x4A,
      MODULE_NN_RO                        = 0x4B,
      MODULE_NN_GD                        = 0x4C,
      MODULE_NN_CARDSPI                   = 0x4D,
      MODULE_NN_EC                        = 0x4E,
      MODULE_NN_WEBBRS                    = 0x4F,
      MODULE_NN_TEST                      = 0x50,
      MODULE_NN_ENC                       = 0x51,
      MODULE_NN_PIA                       = 0x52,
      MODULE_APPLICATION                  = 0x1FE,
   };
 
   enum LegacySummary
   {
      SUMMARY_SUCCESS                     = 0,
      SUMMARY_NOTHING_HAPPENED            = 1,
      SUMMARY_WOULD_BLOCK                 = 2,
      SUMMARY_OUT_OF_RESOURCE             = 3,
      SUMMARY_NOT_FOUND                   = 4,
      SUMMARY_INVALID_STATE               = 5,
      SUMMARY_NOT_SUPPORTED               = 6,
      SUMMARY_INVALID_ARGUMENT            = 7,
      SUMMARY_WRONG_ARGUMENT              = 8,
      SUMMARY_CANCELLED                   = 9,
      SUMMARY_STATUS_CHANGED              = 10,
      SUMMARY_INTERNAL                    = 11,
   };
 
   enum LegacySignature
   {
      SIGNATURE_IS_LEGACY                 = 3,
   };
 
public:
   Result() :
      mValue(0)
   {
   }
 
   Result(Level level, Module module, unsigned description) :
      mValue(((level & 0x7) << 29) | ((module & 0x1FF) << 20) | (description & 0xFFFFF))
   {
   }
 
   Result(const NNResult &result) :
      mValue(result.value)
   {
   }
 
   bool IsFailure() const
   {
      return !IsSuccess();
   }
 
   bool IsSuccess() const
   {
      return mValue >= 0; // level >= 0
   }
 
   bool IsLegacy() const
   {
      return ((mValue >> 27) & 0x3) == SIGNATURE_IS_LEGACY;
   }
 
   unsigned GetDescription() const
   {
      return mValue & (IsLegacy() ? 0x3FF : 0xFFFFF);
   }
 
   int GetLevel() const
   {
      if (IsLegacy()) {
         return (mValue << 14) >> 28; // cause arithmetic shift
      }
 
      return mValue >> 29;
   }
 
   unsigned GetModule() const
   {
      return (mValue >> 20) & (IsLegacy() ? 0x7F : 0x1FF);
   }
 
   unsigned GetSummary() const
   {
      if (IsLegacy()) {
         return (mValue >> 10) & 0xF;
      }
 
      return 0;
   }
 
   operator bool() const
   {
      return IsSuccess();
   }
 
   operator NNResult() const
   {
      NNResult result;
      result.value = mValue;
      return result;
   }
 
   bool operator==(const Result &other) const
   {
      return mValue == other.mValue;
   }
 
   bool operator!=(const Result &other) const
   {
      return mValue != other.mValue;
   }
 
private:
   int32_t mValue;
};
 
} // namespace nn
 
#endif // ifdef __cplusplus