定义ignore配置文件忽略文件统计
原创
©著作权归作者所有：来自51CTO博客作者我是006的原创作品，请联系作者获取转载授权，否则将追究法律责任
/*#include <iostream>
#include <string>
#include <regex>
#include <boost/property_tree/ptree.hpp>
#include <boost/property_tree/ini_parser.hpp>
int main() {
std::regex reg1(".*\\.xml");
bool found = regex_match("value.xml",reg1);
std::cout << found << std::endl;
boost::property_tree::ptree properties;
boost::property_tree::ini_parser::read_ini("./ignore.ini", properties);
boost::property_tree::basic_ptree<std::string, std::string>items = properties.get_child("");
for (auto item = begin(items);item != end(items);++item) {
std::cout << item->first.data() << " " << item->second.data() << std::endl;
}
return 0;
}*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <dirent.h>
#include <iostream>
#include <string>
#include <vector>
#include <set>
#include <regex>
#include <boost/property_tree/ptree.hpp>
#include <boost/property_tree/ini_parser.hpp>
#include "trie_tree.hpp"
static const int SIZE_UNIT_NUM = 5;
struct file_info {
file_info(const std::string &str) : file_name(str) {
total_size = 0;
detail_size.resize(SIZE_UNIT_NUM, 0);
}
inline void show_info() const {
std::cout << "file name = " << file_name << " size = " << total_size << "B" << " detail size:" << detail_size[4] << "T" << detail_size[3] << "G" << detail_size[2] << "M" << detail_size[1] << "K" << detail_size[0] << "B" << std::endl;
}
std::string file_name;
size_t total_size;
std::vector<size_t>detail_size; // Byte KB MB GB TB
};
class file_system {
public:
file_system() = default;
file_system(const file_system &) = delete;
file_system & operator = (const file_system &) = delete;
~file_system() = default;
public:
bool init(const char *path = "./ignore.ini") {
if (false == trieTree_.init()) {
std::cerr << "trie tree init failed." << std::endl;
return false;
}
parse_ini_file(path);
return true;
}
void stat_file_info(const char *dir_path) {
get_file_info(dir_path);
for (const auto &info : file_info_set_) {
total_size_ += info.total_size;
info.show_info();
}
file_info fileinfo(dir_path);
stat_file_size(fileinfo, total_size_);
fileinfo.show_info();
}
size_t get_total_dir_size() const {
return total_size_;
}
private:
void parse_ini_file(const char *path) {
boost::property_tree::ptree properties;
try {
boost::property_tree::ini_parser::read_ini(path, properties);
}
catch (std::exception &e) {
std::cerr << e.what() << std::endl;
return;
}
boost::property_tree::basic_ptree<std::string, std::string>items = properties.get_child("");
for (auto item = begin(items);item != end(items);++item) {
trieTree_.insert(item->second.data().c_str());
}
}
bool need_to_ignore(const char *name) {
int j = strlen(name) - 1;
for (;j >= 0;j--) {
if ('.' == name[j]) {
break;
}
}
if (j < 0) {
return false;
}
name += (j + 1);
return trieTree_.find(name);
}
void stat_file_size(file_info &fileinfo, size_t bytes) {
fileinfo.total_size = bytes;
for (auto i = 0;i < SIZE_UNIT_NUM;i++) {
auto x = bytes / 1024;
auto y = bytes % 1024;
fileinfo.detail_size[i] = y;
if (0 == x) {
break;
}
bytes = x;
}
}
void get_file_info(const char *dir_path) {
DIR *dirp = nullptr;
struct stat stat_buf;
dirp = ::opendir(dir_path);
if (nullptr == dirp) {
std::cerr << dir_path << " opendir failed." << std::endl;
::exit(-1);
}
::chdir(dir_path);
struct dirent *entry = nullptr;
while (nullptr != (entry = readdir(dirp))) {
::lstat(entry->d_name, &stat_buf);
if (true == need_to_ignore(entry->d_name)) {
continue;
}
if (!S_ISDIR(stat_buf.st_mode)) {
file_info fileinfo(entry->d_name);
stat_file_size(fileinfo, stat_buf.st_size);
file_info_set_.emplace_back(fileinfo);
continue;
}
if (0 == strcmp(entry->d_name, ".") || 0 == strcmp(entry->d_name, "..")) {
continue;
}
file_info fileinfo(entry->d_name);
stat_file_size(fileinfo, stat_buf.st_size);
file_info_set_.emplace_back(fileinfo);
get_file_info(entry->d_name);
}
::chdir("..");
::closedir(dirp);
}
private:
size_t total_size_ = 0;
std::vector<file_info>file_info_set_;
trie_tree trieTree_;
};
int main() {
file_system filesystem;
if (false == filesystem.init()) {
return -1;
}
filesystem.stat_file_info("/root/rel/log");
return 0;
}
#include <stdlib.h>
#include <time.h>
#include <iostream>
#include <vector>
#include <string>
#include <thread>
#define SAFE_DEL(p) do { if (nullptr != p) { delete p; p = nullptr; }} while (0)
enum class TrieNodeType {
UNCOMPLETED,
COMPLETED
};
struct trie_node {
static const size_t MAX_NODE_NUM = 256;
TrieNodeType type = TrieNodeType::UNCOMPLETED;
trie_node *links[MAX_NODE_NUM] = { nullptr };
};
class trie_tree {
public:
trie_tree() = default;
trie_tree(const trie_tree &) = delete;
trie_tree & operator = (const trie_tree &) = delete;
virtual ~trie_tree() {
destory(root_);
}
public:
bool init() {
try {
root_ = new trie_node;
}
catch (...) {
return false;
}
init_succ = true;
return true;
}
bool insert(const char *word) {
char ch = 0;
trie_node *ptr = nullptr;
if (false == init_succ) {
return false;
}
auto cur_node_ptr = root_;
for (int i = 0;word[i];i++) {
ch = word[i];
if (false == charater_is_valid(ch)) {
return false;
}
auto &link = cur_node_ptr->links[ch];
if (nullptr == link) {
ptr = create_node();
link = ptr;
}
cur_node_ptr = link;
}
if (TrieNodeType::COMPLETED == cur_node_ptr->type) {
std::cerr << "word:" << word << " reapted." << std::endl;
return false;
}
cur_node_ptr->type = TrieNodeType::COMPLETED;
return true;
}
bool find(const char *word) {
char ch = 0;
trie_node *ptr = nullptr;
if (false == init_succ) {
return false;
}
auto cur_node_ptr = root_;
for (int i = 0;word[i];i++) {
ch = word[i];
if (false == charater_is_valid(ch)) {
return false;
}
auto &link = cur_node_ptr->links[ch];
if (nullptr == link) {
return false;
}
cur_node_ptr = link;
}
return TrieNodeType::COMPLETED == cur_node_ptr->type;
}
bool find(const char *prefix_word, std::vector<std::string>&words) {
char ch = 0;
trie_node *ptr = nullptr;
if (false == init_succ) {
return false;
}
auto cur_node_ptr = root_;
std::string str;
for (int i = 0;prefix_word[i];i++) {
ch = prefix_word[i];
if (false == charater_is_valid(ch)) {
return false;
}
auto &link = cur_node_ptr->links[ch];
if (nullptr == link) {
return false;
}
str += ch;
cur_node_ptr = link;
}
find_all_words(cur_node_ptr, str, words);
return true;
}
private:
inline trie_node *create_node() {
trie_node *ptr = nullptr;
try {
ptr = new trie_node;
}
catch (std::exception &e) {
std::cerr << e.what() << std::endl;
::exit(-1);
}
return ptr;
}
bool charater_is_valid(char ch) {
return (ch >= 0 && ch < trie_node::MAX_NODE_NUM);
}
void find_all_words(const trie_node *ptr, std::string &str, std::vector<std::string>&words) {
if (nullptr == ptr) {
return;
}
char ch = 0;
for (size_t index = 0;index < trie_node::MAX_NODE_NUM;index++) {
auto &link = ptr->links[index];
if (nullptr == link) {
continue;
}
ch = index;
str += ch;
find_all_words(link, str, words);
}
if (TrieNodeType::COMPLETED == ptr->type) {
words.emplace_back(str);
}
str.erase(end(str) - 1);
}
void destory(trie_node *&ptr) {
if (nullptr == ptr) {
return;
}
for (size_t index = 0;index < trie_node::MAX_NODE_NUM;index++) {
destory(ptr->links[index]);
}
SAFE_DEL(ptr);
}
private:
trie_node *root_ = nullptr;
bool init_succ = false;
};
