llfio_v2_xxx::path_view Class Reference

A borrowed view of a path. A lightweight trivial-type alternative to std::filesystem::path. More...

#include "path_view.hpp"

Inheritance diagram for llfio_v2_xxx::path_view:

Public Types
using	const_iterator = detail::path_view_iterator
	Const iterator type.
using	iterator = const_iterator
	iterator type
using	reverse_iterator = std::reverse_iterator< iterator >
	Reverse iterator.
using	const_reverse_iterator = std::reverse_iterator< const_iterator >
	Const reverse iterator.
using	size_type = path_view_component::size_type
	Size type.
using	difference_type = std::ptrdiff_t
	Difference type.
enum	format : uint8_t {   unknown , native_format , generic_format , auto_format ,   binary_format }
	How to interpret separators. More...
enum	termination { zero_terminated , not_zero_terminated }
	The zero termination to use. More...
using	byte = llfio_v2_xxx ::byte
	Character type for passthrough input.
using	char16_t = detail::char16_t
template<class T >
using	default_rendered_path_deleter = std::default_delete< T >
	The default deleter to use.
template<class T = typename filesystem::path::value_type, class AllocatorOrDeleter = default_rendered_path_deleter<T[]>, size_t _internal_buffer_size = default_internal_buffer_size>
using	zero_terminated_rendered_path = rendered_path< termination::zero_terminated, T, AllocatorOrDeleter, _internal_buffer_size >
	Convenience type alias.
template<class T = typename filesystem::path::value_type, class AllocatorOrDeleter = default_rendered_path_deleter<T[]>, size_t _internal_buffer_size = default_internal_buffer_size>
using	not_zero_terminated_rendered_path = rendered_path< termination::not_zero_terminated, T, AllocatorOrDeleter, _internal_buffer_size >
	Convenience type alias.

Public Member Functions
constexpr	path_view ()
	Constructs an empty path view.
constexpr	path_view (path_view_component p, format fmt=auto_format) noexcept
	Constructs a path view component identical to the input, except with different format interpretation.
	path_view (const filesystem::path &v, format fmt=auto_format) noexcept
template<class Char , typename std::enable_if<(is_source_chartype_acceptable< Char >), bool >::type = true>
constexpr	path_view (const std::basic_string< Char > &v, format fmt=auto_format) noexcept
constexpr	path_view (const char *b, size_t l, enum termination zt, format fmt=auto_format) noexcept
constexpr	path_view (const wchar_t *b, size_t l, enum termination zt, format fmt=auto_format) noexcept
constexpr	path_view (const char8_t *b, size_t l, enum termination zt, format fmt=auto_format) noexcept
constexpr	path_view (const char16_t *b, size_t l, enum termination zt, format fmt=auto_format) noexcept
constexpr	path_view (const byte *b, size_t l, enum termination zt) noexcept
template<class Char , typename std::enable_if<(is_source_chartype_acceptable< Char >), bool >::type = true>
constexpr	path_view (const Char *s, format fmt=auto_format) noexcept
constexpr	path_view (const byte *s) noexcept
template<class Char , typename std::enable_if<(is_source_chartype_acceptable< Char >), bool >::type = true>
constexpr	path_view (basic_string_view< Char > v, enum termination zt, format fmt=auto_format) noexcept
constexpr	path_view (span< const byte > v, enum termination zt) noexcept
template<class It , class End , typename std::enable_if<(is_source_chartype_acceptable< typename It::value_type >), bool >::type = true, typename std::enable_if<(is_source_chartype_acceptable< typename End::value_type >), bool >::type = true>
constexpr	path_view (It b, End e, enum termination zt, format fmt=auto_format) noexcept
template<class It , class End , typename std::enable_if<(is_source_chartype_acceptable< std::decay_t< It > >), bool >::type = true, typename std::enable_if<(is_source_chartype_acceptable< std::decay_t< End > >), bool >::type = true>
constexpr	path_view (It *b, End *e, enum termination zt, format fmt=auto_format) noexcept
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<class It , class End , typename std::enable_if<(std::is_same< typename It::value_type, byte >::value), bool >::type = true, typename std::enable_if<(std::is_same< typename End::value_type, byte >::value), bool >::type = true>
constexpr	path_view (It b, End e, enum termination zt) noexcept
template<class It , class End , typename std::enable_if<(std::is_same< std::decay_t< It >, byte >::value), bool >::type = true, typename std::enable_if<(std::is_same< std::decay_t< End >, byte >::value), bool >::type = true>
constexpr	path_view (It *b, End *e, enum termination zt) noexcept
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
	path_view (const path_view &)=default
	Default copy constructor.
	path_view (path_view &&o) noexcept=default
	Default move constructor.
path_view &	operator= (const path_view &p)=default
	Default copy assignment.
path_view &	operator= (path_view &&p) noexcept=default
	Default move assignment.
constexpr bool	has_root_path () const noexcept
	True if has root path.
constexpr bool	has_root_name () const noexcept
	True if has root name.
constexpr bool	has_root_directory () const noexcept
	True if has root directory.
constexpr bool	has_relative_path () const noexcept
	True if has relative path.
constexpr bool	has_parent_path () const noexcept
	True if has parent path.
constexpr bool	has_filename () const noexcept
	True if has filename.
constexpr bool	is_absolute () const noexcept
	True if absolute.
constexpr bool	is_relative () const noexcept
	True if relative.
constexpr const_iterator	cbegin () const noexcept
	Returns an iterator to the first path component.
constexpr const_iterator	begin () const noexcept
	Returns an iterator to the first path component.
constexpr iterator	begin () noexcept
	Returns an iterator to the first path component.
constexpr const_iterator	cend () const noexcept
	Returns an iterator to after the last path component.
constexpr const_iterator	end () const noexcept
	Returns an iterator to after the last path component.
constexpr iterator	end () noexcept
	Returns an iterator to after the last path component.
constexpr path_view	remove_filename () const noexcept
	Returns a copy of this view with the end adjusted to match the final separator.
constexpr path_view	root_name () const noexcept
	Returns a view of the root name part of this view e.g. C:
constexpr path_view	root_directory () const noexcept
	Returns a view of the root directory, if there is one e.g. /.
constexpr path_view	root_path () const noexcept
	Returns, if any, a view of the root path part of this view e.g. C:/.
constexpr path_view	relative_path () const noexcept
	Returns a view of everything after the root path.
constexpr path_view	parent_path () const noexcept
	Returns a view of the everything apart from the filename part of this view.
constexpr path_view	filename () const noexcept
	Returns a view of the filename part of this view.
constexpr path_view	without_trailing_separator () const noexcept
	Returns a view of this view without a trailing separator, if there is one, unless the input is '/'.
template<class T = typename filesystem::path::value_type, class Deleter = default_rendered_path_deleter<T[]>, size_t _internal_buffer_size = default_internal_buffer_size, typename std::enable_if<(path_view::is_source_acceptable< T >), bool >::type = true>
constexpr int	compare (path_view p, const std::locale &loc) const
template<class T = typename filesystem::path::value_type, class Deleter = default_rendered_path_deleter<T[]>, size_t _internal_buffer_size = default_internal_buffer_size, typename std::enable_if<(path_view::is_source_acceptable< T >), bool >::type = true>
constexpr int	compare (path_view p) const
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
constexpr enum termination	termination () const noexcept
	The zero termination during construction.
const byte *	_raw_data () const noexcept
constexpr void	swap (path_view_component &o) noexcept
	Swap the view with another.
constexpr bool	empty () const noexcept
	True if empty.
constexpr size_t	native_size () const noexcept
	Returns the size of the view in characters.
constexpr format	formatting () const noexcept
	How path separators shall be interpreted.
constexpr bool	has_null_termination () const noexcept
	True if input is declared to be null terminated.
constexpr bool	has_stem () const noexcept
	True if stem() returns a non-empty path.
constexpr bool	has_extension () const noexcept
	True if extension() returns a non-empty path.
constexpr bool	contains_glob () const noexcept
	True if the view contains any of the characters *, ?, (POSIX only: [ or ]).
constexpr path_view_component	stem () const noexcept
	Returns a view of the filename without any file extension.
constexpr path_view_component	extension () const noexcept
	Returns a view of the file extension part of this view.
filesystem::path	path () const
	Return the path view as a path. Allocates and copies memory!
template<class T = typename filesystem::path::value_type, class Deleter = default_rendered_path_deleter<T[]>, size_t _internal_buffer_size = default_internal_buffer_size, typename std::enable_if<(is_source_acceptable< T >), bool >::type = true>
constexpr int	compare (path_view_component p, const std::locale &loc) const
template<class T = typename filesystem::path::value_type, class Deleter = default_rendered_path_deleter<T[]>, size_t _internal_buffer_size = default_internal_buffer_size, typename std::enable_if<(is_source_acceptable< T >), bool >::type = true>
constexpr int	compare (path_view_component p) const
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<enum path_view_component::termination ZeroTermination, class T = typename filesystem::path::value_type, class AllocatorOrDeleter = default_rendered_path_deleter<T[]>, size_t _internal_buffer_size = default_internal_buffer_size, class... Args, typename std::enable_if<(is_source_acceptable< T >), bool >::type = true, typename = decltype( std::is_constructible<rendered_path<ZeroTermination, T, AllocatorOrDeleter, _internal_buffer_size>, path_view_component, Args...>::value )>
rendered_path< ZeroTermination, T, AllocatorOrDeleter, _internal_buffer_size >	render (path_view_component view, Args &&...args) const
	Convenience function.
template<class T = typename filesystem::path::value_type, class AllocatorOrDeleter = default_rendered_path_deleter<T[]>, size_t _internal_buffer_size = default_internal_buffer_size, class... Args, typename std::enable_if<(is_source_acceptable< T >), bool >::type = true, typename = decltype( std::is_constructible<rendered_path<termination::zero_terminated, T, AllocatorOrDeleter, _internal_buffer_size>, path_view_component, Args...>::value )>
rendered_path< termination::zero_terminated, T, AllocatorOrDeleter, _internal_buffer_size >	render_null_terminated (Args &&...args) const
	Convenience function.
template<class T = typename filesystem::path::value_type, class AllocatorOrDeleter = default_rendered_path_deleter<T[]>, size_t _internal_buffer_size = default_internal_buffer_size, class... Args, typename std::enable_if<(is_source_acceptable< T >), bool >::type = true, typename = decltype( std::is_constructible<rendered_path<termination::zero_terminated, T, AllocatorOrDeleter, _internal_buffer_size>, path_view_component, Args...>::value )>
rendered_path< termination::not_zero_terminated, T, AllocatorOrDeleter, _internal_buffer_size >	render_unterminated (Args &&...args) const
	Convenience function.

Static Public Attributes
static constexpr auto	preferred_separator = filesystem::path::preferred_separator
	The preferred separator type.
template<class Char >
static constexpr bool	is_source_chartype_acceptable = detail::is_source_chartype_acceptable<Char>::value
template<class Char >
static constexpr bool	is_source_acceptable = detail::is_source_acceptable<Char>::value
static constexpr size_t	default_internal_buffer_size = 1024
	The default internal buffer size used by rendered_path.

Friends
constexpr bool	llfio_v2_xxx::operator== (path_view x, path_view y) noexcept
constexpr bool	llfio_v2_xxx::operator!= (path_view x, path_view y) noexcept
constexpr bool	llfio_v2_xxx ::operator< (path_view x, path_view y) noexcept
constexpr size_t	hash_value (path_view x) noexcept
	Return the combined hash of individual path components.

Detailed Description

A borrowed view of a path. A lightweight trivial-type alternative to std::filesystem::path.

LLFIO is sufficiently fast that std::filesystem::path as a wrapper of an underlying std::basic_string<> can be problematically expensive for some filing system operations due to the potential memory allocation. LLFIO therefore works exclusively with borrowed views of other path storage.

Some of the API for std::filesystem::path is replicated here, however any APIs which modify the path other than taking subsets are obviously not possible with borrowed views.

Each consumer of path_view defines what the "native platform transport" and "native platform encoding" is. For LLFIO, the native platform transport is defined to be std::filesystem::path::value_type, which is as follows:

• POSIX: The native platform transport is char.

• Microsoft Windows: The native platform transport is wchar_t.

  If** the input to path_view equals the native platform transport, the bits supplied will be passed through to the operating system without translation (see below). If* the consuming API expects null termination, and the input to path_view is null terminated, then you are guaranteed that the originally supplied buffer is passed through. If the input is not null terminated, a bitwise identical copy is made into temporary storage (which will be the stack for smaller strings), which is then null terminated before passing to the consuming API.

If the input to path_view does NOT equal the native platform transport, then a translation of the input bits will be performed into temporary storage just before calling the consuming API. The rules are as follows:

• POSIX: The native platform encoding is assumed to be UTF-8. If the input is char8_t or char, it is not translated. If the input is char16_t, a UTF-16 to UTF-8 translation is performed.
• Microsoft Windows: The native platform encoding is assumed to be UTF-16. If the input is char16_t or wchar_t, it is not translated. If the input is char8_t, a UTF-8 to UTF-16 translation is performed. If the input is char, the Microsoft Windows API for ANSI to UTF-16 translation is invoked in order to match how Windows ANSI APIs are mapped onto the Windows Unicode APIs (be aware this is very slow).

Windows specific notes:

On Microsoft Windows, filesystem paths may require to be zero terminated, or they may not. Which is the case depends on whether LLFIO calls the NT kernel API directly rather than the Win32 API. As a general rule as to when which is used, the NT kernel API is called instead of the Win32 API when:

• For any paths relative to a path_handle (the Win32 API does not provide a race free file system API).
• For any paths beginning with \!!\, we pass the path + 3 characters directly through. This prefix is a pure LLFIO extension, and will not be recognised by other code.
• For any paths beginning with \??\, we pass the path + 0 characters directly through. Note the NT kernel keeps a symlink at \??\ which refers to the DosDevices namespace for the current login, so as an incorrect relation which you should not rely on, the Win32 path C:\foo probably will appear at \??\C:\foo.

These prefixes are still passed to the Win32 API:

• \\?\ which is used to tell a Win32 API that the remaining path is longer than a DOS path.
• \\.\ which since Windows 7 is treated exactly like \\?\.

If the NT kernel API is used directly then:

• If the calling thread has the ThreadExplicitCaseSensitivity privilege, or the system registry has enabled case sensitive lookup for NTFS, paths are matched case sensitively as raw bytes via memcmp(), not case insensitively (requires slow locale conversion).
• If the NTFS directory has its case sensitive lookup bit set (see handle::flag
• The path limit is 32,767 characters.

If you really care about performance, you are very strongly recommended to use the NT kernel API wherever possible. Where paths are involved, it is often three to five times faster due to the multiple memory allocations and string translations that the Win32 functions perform before calling the NT kernel routine.

If however you are taking input from some external piece of code, then for maximum compatibility you should still use the Win32 API.

Member Enumeration Documentation

format

enum llfio_v2_xxx::path_view_component::format : uint8_t

inherited

How to interpret separators.

Enumerator
native_format	Separate at the native path separator only.
generic_format	Separate at the generic path separator only.
auto_format	Separate at both the native and generic path separators.
binary_format	Do not separate at any path separator.

  {
    unknown,
    native_format,   //!< Separate at the native path separator only.
    generic_format,  //!< Separate at the generic path separator only.
    auto_format,     //!< Separate at both the native and generic path separators.
    binary_format    //!< Do not separate at any path separator.
  };

termination

enum llfio_v2_xxx::path_view_component::termination

inherited

The zero termination to use.

Enumerator
zero_terminated	The input is zero terminated, or requested output ought to be zero terminated.
not_zero_terminated	The input is not zero terminated, or requested output ought to not be zero terminated.

  {
    zero_terminated,      //!< The input is zero terminated, or requested output ought to be zero terminated.
    not_zero_terminated,  //!< The input is not zero terminated, or requested output ought to not be zero terminated.
  };

Constructor & Destructor Documentation

path_view() [1/17]

constexpr llfio_v2_xxx::path_view::path_view ( )

inlineconstexpr

Constructs an empty path view.

{}  // NOLINT

path_view() [2/17]

constexpr llfio_v2_xxx::path_view::path_view ( path_view_component  p, format  fmt = auto_format  )

inlineconstexprnoexcept

Constructs a path view component identical to the input, except with different format interpretation.

      : path_view_component(p, fmt)
  {
  }

path_view() [3/17]

llfio_v2_xxx::path_view::path_view ( const filesystem::path &  v, format  fmt = auto_format  )

inlinenoexcept

Implicitly constructs a path view from a path. The input path MUST continue to exist for this view to be valid (DEVIATES from P1030 due to filesystem::path not exposing its path formatting).

      : path_view_component(v, fmt)
  {
  }

path_view() [4/17]

template<class Char , typename std::enable_if<(is_source_chartype_acceptable< Char >), bool >::type = true>

constexpr llfio_v2_xxx::path_view::path_view ( const std::basic_string< Char > &  v, format  fmt = auto_format  )

inlineconstexprnoexcept

Constructs from a basic string if the character type is one of char, wchar_t, char8_t or char16_t.

      : path_view_component(v.data(), v.size(), zero_terminated, fmt)
  {
  }

path_view() [5/17]

constexpr llfio_v2_xxx::path_view::path_view ( const char *  b, size_t  l, enum termination  zt, format  fmt = auto_format  )

inlineconstexprnoexcept

Constructs from a lengthed array of one of char, wchar_t, char8_t or char16_t. The input string MUST continue to exist for this view to be valid.

      : path_view_component(b, l, zt, fmt)
  {
  }

path_view() [6/17]

constexpr llfio_v2_xxx::path_view::path_view ( const wchar_t *  b, size_t  l, enum termination  zt, format  fmt = auto_format  )

inlineconstexprnoexcept

Constructs from a lengthed array of one of char, wchar_t, char8_t or char16_t. The input string MUST continue to exist for this view to be valid.

      : path_view_component(b, l, zt, fmt)
  {
  }

path_view() [7/17]

constexpr llfio_v2_xxx::path_view::path_view ( const char8_t *  b, size_t  l, enum termination  zt, format  fmt = auto_format  )

inlineconstexprnoexcept

Constructs from a lengthed array of one of char, wchar_t, char8_t or char16_t. The input string MUST continue to exist for this view to be valid.

      : path_view_component(b, l, zt, fmt)
  {
  }

path_view() [8/17]

constexpr llfio_v2_xxx::path_view::path_view ( const char16_t *  b, size_t  l, enum termination  zt, format  fmt = auto_format  )

inlineconstexprnoexcept

Constructs from a lengthed array of one of char, wchar_t, char8_t or char16_t. The input string MUST continue to exist for this view to be valid.

      : path_view_component(b, l, zt, fmt)
  {
  }

path_view() [9/17]

constexpr llfio_v2_xxx::path_view::path_view ( const byte *  b, size_t  l, enum termination  zt  )

inlineconstexprnoexcept

Constructs from a lengthed array of byte. The input array MUST continue to exist for this view to be valid.

      : path_view_component(b, l, zt)
  {
  }

path_view() [10/17]

template<class Char , typename std::enable_if<(is_source_chartype_acceptable< Char >), bool >::type = true>

constexpr llfio_v2_xxx::path_view::path_view ( const Char *  s, format  fmt = auto_format  )

inlineconstexprnoexcept

Implicitly constructs a path view from a zero terminated pointer to a character array, which must be one of char, wchar_t, char8_t or char16_t. The input string MUST continue to exist for this view to be valid.

      : path_view_component(s, detail::constexpr_strlen(s), zero_terminated, fmt)
  {
  }

path_view() [11/17]

constexpr llfio_v2_xxx::path_view::path_view ( const byte *  s )

inlineconstexprnoexcept

Implicitly constructs a path view from a zero terminated pointer to byte array. The input array MUST continue to exist for this view to be valid.

      : path_view_component(s)
  {
  }

path_view() [12/17]

template<class Char , typename std::enable_if<(is_source_chartype_acceptable< Char >), bool >::type = true>

constexpr llfio_v2_xxx::path_view::path_view ( basic_string_view< Char >  v, enum termination  zt, format  fmt = auto_format  )

inlineconstexprnoexcept

Constructs from a basic string view if the character type is one of char, wchar_t, char8_t or char16_t.

      : path_view_component(v.data(), v.size(), zt, fmt)
  {
  }

path_view() [13/17]

constexpr llfio_v2_xxx::path_view::path_view ( span< const byte >  v, enum termination  zt  )

inlineconstexprnoexcept

Constructs from a span<const byte>.

      : path_view_component(v, zt)
  {
  }

path_view() [14/17]

template<class It , class End , typename std::enable_if<(is_source_chartype_acceptable< typename It::value_type >), bool >::type = true, typename std::enable_if<(is_source_chartype_acceptable< typename End::value_type >), bool >::type = true>

constexpr llfio_v2_xxx::path_view::path_view ( It  b, End  e, enum termination  zt, format  fmt = auto_format  )

inlineconstexprnoexcept

Constructs from an iterator sequence if the iterator is contiguous, if its value type is one of char, wchar_t, char8_t or char16_t.

(DEVIATES from P1030, cannot detect contiguous iterator in SFINAE in C++ 14)

      : path_view_component(addressof(*b), e - b, zt, fmt)
  {
  }

path_view() [15/17]

template<class It , class End , typename std::enable_if<(is_source_chartype_acceptable< std::decay_t< It > >), bool >::type = true, typename std::enable_if<(is_source_chartype_acceptable< std::decay_t< End > >), bool >::type = true>

constexpr llfio_v2_xxx::path_view::path_view ( It *  b, End *  e, enum termination  zt, format  fmt = auto_format  )

inlineconstexprnoexcept

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

      : path_view_component(b, e - b, zt, fmt)
  {
  }

path_view() [16/17]

template<class It , class End , typename std::enable_if<(std::is_same< typename It::value_type, byte >::value), bool >::type = true, typename std::enable_if<(std::is_same< typename End::value_type, byte >::value), bool >::type = true>

constexpr llfio_v2_xxx::path_view::path_view ( It  b, End  e, enum termination  zt  )

inlineconstexprnoexcept

Constructs from an iterator sequence if the iterator is contiguous, if its value type is byte.

(DEVIATES from P1030, cannot detect contiguous iterator in SFINAE in C++ 14)

      : path_view_component(addressof(*b), e - b, zt, binary_format)
  {
  }

path_view() [17/17]

template<class It , class End , typename std::enable_if<(std::is_same< std::decay_t< It >, byte >::value), bool >::type = true, typename std::enable_if<(std::is_same< std::decay_t< End >, byte >::value), bool >::type = true>

constexpr llfio_v2_xxx::path_view::path_view ( It *  b, End *  e, enum termination  zt  )

inlineconstexprnoexcept

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

      : path_view_component(b, e - b, zt, binary_format)
  {
  }

Member Function Documentation

_raw_data()

const byte * llfio_v2_xxx::path_view_component::_raw_data ( ) const

inlinenoexceptinherited

{ return _bytestr; }

begin() [1/2]

constexpr path_view::const_iterator llfio_v2_xxx::path_view::begin ( ) const

inlineconstexprnoexcept

Returns an iterator to the first path component.

{
  return cbegin();
}

begin() [2/2]

constexpr path_view::iterator llfio_v2_xxx::path_view::begin ( )

inlineconstexprnoexcept

Returns an iterator to the first path component.

{
  return cbegin();
}

cbegin()

constexpr path_view::const_iterator llfio_v2_xxx::path_view::cbegin ( ) const

inlineconstexprnoexcept

Returns an iterator to the first path component.

{
  return const_iterator(this, false);
}

cend()

constexpr path_view::const_iterator llfio_v2_xxx::path_view::cend ( ) const

inlineconstexprnoexcept

Returns an iterator to after the last path component.

{
  return const_iterator(this, true);
}

compare() [1/4]

template<class T , class Deleter , size_t _internal_buffer_size, typename std::enable_if<(path_view::is_source_acceptable< T >), bool >::type >

constexpr int llfio_v2_xxx::path_view::compare ( path_view  p ) const

inlineconstexpr

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

{
  auto it1 = begin(), it2 = o.begin();
  for(; it1 != end() && it2 != o.end(); ++it1, ++it2)
  {
    int res = it1->compare<T, Deleter, _internal_buffer_size>(*it2);
    if(res != 0)
    {
      return res;
    }
  }
  if(it1 == end() && it2 != o.end())
  {
    return -1;
  }
  if(it1 != end() && it2 == o.end())
  {
    return 1;
  }
  return 0;  // identical
}

compare() [2/4]

template<class T , class Deleter , size_t _internal_buffer_size, typename std::enable_if<(path_view::is_source_acceptable< T >), bool >::type >

constexpr int llfio_v2_xxx::path_view::compare ( path_view  p, const std::locale &  loc  ) const

inlineconstexpr

Compares the two path views for equivalence or ordering using T as the destination encoding, if necessary.

If the source encodings of the two path views are compatible, a lexicographical comparison is performed. If they are incompatible, either or both views are converted to the destination encoding using rendered_path<T, Delete, _internal_buffer_size>, and then a lexicographical comparison is performed.

This can, for obvious reasons, be expensive. It can also throw exceptions, as rendered_path does.

If the destination encoding is byte, memcmp() is used, and rendered_path is never invoked as the two sources are byte compared directly.

{
  auto it1 = begin(), it2 = o.begin();
  for(; it1 != end() && it2 != o.end(); ++it1, ++it2)
  {
    int res = it1->compare<T, Deleter, _internal_buffer_size>(*it2, loc);
    if(res != 0)
    {
      return res;
    }
  }
  if(it1 == end() && it2 != o.end())
  {
    return -1;
  }
  if(it1 != end() && it2 == o.end())
  {
    return 1;
  }
  return 0;  // identical
}

compare() [3/4]

template<class T = typename filesystem::path::value_type, class Deleter = default_rendered_path_deleter<T[]>, size_t _internal_buffer_size = default_internal_buffer_size, typename std::enable_if<(is_source_acceptable< T >), bool >::type = true>

constexpr int llfio_v2_xxx::path_view_component::compare ( path_view_component  p ) const

inlineconstexprinherited

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

  {
    return _invoke(
    [&](const auto &self) {
      return p._invoke([&](const auto &other) { return _compare<T, Deleter, _internal_buffer_size>(self, termination(), other, p.termination(), nullptr); });
    });
  }

compare() [4/4]

template<class T = typename filesystem::path::value_type, class Deleter = default_rendered_path_deleter<T[]>, size_t _internal_buffer_size = default_internal_buffer_size, typename std::enable_if<(is_source_acceptable< T >), bool >::type = true>

constexpr int llfio_v2_xxx::path_view_component::compare ( path_view_component  p, const std::locale &  loc  ) const

inlineconstexprinherited

Compares the two path views for equivalence or ordering using T as the destination encoding, if necessary.

If the source encodings of the two path views are compatible, a lexicographical comparison is performed. If they are incompatible, either or both views are converted to the destination encoding using rendered_path<T, Delete, _internal_buffer_size>, and then a lexicographical comparison is performed.

This can, for obvious reasons, be expensive. It can also throw exceptions, as rendered_path does.

If the destination encoding is byte, memcmp() is used, and rendered_path is never invoked as the two sources are byte compared directly.

  {
    return _invoke(
    [&](const auto &self)
    { return p._invoke([&](const auto &other) { return _compare<T, Deleter, _internal_buffer_size>(self, termination(), other, p.termination(), &loc); }); });
  }

contains_glob()

constexpr bool llfio_v2_xxx::path_view_component::contains_glob ( ) const

inlineconstexprnoexceptinherited

True if the view contains any of the characters *, ?, (POSIX only: [ or ]).

  {
    return _invoke(
    [](const auto &v)
    {
      using value_type = typename std::remove_reference<decltype(*v.data())>::type;
#ifdef _WIN32
      const value_type *tofind = (sizeof(value_type) > 1) ? (const value_type *) L"*?" : (const value_type *) "*?";
#else
      const value_type *tofind = (sizeof(value_type) > 1) ? (const value_type *) L"*?[]" : (const value_type *) "*?[]";
#endif
      return string_view::npos != v.find_first_of(tofind);
    });
  }

empty()

constexpr bool llfio_v2_xxx::path_view_component::empty ( ) const

inlineconstexprnoexceptinherited

True if empty.

{ return _length == 0; }

end() [1/2]

constexpr path_view::const_iterator llfio_v2_xxx::path_view::end ( ) const

inlineconstexprnoexcept

Returns an iterator to after the last path component.

{
  return cend();
}

end() [2/2]

constexpr path_view::iterator llfio_v2_xxx::path_view::end ( )

inlineconstexprnoexcept

Returns an iterator to after the last path component.

{
  return cend();
}

extension()

constexpr path_view_component llfio_v2_xxx::path_view_component::extension ( ) const

inlineconstexprnoexceptinherited

Returns a view of the file extension part of this view.

  {
    auto self = _filename();
    return self._invoke(
    [this](const auto &v)
    {
      auto dot_idx = v.rfind('.');
      if(_npos == dot_idx || dot_idx == 0 || (dot_idx == 1 && v[dot_idx - 1] == '.'))
      {
        return path_view_component();
      }
      return path_view_component(v.data() + dot_idx, v.size() - dot_idx, termination());
    });
  }

filename()

constexpr path_view llfio_v2_xxx::path_view::filename ( ) const

inlineconstexprnoexcept

Returns a view of the filename part of this view.

{ return this->_filename(); }

formatting()

constexpr format llfio_v2_xxx::path_view_component::formatting ( ) const

inlineconstexprnoexceptinherited

How path separators shall be interpreted.

{ return _format; }

has_extension()

constexpr bool llfio_v2_xxx::path_view_component::has_extension ( ) const

inlineconstexprnoexceptinherited

True if extension() returns a non-empty path.

{ return !extension().empty(); }

has_filename()

constexpr bool llfio_v2_xxx::path_view::has_filename ( ) const

inlineconstexprnoexcept

True if has filename.

{ return !filename().empty(); }

has_null_termination()

constexpr bool llfio_v2_xxx::path_view_component::has_null_termination ( ) const

inlineconstexprnoexceptinherited

True if input is declared to be null terminated.

{ return _zero_terminated; }

has_parent_path()

constexpr bool llfio_v2_xxx::path_view::has_parent_path ( ) const

inlineconstexprnoexcept

True if has parent path.

{ return !parent_path().empty(); }

has_relative_path()

constexpr bool llfio_v2_xxx::path_view::has_relative_path ( ) const

inlineconstexprnoexcept

True if has relative path.

{ return !relative_path().empty(); }

has_root_directory()

constexpr bool llfio_v2_xxx::path_view::has_root_directory ( ) const

inlineconstexprnoexcept

True if has root directory.

{ return !root_directory().empty(); }

has_root_name()

constexpr bool llfio_v2_xxx::path_view::has_root_name ( ) const

inlineconstexprnoexcept

True if has root name.

{ return !root_name().empty(); }

has_root_path()

constexpr bool llfio_v2_xxx::path_view::has_root_path ( ) const

inlineconstexprnoexcept

True if has root path.

{ return !root_path().empty(); }

has_stem()

constexpr bool llfio_v2_xxx::path_view_component::has_stem ( ) const

inlineconstexprnoexceptinherited

True if stem() returns a non-empty path.

{ return !stem().empty(); }

is_absolute()

constexpr bool llfio_v2_xxx::path_view::is_absolute ( ) const

inlineconstexprnoexcept

True if absolute.

  {
    auto sep_idx = this->_find_first_sep();
    if(_npos == sep_idx)
    {
      return false;
    }
#ifdef _WIN32
    if(is_ntpath())
      return true;
    return this->_invoke(
    [sep_idx](const auto &v)
    {
      if(sep_idx == 0)
      {
        if(v[sep_idx + 1] == preferred_separator)  // double separator at front
          return true;
      }
      auto colon_idx = v.find(':');
      return colon_idx < sep_idx;  // colon before first separator
    });
#else
    return sep_idx == 0;
#endif
  }

is_relative()

constexpr bool llfio_v2_xxx::path_view::is_relative ( ) const

inlineconstexprnoexcept

True if relative.

{ return !is_absolute(); }

native_size()

constexpr size_t llfio_v2_xxx::path_view_component::native_size ( ) const

inlineconstexprnoexceptinherited

Returns the size of the view in characters.

  {
    return _invoke([](const auto &v) { return v.size(); });
  }

parent_path()

constexpr path_view llfio_v2_xxx::path_view::parent_path ( ) const

inlineconstexprnoexcept

Returns a view of the everything apart from the filename part of this view.

  {
    auto sep_idx = this->_find_last_sep();
    if(_npos == sep_idx)
    {
      return path_view();
    }
#ifdef _WIN32
    return this->_invoke(
    [this, sep_idx](const auto &v)
    {
      // UNC paths return a trailing slash if the parent path is the server name
      if(is_uncpath())
      {
        auto sep_idx2 = this->_find_first_sep(2);
        if(sep_idx2 == sep_idx)
        {
          return path_view(v.data(), sep_idx + 1, not_zero_terminated, formatting());
        }
      }
      // If a C:\ or whatever, return exactly that.
      auto rp = root_path();
      if(rp.native_size() == native_size())
      {
        return *this;
      }
      return path_view(v.data(), (sep_idx == 0) ? 1 : sep_idx, not_zero_terminated, formatting());
    });
#else
    return this->_invoke([this, sep_idx](const auto &v) { return path_view(v.data(), (sep_idx == 0) ? 1 : sep_idx, not_zero_terminated, formatting()); });
#endif
  }

path()

filesystem::path llfio_v2_xxx::path_view_component::path ( ) const

inlineinherited

Return the path view as a path. Allocates and copies memory!

  {
    return _invoke(
    [&](const auto &v)
    {
      return _path_from_char_array(v,
                                   [](format f) -> filesystem::path::format
                                   {
                                     switch(f)
                                     {
                                     case format::generic_format:
                                       return filesystem::path::format::generic_format;
                                     case format::native_format:
                                       return filesystem::path::format::native_format;
                                     default:
                                       return filesystem::path::format::auto_format;
                                     }
                                   }(formatting()));
    });
  }

relative_path()

constexpr path_view llfio_v2_xxx::path_view::relative_path ( ) const

inlineconstexprnoexcept

Returns a view of everything after the root path.

  {
    auto sep_idx = this->_find_first_sep();
    if(_npos == sep_idx)
    {
      return *this;
    }
#ifdef _WIN32
    return this->_invoke(
    [this, sep_idx](const auto &v) mutable
    {
      // Special case \\.\ and \\?\ to match filesystem::path
      if(is_ntpath() || (v.size() >= 4 && sep_idx == 0 && v[1] == '\\' && (v[2] == '.' || v[2] == '?') && v[3] == '\\'))
      {
        return path_view(v.data() + 4, v.size() - 4, this->termination(), formatting());
      }
      // Is there a drive letter before the first separator?
      auto colon_idx = v.find(':');
      if(colon_idx < sep_idx)
      {
        return path_view(v.data() + sep_idx + 1, v.size() - sep_idx - 1, this->termination(), formatting());
      }
      // UNC paths return the server name as the root path
      if(is_uncpath())
      {
        sep_idx = this->_find_first_sep(2);
        if(_npos == sep_idx)
        {
          return path_view();
        }
        return path_view(v.data() + sep_idx + 1, v.size() - sep_idx - 1, this->termination(), formatting());
      }
#else
    return this->_invoke(
    [this, sep_idx](const auto &v)
    {
#endif
      if(sep_idx == 0)
      {
        return path_view(v.data() + 1, v.size() - 1, this->termination(), formatting());
      }
      return *this;
    });
  }

remove_filename()

constexpr path_view llfio_v2_xxx::path_view::remove_filename ( ) const

inlineconstexprnoexcept

Returns a copy of this view with the end adjusted to match the final separator.

  {
    auto sep_idx = this->_find_last_sep();
    if(_npos == sep_idx)
    {
      // Sorry, this semantic is so broken that it's unwise to emulate!
      return path_view();
    }
    return this->_invoke([sep_idx, this](auto v) { return path_view(v.data(), (sep_idx + 1), not_zero_terminated, formatting()); });
  }

render()

template<enum path_view_component::termination ZeroTermination, class T = typename filesystem::path::value_type, class AllocatorOrDeleter = default_rendered_path_deleter<T[]>, size_t _internal_buffer_size = default_internal_buffer_size, class... Args, typename std::enable_if<(is_source_acceptable< T >), bool >::type = true, typename = decltype( std::is_constructible<rendered_path<ZeroTermination, T, AllocatorOrDeleter, _internal_buffer_size>, path_view_component, Args...>::value )>

rendered_path< ZeroTermination, T, AllocatorOrDeleter, _internal_buffer_size > llfio_v2_xxx::path_view_component::render ( path_view_component  view, Args &&...  args  ) const

inlineinherited

Convenience function.

  {
    return rendered_path<ZeroTermination, T, AllocatorOrDeleter, _internal_buffer_size>(view, std::forward<Args>(args)...);
  }

render_null_terminated()

template<class T = typename filesystem::path::value_type, class AllocatorOrDeleter = default_rendered_path_deleter<T[]>, size_t _internal_buffer_size = default_internal_buffer_size, class... Args, typename std::enable_if<(is_source_acceptable< T >), bool >::type = true, typename = decltype( std::is_constructible<rendered_path<termination::zero_terminated, T, AllocatorOrDeleter, _internal_buffer_size>, path_view_component, Args...>::value )>

rendered_path< termination::zero_terminated, T, AllocatorOrDeleter, _internal_buffer_size > llfio_v2_xxx::path_view_component::render_null_terminated ( Args &&...  args ) const

inlineinherited

Convenience function.

  {
    return rendered_path<termination::zero_terminated, T, AllocatorOrDeleter, _internal_buffer_size>(*this, std::forward<Args>(args)...);
  }

render_unterminated()

template<class T = typename filesystem::path::value_type, class AllocatorOrDeleter = default_rendered_path_deleter<T[]>, size_t _internal_buffer_size = default_internal_buffer_size, class... Args, typename std::enable_if<(is_source_acceptable< T >), bool >::type = true, typename = decltype( std::is_constructible<rendered_path<termination::zero_terminated, T, AllocatorOrDeleter, _internal_buffer_size>, path_view_component, Args...>::value )>

rendered_path< termination::not_zero_terminated, T, AllocatorOrDeleter, _internal_buffer_size > llfio_v2_xxx::path_view_component::render_unterminated ( Args &&...  args ) const

inlineinherited

Convenience function.

  {
    return rendered_path<termination::not_zero_terminated, T, AllocatorOrDeleter, _internal_buffer_size>(*this, std::forward<Args>(args)...);
  }

root_directory()

constexpr path_view llfio_v2_xxx::path_view::root_directory ( ) const

inlineconstexprnoexcept

Returns a view of the root directory, if there is one e.g. /.

  {
    auto sep_idx = this->_find_first_sep();
    if(_npos == sep_idx)
    {
      return path_view();
    }
    return this->_invoke(
    [sep_idx, this](const auto &v)
    {
#ifdef _WIN32
      auto colon_idx = v.find(':');
      if(colon_idx < sep_idx)
      {
        return path_view(v.data() + sep_idx, 1, not_zero_terminated, formatting());
      }
#endif
      if(sep_idx == 0)
      {
        return path_view(v.data(), 1, not_zero_terminated, formatting());
      }
      return path_view();
    });
  }

root_name()

constexpr path_view llfio_v2_xxx::path_view::root_name ( ) const

inlineconstexprnoexcept

Returns a view of the root name part of this view e.g. C:

  {
    auto sep_idx = this->_find_first_sep();
    if(_npos == sep_idx)
    {
      return path_view();
    }
    return this->_invoke([sep_idx, this](const auto &v) { return path_view(v.data(), sep_idx, not_zero_terminated, formatting()); });
  }

root_path()

constexpr path_view llfio_v2_xxx::path_view::root_path ( ) const

inlineconstexprnoexcept

Returns, if any, a view of the root path part of this view e.g. C:/.

  {
    auto sep_idx = this->_find_first_sep();
    if(_npos == sep_idx)
    {
      return path_view();
    }
#ifdef _WIN32
    return this->_invoke(
    [this, sep_idx](const auto &v) mutable
    {
      // Special case \\.\ and \\?\ to match filesystem::path
      if(is_ntpath() || (v.size() >= 4 && sep_idx == 0 && v[1] == '\\' && (v[2] == '.' || v[2] == '?') && v[3] == '\\'))
      {
        return path_view(v.data() + 0, 4, not_zero_terminated, formatting());
      }
      // Is there a drive letter before the first separator?
      auto colon_idx = v.find(':');
      if(colon_idx < sep_idx)
      {
        return path_view(v.data(), sep_idx + 1, not_zero_terminated, formatting());
      }
      // UNC paths return the server name as the root path
      if(is_uncpath())
      {
        sep_idx = this->_find_first_sep(2);
        if(_npos == sep_idx)
        {
          return *this;
        }
        return path_view(v.data(), sep_idx + 1, not_zero_terminated, formatting());
      }
#else
    return this->_invoke(
    [this, sep_idx](const auto &v)
    {
#endif
      if(sep_idx == 0)
      {
        return path_view(v.data(), 1, not_zero_terminated, formatting());
      }
      return path_view();
    });
  }

stem()

constexpr path_view_component llfio_v2_xxx::path_view_component::stem ( ) const

inlineconstexprnoexceptinherited

Returns a view of the filename without any file extension.

  {
    auto self = _filename();
    return self._invoke(
    [self](const auto &v)
    {
      auto dot_idx = v.rfind('.');
      if(_npos == dot_idx || dot_idx == 0 || (dot_idx == 1 && v[dot_idx - 1] == '.'))
      {
        return self;
      }
      return path_view_component(v.data(), dot_idx, not_zero_terminated);
    });
  }

swap()

constexpr void llfio_v2_xxx::path_view_component::swap ( path_view_component &  o )

inlineconstexprnoexceptinherited

Swap the view with another.

  {
    path_view_component x = *this;
    *this = o;
    o = x;
  }

termination()

constexpr enum termination llfio_v2_xxx::path_view_component::termination ( ) const

inlineconstexprnoexceptinherited

The zero termination during construction.

{ return _zero_terminated ? zero_terminated : not_zero_terminated; }

without_trailing_separator()

constexpr path_view llfio_v2_xxx::path_view::without_trailing_separator ( ) const

inlineconstexprnoexcept

Returns a view of this view without a trailing separator, if there is one, unless the input is '/'.

  {
    auto sep_idx = this->_find_last_sep();
    return this->_invoke(
    [this, sep_idx](const auto &v)
    {
      if(sep_idx > 0 && v.size() - 1 == sep_idx)
      {
        return path_view(v.data(), sep_idx, not_zero_terminated, formatting());
      }
      else
      {
        return *this;
      }
    });
  }

Friends And Related Symbol Documentation

hash_value

constexpr size_t hash_value ( path_view  x )

friend

Return the combined hash of individual path components.

{
  size_t ret = 0;
  for(auto component : x)
  {
    ret ^= hash_value(component) + 0x9e3779b9 + (ret << 6) + (ret >> 2);
  }
  return ret;
}

Member Data Documentation

_bytestr

const byte* llfio_v2_xxx::path_view_component::_bytestr {nullptr}

inherited

{nullptr};

is_source_acceptable

template<class Char >

constexpr bool llfio_v2_xxx::path_view_component::is_source_acceptable = detail::is_source_acceptable<Char>::value

staticconstexprinherited

True if path views can be constructed from this source. i.e. is_source_chartype_acceptable, or is byte

is_source_chartype_acceptable

template<class Char >

constexpr bool llfio_v2_xxx::path_view_component::is_source_chartype_acceptable = detail::is_source_chartype_acceptable<Char>::value

staticconstexprinherited

True if path views can be constructed from this character type. i.e. is one of char, wchar_t, char8_t, char16_t

---

The documentation for this class was generated from the following file:

• include/llfio/v2.0/path_view.hpp