29 Input/output library [input.output]

• (4.1)
  If

  (options & copy_options::create_symlinks) != copy_options::none ||
  (options & copy_options::skip_symlinks) != copy_options::none
  

  then auto f = symlink_­status(from) and if needed auto t = symlink_­status(to).
• (4.2)
  Otherwise, if

  (options & copy_options::copy_symlinks) != copy_options::none
  

  then auto f = symlink_­status(from) and if needed auto t = status(to).
• (4.3)
  Otherwise, auto f = status(from) and if needed auto t = status(to).

• (4.4)
  If f.type() or t.type() is an implementation-defined file type ([fs.enum.file.type]), then the effects are implementation-defined.
• (4.5)
  Otherwise, an error is reported as specified in [fs.err.report] if:
  • (4.5.1)
    exists(f) is false, or
  • (4.5.2)
    equivalent(from, to) is true, or
  • (4.5.3)
    is_­other(f) || is_­other(t) is true, or
  • (4.5.4)
    is_­directory(f) && is_­regular_­file(t) is true.
• (4.6)
  Otherwise, if is_­symlink(f), then:
  • (4.6.1)
    If (options & copy_­options​::​skip_­symlinks) != copy_­options​::​none then return.
  • (4.6.2)
    Otherwise if

    !exists(t) && (options & copy_options::copy_symlinks) != copy_options::none
    

    then copy_­symlink(from, to).
  • (4.6.3)
    Otherwise report an error as specified in [fs.err.report].
• (4.7)
  Otherwise, if is_­regular_­file(f), then:
  • (4.7.1)
    If (options & copy_­options​::​directories_­only) != copy_­options​::​none, then return.
  • (4.7.2)
    Otherwise, if (options & copy_­options​::​create_­symlinks) != copy_­options​::​none, then create a symbolic link to the source file.
  • (4.7.3)
    Otherwise, if (options & copy_­options​::​create_­hard_­links) != copy_­options​::​none, then create a hard link to the source file.
  • (4.7.4)
    Otherwise, if is_­directory(t), then copy_­file(from, to/from.filename(), options).
  • (4.7.5)
    Otherwise, copy_­file(from, to, options).
• (4.8)
  Otherwise, if

  is_directory(f) &&
  (options & copy_options::create_symlinks) != copy_options::none
  

  then report an error with an error_­code argument equal to make_­error_­code(errc​::​is_­a_­directory).
• (4.9)
  Otherwise, if

  is_directory(f) &&
  ((options & copy_options::recursive) != copy_options::none ||
   options == copy_options::none)
  

  then:
  • (4.9.1)
    If exists(t) is false, then create_­directory(to, from).
  • (4.9.2)
    Then, iterate over the files in from, as if by

    for (const directory_entry& x : directory_iterator(from))
      copy(x.path(), to/x.path().filename(),
           options | copy_options::in-recursive-copy);
    

    where in-recursive-copy is a bitmask element of copy_­options that is not one of the elements in [fs.enum.copy.opts].
• (4.10)
  Otherwise, for the signature with argument ec, ec.clear().
• (4.11)
  Otherwise, no effects.

• (4.1)
  Report an error as specified in [fs.err.report] if:
  • (4.1.1)
    is_­regular_­file(from) is false, or
  • (4.1.2)
    exists(to) is true and is_­regular_­file(to) is false, or
  • (4.1.3)
    exists(to) is true and equivalent(from, to) is true, or
  • (4.1.4)
    exists(to) is true and

    (options & (copy_options::skip_existing |
                copy_options::overwrite_existing |
                copy_options::update_existing)) == copy_options::none
    

• (4.2)
  Otherwise, copy the contents and attributes of the file from resolves to, to the file to resolves to, if:
  • (4.2.1)
    exists(to) is false, or
  • (4.2.2)
    (options & copy_­options​::​overwrite_­existing) != copy_­options​::​none, or
  • (4.2.3)
    (options & copy_­options​::​update_­existing) != copy_­options​::​none and from is more recent than to, determined as if by use of the last_­write_­time function ([fs.op.last.write.time]).
• (4.3)
  Otherwise, no effects.

• (2.1)
  exists(to) && exists(new_­hard_­link) && equivalent(to, new_­hard_­link)
• (2.2)
  The contents of the file or directory to resolves to are unchanged.

• (2.1)
  If is_­regular_­file(p), the size in bytes of the file p resolves to, determined as if by the value of the POSIX stat class member st_­size obtained as if by POSIX stat().
• (2.2)
  Otherwise, the result is implementation-defined.

• (1.1)
  Determine file_­status s, as if by status(p) or status(p, ec), respectively.
• (1.2)
  For the signature with argument ec, return false if an error occurred.
• (1.3)
  Otherwise, if is_­directory(s):
  • (1.3.1)
    Create a variable itr, as if by directory_­iterator itr(p) or directory_­iterator itr(p, ec), respectively.
  • (1.3.2)
    For the signature with argument ec, return false if an error occurred.
  • (1.3.3)
    Otherwise, return itr == directory_­iterator().
• (1.4)
  Otherwise:
  • (1.4.1)
    Determine uintmax_­t sz, as if by file_­size(p) or file_­size(p, ec), respectively.
  • (1.4.2)
    For the signature with argument ec, return false if an error occurred.
  • (1.4.3)
    Otherwise, return sz == 0.

weakly_canonical(p).lexically_proximate(weakly_canonical(base));

weakly_canonical(p, ec).lexically_proximate(weakly_canonical(base, ec));

weakly_canonical(p).lexically_relative(weakly_canonical(base));

weakly_canonical(p, ec).lexically_relative(weakly_canonical(base, ec));

error_code ec;
file_status result = status(p, ec);
if (result.type() == file_type::none)
  throw filesystem_error(implementation-supplied-message, p, ec);
return result;

• (6.1)
  If ec != error_­code():
  • (6.1.1)
    If the specific error indicates that p cannot be resolved because some element of the path does not exist, returns file_­status(file_­type​::​not_­found).
  • (6.1.2)
    Otherwise, if the specific error indicates that p can be resolved but the attributes cannot be determined, returns file_­status(file_­type​::​unknown).
  • (6.1.3)
    Otherwise, returns file_­status(file_­type​::​none).
  [ Note

  : These semantics distinguish between p being known not to exist, p existing but not being able to determine its attributes, and there being an error that prevents even knowing if p exists. These distinctions are important to some use cases. — end note

   ]
• (6.2)
  Otherwise,
  • (6.2.1)
    If the attributes indicate a regular file, as if by POSIX S_­ISREG, returns file_­status(file_­type​::​regular, prms).
    [ Note

    : file_­type​::​regular implies appropriate <fstream> operations would succeed, assuming no hardware, permission, access, or file system race errors. Lack of file_­type​::​regular does not necessarily imply <fstream> operations would fail on a directory. — end note

     ]
  • (6.2.2)
    Otherwise, if the attributes indicate a directory, as if by POSIX S_­ISDIR, returns file_­status(file_­type​::​directory, prms).
    [ Note

    : file_­type​::​directory implies that calling directory_­iterator(p) would succeed. — end note

     ]
  • (6.2.3)
    Otherwise, if the attributes indicate a block special file, as if by POSIX S_­ISBLK, returns file_­status(file_­type​::​block, prms).
  • (6.2.4)
    Otherwise, if the attributes indicate a character special file, as if by POSIX S_­ISCHR, returns file_­status(file_­type​::​character, prms).
  • (6.2.5)
    Otherwise, if the attributes indicate a fifo or pipe file, as if by POSIX S_­ISFIFO, returns file_­status(file_­type​::​fifo, prms).
  • (6.2.6)
    Otherwise, if the attributes indicate a socket, as if by POSIX S_­ISSOCK, returns file_­status(file_­type​::​socket, prms).
  • (6.2.7)
    Otherwise, if the attributes indicate an implementation-defined file type ([fs.enum.file.type]), returns file_­status(file_­type​::​A, prms), where A is the constant for the implementation-defined file type.
  • (6.2.8)
    Otherwise, returns file_­status(file_­type​::​unknown, prms).