Objects of the class tt(fs::path)hi(path (filesystem)) contain names of file
system entries. The class tt(path) is a value-type class: a default
constructor (empty path) as well as standard copy/move construction/assignment
facilities are available. In addition, the following constructors can be used:
    itemization(
    itt(path(string &&tmp))
    itt(path(Type const &source))
    itt(path(InputIter begin, InputIter end))
    )
    
    These constructors expect character sequences (including NTBSs) in various
forms as their arguments. Conceptually, these sequences consist of the
following elements (all optional)
    itemization(
    it() a root-name, e.g., a disk-name (like tt(E:)) or device indicator
        (like tt(//nfs));
    it() a root-directory, present if it is the first character after
        the (optional) root-name;
    it() filename characters (not containing directory separators). In
        addition the `single dot filename' (tt(.)) represents the current
        directory and the `double dot filename' (tt(..)) represents the
        current directory's parent directory;
    it() directory separators (by default the forward slash). Multiple
        consecutive separators are treated like one separator.
    )

    The constructors also define a last tt(format ftmp = auto_format)
parameter, which probably almost never requires a non-default specification
(for this parameter, refer to url(cppreference)
        (http://en.cppreference.com/w/cpp/experimental/fs/path).)

Its modifying member functions are
    itemization(
    itt(path &append(Type const &arg)) or 
                                tt(path &operator/=(Type const &arg)):
       the arguments that can be passed to the constructors (including the
        iterators) can also be passed to these members. Before adding the
        argument the current and tt(arg's) contents are separated by a
        directory separator (unless the resulting path would be absolute if
        the source path is empty and the argument does not represent an
        absolute path);

    itt(void clear()): the tt(path's) contents are erased;

    itt(int compare(Type const &other)): returns the result of
        lexicographically comparing the current path's contents with
        tt(other). tt(Other) can be a tt(path), a string-type or a NTBS;

    itt(path &concat(Type const &arg)) or 
                                tt(path &operator+=(Type const &arg)):
       similar to tt(append), but no directory separator will be used when
        adding tt(arg's) contents to the current tt(path's) contents;

    itt(path &remove_filename()):
       removes the last component of the stored path. If only a root-directory
        is stored, then the root directory is removed. Note that the last
        directory separator is kept, unless it is the only path element;

    itt(path &replace_extension(path const &replacement = path{} )):
       replaces the extension of the last component of the stored path
        (including the extension's dot) with tt(replacement). The extension is
        removed if tt(replacement) is empty. If the tt(path) calling
        tt(replace_extension) has no extension then tt(replacement) is added;

    itt(path &replace_filename(path const &replacement)):
       replaces the last component of the stored path with tt(replacement),
        which itself may contain multiple path elements.  If only a
        root-directory is stored, then it is replaced by tt(replacement). The
        member's behavior is undefined If before calling tt(replace_filename
        path.empty()) returns tt(true);
    )

    hi(path: as string/NTBS)
Accessors (no arguments, const members) return the path's contents as an NTBS
(tt(c_str)), as a string (tt(string, wstring, u8string, u16string, u32string))
(possibly prefixed by tt(generic_), like tt(generic_string)) or as components
of path specifications, returned as tt(path). Example:
        verb(
    fs::path path{ "/usr/local/bin" };
    cout << path.string() << '\n';      // shows:   /usr/local/bin
        )

    hi(path: stream insertion)
tt(Path) objects may be inserted into streams using the tt(<<) (stream
insertion) operator, in which case double quotes surround the displayed path
name. The double quotes are removed when accessing the path's contents as NTBS
or string, and also when assigning (or casting) it to a string.

    hi(path: stream extraction)
tt(Path) objects may also be extracted from streams using the tt(>>) (stream
extraction) operator. In this case a path may optionally be surrounded by
double quotes. The extracted path again contains its surrounding quotes.

    hi(path: component iterators)
tt(Begin) and tt(end) iterators can be used to iterate over all of the
tt(path's) components: each component is returned as a tt(path), root names
and root directories are returned as initial components, followed by the
individual directory (and final filename) components. The directory separators
themselves are not returned when iterating over a tt(path's) components.

    hi(path: component accessors)
    hi(path: decomposers)
Decomposers, returning objects (empty if the requested component is not
present): tt(root_name, root_directory, root_path, relative_path, parent_path)
(i.e., the current contents from which the last element has been removed),
tt(filename, stem) (i.e., the filename without its dot-extension), and
tt(extension). Example:
        verb(
    fs::path path{ "/usr/local/bin" };
    cout << path.relative_path() << '\n';   // shows:  "usr/local/bin"
                                            // (note the double quotes)
        )

When prefixed by tt(has_) the member returns a tt(bool) which is tt(true) if
the component is present. Also available: tt(is_absolute, is_relative)

In addition to the member functions various free operators are available:
tt(==, !=, <, <=, >,) and tt(>=) comparing two tt(path) objects; tt(/)
returning the concatenated tt(lhs) and tt(rhs). Comparisons use
lexicographical comparisons (as if by comparing the return values of their
tt(string) members).

    hi(path: canonical)
To convert a tt(path) (which must refer to an existing directory entry) to its
canonical form (i.e., a path not containing . or .. components) the free
function tt(canonical) (cf. section ref(FSFUN)) can be used:
        verb(
    fs::path path{ "/usr/local/bin/../../share/man" };
    cout << canonical(path) << '\n';    // shows:   "/usr/share/man"
        )







