std::filesystem::directory_entry::is_socket
bool is_socket() const; bool is_socket( std::error_code& ec ) const noexcept; |
(desde C++17) | |
Verifica si el objeto al que se apunta es un socket de comunicación interproceso con nombre. Efectivamente devuelve std::filesystem::is_socket(status()) o std::filesystem::is_socket(status(ec)), respectivamente.
Parámetros
| ec | - | El parámetro de salida para informe de errores en la sobrecarga que no lanza excepciones. |
Valor de retorno
true si el objeto del sistema de archivos al que se hace referencia es un socket de comunicación interproceso con nombre, false de lo contrario.
Excepciones
La sobrecarga que no toma un parámetro std::error_code& lanza filesystem::filesystem_error en los errores de la API del sistema operativo subyacente, construido con p como el primer argumento de la ruta de acceso y el código de error del sistema operativo como el argumento del código de error. La sobrecarga que toma un parámetro std::error_code& lo establece en el código de error de la API del sistema operativo si una llamada a la API del sistema operativo falla, y ejecuta ec.clear() si no ocurren errores. Cualquier sobrecarga que no está marcada con noexcept puede lanzar std::bad_alloc si la asignación de memoria falla.
Ejemplo
#include <cstdio>
#include <cstring>
#include <filesystem>
#include <fstream>
#include <functional>
#include <iostream>
#include <memory>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/un.h>
#include <unistd.h>
namespace fs = std::filesystem;
void print_entry_type(std::filesystem::directory_entry const& entry) {
std::cout << entry.path() << ": ";
if (!entry.exists()) std::cout << "no existe ";
if (entry.is_block_file()) std::cout << "es un dispositivo orientado a bloques ";
if (entry.is_character_file()) std::cout << "es un dispositivo orientado a caracteres ";
if (entry.is_directory()) std::cout << "es un directorio ";
if (entry.is_fifo()) std::cout << "es una tubería IPC con nombre ";
if (entry.is_regular_file()) std::cout << "es un archivo regular ";
if (entry.is_socket()) std::cout << "es un socket IPC con nombre ";
if (entry.is_symlink()) std::cout << "(un enlace simbólico) ";
if (entry.is_other()) std::cout << "(un archivo `other`) ";
std::cout <<'\n';
}
template <typename Type, typename Fun>
class scoped_cleanup {
std::unique_ptr<Type, std::function<void(const Type*)>> u;
public:
scoped_cleanup(Type* ptr, Fun fun) : u{ptr, std::move(fun)} {}
};
int main()
{
// crear archivos de distintos tipos
std::filesystem::current_path(fs::temp_directory_path());
const std::filesystem::path sandbox{"sandbox"};
scoped_cleanup remove_all_at_exit{&sandbox, [](const fs::path* p) {
std::cout << "limpieza: remove_all(" << *p << ")\n";
fs::remove_all(*p);
} };
std::filesystem::create_directory(sandbox);
std::ofstream{sandbox/"file"}; // crea un archivo regular
std::filesystem::create_directory(sandbox/"dir");
mkfifo((sandbox/"pipe").string().data(), 0644);
struct sockaddr_un addr; addr.sun_family = AF_UNIX;
std::strcpy(addr.sun_path, (sandbox/"sock").string().data());
int fd {socket(PF_UNIX, SOCK_STREAM, 0)};
scoped_cleanup close_socket_at_exit{&fd, [](const int* f) {
std::cout << "limpieza: cerrar socket #" << *f << '\n';
close(*f);
} };
bind(fd, reinterpret_cast<sockaddr*>(std::addressof(addr)), sizeof addr);
fs::create_symlink("file", sandbox/"symlink");
for (std::filesystem::directory_entry entry: fs::directory_iterator(sandbox)) {
print_entry_type(entry);
}
// llamadas directas a estado:
for (const char* str: {"/dev/null", "/dev/cpu", "/usr/include/c++",
"/usr/include/asm", "/usr/include/time.h"}) {
print_entry_type(fs::directory_entry{str});
}
} // limpieza mediante objetos `scoped_cleanup`
Posible salida:
"sandbox/symlink": es un archivo regular (un enlace simbólico)
"sandbox/sock": es un socket IPC con nombre (un archivo `other`)
"sandbox/pipe": es una tubería IPC con nombre (un archivo `other`)
"sandbox/dir": es un directorio
"sandbox/file": es un archivo regular
"/dev/null": es un dispositivo orientado a caracteres (un archivo `other`)
"/dev/cpu": no existe
"/usr/include/c++": es un directorio
"/usr/include/asm": es un directorio (un enlace simbólico)
"/usr/include/time.h": es un archivo regular
limpieza: cerrar socket #3
limpieza: remove_all("sandbox")
Véase también
(C++17) |
Verifica si el argumento se refiere a un socket de comunicación interproceso con nombre. (función) |