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

//  Copyright Beman Dawes 2002-2005

//  Copyright Vladimir Prus 2002

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

//  basic_path's 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 <boost/system/system_error.hpp>

#include <boost/iterator/iterator_facade.hpp>

#include <boost/throw_exception.hpp>

#include <boost/shared_ptr.hpp>

#include <boost/type_traits/is_same.hpp>

#include <boost/static_assert.hpp>

#include <string>

#include <algorithm> // for lexicographical_compare

#include <iosfwd>    // needed by basic_path inserter and extractor

#include <stdexcept>

#include <cassert>

# ifndef BOOST_FILESYSTEM_NARROW_ONLY

#   include <locale>

# endif

#include <boost/config/abi_prefix.hpp> // must be the last #include

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

namespace boost

{

  namespace BOOST_FILESYSTEM_NAMESPACE

  {

    template<class String, class Traits> class basic_path;

    struct path_traits;

    typedef basic_path< std::string, path_traits > path;

    struct path_traits

    {

      typedef std::string internal_string_type;

      typedef std::string external_string_type;

      static external_string_type to_external( const path &,

        const internal_string_type & src ) { return src; }

      static internal_string_type to_internal(

        const external_string_type & src ) { return src; }

    };

# ifndef BOOST_FILESYSTEM_NARROW_ONLY

    struct BOOST_FILESYSTEM_DECL wpath_traits;

    typedef basic_path< std::wstring, wpath_traits > wpath;

    struct BOOST_FILESYSTEM_DECL wpath_traits

    {

      typedef std::wstring internal_string_type;

# ifdef BOOST_WINDOWS_API

      typedef std::wstring external_string_type;

      static external_string_type to_external( const wpath &,

        const internal_string_type & src ) { return src; }

      static internal_string_type to_internal(

        const external_string_type & src ) { return src; }

# else

      typedef std::string external_string_type;

      static external_string_type to_external( const wpath & ph,

        const internal_string_type & src );

      static internal_string_type to_internal(

        const external_string_type & src );

# endif

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

      static bool imbue( const std::locale & loc, const std::nothrow_t & );

    };

# endif // ifndef BOOST_FILESYSTEM_NARROW_ONLY

    //  path traits  ---------------------------------------------------------//

    template<class Path> struct is_basic_path

      { BOOST_STATIC_CONSTANT( bool, value = false ); };

    template<> struct is_basic_path<path>

      { BOOST_STATIC_CONSTANT( bool, value = true ); };

# ifndef BOOST_FILESYSTEM_NARROW_ONLY

    template<> struct is_basic_path<wpath>

      { BOOST_STATIC_CONSTANT( bool, value = true ); };

# endif

    // These only have to be specialized if Path::string_type::value_type

    // is not convertible from char, although specializations may eliminate

    // compiler warnings. See ticket 2543.

    template<class Path> struct slash

      { BOOST_STATIC_CONSTANT( char, value = '/' ); };

    template<class Path> struct dot

      { BOOST_STATIC_CONSTANT( char, value = '.' ); };

    template<class Path> struct colon

      { BOOST_STATIC_CONSTANT( char, value = ':' ); };

# ifndef BOOST_FILESYSTEM_NARROW_ONLY

    template<> struct slash<wpath>

      { BOOST_STATIC_CONSTANT( wchar_t, value = L'/' ); };

    template<> struct dot<wpath>

      { BOOST_STATIC_CONSTANT( wchar_t, value = L'.' ); };

    template<> struct colon<wpath>

      { BOOST_STATIC_CONSTANT( wchar_t, value = L':' ); };

# endif

# ifdef BOOST_WINDOWS_PATH

    template<class Path> struct path_alt_separator

      { BOOST_STATIC_CONSTANT( char, value = '\\' ); };

#   ifndef BOOST_FILESYSTEM_NARROW_ONLY

    template<> struct path_alt_separator<wpath>

      { BOOST_STATIC_CONSTANT( wchar_t, value = L'\\' ); };

#   endif

# endif

    //  workaround for VC++ 7.0 and earlier issues with nested classes

    namespace detail

    {

      template<class Path>

      class iterator_helper

      {

      public:

        typedef typename Path::iterator iterator;

        static void do_increment( iterator & ph );

        static void do_decrement( iterator & ph );

      };

    }

    //  basic_path  ----------------------------------------------------------//

    template<class String, class Traits>

    class basic_path

    {

    // invariant: m_path valid according to the portable generic path grammar

      // validate template arguments

// TODO: get these working

//      BOOST_STATIC_ASSERT( ::boost::is_same<String,typename Traits::internal_string_type>::value );

//      BOOST_STATIC_ASSERT( ::boost::is_same<typename Traits::external_string_type,std::string>::value || ::boost::is_same<typename Traits::external_string_type,std::wstring>::value );

    public:

      // compiler generates copy constructor and copy assignment

      typedef basic_path<String, Traits> path_type;

      typedef String string_type;

      typedef typename String::value_type value_type;

      typedef Traits traits_type;

      typedef typename Traits::external_string_type external_string_type; 

      // constructors/destructor

      basic_path() {}

      basic_path( const string_type & s ) { operator/=( s ); }

      basic_path( const value_type * s )  { operator/=( s ); }

#     ifndef BOOST_NO_MEMBER_TEMPLATES

        template <class InputIterator>

          basic_path( InputIterator first, InputIterator last )

            { append( first, last ); }

#     endif

     ~basic_path() {}

      // assignments

      basic_path & operator=( const string_type & s )

      {

#     if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, >= 310)

        m_path.clear();

#     else

        m_path.erase( m_path.begin(), m_path.end() );

#     endif

        operator/=( s ); 

        return *this;

      }

      basic_path & operator=( const value_type * s )

      { 

#     if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, >= 310)

        m_path.clear();

#     else

        m_path.erase( m_path.begin(), m_path.end() );

#     endif

        operator/=( s ); 

        return *this;

      }

#     ifndef BOOST_NO_MEMBER_TEMPLATES

        template <class InputIterator>

          basic_path & assign( InputIterator first, InputIterator last )

            { m_path.clear(); append( first, last ); return *this; }

#     endif

      // modifiers

      basic_path & operator/=( const basic_path & rhs )  { return operator /=( rhs.string().c_str() ); }

      basic_path & operator/=( const string_type & rhs ) { return operator /=( rhs.c_str() ); }

      basic_path & operator/=( const value_type * s );

#     ifndef BOOST_NO_MEMBER_TEMPLATES

        template <class InputIterator>

          basic_path & append( InputIterator first, InputIterator last );

#     endif

      void swap( basic_path & rhs )

      {

        m_path.swap( rhs.m_path );

#       ifdef BOOST_CYGWIN_PATH

          std::swap( m_cygwin_root, rhs.m_cygwin_root );

#       endif

      }

      basic_path & remove_filename();

      basic_path & replace_extension( const string_type & new_extension = string_type() );

# ifndef BOOST_FILESYSTEM_NO_DEPRECATED

      basic_path & remove_leaf() { return remove_filename(); }

# endif

      // observers

      const string_type & string() const         { return m_path; }

      const string_type file_string() const;

      const string_type directory_string() const { return file_string(); }

      const external_string_type external_file_string() const { return Traits::to_external( *this, file_string() ); }

      const external_string_type external_directory_string() const { return Traits::to_external( *this, directory_string() ); }

      basic_path   root_path() const;

      string_type  root_name() const;

      string_type  root_directory() const;

      basic_path   relative_path() const;

      basic_path   parent_path() const;

      string_type  filename() const;

      string_type  stem() const;

      string_type  extension() const;

# ifndef BOOST_FILESYSTEM_NO_DEPRECATED

      string_type  leaf() const            { return filename(); }

      basic_path   branch_path() const     { return parent_path(); }

      bool         has_leaf() const        { return !m_path.empty(); }

      bool         has_branch_path() const { return !parent_path().empty(); }

# endif

      bool empty() const               { return m_path.empty(); } // name consistent with std containers

      bool is_complete() const;

      bool has_root_path() const;

      bool has_root_name() const;

      bool has_root_directory() const;

      bool has_relative_path() const   { return !relative_path().empty(); }

      bool has_filename() const        { return !m_path.empty(); }

      bool has_parent_path() const     { return !parent_path().empty(); }

      // iterators

      class iterator : public boost::iterator_facade<

        iterator,

        string_type const,

        boost::bidirectional_traversal_tag >

      {

      private:

        friend class boost::iterator_core_access;

        friend class boost::BOOST_FILESYSTEM_NAMESPACE::basic_path<String, Traits>;

        const string_type & dereference() const

          { return m_name; }

        bool equal( const iterator & rhs ) const

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

        friend class boost::BOOST_FILESYSTEM_NAMESPACE::detail::iterator_helper<path_type>;

        void increment()

        { 

          boost::BOOST_FILESYSTEM_NAMESPACE::detail::iterator_helper<path_type>::do_increment(

            *this );

        }

        void decrement()

        { 

          boost::BOOST_FILESYSTEM_NAMESPACE::detail::iterator_helper<path_type>::do_decrement(

            *this );

        }

        string_type             m_name;     // current element

        const basic_path *      m_path_ptr; // path being iterated over

        typename string_type::size_type  m_pos;  // position of name in

                                            // path_ptr->string(). The

                                            // end() iterator is indicated by 

                                            // pos == path_ptr->m_path.size()

      }; // iterator

      typedef iterator const_iterator;

      iterator begin() const;

      iterator end() const;

    private:

      // Note: This is an implementation for POSIX and Windows, where there

      // are only minor differences between generic and native path grammars.

      // Private members might be quite different in other implementations,

      // particularly where there were wide differences between portable and

      // native path formats, or between file_string() and

      // directory_string() formats, or simply that the implementation

      // was willing expend additional memory to achieve greater speed for

      // some operations at the expense of other operations.

      string_type  m_path; // invariant: portable path grammar

                           // on Windows, backslashes converted to slashes

#   ifdef BOOST_CYGWIN_PATH

      bool m_cygwin_root; // if present, m_path[0] was slash. note: initialization

                          // done by append

#   endif  

      void m_append_separator_if_needed();

      void m_append( value_type value ); // converts Windows alt_separator

      // Was qualified; como433beta8 reports:

      //    warning #427-D: qualified name is not allowed in member declaration 

      friend class iterator;

      friend class boost::BOOST_FILESYSTEM_NAMESPACE::detail::iterator_helper<path_type>;

      // Deprecated features ease transition for existing code. Don't use these

      // in new code.

# ifndef BOOST_FILESYSTEM_NO_DEPRECATED

    public:

      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 );}

      string_type native_file_string() const { return file_string(); }

      string_type native_directory_string() const { return directory_string(); }

      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();

      basic_path & normalize();

# endif

    };

  //  basic_path non-member functions  ---------------------------------------//

    template< class String, class Traits >

    inline void swap( basic_path<String, Traits> & lhs,

               basic_path<String, Traits> & rhs ) { lhs.swap( rhs ); }

    template< class String, class Traits >

    bool operator<( const basic_path<String, Traits> & lhs, const basic_path<String, Traits> & rhs )

    {

      return std::lexicographical_compare(

        lhs.begin(), lhs.end(), rhs.begin(), rhs.end() );

    }

    template< class String, class Traits >

    bool operator<( const typename basic_path<String, Traits>::string_type::value_type * lhs,

                    const basic_path<String, Traits> & rhs )

    {

      basic_path<String, Traits> tmp( lhs );

      return std::lexicographical_compare(

        tmp.begin(), tmp.end(), rhs.begin(), rhs.end() );

    }

    template< class String, class Traits >

    bool operator<( const typename basic_path<String, Traits>::string_type & lhs,

                    const basic_path<String, Traits> & rhs )

    {

      basic_path<String, Traits> tmp( lhs );

      return std::lexicographical_compare(

        tmp.begin(), tmp.end(), rhs.begin(), rhs.end() );

    }

    template< class String, class Traits >

    bool operator<( const basic_path<String, Traits> & lhs,

                    const typename basic_path<String, Traits>::string_type::value_type * rhs )

    {

      basic_path<String, Traits> tmp( rhs );

      return std::lexicographical_compare(

        lhs.begin(), lhs.end(), tmp.begin(), tmp.end() );

    }

    template< class String, class Traits >

    bool operator<( const basic_path<String, Traits> & lhs,

                    const typename basic_path<String, Traits>::string_type & rhs )

    {

      basic_path<String, Traits> tmp( rhs );

      return std::lexicographical_compare(

        lhs.begin(), lhs.end(), tmp.begin(), tmp.end() );

    }

    //  operator == uses string compare rather than !(lhs < rhs) && !(rhs < lhs) because

    //  the result is the same yet the direct string compare is much more efficient that

    //  lexicographical_compare, and lexicographical_compare used twice at that.

    template< class String, class Traits >

    inline bool operator==( const basic_path<String, Traits> & lhs, const basic_path<String, Traits> & rhs )

    { 

      return lhs.string() == rhs.string();

    }

    template< class String, class Traits >

    inline bool operator==( const typename basic_path<String, Traits>::string_type::value_type * lhs,

                    const basic_path<String, Traits> & rhs )

    {

      return lhs == rhs.string();

    }

    template< class String, class Traits >

    inline bool operator==( const typename basic_path<String, Traits>::string_type & lhs,

                    const basic_path<String, Traits> & rhs )

    {

      return lhs == rhs.string();

    }

    template< class String, class Traits >

    inline bool operator==( const basic_path<String, Traits> & lhs,

                    const typename basic_path<String, Traits>::string_type::value_type * rhs )

    {

      return lhs.string() == rhs;

    }

    template< class String, class Traits >

    inline bool operator==( const basic_path<String, Traits> & lhs,

                    const typename basic_path<String, Traits>::string_type & rhs )

    {

      return lhs.string() == rhs;

    }

    template< class String, class Traits >

    inline bool operator!=( const basic_path<String, Traits> & lhs,

      const basic_path<String, Traits> & rhs )

        { return !(lhs == rhs); }

    template< class String, class Traits >

    inline bool operator!=( const typename basic_path<String,

      Traits>::string_type::value_type * lhs,

        const basic_path<String, Traits> & rhs )

        { return !(lhs == rhs); }

    template< class String, class Traits >

    inline bool operator!=( const typename basic_path<String, Traits>::string_type & lhs,

      const basic_path<String, Traits> & rhs )

        { return !(lhs == rhs); }

    template< class String, class Traits >

    inline bool operator!=( const basic_path<String, Traits> & lhs,

      const typename basic_path<String, Traits>::string_type::value_type * rhs )

        { return !(lhs == rhs); }

    template< class String, class Traits >

    inline bool operator!=( const basic_path<String, Traits> & lhs,

      const typename basic_path<String, Traits>::string_type & rhs )

        { return !(lhs == rhs); }

    template< class String, class Traits >

    inline bool operator>( const basic_path<String, Traits> & lhs, const basic_path<String, Traits> & rhs ) { return rhs < lhs; }

    template< class String, class Traits >

    inline bool operator>( const typename basic_path<String, Traits>::string_type::value_type * lhs,

                    const basic_path<String, Traits> & rhs ) { return rhs < basic_path<String, Traits>(lhs); }

    template< class String, class Traits >

    inline bool operator>( const typename basic_path<String, Traits>::string_type & lhs,

                    const basic_path<String, Traits> & rhs ) { return rhs < basic_path<String, Traits>(lhs); }

    template< class String, class Traits >

    inline bool operator>( const basic_path<String, Traits> & lhs,

                    const typename basic_path<String, Traits>::string_type::value_type * rhs )

                    { return basic_path<String, Traits>(rhs) < lhs; }

    template< class String, class Traits >

    inline bool operator>( const basic_path<String, Traits> & lhs,

                    const typename basic_path<String, Traits>::string_type & rhs )

                    { return basic_path<String, Traits>(rhs) < lhs; }

    template< class String, class Traits >

    inline bool operator<=( const basic_path<String, Traits> & lhs, const basic_path<String, Traits> & rhs ) { return !(rhs < lhs); }

    template< class String, class Traits >

    inline bool operator<=( const typename basic_path<String, Traits>::string_type::value_type * lhs,

                    const basic_path<String, Traits> & rhs ) { return !(rhs < basic_path<String, Traits>(lhs)); }

    template< class String, class Traits >

    inline bool operator<=( const typename basic_path<String, Traits>::string_type & lhs,

                    const basic_path<String, Traits> & rhs ) { return !(rhs < basic_path<String, Traits>(lhs)); }

    template< class String, class Traits >

    inline bool operator<=( const basic_path<String, Traits> & lhs,

                    const typename basic_path<String, Traits>::string_type::value_type * rhs )

                    { return !(basic_path<String, Traits>(rhs) < lhs); }

    template< class String, class Traits >

    inline bool operator<=( const basic_path<String, Traits> & lhs,

                    const typename basic_path<String, Traits>::string_type & rhs )

                    { return !(basic_path<String, Traits>(rhs) < lhs); }

    template< class String, class Traits >

    inline bool operator>=( const basic_path<String, Traits> & lhs, const basic_path<String, Traits> & rhs ) { return !(lhs < rhs); }

    template< class String, class Traits >

    inline bool operator>=( const typename basic_path<String, Traits>::string_type::value_type * lhs,

                    const basic_path<String, Traits> & rhs ) { return !(lhs < basic_path<String, Traits>(rhs)); }

    template< class String, class Traits >

    inline bool operator>=( const typename basic_path<String, Traits>::string_type & lhs,

                    const basic_path<String, Traits> & rhs ) { return !(lhs < basic_path<String, Traits>(rhs)); }

    template< class String, class Traits >

    inline bool operator>=( const basic_path<String, Traits> & lhs,

                    const typename basic_path<String, Traits>::string_type::value_type * rhs )

                    { return !(basic_path<String, Traits>(lhs) < rhs); }

    template< class String, class Traits >

    inline bool operator>=( const basic_path<String, Traits> & lhs,

                    const typename basic_path<String, Traits>::string_type & rhs )

                    { return !(basic_path<String, Traits>(lhs) < rhs); }

    // operator /

    template< class String, class Traits >

    inline basic_path<String, Traits> operator/( 

      const basic_path<String, Traits> & lhs,

      const basic_path<String, Traits> & rhs )

      { return basic_path<String, Traits>( lhs ) /= rhs; }

    template< class String, class Traits >