file_utils.hpp

//--------------------------------------------------------------------------------------------------
// Copyright (c) 2018 Marcus Geelnard
//
// This software is provided 'as-is', without any express or implied warranty. In no event will the
// authors be held liable for any damages arising from the use of this software.
//
// Permission is granted to anyone to use this software for any purpose, including commercial
// applications, and to alter it and redistribute it freely, subject to the following restrictions:
//
//  1. The origin of this software must not be misrepresented; you must not claim that you wrote
//     the original software. If you use this software in a product, an acknowledgment in the
//     product documentation would be appreciated but is not required.
//
//  2. Altered source versions must be plainly marked as such, and must not be misrepresented as
//     being the original software.
//
//  3. This notice may not be removed or altered from any source distribution.
//--------------------------------------------------------------------------------------------------
 
#ifndef BUILDCACHE_FILE_UTILS_HPP_
#define BUILDCACHE_FILE_UTILS_HPP_
 
#include <cstdint>
#include <string>
#include <vector>
 
#include <base/time_utils.hpp>
 
namespace bcache {
namespace file {
class tmp_file_t {
public:
  tmp_file_t(const std::string& dir, const std::string& extension);
 
  ~tmp_file_t();
 
  const std::string& path() const {
    return m_path;
  }
 
private:
  std::string m_path;
};
 
class scoped_work_dir_t {
public:
  scoped_work_dir_t(const std::string& new_work_dir);
  ~scoped_work_dir_t();
 
private:
  std::string m_old_work_dir;
};
 
class file_info_t {
public:
  file_info_t(const std::string& path,
              const time::seconds_t modify_time,
              const time::seconds_t access_time,
              const int64_t size,
              const bool is_dir)
      : m_path(path),
        m_modify_time(modify_time),
        m_access_time(access_time),
        m_size(size),
        m_is_dir(is_dir) {
  }
 
  const std::string& path() const {
    return m_path;
  }
 
  time::seconds_t modify_time() const {
    return m_modify_time;
  }
 
  time::seconds_t access_time() const {
    return m_access_time;
  }
 
  int64_t size() const {
    return m_size;
  }
 
  bool is_dir() const {
    return m_is_dir;
  }
 
private:
  std::string m_path;
  time::seconds_t m_modify_time;
  time::seconds_t m_access_time;
  int64_t m_size;
  bool m_is_dir;
};
 
class exe_path_t {
public:
  exe_path_t(const std::string real_path,
             const std::string virtual_path,
             const std::string invoked_as)
      : m_real_path(real_path), m_virtual_path(virtual_path), m_invoked_as(invoked_as) {
  }
 
  const std::string& real_path() const {
    return m_real_path;
  }
 
  const std::string& virtual_path() const {
    return m_virtual_path;
  }
 
  const std::string& invoked_as() const {
    return m_invoked_as;
  }
 
private:
  std::string m_real_path;
  std::string m_virtual_path;
  std::string m_invoked_as;
};
 
std::string append_path(const std::string& path, const std::string& append);
std::string append_path(const std::string& path, const char* append);
 
std::string canonicalize_path(const std::string& path);
 
std::string get_extension(const std::string& path);
 
std::string change_extension(const std::string& path, const std::string& new_ext);
 
std::string get_file_part(const std::string& path, const bool include_ext = true);
 
std::string get_dir_part(const std::string& path);
 
std::string get_temp_dir();
 
std::string get_user_home_dir();
 
std::string get_cwd();
 
void set_cwd(const std::string& path);
 
std::string resolve_path(const std::string& path);
 
exe_path_t find_executable(const std::string& program, const std::string& exclude = std::string());
 
file_info_t get_file_info(const std::string& path);
 
std::string human_readable_size(const int64_t byte_size);
 
std::vector<file_info_t> walk_directory(const std::string& path);
 
void create_dir(const std::string& path);
 
void create_dir_with_parents(const std::string& path);
 
void remove_file(const std::string& path, const bool ignore_errors = false);
 
void remove_dir(const std::string& path, const bool ignore_errors = false);
 
bool dir_exists(const std::string& path);
 
bool file_exists(const std::string& path);
 
void move(const std::string& from_path, const std::string& to_path);
 
void copy(const std::string& from_path, const std::string& to_path);
 
void link_or_copy(const std::string& from_path, const std::string& to_path);
 
void touch(const std::string& path);
 
std::string read(const std::string& path);
 
void write(const std::string& data, const std::string& path);
 
void write_atomic(const std::string& data, const std::string& path);
 
void append(const std::string& data, const std::string& path);
 
std::string get_unique_id();
 
}  // namespace file
}  // namespace bcache
 
#endif  // BUILDCACHE_FILE_UTILS_HPP_