src/FileUtil.cc

   1 /*
   2  * FileUtil.cc
   3  *
   4  *  Created on: Mar 5, 2011
   5  *      Author: lamikr
   6  */
   7
   8 #include <algorithm>
   9 #include <string>
  10 #include <iostream>
  11 #include <fstream>
  12 #include <sstream>
  13
  14 #include <errno.h>
  15 #include <string.h>
  16 #include <sys/stat.h>
  17 #include <stdbool.h>
  18
  19 #include "log.h"
  20 #include "FileUtil.hh"
  21 #include "DeviceConfig.hh"
  22
  23 using namespace std;
  24 using namespace plp;
  25
  26 template <class NumberDataType>
  27 bool string_to_number(NumberDataType& result,
  28                  const std::string& string_param,
  29                  std::ios_base& (*format)(std::ios_base&))
  30 {
  31         std::istringstream iss(string_param);
  32         return !(iss >> format >> result).fail();
  33 }
  34
  35 FileUtil::FileUtil() {
  36 }
  37
  38 FileUtil::~FileUtil() {
  39 }
  40
  41 char *FileUtil::parse_directory_path(const char *file_path) {
  42         char    *p;
  43         size_t  b_count;
  44         size_t  f_size;
  45         char    *ret_val;
  46
  47         ret_val = NULL;
  48         if (file_path != NULL) {
  49                 f_size  = 0;
  50                 b_count = strlen(file_path);
  51                 for (p = &((char *)file_path)[b_count]; p != (char *)file_path; p--) {
  52                         f_size++;
  53                         if ((*p == '/') ||
  54                             (*p == '\\')) {
  55                                 b_count = (b_count - f_size) + 1;
  56                                 ret_val = strndup(file_path, b_count);
  57                                 log_debug("dir: %s\n", ret_val);
  58                                 break;
  59                         }
  60                 }
  61         }
  62         return ret_val;
  63 }
  64
  65 bool FileUtil::mkdirs(const char *path) {
  66         bool    ret_val;
  67         char    *p;
  68         int     err_flg;
  69
  70         ret_val = true;
  71         if (path != NULL) {
  72                 // go through each directory one by and and create if not exist
  73                 for (p = (char *)path; *p; p++) {
  74                     if ((p != path) &&
  75                         ((*p == '/') ||
  76                          (*p == '\\'))) {
  77                                 *p = '\0';
  78                                 // if dir does not exist, create it
  79                                 if (access(path, F_OK) != 0) {
  80                                         //log_debug("trying to create directory: %s\n", path);
  81                                         err_flg = mkdir(path, S_IRWXU);
  82                                         if (err_flg != 0) {
  83                                                 log_error("Could not create directory: %s\n", path);
  84                                                 ret_val = false;
  85                                                 break;
  86                                         }
  87                                 }
  88                                 *p = '/';
  89                         }
  90                 }
  91                 if (ret_val == true) {
  92                         // if dir does not exist, create it
  93                         if (access(path, F_OK) != 0) {
  94                                 //log_debug("trying to create directory: %s\n", path);
  95                                 err_flg = mkdir(path, S_IRWXU);
  96                                 if (err_flg != 0) {
  97                                         log_error("Could not create directory: %s\n", path);
  98                                         ret_val = false;
  99                                 }
 100                         }
 101                 }
 102         }
 103         else {
 104                 ret_val = false;
 105                 log_error("Could not create NULL directory\n");
 106         }
 107         return ret_val;
 108 }
 109
 110 std::ofstream *FileUtil::open_for_writing(const char *f_path) {
 111         char            *d_path;
 112         size_t          b_count;
 113         ofstream        *ret_val;
 114         bool            b_flg;
 115
 116         ret_val = NULL;
 117         b_flg   = true;
 118         if (f_path != NULL) {
 119                 b_count = strlen(f_path);
 120                 if ((f_path[b_count - 1] != '/') &&
 121                     (f_path[b_count - 1] != '\\')) {
 122                         ret_val = new ofstream();
 123                         ret_val->open(f_path, ios::app);
 124                         if (ret_val->is_open() == false) {
 125                                 d_path  = parse_directory_path(f_path);
 126                                 if (d_path != NULL) {
 127                                         b_flg   = mkdirs(d_path);
 128                                         free(d_path);
 129                                 }
 130                                 if (b_flg == true) {
 131                                         ret_val->open(f_path, ios::app);
 132                                 }
 133                         }
 134                 }
 135                 else {
 136                         log_error("Could not open file, invalid file name. (%s)\n", f_path);
 137                 }
 138         }
 139         else {
 140                 log_error("Could not open file, invalid file name. (= NULL)\n");
 141         }
 142         return ret_val;
 143 }
 144
 145 string FileUtil::concat_paths(string path_start, string path_end) {
 146         return concat_paths(path_start.c_str(), path_end.c_str());
 147 }
 148
 149 string FileUtil::concat_paths(const char *path_start, const char *path_end) {
 150         string  ret_val;
 151         string  end_str;
 152         int     pos;
 153         int     b_count;
 154
 155         if (path_start != NULL) {
 156                 ret_val = path_start;
 157                 if (path_end != NULL) {
 158                         end_str = path_end;
 159                         b_count = ret_val.length();
 160                         pos     = ret_val.find_last_of("/");
 161                         if (pos == (b_count -1)) {
 162                                 ret_val.append(end_str);
 163                         }
 164                         else {
 165                                 pos     = end_str.find_first_of("/");
 166                                 if (pos == 0) {
 167                                         ret_val.append(end_str);
 168                                 }
 169                                 else {
 170                                         ret_val.append("/");
 171                                         ret_val.append(end_str);
 172                                 }
 173                         }
 174                 }
 175         }
 176         else {
 177                 if (path_end != NULL) {
 178                         ret_val = path_end;
 179                 }
 180         }
 181         return ret_val;
 182 }
 183
 184 bool FileUtil::is_subdirectory(const char *path, dirent *direntry) {
 185         bool            ret_val;
 186         struct stat     stat_info;
 187         string          fname;
 188
 189         ret_val = false;
 190         if (direntry != NULL) {
 191                 if ((strcmp(direntry->d_name, ".") == 0) ||
 192                     (strcmp(direntry->d_name, "..") == 0)) {
 193                         ret_val = false;
 194                 }
 195                 else {
 196                         fname   = concat_paths(path, direntry->d_name);
 197                         stat(fname.c_str(), &stat_info);
 198                         ret_val = S_ISDIR(stat_info.st_mode);
 199                         //log_debug("stat for: %s: %d\n", fname.c_str(), ret_val);
 200                 }
 201         }
 202         return ret_val;
 203 }
 204
 205 bool FileUtil::is_datafile(const char *path, dirent *direntry) {
 206         bool            ret_val;
 207         struct stat     stat_info;
 208         string          name;
 209         int             pos;
 210         string          fname;
 211
 212         ret_val = false;
 213         if (direntry != NULL) {
 214                 name    = direntry->d_name;
 215                 pos     = name.find(DATAFILE_SUFFIX);
 216                 if (pos > 0) {
 217                         fname   = concat_paths(path, direntry->d_name);
 218                         stat(fname.c_str(), &stat_info);
 219                         ret_val = S_ISREG(stat_info.st_mode);
 220                 }
 221         }
 222         return ret_val;
 223 }
 224
 225 /**
 226  * get sub-directories sorted in alphabetical order.
 227  */
 228 vector<string> FileUtil::get_subdirectories(const string& path) {
 229         dirent          *direntry;
 230         DIR             *dir;
 231         bool            bool_flg;
 232         vector<string>  ret_val;
 233
 234         //log_debug("scanning path: %s\n", path.c_str());
 235         errno   = 0;
 236         if (path.empty() == false) {
 237                 dir     = opendir(path.c_str());
 238                 if (dir) {
 239                         while (true) {
 240                                 errno           = 0;
 241                                 direntry        = readdir(dir);
 242                                 if (direntry != NULL) {
 243                                         bool_flg        = is_subdirectory(path.c_str(), direntry);
 244                                         if (bool_flg == true) {
 245                                                 ret_val.push_back(string(direntry->d_name));
 246                                                 //log_debug("added dir: %s\n", direntry->d_name);
 247                                         }
 248                                 }
 249                                 else {
 250                                         break;
 251                                 }
 252                         }
 253                         closedir(dir);
 254                         sort(ret_val.begin(), ret_val.end());
 255                 }
 256         }
 257         return ret_val;
 258 }
 259
 260 /**
 261  * get sub-directories sorted in alphabetical order.
 262  */
 263 vector<string> FileUtil::get_data_files(const string& path) {
 264         dirent          *direntry;
 265         DIR             *dir;
 266         vector<string>  ret_val;
 267
 268         errno   = 0;
 269         if (path.empty() == false) {
 270                 dir     = opendir(path.c_str());
 271                 if (dir) {
 272                         while (true) {
 273                                 errno           = 0;
 274                                 direntry        = readdir(dir);
 275                                 if (direntry != NULL) {
 276                                         if (is_datafile(path.c_str(), direntry) == true) {
 277                                                 ret_val.push_back(string(direntry->d_name));
 278                                         }
 279                                 }
 280                                 else {
 281                                         break;
 282                                 }
 283                         }
 284                         closedir(dir);
 285                         sort(ret_val.begin(), ret_val.end());
 286                 }
 287         }
 288         return ret_val;
 289 }