Archives
/
lnav
mirror of https://github.com/tstack/lnav
2
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

[internal] remove ghc::filesystem

Browse Source
pull/1265/head
Tim Stack 4 weeks ago
parent 9a1f383ce1
commit 53b883d015
75 changed files with 382 additions and 6654 deletions
Show Stats Download Patch File Download Diff File

6
src/CMakeLists.txt
Unescape Escape View File

@ -647,12 +647,6 @@ add_library(
mapbox/variant.hpp
mapbox/variant_io.hpp
mapbox/variant_visitor.hpp
ghc/filesystem.hpp
ghc/fs_fwd.hpp
ghc/fs_impl.hpp
ghc/fs_std.hpp
ghc/fs_std_fwd.hpp
ghc/fs_std_impl.hpp
ww898/cp_utf8.hpp
log_level_re.cc

6
src/Makefile.am
Unescape Escape View File

@ -379,12 +379,6 @@ noinst_HEADERS = \
xpath_vtab.hh \
xterm_mouse.hh \
spookyhash/SpookyV2.h \
ghc/filesystem.hpp \
ghc/fs_fwd.hpp \
ghc/fs_impl.hpp \
ghc/fs_std.hpp \
ghc/fs_std_fwd.hpp \
ghc/fs_std_impl.hpp \
ww898/cp_utf8.hpp
nodist_libdiag_a_SOURCES = \

9
src/archive_manager.cc
Unescape Escape View File

@ -52,7 +52,7 @@
#include "fmt/format.h"
#include "hasher.hh"
namespace fs = ghc::filesystem;
namespace fs = std::filesystem;
namespace archive_manager {
@ -269,7 +269,9 @@ extract(const std::string& filename, const extract_cb& cb)
}
}
if (file_count > 0) {
fs::last_write_time(done_path, std::chrono::system_clock::now());
auto now = std::filesystem::file_time_type{
std::chrono::system_clock::now().time_since_epoch()};
fs::last_write_time(done_path, now);
log_info("%s: archive has already been extracted!",
done_path.c_str());
return Ok();
@ -399,7 +401,8 @@ void
cleanup_cache()
{
(void) std::async(std::launch::async, []() {
auto now = std::chrono::system_clock::now();
auto now = std::filesystem::file_time_type{
std::chrono::system_clock::now().time_since_epoch()};
auto cache_path = archive_cache_path();
const auto& cfg = injector::get<const config&>();
std::vector<fs::path> to_remove;

18
src/archive_manager.hh
Unescape Escape View File

@ -39,28 +39,28 @@
#include "base/file_range.hh"
#include "base/result.h"
#include "ghc/filesystem.hpp"
#include <filesystem>
#include "mapbox/variant.hpp"
namespace archive_manager {
struct extract_progress {
extract_progress(ghc::filesystem::path path, ssize_t total)
extract_progress(std::filesystem::path path, ssize_t total)
: ep_path(std::move(path)), ep_total_size(total)
{
}
const ghc::filesystem::path ep_path;
const std::filesystem::path ep_path;
const ssize_t ep_total_size;
std::atomic<size_t> ep_out_size{0};
};
using extract_cb
= std::function<extract_progress*(const ghc::filesystem::path&, ssize_t)>;
= std::function<extract_progress*(const std::filesystem::path&, ssize_t)>;
struct archive_info {
struct entry {
ghc::filesystem::path e_name;
std::filesystem::path e_name;
const char* e_mode;
time_t e_mtime;
std::optional<file_ssize_t> e_size;
@ -73,9 +73,9 @@ struct unknown_file {};
using describe_result = mapbox::util::variant<archive_info, unknown_file>;
Result<describe_result, std::string> describe(
const ghc::filesystem::path& filename);
const std::filesystem::path& filename);
ghc::filesystem::path filename_to_tmp_path(const std::string& filename);
std::filesystem::path filename_to_tmp_path(const std::string& filename);
using walk_result_t = Result<void, std::string>;
@ -90,8 +90,8 @@ using walk_result_t = Result<void, std::string>;
walk_result_t walk_archive_files(
const std::string& filename,
const extract_cb& cb,
const std::function<void(const ghc::filesystem::path&,
const ghc::filesystem::directory_entry&)>&);
const std::function<void(const std::filesystem::path&,
const std::filesystem::directory_entry&)>&);
void cleanup_cache();

41
src/base/fs_util.cc
Unescape Escape View File

@ -27,6 +27,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <fstream>
#include "fs_util.hh"
#include <stdlib.h>
@ -41,7 +43,7 @@ namespace lnav {
namespace filesystem {
std::string
escape_path(const ghc::filesystem::path& p)
escape_path(const std::filesystem::path& p)
{
auto p_str = p.string();
std::string retval;
@ -70,8 +72,8 @@ escape_path(const ghc::filesystem::path& p)
return retval;
}
Result<ghc::filesystem::path, std::string>
realpath(const ghc::filesystem::path& path)
Result<std::filesystem::path, std::string>
realpath(const std::filesystem::path& path)
{
char resolved[PATH_MAX];
auto rc = ::realpath(path.c_str(), resolved);
@ -80,11 +82,11 @@ realpath(const ghc::filesystem::path& path)
return Err(std::string(strerror(errno)));
}
return Ok(ghc::filesystem::path(resolved));
return Ok(std::filesystem::path(resolved));
}
Result<auto_fd, std::string>
create_file(const ghc::filesystem::path& path, int flags, mode_t mode)
create_file(const std::filesystem::path& path, int flags, mode_t mode)
{
auto fd = openp(path, flags | O_CREAT, mode);
@ -98,7 +100,7 @@ create_file(const ghc::filesystem::path& path, int flags, mode_t mode)
}
Result<auto_fd, std::string>
open_file(const ghc::filesystem::path& path, int flags)
open_file(const std::filesystem::path& path, int flags)
{
auto fd = openp(path, flags);
@ -111,8 +113,8 @@ open_file(const ghc::filesystem::path& path, int flags)
return Ok(auto_fd(fd));
}
Result<std::pair<ghc::filesystem::path, auto_fd>, std::string>
open_temp_file(const ghc::filesystem::path& pattern)
Result<std::pair<std::filesystem::path, auto_fd>, std::string>
open_temp_file(const std::filesystem::path& pattern)
{
auto pattern_str = pattern.string();
char pattern_copy[pattern_str.size() + 1];
@ -126,14 +128,14 @@ open_temp_file(const ghc::filesystem::path& pattern)
strerror(errno)));
}
return Ok(std::make_pair(ghc::filesystem::path(pattern_copy), auto_fd(fd)));
return Ok(std::make_pair(std::filesystem::path(pattern_copy), auto_fd(fd)));
}
Result<std::string, std::string>
read_file(const ghc::filesystem::path& path)
read_file(const std::filesystem::path& path)
{
try {
ghc::filesystem::ifstream file_stream(path);
std::ifstream file_stream(path);
if (!file_stream) {
return Err(std::string(strerror(errno)));
@ -149,7 +151,7 @@ read_file(const ghc::filesystem::path& path)
}
Result<write_file_result, std::string>
write_file(const ghc::filesystem::path& path,
write_file(const std::filesystem::path& path,
const string_fragment& content,
std::set<write_file_options> options)
{
@ -175,11 +177,11 @@ write_file(const ghc::filesystem::path& path,
std::error_code ec;
if (options.count(write_file_options::backup_existing)) {
if (ghc::filesystem::exists(path, ec)) {
if (std::filesystem::exists(path, ec)) {
auto backup_path = path;
backup_path += ".bak";
ghc::filesystem::rename(path, backup_path, ec);
std::filesystem::rename(path, backup_path, ec);
if (ec) {
return Err(
fmt::format(FMT_STRING("unable to backup file {}: {}"),
@ -191,7 +193,7 @@ write_file(const ghc::filesystem::path& path,
}
}
ghc::filesystem::rename(tmp_pair.first, path, ec);
std::filesystem::rename(tmp_pair.first, path, ec);
if (ec) {
return Err(
fmt::format(FMT_STRING("unable to move temporary file {}: {}"),
@ -203,7 +205,7 @@ write_file(const ghc::filesystem::path& path,
}
std::string
build_path(const std::vector<ghc::filesystem::path>& paths)
build_path(const std::vector<std::filesystem::path>& paths)
{
return paths
| lnav::itertools::map([](const auto& path) { return path.string(); })
@ -220,7 +222,7 @@ build_path(const std::vector<ghc::filesystem::path>& paths)
}
Result<struct stat, std::string>
stat_file(const ghc::filesystem::path& path)
stat_file(const std::filesystem::path& path)
{
struct stat retval;
@ -233,7 +235,8 @@ stat_file(const ghc::filesystem::path& path)
strerror(errno)));
}
file_lock::file_lock(const ghc::filesystem::path& archive_path)
file_lock::
file_lock(const std::filesystem::path& archive_path)
{
auto lock_path = archive_path;
@ -252,7 +255,7 @@ file_lock::file_lock(const ghc::filesystem::path& archive_path)
namespace fmt {
auto
formatter<ghc::filesystem::path>::format(const ghc::filesystem::path& p,
formatter<std::filesystem::path>::format(const std::filesystem::path& p,
format_context& ctx)
-> decltype(ctx.out()) const
{

43
src/base/fs_util.hh
Unescape Escape View File

@ -30,13 +30,16 @@
#ifndef lnav_fs_util_hh
#define lnav_fs_util_hh
#include <filesystem>
#include <optional>
#include <set>
#include <string>
#include <vector>
#include <sys/stat.h>
#include <unistd.h>
#include "auto_fd.hh"
#include "ghc/filesystem.hpp"
#include "intern_string.hh"
#include "result.h"
@ -51,57 +54,57 @@ is_glob(const std::string& fn)
|| fn.find('[') != std::string::npos);
}
std::string escape_path(const ghc::filesystem::path& p);
std::string escape_path(const std::filesystem::path& p);
inline int
statp(const ghc::filesystem::path& path, struct stat* buf)
statp(const std::filesystem::path& path, struct stat* buf)
{
return stat(path.c_str(), buf);
}
inline int
openp(const ghc::filesystem::path& path, int flags)
openp(const std::filesystem::path& path, int flags)
{
return open(path.c_str(), flags);
}
inline int
openp(const ghc::filesystem::path& path, int flags, mode_t mode)
openp(const std::filesystem::path& path, int flags, mode_t mode)
{
return open(path.c_str(), flags, mode);
}
Result<ghc::filesystem::path, std::string> realpath(
const ghc::filesystem::path& path);
Result<std::filesystem::path, std::string> realpath(
const std::filesystem::path& path);
Result<auto_fd, std::string> create_file(const ghc::filesystem::path& path,
Result<auto_fd, std::string> create_file(const std::filesystem::path& path,
int flags,
mode_t mode);
Result<auto_fd, std::string> open_file(const ghc::filesystem::path& path,
Result<auto_fd, std::string> open_file(const std::filesystem::path& path,
int flags);
Result<struct stat, std::string> stat_file(const ghc::filesystem::path& path);
Result<struct stat, std::string> stat_file(const std::filesystem::path& path);
Result<std::pair<ghc::filesystem::path, auto_fd>, std::string> open_temp_file(
const ghc::filesystem::path& pattern);
Result<std::pair<std::filesystem::path, auto_fd>, std::string> open_temp_file(
const std::filesystem::path& pattern);
Result<std::string, std::string> read_file(const ghc::filesystem::path& path);
Result<std::string, std::string> read_file(const std::filesystem::path& path);
enum class write_file_options {
backup_existing,
};
struct write_file_result {
std::optional<ghc::filesystem::path> wfr_backup_path;
std::optional<std::filesystem::path> wfr_backup_path;
};
Result<write_file_result, std::string> write_file(
const ghc::filesystem::path& path,
const std::filesystem::path& path,
const string_fragment& content,
std::set<write_file_options> options = {});
std::string build_path(const std::vector<ghc::filesystem::path>& paths);
std::string build_path(const std::vector<std::filesystem::path>& paths);
class file_lock {
public:
@ -136,7 +139,7 @@ public:
void unlock() const { lockf(this->lh_fd, F_ULOCK, 0); }
explicit file_lock(const ghc::filesystem::path& archive_path);
explicit file_lock(const std::filesystem::path& archive_path);
auto_fd lh_fd;
};
@ -146,9 +149,9 @@ public:
namespace fmt {
template<>
struct formatter<ghc::filesystem::path> : formatter<string_view> {
auto format(const ghc::filesystem::path& p,
format_context& ctx) -> decltype(ctx.out()) const;
struct formatter<std::filesystem::path> : formatter<string_view> {
auto format(const std::filesystem::path& p, format_context& ctx)
-> decltype(ctx.out()) const;
};
} // namespace fmt

24
src/base/paths.cc
Unescape Escape View File

@ -34,6 +34,8 @@
# include <sstream>
#endif
#include <unistd.h>
#include "fmt/format.h"
#include "paths.hh"
@ -76,7 +78,7 @@ windows_to_unix_file_path(char* input)
}
#endif
ghc::filesystem::path
std::filesystem::path
dotlnav()
{
#ifdef __CYGWIN__
@ -87,26 +89,26 @@ dotlnav()
auto xdg_config_home = getenv("XDG_CONFIG_HOME");
if (home_env != nullptr) {
auto home_path = ghc::filesystem::path(home_env);
auto home_path = std::filesystem::path(home_env);
if (ghc::filesystem::is_directory(home_path)) {
if (std::filesystem::is_directory(home_path)) {
auto home_lnav = home_path / ".lnav";
if (ghc::filesystem::is_directory(home_lnav)) {
if (std::filesystem::is_directory(home_lnav)) {
return home_lnav;
}
if (xdg_config_home != nullptr) {
auto xdg_path = ghc::filesystem::path(xdg_config_home);
auto xdg_path = std::filesystem::path(xdg_config_home);
if (ghc::filesystem::is_directory(xdg_path)) {
if (std::filesystem::is_directory(xdg_path)) {
return xdg_path / "lnav";
}
}
auto home_config = home_path / ".config";
if (ghc::filesystem::is_directory(home_config)) {
if (std::filesystem::is_directory(home_config)) {
return home_config / "lnav";
}
@ -114,16 +116,16 @@ dotlnav()
}
}
return ghc::filesystem::current_path();
return std::filesystem::current_path();
}
ghc::filesystem::path
std::filesystem::path
workdir()
{
auto subdir_name = fmt::format(FMT_STRING("lnav-user-{}-work"), getuid());
auto tmp_path = ghc::filesystem::temp_directory_path();
auto tmp_path = std::filesystem::temp_directory_path();
return tmp_path / ghc::filesystem::path(subdir_name);
return tmp_path / std::filesystem::path(subdir_name);
}
} // namespace paths

6
src/base/paths.hh
Unescape Escape View File

@ -30,7 +30,7 @@
#ifndef lnav_paths_hh
#define lnav_paths_hh
#include "ghc/filesystem.hpp"
#include <filesystem>
namespace lnav {
namespace paths {
@ -48,9 +48,9 @@ char* windows_to_unix_file_path(char* input);
* @param sub The path to the file in the '.lnav' directory.
* @return The full path
*/
ghc::filesystem::path dotlnav();
std::filesystem::path dotlnav();
ghc::filesystem::path workdir();
std::filesystem::path workdir();
} // namespace paths
} // namespace lnav

2
src/base/piper.file.cc
Unescape Escape View File

@ -42,7 +42,7 @@ namespace piper {
const char HEADER_MAGIC[4] = {'L', 0, 'N', 1};
const ghc::filesystem::path&
const std::filesystem::path&
storage_path()
{
static auto INSTANCE = lnav::paths::workdir() / "piper";

4
src/base/piper.file.hh
Unescape Escape View File

@ -39,7 +39,7 @@
#include "auto_mem.hh"
#include "base/intern_string.hh"
#include "ghc/filesystem.hpp"
#include <filesystem>
#include "mapbox/variant_io.hpp"
#include "time_util.hh"
@ -76,7 +76,7 @@ struct header {
}
};
const ghc::filesystem::path& storage_path();
const std::filesystem::path& storage_path();
constexpr size_t HEADER_SIZE = 8;
extern const char HEADER_MAGIC[4];

12
src/command_executor.cc
Unescape Escape View File

@ -603,10 +603,10 @@ multiline_executor::final()
}
static Result<std::string, lnav::console::user_message>
execute_file_contents(exec_context& ec, const ghc::filesystem::path& path)
execute_file_contents(exec_context& ec, const std::filesystem::path& path)
{
static const ghc::filesystem::path stdin_path("-");
static const ghc::filesystem::path dev_stdin_path("/dev/stdin");
static const std::filesystem::path stdin_path("-");
static const std::filesystem::path dev_stdin_path("/dev/stdin");
std::string retval;
FILE* file;
@ -715,13 +715,13 @@ execute_file(exec_context& ec, const std::string& path_and_args)
} else if (errno != ENOENT) {
open_error = strerror(errno);
} else {
auto script_path = ghc::filesystem::path(script_name);
auto script_path = std::filesystem::path(script_name);
if (!script_path.is_absolute()) {
script_path = ec.ec_path_stack.back() / script_path;
}
if (ghc::filesystem::is_regular_file(script_path)) {
if (std::filesystem::is_regular_file(script_path)) {
struct script_metadata meta;
meta.sm_path = script_path;
@ -1066,7 +1066,7 @@ pipe_callback(exec_context& ec, const std::string& cmdline, auto_fd& fd)
});
}
std::error_code errc;
ghc::filesystem::create_directories(lnav::paths::workdir(), errc);
std::filesystem::create_directories(lnav::paths::workdir(), errc);
auto open_temp_res = lnav::filesystem::open_temp_file(lnav::paths::workdir()
/ "exec.XXXXXX");
if (open_temp_res.isErr()) {

4
src/command_executor.hh
Unescape Escape View File

@ -41,7 +41,7 @@
#include "base/lnav.console.hh"
#include "db_sub_source.hh"
#include "fmt/format.h"
#include "ghc/filesystem.hpp"
#include <filesystem>
#include "help_text.hh"
#include "shlex.resolver.hh"
#include "vis_line.hh"
@ -301,7 +301,7 @@ struct exec_context {
std::stack<std::map<std::string, scoped_value_t>> ec_local_vars;
std::vector<provenance_t> ec_provenance;
std::map<std::string, scoped_value_t> ec_global_vars;
std::vector<ghc::filesystem::path> ec_path_stack;
std::vector<std::filesystem::path> ec_path_stack;
std::vector<lnav::console::snippet> ec_source;
help_text* ec_current_help{nullptr};

4
src/curl_looper.cc
Unescape Escape View File

@ -191,7 +191,9 @@ curl_request::complete(CURLcode result)
return -1;
}
curl_looper::curl_looper() : cl_curl_multi(curl_multi_cleanup)
curl_looper::
curl_looper()
: cl_curl_multi(curl_multi_cleanup)
{
this->cl_curl_multi.reset(curl_multi_init());
}

4
src/dump_internals.cc
Unescape Escape View File

@ -61,7 +61,7 @@ dump_internals(const char* internals_dir)
execute_examples();
auto cmd_ref_path = ghc::filesystem::path(internals_dir) / "cmd-ref.rst";
auto cmd_ref_path = std::filesystem::path(internals_dir) / "cmd-ref.rst";
auto cmd_file = std::unique_ptr<FILE, decltype(&fclose)>(
fopen(cmd_ref_path.c_str(), "w+"), fclose);
@ -78,7 +78,7 @@ dump_internals(const char* internals_dir)
}
}
auto sql_ref_path = ghc::filesystem::path(internals_dir) / "sql-ref.rst";
auto sql_ref_path = std::filesystem::path(internals_dir) / "sql-ref.rst";
auto sql_file = std::unique_ptr<FILE, decltype(&fclose)>(
fopen(sql_ref_path.c_str(), "w+"), fclose);
std::set<const help_text*> unique_sql_help;

10
src/file_collection.cc
Unescape Escape View File

@ -162,7 +162,7 @@ file_collection::regenerate_unique_file_names()
safe::ReadAccess<safe_name_to_errors> errs(*this->fc_name_to_errors);
for (const auto& pair : *errs) {
auto path = ghc::filesystem::path(pair.first).filename().string();
auto path = std::filesystem::path(pair.first).filename().string();
if (path.length() > this->fc_largest_path_length) {
this->fc_largest_path_length = path.length();
@ -182,7 +182,7 @@ file_collection::regenerate_unique_file_names()
case file_format_t::ARCHIVE:
case file_format_t::MULTIPLEXED:
case file_format_t::SQLITE_DB: {
auto bn = ghc::filesystem::path(pair.first).filename().string();
auto bn = std::filesystem::path(pair.first).filename().string();
if (bn.length() > this->fc_largest_path_length) {
this->fc_largest_path_length = bn.length();
}
@ -307,7 +307,9 @@ file_collection::watch_logfile(const std::string& filename,
int rc;
auto filename_key = loo.loo_filename.empty() ? filename : loo.loo_filename;
if (this->fc_closed_files.count(filename)) {
if (this->fc_closed_files.count(filename)
|| this->fc_closed_files.count(filename_key))
{
return std::nullopt;
}
@ -464,7 +466,7 @@ file_collection::watch_logfile(const std::string& filename,
},
[&filename, &retval](const auto& tmp_path,
const auto& entry) {
auto arc_path = ghc::filesystem::relative(
auto arc_path = std::filesystem::relative(
entry.path(), tmp_path);
auto custom_name = filename / arc_path;
bool is_visible = true;

15
src/file_converter_manager.cc
Unescape Escape View File

@ -44,7 +44,7 @@
namespace file_converter_manager {
static const ghc::filesystem::path&
static const std::filesystem::path&
cache_dir()
{
static auto INSTANCE = lnav::paths::workdir() / "conversion";
@ -57,7 +57,7 @@ convert(const external_file_format& eff, const std::string& filename)
{
log_info("attempting to convert file -- %s", filename.c_str());
ghc::filesystem::create_directories(cache_dir());
std::filesystem::create_directories(cache_dir());
auto outfile = TRY(lnav::filesystem::open_temp_file(
cache_dir()
/ fmt::format(FMT_STRING("{}.XXXXXX"), eff.eff_format_name)));
@ -160,14 +160,15 @@ cleanup()
{
(void) std::async(std::launch::async, []() {
const auto& cfg = injector::get<const lnav::piper::config&>();
auto now = std::chrono::system_clock::now();
auto now = std::filesystem::file_time_type{
std::chrono::system_clock::now().time_since_epoch()};
auto cache_path = cache_dir();
std::vector<ghc::filesystem::path> to_remove;
std::vector<std::filesystem::path> to_remove;
for (const auto& entry :
ghc::filesystem::directory_iterator(cache_path))
std::filesystem::directory_iterator(cache_path))
{
auto mtime = ghc::filesystem::last_write_time(entry.path());
auto mtime = std::filesystem::last_write_time(entry.path());
auto exp_time = mtime + cfg.c_ttl;
if (now < exp_time) {
continue;
@ -178,7 +179,7 @@ cleanup()
for (auto& entry : to_remove) {
log_debug("removing conversion: %s", entry.c_str());
ghc::filesystem::remove_all(entry);
std::filesystem::remove_all(entry);
}
});
}

4
src/file_converter_manager.hh
Unescape Escape View File

@ -37,13 +37,13 @@
#include "base/auto_pid.hh"
#include "base/result.h"
#include "file_format.hh"
#include "ghc/filesystem.hpp"
#include <filesystem>
namespace file_converter_manager {
struct convert_result {
auto_pid<process_state::running> cr_child;
ghc::filesystem::path cr_destination;
std::filesystem::path cr_destination;
std::shared_ptr<std::vector<std::string>> cr_error_queue;
};

2
src/file_format.cc
Unescape Escape View File

@ -40,7 +40,7 @@
#include "line_buffer.hh"
file_format_t
detect_file_format(const ghc::filesystem::path& filename)
detect_file_format(const std::filesystem::path& filename)
{
auto describe_res = archive_manager::describe(filename);
if (describe_res.isOk()

8
src/file_format.hh
Unescape Escape View File

@ -35,7 +35,7 @@
#include <optional>
#include "fmt/format.h"
#include "ghc/filesystem.hpp"
#include <filesystem>
enum class file_format_t : int {
UNKNOWN,
@ -48,13 +48,13 @@ enum class file_format_t : int {
struct external_file_format {
std::string eff_format_name;
std::string eff_converter;
ghc::filesystem::path eff_source_path;
std::filesystem::path eff_source_path;
};
file_format_t detect_file_format(const ghc::filesystem::path& filename);
file_format_t detect_file_format(const std::filesystem::path& filename);
std::optional<external_file_format> detect_mime_type(
const ghc::filesystem::path& filename);
const std::filesystem::path& filename);
namespace fmt {
template<>

4
src/file_options.cc
Unescape Escape View File

@ -115,9 +115,9 @@ file_options_collection::match(const std::string& path) const
}
std::optional<std::pair<std::string, file_options>>
file_options_hier::match(const ghc::filesystem::path& path) const
file_options_hier::match(const std::filesystem::path& path) const
{
static const auto ROOT_PATH = ghc::filesystem::path("/");
static const auto ROOT_PATH = std::filesystem::path("/");
auto lookup_path = path.parent_path();

6
src/file_options.hh
Unescape Escape View File

@ -35,7 +35,7 @@
#include "base/lnav.console.hh"
#include "base/result.h"
#include "date/tz.h"
#include "ghc/filesystem.hpp"
#include <filesystem>
#include "mapbox/variant.hpp"
#include "safe/safe.h"
#include "yajlpp/yajlpp.hh"
@ -66,12 +66,12 @@ struct file_options_collection {
};
struct file_options_hier {
std::map<ghc::filesystem::path, file_options_collection>
std::map<std::filesystem::path, file_options_collection>
foh_path_to_collection;
size_t foh_generation{0};
std::optional<std::pair<std::string, file_options>> match(
const ghc::filesystem::path& path) const;
const std::filesystem::path& path) const;
};
using safe_file_options_hier = safe::Safe<file_options_hier>;

6
src/files_sub_source.cc
Unescape Escape View File

@ -268,7 +268,7 @@ files_sub_source::text_value_for_line(textview_curses& tc,
if (line < errs->size()) {
auto iter = std::next(errs->begin(), line);
auto path = ghc::filesystem::path(iter->first);
auto path = std::filesystem::path(iter->first);
auto fn = fmt::to_string(path.filename());
truncate_to(fn, filename_width);
@ -293,7 +293,7 @@ files_sub_source::text_value_for_line(textview_curses& tc,
if (line < fc.fc_other_files.size()) {
auto iter = std::next(fc.fc_other_files.begin(), line);
auto path = ghc::filesystem::path(iter->first);
auto path = std::filesystem::path(iter->first);
auto fn = fmt::to_string(path);
truncate_to(fn, filename_width);
@ -322,7 +322,7 @@ files_sub_source::text_value_for_line(textview_curses& tc,
const auto& lf = fc.fc_files[line];
auto ld_opt = lnav_data.ld_log_source.find_data(lf);
auto fn = fmt::to_string(ghc::filesystem::path(lf->get_unique_path()));
auto fn = fmt::to_string(std::filesystem::path(lf->get_unique_path()));
char start_time[64] = "", end_time[64] = "";
std::vector<std::string> file_notes;

6
src/fstat_vtab.cc
Unescape Escape View File

@ -41,7 +41,7 @@
#include "base/lnav_log.hh"
#include "bound_tags.hh"
#include "config.h"
#include "ghc/filesystem.hpp"
#include <filesystem>
#include "sql_help.hh"
#include "sql_util.hh"
#include "vtab_module.hh"
@ -338,7 +338,7 @@ CREATE TABLE fstat (
SQLITE_TRANSIENT);
break;
case FSTAT_COL_DATA: {
auto fs_path = ghc::filesystem::path{path};
auto fs_path = std::filesystem::path{path};
if (!vc.c_error.empty()) {
sqlite3_result_null(ctx);
} else if (S_ISREG(vc.c_stat.st_mode)) {
@ -370,7 +370,7 @@ CREATE TABLE fstat (
to_sqlite(ctx, blob_auto_buffer{std::move(buffer)});
}
} else if (S_ISLNK(vc.c_stat.st_mode)) {
auto link_path = ghc::filesystem::read_symlink(fs_path);
auto link_path = std::filesystem::read_symlink(fs_path);
to_sqlite(ctx, link_path.string());
} else {

6049
src/ghc/filesystem.hpp
View File

File diff suppressed because it is too large Load Diff

38
src/ghc/fs_fwd.hpp
Unescape Escape View File

@ -1,38 +0,0 @@
//---------------------------------------------------------------------------------------
//
// ghc::filesystem - A C++17-like filesystem implementation for C++11/C++14
//
//---------------------------------------------------------------------------------------
//
// Copyright (c) 2018, Steffen Schümann <s.schuemann@pobox.com>
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
//
//---------------------------------------------------------------------------------------
// fs_fwd.hpp - The forwarding header for the header/implementation seperated usage of
// ghc::filesystem.
// This file can be include at any place, where ghc::filesystem api is needed while
// not bleeding implementation details (e.g. system includes) into the global namespace,
// as long as one cpp includes fs_impl.hpp to deliver the matching implementations.
//---------------------------------------------------------------------------------------
#ifndef GHC_FILESYSTEM_FWD_H
#define GHC_FILESYSTEM_FWD_H
#define GHC_FILESYSTEM_FWD
#include <ghc/filesystem.hpp>
#endif // GHC_FILESYSTEM_FWD_H

35
src/ghc/fs_impl.hpp
Unescape Escape View File

@ -1,35 +0,0 @@
//---------------------------------------------------------------------------------------
//
// ghc::filesystem - A C++17-like filesystem implementation for C++11/C++14
//
//---------------------------------------------------------------------------------------
//
// Copyright (c) 2018, Steffen Schümann <s.schuemann@pobox.com>
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
//
//---------------------------------------------------------------------------------------
// fs_impl.hpp - The implementation header for the header/implementation seperated usage of
// ghc::filesystem.
// This file can be used to hide the implementation of ghc::filesystem into a single cpp.
// The cpp has to include this before including fs_fwd.hpp directly or via a different
// header to work.
//---------------------------------------------------------------------------------------
#define GHC_FILESYSTEM_IMPLEMENTATION
#include <ghc/filesystem.hpp>

60
src/ghc/fs_std.hpp
Unescape Escape View File

@ -1,60 +0,0 @@
//---------------------------------------------------------------------------------------
//
// ghc::filesystem - A C++17-like filesystem implementation for C++11/C++14
//
//---------------------------------------------------------------------------------------
//
// Copyright (c) 2018, Steffen Schümann <s.schuemann@pobox.com>
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
//
//---------------------------------------------------------------------------------------
// fs_std.hpp - The dynamic switching header that includes std::filesystem if detected
// or ghc::filesystem if not, and makes the resulting API available in the
// namespace fs.
//---------------------------------------------------------------------------------------
#ifndef GHC_FILESYSTEM_STD_H
#define GHC_FILESYSTEM_STD_H
#if defined(__APPLE__)
#include <Availability.h>
#endif
#if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || (defined(__cplusplus) && __cplusplus >= 201703L)) && defined(__has_include)
#if __has_include(<filesystem>) && (!defined(__MAC_OS_X_VERSION_MIN_REQUIRED) || __MAC_OS_X_VERSION_MIN_REQUIRED >= 101500)
#define GHC_USE_STD_FS
#include <filesystem>
namespace fs {
using namespace std::filesystem;
using ifstream = std::ifstream;
using ofstream = std::ofstream;
using fstream = std::fstream;
}
#endif
#endif
#ifndef GHC_USE_STD_FS
//#define GHC_WIN_DISABLE_WSTRING_STORAGE_TYPE
#include <ghc/filesystem.hpp>
namespace fs {
using namespace ghc::filesystem;
using ifstream = ghc::filesystem::ifstream;
using ofstream = ghc::filesystem::ofstream;
using fstream = ghc::filesystem::fstream;
}
#endif
#endif // GHC_FILESYSTEM_STD_H

63
src/ghc/fs_std_fwd.hpp
Unescape Escape View File

@ -1,63 +0,0 @@
//---------------------------------------------------------------------------------------
//
// ghc::filesystem - A C++17-like filesystem implementation for C++11/C++14
//
//---------------------------------------------------------------------------------------
//
// Copyright (c) 2018, Steffen Schümann <s.schuemann@pobox.com>
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
//
//---------------------------------------------------------------------------------------
// fs_std_fwd.hpp - The forwarding header for the header/implementation seperated usage of
// ghc::filesystem that uses std::filesystem if it detects it.
// This file can be include at any place, where fs::filesystem api is needed while
// not bleeding implementation details (e.g. system includes) into the global namespace,
// as long as one cpp includes fs_std_impl.hpp to deliver the matching implementations.
//---------------------------------------------------------------------------------------
#ifndef GHC_FILESYSTEM_STD_FWD_H
#define GHC_FILESYSTEM_STD_FWD_H
#if defined(__APPLE__)
#include <Availability.h>
#endif
#if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || (defined(__cplusplus) && __cplusplus >= 201703L)) && defined(__has_include)
#if __has_include(<filesystem>) && (!defined(__MAC_OS_X_VERSION_MIN_REQUIRED) || __MAC_OS_X_VERSION_MIN_REQUIRED >= 101500)
#define GHC_USE_STD_FS
#include <filesystem>
namespace fs {
using namespace std::filesystem;
using ifstream = std::ifstream;
using ofstream = std::ofstream;
using fstream = std::fstream;
}
#endif
#endif
#ifndef GHC_USE_STD_FS
//#define GHC_WIN_DISABLE_WSTRING_STORAGE_TYPE
#define GHC_FILESYSTEM_FWD
#include <ghc/filesystem.hpp>
namespace fs {
using namespace ghc::filesystem;
using ifstream = ghc::filesystem::ifstream;
using ofstream = ghc::filesystem::ofstream;
using fstream = ghc::filesystem::fstream;
}
#endif
#endif // GHC_FILESYSTEM_STD_FWD_H

46
src/ghc/fs_std_impl.hpp
Unescape Escape View File

@ -1,46 +0,0 @@
//---------------------------------------------------------------------------------------
//
// ghc::filesystem - A C++17-like filesystem implementation for C++11/C++14
//
//---------------------------------------------------------------------------------------
//
// Copyright (c) 2018, Steffen Schümann <s.schuemann@pobox.com>
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
//
//---------------------------------------------------------------------------------------
// fs_std_impl.hpp - The implementation header for the header/implementation seperated usage of
// ghc::filesystem that does nothing if std::filesystem is detected.
// This file can be used to hide the implementation of ghc::filesystem into a single cpp.
// The cpp has to include this before including fs_std_fwd.hpp directly or via a different
// header to work.
//---------------------------------------------------------------------------------------
#if defined(__APPLE__)
#include <Availability.h>
#endif
#if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || (defined(__cplusplus) && __cplusplus >= 201703L)) && defined(__has_include)
#if __has_include(<filesystem>) && (!defined(__MAC_OS_X_VERSION_MIN_REQUIRED) || __MAC_OS_X_VERSION_MIN_REQUIRED >= 101500)
#define GHC_USE_STD_FS
#endif
#endif
#ifndef GHC_USE_STD_FS
//#define GHC_WIN_DISABLE_WSTRING_STORAGE_TYPE
#define GHC_FILESYSTEM_IMPLEMENTATION
#include <ghc/filesystem.hpp>
#endif

34
src/line_buffer.cc
Unescape Escape View File

@ -135,7 +135,8 @@ private:
#define Z_BUFSIZE 65536U
#define SYNCPOINT_SIZE (1024 * 1024)
line_buffer::gz_indexed::gz_indexed()
line_buffer::gz_indexed::
gz_indexed()
{
if ((this->inbuf = auto_mem<Bytef>::malloc(Z_BUFSIZE)) == NULL) {
throw std::bad_alloc();
@ -364,12 +365,14 @@ line_buffer::gz_indexed::read(void* buf, size_t offset, size_t size)
return bytes;
}
line_buffer::line_buffer()
line_buffer::
line_buffer()
{
ensure(this->invariant());
}
line_buffer::~line_buffer()
line_buffer::~
line_buffer()
{
if (this->lb_loader_future.valid()) {
this->lb_loader_future.wait();
@ -1312,8 +1315,8 @@ line_buffer::get_available()
static_cast<file_ssize_t>(this->lb_buffer.size())};
}
line_buffer::gz_indexed::indexDict::indexDict(const z_stream& s,
const file_size_t size)
line_buffer::gz_indexed::indexDict::
indexDict(const z_stream& s, const file_size_t size)
{
assert((s.data_type & GZ_END_OF_BLOCK_MASK));
assert(!(s.data_type & GZ_END_OF_FILE_MASK));
@ -1374,7 +1377,7 @@ line_buffer::quiesce()
}
}
static ghc::filesystem::path
static std::filesystem::path
line_buffer_cache_path()
{
return lnav::paths::workdir() / "buffer-cache";
@ -1405,7 +1408,7 @@ line_buffer::enable_cache()
.to_string();
auto cache_dir = line_buffer_cache_path() / cached_base_name.substr(0, 2);
ghc::filesystem::create_directories(cache_dir);
std::filesystem::create_directories(cache_dir);
auto cached_file_name = fmt::format(FMT_STRING("{}.bin"), cached_base_name);
auto cached_file_path = cache_dir / cached_file_name;
@ -1418,14 +1421,14 @@ line_buffer::enable_cache()
auto fl = lnav::filesystem::file_lock(cached_file_path);
auto guard = lnav::filesystem::file_lock::guard(&fl);
if (ghc::filesystem::exists(cached_done_path)) {
if (std::filesystem::exists(cached_done_path)) {
log_info("%d:using existing cache file");
auto open_res = lnav::filesystem::open_file(cached_file_path, O_RDWR);
if (open_res.isOk()) {
this->lb_cached_fd = open_res.unwrap();
return;
}
ghc::filesystem::remove(cached_done_path);
std::filesystem::remove(cached_done_path);
}
auto create_res = lnav::filesystem::create_file(
@ -1470,18 +1473,19 @@ void
line_buffer::cleanup_cache()
{
(void) std::async(std::launch::async, []() {
auto now = std::chrono::system_clock::now();
auto now = std::filesystem::file_time_type{
std::chrono::system_clock::now().time_since_epoch()};
auto cache_path = line_buffer_cache_path();
std::vector<ghc::filesystem::path> to_remove;
std::vector<std::filesystem::path> to_remove;
std::error_code ec;
for (const auto& cache_subdir :
ghc::filesystem::directory_iterator(cache_path, ec))
std::filesystem::directory_iterator(cache_path, ec))
{
for (const auto& entry :
ghc::filesystem::directory_iterator(cache_subdir, ec))
std::filesystem::directory_iterator(cache_subdir, ec))
{
auto mtime = ghc::filesystem::last_write_time(entry.path());
auto mtime = std::filesystem::last_write_time(entry.path());
auto exp_time = mtime + 1h;
if (now < exp_time) {
continue;
@ -1493,7 +1497,7 @@ line_buffer::cleanup_cache()
for (auto& entry : to_remove) {
log_debug("removing compressed file cache: %s", entry.c_str());
ghc::filesystem::remove_all(entry, ec);
std::filesystem::remove_all(entry, ec);
}
});
}

22
src/lnav.cc
Unescape Escape View File

@ -319,7 +319,7 @@ static bool
append_default_files()
{
bool retval = true;
auto cwd = ghc::filesystem::current_path();
auto cwd = std::filesystem::current_path();
for (const auto& path : DEFAULT_FILES) {
if (access(path.c_str(), R_OK) == 0) {
@ -2135,7 +2135,9 @@ print_user_msgs(std::vector<lnav::console::user_message> error_list,
if (warning_count > 0 && !mf.mf_print_warnings
&& !(lnav_data.ld_flags & LNF_HEADLESS)
&& (std::chrono::system_clock::now() - lnav_data.ld_last_dot_lnav_time
&& (std::filesystem::file_time_type{
std::chrono::system_clock::now().time_since_epoch()}
- lnav_data.ld_last_dot_lnav_time
> 24h))
{
lnav::console::print(
@ -2239,7 +2241,7 @@ main(int argc, char* argv[])
curr_tz,
},
};
options_hier->foh_path_to_collection.emplace(ghc::filesystem::path("/"),
options_hier->foh_path_to_collection.emplace(std::filesystem::path("/"),
options_coll);
} catch (const std::runtime_error& e) {
log_error("failed to setup tz: %s", e.what());
@ -2260,7 +2262,7 @@ main(int argc, char* argv[])
auto dot_lnav_path = lnav::paths::dotlnav();
std::error_code last_write_ec;
lnav_data.ld_last_dot_lnav_time
= ghc::filesystem::last_write_time(dot_lnav_path, last_write_ec);
= std::filesystem::last_write_time(dot_lnav_path, last_write_ec);
ensure_dotlnav();
@ -2625,7 +2627,7 @@ SELECT tbl_name FROM sqlite_master WHERE sql LIKE 'CREATE VIRTUAL TABLE%'
}
if (endswith(file_path, ".sql")) {
auto sql_path = ghc::filesystem::path(file_path);
auto sql_path = std::filesystem::path(file_path);
auto read_res = lnav::filesystem::read_file(sql_path);
if (read_res.isErr()) {
lnav::console::print(
@ -2675,8 +2677,8 @@ SELECT tbl_name FROM sqlite_master WHERE sql LIKE 'CREATE VIRTUAL TABLE%'
}
auto file_type = file_type_result.unwrap();
auto src_path = ghc::filesystem::path(file_path);
ghc::filesystem::path dst_name;
auto src_path = std::filesystem::path(file_path);
std::filesystem::path dst_name;
if (file_type == config_file_type::CONFIG) {
dst_name = src_path.filename();
} else {
@ -3031,7 +3033,7 @@ SELECT tbl_name FROM sqlite_master WHERE sql LIKE 'CREATE VIRTUAL TABLE%'
file_loc = file_path_str.substr(hash_index);
file_path_without_trailer = file_path_str.substr(0, hash_index);
}
auto file_path = ghc::filesystem::path(
auto file_path = std::filesystem::path(
stat(file_path_without_trailer.c_str(), &st) == 0
? file_path_without_trailer
: file_path_str);
@ -3207,7 +3209,7 @@ SELECT tbl_name FROM sqlite_master WHERE sql LIKE 'CREATE VIRTUAL TABLE%'
}
std::optional<std::string> stdin_url;
ghc::filesystem::path stdin_dir;
std::filesystem::path stdin_dir;
if (load_stdin && !isatty(STDIN_FILENO) && !is_dev_null(STDIN_FILENO)
&& !exec_stdin)
{
@ -3555,7 +3557,7 @@ SELECT tbl_name FROM sqlite_master WHERE sql LIKE 'CREATE VIRTUAL TABLE%'
{
file_size_t stdin_size = 0;
for (const auto& ent :
ghc::filesystem::directory_iterator(stdin_dir))
std::filesystem::directory_iterator(stdin_dir))
{
stdin_size += ent.file_size();
}

6
src/lnav.hh
Unescape Escape View File

@ -82,7 +82,7 @@ typedef enum {
} lnav_status_t;
using ppid_time_pair_t = std::pair<int, int>;
using session_pair_t = std::pair<ppid_time_pair_t, ghc::filesystem::path>;
using session_pair_t = std::pair<ppid_time_pair_t, std::filesystem::path>;
class input_state_tracker : public log_state_dumper {
public:
@ -164,7 +164,7 @@ struct lnav_data_t {
std::list<std::string> ld_commands;
bool ld_cmd_init_done;
bool ld_session_loaded;
std::vector<ghc::filesystem::path> ld_config_paths;
std::vector<std::filesystem::path> ld_config_paths;
file_collection ld_active_files;
std::list<child_poller> ld_child_pollers;
std::list<std::pair<std::string, file_location_t>> ld_files_to_front;
@ -261,7 +261,7 @@ struct lnav_data_t {
lnav::func::scoped_cb ld_status_refresher;
ghc::filesystem::file_time_type ld_last_dot_lnav_time;
std::filesystem::file_time_type ld_last_dot_lnav_time;
};
struct static_service {};

12
src/lnav.management_cli.cc
Unescape Escape View File

@ -669,7 +669,7 @@ struct subcmd_format_t {
auto ppath = regex101::patch_path(validate_res.unwrap(),
en.re_permalink);
if (ghc::filesystem::exists(ppath)) {
if (std::filesystem::exists(ppath)) {
return {
console::user_message::error(
attr_line_t("cannot delete regex101 entry "
@ -772,7 +772,7 @@ struct subcmd_piper_t {
static perform_result_t list_action(const subcmd_piper_t&)
{
static const intern_string_t SRC = intern_string::lookup("piper");
static const auto DOT_HEADER = ghc::filesystem::path(".header");
static const auto DOT_HEADER = std::filesystem::path(".header");
struct item {
lnav::piper::header i_header;
@ -784,7 +784,7 @@ struct subcmd_piper_t {
std::vector<item> items;
std::error_code ec;
for (const auto& instance_dir : ghc::filesystem::directory_iterator(
for (const auto& instance_dir : std::filesystem::directory_iterator(
lnav::piper::storage_path(), ec))
{
if (!instance_dir.is_directory()) {
@ -798,7 +798,7 @@ struct subcmd_piper_t {
instance_dir.path().filename().string());
file_size_t total_size{0};
auto hdr_path = instance_dir / DOT_HEADER;
if (ghc::filesystem::exists(hdr_path)) {
if (std::filesystem::exists(hdr_path)) {
auto hdr_read_res = lnav::filesystem::read_file(hdr_path);
if (hdr_read_res.isOk()) {
auto parse_res
@ -822,7 +822,7 @@ struct subcmd_piper_t {
}
for (const auto& entry :
ghc::filesystem::directory_iterator(instance_dir.path()))
std::filesystem::directory_iterator(instance_dir.path()))
{
if (entry.path().filename() == DOT_HEADER) {
continue;
@ -1007,7 +1007,7 @@ struct subcmd_piper_t {
{
std::error_code ec;
ghc::filesystem::remove_all(lnav::piper::storage_path(), ec);
std::filesystem::remove_all(lnav::piper::storage_path(), ec);
if (ec) {
return {
lnav::console::user_message::error(

8
src/lnav_commands.cc
Unescape Escape View File

@ -385,7 +385,7 @@ com_set_file_timezone(exec_context& ec,
const auto* tz = date::locate_zone(split_args[1]);
auto pattern = split_args.size() == 2
? line_pair->first->get_filename()
: ghc::filesystem::path(split_args[2]);
: std::filesystem::path(split_args[2]);
if (!ec.ec_dry_run) {
static auto& safe_options_hier
@ -485,7 +485,7 @@ com_set_file_timezone_prompt(exec_context& ec, const std::string& cmdline)
log_error("cannot get timezones: %s", e.what());
}
}
auto arg_path = ghc::filesystem::path(pattern_arg);
auto arg_path = std::filesystem::path(pattern_arg);
auto arg_parent = lnav::filesystem::escape_path(arg_path.parent_path());
if (!endswith(arg_parent, "/")) {
arg_parent += "/";
@ -3342,7 +3342,7 @@ com_open(exec_context& ec, std::string cmdline, std::vector<std::string>& args)
fn_str);
}
} else {
auto fn = ghc::filesystem::path(fn_str);
auto fn = std::filesystem::path(fn_str);
auto detect_res = detect_file_format(fn);
attr_line_t al;
attr_line_builder alb(al);
@ -3542,7 +3542,7 @@ com_close(exec_context& ec, std::string cmdline, std::vector<std::string>& args)
}
auto* tc = *lnav_data.ld_view_stack.top();
std::vector<std::optional<ghc::filesystem::path>> actual_path_v;
std::vector<std::optional<std::filesystem::path>> actual_path_v;
std::vector<std::string> fn_v;
if (args.size() > 1) {

24
src/lnav_config.cc
Unescape Escape View File

@ -168,9 +168,9 @@ ensure_dotlnav()
if (glob(crash_glob.c_str(), GLOB_NOCHECK, nullptr, gl.inout()) == 0) {
std::error_code ec;
for (size_t lpc = 0; lpc < gl->gl_pathc; lpc++) {
auto crash_file = ghc::filesystem::path(gl->gl_pathv[lpc]);
auto crash_file = std::filesystem::path(gl->gl_pathv[lpc]);
ghc::filesystem::rename(
std::filesystem::rename(
crash_file, crash_dir_path / crash_file.filename(), ec);
}
}
@ -241,11 +241,11 @@ install_from_git(const std::string& repo)
auto git_cmd = fork_res.unwrap();
if (git_cmd.in_child()) {
if (ghc::filesystem::is_directory(local_formats_path)) {
if (std::filesystem::is_directory(local_formats_path)) {
fmt::print("Updating format repo: {}\n", repo);
log_perror(chdir(local_formats_path.c_str()));
execlp("git", "git", "pull", nullptr);
} else if (ghc::filesystem::is_directory(local_configs_path)) {
} else if (std::filesystem::is_directory(local_configs_path)) {
fmt::print("Updating config repo: {}\n", repo);
log_perror(chdir(local_configs_path.c_str()));
execlp("git", "git", "pull", nullptr);
@ -266,12 +266,12 @@ install_from_git(const std::string& repo)
return false;
}
if (ghc::filesystem::is_directory(local_formats_path)
|| ghc::filesystem::is_directory(local_configs_path))
if (std::filesystem::is_directory(local_formats_path)
|| std::filesystem::is_directory(local_configs_path))
{
return false;
}
if (!ghc::filesystem::is_directory(local_staging_path)) {
if (!std::filesystem::is_directory(local_staging_path)) {
auto um
= lnav::console::user_message::error(
attr_line_t("failed to install git repo: ")
@ -293,7 +293,7 @@ install_from_git(const std::string& repo)
if (glob(config_path.c_str(), 0, nullptr, gl.inout()) == 0) {
for (size_t lpc = 0; lpc < gl->gl_pathc; lpc++) {
auto file_path = ghc::filesystem::path{gl->gl_pathv[lpc]};
auto file_path = std::filesystem::path{gl->gl_pathv[lpc]};
if (file_path.extension() == ".lnav") {
found_lnav_file += 1;
@ -380,7 +380,7 @@ update_installs_from_git()
if (glob(git_formats.c_str(), 0, nullptr, gl.inout()) == 0) {
for (int lpc = 0; lpc < (int) gl->gl_pathc; lpc++) {
auto git_dir
= ghc::filesystem::path(gl->gl_pathv[lpc]).parent_path();
= std::filesystem::path(gl->gl_pathv[lpc]).parent_path();
printf("Updating formats in %s\n", git_dir.c_str());
auto pull_cmd = fmt::format(FMT_STRING("cd '{}' && git pull"),
@ -1723,7 +1723,7 @@ public:
static active_key_map_listener KEYMAP_LISTENER;
Result<config_file_type, std::string>
detect_config_file_type(const ghc::filesystem::path& path)
detect_config_file_type(const std::filesystem::path& path)
{
static const char* id_path[] = {"$schema", nullptr};
@ -1758,7 +1758,7 @@ detect_config_file_type(const ghc::filesystem::path& path)
static void
load_config_from(_lnav_config& lconfig,
const ghc::filesystem::path& path,
const std::filesystem::path& path,
std::vector<lnav::console::user_message>& errors)
{
yajlpp_parse_context ypc(intern_string::lookup(path.string()),
@ -1856,7 +1856,7 @@ load_default_configs(struct _lnav_config& config_obj,
}
void
load_config(const std::vector<ghc::filesystem::path>& extra_paths,
load_config(const std::vector<std::filesystem::path>& extra_paths,
std::vector<lnav::console::user_message>& errors)
{
auto user_config = lnav::paths::dotlnav() / "config.json";

6
src/lnav_config.hh
Unescape Escape View File

@ -45,7 +45,7 @@
#include "base/result.h"
#include "external_opener.cfg.hh"
#include "file_vtab.cfg.hh"
#include "ghc/filesystem.hpp"
#include <filesystem>
#include "lnav_config_fwd.hh"
#include "log.annotate.cfg.hh"
#include "log_level.hh"
@ -144,9 +144,9 @@ enum class config_file_type {
};
Result<config_file_type, std::string> detect_config_file_type(
const ghc::filesystem::path& path);
const std::filesystem::path& path);
void load_config(const std::vector<ghc::filesystem::path>& extra_paths,
void load_config(const std::vector<std::filesystem::path>& extra_paths,
std::vector<lnav::console::user_message>& errors);
void reset_config(const std::string& path);

4
src/log.annotate.cc
Unescape Escape View File

@ -258,10 +258,10 @@ apply(vis_line_t vl, std::vector<intern_string_t> annos)
nullptr,
};
std::vector<ghc::filesystem::path> path_v;
std::vector<std::filesystem::path> path_v;
auto src_path
= ghc::filesystem::path(
= std::filesystem::path(
iter->second.a_handler.pp_location.sl_source.to_string())
.parent_path();
path_v.push_back(src_path);

4
src/log_actions.cc
Unescape Escape View File

@ -134,10 +134,10 @@ action_delegate::execute_action(const std::string& action_name)
std::move(out_pipe.read_end()),
false,
lnav::filesystem::open_temp_file(
ghc::filesystem::temp_directory_path()
std::filesystem::temp_directory_path()
/ "lnav.action.XXXXXX")
.map([](auto pair) {
ghc::filesystem::remove(pair.first);
std::filesystem::remove(pair.first);
return pair;
})

2
src/log_format.cc
Unescape Escape View File

@ -2632,7 +2632,7 @@ using safe_format_header_expressions = safe::Safe<format_header_expressions>;
static safe_format_header_expressions format_header_exprs;
std::optional<external_file_format>
detect_mime_type(const ghc::filesystem::path& filename)
detect_mime_type(const std::filesystem::path& filename)
{
uint8_t buffer[1024];
size_t buffer_size = 0;

2
src/log_format_ext.hh
Unescape Escape View File

@ -322,7 +322,7 @@ public:
GRAPH_ORDERED_FORMATS;
std::set<std::string> elf_source_path;
std::vector<ghc::filesystem::path> elf_format_source_order;
std::vector<std::filesystem::path> elf_format_source_order;
std::map<intern_string_t, int> elf_format_sources;
std::list<intern_string_t> elf_collision;
factory_container<lnav::pcre2pp::code> elf_filename_pcre;

20
src/log_format_loader.cc
Unescape Escape View File

@ -69,7 +69,7 @@ static log_formats_map_t LOG_FORMATS;
struct loader_userdata {
yajlpp_parse_context* ud_parse_context{nullptr};
std::string ud_file_schema;
ghc::filesystem::path ud_format_path;
std::filesystem::path ud_format_path;
std::vector<intern_string_t>* ud_format_names{nullptr};
std::vector<lnav::console::user_message>* ud_errors{nullptr};
};
@ -1221,7 +1221,7 @@ format_error_reporter(const yajlpp_parse_context& ypc,
}
std::vector<intern_string_t>
load_format_file(const ghc::filesystem::path& filename,
load_format_file(const std::filesystem::path& filename,
std::vector<lnav::console::user_message>& errors)
{
std::vector<intern_string_t> retval;
@ -1310,7 +1310,7 @@ load_format_file(const ghc::filesystem::path& filename,
}
static void
load_from_path(const ghc::filesystem::path& path,
load_from_path(const std::filesystem::path& path,
std::vector<lnav::console::user_message>& errors)
{
auto format_path = path / "formats/*/*.json";
@ -1319,7 +1319,7 @@ load_from_path(const ghc::filesystem::path& path,
log_info("loading formats from path: %s", format_path.c_str());
if (glob(format_path.c_str(), 0, nullptr, gl.inout()) == 0) {
for (int lpc = 0; lpc < (int) gl->gl_pathc; lpc++) {
auto filepath = ghc::filesystem::path(gl->gl_pathv[lpc]);
auto filepath = std::filesystem::path(gl->gl_pathv[lpc]);
if (startswith(filepath.filename().string(), "config.")) {
log_info(" not loading config as format: %s",
@ -1343,7 +1343,7 @@ load_from_path(const ghc::filesystem::path& path,
}
void
load_formats(const std::vector<ghc::filesystem::path>& extra_paths,
load_formats(const std::vector<std::filesystem::path>& extra_paths,
std::vector<lnav::console::user_message>& errors)
{
auto default_source = lnav::paths::dotlnav() / "default";
@ -1479,7 +1479,7 @@ load_formats(const std::vector<ghc::filesystem::path>& extra_paths,
static void
exec_sql_in_path(sqlite3* db,
const std::map<std::string, scoped_value_t>& global_vars,
const ghc::filesystem::path& path,
const std::filesystem::path& path,
std::vector<lnav::console::user_message>& errors)
{
auto format_path = path / "formats/*/*.sql";
@ -1488,7 +1488,7 @@ exec_sql_in_path(sqlite3* db,
log_info("executing SQL files in path: %s", format_path.c_str());
if (glob(format_path.c_str(), 0, nullptr, gl.inout()) == 0) {
for (int lpc = 0; lpc < (int) gl->gl_pathc; lpc++) {
auto filename = ghc::filesystem::path(gl->gl_pathv[lpc]);
auto filename = std::filesystem::path(gl->gl_pathv[lpc]);
auto read_res = lnav::filesystem::read_file(filename);
if (read_res.isOk()) {
@ -1511,7 +1511,7 @@ exec_sql_in_path(sqlite3* db,
void
load_format_extra(sqlite3* db,
const std::map<std::string, scoped_value_t>& global_vars,
const std::vector<ghc::filesystem::path>& extra_paths,
const std::vector<std::filesystem::path>& extra_paths,
std::vector<lnav::console::user_message>& errors)
{
for (const auto& extra_path : extra_paths) {
@ -1585,7 +1585,7 @@ extract_metadata_from_file(struct script_metadata& meta_inout)
}
static void
find_format_in_path(const ghc::filesystem::path& path,
find_format_in_path(const std::filesystem::path& path,
available_scripts& scripts)
{
for (auto format_path :
@ -1612,7 +1612,7 @@ find_format_in_path(const ghc::filesystem::path& path,
}
void
find_format_scripts(const std::vector<ghc::filesystem::path>& extra_paths,
find_format_scripts(const std::vector<std::filesystem::path>& extra_paths,
available_scripts& scripts)
{
for (const auto& extra_path : extra_paths) {

12
src/log_format_loader.hh
Unescape Escape View File

@ -39,16 +39,16 @@
#include "base/intern_string.hh"
#include "base/lnav.console.hh"
#include "ghc/filesystem.hpp"
#include <filesystem>
#include "shlex.resolver.hh"
class log_vtab_manager;
std::vector<intern_string_t> load_format_file(
const ghc::filesystem::path& filename,
const std::filesystem::path& filename,
std::vector<lnav::console::user_message>& errors);
void load_formats(const std::vector<ghc::filesystem::path>& extra_paths,
void load_formats(const std::vector<std::filesystem::path>& extra_paths,
std::vector<lnav::console::user_message>& errors);
void load_format_vtabs(log_vtab_manager* vtab_manager,
@ -56,11 +56,11 @@ void load_format_vtabs(log_vtab_manager* vtab_manager,
void load_format_extra(sqlite3* db,
const std::map<std::string, scoped_value_t>& global_vars,
const std::vector<ghc::filesystem::path>& extra_paths,
const std::vector<std::filesystem::path>& extra_paths,
std::vector<lnav::console::user_message>& errors);
struct script_metadata {
ghc::filesystem::path sm_path;
std::filesystem::path sm_path;
std::string sm_name;
std::string sm_synopsis;
std::string sm_description;
@ -72,7 +72,7 @@ struct available_scripts {
std::map<std::string, std::vector<script_metadata>> as_scripts;
};
void find_format_scripts(const std::vector<ghc::filesystem::path>& extra_paths,
void find_format_scripts(const std::vector<std::filesystem::path>& extra_paths,
available_scripts& scripts);
extern const struct json_path_container format_handlers;

10
src/logfile.cc
Unescape Escape View File

@ -70,7 +70,7 @@ static const typed_json_path_container<lnav::gzip::header> file_header_handlers
};
Result<std::shared_ptr<logfile>, std::string>
logfile::open(ghc::filesystem::path filename,
logfile::open(std::filesystem::path filename,
const logfile_open_options& loo,
auto_fd fd)
{
@ -79,7 +79,7 @@ logfile::open(ghc::filesystem::path filename,
auto lf = std::shared_ptr<logfile>(new logfile(std::move(filename), loo));
memset(&lf->lf_stat, 0, sizeof(lf->lf_stat));
ghc::filesystem::path resolved_path;
std::filesystem::path resolved_path;
if (!fd.has_value()) {
auto rp_res = lnav::filesystem::realpath(lf->lf_filename);
@ -196,7 +196,7 @@ logfile::open(ghc::filesystem::path filename,
return Ok(lf);
}
logfile::logfile(ghc::filesystem::path filename,
logfile::logfile(std::filesystem::path filename,
const logfile_open_options& loo)
: lf_filename(std::move(filename)), lf_options(loo)
{
@ -1297,7 +1297,7 @@ logfile::reobserve_from(iterator iter)
}
}
ghc::filesystem::path
std::filesystem::path
logfile::get_path() const
{
return this->lf_filename;
@ -1420,7 +1420,7 @@ logfile::set_filename(const std::string& filename)
{
if (this->lf_filename != filename) {
this->lf_filename = filename;
ghc::filesystem::path p(filename);
std::filesystem::path p(filename);
this->lf_basename = p.filename();
}
}

16
src/logfile.hh
Unescape Escape View File

@ -49,7 +49,7 @@
#include "bookmarks.hh"
#include "byte_array.hh"
#include "file_options.hh"
#include "ghc/filesystem.hpp"
#include <filesystem>
#include "line_buffer.hh"
#include "log_format_fwd.hh"
#include "logfile_fwd.hh"
@ -114,7 +114,7 @@ public:
* descriptor needs to be seekable.
*/
static Result<std::shared_ptr<logfile>, std::string> open(
ghc::filesystem::path filename,
std::filesystem::path filename,
const logfile_open_options& loo,
auto_fd fd = auto_fd{});
@ -122,13 +122,13 @@ public:
const logfile_activity& get_activity() const { return this->lf_activity; }
std::optional<ghc::filesystem::path> get_actual_path() const
std::optional<std::filesystem::path> get_actual_path() const
{
return this->lf_actual_path;
}
/** @return The filename as given in the constructor. */
const ghc::filesystem::path& get_filename() const
const std::filesystem::path& get_filename() const
{
return this->lf_filename;
}
@ -371,7 +371,7 @@ public:
return true;
}
ghc::filesystem::path get_path() const override;
std::filesystem::path get_path() const override;
enum class note_type {
indexing_disabled,
@ -435,16 +435,16 @@ protected:
void set_format_base_time(log_format* lf);
private:
logfile(ghc::filesystem::path filename, const logfile_open_options& loo);
logfile(std::filesystem::path filename, const logfile_open_options& loo);
bool file_options_have_changed();
ghc::filesystem::path lf_filename;
std::filesystem::path lf_filename;
logfile_open_options lf_options;
logfile_activity lf_activity;
bool lf_named_file{true};
bool lf_valid_filename{true};
std::optional<ghc::filesystem::path> lf_actual_path;
std::optional<std::filesystem::path> lf_actual_path;
std::string lf_basename;
std::string lf_content_id;
struct stat lf_stat {};

2
src/logfile_fwd.hh
Unescape Escape View File

@ -35,6 +35,8 @@
#include <chrono>
#include <string>
#include <sys/stat.h>
#include "base/auto_fd.hh"
#include "file_format.hh"
#include "piper.looper.hh"

8
src/md2attr_line.cc
Unescape Escape View File

@ -714,7 +714,7 @@ md2attr_line::to_attr_line(const pugi::xml_node& doc)
if (img_alt) {
link_label = img_alt.value();
} else if (img_src) {
link_label = ghc::filesystem::path(img_src.value())
link_label = std::filesystem::path(img_src.value())
.filename()
.string();
} else {
@ -726,14 +726,14 @@ md2attr_line::to_attr_line(const pugi::xml_node& doc)
if (is_url(src_value)) {
src_href = src_value;
} else {
auto src_path = ghc::filesystem::path(src_value);
auto src_path = std::filesystem::path(src_value);
std::error_code ec;
if (src_path.is_relative() && this->ml_source_path) {
src_path = this->ml_source_path.value().parent_path()
/ src_path;
}
auto canon_path = ghc::filesystem::canonical(src_path, ec);
auto canon_path = std::filesystem::canonical(src_path, ec);
if (!ec) {
src_path = canon_path;
}
@ -1074,7 +1074,7 @@ md2attr_line::append_url_footnote(std::string href_str)
last_block.append(to_superscript(this->ml_footnotes.size() + 1));
this->ml_last_superscript_index = last_block.length();
if (this->ml_source_path && href_str.find(':') == std::string::npos) {
auto link_path = ghc::filesystem::absolute(
auto link_path = std::filesystem::absolute(
this->ml_source_path.value().parent_path() / href_str);
href_str = fmt::format(FMT_STRING("file://{}"), link_path.string());

6
src/md2attr_line.hh
Unescape Escape View File

@ -31,7 +31,7 @@
#define lnav_md2attr_line_hh
#include "base/attr_line.hh"
#include "ghc/filesystem.hpp"
#include <filesystem>
#include "md4cpp.hh"
namespace pugi {
@ -42,7 +42,7 @@ class md2attr_line : public md4cpp::typed_event_handler<attr_line_t> {
public:
md2attr_line() { this->ml_blocks.resize(1); }
md2attr_line& with_source_path(std::optional<ghc::filesystem::path> path)
md2attr_line& with_source_path(std::optional<std::filesystem::path> path)
{
this->ml_source_path = path;
return *this;
@ -83,7 +83,7 @@ private:
void flush_footnotes();
attr_line_t to_attr_line(const pugi::xml_node& doc);
std::optional<ghc::filesystem::path> ml_source_path;
std::optional<std::filesystem::path> ml_source_path;
std::vector<attr_line_t> ml_blocks;
std::vector<list_block_t> ml_list_stack;
std::vector<table_t> ml_tables;

23
src/piper.looper.cc
Unescape Escape View File

@ -189,7 +189,7 @@ environ_to_map()
looper::
looper(std::string name, auto_fd stdout_fd, auto_fd stderr_fd, options opts)
: l_name(std::move(name)), l_cwd(ghc::filesystem::current_path().string()),
: l_name(std::move(name)), l_cwd(std::filesystem::current_path().string()),
l_env(environ_to_map()), l_stdout(std::move(stdout_fd)),
l_stderr(std::move(stderr_fd)), l_options(opts)
{
@ -202,8 +202,8 @@ looper(std::string name, auto_fd stdout_fd, auto_fd stderr_fd, options opts)
hasher().update(getmstime()).update(l_name).to_string(),
count);
count += 1;
} while (ghc::filesystem::exists(this->l_out_dir));
ghc::filesystem::create_directories(this->l_out_dir);
} while (std::filesystem::exists(this->l_out_dir));
std::filesystem::create_directories(this->l_out_dir);
this->l_future = std::async(std::launch::async, [this]() { this->loop(); });
}
@ -638,7 +638,7 @@ looper::loop()
/ fmt::format(FMT_STRING("out.{}.{}"),
os.os_hash_id,
rotate_count % cfg.c_rotations);
ghc::filesystem::rename(tmp_path, out_path);
std::filesystem::rename(tmp_path, out_path);
}
ssize_t wrc;
@ -724,14 +724,15 @@ cleanup()
{
(void) std::async(std::launch::async, []() {
const auto& cfg = injector::get<const config&>();
auto now = std::chrono::system_clock::now();
auto now = std::filesystem::file_time_type{
std::chrono::system_clock::now().time_since_epoch()};
auto cache_path = storage_path();
std::vector<ghc::filesystem::path> to_remove;
std::vector<std::filesystem::path> to_remove;
for (const auto& cache_subdir :
ghc::filesystem::directory_iterator(cache_path))
std::filesystem::directory_iterator(cache_path))
{
auto mtime = ghc::filesystem::last_write_time(cache_subdir.path());
auto mtime = std::filesystem::last_write_time(cache_subdir.path());
auto exp_time = mtime + cfg.c_ttl;
if (now < exp_time) {
continue;
@ -740,9 +741,9 @@ cleanup()
bool is_recent = false;
for (const auto& entry :
ghc::filesystem::directory_iterator(cache_subdir))
std::filesystem::directory_iterator(cache_subdir))
{
auto mtime = ghc::filesystem::last_write_time(entry.path());
auto mtime = std::filesystem::last_write_time(entry.path());
auto exp_time = mtime + cfg.c_ttl;
if (now < exp_time) {
is_recent = true;
@ -756,7 +757,7 @@ cleanup()
for (auto& entry : to_remove) {
log_debug("removing piper directory: %s", entry.c_str());
ghc::filesystem::remove_all(entry);
std::filesystem::remove_all(entry);
}
});
}

12
src/piper.looper.hh
Unescape Escape View File

@ -37,7 +37,7 @@
#include "base/auto_fd.hh"
#include "base/piper.file.hh"
#include "base/result.h"
#include "ghc/filesystem.hpp"
#include <filesystem>
#include "safe/safe.h"
#include "yajlpp/yajlpp_def.hh"
@ -79,9 +79,9 @@ public:
std::string get_name() const { return this->l_name; }
ghc::filesystem::path get_out_dir() const { return this->l_out_dir; }
std::filesystem::path get_out_dir() const { return this->l_out_dir; }
ghc::filesystem::path get_out_pattern() const
std::filesystem::path get_out_pattern() const
{
return this->l_out_dir / "out.*";
}
@ -124,7 +124,7 @@ private:
const std::string l_name;
const std::string l_cwd;
const std::map<std::string, std::string> l_env;
ghc::filesystem::path l_out_dir;
std::filesystem::path l_out_dir;
auto_fd l_stdout;
auto_fd l_stderr;
options l_options;
@ -144,12 +144,12 @@ public:
std::string get_name() const { return this->h_looper->get_name(); }
ghc::filesystem::path get_out_dir() const
std::filesystem::path get_out_dir() const
{
return this->h_looper->get_out_dir();
}
ghc::filesystem::path get_out_pattern() const
std::filesystem::path get_out_pattern() const
{
return this->h_looper->get_out_pattern();
}

2
src/readline_callbacks.cc
Unescape Escape View File

@ -1015,7 +1015,7 @@ rl_callback_int(readline_curses* rc, bool is_alt)
case ln_mode_t::EXEC: {
std::error_code errc;
ghc::filesystem::create_directories(lnav::paths::workdir(), errc);
std::filesystem::create_directories(lnav::paths::workdir(), errc);
auto open_temp_res = lnav::filesystem::open_temp_file(
lnav::paths::workdir() / "exec.XXXXXX");

21
src/readline_curses.cc
Unescape Escape View File

@ -35,6 +35,7 @@
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/param.h>
#include <sys/socket.h>
#include <sys/wait.h>
#include <unistd.h>
@ -640,9 +641,10 @@ readline_context::command_complete(int count, int key)
return rl_insert(count, key);
}
readline_context::readline_context(std::string name,
readline_context::command_map_t* commands,
bool case_sensitive)
readline_context::
readline_context(std::string name,
readline_context::command_map_t* commands,
bool case_sensitive)
: rc_name(std::move(name)), rc_case_sensitive(case_sensitive),
rc_quote_chars("\"'"), rc_highlighter(nullptr)
{
@ -723,8 +725,8 @@ readline_context::save()
hs = nullptr;
}
readline_curses::readline_curses(
std::shared_ptr<pollable_supervisor> supervisor)
readline_curses::
readline_curses(std::shared_ptr<pollable_supervisor> supervisor)
: pollable(supervisor, pollable::category::interactive),
rc_focus(noop_func{}), rc_change(noop_func{}), rc_perform(noop_func{}),
rc_alt_perform(noop_func{}), rc_timeout(noop_func{}),
@ -734,7 +736,8 @@ readline_curses::readline_curses(
{
}
readline_curses::~readline_curses()
readline_curses::~
readline_curses()
{
this->rc_pty[RCF_MASTER].reset();
this->rc_command_pipe[RCF_MASTER].reset();
@ -849,16 +852,16 @@ readline_curses::start()
throw error(errno);
}
auto slave_path = ghc::filesystem::path(slave_path_str);
auto slave_path = std::filesystem::path(slave_path_str);
std::error_code ec;
if (!ghc::filesystem::exists(slave_path, ec)) {
if (!std::filesystem::exists(slave_path, ec)) {
log_warning("ptsname_r() result does not exist -- %s", slave_path_str);
#ifdef TIOCGPTN
int ptn = 0;
if (ioctl(this->rc_pty[RCF_MASTER], TIOCGPTN, &ptn) == 0) {
snprintf(
slave_path_str, sizeof(slave_path_str), "/dev/ttyp%d", ptn);
slave_path = ghc::filesystem::path(slave_path_str);
slave_path = std::filesystem::path(slave_path_str);
log_warning("... trying %s", slave_path.c_str());
}
#endif

2
src/readline_possibilities.cc
Unescape Escape View File

@ -479,7 +479,7 @@ add_config_possibilities()
visited.insert(named_cap.get_name().to_string());
}
ghc::filesystem::path path_obj(path);
std::filesystem::path path_obj(path);
rc->add_possibility(ln_mode_t::COMMAND,
named_cap.get_name().to_string(),
path_obj.parent_path().filename().string());

4
src/regex101.client.cc
Unescape Escape View File

@ -34,7 +34,7 @@
#include "base/itertools.hh"
#include "config.h"
#include "curl_looper.hh"
#include "ghc/filesystem.hpp"
#include <filesystem>
#include "yajlpp/yajlpp_def.hh"
namespace regex101 {
@ -80,7 +80,7 @@ static const typed_json_path_container<upsert_response> RESPONSE_HANDLERS = {
yajlpp::property_handler("version").for_field(&upsert_response::cr_version),
};
static const ghc::filesystem::path REGEX101_BASE_URL
static const std::filesystem::path REGEX101_BASE_URL
= "https://regex101.com/api/regex";
static const char* USER_AGENT = "lnav/" PACKAGE_VERSION;

8
src/regex101.import.cc
Unescape Escape View File

@ -47,7 +47,7 @@ static const std::set<std::string> SUPPORTED_FLAVORS = {
"pcre2",
};
Result<ghc::filesystem::path, lnav::console::user_message>
Result<std::filesystem::path, lnav::console::user_message>
regex101::import(const std::string& url,
const std::string& name,
const std::string& pat_name)
@ -124,7 +124,7 @@ regex101::import(const std::string& url,
auto format_path
= lnav::paths::dotlnav() / "formats" / "installed" / format_filename;
if (ghc::filesystem::exists(format_path)) {
if (std::filesystem::exists(format_path)) {
return Err(lnav::console::user_message::error(
attr_line_t("unable to import: ")
.append(lnav::roles::file(url)))
@ -270,7 +270,7 @@ regex101::import(const std::string& url,
return Ok(format_path);
}
ghc::filesystem::path
std::filesystem::path
regex101::patch_path(const external_log_format* format,
const std::string& permalink)
{
@ -287,7 +287,7 @@ regex101::patch_path(const external_log_format* format,
fmt::format(FMT_STRING("regex101-{}.json"), permalink));
}
Result<ghc::filesystem::path, lnav::console::user_message>
Result<std::filesystem::path, lnav::console::user_message>
regex101::patch(const external_log_format* format,
const std::string& pat_name,
const regex101::client::entry& entry)

8
src/regex101.import.hh
Unescape Escape View File

@ -33,21 +33,21 @@
#include <map>
#include "base/lnav.console.hh"
#include "ghc/filesystem.hpp"
#include <filesystem>
#include "log_format_ext.hh"
#include "regex101.client.hh"
namespace regex101 {
Result<ghc::filesystem::path, lnav::console::user_message> import(
Result<std::filesystem::path, lnav::console::user_message> import(
const std::string& url,
const std::string& name,
const std::string& pat_name);
ghc::filesystem::path patch_path(const external_log_format* format,
std::filesystem::path patch_path(const external_log_format* format,
const std::string& permalink);
Result<ghc::filesystem::path, lnav::console::user_message> patch(
Result<std::filesystem::path, lnav::console::user_message> patch(
const external_log_format* format,
const std::string& pat_name,
const regex101::client::entry& entry);

16
src/session.export.cc
Unescape Escape View File

@ -113,14 +113,14 @@ struct from_sqlite<log_file_session_state> {
namespace lnav {
namespace session {
static std::optional<ghc::filesystem::path>
find_container_dir(ghc::filesystem::path file_path)
static std::optional<std::filesystem::path>
find_container_dir(std::filesystem::path file_path)
{
if (!ghc::filesystem::exists(file_path)) {
if (!std::filesystem::exists(file_path)) {
return std::nullopt;
}
std::optional<ghc::filesystem::path> dir_with_last_readme;
std::optional<std::filesystem::path> dir_with_last_readme;
while (file_path.has_parent_path()
&& file_path != file_path.root_directory())
@ -130,7 +130,7 @@ find_container_dir(ghc::filesystem::path file_path)
std::error_code ec;
for (const auto& entry :
ghc::filesystem::directory_iterator(parent, ec))
std::filesystem::directory_iterator(parent, ec))
{
if (!entry.is_regular_file()) {
continue;
@ -281,12 +281,12 @@ SELECT content_id, format, time_offset FROM lnav_file
}
auto file_path_str = name_pair.first;
auto file_path = ghc::filesystem::path(file_path_str);
auto file_path = std::filesystem::path(file_path_str);
auto container_path_opt = find_container_dir(file_path);
if (container_path_opt) {
auto container_parent = container_path_opt.value().parent_path();
auto file_container_path
= ghc::filesystem::relative(file_path, container_parent)
= std::filesystem::relative(file_path, container_parent)
.string();
file_containers[container_parent.string()].push_back(
file_container_path);
@ -474,7 +474,7 @@ SELECT content_id, format, time_offset FROM lnav_file
}
auto container_parent
= container_path_opt.value().parent_path();
auto file_container_path = ghc::filesystem::relative(
auto file_container_path = std::filesystem::relative(
ld->get_file_ptr()->get_path(), container_parent);
fmt::print(file,
FMT_STRING(":hide-file */{}\n"),

12
src/static_file_vtab.cc
Unescape Escape View File

@ -37,7 +37,7 @@
#include "base/fs_util.hh"
#include "base/lnav_log.hh"
#include "config.h"
#include "ghc/filesystem.hpp"
#include <filesystem>
#include "lnav.hh"
#include "vtab_module.hh"
@ -49,7 +49,7 @@ struct static_file_vtab {
};
struct static_file_info {
ghc::filesystem::path sfi_path;
std::filesystem::path sfi_path;
};
struct sf_vtab_cursor {
@ -124,13 +124,13 @@ sfvt_destroy(sqlite3_vtab* p_vt)
static int sfvt_next(sqlite3_vtab_cursor* cur);
static void
find_static_files(sf_vtab_cursor* p_cur, const ghc::filesystem::path& dir)
find_static_files(sf_vtab_cursor* p_cur, const std::filesystem::path& dir)
{
auto& file_map = p_cur->vc_files;
std::error_code ec;
for (const auto& format_dir_entry :
ghc::filesystem::directory_iterator(dir, ec))
std::filesystem::directory_iterator(dir, ec))
{
if (!format_dir_entry.is_directory()) {
continue;
@ -138,10 +138,10 @@ find_static_files(sf_vtab_cursor* p_cur, const ghc::filesystem::path& dir)
auto format_static_files_dir = format_dir_entry.path() / "static-files";
log_debug("format static files: %s", format_static_files_dir.c_str());
for (const auto& static_file_entry :
ghc::filesystem::recursive_directory_iterator(
std::filesystem::recursive_directory_iterator(
format_static_files_dir, ec))
{
auto rel_path = ghc::filesystem::relative(static_file_entry.path(),
auto rel_path = std::filesystem::relative(static_file_entry.path(),
format_static_files_dir);
file_map[rel_path.string()] = {static_file_entry.path()};

22
src/tailer/drive_tailer.cc
Unescape Escape View File

@ -34,7 +34,7 @@
#include "base/auto_fd.hh"
#include "base/auto_pid.hh"
#include "config.h"
#include "ghc/filesystem.hpp"
#include <filesystem>
#include "line_buffer.hh"
#include "tailerpp.hh"
@ -102,7 +102,7 @@ main(int argc, char* const* argv)
err_pipe.after_fork(child.in());
if (child.in_child()) {
auto this_exe = ghc::filesystem::path(argv[0]);
auto this_exe = std::filesystem::path(argv[0]);
auto exe_dir = this_exe.parent_path();
auto tailer_exe = exe_dir / "tailer";
@ -165,8 +165,8 @@ main(int argc, char* const* argv)
pe.pe_path.c_str(),
pe.pe_msg.c_str());
auto remote_path = ghc::filesystem::absolute(
ghc::filesystem::path(pe.pe_path))
auto remote_path = std::filesystem::absolute(
std::filesystem::path(pe.pe_path))
.relative_path();
printf("removing %s\n", remote_path.c_str());
@ -177,8 +177,8 @@ main(int argc, char* const* argv)
pob.pob_offset,
pob.pob_length);
auto remote_path = ghc::filesystem::absolute(
ghc::filesystem::path(pob.pob_path))
auto remote_path = std::filesystem::absolute(
std::filesystem::path(pob.pob_path))
.relative_path();
#if 0
auto local_path = tmppath / remote_path;
@ -196,7 +196,7 @@ main(int argc, char* const* argv)
struct stat st;
if (fstat(fd, &st) == -1 || !S_ISREG(st.st_mode)) {
ghc::filesystem::remove_all(local_path);
std::filesystem::remove_all(local_path);
send_packet(to_child.get(),
TPT_NEED_BLOCK,
TPPT_STRING, pob.pob_path.c_str(),
@ -222,7 +222,7 @@ main(int argc, char* const* argv)
return;
}
} else if (bytes_read == -1) {
ghc::filesystem::remove_all(local_path);
std::filesystem::remove_all(local_path);
}
send_packet(to_child.get(),
TPT_NEED_BLOCK,
@ -234,11 +234,11 @@ main(int argc, char* const* argv)
#if 0
//printf("got a tail: %s %lld %ld\n", ptb.ptb_path.c_str(),
// ptb.ptb_offset, ptb.ptb_bits.size());
auto remote_path = ghc::filesystem::absolute(
ghc::filesystem::path(ptb.ptb_path)).relative_path();
auto remote_path = std::filesystem::absolute(
std::filesystem::path(ptb.ptb_path)).relative_path();
auto local_path = tmppath / remote_path;
ghc::filesystem::create_directories(local_path.parent_path());
std::filesystem::create_directories(local_path.parent_path());
auto fd = auto_fd(
open(local_path.c_str(), O_WRONLY | O_APPEND | O_CREAT,
0600));

68
src/tailer/tailer.looper.cc
Unescape Escape View File

@ -448,18 +448,18 @@ tailer::looper::host_tailer::for_host(const std::string& netloc)
std::move(err_pipe.read_end())));
}
static ghc::filesystem::path
static std::filesystem::path
remote_cache_path()
{
return lnav::paths::workdir() / "remotes";
}
ghc::filesystem::path
std::filesystem::path
tailer::looper::host_tailer::tmp_path()
{
auto local_path = remote_cache_path();
ghc::filesystem::create_directories(local_path);
std::filesystem::create_directories(local_path);
auto_mem<char> resolved_path;
resolved_path = realpath(local_path.c_str(), nullptr);
@ -478,11 +478,12 @@ scrub_netloc(const std::string& netloc)
return std::regex_replace(netloc, TO_SCRUB, "_");
}
tailer::looper::host_tailer::host_tailer(const std::string& netloc,
auto_pid<process_state::running> child,
auto_fd to_child,
auto_fd from_child,
auto_fd err_from_child)
tailer::looper::host_tailer::
host_tailer(const std::string& netloc,
auto_pid<process_state::running> child,
auto_fd to_child,
auto_fd from_child,
auto_fd err_from_child)
: isc::service<host_tailer>(netloc), ht_netloc(netloc),
ht_local_path(tmp_path() / scrub_netloc(netloc)),
ht_error_reader([netloc,
@ -578,9 +579,9 @@ tailer::looper::host_tailer::loop_body()
this->ht_cycle_count += 1;
if (this->ht_cycle_count % TOUCH_FREQ == 0) {
auto now
= ghc::filesystem::file_time_type{std::chrono::system_clock::now()};
ghc::filesystem::last_write_time(this->ht_local_path, now);
auto now = std::filesystem::file_time_type{
std::chrono::system_clock::now().time_since_epoch()};
std::filesystem::last_write_time(this->ht_local_path, now);
}
auto& conn = this->ht_state.get<connected>();
@ -648,14 +649,14 @@ tailer::looper::host_tailer::loop_body()
}
}
auto remote_path = ghc::filesystem::absolute(
ghc::filesystem::path(pe.pe_path))
auto remote_path = std::filesystem::absolute(
std::filesystem::path(pe.pe_path))
.relative_path();
auto local_path = this->ht_local_path / remote_path;
log_debug("removing %s", local_path.c_str());
this->ht_active_files.erase(local_path);
ghc::filesystem::remove_all(local_path);
std::filesystem::remove_all(local_path);
if (conn.c_desired_paths.empty() && conn.c_child_paths.empty())
{
@ -706,8 +707,8 @@ tailer::looper::host_tailer::loop_body()
update_tailer_description(
this->ht_netloc, conn.c_desired_paths, this->ht_uname);
auto remote_path = ghc::filesystem::absolute(
ghc::filesystem::path(pob.pob_path))
auto remote_path = std::filesystem::absolute(
std::filesystem::path(pob.pob_path))
.relative_path();
auto local_path = this->ht_local_path / remote_path;
auto open_res
@ -769,7 +770,7 @@ tailer::looper::host_tailer::loop_body()
if (fstat(fd, &st) == -1 || !S_ISREG(st.st_mode)) {
log_debug("path changed, sending need block");
ghc::filesystem::remove_all(local_path);
std::filesystem::remove_all(local_path);
send_packet(conn.ht_to_child.get(),
TPT_NEED_BLOCK,
TPPT_STRING,
@ -808,7 +809,7 @@ tailer::looper::host_tailer::loop_body()
log_debug(
"unable to read file, sending need block -- %s",
strerror(errno));
ghc::filesystem::remove_all(local_path);
std::filesystem::remove_all(local_path);
break;
}
if (bytes_read == 0) {
@ -847,8 +848,8 @@ tailer::looper::host_tailer::loop_body()
return std::move(this->ht_state);
},
[&](const tailer::packet_tail_block& ptb) {
auto remote_path = ghc::filesystem::absolute(
ghc::filesystem::path(ptb.ptb_path))
auto remote_path = std::filesystem::absolute(
std::filesystem::path(ptb.ptb_path))
.relative_path();
auto local_path = this->ht_local_path / remote_path;
@ -856,7 +857,7 @@ tailer::looper::host_tailer::loop_body()
ptb.ptb_offset,
ptb.ptb_bits.size(),
local_path.c_str());
ghc::filesystem::create_directories(local_path.parent_path());
std::filesystem::create_directories(local_path.parent_path());
auto create_res = lnav::filesystem::create_file(
local_path, O_WRONLY | O_APPEND | O_CREAT, 0600);
@ -869,10 +870,10 @@ tailer::looper::host_tailer::loop_body()
ptb.ptb_bits.data(),
ptb.ptb_bits.size(),
ptb.ptb_offset);
auto mtime = ghc::filesystem::file_time_type{
auto mtime = std::filesystem::file_time_type{
std::chrono::seconds{ptb.ptb_mtime}};
// XXX This isn't atomic with the write...
ghc::filesystem::last_write_time(local_path, mtime);
std::filesystem::last_write_time(local_path, mtime);
}
return std::move(this->ht_state);
},
@ -935,11 +936,11 @@ tailer::looper::host_tailer::loop_body()
return std::move(this->ht_state);
},
[&](const tailer::packet_link& pl) {
auto remote_path = ghc::filesystem::absolute(
ghc::filesystem::path(pl.pl_path))
auto remote_path = std::filesystem::absolute(
std::filesystem::path(pl.pl_path))
.relative_path();
auto local_path = this->ht_local_path / remote_path;
auto remote_link_path = ghc::filesystem::path(pl.pl_link_value);
auto remote_link_path = std::filesystem::path(pl.pl_link_value);
std::string link_path;
if (remote_link_path.is_absolute()) {
@ -954,8 +955,8 @@ tailer::looper::host_tailer::loop_body()
log_debug("symlinking %s -> %s",
local_path.c_str(),
link_path.c_str());
ghc::filesystem::create_directories(local_path.parent_path());
ghc::filesystem::remove_all(local_path);
std::filesystem::create_directories(local_path.parent_path());
std::filesystem::remove_all(local_path);
if (symlink(link_path.c_str(), local_path.c_str()) < 0) {
log_error("symlink failed: %s", strerror(errno));
}
@ -1169,16 +1170,17 @@ void
tailer::cleanup_cache()
{
(void) std::async(std::launch::async, []() {
auto now = std::chrono::system_clock::now();
auto now = std::filesystem::file_time_type{
std::chrono::system_clock::now().time_since_epoch()};
auto cache_path = remote_cache_path();
const auto& cfg = injector::get<const config&>();
std::vector<ghc::filesystem::path> to_remove;
std::vector<std::filesystem::path> to_remove;
log_debug("cache-ttl %d", cfg.c_cache_ttl.count());
for (const auto& entry :
ghc::filesystem::directory_iterator(cache_path))
std::filesystem::directory_iterator(cache_path))
{
auto mtime = ghc::filesystem::last_write_time(entry.path());
auto mtime = std::filesystem::last_write_time(entry.path());
auto exp_time = mtime + cfg.c_cache_ttl;
if (now < exp_time) {
continue;
@ -1189,7 +1191,7 @@ tailer::cleanup_cache()
for (auto& entry : to_remove) {
log_debug("removing cached remote: %s", entry.c_str());
ghc::filesystem::remove_all(entry);
std::filesystem::remove_all(entry);
}
});
}

8
src/tailer/tailer.looper.hh
Unescape Escape View File

@ -38,7 +38,7 @@
#include "base/auto_pid.hh"
#include "base/isc.hh"
#include "base/network.tcp.hh"
#include "ghc/filesystem.hpp"
#include <filesystem>
#include "mapbox/variant.hpp"
namespace tailer {
@ -101,7 +101,7 @@ private:
mstime_t current_time) const override;
private:
static ghc::filesystem::path tmp_path();
static std::filesystem::path tmp_path();
std::string get_display_path(const std::string& remote_path) const;
@ -125,8 +125,8 @@ private:
const std::string ht_netloc;
std::string ht_uname;
const ghc::filesystem::path ht_local_path;
std::set<ghc::filesystem::path> ht_active_files;
const std::filesystem::path ht_local_path;
std::set<std::filesystem::path> ht_active_files;
std::vector<std::string> ht_error_queue;
std::thread ht_error_reader;
state_v ht_state{disconnected()};

10
src/text_anonymizer.cc
Unescape Escape View File

@ -37,7 +37,7 @@
#include "config.h"
#include "data_scanner.hh"
#include "diseases-json.h"
#include "ghc/filesystem.hpp"
#include <filesystem>
#include "hasher.hh"
#include "pcrepp/pcre2pp.hh"
#include "words-json.h"
@ -205,8 +205,8 @@ text_anonymizer::next(string_fragment line)
cu, CURLUPART_PATH, url_part.out(), CURLU_URLDECODE)
== CURLUE_OK)
{
ghc::filesystem::path url_path(url_part.in());
ghc::filesystem::path anon_path;
std::filesystem::path url_path(url_part.in());
std::filesystem::path anon_path;
for (const auto& comp : url_path) {
if (comp == comp.root_path()) {
@ -290,8 +290,8 @@ text_anonymizer::next(string_fragment line)
break;
}
case DT_PATH: {
ghc::filesystem::path inp_path(tok_res->to_string());
ghc::filesystem::path anon_path;
std::filesystem::path inp_path(tok_res->to_string());
std::filesystem::path anon_path;
for (const auto& comp : inp_path) {
auto comp_str = comp.string();

28
src/text_format.cc
Unescape Escape View File

@ -40,16 +40,16 @@
text_format_t
detect_text_format(string_fragment sf,
std::optional<ghc::filesystem::path> path)
std::optional<std::filesystem::path> path)
{
static const std::set<ghc::filesystem::path> FILTER_EXTS = {
static const std::set<std::filesystem::path> FILTER_EXTS = {
".bz2",
".gz",
".lzma",
".xz",
".zst",
};
static const auto C_EXTS = std::set<ghc::filesystem::path>{
static const auto C_EXTS = std::set<std::filesystem::path>{
".h",
".hh",
".hpp",
@ -58,17 +58,17 @@ detect_text_format(string_fragment sf,
".cpp",
".tpp",
};
static const auto PY_EXT = ghc::filesystem::path(".py");
static const auto RS_EXT = ghc::filesystem::path(".rs");
static const auto JAVA_EXT = ghc::filesystem::path(".java");
static const auto TOML_EXT = ghc::filesystem::path(".toml");
static const auto XML_EXT = ghc::filesystem::path(".xml");
static const auto YAML_EXT = ghc::filesystem::path(".yaml");
static const auto YML_EXT = ghc::filesystem::path(".yml");
static const auto MAKEFILE_STEM = ghc::filesystem::path("Makefile");
static const auto MD_EXT = ghc::filesystem::path(".md");
static const auto MARKDOWN_EXT = ghc::filesystem::path(".markdown");
static const auto SH_EXT = ghc::filesystem::path(".sh");
static const auto PY_EXT = std::filesystem::path(".py");
static const auto RS_EXT = std::filesystem::path(".rs");
static const auto JAVA_EXT = std::filesystem::path(".java");
static const auto TOML_EXT = std::filesystem::path(".toml");
static const auto XML_EXT = std::filesystem::path(".xml");
static const auto YAML_EXT = std::filesystem::path(".yaml");
static const auto YML_EXT = std::filesystem::path(".yml");
static const auto MAKEFILE_STEM = std::filesystem::path("Makefile");
static const auto MD_EXT = std::filesystem::path(".md");
static const auto MARKDOWN_EXT = std::filesystem::path(".markdown");
static const auto SH_EXT = std::filesystem::path(".sh");
static const auto DIFF_MATCHERS = lnav::pcre2pp::code::from_const(
R"(^--- .*\n\+\+\+ .*\n)", PCRE2_MULTILINE);

4
src/text_format.hh
Unescape Escape View File

@ -38,7 +38,7 @@
#include "base/intern_string.hh"
#include "fmt/format.h"
#include "ghc/filesystem.hpp"
#include <filesystem>
enum class text_format_t {
TF_UNKNOWN,
@ -131,7 +131,7 @@ struct formatter<text_format_t> : formatter<string_view> {
* @return The detected format.
*/
text_format_t detect_text_format(string_fragment sf,
std::optional<ghc::filesystem::path> path
std::optional<std::filesystem::path> path
= std::nullopt);
struct text_format_meta_t {

14
src/unique_path.hh
Unescape Escape View File

@ -37,7 +37,7 @@
#include <string>
#include <vector>
#include "ghc/filesystem.hpp"
#include <filesystem>
/**
* A source of a path for the unique_path_generator.
@ -51,26 +51,26 @@ public:
this->ups_unique_path = path;
}
const ghc::filesystem::path& get_unique_path() const
const std::filesystem::path& get_unique_path() const
{
return this->ups_unique_path;
}
virtual ghc::filesystem::path get_path() const = 0;
virtual std::filesystem::path get_path() const = 0;
const ghc::filesystem::path& get_path_prefix() const
const std::filesystem::path& get_path_prefix() const
{
return this->ups_prefix;
}
void set_path_prefix(const ghc::filesystem::path& prefix)
void set_path_prefix(const std::filesystem::path& prefix)
{
this->ups_prefix = prefix;
}
private:
ghc::filesystem::path ups_prefix;
ghc::filesystem::path ups_unique_path;
std::filesystem::path ups_prefix;
std::filesystem::path ups_unique_path;
};
/**

2
src/url_handler.cc
Unescape Escape View File

@ -180,7 +180,7 @@ looper::open(std::string url)
host_part_str = host_part;
}
auto source_path = ghc::filesystem::path{
auto source_path = std::filesystem::path{
proto_iter->second.p_handler.pp_location.sl_source.get()};
auto new_path = lnav::filesystem::build_path({
source_path.parent_path(),

6
src/url_loader.hh
Unescape Escape View File

@ -45,7 +45,7 @@ public:
url_loader(const std::string& url) : curl_request(url)
{
std::error_code errc;
ghc::filesystem::create_directories(lnav::paths::workdir(), errc);
std::filesystem::create_directories(lnav::paths::workdir(), errc);
auto tmp_res = lnav::filesystem::open_temp_file(lnav::paths::workdir()
/ "url.XXXXXX");
if (tmp_res.isErr()) {
@ -63,7 +63,7 @@ public:
curl_easy_setopt(this->cr_handle, CURLOPT_BUFFERSIZE, 128L * 1024L);
}
ghc::filesystem::path get_path() const { return this->ul_path; }
std::filesystem::path get_path() const { return this->ul_path; }
long complete(CURLcode result)
{
@ -144,7 +144,7 @@ private:
return retval;
}
ghc::filesystem::path ul_path;
std::filesystem::path ul_path;
auto_fd ul_fd;
off_t ul_resume_offset{0};
};

2
src/view_curses.cc
Unescape Escape View File

@ -792,7 +792,7 @@ view_colors::to_attrs(const lnav_theme& lt,
reporter(&sc.sc_color, lnav::console::user_message::warning(""));
#endif
} else {
auto role_class_path = ghc::filesystem::path(pp_sc.pp_path.to_string());
auto role_class_path = std::filesystem::path(pp_sc.pp_path.to_string());
auto inner = role_class_path.filename().string();
auto outer = role_class_path.parent_path().filename().string();

6
src/yajlpp/yajlpp.cc
Unescape Escape View File

@ -36,7 +36,7 @@
#include "config.h"
#include "fmt/format.h"
#include "ghc/filesystem.hpp"
#include <filesystem>
#include "yajl/api/yajl_parse.h"
#include "yajlpp_def.hh"
@ -1592,8 +1592,8 @@ dump_schema_to(const json_path_container& jpc, const char* internals_dir)
{
yajlpp_gen genner;
yajlpp_gen_context ygc(genner, jpc);
auto internals_dir_path = ghc::filesystem::path(internals_dir);
auto schema_file_name = ghc::filesystem::path(jpc.jpc_schema_id).filename();
auto internals_dir_path = std::filesystem::path(internals_dir);
auto schema_file_name = std::filesystem::path(jpc.jpc_schema_id).filename();
auto schema_path = internals_dir_path / schema_file_name;
auto file = std::unique_ptr<FILE, decltype(&fclose)>(
fopen(schema_path.c_str(), "w+"), fclose);

2
test/drive_data_scanner.cc
Unescape Escape View File

@ -74,7 +74,7 @@ main(int argc, char* argv[])
}
{
std::vector<ghc::filesystem::path> paths;
std::vector<std::filesystem::path> paths;
std::vector<lnav::console::user_message> errors;
load_formats(paths, errors);

2
test/drive_doc_discovery.cc
Unescape Escape View File

@ -42,7 +42,7 @@ main(int argc, char* argv[])
fprintf(stderr, "error: expecting file to discover\n");
retval = EXIT_FAILURE;
} else {
const auto fn = ghc::filesystem::path(argv[1]);
const auto fn = std::filesystem::path(argv[1]);
auto read_res = lnav::filesystem::read_file(fn);
if (read_res.isErr()) {
fprintf(stderr,

2
test/drive_logfile.cc
Unescape Escape View File

@ -84,7 +84,7 @@ main(int argc, char* argv[])
{
std::vector<lnav::console::user_message> errors;
vector<ghc::filesystem::path> paths;
vector<std::filesystem::path> paths;
getenv_opt("test_dir") |
[&paths](auto value) { paths.template emplace_back(value); };

6
test/lnav_doctests.cc
Unescape Escape View File

@ -210,11 +210,11 @@ TEST_CASE("ptime_roundtrip")
class my_path_source : public unique_path_source {
public:
explicit my_path_source(ghc::filesystem::path p) : mps_path(std::move(p)) {}
explicit my_path_source(std::filesystem::path p) : mps_path(std::move(p)) {}
ghc::filesystem::path get_path() const override { return this->mps_path; }
std::filesystem::path get_path() const override { return this->mps_path; }
ghc::filesystem::path mps_path;
std::filesystem::path mps_path;
};
TEST_CASE("unique_path")

10
test/scripty.cc
Unescape Escape View File

@ -71,6 +71,7 @@
#endif
#include <algorithm>
#include <filesystem>
#include <map>
#include <queue>
#include <sstream>
@ -81,7 +82,6 @@
#include "base/auto_mem.hh"
#include "base/string_util.hh"
#include "fmt/format.h"
#include "ghc/filesystem.hpp"
#include "styling.hh"
#include "termios_guard.hh"
#include "ww898/cp_utf8.hpp"
@ -268,9 +268,9 @@ static struct {
pid_t sd_child_pid{-1};
ghc::filesystem::path sd_actual_name;
std::filesystem::path sd_actual_name;
auto_mem<FILE> sd_from_child{fclose};
ghc::filesystem::path sd_expected_name;
std::filesystem::path sd_expected_name;
deque<struct command> sd_replay;
} scripty_data;
@ -1123,8 +1123,8 @@ main(int argc, char* argv[])
scripty_data.sd_expected_name.c_str());
auto options
= ghc::filesystem::copy_options::overwrite_existing;
ghc::filesystem::copy_file(scripty_data.sd_actual_name,
= std::filesystem::copy_options::overwrite_existing;
std::filesystem::copy_file(scripty_data.sd_actual_name,
scripty_data.sd_expected_name,
options);
} else {

1
test/test_cli.sh
Unescape Escape View File

@ -48,6 +48,7 @@ run_cap_test ${lnav_test} -m -I ${test_dir} config blame
export TMPDIR="piper-tmp"
rm -rf ./piper-tmp
mkdir piper-tmp
run_cap_test ${lnav_test} -n -e 'echo hi'
run_cap_test ${lnav_test} -m piper list

2
test/test_top_status.cc
Unescape Escape View File

@ -64,7 +64,7 @@ main(int argc, char* argv[])
setenv("HOME", "/", 1);
std::vector<lnav::console::user_message> errors;
std::vector<ghc::filesystem::path> paths;
std::vector<std::filesystem::path> paths;
load_config(paths, errors);

Write Preview
Loading…
Cancel
Save