llfio_v2_xxx::path_view_component Class Reference

An iterated part of a path_view. More...

#include "path_view.hpp"

Inheritance diagram for llfio_v2_xxx::path_view_component:

Classes
class	rendered_path

Public Types
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	size_type = filesystem::path::string_type::size_type
	The size type.
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_component () noexcept
	Constructs an empty path view component (DEVIATES from P1030, is not trivial due to C++ 14 compatibility)
constexpr	path_view_component (path_view_component p, format fmt) noexcept
	Constructs a path view component identical to the input, except with different format interpretation.
	path_view_component (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_component (const std::basic_string< Char > &v, format fmt=binary_format) noexcept
constexpr	path_view_component (const char *b, size_t l, enum termination zt, format fmt=binary_format) noexcept
constexpr	path_view_component (const wchar_t *b, size_t l, enum termination zt, format fmt=binary_format) noexcept
constexpr	path_view_component (const char8_t *b, size_t l, enum termination zt, format fmt=binary_format) noexcept
constexpr	path_view_component (const char16_t *b, size_t l, enum termination zt, format fmt=binary_format) noexcept
constexpr	path_view_component (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_component (const Char *s, format fmt=binary_format) noexcept
constexpr	path_view_component (const byte *s) noexcept
template<class Char , typename std::enable_if<(is_source_chartype_acceptable< Char >), bool >::type = true>
constexpr	path_view_component (basic_string_view< Char > v, enum termination zt, format fmt=binary_format) noexcept
constexpr	path_view_component (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_component (It b, End e, enum termination zt, format fmt=binary_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_component (It *b, End *e, enum termination zt, format fmt=binary_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_component (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_component (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_component (const path_view_component &)=default
	path_view_component (path_view_component &&)=default
path_view_component &	operator= (const path_view_component &)=default
path_view_component &	operator= (path_view_component &&)=default
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 enum termination	termination () const noexcept
	The zero termination during construction.
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
class	path_view
template<enum path_view_component::termination ZeroTermination, class T , class Deleter , size_t _internal_buffer_size, typename std::enable_if<(is_source_acceptable< T >), bool >::type >
class	rendered_path
constexpr bool	llfio_v2_xxx::operator== (path_view_component x, path_view_component y) noexcept
constexpr bool	llfio_v2_xxx::operator!= (path_view_component x, path_view_component y) noexcept
constexpr bool	llfio_v2_xxx ::operator< (path_view_component x, path_view_component y) noexcept
constexpr size_t	hash_value (path_view_component x) noexcept
	Hashes a path_view_component.
template<class F >
constexpr auto	llfio_v2_xxx::visit (path_view_component view, F &&f)
template<class F >
constexpr auto	llfio_v2_xxx::visit (F &&f, path_view_component view)
std::ostream &	llfio_v2_xxx ::operator<< (std::ostream &s, const path_view_component &v)

Detailed Description

An iterated part of a path_view.

Member Enumeration Documentation

format

enum llfio_v2_xxx::path_view_component::format : uint8_t

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

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_component() [1/17]

constexpr llfio_v2_xxx::path_view_component::path_view_component ( )

inlineconstexprnoexcept

Constructs an empty path view component (DEVIATES from P1030, is not trivial due to C++ 14 compatibility)

      : _zero_terminated(false)
      , _passthrough(false)
      , _char(false)
      , _wchar(false)
      , _utf8(false)
      , _utf16(false)
      , _reserved1(0)
  {
  }  // NOLINT

path_view_component() [2/17]

constexpr llfio_v2_xxx::path_view_component::path_view_component ( path_view_component  p, format  fmt  )

inlineconstexprnoexcept

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

      : _charstr(p._charstr)
      , _length(p._length)
      , _zero_terminated(p._zero_terminated)
      , _passthrough(p._passthrough)
      , _char(p._char)
      , _wchar(p._wchar)
      , _utf8(p._utf8)
      , _utf16(p._utf16)
      , _reserved1(p._reserved1)
      , _format(fmt)
  {
  }

path_view_component() [3/17]

llfio_v2_xxx::path_view_component::path_view_component ( 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.native().c_str(), v.native().size(), zero_terminated, fmt)
  {
  }

path_view_component() [4/17]

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

constexpr llfio_v2_xxx::path_view_component::path_view_component ( const std::basic_string< Char > &  v, format  fmt = binary_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_component() [5/17]

constexpr llfio_v2_xxx::path_view_component::path_view_component ( const char *  b, size_t  l, enum termination  zt, format  fmt = binary_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.

      : _charstr((l == 0) ? nullptr : b)
      , _length((l == 0) ? 0 : l)
      , _zero_terminated((l == 0) ? false : (zt == zero_terminated))
      , _passthrough(false)
      , _char((l == 0) ? false : true)
      , _wchar(false)
      , _utf8(false)
      , _utf16(false)
      , _reserved1(0)
      , _format(fmt)
  {
  }

path_view_component() [6/17]

constexpr llfio_v2_xxx::path_view_component::path_view_component ( const wchar_t *  b, size_t  l, enum termination  zt, format  fmt = binary_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.

      : _wcharstr((l == 0) ? nullptr : b)
      , _length((l == 0) ? 0 : l)
      , _zero_terminated((l == 0) ? false : (zt == zero_terminated))
      , _passthrough(false)
      , _char(false)
      , _wchar((l == 0) ? false : true)
      , _utf8(false)
      , _utf16(false)
      , _reserved1(0)
      , _format(fmt)
  {
  }

path_view_component() [7/17]

constexpr llfio_v2_xxx::path_view_component::path_view_component ( const char8_t *  b, size_t  l, enum termination  zt, format  fmt = binary_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.

      : _char8str((l == 0) ? nullptr : b)
      , _length((l == 0) ? 0 : l)
      , _zero_terminated((l == 0) ? false : (zt == zero_terminated))
      , _passthrough(false)
      , _char(false)
      , _wchar(false)
      , _utf8((l == 0) ? false : true)
      , _utf16(false)
      , _reserved1(0)
      , _format(fmt)
  {
  }

path_view_component() [8/17]

constexpr llfio_v2_xxx::path_view_component::path_view_component ( const char16_t *  b, size_t  l, enum termination  zt, format  fmt = binary_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.

      : _char16str((l == 0) ? nullptr : b)
      , _length((l == 0) ? 0 : l)
      , _zero_terminated((l == 0) ? false : (zt == zero_terminated))
      , _passthrough(false)
      , _char(false)
      , _wchar(false)
      , _utf8(false)
      , _utf16((l == 0) ? false : true)
      , _reserved1(0)
      , _format(fmt)
  {
  }

path_view_component() [9/17]

constexpr llfio_v2_xxx::path_view_component::path_view_component ( 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.

      : _bytestr((l == 0) ? nullptr : b)
      , _length((l == 0) ? 0 : l)
      , _zero_terminated((l == 0) ? false : (zt == zero_terminated))
      , _passthrough((l == 0) ? false : true)
      , _char(false)
      , _wchar(false)
      , _utf8(false)
      , _utf16(false)
      , _reserved1(0)
      , _format(binary_format)
  {
  }

path_view_component() [10/17]

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

constexpr llfio_v2_xxx::path_view_component::path_view_component ( const Char *  s, format  fmt = binary_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_component() [11/17]

constexpr llfio_v2_xxx::path_view_component::path_view_component ( 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, detail::constexpr_strlen(s), zero_terminated)
  {
  }

path_view_component() [12/17]

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

constexpr llfio_v2_xxx::path_view_component::path_view_component ( basic_string_view< Char >  v, enum termination  zt, format  fmt = binary_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_component() [13/17]

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

inlineconstexprnoexcept

Constructs from a span<const byte>.

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

path_view_component() [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_component::path_view_component ( It  b, End  e, enum termination  zt, format  fmt = binary_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_component() [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_component::path_view_component ( It *  b, End *  e, enum termination  zt, format  fmt = binary_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_component() [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_component::path_view_component ( 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_component() [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_component::path_view_component ( 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

inlinenoexcept

{ return _bytestr; }

compare() [1/2]

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

inlineconstexpr

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() [2/2]

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

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.

  {
    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

inlineconstexprnoexcept

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

inlineconstexprnoexcept

True if empty.

{ return _length == 0; }

extension()

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

inlineconstexprnoexcept

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());
    });
  }

formatting()

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

inlineconstexprnoexcept

How path separators shall be interpreted.

{ return _format; }

has_extension()

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

inlineconstexprnoexcept

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

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

has_null_termination()

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

inlineconstexprnoexcept

True if input is declared to be null terminated.

{ return _zero_terminated; }

has_stem()

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

inlineconstexprnoexcept

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

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

native_size()

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

inlineconstexprnoexcept

Returns the size of the view in characters.

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

path()

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

inline

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()));
    });
  }

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

inline

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

inline

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

inline

Convenience function.

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

stem()

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

inlineconstexprnoexcept

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 )

inlineconstexprnoexcept

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

inlineconstexprnoexcept

The zero termination during construction.

  {
    return _zero_terminated ? zero_terminated : not_zero_terminated;
  }

Friends And Related Symbol Documentation

hash_value

constexpr size_t hash_value ( path_view_component  x )

friend

Hashes a path_view_component.

{
  return view._invoke(
  [](auto sv) -> size_t
  {
    // std::hash isn't available for all kinds of string view on older compilers :(
    const auto hash =
    QUICKCPPLIB_NAMESPACE::algorithm::hash::fast_hash::hash((const char *) sv.data(), sv.size() * sizeof(*sv.data()));
    return *(size_t *) &hash;
  });
}

Member Data Documentation

_bytestr

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

{nullptr};

is_source_acceptable

template<class Char >

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

staticconstexpr

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

staticconstexpr

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