//  filesystem path.hpp  ---------------------------------------------------------------//

//  Copyright Vladimir Prus 2002

//  Copyright Beman Dawes 2002-2005, 2009

//  Copyright Andrey Semashev 2021-2024

//  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 <boost/filesystem/config.hpp>

#include <cstddef>

#include <iosfwd>

#include <locale>

#include <string>

#include <iterator>

#include <type_traits>

#if !defined(BOOST_NO_CXX17_HDR_STRING_VIEW)

#include <string_view>

#endif

#include <boost/assert.hpp>

#include <boost/iterator/iterator_facade.hpp>

#include <boost/iterator/iterator_categories.hpp>

#include <boost/io/quoted.hpp>

#include <boost/functional/hash_fwd.hpp>

#include <boost/filesystem/detail/path_traits.hpp>

#include <boost/filesystem/detail/type_traits/negation.hpp>

#include <boost/filesystem/detail/type_traits/conjunction.hpp>

#include <boost/filesystem/detail/type_traits/disjunction.hpp>

#include <boost/filesystem/detail/header.hpp> // must be the last #include

namespace boost {

namespace filesystem {

class path;

namespace path_detail { // intentionally don't use filesystem::detail to not bring internal Boost.Filesystem functions into ADL via path_constants

template< typename Char, Char Separator, Char PreferredSeparator, Char Dot >

struct path_constants

{

    typedef path_constants< Char, Separator, PreferredSeparator, Dot > path_constants_base;

    typedef Char value_type;

    static BOOST_CONSTEXPR_OR_CONST value_type separator = Separator;

    static BOOST_CONSTEXPR_OR_CONST value_type preferred_separator = PreferredSeparator;

    static BOOST_CONSTEXPR_OR_CONST value_type dot = Dot;

};

#if defined(BOOST_NO_CXX17_INLINE_VARIABLES)

template< typename Char, Char Separator, Char PreferredSeparator, Char Dot >

BOOST_CONSTEXPR_OR_CONST typename path_constants< Char, Separator, PreferredSeparator, Dot >::value_type

path_constants< Char, Separator, PreferredSeparator, Dot >::separator;

template< typename Char, Char Separator, Char PreferredSeparator, Char Dot >

BOOST_CONSTEXPR_OR_CONST typename path_constants< Char, Separator, PreferredSeparator, Dot >::value_type

path_constants< Char, Separator, PreferredSeparator, Dot >::preferred_separator;

template< typename Char, Char Separator, Char PreferredSeparator, Char Dot >

BOOST_CONSTEXPR_OR_CONST typename path_constants< Char, Separator, PreferredSeparator, Dot >::value_type

path_constants< Char, Separator, PreferredSeparator, Dot >::dot;

#endif

class path_iterator;

class path_reverse_iterator;

} // namespace path_detail

namespace detail {

struct path_algorithms

{

    // A struct that denotes a contiguous range of characters in a string. A lightweight alternative to string_view.

    struct substring

    {

        std::size_t pos;

        std::size_t size;

    };

    typedef path_traits::path_native_char_type value_type;

    typedef std::basic_string< value_type > string_type;

    static bool has_filename_v3(path const& p);

    static bool has_filename_v4(path const& p);

    BOOST_FILESYSTEM_DECL static path filename_v3(path const& p);

    static path filename_v4(path const& p);

    BOOST_FILESYSTEM_DECL static path stem_v3(path const& p);

    BOOST_FILESYSTEM_DECL static path stem_v4(path const& p);

    BOOST_FILESYSTEM_DECL static path extension_v3(path const& p);

    static path extension_v4(path const& p);

    BOOST_FILESYSTEM_DECL static void remove_filename_v3(path& p);

    BOOST_FILESYSTEM_DECL static void remove_filename_v4(path& p);

    BOOST_FILESYSTEM_DECL static void replace_extension_v3(path& p, path const& new_extension);

    BOOST_FILESYSTEM_DECL static void replace_extension_v4(path& p, path const& new_extension);

    BOOST_FILESYSTEM_DECL static path lexically_normal_v3(path const& p);

    BOOST_FILESYSTEM_DECL static path lexically_normal_v4(path const& p);

    BOOST_FILESYSTEM_DECL static path generic_path_v3(path const& p);

    BOOST_FILESYSTEM_DECL static path generic_path_v4(path const& p);

#if defined(BOOST_FILESYSTEM_WINDOWS_API)

    BOOST_FILESYSTEM_DECL static void make_preferred_v3(path& p);

    BOOST_FILESYSTEM_DECL static void make_preferred_v4(path& p);

#endif

    BOOST_FILESYSTEM_DECL static int compare_v3(path const& left, path const& right);

    BOOST_FILESYSTEM_DECL static int compare_v4(path const& left, path const& right);

    BOOST_FILESYSTEM_DECL static void append_v3(path& p, const value_type* b, const value_type* e);

    BOOST_FILESYSTEM_DECL static void append_v4(path& p, const value_type* b, const value_type* e);

    static void append_v4(path& left, path const& right);

    //  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.

    BOOST_FILESYSTEM_DECL static string_type::size_type append_separator_if_needed(path& p);

    BOOST_FILESYSTEM_DECL static void erase_redundant_separator(path& p, string_type::size_type sep_pos);

    BOOST_FILESYSTEM_DECL static string_type::size_type find_root_name_size(path const& p);

    BOOST_FILESYSTEM_DECL static string_type::size_type find_root_path_size(path const& p);

    BOOST_FILESYSTEM_DECL static substring find_root_directory(path const& p);

    BOOST_FILESYSTEM_DECL static substring find_relative_path(path const& p);

    BOOST_FILESYSTEM_DECL static string_type::size_type find_parent_path_size(path const& p);

    BOOST_FILESYSTEM_DECL static string_type::size_type find_filename_v4_size(path const& p);

    BOOST_FILESYSTEM_DECL static string_type::size_type find_extension_v4_size(path const& p);

    BOOST_FILESYSTEM_DECL static int lex_compare_v3

    (

        path_detail::path_iterator first1, path_detail::path_iterator const& last1,

        path_detail::path_iterator first2, path_detail::path_iterator const& last2

    );

    BOOST_FILESYSTEM_DECL static int lex_compare_v4

    (

        path_detail::path_iterator first1, path_detail::path_iterator const& last1,

        path_detail::path_iterator first2, path_detail::path_iterator const& last2

    );

    BOOST_FILESYSTEM_DECL static void increment_v3(path_detail::path_iterator& it);

    BOOST_FILESYSTEM_DECL static void increment_v4(path_detail::path_iterator& it);

    BOOST_FILESYSTEM_DECL static void decrement_v3(path_detail::path_iterator& it);

    BOOST_FILESYSTEM_DECL static void decrement_v4(path_detail::path_iterator& it);

};

} // namespace detail

//------------------------------------------------------------------------------------//

//                                                                                    //

//                                    class path                                      //

//                                                                                    //

//------------------------------------------------------------------------------------//

class path :

    public filesystem::path_detail::path_constants<

#ifdef BOOST_FILESYSTEM_WINDOWS_API

        detail::path_traits::path_native_char_type, L'/', L'\\', L'.'

#else

        detail::path_traits::path_native_char_type, '/', '/', '.'

#endif

    >

{

    friend class path_detail::path_iterator;

    friend class path_detail::path_reverse_iterator;

    friend struct detail::path_algorithms;

public:

    //  value_type is the character type used by the operating system API to

    //  represent paths.

    typedef detail::path_algorithms::value_type value_type;

    typedef detail::path_algorithms::string_type string_type;

    typedef detail::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.

    //  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.

    //  "const codecvt_type& cvt=codecvt()" default arguments are not used because this

    //  limits the impact of locale("") initialization failures on POSIX systems to programs

    //  that actually depend on locale(""). It further ensures that exceptions thrown

    //  as a result of such failues occur after main() has started, so can be caught.

private:

    //! Assignment operation

    class assign_op

    {

    private:

        path& m_self;

    public:

        typedef void result_type;

        explicit assign_op(path& self) noexcept : m_self(self) {}

        result_type operator() (const value_type* source, const value_type* source_end, const codecvt_type* = nullptr) const

        {

            m_self.m_pathname.assign(source, source_end);

        }

        template< typename OtherChar >

        result_type operator() (const OtherChar* source, const OtherChar* source_end, const codecvt_type* cvt = nullptr) const

        {

            m_self.m_pathname.clear();

            detail::path_traits::convert(source, source_end, m_self.m_pathname, cvt);

        }

    };

    //! Concatenation operation

    class concat_op

    {

    private:

        path& m_self;

    public:

        typedef void result_type;

        explicit concat_op(path& self) noexcept : m_self(self) {}

        result_type operator() (const value_type* source, const value_type* source_end, const codecvt_type* = nullptr) const

        {

            m_self.m_pathname.append(source, source_end);

        }

        template< typename OtherChar >

        result_type operator() (const OtherChar* source, const OtherChar* source_end, const codecvt_type* cvt = nullptr) const

        {

            detail::path_traits::convert(source, source_end, m_self.m_pathname, cvt);

        }

    };

    //! Path appending operation

    class append_op

    {

    private:

        path& m_self;

    public:

        typedef void result_type;

        explicit append_op(path& self) noexcept : m_self(self) {}

        BOOST_FORCEINLINE result_type operator() (const value_type* source, const value_type* source_end, const codecvt_type* = nullptr) const

        {

            m_self.append(source, source_end);

        }

        template< typename OtherChar >

        BOOST_FORCEINLINE result_type operator() (const OtherChar* source, const OtherChar* source_end, const codecvt_type* cvt = nullptr) const

        {

            string_type src;

            detail::path_traits::convert(source, source_end, src, cvt);

            m_self.append(src.data(), src.data() + src.size());

        }

    };

    //! Path comparison operation

    class compare_op

    {

    private:

        path const& m_self;

    public:

        typedef int result_type;

        explicit compare_op(path const& self) noexcept : m_self(self) {}

        result_type operator() (const value_type* source, const value_type* source_end, const codecvt_type* = nullptr) const;

        template< typename OtherChar >

        result_type operator() (const OtherChar* source, const OtherChar* source_end, const codecvt_type* cvt = nullptr) const;

    };

public:

    typedef path_detail::path_iterator iterator;

    typedef iterator const_iterator;

    typedef path_detail::path_reverse_iterator reverse_iterator;

    typedef reverse_iterator const_reverse_iterator;

public:

    //  -----  constructors  -----

    path() noexcept {}

    path(path const& p) : m_pathname(p.m_pathname) {}

    path(path const& p, codecvt_type const&) : m_pathname(p.m_pathname) {}

    path(const value_type* s) : m_pathname(s) {}

    path(const value_type* s, codecvt_type const&) : m_pathname(s) {}

    path(string_type const& s) : m_pathname(s) {}

    path(string_type const& s, codecvt_type const&) : m_pathname(s) {}

#if !defined(BOOST_NO_CXX17_HDR_STRING_VIEW)

    path(std::basic_string_view< value_type > const& s) : m_pathname(s) {}

    path(std::basic_string_view< value_type > const& s, codecvt_type const&) : m_pathname(s) {}

#endif

    template<

        typename Source,

        typename = typename std::enable_if<

            detail::conjunction<

                detail::path_traits::is_path_source< typename std::remove_cv< Source >::type >,

                detail::negation< detail::path_traits::is_native_path_source< typename std::remove_cv< Source >::type > >

            >::value

        >::type

    >

    path(Source const& source)

    {

        assign(source);

    }

    template<

        typename Source,

        typename = typename std::enable_if<

            detail::conjunction<

                detail::path_traits::is_path_source< typename std::remove_cv< Source >::type >,

                detail::negation< detail::path_traits::is_native_path_source< typename std::remove_cv< Source >::type > >

            >::value

        >::type

    >

    explicit path(Source const& source, codecvt_type const& cvt)

    {

        assign(source, cvt);

    }

    path(path&& p) noexcept : m_pathname(static_cast< string_type&& >(p.m_pathname))

    {

    }

    path(path&& p, codecvt_type const&) noexcept : m_pathname(static_cast< string_type&& >(p.m_pathname))

    {

    }

    path& operator=(path&& p) noexcept

    {

        m_pathname = static_cast< string_type&& >(p.m_pathname);

        return *this;

    }

    path& assign(path&& p) noexcept

    {

        m_pathname = static_cast< string_type&& >(p.m_pathname);

        return *this;

    }

    path& assign(path&& p, codecvt_type const&) noexcept

    {

        m_pathname = static_cast< string_type&& >(p.m_pathname);

        return *this;

    }

    path(string_type&& s) noexcept : m_pathname(static_cast< string_type&& >(s))

    {

    }

    path(string_type&& s, codecvt_type const&) noexcept : m_pathname(static_cast< string_type&& >(s))

    {

    }

    path& operator=(string_type&& p) noexcept

    {

        m_pathname = static_cast< string_type&& >(p);

        return *this;

    }

    path& assign(string_type&& p) noexcept

    {

        m_pathname = static_cast< string_type&& >(p);

        return *this;

    }

    path& assign(string_type&& p, codecvt_type const&) noexcept

    {

        m_pathname = static_cast< string_type&& >(p);

        return *this;

    }

    path(const value_type* begin, const value_type* end) : m_pathname(begin, end) {}

    path(const value_type* begin, const value_type* end, codecvt_type const&) : m_pathname(begin, end) {}

    template<

        typename InputIterator,

        typename = typename std::enable_if<

            detail::conjunction<

                detail::path_traits::is_path_source_iterator< InputIterator >,

                detail::negation< detail::path_traits::is_native_char_ptr< InputIterator > >

            >::value

        >::type

    >

    path(InputIterator begin, InputIterator end)

    {

        if (begin != end)

        {

            typedef std::basic_string< typename std::iterator_traits< InputIterator >::value_type > source_t;

            source_t source(begin, end);

            assign(static_cast< source_t&& >(source));

        }

    }

    template<

        typename InputIterator,

        typename = typename std::enable_if<

            detail::conjunction<

                detail::path_traits::is_path_source_iterator< InputIterator >,

                detail::negation< detail::path_traits::is_native_char_ptr< InputIterator > >

            >::value

        >::type

    >

    path(InputIterator begin, InputIterator end, codecvt_type const& cvt)

    {

        if (begin != end)

        {

            typedef std::basic_string< typename std::iterator_traits< InputIterator >::value_type > source_t;

            source_t source(begin, end);

            assign(static_cast< source_t&& >(source), cvt);

        }

    }

    path(std::nullptr_t) = delete;

    path& operator= (std::nullptr_t) = delete;

public:

    //  -----  assignments  -----

    // We need to explicitly define copy assignment as otherwise it will be implicitly defined as deleted because there is move assignment

    path& operator=(path const& p);

    template< typename Source >

    typename std::enable_if<

        detail::disjunction<

            detail::path_traits::is_path_source< typename std::remove_cv< Source >::type >,

            detail::path_traits::is_convertible_to_path_source< typename std::remove_cv< Source >::type >

        >::value,

        path&

    >::type operator=(Source const& source)

    {

        return assign(source);

    }

    path& assign(path const& p)

    {

        m_pathname = p.m_pathname;

        return *this;

    }

    template< typename Source >

    typename std::enable_if<

        detail::path_traits::is_path_source< typename std::remove_cv< Source >::type >::value,

        path&

    >::type assign(Source const& source)

    {

        detail::path_traits::dispatch(source, assign_op(*this));

        return *this;

    }

    template< typename Source >

    typename std::enable_if<

        detail::conjunction<

            detail::path_traits::is_convertible_to_path_source< typename std::remove_cv< Source >::type >,

            detail::negation< detail::path_traits::is_path_source< typename std::remove_cv< Source >::type > >

        >::value,

        path&

    >::type assign(Source const& source)

    {

        detail::path_traits::dispatch_convertible(source, assign_op(*this));

        return *this;

    }

    path& assign(path const& p, codecvt_type const&)

    {

        m_pathname = p.m_pathname;

        return *this;

    }

    template< typename Source >

    typename std::enable_if<

        detail::path_traits::is_path_source< typename std::remove_cv< Source >::type >::value,

        path&

    >::type assign(Source const& source, codecvt_type const& cvt)

    {

        detail::path_traits::dispatch(source, assign_op(*this), &cvt);

        return *this;

    }

    template< typename Source >

    typename std::enable_if<

        detail::conjunction<

            detail::path_traits::is_convertible_to_path_source< typename std::remove_cv< Source >::type >,

            detail::negation< detail::path_traits::is_path_source< typename std::remove_cv< Source >::type > >

        >::value,

        path&

    >::type assign(Source const& source, codecvt_type const& cvt)

    {

        detail::path_traits::dispatch_convertible(source, assign_op(*this), &cvt);

        return *this;

    }

    path& assign(const value_type* begin, const value_type* end)

    {

        m_pathname.assign(begin, end);

        return *this;

    }

    template< typename InputIterator >

    typename std::enable_if<

        detail::conjunction<

            detail::path_traits::is_path_source_iterator< InputIterator >,

            detail::negation< detail::path_traits::is_native_char_ptr< InputIterator > >

        >::value,

        path&

    >::type assign(InputIterator begin, InputIterator end)

    {

        m_pathname.clear();

        if (begin != end)

        {

            typedef std::basic_string< typename std::iterator_traits< InputIterator >::value_type > source_t;

            source_t source(begin, end);

            assign(static_cast< source_t&& >(source));

        }

        return *this;

    }

    path& assign(const value_type* begin, const value_type* end, codecvt_type const&)

    {

        m_pathname.assign(begin, end);

        return *this;

    }

    template< typename InputIterator >

    typename std::enable_if<

        detail::conjunction<

            detail::path_traits::is_path_source_iterator< InputIterator >,

            detail::negation< detail::path_traits::is_native_char_ptr< InputIterator > >

        >::value,

        path&

    >::type assign(InputIterator begin, InputIterator end, codecvt_type const& cvt)

    {

        m_pathname.clear();

        if (begin != end)

        {

            typedef std::basic_string< typename std::iterator_traits< InputIterator >::value_type > source_t;

            source_t source(begin, end);

            assign(static_cast< source_t&& >(source), cvt);

        }

        return *this;

    }

    //  -----  concatenation  -----

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

    template< typename Source >

    typename std::enable_if<

        detail::path_traits::is_convertible_to_path_source< typename std::remove_cv< Source >::type >::value,

        path&

    >::type operator+=(Source const& source)

    {

        return concat(source);

    }

    path& operator+=(value_type c)

    {

        m_pathname.push_back(c);

        return *this;

    }

    template< typename CharT >

    typename std::enable_if<

        detail::path_traits::is_path_char_type< CharT >::value,

        path&

    >::type operator+=(CharT c)

    {

        CharT tmp[2];

        tmp[0] = c;

        tmp[1] = static_cast< CharT >(0);

        concat_op(*this)(tmp, tmp + 1);

        return *this;

    }

    path& concat(path const& p)

    {

        m_pathname.append(p.m_pathname);

        return *this;

    }

    template< typename Source >

    typename std::enable_if<

        detail::path_traits::is_path_source< typename std::remove_cv< Source >::type >::value,

        path&

    >::type concat(Source const& source)

    {

        detail::path_traits::dispatch(source, concat_op(*this));

        return *this;

    }

    template< typename Source >

    typename std::enable_if<

        detail::conjunction<

            detail::path_traits::is_convertible_to_path_source< typename std::remove_cv< Source >::type >,

            detail::negation< detail::path_traits::is_path_source< typename std::remove_cv< Source >::type > >

        >::value,

        path&

    >::type concat(Source const& source)

    {

        detail::path_traits::dispatch_convertible(source, concat_op(*this));

        return *this;

    }

    path& concat(path const& p, codecvt_type const&)

    {

        m_pathname.append(p.m_pathname);

        return *this;

    }

    template< typename Source >

    typename std::enable_if<

        detail::path_traits::is_path_source< typename std::remove_cv< Source >::type >::value,

        path&

    >::type concat(Source const& source, codecvt_type const& cvt)

    {

        detail::path_traits::dispatch(source, concat_op(*this), &cvt);

        return *this;

    }

    template< typename Source >

    typename std::enable_if<

        detail::conjunction<

            detail::path_traits::is_convertible_to_path_source< typename std::remove_cv< Source >::type >,

            detail::negation< detail::path_traits::is_path_source< typename std::remove_cv< Source >::type > >

        >::value,

        path&

    >::type concat(Source const& source, codecvt_type const& cvt)

    {

        detail::path_traits::dispatch_convertible(source, concat_op(*this), &cvt);

        return *this;

    }

    path& concat(const value_type* begin, const value_type* end)

    {

        m_pathname.append(begin, end);

        return *this;

    }

    template< typename InputIterator >

    typename std::enable_if<

        detail::conjunction<

            detail::path_traits::is_path_source_iterator< InputIterator >,

            detail::negation< detail::path_traits::is_native_char_ptr< InputIterator > >

        >::value,

        path&

    >::type concat(InputIterator begin, InputIterator end)

    {

        if (begin != end)

        {

            std::basic_string< typename std::iterator_traits< InputIterator >::value_type > source(begin, end);

            detail::path_traits::dispatch(source, concat_op(*this));

        }

        return *this;

    }

    path& concat(const value_type* begin, const value_type* end, codecvt_type const&)

    {

        m_pathname.append(begin, end);

        return *this;

    }

    template< typename InputIterator >

    typename std::enable_if<

        detail::conjunction<

            detail::path_traits::is_path_source_iterator< InputIterator >,

            detail::negation< detail::path_traits::is_native_char_ptr< InputIterator > >

        >::value,

        path&

    >::type concat(InputIterator begin, InputIterator end, codecvt_type const& cvt)

    {

        if (begin != end)

        {

            std::basic_string< typename std::iterator_traits< InputIterator >::value_type > source(begin, end);

            detail::path_traits::dispatch(source, concat_op(*this), &cvt);

        }

        return *this;

    }

    //  -----  appends  -----

    //  if a separator is added, it is the preferred separator for the platform;

    //  slash for POSIX, backslash for Windows

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

    template< typename Source >

    BOOST_FORCEINLINE typename std::enable_if<

        detail::path_traits::is_convertible_to_path_source< typename std::remove_cv< Source >::type >::value,

        path&

    >::type operator/=(Source const& source)

    {

        return append(source);

    }

    path& append(path const& p);

    template< typename Source >

    BOOST_FORCEINLINE typename std::enable_if<

        detail::path_traits::is_path_source< typename std::remove_cv< Source >::type >::value,

        path&

    >::type append(Source const& source)

    {

        detail::path_traits::dispatch(source, append_op(*this));

        return *this;

    }

    template< typename Source >

    BOOST_FORCEINLINE typename std::enable_if<

        detail::conjunction<

            detail::path_traits::is_convertible_to_path_source< typename std::remove_cv< Source >::type >,

            detail::negation< detail::path_traits::is_path_source< typename std::remove_cv< Source >::type > >

        >::value,

        path&

    >::type append(Source const& source)

    {

        detail::path_traits::dispatch_convertible(source, append_op(*this));

        return *this;

    }

    path& append(path const& p, codecvt_type const&);

    template< typename Source >

    BOOST_FORCEINLINE typename std::enable_if<

        detail::path_traits::is_path_source< typename std::remove_cv< Source >::type >::value,

        path&

    >::type append(Source const& source, codecvt_type const& cvt)

    {

        detail::path_traits::dispatch(source, append_op(*this), &cvt);

        return *this;

    }

    template< typename Source >

    BOOST_FORCEINLINE typename std::enable_if<

        detail::conjunction<

            detail::path_traits::is_convertible_to_path_source< typename std::remove_cv< Source >::type >,

            detail::negation< detail::path_traits::is_path_source< typename std::remove_cv< Source >::type > >

        >::value,

        path&

    >::type append(Source const& source, codecvt_type const& cvt)

    {

        detail::path_traits::dispatch_convertible(source, append_op(*this), &cvt);

        return *this;

    }

    path& append(const value_type* begin, const value_type* end);

    template< typename InputIterator >

    BOOST_FORCEINLINE typename std::enable_if<

        detail::conjunction<

            detail::path_traits::is_path_source_iterator< InputIterator >,

            detail::negation< detail::path_traits::is_native_char_ptr< InputIterator > >

        >::value,

        path&

    >::type append(InputIterator begin, InputIterator end)

    {

        std::basic_string< typename std::iterator_traits< InputIterator >::value_type > source(begin, end);

        detail::path_traits::dispatch(source, append_op(*this));

        return *this;

    }

    path& append(const value_type* begin, const value_type* end, codecvt_type const&);

    template< typename InputIterator >

    BOOST_FORCEINLINE typename std::enable_if<

        detail::conjunction<

            detail::path_traits::is_path_source_iterator< InputIterator >,

            detail::negation< detail::path_traits::is_native_char_ptr< InputIterator > >

        >::value,

        path&

    >::type append(InputIterator begin, InputIterator end, const codecvt_type& cvt)

    {

        std::basic_string< typename std::iterator_traits< InputIterator >::value_type > source(begin, end);

        detail::path_traits::dispatch(source, append_op(*this), &cvt);

        return *this;

    }

    //  -----  modifiers  -----

    void clear() noexcept { m_pathname.clear(); }

    path& make_preferred();

    path& remove_filename();

    BOOST_FILESYSTEM_DECL path& remove_filename_and_trailing_separators();

    BOOST_FILESYSTEM_DECL path& remove_trailing_separator();

    BOOST_FILESYSTEM_DECL path& replace_filename(path const& replacement);

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

    void swap(path& rhs) noexcept { 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  -----

    string_type const& native() const noexcept { return m_pathname; }

    const value_type* c_str() const noexcept { return m_pathname.c_str(); }

    string_type::size_type size() const noexcept { return m_pathname.size(); }

    template< typename String >

    String string() const;

    template< typename String >

    String string(codecvt_type const& cvt) const;

#ifdef BOOST_FILESYSTEM_WINDOWS_API

    std::string string() const

    {

        std::string tmp;

        if (!m_pathname.empty())

            detail::path_traits::convert(m_pathname.data(), m_pathname.data() + m_pathname.size(), tmp);

        return tmp;

    }

    std::string string(codecvt_type const& cvt) const

    {

        std::string tmp;

        if (!m_pathname.empty())

            detail::path_traits::convert(m_pathname.data(), m_pathname.data() + m_pathname.size(), tmp, &cvt);

        return tmp;

    }

    //  string_type is std::wstring, so there is no conversion

    std::wstring const& wstring() const { return m_pathname; }

    std::wstring const& wstring(codecvt_type const&) const { return m_pathname; }

#else // BOOST_FILESYSTEM_POSIX_API

    //  string_type is std::string, so there is no conversion

    std::string const& string() const { return m_pathname; }

    std::string const& string(codecvt_type const&) const { return m_pathname; }

    std::wstring wstring() const

    {

        std::wstring tmp;

        if (!m_pathname.empty())

            detail::path_traits::convert(m_pathname.data(), m_pathname.data() + m_pathname.size(), tmp);

        return tmp;

    }

    std::wstring wstring(codecvt_type const& cvt) const

    {

        std::wstring tmp;

        if (!m_pathname.empty())

            detail::path_traits::convert(m_pathname.data(), m_pathname.data() + m_pathname.size(), tmp, &cvt);

        return tmp;

    }

#endif

    //  -----  generic format observers  -----

    //  Experimental generic function returning generic formatted path (i.e. separators

    //  are forward slashes). Motivation: simpler than a family of generic_*string

    //  functions.

    path generic_path() const;

    template< typename String >

    String generic_string() const;

    template< typename String >

    String generic_string(codecvt_type const& cvt) const;

    std::string generic_string() const { return generic_path().string(); }

    std::string generic_string(codecvt_type const& cvt) const { return generic_path().string(cvt); }

    std::wstring generic_wstring() const { return generic_path().wstring(); }

    std::wstring generic_wstring(codecvt_type const& cvt) const { return generic_path().wstring(cvt); }

    //  -----  compare  -----

    int compare(path const& p) const; // generic, lexicographical

    template< typename Source >

    BOOST_FORCEINLINE typename std::enable_if<

        detail::path_traits::is_path_source< typename std::remove_cv< Source >::type >::value,

        int

    >::type compare(Source const& source) const

    {

        return detail::path_traits::dispatch(source, compare_op(*this));

    }

    template< typename Source >

    BOOST_FORCEINLINE typename std::enable_if<

        detail::conjunction<

            detail::path_traits::is_convertible_to_path_source< typename std::remove_cv< Source >::type >,

            detail::negation< detail::path_traits::is_path_source< typename std::remove_cv< Source >::type > >

        >::value,

        int

    >::type compare(Source const& source) const

    {

        return detail::path_traits::dispatch_convertible(source, compare_op(*this));

    }

    template< typename Source >

    BOOST_FORCEINLINE typename std::enable_if<

        detail::path_traits::is_path_source< typename std::remove_cv< Source >::type >::value,

        int

    >::type compare(Source const& source, codecvt_type const& cvt) const

    {

        return detail::path_traits::dispatch(source, compare_op(*this), &cvt);

    }

    template< typename Source >

    BOOST_FORCEINLINE typename std::enable_if<

        detail::conjunction<

            detail::path_traits::is_convertible_to_path_source< typename std::remove_cv< Source >::type >,

            detail::negation< detail::path_traits::is_path_source< typename std::remove_cv< Source >::type > >

        >::value,

        int

    >::type compare(Source const& source, codecvt_type const& cvt) const

    {

        return detail::path_traits::dispatch_convertible(source, compare_op(*this), &cvt);

    }

    //  -----  decomposition  -----

    path root_path() const { return path(m_pathname.c_str(), m_pathname.c_str() + detail::path_algorithms::find_root_path_size(*this)); }

    // returns 0 or 1 element path even on POSIX, root_name() is non-empty() for network paths

    path root_name() const { return path(m_pathname.c_str(), m_pathname.c_str() + detail::path_algorithms::find_root_name_size(*this)); }

    // returns 0 or 1 element path

    path root_directory() const

    {

        detail::path_algorithms::substring root_dir = detail::path_algorithms::find_root_directory(*this);

        const value_type* p = m_pathname.c_str() + root_dir.pos;

        return path(p, p + root_dir.size);

    }

    path relative_path() const

    {

        detail::path_algorithms::substring rel_path = detail::path_algorithms::find_relative_path(*this);

        const value_type* p = m_pathname.c_str() + rel_path.pos;

        return path(p, p + rel_path.size);

    }

    path parent_path() const { return path(m_pathname.c_str(), m_pathname.c_str() + detail::path_algorithms::find_parent_path_size(*this)); }

    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 noexcept { return m_pathname.empty(); }

    bool filename_is_dot() const;

    bool filename_is_dot_dot() const;

    bool has_root_path() const { return detail::path_algorithms::find_root_path_size(*this) > 0; }

    bool has_root_name() const { return detail::path_algorithms::find_root_name_size(*this) > 0; }

    bool has_root_directory() const { return detail::path_algorithms::find_root_directory(*this).size > 0; }

    bool has_relative_path() const { return detail::path_algorithms::find_relative_path(*this).size > 0; }

    bool has_parent_path() const { return detail::path_algorithms::find_parent_path_size(*this) > 0; }

    bool has_filename() const;

    bool has_stem() const { return !stem().empty(); }

    bool has_extension() const { return !extension().empty(); }

    bool is_relative() const { return !is_absolute(); }

    bool is_absolute() const

    {

#if defined(BOOST_FILESYSTEM_WINDOWS_API)

        return has_root_name() && has_root_directory();

#else

        return has_root_directory();

#endif

    }

    //  -----  lexical operations  -----

    path lexically_normal() const;

    BOOST_FILESYSTEM_DECL path lexically_relative(path const& base) const;

    path lexically_proximate(path const& base) const;

    //  -----  iterators  -----

    BOOST_FILESYSTEM_DECL iterator begin() const;

    BOOST_FILESYSTEM_DECL iterator end() const;

    reverse_iterator rbegin() const;

    reverse_iterator rend() const;

    //  -----  static member functions  -----

    static BOOST_FILESYSTEM_DECL std::locale imbue(std::locale const& loc);

    static BOOST_FILESYSTEM_DECL codecvt_type const& codecvt();

    //--------------------------------------------------------------------------------------//

    //                            class path private members                                //

    //--------------------------------------------------------------------------------------//

private:

    /*

     * 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

};

namespace detail {

BOOST_FILESYSTEM_DECL path const& dot_path();

BOOST_FILESYSTEM_DECL path const& dot_dot_path();

} // namespace detail

namespace path_detail {

//------------------------------------------------------------------------------------//

//                             class path::iterator                                   //

//------------------------------------------------------------------------------------//

class path_iterator :

    public boost::iterator_facade<

        path_iterator,

        const path,

        boost::bidirectional_traversal_tag

    >

{

private:

    friend class boost::iterator_core_access;

    friend class boost::filesystem::path;

    friend class path_reverse_iterator;

    friend struct boost::filesystem::detail::path_algorithms;

    path const& dereference() const { return m_element; }

    bool equal(path_iterator const& rhs) const noexcept

    {

        return m_path_ptr == rhs.m_path_ptr && m_pos == rhs.m_pos;

    }

    void increment();

    void decrement();

private:

    // current element

    path m_element;

    // path being iterated over

    const path* m_path_ptr;

    // position of m_element in m_path_ptr->m_pathname.

    // if m_element is implicit dot, m_pos is the

    // position of the last separator in the path.

    // end() iterator is indicated by

    // m_pos == m_path_ptr->m_pathname.size()

    path::string_type::size_type m_pos;

};

//------------------------------------------------------------------------------------//