How do I copy files and folders using boost and Visual Studio 2005?

Question

I'm trying to use boost::filesystem to copy files and folders (just like a standard copy a folder and paste it in windows explorer).

Although I've been to the boost::filesystem documentation, I still don't really know how to go about doing this.

Do you have to recursively go though each directory (creating it) and find each file copying it?

Additionally, how do you copy the file in C++/Boost?

P.S. I'm using Boost 1.40.0

Update I think I may have ended up creating an answer to this one, only concern being that I don't do any try-catch errors to check for locked files and folders.

The following code makes a copy of a directory in the relative path "../example/ecomm" and duplicates it to a non-existing path "../example/dup_ecomm":

#include <boost/test/unit_test.hpp>
#include <boost/algorithm/string.hpp>
#include <boost/filesystem/operations.hpp>
#include <boost/regex.hpp>
#include <iostream>
#include <fstream>
#include<string>

bool copy_dir( const boost::filesystem::path & ext_dir_path,         // the existing directory
         const boost::filesystem::path & duplicate_dir_path  // the duplicate directory
       )
{
  std::cout << "BEGIN: copy_dir " << endl;
  std::cout << "- ext_dir_path: " << ext_dir_path << endl;
  std::cout << "- duplicate_dir_path: " << duplicate_dir_path << endl;

  // 1. Ensure that the directory we are trying to copy exists.
  if (!boost::filesystem::exists( ext_dir_path ) ) return false;

  bool createdDir = boost::filesystem::create_directory( duplicate_dir_path );

  // cout << "createdDir: " << createdDir << endl;


  copy_dir(ext_dir_path,         // the existing directory
        duplicate_dir_path,  // the duplicate directory,
        ext_dir_path,    // the base path for the existing directory
        duplicate_dir_path,
        true);

  std::cout << "END: copy_dir " << endl;
}


bool copy_dir( const boost::filesystem::path & ext_dir_path,         // the existing directory
         const boost::filesystem::path & duplicate_dir_path,  // the duplicate directory,
         const boost::filesystem::path & base_ext_dir_path,    // the base path for the existing directory
         const boost::filesystem::path & base_duplicate_dir_path, // the base path for the duplicate of the exisiting directory
         bool isRootPath)
{
  // Debug input arguments
  std::cout << "BEGIN: copy_dir " << endl;
  std::cout << "- ext_dir_path: " << ext_dir_path << endl;
  std::cout << "- duplicate_dir_path: " << duplicate_dir_path << endl;
  std::cout << "- base_ext_dir_path: " << base_ext_dir_path << endl;
  std::cout << "- base_duplicate_dir_path: " << base_duplicate_dir_path << endl;
  std::cout << "- isRootPath: " << isRootPath << endl;

  boost::filesystem::directory_iterator end_itr; // default construction yields past-the-end

  cout << "--Beginning itr loop" << endl;
  for ( boost::filesystem::directory_iterator itr( ext_dir_path );
        itr != end_itr;
        ++itr )
  {

    if ( boost::filesystem::is_directory(itr->status()) )
    {
     cout << "---itr->path(): " << itr->path() << endl;


     boost::filesystem::path newExtDir(itr->path());

     string dup_path = itr->path().string();
     boost::algorithm::replace_first(dup_path, base_ext_dir_path.string(), base_duplicate_dir_path.string());
     cout << "dup_path: " << dup_path << endl;

     boost::filesystem::path new_dup_dir(dup_path);

     bool createdDir = boost::filesystem::create_directory( new_dup_dir );

     cout << "creating directory " << dup_path << " created: " << createdDir << endl;

     boost::filesystem::path newDuplicateDir(duplicate_dir_path);

     copy_dir(newExtDir,         // the existing directory
       newDuplicateDir,   // the duplicate directory,
       base_ext_dir_path,
       base_duplicate_dir_path,
       false);
    }
    else 
    {
            cout << "---isLeaf: " << itr->path() << endl;

     string dup_path = itr->path().string();

     boost::algorithm::replace_first(dup_path, base_ext_dir_path.string(), base_duplicate_dir_path.string());

     string src_path = itr->path().string();

     cout << "src_path: " << src_path << endl;
     cout << "dup_path: " << dup_path << endl;

     boost::filesystem::path s_path(src_path);
     boost::filesystem::path d_path(dup_path);

     boost::filesystem::copy_file(s_path, d_path);
    }

  }
  std::cout << "--Ending itr loop" << endl;


  std::cout << "END: copy_dir " << endl;

  return false;
}

test_suite*
init_unit_test_suite( int, char* [] ) {

    boost::filesystem::path ext_dir("..\\example\\ecomm");
    boost::filesystem::path dir_dup("..\\example\\dup_ecomm");

    copy_dir(ext_dir,
          dir_dup);  // the duplicate directory,

        // ... unit tests...etc...
}

My question now is what I'm I forgetting to do in regards to locked files and directories?

Answer 1

boost::filesystem::recursive_directory_iterator