NET_Error.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * NAME:        NET_Error.h
 *
 * COMMENTS:
 *
 */

#ifndef __NET_ERROR_H__
#define __NET_ERROR_H__

#include "NET_API.h"

#include "NET_UniversalLogNetworkingSource.h"

#include <UT/UT_Assert.h>
#include <UT/UT_Error.h>
#include <UT/UT_ErrorManager.h>
#include <UT/UT_StringHolder.h>

enum NET_ErrorCodes
{
    // Curl errors
    NET_ERR_CURL,

    // Sqlite errors
    NET_ERR_SQLITE,

    // Network Manager errors
    NET_ERR_NET_MGR,

    // Stats Manager errors
    NET_ERR_STATS_MGR,

    // SSL Engine errors
    NET_ERR_SSL,

    // Authentication errors
    NET_ERR_AUTH
};

class NET_API NET_Error
{
public:
    static UT_StringHolder errorCode(int code)
    {
        switch(code)
        {
        case NET_ERR_CURL:
            return "HTTP Client";
        case NET_ERR_SQLITE:
            return "Sqlite";
        case NET_ERR_NET_MGR:
            return "General";
        case NET_ERR_STATS_MGR:
            return "Stats";
        case NET_ERR_SSL:
            return "SSL Engine";
        case NET_ERR_AUTH:
            return "Auth";
        default:
            break;
        };
        return UT_StringHolder::theEmptyString;
    }
};

template <typename... Args>
void
NETaddMessage(NET_LogManager& mgr, int code, const char* fmt, Args&&... args)
{
    NETlogMessage(
            mgr, NET_Error::errorCode(code), fmt, std::forward<Args>(args)...);
}
template <typename... Args>
void
NETaddPrompt(NET_LogManager& mgr, int code, const char* fmt, Args&&... args)
{
    NETlogPrompt(
            mgr, NET_Error::errorCode(code), fmt, std::forward<Args>(args)...);
}

template <typename... Args>
void
NETaddWarning(NET_LogManager& mgr, int code, const char* fmt, Args&&... args)
{
    NETlogWarning(
            mgr, NET_Error::errorCode(code), fmt, std::forward<Args>(args)...);
}

template <typename... Args>
void
NETaddError(NET_LogManager& mgr, int code, const char* fmt, Args&&... args)
{
    NETlogError(
            mgr, NET_Error::errorCode(code), fmt, std::forward<Args>(args)...);
}

template <typename... Args>
void
NETaddFatal(NET_LogManager& mgr, int code, const char* fmt, Args&&... args)
{
    NETlogFatal(NET_Error::errorCode(code), fmt, std::forward<Args>(args)...);
}

// -----------------------------------------------------------------------------
// Adds errors to general error manager.
// -----------------------------------------------------------------------------

template <typename... Args>
void
NETaddMessage(int code, const char* fmt, Args&&... args)
{
    NETlogMessage(NET_Error::errorCode(code), fmt, std::forward<Args>(args)...);
}
template <typename... Args>
void
NETaddPrompt(int code, const char* fmt, Args&&... args)
{
    NETlogPrompt(NET_Error::errorCode(code), fmt, std::forward<Args>(args)...);
}

template <typename... Args>
void
NETaddWarning(int code, const char* fmt, Args&&... args)
{
    NETlogWarning(NET_Error::errorCode(code), fmt, std::forward<Args>(args)...);
}

template <typename... Args>
void
NETaddError(int code, const char* fmt, Args&&... args)
{
    NETlogError(NET_Error::errorCode(code), fmt, std::forward<Args>(args)...);
}

template <typename... Args>
void
NETaddFatal(int code, const char* fmt, Args&&... args)
{
    NETlogFatal(NET_Error::errorCode(code), fmt, std::forward<Args>(args)...);
}

#endif // __NET_ERROR_H__