main.hxx

#pragma once
 
// C++
#include <exception>
#include <iostream>
#include <type_traits>
 
// cosmos
#include <cosmos/dso_export.h>
#include <cosmos/cosmos.hxx>
#include <cosmos/proc/types.hxx>
#include <cosmos/string.hxx>
#include <cosmos/utils.hxx>
 
namespace cosmos {
 
class MainNoArgs {
protected: // functions
 
        virtual ExitStatus main() = 0;
 
        template <typename MAIN>
        friend int main(const int argc, const char **argv);
};
 
class MainPlainArgs {
protected: // functions
 
        virtual ExitStatus main(const int argc, const char **argv) = 0;
 
        template <typename MAIN>
        friend int main(const int argc, const char **argv);
};
 
class MainContainerArgs {
protected: // functions
 
        virtual ExitStatus main(const std::string_view argv0, const StringViewVector &args) = 0;
 
        template <typename MAIN>
        friend int main(const int argc, const char **argv);
};
 
 
template <typename MAIN>
int main(const int argc, const char **argv) {
        try {
                cosmos::Init m_init;
                MAIN instance;
 
                try {
                        ExitStatus status;
 
                        if constexpr (std::is_base_of_v<MainNoArgs, MAIN>) {
                                status = static_cast<MainNoArgs&>(instance).main();
                        } else if constexpr (std::is_base_of_v<MainPlainArgs, MAIN>) {
                                status = static_cast<MainPlainArgs&>(instance).main(argc, argv);
                        } else if constexpr (std::is_base_of_v<MainContainerArgs, MAIN>) {
                                status = static_cast<MainContainerArgs&>(instance).main(
                                                std::string_view{argv[0]},
                                                StringViewVector{argv+1, argv+argc});
                        } else {
                                // we cannot use `false` here, because if the
                                // condition does not depend on the template
                                // parameter then it will still be evaluated,
                                // even if the else branch doesn't match
                                // during compile time!
                                static_assert(sizeof(MAIN) == 0, "MAIN type does not implement a main function interface");
                        }
 
                        return to_integral(status);
                } catch (const cosmos::ExitStatus status) {
                        return to_integral(status);
                } catch (const std::exception &ex) {
                        std::cerr << "Unhandled exception: " << ex.what() << std::endl;
                        return to_integral(ExitStatus::FAILURE);
                }
        } catch (const std::exception &ex) {
                // this outer exception handler handles exception thrown from
                // Init or MAIN constructors.
                std::cerr << "Error starting program: " << ex.what() << std::endl;
                return to_integral(ExitStatus::FAILURE);
        }
}
 
}; // end ns