Content      ..     37      38      39      40     ..

Working Draft, Standard for Programming Language C++ (N4713, 2017 year) - page 39

Table 124 — Enum class copy_options

Option group controlling copy_file function effects for existing target files

Constant

Meaning

none

(Default) Error; file already exists.

skip_existing

Do not overwrite existing file, do not report an error.

overwrite_existing

Overwrite the existing file.

update_existing

Overwrite the existing file if it is older than the replacement file.

Option group controlling copy function effects for sub-directories

Constant

Meaning

none

(Default) Do not copy sub-directories.

recursive

Recursively copy sub-directories and their contents.

Option group controlling copy function effects for symbolic links

Constant

Meaning

none

(Default) Follow symbolic links.

copy_symlinks

Copy symbolic links as symbolic links rather than copying the files

that they point to.

skip_symlinks

Ignore symbolic links.

Option group controlling copy function effects for choosing the form of copying

Constant

Meaning

none

(Default) Copy content.

directories_only

Copy directory structure only, do not copy non-directory files.

create_symlinks

Make symbolic links instead of copies of files. The source path shall

be an absolute path unless the destination path is in the current

directory.

create_hard_links Make hard links instead of copies of files.

Table 125 — Enum class perms

Name

Value

POSIX

Definition or notes

(octal)

macro

none

0

There are no permissions set for the file.

owner_read

0400

S_IRUSR

Read permission, owner

owner_write

0200

S_IWUSR

Write permission, owner

owner_exec

0100

S_IXUSR

Execute/search permission, owner

owner_all

0700

S_IRWXU

Read, write, execute/search by owner;

owner_read | owner_write | owner_exec

group_read

040

S_IRGRP

Read permission, group

group_write

020

S_IWGRP

Write permission, group

group_exec

010

S_IXGRP

Execute/search permission, group

group_all

070

S_IRWXG

Read, write, execute/search by group;

group_read | group_write | group_exec

others_read

04

S_IROTH

Read permission, others

others_write

02

S_IWOTH

Write permission, others

others_exec

01

S_IXOTH

Execute/search permission, others

others_all

07

S_IRWXO

Read, write, execute/search by others;

others_read | others_write | others_exec

all

0777

owner_all | group_all | others_all

set_uid

04000

S_ISUID

Set-user-ID on execution

set_gid

02000

S_ISGID

Set-group-ID on execution

sticky_bit

01000

S_ISVTX

Operating system dependent.

mask

07777

all | set_uid | set_gid | sticky_bit

unknown

0xFFFF

The permissions are not known, such as when a file_-

status object is created without specifying the per-

missions

§

30.11.10

1132

31

Regular expressions library

[re]

31.1

General

[re.general]

1

This Clause describes components that C++ programs may use to perform operations involving regular

expression matching and searching.

2

The following subclauses describe a basic regular expression class template and its traits that can handle

char-like (24.1) template arguments, two specializations of this class template that handle sequences of char

and wchar_t, a class template that holds the result of a regular expression match, a series of algorithms

that allow a character sequence to be operated upon by a regular expression, and two iterator types for

enumerating regular expression matches, as described in Table 128.

Table 128 — Regular expressions library summary

Subclause

Header(s)

31.2

Definitions

31.3

Requirements

31.5

Constants

31.6

Exception type

31.7

Traits

31.8

Regular expression template

<regex>

31.9

Submatches

31.10

Match results

31.11

Algorithms

31.12

Iterators

31.13

Grammar

31.2

Definitions

[re.def]

1

The following definitions shall apply to this Clause:

31.2.1

[defns.regex.collating.element]

collating element

a sequence of one or more characters within the current locale that collate as if they were a single character.

31.2.2

[defns.regex.finite.state.machine]

finite state machine

an unspecified data structure that is used to represent a regular expression, and which permits efficient

matches against the regular expression to be obtained.

31.2.3

[defns.regex.format.specifier]

format specifier

a sequence of one or more characters that is to be replaced with some part of a regular expression match.

31.2.4

[defns.regex.matched]

matched

a sequence of zero or more characters is matched by a regular expression when the characters in the sequence

correspond to a sequence of characters defined by the pattern.

31.2.5

[defns.regex.primary.equivalence.class]

primary equivalence class

a set of one or more characters which share the same primary sort key: that is the sort key weighting that

depends only upon character shape, and not accents, case, or locale specific tailorings.

§ 31.2.5

1158

31.2.6

[defns.regex.regular.expression]

regular expression

a pattern that selects specific strings from a set of character strings.

31.2.7

[defns.regex.subexpression]

sub-expression

a subset of a regular expression that has been marked by parenthesis.

31.3

Requirements

[re.req]

1

This subclause defines requirements on classes representing regular expression traits.

[Note: The class

template regex_traits, defined in 31.7, satisfies these requirements.

— end note ]

2

The class template basic_regex, defined in 31.8, needs a set of related types and functions to complete the

definition of its semantics. These types and functions are provided as a set of member typedef-names and

functions in the template parameter traits used by the basic_regex class template. This subclause defines

the semantics of these members.

3

To specialize class template basic_regex for a character container CharT and its related regular expression

traits class Traits, use basic_regex<CharT, Traits>.

4

In Table 129 X denotes a traits class defining types and functions for the character container type charT; u is

an object of type X; v is an object of type const X; p is a value of type const charT*; I1 and I2 are input

iterators (27.2.3); F1 and F2 are forward iterators (27.2.5); c is a value of type const charT; s is an object of

type X::string_type; cs is an object of type const X::string_type; b is a value of type bool; I is a value

of type int; cl is an object of type X::char_class_type, and loc is an object of type X::locale_type.

Table

129

— Regular expression traits class requirements

Expression

Return type

Assertion/note pre-/post-condition

X::char_type

charT

The character container type used in the

implementation of class template

basic_regex.

X::string_type

basic_-

string<charT>

X::locale_type

A copy

A type that represents the locale used by the

constructible type

traits class.

X::char_class_type

A bitmask

A bitmask type representing a particular

type (20.4.2.1.4).

character classification.

X::length(p)

size_t

Yields the smallest i such that p[i] == 0.

Complexity is linear in i .

v.translate(c)

X::char_type

Returns a character such that for any

character d that is to be considered equivalent

to c then v.translate(c) ==

v.translate(d).

v.translate_nocase(c)

X::char_type

For all characters C that are to be considered

equivalent to c when comparisons are to be

performed without regard to case, then

v.translate_nocase(c) ==

v.translate_nocase(C).

v.transform(F1, F2)

X::string_type

Returns a sort key for the character sequence

designated by the iterator range [F1, F2)

such that if the character sequence [G1, G2)

sorts before the character sequence [H1, H2)

then v.transform(G1, G2) <

v.transform(H1, H2).

§ 31.3

1159

Table 129 — Regular expression traits class requirements (contin-

ued)

Expression

Return type

Assertion/note pre-/post-condition

v.transform_primary(F1,

X::string_type

Returns a sort key for the character sequence

F2)

designated by the iterator range [F1, F2)

such that if the character sequence [G1, G2)

sorts before the character sequence [H1, H2)

when character case is not considered then

v.transform_primary(G1, G2) <

v.transform_primary(H1, H2).

v.lookup_collatename(F1,

X::string_type

Returns a sequence of characters that

F2)

represents the collating element consisting of

the character sequence designated by the

iterator range [F1, F2). Returns an empty

string if the character sequence is not a valid

collating element.

v.lookup_classname(F1,

X::char_class_-

Converts the character sequence designated by

F2, b)

type

the iterator range [F1, F2) into a value of a

bitmask type that can subsequently be passed

to isctype. Values returned from

lookup_classname can be bitwise or’ed

together; the resulting value represents

membership in either of the corresponding

character classes. If b is true, the returned

bitmask is suitable for matching characters

without regard to their case. Returns 0 if the

character sequence is not the name of a

character class recognized by X. The value

returned shall be independent of the case of

the characters in the sequence.

v.isctype(c, cl)

bool

Returns true if character c is a member of

one of the character classes designated by cl,

false otherwise.

v.value(c, I)

int

Returns the value represented by the digit c in

base I if the character c is a valid digit in base

I; otherwise returns -1. [Note: The value of I

will only be 8, 10, or 16.

— end note ]

u.imbue(loc)

X::locale_type

Imbues u with the locale loc and returns the

previous locale used by u if any.

v.getloc()

X::locale_type

Returns the current locale used by v, if any.

5

[ Note: Class template regex_traits satisfies the requirements for a regular expression traits class when it

is specialized for char or wchar_t. This class template is described in the header <regex>, and is described

in 31.7.

— end note ]

31.4

Header <regex> synopsis

[re.syn]

#include <initializer_list>

namespace std {

// 31.5, regex constants

namespace regex_constants {

using syntax_option_type = T1 ;

using match_flag_type = T2 ;

using error_type = T3 ;

}

// 31.6, class regex_error

class regex_error;

§ 31.4

1160

Content      ..     37      38      39      40     ..