diff --git a/v3/boost/filesystem.hpp b/v3/boost/filesystem.hpp new file mode 100644 index 0000000..d4be84f --- /dev/null +++ b/v3/boost/filesystem.hpp @@ -0,0 +1,21 @@ +// boost/filesystem/filesystem.hpp -----------------------------------------// + +// Copyright Beman Dawes 2005 + +// Use, modification, and distribution is subject to the Boost Software +// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// See library home page at http://www.boost.org/libs/filesystem + +//----------------------------------------------------------------------------// + +#ifndef BOOST_FILESYSTEM_FILESYSTEM_HPP +#define BOOST_FILESYSTEM_FILESYSTEM_HPP + +#include +#include +#include +#include +#endif + diff --git a/v3/boost/filesystem/config.hpp b/v3/boost/filesystem/config.hpp new file mode 100644 index 0000000..33f8f9e --- /dev/null +++ b/v3/boost/filesystem/config.hpp @@ -0,0 +1,82 @@ +// boost/filesystem/config.hpp -------------------------------------------------------// + +// Copyright Beman Dawes 2003 + +// Distributed under the Boost Software License, Version 1.0. +// See http://www.boost.org/LICENSE_1_0.txt + +// Library home page: http://www.boost.org/libs/filesystem + +//--------------------------------------------------------------------------------------// + +#ifndef BOOST_FILESYSTEM_CONFIG_HPP +#define BOOST_FILESYSTEM_CONFIG_HPP + +#define BOOST_FILESYSTEM_I18N // aid users wishing to compile several versions + +// ability to change namespace aids path_table.cpp ----------------------------------// +#ifndef BOOST_FILESYSTEM_NAMESPACE +# define BOOST_FILESYSTEM_NAMESPACE filesystem +#endif + +// This header implements separate compilation features as described in +// http://www.boost.org/more/separate_compilation.html + +#include +#include // for BOOST_POSIX_API or BOOST_WINDOWS_API +#include + +// BOOST_FILESYSTEM_DEPRECATED needed for source compiles -----------------------------// + +# ifdef BOOST_FILESYSTEM_SOURCE +# define BOOST_FILESYSTEM_DEPRECATED +# endif + +// throw an exception ----------------------------------------------------------------// +// +// Exceptions were originally thrown via boost::throw_exception(). +// As throw_exception() became more complex, it caused user error reporting +// to be harder to interpret, since the exception reported became much more complex. +// The immediate fix was to throw directly, wrapped in a macro to make any later change +// easier. + +#define BOOST_FILESYSTEM_THROW(EX) throw EX + +# if defined( BOOST_NO_STD_WSTRING ) +# error Configuration not supported: Boost.Filesystem V3 and later requires std::wstring support +# endif + +// enable dynamic linking -------------------------------------------------------------// + +#if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_FILESYSTEM_DYN_LINK) +# if defined(BOOST_FILESYSTEM_SOURCE) +# define BOOST_FILESYSTEM_DECL BOOST_SYMBOL_EXPORT +# else +# define BOOST_FILESYSTEM_DECL BOOST_SYMBOL_IMPORT +# endif +#else +# define BOOST_FILESYSTEM_DECL +#endif + +// enable automatic library variant selection ----------------------------------------// + +#if !defined(BOOST_FILESYSTEM_SOURCE) && !defined(BOOST_ALL_NO_LIB) \ + && !defined(BOOST_FILESYSTEM_NO_LIB) +// +// Set the name of our library, this will get undef'ed by auto_link.hpp +// once it's done with it: +// +#define BOOST_LIB_NAME boost_filesystem +// +// If we're importing code from a dll, then tell auto_link.hpp about it: +// +#if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_FILESYSTEM_DYN_LINK) +# define BOOST_DYN_LINK +#endif +// +// And include the header that does the work: +// +#include +#endif // auto-linking disabled + +#endif // BOOST_FILESYSTEM_CONFIG_HPP diff --git a/v3/boost/filesystem/convenience.hpp b/v3/boost/filesystem/convenience.hpp new file mode 100644 index 0000000..47f296a --- /dev/null +++ b/v3/boost/filesystem/convenience.hpp @@ -0,0 +1,52 @@ +// boost/filesystem/convenience.hpp ----------------------------------------// + +// Copyright Beman Dawes, 2002-2005 +// Copyright Vladimir Prus, 2002 +// Use, modification, and distribution is subject to the Boost Software +// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// See library home page at http://www.boost.org/libs/filesystem + +//----------------------------------------------------------------------------// + +#ifndef BOOST_FILESYSTEM_CONVENIENCE_HPP +#define BOOST_FILESYSTEM_CONVENIENCE_HPP + +#include +#include + +#include // must be the last #include + +namespace boost +{ + namespace filesystem + { + +# ifndef BOOST_FILESYSTEM_NO_DEPRECATED + + std::string extension(const path & p) + { + return p.extension().string(); + } + + std::string basename(const path & p) + { + return p.stem().string(); + } + + path change_extension( const path & p, const path & new_extension ) + { + path new_p( p ); + new_p.replace_extension( new_extension ); + return new_p; + } + +# endif + + + } // namespace filesystem +} // namespace boost + +#include // pops abi_prefix.hpp pragmas +#endif // BOOST_FILESYSTEM_CONVENIENCE_HPP diff --git a/v3/boost/filesystem/exception.hpp b/v3/boost/filesystem/exception.hpp new file mode 100644 index 0000000..985cd8f --- /dev/null +++ b/v3/boost/filesystem/exception.hpp @@ -0,0 +1,9 @@ +// boost/filesystem/exception.hpp -----------------------------------------------------// + +// Copyright Beman Dawes 2003 +// Use, modification, and distribution is subject to the Boost Software +// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// This header is no longer used. The contents have been moved to path.hpp. +// It is provided so that user code #includes do not have to be changed. diff --git a/v3/boost/filesystem/fstream.hpp b/v3/boost/filesystem/fstream.hpp new file mode 100644 index 0000000..30afefa --- /dev/null +++ b/v3/boost/filesystem/fstream.hpp @@ -0,0 +1,176 @@ +// boost/filesystem/fstream.hpp ------------------------------------------------------// + +// Copyright Beman Dawes 2002 + +// Distributed under the Boost Software License, Version 1.0. +// See http://www.boost.org/LICENSE_1_0.txt + +// Library home page: http://www.boost.org/libs/filesystem + +//--------------------------------------------------------------------------------------// + +#ifndef BOOST_FILESYSTEM_FSTREAM_HPP +#define BOOST_FILESYSTEM_FSTREAM_HPP + +#include +#include + +#include +#include + +#include // must be the last #include + +// glibc++ doesn't have wchar_t overloads for file stream paths, so on Windows use +// path::string() to get a narrow character c_str() +#if defined(BOOST_WINDOWS_API) && defined(__GLIBCXX__) +# define BOOST_FILESYSTEM_C_STR string().c_str() +#else +# define BOOST_FILESYSTEM_C_STR c_str() +#endif + +namespace boost +{ +namespace filesystem +{ + +//--------------------------------------------------------------------------------------// +// basic_filebuf // +//--------------------------------------------------------------------------------------// + + template < class charT, class traits = std::char_traits > + class basic_filebuf : public std::basic_filebuf + { + private: // disallow copying + basic_filebuf(const basic_filebuf&); + const basic_filebuf& operator=(const basic_filebuf&); + + public: + basic_filebuf() {} + virtual ~basic_filebuf() {} + + basic_filebuf* + open(const path& p, std::ios_base::openmode mode) + { + return std::basic_filebuf::open(p.BOOST_FILESYSTEM_C_STR, mode) + ? this : 0; + } + }; + +//--------------------------------------------------------------------------------------// +// basic_ifstream // +//--------------------------------------------------------------------------------------// + + template < class charT, class traits = std::char_traits > + class basic_ifstream : public std::basic_ifstream + { + private: // disallow copying + basic_ifstream(const basic_ifstream&); + const basic_ifstream& operator=(const basic_ifstream&); + + public: + basic_ifstream() {} + + // use two signatures, rather than one signature with default second + // argument, to workaround VC++ 7.1 bug (ID VSWhidbey 38416) + + explicit basic_ifstream(const path& p) + : std::basic_ifstream(p.BOOST_FILESYSTEM_C_STR, std::ios_base::in) {} + + basic_ifstream(const path& p, std::ios_base::openmode mode) + : std::basic_ifstream(p.BOOST_FILESYSTEM_C_STR, mode) {} + + void open(const path& p) + { std::basic_ifstream::open(p.BOOST_FILESYSTEM_C_STR, std::ios_base::in); } + + void open(const path& p, std::ios_base::openmode mode) + { std::basic_ifstream::open(p.BOOST_FILESYSTEM_C_STR, mode); } + + virtual ~basic_ifstream() {} + }; + +//--------------------------------------------------------------------------------------// +// basic_ofstream // +//--------------------------------------------------------------------------------------// + + template < class charT, class traits = std::char_traits > + class basic_ofstream : public std::basic_ofstream + { + private: // disallow copying + basic_ofstream(const basic_ofstream&); + const basic_ofstream& operator=(const basic_ofstream&); + + public: + basic_ofstream() {} + + // use two signatures, rather than one signature with default second + // argument, to workaround VC++ 7.1 bug (ID VSWhidbey 38416) + + explicit basic_ofstream(const path& p) + : std::basic_ofstream(p.BOOST_FILESYSTEM_C_STR, std::ios_base::out) {} + + basic_ofstream(const path& p, std::ios_base::openmode mode) + : std::basic_ofstream(p.BOOST_FILESYSTEM_C_STR, mode) {} + + void open(const path& p) + { std::basic_ofstream::open(p.BOOST_FILESYSTEM_C_STR, std::ios_base::out); } + + void open(const path& p, std::ios_base::openmode mode) + { std::basic_ofstream::open(p.BOOST_FILESYSTEM_C_STR, mode); } + + virtual ~basic_ofstream() {} + }; + +//--------------------------------------------------------------------------------------// +// basic_fstream // +//--------------------------------------------------------------------------------------// + + template < class charT, class traits = std::char_traits > + class basic_fstream : public std::basic_fstream + { + private: // disallow copying + basic_fstream(const basic_fstream&); + const basic_fstream & operator=(const basic_fstream&); + + public: + basic_fstream() {} + + // use two signatures, rather than one signature with default second + // argument, to workaround VC++ 7.1 bug (ID VSWhidbey 38416) + + explicit basic_fstream(const path& p) + : std::basic_fstream(p.BOOST_FILESYSTEM_C_STR, + std::ios_base::in | std::ios_base::out) {} + + basic_fstream(const path& p, std::ios_base::openmode mode) + : std::basic_fstream(p.BOOST_FILESYSTEM_C_STR, mode) {} + + void open(const path& p) + { std::basic_fstream::open(p.BOOST_FILESYSTEM_C_STR, + std::ios_base::in | std::ios_base::out); } + + void open(const path& p, std::ios_base::openmode mode) + { std::basic_fstream::open(p.BOOST_FILESYSTEM_C_STR, mode); } + + virtual ~basic_fstream() {} + + }; + +//--------------------------------------------------------------------------------------// +// typedefs // +//--------------------------------------------------------------------------------------// + + typedef basic_filebuf filebuf; + typedef basic_ifstream ifstream; + typedef basic_ofstream ofstream; + typedef basic_fstream fstream; + + typedef basic_filebuf wfilebuf; + typedef basic_ifstream wifstream; + typedef basic_fstream wfstream; + typedef basic_ofstream wofstream; + +} // namespace filesystem +} // namespace boost + +#include // pops abi_prefix.hpp pragmas +#endif // BOOST_FILESYSTEM_FSTREAM_HPP diff --git a/v3/boost/filesystem/operations.hpp b/v3/boost/filesystem/operations.hpp new file mode 100644 index 0000000..0025553 --- /dev/null +++ b/v3/boost/filesystem/operations.hpp @@ -0,0 +1,918 @@ +// boost/filesystem/operations.hpp ---------------------------------------------------// + +// Copyright Beman Dawes 2002-2009 +// Copyright Jan Langer 2002 +// Copyright Dietmar Kuehl 2001 +// Copyright Vladimir Prus 2002 + +// Distributed under the Boost Software License, Version 1.0. +// See http://www.boost.org/LICENSE_1_0.txt + +// Library home page: http://www.boost.org/libs/filesystem + +//--------------------------------------------------------------------------------------// + +#ifndef BOOST_FILESYSTEM_OPERATIONS_HPP +#define BOOST_FILESYSTEM_OPERATIONS_HPP + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include // for pair +#include +#include +#include + +#ifdef BOOST_WINDOWS_API +# include +#endif + +#include // must be the last #include + +//--------------------------------------------------------------------------------------// + +namespace boost +{ + namespace filesystem + { + +//--------------------------------------------------------------------------------------// +// // +// support classes and enums // +// // +//--------------------------------------------------------------------------------------// + + enum file_type + { + status_error, +# ifndef BOOST_FILESYSTEM_NO_DEPRECATED + status_unknown = status_error, +# endif + file_not_found, + regular_file, + directory_file, + // the following will never be reported by some operating or file systems + symlink_file, + block_file, + character_file, + fifo_file, + socket_file, + type_unknown // file does exist, but isn't one of the above types or + // we don't have strong enough permission to find its type + }; + + class BOOST_FILESYSTEM_DECL file_status + { + public: + explicit file_status(file_type v = status_error) : m_value(v) {} + + void type(file_type v) { m_value = v; } + file_type type() const { return m_value; } + + bool operator==(const file_status& rhs) const { return type() == rhs.type(); } + bool operator!=(const file_status& rhs) const { return !(*this == rhs); } + + private: + // the internal representation is unspecified so that additional state + // information such as permissions can be added in the future; this + // implementation just uses file_type as the internal representation + + file_type m_value; + }; + + inline bool status_known(file_status f) { return f.type() != status_error; } + inline bool exists(file_status f) { return f.type() != status_error + && f.type() != file_not_found; } + inline bool is_regular_file(file_status f){ return f.type() == regular_file; } + inline bool is_directory(file_status f) { return f.type() == directory_file; } + inline bool is_symlink(file_status f) { return f.type() == symlink_file; } + inline bool is_other(file_status f) { return exists(f) && !is_regular_file(f) + && !is_directory(f) && !is_symlink(f); } + +# ifndef BOOST_FILESYSTEM_NO_DEPRECATED + inline bool is_regular(file_status f) { return f.type() == regular_file; } +# endif + + struct space_info + { + // all values are byte counts + boost::uintmax_t capacity; + boost::uintmax_t free; // <= capacity + boost::uintmax_t available; // <= free + }; + + BOOST_SCOPED_ENUM_START(copy_option) + {fail_if_exists, overwrite_if_exists}; + BOOST_SCOPED_ENUM_END + +//--------------------------------------------------------------------------------------// +// implementation details // +//--------------------------------------------------------------------------------------// + + namespace detail + { + BOOST_FILESYSTEM_DECL + file_status status(const path&p, system::error_code* ec=0); + BOOST_FILESYSTEM_DECL + file_status symlink_status(const path& p, system::error_code* ec=0); + BOOST_FILESYSTEM_DECL + bool is_empty(const path& p, system::error_code* ec=0); + BOOST_FILESYSTEM_DECL + path initial_path(system::error_code* ec=0); + BOOST_FILESYSTEM_DECL + void copy(const path& from, const path& to, system::error_code* ec=0); + BOOST_FILESYSTEM_DECL + void copy_directory(const path& from, const path& to, system::error_code* ec=0); + BOOST_FILESYSTEM_DECL + void copy_file(const path& from, const path& to, + BOOST_SCOPED_ENUM(copy_option) option, // See ticket #2925 + system::error_code* ec=0); + BOOST_FILESYSTEM_DECL + void copy_symlink(const path& from, const path& to, system::error_code* ec=0); + BOOST_FILESYSTEM_DECL + bool create_directories(const path& p, system::error_code* ec=0); + BOOST_FILESYSTEM_DECL + bool create_directory(const path& p, system::error_code* ec=0); + BOOST_FILESYSTEM_DECL + void create_directory_symlink(const path& to, const path& from, + system::error_code* ec=0); + BOOST_FILESYSTEM_DECL + void create_hard_link(const path& to, const path& from, system::error_code* ec=0); + BOOST_FILESYSTEM_DECL + void create_symlink(const path& to, const path& from, system::error_code* ec=0); + BOOST_FILESYSTEM_DECL + path current_path(system::error_code* ec=0); + BOOST_FILESYSTEM_DECL + void current_path(const path& p, system::error_code* ec=0); + BOOST_FILESYSTEM_DECL + bool equivalent(const path& p1, const path& p2, system::error_code* ec=0); + BOOST_FILESYSTEM_DECL + boost::uintmax_t file_size(const path& p, system::error_code* ec=0); + BOOST_FILESYSTEM_DECL + boost::uintmax_t hard_link_count(const path& p, system::error_code* ec=0); + BOOST_FILESYSTEM_DECL + std::time_t last_write_time(const path& p, system::error_code* ec=0); + BOOST_FILESYSTEM_DECL + void last_write_time(const path& p, const std::time_t new_time, + system::error_code* ec=0); + BOOST_FILESYSTEM_DECL + path read_symlink(const path& p, system::error_code* ec=0); + BOOST_FILESYSTEM_DECL + // For standardization, if the committee doesn't like "remove", consider "eliminate" + bool remove(const path& p, system::error_code* ec=0); + BOOST_FILESYSTEM_DECL + boost::uintmax_t remove_all(const path& p, system::error_code* ec=0); + BOOST_FILESYSTEM_DECL + void rename(const path& old_p, const path& new_p, system::error_code* ec=0); + BOOST_FILESYSTEM_DECL + void resize_file(const path& p, uintmax_t size, system::error_code* ec=0); + BOOST_FILESYSTEM_DECL + space_info space(const path& p, system::error_code* ec=0); + BOOST_FILESYSTEM_DECL + path system_complete(const path& p, system::error_code* ec=0); + BOOST_FILESYSTEM_DECL + path unique_path(const path& p, system::error_code* ec=0); + } // namespace detail + +//--------------------------------------------------------------------------------------// +// // +// status query functions // +// // +//--------------------------------------------------------------------------------------// + + inline + file_status status(const path& p) {return detail::status(p);} + inline + file_status status(const path& p, system::error_code& ec) + {return detail::status(p, &ec);} + inline + file_status symlink_status(const path& p) {return detail::symlink_status(p);} + inline + file_status symlink_status(const path& p, system::error_code& ec) + {return detail::symlink_status(p, &ec);} + inline + bool exists(const path& p) {return exists(detail::status(p));} + inline + bool exists(const path& p, system::error_code& ec) + {return exists(detail::status(p, &ec));} + inline + bool is_directory(const path& p) {return is_directory(detail::status(p));} + inline + bool is_directory(const path& p, system::error_code& ec) + {return is_directory(detail::status(p, &ec));} + inline + bool is_regular_file(const path& p) {return is_regular_file(detail::status(p));} + inline + bool is_regular_file(const path& p, system::error_code& ec) + {return is_regular_file(detail::status(p, &ec));} + inline + bool is_other(const path& p) {return is_other(detail::status(p));} + inline + bool is_other(const path& p, system::error_code& ec) + {return is_other(detail::status(p, &ec));} + inline + bool is_symlink(const path& p) {return is_symlink(detail::symlink_status(p));} + inline + bool is_symlink(const path& p, system::error_code& ec) + {return is_symlink(detail::symlink_status(p, &ec));} +# ifndef BOOST_FILESYSTEM_NO_DEPRECATED + inline + bool is_regular(const path& p) {return is_regular(detail::status(p));} + inline + bool is_regular(const path& p, system::error_code& ec) + {return is_regular(detail::status(p, &ec));} +# endif + + inline + bool is_empty(const path& p) {return detail::is_empty(p);} + inline + bool is_empty(const path& p, system::error_code& ec) + {return detail::is_empty(p, &ec);} + +//--------------------------------------------------------------------------------------// +// // +// operational functions // +// in alphabetical order, unless otherwise noted // +// // +//--------------------------------------------------------------------------------------// + +# ifndef BOOST_FILESYSTEM_NO_DEPRECATED + inline + path complete(const path& p) + { + return path(p).make_absolute(detail::initial_path(0)); + } + + inline + path complete(const path& p, const path& base) + { + return path(p).make_absolute(base); + } +# endif + + inline + void copy(const path& from, const path& to) {detail::copy(from, to);} + + inline + void copy(const path& from, const path& to, system::error_code& ec) + {detail::copy(from, to, &ec);} + inline + void copy_directory(const path& from, const path& to) + {detail::copy_directory(from, to);} + inline + void copy_directory(const path& from, const path& to, system::error_code& ec) + {detail::copy_directory(from, to, &ec);} + inline + void copy_file(const path& from, const path& to, // See ticket #2925 + BOOST_SCOPED_ENUM(copy_option) option) + {detail::copy_file(from, to, option);} + inline + void copy_file(const path& from, const path& to) + {detail::copy_file(from, to, copy_option::fail_if_exists);} + inline + void copy_file(const path& from, const path& to, // See ticket #2925 + BOOST_SCOPED_ENUM(copy_option) option, system::error_code& ec) + {detail::copy_file(from, to, option, &ec);} + inline + void copy_file(const path& from, const path& to, system::error_code& ec) + {detail::copy_file(from, to, copy_option::fail_if_exists, &ec);} + inline + void copy_symlink(const path& from, const path& to) {detail::copy_symlink(from, to);} + + inline + void copy_symlink(const path& from, const path& to, system::error_code& ec) + {detail::copy_symlink(from, to, &ec);} + inline + bool create_directories(const path& p) {return detail::create_directories(p);} + + inline + bool create_directories(const path& p, system::error_code& ec) + {return detail::create_directories(p, &ec);} + inline + bool create_directory(const path& p) {return detail::create_directory(p);} + + inline + bool create_directory(const path& p, system::error_code& ec) + {return detail::create_directory(p, &ec);} + inline + void create_directory_symlink(const path& to, const path& from) + {detail::create_directory_symlink(to, from);} + inline + void create_directory_symlink(const path& to, const path& from, system::error_code& ec) + {detail::create_directory_symlink(to, from, &ec);} + inline + void create_hard_link(const path& to, const path& from) {detail::create_hard_link(to, from);} + + inline + void create_hard_link(const path& to, const path& from, system::error_code& ec) + {detail::create_hard_link(to, from, &ec);} + inline + void create_symlink(const path& to, const path& from) {detail::create_symlink(to, from);} + + inline + void create_symlink(const path& to, const path& from, system::error_code& ec) + {detail::create_symlink(to, from, &ec);} + inline + path current_path() {return detail::current_path();} + + inline + path current_path(system::error_code& ec) {return detail::current_path(&ec);} + + inline + void current_path(const path& p) {detail::current_path(p);} + + inline + void current_path(const path& p, system::error_code& ec) {detail::current_path(p, &ec);} + + inline + bool equivalent(const path& p1, const path& p2) {return detail::equivalent(p1, p2);} + + inline + bool equivalent(const path& p1, const path& p2, system::error_code& ec) + {return detail::equivalent(p1, p2, &ec);} + inline + boost::uintmax_t file_size(const path& p) {return detail::file_size(p);} + + inline + boost::uintmax_t file_size(const path& p, system::error_code& ec) + {return detail::file_size(p, &ec);} + inline + boost::uintmax_t hard_link_count(const path& p) {return detail::hard_link_count(p);} + + inline + boost::uintmax_t hard_link_count(const path& p, system::error_code& ec) + {return detail::hard_link_count(p, &ec);} + inline + path initial_path() {return detail::initial_path();} + + inline + path initial_path(system::error_code& ec) {return detail::initial_path(&ec);} + +# ifndef BOOST_FILESYSTEM_NO_DEPRECATED + // support legacy initial_path<...>() + template + path initial_path() {return initial_path();} + template + path initial_path(system::error_code& ec) {return detail::initial_path(&ec);} +# endif + + inline + std::time_t last_write_time(const path& p) {return detail::last_write_time(p);} + + inline + std::time_t last_write_time(const path& p, system::error_code& ec) + {return detail::last_write_time(p, &ec);} + inline + void last_write_time(const path& p, const std::time_t new_time) + {detail::last_write_time(p, new_time);} + inline + void last_write_time(const path& p, const std::time_t new_time, system::error_code& ec) + {detail::last_write_time(p, new_time, &ec);} + inline + path read_symlink(const path& p) {return detail::read_symlink(p);} + + inline + path read_symlink(const path& p, system::error_code& ec) + {return detail::read_symlink(p, &ec);} + inline + // For standardization, if the committee doesn't like "remove", consider "eliminate" + bool remove(const path& p) {return detail::remove(p);} + + inline + bool remove(const path& p, system::error_code& ec) {return detail::remove(p, &ec);} + + inline + boost::uintmax_t remove_all(const path& p) {return detail::remove_all(p);} + + inline + boost::uintmax_t remove_all(const path& p, system::error_code& ec) + {return detail::remove_all(p, &ec);} + inline + void rename(const path& old_p, const path& new_p) {detail::rename(old_p, new_p);} + + inline + void rename(const path& old_p, const path& new_p, system::error_code& ec) + {detail::rename(old_p, new_p, &ec);} + inline // name suggested by Scott McMurray + void resize_file(const path& p, uintmax_t size) {detail::resize_file(p, size);} + + inline + void resize_file(const path& p, uintmax_t size, system::error_code& ec) + {detail::resize_file(p, size, &ec);} + inline + space_info space(const path& p) {return detail::space(p);} + + inline + space_info space(const path& p, system::error_code& ec) {return detail::space(p, &ec);} + +# ifndef BOOST_FILESYSTEM_NO_DEPRECATED + inline bool symbolic_link_exists(const path& p) + { return is_symlink(symlink_status(p)); } +# endif + + inline + path system_complete(const path& p) {return detail::system_complete(p);} + + inline + path system_complete(const path& p, system::error_code& ec) + {return detail::system_complete(p, &ec);} + inline + path unique_path(const path& p="%%%%-%%%%-%%%%-%%%%") + { return detail::unique_path(p); } + inline + path unique_path(const path& p, system::error_code& ec) + { return detail::unique_path(p, &ec); } + +//--------------------------------------------------------------------------------------// +// // +// directory_entry // +// // +//--------------------------------------------------------------------------------------// + +// GCC has a problem with a member function named path within a namespace or +// sub-namespace that also has a class named path. The workaround is to always +// fully qualify the name path when it refers to the class name. + +class BOOST_FILESYSTEM_DECL directory_entry +{ +public: + + // compiler generated copy constructor, copy assignment, and destructor apply + + directory_entry() {} + explicit directory_entry(const boost::filesystem::path& p, + file_status st = file_status(), file_status symlink_st=file_status()) + : m_path(p), m_status(st), m_symlink_status(symlink_st) + {} + + void assign(const boost::filesystem::path& p, + file_status st = file_status(), file_status symlink_st = file_status()) + { m_path = p; m_status = st; m_symlink_status = symlink_st; } + + void replace_filename(const boost::filesystem::path& p, + file_status st = file_status(), file_status symlink_st = file_status()) + { + m_path.remove_filename(); + m_path /= p; + m_status = st; + m_symlink_status = symlink_st; + } + +# ifndef BOOST_FILESYSTEM_NO_DEPRECATED + void replace_leaf(const boost::filesystem::path& p, + file_status st, file_status symlink_st) + { replace_filename(p, st, symlink_st); } +# endif + + const boost::filesystem::path& path() const {return m_path;} + file_status status() const {return m_get_status();} + file_status status(system::error_code& ec) const {return m_get_status(&ec);} + file_status symlink_status() const {return m_get_symlink_status();} + file_status symlink_status(system::error_code& ec) const {return m_get_symlink_status(&ec);} + + bool operator==(const directory_entry& rhs) {return m_path == rhs.m_path;} + bool operator!=(const directory_entry& rhs) {return m_path != rhs.m_path;} + bool operator< (const directory_entry& rhs) {return m_path < rhs.m_path;} + bool operator<=(const directory_entry& rhs) {return m_path <= rhs.m_path;} + bool operator> (const directory_entry& rhs) {return m_path > rhs.m_path;} + bool operator>=(const directory_entry& rhs) {return m_path >= rhs.m_path;} + +private: + boost::filesystem::path m_path; + mutable file_status m_status; // stat()-like + mutable file_status m_symlink_status; // lstat()-like + + file_status m_get_status(system::error_code* ec=0) const; + file_status m_get_symlink_status(system::error_code* ec=0) const; +}; // directory_entry + +//--------------------------------------------------------------------------------------// +// // +// directory_iterator helpers // +// // +//--------------------------------------------------------------------------------------// + +class directory_iterator; + +namespace detail +{ + BOOST_FILESYSTEM_DECL + system::error_code dir_itr_close(// never throws() + void *& handle +# if defined(BOOST_POSIX_API) + , void *& buffer +# endif + ); + + struct dir_itr_imp + { + directory_entry dir_entry; + void* handle; + +# ifdef BOOST_POSIX_API + void* buffer; // see dir_itr_increment implementation +# endif + + dir_itr_imp() : handle(0) +# ifdef BOOST_POSIX_API + , buffer(0) +# endif + {} + + ~dir_itr_imp() // never throws + { + dir_itr_close(handle +# if defined(BOOST_POSIX_API) + , buffer +# endif + ); + } + }; + + // see path::iterator: comment below + BOOST_FILESYSTEM_DECL void directory_iterator_construct(directory_iterator& it, + const path& p, system::error_code* ec); + BOOST_FILESYSTEM_DECL void directory_iterator_increment(directory_iterator& it, + system::error_code* ec); + +} // namespace detail + +//--------------------------------------------------------------------------------------// +// // +// directory_iterator // +// // +//--------------------------------------------------------------------------------------// + + class directory_iterator + : public boost::iterator_facade< directory_iterator, + directory_entry, + boost::single_pass_traversal_tag > + { + public: + + directory_iterator(){} // creates the "end" iterator + + // iterator_facade derived classes don't seem to like implementations in + // separate translation unit dll's, so forward to detail functions + explicit directory_iterator(const path& p) + : m_imp(new detail::dir_itr_imp) + { detail::directory_iterator_construct(*this, p, 0); } + + directory_iterator(const path& p, system::error_code& ec) + : m_imp(new detail::dir_itr_imp) + { detail::directory_iterator_construct(*this, p, &ec); } + + ~directory_iterator() {} // never throws + + directory_iterator& increment(system::error_code& ec) + { + detail::directory_iterator_increment(*this, &ec); + return *this; + } + + private: + friend struct detail::dir_itr_imp; + friend BOOST_FILESYSTEM_DECL void detail::directory_iterator_construct(directory_iterator& it, + const path& p, system::error_code* ec); + friend BOOST_FILESYSTEM_DECL void detail::directory_iterator_increment(directory_iterator& it, + system::error_code* ec); + + // shared_ptr provides shallow-copy semantics required for InputIterators. + // m_imp.get()==0 indicates the end iterator. + boost::shared_ptr< detail::dir_itr_imp > m_imp; + + friend class boost::iterator_core_access; + + boost::iterator_facade< + directory_iterator, + directory_entry, + boost::single_pass_traversal_tag >::reference dereference() const + { + BOOST_ASSERT(m_imp.get() && "attempt to dereference end iterator"); + return m_imp->dir_entry; + } + + void increment() { detail::directory_iterator_increment(*this, 0); } + + bool equal(const directory_iterator& rhs) const + { return m_imp == rhs.m_imp; } + }; + +//--------------------------------------------------------------------------------------// +// // +// recursive_directory_iterator helpers // +// // +//--------------------------------------------------------------------------------------// + + namespace detail + { + struct recur_dir_itr_imp + { + typedef directory_iterator element_type; + std::stack< element_type, std::vector< element_type > > m_stack; + int m_level; + bool m_no_push_request; + + recur_dir_itr_imp() : m_level(0), m_no_push_request(false) {} + + void increment(system::error_code* ec); // ec == 0 means throw on error + + void pop(); + + }; + + // Implementation is inline to avoid dynamic linking difficulties with m_stack: + // Microsoft warning C4251, m_stack needs to have dll-interface to be used by + // clients of struct 'boost::filesystem::detail::recur_dir_itr_imp' + + inline + void recur_dir_itr_imp::increment(system::error_code* ec) + // ec == 0 means throw on error + { + if (m_no_push_request) + { m_no_push_request = false; } + else if (is_directory(m_stack.top()->status())) + { + if (ec == 0) + m_stack.push(directory_iterator(m_stack.top()->path())); + else + { + m_stack.push(directory_iterator(m_stack.top()->path(), *ec)); + if (*ec) return; + } + if (m_stack.top() != directory_iterator()) + { + ++m_level; + return; + } + m_stack.pop(); + } + + while (!m_stack.empty() && ++m_stack.top() == directory_iterator()) + { + m_stack.pop(); + --m_level; + } + } + + inline + void recur_dir_itr_imp::pop() + { + BOOST_ASSERT(m_level > 0 && "pop() on recursive_directory_iterator with level < 1"); + + do + { + m_stack.pop(); + --m_level; + } + while (!m_stack.empty() && ++m_stack.top() == directory_iterator()); + } + } // namespace detail + +//--------------------------------------------------------------------------------------// +// // +// recursive_directory_iterator // +// // +//--------------------------------------------------------------------------------------// + + class recursive_directory_iterator + : public boost::iterator_facade< + recursive_directory_iterator, + directory_entry, + boost::single_pass_traversal_tag > + { + public: + + recursive_directory_iterator(){} // creates the "end" iterator + + explicit recursive_directory_iterator(const path& dir_path) + : m_imp(new detail::recur_dir_itr_imp) + { + m_imp->m_stack.push(directory_iterator(dir_path)); + if (m_imp->m_stack.top() == directory_iterator()) + { m_imp.reset (); } + } + + recursive_directory_iterator(const path& dir_path, + system::error_code & ec) + : m_imp(new detail::recur_dir_itr_imp) + { + m_imp->m_stack.push(directory_iterator(dir_path, ec)); + if (m_imp->m_stack.top() == directory_iterator()) + { m_imp.reset (); } + } + + recursive_directory_iterator& increment(system::error_code* ec) + { + BOOST_ASSERT(m_imp.get() && "increment() on end recursive_directory_iterator"); + m_imp->increment(ec); + return *this; + } + + int level() const + { + BOOST_ASSERT(m_imp.get() && "level() on end recursive_directory_iterator"); + return m_imp->m_level; + } + + bool no_push_request() const + { + BOOST_ASSERT(m_imp.get() && "no_push_request() on end recursive_directory_iterator"); + return m_imp->m_no_push_request; + } + + void pop() + { + BOOST_ASSERT(m_imp.get() && "pop() on end recursive_directory_iterator"); + m_imp->pop(); + if (m_imp->m_stack.empty()) m_imp.reset(); // done, so make end iterator + } + + void no_push() + { + BOOST_ASSERT(m_imp.get() && "no_push() on end recursive_directory_iterator"); + m_imp->m_no_push_request = true; + } + + file_status status() const + { + BOOST_ASSERT(m_imp.get() + && "status() on end recursive_directory_iterator"); + return m_imp->m_stack.top()->status(); + } + + file_status symlink_status() const + { + BOOST_ASSERT(m_imp.get() + && "symlink_status() on end recursive_directory_iterator"); + return m_imp->m_stack.top()->symlink_status(); + } + + private: + + // shared_ptr provides shallow-copy semantics required for InputIterators. + // m_imp.get()==0 indicates the end iterator. + boost::shared_ptr< detail::recur_dir_itr_imp > m_imp; + + friend class boost::iterator_core_access; + + boost::iterator_facade< + recursive_directory_iterator, + directory_entry, + boost::single_pass_traversal_tag >::reference + dereference() const + { + BOOST_ASSERT(m_imp.get() && "dereference of end recursive_directory_iterator"); + return *m_imp->m_stack.top(); + } + + void increment() + { + BOOST_ASSERT(m_imp.get() && "increment of end recursive_directory_iterator"); + m_imp->increment(0); + if (m_imp->m_stack.empty()) m_imp.reset(); // done, so make end iterator + } + + bool equal(const recursive_directory_iterator& rhs) const + { return m_imp == rhs.m_imp; } + + }; + +# if !defined(BOOST_FILESYSTEM_NO_DEPRECATED) + typedef recursive_directory_iterator wrecursive_directory_iterator; +# endif + +//--------------------------------------------------------------------------------------// +// // +// class filesystem_error // +// // +//--------------------------------------------------------------------------------------// + + class filesystem_error : public system::system_error + { + // see http://www.boost.org/more/error_handling.html for design rationale + + // all functions are inline to avoid issues with crossing dll boundaries + + public: + // compiler generates copy constructor and copy assignment + + filesystem_error( + const std::string & what_arg, system::error_code ec) + : system::system_error(ec, what_arg) + { + try + { + m_imp_ptr.reset(new m_imp); + } + catch (...) { m_imp_ptr.reset(); } + } + + filesystem_error( + const std::string & what_arg, const path& path1_arg, + system::error_code ec) + : system::system_error(ec, what_arg) + { + try + { + m_imp_ptr.reset(new m_imp); + m_imp_ptr->m_path1 = path1_arg; + } + catch (...) { m_imp_ptr.reset(); } + } + + filesystem_error( + const std::string & what_arg, const path& path1_arg, + const path& path2_arg, system::error_code ec) + : system::system_error(ec, what_arg) + { + try + { + m_imp_ptr.reset(new m_imp); + m_imp_ptr->m_path1 = path1_arg; + m_imp_ptr->m_path2 = path2_arg; + } + catch (...) { m_imp_ptr.reset(); } + } + + ~filesystem_error() throw() {} + + const path& path1() const + { + static const path empty_path; + return m_imp_ptr.get() ? m_imp_ptr->m_path1 : empty_path ; + } + const path& path2() const + { + static const path empty_path; + return m_imp_ptr.get() ? m_imp_ptr->m_path2 : empty_path ; + } + + const char* what() const throw() + { + if (!m_imp_ptr.get()) + return system::system_error::what(); + + try + { + if (m_imp_ptr->m_what.empty()) + { + m_imp_ptr->m_what = system::system_error::what(); + if (!m_imp_ptr->m_path1.empty()) + { + m_imp_ptr->m_what += ": \""; + m_imp_ptr->m_what += m_imp_ptr->m_path1.string(); + m_imp_ptr->m_what += "\""; + } + if (!m_imp_ptr->m_path2.empty()) + { + m_imp_ptr->m_what += ", \""; + m_imp_ptr->m_what += m_imp_ptr->m_path2.string(); + m_imp_ptr->m_what += "\""; + } + } + return m_imp_ptr->m_what.c_str(); + } + catch (...) + { + return system::system_error::what(); + } + } + + private: + struct m_imp + { + path m_path1; // may be empty() + path m_path2; // may be empty() + std::string m_what; // not built until needed + }; + boost::shared_ptr m_imp_ptr; + }; + +// test helper -----------------------------------------------------------------------// + +// Not part of the documented interface since false positives are possible; +// there is no law that says that an OS that has large stat.st_size +// actually supports large file sizes. + + namespace detail + { + BOOST_FILESYSTEM_DECL bool possible_large_file_size_support(); + } + + } // namespace filesystem +} // namespace boost + + +#include // pops abi_prefix.hpp pragmas +#endif // BOOST_FILESYSTEM_OPERATIONS_HPP diff --git a/v3/boost/filesystem/path.hpp b/v3/boost/filesystem/path.hpp new file mode 100644 index 0000000..05557ee --- /dev/null +++ b/v3/boost/filesystem/path.hpp @@ -0,0 +1,635 @@ +// filesystem path.hpp ---------------------------------------------------------------// + +// Copyright Beman Dawes 2002-2005, 2009 +// Copyright Vladimir Prus 2002 + +// Distributed under the Boost Software License, Version 1.0. +// See http://www.boost.org/LICENSE_1_0.txt + +// Library home page: http://www.boost.org/libs/filesystem + +// path::stem(), extension(), and replace_extension() are based on +// basename(), extension(), and change_extension() from the original +// filesystem/convenience.hpp header by Vladimir Prus. + +#ifndef BOOST_FILESYSTEM_PATH_HPP +#define BOOST_FILESYSTEM_PATH_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include // needed by basic_path inserter and extractor +#include +#include +#include +#include + +#include // must be the last #include + +namespace boost +{ +namespace filesystem +{ + //------------------------------------------------------------------------------------// + // // + // class path // + // // + //------------------------------------------------------------------------------------// + +/* + Why are there no const codecvt_type& arguments? + ------------------------------------------------ + + To hold down the size of the class path interface. Per function codecvt facets + just aren't needed very often in practice. + + An RAII idiom can be used to ensure push/pop behavior as an alternative. + + Note that codecvt() is passed to the path_traits::convert functions, since that + decouples the convert functions from class path. + + const codecvt_type & can be added later, but once added, they can never be removed + since that would break user code. +*/ + + class BOOST_FILESYSTEM_DECL path + { + public: + + // value_type is the character type used by the operating system API to + // represent paths. + +# ifdef BOOST_WINDOWS_API + typedef wchar_t value_type; +# else + typedef char value_type; +# endif + typedef std::basic_string string_type; + typedef path_traits::codecvt_type codecvt_type; + + // ----- character encoding conversions ----- + + // Following the principle of least astonishment, path input arguments + // passed to or obtained from the operating system via objects of + // class path behave as if they were directly passed to or + // obtained from the O/S API, unless conversion is explicitly requested. + // + // POSIX specfies that path strings are passed unchanged to and from the + // API. Note that this is different from the POSIX command line utilities, + // which convert according to a locale. + // + // Thus for POSIX, char strings do not undergo conversion. wchar_t strings + // are converted to/from char using the path locale or, if a conversion + // argument is given, using a conversion object modeled on + // std::wstring_convert. + // + // The path locale, which is global to the thread, can be changed by the + // imbue() function. It is initialized to an implementation defined locale. + // + // For Windows, wchar_t strings do not undergo conversion. char strings + // are converted using the "ANSI" or "OEM" code pages, as determined by + // the AreFileApisANSI() function, or, if a conversion argument is given, + // using a conversion object modeled on std::wstring_convert. + // + // See m_pathname comments for further important rationale. + + // Design alternative; each function can have an additional overload that + // supplies a conversion locale. For example: + // + // template< class ForwardIterator, class WStringConvert > + // path(ForwardIterator begin, ForwardIterator end, + // const std::locale & loc, + // system::error_code & ec = boost::throws()); + // + // This alternative was rejected as too complex for the limited benefits; + // it nearly doubles the size of the interface, and adds a lot of + // implementation and test code, yet would likely be rarely used. The same + // effect can be achieved via the much simpler imbue() mechanism. + + + // TODO: rules needed for operating systems that use / or . + // differently, or format directory paths differently from file paths. + // + // ************************************************************************ + // + // More work needed: How to handle an operating system that may have + // slash characters or dot characters in valid filenames, either because + // it doesn't follow the POSIX standard, or because it allows MBCS + // filename encodings that may contain slash or dot characters. For + // example, ISO/IEC 2022 (JIS) encoding which allows switching to + // JIS x0208-1983 encoding. A valid filename in this set of encodings is + // 0x1B 0x24 0x42 [switch to X0208-1983] 0x24 0x2F [U+304F Kiragana letter KU] + // ^^^^ + // Note that 0x2F is the ASCII slash character + // + // ************************************************************************ + + // Supported source arguments: half-open iterator range, container, c-array, + // and single pointer to null terminated string. + + // All source arguments except pointers to null terminated byte strings support + // multi-byte character strings which may have embedded nulls. Embedded null + // support is required for some Asian languages on Windows. + + // ----- constructors ----- + + path(){} + + path(const path& p) : m_pathname(p.m_pathname) {} + + template + path(InputIterator begin, InputIterator end) + { + if (begin != end) + { + std::basic_string::value_type> + s(begin, end); + path_traits::convert(s.c_str(), s.c_str()+s.size(), m_pathname, codecvt()); + } + } + + template + path(Source const& source) + { + path_traits::dispatch(source, m_pathname, codecvt()); + } + + // ----- assignments ----- + + path& operator=(const path& p) + { + m_pathname = p.m_pathname; + return *this; + } + + template + path& assign(InputIterator begin, InputIterator end) + { + m_pathname.clear(); + if (begin != end) + { + std::basic_string::value_type> + s(begin, end); + path_traits::convert(s.c_str(), s.c_str()+s.size(), m_pathname, codecvt()); + } + return *this; + } + + template + path& operator=(Source const& source) + { + m_pathname.clear(); + path_traits::dispatch(source, m_pathname, codecvt()); + return *this; + } + + // ----- appends ----- + + // if a separator is added, it is the preferred separator for the platform; + // slash for POSIX, backslash for Windows + + path& operator/=(const path& p); + + template + path& append(InputIterator begin, InputIterator end); + + template + path& operator/=(Source const& source); + + // ----- modifiers ----- + + void clear() { m_pathname.clear(); } + path& make_absolute(const path& base); + path& make_preferred() +# ifdef BOOST_POSIX_API + { return *this; } // POSIX no effect +# else // BOOST_WINDOWS_API + ; // change slashes to backslashes +# endif + path& remove_filename(); + path& replace_extension(const path& new_extension = path()); + void swap(path& rhs) { m_pathname.swap(rhs.m_pathname); } + + // ----- observers ----- + + // For operating systems that format file paths differently than directory + // paths, return values from observers are formatted as file names unless there + // is a trailing separator, in which case returns are formatted as directory + // paths. POSIX and Windows make no such distinction. + + // Implementations are permitted to return const values or const references. + + // The string or path returned by an observer are specified as being formatted + // as "native" or "generic". + // + // For POSIX, these are all the same format; slashes and backslashes are as input and + // are not modified. + // + // For Windows, native: as input; slashes and backslashes are not modified; + // this is the format of the internally stored string. + // generic: backslashes are converted to slashes + + // ----- native format observers ----- + + const string_type& native() const { return m_pathname; } // Throws: nothing + const value_type* c_str() const { return m_pathname.c_str(); } // Throws: nothing + + template + String string() const; + +# ifdef BOOST_WINDOWS_API + const std::string string() const; + const std::wstring& wstring() const { return m_pathname; } + +# else // BOOST_POSIX_API + const std::string& string() const { return m_pathname; } + const std::wstring wstring() const + { + std::wstring tmp; + if (!m_pathname.empty()) + path_traits::convert(&*m_pathname.begin(), &*m_pathname.begin()+m_pathname.size(), + tmp, codecvt()); + return tmp; + } + +# endif + + // ----- generic format observers ----- + + template + String generic_string() const; + +# ifdef BOOST_WINDOWS_API + const std::string generic_string() const; + const std::wstring generic_wstring() const; + +# else // BOOST_POSIX_API + const std::string& generic_string() const { return m_pathname; } + const std::wstring generic_wstring() const { return wstring(); } + +# endif + + // ----- decomposition ----- + + path root_path() const; + path root_name() const; // returns 0 or 1 element path + // even on POSIX, root_name() is non-empty() for network paths + path root_directory() const; // returns 0 or 1 element path + path relative_path() const; + path parent_path() const; + path filename() const; // returns 0 or 1 element path + path stem() const; // returns 0 or 1 element path + path extension() const; // returns 0 or 1 element path + + // ----- query ----- + + bool empty() const { return m_pathname.empty(); } // name consistent with std containers + bool has_root_path() const { return has_root_directory() || has_root_name(); } + bool has_root_name() const { return !root_name().empty(); } + bool has_root_directory() const { return !root_directory().empty(); } + bool has_relative_path() const { return !relative_path().empty(); } + bool has_parent_path() const { return !parent_path().empty(); } + bool has_filename() const { return !m_pathname.empty(); } + bool has_stem() const { return !stem().empty(); } + bool has_extension() const { return !extension().empty(); } + bool is_absolute() const + { +# ifdef BOOST_WINDOWS_API + return has_root_name() && has_root_directory(); +# else + return has_root_directory(); +# endif + } + bool is_relative() const { return !is_absolute(); } + + // ----- imbue ----- + + static std::locale imbue(const std::locale & loc); + + // ----- codecvt ----- + + static const codecvt_type & codecvt() + { + return *wchar_t_codecvt_facet(); + } + + // ----- iterators ----- + + class iterator; + typedef iterator const_iterator; + + iterator begin() const; + iterator end() const; + + // ----- deprecated functions ----- + +# if defined(BOOST_FILESYSTEM_DEPRECATED) && defined(BOOST_FILESYSTEM_NO_DEPRECATED) +# error both BOOST_FILESYSTEM_DEPRECATED and BOOST_FILESYSTEM_NO_DEPRECATED are defined +# endif + +# if !defined(BOOST_FILESYSTEM_NO_DEPRECATED) + // recently deprecated functions supplied by default + path& normalize() { return m_normalize(); } + path& remove_leaf() { return remove_filename(); } + path leaf() const { return filename(); } + path branch_path() const { return parent_path(); } + bool has_leaf() const { return !m_pathname.empty(); } + bool has_branch_path() const { return !parent_path().empty(); } + bool is_complete() const { return is_absolute(); } +# endif + +# if defined(BOOST_FILESYSTEM_DEPRECATED) + // deprecated functions with enough signature or semantic changes that they are + // not supplied by default + const std::string file_string() const { return string(); } + const std::string directory_string() const { return string(); } + const std::string native_file_string() const { return string(); } + const std::string native_directory_string() const { return string(); } + const string_type external_file_string() const { return native(); } + const string_type external_directory_string() const { return native(); } + + // older functions no longer supported + //typedef bool (*name_check)(const std::string & name); + //basic_path(const string_type& str, name_check) { operator/=(str); } + //basic_path(const typename string_type::value_type* s, name_check) + // { operator/=(s);} + //static bool default_name_check_writable() { return false; } + //static void default_name_check(name_check) {} + //static name_check default_name_check() { return 0; } + //basic_path& canonize(); +# endif + +//--------------------------------------------------------------------------------------// +// class path private members // +//--------------------------------------------------------------------------------------// + + private: +# if defined(_MSC_VER) +# pragma warning(push) // Save warning settings +# pragma warning(disable : 4251) // disable warning: class 'std::basic_string<_Elem,_Traits,_Ax>' +# endif // needs to have dll-interface... +/* + m_pathname has the type, encoding, and format required by the native + operating system. Thus for POSIX and Windows there is no conversion for + passing m_pathname.c_str() to the O/S API or when obtaining a path from the + O/S API. POSIX encoding is unspecified other than for dot and slash + characters; POSIX just treats paths as a sequence of bytes. Windows + encoding is UCS-2 or UTF-16 depending on the version. +*/ + string_type m_pathname; // Windows: as input; backslashes NOT converted to slashes, + // slashes NOT converted to backslashes +# if defined(_MSC_VER) +# pragma warning(pop) // restore warning settings. +# endif + + string_type::size_type m_append_separator_if_needed(); + // Returns: If separator is to be appended, m_pathname.size() before append. Otherwise 0. + // Note: An append is never performed if size()==0, so a returned 0 is unambiguous. + + void m_erase_redundant_separator(string_type::size_type sep_pos); + string_type::size_type m_parent_path_end() const; + void m_portable(); + + path& m_normalize(); + + // Was qualified; como433beta8 reports: + // warning #427-D: qualified name is not allowed in member declaration + friend class iterator; + friend bool operator<(const path& lhs, const path& rhs); + + // see path::iterator::increment/decrement comment below + static void m_path_iterator_increment(path::iterator & it); + static void m_path_iterator_decrement(path::iterator & it); + + static const codecvt_type *& wchar_t_codecvt_facet(); + + }; // class path + +# if defined(BOOST_FILESYSTEM_DEPRECATED) + typedef path wpath; +# endif + + //------------------------------------------------------------------------------------// + // class path::iterator // + //------------------------------------------------------------------------------------// + + class path::iterator + : public boost::iterator_facade< + iterator, + path const, + boost::bidirectional_traversal_tag > + { + private: + friend class boost::iterator_core_access; + friend class boost::filesystem::path; + friend void m_path_iterator_increment(path::iterator & it); + friend void m_path_iterator_decrement(path::iterator & it); + + const path& dereference() const { return m_element; } + + bool equal(const iterator & rhs) const + { + return m_path_ptr == rhs.m_path_ptr && m_pos == rhs.m_pos; + } + + // iterator_facade derived classes don't seem to like implementations in + // separate translation unit dll's, so forward to class path static members + void increment() { m_path_iterator_increment(*this); } + void decrement() { m_path_iterator_decrement(*this); } + + path m_element; // current element + const path * m_path_ptr; // path being iterated over + string_type::size_type m_pos; // position of name in + // m_path_ptr->m_pathname. The + // end() iterator is indicated by + // m_pos == m_path_ptr->m_pathname.size() + }; // path::iterator + + //------------------------------------------------------------------------------------// + // // + // class scoped_path_locale // + // // + //------------------------------------------------------------------------------------// + + class scoped_path_locale + { + public: + scoped_path_locale(const std::locale & loc) + : m_saved_locale(loc) + { + path::imbue(loc); + } + + ~scoped_path_locale() // never throws() + { + try { path::imbue(m_saved_locale); } + catch (...) {} + }; + + private: + std::locale m_saved_locale; + }; + + //------------------------------------------------------------------------------------// + // // + // non-member functions // + // // + //------------------------------------------------------------------------------------// + + // std::lexicographical_compare would infinately recurse because path iterators + // yield paths, so provide a path aware version + inline bool lexicographical_compare(path::iterator first1, path::iterator last1, + path::iterator first2, path::iterator last2) + { + for (; first1 != last1 && first2 != last2 ; ++first1, ++first2) + { + if (first1->native() < first2->native()) return true; + if (first2->native() < first1->native()) return false; + } + return first1 == last1 && first2 != last2; + } + + inline bool operator<(const path& lhs, const path& rhs) + { + return lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end()); + } + + inline bool operator<=(const path& lhs, const path& rhs) { return !(rhs < lhs); } + inline bool operator> (const path& lhs, const path& rhs) { return rhs < lhs; } + inline bool operator>=(const path& lhs, const path& rhs) { return !(lhs < rhs); } + + // equality operators act as if comparing generic format strings, to achieve the + // effect of lexicographical_compare element by element compare. + // operator==() efficiency is a concern; a user reported the original version 2 + // !(lhs < rhs) && !(rhs < lhs) implementation caused a serious performance problem + // for a map of 10,000 paths. + +# ifdef BOOST_WINDOWS_API + inline bool operator==(const path& lhs, const path::value_type* rhs) + { + const path::value_type* l(lhs.c_str()); + while ((*l == *rhs || (*l == L'\\' && *rhs == L'/') || (*l == L'/' && *rhs == L'\\')) + && *l) { ++l; ++rhs; } + return *l == *rhs || (*l == L'\\' && *rhs == L'/') || (*l == L'/' && *rhs == L'\\'); + } + inline bool operator==(const path& lhs, const path& rhs) { return lhs == rhs.c_str(); } + inline bool operator==(const path& lhs, const path::string_type& rhs) { return lhs == rhs.c_str(); } + inline bool operator==(const path::string_type& lhs, const path& rhs) { return rhs == lhs.c_str(); } + inline bool operator==(const path::value_type* lhs, const path& rhs) { return rhs == lhs; } +# else // BOOST_POSIX_API + inline bool operator==(const path& lhs, const path& rhs) { return lhs.native() == rhs.native(); } + inline bool operator==(const path& lhs, const path::string_type& rhs) { return lhs.native() == rhs; } + inline bool operator==(const path& lhs, const path::value_type* rhs) { return lhs.native() == rhs; } + inline bool operator==(const path::string_type& lhs, const path& rhs) { return lhs == rhs.native(); } + inline bool operator==(const path::value_type* lhs, const path& rhs) { return lhs == rhs.native(); } +# endif + + inline bool operator!=(const path& lhs, const path& rhs) { return !(lhs == rhs); } + inline bool operator!=(const path& lhs, const path::string_type& rhs) { return !(lhs == rhs); } + inline bool operator!=(const path& lhs, const path::value_type* rhs) { return !(lhs == rhs); } + inline bool operator!=(const path::string_type& lhs, const path& rhs) { return !(lhs == rhs); } + inline bool operator!=(const path::value_type* lhs, const path& rhs) { return !(lhs == rhs); } + + inline void swap(path& lhs, path& rhs) { lhs.swap(rhs); } + + inline path operator/(const path& lhs, const path& rhs) { return path(lhs) /= rhs; } + + // inserters and extractors + + inline std::ostream& operator<<(std::ostream & os, const path& p) + { + os << p.string(); + return os; + } + + inline std::wostream& operator<<(std::wostream & os, const path& p) + { + os << p.wstring(); + return os; + } + + inline std::istream& operator>>(std::istream & is, path& p) + { + std::string str; + is >> str; + p = str; + return is; + } + + inline std::wistream& operator>>(std::wistream & is, path& p) + { + std::wstring str; + is >> str; + p = str; + return is; + } + + // name_checks + + BOOST_FILESYSTEM_DECL bool portable_posix_name(const std::string & name); + BOOST_FILESYSTEM_DECL bool windows_name(const std::string & name); + BOOST_FILESYSTEM_DECL bool portable_name(const std::string & name); + BOOST_FILESYSTEM_DECL bool portable_directory_name(const std::string & name); + BOOST_FILESYSTEM_DECL bool portable_file_name(const std::string & name); + BOOST_FILESYSTEM_DECL bool native(const std::string & name); + +//--------------------------------------------------------------------------------------// +// class path member template implementation // +//--------------------------------------------------------------------------------------// + + template + path& path::append(InputIterator begin, InputIterator end) + { + if (begin == end) + return *this; + string_type::size_type sep_pos(m_append_separator_if_needed()); + std::basic_string::value_type> + s(begin, end); + path_traits::convert(s.c_str(), s.c_str()+s.size(), m_pathname, codecvt()); + if (sep_pos) + m_erase_redundant_separator(sep_pos); + return *this; + } + + template + path& path::operator/=(Source const & source) + { + if (path_traits::empty(source)) + return *this; + string_type::size_type sep_pos(m_append_separator_if_needed()); + path_traits::dispatch(source, m_pathname, codecvt()); + if (sep_pos) + m_erase_redundant_separator(sep_pos); + return *this; + } + +//--------------------------------------------------------------------------------------// +// class path member template specializations // +//--------------------------------------------------------------------------------------// + + template <> inline + std::string path::string() const { return string(); } + + template <> inline + std::wstring path::string() const { return wstring(); } + + template <> inline + std::string path::generic_string() const { return generic_string(); } + + template <> inline + std::wstring path::generic_string() const { return generic_wstring(); } + + +} // namespace filesystem +} // namespace boost + +#include // pops abi_prefix.hpp pragmas + +#endif // BOOST_FILESYSTEM_PATH_HPP diff --git a/v3/boost/filesystem/path_traits.hpp b/v3/boost/filesystem/path_traits.hpp new file mode 100644 index 0000000..ee6682b --- /dev/null +++ b/v3/boost/filesystem/path_traits.hpp @@ -0,0 +1,204 @@ +// filesystem path_traits.hpp --------------------------------------------------------// + +// Copyright Beman Dawes 2009 + +// Distributed under the Boost Software License, Version 1.0. +// See http://www.boost.org/LICENSE_1_0.txt + +// Library home page: http://www.boost.org/libs/filesystem + +#ifndef BOOST_FILESYSTEM_PATH_TRAITS_HPP +#define BOOST_FILESYSTEM_PATH_TRAITS_HPP + +#include +#include +#include +#include +#include +#include +// #include //**** comment me out **** + +#include // must be the last #include + +namespace boost { namespace filesystem { + + BOOST_FILESYSTEM_DECL const system::error_category& codecvt_error_category(); + // uses std::codecvt_base::result used for error codes: + // + // ok: Conversion successful. + // partial: Not all source characters converted; one or more additional source + // characters are needed to produce the final target character, or the + // size of the target intermediate buffer was too small to hold the result. + // error: A character in the source could not be converted to the target encoding. + // noconv: The source and target characters have the same type and encoding, so no + // conversion was necessary. + + class directory_entry; + +namespace path_traits { + + typedef std::codecvt codecvt_type; + + // Pathable empty + + template inline + bool empty(const Container & c) + { return c.begin() == c.end(); } + + template inline + bool empty(T * const & c_str) + { + BOOST_ASSERT(c_str); + return !*c_str; + } + + template inline + bool empty(T (&)[N]) + { return N <= 1; } + + // Source dispatch + + // contiguous containers + template inline + void dispatch(const std::string& c, U& to, const codecvt_type& cvt) + { + if (c.size()) + convert(&*c.begin(), &*c.begin() + c.size(), to, cvt); + } + template inline + void dispatch(const std::wstring& c, U& to, const codecvt_type& cvt) + { + if (c.size()) + convert(&*c.begin(), &*c.begin() + c.size(), to, cvt); + } + template inline + void dispatch(const std::vector& c, U& to, const codecvt_type& cvt) + { + if (c.size()) + convert(&*c.begin(), &*c.begin() + c.size(), to, cvt); + } + template inline + void dispatch(const std::vector& c, U& to, const codecvt_type& cvt) + { + if (c.size()) + convert(&*c.begin(), &*c.begin() + c.size(), to, cvt); + } + + // non-contiguous containers + template inline + void dispatch(const Container & c, U& to, const codecvt_type& cvt) + { + if (c.size()) + { + std::basic_string s(c.begin(), c.end()); + convert(s.c_str(), s.c_str()+s.size(), to, cvt); + } + } + + // c_str + template inline + void dispatch(T * const & c_str, U& to, const codecvt_type& cvt) + { +// std::cout << "dispatch() const T *\n"; + BOOST_ASSERT(c_str); + convert(c_str, to, cvt); + } + + // C-style array + template inline + void dispatch(T (&array)[N], U& to, const codecvt_type& cvt) // T, N, U deduced + { +// std::cout << "dispatch() array, N=" << N << "\n"; + convert(array, array + N - 1, to, cvt); + } + + BOOST_FILESYSTEM_DECL + void dispatch(const directory_entry & de, +# ifdef BOOST_WINDOWS_API + std::wstring & to, +# else + std::string & to, +# endif + const codecvt_type&); + + // value types differ ---------------------------------------------------------------// + // + // A from_end argument of 0 is less efficient than a known end, so use only if needed + + BOOST_FILESYSTEM_DECL + void convert(const char* from, + const char* from_end, // 0 for null terminated MBCS + std::wstring & to, + const codecvt_type& cvt); + + BOOST_FILESYSTEM_DECL + void convert(const wchar_t* from, + const wchar_t* from_end, // 0 for null terminated MBCS + std::string & to, + const codecvt_type& cvt); + + inline + void convert(const char* from, + std::wstring & to, + const codecvt_type& cvt) + { + BOOST_ASSERT(from); + convert(from, 0, to, cvt); + } + + inline + void convert(const wchar_t* from, + std::string & to, + const codecvt_type& cvt) + { + BOOST_ASSERT(from); + convert(from, 0, to, cvt); + } + + // value types same -----------------------------------------------------------------// + + // char + + inline + void convert(const char* from, const char* from_end, std::string & to, + const codecvt_type&) + { + BOOST_ASSERT(from); + BOOST_ASSERT(from_end); + to.append(from, from_end); + } + + inline + void convert(const char* from, + std::string & to, + const codecvt_type&) + { + BOOST_ASSERT(from); + to += from; + } + + // wchar_t + + inline + void convert(const wchar_t* from, const wchar_t* from_end, std::wstring & to, + const codecvt_type&) + { + BOOST_ASSERT(from); + BOOST_ASSERT(from_end); + to.append(from, from_end); + } + + inline + void convert(const wchar_t* from, + std::wstring & to, + const codecvt_type&) + { + BOOST_ASSERT(from); + to += from; + } + +}}} // namespace boost::filesystem::path_traits + +#include // pops abi_prefix.hpp pragmas + +#endif // BOOST_FILESYSTEM_PATH_TRAITS_HPP diff --git a/v3/libs/filesystem/build/Jamfile.v2 b/v3/libs/filesystem/build/Jamfile.v2 new file mode 100644 index 0000000..c35cbbb --- /dev/null +++ b/v3/libs/filesystem/build/Jamfile.v2 @@ -0,0 +1,32 @@ +# Boost Filesystem Library Build Jamfile + +# (C) Copyright Beman Dawes 2002-2006 +# Distributed under the Boost Software License, Version 1.0. +# (See accompanying file LICENSE_1_0.txt or www.boost.org/LICENSE_1_0.txt) + + +# See library home page at http://www.boost.org/libs/filesystem + +project boost/filesystem + : source-location ../src + : usage-requirements # pass these requirement to dependents (i.e. users) + shared:BOOST_FILESYSTEM_DYN_LINK=1 + ; + +SOURCES = + operations path path_traits portability unique_path utf8_codecvt_facet windows_file_codecvt codecvt_error_category ; + +lib boost_filesystem + : $(SOURCES).cpp ../../system/build//boost_system + : shared:BOOST_FILESYSTEM_DYN_LINK=1 # tell source we're building dll's + : + : # Boost.Filesystem uses some of Boost.System functions in inlined/templated + # functions, so clients that use Boost.Filesystem will have direct references + # to Boost.System symbols. On Windows, Darwin, and some other platforms, this + # means those clients have to be directly linked to Boost.System. For static + # linking this happens anyway, but for shared we need to make it happen. Since + # doing so is harmless even when not needed, we do it for all platforms. + shared:../../system/build//boost_system + ; + +boost-install boost_filesystem ; \ No newline at end of file diff --git a/v3/libs/filesystem/doc/Jamfile.v2 b/v3/libs/filesystem/doc/Jamfile.v2 new file mode 100644 index 0000000..4de58f5 --- /dev/null +++ b/v3/libs/filesystem/doc/Jamfile.v2 @@ -0,0 +1,19 @@ +# Boost Filesystem Library Example Jamfile + +# Copyright Beman Dawes 2010 + +# Distributed under the Boost Software License, Version 1.0. +# See www.boost.org/LICENSE_1_0.txt + +# Library home page: http://www.boost.org/libs/filesystem + +project + : requirements + /boost/filesystem//boost_filesystem + /boost/system//boost_system + msvc:on + static + ; + +exe path_table : path_table.cpp ; +install path_table-copy : path_table : . ; \ No newline at end of file diff --git a/v3/libs/filesystem/doc/POSIX_filename_encoding.txt b/v3/libs/filesystem/doc/POSIX_filename_encoding.txt new file mode 100644 index 0000000..14c45c0 --- /dev/null +++ b/v3/libs/filesystem/doc/POSIX_filename_encoding.txt @@ -0,0 +1,55 @@ +http://www.linuxfromscratch.org/blfs/view/svn/introduction/locale-issues.html + +"The POSIX standard mandates that the filename encoding is the encoding implied by the current LC_CTYPE locale category." + +------- + +http://mail.nl.linux.org/linux-utf8/2001-02/msg00103.html + +From: Markus Kuhn + +Tom Tromey wrote on 2001-02-05 00:36 UTC: +> Kai> IMAO, a *real* filesystem should use some encoding of ISO 10646 - +> Kai> UTF-8, UTF-16, or UTF-32 are all viable options. The same should +> Kai> be true for the kernel filename interfaces. +> +> I like this, but what should I do right now? + +The POSIX kernel file system interface is engraved into stone and +extremely unlikely to change. File names are arbitrary binary strings, +with only the '/' and '\0' bytes having any special semantics. You can +use arbitrary coded character sets on it as long as they do not +introduce '/' and '\0' bytes spuriously. Writers and readers have to +somehow agree on what encoding to use and the only really practical way +is to use the same encoding on all systems that share files. Eventually, +everyone will be using UTF-8 for file names on POSIX systems. Right now, +I would recommend users to use only ASCII for filenames, as this is +already UTF-8 and therefore simplifies migration. Using the ISO 8859, +JIS, etc. filenames should soon be considered deprecated practice. + +> I work on libgcj, the runtime component of gcj, the Java front end to +> GCC. In libgcj of course we use UCS-2 everywhere, since that is what +> Java does. Currently, for Unixy systems, we assume that all file +> names are UTF-8. + +The best solution is to assume that the file names are in the +locale-specific multi-byte encoding. Simply use mbrtowc and wcrtomb to +convert between Unicode and the locale-dependent multi-byte encoding +used in file names and text files if the ISO C 99 symbol +__STDC_ISO_10646__ is defined (which guarantees that wchar_t = UCS). On +Linux, this has been the case since glibc 2.2. + +> (Actually, we do something notably worse, which is +> assume that file names are Java-style UTF-8, with the weird encoding +> for \u0000.) + +\u0000 = NUL was never a character allowed in filenames under POSIX. +Raise an exception if someone tries to use it in a filename. Problem +solved. + +I never understood, why Java found it necessary to introduce two +distinct ASCII NUL characters. + +------ + +Interesting idea. Use iconv to create shift-jis or other mbcs test cases. diff --git a/v3/libs/filesystem/doc/boost.png b/v3/libs/filesystem/doc/boost.png new file mode 100644 index 0000000..b4d51fc Binary files /dev/null and b/v3/libs/filesystem/doc/boost.png differ diff --git a/v3/libs/filesystem/doc/deprecated.html b/v3/libs/filesystem/doc/deprecated.html new file mode 100644 index 0000000..3ad8517 --- /dev/null +++ b/v3/libs/filesystem/doc/deprecated.html @@ -0,0 +1,208 @@ + + + + + + + +Filesystem Deprecated Features + + + + + + + + + + +
+ +boost.png (6897 bytes) + Filesystem Deprecated Features +
+ + + + +
Boost Home    + Library Home    + Reference    + Tutorial    + FAQ    + Portability    + V3 Intro    + V3 Design    + Deprecated    +
+ +

Deprecated names and features

+

As the library evolves over time, names sometimes +change or features are removed. To ease transition, Boost.Filesystem deprecates +the old names and features, but continues to provide them unless macro +BOOST_FILESYSTEM_NO_DEPRECATED is defined.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Component +

Old name, now deprecated

 +

New name

basic_pathleaf()filename()
basic_pathbranch_path()parent_path()
basic_pathhas_leaf()has_filename()
basic_pathhas_branch_path()has_parent_path()
+ basic_path +

remove_leaf()

 +

remove_filename()

+ basic_path + basic_path( const string_type & str,
+  name_check )		 + feature removed
+ basic_path + basic_path( const string_type::value_type * s,
+  name_check )		 + feature removed
+ basic_path + native_file_string() + file_string()
+ basic_path + native_directory_string() + directory_string()
+ basic_path + default_name_check_writable() + feature removed
+ basic_path + default_name_check( name_check ) + feature removed
+ basic_path + default_name_check() + feature removed
+ basic_path + canonize() + feature removed
+ basic_path + normalize() + feature removed
+ operations.hpp + is_regular( file_status f ) + is_regular_file( file_status f )
+ operations.hpp + symbolic_link_exists( const path & ph ) + feature removed
+ basic_directory_status + filename() + feature removed, use path().filename() instead
+ basic_directory_status + leaf() + feature removed, use path().filename() instead
+ basic_directory_status + string() + feature removed, use path().string() instead
+ +
+

Revised +17 February, 2010

+ +

© Copyright Beman Dawes, 2002-2005, 2010

+

Use, modification, and distribution are subject to the Boost Software +License, Version 1.0. See +www.boost.org/LICENSE_1_0.txt

+ + + + \ No newline at end of file diff --git a/v3/libs/filesystem/doc/design.htm b/v3/libs/filesystem/doc/design.htm new file mode 100644 index 0000000..9655d1d --- /dev/null +++ b/v3/libs/filesystem/doc/design.htm @@ -0,0 +1,353 @@ + + + + + + + +Boost Filesystem Library Design + + + + + +

+Filesystem +Library Design

+ +

Introduction
+Requirements
+Realities
+Rationale
+Abandoned_Designs
+References

+ +

Introduction

+ +

The primary motivation for beginning work on the Filesystem Library was +frustration with Boost administrative tools.  Scripts were written in +Python, Perl, Bash, and Windows command languages.  There was no single +scripting language familiar and acceptable to all Boost administrators. Yet they +were all skilled C++ programmers - why couldn't C++ be used as the scripting +language?

+ +

The key feature C++ lacked for script-like applications was the ability to +perform portable filesystem operations on directories and their contents. The +Filesystem Library was developed to fill that void.

+ +

The intent is not to compete with traditional scripting languages, but to +provide a solution for situations where C++ is already the language +of choice..

+ +

Requirements

+
    +
  • Be able to write portable script-style filesystem operations in modern + C++.
    +
    + Rationale: This is a common programming need. It is both an + embarrassment and a hardship that this is not possible with either the current + C++ or Boost libraries.  The need is particularly acute + when C++ is the only toolset allowed in the tool chain.  File system + operations are provided by many languages used on multiple platforms, + such as Perl and Python, as well as by many platform specific scripting + languages. All operating systems provide some form of API for filesystem + operations, and the POSIX bindings are increasingly available even on + operating systems not normally associated with POSIX, such as the Mac, z/OS, + or OS/390.
    + 
    • +
  • Work within the realities described below.
    +
    + Rationale: This isn't a research project. The need is for something that works on + today's platforms, including some of the embedded operating systems + with limited file systems. Because of the emphasis on portability, such a + library would be much more useful if standardized. That means being able to + work with a much wider range of platforms that just Unix or Windows and their + clones.
    + 
    • +
  • Avoid dangerous programming practices. Particularly, all-too-easy-to-ignore error notifications + and use of global variables. If a dangerous feature is provided, identify it as such.
    +
    + Rationale: Normally this would be covered by "the usual Boost requirements...", + but it is mentioned explicitly because the equivalent native platform and + scripting language interfaces often depend on all-too-easy-to-ignore error + notifications and global variables like "current + working directory".
    + 
    • +
  • Structure the library so that it is still useful even if some functionality + does not map well onto a given platform or directory tree. Particularly, much + useful functionality should be portable even to flat +(non-hierarchical) filesystems.
    +
    + Rationale: Much functionality which does not + require a hierarchical directory structure is still useful on flat-structure + filesystems.  There are many systems, particularly embedded systems, + where even very limited functionality is still useful.
    • +
+
    +
  • Interface smoothly with current C++ Standard Library input/output + facilities.  For example, paths should be + easy to use in std::basic_fstream constructors.
    +
    + Rationale: One of the most common uses of file system functionality is to + manipulate paths for eventual use in input/output operations.  + Thus the need to interface smoothly with standard library I/O.
    + 
    • +
  • Suitable for eventual standardization. The implication of this requirement + is that the interface be close to minimal, and that great care be take + regarding portability.
    +
    + Rationale: The lack of file system operations is a serious hole + in the current standard, with no other known candidates to fill that hole. + Libraries with elaborate interfaces and difficult to port specifications are much less likely to be accepted for + standardization.
    + 
    • +
  • The usual Boost requirements and + guidelines apply.
    + 
    • +
  • Encourage, but do not require, portability in path names.
    +
    + Rationale: For paths which originate from user input it is unreasonable to + require portable path syntax.
    + 
    • +
  • Avoid giving the illusion of portability where portability in fact does not + exist.
    +
    + Rationale: Leaving important behavior unspecified or "implementation defined" does a + great disservice to programmers using a library because it makes it appear + that code relying on the behavior is portable, when in fact there is nothing + portable about it. The only case where such under-specification is acceptable is when both users and implementors know from + other sources exactly what behavior is required, yet for some reason it isn't + possible to specify it exactly.
    • +
+

Realities

+
    +
  • Some operating systems have a single directory tree root, others have + multiple roots.
    + 
    • +
  • Some file systems provide both a long and short form of filenames.
    + 
    • +
  • Some file systems have different syntax for file paths and directory + paths.
    + 
    • +
  • Some file systems have different rules for valid file names and valid + directory names.
    + 
    • +
  • Some file systems (ISO-9660, level 1, for example) use very restricted + (so-called 8.3) file names.
    + 
    • +
  • Some operating systems allow file systems with different + characteristics to be "mounted" within a directory tree.  Thus a + ISO-9660 or Windows + file system may end up as a sub-tree of a POSIX directory tree.
    + 
    • +
  • Wide-character versions of directory and file operations are available on some operating + systems, and not available on others.
    + 
    • +
  • There is no law that says directory hierarchies have to be specified in + terms of left-to-right decent from the root.
    + 
    • +
  • Some file systems have a concept of file "version number" or "generation + number".  Some don't.
    + 
    • +
  • Not all operating systems use single character separators in path names.  Some use + paired notations. A typical fully-specified OpenVMS filename + might look something like this:
    +
    +    DISK$SCRATCH:[GEORGE.PROJECT1.DAT]BIG_DATA_FILE.NTP;5
    +
    + The general OpenVMS format is:
    +
    +     + Device:[directories.dot.separated]filename.extension;version_number
    + 
    • +
  • For common file systems, determining if two descriptors are for same + entity is extremely difficult or impossible.  For example, the concept of + equality can be different for each portion of a path - some portions may be + case or locale sensitive, others not. Case sensitivity is a property of the + pathname itself, and not the platform. Determining collating sequence is even + worse.
    + 
    • +
  • Race-conditions may occur. Directory trees, directories, files, and file attributes are in effect shared between all threads, processes, and computers which have access to the + filesystem.  That may well include computers on the other side of the + world or in orbit around the world. This implies that file system operations + may fail in unexpected ways. For example:
    +
    +      assert( exists("foo") == exists("foo") ); + // may fail!
    +     assert( is_directory("foo") == is_directory("foo"); + // may fail!
    +
    + In the first example, the file may have been deleted between calls to + exists().  In the second example, the file may have been deleted and then + replaced by a directory of the same name between the calls to is_directory().
    + 
    • +
  • Even though an application may be portable, it still will have to traffic + in system specific paths occasionally; user provided input is a common + example.
    + 
    • +
  • Symbolic links cause canonical and + normal form of some paths to represent different files or directories. For + example, given the directory hierarchy /a/b/c, with a symbolic + link in /a named x  pointing to b/c, + then under POSIX Pathname Resolution rules a path of "/a/x/.." + should resolve to "/a/b". If "/a/x/.." were first + normalized to "/a", it would resolve incorrectly. (Case supplied + by Walter Landry.)
    • +
+ +

Rationale

+ +

The Requirements and +Realities above drove much of the C++ interface design.  In particular, +the desire to make script-like code straightforward caused a great deal of +effort to go into ensuring that apparently simple expressions like exists( "foo" +) work as expected.

+ +

See the FAQ for the rationale behind many detailed +design decisions.

+ +

Several key insights went into the path class design:

+
    +
  • Decoupling of the input formats, internal conceptual (vector<string> + or other sequence) + model, and output formats.
    • +
  • Providing two input formats (generic and O/S specific) broke a major + design deadlock.
    • +
  • Providing several output formats solved another set of previously + intractable problems.
    • +
  • Several non-obvious functions (particularly decomposition and composition) + are required to support portable code. (Peter Dimov, Thomas Witt, Glen + Knowles, others.)
    • +
+ +

Error checking was a particularly difficult area. One key insight was that +with file and directory names, portability isn't a universal truth.  +Rather, the programmer must think out the question "What operating systems do I +want this path to be portable to?"  By providing support for several +answers to that question, the Filesystem Library alerts programmers of the need +to ask it in the first place.

+

Abandoned Designs

+

operations.hpp

+

Dietmar Kühl's original dir_it design and implementation supported +wide-character file and directory names. It was abandoned after extensive +discussions among Library Working Group members failed to identify portable +semantics for wide-character names on systems not providing native support. See +FAQ.

+

Previous iterations of the interface design used explicitly named functions providing a +large number of convenience operations, with no compile-time or run-time +options. There were so many function names that they were very confusing to use, +and the interface was much larger. Any benefits seemed theoretical rather than +real.

+

Designs based on compile time (rather than runtime) flag and option selection +(via policy, enum, or int template parameters) became so complicated that they +were abandoned, often after investing quite a bit of time and effort. The need +to qualify attribute or option names with namespaces, even aliases, made use in +template parameters ugly; that wasn't fully appreciated until actually writing +real code.

+

Yet another set of convenience functions ( for example, remove with +permissive, prune, recurse, and other options, plus predicate, and possibly +other, filtering features) were abandoned because the details became both +complex and contentious.

+ +

What is left is a toolkit of low-level operations from which the user can +create more complex convenience operations, plus a very small number of +convenience functions which were found to be useful enough to justify inclusion.

+ +

path.hpp

+ +

There were so many abandoned path designs, I've lost track. Policy-based +class templates in several flavors, constructor supplied runtime policies, +operation specific runtime policies, they were all considered, often +implemented, and ultimately abandoned as far too complicated for any small +benefits observed.

+ +

Additional design considerations apply to Internationalization.

+ +

error checking

+ +

A number of designs for the error checking machinery were abandoned, some +after experiments with implementations. Totally automatic error checking was +attempted in particular. But automatic error checking tended to make the overall +library design much more complicated.

+ +

Some designs associated error checking mechanisms with paths.  Some with +operations functions.  A policy-based error checking template design was +partially implemented, then abandoned as too complicated for everyday +script-like programs.

+ +

The final design, which depends partially on explicit error checking function +calls,  is much simpler and straightforward, although it does depend to +some extent on programmer discipline.  But it should allow programmers who +are concerned about portability to be reasonably sure that their programs will +work correctly on their choice of target systems.

+ +

References

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
[IBM-01]IBM Corporation, z/OS V1R3.0 C/C++ Run-Time +Library Reference, SA22-7821-02, 2001, + + www-1.ibm.com/servers/eserver/zseries/zos/bkserv/
[ISO-9660]International Standards Organization, 1988
[Kuhn]UTF-8 and Unicode FAQ for Unix/Linux, + + www.cl.cam.ac.uk/~mgk25/unicode.html
[MSDN] Microsoft Platform SDK for Windows, Storage Start +Page, + + msdn.microsoft.com/library/en-us/fileio/base/storage_start_page.asp
[POSIX-01]IEEE Std 1003.1-2001, ISO/IEC 9945:2002, and The Open Group Base Specifications, Issue 6. Also known as The + Single Unix® Specification, Version 3. + Available from each of the organizations involved in its creation. For + example, read online or download from + + www.unix.org/single_unix_specification/. The ISO JTC1/SC22/WG15 - POSIX +homepage is + www.open-std.org/jtc1/sc22/WG15/
[URI]RFC-2396, Uniform Resource Identifiers (URI): Generic +Syntax, + www.ietf.org/rfc/rfc2396.txt
[UTF-16]Wikipedia, UTF-16, + + en.wikipedia.org/wiki/UTF-16
[Wulf-Shaw-73]William Wulf, Mary Shaw, Global +Variable Considered Harmful, ACM SIGPLAN Notices, 8, 2, 1973, pp. 23-34
+ +
+

Revised +18 February, 2010

+ +

© Copyright Beman Dawes, 2002

+

Use, modification, and distribution are subject to the Boost Software +License, Version 1.0. (See accompanying file +LICENSE_1_0.txt or copy at +www.boost.org/LICENSE_1_0.txt)

+ + + + \ No newline at end of file diff --git a/v3/libs/filesystem/doc/do_list.html b/v3/libs/filesystem/doc/do_list.html new file mode 100644 index 0000000..ed5b619 --- /dev/null +++ b/v3/libs/filesystem/doc/do_list.html @@ -0,0 +1,148 @@ + + + + + + + +Do List + + + + + +

Boost Filesystem Do List
+31 May 2010

+ +

Beta 1 comments

+
    +
  • + +

    Zach Laine:

    • +
+
+ 
The descriptions for portable_name() and portable_directory_name()
+appear to be at odds.
+
+portable_name() : ... && (name is "." or "..", and the first character
+not a period or hyphen)
+
+portable_directory_name(): ... && (name is "." or ".."  or contains no periods)
+
+Should portable_name() be "... && (name is "." or "..", or contains no
+periods) && (first character not a hyphen)"?  Maybe I'm missing
+something?
+
+
    +
  • +

    Scott McMurray - treat as Wish List:

    • +
+
+ 
- uncomplete(p, base)
+
+My pet request.  It may be useful to simplify other functions as well,
+since there's no current way to go from an absolute path to a relative
+one, meaning that most functions need to handle relative ones even
+when that might not be natural.  With this functionality,
+preconditions requiring absolute paths would be less onerous.
+
+   Precondition: p.is_absolute() && base.is_absolute()
+
+   Effects: Extracts a path, rp, from p relative to base such that
+canonical(p) == complete(rp, base).  Any ".." path elements in rp form
+a prefix.
+
+   Returns: The extracted path.
+
+   Postconditions: For the returned path, rp, rp.is_relative() ==
+(p.root_name() == b.root_name()).
+
+[Notes: This function simplifies paths by omitting context.  It is
+particularly useful for serializing paths such that it can be usefully
+moved between hosts where the context may be different, such as inside
+source control trees.  It can also be helpful for display to users,
+such as in shells where paths are often shown relative to $HOME.
+
+In the presence of symlinks, the result of this function may differ
+between implementations, as some may expand symlinks that others may
+not.  The simplest implementation uses canonical to expand both p and
+base, then removes the common prefix and prepends the requisite ".."
+elements.  Smarter implementations will avoid expanding symlinks
+unnecessarily.  No implementation is expected to discover new symlinks
+to return paths with fewer elements.]
+
+

Docs

+
    +
  • Reorganize files - delete examples that no longer apply.
    • +
  • Should minimal.css be changed to used relative font sizes? See + http://www.w3schools.com/CSS/pr_font_font-size.asp\
    • +
  • Document behavior of path::replace_extension has change WRT argument w/o a + dot.
    • +
  • Document leading //: no longer treated specially. + But is that really correct?
    • +
  • Behavior of root_path() has been changed. Change + needs to be propagated to trunk?
    • +
  • Add docs for scoped_path_locale.
    • +
  • Regenerate path decomposition table.
    • +
+ +

Code

+

All

+
    +
  • Move semantics.
    • +
  • Use BOOST_DELETED, BOOST_DEFAULTED, where + appropriate.
    • +
  • Other C++0x features.
    • +
+

Class path

+
    +
  • Windows, POSIX, conversions for char16_t, char32_t for C++0x compilers.
    • +
  • Add Windows Alternate Data Stream test cases. See http://en.wikipedia.org/wiki/NTFS + Features.
    • +
  • Add test case: relational operators on paths differing only in trailing + separator. Rationale?
    • +
  • Provide the name check functions for more character types? Templatize? + take a path argument?
    • +
  • Add test for scoped_path_locale.
    • +
  • Add codepage 936/950/etc test cases.
    • +
  • Should UDT's be supported?
    • +
  • Should path iteration to a separator result in:
    + -- the actual separator used
    + -- the preferred separator
    + -- the generic separator <-- makes it easier to write portable code
    + -- a dot
    • +
+

Operations

+
    +
  • Would complete(), system_complete() be clearer if renamed absolute(), + absolute_system() (or absolute_native())?
    • +
  • Review all operations.cpp code for race conditions similar to #2925. Fix + or document.
    • +
  • Enable all BOOST_FILESYSTEM_NO_DEPRECATED code.
    • +
  • rename and remove names are problems. If users says "using + namespace boost::filesystem"
    + and some header included stdio, there is just too much chance of silent error.
    • +
  • create_directories error handling needs work.
    • +
  • Fold convenience.hpp into operations.hpp
    • +
  • Two argument recursive_directory_iterator ctor isn't recognizing throws(). + Would it be better to fold into a single two argument ctor with default?
    • +
  • Add the push_directory class from tools/release/required_files.cpp
    • +
+ +

Miscellaneous

+
    +
  • Regular classes need hash functions.
    • +
+ +
+

© Copyright Beman Dawes, 2010

+

Distributed under the Boost Software License, Version 1.0. See +www.boost.org/LICENSE_1_0.txt

+ + + + \ No newline at end of file diff --git a/v3/libs/filesystem/doc/faq.htm b/v3/libs/filesystem/doc/faq.htm new file mode 100644 index 0000000..0cb671a --- /dev/null +++ b/v3/libs/filesystem/doc/faq.htm @@ -0,0 +1,147 @@ + + + + + + + +Filesystem FAQ + + + + + + + + + + +
+ +boost.png (6897 bytes) + Filesystem FAQ +
+ + + + + +
Boost Home    + Library Home    + Reference    + Tutorial    + FAQ    + Portability    + V3 Intro    + V3 Design    + Deprecated    +
+ +

+Frequently Asked Questions

+

General questions

+

Why not support a concept of specific kinds of file systems, such as posix_file_system or windows_file_system.

+

Portability is one of the most important requirements for the +library. Features specific to a particular operating system or file system +can always be accessed by using the operating system's API.

+ +

+Class path questions

+

Why base the generic pathname format on POSIX?

+

POSIX is an ISO Standard. It is the basis for the most familiar +pathname formats, +not just for POSIX-based operating systems but also for Windows and the +URL portion of URI's. It is ubiquitous and +familiar.  On many systems, it is very easy to implement because it is +either the native operating system format (Unix and Windows) or via a +operating system supplied +POSIX library (z/OS, OS/390, and many more.)

+

Why not use a full URI (Universal Resource Identifier) based path?

+

URI's would promise more than the Filesystem Library can actually deliver, +since URI's extend far beyond what most operating systems consider a file or a +directory.  Thus for the primary "portable script-style file system +operations" requirement of the Filesystem Library, full URI's appear to be over-specification.

+

Why isn't path a base class with derived directory_path and +file_path classes?

+

Why bother?  The behavior of all three classes is essentially identical. +Several early versions did require users to identify each path as a file or +directory path, and this seemed to increase coding errors and decrease code +readability. There was no apparent upside benefit.

+

Why do path decomposition functions yielding a single element return a +path rather than a string?

+

Interface simplicity. If they returned strings, flavors would be needed for +string, wstring, u16string, +u32string, and generic strings.

+

Why don't path member functions have overloads with error_code& arguments?

+

They have not been requested by users; the need for error reporting via +error_code seems limited to operations failures rather than path failures.

+

Operations function questions

+

Why not supply a 'handle' type, and let the file and directory operations +traffic in it?

+

It isn't clear there is any feasible way to meet the "portable script-style +file system operations" requirement with such a system. File systems exist where operations are usually performed on + some non-string handle type. The classic Mac OS has been mentioned explicitly as a case where +trafficking in paths isn't always natural.   

+

The case for the "handle" (opaque data type to identify a file) +style may be strongest for directory iterator value type.  (See Jesse Jones' Jan 28, +2002, Boost postings). However, as class path has evolved, it seems sufficient +even as the directory iterator value type.

+

Why are the operations functions so low-level?

+

To provide a toolkit from which higher-level functionality can be created.

+

An +extended attempt to add convenience functions on top of, or as a replacement +for, the low-level functionality failed because there is no widely acceptable +set of simple semantics for most convenience functions considered.  +Attempts to provide alternate semantics via either run-time options or +compile-time polices became overly complicated in relation to the value +delivered, or became contentious.  OTOH, the specific functionality needed for several trial +applications was very easy for the user to construct from the lower-level +toolkit functions.  See Failed +Attempts.

+

Isn't it inconsistent then to provide a few convenience functions?

+

Yes, but experience with both this library, POSIX, and Windows, indicates +the utility of certain convenience functions, and that it is possible to provide +simple, yet widely acceptable, semantics for them. For example, remove_all().

+

Why are there directory_iterator overloads for operations.hpp +predicate functions? Isn't two ways to do the same thing poor design?

+

Yes, two ways to do the same thing is often a poor design practice. But the +iterator versions are often much more efficient. Calling status() during +iteration over a directory containing 15,000 files took 6 seconds for the path +overload, and 1 second for the iterator overload, for tests on a freshly booted +machine. Times were .90 seconds and .30 seconds, for tests after prior use of +the directory. This performance gain is large enough to justify deviating from +preferred design practices. Neither overload alone meets all needs.

+

Why are the operations functions so picky about errors?

+

Safety. The default is to be safe rather than sorry. This is particularly +important given the reality that on many computer systems files and directories +are globally shared resources, and thus subject to +race conditions.

+

Why are attributes accessed via named functions rather than property maps?

+

For commonly used attributes (existence, directory or file, emptiness), +simple syntax and guaranteed presence outweigh other considerations. Because +access to many other attributes is inherently system dependent, +property maps are viewed as the best hope for access and modification, but it is +better design to provide such functionality in a separate library. (Historical +note: even the apparently simple attribute "read-only" turned out to be so +system depend as to be disqualified as a "guaranteed presence" operation.)

+

Why isn't automatic name portability error detection provided?

+

A number (at least six) of designs for name validity error +detection were evaluated, including at least four complete implementations.  +While the details for rejection differed, all of the more powerful name validity checking +designs distorted other +otherwise simple aspects of the library. Even the simple name checking provided +in prior library versions was a constant source of user complaints. While name checking can be helpful, it +isn't important enough to justify added a lot of additional complexity.

+

Why are paths sometimes manipulated by member functions and sometimes by +non-member functions?

+

The design rule is that purely lexical operations are supplied as class +path member +functions, while operations performed by the operating system are provided as +free functions.

+
+

Revised +17 February, 2010

+

© Copyright Beman Dawes, 2002

+

Use, modification, and distribution are subject to the Boost Software +License, Version 1.0. See +www.boost.org/LICENSE_1_0.txt

\ No newline at end of file diff --git a/v3/libs/filesystem/doc/index.htm b/v3/libs/filesystem/doc/index.htm new file mode 100644 index 0000000..f2debd5 --- /dev/null +++ b/v3/libs/filesystem/doc/index.htm @@ -0,0 +1,440 @@ + + + + + + + +Filesystem Home + + + + + + + + + + +
+ +boost.png (6897 bytes) + Filesystem Library +
+ + + + + +
Boost Home    + Library Home    + Reference    + Tutorial    + FAQ    + Portability    + V3 Intro    + V3 Design    + Deprecated    +
+ + + + + + + + +
+ Contents
+ Introduction
+ Documentation
+ Using the library
+ Cautions
+ Headers
+ Example programs
+ Implementation
+ Macros
+ Building the object-library
+ Notes for Cygwin users
+ Version history
+  with acknowledgements
+ +

Introduction

+

The Boost.Filesystem library provides facilities to manipulate files and directories, +and the paths that identify them.

+ +

The features of the library include:

+ +
    +
  • A modern C++ interface, highly compatible with the C++ standard + library.
    • +
+
+
+ +

Many users say the interface is their primary motivation for using +Boost.Filesystem. They like its use of familiar idioms based on standard library +containers, iterators, and algorithms. They like having errors reported by +throwing exceptions.

+ +
+
+
    +
  • Portability between operating systems.
    + 
      +
    • At the C++ syntax level, it is convenient to learn and use one interface + regardless of the operating system.
      • +
    • At the semantic level, behavior of code is reasonably portable across + operating systems.
      • +
    • Dual generic or native path format support encourages program + portability, yet still allows communication with users in system specific + formats.
      + 
      • +
    +
    • +
  • Error handling and reporting via C++ exceptions (the default) or error + codes.
    + 
      +
    • C++ exceptions are the preferred error reporting mechanism for most + applications. The exception thrown includes the detailed error code + information important for diagnosing the exact cause of file system errors.
      • +
    • Error reporting via error code allows user code that provides detailed + error recovery to avoid becoming so littered with try-catch blocks as to be + unmaintainable.
      + 
      • +
    +
    • +
  • Suitable for a broad spectrum of applications, ranging from simple + script-like operations to extremely complex production code.
    + 
      +
    • At the simple script-like end of the spectrum, the intent is not to + compete with Python, Perl, or shell languages, but rather to provide + filesystem operations when C++ is already the language of choice.
      • +
    • Finer grained control over operations and error handling is available to + support more complex applications or other cases where throwing exceptions + isn't desired.
      • +
    +
    • +
+ +

A proposal, + +N1975, to include Boost.Filesystem in Technical Report 2 has been accepted +by the C++ Standards Committee. That proposal was based on version 2 of +Boost.Filesystem; presumably the final TR2 form will be based on version 3.

+ +

Documentation

+ +

Tutorial - A gentle introduction to +the library, with example programs provided for you to experiment with.

+ +

Reference - Formal documentation in the +style of the C++ standard for +every component of the library.

+ +

FAQ - Frequently asked questions.

+ +

Portability Guide - Help for those +concerned with writing code to run on multiple operating systems.

+ +

Deprecated Features - Identifies +deprecated features and their replacements.

+ +

Version 3 Introduction - Aimed at users of prior +Boost.Filesystem versions.

+ +

Version 3 Design - Historical document +from the start of the Version 3 design process.

+ +

Original Design - Historical document from +the start of the Version 1 design process.

+ +

Do List - Boost.Filesystem development work +in the pipeline.

+ +

Using the library

+

Boost.Filesystem is implemented as a separately compiled library, so you must install +binaries in a location that can be found by your linker. If you followed the +Boost Getting Started instructions, that's already been done for you.

+

Cautions

+

After reading the tutorial you can dive right into simple, +script-like programs using the Filesystem Library! Before doing any serious +work, however, there a few cautions to be aware of:

+

Effects and Postconditions not guaranteed in the presence of race-conditions

+

Filesystem function specifications follow the C++ Standard Library form, specifying behavior in terms of +effects and postconditions. If +a race-condition exists, a function's +postconditions may no longer be true by the time the function returns to the +caller.

+
+

Explanation: The state of files and directories is often +globally shared, and thus may be changed unexpectedly by other threads, +processes, or even other computers having network access to the filesystem. As an +example of the difficulties this can cause, note that the following asserts +may fail:

+
+

assert( exists( "foo" ) == exists( "foo" ) );  // +(1)
+
+remove_all( "foo" );
+assert( !exists( "foo" ) );  // (2)
+
+assert( is_directory( "foo" ) == is_directory( "foo" ) ); // +(3)

+
+

(1) will fail if a non-existent "foo" comes into existence, or an +existent "foo" is removed, between the first and second call to exists(). +This could happen if, during the execution of the example code, another thread, +process, or computer is also performing operations in the same directory.

+

(2) will fail if between the call to remove_all() and the call to +exists() a new file or directory named "foo" is created by another +thread, process, or computer.

+

(3) will fail if another thread, process, or computer removes an +existing file "foo" and then creates a directory named "foo", between the +example code's two calls to is_directory().

+
+

May throw exceptions

+

Unless otherwise specified, Boost.Filesystem functions throw +basic_filesystem_error +exceptions if they cannot successfully complete their operational +specifications. Also, implementations may use C++ Standard Library functions, +which may throw std::bad_alloc. These exceptions may be thrown even +though the error condition leading to the exception is not explicitly specified +in the function's "Throws" paragraph.

+

All exceptions thrown by the Filesystem +Library are implemented by calling +boost::throw_exception(). Thus exact behavior may differ depending on +BOOST_NO_EXCEPTIONS at the time the filesystem source files are compiled.

+

Non-throwing versions are provided of several functions that are often used +in contexts where error codes may be the preferred way to report an error.

+ +

Headers

+ +

The Boost.Filesystem library provides several headers:

+ +
    +
  • Header <boost/filesystem.hpp> + provides access to all features of the library, except file streams.
    + 
    • +
  • Header <boost/filesystem/fstream.hpp> + inherits the same components as the C++ Standard + Library's fstream header, but files are identified by const path& + arguments rather that const char* arguments.
    • +
+

Example programs

+

See the tutorial for example programs.

+

Other examples

+

The programs used to generate the Boost regression test status tables use the +Filesystem Library extensively.  See:

+ +

Implementation

+

The current implementation supports operating systems which provide +the POSIX or Windows API's.

+

The library is in regular use on Apple OS X, HP-UX, IBM AIX, Linux, +Microsoft Windows, SGI IRIX, and Sun Solaris operating systems using a variety +of compilers.

+

Macros

+

Users may defined the following macros if desired. Sensible defaults are +provided, so users can ignore these macros unless they have special needs.

+ + + + + + + + + + + + + + + + + + + + + +
Macro NameDefaultEffect if defined
BOOST_FILESYSTEM_NO_DEPRECATEDNot defined.Deprecated features are excluded from headers.
BOOST_FILESYSTEM_DYN_LINKDefined if BOOST_ALL_DYN_LINK is defined, + otherwise not defined.The Boost.Filesystem library is dynamically linked. If not defined, + static linking is assumed.
BOOST_FILESYSTEM_NO_LIBDefined if BOOST_ALL_NO_LIB is defined, + otherwise not defined.Boost.Filesystem library does not use the Boost auto-link + facility.
+

User-defined BOOST_POSIX_API and BOOST_WINDOWS_API macros are no longer +supported.

+

Building the object-library

+

The object-library will be built automatically if you are using the Boost +build system. See +Getting Started. It can also be +built manually using a Jamfile +supplied in directory libs/filesystem/build, or the user can construct an IDE +project or make file which includes the object-library source files.

+

The object-library source files are +supplied in directory libs/filesystem/src. These source files implement the +library for POSIX or Windows compatible operating systems; no implementation is +supplied for other operating systems. Note that many operating systems not +normally thought of as POSIX systems, such as mainframe legacy +operating systems or embedded operating systems, support POSIX compatible file +systems and so will work with the Filesystem Library.

+

The object-library can be built for static or dynamic (shared/dll) linking. +This is controlled by the BOOST_ALL_DYN_LINK or BOOST_FILESYSTEM_DYN_LINK +macros. See the Separate +Compilation page for a description of the techniques used.

+

Note for Cygwin users

+

Cygwin version 1.7 or later is +required. Only later versions of GCC with wide character strings are supported. +The library's implementation code treats Cygwin as a Windows platform, and thus +uses the Windows API.

+ +

Version history

+ +

Version 3

+ +

Boost 1.??.0 - ???, 2010 - Internationalization via single class path. +More uniform error handling.

+ +

Peter Dimov suggested use of a single path class rather than a basic_path +class template. That idea was the basis for the Version 3 redesign.

+ +

Thanks for comments from Robert Stewart, Zach Laine, Peter Dimov, Gregory +Peele, Scott McMurray, John Bytheway, Jeff Flinn, Jeffery Bosboom.

+ +

Version 2

+ +

Boost 1.34.0 - May, 2007 - Internationalization via basic_path +template.

+ +

So many people have contributed comments and bug reports that it isn't any +longer possible to acknowledge them individually. That said, Peter Dimov and Rob +Stewart need to be specially thanked for their many constructive criticisms and +suggestions. Terence +Wilson and Chris Frey contributed timing programs which helped illuminate +performance issues.

+ +

Version 1

+ +

Boost 1.30.0 - March, 2003 - Initial official Boost release.

+ +

The Filesystem Library was designed and implemented by Beman Dawes. The +original directory_iterator and filesystem_error classes were +based on prior work from Dietmar Kuehl, as modified by Jan Langer. Thomas Witt +was a particular help in later stages of initial development. Peter Dimov and +Rob Stewart made many useful suggestions and comments over a long period of +time. Howard Hinnant helped with internationalization issues.

+ +

Key design requirements and +design realities were developed during +extensive discussions on the Boost mailing list, followed by comments on the +initial implementation. Numerous helpful comments were then received during the +Formal Review.

Participants included +Aaron Brashears, +Alan Bellingham, +Aleksey Gurtovoy, +Alex Rosenberg, +Alisdair Meredith, +Andy Glew, +Anthony Williams, +Baptiste Lepilleur, +Beman Dawes, +Bill Kempf, +Bill Seymour, +Carl Daniel, +Chris Little, +Chuck Allison, +Craig Henderson, +Dan Nuffer, +Dan'l Miller, +Daniel Frey, +Darin Adler, +David Abrahams, +David Held, +Davlet Panech, +Dietmar Kuehl, +Douglas Gregor, +Dylan Nicholson, +Ed Brey, +Eric Jensen, +Eric Woodruff, +Fedder Skovgaard, +Gary Powell, +Gennaro Prota, +Geoff Leyland, +George Heintzelman, +Giovanni Bajo, +Glen Knowles, +Hillel Sims, +Howard Hinnant, +Jaap Suter, +James Dennett, +Jan Langer, +Jani Kajala, +Jason Stewart, +Jeff Garland, +Jens Maurer, +Jesse Jones, +Jim Hyslop, +Joel de Guzman, +Joel Young, +John Levon, +John Maddock, +John Williston, +Jonathan Caves, +Jonathan Biggar, +Jurko, +Justus Schwartz, +Keith Burton, +Ken Hagen, +Kostya Altukhov, +Mark Rodgers, +Martin Schuerch, +Matt Austern, +Matthias Troyer, +Mattias Flodin, +Michiel Salters, +Mickael Pointier, +Misha Bergal, +Neal Becker, +Noel Yap, +Parksie, +Patrick Hartling, Pavel Vozenilek, +Pete Becker, +Peter Dimov, +Rainer Deyke, +Rene Rivera, +Rob Lievaart, +Rob Stewart, +Ron Garcia, +Ross Smith, +Sashan, +Steve Robbins, +Thomas Witt, +Tom Harris, +Toon Knapen, +Victor Wagner, +Vincent Finn, +Vladimir Prus, and +Yitzhak Sapir + +

A lengthy discussion on the C++ committee's library reflector illuminated the "illusion +of portability" problem, particularly in postings by PJ Plauger and Pete Becker.

+ +

Walter Landry provided much help illuminating symbolic link use cases for +version 1.31.0. 

+ +
+

Revised +31 May, 2010

+ +

© Copyright Beman Dawes, 2002-2005

+

Use, modification, and distribution are subject to the Boost Software +License, Version 1.0. See +www.boost.org/LICENSE_1_0.txt

+ + + + \ No newline at end of file diff --git a/v3/libs/filesystem/doc/minimal.css b/v3/libs/filesystem/doc/minimal.css new file mode 100644 index 0000000..2e5812a --- /dev/null +++ b/v3/libs/filesystem/doc/minimal.css @@ -0,0 +1,29 @@ +/* + + © Copyright Beman Dawes, 2007 + + Distributed under the Boost Software License, Version 1.0. + See www.boost.org/LICENSE_1_0.txt + +*/ + +/******************************************************************************* + Body +*******************************************************************************/ + +body { font-family: sans-serif; margin: 1em; } + +/******************************************************************************* + Table +*******************************************************************************/ + +table { margin: 0.5em; } + +/******************************************************************************* + Font sizes +*******************************************************************************/ + +p, td, li, blockquote { font-size: 10pt; } +pre { font-size: 9pt; } + +/*** end ***/ \ No newline at end of file diff --git a/v3/libs/filesystem/doc/path_table.cpp b/v3/libs/filesystem/doc/path_table.cpp new file mode 100644 index 0000000..e51c57f --- /dev/null +++ b/v3/libs/filesystem/doc/path_table.cpp @@ -0,0 +1,260 @@ +// Generate an HTML table showing path decomposition ---------------------------------// + +// Copyright Beman Dawes 2005. + +// Distributed under the Boost Software License, Version 1.0. +// See http://www.boost.org/LICENSE_1_0.txt + +// See http://www.boost.org/libs/filesystem for documentation. + +// For purposes of generating the table, support both POSIX and Windows paths + +#include "boost/filesystem.hpp" +#include +#include + +using boost::filesystem::path; +using std::string; +using std::cout; + +namespace +{ + std::ifstream infile; + std::ofstream posix_outfile; + std::ifstream posix_infile; + std::ofstream outfile; + + bool posix; + + const string empty_string; + + struct column_base + { + virtual string heading() const = 0; + virtual string cell_value( const path & p ) const = 0; + }; + + struct c0 : public column_base + { + string heading() const { return string("string()"); } + string cell_value( const path & p ) const { return p.string(); } + } o0; + + struct c1 : public column_base + { + string heading() const { return string("generic_
string()"); } + string cell_value( const path & p ) const { return p.generic_string(); } + } o1; + + struct c2 : public column_base + { + string heading() const { return string("Iteration
over
Elements"); } + string cell_value( const path & p ) const + { + string s; + for( path::iterator i(p.begin()); i != p.end(); ++i ) + { + if ( i != p.begin() ) s += ','; + s += (*i).string(); + } + return s; + } + } o2; + + struct c3 : public column_base + { + string heading() const { return string("root_
path()"); } + string cell_value( const path & p ) const { return p.root_path().string(); } + } o3; + + struct c4 : public column_base + { + string heading() const { return string("root_
name()"); } + string cell_value( const path & p ) const { return p.root_name().string(); } + } o4; + + struct c5 : public column_base + { + string heading() const { return string("root_
directory()"); } + string cell_value( const path & p ) const { return p.root_directory().string(); } + } o5; + + struct c6 : public column_base + { + string heading() const { return string("relative_
path()"); } + string cell_value( const path & p ) const { return p.relative_path().string(); } + } o6; + + struct c7 : public column_base + { + string heading() const { return string("parent_
path()"); } + string cell_value( const path & p ) const { return p.parent_path().string(); } + } o7; + + struct c8 : public column_base + { + string heading() const { return string("filename()"); } + string cell_value( const path & p ) const { return p.filename().string(); } + } o8; + + const column_base * column[] = { &o2, &o0, &o1, &o3, &o4, &o5, &o6, &o7, &o8 }; + + // do_cell ---------------------------------------------------------------// + + void do_cell( const string & test_case, int i ) + { + string temp = column[i]->cell_value(path(test_case)); + string value; + outfile << ""; + if (temp.empty()) + value = "empty"; + else + value = string("") + temp + ""; + + if (posix) + posix_outfile << value << '\n'; + else + { + std::getline(posix_infile, temp); + if (value != temp) // POSIX and Windows differ + { + value.insert(0, "
"); + value.insert(0, temp); + value.insert(0, ""); + value += ""; + } + outfile << value; + } + outfile << "\n"; + } + +// do_row ------------------------------------------------------------------// + + void do_row( const string & test_case ) + { + outfile << "\n"; + + if (test_case.empty()) + outfile << "empty\n"; + else + outfile << "" << test_case << "\n"; + + for ( int i = 0; i < sizeof(column)/sizeof(column_base&); ++i ) + { + do_cell( test_case, i ); + } + + outfile << "\n"; + } + +// do_table ----------------------------------------------------------------// + + void do_table() + { + outfile << + "

Path Decomposition Table

\n" + "

Shaded entries indicate cases where POSIX and Windows\n" + "implementations yield different results. The top value is the\n" + "POSIX result and the bottom value is the Windows result.\n" + "\n" + "

\n" + ; + + // generate the column headings + + outfile << "

\n"; + + for ( int i = 0; i < sizeof(column)/sizeof(column_base&); ++i ) + { + outfile << "\n"; + } + + outfile << "\n"; + + // generate a row for each input line + + string test_case; + while ( std::getline( infile, test_case ) ) + { + if (!test_case.empty() && *--test_case.end() == '\r') + test_case.erase(test_case.size()-1); + if (test_case.empty() || test_case[0] != '#') + do_row( test_case ); + } + + outfile << "
Constructor
argument		" << column[i]->heading() << "
\n"; + } + +} // unnamed namespace + +// main ------------------------------------------------------------------------------// + +#define BOOST_NO_CPP_MAIN_SUCCESS_MESSAGE +#include + +int cpp_main( int argc, char * argv[] ) // note name! +{ + if ( argc != 5 ) + { + std::cerr << + "Usage: path_table \"POSIX\"|\"Windows\" input-file posix-file output-file\n" + "Run on POSIX first, then on Windows\n" + " \"POSIX\" causes POSIX results to be save in posix-file;\n" + " \"Windows\" causes POSIX results read from posix-file\n" + " input-file contains the paths to appear in the table.\n" + " posix-file will be used for POSIX results\n" + " output-file will contain the generated HTML.\n" + ; + return 1; + } + + infile.open( argv[2] ); + if ( !infile ) + { + std::cerr << "Could not open input file: " << argv[2] << std::endl; + return 1; + } + + if (string(argv[1]) == "POSIX") + { + posix = true; + posix_outfile.open( argv[3] ); + if ( !posix_outfile ) + { + std::cerr << "Could not open POSIX output file: " << argv[3] << std::endl; + return 1; + } + } + else + { + posix = false; + posix_infile.open( argv[3] ); + if ( !posix_infile ) + { + std::cerr << "Could not open POSIX input file: " << argv[3] << std::endl; + return 1; + } + } + + outfile.open( argv[4] ); + if ( !outfile ) + { + std::cerr << "Could not open output file: " << argv[2] << std::endl; + return 1; + } + + outfile << "\n" + "\n" + "Path Decomposition Table\n" + "\n" + "\n" + ; + + do_table(); + + outfile << "\n" + "\n" + ; + + return 0; +} diff --git a/v3/libs/filesystem/doc/path_table.txt b/v3/libs/filesystem/doc/path_table.txt new file mode 100644 index 0000000..40809c6 --- /dev/null +++ b/v3/libs/filesystem/doc/path_table.txt @@ -0,0 +1,50 @@ +# Paths for the reference.html Path Decomposition Table +# +# This is the input file for path_table, which generates the actual html +# +# Copyright Beman Dawes 2010 +# +# Distributed under the Boost Software License, Version 1.0. +# See www.boost.org/LICENSE_1_0.txt +# +# Note that an empty line is treated as input rather than as a comment + +. +.. +foo +/ +/foo +foo/ +/foo/ +foo/bar +/foo/bar +//net +//net/foo +///foo/// +///foo///bar +/. +./ +/.. +../ +foo/. +foo/.. +foo/./ +foo/./bar +foo/.. +foo/../ +foo/../bar +c: +c:/ +c:foo +c:/foo +c:foo/ +c:/foo/ +c:/foo/bar +prn: +c:\ +c:foo +c:\foo +c:foo\ +c:\foo\ +c:\foo/ +c:/foo\bar diff --git a/v3/libs/filesystem/doc/portability_guide.htm b/v3/libs/filesystem/doc/portability_guide.htm new file mode 100644 index 0000000..e8f1536 --- /dev/null +++ b/v3/libs/filesystem/doc/portability_guide.htm @@ -0,0 +1,241 @@ + + + + + + + +Portability Guide + + + + + +

+Path +Name Portability +Guide

+ + + + + +
Boost Home    + Library Home    + Reference    + Tutorial    + FAQ    + Portability    + V3 Intro    + V3 Design    + Deprecated    +
+ +

+Introduction
+name_check functions
+File and directory name recommendations

+

Introduction

+

Like any other C++ program which performs I/O operations, there is no +guarantee that a program using Boost.Filesystem will be portable between +operating systems. Critical aspects of I/O such as how the operating system +interprets paths are unspecified by the C and C++ Standards.

+

It is not possible to know if a file or directory name will be +valid (and thus portable) for an unknown operating system. There is always the possibility that an operating system could use +names which are unusual (numbers less than 4096, for example) or very +limited in size (maximum of six character names, for example). In other words, +portability is never absolute; it is always relative to specific operating +systems or +file systems.

+

It is possible, however, to know in advance if a directory or file name is likely to be valid for a particular +operating system. It is also possible to construct names which are +likely to be portable to a large number of modern and legacy operating systems.

+ +

Almost all modern operating systems support multiple file systems. At the +minimum, they support a native file system plus a CD-ROM file system (Generally +ISO-9669, often with Juliet extensions).

+ +

Each file system +may have its own naming rules. For example, modern versions of Windows support NTFS, FAT, FAT32, and ISO-9660 file systems, among others, and the naming rules +for those file systems differ. Each file system may also have +differing rules for overall path validity, such as a maximum length or number of +sub-directories. Some legacy systems have different rules for directory names +versus regular file names.

+ +

As a result, Boost.Filesystem's name_check functions +cannot guarantee directory and file name portability. Rather, they are intended to +give the programmer a "fighting chance" to achieve portability by early +detection of common naming problems.

+ +

name_check functions

+ +

A name_check function +returns true if its argument is valid as a directory and regular file name for a +particular operating or file system. A number of these functions are provided.

+ +

The portable_name function is of particular +interest because it has been carefully designed to provide wide +portability yet not overly restrict expressiveness.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Library Supplied name_check Functions
FunctionDescription
portable_posix_name(const + std::string& name)Returns: true if !name.empty() && name contains only the characters + specified in Portable Filename Character Set rules as defined in by + POSIX (www.opengroup.org/onlinepubs/007904975/basedefs/xbd_chap03.html).
+ The allowed characters are 0-9, a-z, A-Z, + '.', '_', and '-'.

Use: + applications which must be portable to any POSIX system.

windows_name(const + std::string& name)Returns:  true if !name.empty() && name contains + only the characters specified by the Windows platform SDK as valid + regardless of the file system && (name is "." or + ".."  or does not end with a trailing space or period).  + The allowed characters are anything except 0x0-0x1F, '<', + '>', ':', '"', '/', + '\', and '|'.

+ Use: applications which must be portable to Windows.

+

Note: Reserved device names are not valid as file names, but are + not being detected because they are still valid as a path. Specifically, + CON, PRN, AUX, CLOCK$, NUL, COM[1-9], LPT[1-9], and these names followed by + an extension (for example, NUL.tx7).

portable_name(const + std::string& name)Returns:  windows_name(name) && portable_posix_name(name) + && (name is "." or "..", and the first character not a period or hyphen).

Use: applications which must be portable to a wide variety of + modern operating systems, large and small, and to some legacy O/S's. The + first character not a period or hyphen restriction is a requirement of + several older operating systems.

+ portable_directory_name(const std::string& name)Returns: portable_name(name) && (name is "." + or ".."  or contains no periods).

Use: applications + which must be portable to a wide variety of platforms, including OpenVMS.

+ portable_file_name(const std::string& name)Returns: portable_name(name) && any period is followed by one to three additional + non-period characters.

Use: + applications which must be portable to a wide variety of platforms, + including OpenVMS and other systems which have a concept of "file extension" + but limit its length.

native(const + std::string& name)Returns: Implementation defined. Returns + true for names considered valid by the operating system's native file + systems.

Note: May return true for some names not considered valid + by the operating system under all conditions (particularly on operating systems which support + multiple file systems.)

+ +

File and directory name recommendations

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
RecommendationRationale
Limit file and directory names to the characters A-Z, a-z, 0-9, period, hyphen, and + underscore.

Use any of the "portable_" + name check functions to enforce this recommendation.

These are the characters specified by the POSIX standard for portable directory and + file names, and are also valid for Windows, Mac, and many other modern file systems.
Do not use a period or hyphen as the first + character of a name. Do not use period as the last character of a name.

+ Use portable_name, + portable_directory_name, or + portable_file_name to enforce this + recommendation.

Some operating systems treat have special rules for the + first character of names. POSIX, for example. Windows does not permit period + as the last character.
Do not use periods in directory names.

Use + portable_directory_name to enforce + this recommendation.

Requirement for ISO-9660 without Juliet extensions, OpenVMS filesystem, and other legacy systems.
Do not use more that one period in a file name, and limit + the portion after the period to three characters.

Use + portable_file_name to enforce this + recommendation.

Requirement for ISO-9660 level 1, OpenVMS filesystem, and + other legacy systems.
Do not assume names are case sensitive. For example, do not expected a directory to be + able to hold separate elements named "Foo" and "foo". Some file systems are case insensitive.  For example, Windows + NTFS is case preserving in the way it stores names, but case insensitive in + searching for names (unless running under the POSIX sub-system, it which + case it does case sensitive searches).
Do not assume names are case insensitive.  For example, do not expect a file + created with the name of "Foo" to be opened successfully with the name of "foo".Some file systems are case sensitive.  For example, POSIX.
Don't use hyphens in names.ISO-9660 level 1, and possibly some legacy systems, do not permit + hyphens.
Limit the length of the string returned by path::string() to + 255 characters.  + Note that ISO 9660 has an explicit directory tree depth limit of 8, although + this depth limit is removed by the Juliet extensions.Some operating systems place limits on the total path length.  For example, + Windows 2000 limits paths to 260 characters total length.
Limit the length of any one name in a path.  Pick the specific limit according to + the operating systems and or file systems you wish portability to:
+    Not a concern::  POSIX, Windows, MAC OS X.
+    31 characters: Classic Mac OS
+   8 characters + period + 3 characters: ISO 9660 level 1
+   32 characters: ISO 9660 level 2 and 3
+   128 characters (64 if Unicode): ISO 9660 with Juliet extensions		Limiting name length can markedly reduce the expressiveness of file names, yet placing + only very high limits on lengths inhibits widest portability.
+ +
+

Revised +17 February, 2010

+ +

© Copyright Beman Dawes, 2002, 2003

+

Use, modification, and distribution are subject to the Boost Software +License, Version 1.0. (See accompanying file +LICENSE_1_0.txt or copy at +www.boost.org/LICENSE_1_0.txt)

+ + + + \ No newline at end of file diff --git a/v3/libs/filesystem/doc/reference.html b/v3/libs/filesystem/doc/reference.html new file mode 100644 index 0000000..7b9aed4 --- /dev/null +++ b/v3/libs/filesystem/doc/reference.html @@ -0,0 +1,3080 @@ + + + + + + + +Filesystem Reference + + + + + + + + + + + +
+ +boost.png (6897 bytes) + Filesystem Library
+ + Version 3
+ + + + + + +
Boost Home    + Library Home    + Reference    + Tutorial    + FAQ    + Portability    + V3 Intro    + V3 Design    + Deprecated    +
+ +

Reference Documentation

+ +

Table of Contents

+ + + + + + + +
Introduction
+ Definitions
+ Conformance
+ + Header <filesystem> synopsis
+ Error reporting
+ Class path
+     path constructors
+    path assignments
+    path appends
+    path modifiers
+    path native + format observers
+    path generic + format observers
+    path decomposition
+    path query
+    path iterators
+    path deprecated functions
+    path non-member functions
+    path inserters and extractors
+  Class filesystem_error
+    filesystem_error + constructors
+    filesystem_error path1
+    filesystem_error path2
+    filesystem_error what
+Class directory_entry
+    +directory_entry constructors
+    directory_entry modifiers
+    directory_entry observers
+Class directory_iterator
+    directory_iterator + members
+Class recursive_directory_iterator
+ Class + file_status
+  		 + + Operational functions
+     copy_file
+     create_directories
+     create_directory
+     create_hard_link
+     create_symlink
+     current_path
+     exists
+     equivalent
+     file_size
+     initial_path
+     is_directory
+     is_empty
+     is_other
+     is_regular_file
+     is_symlink
+     last_write_time
+     read_symlink
+     remove
+     remove_all
+     rename
+     resize_file
+     space
+     status
+     status_known
+     symlink_status
+     system_complete
+     unique_path		 + File streams
+Path decomposition table
+Acknowledgements
+References
+ 
+ +

Introduction

+ +

This reference documentation describes components that C++ programs may use +to perform operations involving file systems, including paths, regular files, +and directories.

+

Definitions

+

The following definitions shall apply throughout this reference documentation:

+

File: An object that can be written to, or read from, or both. A file +has certain attributes, including type. Common types of files include regular files +and directories. Other types of files, such as symbolic links, may be supported by the +implementation.

+

File system: A collection of files and certain of their attributes.

+

Filename: The name of a file. Slash and 0 +characters are not permitted. Implementations may define additional +characters or specific names that are not permitted. Filenames .  +and ..  have special meaning. Implementations may define +additional filenames that have special meaning.

+
+

[Note: Most operating systems prohibit the ANSI control characters + (0x00-0x31) in filenames.

+

Windows prohibits the characters 0x00-0x31, ", + *, :, <, >, ?, + \, /, and | --end note]

+
+

Path: A sequence of elements that identify +a location within a filesystem. The elements are the root-nameopt, +root-directoryopt, and an optional sequence of filenames. [Note: +A pathname is the concrete representation of a path. --end note]

+

Absolute path: A path that uniquely +identifies a file. The format is implementation defined.

+
+

[Note: For POSIX-like implementations, including Unix + variants, Linux, and Cygwin, only paths + that begin with a slash are absolute paths.

+

For Windows-like implementations, including Windows and + MinGW, only paths that begin with a drive + specifier followed by a slash, or begin with two slashes, are absolute paths. --end + note]

+
+

Relative path: A path that uniquely +identifies a file only when considered relative to some other path. [Note: +Paths "." and ".." are considered to be relative paths. --end note]

+

Pathname: A character string that represents a +path. Pathnames are formatted according to the generic pathname format or the +native pathname format.

+

Generic pathname format:

+
+

pathname:
+            root-nameopt +root-directoryopt relative-pathopt

+

root-name:
+            +implementation-defined

+
+
+

[Note: Most POSIX and Windows based operating system define a name +beginning with two slashes (or backslashes, for Windows) as a root-name +identifying network locations. Windows defines a single letter followed by a +":" as a root-name identifying a disc drive. --end note]

+
+
+

root-directory:
+            +directory-separator

+

relative-path:
+            +filename
+            relative-path +directory-separator
+            relative-path +directory-separator filename

+

filename:
+            name
+            "."
+            +".."

+

directory-separator:
+            "/"
+      "/" directory-separator

+

Multiple successive directory-separator characters are considered to +be the same as one directory-separator character. The filename +"." is considered to be a reference to the current directory. The +filename ".." is considered to be a reference to the current +directory. Specific filenames may have special meaning for a particular +operating system.

+
+

Native pathname format:  +An implementation defined format. [Note: For POSIX-like operating +systems, the native format is the same as the generic format. For Windows, the +native format is similar to the generic format, but the directory-separator +characters can be either slashes or backslashes. --end note]

+

Link: A directory entry object that associates a +filename with a file. On some file systems, several directory entries can +associate names with the same file.

+

Hard link: A link to an existing file. Some +file systems support multiple hard links to a file. If the last hard link to a +file is removed, the file itself is removed.

+
+

[Note: A hard link can be thought of as a shared-ownership smart +pointer to a file. -- end note]

+
+

Symbolic link: A type of file with the +property that when the file is encountered during pathname resolution, a string +stored by the file is used to modify the pathname resolution.

+
+

[Note: A symbolic link can be thought of as a raw pointer to a file. +If the file pointed to does not exist, the symbolic link is said to be a +"dangling" symbolic link. -- end note]

+
+

Race condition: The condition that occurs +when multiple threads, processes, or computers interleave access and +modification of +the same object within a file system.

+

Dot, Dot Dot: Synonyms for the filenames "." +and "..", respectively. The dot filename names the current +directory. The dot dot filename names the parent directory.

+

Conformance

+

Behavior is sometimes specified by reference to ISO/IEC 9945:2003, +POSIX. How such behavior is actually implemented is unspecified.

+
+

[Note: This constitutes an "as if" rule for implementation of +operating system dependent behavior. Presumably implementations will usually call native +operating system API's. --end note]

+
+

Implementations are encouraged, but not required, to support such behavior + +as it is defined by POSIX. Implementations shall document any +behavior that differs from the POSIX defined behavior. Implementations that do not support exact POSIX behavior are +encouraged to provide behavior as close to POSIX behavior as is reasonable given the +limitations of actual operating systems and file systems. If an implementation cannot provide any +reasonable behavior, the implementation shall report an error in an +implementation-defined manner.

+
+

[Note: Such errors might be reported by an #error directive, a +static_assert, a filesystem_error exception, a special +return value, or some other manner. --end note]

+
+

Specific operating systems such as OpenMVS, +UNIX, and Windows are mentioned only for purposes of illustration or to +give guidance to implementers. No slight to other operating systems is implied +or intended.

+

The Effects and Postconditions of functions described in this +reference +may not be achieved in +the presence of race conditions. No diagnostic is required.

+

If the possibility of race conditions would make it unreliable for a program to +test for a precondition before calling a function described in this clause, +Requires is not specified for the condition. Instead, the condition is +specified as a Throws condition.

+
+

[Note: As a design practice, preconditions are not specified when it +is unreasonable for a program to detect them prior to calling the function. +-- end note]

+
+

Header <boost/filesystem> synopsis

+
  namespace boost
+  {
+    namespace filesystem
+    {
+      class path;
+
+      void swap(path& lhs, path& rhs);
+      bool lexicographical_compare(path::iterator first1, path::iterator last1,
+                                   path::iterator first2, path::iterator last2);
+
+      bool operator==(const path& lhs, const path& rhs);
+      bool operator!=(const path& lhs, const path& rhs);
+      bool operator< (const path& lhs, const path& rhs);
+      bool operator<=(const path& lhs, const path& rhs);
+      bool operator> (const path& lhs, const path& rhs);
+      bool operator>=(const path& lhs, const path& rhs);
+
+      path operator/ (const path& lhs, const path& rhs);
+
+      std::ostream&  operator<<( std::ostream& os, const path& p );
+      std::wostream& operator<<( std::wostream& os, const path& p );
+      std::istream&  operator>>( std::istream& is, path& p );
+      std::wistream& operator>>( std::wistream& is, path& p )
+
+      class filesystem_error;
+      
+      class directory_entry;
+
+      class directory_iterator;
+
+      class recursive_directory_iterator;
+
+      enum file_type { status_error, file_not_found, regular_file, directory_file,
+                       symlink_file, block_file, character_file, fifo_file, socket_file,
+                       type_unknown
+                     };
+
+      class file_status;
+
+      struct space_info  // returned by space function
+      {
+        uintmax_t capacity;
+        uintmax_t free; 
+        uintmax_t available; // free space available to a non-privileged process
+      };
+
+      BOOST_SCOPED_ENUM_START(copy_option)
+      {
+        fail_if_exists,
+        overwrite_if_exists
+      };
+      BOOST_SCOPED_ENUM_END
+
+      // operational functions
+
+      void         copy_file(const path& from, const path& to);
+      void         copy_file(const path& from, const path& to, system::error_code& ec);
+      void         copy_file(const path& from, const path& to, BOOST_SCOPED_ENUM(copy_option) option);
+      void         copy_file(const path& from, const path& to, BOOST_SCOPED_ENUM(copy_option) option,
+                             system::error_code& ec);
+
+      bool         create_directories(const path& p);
+      bool         create_directories(const path& p, system::error_code& ec);
+
+      bool         create_directory(const path& p);
+      bool         create_directory(const path& p, system::error_code& ec);
+
+      void         create_hard_link(const path& to, const path& from);
+      void         create_hard_link(const path& to, const path& from, system::error_code& ec);
+
+      void         create_symlink(const path& to, const path& from);
+      void         create_symlink(const path& to, const path& from, system::error_code& ec);
+
+      path         current_path();
+      path         current_path(system::error_code& ec);
+      void         current_path(const path& p);
+      void         current_path(const path& p, system::error_code& ec);
+
+      bool         exists(file_status s);
+      bool         exists(const path& p);
+      bool         exists(const path& p, system::error_code& ec);
+
+      bool         equivalent(const path& p1, const path& p2);
+      bool         equivalent(const path& p1, const path& p2, system::error_code& ec);
+
+      uintmax_t    file_size(const path& p);
+      uintmax_t    file_size(const path& p, system::error_code& ec);
+
+      const path&  initial_path();
+      const path&  initial_path(system::error_code& ec);
+
+      bool         is_directory(file_status s);
+      bool         is_directory(const path& p);
+      bool         is_directory(const path& p, system::error_code& ec);
+
+      bool         is_empty(const path& p);
+      bool         is_empty(const path& p, system::error_code& ec);
+
+      bool         is_other(file_status s);
+      bool         is_other(const path& p,);
+      bool         is_other(const path& p, system::error_code& ec);
+
+      bool         is_regular_file(file_status s); 
+      bool         is_regular_file(const path& p);
+      bool         is_regular_file(const path& p, system::error_code& ec);
+
+      bool         is_symlink(file_status s);
+      bool         is_symlink(const path& p);
+      bool         is_symlink(const path& p, system::error_code& ec);
+
+      std::time_t  last_write_time(const path& p);
+      std::time_t  last_write_time(const path& p, system::error_code& ec);
+      void         last_write_time(const path& p, const std::time_t new_time);
+      void         last_write_time(const path& p, const std::time_t new_time, system::error_code& ec);
+
+      path         read_symlink(const path& p);
+      path         read_symlink(const path& p, system::error_code& ec);
+
+      bool         remove(const path& p);
+      bool         remove(const path& p, system::error_code& ec);
+
+      uintmax_t    remove_all(const path& p);
+      uintmax_t    remove_all(const path& p, system::error_code& ec);
+
+      void         rename(const path& from, const path& to);
+      void         rename(const path& from, const path& to, system::error_code& ec);
+
+      space_info   space(const path& p);
+      space_info   space(const path& p, system::error_code& ec);
+
+      file_status  status(const path& p);
+      file_status  status(const path& p, system::error_code& ec);
+
+      bool         status_known(file_status s);
+
+      file_status  symlink_status(const path& p);
+      file_status  symlink_status(const path& p, system::error_code& ec);
+
+      path         system_complete(const path& p);
+      path         system_complete(const path& p, system::error_code& ec);
+
+      path         unique_path(const path& model="%%%%-%%%%-%%%%-%%%%");
+      path         unique_path(const path& model, system::error_code& ec);
+
+    } // namespace filesystem
+  } // namespace boost
+

Error reporting

+

Filesystem library functions often provide two overloads, one that +throws an exception to report file system errors, and another that sets an +error_code.

+
+

[Note: This supports two common use cases:

+
    +
  • Uses where file system +errors are truly exceptional and indicate a serious failure. Throwing an + exception is the most appropriate response. This is the preferred default for + most everyday programming.
    + 
    • +
  • Uses where file system system errors are routine and do not necessarily represent + failure. Returning an error code is the most appropriate response. This allows + application specific error handling, including simply ignoring the error.
    • +
+

--end note]

+
+

Functions not having an argument of type +system::error_code& +report errors as follows, unless otherwise specified:

+
    +
  • When a call by the + implementation to an operating system or other underlying API results in an + error that prevents the function from meeting its specifications, an exception + of type +filesystem_error is thrown.
    + 
    • +
  • Failure to allocate storage is reported by throwing an exception as described in the C++ standard, + 17.6.4.10 [res.on.exception.handling].
    + 
    • +
  • Destructors throw nothing.
    • +
+

Functions having an argument of type +system::error_code& report errors as follows, unless otherwise + specified:

+
    +
  • If a call by the + implementation to an operating system or other underlying API results in an + error that prevents the function from meeting its specifications, the +system::error_code& argument is set as + appropriate appropriate for the specific error. Otherwise, clear() + is called on the +system::error_code& argument.
    + 
    • +
  • Failure to allocate storage is reported by + throwing an exception as described in the C++ standard, + 17.6.4.10 [res.on.exception.handling].
    • +
+

Class path

+

An object of class path represents a path, +and contains a pathname Such an object is concerned only with the lexical and syntactic aspects +of a path. The path may not actually exist in external storage, and may contain pathnames which are not even valid for the current operating +system.

+
  namespace boost
+  {
+    namespace filesystem
+    {
+      class path
+      {
+      public:
+        typedef see below                     value_type;  // char for POSIX, wchar_t for Windows
+        typedef std::basic_string<value_type> string_type;
+        typedef path_traits::codecvt_type     codecvt_type;
+
+        // constructors and destructor
+        path();
+        path(const path& p);
+
+        template <class InputIterator>
+          path(InputIterator begin, InputIterator end);
+
+        template <class Source>
+          path(Source const& source);
+
+       ~path();
+
+        // assignments
+        path& operator=(const path& p);
+
+        template <class InputIterator>
+          path& assign(InputIterator begin, InputIterator end);
+
+        template <class Source>
+          path& operator=(Source const& source);
+
+        // appends
+        path& operator/=(const path& p);
+
+        template <class InputIterator>
+          path& append(InputIterator begin, InputIterator end);
+
+        template <class Source>
+          path& operator/=(Source const& source);
+
+        // modifiers
+        void  clear();
+        path& make_absolute(const path& base);
+        path& make_preferred();  // POSIX: no effect. Windows: convert slashes to backslashes
+        path& remove_filename();
+        path& replace_extension(const path& new_extension = path());
+        void  swap(path& rhs);
+
+        // native format observers
+        const string_type&  native() const;            // native format, encoding
+        const value_type*   c_str() const;             // native().c_str()
+
+        template <class String>
+        String string() const;                         // native format, uses codecvt() for encoding
+
+        const string        string() const;            // native format, uses codecvt() for encoding
+        const wstring       wstring() const;           // ditto
+        const u16string     u16string() const;         // ditto
+        const u32string     u32string() const;         // ditto
+
+        // generic format observers
+        template <class String>
+        String generic_string() const;
+
+        const string        generic_string() const;    // generic format, uses codecvt() for encoding
+        const wstring       generic_wstring() const;   // ditto
+        const u16string     generic_u16string() const; // ditto
+        const u32string     generic_u32string() const; // ditto
+
+        // decomposition
+        path  root_name() const;
+        path  root_directory() const;
+        path  root_path() const;
+        path  relative_path() const;
+        path  parent_path() const;
+        path  filename() const;
+        path  stem() const;
+        path  extension() const;
+
+        // query
+        bool empty() const;
+        bool has_root_name() const;
+        bool has_root_directory() const;
+        bool has_root_path() const;
+        bool has_relative_path() const;
+        bool has_parent_path() const;
+        bool has_filename() const;
+        bool has_stem() const;
+        bool has_extension() const;
+        bool is_absolute() const;
+        bool is_relative() const;
+
+        // iterators
+        class iterator;
+        typedef iterator const_iterator;
+
+        iterator begin() const;
+        iterator end() const;
+        
+        // encoding conversion
+        static std::locale imbue( const std::locale& loc );
+        static const codecvt_type & codecvt();
+
+      private:
+        string_type pathname;  // exposition only
+      };
+
+    } // namespace filesystem
+  } // namespace boost
+

value_type is an implementation-defined typedef for the +character type used by the implementation to represent pathnames.

+
+

[Note: For POSIX-like implementations, including Unixes, Linux, +and + Cygwin, path::value_type +is char .

+

For Windows-like implementations, including Windows and +MinGW, path::value_type is +wchar_t. --end note]

+
+

For member functions described as returning const string, +const wstring, const u16string, or const u32string, +implementations are permitted to return const string&, const +wstring&, const u16string&, or const u32string&, +respectively.

+
+

[Note: This allows implementations to avoid unnecessary copies when no +conversion is required. +Return-by-value is specified as +const to ensure programs won't break if moved to a return-by-reference +implementation. -- +end note]

+
+

InputIterator is required meet the +requirements for a C++ standard library RandomIterator +compliant iterator. The iterator's value type is required to be char, + wchar_t, char16_t, or char32_t.

+

Source is required to be one of:

+
    +
  • A container with a value type of char, + wchar_t, char16_t, or char32_t.
    • +
  • An iterator for a null terminated byte-string. The value type is required + to be char, wchar_t, char16_t, or + char32_t.
    • +
  • A C-array. The value type is required to be char, + wchar_t, char16_t, or char32_t.
    • +
  • A boost::filesystem::directory_entry.
    • +
+

The specifications for certain path functions require that +arguments in the generic pathname format be converted to native pathname format +as they are stored in pathname. If the native format requires +regular file paths and directory paths to be formatted differently, the +implementation shall determine which format to use according to whether or not +the last element of the generic format string is a separator. [Example: +On OpenVMS, a path +constructed from "/cats/jane" would considered a regular file +path, and have a native format of "[CATS]JANE", while a +path constructed from "/cats/jane/" would be considered a +directory path, and have a native format of "[CATS.JANE]". +--end example] [Note: POSIX and Windows use the same native format +for regular file and directory pathnames, so this paragraph does not apply to +them. --end note]

+ + + + + +
+ Class path does not currently map invalid characters in + filenames to valid characters. In the future we might add something like + this:
+

When converting filenames to the native operating system format, +implementations are encouraged, but not required, to convert otherwise invalid +characters or character sequences to valid characters or character sequences. +Such conversions are implementation-defined.

+
+

[Note: Filename conversion allows much wider portability of both +programs and filenames that would otherwise be possible.

+

Implementations are encouraged to base conversion on existing standards or +practice. Examples include the Uniform Resource Locator escape syntax of a percent sign ('%') +followed by two hex digits representing the character value. On +OpenVMS, which does not allow percent signs in filenames, a dollar sign ('$') +followed by two hex digits is the existing practice, as is converting lowercase +letters to uppercase. -- end note.]

+
+
+
+ +

+path constructors

+
path();
+
+

Postconditions: empty().

+
+
template <class InputIterator>
+  path(InputIterator begin, InputIterator end);
+
template <class Source>
+  path(Source const& source);
+
+

Effects: Stores the contents [begin,end) + or source in pathname. If the contents are in the + generic format, they are converted to the native format. [Note: For + POSIX and Windows based implementations, the generic format is already + acceptable as a native format, so no generic to native conversion is + performed. --end note]

+

+ Remarks: If the value type of  [begin,end) + or source is not value_type, the contents are + converted by codecvt().

+
+

+path assignments

+
template <class InputIterator>
+  path& assign(InputIterator begin, InputIterator end);
+
template <class Source>
+  path& operator=(Source const& source);
+
+

Effects: Stores the contents [begin,end) + or source in pathname. If the contents are in the + generic format, they are converted to the native format. [Note: For + POSIX and Windows based implementations, the generic format is already + acceptable as a native format, so no generic to native conversion is + performed. --end note]

+

+ Returns: *this

+

+ Remarks: If the value type of  [begin,end) + or source is not value_type, the contents are + converted by codecvt().

+
+

path appends

+

The append operations use operator/= to denote their semantic + effect of appending the platform's preferred directory separator when needed. The + preferred + directory separator is implementation-defined.

+
+

[Note: For POSIX-like implementations, including + Unix variants, Linux, and + Cygwin, the preferred directory separator is a + single forward slash.

+

For Windows-like implementations, including Windows and + MinGW, the preferred directory + separator is a single backslash.--end note]

+
+
path& operator/=(const path& p);
+
+

Effects:

+
+ Appends the preferred directory separator to the contained pathname, unless:
    +
  • an added separator + would be redundant, or
    • +
  • would change an relative path to an absolute path, or
    • +
  • p.empty(), or
    • +
  • *p.native().cbegin() is a directory separator.
    • +
+

Appends p.native() to pathname.

+
+

Returns: *this

+
+
template <class InputIterator>
+  path& append(InputIterator begin, InputIterator end);
+
template <class Source>
+  path& operator/=(Source const & source);
+
+

Effects:

+
+

Appends a native directory separator to the contained pathname, unless:

+
    +
  • an added separator + would be redundant, or
    • +
  • would change an relative path to an absoute path, or
    • +
  • p.empty(), or
    • +
  • *p.native().cbegin() is a separator.
    • +
+

Appends the contents [begin,end) + or source to pathname. If the contents are in the + generic format, they are converted to the native format. [Note: For + POSIX and Windows based implementations, the generic format is already + acceptable as a native format, so no generic to native conversion is + performed. --end note]

+
+

Remarks: If the value type of  [begin,end) + or source is not value_type, the contents are + converted by codecvt().

+

Returns: *this

+
+ +

+path modifiers

+
void clear();
+
+

Postcondition: this->empty() is true.

+
+
path& make_absolute(const path& base);
+
+

Preconditions: + (has_root_name() || base.has_root_name() || path("/").is_absolute()) && (has_root_directory() + || base.has_root_directory()) is true.

+

Effects: Makes m_pathname absolute by applying the following rules:

+ + + + + + + + + + + + + + + + +
 has_root_directory()!has_root_directory()
has_root_name()No changeroot_name() / base.root_directory()
+ / base.relative_path() / relative_path()
!has_root_name()base.root_name()
+ / pathname		base / pathname
+

Postconditions: + is_absolute() is true.

+

Returns: *this.

+

[Note: When portable behavior is + required, use absolute(). When operating system dependent behavior is + required, use system_complete().

+

Portable behavior is useful when dealing with paths created + internally within a program, particularly if the program should exhibit the + same behavior on all operating systems.

+

Operating system dependent behavior is useful when dealing with + paths supplied by user input, reported to program users, or when such behavior + is expected by program users. -- + end note]

+
+
path& make_preferred();
+
+

Effects: The contained pathname is converted to the preferred native + format. [Note: On Windows, the effect is to replace slashes with + backslashes. On POSIX, there is no effect. -- end note]

+

Returns: *this

+
+ +
path& remove_filename();
+
+

Returns: As if, *this = parent_path();

+

[Note: This function is needed to efficiently implement + directory_iterator. It is exposed to allow additional uses. The actual + implementation may be much more efficient than *this = parent_path()  -- end + note]

+
+
path& replace_extension(const path& new_extension = path());
+
+

Postcondition: extension() == replacement, + where replacement is new_extension if + new_extension.empty() || new_extension[0] == the dot character, + otherwise replacement is the dot character followed by + new_extension.

+

Returns: *this

+
+
void swap(path& rhs);
+
+

Effects: + Swaps the contents of the two paths.

+

Throws: + nothing.

+

Complexity: + constant time.

+
+ +

path +native format observers

+

The string returned by all native format observers is in the +native pathname format.

+
const string_type&  native() const;
+
+

Returns: pathname.

+

Throws: nothing.

+
+
const value_type* c_str() const;
+
+

Returns: pathname.c_str().

+

Throws: nothing.

+
+
template <class String>
+String string() const;
+
+

Returns: pathname.

+

Remarks: If pathname is of a different type than +String, conversion is performed using +codecvt().

+
+
const string string() const;
+const wstring wstring() const;
+const u16string u16string() const;
+const u32wstring u32wstring() const;
+
+

Returns: pathname.

+

Remarks: If pathname is not of the same type as the +function's return type, conversion is performed using +codecvt(). If pathname is of the same type as the +function's return type, the function is permitted to return by const& +rather than const value. [Note: For POSIX, this occurs for +string(), for Windows, wstring(). --end note]

+
+ +

path +generic format observers

+

The string returned by all generic format observers is in the +generic pathname format.

+

[Note: For POSIX, no conversion occurs, since the native format and +generic format are the same. For Windows, backslashes are converted to slashes +--end note]

+
template <class String>
+String generic_string() const;
+
+

Returns: pathname.

+

Remarks: If pathname is of a different type than +String, conversion is performed using +codecvt().

+
+
const string generic_string() const;
+const wstring generic_wstring() const;
+const u16string generic_u16string() const;
+const u32wstring generic_u32wstring() const;
+
+

Returns: pathname.

+

Remarks: If pathname is not of the same type as the +function's return type, conversion is performed using +codecvt(). If pathname is of the same type as the +function's return type, and the generic format is the same as the native format, +the function is permitted to return by const& rather than +const value. [Note: For POSIX, this occurs for string(). +It never occurs for Windows, because backslashes must be converted to slashes. +--end note]

+
+ +

path +decomposition

+

See the +Path decomposition table for examples +for values returned by decomposition functions. The +Tutorial may also be +helpful.

+
path root_name() const;
+
+

Returns: root-name, if pathname includes +root-name, otherwise path().

+
+
path root_directory() const;
+
+

Returns: root-directory, if pathname includes +root-directory, otherwise path().

+

If root-directory is composed of slash name, slash is +excluded from the returned string.

+
+
path root_path() const;
+
+

Returns: root_name() / root_directory()

+
+
path relative_path() const;
+
+

Returns: A path composed from pathname, if +!empty(), beginning +with the first filename after root-path. Otherwise, path().

+
+
path parent_path() const;
+
+

Returns: (empty() || begin() == --end()) ? path() : pp, where + pp is constructed as if by + starting with an empty path and successively applying + operator/= for each element in the range begin(), + --end().

+
+
path filename() const;
+
+

Returns: empty() ? path() : *--end()

+

[Example:

+
+ 
std::cout << path("/foo/bar.txt").filename(); // outputs "bar.txt" (without the quotes)
+
+

--end example]

+
+
path stem(const path& p) const;
+
+

Returns: if p.filename()contains a dot but does not + consist solely of one or to two dots, returns + the substring of p.filename() starting at its beginning and + ending at the last dot (the dot is not included). Otherwise, + returns + p.filename().

+

[Example:

+
+ 
std::cout << path("/foo/bar.txt").stem(); // outputs "bar" (without the quotes)
+ 
path p = "foo.bar.baz.tar";
+for (; !p.extension().empty(); p = p.stem())
+  std::cout << p.extension() << '\n';
+  // outputs: .tar
+  //          .baz
+  //          .bar
+
+

--end example]

+
+
path extension(const path& p) const;
+
+

Returns: if p.filename() contains a dot but does not + consist solely of one or to two dots, returns + the substring of p.filename() starting at the rightmost dot + and ending at the path's end. Otherwise, returns an empty path + object.

+

Remarks: Implementations are permitted but not required to define additional + behavior for file systems which append additional elements to extensions, such + as alternate data streams or partitioned dataset names.

+

[Example:

+
+ 
std::cout << path("/foo/bar.txt").extension(); // outputs ".txt" (without the quotes)
+
+

--end example]

+

[Note: The dot is included in the return value so that + it is possible to distinguish between no extension and an empty extension. See + + http://permalink.gmane.org/gmane.comp.lib.boost.devel/199744 for more + extensive rationale.  -- end note]

+
+

path query

+
bool empty() const;
+
+

Returns: m_pathname.empty().

+
+
bool has_root_path() const;
+
+

Returns: !root_path().empty()

+
+
bool has_root_name() const;
+
+

Returns: !root_name().empty()

+
+
bool has_root_directory() const;
+
+

Returns: !root_directory().empty()

+
+
bool has_relative_path() const;
+
+

Returns: !relative_path().empty()

+
+
bool has_parent_path() const;
+
+

Returns: !parent_path().empty()

+
+
bool has_filename() const;
+
+

Returns: !filename().empty()

+
+
bool has_stem() const;
+
+

Returns: !stem().empty()

+
+
bool has_extension() const;
+
+

Returns: !extension().empty()

+
+
bool is_absolute() const;
+
+

Returns: true + if the elements of root_path() uniquely identify a directory, else false.

+

[Note: On POSIX, + path("/foo").is_absolute() returns true. On Windows, + path("/foo").is_absolute() returns false. --end note]

+
+
bool is_relative() const;
+
+

Returns: !is_absolute().

+
+

+path iterators

+

A path::iterator is a constant iterator satisfying all +the requirements of a bidirectional iterator (C++ Std, 24.1.4 Bidirectional +iterators [lib.bidirectional.iterators]). Its value_type is +path.

+

Calling any non-const member function of a path object + invalidates all iterators referring to elements of that object.

+

The forward traversal order is as follows:

+
    +
  • The root-name element, if present.
    • +
  • The root-directory element, if present.
    • +
  • Each successive filename element, if present.
    • +
  • Dot, if one or more trailing non-root slash + characters are present.
    • +
+

The backward traversal order is the reverse of forward traversal.

+ 
iterator begin() const;
+
+

Returns: An iterator for the first present element in the traversal + list above. If no elements are present, the end iterator.

+
+
iterator end() const;
+
+

Returns: The end iterator.

+
+

path deprecated functions

+

Several member functions from previous versions of class path +have been deprecated, either because they have been renamed or because the +functionality is no longer desirable or has become obsolete.

+

Deprecated functions available by default; will be suppressed if +BOOST_FILESYSTEM_NO_DEPRECATED is defined:

+
+ 
path&  remove_leaf()           { return remove_filename(); }
+path   leaf() const            { return filename(); }
+path   branch_path() const     { return parent_path(); }
+bool   has_leaf() const        { return !m_path.empty(); }
+bool   has_branch_path() const { return !parent_path().empty(); }
+
+

Deprecated functions not available by default; will be supplied if +BOOST_FILESYSTEM_DEPRECATED is defined:

+
+ 
const std::string  file_string() const               { return native_string(); }
+const std::string  directory_string() const          { return native_string(); }
+const std::string  native_file_string() const        { return native_string(); }
+const std::string  native_directory_string() const   { return native_string(); }
+const string_type  external_file_string() const      { return native(); }
+const string_type  external_directory_string() const { return native(); }
+
+

path +non-member functions

+
void swap( path& lhs, path& rhs )
+
+

Effects: + lhs.swap(rhs).

+
+ 
bool lexicographical_compare(path::iterator first1, path::iterator last1,
+                             path::iterator first2, path::iterator last2)
+
+

Returns: true if the sequence of native() + strings for the elements defined by the range [first1,last1) is + lexicographically less than the sequence of native() strings for + the elements defined by the range [first2,last2). Returns + false otherwise.

+

Remarks: If two sequences have the same number of elements and their + corresponding elements are equivalent, then neither sequence is + lexicographically less than the other. If one sequence is a prefix of the + other, then the shorter sequence is lexicographically less than the longer + sequence. Otherwise, the lexicographical comparison of the sequences yields + the same result as the comparison of the first corresponding pair of elements + that are not equivalent.

+ 
  for ( ; first1 != last1 && first2 != last2 ; ++first1, ++first2) {
+    if (first1->native() < first2->native()) return true;
+    if (first2->native() < first1->native()) return false;
+  }
+  return first1 == last1 && first2 != last2;
+

[Note: A path aware lexicographical_compare + is provided to avoid infinite recursion in std::lexicographical_compare + due to the path iterator's value type itself being path. + --end note]

+
+
bool operator< (const path& lhs, const path& rhs);
+
+

Returns: return lexicographical_compare(lhs.begin(), lhs.end(), + rhs.begin(), rhs.end()).

+
+
bool operator<=(const path& lhs, const path& rhs);
+
+

Returns: !(rhs < lhs).

+
+
bool operator> (const path& lhs, const path& rhs);
+
+

Returns: rhs < lhs.

+
+
bool operator>=(const path& lhs, const path& rhs);
+
+

Returns: !(lhs < rhs).

+
+
bool operator==(const path& lhs, const path& rhs);
+
+

Returns: !(lhs < rhs) && !(rhs < lhs).

+

[Note: Actual implementations may use an equivalent, but more + efficient, algorithm. --end note]

+

[Note: Path equality and path + equivalence have different semantics.

+

Equality is determined by the path + non-member operator==, which considers the two path's lexical + representations only. Thus path("foo") == "bar" is never + true.

+

Equivalence is determined by the equivalent() + non-member function, which determines if two paths resolve to the same file system entity. + Thus equivalent("foo", "bar") will be true + when both paths resolve to the same file.

+

Programmers wishing to determine if two paths are "the same" must decide if + "the same" means "the same representation" or "resolve to the same actual + file", and choose the appropriate function accordingly. + -- end note]

+
+
bool operator!=(const path& lhs, const path& rhs);
+
+

Returns: !(lhs == rhs).

+
+
path operator/ (const path& lhs, const path& rhs);
+
+

Returns: path(lhs) /= rhs.

+
+

path inserters + and extractors

+
std::ostream& operator<<(std::ostream & os, const path& p);
+
+

Effects:  + os << p.string();

+

Returns: + os

+
+
std::wostream& operator<<(std::wostream & os, const path& p);
+
+

Effects:  + os << p.wstring();

+

Returns: + os

+
+
std::istream& operator>>(std::istream & is, path& p);
+
+

Effects: +   std::string str;
+        is >> str;
+        p = str;

+

Returns: + is

+
+
std::wistream& operator>>(std::wistream & is, path& p);
+
+

Effects: +   std::wstring str;
+        is >> str;
+        p = str;

+

Returns: + is

+
+

Class filesystem_error

+
  namespace boost
+  {
+    namespace filesystem
+    {
+      class basic_filesystem_error : public system_error
+      {
+      public:
+        filesystem_error();
+        filesystem_error(const filesystem_error&);
+        filesystem_error(const std::string& what_arg, system::error_code ec);
+        filesystem_error(const std::string& what_arg, const path& p1, system::error_code ec);
+        filesystem_error(const std::string& what_arg, const path& p1, const path& p2, system::error_code ec);
+
+        filesystem_error& filesystem_error(const filesystem_error&);
+       ~filesystem_error();
+
+        filesystem_error& operator=(const filesystem_error&);
+
+        const path& path1() const;
+        const path& path2() const;
+
+        const char * what() const;
+      };
+    } // namespace filesystem
+  } // namespace boost
+

The class template basic_filesystem_error defines the type of +objects thrown as exceptions to report file system errors from functions described in this +clause.

+

filesystem_error members

+
filesystem_error(const std::string& what_arg, error_code ec);
+
+

Postconditions:

+ + + + + + + + + + + + + + + + + + + + + +
ExpressionValue
+ runtime_error::what() + what_arg.c_str()
code()ec
path1().empty()true
path2().empty()true
+
+
filesystem_error(const std::string& what_arg, const path_type& p1, error_code ec);
+
+

Postconditions:

+ + + + + + + + + + + + + + + + + + + + + +
ExpressionValue
+ runtime_error::what() + what_arg.c_str()
code()ec
path1()Reference to stored copy of + p1
path2().empty()true
+
+
filesystem_error(const std::string& what_arg, const path_type& p1, const path_type& p2, error_code ec);
+
+

Postconditions:

+ + + + + + + + + + + + + + + + + + + + + +
ExpressionValue
+ runtime_error::what() + + what_arg.c_str()
code()ec
path1()Reference to stored copy of + p1
path2()Reference to stored copy of + p2
+
+
const path& path1() const;
+
+

Returns: Reference to copy of p1 stored by the + constructor, or, if none, an empty path.

+
+
const path& path2() const;
+
+

Returns: Reference to copy of p2 stored by the + constructor, or, if none, an empty path.

+
+
const char* what() const;
+
+

Returns: A string containing runtime_error::what(). The exact format is unspecified. + Implementations are encouraged but not required to include + path1.native_string()if not empty, path2.native_string()if + not empty, and system_error::what() strings in the returned + string.

+
+

Class directory_entry

+
  namespace boost
+  {
+    namespace filesystem
+    {
+      class directory_entry
+      {
+      public:
+
+        // constructors and destructor
+        directory_entry();
+        directory_entry(const directory_entry&);
+        explicit directory_entry(const path_type& p, file_status st=file_status(), file_status symlink_st=file_status());
+       ~directory_entry(); 
+
+        // modifiers
+        directory_entry& operator=(const directory_entry&);
+        void assign(const path_type& p, file_status st=file_status(), file_status symlink_st=file_status());
+        void replace_filename(const path& p, file_status st=file_status(), file_status symlink_st=file_status());
+
+        // observers
+        const path&  path() const;
+        file_status  status(system::error_code& ec) const;
+        file_status  symlink_status(system::error_code& ec) const;
+
+        bool operator< (const directory_entry& rhs);
+        bool operator==(const directory_entry& rhs); 
+        bool operator!=(const directory_entry& rhs); 
+        bool operator< (const directory_entry& rhs);
+        bool operator<=(const directory_entry& rhs);
+        bool operator> (const directory_entry& rhs);
+        bool operator>=(const directory_entry& rhs);
+
+      private:
+        path_type            m_path;           // for exposition only
+        mutable file_status  m_status;         // for exposition only; stat()-like
+        mutable file_status  m_symlink_status; // for exposition only; lstat()-like
+      };
+
+    } // namespace filesystem
+  } // namespace boost
+

A directory_entry object stores a path object, +a file_status object for non-symbolic link status, and a +file_status object for symbolic link status. The file_status +objects act as value caches.

+
+

[Note: Because status()on a pathname may be a very expensive operation, +some operating systems provide status information as a byproduct of directory +iteration. Caching such status information can result is significant time savings. Cached and +non-cached results may differ in the presence of race conditions. -- end note]

+

Actual cold-boot timing of iteration over +a directory with 15,047 entries was six seconds for non-cached status queries +versus one second for cached status queries. Windows XP, 3.0 GHz processor, with +a moderately fast hard-drive. Similar speedups are expected on Linux and BSD-derived +systems that provide status as a by-product of directory iteration.

+
+

directory_entry constructors

+
directory_entry();
+
+

Postconditions:

+ + + + + + + + + + + + + + + + + +
ExpressionValue
path().empty()true
status()file_status()
symlink_status()file_status()
+
+
explicit directory_entry(const path_type& p, file_status st=file_status(), file_status symlink_st=file_status());
+
+

Postconditions:

+ + + + + + + + + + + + + + + + + +
ExpressionValue
path()p
status()st
symlink_status()symlink_st
+
+

directory_entry modifiers

+
void assign(const path_type& p, file_status st=file_status(), file_status symlink_st=file_status());
+
+

Postconditions:

+ + + + + + + + + + + + + + + + + +
ExpressionValue
path()p
status()st
symlink_status()symlink_st
+
+
void replace_filename(const path& p, file_status st=file_status(), file_status symlink_st=file_status());
+
+

Postconditions:

+ + + + + + + + + + + + + + + + + +
ExpressionValue
path()path().branch() / s
status()st
symlink_status()symlink_st
+
+

directory_entry observers

+
const path& path() const;
+
+

Returns: m_path

+
+
file_status status(system::error_code& ec) const;
+
+

Effects: +As if,

+
+ 
if ( !status_known( m_status ) )
+{
+  if ( status_known(m_symlink_status) && !is_symlink(m_symlink_status) )
+    { m_status = m_symlink_status; }
+  else { m_status = status(m_path, ec); }
+}
+else if ( &ec != &boost::throws() ) ec.clear();
+
+

Returns: m_status

+
+
file_status  symlink_status(system::error_code& ec) const;
+
+

Effects: +As if,

+
+ 
if ( !status_known( m_symlink_status ) )
+{
+  m_symlink_status = symlink_status(m_path, ec);
+}
+else if ( &ec != &boost::throws() ) ec.clear();
+
+

Returns: + m_symlink_status

+
+
bool operator==(const directory_entry& rhs);
+
+

Returns: m_path == + rhs.m_path.

+
+
bool operator!=(const directory_entry& rhs);
+
+

Returns: m_path != + rhs.m_path.

+
+
bool operator< (const directory_entry& rhs);
+
+

Returns: m_path < + rhs.m_path.

+
+
bool operator<=(const directory_entry& rhs);
+
+

Returns: m_path <= + rhs.m_path.

+
+
bool operator> (const directory_entry& rhs);
+
+

Returns: m_path > + rhs.m_path.

+
+
bool operator>=(const directory_entry& rhs);
+
+

Returns: m_path >= + rhs.m_path.

+
+

Class directory_iterator

+

Objects of type directory_iterator provide standard library +compliant iteration over the contents of a directory. Also see class +recursive_directory_iterator.

+
  namespace boost
+  {
+    namespace filesystem
+    {
+      class directory_iterator
+        : public boost::iterator_facade< directory_iterator,
+                                         directory_entry,
+                                         boost::single_pass_traversal_tag >
+      {
+      public:
+        // member functions
+
+        directory_iterator();  // creates the "end" iterator
+        directory_iterator(const directory_iterator&);
+        explicit directory_iterator(const path& p);
+        directory_iterator(const path& p, system::error_code& ec);
+       ~directory_iterator();
+
+        directory_iterator& operator=(const directory_iterator&);
+
+        directory_iterator& operator++();
+        directory_iterator& increment(system::error_code& ec);
+
+        // other members as required by
+        //  C++ Std, 24.1.1 Input iterators [input.iterators]
+      };
+
+    } // namespace filesystem
+  } // namespace boost
+

directory_iterator satisfies the requirements of an +input iterator (C++ Std, 24.2.1, Input iterators [input.iterators]).

+

A directory_iterator reads successive elements from the directory for +which it was constructed, as if by calling POSIX + +readdir_r(). After a directory_iterator is constructed, and every time +operator++ is called, +it reads a directory element and stores information about it in a object of type +directory_entry. +operator++ is not equality preserving; that is, i == j does not imply that +++i == ++j.

+
+

[Note: The practical consequence of not preserving equality is that directory iterators +can only be used for single-pass algorithms. --end note]

+
+

If the end of the directory elements is reached, the iterator becomes equal to +the end iterator value. The constructor directory_iterator() +with no arguments always constructs an end iterator object, which is the only +legitimate iterator to be used for the end condition. The result of +operator* on an end iterator is not defined. For any other iterator value +a const directory_entry& is returned. The result of +operator-> on an end iterator is not defined. For any other iterator value a const directory_entry* is +returned.

+

Two end iterators are always equal. An end iterator is not equal to a non-end +iterator.

+
+

The above wording is based on the +Standard Library's istream_iterator wording.

+
+

The result of calling the path() member of the +directory_entry object obtained by dereferencing a +directory_iterator is a reference to a path +object composed of the directory argument from which the iterator was +constructed with filename of the directory entry appended as if by +operator/=.

+

Directory iteration shall not yield directory entries for the current (dot) +and parent (dot dot) directories.

+

The order of directory entries obtained by dereferencing successive +increments of a directory_iterator is unspecified.

+
+

[Note: Programs performing directory iteration may wish to test if the +path obtained by dereferencing a directory iterator actually exists. It could be +a +symbolic link to a non-existent file. Programs recursively +walking directory trees for purposes of removing and renaming entries may wish +to avoid following symbolic links.

+

If a file is removed from or added to a directory after the +construction of a directory_iterator for the directory, it is +unspecified whether or not subsequent incrementing of the iterator will ever +result in an iterator whose value is the removed or added directory entry. See +POSIX + +readdir_r(). +--end note]

+
+

directory_iterator members

+ +

directory_iterator();

+ +
+ +

Effects: Constructs the end iterator.

+ +

Throws: Nothing.

+ +
+ +
explicit directory_iterator(const path& p);
+directory_iterator(const path& p, system::error_code& ec);
+
+ +

Effects: Constructs a iterator representing the first +entry in the directory p resolves to, if any; otherwise, the end iterator.

+ +

Throws: As specified in + + Error reporting.

+ +

[Note: To iterate over the current directory, use +directory_iterator(".") rather than directory_iterator(""). +-- end note]

+
+
directory_iterator& operator++();
+directory_iterator& increment(system::error_code& ec);
+
+ +

Effects: As specified by the C++ Standard, 24.1.1 Input iterators [input.iterators]

+ +

Returns: *this.

+ +

Throws: As specified in + + Error reporting.

+ +
+

Class recursive_directory_iterator

+

Objects of type directory_iterator provide standard library +compliant iteration over the contents of a directory, including recursion into +its sub-directories.

+
  namespace boost
+  {
+    namespace filesystem
+    {
+      class recursive_directory_iterator :
+        public iterator<input_iterator_tag, directory_entry >
+      {
+      public:
+
+        // constructors and destructor
+        recursive_directory_iterator();
+        recursive_directory_iterator(const recursive_directory_iterator&);
+        explicit recursive_directory_iterator(const path& p);
+        recursive_directory_iterator(const path& p, system::error_code& ec);
+       ~recursive_directory_iterator();
+
+        // observers
+        int level() const;
+        bool no_push_request() const;
+
+        // modifiers
+        recursive_directory_iterator& operator=(const recursive_directory_iterator&);
+
+        recursive_directory_iterator& operator++();
+        recursive_directory_iterator& increment(system::error_code& ec);
+
+        void pop();
+        void no_push();
+
+        // other members as required by
+        //  C++ Std, 24.1.2 Input iterators [input.iterators]
+
+      private:
+        int  m_level;           // for exposition only
+        bool m_no_push_request;  // for exposition only
+      };
+
+    } // namespace filesystem
+  } // namespace boost
+

The behavior of a recursive_directory_iterator is the same +as a directory_iterator unless otherwise specified.

+
    +
  • When an iterator reaches the end of the directory currently being iterated + over, or when pop() is called, m_level is + decremented, and iteration continues with the parent directory, until the + directory specified in the constructor argument is reached.
    • +
+
+

[Note: One of the uses of no_push() is to prevent + unwanted recursion into a directory symlink. This may be necessary to + prevent loops on some operating systems. --end note]

+
+
recursive_directory_iterator();
+
+ +

Effects: Constructs the end iterator.

+ +

Throws: Nothing.

+ +
+ +
explicit recursive_directory_iterator(const path& p);
+recursive_directory_iterator(const path& p, system::error_code& ec);
+
+ +

Effects:  Constructs a iterator representing the first +entry in the directory p resolves to, if any; otherwise, the end iterator.

+ +

Postconditions: Unless the end iterator was constructed, +level() == 0, no_push_request() == false.

+ +

Throws: As specified in + + Error reporting.

+ +

[Note: To iterate over the current directory, use recursive_directory_iterator(".") rather than +recursive_directory_iterator(""). +-- end note]

+
+
int level() const;
+
+

Requires: *this != recursive_directory_iterator().

+

Returns: m_level.

+

Throws: Nothing.

+
+
bool no_push_request() const;
+
+

Requires: *this != recursive_directory_iterator().

+

Returns: m_no_push_request.

+

Throws: Nothing.

+
+
recursive_directory_iterator& operator++();
+recursive_directory_iterator& increment(system::error_code& ec);
+
+ +

Effects: As specified by the C++ Standard, 24.1.1 Input iterators [input.iterators], +except that if (*this)->is_directory() && !no_push_requested() then  m_level +is incremented and (*this)->path() is recursively iterated into.

+ +

Postconditions: no_push_request() == false.

+ +

Returns: *this.

+ +

Throws: As specified in + + Error reporting.

+ +
+
void pop();
+
+

Requires: *this != recursive_directory_iterator().

+

Effects: If level() == 0, set *this to recursive_directory_iterator(). + Otherwise, --m_level, cease iteration of the directory currently being + iterated over, and continue iteration over the parent directory.

+

Throws: Nothing.

+
+
void no_push();
+
+

Requires: *this != recursive_directory_iterator().

+

Postconditions: no_push_request() == true.

+

Throws: Nothing.

+

[Note: One of the uses of no_push() is to prevent + unwanted recursion into a directory symlink. This may be necessary to + prevent loops on some operating systems. --end note]

+
+

Class file_status

+
  namespace boost
+  {
+    namespace filesystem
+    {
+      class file_status
+      {
+      public:
+        file_status();
+        file_status(const file_status&);
+        explicit file_status(file_type v=status_error);
+       ~file_status();
+
+        file_type type() const;
+        void type(file_type v);
+      };
+    } // namespace filesystem
+  } // namespace boost
+

An object of type file_status stores information about the status of a +file. The internal form of the stored information is unspecified.

+
+

[Note: The class may be extended in the future to store + additional status information. --end note]

+
+

Members

+
explicit file_status(file_type v=status_error);
+
+

Effects: Stores v.

+

Throws: Nothing.

+
+
file_type type() const;
+
+

Returns: The stored file_type.

+
+
void type(file_type v);
+
+

Effects: Stores v, replacing the previously stored + value.

+
+

Operational functions

+

Operational functions query or modify files, including directories, in external +storage.

+

Operational functions access a file by resolving an +object of class path to a particular file in a file hierarchy. The +path is resolved as if by the POSIX + +Pathname Resolution mechanism.

+

[Note: Because hardware failures, network failures, +race conditions, and many +other kinds of errors occur frequently in file system operations, users should be aware +that any filesystem operational function, no matter how apparently innocuous, may encounter +an error. See Error reporting. -- end note]

+

Operational function specifications

+
void copy_file(const path& from, const path& to);
+
+

Effects: copy_file(from, to, + copy_option::fail_if_exists).

+ +

Throws: As specified in + + Error reporting.

+ +
+
void copy_file(const path& from, const path& to, system::error_code& ec);
+
+

Effects: copy_file(from, to, + copy_option::fail_if_exists, ec).

+ +

Throws: As specified in + + Error reporting.

+ +
+
void copy_file(const path& from, const path& to, BOOST_SCOPED_ENUM(copy_option) option);
+void copy_file(const path& from, const path& to, BOOST_SCOPED_ENUM(copy_option) option, system::error_code& ec);
+
+

Effects: If option == copy_option::fail_if_exists + && exists(to), an error is reported. Otherwise, the contents and attributes of the file from + resolves to are copied to the file to resolves to.

+

Throws: As specified in + + Error reporting.

+
+
bool create_directories(const path& p);
+bool create_directories(const path& p, system::error_code& ec);
+
+

Requires: p.empty() ||
+ forall px: px == p || is_parent(px, p): is_directory(px) || !exists( px ) +

+

Postconditions: is_directory(p)

+

Returns: The value of !exists(p) prior to the + establishment of the postcondition.

+

Throws: As specified in + + Error reporting.

+
+
bool create_directory(const path& p);
+bool create_directory(const path& p, system::error_code& ec);
+
+

Effects: Attempts to create the directory p resolves to, + as if by POSIX + mkdir() with a second argument of S_IRWXU|S_IRWXG|S_IRWXO.

+

Postcondition: is_directory(p)

+

Returns: true if a new directory was created, otherwise + false.

+

Throws: As specified in + + Error reporting.

+
+
void create_hard_link(const path& to, const path& from);
+void create_hard_link(const path& to, const path& from, system::error_code& ec);
+
+

Effects: Establishes the postcondition, as if by + POSIX + + + link().

+

Postconditions:

+
    +
  •  exists(to) && + exists(from) && equivalent(to, + from)
    • +
  • The contents of the file or directory + to resolves to are unchanged.
    • +
+

Throws: As specified in + + Error reporting.

+

[Note: + Some operating systems do not support hard links at all or support + them only for regular files. Some file systems do not support hard + links regardless of the operating system - the FAT system used on floppy + discs, memory cards and flash drives, for example. Some file systems limit the + number of links per file. Thus hard links should only be used if these + situations are not concerns, or if workarounds are provided. -- end note]

+
+
void create_symlink(const path& to, const path& from);
+void create_symlink(const path& to, const path& from, system::error_code& ec);
+
+

Effects: + Establishes the postcondition, as if by + POSIX + + + symlink().

+

+ Postconditions: from resolves to a symbolic link file that + contains an unspecified representation of to.

+

Throws: As specified in + + Error reporting.

+

[Note: + Some operating systems do not support symbolic links at all or support + them only for regular files. Windows prior to Vista, for example, did not + support symbolic links. + Some file systems do not + support + symbolic links regardless of the operating system - the FAT system used on floppy discs, memory cards and flash + drives, + for example. Thus symbolic links should only be used if these situations are + not concerns, or if workarounds are provided. -- end note]

+
+
path current_path();
+path current_path(system::error_code& ec);
+
+

Returns: The current working directory path, as if by POSIX + + + getcwd(). is_absolute() is true for the returned path.

+

Throws: As specified in + + Error reporting.

+

[Note: The current path as returned by many operating systems is a + dangerous global variable. It may be changed unexpectedly by a third-party or + system library functions, or by another thread. For a safer alternative, + see initial_path(). The + current_path() name was chosen to emphasize that the return is a + path, not just a single directory name. -- end note]

+
+
void current_path(const path& p);
+void current_path(const path& p, system::error_code& ec);
+
+

Effects: + Establishes the postcondition, as if by + POSIX + + + chdir().

+

Postconditions: equivalent(p, current_path()).

+

Throws: As specified in + +Error reporting.

+
+
bool exists(file_status s);
+
+

Returns: + status_known(s) && s.type() != file_not_found

+

Throws: Nothing.

+
+
bool exists(const path& p);
+bool exists(const path& p, system::error_code& ec);
+
+

Returns: exists(status(p)) or exists(status(p, ec)), + respectively.

+

Throws: filesystem_error; overload with error_code& throws +nothing.

+
+
bool equivalent(const path& p1, const path& p2);
+bool equivalent(const path& p1, const path& p2, system::error_code& ec);
+
+

Effects: Determines file_status s1 + and s2, as if by status(p1) and  status(p2), + respectively.

+

Returns: true, if sf1 == + sf2 and p1 and p2 resolve to the same file + system entity, else false.

+
+

Two paths are considered to resolve to the same + file system entity if two candidate entities reside on the same device at the + same location. This is determined as if by the values of the POSIX + + + stat structure, obtained as if by + + stat() for the two paths, having equal st_dev values + and equal st_ino values.

+

[Note: POSIX requires that "st_dev + must be unique within a Local Area Network". Conservative POSIX + implementations may also wish to check for equal st_size and + st_mtime values. Windows implementations may use + GetFileInformationByHandle() as a surrogate for stat(), + and consider "same" to be equal values for dwVolumeSerialNumber, + nFileIndexHigh, nFileIndexLow, nFileSizeHigh, + nFileSizeLow, ftLastWriteTime.dwLowDateTime, and + ftLastWriteTime.dwHighDateTime. -- end note]

+
+

Throws: filesystem_error + if (!exists(s1) && !exists(s2)) || (is_other(s1) && is_other(s2)), + otherwise as specified in + + Error reporting.

+
+
uintmax_t file_size(const path& p);
+uintmax_t file_size(const path& p, system::error_code& ec);
+
+

Remarks:

+

Returns: If exists(p) && is_regular_file(p), the size + in bytes + of the file p resolves to, determined as if by the value of + the POSIX + stat structure member st_size + obtained as if by POSIX + stat(). + Otherwise, static_cast<uintmax_t>(-1).

+

Throws: As specified in + + Error reporting.

+
+
const path& initial_path();
+const path& initial_path(system::error_code& ec);
+
+

Returns: current_path() at the time of entry to + main().

+

Throws: Nothing.

+

[Note: These semantics turn a dangerous global variable into a safer + global constant. --end note]

+

[Note: Full implementation requires runtime library support. + Implementations which cannot provide runtime library support are encouraged to + instead store the value of current_path() at the first call of + initial_path(), and + return this value for all subsequent calls. Programs using + initial_path() are + encouraged to call it immediately on entrance to main() so that + they will work correctly with such partial implementations. --end note]

+
+
bool is_directory(file_status s);
+
+

Returns: + s.type() == directory_file

+

Throws: Nothing.

+
+
bool is_directory(const path& p);
+bool is_directory(const path& p, system::error_code& ec);
+
+

Returns: is_directory(status(p)) or is_directory(status(p, ec)), + respectively.

+

Throws: filesystem_error; overload with error_code& throws +nothing.

+
+
bool is_empty(const path& p);
+bool is_empty(const path& p, system::error_code& ec);
+
+

Effects: Determines file_status s, as if by + status(p, ec).

+

Returns: is_directory(s)
+         ? + directory_iterator(p) == directory_iterator()
+         : file_size(p) == 0;

+
+
bool is_regular_file(file_status s);
+
+

Returns: + s.type() == regular_file

+

Throws: Nothing.

+
+
bool is_regular_file(const path& p);
+
+

Returns: is_regular_file(status(p)).

+

Throws: filesystem_error + if status(p) would throw filesystem_error.

+
+
bool is_regular_file(const path& p, system::error_code& ec);
+
+

Effects: Sets ec as if by status(p, ec). [Note: + status_error, + file_not_found + and + type_unknown + cases set ec + to error values. To distinguish between cases, call the + status + function directly. -- end + note]

+

Returns: is_regular_file(status(p, ec)).

+

Throws: Nothing.

+
+
bool is_other(file_status s);
+
+

Returns: + return exists(s) && !is_regular_file(s) && !is_directory(s) && !is_symlink(s)

+

Throws: Nothing.

+
+
bool is_other(const path& p);
+bool is_other(const path& p, system::error_code& ec);
+
+

Returns: is_other(status(p)) or is_other(status(p, ec)), + respectively.

+

Throws: filesystem_error; overload with error_code& throws + nothing.

+
+
bool is_symlink(file_status s);
+
+

Returns: + s.type() == symlink_file

+

Throws: Nothing.

+
+
bool is_symlink(const path& p);
+bool is_symlink(const path& p, system::error_code& ec);
+
+

Returns: is_symlink(symlink_status(p)) or is_symlink(symlink_status(p, ec)), + respectively.

+

Throws: filesystem_error; overload with error_code& throws + nothing.

+
+
std::time_t last_write_time(const path& p);
+std::time_t last_write_time(const path& p, system::error_code& ec);
+
+

Returns: The time of last data modification of p, determined as if by the + value of the POSIX + stat structure member st_mtime  obtained + as if by POSIX + stat().

+
+
void last_write_time(const path& p, const std::time_t new_time);
+void last_write_time(const path& p, const std::time_t new_time, system::error_code& ec);
+
+

Effects: Sets the time of last data modification of the file + resolved to by p + to new_time, as if by POSIX + stat() + followed by POSIX + + utime().

+

Throws: As specified in + + Error reporting.

+

[Note: A postcondition of last_write_time(p) == + new_time is not specified since it might not hold for file systems + with coarse time granularity. -- end note]

+
+
path read_symlink(const path& p);
+path read_symlink(const path& p, system::error_code& ec);
+
+

Returns:  If p resolves to a symbolic + link, a path object containing the contents of that symbolic + link. Otherwise an empty path object.

+

Throws: As specified in + + Error reporting. [Note: It is an error if p does not + resolve to a symbolic link. -- end note]

+
+
bool remove(const path& p);
+bool remove(const path& p, system::error_code& ec);
+
+

Effects:  If exists(symlink_status(p,ec)), it is + removed + as if by POSIX + remove().

+
+

[Note: A symbolic link is itself removed, rather than the file it + resolves to being removed. -- end note]

+
+

Postcondition: !exists(symlink_status(p)).

+

Returns:  false if p did not exist in the first + place, otherwise true.

+

Throws: As specified in + + Error reporting.

+
+
uintmax_t remove_all(const path& p);
+uintmax_t remove_all(const path& p, system::error_code& ec);
+
+

Effects:  Recursively deletes the contents of p if it exists, + then deletes file p itself, + as if by POSIX + remove().

+
+

[Note: A symbolic link is itself removed, rather than the file it + resolves to being removed. -- end note]

+
+

Postcondition: !exists(p)

+

Returns: The number of files removed.

+

Throws: As specified in + + Error reporting.

+
+
void rename(const path& old_p, const path& new_p);
+void rename(const path& old_p, const path& new_p, system::error_code& ec);
+
+

Effects: Renames old_p to new_p, as if by + POSIX + + rename().

+
+

[Note: If old_p and new_p resolve to the + same existing file, no action is taken. Otherwise, if new_p resolves to an + existing non-directory file, it is removed, while if new_p resolves to an + existing directory, it is removed if empty on POSIX but is an error on Windows. A symbolic link is itself renamed, rather than + the file it resolves to being renamed. -- end note]

+
+

Throws: As specified in + + Error reporting.

+
+
void resize_file(const path& p, uintmax_t new_size);
+void resize_file(const path& p, uintmax_t new_size, system::error_code& ec);
+
+

Postconditions: file_size() == new_size.

+

Throws: As specified in + +Error reporting.

+

Remarks: Achieves its postconditions as if by + POSIX + + truncate().

+
+
space_info space(const path& p);
+space_info space(const path& p, system::error_code& ec);
+
+

Returns: An object of type + space_info. The value of the space_info object is determined as if by + using POSIX + + statvfs() to obtain a POSIX struct + + statvfs, and then multiplying its f_blocks, + f_bfree, and f_bavail members by its f_frsize + member, and assigning the results to the capacity, free, + and available members respectively. Any members for which the + value cannot be determined shall be set to -1.

+

Throws: As specified in + + Error reporting.

+
+
file_status status(const path& p);
+
+

Effects: As if:

+
+ 
system::error_code ec;
+file_status result = status(p, ec);
+if (result == status_error)
+  throw filesystem_error(implementation-supplied-message, p, ec);
+return result;
+
+

Returns: See above.

+

Throws: filesystem_error. +[Note: result values of + file_status(file_not_found)and + file_status(type_unknown) are not considered failures and do not + cause an exception to be +thrown. -- end note]

+
+
file_status status(const path& p, system::error_code& ec);
+
+

Effects:

+
+

If possible, determines the attributes + of the file + p resolves to, as if by POSIX + stat().

+ If, during attribute determination, the underlying file system API reports + an error, sets ec to indicate the specific error reported. + Otherwise, ec.clear().
+

[Note: This allows users to inspect the specifics of underlying + API errors even when the value returned by status() is not + file_status(status_error).  --end note]

+
+
+

Returns:

+
+

If ec != error_code():

+
    +
  • If the specific error indicates that p cannot be resolved + because some element of the path does not exist, return + file_status(file_not_found). [Note: POSIX errors that + indicate this are ENOENT or ENOTDIR. Windows equivalents + include ERROR_FILE_NOT_FOUND, ERROR_PATH_NOT_FOUND, ERROR_INVALID_NAME, + ERROR_INVALID_PARAMETER, ERROR_BAD_PATHNAME, and ERROR_BAD_NETPATH. -- + end note]
    + 
    • +
  • Otherwise, if the specific error indicates that p can be resolved + but the attributes cannot be determined, return + file_status(type_unknown). [Note: For example, Windows + ERROR_SHARING_VIOLATION errors. For POSIX, the case never arises. -- end + note]
    + 
    • +
  • Otherwise, return + file_status(status_error).
    • +
+
+

[Note: These semantics distinguish between + p being known not to exist, + p existing but not being able to determine its attributes, + and there being an error that prevents even knowing if + p exists. These + distinctions are important to some use cases. --end note]

+
+

Otherwise,

+
    +
  • If the attributes indicate a regular file, as if by POSIX S_ISREG(), + return + file_status(regular_file). [Note: +regular_file implies appropriate <fstream> operations + would succeed, assuming no hardware, permission, access, or race condition + errors. Lack of +regular_file does not necessarily imply <fstream> operations would +fail on a directory. +-- end note]
    + 
    • +
  • Otherwise, if the attributes indicate a directory, as if by POSIX + S_ISDIR(), + return + file_status(directory_file). [Note: directory_file implies +directory_iterator(p)would succeed. +-- end note]
    + 
    • +
  • Otherwise, if the attributes indicate a block special file, as if by POSIX + S_ISBLK(), + return + file_status(block_file).
    + 
    • +
  • Otherwise, if the attributes indicate a character special file, as if by POSIX + S_ISCHR(), + return + file_status(character_file).
    + 
    • +
  • Otherwise, if the attributes indicate a fifo or pipe file, as if by POSIX + S_ISFIFO(), + return + file_status(fifo_file).
    + 
    • +
  • Otherwise, if the attributes indicate a socket, as if by POSIX + S_ISSOCK(), + return + file_status(socket_file).
    + 
    • +
  • Otherwise, return + file_status(type_unknown).
    • +
+
+

Throws: Nothing.

+

Remarks: If a symbolic link is encountered during pathname + resolution, + pathname resolution continues using the contents of the symbolic link.

+
+
bool status_known(file_status s);
+
+

Returns: + s.type() != status_error

+

Throws: Nothing.

+
+
file_status symlink_status(const path& p);
+file_status symlink_status(const path& p, system::error_code& ec);
+
+

Effects:  Same as status(), above, + except that the attributes + of + p are determined as if by POSIX + + lstat().

+
+
+

Returns: Same as status(), above, except + that if the attributes indicate a symbolic link, as if by POSIX + + S_ISLNK(), return file_status(symlink_file).

+

Throws: Nothing.

+

Remarks: Pathname resolution terminates if p names a symbolic link.

+
+
path system_complete(const path& p);
+path system_complete(const path& p, system::error_code& ec);
+
+

Effects: Composes an absolute path from p, using the + same rules used by the operating system to resolve a path passed as the + filename argument to standard library open functions.

+

Returns: The composed path.

+

Postconditions: For the returned path, rp, + rp.is_absolute() is true.

+

[Note: For POSIX, system_complete(p) has the same semantics as + complete(p, current_path()).

+

For Windows, system_complete(p) has the + same semantics as complete(ph, current_path()) if + p.is_absolute() || !p.has_root_name() or p and base have the same + root_name(). + Otherwise it acts like complete(p, kinky), where kinky + is the current directory for the p.root_name() drive. This will + be the current directory of that drive the last time it was set, and thus may + be residue left over from a prior program run by the command + processor! Although these semantics are often useful, they are also very + error-prone.

+

See + complete() note for usage suggestions. -- end note]

+
+
path unique_path(const path& model="%%%%-%%%%-%%%%-%%%%");
+path unique_path(const path& model, system::error_code& ec);
+
+

The unique_path function generates a path name suitable for + creating temporary files, including directories. The name is based + on a model that uses the percent sign character to specify replacement by a + random hexadecimal digit. [Note: The more bits of randomness in the + generated path name, the less likelihood of prior existence or being guessed. + Each replacement hexadecimal digit in the model adds four bits of randomness. + The default model thus provides 64 bits of randomness. This is sufficient for + most applications. --end note]

+

Returns: A path identical to model, except that each + occurrence of a percent sign character is replaced by a random hexadecimal + digit character in the range 0-9, a-f.

+

Throws: As specified in + + Error reporting.

+

Remarks: Implementations are encouraged to obtain the required + randomness via a + + cryptographically secure pseudo-random number generator, such as one + provided by the operating system. [Note: Such generators may block + until sufficient entropy develops. --end note]

+
+

File streams - +<boost/filesystem/fstream.hpp>

+

Replacements are provided for the file stream classes from the C++ standard +library's <fstream> header. These replacement classes +publicly inherit from the standard library classes. In the Boost.Filesystem +version, constructors and open functions take const path& arguments +instead of +const char* arguments. There are no other differences in syntax or +semantics.

+
namespace boost
+{
+  namespace filesystem
+  {
+    template < class charT, class traits = std::char_traits<charT> >
+    class basic_filebuf : public std::basic_filebuf<charT,traits>
+    {
+    public:
+      basic_filebuf<charT,traits>*
+        open(const path& p, std::ios_base::openmode mode);
+    };
+
+    template < class charT, class traits = std::char_traits<charT> >
+    class basic_ifstream : public std::basic_ifstream<charT,traits>
+    {
+    public:
+      explicit basic_ifstream(const path& p, std::ios_base::openmode mode=std::ios_base::in)
+      void open(const path& p, std::ios_base::openmode mode=std::ios_base::in);
+    };
+
+    template < class charT, class traits = std::char_traits<charT> >
+    class basic_ofstream : public std::basic_ofstream<charT,traits>
+    {
+    public:
+      explicit basic_ofstream(const path& p, std::ios_base::openmode mode=std::ios_base::out);
+      void open(const path& p, std::ios_base::openmode mode=std::ios_base::out);
+    };
+
+    template < class charT, class traits = std::char_traits<charT> >
+    class basic_fstream : public std::basic_fstream<charT,traits>
+    {
+    public:
+      explicit basic_fstream(const path& p,
+        std::ios_base::openmode mode=std::ios_base::in | std::ios_base::out);
+      void open(const path& p,
+        std::ios_base::openmode mode=std::ios_base::in | std::ios_base::out);
+    };
+
+    typedef basic_filebuf<char> filebuf;
+    typedef basic_ifstream<char> ifstream;
+    typedef basic_ofstream<char> ofstream;
+    typedef basic_fstream<char> fstream;
+
+    typedef basic_filebuf<wchar_t> wfilebuf;
+    typedef basic_ifstream<wchar_t> wifstream;
+    typedef basic_fstream<wchar_t> wfstream;
+    typedef basic_ofstream<wchar_t> wofstream;
+    
+  } // namespace filesystem
+} // namespace boost
+

Path decomposition table

+

The table is generated by a program compiled with the Boost implementation.

+

Shaded entries indicate cases where POSIX and Windows +implementations yield different results. The top value is the +POSIX result and the bottom value is the Windows result.
+  +

+

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Constructor
argument		Iteration
over
Elements		string()generic_
string()		root_
path()		root_
name()		root_
directory()		relative_
path()		parent_
path()		filename()
emptyemptyemptyemptyemptyemptyemptyemptyemptyempty
....emptyemptyempty.empty.
........emptyemptyempty..empty..
foofoofoofooemptyemptyemptyfooemptyfoo
/////empty/emptyempty/
/foo/,foo/foo/foo/empty/foo/foo
foo/foo,.foo/foo/emptyemptyemptyfoo/foo.
/foo//,foo,./foo//foo//empty/foo//foo.
foo/barfoo,barfoo/barfoo/baremptyemptyemptyfoo/barfoobar
/foo/bar/,foo,bar/foo/bar/foo/bar/empty/foo/bar/foobar
//net//net//net//net//net//netemptyemptyempty//net
//net/foo//net,/,foo//net/foo//net/foo//net///net/foo//net/foo
///foo////,foo,.///foo//////foo////empty/foo//////foo.
///foo///bar/,foo,bar///foo///bar///foo///bar/empty/foo///bar///foobar
/./,./././empty/./.
./.,.././emptyemptyempty./..
/../,../../../empty/../..
../..,.../../emptyemptyempty../...
foo/.foo,.foo/.foo/.emptyemptyemptyfoo/.foo.
foo/..foo,..foo/..foo/..emptyemptyemptyfoo/..foo..
foo/./foo,.,.foo/./foo/./emptyemptyemptyfoo/./foo/..
foo/./barfoo,.,barfoo/./barfoo/./baremptyemptyemptyfoo/./barfoo/.bar
foo/..foo,..foo/..foo/..emptyemptyemptyfoo/..foo..
foo/../foo,..,.foo/../foo/../emptyemptyemptyfoo/../foo/...
foo/../barfoo,..,barfoo/../barfoo/../baremptyemptyemptyfoo/../barfoo/..bar
c:c:c:c:empty
c:		empty
c:		emptyc:
empty		emptyc:
c:/c:,.
c:,/		c:/c:/empty
c:/		empty
c:		empty
/		c:/
empty		c:.
/
c:fooc:foo
c:,foo		c:fooc:fooempty
c:		empty
c:		emptyc:foo
foo		empty
c:		c:foo
foo
c:/fooc:,foo
c:,/,foo		c:/fooc:/fooempty
c:/		empty
c:		empty
/		c:/foo
foo		c:
c:/		foo
c:foo/c:foo,.
c:,foo,.		c:foo/c:foo/empty
c:		empty
c:		emptyc:foo/
foo/		c:foo.
c:/foo/c:,foo,.
c:,/,foo,.		c:/foo/c:/foo/empty
c:/		empty
c:		empty
/		c:/foo/
foo/		c:/foo.
c:/foo/barc:,foo,bar
c:,/,foo,bar		c:/foo/barc:/foo/barempty
c:/		empty
c:		empty
/		c:/foo/bar
foo/bar		c:/foobar
prn:prn:prn:prn:empty
prn:		empty
prn:		emptyprn:
empty		emptyprn:
c:\c:\
c:,/		c:\c:\
c:/		empty
c:\		empty
c:		empty
\		c:\
empty		empty
c:		c:\
\
c:fooc:foo
c:,foo		c:fooc:fooempty
c:		empty
c:		emptyc:foo
foo		empty
c:		c:foo
foo
c:\fooc:\foo
c:,/,foo		c:\fooc:\foo
c:/foo		empty
c:\		empty
c:		empty
\		c:\foo
foo		empty
c:\		c:\foo
foo
c:foo\c:foo\
c:,foo,.		c:foo\c:foo\
c:foo/		empty
c:		empty
c:		emptyc:foo\
foo\		empty
c:foo		c:foo\
.
c:\foo\c:\foo\
c:,/,foo,.		c:\foo\c:\foo\
c:/foo/		empty
c:\		empty
c:		empty
\		c:\foo\
foo\		empty
c:\foo		c:\foo\
.
c:\foo/c:\foo,.
c:,/,foo,.		c:\foo/c:\foo/
c:/foo/		empty
c:\		empty
c:		empty
\		c:\foo/
foo/		c:\foo.
c:/foo\barc:,foo\bar
c:,/,foo,bar		c:/foo\barc:/foo\bar
c:/foo/bar		empty
c:/		empty
c:		empty
/		c:/foo\bar
foo\bar		c:
c:/foo		foo\bar
bar
+ +
+

Acknowledgements

+

This Filesystem Library is dedicated to my wife, Sonda, who provided the +support necessary to see both a trial implementation and the proposal itself +through to completion. She gave me the strength to continue after a difficult +year of cancer treatment in the middle of it all.

+

Many people contributed technical comments, ideas, and suggestions to the +Boost Filesystem Library. See + +http://www.boost.org/libs/filesystem/doc/index.htm#Acknowledgements.

+

Dietmar Kuehl contributed the original Boost Filesystem Library directory_iterator design. Peter Dimov, Walter Landry, Rob Stewart, and Thomas +Witt were particularly helpful in refining the library.

+

The create_directories, extension, basename, and replace_extension functions +were developed by Vladimir Prus.

+

Howard Hinnant and John Maddock reviewed a draft of the version 2 proposal, and +identified a number of mistakes or weaknesses, resulting in a more polished +final document.

+

Peter Dimov suggested a single class path, with member templates to adapt to +multiple string types. His idea became the basis for the version 3 path design.

+

References

+ + + + + + + + + +
[ISO-POSIX]ISO/IEC 9945:2003, IEEE Std 1003.1-2001, and The Open Group + Base Specifications, Issue 6. Also known as The Single Unix® + Specification, Version 3. Available from each of the organizations involved + in its creation. For example, read online or download from + + www.unix.org/single_unix_specification/. The ISO JTC1/SC22/WG15 - + POSIX homepage is + www.open-std.org/jtc1/sc22/WG15/
[Abrahams]Dave Abrahams, Error and Exception Handling, + + www.boost.org/more/error_handling.html
+
+

© Copyright Beman Dawes, 2002, 2006, 2007, 2009, 2010

+

Distributed under the Boost Software License, Version 1.0. See +www.boost.org/LICENSE_1_0.txt

+

Revised +05 March 2010

+ + + + \ No newline at end of file diff --git a/v3/libs/filesystem/doc/tutorial.html b/v3/libs/filesystem/doc/tutorial.html new file mode 100644 index 0000000..01895a3 --- /dev/null +++ b/v3/libs/filesystem/doc/tutorial.html @@ -0,0 +1,1156 @@ + + + + + + + +Filesystem Tutorial + + + + + + + + + + +
+ +boost.png (6897 bytes) + Filesystem Tutorial +
+ + + + + +
Boost Home    + Library Home    + Reference    + Tutorial    + FAQ    + Portability    + V3 Intro    + V3 Design    + Deprecated    +
+

+ Introduction
+ Preliminaries
+ Reporting the size of a file - (tut1.cpp)
+ Using status queries to determine file existence and type - (tut2.cpp)
+ Directory iteration plus catching + exceptions - (tut3.cpp)
+ Using path decomposition, plus sorting results - (tut4.cpp)
+ Class path: Constructors, including + Unicode - (tut5.cpp)
+ Class path: Generic format vs. Native format
+ Class path: Iterators, observers, composition, decomposition, and query - (path_info.cpp)
+ Error reporting
+

+

Introduction

+ +

This tutorial develops a little command line program to list information +about files and directories - essentially a much simplified version of the POSIX ls or Windows dir +commands. We'll start with the simplest possible version and progress to more +complex functionality. Along the way we'll digress to cover topics you'll need +to know about to understand Boost.Filesystem.

+ +

Source code for each of the tutorial programs is available, and you +are encouraged to compile, test, and experiment with it. To conserve space, we won't +always show boilerplate code here, but the provided source is complete and +ready to build.

+ +

Preliminaries

+ +

Install the Boost distribution if you haven't already done so. See the +Boost Getting +Started docs.

+ +

This tutorial assumes you are going to compile and test the examples using +the provided scripts. That's highly recommended.

+ +
+ +

If you are planning to compile and test the examples but not use the +scripts, make sure your build setup knows where to +locate or build the Boost library binaries.

+ +
+

Fire up your command line interpreter, and type the following commands:

+ + + + + + + + + + +
Ubuntu Linux Microsoft Windows
+ 
$ cd boost-root/libs/filesystem/example/test
+$ ./setup
+$ ./bld
+$ ./tut1
+Usage: tut1 path
+ 		+ 
>cd boost-root\libs\filesystem\example\test
+>setup
+>bld
+>tut1
+Usage: tut1 path
+
+ +

If the tut1 command outputs "Usage: tut1 path", all +is well. A set of tutorial programs has been copied (by setup) to +boost-root/libs/filesystem/example/test +and then built. You are encouraged to modify and experiment with them as the +tutorial progresses. Just invoke the bld script again to rebuild.

+ +

If something didn't work right, here are troubleshooting suggestions:

+ +
    +
  • The bjam program executable isn't being found. + Check your path environmental variable if it should have been found, + otherwise see + Boost + Getting Started.
    + 
    • +
  • Look at bjam.log to try to spot an indication of the + problem.
    • +
+ +

Reporting the size of a file - (tut1.cpp)

+ +

Let's get started. One of the simplest things we can do is report the size of +a file.

+ + + + + +
+ 
tut1.cpp
+
+ 
#include <iostream>
+#include <boost/filesystem.hpp>
+using namespace boost::filesystem;
+
+int main(int argc, char* argv[])
+{
+  if (argc < 2)
+  {
+    std::cout << "Usage: tut1 path\n";
+    return 1;
+  }
+  std::cout << argv[1] << " " << file_size(argv[1]) << '\n';
+  return 0;
+}
+
+
+ +

The Boost.Filesystem file_size +function returns a uintmax_t +containing the size of the file named by the argument. The declaration looks +like this:

+ +
+ 
uintmax_t file_size(const path& p);
+
+

For now, all you need to know is that class path has constructors that take +const char * and many other useful types. (If you can't wait to +find out more, skip ahead to the class path section of +the tutorial.)

+

Please take a minute to try out tut1 on your system, using a +file that is known to exist, such as tut1.cpp. Here is what the +results look like on two different operating systems:

+ + + + + + + + + + +
Ubuntu Linux Microsoft Windows
+ 
$ ./tut1 tut1.cpp
+tut1.cpp 569
+ 
$ ls -l tut1.cpp
+-rwxrwxrwx 1 root root 569 2010-02-01 07:31 tut1.cpp
+ 		+ 
>tut1 tut1.cpp
+tut1.cpp 592
+>dir tut1.cpp
+...
+01/30/2010 10:47 AM 592 tut1.cpp
+...
+
+ +

So far, so good. The reported Linux and Windows sizes are different because +the Linux tests used "\n" line endings, while the Windows tests +used "\r\n" line endings.

+

Now try again, but give a path that doesn't exist:

+ + + + + + + + + + +
Ubuntu Linux Microsoft Windows
+ 
$ ./tut1 foo
+terminate called after throwing an instance of 'boost::exception_detail::
+clone_impl<boost::exception_detail::error_info_injector<boost::
+filesystem::filesystem_error> >'
+  what(): boost::filesystem::file_size: No such file or directory: "foo"
+Aborted
+ 		+ 
>tut1 foo
+

An exception is thrown; the exact form of the response depends on + Windows system options.

+ +

What happens? + There's no file named foo in the current directory, so an +exception is thrown.

+

Try this:

+ + + + + + + + + + +
Ubuntu Linux Microsoft Windows
+ 
$ ./tut1 .
+terminate called after throwing an instance of 'boost::exception_detail::
+clone_impl<boost::exception_detail::error_info_injector<boost::
+filesystem::filesystem_error> >'
+  what(): boost::filesystem::file_size: Operation not permitted "."
+Aborted
+ 		+ 
>tut1 .
+

An exception is thrown; the exact form of the response depends on + Windows system options.

+ +

The current directory exists, but file_size() works on regular + files, not directories, so again, an exception is thrown.

+ +

We'll deal with those situations in tut2.cpp.

+ +

Using status queries to determine file existence and type - (tut2.cpp)

+ +

Boost.Filesystem includes status query functions such as +exists, +is_directory, and +is_regular_file. These return +bool's, and will return true if the condition +described by their name is met. Otherwise they return false, +including when any element +of the path argument can't be found.

+ +

tut2.cpp uses several of the status query functions to cope with non-existent +files and with different kinds of files:

+ + + + + +
+ 
tut2.cpp
+
+ 
int main(int argc, char* argv[])
+{
+  path p (argv[1]);   // p reads clearer than argv[1] in the following code
+
+  if (exists(p))    // does p actually exist?
+  {
+    if (is_regular_file(p))        // is p a regular file?   
+      cout << p << " size is " << file_size(p) << '\n';
+
+    else if (is_directory(p))      // is p a directory?
+      cout << p << "is a directory\n";
+
+    else
+      cout << p << "exists, but is neither a regular file nor a directory\n";
+  }
+  else
+    cout << p << "does not exist\n";
+
+  return 0;
+}
+
+
+ +

Give it a try:

+ + + + + + + + + + +
Ubuntu Linux Microsoft Windows
+ 
$ ./tut2 tut2.cpp
+tut2 size is cpp 1037
+$ ./tut2 foo
+foo does not exist
+$ ./tut2 .
+. is a directory
+ 		+ 
>tut2 tut2.cpp
+tut2.cpp size is 1079
+
+>tut2 foo
+foo does not exist
+
+>tut2 .
+. is a directory
+
+ +

Although tut2 works OK in these tests, the output is less than satisfactory +for a directory. We'd typically like to see a list of the directory's contents. In tut3.cpp +we will see how to iterate over directories.

+ +

But first, let's try one more test:

+ + + + + + + + + + +
Ubuntu Linux Microsoft Windows
+ 
$ ls /home/jane/foo
+ls: cannot access /home/jane/foo: Permission denied
+$ ./tut2 /home/jane/foo
+terminate called after throwing an instance of 'boost::exception_detail::
+clone_impl<boost::exception_detail::error_info_injector<boost::
+filesystem::filesystem_error> >'
+   what(): boost::filesystem::status: Permission denied:
+     "/home/jane/foo"
+Aborted
+ 		+ 
>dir e:\
+The device is not ready.
+>tut2 e:\
+

An exception is thrown; the exact form of the response depends on + Windows system options.

+ +

On the Linux system, the test was being run from an account that did not have +permission to access /home/jane/foo. On the Windows system, +e: was a Compact Disc reader/writer that was not ready. End users +shouldn't have to interpret cryptic exceptions reports, so as we move on to tut3.cpp +we will increase the robustness of the code, too.

+ +

Directory iteration plus catching +exceptions - (tut3.cpp)

+ +

Boost.Filesystem's +directory_iterator class is just what we need here. It follows the +general pattern of the standard library's istream_iterator. Constructed from +a path, it iterates over the contents of the directory. A default constructed directory_iterator +acts as the end iterator.

+ +

The value type of directory_iterator is +directory_entry. A +directory_entry object contains a path and file_status +information.  A +directory_entry object +can be used directly, but can also be passed to path arguments in function calls.

+ +

The other need is increased robustness in the face of the many kinds of +errors that can affect file system operations. We could do that at the level of +each call to a Boost.Filesystem function (see Error +reporting), but it is easier to supply an overall try/catch block.

+ + + + + +
+ 
tut3.cpp
+
+ 
int main(int argc, char* argv[])
+{
+  path p (argv[1]);   // p reads clearer than argv[1] in the following code
+
+  try
+  {
+    if (exists(p))    // does p actually exist?
+    {
+      if (is_regular_file(p))        // is p a regular file?   
+        cout << p << " size is " << file_size(p) << '\n';
+
+      else if (is_directory(p))      // is p a directory?
+      {
+        cout << p << " is a directory containing:\n";
+
+        copy(directory_iterator(p), directory_iterator(), // directory_iterator::value_type
+          ostream_iterator<directory_entry>(cout, "\n")); // is directory_entry, which is
+                                                          // converted to a path by the
+                                                          // path stream inserter
+      }
+
+      else
+        cout << p << " exists, but is neither a regular file nor a directory\n";
+    }
+    else
+      cout << p << " does not exist\n";
+  }
+
+  catch (const filesystem_error& ex)
+  {
+    cout << ex.what() << '\n';
+  }
+
+  return 0;
+}
+
+
+ +

Give tut3 a try, passing it a path to a directory as a command line argument. +Here is a run on a checkout of the Boost Subversion trunk, followed by a repeat +of the test cases that caused exceptions on Linux and Windows:

+ + + + + + + + + + +
Ubuntu Linux Microsoft Windows
+ 
$ ./tut3 ~/boost/trunk
+/home/beman/boost/trunk is a directory containing:
+  /home/beman/boost/trunk/tools
+  /home/beman/boost/trunk/boost-build.jam
+  /home/beman/boost/trunk/dist
+  /home/beman/boost/trunk/doc
+  /home/beman/boost/trunk/bootstrap.sh
+  /home/beman/boost/trunk/index.html
+  /home/beman/boost/trunk/bootstrap.bat
+  /home/beman/boost/trunk/boost.css
+  /home/beman/boost/trunk/INSTALL
+  /home/beman/boost/trunk/rst.css
+  /home/beman/boost/trunk/boost
+  /home/beman/boost/trunk/people
+  /home/beman/boost/trunk/wiki
+  /home/beman/boost/trunk/boost.png
+  /home/beman/boost/trunk/LICENSE_1_0.txt
+  /home/beman/boost/trunk/more
+  /home/beman/boost/trunk/Jamroot
+  /home/beman/boost/trunk/.svn
+  /home/beman/boost/trunk/libs
+  /home/beman/boost/trunk/index.htm
+  /home/beman/boost/trunk/status
+  /home/beman/boost/trunk/CMakeLists.txt
+ 		+ 
>tut3 c:\boost\trunk
+c:\boost\trunk is a directory containing:
+   c:\boost\trunk\.svn
+   c:\boost\trunk\boost
+   c:\boost\trunk\boost-build.jam
+   c:\boost\trunk\boost.css
+   c:\boost\trunk\boost.png
+   c:\boost\trunk\bootstrap.bat
+   c:\boost\trunk\bootstrap.sh
+   c:\boost\trunk\CMakeLists.txt
+   c:\boost\trunk\dist
+   c:\boost\trunk\doc
+   c:\boost\trunk\index.htm
+   c:\boost\trunk\index.html
+   c:\boost\trunk\INSTALL
+   c:\boost\trunk\Jamroot
+   c:\boost\trunk\libs
+   c:\boost\trunk\LICENSE_1_0.txt
+   c:\boost\trunk\more
+   c:\boost\trunk\people
+   c:\boost\trunk\rst.css
+   c:\boost\trunk\status
+   c:\boost\trunk\tools
+   c:\boost\trunk\wiki
+
+>tut3 e:\
+boost::filesystem::status: The device is not ready: "e:\"
+
+ +

Not bad, but we can make further improvements:

+ +
    +
  • The listing would be much easier to read if only the filename was + displayed, rather than the full path.
    + 
    • +
  • The Linux listing isn't sorted. That's because the ordering of + directory iteration is unspecified. Ordering depends on the underlying + operating system API and file system specifics. So we need to sort the + results ourselves.
    • +
+ +

Move on to tut4.cpp to see how those changes play out!

+ +

Using path decomposition, plus sorting results - (tut4.cpp)

+ + + + + +
+ 
tut4.cpp
+
+ 
int main(int argc, char* argv[])
+{
+  path p (argv[1]);   // p reads clearer than argv[1] in the following code
+
+  try
+  {
+    if (exists(p))    // does p actually exist?
+    {
+      if (is_regular_file(p))        // is p a regular file?   
+        cout << p << " size is " << file_size(p) << '\n';
+
+      else if (is_directory(p))      // is p a directory?
+      {
+        cout << p << " is a directory containing:\n";
+
+        typedef vector<path> vec;             // store paths,
+        vec v;                                // so we can sort them later
+
+        copy(directory_iterator(p), directory_iterator(), back_inserter(v));
+
+        sort(v.begin(), v.end());             // sort, since directory iteration
+                                              // is not ordered on some file systems
+  
+        for (vec::const_iterator it (v.begin()); it != v.end(); ++it)
+        {
+          cout << "   " << *it << '\n';
+        }
+      }
+
+      else
+        cout << p << " exists, but is neither a regular file nor a directory\n";
+    }
+    else
+      cout << p << " does not exist\n";
+  }
+
+  catch (const filesystem_error& ex)
+  {
+    cout << ex.what() << '\n';
+  }
+
+  return 0;
+}
+
+
+ +

The key difference between tut3.cpp and tut4.cpp is + what happens in the directory iteration loop. We changed:

+
+ 
cout << " " << *it << '\n';   // *it returns a directory_entry,
+
+

to:

+
+ 
path fn = it->path().filename();   // extract the filename from the path
+v.push_back(fn);                   // push into vector for later sorting
+
+

path() + is a directory_entry observer function. + filename() is one of + several path decomposition functions. It extracts the filename portion ("index.html") + from a path ("/home/beman/boost/trunk/index.html"). These decomposition functions are + more fully explored in the Path iterators, observers, + composition, decomposition and query portion of this tutorial.

+

The above was written as two lines of code for clarity. It could have + been written more concisely as:

+
+ 
v.push_back(it->path().filename()); // we only care about the filename
+
+

Here is the output from a test of tut4.cpp:

+ + + + + + + + + + +
Ubuntu Linux Microsoft Windows
+ 
$ ./tut4 ~/boost/trunk
+/home/beman/boost/trunk is a directory containing:
+  .svn
+  CMakeLists.txt
+  INSTALL
+  Jamroot
+  LICENSE_1_0.txt
+  boost
+  boost-build.jam
+  boost.css
+  boost.png
+  bootstrap.bat
+  bootstrap.sh
+  doc
+  index.htm
+  index.html
+  libs
+  more
+  people
+  rst.css
+  status
+  tools
+  wiki
+ 		+ 
C:\v3d>tut4 c:\boost\trunk
+c:\boost\trunk is a directory containing:
+  .svn
+  CMakeLists.txt
+  INSTALL
+  Jamroot
+  LICENSE_1_0.txt
+  boost
+  boost-build.jam
+  boost.css
+  boost.png
+  bootstrap.bat
+  bootstrap.sh
+  doc
+  index.htm
+  index.html
+  libs
+  more
+  people
+  rst.css
+  status
+  tools
+  wiki
+
+ +

That completes the main portion of this tutorial. If you haven't already + worked through the Class path sections of this tutorial, dig into them now. + The Error reporting section may also be of + interest, although it can be skipped unless you are deeply concerned about + error handling issues.

+ +
+ +

 Class path: Constructors, +including Unicode - (tut5.cpp)

+ +

Traditional C interfaces pass paths as const char* arguments. +C++ interfaces may add const std::string& overloads, but adding +overloads becomes untenable if wide characters, containers, and iterator ranges +need to be supported.

+

Passing paths as const path& arguments is far simpler, yet far +more flexible because class path itself is far more flexible:

+
    +
  1. Class path supports multiple character types and encodings, including Unicode, to + ease internationalization.
    2. +
  2. Class path supports multiple source types, such as iterators for null terminated + sequences, iterator ranges, containers (including std::basic_string), + and directory_entry's, + so functions taking paths don't need to provide several overloads.
    3. +
  3. Class path supports both native and generic pathname formats, so programs can be + portable between operating systems yet use native formats where desirable.
    4. +
  4. Class path supplies a full set of iterators, observers, composition, + decomposition, and query functions, making pathname manipulations easy, + convenient, reliable, and portable.
    5. +
+

Here is how (1) and (2) work. Class path constructors, +assignments, and appends have member templates for sources. For example, here +are the constructors that take sources:

+ +
+ 
template <class Source>
+  path(Source const& source);
+ 
template <class InputIterator>
+  path(InputIterator begin, InputIterator end);
+
+

Let's look at a little program that shows how comfortable class path is with +both narrow and wide characters in C-style strings, C++ strings, and via C++ +iterators:

+ + + + + +
+ 
tut5.cpp
+
+ 
#include <boost/filesystem.hpp>
+#include <string>
+#include <list>
+namespace fs = boost::filesystem;
+
+int main()
+{
+  // \u263A is "Unicode WHITE SMILING FACE = have a nice day!"
+  std::string narrow_string ("smile2");
+  std::wstring wide_string (L"smile2\u263A");
+  std::list<char> narrow_list;
+  narrow_list.push_back('s');
+  narrow_list.push_back('m');
+  narrow_list.push_back('i');
+  narrow_list.push_back('l');
+  narrow_list.push_back('e');
+  narrow_list.push_back('3');
+  std::list<wchar_t> wide_list;
+  wide_list.push_back(L's');
+  wide_list.push_back(L'm');
+  wide_list.push_back(L'i');
+  wide_list.push_back(L'l');
+  wide_list.push_back(L'e');
+  wide_list.push_back(L'3');
+  wide_list.push_back(L'\u263A');
+
+  { fs::ofstream f("smile"); }
+  { fs::ofstream f(L"smile\u263A"); }
+  { fs::ofstream f(narrow_string); }
+  { fs::ofstream f(wide_string); }
+  { fs::ofstream f(narrow_list); }
+  { fs::ofstream f(wide_list); }
+  narrow_list.pop_back();
+  narrow_list.push_back('4');
+  wide_list.pop_back();
+  wide_list.pop_back();
+  wide_list.push_back(L'4');
+  wide_list.push_back(L'\u263A');
+  { fs::ofstream f(fs::path(narrow_list.begin(), narrow_list.end())); }
+  { fs::ofstream f(fs::path(wide_list.begin(), wide_list.end())); }
+
+  return 0;
+}
+
+
+ +

Testing tut5:

+ + + + + + + + + + +
Ubuntu Linux Microsoft Windows
+ 
$ ./tut5
+$ ls smile*
+smile smile☺ smile2 smile2☺ smile3 smile3☺ smile4 smile4☺
+ 		+ 
>tut5
+>dir /b smile*
+smile
+smile2
+smile2☺
+smile3
+smile3☺
+smile4
+smile4☺
+smile☺
+
+ +

Note that the exact appearance of the smiling face will depend on the font, +font size, and other settings for your command line window. The above tests were +run with out-of-the-box Ubuntu 9.10 and Windows 7, US Edition. If you don't get +the above results, take a look at the boost-root/libs/filesystem/example/test +directory with your system's GUI file browser, such as Linux Nautilus, Mac OS X +Finder, or Windows Explorer. These tend to be more comfortable with +international character sets than command line interpreters.

+ +

Class path takes care of whatever character type or encoding + conversions are required by the particular operating system. Thus as + tut5 demonstrates, it's no problem to pass a wide character string to a + Boost.Filesystem operational function even if the underlying operating system + uses narrow characters, and visa versa. And the same applies to user supplied + functions that take const path& arguments.

+ +

Class path also provides path syntax that is portable across operating systems, + element iterators, and observer, composition, decomposition, and query + functions to manipulate the elements of a path. The next section of this + tutorial deals with path syntax.

+ +
+ +

Class path: Generic format vs. Native format

+ +

Class path deals with two different pathname +formats - generic format and native format. For POSIX-like +file systems, these formats are the same. But for users of Windows and +other non-POSIX file systems, the distinction is important. Even +programmers writing for POSIX-like systems need to understand the distinction if +they want their code to be portable to non-POSIX systems.

+ +

The generic format is the familiar /my_directory/my_file.txt format used by POSIX-like +operating systems such as the Unix variants, Linux, and Mac OS X. Windows also +recognizes the generic format, and it is the basis for the familiar Internet URL +format. The directory +separator character is always one or more slash characters.

+ +

The native format is the format as defined by the particular +operating system. For Windows, either the slash or the backslash can be used as +the directory separator character. If a drive specifier or a backslash appears +in a pathname on a Windows system, it is always treated as the native format.

+ +

We can use tut4 to explore the two formats:

+ + + + + + + + + + +
Ubuntu Linux Microsoft Windows
+ 
$ ./tut4 tut4.cpp
+tut4.cpp: 1920
+
+$ ./tut4 ./tut4.cpp
+./tut4.cpp: 1920
+
+$ ./tut4 .\tut4.cpp
+.tut4.cpp: does not exist
+
+$ ./tut4 .\\tut4.cpp
+.\tut4.cpp: does not exist
+ 		+ 
>tut4 tut4.cpp
+tut4.cpp: 1984
+
+>tut4 ./tut4.cpp
+./tut4.cpp: 1984
+
+>tut4 .\tut4.cpp
+.\tut4.cpp: 1984
+
+>tut4 .\\tut4.cpp
+.\\tut4.cpp: 1984
+
+ +

The distinction between generic format and native format is important when + communicating with native C-style API's and with users. Both tend to expect + paths in the native format and are confused by the generic format. The generic + format is great, however, for writing portable programs that work regardless + of operating system.

+ +

The next section covers class path observers, composition, + decomposition, query, and iteration over the elements of a path.

+ +
+ +

Class path: Iterators, observers, composition, decomposition, and query +- (path_info.cpp)

+ +

The path_info.cpp program is handy for learning how class path +iterators, +observers, composition, decomposition, and query functions work on your system. +If it hasn't already already been built on your system, please build it now. Run +the examples below on your system, and try some different path arguments as we +go along.

+ +

path_info produces several dozen output lines every time it's +invoked. We will only show the output lines we are interested in at each step.

+ +

First we'll look at iteration over the elements of a path, and then use +iteration to illustrate the difference between generic and native format paths.

+ + + + + + + + + + +
Ubuntu Linux Microsoft Windows
+ 
$ ./path_info /foo/bar/baa.txt
+...
+elements:
+  /
+  foo
+  bar
+  baa.txt
+ 		+ 
>path_info /foo/bar/baa.txt
+...
+elements:
+  /
+  foo
+  bar
+  baa.txt
+
+ +

Thus on both POSIX and Windows based systems the path "/foo/bar/baa.txt" +is seen as having four elements.

+ +

Here is the code that produced the above listing:

+ + + + + +
+
+ 
cout << "\nelements:\n";
+
+for (path::iterator it = p.begin(); it != p.end(); ++it)
+  cout << " " << *it << '\n';
+
+
+

path::iterator::value_type is path::string_type, +and iteration treats path as a container of filenames.

+ +

Let's look at some of the output from a slightly different +example:

+ + + + + + + + + + +
Ubuntu Linux Microsoft Windows
+ 
$ ./path_info /foo/bar/baa.txt
+
+composed path:
+  cout << -------------: /foo/bar/baa.txt
+  preferred()----------: /foo/bar/baa.txt
+...
+observers, native format:
+  native()-------------: /foo/bar/baa.txt
+  c_str()--------------: /foo/bar/baa.txt
+  string()-------------: /foo/bar/baa.txt
+  wstring()------------: /foo/bar/baa.txt
+
+observers, generic format:
+  generic_string()-----: /foo/bar/baa.txt
+  generic_wstring()----: /foo/bar/baa.txt
+ 		+ 
>path_info /foo/bar\baa.txt
+
+composed path:
+  cout << -------------: /foo/bar/baa.txt
+  preferred()----------: \foo\bar\baa.txt
+...
+observers, native format:
+  native()-------------: /foo/bar\baa.txt
+  c_str()--------------: /foo/bar\baa.txt
+  string()-------------: /foo/bar\baa.txt
+  wstring()------------: /foo/bar\baa.txt
+
+observers, generic format:
+  generic_string()-----: /foo/bar/baa.txt
+  generic_wstring()----: /foo/bar/baa.txt
+
+ +

Native format observers should be used when interacting with the +operating system or with users; that's what they expect.

+ +

Generic format observers should be used when the results need to be +portable and uniform regardless of the operating system.

+ +

path objects always hold pathnames in the native +format, but otherwise leave them unchanged from their source. The +preferred() function will convert to the +preferred form, if the native format has several forms. Thus on Windows, it will +convert slashes to backslashes.

+ +

Let's move on to decomposition and query functions:

+ + + + + + + + + + +
Ubuntu Linux Microsoft Windows
+ 
$ ./path_info /foo/bar/baa.txt
+...
+decomposition:
+  root_name()----------:
+  root_directory()-----: /
+  root_path()----------: /
+  relative_path()------: foo/bar/baa.txt
+  parent_path()--------: /foo/bar
+  filename()-----------: baa.txt
+  stem()---------------: baa
+  extension()----------: .txt
+
+query:
+  empty()--------------: false
+  is_absolute()--------: true
+  has_root_name()------: false
+  has_root_directory()-: true
+  has_root_path()------: true
+  has_relative_path()--: true
+  has_parent_path()----: true
+  has_filename()-------: true
+  has_stem()-----------: true
+  has_extension()------: true
+ 		+ 
>path_info /foo/bar/baa.txt
+...
+decomposition:
+  root_name()----------:
+  root_directory()-----: /
+  root_path()----------: /
+  relative_path()------: foo/bar/baa.txt
+  parent_path()--------: /foo/bar
+  filename()-----------: baa.txt
+  stem()---------------: baa
+  extension()----------: .txt
+
+query:
+  empty()--------------: false
+  is_absolute()--------: false
+  has_root_name()------: false
+  has_root_directory()-: true
+  has_root_path()------: true
+  has_relative_path()--: true
+  has_parent_path()----: true
+  has_filename()-------: true
+  has_stem()-----------: true
+  has_extension()------: true
+
+ +

These are pretty self-evident, but do note the difference in the +result of is_absolute() between Linux and Windows. Because there is +no root name (i.e. drive specifier or network name), a lone slash (or backslash) +is a relative path on Windows.

+ +

On to composition!

+ +

Class path uses / and /= operators to +append elements. That's a reminder +that these operations append the operating system's preferred directory +separator if needed. The preferred +directory separator is a slash on POSIX-like systems, and a backslash on +Windows-like systems.

+ +

path_info.cpp +composes a path by appending each of the command line elements to an initially +empty path:

+ + + + + +
+
+ 
path p;  // compose a path from the command line arguments
+
+for (; argc > 1; --argc, ++argv)
+  p /= argv[1];
+
+cout << "\ncomposed path:\n";
+cout << " cout << -------------: " << p << "\n";
+cout << " preferred()----------: " << p.preferred() << "\n";
+
+
+ +

Let's give this code a try:

+ + + + + + + + + + +
Ubuntu Linux Microsoft Windows
+ 
$ ./path_info / foo/bar baa.txt
+
+composed path:
+  cout << -------------: /foo/bar/baa.txt
+  preferred()----------: /foo/bar/baa.txt
+ 		+ 
>path_info / foo/bar baa.txt
+
+composed path:
+  cout << -------------: /foo/bar\baa.txt
+  preferred()----------: \foo\bar\baa.txt
+
+ +

 

+ +
+ +

Error reporting

+ +

The Boost.Filesystem file_size function has two overloads:

+ +
+ 
uintmax_t file_size(const path& p);
+uintmax_t file_size(const path& p, system::error_code& ec);
+
+

The only significant difference between the two is how they report errors.

+

The + first signature will throw exceptions to report errors. A +filesystem_error exception will be thrown +on an + operational error. filesystem_error is derived from std::runtime_error. +It has a + member function to obtain the +error_code reported by the source + of the error. It also has member functions to obtain the path or paths that caused + the error.

+ +
+ +

Motivation for the second signature: Throwing exceptions on errors was the entire error reporting story for the earliest versions of + Boost.Filesystem, and indeed throwing exceptions on errors works very well for + many applications. But user reports trickled in that some code became so + littered with try and catch blocks as to be unreadable and unmaintainable. In + some applications I/O errors aren't exceptional, and that's the use case for + the second signature.

+ +
+ +

Functions with a system::error_code& argument set that + argument to report operational error status, and so do not throw exceptions when I/O + related errors occur. For a full explanation, see + Error reporting in the reference + documentation.

+ +
+

© Copyright Beman Dawes 2010

+

Distributed under the Boost Software License, Version 1.0. See +www.boost.org/LICENSE_1_0.txt

+

Revised +02 March 2010

+ + + + \ No newline at end of file diff --git a/v3/libs/filesystem/doc/v3.html b/v3/libs/filesystem/doc/v3.html new file mode 100644 index 0000000..7ecd3e3 --- /dev/null +++ b/v3/libs/filesystem/doc/v3.html @@ -0,0 +1,129 @@ + + + + + + +Filesystem V3 Intro + + + + + + + + + +
+ +boost.png (6897 bytes) + Filesystem + Version 3
+ Introduction
+ + + + + +
Boost Home    + Library Home    + Reference    + Tutorial    + FAQ    + Portability    + V3 Intro    + V3 Design    + Deprecated    +
+ +

Boost Filesystem Version 3

+ +

Version 3 is a major revision of the Boost Filesystem library. Important +changes include:

+ +
    +
  • A single class path handles all aspects of + internationalization, replacing the previous template and its path + and wpath instantiations. Character types char, + wchar_t, char16_t, and char32_t are + supported. This is a major simplification of the path abstraction, + particularly for functions that take path arguments.
    + 
    • +
  • New class path members include:
    +  + +
    • +
  • New or improved operations functions include:
    + 
      +
    • create_symlink() now supported on both POSIX and Windows.
      • +
    • read_symlink() function added. Supported on both POSIX and + Windows. Used to read the contents of a symlink itself.
      • +
    • resize_file() function added. Supported on both POSIX and + Windows. Used to shrink or grow a regular file.
      • +
    • unique_path() function added. Supported on both POSIX and + Windows. Used to generate a secure temporary pathname.
      + 
      • +
    +
    • +
  • Support for error reporting via error_code is now uniform + throughout the operations functions.
    + 
    • +
  • Documentation has been reworked, including re-writes of major portions.
    + 
    • +
  • A new Tutorial provides a hopefully much + gentler and more complete introduction for new users. Current users might want + to review the three sections related to class path.
    + 
    • +
+ +

Breaking changes

+ +

To ease the transition, Versions 2 and 3 will both be included in the next +several Boost releases. Version 2 will be the default version for one release +cycle, and then Version 3 will become the default version.

+

Class path

+
    +
  • Class template basic_path and its specializations are gone.
    • +
  • Certain functions now return path objects rather than + basic_string objects:
      +
    • root_name()
      • +
    • root_directory()
      • +
    • filename()
      • +
    • stem()
      • +
    • extension()
      • +
    +
    • +
  •  path::iterator::value_type and  + path::const_iterator::value_type is path rather than + basic_string.
    • +
+

Compiler support

+
    +
  • Compilers and standard libraries that do not fully support wide characters + and wide character strings (wstring) are no longer supported. + This impacts primarily Cygwin users; versions prior to 1.7 are no longer + supported.
    + 
    • +
  • Microsoft VC++ 7.1 and earlier are no longer supported.
    • +
+ +
+

© Copyright Beman Dawes, 2009

+

Distributed under the Boost Software License, Version 1.0. See +www.boost.org/LICENSE_1_0.txt

+

Revised +22 February 2010

+ + + + \ No newline at end of file diff --git a/v3/libs/filesystem/doc/v3_design.html b/v3/libs/filesystem/doc/v3_design.html new file mode 100644 index 0000000..fb3f24d --- /dev/null +++ b/v3/libs/filesystem/doc/v3_design.html @@ -0,0 +1,192 @@ + + + + + + + +Filesystem V3 Design + + + + + + + + + + +
+ +boost.png (6897 bytes) + Filesystem Version 3
+ Design
+ + + + + +
Boost Home    + Library Home    + Reference    + Tutorial    + FAQ    + Portability    + V3 Intro    + V3 Design    + Deprecated    +
+ + + + + + + + +
+ Contents
+ Introduction
+ Problem
+ Solution
+ Details
+ Other changes
+ Acknowledgements
+ +

Caution: This page documents thinking early in the V3 development +process, and is intended to serve historical purposes. It is not updated to +reflect the current state of the library.

+ +

Introduction

+ +

During the review of Boost.Filesystem.V2 (Internationalization), Peter Dimov +suggested that the basic_path class template was unwieldy, and that a single +path type that accommodated multiple character types and encodings would be more +flexible. Although I wasn't willing to stop development at that time to +explore how this idea might be implemented, or to break from the pattern for +Internationalization used the C++ standard library, I've often thought about +Peter's suggestion. With the advent of C++0x char16_t and char32_t character +types, the basic_path class template approach becomes even more unwieldy, so it +is time to revisit the problem in light of Peter's suggestion.

+ +

Problem

+ +

With Filesystem.V2, a path argument to a user defined function that is to +accommodate multiple character types and encodings must be written as a +template. Do-the-right-thing overloads or template metaprogramming must be +employed to allow arguments to be written as string literals. Here's what it +looks like:

+ +
+ 
template<class Path>
+void foo( const Path & p );
+ 
inline void foo( const path & p )
+{
+  return foo<path>( p );
+}
+inline void foo( const wpath & p )
+{
+  return foo<wpath>( p );
+}
+
+

That's really ugly for such a simple need, and there would be a combinatorial +explosion if the function took multiple Path arguments and each could be either +narrow or wide. It gets even worse if the C++0x char16_t and +char32_t types are to be supported.

+ +

Solution

+ +

Overview:

+ +
    +
  • A single, non-template, class path.
    • +
  • Each member function is a template accommodating the various + applicable character types, including user-defined character types.
    • +
  • Hold the path internally in a string of the type used by the operating + system API; std::string for POSIX, std::wstring for Windows.
    • +
+ +

The signatures presented in Problem collapse to +simply:

+
+ 
void foo( const path & p );
+
+ +

That's a signification reduction in code complexity. Specification becomes +simpler, too. I believe it will be far easier to teach, and result in much more +flexible user code.

+ +

Other benefits:

+
    +
  • All the polymorphism still occurs at compile time.
    • +
  • Efficiency is increased, in that conversions of the encoding, if required, + only occur once at the time of creation, not each time the path is used.
    • +
  • The size of the implementation code drops approximately in half and + becomes much more readable.
    • +
+

Possible problems:

+
    +
  • The combination of member function templates and implicit constructors can + result in unclear error messages when the user makes simple commonplace coding + errors. This should be much less of a problem with C++ concepts, but in the + meantime work continues to restrict over aggressive templates via enable_if/disable_if.
    • +
+

Details

+ + + + + + + + + + + + + + + + + + + + +
+

Encoding Conversions

+

Host system

 +

char string path arguments

 +

wide string path arguments

Systems with char as the native API path character type (i.e. + POSIX-like systems)No conversion.Conversion occurs, performed by the current path locale's + codecvt facet.
Systems with wchar_t as the native API path character type + (i.e. Windows-like systems).Conversion occurs, performed by the current path locale's + codecvt facet.No conversion.
+ +

When a class path function argument type matches the the operating system's +API argument type for paths, no conversion is performed rather than conversion +to a specified encoding such as one of the Unicode encodings. This avoids +unintended consequences, etc.

+ +

Other changes

+ +

Uniform hybrid error handling: The hybrid error handling idiom has +been consistently applied to all applicable functions.

+ +

Acknowledgements

+ +

Peter Dimov suggested the idea of a single path class that could cope with +multiple character types and encodings. Walter Landry contributed both the design and implementation of the copy_any, +copy_directory, copy_symlink, and read_symlink functions.

+ +
+

Revised +18 February, 2010

+ +

© Copyright Beman Dawes, 2008

+

Use, modification, and distribution are subject to the Boost Software +License, Version 1.0. See +www.boost.org/LICENSE_1_0.txt

+ + + + \ No newline at end of file diff --git a/v3/libs/filesystem/example/Jamfile.v2 b/v3/libs/filesystem/example/Jamfile.v2 new file mode 100644 index 0000000..8dda450 --- /dev/null +++ b/v3/libs/filesystem/example/Jamfile.v2 @@ -0,0 +1,24 @@ +# Boost Filesystem Library Example Jamfile + +# (C) Copyright Vladimir Prus 2003 + +# Distributed under the Boost Software License, Version 1.0. +# See www.boost.org/LICENSE_1_0.txt + +# Library home page: http://www.boost.org/libs/filesystem + +project + : requirements + /boost/filesystem//boost_filesystem + /boost/system//boost_system + msvc:on + static + ; + +exe tut0 : tut0.cpp ; +exe tut1 : tut1.cpp ; +exe tut2 : tut2.cpp ; +exe tut3 : tut3.cpp ; +exe tut4 : tut4.cpp ; +exe tut5 : tut5.cpp ; +exe path_info : path_info.cpp ; diff --git a/v3/libs/filesystem/example/error_demo.cpp b/v3/libs/filesystem/example/error_demo.cpp new file mode 100644 index 0000000..ce16b3b --- /dev/null +++ b/v3/libs/filesystem/example/error_demo.cpp @@ -0,0 +1,185 @@ +// error_demo.cpp --------------------------------------------------------------------// + +// Copyright Beman Dawes 2009 + +// Distributed under the Boost Software License, Version 1.0. +// See http://www.boost.org/LICENSE_1_0.txt + +// Library home page: http://www.boost.org/libs/filesystem + +//--------------------------------------------------------------------------------------// +// // +// The purpose of this program is to demonstrate how error reporting works. // +// // +//--------------------------------------------------------------------------------------// + +#include +#include +#include + +using std::cout; +using boost::filesystem::path; +using boost::filesystem::filesystem_error; +using boost::system::error_code; +using boost::system::system_error; +namespace fs = boost::filesystem; + +namespace +{ + void report_system_error(const system_error& ex) + { + cout << " threw system_error:\n" + << " ex.code().value() is " << ex.code().value() << '\n' + << " ex.code().category().name() is " << ex.code().category().name() << '\n' + << " ex.what() is " << ex.what() << '\n' + ; + } + + void report_filesystem_error(const system_error& ex) + { + cout << " threw filesystem_error exception:\n" + << " ex.code().value() is " << ex.code().value() << '\n' + << " ex.code().category().name() is " << ex.code().category().name() << '\n' + << " ex.what() is " << ex.what() << '\n' + ; + } + + void report_status(fs::file_status s) + { + cout << " file_status::type() is "; + switch (s.type()) + { + case fs::status_error: + cout << "status_error\n"; break; + case fs::file_not_found: + cout << "file_not_found\n"; break; + case fs::regular_file: + cout << "regular_file\n"; break; + case fs::directory_file: + cout << "directory_file\n"; break; + case fs::symlink_file: + cout << "symlink_file\n"; break; + case fs::block_file: + cout << "block_file\n"; break; + case fs::character_file: + cout << "character_file\n"; break; + case fs::fifo_file: + cout << "fifo_file\n"; break; + case fs::socket_file: + cout << "socket_file\n"; break; + case fs::type_unknown: + cout << "type_unknown\n"; break; + default: + cout << "not a valid enumeration constant\n"; + } + } + + void report_error_code(const error_code& ec) + { + cout << " ec:\n" + << " value() is " << ec.value() << '\n' + << " category().name() is " << ec.category().name() << '\n' + << " message() is " << ec.message() << '\n' + ; + } + + bool threw_exception; + +} + +int main(int argc, char* argv[]) +{ + if (argc < 2) + { + cout << "Usage: error_demo path\n"; + return 1; + } + + error_code ec; + + //// construct path - no error_code + + //try { path p1(argv[1]); } + //catch (const system_error& ex) + //{ + // cout << "construct path without error_code"; + // report_system_error(ex); + //} + + //// construct path - with error_code + + path p (argv[1]); + + fs::file_status s; + bool b (false); + fs::directory_iterator di; + + // get status - no error_code + + cout << "\nstatus(\"" << p.string() << "\");\n"; + threw_exception = false; + + try { s = fs::status(p); } + catch (const system_error& ex) + { + report_filesystem_error(ex); + threw_exception = true; + } + if (!threw_exception) + cout << " Did not throw exception\n"; + report_status(s); + + // get status - with error_code + + cout << "\nstatus(\"" << p.string() << "\", ec);\n"; + s = fs::status(p, ec); + report_status(s); + report_error_code(ec); + + // query existence - no error_code + + cout << "\nexists(\"" << p.string() << "\");\n"; + threw_exception = false; + + try { b = fs::exists(p); } + catch (const system_error& ex) + { + report_filesystem_error(ex); + threw_exception = true; + } + if (!threw_exception) + { + cout << " Did not throw exception\n" + << " Returns: " << (b ? "true" : "false") << '\n'; + } + + // query existence - with error_code + + // directory_iterator - no error_code + + cout << "\ndirectory_iterator(\"" << p.string() << "\");\n"; + threw_exception = false; + + try { di = fs::directory_iterator(p); } + catch (const system_error& ex) + { + report_filesystem_error(ex); + threw_exception = true; + } + if (!threw_exception) + { + cout << " Did not throw exception\n" + << (di == fs::directory_iterator() ? " Equal" : " Not equal") + << " to the end iterator\n"; + } + + // directory_iterator - with error_code + + cout << "\ndirectory_iterator(\"" << p.string() << "\", ec);\n"; + di = fs::directory_iterator(p, ec); + cout << (di == fs::directory_iterator() ? " Equal" : " Not equal") + << " to the end iterator\n"; + report_error_code(ec); + + return 0; +} diff --git a/v3/libs/filesystem/example/file_size.cpp b/v3/libs/filesystem/example/file_size.cpp new file mode 100644 index 0000000..3fbfa4e --- /dev/null +++ b/v3/libs/filesystem/example/file_size.cpp @@ -0,0 +1,44 @@ +// file_size program -------------------------------------------------------// + +// Copyright Beman Dawes, 2004 + +// Use, modification, and distribution is subject to the Boost Software +// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org/libs/filesystem for documentation. + +#include +#include + +namespace fs = boost::filesystem; + +int main( int argc, char* argv[] ) +{ + + if ( argc != 2 ) + { + std::cout << "Usage: file_size path\n"; + return 1; + } + + std::cout << "sizeof(intmax_t) is " << sizeof(boost::intmax_t) << '\n'; + + fs::path p( argv[1] ); + + if ( !fs::exists( p ) ) + { + std::cout << "not found: " << argv[1] << std::endl; + return 1; + } + + if ( !fs::is_regular( p ) ) + { + std::cout << "not a regular file: " << argv[1] << std::endl; + return 1; + } + + std::cout << "size of " << argv[1] << " is " << fs::file_size( p ) + << std::endl; + return 0; +} diff --git a/v3/libs/filesystem/example/mbcopy.cpp b/v3/libs/filesystem/example/mbcopy.cpp new file mode 100644 index 0000000..2b1f603 --- /dev/null +++ b/v3/libs/filesystem/example/mbcopy.cpp @@ -0,0 +1,90 @@ +// Boost.Filesystem mbcopy.cpp ---------------------------------------------// + +// Copyright Beman Dawes 2005 + +// Use, modification, and distribution is subject to the Boost Software +// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// Copy the files in a directory, using mbpath to represent the new file names +// See http://../doc/path.htm#mbpath for more information + +// See deprecated_test for tests of deprecated features +#define BOOST_FILESYSTEM_NO_DEPRECATED + +#include +# ifdef BOOST_FILESYSTEM_NARROW_ONLY +# error This compiler or standard library does not support wide-character strings or paths +# endif + +#include "mbpath.hpp" +#include +#include +#include +#include "../src/utf8_codecvt_facet.hpp" + +namespace fs = boost::filesystem; + +namespace +{ + // we can't use boost::filesystem::copy_file() because the argument types + // differ, so provide a not-very-smart replacement. + + void copy_file( const fs::wpath & from, const user::mbpath & to ) + { + fs::ifstream from_file( from, std::ios_base::in | std::ios_base::binary ); + if ( !from_file ) { std::cout << "input open failed\n"; return; } + + fs::ofstream to_file( to, std::ios_base::out | std::ios_base::binary ); + if ( !to_file ) { std::cout << "output open failed\n"; return; } + + char c; + while ( from_file.get(c) ) + { + to_file.put(c); + if ( to_file.fail() ) { std::cout << "write error\n"; return; } + } + + if ( !from_file.eof() ) { std::cout << "read error\n"; } + } +} + +int main( int argc, char * argv[] ) +{ + if ( argc != 2 ) + { + std::cout << "Copy files in the current directory to a target directory\n" + << "Usage: mbcopy \n"; + return 1; + } + + // For encoding, use Boost UTF-8 codecvt + std::locale global_loc = std::locale(); + std::locale loc( global_loc, new fs::detail::utf8_codecvt_facet ); + user::mbpath_traits::imbue( loc ); + + std::string target_string( argv[1] ); + user::mbpath target_dir( user::mbpath_traits::to_internal( target_string ) ); + + if ( !fs::is_directory( target_dir ) ) + { + std::cout << "Error: " << argv[1] << " is not a directory\n"; + return 1; + } + + for ( fs::wdirectory_iterator it( L"." ); + it != fs::wdirectory_iterator(); ++it ) + { + if ( fs::is_regular_file(it->status()) ) + { + copy_file( *it, target_dir / it->path().filename() ); + } + } + + return 0; +} + + + + + diff --git a/v3/libs/filesystem/example/mbpath.cpp b/v3/libs/filesystem/example/mbpath.cpp new file mode 100644 index 0000000..4359001 --- /dev/null +++ b/v3/libs/filesystem/example/mbpath.cpp @@ -0,0 +1,80 @@ +// Boost.Filesystem mbpath.cpp ---------------------------------------------// + +// (c) Copyright Beman Dawes 2005 + +// Use, modification, and distribution is subject to the Boost Software +// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// See Boost.Filesystem home page at http://www.boost.org/libs/filesystem + +#include +# ifdef BOOST_FILESYSTEM_NARROW_ONLY +# error This compiler or standard library does not support wide-character strings or paths +# endif + +#include "mbpath.hpp" +#include +#include + +namespace fs = boost::filesystem; + +namespace +{ + // ISO C calls this "the locale-specific native environment": + std::locale loc(""); + + const std::codecvt * + cvt( &std::use_facet > + ( loc ) ); +} + +namespace user +{ + mbpath_traits::external_string_type + mbpath_traits::to_external( const mbpath & ph, + const internal_string_type & src ) + { + std::size_t work_size( cvt->max_length() * (src.size()+1) ); + boost::scoped_array work( new char[ work_size ] ); + std::mbstate_t state; + const internal_string_type::value_type * from_next; + external_string_type::value_type * to_next; + if ( cvt->out( + state, src.c_str(), src.c_str()+src.size(), from_next, work.get(), + work.get()+work_size, to_next ) != std::codecvt_base::ok ) + boost::throw_exception >( + fs::basic_filesystem_error( + "user::mbpath::to_external conversion error", + ph, boost::system::error_code( EINVAL, boost::system::errno_ecat ) ) ); + *to_next = '\0'; + return external_string_type( work.get() ); + } + + mbpath_traits::internal_string_type + mbpath_traits::to_internal( const external_string_type & src ) + { + std::size_t work_size( src.size()+1 ); + boost::scoped_array work( new wchar_t[ work_size ] ); + std::mbstate_t state; + const external_string_type::value_type * from_next; + internal_string_type::value_type * to_next; + if ( cvt->in( + state, src.c_str(), src.c_str()+src.size(), from_next, work.get(), + work.get()+work_size, to_next ) != std::codecvt_base::ok ) + boost::throw_exception >( + fs::basic_filesystem_error( + "user::mbpath::to_internal conversion error", + boost::system::error_code( EINVAL, boost::system::errno_ecat ) ) ); + *to_next = L'\0'; + return internal_string_type( work.get() ); + } + + void mbpath_traits::imbue( const std::locale & new_loc ) + { + loc = new_loc; + cvt = &std::use_facet + >( loc ); + } + +} // namespace user diff --git a/v3/libs/filesystem/example/mbpath.hpp b/v3/libs/filesystem/example/mbpath.hpp new file mode 100644 index 0000000..f752b3f --- /dev/null +++ b/v3/libs/filesystem/example/mbpath.hpp @@ -0,0 +1,44 @@ +// Boost.Filesystem mbpath.hpp ---------------------------------------------// + +// Copyright Beman Dawes 2005 + +// Use, modification, and distribution is subject to the Boost Software +// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// Encodes wide character paths as MBCS +// See http://../doc/path.htm#mbpath for more information + +#include +#include // for std::mbstate_t +#include +#include + +namespace user +{ + struct mbpath_traits; + + typedef boost::filesystem::basic_path mbpath; + + struct mbpath_traits + { + typedef std::wstring internal_string_type; + typedef std::string external_string_type; + + static external_string_type to_external( const mbpath & ph, + const internal_string_type & src ); + + static internal_string_type to_internal( const external_string_type & src ); + + static void imbue( const std::locale & loc ); + }; +} // namespace user + +namespace boost +{ + namespace filesystem + { + template<> struct is_basic_path + { static const bool value = true; }; + } +} diff --git a/v3/libs/filesystem/example/path_info.cpp b/v3/libs/filesystem/example/path_info.cpp new file mode 100644 index 0000000..5c32b20 --- /dev/null +++ b/v3/libs/filesystem/example/path_info.cpp @@ -0,0 +1,83 @@ +// path_info.cpp ---------------------------------------------------------------------// + +// Copyright Beman Dawes 2009 + +// Distributed under the Boost Software License, Version 1.0. +// See http://www.boost.org/LICENSE_1_0.txt + +// Library home page: http://www.boost.org/libs/filesystem + +#include +#include +using namespace std; +using namespace boost::filesystem; + +const char * say_what(bool b) { return b ? "true" : "false"; } + +int main(int argc, char* argv[]) +{ + if (argc < 2) + { + cout << "Usage: path_info path-portion...\n" + "Example: path_info foo/bar baz\n" +# ifdef BOOST_POSIX_API + " would report info about the composed path foo/bar/baz\n"; +# else // BOOST_WINDOWS_API + " would report info about the composed path foo/bar\\baz\n"; +# endif + return 1; + } + + path p; // compose a path from the command line arguments + + for (; argc > 1; --argc, ++argv) + p /= argv[1]; + + cout << "\ncomposed path:\n"; + cout << " cout << -------------: " << p << "\n"; + cout << " make_preferred()----------: " << path(p).make_preferred() << "\n"; + + cout << "\nelements:\n"; + + for (path::iterator it(p.begin()), it_end(p.end()); it != it_end; ++it) + cout << " " << *it << '\n'; + + cout << "\nobservers, native format:" << endl; +# ifdef BOOST_POSIX_API + cout << " native()-------------: " << p.native() << endl; + cout << " c_str()--------------: " << p.c_str() << endl; +# else // BOOST_WINDOWS_API + wcout << L" native()-------------: " << p.native() << endl; + wcout << L" c_str()--------------: " << p.c_str() << endl; +# endif + cout << " string()-------------: " << p.string() << endl; + wcout << L" wstring()------------: " << p.wstring() << endl; + + cout << "\nobservers, generic format:\n"; + cout << " generic_string()-----: " << p.generic_string() << endl; + wcout << L" generic_wstring()----: " << p.generic_wstring() << endl; + + cout << "\ndecomposition:\n"; + cout << " root_name()----------: " << p.root_name() << '\n'; + cout << " root_directory()-----: " << p.root_directory() << '\n'; + cout << " root_path()----------: " << p.root_path() << '\n'; + cout << " relative_path()------: " << p.relative_path() << '\n'; + cout << " parent_path()--------: " << p.parent_path() << '\n'; + cout << " filename()-----------: " << p.filename() << '\n'; + cout << " stem()---------------: " << p.stem() << '\n'; + cout << " extension()----------: " << p.extension() << '\n'; + + cout << "\nquery:\n"; + cout << " empty()--------------: " << say_what(p.empty()) << '\n'; + cout << " is_absolute()--------: " << say_what(p.is_absolute()) << '\n'; + cout << " has_root_name()------: " << say_what(p.has_root_name()) << '\n'; + cout << " has_root_directory()-: " << say_what(p.has_root_directory()) << '\n'; + cout << " has_root_path()------: " << say_what(p.has_root_path()) << '\n'; + cout << " has_relative_path()--: " << say_what(p.has_relative_path()) << '\n'; + cout << " has_parent_path()----: " << say_what(p.has_parent_path()) << '\n'; + cout << " has_filename()-------: " << say_what(p.has_filename()) << '\n'; + cout << " has_stem()-----------: " << say_what(p.has_stem()) << '\n'; + cout << " has_extension()------: " << say_what(p.has_extension()) << '\n'; + + return 0; +} diff --git a/v3/libs/filesystem/example/simple_ls.cpp b/v3/libs/filesystem/example/simple_ls.cpp new file mode 100644 index 0000000..db2939e --- /dev/null +++ b/v3/libs/filesystem/example/simple_ls.cpp @@ -0,0 +1,84 @@ +// simple_ls program -------------------------------------------------------// + +// Copyright Jeff Garland and Beman Dawes, 2002 + +// Use, modification, and distribution is subject to the Boost Software +// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org/libs/filesystem for documentation. + +// As an example program, we don't want to use any deprecated features +#define BOOST_FILESYSTEM_NO_DEPRECATED + +#include "boost/filesystem/operations.hpp" +#include "boost/filesystem/path.hpp" +#include "boost/progress.hpp" +#include + +namespace fs = boost::filesystem; + +int main(int argc, char* argv[]) +{ + fs::path p(fs::initial_path()); + + if (argc > 1) + p = fs::system_complete(argv[1]); + else + std::cout << "\nusage: simple_ls [path]" << std::endl; + + unsigned long file_count = 0; + unsigned long dir_count = 0; + unsigned long other_count = 0; + unsigned long err_count = 0; + + if (!fs::exists(p)) + { + std::cout << "\nNot found: " << p << std::endl; + return 1; + } + + if (fs::is_directory(p)) + { + std::cout << "\nIn directory: " << p << "\n\n"; + fs::directory_iterator end_iter; + for (fs::directory_iterator dir_itr(p); + dir_itr != end_iter; + ++dir_itr) + { + try + { + if (fs::is_directory(dir_itr->status())) + { + ++dir_count; + std::cout << dir_itr->path().filename() << " [directory]\n"; + } + else if (fs::is_regular_file(dir_itr->status())) + { + ++file_count; + std::cout << dir_itr->path().filename() << "\n"; + } + else + { + ++other_count; + std::cout << dir_itr->path().filename() << " [other]\n"; + } + + } + catch (const std::exception & ex) + { + ++err_count; + std::cout << dir_itr->path().filename() << " " << ex.what() << std::endl; + } + } + std::cout << "\n" << file_count << " files\n" + << dir_count << " directories\n" + << other_count << " others\n" + << err_count << " errors\n"; + } + else // must be a file + { + std::cout << "\nFound: " << p << "\n"; + } + return 0; +} diff --git a/v3/libs/filesystem/example/tchar.cpp b/v3/libs/filesystem/example/tchar.cpp new file mode 100644 index 0000000..5f33d69 --- /dev/null +++ b/v3/libs/filesystem/example/tchar.cpp @@ -0,0 +1,39 @@ +// Example use of Microsoft TCHAR ----------------------------------------------------// + +// Copyright Beman Dawes 2008 + +// Distributed under the Boost Software License, Version 1.0. +// See http://www.boost.org/LICENSE_1_0.txt + +#include +#include +#include +#include +#include +#include + +namespace fs = boost::filesystem; + +typedef std::basic_string tstring; + +void func( const fs::path & p ) +{ + assert( fs::exists( p ) ); +} + +int main() +{ + // get a path that is known to exist + fs::path cp = fs::current_path(); + + // demo: get tstring from the path + tstring cp_as_tstring = cp.string(); + + // demo: pass tstring to filesystem function taking path + assert( fs::exists( cp_as_tstring ) ); + + // demo: pass tstring to user function taking path + func( cp_as_tstring ); + + return 0; +} diff --git a/v3/libs/filesystem/example/test/Jamfile.v2 b/v3/libs/filesystem/example/test/Jamfile.v2 new file mode 100644 index 0000000..3b3dde5 --- /dev/null +++ b/v3/libs/filesystem/example/test/Jamfile.v2 @@ -0,0 +1,31 @@ +# Boost Filesystem Library Tutorial Jamfile + +# (C) Copyright Beman Dawes 2010 +# (C) Copyright Vladimir Prus 2003 + +# Distributed under the Boost Software License, Version 1.0. +# See www.boost.org/LICENSE_1_0.txt + +# Library home page: http://www.boost.org/libs/filesystem + +project + : requirements + /boost/filesystem//boost_filesystem + /boost/system//boost_system + msvc:on + ; + +exe tut1 : tut1.cpp ; +exe tut2 : tut2.cpp ; +exe tut3 : tut3.cpp ; +exe tut4 : tut4.cpp ; +exe tut5 : tut5.cpp ; +exe path_info : path_info.cpp ; + +install tut1-copy : tut1 : . ; +install tut2-copy : tut2 : . ; +install tut3-copy : tut3 : . ; +install tut4-copy : tut4 : . ; +install tut5-copy : tut5 : . ; +install path_info-copy : path_info : . ; + diff --git a/v3/libs/filesystem/example/test/bld.bat b/v3/libs/filesystem/example/test/bld.bat new file mode 100644 index 0000000..9768600 --- /dev/null +++ b/v3/libs/filesystem/example/test/bld.bat @@ -0,0 +1,7 @@ +@echo off +rem Copyright Beman Dawes, 2010 +rem Distributed under the Boost Software License, Version 1.0. +rem See www.boost.org/LICENSE_1_0.txt + +bjam %* >bjam.log +find "error" bjam.log +grep "error" nul +copy /y ..\tut2.cpp >nul +copy /y ..\tut3.cpp >nul +copy /y ..\tut4.cpp >nul +copy /y ..\tut5.cpp >nul +copy /y ..\path_info.cpp >nul +del *.exe 2>nul +del *.pdb 2>nul diff --git a/v3/libs/filesystem/example/test/setup.sh b/v3/libs/filesystem/example/test/setup.sh new file mode 100755 index 0000000..c2f3c79 --- /dev/null +++ b/v3/libs/filesystem/example/test/setup.sh @@ -0,0 +1,19 @@ +#!/usr/bin/env bash + +# Copyright Beman Dawes, 2010 +# Distributed under the Boost Software License, Version 1.0. +# See www.boost.org/LICENSE_1_0.txt + +cp ../tut1.cpp . +cp ../tut2.cpp . +cp ../tut3.cpp . +cp ../tut4.cpp . +cp ../tut5.cpp . +cp ../path_info.cpp . +rm tut1 2>~/junk +rm tut2 2>~/junk +rm tut3 2>~/junk +rm tut4 2>~/junk +rm tut5 2>~/junk +rm path_info 2>~/junk + diff --git a/v3/libs/filesystem/example/tut0.cpp b/v3/libs/filesystem/example/tut0.cpp new file mode 100644 index 0000000..4055100 --- /dev/null +++ b/v3/libs/filesystem/example/tut0.cpp @@ -0,0 +1,25 @@ +// filesystem tut0.cpp ---------------------------------------------------------------// + +// Copyright Beman Dawes 2009 + +// Distributed under the Boost Software License, Version 1.0. +// See http://www.boost.org/LICENSE_1_0.txt + +// Library home page: http://www.boost.org/libs/filesystem + +#include +#include +namespace fs = boost::filesystem; + +int main(int argc, char* argv[]) +{ + if (argc < 2) + { + std::cout << "Usage: tut0 path\n"; + return 1; + } + + std::cout << argv[1] << '\n'; + + return 0; +} diff --git a/v3/libs/filesystem/example/tut1.cpp b/v3/libs/filesystem/example/tut1.cpp new file mode 100644 index 0000000..3ac85b9 --- /dev/null +++ b/v3/libs/filesystem/example/tut1.cpp @@ -0,0 +1,23 @@ +// filesystem tut1.cpp ---------------------------------------------------------------// + +// Copyright Beman Dawes 2009 + +// Distributed under the Boost Software License, Version 1.0. +// See http://www.boost.org/LICENSE_1_0.txt + +// Library home page: http://www.boost.org/libs/filesystem + +#include +#include +using namespace boost::filesystem; + +int main(int argc, char* argv[]) +{ + if (argc < 2) + { + std::cout << "Usage: tut1 path\n"; + return 1; + } + std::cout << argv[1] << " " << file_size(argv[1]) << '\n'; + return 0; +} diff --git a/v3/libs/filesystem/example/tut2.cpp b/v3/libs/filesystem/example/tut2.cpp new file mode 100644 index 0000000..2ca8562 --- /dev/null +++ b/v3/libs/filesystem/example/tut2.cpp @@ -0,0 +1,40 @@ +// filesystem tut2.cpp ---------------------------------------------------------------// + +// Copyright Beman Dawes 2009 + +// Distributed under the Boost Software License, Version 1.0. +// See http://www.boost.org/LICENSE_1_0.txt + +// Library home page: http://www.boost.org/libs/filesystem + +#include +#include +using namespace std; +using namespace boost::filesystem; + +int main(int argc, char* argv[]) +{ + if (argc < 2) + { + cout << "Usage: tut2 path\n"; + return 1; + } + + path p (argv[1]); // p reads clearer than argv[1] in the following code + + if (exists(p)) // does p actually exist? + { + if (is_regular_file(p)) // is p a regular file? + cout << p << " size is " << file_size(p) << '\n'; + + else if (is_directory(p)) // is p a directory? + cout << p << " is a directory\n"; + + else + cout << p << " exists, but is neither a regular file nor a directory\n"; + } + else + cout << p << " does not exist\n"; + + return 0; +} diff --git a/v3/libs/filesystem/example/tut3.cpp b/v3/libs/filesystem/example/tut3.cpp new file mode 100644 index 0000000..bb4494e --- /dev/null +++ b/v3/libs/filesystem/example/tut3.cpp @@ -0,0 +1,56 @@ +// filesystem tut3.cpp ---------------------------------------------------------------// + +// Copyright Beman Dawes 2009 + +// Distributed under the Boost Software License, Version 1.0. +// See http://www.boost.org/LICENSE_1_0.txt + +// Library home page: http://www.boost.org/libs/filesystem + +#include +#include +#include +#include +using namespace std; +using namespace boost::filesystem; + +int main(int argc, char* argv[]) +{ + if (argc < 2) + { + cout << "Usage: tut3 path\n"; + return 1; + } + + path p (argv[1]); // p reads clearer than argv[1] in the following code + + try + { + if (exists(p)) // does p actually exist? + { + if (is_regular_file(p)) // is p a regular file? + cout << p << " size is " << file_size(p) << '\n'; + + else if (is_directory(p)) // is p a directory? + { + cout << p << " is a directory containing:\n"; + + copy(directory_iterator(p), directory_iterator(), // directory_iterator::value_type + ostream_iterator(cout, "\n")); // is directory_entry, which is + // converted to a path by the + // path stream inserter + } + else + cout << p << " exists, but is neither a regular file nor a directory\n"; + } + else + cout << p << " does not exist\n"; + } + + catch (const filesystem_error& ex) + { + cout << ex.what() << '\n'; + } + + return 0; +} diff --git a/v3/libs/filesystem/example/tut4.cpp b/v3/libs/filesystem/example/tut4.cpp new file mode 100644 index 0000000..5888c3a --- /dev/null +++ b/v3/libs/filesystem/example/tut4.cpp @@ -0,0 +1,65 @@ +// filesystem tut4.cpp ---------------------------------------------------------------// + +// Copyright Beman Dawes 2009 + +// Distributed under the Boost Software License, Version 1.0. +// See http://www.boost.org/LICENSE_1_0.txt + +// Library home page: http://www.boost.org/libs/filesystem + +#include +#include +#include +#include +#include +using namespace std; +using namespace boost::filesystem; + +int main(int argc, char* argv[]) +{ + if (argc < 2) + { + cout << "Usage: tut4 path\n"; + return 1; + } + + path p (argv[1]); // p reads clearer than argv[1] in the following code + + try + { + if (exists(p)) // does p actually exist? + { + if (is_regular_file(p)) // is p a regular file? + cout << p << " size is " << file_size(p) << '\n'; + + else if (is_directory(p)) // is p a directory? + { + cout << p << " is a directory containing:\n"; + + typedef vector vec; // store paths, + vec v; // so we can sort them later + + copy(directory_iterator(p), directory_iterator(), back_inserter(v)); + + sort(v.begin(), v.end()); // sort, since directory iteration + // is not ordered on some file systems + + for (vec::const_iterator it(v.begin()), it_end(v.end()); it != it_end; ++it) + { + cout << " " << *it << '\n'; + } + } + else + cout << p << " exists, but is neither a regular file nor a directory\n"; + } + else + cout << p << " does not exist\n"; + } + + catch (const filesystem_error& ex) + { + cout << ex.what() << '\n'; + } + + return 0; +} diff --git a/v3/libs/filesystem/example/tut5.cpp b/v3/libs/filesystem/example/tut5.cpp new file mode 100644 index 0000000..d665b0d --- /dev/null +++ b/v3/libs/filesystem/example/tut5.cpp @@ -0,0 +1,52 @@ +// filesystem tut5.cpp ---------------------------------------------------------------// + +// Copyright Beman Dawes 2010 + +// Distributed under the Boost Software License, Version 1.0. +// See http://www.boost.org/LICENSE_1_0.txt + +// Library home page: http://www.boost.org/libs/filesystem + +#include +#include +#include +namespace fs = boost::filesystem; + +int main() +{ + // \u263A is "Unicode WHITE SMILING FACE = have a nice day!" + std::string narrow_string ("smile2"); + std::wstring wide_string (L"smile2\u263A"); + std::list narrow_list; + narrow_list.push_back('s'); + narrow_list.push_back('m'); + narrow_list.push_back('i'); + narrow_list.push_back('l'); + narrow_list.push_back('e'); + narrow_list.push_back('3'); + std::list wide_list; + wide_list.push_back(L's'); + wide_list.push_back(L'm'); + wide_list.push_back(L'i'); + wide_list.push_back(L'l'); + wide_list.push_back(L'e'); + wide_list.push_back(L'3'); + wide_list.push_back(L'\u263A'); + + { fs::ofstream f("smile"); } + { fs::ofstream f(L"smile\u263A"); } + { fs::ofstream f(narrow_string); } + { fs::ofstream f(wide_string); } + { fs::ofstream f(narrow_list); } + { fs::ofstream f(wide_list); } + narrow_list.pop_back(); + narrow_list.push_back('4'); + wide_list.pop_back(); + wide_list.pop_back(); + wide_list.push_back(L'4'); + wide_list.push_back(L'\u263A'); + { fs::ofstream f(fs::path(narrow_list.begin(), narrow_list.end())); } + { fs::ofstream f(fs::path(wide_list.begin(), wide_list.end())); } + + return 0; +} diff --git a/v3/libs/filesystem/index.html b/v3/libs/filesystem/index.html new file mode 100644 index 0000000..86e86eb --- /dev/null +++ b/v3/libs/filesystem/index.html @@ -0,0 +1,14 @@ + + + + + +Automatic redirection failed, please go to +doc/index.htm. +
+

© Copyright Beman Dawes, 2003

+

Distributed under the Boost Software +License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +www.boost.org/LICENSE_1_0.txt)

+ + diff --git a/v3/libs/filesystem/src/codecvt_error_category.cpp b/v3/libs/filesystem/src/codecvt_error_category.cpp new file mode 100644 index 0000000..1932961 --- /dev/null +++ b/v3/libs/filesystem/src/codecvt_error_category.cpp @@ -0,0 +1,80 @@ +// codecvt_error_category implementation file ----------------------------------------// + +// Copyright Beman Dawes 2009 + +// Distributed under the Boost Software License, Version 1.0. +// See http://www.boost.org/LICENSE_1_0.txt) + +// Library home page at http://www.boost.org/libs/filesystem + +//--------------------------------------------------------------------------------------// + +#include + +// define BOOST_FILESYSTEM_SOURCE so that knows +// the library is being built (possibly exporting rather than importing code) +#define BOOST_FILESYSTEM_SOURCE + +#include +#include +#include +#include +#include +#include +#include + +//--------------------------------------------------------------------------------------// + +namespace +{ + class codecvt_error_cat : public boost::system::error_category + { + public: + codecvt_error_cat(){} + const char* name() const; + std::string message(int ev) const; + }; + + const char* codecvt_error_cat::name() const + { + return "codecvt"; + } + + std::string codecvt_error_cat::message(int ev) const + { + std::string str; + switch (ev) + { + case std::codecvt_base::ok: + str = "ok"; + break; + case std::codecvt_base::partial: + str = "partial"; + break; + case std::codecvt_base::error: + str = "error"; + break; + case std::codecvt_base::noconv: + str = "noconv"; + break; + default: + str = "unknown error"; + } + return str; + } + +} // unnamed namespace + +namespace boost +{ + namespace filesystem + { + + BOOST_FILESYSTEM_DECL const boost::system::error_category& codecvt_error_category() + { + static const codecvt_error_cat codecvt_error_cat_const; + return codecvt_error_cat_const; + } + + } // namespace system +} // namespace boost diff --git a/v3/libs/filesystem/src/error_code.cpp b/v3/libs/filesystem/src/error_code.cpp new file mode 100644 index 0000000..3a7b39b --- /dev/null +++ b/v3/libs/filesystem/src/error_code.cpp @@ -0,0 +1,421 @@ +// error_code support implementation file ----------------------------------// + +// Copyright Beman Dawes 2002, 2006 + +// Distributed under the Boost Software License, Version 1.0. (See accompanying +// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// See library home page at http://www.boost.org/libs/system + +//----------------------------------------------------------------------------// + +#include + +// define BOOST_SYSTEM_SOURCE so that knows +// the library is being built (possibly exporting rather than importing code) +#define BOOST_SYSTEM_SOURCE + +#include +#include +#include +#include +#include +#include + +using namespace boost::system; +using namespace boost::system::posix_error; + +#include // for strerror/strerror_r + +# if defined( BOOST_WINDOWS_API ) +# include +# ifndef ERROR_INCORRECT_SIZE +# define ERROR_INCORRECT_SIZE ERROR_BAD_ARGUMENTS +# endif +# endif + +//----------------------------------------------------------------------------// + +namespace +{ + + // standard error categories ---------------------------------------------// + + class generic_error_category : public error_category + { + public: + generic_error_category(){} + const char * name() const; + std::string message( int ev ) const; + }; + + class system_error_category : public error_category + { + public: + system_error_category(){} + const char * name() const; + std::string message( int ev ) const; + error_condition default_error_condition( int ev ) const; + }; + + // generic_error_category implementation ---------------------------------// + + const char * generic_error_category::name() const + { + return "GENERIC"; + } + + std::string generic_error_category::message( int ev ) const + { + // strerror_r is preferred because it is always thread safe, + // however, we fallback to strerror in certain cases because: + // -- Windows doesn't provide strerror_r. + // -- HP and Sundo provide strerror_r on newer systems, but there is + // no way to tell if is available at runtime and in any case their + // versions of strerror are thread safe anyhow. + // -- Linux only sometimes provides strerror_r. + // -- Tru64 provides strerror_r only when compiled -pthread. + // -- VMS doesn't provide strerror_r, but on this platform, strerror is + // thread safe. + # if defined(BOOST_WINDOWS_API) || defined(__hpux) || defined(__sun)\ + || (defined(__linux) && (!defined(__USE_XOPEN2K) || defined(BOOST_SYSTEM_USE_STRERROR)))\ + || (defined(__osf__) && !defined(_REENTRANT))\ + || (defined(__vms)) + const char * c_str = std::strerror( ev ); + return std::string( c_str ? c_str : "Unknown error" ); + # else + char buf[64]; + char * bp = buf; + std::size_t sz = sizeof(buf); + # if defined(__CYGWIN__) || defined(__USE_GNU) + // Oddball version of strerror_r + const char * c_str = strerror_r( ev, bp, sz ); + return std::string( c_str ? c_str : "Unknown error" ); + # else + // POSIX version of strerror_r + int result; + for (;;) + { + // strerror_r returns 0 on success, otherwise ERANGE if buffer too small, + // invalid_argument if ev not a valid error number + # if defined (__sgi) + const char * c_str = strerror( ev ); + result = 0; + return std::string( c_str ? c_str : "Unknown error" ); + # else + result = strerror_r( ev, bp, sz ); + # endif + if (result == 0 ) + break; + else + { + # if defined(__linux) + // Linux strerror_r returns -1 on error, with error number in errno + result = errno; + # endif + if ( result != ERANGE ) break; + if ( sz > sizeof(buf) ) std::free( bp ); + sz *= 2; + if ( (bp = static_cast(std::malloc( sz ))) == 0 ) + return std::string( "ENOMEM" ); + } + } + try + { + std::string msg( ( result == invalid_argument ) ? "Unknown error" : bp ); + if ( sz > sizeof(buf) ) std::free( bp ); + sz = 0; + return msg; + } + catch(...) + { + if ( sz > sizeof(buf) ) std::free( bp ); + throw; + } + # endif + # endif + } + // system_error_category implementation --------------------------------// + + const char * system_error_category::name() const + { + return "system"; + } + + error_condition system_error_category::default_error_condition( int ev ) const + { + switch ( ev ) + { + case 0: return make_error_condition( success ); + # if defined(BOOST_POSIX_API) + // POSIX-like O/S -> posix_errno decode table ---------------------------// + case E2BIG: return make_error_condition( argument_list_too_long ); + case EACCES: return make_error_condition( permission_denied ); + case EADDRINUSE: return make_error_condition( address_in_use ); + case EADDRNOTAVAIL: return make_error_condition( address_not_available ); + case EAFNOSUPPORT: return make_error_condition( address_family_not_supported ); + case EAGAIN: return make_error_condition( resource_unavailable_try_again ); + case EALREADY: return make_error_condition( connection_already_in_progress ); + case EBADF: return make_error_condition( bad_file_descriptor ); + case EBADMSG: return make_error_condition( bad_message ); + case EBUSY: return make_error_condition( device_or_resource_busy ); + case ECANCELED: return make_error_condition( operation_canceled ); + case ECHILD: return make_error_condition( no_child_process ); + case ECONNABORTED: return make_error_condition( connection_aborted ); + case ECONNREFUSED: return make_error_condition( connection_refused ); + case ECONNRESET: return make_error_condition( connection_reset ); + case EDEADLK: return make_error_condition( resource_deadlock_would_occur ); + case EDESTADDRREQ: return make_error_condition( destination_address_required ); + case EDOM: return make_error_condition( argument_out_of_domain ); + case EEXIST: return make_error_condition( file_exists ); + case EFAULT: return make_error_condition( bad_address ); + case EFBIG: return make_error_condition( file_too_large ); + case EHOSTUNREACH: return make_error_condition( host_unreachable ); + case EIDRM: return make_error_condition( identifier_removed ); + case EILSEQ: return make_error_condition( illegal_byte_sequence ); + case EINPROGRESS: return make_error_condition( operation_in_progress ); + case EINTR: return make_error_condition( interrupted ); + case EINVAL: return make_error_condition( invalid_argument ); + case EIO: return make_error_condition( io_error ); + case EISCONN: return make_error_condition( already_connected ); + case EISDIR: return make_error_condition( is_a_directory ); + case ELOOP: return make_error_condition( too_many_synbolic_link_levels ); + case EMFILE: return make_error_condition( too_many_files_open ); + case EMLINK: return make_error_condition( too_many_links ); + case EMSGSIZE: return make_error_condition( message_size ); + case ENAMETOOLONG: return make_error_condition( filename_too_long ); + case ENETDOWN: return make_error_condition( network_down ); + case ENETRESET: return make_error_condition( network_reset ); + case ENETUNREACH: return make_error_condition( network_unreachable ); + case ENFILE: return make_error_condition( too_many_files_open_in_system ); + case ENOBUFS: return make_error_condition( no_buffer_space ); + case ENODATA: return make_error_condition( no_message_available ); + case ENODEV: return make_error_condition( no_such_device ); + case ENOENT: return make_error_condition( no_such_file_or_directory ); + case ENOEXEC: return make_error_condition( executable_format_error ); + case ENOLCK: return make_error_condition( no_lock_available ); + case ENOLINK: return make_error_condition( no_link ); + case ENOMEM: return make_error_condition( not_enough_memory ); + case ENOMSG: return make_error_condition( no_message ); + case ENOPROTOOPT: return make_error_condition( no_protocol_option ); + case ENOSPC: return make_error_condition( no_space_on_device ); + case ENOSR: return make_error_condition( no_stream_resources ); + case ENOSTR: return make_error_condition( not_a_stream ); + case ENOSYS: return make_error_condition( function_not_supported ); + case ENOTCONN: return make_error_condition( not_connected ); + case ENOTDIR: return make_error_condition( not_a_directory ); + # if ENOTEMPTY != EEXIST // AIX treats ENOTEMPTY and EEXIST as the same value + case ENOTEMPTY: return make_error_condition( directory_not_empty ); + # endif // ENOTEMPTY != EEXIST + case ENOTRECOVERABLE: return make_error_condition( state_not_recoverable ); + case ENOTSOCK: return make_error_condition( not_a_socket ); + case ENOTSUP: return make_error_condition( not_supported ); + case ENOTTY: return make_error_condition( inappropriate_io_control_operation ); + case ENXIO: return make_error_condition( no_such_device_or_address ); + # if EOPNOTSUPP != ENOTSUP + case EOPNOTSUPP: return make_error_condition( operation_not_supported ); + # endif // EOPNOTSUPP != ENOTSUP + case EOVERFLOW: return make_error_condition( value_too_large ); + case EOWNERDEAD: return make_error_condition( owner_dead ); + case EPERM: return make_error_condition( operation_not_permitted ); + case EPIPE: return make_error_condition( broken_pipe ); + case EPROTO: return make_error_condition( protocol_error ); + case EPROTONOSUPPORT: return make_error_condition( protocol_not_supported ); + case EPROTOTYPE: return make_error_condition( wrong_protocol_type ); + case ERANGE: return make_error_condition( result_out_of_range ); + case EROFS: return make_error_condition( read_only_file_system ); + case ESPIPE: return make_error_condition( invalid_seek ); + case ESRCH: return make_error_condition( no_such_process ); + case ETIME: return make_error_condition( stream_timeout ); + case ETIMEDOUT: return make_error_condition( timed_out ); + case ETXTBSY: return make_error_condition( text_file_busy ); + # if EAGAIN != EWOULDBLOCK + case EWOULDBLOCK: return make_error_condition( operation_would_block ); + # endif // EAGAIN != EWOULDBLOCK + case EXDEV: return make_error_condition( cross_device_link ); + #else + // Windows system -> posix_errno decode table ---------------------------// + // see WinError.h comments for descriptions of errors + case ERROR_ACCESS_DENIED: return make_error_condition( permission_denied ); + case ERROR_ALREADY_EXISTS: return make_error_condition( file_exists ); + case ERROR_BAD_UNIT: return make_error_condition( no_such_device ); + case ERROR_BUFFER_OVERFLOW: return make_error_condition( filename_too_long ); + case ERROR_BUSY: return make_error_condition( device_or_resource_busy ); + case ERROR_BUSY_DRIVE: return make_error_condition( device_or_resource_busy ); + case ERROR_CANNOT_MAKE: return make_error_condition( permission_denied ); + case ERROR_CANTOPEN: return make_error_condition( io_error ); + case ERROR_CANTREAD: return make_error_condition( io_error ); + case ERROR_CANTWRITE: return make_error_condition( io_error ); + case ERROR_CURRENT_DIRECTORY: return make_error_condition( permission_denied ); + case ERROR_DEV_NOT_EXIST: return make_error_condition( no_such_device ); + case ERROR_DEVICE_IN_USE: return make_error_condition( device_or_resource_busy ); + case ERROR_DIR_NOT_EMPTY: return make_error_condition( directory_not_empty ); + case ERROR_DIRECTORY: return make_error_condition( invalid_argument ); // WinError.h: "The directory name is invalid" + case ERROR_DISK_FULL: return make_error_condition( no_space_on_device ); + case ERROR_FILE_EXISTS: return make_error_condition( file_exists ); + case ERROR_FILE_NOT_FOUND: return make_error_condition( no_such_file_or_directory ); + case ERROR_HANDLE_DISK_FULL: return make_error_condition( no_space_on_device ); + case ERROR_INVALID_ACCESS: return make_error_condition( permission_denied ); + case ERROR_INVALID_DRIVE: return make_error_condition( no_such_device ); + case ERROR_INVALID_FUNCTION: return make_error_condition( function_not_supported ); + case ERROR_INVALID_HANDLE: return make_error_condition( invalid_argument ); + case ERROR_INVALID_NAME: return make_error_condition( invalid_argument ); + case ERROR_LOCK_VIOLATION: return make_error_condition( no_lock_available ); + case ERROR_LOCKED: return make_error_condition( no_lock_available ); + case ERROR_NEGATIVE_SEEK: return make_error_condition( invalid_argument ); + case ERROR_NOACCESS: return make_error_condition( permission_denied ); + case ERROR_NOT_ENOUGH_MEMORY: return make_error_condition( not_enough_memory ); + case ERROR_NOT_READY: return make_error_condition( resource_unavailable_try_again ); + case ERROR_NOT_SAME_DEVICE: return make_error_condition( cross_device_link ); + case ERROR_OPEN_FAILED: return make_error_condition( io_error ); + case ERROR_OPEN_FILES: return make_error_condition( device_or_resource_busy ); + case ERROR_OPERATION_ABORTED: return make_error_condition( operation_canceled ); + case ERROR_OUTOFMEMORY: return make_error_condition( not_enough_memory ); + case ERROR_PATH_NOT_FOUND: return make_error_condition( no_such_file_or_directory ); + case ERROR_READ_FAULT: return make_error_condition( io_error ); + case ERROR_RETRY: return make_error_condition( resource_unavailable_try_again ); + case ERROR_SEEK: return make_error_condition( io_error ); + case ERROR_SHARING_VIOLATION: return make_error_condition( permission_denied ); + case ERROR_TOO_MANY_OPEN_FILES: return make_error_condition( too_many_files_open ); + case ERROR_WRITE_FAULT: return make_error_condition( io_error ); + case ERROR_WRITE_PROTECT: return make_error_condition( permission_denied ); + case WSAEACCES: return make_error_condition( permission_denied ); + case WSAEADDRINUSE: return make_error_condition( address_in_use ); + case WSAEADDRNOTAVAIL: return make_error_condition( address_not_available ); + case WSAEAFNOSUPPORT: return make_error_condition( address_family_not_supported ); + case WSAEALREADY: return make_error_condition( connection_already_in_progress ); + case WSAEBADF: return make_error_condition( bad_file_descriptor ); + case WSAECONNABORTED: return make_error_condition( connection_aborted ); + case WSAECONNREFUSED: return make_error_condition( connection_refused ); + case WSAECONNRESET: return make_error_condition( connection_reset ); + case WSAEDESTADDRREQ: return make_error_condition( destination_address_required ); + case WSAEFAULT: return make_error_condition( bad_address ); + case WSAEHOSTUNREACH: return make_error_condition( host_unreachable ); + case WSAEINPROGRESS: return make_error_condition( operation_in_progress ); + case WSAEINTR: return make_error_condition( interrupted ); + case WSAEINVAL: return make_error_condition( invalid_argument ); + case WSAEISCONN: return make_error_condition( already_connected ); + case WSAEMFILE: return make_error_condition( too_many_files_open ); + case WSAEMSGSIZE: return make_error_condition( message_size ); + case WSAENAMETOOLONG: return make_error_condition( filename_too_long ); + case WSAENETDOWN: return make_error_condition( network_down ); + case WSAENETRESET: return make_error_condition( network_reset ); + case WSAENETUNREACH: return make_error_condition( network_unreachable ); + case WSAENOBUFS: return make_error_condition( no_buffer_space ); + case WSAENOPROTOOPT: return make_error_condition( no_protocol_option ); + case WSAENOTCONN: return make_error_condition( not_connected ); + case WSAENOTSOCK: return make_error_condition( not_a_socket ); + case WSAEOPNOTSUPP: return make_error_condition( operation_not_supported ); + case WSAEPROTONOSUPPORT: return make_error_condition( protocol_not_supported ); + case WSAEPROTOTYPE: return make_error_condition( wrong_protocol_type ); + case WSAETIMEDOUT: return make_error_condition( timed_out ); + case WSAEWOULDBLOCK: return make_error_condition( operation_would_block ); + #endif + default: return error_condition( ev, system_category ); + } + } + +# if !defined( BOOST_WINDOWS_API ) + + std::string system_error_category::message( int ev ) const + { + return generic_category.message( ev ); + } +# else +// TODO: + +//Some quick notes on the implementation (sorry for the noise if +//someone has already mentioned them): +// +//- The ::LocalFree() usage isn't exception safe. +// +//See: +// +// +// +//in the implementation of what() for an example. +// +//Cheers, +//Chris + std::string system_error_category::message( int ev ) const + { +# ifndef BOOST_NO_ANSI_APIS + LPVOID lpMsgBuf; + DWORD retval = ::FormatMessageA( + FORMAT_MESSAGE_ALLOCATE_BUFFER | + FORMAT_MESSAGE_FROM_SYSTEM | + FORMAT_MESSAGE_IGNORE_INSERTS, + NULL, + ev, + MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language + (LPSTR) &lpMsgBuf, + 0, + NULL + ); + if (retval == 0) + return std::string("Unknown error"); + + std::string str( static_cast(lpMsgBuf) ); + ::LocalFree( lpMsgBuf ); // free the buffer +# else // WinCE workaround + LPVOID lpMsgBuf; + DWORD retval = ::FormatMessageW( + FORMAT_MESSAGE_ALLOCATE_BUFFER | + FORMAT_MESSAGE_FROM_SYSTEM | + FORMAT_MESSAGE_IGNORE_INSERTS, + NULL, + ev, + MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language + (LPWSTR) &lpMsgBuf, + 0, + NULL + ); + if (retval == 0) + return std::string("Unknown error"); + + int num_chars = (wcslen( static_cast(lpMsgBuf) ) + 1) * 2; + LPSTR narrow_buffer = (LPSTR)_alloca( num_chars ); + if (::WideCharToMultiByte(CP_ACP, 0, static_cast(lpMsgBuf), -1, narrow_buffer, num_chars, NULL, NULL) == 0) + return std::string("Unknown error"); + + std::string str( narrow_buffer ); + ::LocalFree( lpMsgBuf ); // free the buffer +# endif + while ( str.size() + && (str[str.size()-1] == '\n' || str[str.size()-1] == '\r') ) + str.erase( str.size()-1 ); + if ( str.size() && str[str.size()-1] == '.' ) + { str.erase( str.size()-1 ); } + return str; + } +# endif + +} // unnamed namespace + +namespace boost +{ + namespace system + { + + + + BOOST_SYSTEM_DECL error_code throws; // "throw on error" special error_code; + // note that it doesn't matter if this + // isn't initialized before use since + // the only use is to take its + // address for comparison purposes + + BOOST_SYSTEM_DECL const error_category & get_system_category() + { + static const system_error_category system_category_const; + return system_category_const; + } + + BOOST_SYSTEM_DECL const error_category & get_generic_category() + { + static const generic_error_category generic_category_const; + return generic_category_const; + } + + } // namespace system +} // namespace boost diff --git a/v3/libs/filesystem/src/operations.cpp b/v3/libs/filesystem/src/operations.cpp new file mode 100644 index 0000000..b20f3bd --- /dev/null +++ b/v3/libs/filesystem/src/operations.cpp @@ -0,0 +1,1769 @@ +// operations.cpp --------------------------------------------------------------------// + +// Copyright 2002-2009 Beman Dawes +// Copyright 2001 Dietmar Kuehl + +// Distributed under the Boost Software License, Version 1.0. +// See http://www.boost.org/LICENSE_1_0.txt + +// See library home page at http://www.boost.org/libs/filesystem + +//--------------------------------------------------------------------------------------// + +// define BOOST_FILESYSTEM_SOURCE so that knows +// the library is being built (possibly exporting rather than importing code) +#define BOOST_FILESYSTEM_SOURCE + +#define _POSIX_PTHREAD_SEMANTICS // Sun readdir_r()needs this + +#if !(defined(__HP_aCC) && defined(_ILP32) && \ + !defined(_STATVFS_ACPP_PROBLEMS_FIXED)) +#define _FILE_OFFSET_BITS 64 // at worst, these defines may have no effect, +#endif +#define __USE_FILE_OFFSET64 // but that is harmless on Windows and on POSIX + // 64-bit systems or on 32-bit systems which don't have files larger + // than can be represented by a traditional POSIX/UNIX off_t type. + // OTOH, defining them should kick in 64-bit off_t's (and thus + // st_size)on 32-bit systems that provide the Large File + // Support (LFS)interface, such as Linux, Solaris, and IRIX. + // The defines are given before any headers are included to + // ensure that they are available to all included headers. + // That is required at least on Solaris, and possibly on other + // systems as well. + +#include +#include +#include +#include // for malloc, free + +#ifdef BOOST_FILEYSTEM_INCLUDE_IOSTREAM +# include +#endif + +namespace fs = boost::filesystem; +using boost::filesystem::path; +using boost::filesystem::filesystem_error; +using boost::system::error_code; +using boost::system::error_category; +using boost::system::system_category; +using std::string; +using std::wstring; + +# ifdef BOOST_POSIX_API + +# include +# if !defined(__APPLE__) && !defined(__OpenBSD__) +# include +# define BOOST_STATVFS statvfs +# define BOOST_STATVFS_F_FRSIZE vfs.f_frsize +# else +# ifdef __OpenBSD__ +# include +# endif +# include +# define BOOST_STATVFS statfs +# define BOOST_STATVFS_F_FRSIZE static_cast(vfs.f_bsize) +# endif +# include +# include +# include +# include +# include "limits.h" + +# else // BOOST_WINDOW_API + +# if (defined(__MINGW32__) || defined(__CYGWIN__)) && !defined(WINVER) + // Versions of MinGW or Cygwin that support Filesystem V3 support at least WINVER 0x501. + // See MinGW's windef.h +# define WINVER 0x501 +# endif +# include +# include +# if !defined(_WIN32_WINNT) +# define _WIN32_WINNT 0x0500 +# endif +# if defined(__BORLANDC__) || defined(__MWERKS__) +# if defined(__BORLANDC__) + using std::time_t; +# endif +# include +# else +# include +# endif + +// REPARSE_DATA_BUFFER related definitions are found in ntifs.h, which is part of the +// Windows Device Driver Kit. Since that's inconvenient, the definitions are provided +// here. See http://msdn.microsoft.com/en-us/library/ms791514.aspx + +#if !defined(REPARSE_DATA_BUFFER_HEADER_SIZE) // mingw winnt.h does provide the defs + +#define SYMLINK_FLAG_RELATIVE 1 + +typedef struct _REPARSE_DATA_BUFFER { + ULONG ReparseTag; + USHORT ReparseDataLength; + USHORT Reserved; + union { + struct { + USHORT SubstituteNameOffset; + USHORT SubstituteNameLength; + USHORT PrintNameOffset; + USHORT PrintNameLength; + ULONG Flags; + WCHAR PathBuffer[1]; + /* Example of distinction between substitute and print names: + mklink /d ldrive c:\ + SubstituteName: c:\\??\ + PrintName: c:\ + */ + } SymbolicLinkReparseBuffer; + struct { + USHORT SubstituteNameOffset; + USHORT SubstituteNameLength; + USHORT PrintNameOffset; + USHORT PrintNameLength; + WCHAR PathBuffer[1]; + } MountPointReparseBuffer; + struct { + UCHAR DataBuffer[1]; + } GenericReparseBuffer; + }; +} REPARSE_DATA_BUFFER, *PREPARSE_DATA_BUFFER; + +#define REPARSE_DATA_BUFFER_HEADER_SIZE \ + FIELD_OFFSET(REPARSE_DATA_BUFFER, GenericReparseBuffer) + +#define MAXIMUM_REPARSE_DATA_BUFFER_SIZE ( 16 * 1024 ) +#endif + +# endif + +// BOOST_FILESYSTEM_STATUS_CACHE enables file_status cache in +// dir_itr_increment. The config tests are placed here because some of the +// macros being tested come from dirent.h. +// +// TODO: find out what macros indicate dirent::d_type present in more libraries +# if defined(BOOST_WINDOWS_API)\ + || defined(_DIRENT_HAVE_D_TYPE)// defined by GNU C library if d_type present +# define BOOST_FILESYSTEM_STATUS_CACHE +# endif + +#include // even on Windows some functions use stat() +#include +#include +#include // for remove, rename +#include +#include +// #include // for debugging only; comment out when not in use + +// POSIX/Windows macros ----------------------------------------------------// + +// Portions of the POSIX and Windows API's are very similar, except for name, +// order of arguments, and meaning of zero/non-zero returns. The macros below +// abstract away those differences. They follow Windows naming and order of +// arguments, and return true to indicate no error occurred. [POSIX naming, +// order of arguments, and meaning of return were followed initially, but +// found to be less clear and cause more coding errors.] + +# if defined(BOOST_POSIX_API) + +// POSIX uses a 0 return to indicate success +# define BOOST_ERRNO errno +# define BOOST_SET_CURRENT_DIRECTORY(P)(::chdir(P)== 0) +# define BOOST_CREATE_DIRECTORY(P)(::mkdir(P, S_IRWXU|S_IRWXG|S_IRWXO)== 0) +# define BOOST_CREATE_HARD_LINK(F,T)(::link(T, F)== 0) +# define BOOST_CREATE_SYMBOLIC_LINK(F,T,Flag)(::symlink(T, F)== 0) +# define BOOST_REMOVE_DIRECTORY(P)(::rmdir(P)== 0) +# define BOOST_DELETE_FILE(P)(::unlink(P)== 0) +# define BOOST_COPY_DIRECTORY(F,T)(!(::stat(from.c_str(), &from_stat)!= 0\ + || ::mkdir(to.c_str(),from_stat.st_mode)!= 0)) +# define BOOST_COPY_FILE(F,T,FailIfExistsBool)copy_file_api(F, T, FailIfExistsBool) +# define BOOST_MOVE_FILE(OLD,NEW)(::rename(OLD, NEW)== 0) +# define BOOST_RESIZE_FILE(P,SZ)(::truncate(P, SZ)== 0) + +# define BOOST_ERROR_NOT_SUPPORTED ENOSYS +# define BOOST_ERROR_ALREADY_EXISTS EEXIST + +# else // BOOST_WINDOWS_API + +// Windows uses a non-0 return to indicate success +# define BOOST_ERRNO ::GetLastError() +# define BOOST_SET_CURRENT_DIRECTORY(P)(::SetCurrentDirectoryW(P)!= 0) +# define BOOST_CREATE_DIRECTORY(P)(::CreateDirectoryW(P, 0)!= 0) +# define BOOST_CREATE_HARD_LINK(F,T)(create_hard_link_api(F, T, 0)!= 0) +# define BOOST_CREATE_SYMBOLIC_LINK(F,T,Flag)(create_symbolic_link_api(F, T, Flag)!= 0) +# define BOOST_REMOVE_DIRECTORY(P)(::RemoveDirectoryW(P)!= 0) +# define BOOST_DELETE_FILE(P)(::DeleteFileW(P)!= 0) +# define BOOST_COPY_DIRECTORY(F,T)(::CreateDirectoryExW(F, T, 0)!= 0) +# define BOOST_COPY_FILE(F,T,FailIfExistsBool)(::CopyFileW(F, T, FailIfExistsBool)!= 0) +# define BOOST_MOVE_FILE(OLD,NEW)(::MoveFileExW(OLD, NEW, MOVEFILE_REPLACE_EXISTING)!= 0) +# define BOOST_RESIZE_FILE(P,SZ)(resize_file_api(P, SZ)!= 0) +# define BOOST_READ_SYMLINK(P,T) + +# define BOOST_ERROR_ALREADY_EXISTS ERROR_ALREADY_EXISTS +# define BOOST_ERROR_NOT_SUPPORTED ERROR_NOT_SUPPORTED + +# endif + +//--------------------------------------------------------------------------------------// +// // +// helpers (all operating systems) // +// // +//--------------------------------------------------------------------------------------// + +namespace +{ + +# ifdef BOOST_POSIX_API + const char dot = '.'; +# else + const wchar_t dot = L'.'; +# endif + + boost::filesystem::directory_iterator end_dir_itr; + + const std::size_t buf_size(128); + const error_code ok; + + bool error(bool was_error, error_code* ec, const string& message) + { + if (!was_error) + { + if (ec != 0) ec->clear(); + } + else + { // error + if (ec == 0) + BOOST_FILESYSTEM_THROW(filesystem_error(message, + error_code(BOOST_ERRNO, system_category()))); + else + ec->assign(BOOST_ERRNO, system_category()); + } + return was_error; + } + + bool error(bool was_error, const path& p, error_code* ec, const string& message) + { + if (!was_error) + { + if (ec != 0) ec->clear(); + } + else + { // error + if (ec == 0) + BOOST_FILESYSTEM_THROW(filesystem_error(message, + p, error_code(BOOST_ERRNO, system_category()))); + else + ec->assign(BOOST_ERRNO, system_category()); + } + return was_error; + } + + bool error(bool was_error, const path& p1, const path& p2, error_code* ec, + const string& message) + { + if (!was_error) + { + if (ec != 0) ec->clear(); + } + else + { // error + if (ec == 0) + BOOST_FILESYSTEM_THROW(filesystem_error(message, + p1, p2, error_code(BOOST_ERRNO, system_category()))); + else + ec->assign(BOOST_ERRNO, system_category()); + } + return was_error; + } + + bool error(bool was_error, const error_code& result, + const path& p, error_code* ec, const string& message) + // Overwrites ec if there has already been an error + { + if (!was_error) + { + if (ec != 0) ec->clear(); + } + else + { // error + if (ec == 0) + BOOST_FILESYSTEM_THROW(filesystem_error(message, p, result)); + else + *ec = result; + } + return was_error; + } + + bool error(bool was_error, const error_code& result, + const path& p1, const path& p2, error_code* ec, const string& message) + // Overwrites ec if there has already been an error + { + if (!was_error) + { + if (ec != 0) ec->clear(); + } + else + { // error + if (ec == 0) + BOOST_FILESYSTEM_THROW(filesystem_error(message, p1, p2, result)); + else + *ec = result; + } + return was_error; + } + + bool is_empty_directory(const path& p) + { + return fs::directory_iterator(p)== end_dir_itr; + } + + bool remove_directory(const path& p) // true if succeeds + { return BOOST_REMOVE_DIRECTORY(p.c_str()); } + + bool remove_file(const path& p) // true if succeeds + { return BOOST_DELETE_FILE(p.c_str()); } + + // called by remove and remove_all_aux + bool remove_file_or_directory(const path& p, fs::file_status sym_stat, error_code* ec) + // return true if file removed, false if not removed + { + if (sym_stat.type()== fs::file_not_found) + { + if (ec != 0) ec->clear(); + return false; + } + + if (fs::is_directory(sym_stat)) + { + if (error(!remove_directory(p), p, ec, "boost::filesystem::remove")) + return false; + } + else + { + if (error(!remove_file(p), p, ec, "boost::filesystem::remove")) + return false; + } + return true; + } + + boost::uintmax_t remove_all_aux(const path& p, fs::file_status sym_stat, + error_code* ec) + { + boost::uintmax_t count = 1; + + if (!fs::is_symlink(sym_stat)// don't recurse symbolic links + && fs::is_directory(sym_stat)) + { + for (fs::directory_iterator itr(p); + itr != end_dir_itr; ++itr) + { + fs::file_status tmp_sym_stat = fs::symlink_status(itr->path(), *ec); + if (ec != 0 && ec) + return count; + count += remove_all_aux(itr->path(), tmp_sym_stat, ec); + } + } + remove_file_or_directory(p, sym_stat, ec); + return count; + } + +#ifdef BOOST_POSIX_API + +//--------------------------------------------------------------------------------------// +// // +// POSIX-specific helpers // +// // +//--------------------------------------------------------------------------------------// + + bool not_found_error(int errval) + { + return errno == ENOENT || errno == ENOTDIR; + } + + bool // true if ok + copy_file_api(const std::string& from_p, + const std::string& to_p, bool fail_if_exists) + { + const std::size_t buf_sz = 32768; + boost::scoped_array buf(new char [buf_sz]); + int infile=-1, outfile=-1; // -1 means not open + + // bug fixed: code previously did a stat()on the from_file first, but that + // introduced a gratuitous race condition; the stat()is now done after the open() + + if ((infile = ::open(from_p.c_str(), O_RDONLY))< 0) + { return false; } + + struct stat from_stat; + if (::stat(from_p.c_str(), &from_stat)!= 0) + { return false; } + + int oflag = O_CREAT | O_WRONLY; + if (fail_if_exists)oflag |= O_EXCL; + if ((outfile = ::open(to_p.c_str(), oflag, from_stat.st_mode))< 0) + { + int open_errno = errno; + BOOST_ASSERT(infile >= 0); + ::close(infile); + errno = open_errno; + return false; + } + + ssize_t sz, sz_read=1, sz_write; + while (sz_read > 0 + && (sz_read = ::read(infile, buf.get(), buf_sz))> 0) + { + // Allow for partial writes - see Advanced Unix Programming (2nd Ed.), + // Marc Rochkind, Addison-Wesley, 2004, page 94 + sz_write = 0; + do + { + if ((sz = ::write(outfile, buf.get() + sz_write, + sz_read - sz_write))< 0) + { + sz_read = sz; // cause read loop termination + break; // and error to be thrown after closes + } + sz_write += sz; + } while (sz_write < sz_read); + } + + if (::close(infile)< 0)sz_read = -1; + if (::close(outfile)< 0)sz_read = -1; + + return sz_read >= 0; + } + +# else + +//--------------------------------------------------------------------------------------// +// // +// Windows-specific helpers // +// // +//--------------------------------------------------------------------------------------// + + bool not_found_error(int errval) + { + return errval == ERROR_FILE_NOT_FOUND + || errval == ERROR_PATH_NOT_FOUND + || errval == ERROR_INVALID_NAME // "tools/jam/src/:sys:stat.h", "//foo" + || errval == ERROR_INVALID_DRIVE // USB card reader with no card inserted + || errval == ERROR_NOT_READY // CD/DVD drive with no disc inserted + || errval == ERROR_INVALID_PARAMETER // ":sys:stat.h" + || errval == ERROR_BAD_PATHNAME // "//nosuch" on Win64 + || errval == ERROR_BAD_NETPATH; // "//nosuch" on Win32 + } + + // these constants come from inspecting some Microsoft sample code + std::time_t to_time_t(const FILETIME & ft) + { + __int64 t = (static_cast<__int64>(ft.dwHighDateTime)<< 32) + + ft.dwLowDateTime; +# if !defined(BOOST_MSVC) || BOOST_MSVC > 1300 // > VC++ 7.0 + t -= 116444736000000000LL; +# else + t -= 116444736000000000; +# endif + t /= 10000000; + return static_cast(t); + } + + void to_FILETIME(std::time_t t, FILETIME & ft) + { + __int64 temp = t; + temp *= 10000000; +# if !defined(BOOST_MSVC) || BOOST_MSVC > 1300 // > VC++ 7.0 + temp += 116444736000000000LL; +# else + temp += 116444736000000000; +# endif + ft.dwLowDateTime = static_cast(temp); + ft.dwHighDateTime = static_cast(temp >> 32); + } + + // Thanks to Jeremy Maitin-Shepard for much help and for permission to + // base the equivalent()implementation on portions of his + // file-equivalence-win32.cpp experimental code. + + struct handle_wrapper + { + HANDLE handle; + handle_wrapper(HANDLE h) + : handle(h){} + ~handle_wrapper() + { + if (handle != INVALID_HANDLE_VALUE) + ::CloseHandle(handle); + } + }; + + HANDLE create_file_handle(path p, DWORD dwDesiredAccess, + DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, + DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, + HANDLE hTemplateFile) + { + return ::CreateFileW(p.c_str(), dwDesiredAccess, dwShareMode, + lpSecurityAttributes, dwCreationDisposition, dwFlagsAndAttributes, + hTemplateFile); + } + + inline std::size_t get_full_path_name( + const path& src, std::size_t len, wchar_t* buf, wchar_t** p) + { + return static_cast( + ::GetFullPathNameW(src.c_str(), static_cast(len), buf, p)); + } + + BOOL resize_file_api(const wchar_t* p, boost::uintmax_t size) + { + HANDLE handle = CreateFileW(p, GENERIC_WRITE, 0, 0, OPEN_EXISTING, + FILE_ATTRIBUTE_NORMAL, 0); + LARGE_INTEGER sz; + sz.QuadPart = size; + return handle != INVALID_HANDLE_VALUE + && ::SetFilePointerEx(handle, sz, 0, FILE_BEGIN) + && ::SetEndOfFile(handle) + && ::CloseHandle(handle); + } + + // Windows kernel32.dll functions that may or may not be present + // must be accessed through pointers + + typedef BOOL (WINAPI *PtrCreateHardLinkW)( + /*__in*/ LPCWSTR lpFileName, + /*__in*/ LPCWSTR lpExistingFileName, + /*__reserved*/ LPSECURITY_ATTRIBUTES lpSecurityAttributes + ); + + PtrCreateHardLinkW create_hard_link_api = PtrCreateHardLinkW( + ::GetProcAddress( + ::GetModuleHandle(TEXT("kernel32.dll")), "CreateHardLinkW")); + + typedef BOOLEAN (WINAPI *PtrCreateSymbolicLinkW)( + /*__in*/ LPCWSTR lpSymlinkFileName, + /*__in*/ LPCWSTR lpTargetFileName, + /*__in*/ DWORD dwFlags + ); + + PtrCreateSymbolicLinkW create_symbolic_link_api = PtrCreateSymbolicLinkW( + ::GetProcAddress( + ::GetModuleHandle(TEXT("kernel32.dll")), "CreateSymbolicLinkW")); +#endif + +//#ifdef BOOST_WINDOWS_API +// +// +// inline bool get_free_disk_space(const std::wstring& ph, +// PULARGE_INTEGER avail, PULARGE_INTEGER total, PULARGE_INTEGER free) +// { return ::GetDiskFreeSpaceExW(ph.c_str(), avail, total, free)!= 0; } +// +//#endif + +} // unnamed namespace + +//--------------------------------------------------------------------------------------// +// // +// operations functions declared in operations.hpp // +// in alphabetic order // +// // +//--------------------------------------------------------------------------------------// + +namespace boost +{ +namespace filesystem +{ +namespace detail +{ + BOOST_FILESYSTEM_DECL bool possible_large_file_size_support() + { +# ifdef BOOST_POSIX_API + struct stat lcl_stat; + return sizeof(lcl_stat.st_size)> 4; +# else + return true; +# endif + } + + BOOST_FILESYSTEM_DECL + void copy(const path& from, const path& to, system::error_code* ec) + { + file_status s(symlink_status(from, *ec)); + if (ec != 0 && ec)return; + + if(is_symlink(s)) + { + copy_symlink(from, to, *ec); + } + else if(is_directory(s)) + { + copy_directory(from, to, *ec); + } + else if(is_regular_file(s)) + { + copy_file(from, to, copy_option::fail_if_exists, *ec); + } + else + { + if (ec == 0) + BOOST_FILESYSTEM_THROW(filesystem_error("boost::filesystem::copy", + from, to, error_code(BOOST_ERROR_NOT_SUPPORTED, system_category()))); + ec->assign(BOOST_ERROR_NOT_SUPPORTED, system_category()); + } + } + + BOOST_FILESYSTEM_DECL + void copy_directory(const path& from, const path& to, system::error_code* ec) + { +# ifdef BOOST_POSIX_API + struct stat from_stat; +# endif + error(!BOOST_COPY_DIRECTORY(from.c_str(), to.c_str()), + from, to, ec, "boost::filesystem::copy_directory"); + } + + BOOST_FILESYSTEM_DECL + void copy_file(const path& from, const path& to, + BOOST_SCOPED_ENUM(copy_option)option, + error_code* ec) + { + error(!BOOST_COPY_FILE(from.c_str(), to.c_str(), + option == copy_option::fail_if_exists), + from, to, ec, "boost::filesystem::copy_file"); + } + + BOOST_FILESYSTEM_DECL + void copy_symlink(const path& from, const path& to, system::error_code* ec) + { +# ifdef BOOST_POSIX_API + path p(read_symlink(from, ec)); + if (ec != 0 && ec) return; + create_symlink(p, to, ec); + +# elif _WIN32_WINNT < 0x0600 // SDK earlier than Vista and Server 2008 + error(true, error_code(BOOST_ERROR_NOT_SUPPORTED, system_category()), to, from, ec, + "boost::filesystem::copy_symlink"); + +# else // modern Windows + + // see if actually supported by Windows runtime dll + if (error(!create_symbolic_link_api, + error_code(BOOST_ERROR_NOT_SUPPORTED, system_category()), + to, from, ec, + "boost::filesystem::copy_symlink")) + return; + + // preconditions met, so attempt the copy + error(!::CopyFileExW(from.c_str(), to.c_str(), 0, 0, 0, + COPY_FILE_COPY_SYMLINK | COPY_FILE_FAIL_IF_EXISTS), to, from, ec, + "boost::filesystem::copy_symlink"); +# endif + + } + + BOOST_FILESYSTEM_DECL + bool create_directories(const path& p, system::error_code* ec) + { + if (p.empty() || exists(p)) + { + if (!p.empty() && !is_directory(p)) + { + if (ec == 0) + BOOST_FILESYSTEM_THROW(filesystem_error( + "boost::filesystem::create_directories", p, + error_code(system::errc::file_exists, system::generic_category()))); + else ec->assign(system::errc::file_exists, system::generic_category()); + } + return false; + } + + // First create branch, by calling ourself recursively + create_directories(p.parent_path(), ec); + // Now that parent's path exists, create the directory + create_directory(p, ec); + return true; + } + + BOOST_FILESYSTEM_DECL + bool create_directory(const path& p, error_code* ec) + { + if (BOOST_CREATE_DIRECTORY(p.c_str())) + { + if (ec != 0) ec->clear(); + return true; + } + + // attempt to create directory failed + int errval(BOOST_ERRNO); // save reason for failure + error_code dummy; + if (errval == BOOST_ERROR_ALREADY_EXISTS && is_directory(p, dummy)) + { + if (ec != 0) ec->clear(); + return false; + } + + // attempt to create directory failed && it doesn't already exist + if (ec == 0) + BOOST_FILESYSTEM_THROW(filesystem_error("boost::filesystem::create_directory", + p, error_code(errval, system_category()))); + else + ec->assign(errval, system_category()); + return false; + } + + BOOST_FILESYSTEM_DECL + void create_directory_symlink(const path& to, const path& from, + system::error_code* ec) + { +# if defined(BOOST_WINDOWS_API) && _WIN32_WINNT < 0x0600 // SDK earlier than Vista and Server 2008 + + error(true, error_code(BOOST_ERROR_NOT_SUPPORTED, system_category()), to, from, ec, + "boost::filesystem::create_directory_symlink"); +# else + +# if defined(BOOST_WINDOWS_API) && _WIN32_WINNT >= 0x0600 + // see if actually supported by Windows runtime dll + if (error(!create_symbolic_link_api, + error_code(BOOST_ERROR_NOT_SUPPORTED, system_category()), + to, from, ec, + "boost::filesystem::create_directory_symlink")) + return; +# endif + + error(!BOOST_CREATE_SYMBOLIC_LINK(from.c_str(), to.c_str(), SYMBOLIC_LINK_FLAG_DIRECTORY), + to, from, ec, "boost::filesystem::create_directory_symlink"); +# endif + } + + BOOST_FILESYSTEM_DECL + void create_hard_link(const path& to, const path& from, error_code* ec) + { + +# if defined(BOOST_WINDOWS_API) && _WIN32_WINNT < 0x0500 // SDK earlier than Win 2K + + error(true, error_code(BOOST_ERROR_NOT_SUPPORTED, system_category()), to, from, ec, + "boost::filesystem::create_hard_link"); +# else + +# if defined(BOOST_WINDOWS_API) && _WIN32_WINNT >= 0x0500 + // see if actually supported by Windows runtime dll + if (error(!create_hard_link_api, + error_code(BOOST_ERROR_NOT_SUPPORTED, system_category()), + to, from, ec, + "boost::filesystem::create_hard_link")) + return; +# endif + + error(!BOOST_CREATE_HARD_LINK(from.c_str(), to.c_str()), to, from, ec, + "boost::filesystem::create_hard_link"); +# endif + } + + BOOST_FILESYSTEM_DECL + void create_symlink(const path& to, const path& from, error_code* ec) + { +# if defined(BOOST_WINDOWS_API) && _WIN32_WINNT < 0x0600 // SDK earlier than Vista and Server 2008 + error(true, error_code(BOOST_ERROR_NOT_SUPPORTED, system_category()), to, from, ec, + "boost::filesystem::create_directory_symlink"); +# else + +# if defined(BOOST_WINDOWS_API) && _WIN32_WINNT >= 0x0600 + // see if actually supported by Windows runtime dll + if (error(!create_symbolic_link_api, + error_code(BOOST_ERROR_NOT_SUPPORTED, system_category()), + to, from, ec, + "boost::filesystem::create_directory_symlink")) + return; +# endif + + error(!BOOST_CREATE_SYMBOLIC_LINK(from.c_str(), to.c_str(), 0), + to, from, ec, "boost::filesystem::create_directory_symlink"); +# endif + } + + BOOST_FILESYSTEM_DECL + path current_path(error_code* ec) + { +# ifdef BOOST_POSIX_API + path cur; + for (long path_max = 128;; path_max *=2)// loop 'til buffer large enough + { + boost::scoped_array + buf(new char[static_cast(path_max)]); + if (::getcwd(buf.get(), static_cast(path_max))== 0) + { + if (error(errno != ERANGE + // bug in some versions of the Metrowerks C lib on the Mac: wrong errno set +# if defined(__MSL__) && (defined(macintosh) || defined(__APPLE__) || defined(__APPLE_CC__)) + && errno != 0 +# endif + , ec, "boost::filesystem::current_path")) + { + break; + } + } + else + { + cur = buf.get(); + if (ec != 0) ec->clear(); + break; + } + } + return cur; + +# else + DWORD sz; + if ((sz = ::GetCurrentDirectoryW(0, NULL))== 0)sz = 1; + boost::scoped_array buf(new path::value_type[sz]); + error(::GetCurrentDirectoryW(sz, buf.get())== 0, ec, + "boost::filesystem::current_path"); + return path(buf.get()); +# endif + } + + + BOOST_FILESYSTEM_DECL + void current_path(const path& p, system::error_code* ec) + { + error(!BOOST_SET_CURRENT_DIRECTORY(p.c_str()), + p, ec, "boost::filesystem::current_path"); + } + + BOOST_FILESYSTEM_DECL + bool equivalent(const path& p1, const path& p2, system::error_code* ec) + { +# ifdef BOOST_POSIX_API + struct stat s2; + int e2(::stat(p2.c_str(), &s2)); + struct stat s1; + int e1(::stat(p1.c_str(), &s1)); + + if (e1 != 0 || e2 != 0) + { + // if one is invalid and the other isn't then they aren't equivalent, + // but if both are invalid then it is an error + error (e1 != 0 && e2 != 0, p1, p2, ec, "boost::filesystem::equivalent"); + return false; + } + + // both stats now known to be valid + return s1.st_dev == s2.st_dev && s1.st_ino == s2.st_ino + // According to the POSIX stat specs, "The st_ino and st_dev fields + // taken together uniquely identify the file within the system." + // Just to be sure, size and mod time are also checked. + && s1.st_size == s2.st_size && s1.st_mtime == s2.st_mtime; + +# else // Windows + + // Note well: Physical location on external media is part of the + // equivalence criteria. If there are no open handles, physical location + // can change due to defragmentation or other relocations. Thus handles + // must be held open until location information for both paths has + // been retrieved. + + // p2 is done first, so any error reported is for p1 + handle_wrapper h2( + create_file_handle( + p2.c_str(), + 0, + FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE, + 0, + OPEN_EXISTING, + FILE_FLAG_BACKUP_SEMANTICS, + 0)); + + handle_wrapper h1( + create_file_handle( + p1.c_str(), + 0, + FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE, + 0, + OPEN_EXISTING, + FILE_FLAG_BACKUP_SEMANTICS, + 0)); + + if (h1.handle == INVALID_HANDLE_VALUE + || h2.handle == INVALID_HANDLE_VALUE) + { + // if one is invalid and the other isn't, then they aren't equivalent, + // but if both are invalid then it is an error + error(h1.handle == INVALID_HANDLE_VALUE + && h2.handle == INVALID_HANDLE_VALUE, p1, p2, ec, + "boost::filesystem::equivalent"); + return false; + } + + // at this point, both handles are known to be valid + + BY_HANDLE_FILE_INFORMATION info1, info2; + + if (error(!::GetFileInformationByHandle(h1.handle, &info1), + p1, p2, ec, "boost::filesystem::equivalent")) + return false; + + if (error(!::GetFileInformationByHandle(h2.handle, &info2), + p1, p2, ec, "boost::filesystem::equivalent")) + return false; + + // In theory, volume serial numbers are sufficient to distinguish between + // devices, but in practice VSN's are sometimes duplicated, so last write + // time and file size are also checked. + return + info1.dwVolumeSerialNumber == info2.dwVolumeSerialNumber + && info1.nFileIndexHigh == info2.nFileIndexHigh + && info1.nFileIndexLow == info2.nFileIndexLow + && info1.nFileSizeHigh == info2.nFileSizeHigh + && info1.nFileSizeLow == info2.nFileSizeLow + && info1.ftLastWriteTime.dwLowDateTime + == info2.ftLastWriteTime.dwLowDateTime + && info1.ftLastWriteTime.dwHighDateTime + == info2.ftLastWriteTime.dwHighDateTime; + +# endif + } + + BOOST_FILESYSTEM_DECL + boost::uintmax_t file_size(const path& p, error_code* ec) + { +# ifdef BOOST_POSIX_API + + struct stat path_stat; + if (error(::stat(p.c_str(), &path_stat)!= 0, + p, ec, "boost::filesystem::file_size")) + return static_cast(-1); + if (error(!S_ISREG(path_stat.st_mode), + error_code(EPERM, system_category()), + p, ec, "boost::filesystem::file_size")) + return static_cast(-1); + + return static_cast(path_stat.st_size); + +# else // Windows + + // assume uintmax_t is 64-bits on all Windows compilers + + WIN32_FILE_ATTRIBUTE_DATA fad; + + if (error(::GetFileAttributesExW(p.c_str(), ::GetFileExInfoStandard, &fad)== 0, + p, ec, "boost::filesystem::file_size")) + return static_cast(-1); + + if (error((fad.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)!= 0, + error_code(ERROR_NOT_SUPPORTED, system_category()), + p, ec, "boost::filesystem::file_size")) + return static_cast(-1); + + return (static_cast(fad.nFileSizeHigh) + << (sizeof(fad.nFileSizeLow)*8)) + fad.nFileSizeLow; +# endif + } + + BOOST_FILESYSTEM_DECL + boost::uintmax_t hard_link_count(const path& p, system::error_code* ec) + { +# ifdef BOOST_POSIX_API + + struct stat path_stat; + return error(::stat(p.c_str(), &path_stat)!= 0, + p, ec, "boost::filesystem::hard_link_count") + ? 0 + : static_cast(path_stat.st_nlink); + +# else // Windows + + // Link count info is only available through GetFileInformationByHandle + BY_HANDLE_FILE_INFORMATION info; + handle_wrapper h( + create_file_handle(p.c_str(), 0, + FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE, 0, + OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, 0)); + return + !error(h.handle == INVALID_HANDLE_VALUE, + p, ec, "boost::filesystem::hard_link_count") + && !error(::GetFileInformationByHandle(h.handle, &info)== 0, + p, ec, "boost::filesystem::hard_link_count") + ? info.nNumberOfLinks + : 0; +# endif + } + + BOOST_FILESYSTEM_DECL + path initial_path(error_code* ec) + { + static path init_path; + if (init_path.empty()) + init_path = current_path(ec); + else if (ec != 0) ec->clear(); + return init_path; + } + + BOOST_FILESYSTEM_DECL + bool is_empty(const path& p, system::error_code* ec) + { +# ifdef BOOST_POSIX_API + + struct stat path_stat; + if (error(::stat(p.c_str(), &path_stat)!= 0, + p, ec, "boost::filesystem::is_empty")) + return false; + return S_ISDIR(path_stat.st_mode) + ? is_empty_directory(p) + : path_stat.st_size == 0; +# else + + WIN32_FILE_ATTRIBUTE_DATA fad; + if (error(::GetFileAttributesExW(p.c_str(), ::GetFileExInfoStandard, &fad)== 0, + p, ec, "boost::filesystem::is_empty")) + return false; + + if (ec != 0) ec->clear(); + return + (fad.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) + ? is_empty_directory(p) + : (!fad.nFileSizeHigh && !fad.nFileSizeLow); +# endif + } + + BOOST_FILESYSTEM_DECL + std::time_t last_write_time(const path& p, system::error_code* ec) + { +# ifdef BOOST_POSIX_API + + struct stat path_stat; + if (error(::stat(p.c_str(), &path_stat)!= 0, + p, ec, "boost::filesystem::last_write_time")) + return std::time_t(-1); + return path_stat.st_mtime; + +# else + + handle_wrapper hw( + create_file_handle(p.c_str(), 0, + FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE, 0, + OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, 0)); + + if (error(hw.handle == INVALID_HANDLE_VALUE, + p, ec, "boost::filesystem::last_write_time")) + return std::time_t(-1); + + FILETIME lwt; + + if (error(::GetFileTime(hw.handle, 0, 0, &lwt)== 0, + p, ec, "boost::filesystem::last_write_time")) + return std::time_t(-1); + + return to_time_t(lwt); +# endif + } + + BOOST_FILESYSTEM_DECL + void last_write_time(const path& p, const std::time_t new_time, + system::error_code* ec) + { +# ifdef BOOST_POSIX_API + + struct stat path_stat; + if (error(::stat(p.c_str(), &path_stat)!= 0, + p, ec, "boost::filesystem::last_write_time")) + return; + ::utimbuf buf; + buf.actime = path_stat.st_atime; // utime()updates access time too:-( + buf.modtime = new_time; + error(::utime(p.c_str(), &buf)!= 0, + p, ec, "boost::filesystem::last_write_time"); + +# else + + handle_wrapper hw( + create_file_handle(p.c_str(), FILE_WRITE_ATTRIBUTES, + FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE, 0, + OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, 0)); + + if (error(hw.handle == INVALID_HANDLE_VALUE, + p, ec, "boost::filesystem::last_write_time")) + return; + + FILETIME lwt; + to_FILETIME(new_time, lwt); + + error(::SetFileTime(hw.handle, 0, 0, &lwt)== 0, + p, ec, "boost::filesystem::last_write_time"); +# endif + } + + BOOST_FILESYSTEM_DECL + path read_symlink(const path& p, system::error_code* ec) + { + path symlink_path; + +# ifdef BOOST_POSIX_API + + for (std::size_t path_max = 64;; path_max *= 2)// loop 'til buffer large enough + { + boost::scoped_array buf(new char[path_max]); + ssize_t result; + if ((result=::readlink(p.c_str(), buf.get(), path_max))== -1) + { + if (ec == 0) + BOOST_FILESYSTEM_THROW(filesystem_error("boost::filesystem::read_symlink", + p, error_code(errno, system_category()))); + else ec->assign(errno, system_category()); + break; + } + else + { + if(result != static_cast(path_max)) + { + symlink_path.assign(buf.get(), buf.get() + result); + if (ec != 0) ec->clear(); + break; + } + } + } + +# elif _WIN32_WINNT < 0x0600 // SDK earlier than Vista and Server 2008 + error(true, error_code(BOOST_ERROR_NOT_SUPPORTED, system_category()), p, ec, + "boost::filesystem::read_symlink"); +# else // Vista and Server 2008 SDK, or later + + union info_t + { + char buf[REPARSE_DATA_BUFFER_HEADER_SIZE+MAXIMUM_REPARSE_DATA_BUFFER_SIZE]; + REPARSE_DATA_BUFFER rdb; + } info; + + handle_wrapper h( + create_file_handle(p.c_str(),GENERIC_READ, 0, 0, OPEN_EXISTING, + FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OPEN_REPARSE_POINT, 0)); + + if (error(h.handle == INVALID_HANDLE_VALUE, p, ec, "boost::filesystem::read_symlink")) + return symlink_path; + + DWORD sz; + + if (!error(::DeviceIoControl(h.handle, FSCTL_GET_REPARSE_POINT, + 0, 0, info.buf, sizeof(info), &sz, 0) == 0, p, ec, + "boost::filesystem::read_symlink" )) + symlink_path.assign( + static_cast(info.rdb.SymbolicLinkReparseBuffer.PathBuffer) + + info.rdb.SymbolicLinkReparseBuffer.PrintNameOffset/sizeof(wchar_t), + static_cast(info.rdb.SymbolicLinkReparseBuffer.PathBuffer) + + info.rdb.SymbolicLinkReparseBuffer.PrintNameOffset/sizeof(wchar_t) + + info.rdb.SymbolicLinkReparseBuffer.PrintNameLength/sizeof(wchar_t)); +# endif + return symlink_path; + } + + BOOST_FILESYSTEM_DECL + bool remove(const path& p, error_code* ec) + { + error_code tmp_ec; + file_status sym_status = symlink_status(p, tmp_ec); + if (error(sym_status.type() == status_error, tmp_ec, p, ec, + "boost::filesystem::remove")) + return false; + + return remove_file_or_directory(p, sym_status, ec); + } + + BOOST_FILESYSTEM_DECL + boost::uintmax_t remove_all(const path& p, error_code* ec) + { + error_code tmp_ec; + file_status sym_status = symlink_status(p, tmp_ec); + if (error(sym_status.type() == status_error, tmp_ec, p, ec, + "boost::filesystem::remove_all")) + return 0; + + return exists(sym_status) // exists() throws nothing + ? remove_all_aux(p, sym_status, ec) + : 0; + } + + BOOST_FILESYSTEM_DECL + void rename(const path& old_p, const path& new_p, error_code* ec) + { + error(!BOOST_MOVE_FILE(old_p.c_str(), new_p.c_str()), old_p, new_p, ec, + "boost::filesystem::rename"); + } + + BOOST_FILESYSTEM_DECL + void resize_file(const path& p, uintmax_t size, system::error_code* ec) + { + error(!BOOST_RESIZE_FILE(p.c_str(), size), p, ec, "boost::filesystem::resize_file"); + } + + BOOST_FILESYSTEM_DECL + space_info space(const path& p, error_code* ec) + { +# ifdef BOOST_POSIX_API + struct BOOST_STATVFS vfs; + space_info info; + if (!error(::BOOST_STATVFS(p.c_str(), &vfs)!= 0, + p, ec, "boost::filesystem::space")) + { + info.capacity + = static_cast(vfs.f_blocks)* BOOST_STATVFS_F_FRSIZE; + info.free + = static_cast(vfs.f_bfree)* BOOST_STATVFS_F_FRSIZE; + info.available + = static_cast(vfs.f_bavail)* BOOST_STATVFS_F_FRSIZE; + } + +# else + ULARGE_INTEGER avail, total, free; + space_info info; + + if (!error(::GetDiskFreeSpaceExW(p.c_str(), &avail, &total, &free)== 0, + p, ec, "boost::filesystem::space")) + { + info.capacity + = (static_cast(total.HighPart)<< 32) + + total.LowPart; + info.free + = (static_cast(free.HighPart)<< 32) + + free.LowPart; + info.available + = (static_cast(avail.HighPart)<< 32) + + avail.LowPart; + } + +# endif + + else + { + info.capacity = info.free = info.available = 0; + } + return info; + } + +# ifndef BOOST_POSIX_API + + file_status process_status_failure(const path& p, error_code* ec) + { + int errval(::GetLastError()); + if (ec != 0) // always report errval, even though some + ec->assign(errval, system_category()); // errval values are not status_errors + + if (not_found_error(errval)) + { + return file_status(file_not_found); + } + else if ((errval == ERROR_SHARING_VIOLATION)) + { + return file_status(type_unknown); + } + if (ec == 0) + BOOST_FILESYSTEM_THROW(filesystem_error("boost::filesystem::status", + p, error_code(errval, system_category()))); + return file_status(status_error); + } +# endif + + BOOST_FILESYSTEM_DECL + file_status status(const path& p, error_code* ec) + { +# ifdef BOOST_POSIX_API + + struct stat path_stat; + if (::stat(p.c_str(), &path_stat)!= 0) + { + if (ec != 0) // always report errno, even though some + ec->assign(errno, system_category()); // errno values are not status_errors + + if (not_found_error(errno)) + { + return fs::file_status(fs::file_not_found); + } + if (ec == 0) + BOOST_FILESYSTEM_THROW(filesystem_error("boost::filesystem::status", + p, error_code(errno, system_category()))); + return fs::file_status(fs::status_error); + } + if (ec != 0) ec->clear();; + if (S_ISDIR(path_stat.st_mode)) + return fs::file_status(fs::directory_file); + if (S_ISREG(path_stat.st_mode)) + return fs::file_status(fs::regular_file); + if (S_ISBLK(path_stat.st_mode)) + return fs::file_status(fs::block_file); + if (S_ISCHR(path_stat.st_mode)) + return fs::file_status(fs::character_file); + if (S_ISFIFO(path_stat.st_mode)) + return fs::file_status(fs::fifo_file); + if (S_ISSOCK(path_stat.st_mode)) + return fs::file_status(fs::socket_file); + return fs::file_status(fs::type_unknown); + +# else // Windows + + DWORD attr(::GetFileAttributesW(p.c_str())); + if (attr == 0xFFFFFFFF) + { + return detail::process_status_failure(p, ec); + } + + // symlink handling + if (attr & FILE_ATTRIBUTE_REPARSE_POINT)// aka symlink + { + handle_wrapper h( + create_file_handle( + p.c_str(), + 0, // dwDesiredAccess; attributes only + FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE, + 0, // lpSecurityAttributes + OPEN_EXISTING, + FILE_FLAG_BACKUP_SEMANTICS, + 0)); // hTemplateFile + if (h.handle == INVALID_HANDLE_VALUE) + { + return detail::process_status_failure(p, ec); + } + } + + if (ec != 0) ec->clear(); + return (attr & FILE_ATTRIBUTE_DIRECTORY) + ? file_status(directory_file) + : file_status(regular_file); + +# endif + } + + BOOST_FILESYSTEM_DECL + file_status symlink_status(const path& p, error_code* ec) + { +# ifdef BOOST_POSIX_API + + struct stat path_stat; + if (::lstat(p.c_str(), &path_stat)!= 0) + { + if (ec != 0) // always report errno, even though some + ec->assign(errno, system_category()); // errno values are not status_errors + + if (errno == ENOENT || errno == ENOTDIR) // these are not errors + { + return fs::file_status(fs::file_not_found); + } + if (ec == 0) + BOOST_FILESYSTEM_THROW(filesystem_error("boost::filesystem::status", + p, error_code(errno, system_category()))); + return fs::file_status(fs::status_error); + } + if (ec != 0) ec->clear(); + if (S_ISREG(path_stat.st_mode)) + return fs::file_status(fs::regular_file); + if (S_ISDIR(path_stat.st_mode)) + return fs::file_status(fs::directory_file); + if (S_ISLNK(path_stat.st_mode)) + return fs::file_status(fs::symlink_file); + if (S_ISBLK(path_stat.st_mode)) + return fs::file_status(fs::block_file); + if (S_ISCHR(path_stat.st_mode)) + return fs::file_status(fs::character_file); + if (S_ISFIFO(path_stat.st_mode)) + return fs::file_status(fs::fifo_file); + if (S_ISSOCK(path_stat.st_mode)) + return fs::file_status(fs::socket_file); + return fs::file_status(fs::type_unknown); + +# else // Windows + + DWORD attr(::GetFileAttributesW(p.c_str())); + if (attr == 0xFFFFFFFF) + { + return detail::process_status_failure(p, ec); + } + + if (ec != 0) ec->clear(); + + if (attr & FILE_ATTRIBUTE_REPARSE_POINT)// aka symlink + return file_status(symlink_file); + + return (attr & FILE_ATTRIBUTE_DIRECTORY) + ? file_status(directory_file) + : file_status(regular_file); + +# endif + } + + BOOST_FILESYSTEM_DECL + path system_complete(const path& p, system::error_code* ec) + { +# ifdef BOOST_POSIX_API + return (p.empty() || p.is_absolute()) + ? p : current_path()/ p; + +# else + if (p.empty()) + { + if (ec != 0) ec->clear(); + return p; + } + wchar_t buf[buf_size]; + wchar_t* pfn; + std::size_t len = get_full_path_name(p, buf_size, buf, &pfn); + + if (error(len == 0, p, ec, "boost::filesystem::system_complete")) + return path(); + + if (len < buf_size)// len does not include null termination character + return path(&buf[0]); + + boost::scoped_array big_buf(new wchar_t[len]); + + return error(get_full_path_name(p, len , big_buf.get(), &pfn)== 0, + p, ec, "boost::filesystem::system_complete") + ? path() + : path(big_buf.get()); +# endif + } + +} // namespace detail + +//--------------------------------------------------------------------------------------// +// // +// directory_entry // +// // +//--------------------------------------------------------------------------------------// + + file_status + directory_entry::m_get_status(system::error_code* ec) const + { + if (!status_known(m_status)) + { + // optimization: if the symlink status is known, and it isn't a symlink, + // then status and symlink_status are identical so just copy the + // symlink status to the regular status. + if (status_known(m_symlink_status) + && !is_symlink(m_symlink_status)) + { + m_status = m_symlink_status; + if (ec != 0) ec->clear(); + } + else m_status = detail::status(m_path, ec); + } + else if (ec != 0) ec->clear(); + return m_status; + } + + file_status + directory_entry::m_get_symlink_status(system::error_code* ec) const + { + if (!status_known(m_symlink_status)) + m_symlink_status = detail::symlink_status(m_path, ec); + else if (ec != 0) ec->clear(); + return m_symlink_status; + } + +// dispatch directory_entry supplied here rather than in +// , thus avoiding header circularity. +// test cases are in operations_unit_test.cpp + +namespace path_traits +{ + void dispatch(const directory_entry & de, +# ifdef BOOST_WINDOWS_API + std::wstring& to, +# else + std::string& to, +# endif + const codecvt_type &) + { + to = de.path().native(); + } + +} // namespace path_traits +} // namespace filesystem +} // namespace boost + +//--------------------------------------------------------------------------------------// +// // +// directory_iterator // +// // +//--------------------------------------------------------------------------------------// + +namespace +{ +# ifdef BOOST_POSIX_API + + error_code path_max(std::size_t & result) + // this code is based on Stevens and Rago, Advanced Programming in the + // UNIX envirnment, 2nd Ed., ISBN 0-201-43307-9, page 49 + { +# ifdef PATH_MAX + static std::size_t max = PATH_MAX; +# else + static std::size_t max = 0; +# endif + if (max == 0) + { + errno = 0; + long tmp = ::pathconf("/", _PC_NAME_MAX); + if (tmp < 0) + { + if (errno == 0)// indeterminate + max = 4096; // guess + else return error_code(errno, system_category()); + } + else max = static_cast(tmp + 1); // relative root + } + result = max; + return ok; + } + + error_code dir_itr_first(void *& handle, void *& buffer, + const char* dir, string& target, + fs::file_status &, fs::file_status &) + { + if ((handle = ::opendir(dir))== 0) + return error_code(errno, system_category()); + target = string("."); // string was static but caused trouble + // when iteration called from dtor, after + // static had already been destroyed + std::size_t path_size (0); // initialization quiets gcc warning (ticket #3509) + error_code ec = path_max(path_size); + if (ec)return ec; + dirent de; + buffer = std::malloc((sizeof(dirent) - sizeof(de.d_name)) + + path_size + 1); // + 1 for "/0" + return ok; + } + + // warning: the only dirent member updated is d_name + inline int readdir_r_simulator(DIR * dirp, struct dirent * entry, + struct dirent ** result)// *result set to 0 on end of directory + { + errno = 0; + +# if !defined(__CYGWIN__)\ + && defined(_POSIX_THREAD_SAFE_FUNCTIONS)\ + && defined(_SC_THREAD_SAFE_FUNCTIONS)\ + && (_POSIX_THREAD_SAFE_FUNCTIONS+0 >= 0)\ + && (!defined(__hpux) || defined(_REENTRANT)) \ + && (!defined(_AIX) || defined(__THREAD_SAFE)) + if (::sysconf(_SC_THREAD_SAFE_FUNCTIONS)>= 0) + { return ::readdir_r(dirp, entry, result); } +# endif + + struct dirent * p; + *result = 0; + if ((p = ::readdir(dirp))== 0) + return errno; + std::strcpy(entry->d_name, p->d_name); + *result = entry; + return 0; + } + + error_code dir_itr_increment(void *& handle, void *& buffer, + string& target, fs::file_status & sf, fs::file_status & symlink_sf) + { + BOOST_ASSERT(buffer != 0); + dirent * entry(static_cast(buffer)); + dirent * result; + int return_code; + if ((return_code = readdir_r_simulator(static_cast(handle), + entry, &result))!= 0)return error_code(errno, system_category()); + if (result == 0) + return fs::detail::dir_itr_close(handle, buffer); + target = entry->d_name; +# ifdef BOOST_FILESYSTEM_STATUS_CACHE + if (entry->d_type == DT_UNKNOWN) // filesystem does not supply d_type value + { + sf = symlink_sf = fs::file_status(fs::status_error); + } + else // filesystem supplies d_type value + { + if (entry->d_type == DT_DIR) + sf = symlink_sf = fs::file_status(fs::directory_file); + else if (entry->d_type == DT_REG) + sf = symlink_sf = fs::file_status(fs::regular_file); + else if (entry->d_type == DT_LNK) + { + sf = fs::file_status(fs::status_error); + symlink_sf = fs::file_status(fs::symlink_file); + } + else sf = symlink_sf = fs::file_status(fs::status_error); + } +# else + sf = symlink_sf = fs::file_status(fs::status_error); +# endif + return ok; + } + +# else // BOOST_WINDOWS_API + + error_code dir_itr_first(void *& handle, const fs::path& dir, + wstring& target, fs::file_status & sf, fs::file_status & symlink_sf) + // Note: an empty root directory has no "." or ".." entries, so this + // causes a ERROR_FILE_NOT_FOUND error which we do not considered an + // error. It is treated as eof instead. + { + // use a form of search Sebastian Martel reports will work with Win98 + wstring dirpath(dir.wstring()); + dirpath += (dirpath.empty() + || (dirpath[dirpath.size()-1] != L'\\' + && dirpath[dirpath.size()-1] != L'/' + && dirpath[dirpath.size()-1] != L':'))? L"\\*" : L"*"; + + WIN32_FIND_DATAW data; + if ((handle = ::FindFirstFileW(dirpath.c_str(), &data)) + == INVALID_HANDLE_VALUE) + { + handle = 0; + return error_code( (::GetLastError() == ERROR_FILE_NOT_FOUND + // Windows Mobile returns ERROR_NO_MORE_FILES; see ticket #3551 + || ::GetLastError() == ERROR_NO_MORE_FILES) + ? 0 : ::GetLastError(), system_category() ); + } + target = data.cFileName; + if (data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) + { sf.type(fs::directory_file); symlink_sf.type(fs::directory_file); } + else { sf.type(fs::regular_file); symlink_sf.type(fs::regular_file); } + return error_code(); + } + + error_code dir_itr_increment(void *& handle, wstring& target, + fs::file_status & sf, fs::file_status & symlink_sf) + { + WIN32_FIND_DATAW data; + if (::FindNextFileW(handle, &data)== 0)// fails + { + int error = ::GetLastError(); + fs::detail::dir_itr_close(handle); + return error_code(error == ERROR_NO_MORE_FILES ? 0 : error, system_category()); + } + target = data.cFileName; + if (data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) + { sf.type(fs::directory_file); symlink_sf.type(fs::directory_file); } + else { sf.type(fs::regular_file); symlink_sf.type(fs::regular_file); } + return error_code(); + } +#endif + + const error_code not_found_error_code ( +# ifdef BOOST_WINDOWS_API + ERROR_PATH_NOT_FOUND +# else + ENOENT +# endif + , system_category()); + +} // unnamed namespace + +namespace boost +{ +namespace filesystem +{ + +namespace detail +{ + // dir_itr_close is called both from the ~dir_itr_imp()destructor + // and dir_itr_increment() + BOOST_FILESYSTEM_DECL + system::error_code dir_itr_close( // never throws + void *& handle +# if defined(BOOST_POSIX_API) + , void *& buffer +# endif + ) + { +# ifdef BOOST_POSIX_API + std::free(buffer); + buffer = 0; + if (handle == 0)return ok; + DIR * h(static_cast(handle)); + handle = 0; + return error_code(::closedir(h)== 0 ? 0 : errno, system_category()); + +# else + if (handle != 0) + { + ::FindClose(handle); + handle = 0; + } + return ok; + +# endif + } + + void directory_iterator_construct(directory_iterator& it, + const path& p, system::error_code* ec) + { + if (error(p.empty(), not_found_error_code, p, ec, + "boost::filesystem::directory_iterator::construct"))return; + + path::string_type filename; + file_status file_stat, symlink_file_stat; + error_code result = dir_itr_first(it.m_imp->handle, +# if defined(BOOST_POSIX_API) + it.m_imp->buffer, +# endif + p.c_str(), filename, file_stat, symlink_file_stat); + + if (result) + { + it.m_imp.reset(); + error(true, result, p, + ec, "boost::filesystem::directory_iterator::construct"); + return; + } + + if (it.m_imp->handle == 0)it.m_imp.reset(); // eof, so make end iterator + else // not eof + { + it.m_imp->dir_entry.assign(p / filename, + file_stat, symlink_file_stat); + if (filename[0] == dot // dot or dot-dot + && (filename.size()== 1 + || (filename[1] == dot + && filename.size()== 2))) + { it.increment(); } + } + } + + void directory_iterator_increment(directory_iterator& it, + system::error_code* ec) + { + BOOST_ASSERT(it.m_imp.get() && "attempt to increment end iterator"); + BOOST_ASSERT(it.m_imp->handle != 0 && "internal program error"); + + path::string_type filename; + file_status file_stat, symlink_file_stat; + system::error_code temp_ec; + + for (;;) + { + temp_ec = dir_itr_increment(it.m_imp->handle, +# if defined(BOOST_POSIX_API) + it.m_imp->buffer, +# endif + filename, file_stat, symlink_file_stat); + + if (temp_ec) + { + it.m_imp.reset(); + if (ec == 0) + BOOST_FILESYSTEM_THROW( + filesystem_error("boost::filesystem::directory_iterator::operator++", + it.m_imp->dir_entry.path().parent_path(), + error_code(BOOST_ERRNO, system_category()))); + ec->assign(BOOST_ERRNO, system_category()); + return; + } + else if (ec != 0) ec->clear(); + + if (it.m_imp->handle == 0){ it.m_imp.reset(); return; } // eof, make end + if (!(filename[0] == dot // !(dot or dot-dot) + && (filename.size()== 1 + || (filename[1] == dot + && filename.size()== 2)))) + { + it.m_imp->dir_entry.replace_filename( + filename, file_stat, symlink_file_stat); + return; + } + } + } +} // namespace detail +} // namespace filesystem +} // namespace boost diff --git a/v3/libs/filesystem/src/path.cpp b/v3/libs/filesystem/src/path.cpp new file mode 100644 index 0000000..9d826d1 --- /dev/null +++ b/v3/libs/filesystem/src/path.cpp @@ -0,0 +1,848 @@ +// filesystem path.cpp ------------------------------------------------------------- // + +// Copyright Beman Dawes 2008 + +// Distributed under the Boost Software License, Version 1.0. +// See http://www.boost.org/LICENSE_1_0.txt + +// Library home page: http://www.boost.org/libs/filesystem + +// define BOOST_FILESYSTEM_SOURCE so that knows +// the library is being built (possibly exporting rather than importing code) +#define BOOST_FILESYSTEM_SOURCE + +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef BOOST_WINDOWS_API +# include "windows_file_codecvt.hpp" +# include +#elif defined(macintosh) || defined(__APPLE__) || defined(__APPLE_CC__) +# include "utf8_codecvt_facet.hpp" +#endif + +#ifdef BOOST_FILESYSTEM_DEBUG +# include +# include +#endif + +namespace fs = boost::filesystem; + +using fs::path; + +using std::string; +using std::wstring; + +using boost::system::error_code; + +#ifndef BOOST_FILESYSTEM_CODECVT_BUF_SIZE +# define BOOST_FILESYSTEM_CODECVT_BUF_SIZE 256 +#endif + +//--------------------------------------------------------------------------------------// +// // +// class path helpers // +// // +//--------------------------------------------------------------------------------------// + +namespace +{ + //------------------------------------------------------------------------------------// + // miscellaneous class path helpers // + //------------------------------------------------------------------------------------// + + typedef path::value_type value_type; + typedef path::string_type string_type; + typedef string_type::size_type size_type; + + const std::size_t default_codecvt_buf_size = BOOST_FILESYSTEM_CODECVT_BUF_SIZE; + +# ifdef BOOST_WINDOWS_API + + const wchar_t separator = L'/'; + const wchar_t preferred_separator = L'\\'; + const wchar_t* const separators = L"/\\"; + const wchar_t* separator_string = L"/"; + const wchar_t* preferred_separator_string = L"\\"; + const wchar_t colon = L':'; + const wchar_t dot = L'.'; + const fs::path dot_path(L"."); + const fs::path dot_dot_path(L".."); + +# else + + const char separator = '/'; + const char preferred_separator = '/'; + const char* const separators = "/"; + const char* separator_string = "/"; + const char* preferred_separator_string = "/"; + const char colon = ':'; + const char dot = '.'; + const fs::path dot_path("."); + const fs::path dot_dot_path(".."); + +# endif + + inline bool is_separator(fs::path::value_type c) + { + return c == separator +# ifdef BOOST_WINDOWS_API + || c == preferred_separator +# endif + ; + } + + bool is_non_root_separator(const string_type& str, size_type pos); + // pos is position of the separator + + size_type filename_pos(const string_type& str, + size_type end_pos); // end_pos is past-the-end position + // Returns: 0 if str itself is filename (or empty) + + size_type root_directory_start(const string_type& path, size_type size); + // Returns: npos if no root_directory found + + void first_element( + const string_type& src, + size_type& element_pos, + size_type& element_size, +# if !BOOST_WORKAROUND(BOOST_MSVC, <= 1310) // VC++ 7.1 + size_type size = string_type::npos +# else + size_type size = -1 +# endif + ); + +} // unnamed namespace + +//--------------------------------------------------------------------------------------// +// // +// class path implementation // +// // +//--------------------------------------------------------------------------------------// + +namespace boost +{ +namespace filesystem +{ + + path & path::operator/=(const path & p) + { + if (p.empty()) + return *this; + if (!is_separator(*p.m_pathname.begin())) + m_append_separator_if_needed(); + m_pathname += p.m_pathname; + return *this; + } + +# ifdef BOOST_WINDOWS_API + + const std::string path::string() const + { + std::string tmp; + if (!m_pathname.empty()) + path_traits::convert(&*m_pathname.begin(), &*m_pathname.begin()+m_pathname.size(), + tmp, codecvt()); + return tmp; + } + + void path::m_portable() + { + for (string_type::iterator it = m_pathname.begin(); + it != m_pathname.end(); ++it) + { + if (*it == L'\\') + *it = L'/'; + } + } + + const std::string path::generic_string() const + { + path tmp(*this); + tmp.m_portable(); + return tmp.string(); + } + + const std::wstring path::generic_wstring() const + { + path tmp(*this); + tmp.m_portable(); + return tmp.wstring(); + } + +# endif // BOOST_WINDOWS_API + + // m_append_separator_if_needed ----------------------------------------------------// + + path::string_type::size_type path::m_append_separator_if_needed() + { + if (!m_pathname.empty() && +# ifdef BOOST_WINDOWS_API + *(m_pathname.end()-1) != colon && +# endif + !is_separator(*(m_pathname.end()-1))) + { + string_type::size_type tmp(m_pathname.size()); + m_pathname += preferred_separator; + return tmp; + } + return 0; + } + + // m_erase_redundant_separator -----------------------------------------------------// + + void path::m_erase_redundant_separator(string_type::size_type sep_pos) + { + if (sep_pos // a separator was added + && sep_pos < m_pathname.size() // and something was appended + && (m_pathname[sep_pos+1] == separator // and it was also separator +# ifdef BOOST_WINDOWS_API + || m_pathname[sep_pos+1] == preferred_separator // or preferred_separator +# endif +)) { m_pathname.erase(sep_pos, 1); } // erase the added separator + } + + // modifiers -----------------------------------------------------------------------// + + path& path::make_absolute(const path& base) + { + // store expensive to compute values that are needed multiple times + path this_root_name (root_name()); + path base_root_name (base.root_name()); + path this_root_directory (root_directory()); + +# ifdef BOOST_WINDOWS_API + BOOST_ASSERT(!this_root_name.empty() || !base_root_name.empty()); +# endif + + BOOST_ASSERT(!this_root_directory.empty() || base.has_root_directory()); + + if (m_pathname.empty()) + m_pathname = base.m_pathname; + + else if (!this_root_name.empty()) // has_root_name + { + if (this_root_directory.empty()) // !root_directory() + { + path tmp (this_root_name / base.root_directory() + / base.relative_path() / relative_path()); + m_pathname.swap(tmp.m_pathname); + } + // else is_absolute() so do nothing at all + } + + else if (has_root_directory()) + { +# ifdef BOOST_POSIX_API + if (base_root_name.empty()) return *this; +# endif + path tmp (base_root_name / m_pathname); + m_pathname.swap(tmp.m_pathname); + } + + else + { + path tmp (base / m_pathname); + m_pathname.swap(tmp.m_pathname); + } + + return *this; + } + +# ifdef BOOST_WINDOWS_API + path & path::make_preferred() + { + for (string_type::iterator it = m_pathname.begin(); + it != m_pathname.end(); ++it) + { + if (*it == L'/') + *it = L'\\'; + } + return *this; + } +# endif + + path& path::remove_filename() + { + m_pathname.erase(m_parent_path_end()); + return *this; + } + + path & path::replace_extension(const path & source) + { + // erase existing extension if any + size_type pos(m_pathname.rfind(dot)); + if (pos != string_type::npos) + m_pathname.erase(pos); + + // append source extension if any + pos = source.m_pathname.rfind(dot); + if (pos != string_type::npos) + m_pathname += source.c_str() + pos; + + return *this; + } + + // decomposition -------------------------------------------------------------------// + + path path::root_path() const + { + path temp(root_name()); + if (!root_directory().empty()) temp.m_pathname += root_directory().c_str(); + return temp; + } + + path path::root_name() const + { + iterator itr(begin()); + + return (itr.m_pos != m_pathname.size() + && ( + (itr.m_element.m_pathname.size() > 1 + && is_separator(itr.m_element.m_pathname[0]) + && is_separator(itr.m_element.m_pathname[1]) + ) +# ifdef BOOST_WINDOWS_API + || itr.m_element.m_pathname[itr.m_element.m_pathname.size()-1] == colon +# endif + )) + ? itr.m_element + : path(); + } + + path path::root_directory() const + { + size_type pos(root_directory_start(m_pathname, m_pathname.size())); + + return pos == string_type::npos + ? path() + : path(m_pathname.c_str() + pos, m_pathname.c_str() + pos + 1); + } + + path path::relative_path() const + { + iterator itr(begin()); + + for (; itr.m_pos != m_pathname.size() + && (is_separator(itr.m_element.m_pathname[0]) +# ifdef BOOST_WINDOWS_API + || itr.m_element.m_pathname[itr.m_element.m_pathname.size()-1] == colon +# endif + ); ++itr) {} + + return path(m_pathname.c_str() + itr.m_pos); + } + + string_type::size_type path::m_parent_path_end() const + { + size_type end_pos(filename_pos(m_pathname, m_pathname.size())); + + bool filename_was_separator(m_pathname.size() + && is_separator(m_pathname[end_pos])); + + // skip separators unless root directory + size_type root_dir_pos(root_directory_start(m_pathname, end_pos)); + for (; + end_pos > 0 + && (end_pos-1) != root_dir_pos + && is_separator(m_pathname[end_pos-1]) + ; + --end_pos) {} + + return (end_pos == 1 && root_dir_pos == 0 && filename_was_separator) + ? string_type::npos + : end_pos; + } + + path path::parent_path() const + { + size_type end_pos(m_parent_path_end()); + return end_pos == string_type::npos + ? path() + : path(m_pathname.c_str(), m_pathname.c_str() + end_pos); + } + + path path::filename() const + { + size_type pos(filename_pos(m_pathname, m_pathname.size())); + return (m_pathname.size() + && pos + && is_separator(m_pathname[pos]) + && is_non_root_separator(m_pathname, pos)) + ? dot_path + : path(m_pathname.c_str() + pos); + } + + path path::stem() const + { + path name(filename()); + if (name == dot_path || name == dot_dot_path) return name; + size_type pos(name.m_pathname.rfind(dot)); + return pos == string_type::npos + ? name + : path(name.m_pathname.c_str(), name.m_pathname.c_str() + pos); + } + + path path::extension() const + { + path name(filename()); + if (name == dot_path || name == dot_dot_path) return path(); + size_type pos(name.m_pathname.rfind(dot)); + return pos == string_type::npos + ? path() + : path(name.m_pathname.c_str() + pos); + } + + // m_normalize ----------------------------------------------------------------------// + + path& path::m_normalize() + { + if (m_pathname.empty()) return *this; + + path temp; + iterator start(begin()); + iterator last(end()); + iterator stop(last--); + for (iterator itr(start); itr != stop; ++itr) + { + // ignore "." except at start and last + if (itr->native().size() == 1 + && (itr->native())[0] == dot + && itr != start + && itr != last) continue; + + // ignore a name and following ".." + if (!temp.empty() + && itr->native().size() == 2 + && (itr->native())[0] == dot + && (itr->native())[1] == dot) // dot dot + { + string_type lf(temp.filename().native()); + if (lf.size() > 0 + && (lf.size() != 1 + || (lf[0] != dot + && lf[0] != separator)) + && (lf.size() != 2 + || (lf[0] != dot + && lf[1] != dot +# ifdef BOOST_WINDOWS_API + && lf[1] != colon +# endif + ) + ) + ) + { + temp.remove_filename(); + // if not root directory, must also remove "/" if any + if (temp.m_pathname.size() > 0 + && temp.m_pathname[temp.m_pathname.size()-1] + == separator) + { + string_type::size_type rds( + root_directory_start(temp.m_pathname, temp.m_pathname.size())); + if (rds == string_type::npos + || rds != temp.m_pathname.size()-1) + { temp.m_pathname.erase(temp.m_pathname.size()-1); } + } + + iterator next(itr); + if (temp.empty() && ++next != stop + && next == last && *last == dot_path) temp /= dot_path; + continue; + } + } + + temp /= *itr; + }; + + if (temp.empty()) temp /= dot_path; + m_pathname = temp.m_pathname; + return *this; + } + +} // namespace filesystem +} // namespace boost + +//--------------------------------------------------------------------------------------// +// // +// class path helpers implementation // +// // +//--------------------------------------------------------------------------------------// + +namespace +{ + + // is_non_root_separator -------------------------------------------------// + + bool is_non_root_separator(const string_type & str, size_type pos) + // pos is position of the separator + { + BOOST_ASSERT(!str.empty() && is_separator(str[pos]) + && "precondition violation"); + + // subsequent logic expects pos to be for leftmost slash of a set + while (pos > 0 && is_separator(str[pos-1])) + --pos; + + return pos != 0 + && (pos <= 2 || !is_separator(str[1]) + || str.find_first_of(separators, 2) != pos) +# ifdef BOOST_WINDOWS_API + && (pos !=2 || str[1] != colon) +# endif + ; + } + + // filename_pos --------------------------------------------------------------------// + + size_type filename_pos(const string_type & str, + size_type end_pos) // end_pos is past-the-end position + // return 0 if str itself is filename (or empty) + { + // case: "//" + if (end_pos == 2 + && is_separator(str[0]) + && is_separator(str[1])) return 0; + + // case: ends in "/" + if (end_pos && is_separator(str[end_pos-1])) + return end_pos-1; + + // set pos to start of last element + size_type pos(str.find_last_of(separators, end_pos-1)); + +# ifdef BOOST_WINDOWS_API + if (pos == string_type::npos) + pos = str.find_last_of(colon, end_pos-2); +# endif + + return (pos == string_type::npos // path itself must be a filename (or empty) + || (pos == 1 && is_separator(str[0]))) // or net + ? 0 // so filename is entire string + : pos + 1; // or starts after delimiter + } + + // root_directory_start ------------------------------------------------------------// + + size_type root_directory_start(const string_type & path, size_type size) + // return npos if no root_directory found + { + +# ifdef BOOST_WINDOWS_API + // case "c:/" + if (size > 2 + && path[1] == colon + && is_separator(path[2])) return 2; +# endif + + // case "//" + if (size == 2 + && is_separator(path[0]) + && is_separator(path[1])) return string_type::npos; + + // case "//net {/}" + if (size > 3 + && is_separator(path[0]) + && is_separator(path[1]) + && !is_separator(path[2])) + { + string_type::size_type pos(path.find_first_of(separators, 2)); + return pos < size ? pos : string_type::npos; + } + + // case "/" + if (size > 0 && is_separator(path[0])) return 0; + + return string_type::npos; + } + + // first_element --------------------------------------------------------------------// + // sets pos and len of first element, excluding extra separators + // if src.empty(), sets pos,len, to 0,0. + + void first_element( + const string_type & src, + size_type & element_pos, + size_type & element_size, + size_type size +) + { + if (size == string_type::npos) size = src.size(); + element_pos = 0; + element_size = 0; + if (src.empty()) return; + + string_type::size_type cur(0); + + // deal with // [network] + if (size >= 2 && is_separator(src[0]) + && is_separator(src[1]) + && (size == 2 + || !is_separator(src[2]))) + { + cur += 2; + element_size += 2; + } + + // leading (not non-network) separator + else if (is_separator(src[0])) + { + ++element_size; + // bypass extra leading separators + while (cur+1 < size + && is_separator(src[cur+1])) + { + ++cur; + ++element_pos; + } + return; + } + + // at this point, we have either a plain name, a network name, + // or (on Windows only) a device name + + // find the end + while (cur < size +# ifdef BOOST_WINDOWS_API + && src[cur] != colon +# endif + && !is_separator(src[cur])) + { + ++cur; + ++element_size; + } + +# ifdef BOOST_WINDOWS_API + if (cur == size) return; + // include device delimiter + if (src[cur] == colon) + { ++element_size; } +# endif + + return; + } + +} // unnammed namespace + +//--------------------------------------------------------------------------------------// +// // +// class path::iterator implementation // +// // +//--------------------------------------------------------------------------------------// + +namespace boost +{ +namespace filesystem +{ + + path::iterator path::begin() const + { + iterator itr; + itr.m_path_ptr = this; + size_type element_size; + first_element(m_pathname, itr.m_pos, element_size); + itr.m_element = m_pathname.substr(itr.m_pos, element_size); + if (itr.m_element.m_pathname == preferred_separator_string) + itr.m_element.m_pathname = separator_string; // needed for Windows, harmless on POSIX + return itr; + } + + path::iterator path::end() const + { + iterator itr; + itr.m_path_ptr = this; + itr.m_pos = m_pathname.size(); + return itr; + } + + void path::m_path_iterator_increment(path::iterator & it) + { + BOOST_ASSERT(it.m_pos < it.m_path_ptr->m_pathname.size() && "path::basic_iterator increment past end()"); + + // increment to position past current element + it.m_pos += it.m_element.m_pathname.size(); + + // if end reached, create end basic_iterator + if (it.m_pos == it.m_path_ptr->m_pathname.size()) + { + it.m_element.clear(); + return; + } + + // both POSIX and Windows treat paths that begin with exactly two separators specially + bool was_net(it.m_element.m_pathname.size() > 2 + && is_separator(it.m_element.m_pathname[0]) + && is_separator(it.m_element.m_pathname[1]) + && !is_separator(it.m_element.m_pathname[2])); + + // process separator (Windows drive spec is only case not a separator) + if (is_separator(it.m_path_ptr->m_pathname[it.m_pos])) + { + // detect root directory + if (was_net +# ifdef BOOST_WINDOWS_API + // case "c:/" + || it.m_element.m_pathname[it.m_element.m_pathname.size()-1] == colon +# endif + ) + { + it.m_element.m_pathname = separator; + return; + } + + // bypass separators + while (it.m_pos != it.m_path_ptr->m_pathname.size() + && is_separator(it.m_path_ptr->m_pathname[it.m_pos])) + { ++it.m_pos; } + + // detect trailing separator, and treat it as ".", per POSIX spec + if (it.m_pos == it.m_path_ptr->m_pathname.size() + && is_non_root_separator(it.m_path_ptr->m_pathname, it.m_pos-1)) + { + --it.m_pos; + it.m_element = dot_path; + return; + } + } + + // get next element + size_type end_pos(it.m_path_ptr->m_pathname.find_first_of(separators, it.m_pos)); + if (end_pos == string_type::npos) end_pos = it.m_path_ptr->m_pathname.size(); + it.m_element = it.m_path_ptr->m_pathname.substr(it.m_pos, end_pos - it.m_pos); + } + + void path::m_path_iterator_decrement(path::iterator & it) + { + BOOST_ASSERT(it.m_pos && "path::iterator decrement past begin()"); + + size_type end_pos(it.m_pos); + + // if at end and there was a trailing non-root '/', return "." + if (it.m_pos == it.m_path_ptr->m_pathname.size() + && it.m_path_ptr->m_pathname.size() > 1 + && is_separator(it.m_path_ptr->m_pathname[it.m_pos-1]) + && is_non_root_separator(it.m_path_ptr->m_pathname, it.m_pos-1) + ) + { + --it.m_pos; + it.m_element = dot_path; + return; + } + + size_type root_dir_pos(root_directory_start(it.m_path_ptr->m_pathname, end_pos)); + + // skip separators unless root directory + for ( + ; + end_pos > 0 + && (end_pos-1) != root_dir_pos + && is_separator(it.m_path_ptr->m_pathname[end_pos-1]) + ; + --end_pos) {} + + it.m_pos = filename_pos(it.m_path_ptr->m_pathname, end_pos); + it.m_element = it.m_path_ptr->m_pathname.substr(it.m_pos, end_pos - it.m_pos); + if (it.m_element.m_pathname == preferred_separator_string) + it.m_element.m_pathname = separator_string; // needed for Windows, harmless on POSIX + } + +} // namespace filesystem +} // namespace boost + +//--------------------------------------------------------------------------------------// +// // +// detail helpers // +// // +//--------------------------------------------------------------------------------------// + +namespace +{ + + //------------------------------------------------------------------------------------// + // locale helpers // + //------------------------------------------------------------------------------------// + + // std::locale construction can throw (if LC_MESSAGES is wrong, for example), + // so a static at function scope is used to ensure that exceptions can be + // caught. (A previous version was at namespace scope, so initialization + // occurred before main(), preventing exceptions from being caught.) + + std::locale default_locale() + { +# ifdef BOOST_WINDOWS_API + std::locale global_loc = std::locale(); + std::locale loc(global_loc, new windows_file_codecvt); + return loc; + +# elif defined(macintosh) || defined(__APPLE__) || defined(__APPLE_CC__) + // "All BSD system functions expect their string parameters to be in UTF-8 encoding + // and nothing else." http://developer.apple.com/mac/library/documentation/MacOSX/Conceptual/BPInternational/Articles/FileEncodings.html + // + // "The kernel will reject any filename that is not a valid UTF-8 string, and it will + // even be normalized (to Unicode NFD) before stored on disk, at least when using HFS. + // The right way to deal with it would be to always convert the filename to UTF-8 + // before trying to open/create a file." http://lists.apple.com/archives/unix-porting/2007/Sep/msg00023.html + // + // "How a file name looks at the API level depends on the API. Current Carbon APIs + // handle file names as an array of UTF-16 characters; POSIX ones handle them as an + // array of UTF-8, which is why UTF-8 works well in Terminal. How it's stored on disk + // depends on the disk format; HFS+ uses UTF-16, but that's not important in most + // cases." http://lists.apple.com/archives/applescript-users/2002/Sep/msg00319.html + // + // Many thanks to Peter Dimov for digging out the above references! + std::locale global_loc = std::locale(); + std::locale loc(global_loc, new boost::filesystem::detail::utf8_codecvt_facet); + return loc; + +# else + // ISO C calls this "the locale-specific native environment": + return std::locale(""); + +# endif + } + + std::locale & path_locale() + { + static std::locale loc(default_locale()); + return loc; + } + +} // unnamed namespace + +//--------------------------------------------------------------------------------------// +// path::imbue implementation // +//--------------------------------------------------------------------------------------// + +namespace boost +{ +namespace filesystem +{ + + const path::codecvt_type *& + path::wchar_t_codecvt_facet() + { + static const std::codecvt * + facet( + &std::use_facet > + (path_locale())); + return facet; + } + + std::locale path::imbue(const std::locale & loc) + { + std::locale temp(path_locale()); + path_locale() = loc; + wchar_t_codecvt_facet() = &std::use_facet + >(path_locale()); + return temp; + } + +} // namespace filesystem +} // namespace boost diff --git a/v3/libs/filesystem/src/path_traits.cpp b/v3/libs/filesystem/src/path_traits.cpp new file mode 100644 index 0000000..90d2b35 --- /dev/null +++ b/v3/libs/filesystem/src/path_traits.cpp @@ -0,0 +1,194 @@ +// filesystem path_traits.cpp --------------------------------------------------------// + +// Copyright Beman Dawes 2008, 2009 + +// Distributed under the Boost Software License, Version 1.0. +// See http://www.boost.org/LICENSE_1_0.txt + +// Library home page: http://www.boost.org/libs/filesystem + +// define BOOST_FILESYSTEM_SOURCE so that knows +// the library is being built (possibly exporting rather than importing code) +#define BOOST_FILESYSTEM_SOURCE + +#include +#include +#include +#include +#include // for codecvt_base::result +#include // for strlen +#include // for wcslen + +namespace pt = boost::filesystem::path_traits; +namespace fs = boost::filesystem; +namespace bs = boost::system; + +//--------------------------------------------------------------------------------------// +// configuration // +//--------------------------------------------------------------------------------------// + +#ifndef BOOST_FILESYSTEM_CODECVT_BUF_SIZE +# define BOOST_FILESYSTEM_CODECVT_BUF_SIZE 256 +#endif + +namespace { + + const std::size_t default_codecvt_buf_size = BOOST_FILESYSTEM_CODECVT_BUF_SIZE; + + +//--------------------------------------------------------------------------------------// +// // +// The public convert() functions do buffer management, and then forward to the // +// convert_aux() functions for the actual call to the codecvt facet. // +// // +//--------------------------------------------------------------------------------------// + +//--------------------------------------------------------------------------------------// +// convert_aux const char* to wstring // +//--------------------------------------------------------------------------------------// + + void convert_aux( + const char* from, + const char* from_end, + wchar_t* to, wchar_t* to_end, + std::wstring & target, + const pt::codecvt_type & cvt) + { + //std::cout << std::hex + // << " from=" << std::size_t(from) + // << " from_end=" << std::size_t(from_end) + // << " to=" << std::size_t(to) + // << " to_end=" << std::size_t(to_end) + // << std::endl; + + std::mbstate_t state = std::mbstate_t(); // perhaps unneeded, but cuts bug reports + const char* from_next; + wchar_t* to_next; + + std::codecvt_base::result res; + + if ((res=cvt.in(state, from, from_end, from_next, + to, to_end, to_next)) != std::codecvt_base::ok) + { + //std::cout << " result is " << static_cast(res) << std::endl; + BOOST_FILESYSTEM_THROW(bs::system_error(res, fs::codecvt_error_category(), + "boost::filesystem::path codecvt to wstring")); + } + target.append(to, to_next); + } + +//--------------------------------------------------------------------------------------// +// convert_aux const wchar_t* to string // +//--------------------------------------------------------------------------------------// + + void convert_aux( + const wchar_t* from, + const wchar_t* from_end, + char* to, char* to_end, + std::string & target, + const pt::codecvt_type & cvt) + { + //std::cout << std::hex + // << " from=" << std::size_t(from) + // << " from_end=" << std::size_t(from_end) + // << " to=" << std::size_t(to) + // << " to_end=" << std::size_t(to_end) + // << std::endl; + + std::mbstate_t state = std::mbstate_t(); // perhaps unneeded, but cuts bug reports + const wchar_t* from_next; + char* to_next; + + std::codecvt_base::result res; + + if ((res=cvt.out(state, from, from_end, from_next, + to, to_end, to_next)) != std::codecvt_base::ok) + { + //std::cout << " result is " << static_cast(res) << std::endl; + BOOST_FILESYSTEM_THROW(bs::system_error(res, fs::codecvt_error_category(), + "boost::filesystem::path codecvt to string")); + } + target.append(to, to_next); + } + +} // unnamed namespace + +//--------------------------------------------------------------------------------------// +// path_traits // +//--------------------------------------------------------------------------------------// + +namespace boost { namespace filesystem { namespace path_traits { + +//--------------------------------------------------------------------------------------// +// convert const char* to wstring // +//--------------------------------------------------------------------------------------// + + BOOST_FILESYSTEM_DECL + void convert(const char* from, + const char* from_end, // 0 for null terminated MBCS + std::wstring & to, + const codecvt_type & cvt) + { + BOOST_ASSERT(from); + + if (!from_end) // null terminated + { + from_end = from + std::strlen(from); + } + + if (from == from_end) return; + + std::size_t buf_size = (from_end - from) * 3; // perhaps too large, but that's OK + + // dynamically allocate a buffer only if source is unusually large + if (buf_size > default_codecvt_buf_size) + { + boost::scoped_array< wchar_t > buf(new wchar_t [buf_size]); + convert_aux(from, from_end, buf.get(), buf.get()+buf_size, to, cvt); + } + else + { + wchar_t buf[default_codecvt_buf_size]; + convert_aux(from, from_end, buf, buf+default_codecvt_buf_size, to, cvt); + } + } + +//--------------------------------------------------------------------------------------// +// convert const wchar_t* to string // +//--------------------------------------------------------------------------------------// + + BOOST_FILESYSTEM_DECL + void convert(const wchar_t* from, + const wchar_t* from_end, // 0 for null terminated MBCS + std::string & to, + const codecvt_type & cvt) + { + BOOST_ASSERT(from); + + if (!from_end) // null terminated + { + from_end = from + std::wcslen(from); + } + + if (from == from_end) return; + + // The codecvt length functions may not be implemented, and I don't really + // understand them either. Thus this code is just a guess; if it turns + // out the buffer is too small then an error will be reported and the code + // will have to be fixed. + std::size_t buf_size = (from_end - from) * 4; // perhaps too large, but that's OK + buf_size += 4; // encodings like shift-JIS need some prefix space + + // dynamically allocate a buffer only if source is unusually large + if (buf_size > default_codecvt_buf_size) + { + boost::scoped_array< char > buf(new char [buf_size]); + convert_aux(from, from_end, buf.get(), buf.get()+buf_size, to, cvt); + } + else + { + char buf[default_codecvt_buf_size]; + convert_aux(from, from_end, buf, buf+default_codecvt_buf_size, to, cvt); + } + } +}}} // namespace boost::filesystem::path_traits diff --git a/v3/libs/filesystem/src/portability.cpp b/v3/libs/filesystem/src/portability.cpp new file mode 100644 index 0000000..bd62b12 --- /dev/null +++ b/v3/libs/filesystem/src/portability.cpp @@ -0,0 +1,115 @@ +// portability.cpp -------------------------------------------------------------------// + +// Copyright 2002-2005 Beman Dawes +// Use, modification, and distribution is subject to the Boost Software +// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy +// at http://www.boost.org/LICENSE_1_0.txt) + +// See library home page at http://www.boost.org/libs/filesystem + +//--------------------------------------------------------------------------------------// + +// define BOOST_FILESYSTEM_SOURCE so that knows +// the library is being built (possibly exporting rather than importing code) +#define BOOST_FILESYSTEM_SOURCE + +#include +#include + +namespace fs = boost::filesystem; + +#include // SGI MIPSpro compilers need this + +# ifdef BOOST_NO_STDC_NAMESPACE + namespace std { using ::strerror; } +# endif + +//--------------------------------------------------------------------------------------// + +namespace +{ + const char invalid_chars[] = + "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F" + "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F" + "<>:\"/\\|"; + // note that the terminating '\0' is part of the string - thus the size below + // is sizeof(invalid_chars) rather than sizeof(invalid_chars)-1. I + const std::string windows_invalid_chars(invalid_chars, sizeof(invalid_chars)); + + const std::string valid_posix( + "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789._-"); + +} // unnamed namespace + +namespace boost +{ + namespace filesystem + { + + // name_check functions ----------------------------------------------// + +# ifdef BOOST_WINDOWS + BOOST_FILESYSTEM_DECL bool native(const std::string & name) + { + return windows_name(name); + } +# else + BOOST_FILESYSTEM_DECL bool native(const std::string & name) + { + return name.size() != 0 + && name[0] != ' ' + && name.find('/') == std::string::npos; + } +# endif + + BOOST_FILESYSTEM_DECL bool portable_posix_name(const std::string & name) + { + return name.size() != 0 + && name.find_first_not_of(valid_posix) == std::string::npos; + } + + BOOST_FILESYSTEM_DECL bool windows_name(const std::string & name) + { + return name.size() != 0 + && name[0] != ' ' + && name.find_first_of(windows_invalid_chars) == std::string::npos + && *(name.end()-1) != ' ' + && (*(name.end()-1) != '.' + || name.length() == 1 || name == ".."); + } + + BOOST_FILESYSTEM_DECL bool portable_name(const std::string & name) + { + return + name.size() != 0 + && (name == "." + || name == ".." + || (windows_name(name) + && portable_posix_name(name) + && name[0] != '.' && name[0] != '-')); + } + + BOOST_FILESYSTEM_DECL bool portable_directory_name(const std::string & name) + { + return + name == "." + || name == ".." + || (portable_name(name) + && name.find('.') == std::string::npos); + } + + BOOST_FILESYSTEM_DECL bool portable_file_name(const std::string & name) + { + std::string::size_type pos; + return + portable_name(name) + && name != "." + && name != ".." + && ((pos = name.find('.')) == std::string::npos + || (name.find('.', pos+1) == std::string::npos + && (pos + 5) > name.length())) + ; + } + + } // namespace filesystem +} // namespace boost diff --git a/v3/libs/filesystem/src/unique_path.cpp b/v3/libs/filesystem/src/unique_path.cpp new file mode 100644 index 0000000..8dad8a4 --- /dev/null +++ b/v3/libs/filesystem/src/unique_path.cpp @@ -0,0 +1,138 @@ +// filesystem system_crypt_random.cpp ------------------------------------------------// + +// Copyright Beman Dawes 2010 + +// Distributed under the Boost Software License, Version 1.0. +// See http://www.boost.org/LICENSE_1_0.txt + +// Library home page: http://www.boost.org/libs/filesystem + +//--------------------------------------------------------------------------------------// + +// define BOOST_FILESYSTEM_SOURCE so that knows +// the library is being built (possibly exporting rather than importing code) +#define BOOST_FILESYSTEM_SOURCE + +#include + +# ifdef BOOST_POSIX_API +# include +# else // BOOST_WINDOWS_API +# include +# include +# pragma comment(lib, "Advapi32.lib") +# endif + +namespace { + +void fail(int err, boost::system::error_code* ec) +{ + if (ec == 0) + BOOST_FILESYSTEM_THROW( boost::system::system_error(err, + boost::system::system_category(), + "boost::filesystem::unique_path")); + + ec->assign(err, boost::system::system_category()); + return; +} + +void system_crypt_random(void* buf, std::size_t len, boost::system::error_code* ec) +{ +# ifdef BOOST_POSIX_API + + int file = open("/dev/urandom", O_RDONLY); + if (file == -1) + { + file = open("/dev/random", O_RDONLY); + if (file == -1) + { + fail(errno, ec); + return; + } + } + + size_t bytes_read = 0; + while (bytes_read < len) + { + ssize_t n = read(file, buf, len - bytes_read); + if (n == -1) + { + close(file); + fail(errno, ec); + return; + } + bytes_read += n; + buf = static_cast(buf) + n; + } + + close(file); + +# else // BOOST_WINDOWS_API + + HCRYPTPROV handle; + int errval = 0; + + if (!::CryptAcquireContextW(&handle, 0, 0, PROV_RSA_FULL, 0)) + { + errval = ::GetLastError(); + if (errval == NTE_BAD_KEYSET) + { + if (!::CryptAcquireContextW(&handle, 0, 0, PROV_RSA_FULL, CRYPT_NEWKEYSET)) + { + errval = ::GetLastError(); + } + else errval = 0; + } + } + + if (!errval) + { + BOOL gen_ok = ::CryptGenRandom(handle, len, static_cast(buf)); + if (!gen_ok) + errval = ::GetLastError(); + ::CryptReleaseContext(handle, 0); + } + + if (!errval) return; + + fail(errval, ec); +# endif +} + +} // unnamed namespace + +namespace boost { namespace filesystem { namespace detail { + +BOOST_FILESYSTEM_DECL +path unique_path(const path& model, system::error_code* ec) +{ + std::wstring s (model.wstring()); // std::string ng for MBCS encoded POSIX + const wchar_t hex[] = L"0123456789abcdef"; + const int n_ran = 16; + const int max_nibbles = 2 * n_ran; // 4-bits per nibble + char ran[n_ran]; + + int nibbles_used = max_nibbles; + for(std::wstring::size_type i=0; i < s.size(); ++i) + { + if (s[i] == L'%') // digit request + { + if (nibbles_used == max_nibbles) + { + system_crypt_random(ran, sizeof(ran), ec); + if (ec != 0 && *ec) + return ""; + nibbles_used = 0; + } + int c = ran[nibbles_used/2]; + c >>= 4 * (nibbles_used++ & 1); // if odd, shift right 1 nibble + s[i] = hex[c & 0xf]; // convert to hex digit and replace + } + } + + if (ec != 0) ec->clear(); + + return s; +} + +}}} diff --git a/v3/libs/filesystem/src/utf8_codecvt_facet.cpp b/v3/libs/filesystem/src/utf8_codecvt_facet.cpp new file mode 100644 index 0000000..3fe3e95 --- /dev/null +++ b/v3/libs/filesystem/src/utf8_codecvt_facet.cpp @@ -0,0 +1,20 @@ +// Copyright Vladimir Prus 2004. +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt +// or copy at http://www.boost.org/LICENSE_1_0.txt) + +#define BOOST_FILESYSTEM_SOURCE +#include + +#define BOOST_UTF8_BEGIN_NAMESPACE \ + namespace boost { namespace filesystem { namespace detail { + +#define BOOST_UTF8_END_NAMESPACE }}} +#define BOOST_UTF8_DECL BOOST_FILESYSTEM_DECL + +#include "libs/detail/utf8_codecvt_facet.cpp" + + +#undef BOOST_UTF8_BEGIN_NAMESPACE +#undef BOOST_UTF8_END_NAMESPACE +#undef BOOST_UTF8_DECL diff --git a/v3/libs/filesystem/src/utf8_codecvt_facet.hpp b/v3/libs/filesystem/src/utf8_codecvt_facet.hpp new file mode 100644 index 0000000..3b78fb1 --- /dev/null +++ b/v3/libs/filesystem/src/utf8_codecvt_facet.hpp @@ -0,0 +1,24 @@ +// Copyright (c) 2001 Ronald Garcia, Indiana University (garcia@osl.iu.edu) +// Andrew Lumsdaine, Indiana University (lums@osl.iu.edu). + +// Distributed under the Boost Software License, Version 1.0. +// (See http://www.boost.org/LICENSE_1_0.txt) + +#ifndef BOOST_FILESYSTEM_UTF8_CODECVT_FACET_HPP +#define BOOST_FILESYSTEM_UTF8_CODECVT_FACET_HPP + +#include + +#define BOOST_UTF8_BEGIN_NAMESPACE \ + namespace boost { namespace filesystem { namespace detail { + +#define BOOST_UTF8_END_NAMESPACE }}} +#define BOOST_UTF8_DECL BOOST_FILESYSTEM_DECL + +#include + +#undef BOOST_UTF8_BEGIN_NAMESPACE +#undef BOOST_UTF8_END_NAMESPACE +#undef BOOST_UTF8_DECL + +#endif diff --git a/v3/libs/filesystem/src/windows_file_codecvt.cpp b/v3/libs/filesystem/src/windows_file_codecvt.cpp new file mode 100644 index 0000000..6f54cb4 --- /dev/null +++ b/v3/libs/filesystem/src/windows_file_codecvt.cpp @@ -0,0 +1,63 @@ +// filesystem windows_file_codecvt.cpp -----------------------------------------// + +// Copyright Beman Dawes 2009 + +// Distributed under the Boost Software License, Version 1.0. +// See http://www.boost.org/LICENSE_1_0.txt + +// Library home page: http://www.boost.org/libs/filesystem + +// define BOOST_FILESYSTEM_SOURCE so that knows +// the library is being built (possibly exporting rather than importing code) +#define BOOST_FILESYSTEM_SOURCE + +#include + +#ifdef BOOST_WINDOWS_API + +#include "windows_file_codecvt.hpp" + +#define WINVER 0x0500 // MinGW for GCC 4.4 requires this +#include + + std::codecvt_base::result windows_file_codecvt::do_in( + std::mbstate_t &, + const char* from, const char* from_end, const char*& from_next, + wchar_t* to, wchar_t* to_end, wchar_t*& to_next) const + { + UINT codepage = AreFileApisANSI() ? CP_THREAD_ACP : CP_OEMCP; + + int count; + if ((count = ::MultiByteToWideChar(codepage, MB_PRECOMPOSED, from, + from_end - from, to, to_end - to)) == 0) + { + return error; // conversion failed + } + + from_next = from_end; + to_next = to + count; + *to_next = L'\0'; + return ok; + } + + std::codecvt_base::result windows_file_codecvt::do_out( + std::mbstate_t &, + const wchar_t* from, const wchar_t* from_end, const wchar_t* & from_next, + char* to, char* to_end, char* & to_next) const + { + UINT codepage = AreFileApisANSI() ? CP_THREAD_ACP : CP_OEMCP; + + int count; + if ((count = ::WideCharToMultiByte(codepage, WC_NO_BEST_FIT_CHARS, from, + from_end - from, to, to_end - to, 0, 0)) == 0) + { + return error; // conversion failed + } + + from_next = from_end; + to_next = to + count; + *to_next = '\0'; + return ok; + } + + # endif // BOOST_WINDOWS_API diff --git a/v3/libs/filesystem/src/windows_file_codecvt.hpp b/v3/libs/filesystem/src/windows_file_codecvt.hpp new file mode 100644 index 0000000..4bfc212 --- /dev/null +++ b/v3/libs/filesystem/src/windows_file_codecvt.hpp @@ -0,0 +1,55 @@ +// filesystem windows_file_codecvt.hpp -----------------------------------------------// + +// Copyright Beman Dawes 2009 + +// Distributed under the Boost Software License, Version 1.0. +// See http://www.boost.org/LICENSE_1_0.txt + +// Library home page: http://www.boost.org/libs/filesystem + +#ifndef BOOST_FILESYSTEM_WIN_FILE_CODECVT_HPP +#define BOOST_FILESYSTEM_WIN_FILE_CODECVT_HPP + +#include + + //------------------------------------------------------------------------------------// + // // + // class windows_file_codecvt // + // // + // Warning: partial implementation; even do_in and do_out only partially meet the // + // standard library specifications as the "to" buffer must hold the entire result. // + // // + //------------------------------------------------------------------------------------// + + class BOOST_FILESYSTEM_DECL windows_file_codecvt + : public std::codecvt< wchar_t, char, std::mbstate_t > + { + public: + explicit windows_file_codecvt() + : std::codecvt() {} + protected: + + virtual bool do_always_noconv() const throw() { return false; } + + // seems safest to assume variable number of characters since we don't + // actually know what codepage is active + virtual int do_encoding() const throw() { return 0; } + + virtual std::codecvt_base::result do_in(std::mbstate_t& state, + const char* from, const char* from_end, const char*& from_next, + wchar_t* to, wchar_t* to_end, wchar_t*& to_next) const; + + virtual std::codecvt_base::result do_out(std::mbstate_t & state, + const wchar_t* from, const wchar_t* from_end, const wchar_t*& from_next, + char* to, char* to_end, char*& to_next) const; + + virtual std::codecvt_base::result do_unshift(std::mbstate_t&, + char* /*from*/, char* /*to*/, char* & /*next*/) const { return ok; } + + virtual int do_length(std::mbstate_t&, + const char* /*from*/, const char* /*from_end*/, std::size_t /*max*/) const { return 0; } + + virtual int do_max_length() const throw () { return 0; } + }; + +#endif // BOOST_FILESYSTEM_WIN_FILE_CODECVT_HPP diff --git a/v3/libs/filesystem/test/Jamfile.v2 b/v3/libs/filesystem/test/Jamfile.v2 new file mode 100644 index 0000000..844d3ac --- /dev/null +++ b/v3/libs/filesystem/test/Jamfile.v2 @@ -0,0 +1,34 @@ +# Boost Filesystem Library test Jamfile + +# (C) Copyright Beman Dawes 2002-2006 +# Distributed under the Boost Software License, Version 1.0. +# (See accompanying file LICENSE_1_0.txt or www.boost.org/LICENSE_1_0.txt) + +project + : requirements + /boost/filesystem//boost_filesystem + /boost/system//boost_system + msvc:on + ; + +# Some tests are run both statically and as shared libraries since it is helpful +# to know if failures in shared library tests are related to sharing or not. + + test-suite "filesystem" : + [ run path_unit_test.cpp : : : shared ] + [ run path_unit_test.cpp : : : static : path_unit_test_static ] + [ run path_test.cpp : : : shared ] + [ run path_test.cpp : : : static : path_test_static ] + [ run operations_unit_test.cpp : : : shared ] + [ run operations_unit_test.cpp : : : static : operations_unit_test_static ] + [ run operations_test.cpp : : : shared ] + [ run operations_test.cpp : : : static : operations_test_static ] + [ run fstream_test.cpp ] + [ run convenience_test.cpp ] + [ run large_file_support_test.cpp ] + [ run deprecated_test.cpp ] + [ run ../example/simple_ls.cpp ] + +# [ compile ../example/mbcopy.cpp ] +# [ compile ../example/mbpath.cpp ] + ; diff --git a/v3/libs/filesystem/test/convenience_test.cpp b/v3/libs/filesystem/test/convenience_test.cpp new file mode 100644 index 0000000..730d714 --- /dev/null +++ b/v3/libs/filesystem/test/convenience_test.cpp @@ -0,0 +1,159 @@ +// libs/filesystem/test/convenience_test.cpp -----------------------------------------// + +// Copyright Beman Dawes, 2002 +// Copyright Vladimir Prus, 2002 +// Use, modification, and distribution is subject to the Boost Software +// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// See library home page at http://www.boost.org/libs/filesystem + +#include + +// See deprecated_test for tests of deprecated features +#define BOOST_FILESYSTEM_NO_DEPRECATED + +#include +namespace fs = boost::filesystem; +using fs::path; +namespace sys = boost::system; + +#include +#include +#include +#include + +namespace +{ + template< typename F > + bool throws_fs_error(F func) + { + try { func(); } + + catch (const fs::filesystem_error &) + { + return true; + } + return false; + } + + void create_recursive_iterator(const fs::path & ph) + { + fs::recursive_directory_iterator it(ph); + } +} + +// ------------------------------------------------------------------------------------// + +int main(int, char*[]) +{ + +// create_directories() tests --------------------------------------------------------// + + BOOST_TEST(!fs::create_directories("")); // should be harmless + BOOST_TEST(!fs::create_directories("/")); // ditto + + fs::remove_all("xx"); // make sure slate is blank + BOOST_TEST(!fs::exists("xx")); // reality check + + BOOST_TEST(fs::create_directories("xx")); + BOOST_TEST(fs::exists("xx")); + BOOST_TEST(fs::is_directory("xx")); + + BOOST_TEST(fs::create_directories("xx/yy/zz")); + BOOST_TEST(fs::exists("xx")); + BOOST_TEST(fs::exists("xx/yy")); + BOOST_TEST(fs::exists("xx/yy/zz")); + BOOST_TEST(fs::is_directory("xx")); + BOOST_TEST(fs::is_directory("xx/yy")); + BOOST_TEST(fs::is_directory("xx/yy/zz")); + + path is_a_file("xx/uu"); + { + std::ofstream f(is_a_file.string().c_str()); + BOOST_TEST(!!f); + } + BOOST_TEST(throws_fs_error( + boost::bind(fs::create_directories, is_a_file))); + BOOST_TEST(throws_fs_error( + boost::bind(fs::create_directories, is_a_file / "aa"))); + +// recursive_directory_iterator tests ----------------------------------------// + + sys::error_code ec; + fs::recursive_directory_iterator it("/no-such-path", ec); + BOOST_TEST(ec); + + BOOST_TEST(throws_fs_error( + boost::bind(create_recursive_iterator, "/no-such-path"))); + + fs::remove("xx/uu"); + +#ifdef BOOST_WINDOWS_API + // These tests depends on ordering of directory entries, and that's guaranteed + // on Windows but not necessarily on other operating systems + { + std::ofstream f("xx/yya"); + BOOST_TEST(!!f); + } + + for (it = fs::recursive_directory_iterator("xx"); + it != fs::recursive_directory_iterator(); ++it) + { std::cout << it->path() << '\n'; } + + it = fs::recursive_directory_iterator("xx"); + BOOST_TEST(it->path() == "xx/yy"); + BOOST_TEST(it.level() == 0); + ++it; + BOOST_TEST(it->path() == "xx/yy/zz"); + BOOST_TEST(it.level() == 1); + it.pop(); + BOOST_TEST(it->path() == "xx/yya"); + BOOST_TEST(it.level() == 0); + it++; + BOOST_TEST(it == fs::recursive_directory_iterator()); + + it = fs::recursive_directory_iterator("xx"); + BOOST_TEST(it->path() == "xx/yy"); + it.no_push(); + ++it; + BOOST_TEST(it->path() == "xx/yya"); + ++it; + BOOST_TEST(it == fs::recursive_directory_iterator()); + + fs::remove("xx/yya"); +#endif + + it = fs::recursive_directory_iterator("xx/yy/zz"); + BOOST_TEST(it == fs::recursive_directory_iterator()); + + it = fs::recursive_directory_iterator("xx"); + BOOST_TEST(it->path() == "xx/yy"); + BOOST_TEST(it.level() == 0); + ++it; + BOOST_TEST(it->path() == "xx/yy/zz"); + BOOST_TEST(it.level() == 1); + it++; + BOOST_TEST(it == fs::recursive_directory_iterator()); + + it = fs::recursive_directory_iterator("xx"); + BOOST_TEST(it->path() == "xx/yy"); + it.no_push(); + ++it; + BOOST_TEST(it == fs::recursive_directory_iterator()); + + it = fs::recursive_directory_iterator("xx"); + BOOST_TEST(it->path() == "xx/yy"); + ++it; + it.pop(); + BOOST_TEST(it == fs::recursive_directory_iterator()); + + ec.clear(); + BOOST_TEST(!ec); + // check that two argument failed constructor creates the end iterator + BOOST_TEST(fs::recursive_directory_iterator("nosuchdir", ec) + == fs::recursive_directory_iterator()); + BOOST_TEST(ec); + + return ::boost::report_errors(); +} diff --git a/v3/libs/filesystem/test/deprecated_test.cpp b/v3/libs/filesystem/test/deprecated_test.cpp new file mode 100644 index 0000000..07c225d --- /dev/null +++ b/v3/libs/filesystem/test/deprecated_test.cpp @@ -0,0 +1,240 @@ +// deprecated_test program --------------------------------------------------// + +// Copyright Beman Dawes 2002 +// Copyright Vladimir Prus 2002 + +// Distributed under the Boost Software License, Version 1.0. +// See http://www.boost.org/LICENSE_1_0.txt + +// Library home page: http://www.boost.org/libs/filesystem + +// This test verifies that various deprecated names still work. This is +// important to preserve existing code that uses the old names. + +#define BOOST_FILESYSTEM_DEPRECATED + +#include +#include + +namespace fs = boost::filesystem; +using boost::filesystem::path; + +#define PATH_CHECK(a, b) check(a, b, __LINE__) + +namespace +{ + std::string platform(BOOST_PLATFORM); + + void check(const fs::path & source, + const std::string & expected, int line) + { + if (source.generic_string()== expected) return; + + ++::boost::detail::test_errors(); + + std::cout << '(' << line << ") source.string(): \"" << source.string() + << "\" != expected: \"" << expected + << "\"" << std::endl; + } + + void normalize_test() + { + PATH_CHECK(path("").normalize(), ""); + PATH_CHECK(path("/").normalize(), "/"); + PATH_CHECK(path("//").normalize(), "//"); + PATH_CHECK(path("///").normalize(), "/"); + PATH_CHECK(path("f").normalize(), "f"); + PATH_CHECK(path("foo").normalize(), "foo"); + PATH_CHECK(path("foo/").normalize(), "foo/."); + PATH_CHECK(path("f/").normalize(), "f/."); + PATH_CHECK(path("/foo").normalize(), "/foo"); + PATH_CHECK(path("foo/bar").normalize(), "foo/bar"); + PATH_CHECK(path("..").normalize(), ".."); + PATH_CHECK(path("../..").normalize(), "../.."); + PATH_CHECK(path("/..").normalize(), "/.."); + PATH_CHECK(path("/../..").normalize(), "/../.."); + PATH_CHECK(path("../foo").normalize(), "../foo"); + PATH_CHECK(path("foo/..").normalize(), "."); + PATH_CHECK(path("foo/../").normalize(), "./."); + PATH_CHECK((path("foo") / "..").normalize() , "."); + PATH_CHECK(path("foo/...").normalize(), "foo/..."); + PATH_CHECK(path("foo/.../").normalize(), "foo/.../."); + PATH_CHECK(path("foo/..bar").normalize(), "foo/..bar"); + PATH_CHECK(path("../f").normalize(), "../f"); + PATH_CHECK(path("/../f").normalize(), "/../f"); + PATH_CHECK(path("f/..").normalize(), "."); + PATH_CHECK((path("f") / "..").normalize() , "."); + PATH_CHECK(path("foo/../..").normalize(), ".."); + PATH_CHECK(path("foo/../../").normalize(), "../."); + PATH_CHECK(path("foo/../../..").normalize(), "../.."); + PATH_CHECK(path("foo/../../../").normalize(), "../../."); + PATH_CHECK(path("foo/../bar").normalize(), "bar"); + PATH_CHECK(path("foo/../bar/").normalize(), "bar/."); + PATH_CHECK(path("foo/bar/..").normalize(), "foo"); + PATH_CHECK(path("foo/bar/../").normalize(), "foo/."); + PATH_CHECK(path("foo/bar/../..").normalize(), "."); + PATH_CHECK(path("foo/bar/../../").normalize(), "./."); + PATH_CHECK(path("foo/bar/../blah").normalize(), "foo/blah"); + PATH_CHECK(path("f/../b").normalize(), "b"); + PATH_CHECK(path("f/b/..").normalize(), "f"); + PATH_CHECK(path("f/b/../").normalize(), "f/."); + PATH_CHECK(path("f/b/../a").normalize(), "f/a"); + PATH_CHECK(path("foo/bar/blah/../..").normalize(), "foo"); + PATH_CHECK(path("foo/bar/blah/../../bletch").normalize(), "foo/bletch"); + PATH_CHECK(path("//net").normalize(), "//net"); + PATH_CHECK(path("//net/").normalize(), "//net/"); + PATH_CHECK(path("//..net").normalize(), "//..net"); + PATH_CHECK(path("//net/..").normalize(), "//net/.."); + PATH_CHECK(path("//net/foo").normalize(), "//net/foo"); + PATH_CHECK(path("//net/foo/").normalize(), "//net/foo/."); + PATH_CHECK(path("//net/foo/..").normalize(), "//net/"); + PATH_CHECK(path("//net/foo/../").normalize(), "//net/."); + + PATH_CHECK(path("/net/foo/bar").normalize(), "/net/foo/bar"); + PATH_CHECK(path("/net/foo/bar/").normalize(), "/net/foo/bar/."); + PATH_CHECK(path("/net/foo/..").normalize(), "/net"); + PATH_CHECK(path("/net/foo/../").normalize(), "/net/."); + + PATH_CHECK(path("//net//foo//bar").normalize(), "//net/foo/bar"); + PATH_CHECK(path("//net//foo//bar//").normalize(), "//net/foo/bar/."); + PATH_CHECK(path("//net//foo//..").normalize(), "//net/"); + PATH_CHECK(path("//net//foo//..//").normalize(), "//net/."); + + PATH_CHECK(path("///net///foo///bar").normalize(), "/net/foo/bar"); + PATH_CHECK(path("///net///foo///bar///").normalize(), "/net/foo/bar/."); + PATH_CHECK(path("///net///foo///..").normalize(), "/net"); + PATH_CHECK(path("///net///foo///..///").normalize(), "/net/."); + + if (platform == "Windows") + { + PATH_CHECK(path("c:..").normalize(), "c:.."); + PATH_CHECK(path("c:foo/..").normalize(), "c:"); + + PATH_CHECK(path("c:foo/../").normalize(), "c:."); + + PATH_CHECK(path("c:/foo/..").normalize(), "c:/"); + PATH_CHECK(path("c:/foo/../").normalize(), "c:/."); + PATH_CHECK(path("c:/..").normalize(), "c:/.."); + PATH_CHECK(path("c:/../").normalize(), "c:/../."); + PATH_CHECK(path("c:/../..").normalize(), "c:/../.."); + PATH_CHECK(path("c:/../../").normalize(), "c:/../../."); + PATH_CHECK(path("c:/../foo").normalize(), "c:/../foo"); + PATH_CHECK(path("c:/../foo/").normalize(), "c:/../foo/."); + PATH_CHECK(path("c:/../../foo").normalize(), "c:/../../foo"); + PATH_CHECK(path("c:/../../foo/").normalize(), "c:/../../foo/."); + PATH_CHECK(path("c:/..foo").normalize(), "c:/..foo"); + } + else // POSIX + { + PATH_CHECK(path("c:..").normalize(), "c:.."); + PATH_CHECK(path("c:foo/..").normalize(), "."); + PATH_CHECK(path("c:foo/../").normalize(), "./."); + PATH_CHECK(path("c:/foo/..").normalize(), "c:"); + PATH_CHECK(path("c:/foo/../").normalize(), "c:/."); + PATH_CHECK(path("c:/..").normalize(), "."); + PATH_CHECK(path("c:/../").normalize(), "./."); + PATH_CHECK(path("c:/../..").normalize(), ".."); + PATH_CHECK(path("c:/../../").normalize(), "../."); + PATH_CHECK(path("c:/../foo").normalize(), "foo"); + PATH_CHECK(path("c:/../foo/").normalize(), "foo/."); + PATH_CHECK(path("c:/../../foo").normalize(), "../foo"); + PATH_CHECK(path("c:/../../foo/").normalize(), "../foo/."); + PATH_CHECK(path("c:/..foo").normalize(), "c:/..foo"); + } + } + + // Compile-only tests not intended to be executed -----------------------------------// + + void compile_only() + { + fs::path p; + + fs::initial_path(); + fs::initial_path(); + + p.file_string(); + p.directory_string(); + } + + // path_rename_test -----------------------------------------------------------------// + + void path_rename_test() + { + fs::path p("foo/bar/blah"); + + BOOST_TEST_EQ(path("foo/bar/blah").remove_leaf(), "foo/bar"); + BOOST_TEST_EQ(p.leaf(), "blah"); + BOOST_TEST_EQ(p.branch_path(), "foo/bar"); + BOOST_TEST(p.has_leaf()); + BOOST_TEST(p.has_branch_path()); + BOOST_TEST(!p.is_complete()); + + if (platform == "Windows") + { + BOOST_TEST_EQ(path("foo\\bar\\blah").remove_leaf(), "foo\\bar"); + p = "foo\\bar\\blah"; + BOOST_TEST_EQ(p.branch_path(), "foo\\bar"); + } + } + +} // unnamed namespace + + +//--------------------------------------------------------------------------------------// + +int main(int /*argc*/, char* /*argv*/[]) +{ + // The choice of platform is make at runtime rather than compile-time + // so that compile errors for all platforms will be detected even though + // only the current platform is runtime tested. + platform = (platform == "Win32" || platform == "Win64" || platform == "Cygwin") + ? "Windows" + : "POSIX"; + std::cout << "Platform is " << platform << '\n'; + + //path::default_name_check(fs::no_check); + + fs::directory_entry de("foo/bar"); + + de.replace_leaf("", fs::file_status(), fs::file_status()); + + //de.leaf(); + //de.string(); + + fs::path ng(" no-way, Jose"); + BOOST_TEST(!fs::is_regular(ng)); // verify deprecated name still works + BOOST_TEST(!fs::symbolic_link_exists("nosuchfileordirectory")); + + path_rename_test(); + normalize_test(); + +// extension() tests ---------------------------------------------------------// + + BOOST_TEST(fs::extension("a/b") == ""); + BOOST_TEST(fs::extension("a/b.txt") == ".txt"); + BOOST_TEST(fs::extension("a/b.") == "."); + BOOST_TEST(fs::extension("a.b.c") == ".c"); + BOOST_TEST(fs::extension("a.b.c.") == "."); + BOOST_TEST(fs::extension("") == ""); + BOOST_TEST(fs::extension("a/") == ""); + +// basename() tests ----------------------------------------------------------// + + BOOST_TEST(fs::basename("b") == "b"); + BOOST_TEST(fs::basename("a/b.txt") == "b"); + BOOST_TEST(fs::basename("a/b.") == "b"); + BOOST_TEST(fs::basename("a.b.c") == "a.b"); + BOOST_TEST(fs::basename("a.b.c.") == "a.b.c"); + BOOST_TEST(fs::basename("") == ""); + +// change_extension tests ---------------------------------------------------// + + BOOST_TEST(fs::change_extension("a.txt", ".tex").string() == "a.tex"); + BOOST_TEST(fs::change_extension("a.", ".tex").string() == "a.tex"); + BOOST_TEST(fs::change_extension("a", ".txt").string() == "a.txt"); + BOOST_TEST(fs::change_extension("a.b.txt", ".tex").string() == "a.b.tex"); + // see the rationale in html docs for explanation why this works + BOOST_TEST(fs::change_extension("", ".png").string() == ".png"); + + return ::boost::report_errors(); +} diff --git a/v3/libs/filesystem/test/design_use_cases.cpp b/v3/libs/filesystem/test/design_use_cases.cpp new file mode 100644 index 0000000..49b0c28 --- /dev/null +++ b/v3/libs/filesystem/test/design_use_cases.cpp @@ -0,0 +1,81 @@ +#include +#include + +// Minimal class path + +class path +{ +public: + path( const char * ) + { + std::cout << "path( const char * )\n"; + } + path( const std::string & ) + { + std::cout << "path( std::string & )\n"; + } + +// for maximum efficiency, either signature must work +# ifdef BY_VALUE + operator const std::string() const +# else + operator const std::string&() const +# endif + { + std::cout << "operator string\n"; + return m_path; + } + +#ifdef NAMED_CONVERSION + std::string string() const + { + std::cout << "std::string string() const\n"; + return m_path; + } +#endif + +private: + std::string m_path; +}; + +bool operator==( const path &, const path & ) +{ + std::cout << "operator==( const path &, const path & )\n"; + return true; +} + +// These are the critical use cases. If any of these don't compile, usability +// is unacceptably degraded. + +void f( const path & ) +{ + std::cout << "f( const path & )\n"; +} + +int main() +{ + f( "foo" ); + f( std::string( "foo" ) ); + f( path( "foo" ) ); + + std::cout << '\n'; + + std::string s1( path( "foo" ) ); + std::string s2 = path( "foo" ); + s2 = path( "foo" ); + +#ifdef NAMED_CONVERSION + s2 = path( "foo" ).string(); +#endif + + std::cout << '\n'; + + // these must call bool path( const path &, const path & ); + path( "foo" ) == path( "foo" ); + path( "foo" ) == "foo"; + path( "foo" ) == std::string( "foo" ); + "foo" == path( "foo" ); + std::string( "foo" ) == path( "foo" ); + + return 0; +} diff --git a/v3/libs/filesystem/test/equivalent.cpp b/v3/libs/filesystem/test/equivalent.cpp new file mode 100644 index 0000000..be3089a --- /dev/null +++ b/v3/libs/filesystem/test/equivalent.cpp @@ -0,0 +1,39 @@ +// equivalent program -------------------------------------------------------// + +// Copyright (c) 2004 Beman Dawes + +// Use, modification, and distribution is subject to the Boost Software +// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy +// at http://www.boost.org/LICENSE_1_0.txt) + +// See library home page at http://www.boost.org/libs/filesystem + +//----------------------------------------------------------------------------// + +#include +#include +#include + +int main( int argc, char * argv[] ) +{ + boost::filesystem::path::default_name_check( boost::filesystem::native ); + if ( argc != 3 ) + { + std::cout << "Usage: equivalent path1 path2\n"; + return 2; + } + + bool eq; + try + { + eq = boost::filesystem::equivalent( argv[1], argv[2] ); + } + catch ( const std::exception & ex ) + { + std::cout << ex.what() << "\n"; + return 3; + } + + std::cout << (eq ? "Paths are equivalent\n" : "Paths are not equivalent\n"); + return !eq; +} diff --git a/v3/libs/filesystem/test/fstream_test.cpp b/v3/libs/filesystem/test/fstream_test.cpp new file mode 100644 index 0000000..59f2726 --- /dev/null +++ b/v3/libs/filesystem/test/fstream_test.cpp @@ -0,0 +1,160 @@ +// fstream_test.cpp ------------------------------------------------------------------// + +// Copyright Beman Dawes 2002 + +// Distributed under the Boost Software License, Version 1.0. +// See http://www.boost.org/LICENSE_1_0.txt + +// Library home page: http://www.boost.org/libs/filesystem + +#include + +// See deprecated_test for tests of deprecated features +#define BOOST_FILESYSTEM_NO_DEPRECATED + +#include +#include +#include +#include +#include // for std::remove + +#include "../src/utf8_codecvt_facet.hpp" + +namespace fs = boost::filesystem; + +#include +#ifdef BOOST_NO_STDC_NAMESPACE + namespace std { using ::remove; } +#endif + +#include + +#if defined(_MSC_VER) +# pragma warning(push) // Save warning settings. +# pragma warning(disable : 4428) // Disable universal-character-name encountered in source warning. +#endif + +namespace +{ + bool cleanup = true; + + void test(const fs::path & p) + { + { + std::cout << " in test 1\n"; + fs::filebuf fb; + fb.open(p, std::ios_base::in); + BOOST_TEST(fb.is_open() == fs::exists(p)); + } + { + std::cout << " in test 2\n"; + fs::filebuf fb1; + fb1.open(p, std::ios_base::out); + BOOST_TEST(fb1.is_open()); + } + { + std::cout << " in test 3\n"; + fs::filebuf fb2; + fb2.open(p, std::ios_base::in); + BOOST_TEST(fb2.is_open()); + } + { + std::cout << " in test 4\n"; + fs::ifstream tfs(p); + BOOST_TEST(tfs.is_open()); + } + { + std::cout << " in test 4.1\n"; + fs::ifstream tfs(p / p.filename()); // should fail + BOOST_TEST(!tfs.is_open()); + } + { + std::cout << " in test 5\n"; + fs::ifstream tfs(p, std::ios_base::in); + BOOST_TEST(tfs.is_open()); + } + { + std::cout << " in test 6\n"; + fs::ifstream tfs; + tfs.open(p); + BOOST_TEST(tfs.is_open()); + } + { + std::cout << " in test 7\n"; + fs::ifstream tfs; + tfs.open(p, std::ios_base::in); + BOOST_TEST(tfs.is_open()); + } + { + std::cout << " in test 8\n"; + fs::ofstream tfs(p); + BOOST_TEST(tfs.is_open()); + } + { + std::cout << " in test 9\n"; + fs::ofstream tfs(p, std::ios_base::out); + BOOST_TEST(tfs.is_open()); + } + { + std::cout << " in test 10\n"; + fs::ofstream tfs; + tfs.open(p); + BOOST_TEST(tfs.is_open()); + } + { + std::cout << " in test 11\n"; + fs::ofstream tfs; + tfs.open(p, std::ios_base::out); + BOOST_TEST(tfs.is_open()); + } + { + std::cout << " in test 12\n"; + fs::fstream tfs(p); + BOOST_TEST(tfs.is_open()); + } + { + std::cout << " in test 13\n"; + fs::fstream tfs(p, std::ios_base::in|std::ios_base::out); + BOOST_TEST(tfs.is_open()); + } + { + std::cout << " in test 14\n"; + fs::fstream tfs; + tfs.open(p); + BOOST_TEST(tfs.is_open()); + } + { + std::cout << " in test 15\n"; + fs::fstream tfs; + tfs.open(p, std::ios_base::in|std::ios_base::out); + BOOST_TEST(tfs.is_open()); + } + + if (cleanup) fs::remove(p); + + } // test +} // unnamed namespace + +int main(int argc, char*[]) +{ + if (argc > 1) cleanup = false; + + // test narrow characters + std::cout << "narrow character tests:\n"; + test("fstream_test_foo"); + + + // So that tests are run with known encoding, use Boost UTF-8 codecvt + std::locale global_loc = std::locale(); + std::locale loc(global_loc, new fs::detail::utf8_codecvt_facet); + fs::path::imbue(loc); + + // test with some wide characters + // \u2780 is circled 1 against white background == e2 9e 80 in UTF-8 + // \u2781 is circled 2 against white background == e2 9e 81 in UTF-8 + // \u263A is a white smiling face + std::cout << "\nwide character tests:\n"; + test(L"fstream_test_\u2780\u263A"); + + return ::boost::report_errors(); +} diff --git a/v3/libs/filesystem/test/large_file_support_test.cpp b/v3/libs/filesystem/test/large_file_support_test.cpp new file mode 100644 index 0000000..45ed12a --- /dev/null +++ b/v3/libs/filesystem/test/large_file_support_test.cpp @@ -0,0 +1,36 @@ +// Boost large_file_support_test.cpp ---------------------------------------// + +// Copyright Beman Dawes 2004. +// Use, modification, and distribution is subject to the Boost Software +// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// See library home page at http://www.boost.org/libs/filesystem + + +// See deprecated_test for tests of deprecated features +#define BOOST_FILESYSTEM_NO_DEPRECATED + +#include +namespace fs = boost::filesystem; + +#include + +int main() +{ + if ( fs::detail::possible_large_file_size_support() ) + { + std::cout << "It appears that file sizes greater that 2 gigabytes are possible\n" + "for this configuration on this platform since the operating system\n" + "does use a large enough integer type to report large file sizes.\n\n" + "Whether or not such support is actually present depends on the OS\n"; + return 0; + } + std::cout << "The operating system is using an integer type to report file sizes\n" + "that can not represent file sizes greater that 2 gigabytes (31-bits).\n" + "Thus the Filesystem Library will not correctly deal with such large\n" + "files. If you think that this operatiing system should be able to\n" + "support large files, please report the problem to the Boost developers\n" + "mailing list.\n"; + return 1; +} diff --git a/v3/libs/filesystem/test/msvc/common.vsprops b/v3/libs/filesystem/test/msvc/common.vsprops new file mode 100644 index 0000000..d50cec7 --- /dev/null +++ b/v3/libs/filesystem/test/msvc/common.vsprops @@ -0,0 +1,21 @@ + + + + + diff --git a/v3/libs/filesystem/test/msvc/convenience_test/convenience_test.vcproj b/v3/libs/filesystem/test/msvc/convenience_test/convenience_test.vcproj new file mode 100644 index 0000000..2c2ad54 --- /dev/null +++ b/v3/libs/filesystem/test/msvc/convenience_test/convenience_test.vcproj @@ -0,0 +1,219 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/v3/libs/filesystem/test/msvc/deprecated_test/deprecated_test.vcproj b/v3/libs/filesystem/test/msvc/deprecated_test/deprecated_test.vcproj new file mode 100644 index 0000000..c0b3ecd --- /dev/null +++ b/v3/libs/filesystem/test/msvc/deprecated_test/deprecated_test.vcproj @@ -0,0 +1,195 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/v3/libs/filesystem/test/msvc/error_demo/error_demo.vcproj b/v3/libs/filesystem/test/msvc/error_demo/error_demo.vcproj new file mode 100644 index 0000000..91e2984 --- /dev/null +++ b/v3/libs/filesystem/test/msvc/error_demo/error_demo.vcproj @@ -0,0 +1,191 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/v3/libs/filesystem/test/msvc/filesystem-v3-sandbox.sln b/v3/libs/filesystem/test/msvc/filesystem-v3-sandbox.sln new file mode 100644 index 0000000..d013ecb --- /dev/null +++ b/v3/libs/filesystem/test/msvc/filesystem-v3-sandbox.sln @@ -0,0 +1,210 @@ + +Microsoft Visual Studio Solution File, Format Version 10.00 +# Visual C++ Express 2008 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "path_unit_test", "path_unit_test\path_unit_test.vcproj", "{3C77F610-2E31-4087-9DF2-7CD45198A02D}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "operations_unit_test", "operations_unit_test\operations_unit_test.vcproj", "{5DAF595A-4640-4F86-8A5F-E54E3E4CE7D0}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "operations_test", "operations_test\operations_test.vcproj", "{8BB7E604-46EF-42BE-ABB5-D7044B3E8A40}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "path_test", "path_test\path_test.vcproj", "{F3D230C4-9185-4C2B-AB0E-0F0D28D8268C}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "system_dll", "system_dll\system_dll.vcproj", "{F94CCADD-A90B-480C-A304-C19D015D36B1}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "filesystem_dll", "filesystem_dll\filesystem_dll.vcproj", "{FFD738F7-96F0-445C-81EA-551665EF53D1}" + ProjectSection(ProjectDependencies) = postProject + {F94CCADD-A90B-480C-A304-C19D015D36B1} = {F94CCADD-A90B-480C-A304-C19D015D36B1} + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "convenience_test", "convenience_test\convenience_test.vcproj", "{08986FB5-0C83-4BC4-92DF-05E12E1C03C1}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "path_test_dynamic_link", "path_test_dynamic_link\path_test_dynamic_linkl.vcproj", "{54347DE3-6AA2-4466-A2EC-7176E0EC1110}" + ProjectSection(ProjectDependencies) = postProject + {F94CCADD-A90B-480C-A304-C19D015D36B1} = {F94CCADD-A90B-480C-A304-C19D015D36B1} + {FFD738F7-96F0-445C-81EA-551665EF53D1} = {FFD738F7-96F0-445C-81EA-551665EF53D1} + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "fstream_test", "fstream_test\fstream_test.vcproj", "{A9939CD7-BE1C-4334-947C-4C320D49B3CA}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "deprecated_test", "deprecated_test\deprecated_test.vcproj", "{D73BC50F-956E-4A44-BF9F-A8BB80DF0000}" + ProjectSection(ProjectDependencies) = postProject + {F94CCADD-A90B-480C-A304-C19D015D36B1} = {F94CCADD-A90B-480C-A304-C19D015D36B1} + {FFD738F7-96F0-445C-81EA-551665EF53D1} = {FFD738F7-96F0-445C-81EA-551665EF53D1} + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "proof_of_concept", "proof_of_concept\proof_of_concept.vcproj", "{440316C4-E19E-41DE-92A6-B78B3900E97F}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "simple_ls", "simple_ls\simple_ls.vcproj", "{6B8EC880-702E-418A-BC63-CA46C6CC7B27}" + ProjectSection(ProjectDependencies) = postProject + {F94CCADD-A90B-480C-A304-C19D015D36B1} = {F94CCADD-A90B-480C-A304-C19D015D36B1} + {FFD738F7-96F0-445C-81EA-551665EF53D1} = {FFD738F7-96F0-445C-81EA-551665EF53D1} + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "complete_func_combos", "complete_func_combos\complete_func_combos.vcproj", "{B0725661-C439-484E-BD67-E367AC78C60A}" + ProjectSection(ProjectDependencies) = postProject + {F94CCADD-A90B-480C-A304-C19D015D36B1} = {F94CCADD-A90B-480C-A304-C19D015D36B1} + {FFD738F7-96F0-445C-81EA-551665EF53D1} = {FFD738F7-96F0-445C-81EA-551665EF53D1} + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "error_demo", "error_demo\error_demo.vcproj", "{709A954B-4F1E-4375-A418-BCBFFE598715}" + ProjectSection(ProjectDependencies) = postProject + {F94CCADD-A90B-480C-A304-C19D015D36B1} = {F94CCADD-A90B-480C-A304-C19D015D36B1} + {FFD738F7-96F0-445C-81EA-551665EF53D1} = {FFD738F7-96F0-445C-81EA-551665EF53D1} + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "tut1", "tut1\tut1.vcproj", "{6376B8E4-7FD4-466B-978E-E8DA6E938689}" + ProjectSection(ProjectDependencies) = postProject + {F94CCADD-A90B-480C-A304-C19D015D36B1} = {F94CCADD-A90B-480C-A304-C19D015D36B1} + {FFD738F7-96F0-445C-81EA-551665EF53D1} = {FFD738F7-96F0-445C-81EA-551665EF53D1} + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "tut3", "tut3\tut3.vcproj", "{4FF64FA7-6806-401D-865C-79DD064D4A9E}" + ProjectSection(ProjectDependencies) = postProject + {F94CCADD-A90B-480C-A304-C19D015D36B1} = {F94CCADD-A90B-480C-A304-C19D015D36B1} + {FFD738F7-96F0-445C-81EA-551665EF53D1} = {FFD738F7-96F0-445C-81EA-551665EF53D1} + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "tut2", "tut2\tut2.vcproj", "{CD69B175-389E-4F8F-85DC-03C56A47CD1D}" + ProjectSection(ProjectDependencies) = postProject + {F94CCADD-A90B-480C-A304-C19D015D36B1} = {F94CCADD-A90B-480C-A304-C19D015D36B1} + {FFD738F7-96F0-445C-81EA-551665EF53D1} = {FFD738F7-96F0-445C-81EA-551665EF53D1} + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "tut4", "tut4\tut4.vcproj", "{256EA89A-E073-4CE8-B675-BE2FBC6B2691}" + ProjectSection(ProjectDependencies) = postProject + {F94CCADD-A90B-480C-A304-C19D015D36B1} = {F94CCADD-A90B-480C-A304-C19D015D36B1} + {FFD738F7-96F0-445C-81EA-551665EF53D1} = {FFD738F7-96F0-445C-81EA-551665EF53D1} + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "path_info", "path_info\path_info.vcproj", "{18EA74B4-B284-4FD4-BC0A-3B2193801B8D}" + ProjectSection(ProjectDependencies) = postProject + {F94CCADD-A90B-480C-A304-C19D015D36B1} = {F94CCADD-A90B-480C-A304-C19D015D36B1} + {FFD738F7-96F0-445C-81EA-551665EF53D1} = {FFD738F7-96F0-445C-81EA-551665EF53D1} + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "space", "space\space.vcproj", "{1AEABC96-F4D5-4B15-B246-3AA34A1827CB}" + ProjectSection(ProjectDependencies) = postProject + {F94CCADD-A90B-480C-A304-C19D015D36B1} = {F94CCADD-A90B-480C-A304-C19D015D36B1} + {FFD738F7-96F0-445C-81EA-551665EF53D1} = {FFD738F7-96F0-445C-81EA-551665EF53D1} + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "tut5", "tut5\tut5.vcproj", "{9D7703A1-F076-4362-BE31-A1C5893D05DF}" + ProjectSection(ProjectDependencies) = postProject + {F94CCADD-A90B-480C-A304-C19D015D36B1} = {F94CCADD-A90B-480C-A304-C19D015D36B1} + {FFD738F7-96F0-445C-81EA-551665EF53D1} = {FFD738F7-96F0-445C-81EA-551665EF53D1} + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "scratch", "scratch\scratch.vcproj", "{D2F172A6-1D20-458D-8C46-83A2FBAC73E4}" + ProjectSection(ProjectDependencies) = postProject + {F94CCADD-A90B-480C-A304-C19D015D36B1} = {F94CCADD-A90B-480C-A304-C19D015D36B1} + {FFD738F7-96F0-445C-81EA-551665EF53D1} = {FFD738F7-96F0-445C-81EA-551665EF53D1} + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "path_table", "path_table\path_table.vcproj", "{0CAE0949-3678-4AC9-A17D-DFCD9F72C4B7}" + ProjectSection(ProjectDependencies) = postProject + {F94CCADD-A90B-480C-A304-C19D015D36B1} = {F94CCADD-A90B-480C-A304-C19D015D36B1} + {FFD738F7-96F0-445C-81EA-551665EF53D1} = {FFD738F7-96F0-445C-81EA-551665EF53D1} + EndProjectSection +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Win32 = Debug|Win32 + Release|Win32 = Release|Win32 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {3C77F610-2E31-4087-9DF2-7CD45198A02D}.Debug|Win32.ActiveCfg = Debug|Win32 + {3C77F610-2E31-4087-9DF2-7CD45198A02D}.Debug|Win32.Build.0 = Debug|Win32 + {3C77F610-2E31-4087-9DF2-7CD45198A02D}.Release|Win32.ActiveCfg = Release|Win32 + {3C77F610-2E31-4087-9DF2-7CD45198A02D}.Release|Win32.Build.0 = Release|Win32 + {5DAF595A-4640-4F86-8A5F-E54E3E4CE7D0}.Debug|Win32.ActiveCfg = Debug|Win32 + {5DAF595A-4640-4F86-8A5F-E54E3E4CE7D0}.Debug|Win32.Build.0 = Debug|Win32 + {5DAF595A-4640-4F86-8A5F-E54E3E4CE7D0}.Release|Win32.ActiveCfg = Release|Win32 + {5DAF595A-4640-4F86-8A5F-E54E3E4CE7D0}.Release|Win32.Build.0 = Release|Win32 + {8BB7E604-46EF-42BE-ABB5-D7044B3E8A40}.Debug|Win32.ActiveCfg = Debug|Win32 + {8BB7E604-46EF-42BE-ABB5-D7044B3E8A40}.Debug|Win32.Build.0 = Debug|Win32 + {8BB7E604-46EF-42BE-ABB5-D7044B3E8A40}.Release|Win32.ActiveCfg = Release|Win32 + {8BB7E604-46EF-42BE-ABB5-D7044B3E8A40}.Release|Win32.Build.0 = Release|Win32 + {F3D230C4-9185-4C2B-AB0E-0F0D28D8268C}.Debug|Win32.ActiveCfg = Debug|Win32 + {F3D230C4-9185-4C2B-AB0E-0F0D28D8268C}.Debug|Win32.Build.0 = Debug|Win32 + {F3D230C4-9185-4C2B-AB0E-0F0D28D8268C}.Release|Win32.ActiveCfg = Release|Win32 + {F3D230C4-9185-4C2B-AB0E-0F0D28D8268C}.Release|Win32.Build.0 = Release|Win32 + {F94CCADD-A90B-480C-A304-C19D015D36B1}.Debug|Win32.ActiveCfg = Debug|Win32 + {F94CCADD-A90B-480C-A304-C19D015D36B1}.Debug|Win32.Build.0 = Debug|Win32 + {F94CCADD-A90B-480C-A304-C19D015D36B1}.Release|Win32.ActiveCfg = Release|Win32 + {F94CCADD-A90B-480C-A304-C19D015D36B1}.Release|Win32.Build.0 = Release|Win32 + {FFD738F7-96F0-445C-81EA-551665EF53D1}.Debug|Win32.ActiveCfg = Debug|Win32 + {FFD738F7-96F0-445C-81EA-551665EF53D1}.Debug|Win32.Build.0 = Debug|Win32 + {FFD738F7-96F0-445C-81EA-551665EF53D1}.Release|Win32.ActiveCfg = Release|Win32 + {FFD738F7-96F0-445C-81EA-551665EF53D1}.Release|Win32.Build.0 = Release|Win32 + {08986FB5-0C83-4BC4-92DF-05E12E1C03C1}.Debug|Win32.ActiveCfg = Debug|Win32 + {08986FB5-0C83-4BC4-92DF-05E12E1C03C1}.Debug|Win32.Build.0 = Debug|Win32 + {08986FB5-0C83-4BC4-92DF-05E12E1C03C1}.Release|Win32.ActiveCfg = Release|Win32 + {08986FB5-0C83-4BC4-92DF-05E12E1C03C1}.Release|Win32.Build.0 = Release|Win32 + {54347DE3-6AA2-4466-A2EC-7176E0EC1110}.Debug|Win32.ActiveCfg = Debug|Win32 + {54347DE3-6AA2-4466-A2EC-7176E0EC1110}.Debug|Win32.Build.0 = Debug|Win32 + {54347DE3-6AA2-4466-A2EC-7176E0EC1110}.Release|Win32.ActiveCfg = Release|Win32 + {54347DE3-6AA2-4466-A2EC-7176E0EC1110}.Release|Win32.Build.0 = Release|Win32 + {A9939CD7-BE1C-4334-947C-4C320D49B3CA}.Debug|Win32.ActiveCfg = Debug|Win32 + {A9939CD7-BE1C-4334-947C-4C320D49B3CA}.Debug|Win32.Build.0 = Debug|Win32 + {A9939CD7-BE1C-4334-947C-4C320D49B3CA}.Release|Win32.ActiveCfg = Release|Win32 + {A9939CD7-BE1C-4334-947C-4C320D49B3CA}.Release|Win32.Build.0 = Release|Win32 + {D73BC50F-956E-4A44-BF9F-A8BB80DF0000}.Debug|Win32.ActiveCfg = Debug|Win32 + {D73BC50F-956E-4A44-BF9F-A8BB80DF0000}.Debug|Win32.Build.0 = Debug|Win32 + {D73BC50F-956E-4A44-BF9F-A8BB80DF0000}.Release|Win32.ActiveCfg = Release|Win32 + {D73BC50F-956E-4A44-BF9F-A8BB80DF0000}.Release|Win32.Build.0 = Release|Win32 + {440316C4-E19E-41DE-92A6-B78B3900E97F}.Debug|Win32.ActiveCfg = Debug|Win32 + {440316C4-E19E-41DE-92A6-B78B3900E97F}.Release|Win32.ActiveCfg = Release|Win32 + {440316C4-E19E-41DE-92A6-B78B3900E97F}.Release|Win32.Build.0 = Release|Win32 + {6B8EC880-702E-418A-BC63-CA46C6CC7B27}.Debug|Win32.ActiveCfg = Debug|Win32 + {6B8EC880-702E-418A-BC63-CA46C6CC7B27}.Debug|Win32.Build.0 = Debug|Win32 + {6B8EC880-702E-418A-BC63-CA46C6CC7B27}.Release|Win32.ActiveCfg = Release|Win32 + {6B8EC880-702E-418A-BC63-CA46C6CC7B27}.Release|Win32.Build.0 = Release|Win32 + {B0725661-C439-484E-BD67-E367AC78C60A}.Debug|Win32.ActiveCfg = Debug|Win32 + {B0725661-C439-484E-BD67-E367AC78C60A}.Debug|Win32.Build.0 = Debug|Win32 + {B0725661-C439-484E-BD67-E367AC78C60A}.Release|Win32.ActiveCfg = Release|Win32 + {B0725661-C439-484E-BD67-E367AC78C60A}.Release|Win32.Build.0 = Release|Win32 + {709A954B-4F1E-4375-A418-BCBFFE598715}.Debug|Win32.ActiveCfg = Debug|Win32 + {709A954B-4F1E-4375-A418-BCBFFE598715}.Debug|Win32.Build.0 = Debug|Win32 + {709A954B-4F1E-4375-A418-BCBFFE598715}.Release|Win32.ActiveCfg = Release|Win32 + {709A954B-4F1E-4375-A418-BCBFFE598715}.Release|Win32.Build.0 = Release|Win32 + {6376B8E4-7FD4-466B-978E-E8DA6E938689}.Debug|Win32.ActiveCfg = Debug|Win32 + {6376B8E4-7FD4-466B-978E-E8DA6E938689}.Debug|Win32.Build.0 = Debug|Win32 + {6376B8E4-7FD4-466B-978E-E8DA6E938689}.Release|Win32.ActiveCfg = Release|Win32 + {6376B8E4-7FD4-466B-978E-E8DA6E938689}.Release|Win32.Build.0 = Release|Win32 + {4FF64FA7-6806-401D-865C-79DD064D4A9E}.Debug|Win32.ActiveCfg = Debug|Win32 + {4FF64FA7-6806-401D-865C-79DD064D4A9E}.Debug|Win32.Build.0 = Debug|Win32 + {4FF64FA7-6806-401D-865C-79DD064D4A9E}.Release|Win32.ActiveCfg = Release|Win32 + {4FF64FA7-6806-401D-865C-79DD064D4A9E}.Release|Win32.Build.0 = Release|Win32 + {CD69B175-389E-4F8F-85DC-03C56A47CD1D}.Debug|Win32.ActiveCfg = Debug|Win32 + {CD69B175-389E-4F8F-85DC-03C56A47CD1D}.Debug|Win32.Build.0 = Debug|Win32 + {CD69B175-389E-4F8F-85DC-03C56A47CD1D}.Release|Win32.ActiveCfg = Release|Win32 + {CD69B175-389E-4F8F-85DC-03C56A47CD1D}.Release|Win32.Build.0 = Release|Win32 + {256EA89A-E073-4CE8-B675-BE2FBC6B2691}.Debug|Win32.ActiveCfg = Debug|Win32 + {256EA89A-E073-4CE8-B675-BE2FBC6B2691}.Debug|Win32.Build.0 = Debug|Win32 + {256EA89A-E073-4CE8-B675-BE2FBC6B2691}.Release|Win32.ActiveCfg = Release|Win32 + {256EA89A-E073-4CE8-B675-BE2FBC6B2691}.Release|Win32.Build.0 = Release|Win32 + {18EA74B4-B284-4FD4-BC0A-3B2193801B8D}.Debug|Win32.ActiveCfg = Debug|Win32 + {18EA74B4-B284-4FD4-BC0A-3B2193801B8D}.Debug|Win32.Build.0 = Debug|Win32 + {18EA74B4-B284-4FD4-BC0A-3B2193801B8D}.Release|Win32.ActiveCfg = Release|Win32 + {18EA74B4-B284-4FD4-BC0A-3B2193801B8D}.Release|Win32.Build.0 = Release|Win32 + {1AEABC96-F4D5-4B15-B246-3AA34A1827CB}.Debug|Win32.ActiveCfg = Debug|Win32 + {1AEABC96-F4D5-4B15-B246-3AA34A1827CB}.Debug|Win32.Build.0 = Debug|Win32 + {1AEABC96-F4D5-4B15-B246-3AA34A1827CB}.Release|Win32.ActiveCfg = Release|Win32 + {1AEABC96-F4D5-4B15-B246-3AA34A1827CB}.Release|Win32.Build.0 = Release|Win32 + {9D7703A1-F076-4362-BE31-A1C5893D05DF}.Debug|Win32.ActiveCfg = Debug|Win32 + {9D7703A1-F076-4362-BE31-A1C5893D05DF}.Debug|Win32.Build.0 = Debug|Win32 + {9D7703A1-F076-4362-BE31-A1C5893D05DF}.Release|Win32.ActiveCfg = Release|Win32 + {9D7703A1-F076-4362-BE31-A1C5893D05DF}.Release|Win32.Build.0 = Release|Win32 + {D2F172A6-1D20-458D-8C46-83A2FBAC73E4}.Debug|Win32.ActiveCfg = Debug|Win32 + {D2F172A6-1D20-458D-8C46-83A2FBAC73E4}.Debug|Win32.Build.0 = Debug|Win32 + {D2F172A6-1D20-458D-8C46-83A2FBAC73E4}.Release|Win32.ActiveCfg = Release|Win32 + {D2F172A6-1D20-458D-8C46-83A2FBAC73E4}.Release|Win32.Build.0 = Release|Win32 + {0CAE0949-3678-4AC9-A17D-DFCD9F72C4B7}.Debug|Win32.ActiveCfg = Debug|Win32 + {0CAE0949-3678-4AC9-A17D-DFCD9F72C4B7}.Debug|Win32.Build.0 = Debug|Win32 + {0CAE0949-3678-4AC9-A17D-DFCD9F72C4B7}.Release|Win32.ActiveCfg = Release|Win32 + {0CAE0949-3678-4AC9-A17D-DFCD9F72C4B7}.Release|Win32.Build.0 = Release|Win32 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/v3/libs/filesystem/test/msvc/filesystem_dll/filesystem_dll.vcproj b/v3/libs/filesystem/test/msvc/filesystem_dll/filesystem_dll.vcproj new file mode 100644 index 0000000..9b278ab --- /dev/null +++ b/v3/libs/filesystem/test/msvc/filesystem_dll/filesystem_dll.vcproj @@ -0,0 +1,225 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/v3/libs/filesystem/test/msvc/fstream_test/fstream_test.vcproj b/v3/libs/filesystem/test/msvc/fstream_test/fstream_test.vcproj new file mode 100644 index 0000000..399b857 --- /dev/null +++ b/v3/libs/filesystem/test/msvc/fstream_test/fstream_test.vcproj @@ -0,0 +1,223 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/v3/libs/filesystem/test/msvc/operations_test/operations_test.vcproj b/v3/libs/filesystem/test/msvc/operations_test/operations_test.vcproj new file mode 100644 index 0000000..0cf8c62 --- /dev/null +++ b/v3/libs/filesystem/test/msvc/operations_test/operations_test.vcproj @@ -0,0 +1,218 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/v3/libs/filesystem/test/msvc/operations_unit_test/operations_unit_test.vcproj b/v3/libs/filesystem/test/msvc/operations_unit_test/operations_unit_test.vcproj new file mode 100644 index 0000000..e4008b4 --- /dev/null +++ b/v3/libs/filesystem/test/msvc/operations_unit_test/operations_unit_test.vcproj @@ -0,0 +1,233 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/v3/libs/filesystem/test/msvc/path_test/path_test.vcproj b/v3/libs/filesystem/test/msvc/path_test/path_test.vcproj new file mode 100644 index 0000000..43d9562 --- /dev/null +++ b/v3/libs/filesystem/test/msvc/path_test/path_test.vcproj @@ -0,0 +1,223 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/v3/libs/filesystem/test/msvc/path_test_dynamic_link/path_test_dynamic_linkl.vcproj b/v3/libs/filesystem/test/msvc/path_test_dynamic_link/path_test_dynamic_linkl.vcproj new file mode 100644 index 0000000..9a754ef --- /dev/null +++ b/v3/libs/filesystem/test/msvc/path_test_dynamic_link/path_test_dynamic_linkl.vcproj @@ -0,0 +1,201 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/v3/libs/filesystem/test/msvc/path_unit_test/path_unit_test.vcproj b/v3/libs/filesystem/test/msvc/path_unit_test/path_unit_test.vcproj new file mode 100644 index 0000000..322a54b --- /dev/null +++ b/v3/libs/filesystem/test/msvc/path_unit_test/path_unit_test.vcproj @@ -0,0 +1,223 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/v3/libs/filesystem/test/msvc/simple_ls/simple_ls.vcproj b/v3/libs/filesystem/test/msvc/simple_ls/simple_ls.vcproj new file mode 100644 index 0000000..9eac29b --- /dev/null +++ b/v3/libs/filesystem/test/msvc/simple_ls/simple_ls.vcproj @@ -0,0 +1,199 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/v3/libs/filesystem/test/msvc/system_dll/system_dll.vcproj b/v3/libs/filesystem/test/msvc/system_dll/system_dll.vcproj new file mode 100644 index 0000000..5375a9b --- /dev/null +++ b/v3/libs/filesystem/test/msvc/system_dll/system_dll.vcproj @@ -0,0 +1,197 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/v3/libs/filesystem/test/msvc/tchar_example/tchar_example.vcproj b/v3/libs/filesystem/test/msvc/tchar_example/tchar_example.vcproj new file mode 100644 index 0000000..80548e2 --- /dev/null +++ b/v3/libs/filesystem/test/msvc/tchar_example/tchar_example.vcproj @@ -0,0 +1,212 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/v3/libs/filesystem/test/msvc/tut0/tut0.vcproj b/v3/libs/filesystem/test/msvc/tut0/tut0.vcproj new file mode 100644 index 0000000..fea6600 --- /dev/null +++ b/v3/libs/filesystem/test/msvc/tut0/tut0.vcproj @@ -0,0 +1,190 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/v3/libs/filesystem/test/msvc/tut1/tut1.vcproj b/v3/libs/filesystem/test/msvc/tut1/tut1.vcproj new file mode 100644 index 0000000..d288e52 --- /dev/null +++ b/v3/libs/filesystem/test/msvc/tut1/tut1.vcproj @@ -0,0 +1,193 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/v3/libs/filesystem/test/msvc/tut2/tut2.vcproj b/v3/libs/filesystem/test/msvc/tut2/tut2.vcproj new file mode 100644 index 0000000..47d157d --- /dev/null +++ b/v3/libs/filesystem/test/msvc/tut2/tut2.vcproj @@ -0,0 +1,189 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/v3/libs/filesystem/test/msvc/tut3/tut3.vcproj b/v3/libs/filesystem/test/msvc/tut3/tut3.vcproj new file mode 100644 index 0000000..37964b0 --- /dev/null +++ b/v3/libs/filesystem/test/msvc/tut3/tut3.vcproj @@ -0,0 +1,187 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/v3/libs/filesystem/test/msvc/tut4/tut4.vcproj b/v3/libs/filesystem/test/msvc/tut4/tut4.vcproj new file mode 100644 index 0000000..307b9b7 --- /dev/null +++ b/v3/libs/filesystem/test/msvc/tut4/tut4.vcproj @@ -0,0 +1,189 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/v3/libs/filesystem/test/msvc/wide_test/wide_test.vcproj b/v3/libs/filesystem/test/msvc/wide_test/wide_test.vcproj new file mode 100644 index 0000000..d169602 --- /dev/null +++ b/v3/libs/filesystem/test/msvc/wide_test/wide_test.vcproj @@ -0,0 +1,191 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/v3/libs/filesystem/test/operations_test.cpp b/v3/libs/filesystem/test/operations_test.cpp new file mode 100644 index 0000000..539826f --- /dev/null +++ b/v3/libs/filesystem/test/operations_test.cpp @@ -0,0 +1,1294 @@ +// Boost operations_test.cpp ---------------------------------------------------------// + +// Copyright Beman Dawes 2002, 2009. + +// Distributed under the Boost Software License, Version 1.0. +// See http://www.boost.org/LICENSE_1_0.txt + +// Library home page: http://www.boost.org/libs/filesystem + +#include + +// See deprecated_test for tests of deprecated features +#define BOOST_FILESYSTEM_NO_DEPRECATED + +#include +#include +namespace fs = boost::filesystem; + +#include +#include + +using boost::system::error_code; +using boost::system::system_category; +using boost::system::system_error; + +#include +#include +#include +#include // for strncmp, etc. +#include +#include // for system() + +#ifdef BOOST_WINDOWS_API +# include +#endif + +// glibc++ doesn't have wchar_t overloads for file stream paths, so on Windows use +// path::string() to get a narrow character c_str() +#if defined(BOOST_WINDOWS_API) && defined(__GLIBCXX__) +# define BOOST_FILESYSTEM_C_STR string().c_str() +#else +# define BOOST_FILESYSTEM_C_STR c_str() +#endif + +#define CHECK_EXCEPTION(Functor,Expect) throws_fs_error(Functor,Expect,__LINE__) + +namespace +{ + typedef int errno_t; + std::string platform(BOOST_PLATFORM); + bool report_throws; + bool cleanup = true; + fs::directory_iterator end_itr; + fs::path dir; + fs::path d1; + fs::path d2; + bool create_symlink_ok(true); + fs::path ng(" no-way, Jose"); + + unsigned short language_id; // 0 except for Windows + + const char* temp_dir_name = "temp_fs_test_dir"; + + void create_file(const fs::path & ph, const std::string & contents) + { + std::ofstream f(ph.BOOST_FILESYSTEM_C_STR); + if (!f) + throw fs::filesystem_error("operations_test create_file", + ph, error_code(errno, system_category())); + if (!contents.empty()) f << contents; + } + + void verify_file(const fs::path & ph, const std::string & expected) + { + std::ifstream f(ph.BOOST_FILESYSTEM_C_STR); + if (!f) + throw fs::filesystem_error("operations_test verify_file", + ph, error_code(errno, system_category())); + std::string contents; + f >> contents; + if (contents != expected) + throw fs::filesystem_error("operations_test verify_file contents \"" + + contents + "\" != \"" + expected + "\"", ph, error_code()); + } + + template< typename F > + bool throws_fs_error(F func, errno_t en, int line) + { + try { func(); } + + catch (const fs::filesystem_error & ex) + { + if (report_throws) + { + // use the what() convenience function to display exceptions + std::cout << "\n" << ex.what() << "\n"; + } + if (en == 0 + || en == ex.code().default_error_condition().value()) return true; + std::cout + << "\nWarning: line " << line + << " exception reports default_error_condition().value() " + << ex.code().default_error_condition().value() + << ", should be " << en + << "\n value() is " << ex.code().value() + << std::endl; + return true; + } + return false; + } + + boost::system::error_category* poison_category_aux() { return 0; } + boost::system::error_category& poison_category() { return *poison_category_aux(); } + + // compile-only two argument "do-the-right-thing" tests + // verifies that all overload combinations compile without error + void do_not_call() + { + fs::path p; + std::string s; + const char* a = 0; + fs::copy_file(p, p); + fs::copy_file(s, p); + fs::copy_file(a, p); + fs::copy_file(p, s); + fs::copy_file(p, a); + fs::copy_file(s, s); + fs::copy_file(a, s); + fs::copy_file(s, a); + fs::copy_file(a, a); + } + + void bad_file_size() + { + fs::file_size(" No way, Jose"); + } + + void bad_directory_size() + { + fs::file_size(fs::current_path()); + } + + fs::path bad_create_directory_path; + void bad_create_directory() + { + fs::create_directory(bad_create_directory_path); + } + + void bad_equivalent() + { + fs::equivalent("no-such-path", "another-not-present-path"); + } + + fs::path bad_remove_dir; + void bad_remove() + { + fs::remove(bad_remove_dir); + } + + class renamer + { + public: + renamer(const fs::path & p1, const fs::path & p2) + : from(p1), to(p2) {} + void operator()() + { + fs::rename(from, to); + } + private: + fs::path from; + fs::path to; + }; + + // exception_tests() ---------------------------------------------------------------// + + void exception_tests() + { + std::cout << "exception_tests..." << std::endl; + bool exception_thrown; + + // catch runtime_error by value + + std::cout << " catch runtime_error by value" << std::endl; + exception_thrown = false; + try + { + fs::create_directory("no-such-dir/foo/bar"); + } + catch (std::runtime_error x) + { + exception_thrown = true; + if (report_throws) std::cout << x.what() << std::endl; + if (platform == "Windows" && language_id == 0x0409) // English (United States) + // the stdcxx standard library apparently appends additional info + // to what(), so check only the initial portion: + BOOST_TEST(std::strncmp(x.what(), + "boost::filesystem::create_directory", + sizeof("boost::filesystem::create_directory")-1) == 0); + } + BOOST_TEST(exception_thrown); + + // catch system_error by value + + std::cout << " catch system_error by value" << std::endl; + exception_thrown = false; + try + { + fs::create_directory("no-such-dir/foo/bar"); + } + catch (system_error x) + { + exception_thrown = true; + if (report_throws) std::cout << x.what() << std::endl; + if (platform == "Windows" && language_id == 0x0409) // English (United States) + BOOST_TEST(std::strcmp(x.what(), + "boost::filesystem::create_directory: The system cannot find the path specified") == 0); + } + BOOST_TEST(exception_thrown); + + // catch filesystem_error by value + + std::cout << " catch filesystem_error by value" << std::endl; + exception_thrown = false; + try + { + fs::create_directory("no-such-dir/foo/bar"); + } + catch (fs::filesystem_error x) + { + exception_thrown = true; + if (report_throws) std::cout << x.what() << std::endl; + if (platform == "Windows" && language_id == 0x0409) // English (United States) + { + bool ok (std::strcmp(x.what(), + "boost::filesystem::create_directory: The system cannot find the path specified: \"no-such-dir/foo/bar\"") == 0); + BOOST_TEST(ok); + if (!ok) + { + std::cout << "what returns \"" << x.what() << "\"" << std::endl; + } + } + } + BOOST_TEST(exception_thrown); + + // catch filesystem_error by const reference + + std::cout << " catch filesystem_error by const reference" << std::endl; + exception_thrown = false; + try + { + fs::create_directory("no-such-dir/foo/bar"); + } + catch (const fs::filesystem_error & x) + { + exception_thrown = true; + if (report_throws) std::cout << x.what() << std::endl; + if (platform == "Windows" && language_id == 0x0409) // English (United States) + { + bool ok (std::strcmp(x.what(), + "boost::filesystem::create_directory: The system cannot find the path specified: \"no-such-dir/foo/bar\"") == 0); + BOOST_TEST(ok); + if (!ok) + { + std::cout << "what returns \"" << x.what() << "\"" << std::endl; + } + } + } + BOOST_TEST(exception_thrown); + + // the bound functions should throw, so CHECK_EXCEPTION() should return true + + BOOST_TEST(CHECK_EXCEPTION(bad_file_size, ENOENT)); + + if (platform == "Windows") + BOOST_TEST(CHECK_EXCEPTION(bad_directory_size, ENOENT)); + else + BOOST_TEST(CHECK_EXCEPTION(bad_directory_size, 0)); + + // test path::exception members + try { fs::file_size(ng); } // will throw + + catch (const fs::filesystem_error & ex) + { + BOOST_TEST(ex.path1().string() == " no-way, Jose"); + } + + std::cout << " exception_tests complete" << std::endl; + } + + // directory_iterator_tests --------------------------------------------------------// + + void directory_iterator_tests() + { + std::cout << "directory_iterator_tests..." << std::endl; + + bool dir_itr_exception(false); + try { fs::directory_iterator it(""); } + catch (const fs::filesystem_error &) { dir_itr_exception = true; } + BOOST_TEST(dir_itr_exception); + + error_code ec; + + BOOST_TEST(!ec); + fs::directory_iterator it("", ec); + BOOST_TEST(ec); + + dir_itr_exception = false; + try { fs::directory_iterator it("nosuchdirectory"); } + catch (const fs::filesystem_error &) { dir_itr_exception = true; } + BOOST_TEST(dir_itr_exception); + + ec.clear(); + fs::directory_iterator it2("nosuchdirectory", ec); + BOOST_TEST(ec); + + dir_itr_exception = false; + try + { + error_code ec; + fs::directory_iterator it("nosuchdirectory", ec); + BOOST_TEST(ec); + BOOST_TEST(ec == boost::system::errc::no_such_file_or_directory); + } + catch (const fs::filesystem_error &) { dir_itr_exception = true; } + BOOST_TEST(!dir_itr_exception); + + { + // probe query function overloads + fs::directory_iterator dir_itr(dir); + // BOOST_TEST(fs::is_directory(*dir_itr)); + BOOST_TEST(fs::is_directory(dir_itr->status())); + // BOOST_TEST(fs::is_directory(fs::symlink_status(*dir_itr))); + BOOST_TEST(fs::is_directory(dir_itr->symlink_status())); + BOOST_TEST(dir_itr->path().filename() == "d1"); + } + + // create a second directory named d2 + d2 = dir / "d2"; + fs::create_directory(d2); + BOOST_TEST(fs::exists(d2)); + BOOST_TEST(fs::is_directory(d2)); + + // test the basic operation of directory_iterators, and test that + // stepping one iterator doesn't affect a different iterator. + { + fs::directory_iterator dir_itr(dir); + BOOST_TEST(fs::exists(dir_itr->status())); + BOOST_TEST(fs::is_directory(dir_itr->status())); + BOOST_TEST(!fs::is_regular_file(dir_itr->status())); + BOOST_TEST(!fs::is_other(dir_itr->status())); + BOOST_TEST(!fs::is_symlink(dir_itr->status())); + + fs::directory_iterator dir_itr2(dir); + BOOST_TEST(dir_itr->path().filename() == "d1" + || dir_itr->path().filename() == "d2"); + BOOST_TEST(dir_itr2->path().filename() == "d1" || dir_itr2->path().filename() == "d2"); + if (dir_itr->path().filename() == "d1") + { + BOOST_TEST((++dir_itr)->path().filename() == "d2"); + BOOST_TEST(dir_itr2->path().filename() == "d1"); + BOOST_TEST((++dir_itr2)->path().filename() == "d2"); + } + else + { + BOOST_TEST(dir_itr->path().filename() == "d2"); + BOOST_TEST((++dir_itr)->path().filename() == "d1"); + BOOST_TEST((dir_itr2)->path().filename() == "d2"); + BOOST_TEST((++dir_itr2)->path().filename() == "d1"); + } + BOOST_TEST(++dir_itr == fs::directory_iterator()); + BOOST_TEST(dir_itr2 != fs::directory_iterator()); + ec.clear(); + dir_itr2.increment(ec); + BOOST_TEST(!ec); + BOOST_TEST(dir_itr2 == fs::directory_iterator()); + } + + { // *i++ must work to meet the standard's InputIterator requirements + fs::directory_iterator dir_itr(dir); + BOOST_TEST(dir_itr->path().filename() == "d1" + || dir_itr->path().filename() == "d2"); + if (dir_itr->path().filename() == "d1") + { + BOOST_TEST((*dir_itr++).path().filename() == "d1"); + BOOST_TEST(dir_itr->path().filename() == "d2"); + } + else + { + // Check C++98 input iterator requirements + BOOST_TEST((*dir_itr++).path().filename() == "d2"); + // input iterator requirements in the current WP would require this check: + // BOOST_TEST(implicit_cast(*dir_itr++).filename() == "d1"); + + BOOST_TEST(dir_itr->path().filename() == "d1"); + } + + // test case reported in comment to SourceForge bug tracker [937606] + fs::directory_iterator it(dir); + const fs::path p1 = (*it++).path(); + BOOST_TEST(it != fs::directory_iterator()); + const fs::path p2 = (*it++).path(); + BOOST_TEST(p1 != p2); + BOOST_TEST(it == fs::directory_iterator()); + } + + // Windows has a tricky special case when just the root-name is given, + // causing the rest of the path to default to the current directory. + // Reported as S/F bug [ 1259176 ] + if (platform == "Windows") + { + fs::path root_name_path(fs::current_path().root_name()); + fs::directory_iterator it(root_name_path); + BOOST_TEST(it != fs::directory_iterator()); +// BOOST_TEST(fs::exists((*it).path())); + BOOST_TEST(fs::exists(it->path())); + BOOST_TEST(it->path().parent_path() == root_name_path); + bool found(false); + do + { + if (it->path().filename() == temp_dir_name) found = true; + } while (++it != fs::directory_iterator()); + BOOST_TEST(found); + } + + // there was an inital bug in directory_iterator that caused premature + // close of an OS handle. This block will detect regression. + { + fs::directory_iterator di; + { + di = fs::directory_iterator(dir); + } + BOOST_TEST(++di != fs::directory_iterator()); + } + + std::cout << " directory_iterator_tests complete" << std::endl; + } + + // create_hard_link_tests ----------------------------------------------------------// + + void create_hard_link_tests() + { + std::cout << "create_hard_link_tests..." << std::endl; + + fs::path from_ph(dir / "f3"); + fs::path file_ph(dir / "f1"); + + BOOST_TEST(!fs::exists(from_ph)); + BOOST_TEST(fs::exists(file_ph)); + bool create_hard_link_ok(true); + try { fs::create_hard_link(file_ph, from_ph); } + catch (const fs::filesystem_error & ex) + { + create_hard_link_ok = false; + std::cout + << " *** For information only ***\n" + " create_hard_link() attempt failed\n" + " filesystem_error.what() reports: " << ex.what() << "\n" + " create_hard_link() may not be supported on this file system\n"; + } + + if (create_hard_link_ok) + { + std::cout + << " *** For information only ***\n" + " create_hard_link() succeeded\n"; + BOOST_TEST(fs::exists(from_ph)); + BOOST_TEST(fs::exists(file_ph)); + BOOST_TEST(fs::equivalent(from_ph, file_ph)); + BOOST_TEST(fs::hard_link_count(from_ph) == 2); + BOOST_TEST(fs::hard_link_count(file_ph) == 2); + } + + // Although tests may be running on a FAT or other file system that does + // not support hard links, that is unusual enough that it is considered + // a test failure. + BOOST_TEST(create_hard_link_ok); + + error_code ec; + fs::create_hard_link(fs::path("doesnotexist"), + fs::path("shouldnotwork"), ec); + BOOST_TEST(ec); + } + + // create_symlink_tests ------------------------------------------------------------// + + void create_symlink_tests() + { + std::cout << "create_symlink_tests..." << std::endl; + + fs::path from_ph(dir / "f4"); + fs::path file_ph(dir / "f1"); + BOOST_TEST(!fs::exists(from_ph)); + BOOST_TEST(fs::exists(file_ph)); + try { fs::create_symlink(file_ph, from_ph); } + catch (const fs::filesystem_error & ex) + { + create_symlink_ok = false; + std::cout + << " *** For information only ***\n" + " create_symlink() attempt failed\n" + " filesystem_error.what() reports: " << ex.what() << "\n" + " create_symlink() may not be supported on this operating system or file system\n"; + } + + if (create_symlink_ok) + { + std::cout + << " *** For information only ***\n" + " create_symlink() succeeded\n"; + BOOST_TEST(fs::exists(from_ph)); + BOOST_TEST(fs::is_symlink(from_ph)); + BOOST_TEST(fs::exists(file_ph)); + BOOST_TEST(fs::equivalent(from_ph, file_ph)); + BOOST_TEST(fs::read_symlink(from_ph) == file_ph); + + fs::file_status stat = fs::symlink_status(from_ph); + BOOST_TEST(fs::exists(stat)); + BOOST_TEST(!fs::is_directory(stat)); + BOOST_TEST(!fs::is_regular_file(stat)); + BOOST_TEST(!fs::is_other(stat)); + BOOST_TEST(fs::is_symlink(stat)); + + stat = fs::status(from_ph); + BOOST_TEST(fs::exists(stat)); + BOOST_TEST(!fs::is_directory(stat)); + BOOST_TEST(fs::is_regular_file(stat)); + BOOST_TEST(!fs::is_other(stat)); + BOOST_TEST(!fs::is_symlink(stat)); + + // since create_symlink worked, copy_symlink should also work + fs::path symlink2_ph(dir / "symlink2"); + fs::copy_symlink(from_ph, symlink2_ph); + stat = fs::symlink_status(symlink2_ph); + BOOST_TEST(fs::is_symlink(stat)); + BOOST_TEST(fs::exists(stat)); + BOOST_TEST(!fs::is_directory(stat)); + BOOST_TEST(!fs::is_regular_file(stat)); + BOOST_TEST(!fs::is_other(stat)); + } + + error_code ec = error_code(); + fs::create_symlink("doesnotexist", "", ec); + BOOST_TEST(ec); + } + + // rename_tests --------------------------------------------------------------------// + + void rename_tests() + { + std::cout << "rename_tests..." << std::endl; + + fs::path file_ph(dir / "f1"); + BOOST_TEST(fs::exists(file_ph)); + + // error: rename a non-existent old file + BOOST_TEST(!fs::exists(d1 / "f99")); + BOOST_TEST(!fs::exists(d1 / "f98")); + renamer n1a(d1 / "f99", d1 / "f98"); + BOOST_TEST(CHECK_EXCEPTION(n1a, ENOENT)); + renamer n1b(fs::path(""), d1 / "f98"); + BOOST_TEST(CHECK_EXCEPTION(n1b, ENOENT)); + + // error: rename an existing file to "" + renamer n2(file_ph, ""); + BOOST_TEST(CHECK_EXCEPTION(n2, ENOENT)); + + // rename an existing file to an existent file + create_file(dir / "ff1", "ff1"); + create_file(dir / "ff2", "ff2"); + fs::rename(dir / "ff2", dir / "ff1"); + BOOST_TEST(fs::exists(dir / "ff1")); + verify_file(dir / "ff1", "ff2"); + BOOST_TEST(!fs::exists(dir / "ff2")); + + // rename an existing file to itself + BOOST_TEST(fs::exists(dir / "f1")); + fs::rename(dir / "f1", dir / "f1"); + BOOST_TEST(fs::exists(dir / "f1")); + + // error: rename an existing directory to an existing non-empty directory + BOOST_TEST(fs::exists(dir / "f1")); + BOOST_TEST(fs::exists(d1 / "f2")); + // several POSIX implementations (cygwin, openBSD) report ENOENT instead of EEXIST, + // so we don't verify error type on the following test. + renamer n3b(dir, d1); + BOOST_TEST(CHECK_EXCEPTION(n3b, 0)); + + // error: move existing file to a nonexistent parent directory + BOOST_TEST(!fs::is_directory(dir / "f1")); + BOOST_TEST(!fs::exists(dir / "d3/f3")); + renamer n4a(dir / "f1", dir / "d3/f3"); + BOOST_TEST(CHECK_EXCEPTION(n4a, ENOENT)); + + // rename existing file in same directory + BOOST_TEST(fs::exists(d1 / "f2")); + BOOST_TEST(!fs::exists(d1 / "f50")); + fs::rename(d1 / "f2", d1 / "f50"); + BOOST_TEST(!fs::exists(d1 / "f2")); + BOOST_TEST(fs::exists(d1 / "f50")); + fs::rename(d1 / "f50", d1 / "f2"); + BOOST_TEST(fs::exists(d1 / "f2")); + BOOST_TEST(!fs::exists(d1 / "f50")); + + // move and rename an existing file to a different directory + fs::rename(d1 / "f2", d2 / "f3"); + BOOST_TEST(!fs::exists(d1 / "f2")); + BOOST_TEST(!fs::exists(d2 / "f2")); + BOOST_TEST(fs::exists(d2 / "f3")); + BOOST_TEST(!fs::is_directory(d2 / "f3")); + verify_file(d2 / "f3", "foobar1"); + fs::rename(d2 / "f3", d1 / "f2"); + BOOST_TEST(fs::exists(d1 / "f2")); + + // error: move existing directory to nonexistent parent directory + BOOST_TEST(fs::exists(d1)); + BOOST_TEST(!fs::exists(dir / "d3/d5")); + BOOST_TEST(!fs::exists(dir / "d3")); + renamer n5a(d1, dir / "d3/d5"); + BOOST_TEST(CHECK_EXCEPTION(n5a, ENOENT)); + + // rename existing directory + fs::path d3(dir / "d3"); + BOOST_TEST(fs::exists(d1)); + BOOST_TEST(fs::exists(d1 / "f2")); + BOOST_TEST(!fs::exists(d3)); + fs::rename(d1, d3); + BOOST_TEST(!fs::exists(d1)); + BOOST_TEST(fs::exists(d3)); + BOOST_TEST(fs::is_directory(d3)); + BOOST_TEST(!fs::exists(d1 / "f2")); + BOOST_TEST(fs::exists(d3 / "f2")); + fs::rename(d3, d1); + BOOST_TEST(fs::exists(d1)); + BOOST_TEST(fs::exists(d1 / "f2")); + BOOST_TEST(!fs::exists(d3)); + + // rename and move d1 to d2 / "d20" + BOOST_TEST(fs::exists(d1)); + BOOST_TEST(!fs::exists(d2 / "d20")); + BOOST_TEST(fs::exists(d1 / "f2")); + fs::rename(d1, d2 / "d20"); + BOOST_TEST(!fs::exists(d1)); + BOOST_TEST(fs::exists(d2 / "d20")); + BOOST_TEST(fs::exists(d2 / "d20" / "f2")); + fs::rename(d2 / "d20", d1); + BOOST_TEST(fs::exists(d1)); + BOOST_TEST(!fs::exists(d2 / "d20")); + BOOST_TEST(fs::exists(d1 / "f2")); + } + + // predicate_and_status_tests ------------------------------------------------------// + + void predicate_and_status_tests() + { + std::cout << "predicate_and_status_tests..." << std::endl; + + BOOST_TEST(!fs::exists(ng)); + BOOST_TEST(!fs::is_directory(ng)); + BOOST_TEST(!fs::is_regular_file(ng)); + BOOST_TEST(!fs::is_symlink(ng)); + fs::file_status stat(fs::status(ng)); + BOOST_TEST(fs::status_known(stat)); + BOOST_TEST(!fs::exists(stat)); + BOOST_TEST(!fs::is_directory(stat)); + BOOST_TEST(!fs::is_regular_file(stat)); + BOOST_TEST(!fs::is_other(stat)); + BOOST_TEST(!fs::is_symlink(stat)); + stat = fs::status(""); + BOOST_TEST(fs::status_known(stat)); + BOOST_TEST(!fs::exists(stat)); + BOOST_TEST(!fs::is_directory(stat)); + BOOST_TEST(!fs::is_regular_file(stat)); + BOOST_TEST(!fs::is_other(stat)); + BOOST_TEST(!fs::is_symlink(stat)); + } + + // create_directory_tests ----------------------------------------------------------// + + void create_directory_tests() + { + std::cout << "create_directory_tests..." << std::endl; + + // create a directory, then check it for consistency + // take extra care to report problems, since if this fails + // many subsequent tests will fail + try + { + fs::create_directory(dir); + } + + catch (const fs::filesystem_error & x) + { + std::cout << x.what() << "\n\n" + "***** Creating directory " << dir << " failed. *****\n" + "***** This is a serious error that will prevent further tests *****\n" + "***** from returning useful results. Further testing is aborted. *****\n\n"; + std::exit(1); + } + + catch (...) + { + std::cout << "\n\n" + "***** Creating directory " << dir << " failed. *****\n" + "***** This is a serious error that will prevent further tests *****\n" + "***** from returning useful results. Further testing is aborted. *****\n\n"; + std::exit(1); + } + + BOOST_TEST(fs::exists(dir)); + BOOST_TEST(fs::is_empty(dir)); + BOOST_TEST(fs::is_directory(dir)); + BOOST_TEST(!fs::is_regular_file(dir)); + BOOST_TEST(!fs::is_other(dir)); + BOOST_TEST(!fs::is_symlink(dir)); + fs::file_status stat = fs::status(dir); + BOOST_TEST(fs::exists(stat)); + BOOST_TEST(fs::is_directory(stat)); + BOOST_TEST(!fs::is_regular_file(stat)); + BOOST_TEST(!fs::is_other(stat)); + BOOST_TEST(!fs::is_symlink(stat)); + + std::cout << " create_directory_tests complete" << std::endl; + } + + // current_directory_tests ---------------------------------------------------------// + + void current_directory_tests() + { + std::cout << "current_directory_tests..." << std::endl; + + // set the current directory, then check it for consistency + fs::path original_dir = fs::current_path(); + BOOST_TEST(dir != original_dir); + fs::current_path(dir); + BOOST_TEST(fs::current_path() == dir); + BOOST_TEST(fs::current_path() != original_dir); + fs::current_path(original_dir); + BOOST_TEST(fs::current_path() == original_dir); + BOOST_TEST(fs::current_path() != dir); + + // make sure the overloads work + fs::current_path(dir.c_str()); + BOOST_TEST(fs::current_path() == dir); + BOOST_TEST(fs::current_path() != original_dir); + fs::current_path(original_dir.string()); + BOOST_TEST(fs::current_path() == original_dir); + BOOST_TEST(fs::current_path() != dir); + } + + // create_directories_tests --------------------------------------------------------// + + void create_directories_tests() + { + std::cout << "create_directories_tests..." << std::endl; + + fs::path p = dir / "level1" / "level2"; + + BOOST_TEST(!fs::exists(p)); + BOOST_TEST(fs::create_directories(p)); + BOOST_TEST(fs::exists(p)); + BOOST_TEST(fs::is_directory(p)); + } + + // resize_file_tests ---------------------------------------------------------------// + + void resize_file_tests() + { + std::cout << "resize_file_tests..." << std::endl; + + const std::string f ("resize_file_test.txt"); + + fs::remove(f); + create_file(f, "1234567890"); + + BOOST_TEST(fs::exists(f)); + BOOST_TEST_EQ(fs::file_size(f), 10U); + fs::resize_file(f, 5); + BOOST_TEST(fs::exists(f)); + BOOST_TEST_EQ(fs::file_size(f), 5U); + fs::resize_file(f, 15); + BOOST_TEST(fs::exists(f)); + BOOST_TEST_EQ(fs::file_size(f), 15U); + + error_code ec; + fs::resize_file("no such file", 15, ec); + BOOST_TEST(ec); + } + + // status_of_nonexistent_tests -----------------------------------------------------// + + void status_of_nonexistent_tests() + { + std::cout << "status_of_nonexistent_tests..." << std::endl; + fs::path p ("nosuch"); + BOOST_TEST(!fs::exists(p)); + BOOST_TEST(!fs::is_regular_file(p)); + BOOST_TEST(!fs::is_directory(p)); + BOOST_TEST(!fs::is_symlink(p)); + BOOST_TEST(!fs::is_other(p)); + + fs::file_status s = fs::status(p); + BOOST_TEST(!fs::exists(s)); + BOOST_TEST_EQ(s.type(), fs::file_not_found); + BOOST_TEST(fs::status_known(s)); + BOOST_TEST(!fs::is_regular_file(s)); + BOOST_TEST(!fs::is_directory(s)); + BOOST_TEST(!fs::is_symlink(s)); + BOOST_TEST(!fs::is_other(s)); + } + + // status_error_reporting_tests ----------------------------------------------------// + + void status_error_reporting_tests() + { + std::cout << "status_error_reporting_tests..." << std::endl; + + error_code ec; + + // test status, ec, for existing file + ec.assign(-1,poison_category()); + BOOST_TEST(ec.value() == -1); + BOOST_TEST(&ec.category() == &poison_category()); + fs::file_status s = fs::status(".",ec); + BOOST_TEST(ec.value() == 0); + BOOST_TEST(ec.category() == system_category()); + BOOST_TEST(fs::exists(s)); + BOOST_TEST(fs::is_directory(s)); + + // test status, ec, for non-existing file + fs::path p ("nosuch"); + ec.assign(-1,poison_category()); + s = fs::status(p,ec); + BOOST_TEST(ec.value() != 0); + BOOST_TEST(ec.category() == system_category()); + + BOOST_TEST(!fs::exists(s)); + BOOST_TEST_EQ(s.type(), fs::file_not_found); + BOOST_TEST(fs::status_known(s)); + BOOST_TEST(!fs::is_regular_file(s)); + BOOST_TEST(!fs::is_directory(s)); + BOOST_TEST(!fs::is_symlink(s)); + BOOST_TEST(!fs::is_other(s)); + + // test queries, ec, for existing file + ec.assign(-1,poison_category()); + BOOST_TEST(fs::exists(".", ec)); + BOOST_TEST(ec.value() == 0); + BOOST_TEST(ec.category() == system_category()); + ec.assign(-1,poison_category()); + BOOST_TEST(!fs::is_regular_file(".", ec)); + BOOST_TEST(ec.value() == 0); + BOOST_TEST(ec.category() == system_category()); + ec.assign(-1,poison_category()); + BOOST_TEST(fs::is_directory(".", ec)); + BOOST_TEST(ec.value() == 0); + BOOST_TEST(ec.category() == system_category()); + + // test queries, ec, for non-existing file + ec.assign(-1,poison_category()); + BOOST_TEST(!fs::exists(p, ec)); + BOOST_TEST(ec.value() != 0); + BOOST_TEST(ec.category() == system_category()); + ec.assign(-1,poison_category()); + BOOST_TEST(!fs::is_regular_file(p, ec)); + BOOST_TEST(ec.value() != 0); + BOOST_TEST(ec.category() == system_category()); + ec.assign(-1,poison_category()); + BOOST_TEST(!fs::is_directory(p, ec)); + BOOST_TEST(ec.value() != 0); + BOOST_TEST(ec.category() == system_category()); + } + + // remove_tests --------------------------------------------------------------------// + + void remove_tests(const fs::path& dir) + { + std::cout << "remove_tests..." << std::endl; + + // remove() file + fs::path file_ph = dir / "shortlife"; + BOOST_TEST(!fs::exists(file_ph)); + create_file(file_ph, ""); + BOOST_TEST(fs::exists(file_ph)); + BOOST_TEST(!fs::is_directory(file_ph)); + BOOST_TEST(fs::remove(file_ph)); + BOOST_TEST(!fs::exists(file_ph)); + BOOST_TEST(!fs::remove("no-such-file")); + BOOST_TEST(!fs::remove("no-such-directory/no-such-file")); + + // remove() directory + fs::path d1 = dir / "shortlife_dir"; + BOOST_TEST(!fs::exists(d1)); + fs::create_directory(d1); + BOOST_TEST(fs::exists(d1)); + BOOST_TEST(fs::is_directory(d1)); + BOOST_TEST(fs::is_empty(d1)); + bad_remove_dir = dir; + BOOST_TEST(CHECK_EXCEPTION(bad_remove, ENOTEMPTY)); + BOOST_TEST(fs::remove(d1)); + BOOST_TEST(!fs::exists(d1)); + } + + // remove_symlink_tests ------------------------------------------------------------// + + void remove_symlink_tests() + { + std::cout << "remove_symlink_tests..." << std::endl; + + // remove() dangling symbolic link + fs::path link("dangling_link"); + fs::remove(link); // remove any residue from past tests + BOOST_TEST(!fs::is_symlink(link)); + BOOST_TEST(!fs::exists(link)); + fs::create_symlink("nowhere", link); + BOOST_TEST(!fs::exists(link)); + BOOST_TEST(fs::is_symlink(link)); + BOOST_TEST(fs::remove(link)); + BOOST_TEST(!fs::is_symlink(link)); + + // remove() self-refering symbolic link + link = "link_to_self"; + fs::remove(link); // remove any residue from past tests + BOOST_TEST(!fs::is_symlink(link)); + BOOST_TEST(!fs::exists(link)); + fs::create_symlink(link, link); + BOOST_TEST(fs::remove(link)); + BOOST_TEST(!fs::exists(link)); + BOOST_TEST(!fs::is_symlink(link)); + + // remove() cyclic symbolic link + link = "link_to_a"; + fs::path link2("link_to_b"); + fs::remove(link); // remove any residue from past tests + fs::remove(link2); // remove any residue from past tests + BOOST_TEST(!fs::is_symlink(link)); + BOOST_TEST(!fs::exists(link)); + fs::create_symlink(link, link2); + fs::create_symlink(link2, link); + BOOST_TEST(fs::remove(link)); + BOOST_TEST(fs::remove(link2)); + BOOST_TEST(!fs::exists(link)); + BOOST_TEST(!fs::exists(link2)); + BOOST_TEST(!fs::is_symlink(link)); + + // remove() symbolic link to file + fs::path file_ph = "link_target"; + fs::remove(file_ph); // remove any residue from past tests + BOOST_TEST(!fs::exists(file_ph)); + create_file(file_ph, ""); + BOOST_TEST(fs::exists(file_ph)); + BOOST_TEST(!fs::is_directory(file_ph)); + BOOST_TEST(fs::is_regular_file(file_ph)); + link = "non_dangling_link"; + fs::create_symlink(file_ph, link); + BOOST_TEST(fs::exists(link)); + BOOST_TEST(!fs::is_directory(link)); + BOOST_TEST(fs::is_regular_file(link)); + BOOST_TEST(fs::is_symlink(link)); + BOOST_TEST(fs::remove(link)); + BOOST_TEST(fs::exists(file_ph)); + BOOST_TEST(!fs::exists(link)); + BOOST_TEST(!fs::is_symlink(link)); + BOOST_TEST(fs::remove(file_ph)); + BOOST_TEST(!fs::exists(file_ph)); + } + + // copy_file_tests -----------------------------------------------------------------// + + void copy_file_tests(const fs::path& file_ph, const fs::path& d1) + { + std::cout << "copy_file_tests..." << std::endl; + + BOOST_TEST(fs::exists(file_ph)); + fs::remove(d1 / "f2"); // remove possible residue from prior testing + BOOST_TEST(fs::exists(d1)); + BOOST_TEST(!fs::exists(d1 / "f2")); + std::cout << " copy " << file_ph << " to " << d1 / "f2" << std::endl; + fs::copy_file(file_ph, d1 / "f2"); + std::cout << " copy complete" << std::endl; + BOOST_TEST(fs::exists(file_ph)); + BOOST_TEST(fs::exists(d1 / "f2")); + BOOST_TEST(!fs::is_directory(d1 / "f2")); + verify_file(d1 / "f2", "foobar1"); + + bool copy_ex_ok = false; + try { fs::copy_file(file_ph, d1 / "f2"); } + catch (const fs::filesystem_error &) { copy_ex_ok = true; } + BOOST_TEST(copy_ex_ok); + + copy_ex_ok = false; + try { fs::copy_file(file_ph, d1 / "f2", fs::copy_option::fail_if_exists); } + catch (const fs::filesystem_error &) { copy_ex_ok = true; } + BOOST_TEST(copy_ex_ok); + + copy_ex_ok = true; + try { fs::copy_file(file_ph, d1 / "f2", fs::copy_option::overwrite_if_exists); } + catch (const fs::filesystem_error &) { copy_ex_ok = false; } + BOOST_TEST(copy_ex_ok); + } + + // write_time_tests ----------------------------------------------------------------// + + void write_time_tests(const fs::path& dir) + { + std::cout << "write_time_tests..." << std::endl; + + fs::path file_ph = dir / "foobar2"; + create_file(file_ph, "foobar2"); + BOOST_TEST(fs::exists(file_ph)); + BOOST_TEST(!fs::is_directory(file_ph)); + BOOST_TEST(fs::is_regular_file(file_ph)); + BOOST_TEST(fs::file_size(file_ph) == 7); + verify_file(file_ph, "foobar2"); + + // Some file system report last write time as local (FAT), while + // others (NTFS) report it as UTC. The C standard does not specify + // if time_t is local or UTC. + + std::time_t ft = fs::last_write_time(file_ph); + std::cout << "\n UTC last_write_time() for a file just created is " + << std::asctime(std::gmtime(&ft)) << std::endl; + + std::tm * tmp = std::localtime(&ft); + std::cout << "\n Year is " << tmp->tm_year << std::endl; + --tmp->tm_year; + std::cout << " Change year to " << tmp->tm_year << std::endl; + fs::last_write_time(file_ph, std::mktime(tmp)); + std::time_t ft2 = fs::last_write_time(file_ph); + std::cout << " last_write_time() for the file is now " + << std::asctime(std::gmtime(&ft2)) << std::endl; + BOOST_TEST(ft != fs::last_write_time(file_ph)); + + std::cout << "\n Reset to current time" << std::endl; + fs::last_write_time(file_ph, ft); + double time_diff = std::difftime(ft, fs::last_write_time(file_ph)); + std::cout + << " original last_write_time() - current last_write_time() is " + << time_diff << " seconds" << std::endl; + BOOST_TEST(time_diff >= -60.0 && time_diff <= 60.0); + } + + // platform_specific_tests ---------------------------------------------------------// + + void platform_specific_tests() + { + // Windows only tests + if (platform == "Windows") + { + std::cout << "Window specific tests..." + "\n (may take several seconds)" << std::endl; + + BOOST_TEST(!fs::exists(fs::path("//share-not"))); + BOOST_TEST(!fs::exists(fs::path("//share-not/"))); + BOOST_TEST(!fs::exists(fs::path("//share-not/foo"))); + BOOST_TEST(!fs::exists("tools/jam/src/:sys:stat.h")); // !exists() if ERROR_INVALID_NAME + BOOST_TEST(!fs::exists(":sys:stat.h")); // !exists() if ERROR_INVALID_PARAMETER + BOOST_TEST(dir.string().size() > 1 + && dir.string()[1] == ':'); // verify path includes drive + + BOOST_TEST(fs::system_complete("").empty()); + BOOST_TEST(fs::system_complete("/") == fs::initial_path().root_path()); + BOOST_TEST(fs::system_complete("foo") + == fs::initial_path() / "foo"); + + fs::path p1(fs::system_complete("/foo")); + BOOST_TEST_EQ(p1.string().size(), 6U); // this failed during v3 development due to bug + std::string s1(p1.string() ); + std::string s2(fs::initial_path().root_path().string()+"foo"); + BOOST_TEST_EQ(s1, s2); + + BOOST_TEST(fs::path("x:/").make_absolute(fs::initial_path()).string() + == "x:/"); + BOOST_TEST(fs::path("x:/foo").make_absolute(fs::initial_path()).string() + == "x:/foo"); + + BOOST_TEST(fs::system_complete(fs::path(fs::initial_path().root_name())) + == fs::initial_path()); + BOOST_TEST(fs::system_complete(fs::path(fs::initial_path().root_name().string() + + "foo")).string() == fs::initial_path() / "foo"); + BOOST_TEST(fs::system_complete(fs::path("c:/")).generic_string() + == "c:/"); + BOOST_TEST(fs::system_complete(fs::path("c:/foo")).generic_string() + == "c:/foo"); + BOOST_TEST(fs::system_complete(fs::path("//share")).generic_string() + == "//share"); + } // Windows + + else if (platform == "POSIX") + { + std::cout << "POSIX specific tests..." << std::endl; + BOOST_TEST(fs::system_complete("").empty()); + BOOST_TEST(fs::initial_path().root_path().string() == "/"); + BOOST_TEST(fs::system_complete("/").string() == "/"); + BOOST_TEST(fs::system_complete("foo").string() + == fs::initial_path().string()+"/foo"); + BOOST_TEST(fs::system_complete("/foo").string() + == fs::initial_path().root_path().string()+"foo"); + } // POSIX + } + + // initial_tests -------------------------------------------------------------------// + + void initial_tests() + { + std::cout << "initial_tests..." << std::endl; + + std::cout << " initial_path().string() is\n \"" + << fs::initial_path().string() + << "\"\n\n"; + BOOST_TEST(fs::initial_path().is_absolute()); + BOOST_TEST(fs::current_path().is_absolute()); + BOOST_TEST(fs::initial_path().string() + == fs::current_path().string()); + } + + // space_tests ---------------------------------------------------------------------// + + void space_tests() + { + std::cout << "space_tests..." << std::endl; + + // make some reasonable assuptions for testing purposes + fs::space_info spi(fs::space(dir)); + BOOST_TEST(spi.capacity > 1000000); + BOOST_TEST(spi.free > 1000); + BOOST_TEST(spi.capacity > spi.free); + BOOST_TEST(spi.free >= spi.available); + + // it is convenient to display space, but older VC++ versions choke +# if !defined(BOOST_MSVC) || _MSC_VER >= 1300 // 1300 == VC++ 7.0 + std::cout << " capacity = " << spi.capacity << '\n'; + std::cout << " free = " << spi.free << '\n'; + std::cout << " available = " << spi.available << '\n'; +# endif + } + + // equivalent_tests ----------------------------------------------------------------// + + void equivalent_tests(const fs::path& file_ph) + { + std::cout << "equivalent_tests..." << std::endl; + + BOOST_TEST(CHECK_EXCEPTION(bad_equivalent, ENOENT)); + BOOST_TEST(fs::equivalent(file_ph, dir / "f1")); + BOOST_TEST(fs::equivalent(dir, d1 / "..")); + BOOST_TEST(!fs::equivalent(file_ph, dir)); + BOOST_TEST(!fs::equivalent(dir, file_ph)); + BOOST_TEST(!fs::equivalent(d1, d2)); + BOOST_TEST(!fs::equivalent(dir, ng)); + BOOST_TEST(!fs::equivalent(ng, dir)); + BOOST_TEST(!fs::equivalent(file_ph, ng)); + BOOST_TEST(!fs::equivalent(ng, file_ph)); + } + + // _tests --------------------------------------------------------------------------// + + void _tests() + { + std::cout << "_tests..." << std::endl; + } + +} // unnamed namespace + + //------------------------------------------------------------------------------------// + // // + // main // + // // + //------------------------------------------------------------------------------------// + +int main(int argc, char* argv[]) +{ +// document state of critical macros +#ifdef BOOST_POSIX_API + std::cout << "BOOST_POSIX_API is defined\n"; +#endif +#ifdef BOOST_WINDOWS_API + std::cout << "BOOST_WINDOWS_API is defined\n"; +#endif +#ifdef BOOST_POSIX_API + std::cout << "BOOST_POSIX_API is defined\n"; +#endif +#ifdef BOOST_WINDOWS_API + std::cout << "BOOST_WINDOWS_API is defined\n"; +#endif + + if (argc > 1 && *argv[1]=='-' && *(argv[1]+1)=='t') report_throws = true; + if (argc > 1 && *argv[1]=='-' && *(argv[1]+1)=='x') cleanup = false; + + // The choice of platform to test is make at runtime rather than compile-time + // so that compile errors for all platforms will be detected even though + // only the current platform is runtime tested. +# if defined(BOOST_POSIX_API) + platform = "POSIX"; +# elif defined(BOOST_WINDOWS_API) + platform = "Windows"; +# if !defined(__MINGW32__) && !defined(__CYGWIN__) + language_id = ::GetUserDefaultUILanguage(); +# else + language_id = 0x0409; // Assume US English +# endif +# else +# error neither BOOST_POSIX_API nor BOOST_WINDOWS_API is defined. See boost/system/api_config.hpp +# endif + std::cout << "API is " << platform << std::endl; + + dir = fs::initial_path() / temp_dir_name; + + if (fs::exists(dir)) + { + std::cout << "remove residue from prior failed tests..." << std::endl; + fs::remove_all(dir); + } + BOOST_TEST(!fs::exists(dir)); + + // several functions give unreasonable results if uintmax_t isn't 64-bits + std::cout << "sizeof(boost::uintmax_t) = " << sizeof(boost::uintmax_t) << '\n'; + BOOST_TEST(sizeof(boost::uintmax_t) >= 8); + + initial_tests(); + predicate_and_status_tests(); + exception_tests(); + platform_specific_tests(); + create_directory_tests(); + current_directory_tests(); + space_tests(); + + // create directory d1, used by subsequent tests + BOOST_TEST(!fs::create_directory(dir)); + BOOST_TEST(!fs::is_symlink(dir)); + BOOST_TEST(!fs::is_symlink("nosuchfileordirectory")); + d1 = dir / "d1"; + BOOST_TEST(fs::create_directory(d1)); + BOOST_TEST(fs::exists(d1)); + BOOST_TEST(fs::is_directory(d1)); + BOOST_TEST(fs::is_empty(d1)); + + status_of_nonexistent_tests(); + status_error_reporting_tests(); + directory_iterator_tests(); + create_directories_tests(); // must run AFTER directory_iterator_tests + + // create an empty file named "f0", used in subsequent tests + fs::path file_ph(dir / "f0"); + create_file(file_ph, ""); + BOOST_TEST(fs::exists(file_ph)); + BOOST_TEST(!fs::is_directory(file_ph)); + BOOST_TEST(fs::is_regular_file(file_ph)); + BOOST_TEST(fs::is_empty(file_ph)); + BOOST_TEST(fs::file_size(file_ph) == 0); + BOOST_TEST(fs::hard_link_count(file_ph) == 1); + + bad_create_directory_path = file_ph; + BOOST_TEST(CHECK_EXCEPTION(bad_create_directory, EEXIST)); + fs::file_status stat = fs::status(file_ph); + BOOST_TEST(fs::status_known(stat)); + BOOST_TEST(fs::exists(stat)); + BOOST_TEST(!fs::is_directory(stat)); + BOOST_TEST(fs::is_regular_file(stat)); + BOOST_TEST(!fs::is_other(stat)); + BOOST_TEST(!fs::is_symlink(stat)); + + // create a file named "f1", used in subsequent tests + file_ph = dir / "f1"; + create_file(file_ph, "foobar1"); + + BOOST_TEST(fs::exists(file_ph)); + BOOST_TEST(!fs::is_directory(file_ph)); + BOOST_TEST(fs::is_regular_file(file_ph)); + BOOST_TEST(fs::file_size(file_ph) == 7); + verify_file(file_ph, "foobar1"); + + equivalent_tests(file_ph); + create_hard_link_tests(); + create_symlink_tests(); + resize_file_tests(); + copy_file_tests(file_ph, d1); + rename_tests(); + remove_tests(dir); + if (create_symlink_ok) // only if symlinks supported + remove_symlink_tests(); + write_time_tests(dir); + + // post-test cleanup + if (cleanup) + { + BOOST_TEST(fs::remove_all(dir) != 0); + // above was added just to simplify testing, but it ended up detecting + // a bug (failure to close an internal search handle). + BOOST_TEST(!fs::exists(dir)); + BOOST_TEST(fs::remove_all(dir) == 0); + } + return ::boost::report_errors(); +} // main + diff --git a/v3/libs/filesystem/test/operations_unit_test.cpp b/v3/libs/filesystem/test/operations_unit_test.cpp new file mode 100644 index 0000000..bec953d --- /dev/null +++ b/v3/libs/filesystem/test/operations_unit_test.cpp @@ -0,0 +1,229 @@ +// operations_unit_test.cpp ----------------------------------------------------------// + +// Copyright Beman Dawes 2008, 2009 + +// Distributed under the Boost Software License, Version 1.0. +// See http://www.boost.org/LICENSE_1_0.txt + +// Library home page: http://www.boost.org/libs/filesystem + +#include + +// See deprecated_test for tests of deprecated features +#define BOOST_FILESYSTEM_NO_DEPRECATED + +#include +#include +#include +#include + +using namespace boost::filesystem; +using namespace boost::system; +using std::cout; +using std::string; + +#define CHECK(x) check(x, __FILE__, __LINE__) + +namespace +{ + + void check(bool ok, const char* file, int line) + { + if (ok) return; + + ++::boost::detail::test_errors(); + + std::cout << file << '(' << line << "): test failed\n"; + } + + // query_test ----------------------------------------------------------------------// + + void query_test() + { + std::cout << "query test..." << std::endl; + + error_code ec; + + CHECK(file_size("no-such-file", ec) == static_cast(-1)); + CHECK(ec == errc::no_such_file_or_directory); + + CHECK(status("no-such-file") == file_status(file_not_found)); + + CHECK(exists("/")); + CHECK(is_directory("/")); + CHECK(!exists("no-such-file")); + + exists("/", ec); + if (ec) + { + std::cout << "exists(\"/\", ec) resulted in non-zero ec.value()" << std::endl; + std::cout << "ec value: " << ec.value() << ", message: "<< ec.message() << std::endl; + } + CHECK(!ec); + + CHECK(exists("/")); + CHECK(is_directory("/")); + CHECK(!is_regular_file("/")); + CHECK(!boost::filesystem::is_empty("/")); + CHECK(!is_other("/")); + } + + // directory_iterator_test -----------------------------------------------// + + void directory_iterator_test() + { + std::cout << "directory_iterator_test..." << std::endl; + + directory_iterator end; + + directory_iterator it("."); + + CHECK(!it->path().empty()); + + if (is_regular_file(it->status())) + { + CHECK(is_regular_file(it->symlink_status())); + CHECK(!is_directory(it->status())); + CHECK(!is_symlink(it->status())); + CHECK(!is_directory(it->symlink_status())); + CHECK(!is_symlink(it->symlink_status())); + } + else + { + CHECK(is_directory(it->status())); + CHECK(is_directory(it->symlink_status())); + CHECK(!is_regular_file(it->status())); + CHECK(!is_regular_file(it->symlink_status())); + CHECK(!is_symlink(it->status())); + CHECK(!is_symlink(it->symlink_status())); + } + + for (; it != end; ++it) + { +// cout << " " << it->path().string() << "\n"; + } + + std::cout << "directory_iterator_test complete" << std::endl; + } + + // operations_test -------------------------------------------------------// + + void operations_test() + { + std::cout << "operations test..." << std::endl; + + error_code ec; + + CHECK(!create_directory("/", ec)); + + CHECK(!boost::filesystem::remove("no-such-file-or-directory")); + CHECK(!remove_all("no-such-file-or-directory")); + + space_info info = space("/"); + + CHECK(info.available <= info.capacity); + + CHECK(equivalent("/", "/")); + CHECK(!equivalent("/", ".")); + + std::time_t ft = last_write_time("."); + ft = -1; + last_write_time(".", ft, ec); + } + + // directory_entry_test ------------------------------------------------------------// + + void directory_entry_test() + { + std::cout << "directory_entry test..." << std::endl; + + directory_entry de("foo.bar", file_status(regular_file), file_status(directory_file)); + + CHECK(de.path() == "foo.bar"); + CHECK(de.status() == file_status(regular_file)); + CHECK(de.symlink_status() == file_status(directory_file)); + CHECK(de < directory_entry("goo.bar")); + CHECK(de == directory_entry("foo.bar")); + CHECK(de != directory_entry("goo.bar")); + de.replace_filename("bar.foo"); + CHECK(de.path() == "bar.foo"); + } + + // directory_entry_overload_test ---------------------------------------------------// + + void directory_entry_overload_test() + { + std::cout << "directory_entry overload test..." << std::endl; + + directory_iterator it("."); + path p(*it); + } + + // error_handling_test -------------------------------------------------------------// + + void error_handling_test() + { + std::cout << "error handling test..." << std::endl; + + bool threw(false); + try + { + file_size("no-such-file"); + } + catch (const boost::filesystem::filesystem_error & ex) + { + threw = true; + cout << "\nas expected, attempt to get size of non-existent file threw a filesystem_error\n" + "what() returns " << ex.what() << "\n"; + } + catch (...) + { + cout << "\nunexpected exception type caught" << std::endl; + } + + CHECK(threw); + + error_code ec; + CHECK(!create_directory("/", ec)); + } + +} // unnamed namespace + +//--------------------------------------------------------------------------------------// +// // +// main // +// // +//--------------------------------------------------------------------------------------// + +int main() +{ +// document state of critical macros +#ifdef BOOST_POSIX_API + cout << "BOOST_POSIX_API is defined\n"; +#endif +#ifdef BOOST_WINDOWS_API + cout << "BOOST_WINDOWS_API is defined\n"; +#endif +#ifdef BOOST_POSIX_API + cout << "BOOST_POSIX_API is defined\n"; +#endif +#ifdef BOOST_WINDOWS_API + cout << "BOOST_WINDOWS_API is defined\n"; +#endif + cout << "BOOST_FILESYSTEM_DECL" << BOOST_STRINGIZE(=BOOST_FILESYSTEM_DECL) << "\n"; + cout << "BOOST_SYMBOL_VISIBLE" << BOOST_STRINGIZE(=BOOST_SYMBOL_VISIBLE) << "\n"; + + cout << "current_path() is " << current_path().string() << std::endl; + + query_test(); + directory_iterator_test(); + operations_test(); + directory_entry_test(); + directory_entry_overload_test(); + error_handling_test(); + + std::cout << unique_path() << std::endl; + std::cout << unique_path("foo-%%%%%-%%%%%-bar") << std::endl; + + return ::boost::report_errors(); +} diff --git a/v3/libs/filesystem/test/path_test.cpp b/v3/libs/filesystem/test/path_test.cpp new file mode 100644 index 0000000..c4cde71 --- /dev/null +++ b/v3/libs/filesystem/test/path_test.cpp @@ -0,0 +1,1693 @@ +// path_test program -----------------------------------------------------------------// + +// Copyright Beman Dawes 2002, 2008 +// Copyright Vladimir Prus 2002 + +// Use, modification, and distribution is subject to the Boost Software +// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// See library home page at http://www.boost.org/libs/filesystem + +// basic_path's stem(), extension(), and replace_extension() tests are based +// on basename(), extension(), and change_extension() tests from the original +// convenience_test.cpp by Vladimir Prus. + +#include + +// See deprecated_test for tests of deprecated features +#define BOOST_FILESYSTEM_NO_DEPRECATED + +#include +#include +#include +#include +#include +#include +#include +#include + +namespace fs = boost::filesystem; +using boost::filesystem::path; + +#include + +#define PATH_CHECK(a, b) check(a, b, __FILE__, __LINE__) +#define CHECK_EQUAL(a,b) check_equal(a, b, __FILE__, __LINE__) + +namespace +{ + std::string platform(BOOST_PLATFORM); + + void check(const fs::path & source, + const std::string & expected, const char* file, int line) + { + if (source.string() == expected) + return; + + std::cout << file + << '(' << line << "): source: \"" << source + << "\" != expected: \"" << expected + << "\"" << std::endl; + + ++::boost::detail::test_errors(); + } + + void check_equal(const fs::path & source, + const std::string & expected, const char* file, int line) + { + if (source == expected) return; + + ++::boost::detail::test_errors(); + + std::cout << file << '(' << line << "): source: \"" << source + << "\" != expected: \"" << expected + << "\"" << std::endl; + } + + path p1("fe/fi/fo/fum"); + path p2(p1); + path p3; + path p4("foobar"); + path p5; + + // exception_tests -----------------------------------------------------------------// + + void exception_tests() + { + std::cout << "exception_tests..." << std::endl; + const std::string str_1("string-1"); + boost::system::error_code ec(12345, boost::system::system_category()); + try { throw fs::filesystem_error(str_1, ec); } + catch (const fs::filesystem_error & ex) + { + //std::cout << ex.what() << "*" << std::endl; + //BOOST_TEST(std::strcmp(ex.what(), + // "string-1: Unknown error") == 0); + BOOST_TEST(ex.code() == ec); + } + + try { throw fs::filesystem_error(str_1, "p1", "p2", ec); } + catch (const fs::filesystem_error & ex) + { + //std::cout << ex.what() << "*" << std::endl; + //BOOST_TEST(std::strcmp(ex.what(), + // "string-1: Unknown error: \"p1\", \"p2\"") == 0); + BOOST_TEST(ex.code() == ec); + BOOST_TEST(ex.path1() == "p1"); + BOOST_TEST(ex.path2() == "p2"); + } + } + + // overload_tests ------------------------------------------------------------------// + + // These verify various overloads don't cause compiler errors + // They pre-date operations_unit_test.cpp + + void overload_tests() + { + std::cout << "overload_tests..." << std::endl; + + fs::exists(p1); + fs::exists("foo"); + fs::exists(std::string("foo")); + + fs::exists(p1 / path("foo")); + fs::exists(p1 / "foo"); + fs::exists(p1 / std::string("foo")); + + fs::exists("foo" / p1); + fs::exists(std::string("foo") / p1); + + p4 /= path("foo"); + p4 /= "foo"; + p4 /= std::string("foo"); + } + + // iterator_tests ------------------------------------------------------------------// + + void iterator_tests() + { + std::cout << "iterator_tests..." << std::endl; + + path itr_ck = ""; + path::const_iterator itr = itr_ck.begin(); + BOOST_TEST(itr == itr_ck.end()); + + itr_ck = "/"; + itr = itr_ck.begin(); + BOOST_TEST(*itr == std::string("/")); + BOOST_TEST(++itr == itr_ck.end()); + BOOST_TEST(*--itr == std::string("/")); + + itr_ck = "foo"; + BOOST_TEST(*itr_ck.begin() == std::string("foo")); + BOOST_TEST(boost::next(itr_ck.begin()) == itr_ck.end()); + BOOST_TEST(*boost::prior(itr_ck.end()) == std::string("foo")); + BOOST_TEST(boost::prior(itr_ck.end()) == itr_ck.begin()); + + itr_ck = path("/foo"); + BOOST_TEST(*itr_ck.begin() == std::string("/")); + BOOST_TEST(*boost::next(itr_ck.begin()) == std::string("foo")); + BOOST_TEST(boost::next(boost::next(itr_ck.begin())) == itr_ck.end()); + BOOST_TEST(boost::next(itr_ck.begin()) == boost::prior(itr_ck.end())); + BOOST_TEST(*boost::prior(itr_ck.end()) == std::string("foo")); + BOOST_TEST(*boost::prior(boost::prior(itr_ck.end())) == std::string("/")); + BOOST_TEST(boost::prior(boost::prior(itr_ck.end())) == itr_ck.begin()); + + itr_ck = "/foo/bar"; + itr = itr_ck.begin(); + BOOST_TEST(*itr == std::string("/")); + BOOST_TEST(*++itr == std::string("foo")); + BOOST_TEST(*++itr == std::string("bar")); + BOOST_TEST(++itr == itr_ck.end()); + CHECK_EQUAL(*--itr, "bar"); + CHECK_EQUAL(*--itr, "foo"); + CHECK_EQUAL(*--itr, "/"); + + itr_ck = "../f"; // previously failed due to short name bug + itr = itr_ck.begin(); + CHECK_EQUAL(*itr, ".."); + CHECK_EQUAL(*++itr, "f"); + BOOST_TEST(++itr == itr_ck.end()); + CHECK_EQUAL(*--itr, "f"); + CHECK_EQUAL(*--itr, ".."); + + // POSIX says treat "/foo/bar/" as "/foo/bar/." + itr_ck = "/foo/bar/"; + itr = itr_ck.begin(); + CHECK_EQUAL(*itr, "/"); + CHECK_EQUAL(*++itr, "foo"); + CHECK_EQUAL(*++itr, "bar"); + CHECK_EQUAL(*++itr, "."); + BOOST_TEST(++itr == itr_ck.end()); + CHECK_EQUAL(*--itr, "."); + CHECK_EQUAL(*--itr, "bar"); + CHECK_EQUAL(*--itr, "foo"); + CHECK_EQUAL(*--itr, "/"); + + // POSIX says treat "/f/b/" as "/f/b/." + itr_ck = "/f/b/"; + itr = itr_ck.begin(); + CHECK_EQUAL(*itr, "/"); + CHECK_EQUAL(*++itr, "f"); + CHECK_EQUAL(*++itr, "b"); + CHECK_EQUAL(*++itr, "."); + BOOST_TEST(++itr == itr_ck.end()); + CHECK_EQUAL(*--itr, "."); + CHECK_EQUAL(*--itr, "b"); + CHECK_EQUAL(*--itr, "f"); + CHECK_EQUAL(*--itr, "/"); + + itr_ck = "//net"; + itr = itr_ck.begin(); + // two leading slashes are permitted by POSIX (as implementation defined), + // while for Windows it is always well defined (as a network name) + CHECK_EQUAL(*itr, "//net"); + BOOST_TEST(++itr == itr_ck.end()); + CHECK_EQUAL(*--itr, "//net"); + + itr_ck = "//net/"; + itr = itr_ck.begin(); + CHECK_EQUAL(*itr, "//net"); + CHECK_EQUAL(*++itr, "/"); + BOOST_TEST(++itr == itr_ck.end()); + CHECK_EQUAL(*--itr, "/"); + CHECK_EQUAL(*--itr, "//net"); + + itr_ck = "//foo///bar///"; + itr = itr_ck.begin(); + CHECK_EQUAL(*itr, "//foo"); + CHECK_EQUAL(*++itr, "/"); + CHECK_EQUAL(*++itr, "bar"); + CHECK_EQUAL(*++itr, "."); + BOOST_TEST(++itr == itr_ck.end()); + CHECK_EQUAL(*--itr, "."); + CHECK_EQUAL(*--itr, "bar"); + CHECK_EQUAL(*--itr, "/"); + CHECK_EQUAL(*--itr, "//foo"); + + itr_ck = "///foo///bar///"; + itr = itr_ck.begin(); + // three or more leading slashes are to be treated as a single slash + CHECK_EQUAL(*itr, "/"); + CHECK_EQUAL(*++itr, "foo"); + CHECK_EQUAL(*++itr, "bar"); + CHECK_EQUAL(*++itr, "."); + BOOST_TEST(++itr == itr_ck.end()); + CHECK_EQUAL(*--itr, "."); + CHECK_EQUAL(*--itr, "bar"); + CHECK_EQUAL(*--itr, "foo"); + CHECK_EQUAL(*--itr, "/"); + + if (platform == "Windows") + { + itr_ck = "c:/"; + itr = itr_ck.begin(); + CHECK_EQUAL(*itr, "c:"); + CHECK_EQUAL(*++itr, "/"); + BOOST_TEST(++itr == itr_ck.end()); + CHECK_EQUAL(*--itr, "/"); + CHECK_EQUAL(*--itr, "c:"); + + itr_ck = "c:\\foo"; + itr = itr_ck.begin(); + BOOST_TEST(*itr == std::string("c:")); + BOOST_TEST(*++itr == std::string("/")); + BOOST_TEST(*++itr == std::string("foo")); + BOOST_TEST(++itr == itr_ck.end()); + BOOST_TEST(*--itr == std::string("foo")); + BOOST_TEST(*--itr == std::string("/")); + BOOST_TEST(*--itr == std::string("c:")); + + itr_ck = "\\\\\\foo\\\\\\bar\\\\\\"; + itr = itr_ck.begin(); + // three or more leading slashes are to be treated as a single slash + CHECK_EQUAL(*itr, "/"); + CHECK_EQUAL(*++itr, "foo"); + CHECK_EQUAL(*++itr, "bar"); + CHECK_EQUAL(*++itr, "."); + BOOST_TEST(++itr == itr_ck.end()); + CHECK_EQUAL(*--itr, "."); + CHECK_EQUAL(*--itr, "bar"); + CHECK_EQUAL(*--itr, "foo"); + CHECK_EQUAL(*--itr, "/"); + + itr_ck = "c:foo"; + itr = itr_ck.begin(); + BOOST_TEST(*itr == std::string("c:")); + BOOST_TEST(*++itr == std::string("foo")); + BOOST_TEST(++itr == itr_ck.end()); + BOOST_TEST(*--itr == std::string("foo")); + BOOST_TEST(*--itr == std::string("c:")); + + itr_ck = "c:foo/"; + itr = itr_ck.begin(); + BOOST_TEST(*itr == std::string("c:")); + BOOST_TEST(*++itr == std::string("foo")); + BOOST_TEST(*++itr == std::string(".")); + BOOST_TEST(++itr == itr_ck.end()); + BOOST_TEST(*--itr == std::string(".")); + BOOST_TEST(*--itr == std::string("foo")); + BOOST_TEST(*--itr == std::string("c:")); + + itr_ck = path("c:"); + BOOST_TEST(*itr_ck.begin() == std::string("c:")); + BOOST_TEST(next(itr_ck.begin()) == itr_ck.end()); + BOOST_TEST(prior(itr_ck.end()) == itr_ck.begin()); + BOOST_TEST(*prior(itr_ck.end()) == std::string("c:")); + + itr_ck = path("c:/"); + BOOST_TEST(*itr_ck.begin() == std::string("c:")); + BOOST_TEST(*next(itr_ck.begin()) == std::string("/")); + BOOST_TEST(next(next(itr_ck.begin())) == itr_ck.end()); + BOOST_TEST(prior(prior(itr_ck.end())) == itr_ck.begin()); + BOOST_TEST(*prior(itr_ck.end()) == std::string("/")); + BOOST_TEST(*prior(prior(itr_ck.end())) == std::string("c:")); + + itr_ck = path("c:foo"); + BOOST_TEST(*itr_ck.begin() == std::string("c:")); + BOOST_TEST(*next(itr_ck.begin()) == std::string("foo")); + BOOST_TEST(next(next(itr_ck.begin())) == itr_ck.end()); + BOOST_TEST(prior(prior(itr_ck.end())) == itr_ck.begin()); + BOOST_TEST(*prior(itr_ck.end()) == std::string("foo")); + BOOST_TEST(*prior(prior(itr_ck.end())) == std::string("c:")); + + itr_ck = path("c:/foo"); + BOOST_TEST(*itr_ck.begin() == std::string("c:")); + BOOST_TEST(*next(itr_ck.begin()) == std::string("/")); + BOOST_TEST(*next(next(itr_ck.begin())) == std::string("foo")); + BOOST_TEST(next(next(next(itr_ck.begin()))) == itr_ck.end()); + BOOST_TEST(prior(prior(prior(itr_ck.end()))) == itr_ck.begin()); + BOOST_TEST(*prior(itr_ck.end()) == std::string("foo")); + BOOST_TEST(*prior(prior(itr_ck.end())) == std::string("/")); + BOOST_TEST(*prior(prior(prior(itr_ck.end()))) == std::string("c:")); + + itr_ck = path("//net"); + BOOST_TEST(*itr_ck.begin() == std::string("//net")); + BOOST_TEST(next(itr_ck.begin()) == itr_ck.end()); + BOOST_TEST(prior(itr_ck.end()) == itr_ck.begin()); + BOOST_TEST(*prior(itr_ck.end()) == std::string("//net")); + + itr_ck = path("//net/"); + CHECK_EQUAL(*itr_ck.begin(), "//net"); + CHECK_EQUAL(*next(itr_ck.begin()), "/"); + BOOST_TEST(next(next(itr_ck.begin())) == itr_ck.end()); + BOOST_TEST(prior(prior(itr_ck.end())) == itr_ck.begin()); + CHECK_EQUAL(*prior(itr_ck.end()), "/"); + CHECK_EQUAL(*prior(prior(itr_ck.end())), "//net"); + + itr_ck = path("//net/foo"); + BOOST_TEST(*itr_ck.begin() == std::string("//net")); + BOOST_TEST(*next(itr_ck.begin()) == std::string("/")); + BOOST_TEST(*next(next(itr_ck.begin())) == std::string("foo")); + BOOST_TEST(next(next(next(itr_ck.begin()))) == itr_ck.end()); + BOOST_TEST(prior(prior(prior(itr_ck.end()))) == itr_ck.begin()); + BOOST_TEST(*prior(itr_ck.end()) == std::string("foo")); + BOOST_TEST(*prior(prior(itr_ck.end())) == std::string("/")); + BOOST_TEST(*prior(prior(prior(itr_ck.end()))) == std::string("//net")); + + itr_ck = path("prn:"); + BOOST_TEST(*itr_ck.begin() == std::string("prn:")); + BOOST_TEST(next(itr_ck.begin()) == itr_ck.end()); + BOOST_TEST(prior(itr_ck.end()) == itr_ck.begin()); + BOOST_TEST(*prior(itr_ck.end()) == std::string("prn:")); + } + else + { + itr_ck = "///"; + itr = itr_ck.begin(); + CHECK_EQUAL(*itr, "/"); + BOOST_TEST(++itr == itr_ck.end()); + } + } + + // non_member_tests ----------------------------------------------------------------// + + void non_member_tests() + { + std::cout << "non_member_tests..." << std::endl; + + // test non-member functions, particularly operator overloads + + path e, e2; + std::string es, es2; + char ecs[] = ""; + char ecs2[] = ""; + + char acs[] = "a"; + std::string as(acs); + path a(as); + + char acs2[] = "a"; + std::string as2(acs2); + path a2(as2); + + char bcs[] = "b"; + std::string bs(bcs); + path b(bs); + + // swap + a.swap(b); + BOOST_TEST(a.string() == "b"); + BOOST_TEST(b.string() == "a"); + fs::swap(a, b); + BOOST_TEST(a.string() == "a"); + BOOST_TEST(b.string() == "b"); + + // probe operator / + PATH_CHECK(path("") / ".", "."); + PATH_CHECK(path("") / "..", ".."); + if (platform == "Windows") + { + BOOST_TEST(path("foo\\bar") == "foo/bar"); + BOOST_TEST((b / a).string() == "b\\a"); + BOOST_TEST((bs / a).string() == "b\\a"); + BOOST_TEST((bcs / a).string() == "b\\a"); + BOOST_TEST((b / as).string() == "b\\a"); + BOOST_TEST((b / acs).string() == "b\\a"); + PATH_CHECK(path("a") / "b", "a\\b"); + PATH_CHECK(path("..") / "", ".."); + PATH_CHECK(path("foo") / path("bar"), "foo\\bar"); // path arg + PATH_CHECK(path("foo") / "bar", "foo\\bar"); // const char* arg + PATH_CHECK(path("foo") / path("woo/bar").filename(), "foo\\bar"); // const std::string & arg + PATH_CHECK("foo" / path("bar"), "foo\\bar"); + PATH_CHECK(path("..") / ".." , "..\\.."); + PATH_CHECK(path("/") / ".." , "/.."); + PATH_CHECK(path("/..") / ".." , "/..\\.."); + PATH_CHECK(path("..") / "foo" , "..\\foo"); + PATH_CHECK(path("foo") / ".." , "foo\\.."); + PATH_CHECK(path("..") / "f" , "..\\f"); + PATH_CHECK(path("/..") / "f" , "/..\\f"); + PATH_CHECK(path("f") / ".." , "f\\.."); + PATH_CHECK(path("foo") / ".." / ".." , "foo\\..\\.."); + PATH_CHECK(path("foo") / ".." / ".." / ".." , "foo\\..\\..\\.."); + PATH_CHECK(path("f") / ".." / "b" , "f\\..\\b"); + PATH_CHECK(path("foo") / ".." / "bar" , "foo\\..\\bar"); + PATH_CHECK(path("foo") / "bar" / ".." , "foo\\bar\\.."); + PATH_CHECK(path("foo") / "bar" / ".." / "..", "foo\\bar\\..\\.."); + PATH_CHECK(path("foo") / "bar" / ".." / "blah", "foo\\bar\\..\\blah"); + PATH_CHECK(path("f") / "b" / ".." , "f\\b\\.."); + PATH_CHECK(path("f") / "b" / ".." / "a", "f\\b\\..\\a"); + PATH_CHECK(path("foo") / "bar" / "blah" / ".." / "..", "foo\\bar\\blah\\..\\.."); + PATH_CHECK(path("foo") / "bar" / "blah" / ".." / ".." / "bletch", "foo\\bar\\blah\\..\\..\\bletch"); + + PATH_CHECK(path(".") / "foo", ".\\foo"); + PATH_CHECK(path(".") / "..", ".\\.."); + PATH_CHECK(path("foo") / ".", "foo\\."); + PATH_CHECK(path("..") / ".", "..\\."); + PATH_CHECK(path(".") / ".", ".\\."); + PATH_CHECK(path(".") / "." / ".", ".\\.\\."); + PATH_CHECK(path(".") / "foo" / ".", ".\\foo\\."); + PATH_CHECK(path("foo") / "." / "bar", "foo\\.\\bar"); + PATH_CHECK(path("foo") / "." / ".", "foo\\.\\."); + PATH_CHECK(path("foo") / "." / "..", "foo\\.\\.."); + PATH_CHECK(path(".") / "." / "..", ".\\.\\.."); + PATH_CHECK(path(".") / ".." / ".", ".\\..\\."); + PATH_CHECK(path("..") / "." / ".", "..\\.\\."); + } + else // POSIX + { + BOOST_TEST((b / a).string() == "b/a"); + BOOST_TEST((bs / a).string() == "b/a"); + BOOST_TEST((bcs / a).string() == "b/a"); + BOOST_TEST((b / as).string() == "b/a"); + BOOST_TEST((b / acs).string() == "b/a"); + PATH_CHECK(path("a") / "b", "a/b"); + PATH_CHECK(path("..") / "", ".."); + PATH_CHECK(path("") / "..", ".."); + PATH_CHECK(path("foo") / path("bar"), "foo/bar"); // path arg + PATH_CHECK(path("foo") / "bar", "foo/bar"); // const char* arg + PATH_CHECK(path("foo") / path("woo/bar").filename(), "foo/bar"); // const std::string & arg + PATH_CHECK("foo" / path("bar"), "foo/bar"); + PATH_CHECK(path("..") / ".." , "../.."); + PATH_CHECK(path("/") / ".." , "/.."); + PATH_CHECK(path("/..") / ".." , "/../.."); + PATH_CHECK(path("..") / "foo" , "../foo"); + PATH_CHECK(path("foo") / ".." , "foo/.."); + PATH_CHECK(path("..") / "f" , "../f"); + PATH_CHECK(path("/..") / "f" , "/../f"); + PATH_CHECK(path("f") / ".." , "f/.."); + PATH_CHECK(path("foo") / ".." / ".." , "foo/../.."); + PATH_CHECK(path("foo") / ".." / ".." / ".." , "foo/../../.."); + PATH_CHECK(path("f") / ".." / "b" , "f/../b"); + PATH_CHECK(path("foo") / ".." / "bar" , "foo/../bar"); + PATH_CHECK(path("foo") / "bar" / ".." , "foo/bar/.."); + PATH_CHECK(path("foo") / "bar" / ".." / "..", "foo/bar/../.."); + PATH_CHECK(path("foo") / "bar" / ".." / "blah", "foo/bar/../blah"); + PATH_CHECK(path("f") / "b" / ".." , "f/b/.."); + PATH_CHECK(path("f") / "b" / ".." / "a", "f/b/../a"); + PATH_CHECK(path("foo") / "bar" / "blah" / ".." / "..", "foo/bar/blah/../.."); + PATH_CHECK(path("foo") / "bar" / "blah" / ".." / ".." / "bletch", "foo/bar/blah/../../bletch"); + + PATH_CHECK(path(".") / "foo", "./foo"); + PATH_CHECK(path(".") / "..", "./.."); + PATH_CHECK(path("foo") / ".", "foo/."); + PATH_CHECK(path("..") / ".", "../."); + PATH_CHECK(path(".") / ".", "./."); + PATH_CHECK(path(".") / "." / ".", "././."); + PATH_CHECK(path(".") / "foo" / ".", "./foo/."); + PATH_CHECK(path("foo") / "." / "bar", "foo/./bar"); + PATH_CHECK(path("foo") / "." / ".", "foo/./."); + PATH_CHECK(path("foo") / "." / "..", "foo/./.."); + PATH_CHECK(path(".") / "." / "..", "././.."); + PATH_CHECK(path(".") / ".." / ".", "./../."); + PATH_CHECK(path("..") / "." / ".", ".././."); + } + + // probe operator < + BOOST_TEST(!(e < e2)); + BOOST_TEST(!(es < e2)); + BOOST_TEST(!(ecs < e2)); + BOOST_TEST(!(e < es2)); + BOOST_TEST(!(e < ecs2)); + + BOOST_TEST(e < a); + BOOST_TEST(es < a); + BOOST_TEST(ecs < a); + BOOST_TEST(e < as); + BOOST_TEST(e < acs); + + BOOST_TEST(a < b); + BOOST_TEST(as < b); + BOOST_TEST(acs < b); + BOOST_TEST(a < bs); + BOOST_TEST(a < bcs); + + BOOST_TEST(!(a < a2)); + BOOST_TEST(!(as < a2)); + BOOST_TEST(!(acs < a2)); + BOOST_TEST(!(a < as2)); + BOOST_TEST(!(a < acs2)); + + // make sure basic_path overloads don't conflict with std::string overloads + + BOOST_TEST(!(as < as)); + BOOST_TEST(!(as < acs)); + BOOST_TEST(!(acs < as)); + + // reality check character set is as expected + BOOST_TEST(std::string("a.b") < std::string("a/b")); + // verify compare is actually lexicographical + BOOST_TEST(path("a/b") < path("a.b")); + + // make sure the derivative operators also work + + BOOST_TEST(b > a); + BOOST_TEST(b > as); + BOOST_TEST(b > acs); + BOOST_TEST(bs > a); + BOOST_TEST(bcs > a); + + BOOST_TEST(!(a2 > a)); + BOOST_TEST(!(a2 > as)); + BOOST_TEST(!(a2 > acs)); + BOOST_TEST(!(as2 > a)); + BOOST_TEST(!(acs2 > a)); + + BOOST_TEST(a <= b); + BOOST_TEST(as <= b); + BOOST_TEST(acs <= b); + BOOST_TEST(a <= bs); + BOOST_TEST(a <= bcs); + + BOOST_TEST(a <= a2); + BOOST_TEST(as <= a2); + BOOST_TEST(acs <= a2); + BOOST_TEST(a <= as2); + BOOST_TEST(a <= acs2); + + BOOST_TEST(b >= a); + BOOST_TEST(bs >= a); + BOOST_TEST(bcs >= a); + BOOST_TEST(b >= as); + BOOST_TEST(b >= acs); + + BOOST_TEST(a2 >= a); + BOOST_TEST(as2 >= a); + BOOST_TEST(acs2 >= a); + BOOST_TEST(a2 >= as); + BOOST_TEST(a2 >= acs); + + // operator == and != are implemented separately, so test separately + + path p1("fe/fi/fo/fum"); + path p2(p1); + path p3("fe/fi/fo/fumm"); + BOOST_TEST(p1.string() != p3.string()); + + // check each overload + BOOST_TEST(p1 != p3); + BOOST_TEST(p1 != p3.string()); + BOOST_TEST(p1 != p3.string().c_str()); + BOOST_TEST(p1.string() != p3); + BOOST_TEST(p1.string().c_str() != p3); + + p3 = p2; + BOOST_TEST(p1.string() == p3.string()); + + // check each overload + BOOST_TEST(p1 == p3); + BOOST_TEST(p1 == p3.string()); + BOOST_TEST(p1 == p3.string().c_str()); + BOOST_TEST(p1.string() == p3); + BOOST_TEST(p1.string().c_str() == p3); + + if (platform == "Windows") + { + std::cout << "Windows relational tests..." << std::endl; + path p10 ("c:\\file"); + path p11 ("c:/file"); + // check each overload + BOOST_TEST(p10.generic_string() == p11.generic_string()); + BOOST_TEST(p10 == p11); + BOOST_TEST(p10 == p11.string()); + BOOST_TEST(p10 == p11.string().c_str()); + BOOST_TEST(p10.string() == p11); + BOOST_TEST(p10.string().c_str() == p11); + BOOST_TEST(p10 == L"c:\\file"); + BOOST_TEST(p10 == L"c:/file"); + BOOST_TEST(p11 == L"c:\\file"); + BOOST_TEST(p11 == L"c:/file"); + BOOST_TEST(L"c:\\file" == p10); + BOOST_TEST(L"c:/file" == p10); + BOOST_TEST(L"c:\\file" == p11); + BOOST_TEST(L"c:/file" == p11); + + BOOST_TEST(!(p10.generic_string() != p11.generic_string())); + BOOST_TEST(!(p10 != p11)); + BOOST_TEST(!(p10 != p11.string())); + BOOST_TEST(!(p10 != p11.string().c_str())); + BOOST_TEST(!(p10.string() != p11)); + BOOST_TEST(!(p10.string().c_str() != p11)); + BOOST_TEST(!(p10 != L"c:\\file")); + BOOST_TEST(!(p10 != L"c:/file")); + BOOST_TEST(!(p11 != L"c:\\file")); + BOOST_TEST(!(p11 != L"c:/file")); + BOOST_TEST(!(L"c:\\file" != p10)); + BOOST_TEST(!(L"c:/file" != p10)); + BOOST_TEST(!(L"c:\\file" != p11)); + BOOST_TEST(!(L"c:/file" != p11)); + + BOOST_TEST(!(p10.string() < p11.string())); + BOOST_TEST(!(p10 < p11)); + BOOST_TEST(!(p10 < p11.string())); + BOOST_TEST(!(p10 < p11.string().c_str())); + BOOST_TEST(!(p10.string() < p11)); + BOOST_TEST(!(p10.string().c_str() < p11)); + BOOST_TEST(!(p10 < L"c:\\file")); + BOOST_TEST(!(p10 < L"c:/file")); + BOOST_TEST(!(p11 < L"c:\\file")); + BOOST_TEST(!(p11 < L"c:/file")); + BOOST_TEST(!(L"c:\\file" < p10)); + BOOST_TEST(!(L"c:/file" < p10)); + BOOST_TEST(!(L"c:\\file" < p11)); + BOOST_TEST(!(L"c:/file" < p11)); + + BOOST_TEST(!(p10.generic_string() > p11.generic_string())); + BOOST_TEST(!(p10 > p11)); + BOOST_TEST(!(p10 > p11.string())); + BOOST_TEST(!(p10 > p11.string().c_str())); + BOOST_TEST(!(p10.string() > p11)); + BOOST_TEST(!(p10.string().c_str() > p11)); + BOOST_TEST(!(p10 > L"c:\\file")); + BOOST_TEST(!(p10 > L"c:/file")); + BOOST_TEST(!(p11 > L"c:\\file")); + BOOST_TEST(!(p11 > L"c:/file")); + BOOST_TEST(!(L"c:\\file" > p10)); + BOOST_TEST(!(L"c:/file" > p10)); + BOOST_TEST(!(L"c:\\file" > p11)); + BOOST_TEST(!(L"c:/file" > p11)); + } + } + + // query_and_decomposition_tests ---------------------------------------------------// + // + // remove_filename() is also tested here, because its specification depends on + // a decomposition function. + + void query_and_decomposition_tests() + { + std::cout << "query_and_decomposition_tests..." << std::endl; + + // stem() tests not otherwise covered + BOOST_TEST(path("b").stem() == "b"); + BOOST_TEST(path("a/b.txt").stem() == "b"); + BOOST_TEST(path("a/b.").stem() == "b"); + BOOST_TEST(path("a.b.c").stem() == "a.b"); + BOOST_TEST(path("a.b.c.").stem() == "a.b.c"); + + // extension() tests not otherwise covered + BOOST_TEST(path("a/b").extension() == ""); + BOOST_TEST(path("a/b.txt").extension() == ".txt"); + BOOST_TEST(path("a/b.").extension() == "."); + BOOST_TEST(path("a.b.c").extension() == ".c"); + BOOST_TEST(path("a.b.c.").extension() == "."); + BOOST_TEST(path("a/").extension() == ""); + + // main q & d test sequence + path p; + path q; + + p = q = ""; + BOOST_TEST(p.relative_path().string() == ""); + BOOST_TEST(p.parent_path().string() == ""); + BOOST_TEST_EQ(q.remove_filename().string(), p.parent_path().string()); + BOOST_TEST(p.filename() == ""); + BOOST_TEST(p.stem() == ""); + BOOST_TEST(p.extension() == ""); + BOOST_TEST(p.root_name() == ""); + BOOST_TEST(p.root_directory() == ""); + BOOST_TEST(p.root_path().string() == ""); + BOOST_TEST(!p.has_root_path()); + BOOST_TEST(!p.has_root_name()); + BOOST_TEST(!p.has_root_directory()); + BOOST_TEST(!p.has_relative_path()); + BOOST_TEST(!p.has_filename()); + BOOST_TEST(!p.has_stem()); + BOOST_TEST(!p.has_extension()); + BOOST_TEST(!p.has_parent_path()); + BOOST_TEST(!p.is_absolute()); + + p = q = "/"; + BOOST_TEST(p.relative_path().string() == ""); + BOOST_TEST(p.parent_path().string() == ""); + BOOST_TEST_EQ(q.remove_filename().string(), p.parent_path().string()); + BOOST_TEST(p.filename() == "/"); + BOOST_TEST(p.stem() == "/"); + BOOST_TEST(p.extension() == ""); + BOOST_TEST(p.root_name() == ""); + BOOST_TEST(p.root_directory() == "/"); + BOOST_TEST(p.root_path().string() == "/"); + BOOST_TEST(p.has_root_path()); + BOOST_TEST(!p.has_root_name()); + BOOST_TEST(p.has_root_directory()); + BOOST_TEST(!p.has_relative_path()); + BOOST_TEST(p.has_filename()); + BOOST_TEST(p.has_stem()); + BOOST_TEST(!p.has_extension()); + BOOST_TEST(!p.has_parent_path()); + if (platform == "POSIX") + BOOST_TEST(p.is_absolute()); + else + BOOST_TEST(!p.is_absolute()); + + p = q = "//"; + CHECK_EQUAL(p.relative_path().string(), ""); + CHECK_EQUAL(p.parent_path().string(), ""); + BOOST_TEST_EQ(q.remove_filename().string(), p.parent_path().string()); + CHECK_EQUAL(p.filename(), "//"); + CHECK_EQUAL(p.stem(), "//"); + CHECK_EQUAL(p.extension(), ""); + CHECK_EQUAL(p.root_name(), "//"); + CHECK_EQUAL(p.root_directory(), ""); + CHECK_EQUAL(p.root_path().string(), "//"); + BOOST_TEST(p.has_root_path()); + BOOST_TEST(p.has_root_name()); + BOOST_TEST(!p.has_root_directory()); + BOOST_TEST(!p.has_relative_path()); + BOOST_TEST(p.has_filename()); + BOOST_TEST(p.has_stem()); + BOOST_TEST(!p.has_extension()); + BOOST_TEST(!p.has_parent_path()); + BOOST_TEST(!p.is_absolute()); + + p = q = "///"; + CHECK_EQUAL(p.relative_path().string(), ""); + CHECK_EQUAL(p.parent_path().string(), ""); + BOOST_TEST_EQ(q.remove_filename().string(), p.parent_path().string()); + CHECK_EQUAL(p.filename(), "/"); + CHECK_EQUAL(p.stem(), "/"); + CHECK_EQUAL(p.extension(), ""); + CHECK_EQUAL(p.root_name(), ""); + CHECK_EQUAL(p.root_directory(), "/"); + CHECK_EQUAL(p.root_path().string(), "/"); + BOOST_TEST(p.has_root_path()); + BOOST_TEST(!p.has_root_name()); + BOOST_TEST(p.has_root_directory()); + BOOST_TEST(!p.has_relative_path()); + BOOST_TEST(p.has_filename()); + BOOST_TEST(p.has_stem()); + BOOST_TEST(!p.has_extension()); + BOOST_TEST(!p.has_parent_path()); + if (platform == "POSIX") + BOOST_TEST(p.is_absolute()); + else + BOOST_TEST(!p.is_absolute()); + + p = q = "."; + BOOST_TEST(p.relative_path().string() == "."); + BOOST_TEST(p.parent_path().string() == ""); + BOOST_TEST_EQ(q.remove_filename().string(), p.parent_path().string()); + BOOST_TEST(p.filename() == "."); + BOOST_TEST(p.stem() == "."); + BOOST_TEST(p.extension() == ""); + BOOST_TEST(p.root_name() == ""); + BOOST_TEST(p.root_directory() == ""); + BOOST_TEST(p.root_path().string() == ""); + BOOST_TEST(!p.has_root_path()); + BOOST_TEST(!p.has_root_name()); + BOOST_TEST(!p.has_root_directory()); + BOOST_TEST(p.has_relative_path()); + BOOST_TEST(p.has_filename()); + BOOST_TEST(p.has_stem()); + BOOST_TEST(!p.has_extension()); + BOOST_TEST(!p.has_parent_path()); + BOOST_TEST(!p.is_absolute()); + + p = q = ".."; + BOOST_TEST(p.relative_path().string() == ".."); + BOOST_TEST(p.parent_path().string() == ""); + BOOST_TEST_EQ(q.remove_filename().string(), p.parent_path().string()); + BOOST_TEST(p.filename() == ".."); + BOOST_TEST(p.stem() == ".."); + BOOST_TEST(p.extension() == ""); + BOOST_TEST(p.root_name() == ""); + BOOST_TEST(p.root_directory() == ""); + BOOST_TEST(p.root_path().string() == ""); + BOOST_TEST(!p.has_root_path()); + BOOST_TEST(!p.has_root_name()); + BOOST_TEST(!p.has_root_directory()); + BOOST_TEST(p.has_relative_path()); + BOOST_TEST(p.has_filename()); + BOOST_TEST(p.has_stem()); + BOOST_TEST(!p.has_extension()); + BOOST_TEST(!p.has_parent_path()); + BOOST_TEST(!p.is_absolute()); + + p = q = "foo"; + BOOST_TEST(p.relative_path().string() == "foo"); + BOOST_TEST(p.parent_path().string() == ""); + BOOST_TEST_EQ(q.remove_filename().string(), p.parent_path().string()); + BOOST_TEST(p.filename() == "foo"); + BOOST_TEST(p.stem() == "foo"); + BOOST_TEST(p.extension() == ""); + BOOST_TEST(p.root_name() == ""); + BOOST_TEST(p.root_directory() == ""); + BOOST_TEST(p.root_path().string() == ""); + BOOST_TEST(!p.has_root_path()); + BOOST_TEST(!p.has_root_name()); + BOOST_TEST(!p.has_root_directory()); + BOOST_TEST(p.has_relative_path()); + BOOST_TEST(p.has_filename()); + BOOST_TEST(p.has_stem()); + BOOST_TEST(!p.has_extension()); + BOOST_TEST(!p.has_parent_path()); + BOOST_TEST(!p.is_absolute()); + + p = q = "/foo"; + CHECK_EQUAL(p.relative_path().string(), "foo"); + CHECK_EQUAL(p.parent_path().string(), "/"); + BOOST_TEST_EQ(q.remove_filename().string(), p.parent_path().string()); + CHECK_EQUAL(p.filename(), "foo"); + CHECK_EQUAL(p.stem(), "foo"); + CHECK_EQUAL(p.extension(), ""); + CHECK_EQUAL(p.root_name(), ""); + CHECK_EQUAL(p.root_directory(), "/"); + CHECK_EQUAL(p.root_path().string(), "/"); + BOOST_TEST(p.has_root_path()); + BOOST_TEST(!p.has_root_name()); + BOOST_TEST(p.has_root_directory()); + BOOST_TEST(p.has_relative_path()); + BOOST_TEST(p.has_filename()); + BOOST_TEST(p.has_stem()); + BOOST_TEST(!p.has_extension()); + BOOST_TEST(p.has_parent_path()); + if (platform == "POSIX") + BOOST_TEST(p.is_absolute()); + else + BOOST_TEST(!p.is_absolute()); + + p = q = "/foo/"; + CHECK_EQUAL(p.relative_path().string(), "foo/"); + CHECK_EQUAL(p.parent_path().string(), "/foo"); + BOOST_TEST_EQ(q.remove_filename().string(), p.parent_path().string()); + CHECK_EQUAL(p.filename(), "."); + CHECK_EQUAL(p.stem(), "."); + CHECK_EQUAL(p.extension(), ""); + CHECK_EQUAL(p.root_name(), ""); + CHECK_EQUAL(p.root_directory(), "/"); + CHECK_EQUAL(p.root_path().string(), "/"); + BOOST_TEST(p.has_root_path()); + BOOST_TEST(!p.has_root_name()); + BOOST_TEST(p.has_root_directory()); + BOOST_TEST(p.has_relative_path()); + BOOST_TEST(p.has_filename()); + BOOST_TEST(p.has_stem()); + BOOST_TEST(!p.has_extension()); + BOOST_TEST(p.has_parent_path()); + if (platform == "POSIX") + BOOST_TEST(p.is_absolute()); + else + BOOST_TEST(!p.is_absolute()); + + p = q = "///foo"; + CHECK_EQUAL(p.relative_path().string(), "foo"); + CHECK_EQUAL(p.parent_path().string(), "/"); + BOOST_TEST_EQ(q.remove_filename().string(), p.parent_path().string()); + CHECK_EQUAL(p.filename(), "foo"); + CHECK_EQUAL(p.root_name(), ""); + CHECK_EQUAL(p.root_directory(), "/"); + CHECK_EQUAL(p.root_path().string(), "/"); + BOOST_TEST(p.has_root_path()); + BOOST_TEST(!p.has_root_name()); + BOOST_TEST(p.has_root_directory()); + BOOST_TEST(p.has_relative_path()); + BOOST_TEST(p.has_filename()); + BOOST_TEST(p.has_parent_path()); + if (platform == "POSIX") + BOOST_TEST(p.is_absolute()); + else + BOOST_TEST(!p.is_absolute()); + + p = q = "foo/bar"; + BOOST_TEST(p.relative_path().string() == "foo/bar"); + BOOST_TEST(p.parent_path().string() == "foo"); + BOOST_TEST_EQ(q.remove_filename().string(), p.parent_path().string()); + BOOST_TEST(p.filename() == "bar"); + BOOST_TEST(p.stem() == "bar"); + BOOST_TEST(p.extension() == ""); + BOOST_TEST(p.root_name() == ""); + BOOST_TEST(p.root_directory() == ""); + BOOST_TEST(p.root_path().string() == ""); + BOOST_TEST(!p.has_root_path()); + BOOST_TEST(!p.has_root_name()); + BOOST_TEST(!p.has_root_directory()); + BOOST_TEST(p.has_relative_path()); + BOOST_TEST(p.has_filename()); + BOOST_TEST(p.has_stem()); + BOOST_TEST(!p.has_extension()); + BOOST_TEST(p.has_parent_path()); + BOOST_TEST(!p.is_absolute()); + + p = q = "../foo"; + BOOST_TEST(p.relative_path().string() == "../foo"); + BOOST_TEST(p.parent_path().string() == ".."); + BOOST_TEST_EQ(q.remove_filename().string(), p.parent_path().string()); + BOOST_TEST(p.filename() == "foo"); + BOOST_TEST(p.root_name() == ""); + BOOST_TEST(p.root_directory() == ""); + BOOST_TEST(p.root_path().string() == ""); + BOOST_TEST(!p.has_root_path()); + BOOST_TEST(!p.has_root_name()); + BOOST_TEST(!p.has_root_directory()); + BOOST_TEST(p.has_relative_path()); + BOOST_TEST(p.has_filename()); + BOOST_TEST(p.has_parent_path()); + BOOST_TEST(!p.is_absolute()); + + p = q = "..///foo"; + CHECK_EQUAL(p.relative_path().string(), "..///foo"); + CHECK_EQUAL(p.parent_path().string(), ".."); + BOOST_TEST_EQ(q.remove_filename().string(), p.parent_path().string()); + CHECK_EQUAL(p.filename(), "foo"); + CHECK_EQUAL(p.root_name(), ""); + CHECK_EQUAL(p.root_directory(), ""); + CHECK_EQUAL(p.root_path().string(), ""); + BOOST_TEST(!p.has_root_path()); + BOOST_TEST(!p.has_root_name()); + BOOST_TEST(!p.has_root_directory()); + BOOST_TEST(p.has_relative_path()); + BOOST_TEST(p.has_filename()); + BOOST_TEST(p.has_parent_path()); + BOOST_TEST(!p.is_absolute()); + + p = q = "/foo/bar"; + BOOST_TEST(p.relative_path().string() == "foo/bar"); + BOOST_TEST(p.parent_path().string() == "/foo"); + BOOST_TEST_EQ(q.remove_filename().string(), p.parent_path().string()); + BOOST_TEST(p.filename() == "bar"); + BOOST_TEST(p.root_name() == ""); + BOOST_TEST(p.root_directory() == "/"); + BOOST_TEST(p.root_path().string() == "/"); + BOOST_TEST(p.has_root_path()); + BOOST_TEST(!p.has_root_name()); + BOOST_TEST(p.has_root_directory()); + BOOST_TEST(p.has_relative_path()); + BOOST_TEST(p.has_filename()); + BOOST_TEST(p.has_parent_path()); + if (platform == "POSIX") + BOOST_TEST(p.is_absolute()); + else + BOOST_TEST(!p.is_absolute()); + + // Both POSIX and Windows allow two leading slashs + // (POSIX meaning is implementation defined) + PATH_CHECK(path("//resource"), "//resource"); + PATH_CHECK(path("//resource/"), "//resource/"); + PATH_CHECK(path("//resource/foo"), "//resource/foo"); + + p = q = path("//net"); + CHECK_EQUAL(p.string(), "//net"); + CHECK_EQUAL(p.relative_path().string(), ""); + BOOST_TEST_EQ(q.remove_filename().string(), p.parent_path().string()); + CHECK_EQUAL(p.parent_path().string(), ""); + CHECK_EQUAL(p.filename(), "//net"); + CHECK_EQUAL(p.root_name(), "//net"); + CHECK_EQUAL(p.root_directory(), ""); + CHECK_EQUAL(p.root_path().string(), "//net"); + BOOST_TEST(p.has_root_path()); + BOOST_TEST(p.has_root_name()); + BOOST_TEST(!p.has_root_directory()); + BOOST_TEST(!p.has_relative_path()); + BOOST_TEST(p.has_filename()); + BOOST_TEST(!p.has_parent_path()); + BOOST_TEST(!p.is_absolute()); + + p = q = path("//net/"); + BOOST_TEST(p.relative_path().string() == ""); + BOOST_TEST(p.parent_path().string() == "//net"); + BOOST_TEST_EQ(q.remove_filename().string(), p.parent_path().string()); + BOOST_TEST(p.filename() == "/"); + BOOST_TEST(p.root_name() == "//net"); + BOOST_TEST(p.root_directory() == "/"); + BOOST_TEST(p.root_path().string() == "//net/"); + BOOST_TEST(p.has_root_path()); + BOOST_TEST(p.has_root_name()); + BOOST_TEST(p.has_root_directory()); + BOOST_TEST(!p.has_relative_path()); + BOOST_TEST(p.has_filename()); + BOOST_TEST(p.has_parent_path()); + BOOST_TEST(p.is_absolute()); + + p = q = path("//net/foo"); + BOOST_TEST(p.relative_path().string() == "foo"); + BOOST_TEST(p.parent_path().string() == "//net/"); + BOOST_TEST_EQ(q.remove_filename().string(), p.parent_path().string()); + BOOST_TEST(p.filename() == "foo"); + BOOST_TEST(p.root_name() == "//net"); + BOOST_TEST(p.root_directory() == "/"); + BOOST_TEST(p.root_path().string() == "//net/"); + BOOST_TEST(p.has_root_path()); + BOOST_TEST(p.has_root_name()); + BOOST_TEST(p.has_root_directory()); + BOOST_TEST(p.has_relative_path()); + BOOST_TEST(p.has_filename()); + BOOST_TEST(p.has_parent_path()); + BOOST_TEST(p.is_absolute()); + + p = q = path("//net///foo"); + CHECK_EQUAL(p.relative_path().string(), "foo"); + CHECK_EQUAL(p.parent_path().string(), "//net/"); + BOOST_TEST_EQ(q.remove_filename().string(), p.parent_path().string()); + CHECK_EQUAL(p.filename(), "foo"); + CHECK_EQUAL(p.root_name(), "//net"); + CHECK_EQUAL(p.root_directory(), "/"); + CHECK_EQUAL(p.root_path().string(), "//net/"); + BOOST_TEST(p.has_root_path()); + BOOST_TEST(p.has_root_name()); + BOOST_TEST(p.has_root_directory()); + BOOST_TEST(p.has_relative_path()); + BOOST_TEST(p.has_filename()); + BOOST_TEST(p.has_parent_path()); + BOOST_TEST(p.is_absolute()); + + if (platform == "Windows") + { + + p = q = path("c:"); + BOOST_TEST(p.relative_path().string() == ""); + BOOST_TEST(p.parent_path().string() == ""); + BOOST_TEST_EQ(q.remove_filename().string(), p.parent_path().string()); + BOOST_TEST(p.filename() == "c:"); + BOOST_TEST(p.root_name() == "c:"); + BOOST_TEST(p.root_directory() == ""); + BOOST_TEST(p.root_path().string() == "c:"); + BOOST_TEST(p.has_root_path()); + BOOST_TEST(p.has_root_name()); + BOOST_TEST(!p.has_root_directory()); + BOOST_TEST(!p.has_relative_path()); + BOOST_TEST(p.has_filename()); + BOOST_TEST(!p.has_parent_path()); + BOOST_TEST(!p.is_absolute()); + + p = q = path("c:foo"); + BOOST_TEST(p.relative_path().string() == "foo"); + BOOST_TEST(p.parent_path().string() == "c:"); + BOOST_TEST_EQ(q.remove_filename().string(), p.parent_path().string()); + BOOST_TEST(p.filename() == "foo"); + BOOST_TEST(p.root_name() == "c:"); + BOOST_TEST(p.root_directory() == ""); + BOOST_TEST(p.root_path().string() == "c:"); + BOOST_TEST(p.has_root_path()); + BOOST_TEST(p.has_root_name()); + BOOST_TEST(!p.has_root_directory()); + BOOST_TEST(p.has_relative_path()); + BOOST_TEST(p.has_filename()); + BOOST_TEST(p.has_parent_path()); + BOOST_TEST(!p.is_absolute()); + + p = q = path("c:/"); + BOOST_TEST(p.relative_path().string() == ""); + BOOST_TEST(p.parent_path().string() == "c:"); + BOOST_TEST_EQ(q.remove_filename().string(), p.parent_path().string()); + BOOST_TEST(p.filename() == "/"); + BOOST_TEST(p.root_name() == "c:"); + BOOST_TEST(p.root_directory() == "/"); + BOOST_TEST(p.root_path().string() == "c:/"); + BOOST_TEST(p.has_root_path()); + BOOST_TEST(p.has_root_name()); + BOOST_TEST(p.has_root_directory()); + BOOST_TEST(!p.has_relative_path()); + BOOST_TEST(p.has_filename()); + BOOST_TEST(p.has_parent_path()); + BOOST_TEST(p.is_absolute()); + + p = q = path("c:.."); + BOOST_TEST(p.relative_path().string() == ".."); + BOOST_TEST(p.parent_path().string() == "c:"); + BOOST_TEST_EQ(q.remove_filename().string(), p.parent_path().string()); + BOOST_TEST(p.filename() == ".."); + BOOST_TEST(p.root_name() == "c:"); + BOOST_TEST(p.root_directory() == ""); + BOOST_TEST(p.root_path().string() == "c:"); + BOOST_TEST(p.has_root_path()); + BOOST_TEST(p.has_root_name()); + BOOST_TEST(!p.has_root_directory()); + BOOST_TEST(p.has_relative_path()); + BOOST_TEST(p.has_filename()); + BOOST_TEST(p.has_parent_path()); + BOOST_TEST(!p.is_absolute()); + + p = q = path("c:/foo"); + CHECK_EQUAL(p.relative_path().string(), "foo"); + CHECK_EQUAL(p.parent_path().string(), "c:/"); + BOOST_TEST_EQ(q.remove_filename().string(), p.parent_path().string()); + CHECK_EQUAL(p.filename(), "foo"); + CHECK_EQUAL(p.root_name(), "c:"); + CHECK_EQUAL(p.root_directory(), "/"); + CHECK_EQUAL(p.root_path().string(), "c:/"); + BOOST_TEST(p.has_root_path()); + BOOST_TEST(p.has_root_name()); + BOOST_TEST(p.has_root_directory()); + BOOST_TEST(p.has_relative_path()); + BOOST_TEST(p.has_filename()); + BOOST_TEST(p.has_parent_path()); + BOOST_TEST(p.is_absolute()); + + p = q = path("c://foo"); + CHECK_EQUAL(p.relative_path().string(), "foo"); + CHECK_EQUAL(p.parent_path().string(), "c:/"); + BOOST_TEST_EQ(q.remove_filename().string(), p.parent_path().string()); + CHECK_EQUAL(p.filename(), "foo"); + CHECK_EQUAL(p.root_name(), "c:"); + CHECK_EQUAL(p.root_directory(), "/"); + CHECK_EQUAL(p.root_path().string(), "c:/"); + BOOST_TEST(p.has_root_path()); + BOOST_TEST(p.has_root_name()); + BOOST_TEST(p.has_root_directory()); + BOOST_TEST(p.has_relative_path()); + BOOST_TEST(p.has_filename()); + BOOST_TEST(p.has_parent_path()); + BOOST_TEST(p.is_absolute()); + + p = q = path("c:\\foo\\bar"); + CHECK_EQUAL(p.relative_path().string(), "foo\\bar"); + CHECK_EQUAL(p.parent_path().string(), "c:\\foo"); + BOOST_TEST_EQ(q.remove_filename().string(), p.parent_path().string()); + CHECK_EQUAL(p.filename(), "bar"); + CHECK_EQUAL(p.root_name(), "c:"); + CHECK_EQUAL(p.root_directory(), "\\"); + CHECK_EQUAL(p.root_path().string(), "c:\\"); + BOOST_TEST(p.has_root_path()); + BOOST_TEST(p.has_root_name()); + BOOST_TEST(p.has_root_directory()); + BOOST_TEST(p.has_relative_path()); + BOOST_TEST(p.has_filename()); + BOOST_TEST(p.has_parent_path()); + BOOST_TEST(p.is_absolute()); + + p = q = path("prn:"); + BOOST_TEST(p.relative_path().string() == ""); + BOOST_TEST(p.parent_path().string() == ""); + BOOST_TEST_EQ(q.remove_filename().string(), p.parent_path().string()); + BOOST_TEST(p.filename() == "prn:"); + BOOST_TEST(p.root_name() == "prn:"); + BOOST_TEST(p.root_directory() == ""); + BOOST_TEST(p.root_path().string() == "prn:"); + BOOST_TEST(p.has_root_path()); + BOOST_TEST(p.has_root_name()); + BOOST_TEST(!p.has_root_directory()); + BOOST_TEST(!p.has_relative_path()); + BOOST_TEST(p.has_filename()); + BOOST_TEST(!p.has_parent_path()); + BOOST_TEST(!p.is_absolute()); + + p = q = path("\\\\net\\\\\\foo"); + CHECK_EQUAL(p.relative_path().string(), "foo"); + CHECK_EQUAL(p.parent_path().string(), "\\\\net\\"); + BOOST_TEST_EQ(q.remove_filename().string(), p.parent_path().string()); + CHECK_EQUAL(p.filename(), "foo"); + CHECK_EQUAL(p.root_name(), "\\\\net"); + CHECK_EQUAL(p.root_directory(), "\\"); + CHECK_EQUAL(p.root_path().string(), "\\\\net\\"); + BOOST_TEST(p.has_root_path()); + BOOST_TEST(p.has_root_name()); + BOOST_TEST(p.has_root_directory()); + BOOST_TEST(p.has_relative_path()); + BOOST_TEST(p.has_filename()); + BOOST_TEST(p.has_parent_path()); + BOOST_TEST(p.is_absolute()); + } // Windows + + else + { // POSIX + PATH_CHECK(path("/foo/bar/"), "/foo/bar/"); + PATH_CHECK(path("//foo//bar//"), "//foo//bar//"); + PATH_CHECK(path("///foo///bar///"), "///foo///bar///"); + + p = path("/usr/local/bin:/usr/bin:/bin"); + BOOST_TEST(p.string() == "/usr/local/bin:/usr/bin:/bin"); + } // POSIX + } + + // composition_tests ----------------------------------------------------------------// + + void composition_tests() + { + std::cout << "composition_tests..." << std::endl; + + // these are white box tests constructed with knowledge of execution paths + + // *this.empty() + BOOST_TEST_EQ(path().make_absolute("//foo/bar"), "//foo/bar"); + if (platform == "Windows") + BOOST_TEST_EQ(path().make_absolute("a:/bar"), "a:/bar"); + + // *this.has_root_name() + // *this.has_root_directory() + BOOST_TEST_EQ(path("//foo/bar").make_absolute("//uvw/xyz"), "//foo/bar"); + if (platform == "Windows") + BOOST_TEST_EQ(path("a:/bar").make_absolute("b:/xyz"), "a:/bar"); + // !*this.has_root_directory() + BOOST_TEST_EQ(path("//net").make_absolute("//xyz/"), "//net/"); + BOOST_TEST_EQ(path("//net").make_absolute("//xyz/abc"), "//net/abc"); + BOOST_TEST_EQ(path("//net").make_absolute("//xyz/abc/def"), "//net/abc/def"); + if (platform == "Windows") + { + BOOST_TEST_EQ(path("a:").make_absolute("b:/"), "a:/"); + BOOST_TEST_EQ(path("a:").make_absolute("b:/abc"), "a:/abc"); + BOOST_TEST_EQ(path("a:").make_absolute("b:/abc/def"), "a:/abc/def"); + BOOST_TEST_EQ(path("a:foo").make_absolute("b:/"), "a:/foo"); + BOOST_TEST_EQ(path("a:foo").make_absolute("b:/abc"), "a:/abc/foo"); + BOOST_TEST_EQ(path("a:foo").make_absolute("b:/abc/def"), "a:/abc/def/foo"); + BOOST_TEST_EQ(path("a:foo/bar").make_absolute("b:/"), "a:/foo/bar"); + BOOST_TEST_EQ(path("a:foo/bar").make_absolute("b:/abc"), "a:/abc/foo/bar"); + BOOST_TEST_EQ(path("a:foo/bar").make_absolute("b:/abc/def"), "a:/abc/def/foo/bar"); + } + // !*this.has_root_name() + // *this.has_root_directory() + BOOST_TEST_EQ(path("/").make_absolute("//xyz/"), "//xyz/"); + BOOST_TEST_EQ(path("/").make_absolute("//xyz/abc"), "//xyz/"); + BOOST_TEST_EQ(path("/foo").make_absolute("//xyz/"), "//xyz/foo"); + BOOST_TEST_EQ(path("/foo").make_absolute("//xyz/abc"), "//xyz/foo"); + // !*this.has_root_directory() + BOOST_TEST_EQ(path("foo").make_absolute("//xyz/abc"), "//xyz/abc/foo"); + BOOST_TEST_EQ(path("foo/bar").make_absolute("//xyz/abc"), "//xyz/abc/foo/bar"); + BOOST_TEST_EQ(path(".").make_absolute("//xyz/abc"), "//xyz/abc/."); + BOOST_TEST_EQ(path("..").make_absolute("//xyz/abc"), "//xyz/abc/.."); + BOOST_TEST_EQ(path("./foo").make_absolute("//xyz/abc"), "//xyz/abc/./foo"); + BOOST_TEST_EQ(path("../foo").make_absolute("//xyz/abc"), "//xyz/abc/../foo"); + if (platform == "POSIX") + { + BOOST_TEST_EQ(path("foo").make_absolute("/abc"), "/abc/foo"); + BOOST_TEST_EQ(path("foo/bar").make_absolute("/abc"), "/abc/foo/bar"); + BOOST_TEST_EQ(path(".").make_absolute("/abc"), "/abc/."); + BOOST_TEST_EQ(path("..").make_absolute("/abc"), "/abc/.."); + BOOST_TEST_EQ(path("./foo").make_absolute("/abc"), "/abc/./foo"); + BOOST_TEST_EQ(path("../foo").make_absolute("/abc"), "/abc/../foo"); + } + } + + // construction_tests ---------------------------------------------------------------// + + void construction_tests() + { + std::cout << "construction_tests..." << std::endl; + + PATH_CHECK("", ""); + + PATH_CHECK("foo", "foo"); + PATH_CHECK("f", "f"); + + PATH_CHECK("foo/", "foo/"); + PATH_CHECK("f/", "f/"); + PATH_CHECK("foo/..", "foo/.."); + PATH_CHECK("foo/../", "foo/../"); + PATH_CHECK("foo/bar/../..", "foo/bar/../.."); + PATH_CHECK("foo/bar/../../", "foo/bar/../../"); + PATH_CHECK(path("/"), "/"); + PATH_CHECK(path("/f"), "/f"); + + PATH_CHECK("/foo", "/foo"); + PATH_CHECK(path("/foo/bar/"), "/foo/bar/"); + PATH_CHECK(path("//foo//bar//"), "//foo//bar//"); + PATH_CHECK(path("///foo///bar///"), "///foo///bar///"); + PATH_CHECK(path("\\/foo\\/bar\\/"), "\\/foo\\/bar\\/"); + PATH_CHECK(path("\\//foo\\//bar\\//"), "\\//foo\\//bar\\//"); + + if (platform == "Windows") + { + PATH_CHECK(path("c:") / "foo", "c:foo"); + PATH_CHECK(path("c:") / "/foo", "c:/foo"); + + PATH_CHECK(path("\\foo\\bar\\"), "\\foo\\bar\\"); + PATH_CHECK(path("\\\\foo\\\\bar\\\\"), "\\\\foo\\\\bar\\\\"); + PATH_CHECK(path("\\\\\\foo\\\\\\bar\\\\\\"), "\\\\\\foo\\\\\\bar\\\\\\"); + + PATH_CHECK(path("\\"), "\\"); + PATH_CHECK(path("\\f"), "\\f"); + PATH_CHECK(path("\\foo"), "\\foo"); + PATH_CHECK(path("foo\\bar"), "foo\\bar"); + PATH_CHECK(path("foo bar"), "foo bar"); + PATH_CHECK(path("c:"), "c:"); + PATH_CHECK(path("c:/"), "c:/"); + PATH_CHECK(path("c:."), "c:."); + PATH_CHECK(path("c:./foo"), "c:./foo"); + PATH_CHECK(path("c:.\\foo"), "c:.\\foo"); + PATH_CHECK(path("c:.."), "c:.."); + PATH_CHECK(path("c:/."), "c:/."); + PATH_CHECK(path("c:/.."), "c:/.."); + PATH_CHECK(path("c:/../"), "c:/../"); + PATH_CHECK(path("c:\\..\\"), "c:\\..\\"); + PATH_CHECK(path("c:/../.."), "c:/../.."); + PATH_CHECK(path("c:/../foo"), "c:/../foo"); + PATH_CHECK(path("c:\\..\\foo"), "c:\\..\\foo"); + PATH_CHECK(path("c:../foo"), "c:../foo"); + PATH_CHECK(path("c:..\\foo"), "c:..\\foo"); + PATH_CHECK(path("c:/../../foo"), "c:/../../foo"); + PATH_CHECK(path("c:\\..\\..\\foo"), "c:\\..\\..\\foo"); + PATH_CHECK(path("c:foo/.."), "c:foo/.."); + PATH_CHECK(path("c:/foo/.."), "c:/foo/.."); + PATH_CHECK(path("c:/..foo"), "c:/..foo"); + PATH_CHECK(path("c:foo"), "c:foo"); + PATH_CHECK(path("c:/foo"), "c:/foo"); + PATH_CHECK(path("\\\\netname"), "\\\\netname"); + PATH_CHECK(path("\\\\netname\\"), "\\\\netname\\"); + PATH_CHECK(path("\\\\netname\\foo"), "\\\\netname\\foo"); + PATH_CHECK(path("c:/foo"), "c:/foo"); + PATH_CHECK(path("prn:"), "prn:"); + } + else + { + } + + PATH_CHECK("foo/bar", "foo/bar"); + PATH_CHECK("a/b", "a/b"); // probe for length effects + PATH_CHECK("..", ".."); + PATH_CHECK("../..", "../.."); + PATH_CHECK("/..", "/.."); + PATH_CHECK("/../..", "/../.."); + PATH_CHECK("../foo", "../foo"); + PATH_CHECK("foo/..", "foo/.."); + PATH_CHECK(path("foo/..bar"), "foo/..bar"); + PATH_CHECK("../f", "../f"); + PATH_CHECK("/../f", "/../f"); + PATH_CHECK("f/..", "f/.."); + PATH_CHECK("foo/../..", "foo/../.."); + PATH_CHECK("foo/../../..", "foo/../../.."); + PATH_CHECK("foo/../bar", "foo/../bar"); + PATH_CHECK("foo/bar/..", "foo/bar/.."); + PATH_CHECK("foo/bar/../..", "foo/bar/../.."); + PATH_CHECK("foo/bar/../blah", "foo/bar/../blah"); + PATH_CHECK("f/../b", "f/../b"); + PATH_CHECK("f/b/..", "f/b/.."); + PATH_CHECK("f/b/../a", "f/b/../a"); + PATH_CHECK("foo/bar/blah/../..", "foo/bar/blah/../.."); + PATH_CHECK("foo/bar/blah/../../bletch", "foo/bar/blah/../../bletch"); + PATH_CHECK("...", "..."); + PATH_CHECK("....", "...."); + PATH_CHECK("foo/...", "foo/..."); + PATH_CHECK("abc.", "abc."); + PATH_CHECK("abc..", "abc.."); + PATH_CHECK("foo/abc.", "foo/abc."); + PATH_CHECK("foo/abc..", "foo/abc.."); + + PATH_CHECK(path(".abc"), ".abc"); + PATH_CHECK("a.c", "a.c"); + PATH_CHECK(path("..abc"), "..abc"); + PATH_CHECK("a..c", "a..c"); + PATH_CHECK(path("foo/.abc"), "foo/.abc"); + PATH_CHECK("foo/a.c", "foo/a.c"); + PATH_CHECK(path("foo/..abc"), "foo/..abc"); + PATH_CHECK("foo/a..c", "foo/a..c"); + + PATH_CHECK(".", "."); + PATH_CHECK("./foo", "./foo"); + PATH_CHECK("./..", "./.."); + PATH_CHECK("./../foo", "./../foo"); + PATH_CHECK("foo/.", "foo/."); + PATH_CHECK("../.", "../."); + PATH_CHECK("./.", "./."); + PATH_CHECK("././.", "././."); + PATH_CHECK("./foo/.", "./foo/."); + PATH_CHECK("foo/./bar", "foo/./bar"); + PATH_CHECK("foo/./.", "foo/./."); + PATH_CHECK("foo/./..", "foo/./.."); + PATH_CHECK("foo/./../bar", "foo/./../bar"); + PATH_CHECK("foo/../.", "foo/../."); + PATH_CHECK("././..", "././.."); + PATH_CHECK("./../.", "./../."); + PATH_CHECK(".././.", ".././."); + } + + // append_tests --------------------------------------------------------------------// + + void append_test_aux(const path & p, const std::string & s, const std::string & expect) + { + PATH_CHECK(p / path(s), expect); + PATH_CHECK(p / s.c_str(), expect); + PATH_CHECK(p / s, expect); + path x(p); + x.append(s.begin(), s.end()); + PATH_CHECK(x, expect); + } + + void append_tests() + { + std::cout << "append_tests..." << std::endl; + + // There are many control paths to be exercised, since empty paths and arguments, + // paths with trailing separators, arguments with leading separators, with or without + // other characters being present, are all separate cases that need to be tested. + // Furthermore, some of the code to be tested is specific to argument categories, + // so that results in further permutations to be tested. + + //// code to generate test cases + //// + //// expected results must be checked by hand + //// "foo\bar" expected result must be edited by hand and moved for Windows/POSIX + //// + //const char* x[] = { "", "/", "foo", "foo/" }; + //const char* y[] = { "", "/", "bar", "/bar" }; + + //for (int i = 0; i < sizeof(x)/sizeof(char*); ++i) + // for (int j = 0; j < sizeof(y)/sizeof(char*); ++j) + // { + // std::cout << "\n PATH_CHECK(path(\"" << x[i] << "\") / \"" << y[j] << "\", \"" + // << path(x[i]) / y[j] << "\");\n"; + // std::cout << " append_test_aux(\"" << x[i] << "\", \"" << y[j] << "\", \"" + // << path(x[i]) / y[j] << "\");\n"; + // } + + PATH_CHECK(path("") / "", ""); + append_test_aux("", "", ""); + + PATH_CHECK(path("") / "/", "/"); + append_test_aux("", "/", "/"); + + PATH_CHECK(path("") / "bar", "bar"); + append_test_aux("", "bar", "bar"); + + PATH_CHECK(path("") / "/bar", "/bar"); + append_test_aux("", "/bar", "/bar"); + + PATH_CHECK(path("/") / "", "/"); + append_test_aux("/", "", "/"); + + PATH_CHECK(path("/") / "/", "//"); + append_test_aux("/", "/", "//"); + + PATH_CHECK(path("/") / "bar", "/bar"); + append_test_aux("/", "bar", "/bar"); + + PATH_CHECK(path("/") / "/bar", "//bar"); + append_test_aux("/", "/bar", "//bar"); + + PATH_CHECK(path("foo") / "", "foo"); + append_test_aux("foo", "", "foo"); + + PATH_CHECK(path("foo") / "/", "foo/"); + append_test_aux("foo", "/", "foo/"); + + PATH_CHECK(path("foo") / "/bar", "foo/bar"); + append_test_aux("foo", "/bar", "foo/bar"); + + PATH_CHECK(path("foo/") / "", "foo/"); + append_test_aux("foo/", "", "foo/"); + + PATH_CHECK(path("foo/") / "/", "foo//"); + append_test_aux("foo/", "/", "foo//"); + + PATH_CHECK(path("foo/") / "bar", "foo/bar"); + append_test_aux("foo/", "bar", "foo/bar"); + + PATH_CHECK(path("foo/") / "/bar", "foo//bar"); + append_test_aux("foo/", "/bar", "foo//bar"); + + if (platform == "Windows") + { + PATH_CHECK(path("foo") / "bar", "foo\\bar"); + append_test_aux("foo", "bar", "foo\\bar"); + + // hand created test case specific to Windows + PATH_CHECK(path("c:") / "bar", "c:bar"); + append_test_aux("c:", "bar", "c:bar"); + } + else + { + PATH_CHECK(path("foo") / "bar", "foo/bar"); + append_test_aux("foo", "bar", "foo/bar"); + } + + } + + // name_function_tests -------------------------------------------------------------// + + void name_function_tests() + { + std::cout << "name_function_tests..." << std::endl; + + BOOST_TEST(fs::portable_posix_name(std::string("x"))); + BOOST_TEST(fs::windows_name(std::string("x"))); + BOOST_TEST(fs::portable_name(std::string("x"))); + BOOST_TEST(fs::portable_directory_name(std::string("x"))); + BOOST_TEST(fs::portable_file_name(std::string("x"))); + + BOOST_TEST(fs::portable_posix_name(std::string("."))); + BOOST_TEST(fs::windows_name(std::string("."))); + BOOST_TEST(fs::portable_name(std::string("."))); + BOOST_TEST(fs::portable_directory_name(std::string("."))); + BOOST_TEST(!fs::portable_file_name(std::string("."))); + + BOOST_TEST(fs::portable_posix_name(std::string(".."))); + BOOST_TEST(fs::windows_name(std::string(".."))); + BOOST_TEST(fs::portable_name(std::string(".."))); + BOOST_TEST(fs::portable_directory_name(std::string(".."))); + BOOST_TEST(!fs::portable_file_name(std::string(".."))); + + BOOST_TEST(!fs::native(std::string(""))); + BOOST_TEST(!fs::portable_posix_name(std::string(""))); + BOOST_TEST(!fs::windows_name(std::string(""))); + BOOST_TEST(!fs::portable_name(std::string(""))); + BOOST_TEST(!fs::portable_directory_name(std::string(""))); + BOOST_TEST(!fs::portable_file_name(std::string(""))); + + BOOST_TEST(!fs::native(std::string(" "))); + BOOST_TEST(!fs::portable_posix_name(std::string(" "))); + BOOST_TEST(!fs::windows_name(std::string(" "))); + BOOST_TEST(!fs::portable_name(std::string(" "))); + BOOST_TEST(!fs::portable_directory_name(std::string(" "))); + BOOST_TEST(!fs::portable_file_name(std::string(" "))); + + BOOST_TEST(!fs::portable_posix_name(std::string(":"))); + BOOST_TEST(!fs::windows_name(std::string(":"))); + BOOST_TEST(!fs::portable_name(std::string(":"))); + BOOST_TEST(!fs::portable_directory_name(std::string(":"))); + BOOST_TEST(!fs::portable_file_name(std::string(":"))); + + BOOST_TEST(fs::portable_posix_name(std::string("-"))); + BOOST_TEST(fs::windows_name(std::string("-"))); + BOOST_TEST(!fs::portable_name(std::string("-"))); + BOOST_TEST(!fs::portable_directory_name(std::string("-"))); + BOOST_TEST(!fs::portable_file_name(std::string("-"))); + + BOOST_TEST(!fs::portable_posix_name(std::string("foo bar"))); + BOOST_TEST(fs::windows_name(std::string("foo bar"))); + BOOST_TEST(!fs::windows_name(std::string(" bar"))); + BOOST_TEST(!fs::windows_name(std::string("foo "))); + BOOST_TEST(!fs::portable_name(std::string("foo bar"))); + BOOST_TEST(!fs::portable_directory_name(std::string("foo bar"))); + BOOST_TEST(!fs::portable_file_name(std::string("foo bar"))); + + BOOST_TEST(fs::portable_posix_name(std::string("foo.bar"))); + BOOST_TEST(fs::windows_name(std::string("foo.bar"))); + BOOST_TEST(fs::portable_name(std::string("foo.bar"))); + BOOST_TEST(!fs::portable_directory_name(std::string("foo.bar"))); + BOOST_TEST(fs::portable_file_name(std::string("foo.bar"))); + + BOOST_TEST(fs::portable_posix_name(std::string("foo.barf"))); + BOOST_TEST(fs::windows_name(std::string("foo.barf"))); + BOOST_TEST(fs::portable_name(std::string("foo.barf"))); + BOOST_TEST(!fs::portable_directory_name(std::string("foo.barf"))); + BOOST_TEST(!fs::portable_file_name(std::string("foo.barf"))); + + BOOST_TEST(fs::portable_posix_name(std::string(".foo"))); + BOOST_TEST(fs::windows_name(std::string(".foo"))); + BOOST_TEST(!fs::portable_name(std::string(".foo"))); + BOOST_TEST(!fs::portable_directory_name(std::string(".foo"))); + BOOST_TEST(!fs::portable_file_name(std::string(".foo"))); + + BOOST_TEST(fs::portable_posix_name(std::string("foo."))); + BOOST_TEST(!fs::windows_name(std::string("foo."))); + BOOST_TEST(!fs::portable_name(std::string("foo."))); + BOOST_TEST(!fs::portable_directory_name(std::string("foo."))); + BOOST_TEST(!fs::portable_file_name(std::string("foo."))); + } + + // replace_extension_tests ---------------------------------------------------// + + void replace_extension_tests() + { + std::cout << "replace_extension_tests..." << std::endl; + + BOOST_TEST(path().replace_extension().empty()); + BOOST_TEST(path().replace_extension("a").empty()); + BOOST_TEST(path().replace_extension("a.") == "."); + BOOST_TEST(path().replace_extension("a.txt") == ".txt"); + // see the rationale in html docs for explanation why this works: + BOOST_TEST(path().replace_extension(".txt") == ".txt"); + + BOOST_TEST(path("a.txt").replace_extension() == "a"); + BOOST_TEST(path("a.txt").replace_extension("") == "a"); + BOOST_TEST(path("a.txt").replace_extension(".") == "a."); + BOOST_TEST(path("a.txt").replace_extension(".tex") == "a.tex"); + BOOST_TEST(path("a.txt").replace_extension("tex") == "a"); + BOOST_TEST(path("a.").replace_extension(".tex") == "a.tex"); + BOOST_TEST(path("a.").replace_extension("tex") == "a"); + BOOST_TEST(path("a").replace_extension(".txt") == "a.txt"); + BOOST_TEST(path("a").replace_extension("txt") == "a"); + BOOST_TEST(path("a.b.txt").replace_extension(".tex") == "a.b.tex"); + BOOST_TEST(path("a.b.txt").replace_extension("tex") == "a.b"); + } + +} // unnamed namespace + +//--------------------------------------------------------------------------------------// +// // +// main // +// // +//--------------------------------------------------------------------------------------// + +int main(int, char*[]) +{ + // The choice of platform is make at runtime rather than compile-time + // so that compile errors for all platforms will be detected even though + // only the current platform is runtime tested. + platform = (platform == "Win32" || platform == "Win64" || platform == "Cygwin") + ? "Windows" + : "POSIX"; + std::cout << "Platform is " << platform << '\n'; + + BOOST_TEST(p1.string() != p3.string()); + p3 = p2; + BOOST_TEST(p1.string() == p3.string()); + + path p4("foobar"); + BOOST_TEST(p4.string() == "foobar"); + p4 = p4; // self-assignment + BOOST_TEST(p4.string() == "foobar"); + + construction_tests(); + append_tests(); + overload_tests(); + query_and_decomposition_tests(); + composition_tests(); + iterator_tests(); + non_member_tests(); + exception_tests(); + name_function_tests(); + replace_extension_tests(); + + // verify deprecated names still available + +# ifndef BOOST_FILESYSTEM_NO_DEPRECATED + + p1.branch_path(); + p1.leaf(); + path p_remove_leaf; + p_remove_leaf.remove_leaf(); + +# endif + + std::string s1("//:somestring"); // this used to be treated specially + + // check the path member templates + p5.assign(s1.begin(), s1.end()); + + PATH_CHECK(p5, "//:somestring"); + p5 = s1; + PATH_CHECK(p5, "//:somestring"); + + // this code, courtesy of David Whetstone, detects a now fixed bug that + // derefereced the end iterator (assuming debug build with checked itors) + std::vector v1; + p5.assign(v1.begin(), v1.end()); + std::string s2(v1.begin(), v1.end()); + PATH_CHECK(p5, s2); + p5.assign(s1.begin(), s1.begin() + 1); + PATH_CHECK(p5, "/"); + + BOOST_TEST(p1 != p4); + BOOST_TEST(p1.string() == p2.string()); + BOOST_TEST(p1.string() == p3.string()); + BOOST_TEST(path("foo").filename() == "foo"); + BOOST_TEST(path("foo").parent_path().string() == ""); + BOOST_TEST(p1.filename() == "fum"); + BOOST_TEST(p1.parent_path().string() == "fe/fi/fo"); + BOOST_TEST(path("").empty() == true); + BOOST_TEST(path("foo").empty() == false); + + // inserter and extractor tests +# if !defined(BOOST_MSVC) || BOOST_MSVC > 1300 // bypass VC++ 7.0 and earlier + std::cout << "\nInserter and extractor test..."; + std::stringstream ss; + ss << fs::path("foo/bar") << std::endl; + fs::path round_trip; + ss >> round_trip; + BOOST_TEST(round_trip.string() == "foo/bar"); + std::cout << round_trip.string() << "..." << round_trip << " complete\n"; +# endif + + return ::boost::report_errors(); +} diff --git a/v3/libs/filesystem/test/path_unit_test.cpp b/v3/libs/filesystem/test/path_unit_test.cpp new file mode 100644 index 0000000..6bc4e38 --- /dev/null +++ b/v3/libs/filesystem/test/path_unit_test.cpp @@ -0,0 +1,905 @@ +// filesystem path_unit_test.cpp --------------------------------------------------- // + +// Copyright Beman Dawes 2008, 2009 + +// Distributed under the Boost Software License, Version 1.0. +// See http://www.boost.org/LICENSE_1_0.txt + +// Library home page: http://www.boost.org/libs/filesystem + +// ---------------------------------------------------------------------------------- // +// +// The purpose of this test is to ensure that each function in the public +// interface can be called with arguments of the appropriate types. It does +// not attempt to verify that the full range of values for each argument +// are processed correctly. +// +// For full functionality tests, including probes with many different argument +// values, see path_test.cpp and other test programs. +// +// ---------------------------------------------------------------------------------- // + +#include + +// See deprecated_test for tests of deprecated features +#define BOOST_FILESYSTEM_NO_DEPRECATED + +#include +#include "../src/utf8_codecvt_facet.hpp" // for imbue tests +#include + +#include +#include +#include +#include +#include + +namespace fs = boost::filesystem; +namespace bs = boost::system; +using boost::filesystem::path; +using std::cout; +using std::endl; +using std::string; +using std::wstring; + +#define CHECK(x) check(x, __FILE__, __LINE__) +#define PATH_IS(a, b) check_path(a, b, __FILE__, __LINE__) +#define IS(a,b) check_equal(a, b, __FILE__, __LINE__) + +#if defined(_MSC_VER) +# pragma warning(push) // Save warning settings. +# pragma warning(disable : 4428) // Disable universal-character-name encountered in source warning. +#endif + +namespace +{ + + boost::system::error_code ec; + const boost::system::error_code ok; + const boost::system::error_code ng(-1, boost::system::system_category()); + + std::string platform(BOOST_PLATFORM); + + void check_path(const path & source, + const wstring & expected, const char* file, int line) + { + if (source == expected) return; + + ++::boost::detail::test_errors(); + + std::cout << file; + std::wcout << L'(' << line << L"): source.wstring(): \"" + << source.wstring() + << L"\" != expected: \"" << expected + << L"\"\n" ; + } + + template< class T1, class T2 > + void check_equal(const T1 & value, + const T2 & expected, const char* file, int line) + { + if (value == expected) return; + + ++::boost::detail::test_errors(); + + std::cout << file; + + std::wcout << L'(' << line << L"): value: \"" << value + << L"\" != expected: \"" << expected + << L"\"\n" ; + } + + void check(bool ok, const char* file, int line) + { + if (ok) return; + + ++::boost::detail::test_errors(); + + std::cout << file << '(' << line << "): test failed\n"; + } + + string s("string"); + wstring ws(L"wstring"); + std::list l; // see main() for initialization to s, t, r, i, n, g + std::list wl; // see main() for initialization to w, s, t, r, i, n, g + std::vector v; // see main() for initialization to f, u, z + std::vector wv; // see main() for initialization to w, f, u, z + + // test_constructors ---------------------------------------------------------------// + + void test_constructors() + { + std::cout << "testing constructors..." << std::endl; + + path x0; // default constructor + PATH_IS(x0, L""); + BOOST_TEST_EQ(x0.native().size(), 0U); + + path x1(l.begin(), l.end()); // iterator range char + PATH_IS(x1, L"string"); + BOOST_TEST_EQ(x1.native().size(), 6U); + + path x2(x1); // copy constructor + PATH_IS(x2, L"string"); + BOOST_TEST_EQ(x2.native().size(), 6U); + + path x3(wl.begin(), wl.end()); // iterator range wchar_t + PATH_IS(x3, L"wstring"); + BOOST_TEST_EQ(x3.native().size(), 7U); + + // contiguous containers + path x4(string("std::string")); // std::string + PATH_IS(x4, L"std::string"); + BOOST_TEST_EQ(x4.native().size(), 11U); + + path x5(wstring(L"std::wstring")); // std::wstring + PATH_IS(x5, L"std::wstring"); + BOOST_TEST_EQ(x5.native().size(), 12U); + + path x4v(v); // std::vector + PATH_IS(x4v, L"fuz"); + BOOST_TEST_EQ(x4v.native().size(), 3U); + + path x5v(wv); // std::vector + PATH_IS(x5v, L"wfuz"); + BOOST_TEST_EQ(x5v.native().size(), 4U); + + path x6("array char"); // array char + PATH_IS(x6, L"array char"); + BOOST_TEST_EQ(x6.native().size(), 10U); + + path x7(L"array wchar_t"); // array wchar_t + PATH_IS(x7, L"array wchar_t"); + BOOST_TEST_EQ(x7.native().size(), 13U); + + path x8(s.c_str()); // const char* null terminated + PATH_IS(x8, L"string"); + BOOST_TEST_EQ(x8.native().size(), 6U); + + path x9(ws.c_str()); // const wchar_t* null terminated + PATH_IS(x9, L"wstring"); + BOOST_TEST_EQ(x9.native().size(), 7U); + + // non-contiguous containers + path x10(l); // std::list + PATH_IS(x10, L"string"); + BOOST_TEST_EQ(x10.native().size(), 6U); + + path xll(wl); // std::list + PATH_IS(xll, L"wstring"); + BOOST_TEST_EQ(xll.native().size(), 7U); + } + + path x; + path y; + + // test_assignments ----------------------------------------------------------------// + + void test_assignments() + { + std::cout << "testing assignments..." << std::endl; + + x = path("yet another path"); // another path + PATH_IS(x, L"yet another path"); + BOOST_TEST_EQ(x.native().size(), 16U); + + x = x; // self-assignment + PATH_IS(x, L"yet another path"); + BOOST_TEST_EQ(x.native().size(), 16U); + + x.assign(l.begin(), l.end()); // iterator range char + PATH_IS(x, L"string"); + + x.assign(wl.begin(), wl.end()); // iterator range wchar_t + PATH_IS(x, L"wstring"); + + x = string("std::string"); // container char + PATH_IS(x, L"std::string"); + + x = wstring(L"std::wstring"); // container wchar_t + PATH_IS(x, L"std::wstring"); + + x = "array char"; // array char + PATH_IS(x, L"array char"); + + x = L"array wchar"; // array wchar_t + PATH_IS(x, L"array wchar"); + + x = s.c_str(); // const char* null terminated + PATH_IS(x, L"string"); + + x = ws.c_str(); // const wchar_t* null terminated + PATH_IS(x, L"wstring"); + } + + // test_appends --------------------------------------------------------------------// + + void test_appends() + { + std::cout << "testing appends..." << std::endl; + +# ifdef BOOST_WINDOWS_API +# define BOOST_FS_FOO L"/foo\\" +# else // POSIX paths +# define BOOST_FS_FOO L"/foo/" +# endif + + x = "/foo"; + x /= path(""); // empty path + PATH_IS(x, L"/foo"); + + x = "/foo"; + x /= path("/"); // slash path + PATH_IS(x, L"/foo/"); + + x = "/foo"; + x /= path("/boo"); // slash path + PATH_IS(x, L"/foo/boo"); + + x = "/foo"; + x /= x; // self-append + PATH_IS(x, L"/foo/foo"); + + x = "/foo"; + x /= path("yet another path"); // another path + PATH_IS(x, BOOST_FS_FOO L"yet another path"); + + x = "/foo"; + x.append(l.begin(), l.end()); // iterator range char + PATH_IS(x, BOOST_FS_FOO L"string"); + + x = "/foo"; + x.append(wl.begin(), wl.end()); // iterator range wchar_t + PATH_IS(x, BOOST_FS_FOO L"wstring"); + + x = "/foo"; + x /= string("std::string"); // container char + PATH_IS(x, BOOST_FS_FOO L"std::string"); + + x = "/foo"; + x /= wstring(L"std::wstring"); // container wchar_t + PATH_IS(x, BOOST_FS_FOO L"std::wstring"); + + x = "/foo"; + x /= "array char"; // array char + PATH_IS(x, BOOST_FS_FOO L"array char"); + + x = "/foo"; + x /= L"array wchar"; // array wchar_t + PATH_IS(x, BOOST_FS_FOO L"array wchar"); + + x = "/foo"; + x /= s.c_str(); // const char* null terminated + PATH_IS(x, BOOST_FS_FOO L"string"); + + x = "/foo"; + x /= ws.c_str(); // const wchar_t* null terminated + PATH_IS(x, BOOST_FS_FOO L"wstring"); + } + + // test_observers ------------------------------------------------------------------// + + void test_observers() + { + std::cout << "testing observers..." << std::endl; + + path p0("abc"); + + CHECK(p0.native().size() == 3); + CHECK(p0.string() == "abc"); + CHECK(p0.string().size() == 3); + CHECK(p0.wstring() == L"abc"); + CHECK(p0.wstring().size() == 3); + +# ifdef BOOST_WINDOWS_API + + path p("abc\\def/ghi"); + + CHECK(std::wstring(p.c_str()) == L"abc\\def/ghi"); + + CHECK(p.string() == "abc\\def/ghi"); + CHECK(p.wstring() == L"abc\\def/ghi"); + + CHECK(p.generic_string() == "abc/def/ghi"); + CHECK(p.generic_wstring() == L"abc/def/ghi"); + + CHECK(p.generic_string() == "abc/def/ghi"); + CHECK(p.generic_string() == L"abc/def/ghi"); + CHECK(p.generic_string() == L"abc/def/ghi"); + +# else // BOOST_POSIX_API + + path p("abc\\def/ghi"); + + CHECK(string(p.c_str()) == "abc\\def/ghi"); + + CHECK(p.string() == "abc\\def/ghi"); + CHECK(p.wstring() == L"abc\\def/ghi"); + + CHECK(p.generic_string() == "abc\\def/ghi"); + CHECK(p.generic_wstring() == L"abc\\def/ghi"); + + CHECK(p.generic_string() == "abc\\def/ghi"); + CHECK(p.generic_string() == L"abc\\def/ghi"); + CHECK(p.generic_string() == "abc\\def/ghi"); + +# endif + } + + // test_relationals ----------------------------------------------------------------// + + void test_relationals() + { + std::cout << "testing relationals..." << std::endl; + +# ifdef BOOST_WINDOWS_API + // this is a critical use case to meet user expectations + CHECK(path("c:\\abc") == path("c:/abc")); +# endif + + const path p("bar"); + const path p2("baz"); + + CHECK(!(p < p)); + CHECK(p < p2); + CHECK(!(p2 < p)); + CHECK(p < "baz"); + CHECK(p < string("baz")); + CHECK(p < L"baz"); + CHECK(p < wstring(L"baz")); + CHECK(!("baz" < p)); + CHECK(!(string("baz") < p)); + CHECK(!(L"baz" < p)); + CHECK(!(wstring(L"baz") < p)); + + CHECK(p == p); + CHECK(!(p == p2)); + CHECK(!(p2 == p)); + CHECK(p2 == "baz"); + CHECK(p2 == string("baz")); + CHECK(p2 == L"baz"); + CHECK(p2 == wstring(L"baz")); + CHECK("baz" == p2); + CHECK(string("baz") == p2); + CHECK(L"baz" == p2); + CHECK(wstring(L"baz") == p2); + + CHECK(!(p != p)); + CHECK(p != p2); + CHECK(p2 != p); + + CHECK(p <= p); + CHECK(p <= p2); + CHECK(!(p2 <= p)); + + CHECK(!(p > p)); + CHECK(!(p > p2)); + CHECK(p2 > p); + + CHECK(p >= p); + CHECK(!(p >= p2)); + CHECK(p2 >= p); +} + + // test_inserter_and_extractor -----------------------------------------------------// + + void test_inserter_and_extractor() + { + std::cout << "testing inserter and extractor..." << std::endl; + + path p1("foo"); + path p2; + + std::stringstream ss; + + CHECK(p1 != p2); + ss << p1; + ss >> p2; + CHECK(p1 == p2); + } + + // test_other_non_members ----------------------------------------------------------// + + void test_other_non_members() + { + std::cout << "testing other_non_members..." << std::endl; + + path p1("foo"); + path p2("bar"); + + // operator / + + CHECK(p1 / p2 == path("foo/bar").make_preferred()); + CHECK("foo" / p2 == path("foo/bar").make_preferred()); + CHECK(L"foo" / p2 == path("foo/bar").make_preferred()); + CHECK(string("foo") / p2 == path("foo/bar").make_preferred()); + CHECK(wstring(L"foo") / p2 == path("foo/bar").make_preferred()); + CHECK(p1 / "bar" == path("foo/bar").make_preferred()); + CHECK(p1 / L"bar" == path("foo/bar").make_preferred()); + CHECK(p1 / string("bar") == path("foo/bar").make_preferred()); + CHECK(p1 / wstring(L"bar") == path("foo/bar").make_preferred()); + + swap(p1, p2); + + CHECK(p1 == "bar"); + CHECK(p2 == "foo"); + + CHECK(path("").remove_filename() == ""); + CHECK(path("foo").remove_filename() == ""); + CHECK(path("foo/bar").remove_filename() == "foo"); + } + +// // test_modifiers ------------------------------------------------------------------// +// +// void test_modifiers() +// { +// std::cout << "testing modifiers..." << std::endl; +// +// } + + // test_iterators ------------------------------------------------------------------// + + void test_iterators() + { + std::cout << "testing iterators..." << std::endl; + + path p1; + CHECK(p1.begin() == p1.end()); + + path p2("/"); + CHECK(p2.begin() != p2.end()); + CHECK(*p2.begin() == "/"); + CHECK(++p2.begin() == p2.end()); + + path p3("foo/bar/baz"); + + path::iterator it(p3.begin()); + CHECK(p3.begin() != p3.end()); + CHECK(*it == "foo"); + CHECK(*++it == "bar"); + CHECK(*++it == "baz"); + CHECK(*--it == "bar"); + CHECK(*--it == "foo"); + CHECK(*++it == "bar"); + CHECK(*++it == "baz"); + CHECK(++it == p3.end()); + } + + // test_modifiers ------------------------------------------------------------------// + + void test_modifiers() + { + std::cout << "testing modifiers..." << std::endl; + +// CHECK(path("").make_absolute("") == ""); // should assert +// CHECK(path("").make_absolute("foo") == ""); // should assert + +# ifdef BOOST_WINDOWS_API + CHECK(path("baa").make_absolute("c:/") == "c:/baa"); + CHECK(path("/baa").make_absolute("c:/foo").string() == path("c:/baa").string()); + CHECK(path("baa/baz").make_absolute("c:/foo/bar").string() + == path("c:/foo/bar\\baa/baz").string()); +# else + CHECK(path("baa").make_absolute("/") == "/baa"); + CHECK(path("/baa").make_absolute("/foo").string() == path("/baa").string()); + CHECK(path("baa/baz").make_absolute("/foo/bar").string() + == path("/foo/bar/baa/baz").string()); +# endif + } + + // test_decompositions -------------------------------------------------------------// + + void test_decompositions() + { + std::cout << "testing decompositions..." << std::endl; + + CHECK(path("").root_name().string() == ""); + CHECK(path("foo").root_name().string() == ""); + CHECK(path("/").root_name().string() == ""); + CHECK(path("/foo").root_name().string() == ""); + CHECK(path("//netname").root_name().string() == "//netname"); + CHECK(path("//netname/foo").root_name().string() == "//netname"); + + CHECK(path("").root_directory().string() == ""); + CHECK(path("foo").root_directory().string() == ""); + CHECK(path("/").root_directory().string() == "/"); + CHECK(path("/foo").root_directory().string() == "/"); + CHECK(path("//netname").root_directory().string() == ""); + CHECK(path("//netname/foo").root_directory().string() == "/"); + + CHECK(path("").root_path().string() == ""); + CHECK(path("/").root_path().string() == "/"); + CHECK(path("/foo").root_path().string() == "/"); + CHECK(path("//netname").root_path().string() == "//netname"); + CHECK(path("//netname/foo").root_path().string() == "//netname/"); + +# ifdef BOOST_WINDOWS_API + CHECK(path("c:/foo").root_path().string() == "c:/"); +# endif + + CHECK(path("").relative_path().string() == ""); + CHECK(path("/").relative_path().string() == ""); + CHECK(path("/foo").relative_path().string() == "foo"); + + CHECK(path("").parent_path().string() == ""); + CHECK(path("/").parent_path().string() == ""); + CHECK(path("/foo").parent_path().string() == "/"); + CHECK(path("/foo/bar").parent_path().string() == "/foo"); + + CHECK(path("/foo/bar/baz.zoo").filename().string() == "baz.zoo"); + + CHECK(path("/foo/bar/baz.zoo").stem().string() == "baz"); + CHECK(path("/foo/bar.woo/baz").stem().string() == "baz"); + + CHECK(path("foo.bar.baz.tar.bz2").extension().string() == ".bz2"); + CHECK(path("/foo/bar/baz.zoo").extension().string() == ".zoo"); + CHECK(path("/foo/bar.woo/baz").extension().string() == ""); + } + + // test_queries --------------------------------------------------------------------// + + void test_queries() + { + std::cout << "testing queries..." << std::endl; + + path p1(""); + path p2("//netname/foo.doo"); + + CHECK(p1.empty()); + CHECK(!p1.has_root_path()); + CHECK(!p1.has_root_name()); + CHECK(!p1.has_root_directory()); + CHECK(!p1.has_relative_path()); + CHECK(!p1.has_parent_path()); + CHECK(!p1.has_filename()); + CHECK(!p1.has_stem()); + CHECK(!p1.has_extension()); + CHECK(!p1.is_absolute()); + CHECK(p1.is_relative()); + + CHECK(!p2.empty()); + CHECK(p2.has_root_path()); + CHECK(p2.has_root_name()); + CHECK(p2.has_root_directory()); + CHECK(p2.has_relative_path()); + CHECK(p2.has_parent_path()); + CHECK(p2.has_filename()); + CHECK(p2.has_stem()); + CHECK(p2.has_extension()); + CHECK(p2.is_absolute()); + CHECK(!p2.is_relative()); + + } + + // test_imbue_locale ---------------------------------------------------------------// + + void test_imbue_locale() + { + std::cout << "testing imbue locale..." << std::endl; + + // \u2722 and \xE2\x9C\xA2 are UTF-16 and UTF-8 FOUR TEARDROP-SPOKED ASTERISK + + std::cout << " testing p0 ..." << std::endl; + path p0(L"\u2722"); // for tests that depend on path_traits::convert +# ifdef BOOST_WINDOWS_API + CHECK(p0.string() != "\xE2\x9C\xA2"); +# endif + string p0_string(p0.string()); + + std::cout << " testing p1 ..." << std::endl; + path p1("\xE2\x9C\xA2"); +# ifdef BOOST_WINDOWS_API + CHECK(p1 != L"\u2722"); +# endif + wstring p1_wstring(p1.wstring()); + + // So that tests are run with known encoding, use Boost UTF-8 codecvt + std::locale global_loc = std::locale(); + std::locale loc(global_loc, new fs::detail::utf8_codecvt_facet); + std::cout << " imbuing locale ..." << std::endl; + std::locale old_loc = path::imbue(loc); + + std::cout << " testing with the imbued locale ..." << std::endl; + CHECK(p0.string() == "\xE2\x9C\xA2"); + path p2("\xE2\x9C\xA2"); + CHECK(p2 == L"\u2722"); + CHECK(p2.wstring() == L"\u2722"); + + std::cout << " imbuing the original locale ..." << std::endl; + path::imbue(old_loc); + + std::cout << " testing with the original locale ..." << std::endl; + CHECK(p0.string() == p0_string); + path p3("\xE2\x9C\xA2"); +# ifdef BOOST_WINDOWS_API + CHECK(p3 != L"\u2722"); +# endif + CHECK(p3.wstring() == p1_wstring); + + std::cout << " locale testing complete" << std::endl; + } + + // test_overloads ------------------------------------------------------------------// + + void test_overloads() + { + std::cout << "testing overloads..." << std::endl; + std::string s("hello"); + const char a[] = "goodbye"; + path p1(s); + path p2(s.c_str()); + path p3(a); + path p4("foo"); + + std::wstring ws(L"hello"); + const wchar_t wa[] = L"goodbye"; + path wp1(ws); + path wp2(ws.c_str()); + path wp3(wa); + path wp4(L"foo"); + } + + // test_error_handling -------------------------------------------------------------// + + class error_codecvt + : public std::codecvt< wchar_t, char, std::mbstate_t > + { + public: + explicit error_codecvt() + : std::codecvt() {} + protected: + + virtual bool do_always_noconv() const throw() { return false; } + virtual int do_encoding() const throw() { return 0; } + + virtual std::codecvt_base::result do_in(std::mbstate_t&, + const char*, const char*, const char*&, + wchar_t*, wchar_t*, wchar_t*&) const + { + static std::codecvt_base::result r = std::codecvt_base::noconv; + if (r == std::codecvt_base::partial) r = std::codecvt_base::error; + else if (r == std::codecvt_base::error) r = std::codecvt_base::noconv; + else r = std::codecvt_base::partial; + return r; + } + + virtual std::codecvt_base::result do_out(std::mbstate_t &, + const wchar_t*, const wchar_t*, const wchar_t*&, + char*, char*, char*&) const + { + static std::codecvt_base::result r = std::codecvt_base::noconv; + if (r == std::codecvt_base::partial) r = std::codecvt_base::error; + else if (r == std::codecvt_base::error) r = std::codecvt_base::noconv; + else r = std::codecvt_base::partial; + return r; + } + + virtual std::codecvt_base::result do_unshift(std::mbstate_t&, + char*, char*, char* &) const { return ok; } + virtual int do_length(std::mbstate_t &, + const char*, const char*, std::size_t) const { return 0; } + virtual int do_max_length() const throw () { return 0; } + }; + + void test_error_handling() + { + std::cout << "testing error handling..." << std::endl; + + std::locale global_loc = std::locale(); + std::locale loc(global_loc, new error_codecvt); + std::cout << " imbuing error locale ..." << std::endl; + std::locale old_loc = path::imbue(loc); + + // These tests rely on a path constructor that fails in the locale conversion. + // Thus construction has to call codecvt. Force that by using a narrow string + // for Windows, and a wide string for POSIX. +# ifdef BOOST_WINDOWS_API +# define STRING_FOO_ "foo" +# else +# define STRING_FOO_ L"foo" +# endif + + { + std::cout << " testing std::codecvt_base::partial error..." << std::endl; + bool exception_thrown (false); + try { path(STRING_FOO_); } + catch (const bs::system_error & ex) + { + exception_thrown = true; + BOOST_TEST_EQ(ex.code(), bs::error_code(std::codecvt_base::partial, + fs::codecvt_error_category())); + } + catch (...) { std::cout << "***** unexpected exception type *****" << std::endl; } + BOOST_TEST(exception_thrown); + } + + { + std::cout << " testing std::codecvt_base::error error..." << std::endl; + bool exception_thrown (false); + try { path(STRING_FOO_); } + catch (const bs::system_error & ex) + { + exception_thrown = true; + BOOST_TEST_EQ(ex.code(), bs::error_code(std::codecvt_base::error, + fs::codecvt_error_category())); + } + catch (...) { std::cout << "***** unexpected exception type *****" << std::endl; } + BOOST_TEST(exception_thrown); + } + + { + std::cout << " testing std::codecvt_base::noconv error..." << std::endl; + bool exception_thrown (false); + try { path(STRING_FOO_); } + catch (const bs::system_error & ex) + { + exception_thrown = true; + BOOST_TEST_EQ(ex.code(), bs::error_code(std::codecvt_base::noconv, + fs::codecvt_error_category())); + } + catch (...) { std::cout << "***** unexpected exception type *****" << std::endl; } + BOOST_TEST(exception_thrown); + } + + std::cout << " restoring original locale ..." << std::endl; + path::imbue(old_loc); + } + +# if 0 + +// // test_locales --------------------------------------------------------------------// +// +// void test_locales() +// { +// std::cout << "testing locales..." << std::endl; +// +// } + + // test_user_supplied_type ---------------------------------------------------------// + + typedef std::basic_string user_string; + +} // unnamed namespace + +namespace boost +{ +namespace filesystem +{ + namespace path_traits + { + template<> struct is_iterator { static const bool value = true; }; + template<> struct is_iterator { static const bool value = true; }; + template<> struct is_iterator { static const bool value = true; }; + template<> struct is_iterator { static const bool value = true; }; + template<> struct is_container { static const bool value = true; }; + + template<> + void append(const user_string::value_type * begin, + const user_string::value_type * end, string_type & target, system::error_code & ec) + { + for (; begin != end && *begin; ++begin) + target += *begin + 1; // change so that results distinguishable from char cvts + } + +# ifdef __GNUC__ + // This specialization shouldn't be needed, and VC++, Intel, and others work + // fine without it. But gcc 4.3.2, and presumably other versions, need it. + template<> + void append(const user_string::value_type * begin, + string_type & target, system::error_code & ec) + { + path_traits::append(begin, + static_cast(0), target, ec); + } +# endif + + template<> + user_string convert(const string_type & source, + system::error_code & ec) + { + user_string temp; + for (string_type::const_iterator it = source.begin(); + it != source.end(); ++it) + temp += *it - 1; + return temp; + } + } // namespace path_traits +} // namespace filesystem +} // namespace boost + +namespace +{ + + void test_user_supplied_type() + { + std::cout << "testing user supplied type..." << std::endl; + + user_string::value_type usr_c_str[] = { 'a', 'b', 'c', 0 }; + user_string usr(usr_c_str); + + path p1(usr.c_str()); + CHECK(p1 == path("bcd")); + CHECK(p1 == "bcd"); + user_string s1(p1.string()); + CHECK(s1 == usr); + } + +# endif + +} // unnamed namespace + +//--------------------------------------------------------------------------------------// +// // +// main // +// // +//--------------------------------------------------------------------------------------// + +int main(int, char*[]) +{ +// document state of critical macros +#ifdef BOOST_POSIX_API + cout << "BOOST_POSIX_API" << endl; +#endif +#ifdef BOOST_WINDOWS_API + cout << "BOOST_WINDOWS_API" << endl; +#endif +#ifdef BOOST_POSIX_API + cout << "BOOST_PATH_API" << endl; +#endif +#ifdef BOOST_WINDOWS_API + cout << "BOOST_WINDOWS_API" << endl; +#endif + + l.push_back('s'); + l.push_back('t'); + l.push_back('r'); + l.push_back('i'); + l.push_back('n'); + l.push_back('g'); + + wl.push_back(L'w'); + wl.push_back(L's'); + wl.push_back(L't'); + wl.push_back(L'r'); + wl.push_back(L'i'); + wl.push_back(L'n'); + wl.push_back(L'g'); + + v.push_back('f'); + v.push_back('u'); + v.push_back('z'); + + wv.push_back(L'w'); + wv.push_back(L'f'); + wv.push_back(L'u'); + wv.push_back(L'z'); + + test_overloads(); + test_constructors(); + test_assignments(); + test_appends(); + test_modifiers(); + test_observers(); + test_relationals(); + test_inserter_and_extractor(); + test_other_non_members(); + test_iterators(); + test_decompositions(); + test_queries(); + test_imbue_locale(); + test_error_handling(); + +# if 0 + + test_user_supplied_type(); + +#endif + + std::string foo("\\abc"); + const char* bar = "/abc"; + + if (foo == bar) + cout << "unintended consequence\n"; + + return ::boost::report_errors(); +}