Funciones de <experimental/filesystem>

Estas funciones gratuitas en el <experimental/filesystem> encabezado realizan operaciones de modificación y consulta en rutas de acceso, archivos, vínculos simbólicos, directorios y volúmenes. Para obtener más información y ejemplos de código, vea Navegación del sistema de archivos (C++).

Requisitos

Encabezado: <experimental/filesystem>

Espacio de nombres:std::experimental::filesystem

absolute

path absolute(const path& pval, const path& base = current_path());

La función devuelve el nombre de ruta de acceso absoluto correspondiente a pval con respecto al nombre pathname base:

1. Si pval.has_root_name() && pval.has_root_directory() la función devuelve pval.

2. Si pval.has_root_name() && !pval.has_root_directory() la función devuelve pval.root_name() / / absolute(base).root_directory() / absolute(base).relative_path()pval.relative_path().

3. Si !pval.has_root_name() && pval.has_root_directory() la función devuelve absolute(base).root_name() / pval.

4. Si !pval.has_root_name() && !pval.has_root_directory() la función devuelve absolute(base) / pval.

begin

const directory_iterator& begin(const directory_iterator& iter) noexcept;
const recursive_directory_iterator&
    begin(const recursive_directory_iterator& iter) noexcept;

Ambas funciones devuelven iter.

canonical

path canonical(const path& pval, const path& base = current_path());
path canonical(const path& pval, error_code& ec);
path canonical(const path& pval, const path& base, error_code& ec);

Todas las funciones forman un nombre pabs = absolute(pval, base) de ruta de acceso absoluto (o pabs = absolute(pval) para la sobrecarga sin parámetro base) y, a continuación, lo reducen a una forma canónica en la siguiente secuencia de pasos:

1. Reemplace todos los componentes X de ruta de acceso para los que is_symlink(X) sea true por read_symlink(X).

2. Quite todos los componentes . de ruta de acceso (dot es el directorio actual establecido por los componentes de ruta de acceso anteriores).

3. Quite cada par de componentes de ruta de acceso (dot-dot es el directorio primario establecido por los componentes X/.. de ruta de acceso anteriores).

A continuación, la función devuelve pabs.

copy

void copy(const path& from, const path& to);
void copy(const path& from, const path& to, error_code& ec) noexcept;
void copy(const path& from, const path& to, copy_options opts);
void copy(const path& from, const path& to, copy_options opts, error_code& ec) noexcept;

Todas las funciones posiblemente copian o vinculan uno o varios archivos a fromto bajo control de opts, que se toman como copy_options::none para las sobrecargas sin opts parámetros. opts contendrá como máximo una de las siguientes:

• skip_existing, overwrite_existing o update_existing

• copy_symlinks o skip_symlinks

• directories_only, create_symlinks o create_hard_links

Las funciones determinan primero los file_status valores f de from y t para to. Usan symlink_status cuando opts contiene copy_options::create_symlinks, copy_options::skip_symlinkso copy_options::copy_symlinks, según sea necesario para el origen o destino. De lo contrario, usan status.

Si !exists(f) || equivalent(f, t) || is_other(f) || is_other(t) || is_directory(f)&& is_regular_file(t)es , las funciones notifican un error y se detienen. De lo contrario, si is_symlink(f)es , entonces:

• Si options & copy_options::skip_symlinkses , no haga nada.

• De lo contrario, si !exists(t) && options & copy_options::copy_symlinkses , después copy_symlink(from, to).

• De lo contrario, notifique un error.

De lo contrario, si is_regular_file(f)es , entonces:

• Si opts & copy_options::directories_onlyes , no haga nada.

• De lo contrario, si opts & copy_options::create_symlinkses , después create_symlink(from, to).

• De lo contrario, si opts & copy_options::create_hard_linkses , después create_hard_link(from, to).

• De lo contrario, si is_directory(t)es , después copy_file(from, to / from.filename(), opts).

• En caso contrario, es copy_file(from, to, opts).

De lo contrario, si is_directory(f) && (opts & copy_options::recursive || !opts)es , entonces:

if (!exists(t))
{  // copy directory contents recursively
    create_directory(to, from, ec);

    for (directory_iterator next(from), end; ec == error_code() && next != end; ++next)
    {
        copy(next->path(), to / next->path().filename(), opts, ec);
    }
}

De lo contrario, no haga nada.

copy_file

bool copy_file(const path& from, const path& to);
bool copy_file(const path& from, const path& to, error_code& ec) noexcept;
bool copy_file(const path& from, const path& to, copy_options opts);
bool copy_file(const path& from, const path& to, copy_options opts, error_code& ec) noexcept;

Todas las funciones posiblemente copian el archivo en fromto bajo control de opts, que se toma como copy_options::none para las sobrecargas sin opts parámetro. opts contendrá como máximo uno de skip_existing, overwrite_existingo update_existing.

Si exists(to) && !(opts & (copy_options::skip_existing | copy_options::overwrite_existing | copy_options::update_existing))es , notifique como un error que el archivo ya existe.

De lo contrario, si !exists(to) || opts & copy_options::overwrite_existing || opts & copy_options::update_existing&& last_write_time(to) < last_write_time(from) || !(opts & (copy_options::skip_existing | copy_options::overwrite_existing | copy_options::update_existing)), intenta copiar el contenido y los atributos del archivo from en el archivo to. Informe como un error si se produce un error en el intento de copia.

Las funciones devuelven true si la copia se realiza correctamente y false , de lo contrario, .

copy_symlink

void copy_symlink(const path& from, const path& to);
void copy_symlink(const path& from, const path& to, error_code& ec) noexcept;

Si is_directory(from)es , la función llama a create_directory_symlink(from, to). En caso contrario, llama a create_symlink(from, to).

create_directories

bool create_directories(const path& pval);
bool create_directories(const path& pval, error_code& ec) noexcept;

Para un nombre de ruta de acceso como a\/b\/c, la función crea directorios a y a\/b , según sea necesario, para que pueda crear el directorio a\/b\/c. Solo devuelve true si realmente crea el directorio pval.

create_directory

bool create_directory(const path& pval);

bool create_directory(const path& pval, error_code& ec) noexcept;
bool create_directory(const path& pval, const path& attr);
bool create_directory(const path& pval, const path& attr, error_code& ec) noexcept;

La función crea el directorio pval según sea necesario. Solo devuelve true si realmente crea el directorio pval. Si especifica el attr parámetro , la función copia los permisos del archivo existente. Si no especifica el attr parámetro , la función usa perms::all.

create_directory_symlink

void create_directory_symlink(const path& to, const path& link);
void create_directory_symlink(const path& to, const path& link, error_code& ec) noexcept;

La función crea link como un vínculo simbólico al directorio to.

create_hard_link

void create_hard_link(const path& to,  const path& link);
void create_hard_link(const path& to, const path& link, error_code& ec) noexcept;

La función crea link como un vínculo físico al directorio o archivo to.

create_symlink

void create_symlink(const path& to, const path& link);

void create_symlink(const path& to, const path& link, error_code& ec) noexcept;

La función crea link como un vínculo simbólico al archivo to.

current_path

path current_path();
path current_path(error_code& ec);
void current_path(const path& pval);
void current_path(const path& pval, error_code& ec) noexcept;

Las funciones sin parámetro pval devuelven el nombre pathname del directorio actual. Las funciones restantes establecen el directorio actual en pval.

end

directory_iterator end(const directory_iterator&) noexcept;
recursive_directory_iterator end(const recursive_directory_iterator&) noexcept;

La primera función devuelve directory_iterator() y la segunda función devuelve recursive_directory_iterator().

equivalent

bool equivalent(const path& left, const path& right);
bool equivalent(const path& left, const path& right, error_code& ec) noexcept;

Las funciones solo devuelven true si a la izquierda y a la derecha hacen referencia a la misma entidad del sistema de archivos.

exists

bool exists(file_status stat) noexcept;
bool exists(const path& pval);
bool exists(const path& pval, error_code& ec) noexcept;

La primera función devuelve status_known(stat) && stat.type() != file_type::not_found. Las funciones segunda y tercera devuelven exists(status(pval)).

file_size

uintmax_t file_size(const path& pval);
uintmax_t file_size(const path& pval, error_code& ec) noexcept;

Las funciones devuelven el tamaño en bytes del archivo elegido por pval, si exists(pval) && is_regular_file(pval) y el tamaño del archivo se pueden determinar. De lo contrario, notifican un error y devuelven uintmax_t(-1).

hard_link_count

uintmax_t hard_link_count(const path& pval);
uintmax_t hard_link_count(const path& pval, error_code& ec) noexcept;

La función devuelve el número de vínculos duros para pvalo -1 si se produce un error.

hash_value

size_t hash_value(const path& pval) noexcept;

La función devuelve un valor hash para pval.native().

is_block_file

bool is_block_file(file_status stat) noexcept;
bool is_block_file(const path& pval);
bool is_block_file(const path& pval, error_code& ec) noexcept;

La primera función devuelve stat.type() == file_type::block. Las funciones restantes devuelven is_block_file(status(pval)).

is_character_file

bool is_character_file(file_status stat) noexcept;
bool is_character_file(const path& pval);
bool is_character_file(const path& pval, error_code& ec) noexcept;

La primera función devuelve stat.type() == file_type::character. Las funciones restantes devuelven is_character_file(status(pval)).

is_directory

bool is_directory(file_status stat) noexcept;
bool is_directory(const path& pval);
bool is_directory(const path& pval, error_code& ec) noexcept;

La primera función devuelve stat.type() == file_type::directory. Las funciones restantes devuelven is_directory(status(pval)).

is_empty

bool is_empty(const path& pval);
bool is_empty(const path& pval, error_code& ec) noexcept;

Si is_directory(pval)es , la función devuelve directory_iterator(pval) == directory_iterator(). En caso contrario, devuelve file_size(pval) == 0.

is_fifo

bool is_fifo(file_status stat) noexcept;
bool is_fifo(const path& pval);
bool is_fifo(const path& pval, error_code& ec) noexcept;

La primera función devuelve stat.type() == file_type::fifo. Las funciones restantes devuelven is_fifo(status(pval)).

is_other

bool is_other(file_status stat) noexcept;
bool is_other(const path& pval);
bool is_other(const path& pval, error_code& ec) noexcept;

La primera función devuelve exists(stat) && !is_regular_file(stat) && !is_directory(stat) && !is_symlink(stat). Las funciones restantes devuelven is_other(status(pval)).

is_regular_file

bool is_regular_file(file_status stat) noexcept;
bool is_regular_file(const path& pval);
bool is_regular_file(const path& pval, error_code& ec) noexcept;

La primera función devuelve stat.type() == file_type::regular. Las funciones restantes devuelven is_regular_file(status(pval)).

is_socket

bool is_socket(file_status stat) noexcept;
bool is_socket(const path& pval);
bool is_socket(const path& pval, error_code& ec) noexcept;

La primera función devuelve stat.type() == file_type::socket. Las funciones restantes devuelven is_socket(status(pval)).

is_symlink

bool is_symlink(file_status stat) noexcept;
bool is_symlink(const path& pval);
bool is_symlink(const path& pval, error_code& ec) noexcept;

La primera función devuelve stat.type() == file_type::symlink. Las funciones restantes devuelven is_symlink(status(pval)).

last_write_time

file_time_type last_write_time(const path& pval);
file_time_type last_write_time(const path& pval, error_code& ec) noexcept;
void last_write_time(const path& pval, file_time_type new_time);
void last_write_time(const path& pval, file_time_type new_time, error_code& ec) noexcept;

Las dos primeras funciones devuelven la hora de la última modificación de datos para pval, o file_time_type(-1) si se produce un error. Las dos últimas funciones establecen la hora de la última modificación de datos para pvalnew_timeen .

permissions

void permissions(const path& pval, perms mask);
void permissions(const path& pval, perms mask, error_code& ec) noexcept;

Las funciones establecen los permisos para el nombre de ruta de acceso elegido por para pvalmask & perms::mask bajo el control de perms & (perms::add_perms | perms::remove_perms). mask contiene como máximo uno de perms::add_perms y perms::remove_perms.

Si mask & perms::add_permses , las funciones establecen los permisos en status(pval).permissions() | mask & perms::mask. De lo contrario, si mask & perms::remove_permses , las funciones establecen los permisos en status(pval).permissions() & ~(mask & perms::mask). De lo contrario, las funciones establecen los permisos en mask & perms::mask.

read_symlink

path read_symlink(const path& pval);
path read_symlink(const path& pval, error_code& ec);

Las funciones notifican un error y devuelven path() si !is_symlink(pval). De lo contrario, las funciones devuelven un objeto de tipo path que contiene el vínculo simbólico.

remove

bool remove(const path& pval);
bool remove(const path& pval, error_code& ec) noexcept;

Las funciones solo devuelven true si exists(symlink_status(pval)) y el archivo se quitan correctamente. Se quita un vínculo simbólico, no el archivo que elige.

remove_all

uintmax_t remove_all(const path& pval);
uintmax_t remove_all(const path& pval, error_code& ec) noexcept;

Si pval es un directorio, las funciones quitan de forma recursiva todas las entradas del directorio y, a continuación, la propia entrada. De lo contrario, las funciones llaman a remove. Devuelven un recuento de todos los elementos quitados correctamente.

rename

void rename(const path& from, const path& to);
void rename(const path& from, const path& to, error_code& ec) noexcept;

Las funciones cambian de nombre from a to. Se cambia el nombre de un vínculo simbólico, no el archivo que elige.

resize_file

void resize_file(const path& pval, uintmax_t size);
void resize_file(const path& pval, uintmax_t size, error_code& ec) noexcept;

Las funciones modifican el tamaño de un archivo de forma que file_size(pval) == size.

space

space_info space(const path& pval);
space_info space(const path& pval, error_code& ec) noexcept;

La función devuelve información sobre el volumen elegido por pval, en una estructura de tipo space_info. La estructura contiene uintmax_t(-1) para cualquier valor que no se pueda determinar.

status

file_status status(const path& pval);
file_status status(const path& pval, error_code& ec) noexcept;

Las funciones devuelven el estado pathname, el tipo de archivo y los permisos, asociados a pval. Un vínculo simbólico no se prueba, pero el archivo que elige.

status_known

bool status_known(file_status stat) noexcept;

La función devuelve stat.type() != file_type::none

swap

void swap(path& left, path& right) noexcept;

La función intercambia el contenido de izquierda y derecha.

symlink_status

file_status symlink_status(const path& pval);
file_status symlink_status(const path& pval, error_code& ec) noexcept;

Las funciones devuelven el estado de vínculo simbólico pathname, el tipo de archivo y los permisos asociados a pval. Las funciones se comportan igual status(pval) que salvo que se prueba un vínculo simbólico, no el archivo que elija.

system_complete

path system_complete(const path& pval);
path system_complete(const path& pval, error_code& ec);

Las funciones devuelven un pathname absoluto que tiene en cuenta, según sea necesario, el directorio actual asociado a su nombre raíz. Para POSIX, las funciones devuelven absolute(pval).

temp_directory_path

path temp_directory_path();
path temp_directory_path(error_code& ec);

Las funciones devuelven un nombre de ruta de acceso para un directorio adecuado para contener archivos temporales.

u8path

template <class Source>
path u8path(const Source& source);

template <class InIt>
path u8path(InIt first, InIt last);

La primera función se comporta igual path(source) que y la segunda función se comporta igual path(first, last) que, salvo que el origen elegido en cada caso se toma como una secuencia de elementos char codificados como UTF-8, independientemente del sistema de archivos.

Consulte también

<experimental/filesystem>
<experimental/filesystem> enumeraciones
<experimental/filesystem> operadores