FesaException.cpp

Go to the documentation of this file.

// Copyright CERN 2012 - Developed in collaboration with GSI

#include <fesa-core/Exception/FesaException.h>

#include <fesa-core/Core/AbstractEquipment.h>
#include <fesa-core/Utilities/Lock.h>
#include <fesa-core/Utilities/Mutex.h>
#include <fesa-core/Utilities/ProcessConfiguration.h>
#include <fesa-core/Utilities/StringUtilities.h>

#include <cmw-log/Logger.h>

#include <fstream>
#include <set>
#include <sstream>


namespace
{

CMW::Log::Logger& logger = CMW::Log::LoggerFactory::getLogger("FESA.FWK.fesa-core.Exception.FesaException");

static fesa::Mutex exceptionMutex;

}


namespace fesa
{

bool FesaException::messagesLoaded_ = false;
std::map<std::string, std::string> FesaException::messages_;

FesaException::FesaException() :
    errorCode_(""),
    file_(""),
    lineNumber_(-1)
{
}

FesaException::FesaException(const std::string& file, int32_t lineNumber, const std::string& message) :
    message_(message),
    file_(file),
    lineNumber_(lineNumber)
{
}

FesaException::FesaException(const std::string& file, int32_t lineNumber, const char* errorMessage, ...) :
    errorCode_(errorMessage),
    file_(file),
    lineNumber_(lineNumber)
{
    va_list vl;
    va_start(vl, errorMessage);
    buildMessage(vl);
    va_end(vl);
}

void FesaException::buildMessage(va_list vl)
{
    preloadMessages();

    // if the error code is not there then the message is the error code
    if (messages_.find(errorCode_) == messages_.end())
    {
        std::stringstream result;

        result << "Exception: " << errorCode_ << ". " << file_ << ":" << lineNumber_;
        message_ = result.str();
    }
    else
    {
        message_ = messages_[errorCode_];
        char* parameter = NULL;
        uint32_t i = 0;

        // replace the appearances of the strings $1,$2 ... by the parameters
        while (true)
        {
            ++i;
            char buf[8];
            int32_t nb = snprintf(buf, 8, "$%d", i);
            int32_t pos = static_cast<int32_t>(message_.find(buf, 0));
            if (pos == -1)
                break;

            parameter = NULL;
            parameter = va_arg(vl,char*);
            //if something looks starnge, just break ...we dont want to have a segmentation fault here
            if (parameter == NULL || parameter == (void*) -1)
                break;

            message_ = message_.replace(pos, nb, parameter);

        }
        std::stringstream result;

        result << "Exception: " << errorCode_ << " " << message_ << ". " << file_ << ":" << lineNumber_;
        message_ = result.str();

    }

}

FesaException::~FesaException() throw()
{
}

const char* FesaException::what() const throw()
{
    return message_.c_str();
}

const std::string& FesaException::getMessage() const
{
    return message_;
}

long FesaException::getErrorCodeAsLong()
{
    int32_t result;
    std::stringstream convert;

    std::string::iterator iter;
    for(iter=errorCode_.begin();iter!=errorCode_.end();iter++)
    {
        if(isdigit(*iter))//all digits found there
        {
            convert << *iter;
        }
    }
    convert >> result;
    return result;
}

void FesaException::preloadMessages()
{
    // Accessing shared data, protection is needed
    Lock lock(exceptionMutex);
    // Check if the messages have been loaded yet
    if (messagesLoaded_)
    {
        return;
    }
    const ProcessConfiguration* configuration = AbstractEquipment::getInstance()->getProcessConfiguration();
    const std::string msgConfigFileName = configuration->getMsgConfigFile();
    const std::string labMsgConfigFileName = configuration->getLabMsgConfigFile();
    loadMessagesFile(msgConfigFileName);
    {
        std::ostringstream infoStringStream;
        infoStringStream << "Exception messages loaded from " << msgConfigFileName;
        LOG_INFO_IF(logger, infoStringStream.str());
    }
    loadMessagesFile(labMsgConfigFileName);
    {
        std::ostringstream infoStringStream;
        infoStringStream << "Lab-specific exception messages loaded from " << labMsgConfigFileName;
        LOG_INFO_IF(logger, infoStringStream.str());
    }
    messagesLoaded_ = true;
}

void FesaException::loadMessagesFile(const std::string& file)
{
    try
    {
        std::ifstream ifs(file.c_str());

        if (ifs.fail())//failed to open?
        {
            //since we dont know where the exception-message file is, we have to use simple Exceptions here
            std::string message;
            message += "The Exception-Messagefile: '";
            message += file;
            message += "' is either empty, corrupt or does not exist !";
            throw FesaException(__FILE__, __LINE__,message);
        }
        else
        {
            //parameters
            std::set<std::string> options;
            options.insert("*");

            size_t sep1 = 0;
            std::string strLine;
            while(!ifs.eof())
            {
                getline(ifs,strLine);
                sep1 = strLine.find('=', 0);
                std::string string_key(strLine.substr(0, sep1));
                std::string value(strLine.substr(sep1+1, strLine.length()-sep1));
                FesaException::messages_[string_key] = value;
            }
        }
    }
    catch (std::exception e)
    {
        std::string message = e.what();
        throw FesaException(__FILE__, __LINE__,message);
    }

}

/****************************** EXCEPTION SPECIALIZATION ***********************************/

FesaBadConfigException::FesaBadConfigException(const std::string& file, int32_t lineNumber, const char* errorMessage,
                                               ...)
{
    errorCode_ = errorMessage;
    file_ = file;
    lineNumber_ = lineNumber;
    va_list vl;
    va_start(vl, errorMessage);
    buildMessage(vl);
    va_end(vl);
}

FesaBadConfigException::~FesaBadConfigException() throw ()
{

}

FesaIOException::FesaIOException(const std::string& file, int32_t lineNumber, const char* errorMessage, ...)
{
    errorCode_ = errorMessage;
    file_ = file;
    lineNumber_ = lineNumber;
    va_list vl;
    va_start(vl, errorMessage);
    buildMessage(vl);
    va_end(vl);
}

FesaIOException::~FesaIOException() throw ()
{

}

FesaBadParameterException::FesaBadParameterException(const std::string& file, int32_t lineNumber,
                                                     const char* errorMessage, ...)
{
    errorCode_ = errorMessage;
    file_ = file;
    lineNumber_ = lineNumber;
    va_list vl;
    va_start(vl, errorMessage);
    buildMessage(vl);
    va_end(vl);
}
FesaBadParameterException::~FesaBadParameterException() throw ()
{
}

FesaTypeMismatchException::FesaTypeMismatchException(const std::string& file, int32_t lineNumber,
                                                     const char* errorMessage, ...)
{
    errorCode_ = errorMessage;
    file_ = file;
    lineNumber_ = lineNumber;
    va_list vl;
    va_start(vl, errorMessage);
    buildMessage(vl);
    va_end(vl);
}

FesaTypeMismatchException::~FesaTypeMismatchException() throw ()
{
}

FesaInvalidResourceException::FesaInvalidResourceException(const std::string& file, int32_t lineNumber,
                                                           const char* errorMessage, ...)
{
    errorCode_ = errorMessage;
    file_ = file;
    lineNumber_ = lineNumber;
    va_list vl;
    va_start(vl, errorMessage);
    buildMessage(vl);
    va_end(vl);
}

FesaInvalidResourceException::~FesaInvalidResourceException() throw ()
{
}

FesaFileException::FesaFileException(const std::string& file, int32_t lineNumber, const char* errorMessage, ...)
{
    errorCode_ = errorMessage;
    file_ = file;
    lineNumber_ = lineNumber;
    va_list vl;
    va_start(vl, errorMessage);
    buildMessage(vl);
    va_end(vl);
}

FesaFileException::~FesaFileException() throw ()
{
}

} // fesa