boost/filesystem/convenience.hpp

   1 //  boost/filesystem/convenience.hpp  ----------------------------------------//
   2
   3 //  Copyright Beman Dawes, 2002-2005
   4 //  Copyright Vladimir Prus, 2002
   5 //  Use, modification, and distribution is subject to the Boost Software
   6 //  License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
   7 //  http://www.boost.org/LICENSE_1_0.txt)
   8
   9 //  See library home page at http://www.boost.org/libs/filesystem
  10
  11 //----------------------------------------------------------------------------//
  12
  13 #ifndef BOOST_FILESYSTEM_CONVENIENCE_HPP
  14 #define BOOST_FILESYSTEM_CONVENIENCE_HPP
  15
  16 #include <boost/filesystem/operations.hpp>
  17 #include <boost/system/error_code.hpp>
  18 #include <vector>
  19 #include <stack>
  20
  21 #include <boost/config/abi_prefix.hpp> // must be the last #include
  22
  23 # ifndef BOOST_FILESYSTEM_NARROW_ONLY
  24 #   define BOOST_FS_FUNC(BOOST_FS_TYPE) \
  25       template<class Path> typename boost::enable_if<is_basic_path<Path>, \
  26       BOOST_FS_TYPE>::type
  27 #   define BOOST_FS_FUNC_STRING BOOST_FS_FUNC(typename Path::string_type)
  28 #   define BOOST_FS_TYPENAME typename
  29 # else
  30 #   define BOOST_FS_FUNC(BOOST_FS_TYPE) inline BOOST_FS_TYPE
  31     typedef boost::filesystem::path Path;
  32 #   define BOOST_FS_FUNC_STRING inline std::string
  33 #   define BOOST_FS_TYPENAME
  34 # endif
  35
  36 namespace boost
  37 {
  38   namespace filesystem
  39   {
  40
  41     BOOST_FS_FUNC(bool) create_directories(const Path& ph)
  42     {
  43          if (ph.empty() || exists(ph))
  44          {
  45            if ( !ph.empty() && !is_directory(ph) )
  46                boost::throw_exception( basic_filesystem_error<Path>(
  47                  "boost::filesystem::create_directories", ph,
  48                  make_error_code( boost::system::posix::file_exists ) ) );
  49            return false;
  50          }
  51
  52          // First create branch, by calling ourself recursively
  53          create_directories(ph.parent_path());
  54          // Now that parent's path exists, create the directory
  55          create_directory(ph);
  56          return true;
  57      }
  58
  59 # ifndef BOOST_FILESYSTEM_NO_DEPRECATED
  60
  61     BOOST_FS_FUNC_STRING extension(const Path& ph)
  62     {
  63       typedef BOOST_FS_TYPENAME Path::string_type string_type;
  64       string_type filename = ph.filename();
  65
  66       BOOST_FS_TYPENAME string_type::size_type n = filename.rfind('.');
  67       if (n != string_type::npos)
  68         return filename.substr(n);
  69       else
  70         return string_type();
  71     }
  72
  73     BOOST_FS_FUNC_STRING basename(const Path& ph)
  74     {
  75       typedef BOOST_FS_TYPENAME Path::string_type string_type;
  76       string_type filename = ph.filename();
  77       BOOST_FS_TYPENAME string_type::size_type n = filename.rfind('.');
  78       return filename.substr(0, n);
  79     }
  80
  81
  82     BOOST_FS_FUNC(Path) change_extension( const Path & ph,
  83       const BOOST_FS_TYPENAME Path::string_type & new_extension )
  84       { return ph.parent_path() / (basename(ph) + new_extension); }
  85
  86 # endif
  87
  88 # ifndef BOOST_FILESYSTEM_NARROW_ONLY
  89
  90     // "do-the-right-thing" overloads  ---------------------------------------//
  91
  92     inline bool create_directories(const path& ph)
  93       { return create_directories<path>(ph); }
  94     inline bool create_directories(const wpath& ph)
  95       { return create_directories<wpath>(ph); }
  96
  97 # ifndef BOOST_FILESYSTEM_NO_DEPRECATED
  98     inline std::string extension(const path& ph)
  99       { return extension<path>(ph); }
 100     inline std::wstring extension(const wpath& ph)
 101       { return extension<wpath>(ph); }
 102
 103     inline std::string basename(const path& ph)
 104       { return basename<path>( ph ); }
 105     inline std::wstring basename(const wpath& ph)
 106       { return basename<wpath>( ph ); }
 107
 108     inline path change_extension( const path & ph, const std::string& new_ex )
 109       { return change_extension<path>( ph, new_ex ); }
 110     inline wpath change_extension( const wpath & ph, const std::wstring& new_ex )
 111       { return change_extension<wpath>( ph, new_ex ); }
 112 # endif
 113
 114 # endif
 115
 116
 117     //  basic_recursive_directory_iterator helpers  --------------------------//
 118
 119     namespace detail
 120     {
 121       template< class Path >
 122       struct recur_dir_itr_imp
 123       {
 124         typedef basic_directory_iterator< Path > element_type;
 125         std::stack< element_type, std::vector< element_type > > m_stack;
 126         int  m_level;
 127         bool m_no_push;
 128         bool m_no_throw;
 129
 130         recur_dir_itr_imp() : m_level(0), m_no_push(false), m_no_throw(false) {}
 131       };
 132
 133     } // namespace detail
 134
 135     //  basic_recursive_directory_iterator  ----------------------------------//
 136
 137     template< class Path >
 138     class basic_recursive_directory_iterator
 139       : public boost::iterator_facade<
 140           basic_recursive_directory_iterator<Path>,
 141           basic_directory_entry<Path>,
 142           boost::single_pass_traversal_tag >
 143     {
 144     public:
 145       typedef Path path_type;
 146
 147       basic_recursive_directory_iterator(){}  // creates the "end" iterator
 148
 149       explicit basic_recursive_directory_iterator( const Path & dir_path );
 150       basic_recursive_directory_iterator( const Path & dir_path,
 151         system::error_code & ec );
 152
 153       int level() const { return m_imp->m_level; }
 154
 155       void pop();
 156       void no_push()
 157       {
 158         BOOST_ASSERT( m_imp.get() && "attempt to no_push() on end iterator" );
 159         m_imp->m_no_push = true;
 160       }
 161
 162       file_status status() const
 163       {
 164         BOOST_ASSERT( m_imp.get()
 165           && "attempt to call status() on end recursive_iterator" );
 166         return m_imp->m_stack.top()->status();
 167       }
 168
 169       file_status symlink_status() const
 170       {
 171         BOOST_ASSERT( m_imp.get()
 172           && "attempt to call symlink_status() on end recursive_iterator" );
 173         return m_imp->m_stack.top()->symlink_status();
 174       }
 175
 176     private:
 177
 178       // shared_ptr provides shallow-copy semantics required for InputIterators.
 179       // m_imp.get()==0 indicates the end iterator.
 180       boost::shared_ptr< detail::recur_dir_itr_imp< Path > >  m_imp;
 181
 182       friend class boost::iterator_core_access;
 183
 184       typename boost::iterator_facade<
 185         basic_recursive_directory_iterator<Path>,
 186         basic_directory_entry<Path>,
 187         boost::single_pass_traversal_tag >::reference
 188       dereference() const
 189       {
 190         BOOST_ASSERT( m_imp.get() && "attempt to dereference end iterator" );
 191         return *m_imp->m_stack.top();
 192       }
 193
 194       void increment();
 195
 196       bool equal( const basic_recursive_directory_iterator & rhs ) const
 197         { return m_imp == rhs.m_imp; }
 198
 199     };
 200
 201     typedef basic_recursive_directory_iterator<path> recursive_directory_iterator;
 202 # ifndef BOOST_FILESYSTEM_NARROW_ONLY
 203     typedef basic_recursive_directory_iterator<wpath> wrecursive_directory_iterator;
 204 # endif
 205
 206     //  basic_recursive_directory_iterator implementation  -------------------//
 207
 208     //  constructors
 209     template<class Path>
 210     basic_recursive_directory_iterator<Path>::
 211       basic_recursive_directory_iterator( const Path & dir_path )
 212       : m_imp( new detail::recur_dir_itr_imp<Path> )
 213     {
 214       m_imp->m_stack.push( basic_directory_iterator<Path>( dir_path ) );
 215       if ( m_imp->m_stack.top () == basic_directory_iterator<Path>() )
 216         { m_imp.reset (); }
 217     }
 218
 219     template<class Path>
 220     basic_recursive_directory_iterator<Path>::
 221       basic_recursive_directory_iterator( const Path & dir_path,
 222         system::error_code & ec )
 223       : m_imp( new detail::recur_dir_itr_imp<Path> )
 224     {
 225       m_imp->m_no_throw = true;
 226       m_imp->m_stack.push( basic_directory_iterator<Path>( dir_path, ec ) );
 227       if ( m_imp->m_stack.top () == basic_directory_iterator<Path>() )
 228         { m_imp.reset (); }
 229     }
 230
 231     //  increment
 232     template<class Path>
 233     void basic_recursive_directory_iterator<Path>::increment()
 234     {
 235       BOOST_ASSERT( m_imp.get() && "increment on end iterator" );
 236
 237       static const basic_directory_iterator<Path> end_itr;
 238
 239       if ( m_imp->m_no_push )
 240         { m_imp->m_no_push = false; }
 241       else if ( is_directory( m_imp->m_stack.top()->status() ) )
 242       {
 243         system::error_code ec;
 244 #if BOOST_WORKAROUND(__CODEGEARC__, BOOST_TESTED_AT(0x610))
 245         if( m_imp->m_no_throw ) {
 246             m_imp->m_stack.push(
 247                 basic_directory_iterator<Path>( *m_imp->m_stack.top(), ec )
 248             );
 249         }
 250         else {
 251             m_imp->m_stack.push(
 252                 basic_directory_iterator<Path>( *m_imp->m_stack.top() )
 253             );
 254         }
 255 #else
 256         m_imp->m_stack.push(
 257           m_imp->m_no_throw
 258             ? basic_directory_iterator<Path>( *m_imp->m_stack.top(), ec )
 259             : basic_directory_iterator<Path>( *m_imp->m_stack.top() ) );
 260 #endif
 261         if ( m_imp->m_stack.top() != end_itr )
 262         {
 263           ++m_imp->m_level;
 264           return;
 265         }
 266         m_imp->m_stack.pop();
 267       }
 268
 269       while ( !m_imp->m_stack.empty()
 270         && ++m_imp->m_stack.top() == end_itr )
 271       {
 272         m_imp->m_stack.pop();
 273         --m_imp->m_level;
 274       }
 275
 276       if ( m_imp->m_stack.empty() ) m_imp.reset(); // done, so make end iterator
 277     }
 278
 279     //  pop
 280     template<class Path>
 281     void basic_recursive_directory_iterator<Path>::pop()
 282     {
 283       BOOST_ASSERT( m_imp.get() && "pop on end iterator" );
 284       BOOST_ASSERT( m_imp->m_level > 0 && "pop with level < 1" );
 285
 286       static const basic_directory_iterator<Path> end_itr;
 287
 288       do
 289       {
 290         m_imp->m_stack.pop();
 291         --m_imp->m_level;
 292       }
 293       while ( !m_imp->m_stack.empty()
 294         && ++m_imp->m_stack.top() == end_itr );
 295
 296       if ( m_imp->m_stack.empty() ) m_imp.reset(); // done, so make end iterator
 297     }
 298
 299   } // namespace filesystem
 300 } // namespace boost
 301
 302 #undef BOOST_FS_FUNC_STRING
 303 #undef BOOST_FS_FUNC
 304
 305 #include <boost/config/abi_suffix.hpp> // pops abi_prefix.hpp pragmas
 306 #endif // BOOST_FILESYSTEM_CONVENIENCE_HPP