basecamp.mpp

Go to the documentation of this file.

//==================================================================================================
/// \file
/// This header-file is part of the \aliblong.
/// With supporting legacy or module builds, .mpp-files are either recognized by the build-system
/// as C++20 Module interface files or are included by the
/// \ref alib_manual_modules_impludes "import/include headers".
///
/// \emoji :copyright: 2013-2025 A-Worx GmbH, Germany.
/// Published under \ref mainpage_license "Boost Software License".
//==================================================================================================
#if !defined(ALIB_C20_MODULES) || ((ALIB_C20_MODULES != 0) && (ALIB_C20_MODULES != 1))
#   error "Symbol 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/enumrecords/enumrecords.prepro.hpp"
#include "alib/variables/variables.prepro.hpp"
#include "alib/resources/resources.prepro.hpp"
#include "alib/camp/camp.prepro.hpp"
#include "alib/camp/camp.prepro.hpp"
 
#include <stack>
 
//============================================== Module ============================================
#if ALIB_C20_MODULES
    /// This is a <em><b>C++ Module</b></em> of the \aliblong.
    /// Due to the dual-compile option (either as C++20 Modules or using legacy C++ inclusion),
    /// the C++20 Module names are not of further interest or use.<br>
    /// In general, the names equal the names of the header files listed in the chapter
    /// \ref alib_manual_modules_impludes of the \alib User Manual.
    ///
    /// @see The documentation of the <em><b>"ALib Module"</b></em> given with the corresponding
    ///      Programmer's Manual \alib_camp.
    export module ALib.Camp.Base;
    import        ALib.Lang;
#  if ALIB_MONOMEM
    import        ALib.Monomem;
#  endif
    import        ALib.Singletons;
#  if ALIB_STRINGS
    import        ALib.Strings;
#  endif
#  if ALIB_BOXING
    import        ALib.Boxing;
#  endif
    import        ALib.EnumRecords;
    import        ALib.Resources;
    import        ALib.Format;
    import        ALib.Format.StdImplementation;
    import        ALib.System;
    import        ALib.Exceptions;
    import        ALib.Variables;
    import        ALib.Variables.IniFile;
    import        ALib.Camp;
#else
#   include      "ALib.System.H"
#   include      "ALib.Exceptions.H"
#   include      "ALib.Format.H"
#   include      "ALib.Variables.H"
#   include      "ALib.Variables.IniFile.H"
#   include      "ALib.Camp.H"
#endif
 
//============================================= Exports ============================================
ALIB_EXPORT namespace alib {
 
 
//==================================================================================================
/// This is the reference documentation of module \alib_camp_nl of the \aliblong.<br>
/// Besides the few entities found and documented here (namely in namespace
/// <em>%alib::camp</em>), this module <em>"injects"</em> several overloaded versions of
/// the function \alib{variables;CampVariable} into namespace <em>%alib::variables</em>.
/// @see
///   Please also consult the \ref alib_mod_camp "Programmer's Manual" of this module.
//==================================================================================================
namespace camp {
 
 
//##################################################################################################
// Variables
//##################################################################################################
 
/// Configuration variables of \alib.
/// \note
///   As required by module \alib_variables, this enumerations is equipped with
///   \ref alib_enums_records "ALib Enum Records" of type \alib{variables;Declaration}
///   and resourced with this module.<br>
///   Hence, all variable categories, names, default values and such can be modified
///   by modifying the resource data of the singleton of class \alib{camp;Basecamp}.
enum class Variables
{
    LOCALE               = 1   , ///< See \ref alibcvALIB_LOCALE.
    WAIT_FOR_KEY_PRESS   = 2   , ///< See \ref alibcvALIB_WAIT_FOR_KEY_PRESS.
    HAS_CONSOLE_WINDOW   = 3   , ///< See \ref alibcvALIB_HAS_CONSOLE_WINDOW.
};
 
 
//==================================================================================================
/// This is a strict singleton class representing module \alib_camp.
/// The only instance is found with the namespace variable \ref alib::BASECAMP.
///
/// @see
///   For detailed descriptions, please consult the chapter \ref alib_camp_basecamp of the
///   Programmer's Manual of the module \alib_camp_nl.
//==================================================================================================
class Basecamp : public Camp
{
  public:
    /// If \c true, within #Shutdown, it is waited for a key press in the console
    /// window.<br>
    /// By default, this flag is enabled when debugging a console application under Visual
    /// Studio.<br>
    /// This default behavior can be overruled by setting configuration variable
    /// \ref alibcvALIB_WAIT_FOR_KEY_PRESS.<br>
    /// In addition, this public flag may be modified at run-time (after method #Bootstrap was
    /// invoked).
    bool                    WaitForKeyPressOnTermination                                     =false;
 
    /// This flag indicates if the current process has console output window attached.
    /// While this is not detectable in Unix like systems (or just with huge efforts), in
    /// windows it is. The determination is performed in #Bootstrap and done as follows
    /// - If configuration variable \b ALIB_HAS_CONSOLE_WINDOW
    ///   is set, its value is returned.
    /// - Otherwise, on Unix like OS\c true is returned.
    /// - On Windows OS it is determined if a console window is attached to the process
    ///   using system call \e GetConsoleWindow() and compare its result to \e NULL.
    ///
    /// In addition, this public flag may be modified at run-time (after method #Bootstrap was
    /// invoked).
    ///
    /// \note
    ///   The evaluation of configuration variable \b ALIB_HAS_CONSOLE_WINDOW is done
    ///   only if module \alib_variables is included in the \alibbuild.
    bool                    HasConsoleWindow;
 
    /// This string is set during bootstrapping in the case that a locale information was
    /// found (via standard environment variables or \alib variable \alib{camp::Variables;LOCALE})
    /// and successfully set.<br>
    /// Otherwise this string is \e nulled.
    String                  LocaleFound;
 
    /// Constructor.<br>
    /// While this is public, it must not be invoked as this is a strict singleton type.
    /// (See notes in \ref alib_camp_camp).
    ALIB_DLL
    Basecamp();
 
    /// Implementation of \alib{camp;Camp::Bootstrap}.
    ///
    /// In phase \alib{BootstrapPhases::Final} performs:
    /// - In glibc versions of \alib (GNU/unix) probably invoke glibc method
    ///   <em>setlocale()</em>, depending on the setting of the environment variables
    ///   <em>LANG</em> and <em>LANGUAGE</em> and depending on \alib configuration variable
    ///   \ref alibcvALIB_LOCALE.
    ///
    ///   In addition, invokes
    ///   \alib{strings;TNumberFormat::SetFromLocale;NumberFormat::SetFromLocale} on static singleton
    ///   \alib{strings;TNumberFormat::Global;NumberFormat::Global}.
    ///
    /// - Config variable \ref WAIT_FOR_KEY_PRESS is read and field
    ///   #WaitForKeyPressOnTermination set accordingly.
    ALIB_DLL
    virtual void    Bootstrap()                                                            override;
 
    /// Terminates this camp.
    /// @param phase  The shutdown phase to perform.
    ALIB_DLL
    virtual void    Shutdown( ShutdownPhases phase)                                        override;
 
  //################################################################################################
  // Environment definition/detection
  //################################################################################################
    /// If \c true, the current process is under the hood of a debugger.
    ///
    /// @return \c true if the application is run in a debugger.
    ALIB_DLL
    bool        IsDebuggerPresent();
 
}; // class Basecamp
 
} // namespace alib[::camp]
 
/// The singleton instance of \alibcamp class \alib{camp;Basecamp}.
extern ALIB_DLL camp::Basecamp BASECAMP;
 
} // namespace [alib]
 
 
 
ALIB_RESOURCED_IN_MODULE( alib::system::SystemErrors  , alib::BASECAMP, "SE" )
ALIB_RESOURCED_IN_MODULE( alib::format::ByteSizeUnits , alib::BASECAMP, "BS" )
ALIB_RESOURCED_IN_MODULE( alib::format::FMTExceptions , alib::BASECAMP, "FE" )
 
ALIB_RESOURCED_IN_MODULE( alib::variables::Exceptions , alib::BASECAMP, "VARE" )
 
DOX_MARKER([DOX_VARIABLES_DECLARATION5])
ALIB_ENUMS_ASSIGN_RECORD( alib::camp::Variables, alib::variables::Declaration )
ALIB_RESOURCED_IN_MODULE( alib::camp::Variables, alib::BASECAMP, "Var" )
DOX_MARKER([DOX_VARIABLES_DECLARATION5])
ALIB_RESOURCED_IN_MODULE( alib::variables::Priority   , alib::BASECAMP, "VarPrio" )