Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help 
std::filesystem::is_fifo(3)   C++ Standard Libary  std::filesystem::is_fifo(3)

NAME
       std::filesystem::is_fifo	- std::filesystem::is_fifo

Synopsis
	  Defined in header <filesystem>
	  bool	  is_fifo(    std::filesystem::file_status   s	 )   noexcept;
       (1) (since C++17)
	  bool	   is_fifo(	const	  std::filesystem::path&     p	    );
       (2) (since C++17)
	  bool	is_fifo(  const	 std::filesystem::path&	p, std::error_code& ec
       (3) (since C++17)
	  ) noexcept;

	  Checks if the	given file status or path corresponds  to  a  FIFO  or
       pipe file as if
	  determined by	POSIX S_ISFIFO.

	  1) Equivalent	to s.type() == file_type::fifo.
	  2,3)	Equivalent to is_fifo(status(p)) or is_fifo(status(p, ec)) re-
       spectively.

Parameters
	  s  - file status to check
	  p  - path to query
	  ec - error code to modify in case of errors

Return value
	  true if the file indicated by	p or if	the type indicated s refers to
       a FIFO pipe,
	  false	otherwise. The non-throwing overload returns false if an error
       occurs.

Exceptions
	  Any overload not marked noexcept may throw std::bad_alloc if	memory
       allocation
	  fails.

	  2,3)	Sets  a	std::error_code& parameter to the OS API error code if
       an OS API call
	  fails, and executes ec.clear() if no errors occur.

Example
       // Run this code

	#include <cstdio>
	#include <cstring>
	#include <filesystem>
	#include <fstream>
	#include <iostream>
	#include <sys/socket.h>
	#include <sys/stat.h>
	#include <sys/un.h>
	#include <unistd.h>

	namespace fs = std::filesystem;

	void demo_status(const fs::path& p, fs::file_status s)
	{
	    std::cout << p;
	    // alternative: switch(s.type())  {	 case  fs::file_type::regular:
       ...}
	    if (fs::is_regular_file(s))
		std::cout << " is a regular file\n";
	    if (fs::is_directory(s))
		std::cout << " is a directory\n";
	    if (fs::is_block_file(s))
		std::cout << " is a block device\n";
	    if (fs::is_character_file(s))
		std::cout << " is a character device\n";
	    if (fs::is_fifo(s))
		std::cout << " is a named IPC pipe\n";
	    if (fs::is_socket(s))
		std::cout << " is a named IPC socket\n";
	    if (fs::is_symlink(s))
		std::cout << " is a symlink\n";
	    if (!fs::exists(s))
		std::cout << " does not	exist\n";
	}

	int main()
	{
	    // create files of different kinds
	    fs::create_directory("sandbox");
	    fs::create_directory("sandbox/dir");
	    std::ofstream{"sandbox/file"}; // create regular file
	    fs::create_symlink("file", "sandbox/symlink");

	    mkfifo("sandbox/pipe", 0644);
	    sockaddr_un	addr;
	    addr.sun_family = AF_UNIX;
	    std::strcpy(addr.sun_path, "sandbox/sock");
	    int	fd = socket(PF_UNIX, SOCK_STREAM, 0);
	    bind(fd, reinterpret_cast<sockaddr*>(&addr), sizeof	addr);

	    // demo different status accessors
	    for	 (auto it{fs::directory_iterator("sandbox")}; it != fs::direc-
       tory_iterator();	++it)
		demo_status(*it, it->symlink_status());	// use	cached	status
       from directory entry
	    demo_status("/dev/null", fs::status("/dev/null")); // direct calls
       to status
	    demo_status("/dev/sda", fs::status("/dev/sda"));
	    demo_status("sandbox/no", fs::status("/sandbox/no"));

	    // cleanup (prefer std::unique_ptr-based custom deleters)
	    close(fd);
	    fs::remove_all("sandbox");
	}

Possible output:
	"sandbox/file" is a regular file
	"sandbox/dir" is a directory
	"sandbox/pipe" is a named IPC pipe
	"sandbox/sock" is a named IPC socket
	"sandbox/symlink" is a symlink
	"/dev/null" is a character device
	"/dev/sda" is a	block device
	"sandbox/no" does not exist

See also
	  status	    determines file attributes
	  symlink_status     determines	 file attributes, checking the symlink
       target
	  (C++17)	    (function)
	  (C++17)
	  file_status	    represents file type and permissions
	  (C++17)	    (class)
	  status_known	    checks whether file	status is known
	  (C++17)	    (function)
	  is_block_file	    checks whether the given path refers to block  de-
       vice
	  (C++17)	    (function)
	  is_character_file  checks whether the	given path refers to a charac-
       ter device
	  (C++17)	    (function)
	  is_directory	    checks whether the given path refers to  a	direc-
       tory
	  (C++17)	    (function)
	  is_other	     checks  whether  the  argument refers to an other
       file
	  (C++17)	    (function)
	  is_regular_file   checks whether the argument	refers	to  a  regular
       file
	  (C++17)	    (function)
	  is_socket	     checks whether the	argument refers	to a named IPC
       socket
	  (C++17)	    (function)
	  is_symlink	    checks whether the argument	refers to  a  symbolic
       link
	  (C++17)	    (function)
	  exists	    checks whether path	refers to existing file	system
       object
	  (C++17)	    (function)
			    checks  whether  the  directory  entry refers to a
       named pipe
	  is_fifo	    (public member function of std::filesystem::direc-
       tory_entry)

http://cppreference.com		  2024.06.10	   std::filesystem::is_fifo(3)

Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=std::filesystem::is_fifo&sektion=3&manpath=FreeBSD+Ports+15.1.quarterly>

home | help