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

FreeBSD Manual Pages

  
 
  

home | help 
std::filesy...::is_symlink(3) C++ Standard Libarystd::filesy...::is_symlink(3)

NAME
       std::filesystem::is_symlink - std::filesystem::is_symlink

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

	  Checks  if  the  given file status or	path corresponds to a symbolic
       link, as	if
	  determined by	the POSIX S_IFLNK.

	  1) Equivalent	to s.type() == file_type::symlink.
	  2) Equivalent	to  is_symlink(symlink_status(p))  or  is_symlink(sym-
       link_status(p, ec)).

Parameters
	  s  - file status to check
	  p  - path to examine
	  ec - out-parameter for error reporting in the	non-throwing overload

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

Exceptions
	  2)  The  overload  that  does	 not take a std::error_code& parameter
       throws
	  filesystem::filesystem_error	on  underlying	OS  API	 errors,  con-
       structed	with p as the
	  first	 path  argument	 and the OS error code as the error code argu-
       ment. The overload
	  taking a std::error_code& parameter sets it to the OS	API error code
       if an OS	API
	  call fails, and executes ec.clear() if no errors occur. Any overload
       not marked
	  noexcept may throw std::bad_alloc if memory allocation fails.

Example
       // Run this code

	#include <iostream>
	#include <fstream>
	#include <cstdio>
	#include <cstring>
	#include <filesystem>
	#include <unistd.h>
	#include <sys/socket.h>
	#include <sys/un.h>
	#include <sys/stat.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 de-
       vice\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");
	    std::ofstream("sandbox/file"); // create regular file
	    fs::create_directory("sandbox/dir");
	    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);
	    fs::create_symlink("file", "sandbox/symlink");

	    // 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
	    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_fifo	    checks whether the given path refers  to  a	 named
       pipe
	  (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)
	  exists	    checks whether path	refers to existing file	system
       object
	  (C++17)	    (function)
	  is_symlink	    checks whether the directory  entry	 refers	 to  a
       symbolic	link
			    (public member function of std::filesystem::direc-
       tory_entry)

http://cppreference.com		  2022.07.31	 std::filesy...::is_symlink(3)

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

home | help