fcml_errors.hpp

Go to the documentation of this file.

/*
 * FCML - Free Code Manipulation Library.
 * Copyright (C) 2010-2020 Slawomir Wojtasiak
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */

#ifndef FCML_ERRORS_HPP_
#define FCML_ERRORS_HPP_

#include <vector>

#include "fcml_types.h"
#include "fcml_errors.h"
#include "fcml_common.hpp"

namespace fcml {

class ErrorInfo {
public:

    enum ErrorLevel {
        EL_ERROR,
        EL_WARN
    };

public:

    ErrorInfo() :
        _code( FCML_CEH_GEC_NO_ERROR ),
        _level( EL_ERROR ) {
    }

    ErrorInfo( const fcml_cstring &message, fcml_ceh_error code = FCML_CEH_GEC_NO_ERROR, ErrorLevel level = EL_ERROR ) :
        _message( message ),
        _code( code ),
        _level( level ) {
    }

public:

    fcml_ceh_error getCode() const {
        return _code;
    }

    void setCode(fcml_ceh_error code) {
        _code = code;
    }

    ErrorLevel getLevel() const {
        return _level;
    }

    void setLevel(ErrorLevel level) {
        _level = level;
    }

    const fcml_cstring& getMessage() const {
        return _message;
    }

    void setMessage(const fcml_cstring& message) {
        _message = message;
    }

private:

    fcml_cstring _message;
    fcml_ceh_error _code;
    ErrorLevel _level;

};

class ErrorContainer {
public:

    ErrorContainer() :
        _isWarn(false),
        _isError(false) {
    }

    fcml_usize getSize() const {
        return static_cast<fcml_usize>( _errorInfos.size() );
    }

    const ErrorInfo& operator[]( fcml_usize index ) const {
        checkVectorAccess( index );
        return _errorInfos[index];
    }

    ErrorInfo& operator[]( fcml_usize index ) {
        checkVectorAccess( index );
        return _errorInfos[index];
    }

    void addErrorInfo( const ErrorInfo &errorInfo ) {
        _errorInfos.push_back(errorInfo);
        switch( errorInfo.getLevel() ) {
        case ErrorInfo::EL_ERROR:
            _isError = true;
            break;
        case ErrorInfo::EL_WARN:
            _isWarn = true;
            break;
        }
    }

    bool isError() const {
        return _isError;
    }

    bool isWarn() const {
        return _isWarn;
    }

    bool isEmpty() const {
        return _errorInfos.empty();
    }

    const ErrorInfo& getFirstError() const {
        if( isEmpty() ) {
            throw IllegalStateException( FCML_TEXT( "Container is empty." ) );
        }
        return _errorInfos[0];
    }

    ErrorInfo& getFirstError() {
        if( isEmpty() ) {
            throw IllegalStateException( FCML_TEXT( "Container is empty." ) );
        }
        return _errorInfos[0];
    }

    fcml_cstring getFirstErrorMessage() const {
        fcml_cstring message;
        try {
            const ErrorInfo &errorInfo = getFirstError();
            message = errorInfo.getMessage();
        } catch( IllegalStateException &exc ) {
        }
        return message;
    }

    fcml_cstring prepareErrorMessage( const fcml_cstring &message ) const {
        const fcml_cstring errorMessage = getFirstErrorMessage();
        if( errorMessage.empty() ) {
            return message + FCML_TEXT('.');
        } else {
            return message + FCML_TEXT(": ") + errorMessage;
        }
    }

    void clean() {
        _errorInfos.clear();
        _isWarn = false;
        _isError = false;
    }

private:

    void checkVectorAccess( fcml_usize index ) const {
        if( index >= _errorInfos.size() ) {
            throw BadArgumentException( FCML_TEXT( "Index exceeds the allowed number of error info structures." ) );
        }
    }

private:
    std::vector<ErrorInfo> _errorInfos;
    /* Sets if there is any warning in the container. */
    bool _isWarn;
    /* Sets if there is any error in the container. */
    bool _isError;
};

class ErrorTypeConverter {
public:

    static void convert( const fcml_st_ceh_error_container &src, ErrorContainer &dest ) {
        fcml_st_ceh_error_info *error = src.errors;
        while( error ) {
            ErrorInfo::ErrorLevel level = ( error->level == FCML_EN_CEH_EL_ERROR ) ? ErrorInfo::EL_ERROR : ErrorInfo::EL_WARN;
            dest.addErrorInfo( ErrorInfo( error->message, error->code, level ) );
            error = error->next_error;
        }
    }

};

class ErrorContainerAwareException: public BaseException {
public:

    ErrorContainerAwareException( const fcml_cstring &msg, const ErrorContainer &errorContainer, fcml_ceh_error error = FCML_CEH_GEC_NO_ERROR ) :
            BaseException( msg, error ), _errorContainer( errorContainer ) {
    }

    const ErrorContainer& getErrorContainer() const {
        return _errorContainer;
    }

    void setErrorContainer(const ErrorContainer& errorContainer) {
        _errorContainer = errorContainer;
    }

private:

    ErrorContainer _errorContainer;

};

}

#endif  // FCML_ERRORS_HPP_