environment.hpp

Go to the documentation of this file.

#pragma once
#include "collections/specialized/string_collection.hpp"
#include "collections/specialized/string_dictionary.hpp"
#include "collections/generic/list.hpp"
#include "diagnostics/stack_trace.hpp"
#include "io/directory.hpp"
#include "io/path.hpp"
#include "argument_collection.hpp"
#include "as.hpp"
#include "availability_versions.hpp"
#include "compiler.hpp"
#include "core_export.hpp"
#include "cpp_language.hpp"
#include "enum.hpp"
#include "environment_variable_target.hpp"
#include "event.hpp"
#include "exit_status.hpp"
#include "guid.hpp"
#include "iequatable.hpp"
#include "is.hpp"
#include "operating_system.hpp"
#include "platform_id.hpp"
#include "processor.hpp"
#include "program_exit_event_handler.hpp"
#include "signal_cancel_event_handler.hpp"
#include "size_of.hpp"
#include "static.hpp"
#include "string.hpp"
#include "target_id.hpp"
#include "target_type.hpp"
#include "time_span.hpp"
#include "toolkit.hpp"
#include "usize.hpp"
#include "version.hpp"
#define __XTD_CORE_INTERNAL__
#include "internal/__build_type.hpp"
#include "internal/__compiler_id.hpp"
#include "internal/__compiler_version.hpp"
#include "internal/__cpp_language.hpp"
#include "internal/__xtd_unreachable.hpp"
#undef __XTD_CORE_INTERNAL__
#include <cassert>

// The following constant is defined in the file xtd_command.cmake.
// If the target project is not built with cmake, the following constant must be defined by the build tool like this if the cmake_install_prefix is not modified; otherwise the cmake_install_prefix value:
// | Constant          | Windows Value                | macOS        | linux        |
// | ----------------- | ---------------------------- |--------------|--------------|
// | __XTD_ROOT_PATH__ | "C:\Program Files (x86)\xtd" | "/usr/local" | "/usr/local" |
// Remarks : If __XTD_ROOT_PATH__ is empty the environment variable XTD_ROOT_PATH is used. And if the environment variable XTD_ROOT_PATH is empty too the directory componant of xtd::diagnostics::source_location::current().file_name() is used.
#if !defined(__XTD_ROOT_PATH__)
#  define __XTD_ROOT_PATH__ ""
#endif

namespace xtd {
  class core_export_ environment final static_ {
    class signal_catcher;
  public:
    enum class special_folder {
      desktop = 0,
      programs = 2,
      my_documents = 5,
      personal = 5,
      favorites = 6,
      startup = 7,
      recent = 8,
      send_to = 9,
      start_menu = 11,
      my_music = 13,
      my_videos = 14,
      desktop_directory = 16,
      my_computer = 17,
      network_shortcuts = 19,
      fonts = 20,
      templates = 21,
      common_start_menu = 22,
      common_programs = 23,
      common_startup = 24,
      common_desktop_directory = 25,
      application_data = 26,
      printer_shortcuts = 27,
      local_application_data = 28,
      internet_cache = 32,
      cookies = 33,
      history = 34,
      common_application_data = 35,
      windows = 36,
      system = 37,
      program_files = 38,
      my_pictures = 39,
      user_profile = 40,
      system_x86 = 41,
      program_files_x86 = 42,
      common_program_files = 43,
      common_program_files_x86 = 44,
      common_templates = 45,
      common_documents = 46,
      common_admin_tools = 47,
      admin_tools = 48,
      common_music = 53,
      common_pictures = 54,
      common_videos = 55,
      resources = 56,
      localized_resources = 57,
      common_oem_links = 58,
      cd_burning = 59,
      home = 64,
      application_resources = 999,
      xtd_install = 1000,
      xtd_locale = 1001,
      xtd_reference_guide = 1002,
      xtd_themes = 1003,
      xtd_include = 1004,
      xtd_libraries = 1005,
      xtd_resources = 1006,
      xtd_console_include = 1007,
      xtd_console_libraries = 1008,
      xtd_drawing_include = 1009,
      xtd_drawing_libraries = 1010,
      xtd_drawing_resources = 1011,
      xtd_forms_include = 1012,
      xtd_forms_libraries = 1013,
      xtd_forms_resources = 1014,
      xtd_tunit_include = 1015,
      xtd_tunit_libraries = 1016,
    };
    
    enum class special_folder_option {
      none = 0,
      do_not_verify = 16384,
      create = 32768
    };
    
    class xtd_library final : public xtd::object, public xtd::iequatable<xtd_library> {
    public:
      xtd_library() = default;
      xtd_library(const xtd_library&) = default;
      xtd_library& operator =(const xtd_library&) = default;
      
      
      [[nodiscard]] auto include_path() const noexcept -> const xtd::string&;
      
      [[nodiscard]] auto library_path() const noexcept -> const xtd::string&;
      
      [[nodiscard]] auto name() const noexcept -> const xtd::string&;
      
      [[nodiscard]] auto resources_path() const noexcept -> const xtd::string&;
      
      [[nodiscard]] auto version() const noexcept -> const xtd::version&;
      
      
      [[nodiscard]] auto equals(const object& other) const noexcept -> bool override {return is<xtd_library>(other) && equals(static_cast<const xtd_library&>(other));}
      [[nodiscard]] auto equals(const xtd_library& other) const noexcept -> bool override {return name_ == other.name_ && version_ == other.version_ && include_path_ == other.include_path_ && library_path_ == other.library_path_ && resources_path_ == other.resources_path_;}
      
      [[nodiscard]] auto to_string() const noexcept -> xtd::string override;
      
    private:
      friend class environment;
      xtd_library(const xtd::string& name, const xtd::version& version, const xtd::string& include_path, const xtd::string& library_path, const xtd::string& resources_path);
      xtd::string name_;
      xtd::version version_;
      xtd::string include_path_;
      xtd::string library_path_;
      xtd::string resources_path_;
    };
    
    using xtd_library_collection = xtd::collections::generic::list<xtd_library>;
    
    
    [[nodiscard]] static auto command_line() noexcept -> xtd::string;
    
    [[nodiscard]] static auto compiler_version() noexcept -> xtd::compiler {
      static auto compiler_id = __compiler_id;
      static auto version = __compiler_version;
      static auto build_type = __build_type;
      static xtd::compiler compiler {compiler_id, version, build_type, size_of<xtd::usize>() == 8};
      return compiler;
    }
    
    [[nodiscard]] static auto cpp_version() noexcept -> xtd::cpp_language {
      static auto cpp_language = __cpp_language;
      return cpp_language;
    }
    
    [[nodiscard]] static auto current_directory() -> xtd::string;
    
    static auto current_directory(const xtd::string& directory_name) -> void;
    
    [[nodiscard]] static auto current_managed_thread_id() noexcept -> xtd::int32;
    
    [[nodiscard]] static auto current_thread_id() noexcept -> xtd::intptr;
    
    [[nodiscard]] static auto exit_code() noexcept -> xtd::int32;
    static auto exit_code(xtd::int32 value) noexcept -> void;
    
    [[nodiscard]] static auto has_shutdown_started() -> bool;
    
    [[nodiscard]] static auto is_64_bit_operating_system() noexcept -> bool;
    
    [[nodiscard]] static auto is_64_bit_process() noexcept -> bool;
    
    [[nodiscard]] static auto locale() noexcept -> std::locale;
    
    [[nodiscard]] static auto machine_name() -> xtd::string;
    
    static auto new_line() noexcept -> xtd::string;
    
    template<typename char_t, typename traits_t>
    [[nodiscard]] static auto new_line(std::basic_ostream<char_t, traits_t>& os) -> std::basic_ostream<char_t, traits_t>& {
      for (auto c : new_line())
        os.put(os.widen(c));
      return os;
    }
    
    [[nodiscard]] static auto os_version() noexcept -> xtd::operating_system;
    
    [[nodiscard]] static auto processor_count() -> xtd::usize;
    
    [[nodiscard]] static auto processor_information() -> xtd::processor;
    
    [[nodiscard]] static auto stack_trace() -> xtd::string;
    
    [[nodiscard]] static auto system_directory() -> xtd::string;
    
    [[nodiscard]] static auto system_page_size() -> xtd::usize;
    
    [[nodiscard]] static auto target_type() noexcept -> xtd::target_type {
      return xtd::target_type(as<xtd::target_id>(__XTD_CURRENT_TARGET_ID__));
    }
    
    [[nodiscard]] static auto tick_count() -> xtd::time_span;
    [[nodiscard]] static auto tick_count_milliseconds() -> xtd::int32;
    
    [[nodiscard]] static auto toolkit_version() -> xtd::toolkit;
    
    [[nodiscard]] static auto user_administrator() -> bool;
    
    [[nodiscard]] static auto user_domain_name() -> xtd::string;
    
    [[nodiscard]] static auto user_interactive() -> bool;
    
    [[nodiscard]] static auto user_name() -> xtd::string;
    
    [[nodiscard]] static auto version() noexcept -> xtd::version;
    
    [[nodiscard]] static auto working_set() -> xtd::int64;
    
    [[nodiscard]] static auto xtd_libraries() noexcept -> const xtd_library_collection&;
    
    
    static event<environment, signal_cancel_event_handler> cancel_signal;
    
    static event<environment, program_exit_event_handler> program_exit;
    
    
    static auto abort() -> void;
    
    [[noreturn]] static auto exit() -> void;
    [[noreturn]] static auto exit(xtd::int32 exit_code) -> void;
    [[noreturn]] static auto exit(xtd::exit_status exit_status) -> void;
    
    [[nodiscard]] static auto expand_environment_variables(const xtd::string& name) -> xtd::string;
    
    [[noreturn]] static auto fail_fast() noexcept -> void {fail_fast_(xtd::diagnostics::stack_trace {false}, xtd::null, &string::empty_string);}
    [[noreturn]] static auto fail_fast(const xtd::string& message) noexcept -> void {fail_fast_(xtd::diagnostics::stack_trace {false}, &message, &string::empty_string);}
    template<typename exception_t>
    requires std::derived_from<xtd::raw_type<exception_t>, std::exception>
    [[noreturn]] static auto fail_fast(const xtd::string& message, const exception_t& exception) -> void {fail_fast_(xtd::diagnostics::stack_trace {false}, &message, &exception);}
    template<typename exception_t>
    requires std::derived_from<xtd::raw_type<exception_t>, std::exception>
    [[noreturn]] static auto fail_fast(const exception_t& exception) noexcept -> void {fail_fast_(xtd::diagnostics::stack_trace {false}, xtd::null, &exception);}

    [[nodiscard]] static auto get_command_line_args() -> const xtd::argument_collection&;
    
    [[nodiscard]] static auto get_environment_variable(const xtd::string& variable) -> xtd::string;
    
    [[nodiscard]] static auto get_environment_variable(const xtd::string& variable, xtd::environment_variable_target target) -> xtd::string;
    
    [[nodiscard]] static auto get_environment_variables() -> xtd::collections::specialized::string_dictionary;
    
    [[nodiscard]] static auto get_environment_variables(xtd::environment_variable_target target) -> xtd::collections::specialized::string_dictionary;
    
    [[nodiscard]] static auto get_folder_path(environment::special_folder folder) -> xtd::string {return get_folder_path_(folder, environment::special_folder_option::none);}
    
    [[nodiscard]] static auto get_folder_path(environment::special_folder folder, environment::special_folder_option option) -> xtd::string {return get_folder_path_(folder, option);}
    
    [[nodiscard]] static auto get_logical_drives() -> xtd::collections::specialized::string_collection;
    
    [[noreturn]] static auto quick_exit() noexcept -> void;
    [[noreturn]] static auto quick_exit(xtd::int32 exit_code) noexcept -> void;
    [[noreturn]] static auto quick_exit(xtd::exit_status exit_status) noexcept -> void;
    
    static auto raise(xtd::signal signal) -> void;
    
    static auto set_command_line_args(const xtd::argument_collection& args) -> void;
    
    static auto set_environment_variable(const xtd::string& variable, const xtd::string& value) -> void;
    
    static auto set_environment_variable(const xtd::string& variable, const xtd::string& value, xtd::environment_variable_target target) -> void;

    [[noreturn]] static auto unreachable() -> void {
      assert(false && "xtd::environment::unreachable() was reached");
      __xtd_unreachable();
    }

    
  private:
    static auto on_cancel_signal(xtd::signal_cancel_event_args& e) -> void;
    static auto on_program_exit(const xtd::program_exit_event_args& e) -> void;
 
    [[noreturn]] static auto fail_fast_exit() -> void;
    static auto fail_fast_flush() -> void;
    static auto fail_fast_write_line(const xtd::string& str) -> void;
    template<typename exception_t>
    [[noreturn]] static auto fail_fast_(const xtd::diagnostics::stack_trace& st, const xtd::string* message, const exception_t* exception) -> void {
      fail_fast_write_line("\n\nProcess terminated.");
      if (message && !xtd::string::is_empty(*message)) fail_fast_write_line(*message);
      fail_fast_write_line(st.to_string());
      if (exception) {
        if constexpr (std::derived_from<xtd::raw_type<exception_t>, xtd::exception>) fail_fast_write_line(xtd::string::format("{}: {} (Parameter '{}')", type_of<xtd::raw_type<exception_t>>(), xtd::raw_type<exception_t> {}.message(),  exception->message()));
        else if constexpr (std::derived_from<xtd::raw_type<exception_t>, std::exception>) fail_fast_write_line(xtd::string::format("{} (Parameter '{}')", type_of<xtd::raw_type<exception_t>>(),  exception->what()));
      }
      fail_fast_flush();
      fail_fast_exit();
    }
 
    [[nodiscard]] static auto get_folder_path_(environment::special_folder folder, environment::special_folder_option option, bool is_gui_application = target_type().is_gui_application()) -> xtd::string;
    [[nodiscard]] static auto xtd_root_path() -> xtd::string {return xtd::io::path::get_full_path(string::is_empty(__XTD_ROOT_PATH__) ? (string::is_empty(get_environment_variable("XTD_ROOT_PATH")) ? io::path::get_full_path(io::path::combine(io::path::get_directory_name(xtd::diagnostics::source_location::current().file_name()), "..", "..")) : get_environment_variable("XTD_ROOT_PATH")) : __XTD_ROOT_PATH__);}
    static signal_catcher signal_catcher_;
    static xtd::argument_collection args_;
  };
}

template<> struct xtd::enum_register<xtd::environment::special_folder> {
  static auto values() noexcept {return xtd::enum_collection<xtd::environment::special_folder> {{xtd::environment::special_folder::desktop, "desktop"}, {xtd::environment::special_folder::programs, "programs"}, {xtd::environment::special_folder::my_documents, "my_documents"}, {xtd::environment::special_folder::favorites, "favorites"}, {xtd::environment::special_folder::startup, "startup"}, {xtd::environment::special_folder::recent, "recent"}, {xtd::environment::special_folder::send_to, "send_to"}, {xtd::environment::special_folder::start_menu, "start_menu"}, {xtd::environment::special_folder::my_music, "my_music"}, {xtd::environment::special_folder::my_videos, "my_videos"}, {xtd::environment::special_folder::desktop_directory, "desktop_directory"}, {xtd::environment::special_folder::my_computer, "my_computer"}, {xtd::environment::special_folder::network_shortcuts, "network_shortcuts"}, {xtd::environment::special_folder::fonts, "fonts"}, {xtd::environment::special_folder::templates, "templates"}, {xtd::environment::special_folder::common_start_menu, "common_start_menu"}, {xtd::environment::special_folder::common_programs, "common_programs"}, {xtd::environment::special_folder::common_startup, "common_startup"}, {xtd::environment::special_folder::common_desktop_directory, "common_desktop_directory"}, {xtd::environment::special_folder::application_data, "application_data"}, {xtd::environment::special_folder::printer_shortcuts, "printer_shortcuts"}, {xtd::environment::special_folder::local_application_data, "local_application_data"}, {xtd::environment::special_folder::internet_cache, "internet_cache"}, {xtd::environment::special_folder::cookies, "cookies"}, {xtd::environment::special_folder::history, "history"}, {xtd::environment::special_folder::common_application_data, "common_application_data"}, {xtd::environment::special_folder::windows, "windows"}, {xtd::environment::special_folder::system, "system"}, {xtd::environment::special_folder::program_files, "program_files"}, {xtd::environment::special_folder::my_pictures, "my_pictures"}, {xtd::environment::special_folder::user_profile, "user_profile"}, {xtd::environment::special_folder::system_x86, "system_x86"}, {xtd::environment::special_folder::program_files_x86, "program_files_x86"}, {xtd::environment::special_folder::common_program_files, "common_program_files"}, {xtd::environment::special_folder::common_program_files_x86, "common_program_files_x86"}, {xtd::environment::special_folder::common_templates, "common_templates"}, {xtd::environment::special_folder::common_documents, "common_documents"}, {xtd::environment::special_folder::common_admin_tools, "common_admin_tools"}, {xtd::environment::special_folder::admin_tools, "admin_tools"}, {xtd::environment::special_folder::common_music, "common_music"}, {xtd::environment::special_folder::common_pictures, "common_pictures"}, {xtd::environment::special_folder::common_videos, "common_videos"}, {xtd::environment::special_folder::resources, "resources"}, {xtd::environment::special_folder::localized_resources, "localized_resources"}, {xtd::environment::special_folder::common_oem_links, "common_oem_links"}, {xtd::environment::special_folder::cd_burning, "cd_burning"}, {xtd::environment::special_folder::home, "home"}, {xtd::environment::special_folder::application_resources, "application_resources"}, {xtd::environment::special_folder::xtd_install, "xtd_install"}, {xtd::environment::special_folder::xtd_locale, "xtd_locale"}, {xtd::environment::special_folder::xtd_reference_guide, "xtd_reference_guide"}, {xtd::environment::special_folder::xtd_themes, "xtd_themes"}, {xtd::environment::special_folder::xtd_include, "xtd_include"}, {xtd::environment::special_folder::xtd_libraries, "xtd_libraries"}, {xtd::environment::special_folder::xtd_resources, "xtd_resources"}, {xtd::environment::special_folder::xtd_console_include, "xtd_console_include"}, {xtd::environment::special_folder::xtd_console_libraries, "xtd_console_libraries"}, {xtd::environment::special_folder::xtd_drawing_include, "xtd_drawing_include"}, {xtd::environment::special_folder::xtd_drawing_libraries, "xtd_drawing_libraries"}, {xtd::environment::special_folder::xtd_drawing_resources, "xtd_drawing_resources"}, {xtd::environment::special_folder::xtd_forms_include, "xtd_forms_include"}, {xtd::environment::special_folder::xtd_forms_libraries, "xtd_forms_libraries"}, {xtd::environment::special_folder::xtd_forms_resources, "xtd_forms_resources"}, {xtd::environment::special_folder::xtd_tunit_include, "xtd_tunit_include"}, {xtd::environment::special_folder::xtd_tunit_libraries, "xtd_tunit_libraries"}};}
};
 
template<> struct xtd::enum_register<xtd::environment::special_folder_option> {
  static auto values() noexcept {return xtd::enum_collection<xtd::environment::special_folder_option> {{xtd::environment::special_folder_option::none, "none"}, {xtd::environment::special_folder_option::do_not_verify, "do_not_verify"}, {xtd::environment::special_folder_option::create, "create"}};}
};