main.cpp

Go to the documentation of this file.

/**
 * \file main.cpp
 * \brief Main entry point for the n-body simulation benchmark.
 * \author Le Bars, Yoann
 *
 * This file is part of the pure C++ benchmark.
 *
 * This program is free software: you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the Free
 * Software Foundation, either version 3 of the License, or (at your option)
 * any later version.
 *
 * This program 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 General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along with
 * this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * This program simulates the gravitational interaction of multiple bodies in 3D
 * space.
 *
 * For a full list of command-line options and their descriptions, run the
 * executable with the `--help` flag:
 * \code{.sh}
 * ./pure-cpp --help
 * \endcode
 */
 
#include <QApplication>
#include <QDebug>
#include <QObject>
#include <boost/program_options.hpp>
#include <exception>
 
#include "app_manager.hpp"
#include "app_profiler.hpp"
#include "cmd_line_parser.hpp"
 
/**
 * \brief Namespace for application-wide utility functions, primarily for
 *        exception handling.
 */
namespace AppUtils {
    /**
     * \brief Handles logging an exception message and returning the appropriate
     *        exit code.
     *
     * \param message The translated error message to be logged.
     * \param code The exit code to be returned.
     *
     * \return The integer value of the exit code.
     */
    int handleException(const QString& message, CmdLine::ExitCode code) {
        qCritical().noquote() << message;
        return static_cast<int>(code);
    }
 
    // Overload for exceptions that don’t have a .what() message.
    /**
     * \brief Overload for handling exceptions with a simple C-string message.
     *
     * \param message The non-translated error message.
     * \param code The exit code to be returned.
     *
     * \return The integer value of the exit code.
     */
    int handleException(const char* message, CmdLine::ExitCode code) {
        // Use the QObject::tr context for translation.
        return handleException(QObject::tr(message), code);
    }
}
 
/**
 * \brief The main entry point for the application.
 *
 * \param argc Count of arguments transmitted to the program.
 * \param argv Values of arguments transmitted to the program.
 *
 * \return 0 if everything went well,
 *     otherwise, a negative value corresponding to an ExitCode.
 */
int main(int argc, char* argv[]) {
    // The QApplication must be created first, as it initializes Qt's core.
    AppUtils::AppProfiler::startQtInit();
    QApplication app(argc, argv);
    AppUtils::AppProfiler::stopQtInit();
 
    /* This top-level try-catch block acts as a final exception boundary for
       the entire application. */
    try {
        App::AppManager manager;  // NOLINT
        if (!manager.setup()) {
            return static_cast<int>(CmdLine::ExitCode::Success);
        }
        return manager.run();
    } catch (const po::error& e) {
        // This catch block is now mainly for errors during parsing itself.
        return AppUtils::handleException(
            QObject::tr("Command line error: %1").arg(e.what()),
            CmdLine::ExitCode::CmdLineError);
    } catch (const std::out_of_range& e) {
        return AppUtils::handleException(
            QObject::tr("Out of range index error: "
                        "%1")
                .arg(e.what()),
            CmdLine::ExitCode::OutOfRange);
    } catch (const std::bad_alloc& e) {
        return AppUtils::handleException("Error: not enough memory.",
                                         CmdLine::ExitCode::BadAlloc);
    } catch (const std::exception& e) {
        return AppUtils::handleException(
            QObject::tr("An unexpected error occurred: "
                        "%1")
                .arg(e.what()),
            CmdLine::ExitCode::StdException);
    } catch (...) {
        return AppUtils::handleException("An unknown exception occurred.",
                                         CmdLine::ExitCode::UnknownException);
    }
}