GitHub-Proxy/filesystem
1
0
Fork 0
mirror of https://git.mirrors.martin98.com/https://github.com/gulrak/filesystem synced 2025-06-04 11:13:58 +08:00
Code Issues Packages Projects Releases Wiki Activity

Some changes to make the forwarding/implementation way work on MSVC.

Browse Source
This commit is contained in:
Steffen Schümann 2019-03-24 12:46:19 +01:00
parent 243963558e
commit e8b2bee859
4 changed files with 90 additions and 85 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

50
include/ghc/filesystem.hpp
View File

@ -66,32 +66,37 @@
#define GHC_EXPAND_IMPL #define GHC_EXPAND_IMPL
#define GHC_INLINE #define GHC_INLINE
#ifdef GHC_OS_WINDOWS #ifdef GHC_OS_WINDOWS
# define GHC_FS_API __declspec(dllexport) #define GHC_FS_API
#define GHC_FS_API_CLASS
#else #else
#define GHC_FS_API __attribute__((visibility("default"))) #define GHC_FS_API __attribute__((visibility("default")))
#define GHC_FS_API_CLASS __attribute__((visibility("default")))
#endif #endif
#elif defined(GHC_FILESYSTEM_FWD) #elif defined(GHC_FILESYSTEM_FWD)
#define GHC_INLINE #define GHC_INLINE
#ifdef GHC_OS_WINDOWS #ifdef GHC_OS_WINDOWS
# define GHC_FS_API __declspec(dllimport) #define GHC_FS_API extern
#define GHC_FS_API_CLASS
#else #else
# define GHC_FS_API #define GHC_FS_API extern
#define GHC_FS_API_CLASS
#endif #endif
#else #else
#define GHC_EXPAND_IMPL #define GHC_EXPAND_IMPL
#define GHC_INLINE inline #define GHC_INLINE inline
#define GHC_FS_API #define GHC_FS_API
#define GHC_FS_API_CLASS
#endif #endif
#ifdef GHC_EXPAND_IMPL #ifdef GHC_EXPAND_IMPL
#ifdef GHC_OS_WINDOWS #ifdef GHC_OS_WINDOWS
#include <windows.h>
#include <shellapi.h>
#include <sys/stat.h> #include <sys/stat.h>
#include <sys/types.h> #include <sys/types.h>
#include <wchar.h> #include <wchar.h>
#include <windows.h>
#include <winioctl.h> #include <winioctl.h>
#include <shellapi.h>
#else #else
#include <dirent.h> #include <dirent.h>
#include <fcntl.h> #include <fcntl.h>
@ -147,7 +152,7 @@ namespace ghc {
namespace filesystem { namespace filesystem {
// temporary existing exception type for yet unimplemented parts // temporary existing exception type for yet unimplemented parts
class GHC_FS_API not_implemented_exception : public std::logic_error class GHC_FS_API_CLASS not_implemented_exception : public std::logic_error
{ {
public: public:
not_implemented_exception() not_implemented_exception()
@ -157,7 +162,7 @@ public:
}; };
// 30.10.8 class path // 30.10.8 class path
class GHC_FS_API path class GHC_FS_API_CLASS path
{ {
public: public:
using value_type = std::string::value_type; using value_type = std::string::value_type;
@ -369,7 +374,7 @@ template <class InputIterator>
path u8path(InputIterator first, InputIterator last); path u8path(InputIterator first, InputIterator last);
// 30.10.9 class filesystem_error // 30.10.9 class filesystem_error
class GHC_FS_API filesystem_error : public std::system_error class GHC_FS_API_CLASS filesystem_error : public std::system_error
{ {
public: public:
filesystem_error(const std::string& what_arg, std::error_code ec); filesystem_error(const std::string& what_arg, std::error_code ec);
@ -385,7 +390,7 @@ private:
path _p1, _p2; path _p1, _p2;
}; };
class GHC_FS_API path::iterator class GHC_FS_API_CLASS path::iterator
{ {
public: public:
using value_type = const path; using value_type = const path;
@ -495,7 +500,7 @@ enum class directory_options : uint16_t {
}; };
// 30.10.11 class file_status // 30.10.11 class file_status
class GHC_FS_API file_status class GHC_FS_API_CLASS file_status
{ {
public: public:
// 30.10.11.1 constructors and destructor // 30.10.11.1 constructors and destructor
@ -522,7 +527,7 @@ private:
using file_time_type = std::chrono::time_point<std::chrono::system_clock>; using file_time_type = std::chrono::time_point<std::chrono::system_clock>;
// 30.10.12 Class directory_entry // 30.10.12 Class directory_entry
class GHC_FS_API directory_entry class GHC_FS_API_CLASS directory_entry
{ {
public: public:
// 30.10.12.1 constructors and destructor // 30.10.12.1 constructors and destructor
@ -598,10 +603,10 @@ private:
}; };
// 30.10.13 Class directory_iterator // 30.10.13 Class directory_iterator
class GHC_FS_API directory_iterator class GHC_FS_API_CLASS directory_iterator
{ {
public: public:
class GHC_FS_API proxy class GHC_FS_API_CLASS proxy
{ {
public: public:
const directory_entry& operator*() const& noexcept { return _dir_entry; } const directory_entry& operator*() const& noexcept { return _dir_entry; }
@ -660,7 +665,7 @@ GHC_FS_API directory_iterator begin(directory_iterator iter) noexcept;
GHC_FS_API directory_iterator end(const directory_iterator&) noexcept; GHC_FS_API directory_iterator end(const directory_iterator&) noexcept;
// 30.10.14 class recursive_directory_iterator // 30.10.14 class recursive_directory_iterator
class GHC_FS_API recursive_directory_iterator class GHC_FS_API_CLASS recursive_directory_iterator
{ {
public: public:
using iterator_category = std::input_iterator_tag; using iterator_category = std::input_iterator_tag;
@ -947,7 +952,7 @@ typedef basic_ofstream<wchar_t> wofstream;
typedef basic_fstream<char> fstream; typedef basic_fstream<char> fstream;
typedef basic_fstream<wchar_t> wfstream; typedef basic_fstream<wchar_t> wfstream;
class GHC_FS_API u8arguments class GHC_FS_API_CLASS u8arguments
{ {
public: public:
u8arguments(int& argc, char**& argv); u8arguments(int& argc, char**& argv);
@ -957,10 +962,7 @@ public:
_refargv = _argv; _refargv = _argv;
} }
bool valid() const bool valid() const { return _isvalid; }
{
return _isvalid;
}
private: private:
int _argc; int _argc;
@ -995,7 +997,7 @@ namespace detail {
invalid_argument, invalid_argument,
}; };
GHC_FS_API std::error_code make_error_code(portable_error err); GHC_FS_API std::error_code make_error_code(portable_error err);
} } // namespace detail
namespace detail { namespace detail {
@ -1152,7 +1154,7 @@ GHC_INLINE unsigned consumeUtf8Fragment(const unsigned state, const uint8_t frag
return state == S_RJCT ? static_cast<unsigned>(S_RJCT) : static_cast<unsigned>((utf8_state_info[category + 16] >> (state << 2)) & 0xf); return state == S_RJCT ? static_cast<unsigned>(S_RJCT) : static_cast<unsigned>((utf8_state_info[category + 16] >> (state << 2)) & 0xf);
} }
} // detail } // namespace detail
#endif #endif
@ -1238,7 +1240,7 @@ inline std::string toUtf8(const SourceType* unicodeString)
return toUtf8(std::basic_string<SourceType, std::char_traits<SourceType>>(unicodeString)); return toUtf8(std::basic_string<SourceType, std::char_traits<SourceType>>(unicodeString));
} }
} // detail } // namespace detail
#ifdef GHC_EXPAND_IMPL #ifdef GHC_EXPAND_IMPL
@ -1637,7 +1639,9 @@ GHC_INLINE file_status symlink_status_ex(const path& p, std::error_code& ec, uin
} }
return ec ? file_status(file_type::none) : fs; return ec ? file_status(file_type::none) : fs;
#else #else
(void)sz; (void)nhl; (void)lwt; (void)sz;
(void)nhl;
(void)lwt;
struct ::stat fs; struct ::stat fs;
auto result = ::lstat(p.c_str(), &fs); auto result = ::lstat(p.c_str(), &fs);
if (result == 0) { if (result == 0) {

3
test/CMakeLists.txt
View File

@ -42,3 +42,6 @@ target_link_libraries(multifile_test ghc_filesystem)
add_executable(fwd_impl_test fwd_test.cpp impl_test.cpp) add_executable(fwd_impl_test fwd_test.cpp impl_test.cpp)
target_link_libraries(fwd_impl_test ghc_filesystem) target_link_libraries(fwd_impl_test ghc_filesystem)
if(CMAKE_CXX_COMPILER_ID MATCHES MSVC)
target_compile_definitions(fwd_impl_test PRIVATE _CRT_SECURE_NO_WARNINGS)
endif()

33
test/filesystem_test.cpp
View File

@ -34,12 +34,15 @@
#include <cstring> #include <cstring>
#include <fstream> #include <fstream>
#include <functional> #include <functional>
#include <iostream>
#include <iomanip> #include <iomanip>
#include <iostream>
#include <random> #include <random>
#include <sstream> #include <sstream>
#include <thread> #include <thread>
#ifndef WIN32 #ifdef WIN32
#define NOMINMAX
#include <windows.h>
#else
#include <sys/socket.h> #include <sys/socket.h>
#include <sys/stat.h> #include <sys/stat.h>
#include <sys/types.h> #include <sys/types.h>
@ -53,7 +56,7 @@ using namespace std::filesystem;
using ifstream = std::ifstream; using ifstream = std::ifstream;
using ofstream = std::ofstream; using ofstream = std::ofstream;
using fstream = std::fstream; using fstream = std::fstream;
} } // namespace fs
#ifdef __GNUC__ #ifdef __GNUC__
#define GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) #define GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
#endif #endif
@ -75,7 +78,7 @@ using namespace ghc::filesystem;
using ifstream = ghc::filesystem::ifstream; using ifstream = ghc::filesystem::ifstream;
using ofstream = ghc::filesystem::ofstream; using ofstream = ghc::filesystem::ofstream;
using fstream = ghc::filesystem::fstream; using fstream = ghc::filesystem::fstream;
} } // namespace fs
#endif #endif
#ifndef GHC_FILESYSTEM_FWD_TEST #ifndef GHC_FILESYSTEM_FWD_TEST
@ -110,7 +113,8 @@ struct StringMaker<fs::perms>
template <> template <>
struct StringMaker<fs::file_time_type> struct StringMaker<fs::file_time_type>
{ {
static std::string convert(fs::file_time_type const& value) { static std::string convert(fs::file_time_type const& value)
{
std::time_t t = to_time_t(value); std::time_t t = to_time_t(value);
std::tm ttm = *std::localtime(&t); std::tm ttm = *std::localtime(&t);
std::ostringstream os; std::ostringstream os;
@ -135,8 +139,7 @@ public:
filename += "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"[rng()]; filename += "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"[rng()];
} }
_path = fs::canonical(fs::temp_directory_path()) / filename; _path = fs::canonical(fs::temp_directory_path()) / filename;
} } while (fs::exists(_path));
while(fs::exists(_path));
fs::create_directories(_path); fs::create_directories(_path);
if (opt == TempOpt::change_path) { if (opt == TempOpt::change_path) {
_orig_dir = fs::current_path(); _orig_dir = fs::current_path();
@ -210,7 +213,6 @@ static bool has_host_root_name_support()
return fs::path("//host").has_root_name(); return fs::path("//host").has_root_name();
} }
template <class T> template <class T>
class TestAllocator class TestAllocator
{ {
@ -218,17 +220,14 @@ public:
using value_type = T; using value_type = T;
TestAllocator() noexcept {} TestAllocator() noexcept {}
template <class U> TestAllocator(TestAllocator<U> const&) noexcept {} template <class U>
TestAllocator(TestAllocator<U> const&) noexcept
value_type* allocate(std::size_t n)
{ {
return static_cast<value_type*>(::operator new (n*sizeof(value_type)));
} }
void deallocate(value_type* p, std::size_t) noexcept value_type* allocate(std::size_t n) { return static_cast<value_type*>(::operator new(n * sizeof(value_type))); }
{
::operator delete(p); void deallocate(value_type* p, std::size_t) noexcept { ::operator delete(p); }
}
}; };
template <class T, class U> template <class T, class U>
@ -243,8 +242,6 @@ bool operator!=(TestAllocator<T> const& x, TestAllocator<U> const& y) noexcept
return !(x == y); return !(x == y);
} }
TEST_CASE("Temporary Directory", "[temp dir]") TEST_CASE("Temporary Directory", "[temp dir]")
{ {
fs::path tempPath; fs::path tempPath;

1
test/impl_test.cpp
View File

@ -3,6 +3,7 @@
// where exactly one cpp includes fs_impl.hpp and all others use // where exactly one cpp includes fs_impl.hpp and all others use
// fs_fwd.hpp (to test this with maximum functionality, the unit tests // fs_fwd.hpp (to test this with maximum functionality, the unit tests
// are included here, signaling they should only include the fs_fwd.hpp) // are included here, signaling they should only include the fs_fwd.hpp)
#define NOMINMAX
#include <ghc/fs_impl.hpp> #include <ghc/fs_impl.hpp>
#define CATCH_CONFIG_MAIN #define CATCH_CONFIG_MAIN
#include "catch.hpp" #include "catch.hpp"