cinelerra-5.1/tools/makeappimagetool/includes/misc.h

 1 #pragma once
 2
 3 // system headers
 4 #include <algorithm>
 5 #include <climits>
 6 #include <cstring>
 7 #include <sstream>
 8 #include <string>
 9 #include <unistd.h>
 10 #include <vector>
 11
 12 // libraries
 13 #include <boost/filesystem.hpp>
 14
 15 namespace linuxdeploy {
 16     namespace util {
 17         namespace misc {
 18             static inline bool ltrim(std::string& s, char to_trim = ' ') {
 19                 // TODO: find more efficient way to check whether elements have been removed
 20                 size_t initialLength = s.length();
 21                 s.erase(s.begin(), std::find_if(s.begin(), s.end(), [to_trim](int ch) {
 22                     return ch != to_trim;
 23                 }));
 24                 return s.length() < initialLength;
 25             }
 26
 27             static inline bool rtrim(std::string& s, char to_trim = ' ') {
 28                 // TODO: find more efficient way to check whether elements have been removed
 29                 auto initialLength = s.length();
 30                 s.erase(std::find_if(s.rbegin(), s.rend(), [to_trim](int ch) {
 31                     return ch != to_trim;
 32                 }).base(), s.end());
 33                 return s.length() < initialLength;
 34             }
 35
 36             static inline bool trim(std::string& s, char to_trim = ' ') {
 37                 // returns true if either modifies s
 38                 auto ltrim_result = ltrim(s, to_trim);
 39                 return rtrim(s, to_trim) && ltrim_result;
 40             }
 41
 42             static std::vector<std::string> split(const std::string& s, char delim = ' ') {
 43                 std::vector<std::string> result;
 44
 45                 std::stringstream ss(s);
 46                 std::string item;
 47
 48                 while (std::getline(ss, item, delim)) {
 49                     result.push_back(item);
 50                 }
 51
 52                 return result;
 53             }
 54
 55             static std::vector<std::string> splitLines(const std::string& s) {
 56                 return split(s, '\n');
 57             }
 58
 59             static std::string join(const std::vector<std::string> &strings, const std::string &delimiter) {
 60                 std::string result;
 61                 for (size_t i = 0; i < strings.size(); i++) {
 62                     result += strings[i];
 63
 64                     if (i != strings.size() - 1) {
 65                         result += delimiter;
 66                     }
 67                 }
 68                 return result;
 69             }
 70
 71             static inline std::string strLower(std::string s) {
 72                 std::transform(s.begin(), s.end(), s.begin(), [](unsigned char c) { return std::tolower(c); });
 73                 return s;
 74             }
 75
 76             static bool stringStartsWith(const std::string& string, const std::string& prefix) {
 77                 // sanity check
 78                 if (string.size() < prefix.size())
 79                     return false;
 80
 81                 return strncmp(string.c_str(), prefix.c_str(), prefix.size()) == 0;
 82             }
 83
 84             static bool stringEndsWith(const std::string& string, const std::string& suffix) {
 85                 // sanity check
 86                 if (string.size() < suffix.size())
 87                     return false;
 88
 89                 return strcmp(string.c_str() + (string.size() - suffix.size()), suffix.c_str()) == 0;
 90             }
 91
 92             static bool stringContains(const std::string& string, const std::string& part) {
 93                 return string.find(part) != std::string::npos;
 94             }
 95
 96             static std::string getOwnExecutablePath() {
 97                 // FIXME: reading /proc/self/exe line is Linux specific
 98                 std::vector<char> buf(PATH_MAX, '\0');
 99
 100                 if (readlink("/proc/self/exe", buf.data(), buf.size()) < 0) {
 101                     return "";
 102                 }
 103
 104                 return buf.data();
 105             }
 106
 107             // very simple but for our purposes good enough which like algorithm to find binaries in $PATH
 108             static boost::filesystem::path which(const std::string& name) {
 109                 const auto* path = getenv("PATH");
 110
 111                 namespace bf = boost::filesystem;
 112
 113                 if (path == nullptr)
 114                     return "";
 115
 116                 for (const auto& binDir : split(path, ':')) {
 117                     if (!bf::is_directory(binDir)) {
 118                         continue;
 119                     }
 120
 121                     for (bf::directory_iterator it(binDir); it != bf::directory_iterator{}; ++it) {
 122                         const auto binary = it->path();
 123
 124                         if (binary.filename() == name) {
 125                             // TODO: check if file is executable (skip otherwise)
 126                             return binary;
 127                         }
 128                     }
 129                 }
 130
 131                 return {};
 132             };
 133         }
 134     }
 135 }