system_utils.hpp

Go to the documentation of this file.

#pragma once
#ifndef _CONSOLIX_SYSTEM_UTILS_HPP_INCLUDED
#define _CONSOLIX_SYSTEM_UTILS_HPP_INCLUDED

 
#include <chrono>
#include <cstdlib>
#include <cstdint>
#include <cstring>
#include <string>
 
#ifdef _WIN32
#include <windows.h>
#elif defined(__linux__) || defined(__APPLE__)
#include <unistd.h>
#include <sys/types.h>
#include <pwd.h>
#endif
 
namespace consolix {

    inline bool copy_to_clipboard(const std::string& text) {
#       ifdef _WIN32
        if (OpenClipboard(nullptr)) {
            EmptyClipboard();
            const std::size_t size = (text.size() + 1) * sizeof(char);
            HGLOBAL hMem = GlobalAlloc(GMEM_MOVEABLE, size);
            if (!hMem) {
                CloseClipboard();
                return false;
            }
            std::memcpy(GlobalLock(hMem), text.c_str(), size);
            GlobalUnlock(hMem);
            SetClipboardData(CF_TEXT, hMem);
            CloseClipboard();
            return true;
        }
        return false;
#       elif defined(__APPLE__)
        const std::string command = "echo \"" + text + "\" | pbcopy";
        return std::system(command.c_str()) == 0;
#       elif defined(__linux__)
        const std::string command = "echo \"" + text + "\" | xclip -selection clipboard";
        return std::system(command.c_str()) == 0;
#       else
        return false;
#       endif
    }

    inline std::string get_clipboard_text() {
#       ifdef _WIN32
        if (!OpenClipboard(nullptr)) return "";
        HANDLE hData = GetClipboardData(CF_TEXT);
        if (!hData) {
            CloseClipboard();
            return "";
        }
        char* text = static_cast<char*>(GlobalLock(hData));
        const std::string result(text ? text : "");
        GlobalUnlock(hData);
        CloseClipboard();
        return result;
#       elif defined(__APPLE__)
        return std::system("pbpaste") == 0 ? "(clipboard contents)" : "";
#       elif defined(__linux__)
        return std::system("xclip -selection clipboard -o") == 0 ? "(clipboard contents)" : "";
#       else
        return "";
#       endif
    }

    inline std::string get_os_name() {
#       ifdef _WIN32
        return "Windows";
#       elif defined(__APPLE__)
        return "macOS";
#       elif defined(__linux__)
        return "Linux";
#       else
        return "Unknown OS";
#       endif
    }

    inline std::uint64_t get_system_time_ms() {
        return static_cast<std::uint64_t>(std::chrono::duration_cast<std::chrono::milliseconds>(
            std::chrono::system_clock::now().time_since_epoch()
        ).count());
    }

    inline int get_cpu_count() {
#       ifdef _WIN32
        SYSTEM_INFO sysinfo;
        GetSystemInfo(&sysinfo);
        return static_cast<int>(sysinfo.dwNumberOfProcessors);
#       elif defined(__linux__) || defined(__APPLE__)
        return static_cast<int>(sysconf(_SC_NPROCESSORS_ONLN));
#       else
        return 1;
#       endif
    }

    inline std::string get_home_directory() {
#       ifdef _WIN32
        const char* home = std::getenv("USERPROFILE");
        return home ? std::string(home) : "";
#       elif defined(__linux__) || defined(__APPLE__)
        struct passwd* pw = getpwuid(getuid());
        return pw ? std::string(pw->pw_dir) : "";
#       else
        return "";
#       endif
    }

    inline std::string get_temp_directory() {
#       ifdef _WIN32
        char tempPath[MAX_PATH];
        GetTempPathA(MAX_PATH, tempPath);
        return std::string(tempPath);
#       elif defined(__linux__) || defined(__APPLE__)
        const char* temp = std::getenv("TMPDIR");
        return temp ? std::string(temp) : "/tmp";
#       else
        return "";
#       endif
    }

    inline std::string get_env_var(const std::string& var_name) {
        const char* value = std::getenv(var_name.c_str());
        return value ? std::string(value) : "";
    }
 
}; // namespace consolix
 
#endif // _CONSOLIX_SYSTEM_UTILS_HPP_INCLUDED