app.cpp

//##################################################################################################
//  ALib C++ Framework
//
//  Copyright 2013-2025 A-Worx GmbH, Germany
//  Published under 'Boost Software License' (a free software license, see LICENSE.txt)
//##################################################################################################
#include "alib_precompile.hpp"
#if !defined(ALIB_C20_MODULES) || ((ALIB_C20_MODULES != 0) && (ALIB_C20_MODULES != 1))
#   error "Configuration MACRO ALIB_C20_MODULES has to be given to the compiler as either 0 or 1"
#endif
#if ALIB_C20_MODULES
    module;
#endif
 
//========================================= Global Fragment ========================================
#include "alib/strings/strings.prepro.hpp"
#include "alib/app/app.prepro.hpp"
#include "ALib.Monomem.StdContainers.H"
//============================================== Module ============================================
#if ALIB_C20_MODULES
    module ALib.App;
    import   ALib.App.Impl;
    import   ALib.Lang;
    import   ALib.Strings;
    import   ALib.Boxing;
    import   ALib.EnumRecords;
    import   ALib.EnumRecords.Bootstrap;
    import   ALib.Variables;
#else
#   include "ALib.App.H"
#   include "ALib.Camp.Base.H"
#   include "ALib.Bootstrap.H"
#   include "ALib.ALox.Impl.H"
#   include "ALib.Resources.H"
#endif
//========================================== Implementation ========================================
 
namespace alib::app {
 
App* APP_SINGLETON= nullptr;
 
 
App::App(camp::Camp* camp)
: appCamp(camp) {
    stopWatch.Reset();
 
    ALIB_ASSERT_ERROR(!APP_SINGLETON, "ALIB/APP",
        "A second instance of the App-singleton was created, which is forbidden.")
    APP_SINGLETON= this;
 
    machine.Program.reserve( size_t(States::CNTD_BUILTIN_STATES) + 10 );
    
    machine.Program.insert( machine.Program.end(),  {
         { States::SetCamps              , &App::onBsSetCamps              },
         { States::PrepareResources      , &App::onBsPrepareResources      },
         { States::SetNameVersionAndInfo , &App::onBsSetNameVersionAndInfo },
         { States::PrepareConfig         , &App::onBsPrepareConfig         },
         { States::PreloadVariables      , &App::onBsPreloadVariables      },
         { States::ImportConfig          , &App::onBsImportConfig         },
         { States::FinalizeBootstrap     , &App::onBsFinalizeBootstrap     },
         { States::SetupALox             , &App::onBsSetupALox             },
         { States::RunStart              , &App::onRunStart                },
         { States::Run                   , &App::onRun                     },
         { States::RunEnd                , &App::onRunEnd                  },
         { States::AnnounceShutdown      , &App::onSdAnnounceShutdown      },
         { States::CleanALox             , &App::onSdCleanALox             },
         { States::ExportConfig          , &App::onSdExportConfig          },
         { States::Output                , &App::onSdOutput                },
         { States::FinalizeShutdown      , &App::onSdFinalizeShutdown      },
    });
}
 
App::~App()                                                                                       {}
 
int App::Main( int argc, const char** argv, const wchar_t** argvw ) {
    ARG_C=   argc;
    ARG_VN=  argv;
    ARG_VW=  argvw;
 
    for (StateMachine::Command& cmd : machine.Program )
        try {
            // transition the state machine "State"
            machine.State= cmd.State;
 
            // built-in step?
            if ( cmd.State.IsEnumType<App::States>() ) {
                // transition the state machine "BuiltInState"
                machine.BuiltInState= cmd.State.Get<States>();
                (this->*cmd.Method.BuiltIn)();
            } else {
                (*cmd.Method.Custom)(*this);
            }
 
            // with emergencies, we stop processing
            if ( machine.EmergencyStop )
                break;
 
        // exceptions are converted to exit codes and displayed. A custom conversion implementation
        // may take the current app-state into account to determine the right exit code.
        } catch( Exception& e ) {
            if (e.Type() == Exceptions::ControlledEarlyExit) {
                ALIB_ASSERT_ERROR(machine.BuiltInState == States::Run, "APP",
                   "Exceptions::ControlledEarlyExit thrown while not in States::Run")
                ALIB_ASSERT_ERROR(machine.GetExitCode().Integral() != 0, "APP",
                   "Exceptions::ControlledEarlyExit thrown without having exit code set")
            }
            else
                machine.SetExitCode( exceptionToExitCode(e) );
            exceptionDisplay(e, cErr->Buffer);
        }
 
        // System exceptions should be handled by the descendant.
        catch( std::runtime_error& e ) {
            cErr->Add("Unhandled system exception: ", e.what());
            machine.SetExitCode( App::BuiltInExitCodes::ErrUnknown );
            #if ALIB_DEBUG
                onSdOutput();
                ALIB_WARNING("APP", "System exception not handled. "
                                    "This should be done by the user of class ALib App.")
            #endif
        }
 
        if (machine.EmergencyStop) {
            // finish bootstrapping of ALib, to be able to duly shutdown.
            if ( machine.BuiltInState < States::FinalizeBootstrap )
                Bootstrap();
 
            // shutdown ALib
            if ( machine.BuiltInState < States::FinalizeShutdown)
                Shutdown();
        }
 
    return machine.GetExitCode().Integral<int>();
}
 
 
//##################################################################################################
// Helpers
//##################################################################################################
 
Enum  App::exceptionToExitCode( alib::Exception& e ) {
 
    // Exceptions from ALib module Variables -> either read or write of INI-files failed.
    if ( e.Type().IsEnumType<variables::Exceptions>() ) {
        auto element= e.Type().Get<variables::Exceptions>();
 
        if (    machine.BuiltInState==States::ImportConfig
             && element==variables::Exceptions::ErrorOpeningFile )
                return BuiltInExitCodes::ErrConfigFileNotFound;
 
        if (    machine.BuiltInState==States::ImportConfig
             && element==variables::Exceptions::ErrorWritingFile )
                return BuiltInExitCodes::ErrConfigFileNotWritable;
    }
 
    return Enum(BuiltInExitCodes::ErrUnknown);
}
 
void  App::exceptionDisplay( alib::Exception& exception, AString& target ) {
    if (exception.Type()== Exceptions::ControlledEarlyExit) {
        #if ALIB_DEBUG
            alib::assert::Raise( exception.Back().CI, 1, "APP",
                                "<- Exceptions::ControlledEarlyExit was trown here!" );
            machine.DbgDumpFurtherExitCodes(target);
        #endif
        return;
    }
 
    // print unhandled exceptions
    String512 cmdLine(ProcessInfo::Current().ExecFileName);
    for( int i= 0; i < alib::ARG_C ; ++i )
        cmdLine << ' ' << alib::ARG_VN[i];
    ALIB_LOCK_RECURSIVE_WITH(alib::format::Formatter::DEFAULT_LOCK)
    cErr->Add( "Exception occurred when executing command:\n"
               "    {}\n"
               "Exception details ({} item{}):",
               cmdLine, exception.Size(), (exception.Size() > 1 ? "s" : "") )
         .PushIndent("  ")
         .Add( exception.Format() )
         .PopIndent();
 
    #if ALIB_DEBUG
      cErr->Add( "Application exit-code will be: ", machine.GetExitCode() );
    #endif
 
    machine.DbgDumpFurtherExitCodes(target);
}
 
void App::printConfigFileInfo(Paragraphs& p) {
    LocalAllocator2K cfgFilePathAllocator;
    StdVectorMA<ConfigFileDescriptor> files(cfgFilePathAllocator);
    getConfigFilePaths(files);
 
    if ( !files.size() ) {
        p.Add("None");
        return;
    }
 
    for (ConfigFileDescriptor& fileInfo : files) {
        p.Add( "Configuration file:   {!ATab}:1\n", fileInfo.Pathname );
        p.Add( "  Existed: {!ATab}\n", fileInfo.WasEmpty ? "no" : "yes"  );
 
        if ( fileInfo.Exports.IsNotEmpty() ) {
            Tokenizer tok(fileInfo.Exports, ',');
            while ( tok.HasNext() )
                p.Add("  Exports: {!ATab}\n" , tok.Next() );
}   }   }
 
 
void App::getConfigFilePathsFromResources(StdVectorMA<ConfigFileDescriptor>& files) {
    size_t cnt= 0;
 
    // read file-names from resource, only if not set, yet.
    if ( !files.size() )
        for (;;) {
            String128 resourceName("CFGF_NAME_"); resourceName << (cnt+1);
            String name= appCamp->TryResource( resourceName );
            if (name.IsEmpty())
                break;
            files.emplace_back();
            files.at(cnt).Pathname= name;
            ++cnt;
        }
 
    // read comments from resources
    cnt= 0;
    for (ConfigFileDescriptor& fInfo : files ) {
        if ( fInfo.Comment.IsEmpty() ) {
            String128 resourceName("CFGF_CMT_"); resourceName << (cnt+1);
            fInfo.Comment= appCamp->TryResource( resourceName );
        }
        ++cnt;
    }
 
    // read exports
    cnt= 0;
    for (ConfigFileDescriptor& fInfo : files ) {
        String128 resourceName("CFGF_EXP_"); resourceName << (cnt+1);
        fInfo.Exports= appCamp->TryResource( resourceName );
        ++cnt;
    }
 
    // read additional exports: if more export values in resources exists than,
    // the number of created config-files, the last ones are added to the last file.
    String1K additionalExports;
    for (;;) {
        String128 resourceName("CFGF_EXP_"); resourceName << (cnt+1);
        String exports= appCamp->TryResource( resourceName );
        if (exports.IsNull() )
            break;
        additionalExports << ',' << exports;
        ++cnt;
    }
 
    if ( additionalExports.IsNotEmpty() ) {
        ALIB_ASSERT_ERROR(!files.empty(), "APP",
            "Config-exports {!Q} found, but no config-file is created by the application",
            additionalExports)
        ConfigFileDescriptor& last= files.back();
        if ( last.Exports.IsNotEmpty() )  additionalExports.InsertAt(last.Exports, 0);
        else                              additionalExports.DeleteStart(1);
 
        last.Exports.Allocate(files.get_allocator().GetAllocator(), additionalExports );
 
    }
 
    return;
}
 
void App::getConfigFilePathsMakeAbsolutePaths(StdVectorMA<ConfigFileDescriptor>& files) {
    for (ConfigFileDescriptor& fileInfo : files)  {
        if (fileInfo.Pathname.IsEmpty() || fileInfo.Pathname.IsAbsolute())
            continue;
 
        Path backup(fileInfo.Pathname);
        if (fileInfo.Pathname.CharAtStart() == '.') // some relative adressing
            fileInfo.Pathname.Change( SystemFolders::Current, backup );
        else
            fileInfo.Pathname.Change( SystemFolders::HomeConfig, backup );
}   }
 
void App::getConfigFilePaths(StdVectorMA<ConfigFileDescriptor>& files) {
    getConfigFilePathsFromResources    (files); if (machine.EmergencyStop) return;
    getConfigFilePathsMakeAbsolutePaths(files); if (machine.EmergencyStop) return;
    while (files.size() && files.back().Pathname.IsEmpty())
        files.pop_back();
}
 
 
void App::onBsSetCamps() {
    if ( CAMPS.empty() )
        BootstrapAddDefaultCamps();
 
    if ( appCamp )
        CAMPS.push_back(appCamp);
    else
        appCamp= CAMPS.back();
}
 
void App::onBsPrepareResources() {
    #if ALIB_DEBUG_RESOURCES
        alib::resources::LocalResourcePool::DbgResourceLoadObserver= &std::cout;
    #endif
 
    Bootstrap( BootstrapPhases::PrepareResources );
 
    cOut= monomem::GLOBAL_ALLOCATOR().New<Paragraphs>();
    cErr= monomem::GLOBAL_ALLOCATOR().New<Paragraphs>();
 
    if( cOut->LineWidth == 0) {
        cOut->LineWidth=
        cErr->LineWidth= Console::GetWidth(false, 120);
    }
}
 
void App::onBsSetNameVersionAndInfo() {
    // get app name (if not set)
    if (appName.IsEmpty())
        appName= appCamp->TryResource( "AppName" );
 
    if (appVersion.IsEmpty())
        appVersion= appCamp->TryResource( "AppVersion" );
 
    if (appInfo.IsEmpty()) {
        String infoFmtString= appCamp->TryResource("AppInfo");
        if ( infoFmtString.IsNotEmpty() ) {
            StringLengthResetter resetter(cOut->Buffer);
            cOut->AddMarked(infoFmtString, appName, appVersion, CalendarDateTime(DateTime()).Year);
            appInfo= String(monomem::GLOBAL_ALLOCATOR, cOut->Buffer.Substring(resetter.OriginalLength()));
    }   }
}
 
void App::onBsPrepareConfig()                        { Bootstrap(BootstrapPhases::PrepareConfig ); }
 
void App::onBsPreloadVariables()       { appCamp->GetConfig()->PreloadVariables<lox::Variables>(); }
 
void App::onBsImportConfig() {
    LocalAllocator2K cfgFilePathAllocator;
    StdVectorMA<ConfigFileDescriptor> files(cfgFilePathAllocator);
    getConfigFilePaths(files);
 
    // loop over cfg files (if opening fails, nothing is imported)
    for ( size_t fileNo= 0; fileNo < files.size() ; ++fileNo ) {
        ConfigFileDescriptor& fileInfo= files.at(fileNo);
        if (fileInfo.Pathname.IsEmpty())
            continue;
 
        // import variables
        IniFileFeeder iniFileFeeder(*appCamp->GetConfig());
        try { iniFileFeeder.ImportStart( fileInfo.Pathname ); }
        catch (Exception& e) {
            if (e.Type() != variables::Exceptions::ErrorOpeningFile)
                throw e;
            fileInfo.WasEmpty= true;
            continue;
        }
        iniFileFeeder.ImportAll();
        iniFileFeeder.ImportEnd();
}   }
 
void App::onBsFinalizeBootstrap()                                                   { Bootstrap(); }
 
 
void App::onBsSetupALox() {
    ALIB_ASSERT_ERROR( alib::lox::Log::DEBUG_LOGGER == nullptr, "APP",
                       "DEBUG_LOGGER already created. Obviously logging was used "
                       "prior to the invocation of bs30SetupALox. This can cause issues" )
 
    // Create release lox
    if ( HasBits(flags, Flags::CreateReleaseLox ) ) {
        ALIB_LOCK_RECURSIVE_WITH(monomem::GLOBAL_ALLOCATOR_LOCK)
        Lox_Prune( releaseLox   = monomem::GLOBAL_ALLOCATOR().New<alib::Lox>(releaseLoxName) );
        Lox_Prune( releaseLogger= alib::lox::Lox::CreateConsoleLogger(releaseLoggerName); )
        Lox_SetVerbosity( releaseLogger, Verbosity::Info   , "/"  )
 
        // Set the debug-lox to our release lox
        if (HasBits(flags, Flags::UseReleaseLoggerForDebugLogging ) ) {
            Log_Prune( Log::DEBUG_LOGGER= releaseLogger; )
            Log_Prune( Log::SetALibAssertionPlugin(releaseLox); )
            Log_Prune( alib::lox::DEBUG_LOX= releaseLox; )
    }   }
 
    // todo: create text-file logger
 
}
 
//==================================================================================================
// Shutdown
//==================================================================================================
void App::onSdAnnounceShutdown()                     { alib::Shutdown( ShutdownPhases::Announce ); }
 
 
void App::onSdCleanALox() {
    #if ALOX_DBG_LOG
        if ( HasBits(flags, Flags::ALoxVerbosityExportAllAndWriteBackDbgLogger ) ) {
            Log_GetLogger( pacl, "DEBUG_LOGGER" )
            if (pacl)
                pacl->SetVerbosityExport(&LOG_LOX, true );
        }
    #endif
 
    // set ExportAll and writeback with ALox verbosity-variables which were not in the
    // INI-file before. We do this regardless if there is a INI-file or not. It might benefit
    // for custom configurations systems likewise.
    if (    HasBits(flags, Flags::ALoxVerbosityExportAllAndWriteBackRelLogger)
         && releaseLogger ) {
        releaseLogger->SetVerbosityExport(releaseLox, true );
        Log_Prune( Log::SetALibAssertionPlugin(nullptr); )
        Log_Prune( Log::DEBUG_LOGGER= nullptr; )
        Lox_RemoveLogger( releaseLogger )
        Log_Prune( alib::lox::DEBUG_LOX= nullptr; )
        Lox_Prune(delete  releaseLogger );
 
}   }
 
void App::onSdExportConfig() {
    LocalAllocator2K cfgFilePathAllocator;
    StdVectorMA<ConfigFileDescriptor> files(cfgFilePathAllocator);
    getConfigFilePaths(files);
 
    // loop over two (possible) files
    for ( ConfigFileDescriptor& fileInfo : files ) {
        if (fileInfo.Pathname.IsEmpty())
            continue;
 
        // Open INI-file
        IniFileFeeder iniFileFeeder(*appCamp->GetConfig());
        iniFileFeeder.ExportStart( fileInfo.Pathname );
 
        // export variables that are not existing in the INI-file yet
        int cntChanges= 0;
        Tokenizer tknzr(fileInfo.Exports, ',');
        while (tknzr.HasNext()) {
            auto& tok= tknzr.Next();                     // for root, just the direct children
            int changes= iniFileFeeder.ExportSubTree( tok, tok.Equals("/") );
            if ( changes > 0)
                cntChanges+= changes;
        }
 
        auto& iniFile= iniFileFeeder.GetIniFile();
        // If INI-file was empty, set comment
        if(     iniFileFeeder.DidNotExistOrWasEmpty
            && fileInfo.Comment.IsNotEmpty() ) {
                String4K buf;
                Paragraphs p(buf);
                p.LineWidth= iniFileFeeder.LineWidth;
                p.AddMarked( fileInfo.Comment )
                 .RemoveLastNewLine();
                iniFile.FileComments.Allocate(iniFile.Allocator, buf);
                cntChanges++;
        }
 
        // add section comments (if not existing)
        cntChanges+= iniFileFeeder.AddResourcedSectionComments(BASECAMP , "CFG_SECT_CMT_" );
        cntChanges+= iniFileFeeder.AddResourcedSectionComments(ALOX     , "CFG_SECT_CMT_" );
        cntChanges+= iniFileFeeder.AddResourcedSectionComments(*appCamp , "CFG_SECT_CMT_" );
 
        // write INI-file, if changed.
        if( cntChanges > 0 ) iniFileFeeder.ExportEnd( fileInfo.Pathname );
        else                 iniFileFeeder.ExportEnd();
 
    } // loop over 2 files
}
 
void App::onSdOutput() {
    machine.DbgDumpFurtherExitCodes(cOut->Buffer);
    if ( cOut->Buffer.IsNotEmpty() ) {
        std::cout << cOut->Buffer;
        if (!cOut->Buffer.EndsWith(NEW_LINE))
            std::cout << std::endl;
        cOut->Buffer.Reset();
    }
    std::cout.flush();
 
    if ( cErr->Buffer.IsNotEmpty() ) {
        std::cerr << cErr->Buffer;
        if (!cErr->Buffer.EndsWith(NEW_LINE))
            std::cerr << std::endl;
        cErr->Buffer.Reset();
    }
    std::cerr.flush();
}
void App::onSdFinalizeShutdown() {
    // Check that no code used debug logging
    ALIB_ASSERT_ERROR(    !HasBits(flags, Flags::UseReleaseLoggerForDebugLogging)
                       || Log::DEBUG_LOGGER == nullptr, "APP",
       "Debug logging used somewhere, although the flag UseReleaseLoggerForDebugLogging is set." )
 
 
    // Dump resources
    #if ALIB_DEBUG_RESOURCES
         std::cout << std::endl;
         std::cout << "---------------- Resource Pool Dump ----------------" << std::endl;
             auto resourceList= mainCamp->GetResourcePool().DbgGetList();
             std::cout <<  resources::DbgDump( resourceList ) << std::endl;
         std::cout << "---------------- Resource Pool Dump (end) ----------" << std::endl;
    #endif
 
    // Dump Boxing Info
    #if ALIB_DEBUG_BOXING
        std::cout << std::endl;
        std::cout << "---------------- Debug Boxing ----------------" << std::endl;
            std::cout << alib::boxing::debug::DumpVTables(false);
            std::cout << alib::boxing::debug::DumpFunctions( alib::boxing::debug::GetKnownFunctionTypes() );
            std::cout << alib::boxing::debug::DumpAll();
        std::cout << "---------------- Debug Boxing (end) ----------" << std::endl;
    #endif
 
    if (cOut) cOut->~Paragraphs();
    if (cErr) cErr->~Paragraphs();
 
    // finalize ALib shutdown
    alib::Shutdown();
}
 
 
 
} // namespace [alib::app]