tool to count the objects in a directory tree More...

Typedefs
typedef MyWaitQueues::simple< std::string >	dirQueueType

Functions
void	handleDir (const std::string &path, counterType &counter)

int	main (int argc, const char *argv[])

Variables
static options::single< bool >	ignoreAccess ('i', "ignoreAccess", "ignore subdirs we may not access")

static options::single< bool >	quiet ('q', "quiet", "be quiet, no prefix to output lines")

static options::single< bool >	reportUnknowns ('U',"reportUnknowns", "print a list of items with type DT_UNKNOWN")

static options::single< unsigned >	nThreads ('n', "nThreads", "number of threads", 0)

static std::forward_list< std::string >	unknownList

static std::mutex	unknownListMutex

static unsigned int	runnerType::nWorkers

static std::mutex	runnerType::listMutex

static std::condition_variable	runnerType::cv

static std::atomic< unsigned int >	runnerType::nActiveWorkers

Detailed Description

tool to count the objects in a directory tree

Typedef Documentation

◆ dirQueueType

typedef MyWaitQueues::simple<std::string> dirQueueType

Definition at line 142 of file dirCount.cpp.

Function Documentation

◆ handleDir()

void handleDir	(	const std::string &	path,
		counterType &	counter
	)

Definition at line 259 of file dirCount.cpp.

                                                             {
     static timer::anchor a("opendir");
     timer::instanceUnscoped i(a);
     auto result = opendir(path.c_str());
     i.stop();
     if (result == nullptr) {
         if (errno == EACCES && ignoreAccess) {
             counter.count(counterType::specials::denied);
             return;
         } else if (errno == ENOENT) {
             counter.count(counterType::specials::noent);
             return;
         } else if (errno == ENOTDIR) {
             counter.count(counterType::specials::notdir);
             return;
         }
         throwcall::badval(result, nullptr, "can't open directory ", path);
     }
     scoped::Dir dir(path, result);
     std::forward_list<std::string> subdirs;
     static timer::anchor b("readdir");
     timer::instanceUnscoped I(b);
     while (auto entry = readdir(dir)) {
         I.stop();
         if (entry->d_name[entry->d_name[0] != '.' ? 0 : entry->d_name[1] != '.' ? 1 : 2] == '\0') {
             I.restart();
             continue; // skip . .. and empty strings
         }
         counter.count(entry->d_type);
         if (entry->d_type == DT_DIR) {
             subdirs.emplace_front(entry->d_name);
         } else if (entry->d_type == DT_UNKNOWN && reportUnknowns) {
             std::string item(path);
             item += "/";
             item += entry->d_name;
             unknownList.emplace_front(item);
         }
         I.restart();
     }
     for (const auto& subdir : subdirs) {
         handleDir(path + "/" + subdir, counter);
     }
  
 }

References throwcall::badval(), counterType::count(), ignoreAccess, reportUnknowns, timer::instanceUnscoped::restart(), timer::instanceUnscoped::stop(), and unknownList.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ main()

int main	(	int	argc,
		const char *	argv[]
	)

Definition at line 304 of file dirCount.cpp.

                                        {
     options::parser parser("dirCount", "", {});
     options::positional<options::container<std::string>>paths(10, "paths",
             "paths to consider");
     options::single<bool> timing('t', "timing", "show timing info");
     counterType::init();
     parser.fParse(argc, argv);
  
     counterType counter;
     if (nThreads == 1) {
         for (auto path : paths) {
             handleDir(path, counter);
         }
     } else {
         if (nThreads == 0) {
             nThreads = sysconf(_SC_NPROCESSORS_ONLN);
         }
         dirQueueType dirQueue;
         for (const auto& path : paths) {
             dirQueue.emplace(path);
         }
         for (unsigned int i = 0; i < paths.size(); i++) {
             runnerType::newWorker(dirQueue);
         }
         runnerType::finish(counter, timing);
     }
     counter.print();
     if (timing) {
         timer::anchor::print(std::cerr, "");
     }
     if (reportUnknowns) {
         std::cout << "List of items of type DT_UNKNOWN:\n";
         for (const auto& item: unknownList) {
             std::cout << item << "\n";
         }
     }
     return 0;
 }