coco
635 lines
18 KiB
C++
635 lines
18 KiB
C++
// Copyright (C) 2003 Davis E. King (davis@dlib.net)
|
|
// License: Boost Software License See LICENSE.txt for the full license.
|
|
#ifndef DLIB_DIR_NAV_KERNEl_1_
|
|
#define DLIB_DIR_NAV_KERNEl_1_
|
|
|
|
#ifdef DLIB_ISO_CPP_ONLY
|
|
#error "DLIB_ISO_CPP_ONLY is defined so you can't use this OS dependent code. Turn DLIB_ISO_CPP_ONLY off if you want to use it."
|
|
#endif
|
|
|
|
#include "../platform.h"
|
|
|
|
|
|
#include "dir_nav_kernel_abstract.h"
|
|
#include <string>
|
|
#include "../uintn.h"
|
|
#include "../algs.h"
|
|
|
|
#include "../windows_magic.h"
|
|
#include <windows.h>
|
|
#include <vector>
|
|
#include "../stl_checked.h"
|
|
#include "../enable_if.h"
|
|
#include "../queue.h"
|
|
#include <chrono>
|
|
|
|
namespace dlib
|
|
{
|
|
|
|
|
|
// ----------------------------------------------------------------------------------------
|
|
// ----------------------------------------------------------------------------------------
|
|
// file object
|
|
// ----------------------------------------------------------------------------------------
|
|
// ----------------------------------------------------------------------------------------
|
|
|
|
class file
|
|
{
|
|
/*!
|
|
INITIAL VALUES
|
|
state.name == name()
|
|
state.full_name == full_name()
|
|
state.file_size == size()
|
|
state.last_modified == last_modified()
|
|
|
|
CONVENTION
|
|
state.name == name()
|
|
state.full_name == full_name()
|
|
state.file_size == size()
|
|
state.last_modified == last_modified()
|
|
|
|
!*/
|
|
|
|
friend class directory;
|
|
|
|
struct data
|
|
{
|
|
uint64 file_size;
|
|
std::string name;
|
|
std::string full_name;
|
|
std::chrono::time_point<std::chrono::system_clock> last_modified;
|
|
};
|
|
|
|
|
|
void init ( const std::string& name);
|
|
|
|
public:
|
|
|
|
struct private_constructor{};
|
|
inline file (
|
|
const std::string& name,
|
|
const std::string& full_name,
|
|
const uint64 file_size,
|
|
const std::chrono::time_point<std::chrono::system_clock>& last_modified,
|
|
private_constructor
|
|
)
|
|
{
|
|
state.file_size = file_size;
|
|
state.name = name;
|
|
state.full_name = full_name;
|
|
state.last_modified = last_modified;
|
|
}
|
|
|
|
|
|
|
|
|
|
class file_not_found : public error {
|
|
public: file_not_found(const std::string& s): error(s){}
|
|
};
|
|
|
|
inline file (
|
|
)
|
|
{
|
|
state.file_size = 0;
|
|
}
|
|
|
|
file (
|
|
const std::string& name
|
|
) { init(name); }
|
|
|
|
file (
|
|
const char* name
|
|
) { init(name); }
|
|
|
|
inline const std::string& name (
|
|
) const { return state.name; }
|
|
|
|
inline const std::string& full_name (
|
|
) const { return state.full_name; }
|
|
|
|
operator std::string (
|
|
) const { return full_name(); }
|
|
|
|
inline uint64 size (
|
|
) const { return state.file_size; }
|
|
|
|
inline std::chrono::time_point<std::chrono::system_clock> last_modified (
|
|
) const { return state.last_modified; }
|
|
|
|
bool operator == (
|
|
const file& rhs
|
|
) const;
|
|
|
|
bool operator != (
|
|
const file& rhs
|
|
) const { return !(*this == rhs); }
|
|
|
|
inline bool operator < (
|
|
const file& item
|
|
) const { return full_name() < item.full_name(); }
|
|
|
|
inline void swap (
|
|
file& item
|
|
)
|
|
{
|
|
exchange(state,item.state);
|
|
}
|
|
|
|
private:
|
|
|
|
data state;
|
|
|
|
};
|
|
|
|
// ----------------------------------------------------------------------------------------
|
|
// ----------------------------------------------------------------------------------------
|
|
// directory object
|
|
// ----------------------------------------------------------------------------------------
|
|
// ----------------------------------------------------------------------------------------
|
|
|
|
class directory
|
|
{
|
|
/*!
|
|
INITIAL VALUES
|
|
state.name == name()
|
|
state.full_name == full_name()
|
|
|
|
CONVENTION
|
|
state.name == name()
|
|
state.full_name == full_name()
|
|
is_root() == state.name.size() == 0
|
|
|
|
!*/
|
|
|
|
void init (const std::string& name);
|
|
|
|
public:
|
|
|
|
struct data
|
|
{
|
|
std::string name;
|
|
std::string full_name;
|
|
};
|
|
|
|
|
|
/*
|
|
The reason we don't just make this constructor actually
|
|
private is because doing it this way avoids a bug that
|
|
sometimes occurs in visual studio 7.1. The bug has
|
|
something to do with templated friend functions
|
|
such as the get_filesystem_roots() function below if
|
|
it was declared as a friend template of this class.
|
|
*/
|
|
struct private_constructor{};
|
|
inline directory (
|
|
const std::string& name,
|
|
const std::string& full_name,
|
|
private_constructor
|
|
)
|
|
{
|
|
state.name = name;
|
|
state.full_name = full_name;
|
|
}
|
|
|
|
|
|
class dir_not_found : public error {
|
|
public: dir_not_found(const std::string& s):error(s){}
|
|
};
|
|
class listing_error : public error {
|
|
public: listing_error(const std::string& s):error(s){}
|
|
};
|
|
|
|
inline directory (
|
|
)
|
|
{
|
|
}
|
|
|
|
directory (
|
|
const std::string& name
|
|
) { init(name); }
|
|
|
|
directory (
|
|
const char* name
|
|
) { init(name); }
|
|
|
|
|
|
static char get_separator (
|
|
);
|
|
|
|
|
|
template <
|
|
typename queue_of_files
|
|
>
|
|
void get_files (
|
|
queue_of_files& files
|
|
) const;
|
|
|
|
template <
|
|
typename queue_of_dirs
|
|
>
|
|
void get_dirs (
|
|
queue_of_dirs& dirs
|
|
) const;
|
|
|
|
std::vector<file> get_files (
|
|
) const
|
|
{
|
|
std::vector<file> temp_vector;
|
|
get_files(temp_vector);
|
|
return temp_vector;
|
|
}
|
|
|
|
std::vector<directory> get_dirs (
|
|
) const
|
|
{
|
|
std::vector<directory> temp_vector;
|
|
get_dirs(temp_vector);
|
|
return temp_vector;
|
|
}
|
|
|
|
const directory get_parent (
|
|
) const;
|
|
|
|
inline bool is_root (
|
|
) const { return state.name.size() == 0; }
|
|
|
|
inline const std::string& name (
|
|
) const { return state.name; }
|
|
|
|
inline const std::string& full_name (
|
|
) const { return state.full_name; }
|
|
|
|
operator std::string (
|
|
) const { return full_name(); }
|
|
|
|
bool operator == (
|
|
const directory& rhs
|
|
) const;
|
|
|
|
bool operator != (
|
|
const directory& rhs
|
|
) const { return !(*this == rhs); }
|
|
|
|
inline bool operator < (
|
|
const directory& item
|
|
) const { return full_name() < item.full_name(); }
|
|
|
|
inline void swap (
|
|
directory& item
|
|
)
|
|
{
|
|
exchange(state,item.state);
|
|
}
|
|
|
|
private:
|
|
|
|
// member data
|
|
data state;
|
|
|
|
bool is_root_path (
|
|
const std::string& path
|
|
) const;
|
|
/*!
|
|
ensures
|
|
- returns true if path is a root path.
|
|
Note that this function considers root paths that don't
|
|
have a trailing separator to also be valid.
|
|
!*/
|
|
|
|
|
|
};
|
|
|
|
// ----------------------------------------------------------------------------------------
|
|
|
|
inline std::ostream& operator<< (
|
|
std::ostream& out,
|
|
const directory& item
|
|
) { out << (std::string)item; return out; }
|
|
|
|
inline std::ostream& operator<< (
|
|
std::ostream& out,
|
|
const file& item
|
|
) { out << (std::string)item; return out; }
|
|
|
|
// ----------------------------------------------------------------------------------------
|
|
|
|
template <
|
|
typename queue_of_dir
|
|
>
|
|
typename disable_if<is_std_vector<queue_of_dir>,void>::type get_filesystem_roots (
|
|
queue_of_dir& roots
|
|
)
|
|
{
|
|
roots.clear();
|
|
const DWORD mask = GetLogicalDrives();
|
|
DWORD bit = 1;
|
|
char buf[] = "A:\\";
|
|
|
|
do
|
|
{
|
|
if (mask & bit)
|
|
{
|
|
directory dir("",buf,directory::private_constructor());
|
|
roots.enqueue(dir);
|
|
}
|
|
bit <<= 1;
|
|
++buf[0];
|
|
} while (buf[0] != 'Z');
|
|
}
|
|
|
|
template <
|
|
typename queue_of_dir
|
|
>
|
|
typename enable_if<is_std_vector<queue_of_dir>,void>::type get_filesystem_roots (
|
|
queue_of_dir& roots
|
|
)
|
|
{
|
|
roots.clear();
|
|
const DWORD mask = GetLogicalDrives();
|
|
DWORD bit = 1;
|
|
char buf[] = "A:\\";
|
|
|
|
do
|
|
{
|
|
if (mask & bit)
|
|
{
|
|
directory dir("",buf,directory::private_constructor());
|
|
roots.push_back(dir);
|
|
}
|
|
bit <<= 1;
|
|
++buf[0];
|
|
} while (buf[0] != 'Z');
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------------------
|
|
|
|
inline void swap (
|
|
file& a,
|
|
file& b
|
|
) { a.swap(b); }
|
|
|
|
// ----------------------------------------------------------------------------------------
|
|
|
|
inline void swap (
|
|
directory& a,
|
|
directory& b
|
|
) { a.swap(b); }
|
|
|
|
// ----------------------------------------------------------------------------------------
|
|
// ----------------------------------------------------------------------------------------
|
|
// templated member function definitions
|
|
// ----------------------------------------------------------------------------------------
|
|
// ----------------------------------------------------------------------------------------
|
|
|
|
template <
|
|
typename queue_of_files
|
|
>
|
|
typename disable_if<is_std_vector<queue_of_files>,void>::type
|
|
directory_helper_get_files (
|
|
const directory::data& state,
|
|
queue_of_files& files
|
|
)
|
|
{
|
|
using namespace std;
|
|
typedef directory::listing_error listing_error;
|
|
typedef file::private_constructor private_constructor;
|
|
|
|
files.clear();
|
|
if (state.full_name.size() == 0)
|
|
throw listing_error("This directory object currently doesn't represent any directory.");
|
|
|
|
HANDLE ffind = INVALID_HANDLE_VALUE;
|
|
try
|
|
{
|
|
WIN32_FIND_DATAA data;
|
|
string path = state.full_name;
|
|
// ensure that the path ends with a separator
|
|
if (path[path.size()-1] != directory::get_separator())
|
|
path += directory::get_separator();
|
|
|
|
ffind = FindFirstFileA((path+"*").c_str(), &data);
|
|
if (ffind == INVALID_HANDLE_VALUE)
|
|
{
|
|
throw listing_error("Unable to list the contents of " + state.full_name);
|
|
}
|
|
|
|
|
|
bool no_more_files = false;
|
|
do
|
|
{
|
|
if ((data.dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY) == 0)
|
|
{
|
|
uint64 file_size = data.nFileSizeHigh;
|
|
file_size <<= 32;
|
|
file_size |= data.nFileSizeLow;
|
|
|
|
ULARGE_INTEGER ull;
|
|
ull.LowPart = data.ftLastWriteTime.dwLowDateTime;
|
|
ull.HighPart = data.ftLastWriteTime.dwHighDateTime;
|
|
std::chrono::nanoseconds epoch(100 * (ull.QuadPart - 116444736000000000));
|
|
auto last_modified = std::chrono::time_point<std::chrono::system_clock>(std::chrono::duration_cast<std::chrono::system_clock::duration>(epoch));
|
|
|
|
// this is a file so add it to the queue
|
|
file temp(data.cFileName,path+data.cFileName,file_size, last_modified, private_constructor());
|
|
files.enqueue(temp);
|
|
}
|
|
|
|
if (FindNextFileA(ffind,&data) == 0)
|
|
{
|
|
// an error occurred
|
|
if ( GetLastError() == ERROR_NO_MORE_FILES)
|
|
{
|
|
// there are no more files
|
|
no_more_files = true;
|
|
}
|
|
else
|
|
{
|
|
// there was an error
|
|
throw listing_error("Unable to list the contents of " + state.full_name);
|
|
}
|
|
}
|
|
} while (no_more_files == false);
|
|
|
|
FindClose(ffind);
|
|
ffind = INVALID_HANDLE_VALUE;
|
|
}
|
|
catch (...)
|
|
{
|
|
if (ffind != INVALID_HANDLE_VALUE)
|
|
FindClose(ffind);
|
|
files.clear();
|
|
throw;
|
|
}
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------------------
|
|
|
|
template <
|
|
typename queue_of_files
|
|
>
|
|
typename enable_if<is_std_vector<queue_of_files>,void>::type
|
|
directory_helper_get_files (
|
|
const directory::data& state,
|
|
queue_of_files& files
|
|
)
|
|
{
|
|
queue<file>::kernel_2a temp_files;
|
|
directory_helper_get_files(state,temp_files);
|
|
|
|
files.clear();
|
|
|
|
// copy the queue of files into the vector
|
|
temp_files.reset();
|
|
while (temp_files.move_next())
|
|
{
|
|
files.push_back(temp_files.element());
|
|
}
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------------------
|
|
|
|
template <
|
|
typename queue_of_files
|
|
>
|
|
void directory::
|
|
get_files (
|
|
queue_of_files& files
|
|
) const
|
|
{
|
|
// the reason for this indirection here is because it avoids a bug in
|
|
// the mingw version of gcc
|
|
directory_helper_get_files(state,files);
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------------------
|
|
// ----------------------------------------------------------------------------------------
|
|
// ----------------------------------------------------------------------------------------
|
|
|
|
template <
|
|
typename queue_of_dirs
|
|
>
|
|
typename disable_if<is_std_vector<queue_of_dirs>,void>::type
|
|
directory_helper_get_dirs (
|
|
const directory::data& state,
|
|
queue_of_dirs& dirs
|
|
)
|
|
{
|
|
using namespace std;
|
|
typedef directory::listing_error listing_error;
|
|
typedef directory::private_constructor private_constructor;
|
|
|
|
dirs.clear();
|
|
if (state.full_name.size() == 0)
|
|
throw listing_error("This directory object currently doesn't represent any directory.");
|
|
|
|
HANDLE dfind = INVALID_HANDLE_VALUE;
|
|
try
|
|
{
|
|
WIN32_FIND_DATAA data;
|
|
string path = state.full_name;
|
|
// ensure that the path ends with a separator
|
|
if (path[path.size()-1] != directory::get_separator())
|
|
path += directory::get_separator();
|
|
|
|
dfind = FindFirstFileA((path+"*").c_str(), &data);
|
|
if (dfind == INVALID_HANDLE_VALUE)
|
|
{
|
|
throw listing_error("Unable to list the contents of " + state.full_name);
|
|
}
|
|
|
|
|
|
bool no_more_files = false;
|
|
do
|
|
{
|
|
string tname(data.cFileName);
|
|
if ((data.dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY) != 0 &&
|
|
tname != "." &&
|
|
tname != "..")
|
|
{
|
|
// this is a directory so add it to the queue
|
|
directory temp(tname,path+tname,private_constructor());
|
|
dirs.enqueue(temp);
|
|
}
|
|
|
|
if (FindNextFileA(dfind,&data) == 0)
|
|
{
|
|
// an error occurred
|
|
if ( GetLastError() == ERROR_NO_MORE_FILES)
|
|
{
|
|
// there are no more files
|
|
no_more_files = true;
|
|
}
|
|
else
|
|
{
|
|
// there was an error
|
|
throw listing_error("Unable to list the contents of " + state.full_name);
|
|
}
|
|
}
|
|
} while (no_more_files == false);
|
|
|
|
FindClose(dfind);
|
|
dfind = INVALID_HANDLE_VALUE;
|
|
}
|
|
catch (...)
|
|
{
|
|
if (dfind != INVALID_HANDLE_VALUE)
|
|
FindClose(dfind);
|
|
dirs.clear();
|
|
throw;
|
|
}
|
|
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------------------
|
|
|
|
template <
|
|
typename queue_of_dirs
|
|
>
|
|
typename enable_if<is_std_vector<queue_of_dirs>,void>::type
|
|
directory_helper_get_dirs (
|
|
const directory::data& state,
|
|
queue_of_dirs& dirs
|
|
)
|
|
{
|
|
queue<directory>::kernel_2a temp_dirs;
|
|
directory_helper_get_dirs(state,temp_dirs);
|
|
|
|
dirs.clear();
|
|
|
|
// copy the queue of dirs into the vector
|
|
temp_dirs.reset();
|
|
while (temp_dirs.move_next())
|
|
{
|
|
dirs.push_back(temp_dirs.element());
|
|
}
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------------------
|
|
|
|
template <
|
|
typename queue_of_dirs
|
|
>
|
|
void directory::
|
|
get_dirs (
|
|
queue_of_dirs& dirs
|
|
) const
|
|
{
|
|
// the reason for this indirection here is because it avoids a bug in
|
|
// the mingw version of gcc
|
|
directory_helper_get_dirs(state,dirs);
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------------------
|
|
// ----------------------------------------------------------------------------------------
|
|
// ----------------------------------------------------------------------------------------
|
|
|
|
}
|
|
|
|
|
|
#ifdef NO_MAKEFILE
|
|
#include "dir_nav_kernel_1.cpp"
|
|
#endif
|
|
|
|
#endif // DLIB_DIR_NAV_KERNEl_1_
|
|
|