std::filesy...copy_options(3)

✨ NAME ✨

okay bestie, we're in the C++ Standard Libary manual (yes, that's literally the spelling on the page, not me 😭), and this is the page for std::filesystem::copy_options — aka std::filesystem::copy_options. iconic name, honestly 💅

🦋 Synopsis 🦋

Defined in header <filesystem>:

Defined in header <filesystem>
enum class copy_options {

    none = /* unspecified */,
    skip_existing = /* unspecified */,
    overwrite_existing = /* unspecified */,
    update_existing = /* unspecified */,
    recursive = /* unspecified */,           (since C++17)
    copy_symlinks = /* unspecified */,
    skip_symlinks = /* unspecified */,
    directories_only = /* unspecified */,
    create_symlinks = /* unspecified */,
    create_hard_links = /* unspecified */

};

So this type is literally the options menu for controlling the behavior of the copy() and copy_file() function. very main character energy for an enum, ngl 💖

copy_options satisfies the requirements of BitmaskType — which means the bitwise operators operator&, operator|, operator^, operator~, operator&=, operator|=, and operator^= are defined for this type. none represents the empty bitmask; every other enumerator represents a distinct bitmask element. slay, bitwise bestie ✨

💅 Member constants 💅

okay so listen: at most one copy option in each of the following options groups may be present, otherwise the behavior of the copy functions is undefined. no cap, do not mix and match inside a group 😭

🎀 options controlling copy_file() when the file already exists 🎀

• none — Report an error (default behavior).
• skip_existing — Keep the existing file, without reporting an error.
• overwrite_existing — Replace the existing file.
• update_existing — Replace the existing file only if it is older than the file being copied.

🌸 options controlling the effects of copy() on subdirectories 🌸

• none — Skip subdirectories (default behavior).
• recursive — Recursively copy subdirectories and their content.

🦋 options controlling the effects of copy() on symbolic links 🦋

• none — Follow symlinks (default behavior).
• copy_symlinks — Copy symlinks as symlinks, not as the files they point to.
• skip_symlinks — Ignore symlinks.

👑 options controlling the kind of copying copy() does 👑

• none — Copy file content (default behavior).
• directories_only — Copy the directory structure, but do not copy any non-directory files.
• create_symlinks — Instead of creating copies of files, create symlinks pointing to the originals. Note: the source path must be an absolute path unless the destination path is in the current directory.
• create_hard_links — Instead of creating copies of files, create hardlinks that resolve to the same files as the originals.

🌈 Example 🌈

// Run this code

#include <cstdlib>
#include <filesystem>
#include <fstream>
#include <iostream>
namespace fs = std::filesystem;

int main()
{
    fs::create_directories("sandbox/dir/subdir");
    std::ofstream("sandbox/file1.txt").put('a');
    fs::copy("sandbox/file1.txt", "sandbox/file2.txt"); // copy file
    fs::copy("sandbox/dir", "sandbox/dir2"); // copy directory (non-recursive)
    const auto copyOptions = fs::copy_options::update_existing
                           | fs::copy_options::recursive
                           | fs::copy_options::directories_only
                           ;
    fs::copy("sandbox", "sandbox_copy", copyOptions);
    static_cast<void>(std::system("tree"));
    fs::remove_all("sandbox");
    fs::remove_all("sandbox_copy");
}

🎀 Possible output 🎀

.
├── sandbox
│   ├── dir
│   │   └── subdir
│   ├── dir2
│   ├── file1.txt
│   └── file2.txt
└── sandbox_copy
    ├── dir
    │   └── subdir
    └── dir2

8 directories, 2 files

🔥 See also 🔥

• copy — (C++17) copies files or directories (function)
• copy_file — (C++17) copies file contents (function)

💖 source: http://cppreference.com · version/date: 2024.06.10 · page: std::filesy...copy_options(3) — and that's the whole manual page, bestie. periodt. 💖