if (m_lock_manager) {
m_lock_manager->deregister_alive_file(m_alive_file);
}
- util::remove(m_alive_file);
- util::remove(m_lock_file);
+ remove(m_alive_file);
+ remove(m_lock_file);
#else
CloseHandle(m_handle);
#endif
LOG("Acquired {}", m_lock_file);
#ifndef _WIN32
LOG("Creating {}", m_alive_file);
- const auto result = util::write_file(m_alive_file, "");
+ const auto result = write_file(m_alive_file, "");
if (!result) {
LOG("Failed to write {}: {}", m_alive_file, result.error());
}
ss << get_hostname() << '-' << getpid() << '-' << std::this_thread::get_id();
const auto content_prefix = ss.str();
- util::TimePoint last_seen_activity = [this] {
+ TimePoint last_seen_activity = [this] {
const auto last_lock_update = get_last_lock_update();
- return last_lock_update ? *last_lock_update : util::TimePoint::now();
+ return last_lock_update ? *last_lock_update : TimePoint::now();
}();
std::string initial_content;
k_max_sleep_time * 1000);
while (true) {
- const auto now = util::TimePoint::now();
+ const auto now = TimePoint::now();
const auto my_content =
FMT("{}-{}.{}", content_prefix, now.sec(), now.nsec_decimal_part());
last_seen_activity = *last_lock_update;
}
- const util::Duration inactive_duration =
- util::TimePoint::now() - last_seen_activity;
+ const Duration inactive_duration = TimePoint::now() - last_seen_activity;
if (inactive_duration < k_staleness_limit) {
LOG("Lock {} held by another process active {}.{:03} seconds ago",
m_lock_file,
inactive_duration.sec(),
inactive_duration.nsec_decimal_part() / 1'000'000);
- if (!util::remove(m_alive_file) || !util::remove(m_lock_file)) {
+ if (!remove(m_alive_file) || !remove(m_lock_file)) {
return false;
}
}
}
-std::optional<util::TimePoint>
+std::optional<TimePoint>
LockFile::get_last_lock_update()
{
if (const auto stat = Stat::stat(m_alive_file); stat) {
bool acquire(bool blocking);
#ifndef _WIN32
bool do_acquire(bool blocking);
- std::optional<util::TimePoint> get_last_lock_update();
+ std::optional<TimePoint> get_last_lock_update();
#else
void* do_acquire(bool blocking);
#endif
return;
}
for (const auto& alive_file : m_alive_files) {
- util::set_timestamps(alive_file);
+ set_timestamps(alive_file);
}
awake_time += k_keep_alive_interval;
}
-// Copyright (C) 2022 Joel Rosdahl and other contributors
+// Copyright (C) 2022-2023 Joel Rosdahl and other contributors
//
// See doc/AUTHORS.adoc for a complete list of contributors.
//
bool operator<=(const TimePoint& other) const;
bool operator>=(const TimePoint& other) const;
- TimePoint operator+(const util::Duration& duration) const;
- TimePoint operator-(const util::Duration& duration) const;
+ TimePoint operator+(const Duration& duration) const;
+ TimePoint operator-(const Duration& duration) const;
- util::Duration operator-(const TimePoint& other) const;
+ Duration operator-(const TimePoint& other) const;
private:
int64_t m_ns = 0;
}
inline TimePoint
-TimePoint::operator+(const util::Duration& duration) const
+TimePoint::operator+(const Duration& duration) const
{
return TimePoint(0, nsec() + duration.nsec());
}
inline TimePoint
-TimePoint::operator-(const util::Duration& duration) const
+TimePoint::operator-(const Duration& duration) const
{
return TimePoint(0, nsec() - duration.nsec());
}
-inline util::Duration
+inline Duration
TimePoint::operator-(const TimePoint& other) const
{
- return util::Duration(0, nsec() - other.nsec());
+ return Duration(0, nsec() - other.nsec());
}
} // namespace util
{
#ifndef _WIN32
if (new_umask) {
- m_saved_umask = util::set_umask(*new_umask);
+ m_saved_umask = set_umask(*new_umask);
}
#else
(void)new_umask;
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
# endif
- util::set_umask(*m_saved_umask);
+ set_umask(*m_saved_umask);
# if defined(__GNUC__) && !defined(__clang__)
# pragma GCC diagnostic pop
# endif
void reset();
void update(nonstd::span<const uint8_t> data);
- util::Bytes digest() const;
+ Bytes digest() const;
private:
XXH3_state_t* m_state;
XXH3_128bits_update(m_state, data.data(), data.size());
}
-inline util::Bytes
+inline Bytes
XXH3_128::digest() const
{
const auto result = XXH3_128bits_digest(m_state);
- util::Bytes digest(k_digest_size);
- util::int_to_big_endian(result.high64, &digest[0]);
- util::int_to_big_endian(result.low64, &digest[8]);
+ Bytes digest(k_digest_size);
+ int_to_big_endian(result.high64, &digest[0]);
+ int_to_big_endian(result.low64, &digest[8]);
return digest;
}
template<>
inline std::string
-to_string(const util::Bytes& bytes)
+to_string(const Bytes& bytes)
{
return std::string(to_string_view(bytes));
}
FMT("Failed to open {} for writing: {}", dest, strerror(errno)));
}
}
- TRY(util::read_fd(*src_fd, [&](nonstd::span<const uint8_t> data) {
- util::write_fd(*dest_fd, data.data(), data.size());
+ TRY(read_fd(*src_fd, [&](nonstd::span<const uint8_t> data) {
+ write_fd(*dest_fd, data.data(), data.size());
}));
dest_fd.close();
if (stat) {
return;
}
- const auto result = util::write_file(path, cachedir_tag);
+ const auto result = write_file(path, cachedir_tag);
if (!result) {
LOG("Failed to create {}: {}", path, result.error());
}
void
set_timestamps(const std::string& path,
- std::optional<util::TimePoint> mtime,
- std::optional<util::TimePoint> atime)
+ std::optional<TimePoint> mtime,
+ std::optional<TimePoint> atime)
{
#ifdef HAVE_UTIMENSAT
timespec atime_mtime[2];
// Set atime/mtime of `path`. If `mtime` is std::nullopt, set to the current
// time. If `atime` is std::nullopt, set to what `mtime` specifies.
void set_timestamps(const std::string& path,
- std::optional<util::TimePoint> mtime = std::nullopt,
- std::optional<util::TimePoint> atime = std::nullopt);
+ std::optional<TimePoint> mtime = std::nullopt,
+ std::optional<TimePoint> atime = std::nullopt);
// Write `size` bytes from binary `data` to `fd`.
tl::expected<void, std::string> write_fd(int fd, const void* data, size_t size);
return actual_cwd;
#else
auto pwd = getenv("PWD");
- if (!pwd || !util::is_absolute_path(pwd)) {
+ if (!pwd || !is_absolute_path(pwd)) {
return actual_cwd;
}
std::vector<std::string>
split_path_list(std::string_view path_list)
{
- return util::split_into_strings(path_list, k_path_delimiter);
+ return split_into_strings(path_list, k_path_delimiter);
}
std::string
to_absolute_path(std::string_view path)
{
- if (util::is_absolute_path(path)) {
+ if (is_absolute_path(path)) {
return std::string(path);
} else {
return Util::normalize_abstract_absolute_path(
{
const size_t base16_bytes = 2;
ASSERT(data.size() >= base16_bytes);
- return util::format_base16({data.data(), base16_bytes})
- + util::format_base32hex(
+ return format_base16({data.data(), base16_bytes})
+ + format_base32hex(
{data.data() + base16_bytes, data.size() - base16_bytes});
}
"invalid suffix (supported: d (day) and s (second)): \"{}\"", duration));
}
- auto value = util::parse_unsigned(duration.substr(0, duration.length() - 1));
+ auto value = parse_unsigned(duration.substr(0, duration.length() - 1));
if (!value) {
return value;
};
tl::expected<mode_t, std::string>
parse_umask(std::string_view value)
{
- return util::parse_unsigned(value, 0, 0777, "umask", 8);
+ return parse_unsigned(value, 0, 0777, "umask", 8);
}
tl::expected<uint64_t, std::string>
std::vector<std::string>
split_into_strings(std::string_view string,
const char* separators,
- util::Tokenizer::Mode mode,
- util::Tokenizer::IncludeDelimiter include_delimiter)
+ Tokenizer::Mode mode,
+ Tokenizer::IncludeDelimiter include_delimiter)
{
return split_into<std::string>(string, separators, mode, include_delimiter);
}
std::vector<std::string_view>
split_into_views(std::string_view string,
const char* separators,
- util::Tokenizer::Mode mode,
- util::Tokenizer::IncludeDelimiter include_delimiter)
+ Tokenizer::Mode mode,
+ Tokenizer::IncludeDelimiter include_delimiter)
{
return split_into<std::string_view>(
string, separators, mode, include_delimiter);
// Split `string` into tokens at any of the characters in `separators`.
// `separators` must neither be the empty string nor a nullptr.
-std::vector<std::string> split_into_strings(
- std::string_view string,
- const char* separators,
- util::Tokenizer::Mode mode = util::Tokenizer::Mode::skip_empty,
- util::Tokenizer::IncludeDelimiter include_delimiter =
- util::Tokenizer::IncludeDelimiter::no);
+std::vector<std::string>
+split_into_strings(std::string_view string,
+ const char* separators,
+ Tokenizer::Mode mode = Tokenizer::Mode::skip_empty,
+ Tokenizer::IncludeDelimiter include_delimiter =
+ Tokenizer::IncludeDelimiter::no);
// Split `string` into tokens at any of the characters in `separators`. These
// tokens are views into `string`. `separators` must neither be the empty string
std::vector<std::string_view>
split_into_views(std::string_view string,
const char* separators,
- util::Tokenizer::Mode mode = util::Tokenizer::Mode::skip_empty,
- util::Tokenizer::IncludeDelimiter include_delimiter =
- util::Tokenizer::IncludeDelimiter::no);
+ Tokenizer::Mode mode = Tokenizer::Mode::skip_empty,
+ Tokenizer::IncludeDelimiter include_delimiter =
+ Tokenizer::IncludeDelimiter::no);
// Split `string` into two parts using `split_char` as the delimiter. The second
// part will be `nullopt` if there is no `split_char` in `string.`
namespace util {
std::optional<tm>
-localtime(std::optional<util::TimePoint> time)
+localtime(std::optional<TimePoint> time)
{
- time_t timestamp = time ? time->sec() : util::TimePoint::now().sec();
+ time_t timestamp = time ? time->sec() : TimePoint::now().sec();
#ifdef HAVE_LOCALTIME_R
struct tm result;
if (localtime_r(×tamp, &result)) {
// Thread-safe version of `localtime(3)`. If `time` is not specified the current
// time of day is used.
-std::optional<tm> localtime(std::optional<util::TimePoint> time = {});
+std::optional<tm> localtime(std::optional<TimePoint> time = {});
} // namespace util
-// Copyright (C) 2022 Joel Rosdahl and other contributors
+// Copyright (C) 2022-2023 Joel Rosdahl and other contributors
//
// See doc/AUTHORS.adoc for a complete list of contributors.
//
tl::expected<void, std::string>
zstd_compress(nonstd::span<const uint8_t> input,
- util::Bytes& output,
+ Bytes& output,
int8_t compression_level)
{
const size_t original_output_size = output.size();
tl::expected<void, std::string>
zstd_decompress(nonstd::span<const uint8_t> input,
- util::Bytes& output,
+ Bytes& output,
size_t original_size)
{
const size_t original_output_size = output.size();