file.cpp File Reference

#include "file.hpp"
#include "analyze.hpp"
#include "lolly/hash/uuid.hpp"
#include "string.hpp"
#include "sys_utils.hpp"
#include "tbox/tbox.h"

Include dependency graph for file.cpp:

Go to the source code of this file.

Classes
struct	file_status

Functions
bool	is_local_and_single (url u)
static string	as_local_path (url u)
bool	is_directory (url u)
bool	is_regular (url u)
bool	is_symbolic_link (url u)
bool	is_newer (url which, url than)
bool	is_of_type (url name, string filter)
int	file_size (url u)
int	last_modified (url u)
static tb_long_t	tb_directory_walk_func (tb_char_t const *path, tb_file_info_t const *info, tb_cpointer_t priv)
array< string >	read_directory (url u, bool &error_flag)
url	subdirectories (url u)
void	mkdir (url u)
void	make_dir (url which)
void	rmdir (url u)
void	chdir (url u)
url	url_temp (string suffix)
url	url_temp_dir_sub ()
url	url_temp_dir ()
void	move (url u1, url u2)
void	copy (url u1, url u2)
void	remove (url u)
static url	find_the_first_exist (const url &u)
	lookup the first exist path in a bunch of url, if all url does not exist, then the last one will be used.
static bool	cleanup_and_return_finally (const file_status &status, const url &u, bool fatal, const string &reason)
file_status	load_string_try (url u, string &s)
bool	load_string (url u, string &s, bool fatal)
string	string_load (url u)
file_status	save_string_try (url u, const string &s)
bool	save_string (url u, const string &s, bool fatal)
void	string_save (const string &s, url u)
file_status	append_string_try (url u, const string &s)
bool	append_string (url u, const string &s, bool fatal)
void	string_append_to_file (const string &s, url u)
void	append_to (url what, url to)

Detailed Description

Copyright

GPLv3

Unitests for file.

Author

Darcy

Date

2019-2023

Definition in file file.cpp.

Function Documentation

is_local_and_single()

bool is_local_and_single

(

url

u

)

Definition at line 22 of file file.cpp.

                            {
  string label   = u.label ();
  string protocol= u.protocol ();
  return ((label == "") || (label == "concat") || (label == "root")) &&
         (protocol == "default" || protocol == "file");
}

as_local_path()

static string as_local_path ( url u )

static

Definition at line 30 of file file.cpp.

                      {
  if (is_rooted (u, "file")) {
    return as_string (reroot (u, "default"));
  }
  return as_string (u);
}

is_directory()

bool is_directory

(

url

u

)

Definition at line 38 of file file.cpp.

                     {
  if (!is_local_and_single (u)) return false;
 
  c_string       path (as_local_path (u));
  tb_file_info_t info;
  if (tb_file_info (path, &info)) {
    switch (info.type) {
    case TB_FILE_TYPE_DIRECTORY:
      return true;
    default:
      return false;
    }
  }
  else {
    return false;
  }
}

is_regular()

bool is_regular

(

url

u

)

Definition at line 57 of file file.cpp.

                   {
  if (!is_local_and_single (u)) return false;
 
  c_string       path (as_local_path (u));
  tb_file_info_t info;
  if (tb_file_info (path, &info)) {
    switch (info.type) {
    case TB_FILE_TYPE_FILE:
      return true;
    default:
      return false;
    }
  }
  else {
    return false;
  }
}

is_symbolic_link()

bool is_symbolic_link

(

url

u

)

Definition at line 76 of file file.cpp.

                         {
  if (!is_local_and_single (u)) return false;
 
  c_string       path (as_local_path (u));
  tb_file_info_t info;
  if (tb_file_info (path, &info)) {
    return (info.flags & TB_FILE_FLAG_LINK) != 0;
  }
  else {
    return false;
  }
}

is_newer()

bool is_newer	(	url	which,
		url	than )

Definition at line 90 of file file.cpp.

                               {
  if (!is_local_and_single (which)) return false;
  if (!is_local_and_single (than)) return false;
 
  tb_file_info_t info1, info2;
  if (tb_file_info (c_string (as_local_path (which)), &info1) &
      tb_file_info (c_string (as_local_path (than)), &info2)) {
    return info1.mtime > info2.mtime;
  }
  else {
    return false;
  }
}

is_of_type()

bool is_of_type	(	url	name,
		string	filter )

Definition at line 105 of file file.cpp.

                                     {
  if (is_ramdisc (name)) return true;
 
  if (!is_local_and_single (name)) return false;
 
  if (filter == "") return true;
  int i, n= N (filter);
 
  // Normal files
  if (os_win () || os_mingw ()) {
    string suf;
    if (filter == "x") {
      suf= suffix (name);
      if ((suf != "exe") && (suf != "bat") && (suf != "com")) {
        name= glue (name, ".exe");
        suf = "exe";
      }
    }
  }
  c_string       path (as_local_path (name));
  tb_file_info_t info;
  if (!tb_file_info (path, &info)) {
    return false;
  }
  for (i= 0; i < n; i++)
    switch (filter[i]) {
      // FIXME: should check user id and group id for r, w and x
    case 'f':
      if (info.type != TB_FILE_TYPE_FILE) return false;
      break;
    case 'd':
      if (info.type != TB_FILE_TYPE_DIRECTORY) return false;
      break;
    case 'l':
      if (info.flags != TB_FILE_FLAG_LINK) return false;
      break;
    case 'r':
      if (!tb_file_access (path, TB_FILE_MODE_RO)) return false;
      break;
    case 'w':
      if (!tb_file_access (path, TB_FILE_MODE_WO)) return false;
      break;
    case 'x':
      if (!tb_file_access (path, TB_FILE_MODE_EXEC)) return false;
      break;
    }
  return true;
}

file_size()

int file_size

(

url

u

)

Definition at line 155 of file file.cpp.

                  {
  if (!is_local_and_single (u)) return -1;
 
  c_string       path (as_local_path (u));
  tb_file_info_t info;
  if (tb_file_info (path, &info)) {
    return info.size;
  }
  else {
    return -1;
  }
}

last_modified()

int last_modified

(

url

u

)

Definition at line 169 of file file.cpp.

                      {
  if (!is_local_and_single (u)) return -1;
 
  c_string       path (as_local_path (u));
  tb_file_info_t info;
  if (tb_file_info (path, &info)) {
    return info.mtime;
  }
  else {
    return -1;
  }
}

tb_directory_walk_func()

static tb_long_t tb_directory_walk_func ( tb_char_t const * path, tb_file_info_t const * info, tb_cpointer_t priv )

static

Definition at line 183 of file file.cpp.

                                            {
  // check
  tb_assert_and_check_return_val (path && info, TB_DIRECTORY_WALK_CODE_END);
 
  array<string>* p_arr_result= (array<string>*) priv;
  (*p_arr_result) << as_string (tail (url_system (string (path))));
  return TB_DIRECTORY_WALK_CODE_CONTINUE;
}

read_directory()

array< string > read_directory	(	url	u,
		bool &	error_flag )

Definition at line 194 of file file.cpp.

                                         {
  if (!is_local_and_single (u)) {
    error_flag= false;
    return array<string> ();
  }
 
  c_string      path (as_local_path (u));
  array<string> arr_result= array<string> ();
  error_flag              = !is_directory (u);
  if (error_flag) {
    return arr_result;
  }
  tb_directory_walk (path, 0, tb_false, tb_directory_walk_func, &arr_result);
  return arr_result;
}

subdirectories()

url subdirectories

(

url

u

)

Definition at line 211 of file file.cpp.

                       {
  if (is_or (u)) return subdirectories (u[1]) | subdirectories (u[2]);
  else if (is_directory (u)) {
    url           ret= u;
    bool          error_flag;
    array<string> dir= read_directory (u, error_flag);
    for (int i= 0; i < N (dir); i++)
      if (!starts (dir[i], ".") && is_directory (u * dir[i]))
        ret= ret | subdirectories (u * dir[i]);
    return ret;
  }
  else return url_none ();
}

mkdir()

void mkdir

(

url

u

)

Definition at line 226 of file file.cpp.

              {
  string label= u.label ();
  if (label == "none" || label == "root" || label == "wildcard") return;
  if (is_local_and_single (u)) { // label == "" or label == "concat"
    c_string path (as_local_path (u));
    tb_directory_create (path);
  }
  if (is_or (u)) { // label == "or"
    mkdir (u[1]);
    mkdir (u[2]);
  }
}

make_dir()

void make_dir

(

url

which

)

Definition at line 240 of file file.cpp.

                     {
  if (is_none (which)) return;
  if (!is_directory (which)) {
    make_dir (head (which));
    mkdir (which);
  }
}

rmdir()

void rmdir

(

url

u

)

Definition at line 249 of file file.cpp.

              {
  string label= u.label ();
  if (label == "none" || label == "root" || label == "wildcard") return;
  if (is_local_and_single (u)) { // label == "" or label == "concat"
    c_string path (as_local_path (u));
    tb_directory_remove (path);
  }
  if (is_or (u)) { // label == "or"
    rmdir (u[1]);
    rmdir (u[2]);
  }
}

chdir()

void chdir

(

url

u

)

Definition at line 263 of file file.cpp.

              {
  if (is_local_and_single (u)) {
    c_string path (as_local_path (u));
    if (tb_directory_current_set (path) != tb_true) {
      TM_FAILED ("Failed to change the dir");
    }
  }
  else TM_FAILED ("file path invalid");
}

url_temp()

url url_temp

(

string

suffix

)

Definition at line 274 of file file.cpp.

                         {
  string file_name= replace (lolly::hash::uuid_make (), "-", "_");
  if (!is_empty (suffix)) {
    file_name= file_name * string (".") * suffix;
  }
  url u= url_temp_dir () * url (file_name);
  if (file_size (u) == -1) {
    return u;
  }
  else {
    return url_temp (suffix);
  }
}

url_temp_dir_sub()

url url_temp_dir_sub

(

)

Definition at line 289 of file file.cpp.

                    {
#if defined(OS_WIN) || defined(OS_MINGW)
  url main_tmp_dir= url_system ("$TMP") * url (".lolly");
#else
  url main_tmp_dir= url_system ("/tmp") * url (".lolly");
#endif
  static url tmp_dir= main_tmp_dir * url (as_string (get_process_id ()));
  return (tmp_dir);
}

url_temp_dir()

url url_temp_dir

(

)

Definition at line 300 of file file.cpp.

                {
  static url u;
  if (u == url_none ()) {
    u= url_temp_dir_sub ();
    make_dir (u);
  }
  return u;
}

move()

void move	(	url	u1,
		url	u2 )

Definition at line 310 of file file.cpp.

                      {
  c_string p1 (as_local_path (u1));
  c_string p2 (as_local_path (u2));
 
  tb_file_rename (p1, p2);
}

copy()

void copy	(	url	u1,
		url	u2 )

Definition at line 318 of file file.cpp.

                      {
  c_string p1 (as_local_path (u1));
  c_string p2 (as_local_path (u2));
 
  tb_file_copy (p1, p2, TB_FILE_COPY_LINK);
}

remove()

void remove

(

url

u

)

Definition at line 326 of file file.cpp.

               {
  string label= u.label ();
  if (label == "none" || label == "root" || label == "wildcard") return;
  if (is_local_and_single (u)) {
    c_string path (as_local_path (u));
    tb_file_remove (path);
  }
  else if (is_or (u)) { // label == "or"
    remove (u[1]);
    remove (u[2]);
  }
}

find_the_first_exist()

static url find_the_first_exist ( const url & u )

static

lookup the first exist path in a bunch of url, if all url does not exist, then the last one will be used.

Definition at line 359 of file file.cpp.

                                    {
  url u_iter= expand (u);
  // iterate to find the first existed file
  while (is_or (u_iter)) {
    if (is_regular (u_iter[1])) {
      return u_iter[1];
    }
    u_iter= u_iter[2];
  }
  // if u_target does not exist, just return the last url
  return u_iter;
}

cleanup_and_return_finally()

static bool cleanup_and_return_finally ( const file_status & status, const url & u, bool fatal, const string & reason )

static

Definition at line 373 of file file.cpp.

                                                  {
 
  if (status.buffer != NULL) {
    tm_delete_array (status.buffer);
  }
  if (status.path != NULL) {
    tm_delete_array (status.path);
  }
 
  if (!status.failed) {
    return false;
  }
  cerr << "Failed to " << reason << " in [" << as_local_path (u) << "]" << LF;
  if (fatal) {
    TM_FAILED (status.error_msg);
  }
  return true;
}

load_string_try()

file_status load_string_try	(	url	u,
		string &	s )

Definition at line 394 of file file.cpp.

                                   {
  if (!is_local_and_single (u)) {
    return file_status (true, "Must be a local and single file");
  }
  url         u_target= find_the_first_exist (u);
  const char* path    = as_charp (as_local_path (u_target));
  if (!tb_file_access (path, TB_FILE_MODE_RO)) {
    return file_status (true, "File is not readable", path);
  }
  tb_file_ref_t file= tb_file_init (path, TB_FILE_MODE_RO);
  if (file == tb_null) {
    return file_status (true, "Failed to init the file", path);
  }
  tb_file_sync (file); // lock file
  tb_size_t size= tb_file_size (file);
  if (size == 0) {
    s= "";
    tb_file_exit (file);
    return file_status (false, "", path);
  }
  tb_byte_t* buffer     = tm_new_array<tb_byte_t> (size);
  tb_size_t  real_size  = tb_file_read (file, buffer, size);
  bool       read_sz_equ= (real_size == size);
  bool       exit_suc   = tb_file_exit (file); // exit file
  if (read_sz_equ && exit_suc) {
    s->resize (size);
    // Copying char by char has roughly the same efficiency as constructing new
    // string with buffer.
    for (size_t seek= 0; seek < size; seek++) {
      s[seek]= buffer[seek];
    }
    return file_status (false, "", path, buffer);
  }
  else {
    return file_status (true, "Unexpected behavior during reading", path,
                        buffer);
  }
}

load_string()

bool load_string	(	url	u,
		string &	s,
		bool	fatal )

Definition at line 434 of file file.cpp.

                                           {
  file_status stat= load_string_try (u, s);
  return cleanup_and_return_finally (stat, u, fatal, "load url");
}

string_load()

string string_load

(

url

u

)

Definition at line 440 of file file.cpp.

                    {
  string s;
  // file_url f= u;
  (void) load_string (u, s, false);
  return s;
}

save_string_try()

file_status save_string_try	(	url	u,
		const string &	s )

Definition at line 448 of file file.cpp.

                                         {
  ASSERT (sizeof (tb_byte_t) == sizeof (char),
          "invalid cast from tb_byte_t* to char*");
  if (!is_local_and_single (u)) {
    return file_status (true, "Must be an absolute path");
  }
  url         u_target= find_the_first_exist (u);
  const char* path    = as_charp (as_local_path (u_target));
 
  // tb_file_access cannot check TB_FILE_MODE_CREAT on windows, so create
  // directly
  tb_file_ref_t fout= tb_file_init (path, TB_FILE_MODE_WO | TB_FILE_MODE_CREAT |
                                              TB_FILE_MODE_TRUNC);
  if (fout == tb_null) {
    return file_status (true, "File not writeable", path);
  }
 
  // lock file
  tb_filelock_ref_t lock= tb_filelock_init (fout);
  if (tb_filelock_enter (lock, TB_FILELOCK_MODE_EX) == tb_false) {
    tb_filelock_exit (lock);
    tb_file_exit (fout);
    return file_status (true, "Fail to lock file", path);
  }
 
  tb_size_t        input_size= N (s);
  const tb_byte_t* content  = reinterpret_cast<const tb_byte_t*> (as_charp (s));
  tb_size_t        real_size= tb_file_writ (fout, content, input_size);
  bool             writ_sz_equ= (real_size == input_size);
  bool             release_suc= tb_filelock_leave (lock);
  tb_filelock_exit (lock);
  bool exit_suc= tb_file_exit (fout);
  if (writ_sz_equ && exit_suc && release_suc) {
    return file_status (false, "", path, content);
  }
  else {
    return file_status (true, "Unexpected behavior during writting", path,
                        content);
  }
}

save_string()

bool save_string	(	url	u,
		const string &	s,
		bool	fatal )

Definition at line 490 of file file.cpp.

                                                 {
  file_status stat= save_string_try (u, s);
  return cleanup_and_return_finally (stat, u, fatal, "save to url");
}

string_save()

void string_save	(	const string &	s,
		url	u )

Definition at line 496 of file file.cpp.

                                     {
  (void) save_string (u, s, false);
}

append_string_try()

file_status append_string_try	(	url	u,
		const string &	s )

Definition at line 501 of file file.cpp.

                                           {
  if (!is_local_and_single (u)) {
    return file_status (true, "Must be a local and single file");
  }
  url         u_target= find_the_first_exist (u);
  const char* path    = as_charp (as_local_path (u_target));
 
  // open the file
  tb_file_ref_t fout= tb_file_init (
      path, TB_FILE_MODE_WO | TB_FILE_MODE_APPEND | TB_FILE_MODE_CREAT);
  if (fout == NULL) {
    return file_status (true, "File to append is not found or not appendable",
                        path);
  }
 
  // lock file
  tb_filelock_ref_t lock= tb_filelock_init (fout);
  if (tb_filelock_enter (lock, TB_FILELOCK_MODE_EX) == tb_false) {
    tb_filelock_exit (lock);
    tb_file_exit (fout);
    return file_status (true, "Fail to lock file", path);
  }
 
  // append string to file
  tb_size_t        input_size= N (s);
  const tb_byte_t* content  = reinterpret_cast<const tb_byte_t*> (as_charp (s));
  tb_size_t        real_size= tb_file_writ (fout, content, input_size);
  bool             writ_sz_equ= (real_size == input_size);
  bool             release_suc= tb_filelock_leave (lock);
  tb_filelock_exit (lock);
  bool exit_suc= tb_file_exit (fout);
 
  if (writ_sz_equ && exit_suc && release_suc) {
    return file_status (false, "", path, content);
  }
  else {
    return file_status (true, "Unexpected behavior during appending", path,
                        content);
  }
}

append_string()

bool append_string	(	url	u,
		const string &	s,
		bool	fatal )

Definition at line 543 of file file.cpp.

                                                   {
  file_status stat= append_string_try (u, s);
  return cleanup_and_return_finally (stat, u, fatal, "append to url");
}

string_append_to_file()

void string_append_to_file	(	const string &	s,
		url	u )

Definition at line 549 of file file.cpp.

                                               {
  (void) append_string (u, s, false);
}

append_to()

void append_to	(	url	what,
		url	to )

Definition at line 554 of file file.cpp.

                             {
  string what_s;
  if (load_string (what, what_s, false) || append_string (to, what_s, false))
    cerr << "Append failed for " << to << LF;
}