mirror of
https://github.com/dlang/phobos.git
synced 2025-04-27 13:40:20 +03:00
XREF -> REF (sed)
Done by:
(find . -type f -name "*.d" -print0; \
find . -type f -name "*.dd" -print0) | \
xargs -0 sed -i -r \
's/\$\(XREF\s+([^(),]*),\s*([^(),]*)\)/$(REF \2, std,\1)/g'
This commit is contained in:
anonymous
parent
a207b27056
commit
764caefa36
37 changed files with 167 additions and 167 deletions
18
changelog.dd
18
changelog.dd
|
|
@ -28,12 +28,12 @@ $(BUGSTITLE Library Changes,
|
|||
exposed))
|
||||
$(LI $(RELATIVE_LINK2 iota-length-size_t, `std.range.iota's `.length`
|
||||
property is fixed to `size_t` instead of the type being iterated))
|
||||
$(LI $(XREF uni, isNumber) and $(XREF uni, isPunctuation) now use a separate,
|
||||
$(LI $(REF isNumber, std,uni) and $(REF isPunctuation, std,uni) now use a separate,
|
||||
optimized path for ASCII inputs.)
|
||||
$(LI $(XREF uni, isAlphaNum), which is analogous to $(XREF ascii, isAlphaNum)
|
||||
$(LI $(REF isAlphaNum, std,uni), which is analogous to $(REF isAlphaNum, std,ascii)
|
||||
was added.)
|
||||
$(LI $(XREF regex, regex) now supports inline comments with (?#...) syntax.)
|
||||
$(LI std.regex had numerous optimization applied, compile-time $(XREF regex, ctRegex)
|
||||
$(LI $(REF regex, std,regex) now supports inline comments with (?#...) syntax.)
|
||||
$(LI std.regex had numerous optimization applied, compile-time $(REF ctRegex, std,regex)
|
||||
should now be generally faster then the run-time version.)
|
||||
$(LI $(REF moveAt, std,range,primitives) accepts only `size_t` for its index
|
||||
arguments.)
|
||||
|
|
@ -42,7 +42,7 @@ $(BUGSTITLE Library Changes,
|
|||
$(LI $(REF readLink, std,file) and $(REF symlink, std,file) have been
|
||||
rangified.)
|
||||
$(LI All overloads of `std.conv.toImpl` has been made private. Please use
|
||||
$(XREF conv, to) instead.)
|
||||
$(REF to, std,conv) instead.)
|
||||
$(LI $(RELATIVE_LINK2 min-max-element,
|
||||
`std.algorithm.searching.{min,max}Element` for ranges have been added.))
|
||||
$(LI $(XREF Ternary, std,typecons) was added to represent three valued
|
||||
|
|
@ -63,7 +63,7 @@ $(LI $(LNAME2 process, Process creation in `std.process` was sped up on Posix.)
|
|||
$(LI $(LNAME2 std-algorithm-iteration-cumulativeFold, $(XREF algorithm.iteration,
|
||||
cumulativeFold) was added.)
|
||||
|
||||
$(P $(XREF algorithm.iterator, cumulativeFold) returns the successive
|
||||
$(P $(REF cumulativeFold, std,algorithm.iterator) returns the successive
|
||||
reduced values of an input range.)
|
||||
------
|
||||
assert([1, 2, 3, 4, 5].cumulativeFold!((a, b) => a + b).array == [1, 3, 6, 10, 15]);
|
||||
|
|
@ -73,7 +73,7 @@ assert([1, 2, 3].cumulativeFold!((a, b) => a + b)(100).array == [101, 103, 106])
|
|||
|
||||
$(LI $(LNAME2 padLeft-padRight, `std.range.padLeft` and `std.range.padRight`
|
||||
were added.)
|
||||
$(P $(XREF range, padLeft) and $(XREF range, padRight) are functions for
|
||||
$(P $(REF padLeft, std,range) and $(REF padRight, std,range) are functions for
|
||||
padding ranges to a specified length using the given element.
|
||||
)
|
||||
|
||||
|
|
@ -102,7 +102,7 @@ assert(m.front[1] == "12");
|
|||
-------
|
||||
)
|
||||
|
||||
$(LI $(LNAME2 regex-with-matches, $(XREF regex, splitter) now supports keeping the
|
||||
$(LI $(LNAME2 regex-with-matches, $(REF splitter, std,regex) now supports keeping the
|
||||
pattern matches in the resulting range.)
|
||||
-------
|
||||
import std.regex;
|
||||
|
|
@ -203,7 +203,7 @@ $(LI $(LNAME2 mutation, `std.algorithm.mutation.swapAt` was exposed)
|
|||
|
||||
$(LI $(LNAME2 iota-length-size_t, `std.range.iota's `.length` property is fixed
|
||||
to `size_t` instead of the type being iterated)
|
||||
$(P $(XREF range, iota)'s `.length` property is now always returned as
|
||||
$(P $(REF iota, std,range)'s `.length` property is now always returned as
|
||||
`size_t`. This means if you are on a 32-bit CPU and you are using
|
||||
iota to iterate 64-bit types, the length will be truncated to `size_t`.
|
||||
In non-release mode, you will get an exception if the length exceeds
|
||||
|
|
|
|||
|
|
@ -1767,7 +1767,7 @@ the benefit of have better complexity than the $(D AllocateGC.no) option. Howeve
|
|||
this option is only available for ranges whose equality can be determined via each
|
||||
element's $(D toHash) method. If customized equality is needed, then the $(D pred)
|
||||
template parameter can be passed, and the function will automatically switch to
|
||||
the non-allocating algorithm. See $(XREF functional,binaryFun) for more details on
|
||||
the non-allocating algorithm. See $(REF binaryFun, std,functional) for more details on
|
||||
how to define $(D pred).
|
||||
|
||||
Non-allocating forward range option: $(BIGOH n^2)
|
||||
|
|
|
|||
|
|
@ -122,7 +122,7 @@ The result is then directly returned when $(D front) is called,
|
|||
rather than re-evaluated.
|
||||
|
||||
This can be a useful function to place in a chain, after functions
|
||||
that have expensive evaluation, as a lazy alternative to $(XREF array,array).
|
||||
that have expensive evaluation, as a lazy alternative to $(REF array, std,array).
|
||||
In particular, it can be placed after a call to $(D map), or before a call
|
||||
to $(D filter).
|
||||
|
||||
|
|
@ -205,7 +205,7 @@ Tip: $(D cache) is eager when evaluating elements. If calling front on the
|
|||
underlying _range has a side effect, it will be observeable before calling
|
||||
front on the actual cached _range.
|
||||
|
||||
Furthermore, care should be taken composing $(D cache) with $(XREF _range,take).
|
||||
Furthermore, care should be taken composing $(D cache) with $(REF take, std,_range).
|
||||
By placing $(D take) before $(D cache), then $(D cache) will be "aware"
|
||||
of when the _range ends, and correctly stop caching elements when needed.
|
||||
If calling front has no side effect though, placing $(D take) after $(D cache)
|
||||
|
|
@ -840,13 +840,13 @@ can be avoided by explicitly specifying a predicate lambda with a
|
|||
$(D lazy) parameter.
|
||||
|
||||
$(D each) also supports $(D opApply)-based iterators, so it will work
|
||||
with e.g. $(XREF parallelism, parallel).
|
||||
with e.g. $(REF parallel, std,parallelism).
|
||||
|
||||
Params:
|
||||
pred = predicate to apply to each element of the range
|
||||
r = range or iterable over which each iterates
|
||||
|
||||
See_Also: $(XREF range,tee)
|
||||
See_Also: $(REF tee, std,range)
|
||||
|
||||
*/
|
||||
template each(alias pred = "a")
|
||||
|
|
@ -1029,7 +1029,7 @@ unittest
|
|||
$(D auto filter(Range)(Range rs) if (isInputRange!(Unqual!Range));)
|
||||
|
||||
Implements the higher order _filter function. The predicate is passed to
|
||||
$(XREF functional,unaryFun), and can either accept a string, or any callable
|
||||
$(REF unaryFun, std,functional), and can either accept a string, or any callable
|
||||
that can be executed via $(D pred(element)).
|
||||
|
||||
Params:
|
||||
|
|
@ -1232,9 +1232,9 @@ private struct FilterResult(alias pred, Range)
|
|||
* finding the last element in the range that satisfies the filtering
|
||||
* condition (in addition to finding the first one). The advantage is
|
||||
* that the filtered range can be spanned from both directions. Also,
|
||||
* $(XREF range, retro) can be applied against the filtered range.
|
||||
* $(REF retro, std,range) can be applied against the filtered range.
|
||||
*
|
||||
* The predicate is passed to $(XREF functional,unaryFun), and can either
|
||||
* The predicate is passed to $(REF unaryFun, std,functional), and can either
|
||||
* accept a string, or any callable that can be executed via $(D pred(element)).
|
||||
*
|
||||
* Params:
|
||||
|
|
@ -1325,7 +1325,7 @@ Similarly to $(D uniq), $(D group) produces a range that iterates over unique
|
|||
consecutive elements of the given range. Each element of this range is a tuple
|
||||
of the element and the number of times it is repeated in the original range.
|
||||
Equivalence of elements is assessed by using the predicate $(D pred), which
|
||||
defaults to $(D "a == b"). The predicate is passed to $(XREF functional,binaryFun),
|
||||
defaults to $(D "a == b"). The predicate is passed to $(REF binaryFun, std,functional),
|
||||
and can either accept a string, or any callable that can be executed via
|
||||
$(D pred(element, element)).
|
||||
|
||||
|
|
@ -1772,8 +1772,8 @@ unittest
|
|||
* Chunks an input range into subranges of equivalent adjacent elements.
|
||||
*
|
||||
* Equivalence is defined by the predicate $(D pred), which can be either
|
||||
* binary, which is passed to $(XREF functional,binaryFun), or unary, which is
|
||||
* passed to $(XREF functional,unaryFun). In the binary form, two _range elements
|
||||
* binary, which is passed to $(REF binaryFun, std,functional), or unary, which is
|
||||
* passed to $(REF unaryFun, std,functional). In the binary form, two _range elements
|
||||
* $(D a) and $(D b) are considered equivalent if $(D pred(a,b)) is true. In
|
||||
* unary form, two elements are considered equivalent if $(D pred(a) == pred(b))
|
||||
* is true.
|
||||
|
|
@ -2025,7 +2025,7 @@ both outer and inner ranges of $(D RoR) are forward ranges; otherwise it will
|
|||
be only an input range.
|
||||
|
||||
See_also:
|
||||
$(XREF range,chain), which chains a sequence of ranges with compatible elements
|
||||
$(REF chain, std,range), which chains a sequence of ranges with compatible elements
|
||||
into a single range.
|
||||
*/
|
||||
auto joiner(RoR, Separator)(RoR r, Separator sep)
|
||||
|
|
@ -2626,7 +2626,7 @@ template reduce(fun...) if (fun.length >= 1)
|
|||
/++
|
||||
Seed version. The seed should be a single value if $(D fun) is a
|
||||
single function. If $(D fun) is multiple functions, then $(D seed)
|
||||
should be a $(XREF typecons,Tuple), with one field per function in $(D f).
|
||||
should be a $(REF Tuple, std,typecons), with one field per function in $(D f).
|
||||
|
||||
For convenience, if the seed is const, or has qualified fields, then
|
||||
$(D reduce) will operate on an unqualified copy. If this happens
|
||||
|
|
@ -2768,7 +2768,7 @@ Sometimes it is very useful to compute multiple aggregates in one pass.
|
|||
One advantage is that the computation is faster because the looping overhead
|
||||
is shared. That's why $(D reduce) accepts multiple functions.
|
||||
If two or more functions are passed, $(D reduce) returns a
|
||||
$(XREF typecons, Tuple) object with one member per passed-in function.
|
||||
$(REF Tuple, std,typecons) object with one member per passed-in function.
|
||||
The number of seeds must be correspondingly increased.
|
||||
*/
|
||||
@safe unittest
|
||||
|
|
@ -3459,7 +3459,7 @@ Two adjacent separators are considered to surround an empty element in
|
|||
the split range. Use $(D filter!(a => !a.empty)) on the result to compress
|
||||
empty elements.
|
||||
|
||||
The predicate is passed to $(XREF functional,binaryFun), and can either accept
|
||||
The predicate is passed to $(REF binaryFun, std,functional), and can either accept
|
||||
a string, or any callable that can be executed via $(D pred(element, s)).
|
||||
|
||||
If the empty range is given, the result is a range with one empty
|
||||
|
|
@ -3488,7 +3488,7 @@ Returns:
|
|||
likewise.
|
||||
|
||||
See_Also:
|
||||
$(XREF regex, _splitter) for a version that splits using a regular
|
||||
$(REF _splitter, std,regex) for a version that splits using a regular
|
||||
expression defined separator.
|
||||
*/
|
||||
auto splitter(alias pred = "a == b", Range, Separator)(Range r, Separator s)
|
||||
|
|
@ -3744,7 +3744,7 @@ if (is(typeof(binaryFun!pred(r.front, s)) : bool)
|
|||
Similar to the previous overload of $(D splitter), except this one uses another
|
||||
range as a separator. This can be used with any narrow string type or sliceable
|
||||
range type, but is most popular with string types. The predicate is passed to
|
||||
$(XREF functional,binaryFun), and can either accept a string, or any callable
|
||||
$(REF binaryFun, std,functional), and can either accept a string, or any callable
|
||||
that can be executed via $(D pred(r.front, s.front)).
|
||||
|
||||
Two adjacent separators are considered to surround an empty element in
|
||||
|
|
@ -3768,7 +3768,7 @@ Returns:
|
|||
is a forward range or bidirectional range, the returned range will be
|
||||
likewise.
|
||||
|
||||
See_Also: $(XREF regex, _splitter) for a version that splits using a regular
|
||||
See_Also: $(REF _splitter, std,regex) for a version that splits using a regular
|
||||
expression defined separator.
|
||||
*/
|
||||
auto splitter(alias pred = "a == b", Range, Separator)(Range r, Separator s)
|
||||
|
|
@ -4017,7 +4017,7 @@ if (is(typeof(binaryFun!pred(r.front, s.front)) : bool)
|
|||
|
||||
Similar to the previous overload of $(D splitter), except this one does not use a separator.
|
||||
Instead, the predicate is an unary function on the input range's element type.
|
||||
The $(D isTerminator) predicate is passed to $(XREF functional,unaryFun) and can
|
||||
The $(D isTerminator) predicate is passed to $(REF unaryFun, std,functional) and can
|
||||
either accept a string, or any callable that can be executed via $(D pred(element, s)).
|
||||
|
||||
Two adjacent separators are considered to surround an empty element in
|
||||
|
|
@ -4037,7 +4037,7 @@ Returns:
|
|||
is a forward range or bidirectional range, the returned range will be
|
||||
likewise.
|
||||
|
||||
See_Also: $(XREF regex, _splitter) for a version that splits using a regular
|
||||
See_Also: $(REF _splitter, std,regex) for a version that splits using a regular
|
||||
expression defined separator.
|
||||
*/
|
||||
auto splitter(alias isTerminator, Range)(Range input)
|
||||
|
|
@ -4754,7 +4754,7 @@ Lazily iterates unique consecutive elements of the given range (functionality
|
|||
akin to the $(WEB wikipedia.org/wiki/_Uniq, _uniq) system
|
||||
utility). Equivalence of elements is assessed by using the predicate
|
||||
$(D pred), by default $(D "a == b"). The predicate is passed to
|
||||
$(XREF functional,binaryFun), and can either accept a string, or any callable
|
||||
$(REF binaryFun, std,functional), and can either accept a string, or any callable
|
||||
that can be executed via $(D pred(element, element)). If the given range is
|
||||
bidirectional, $(D uniq) also yields a bidirectional range.
|
||||
|
||||
|
|
|
|||
|
|
@ -385,7 +385,7 @@ range elements, different types of ranges are accepted:
|
|||
|
||||
/**
|
||||
To _copy at most $(D n) elements from a range, you may want to use
|
||||
$(XREF range, take):
|
||||
$(REF take, std,range):
|
||||
*/
|
||||
@safe unittest
|
||||
{
|
||||
|
|
@ -412,7 +412,7 @@ use $(LREF filter):
|
|||
}
|
||||
|
||||
/**
|
||||
$(XREF range, retro) can be used to achieve behavior similar to
|
||||
$(REF retro, std,range) can be used to achieve behavior similar to
|
||||
$(WEB sgi.com/tech/stl/copy_backward.html, STL's copy_backward'):
|
||||
*/
|
||||
@safe unittest
|
||||
|
|
|
|||
|
|
@ -33,7 +33,7 @@ $(T2 endsWith,
|
|||
$(D endsWith("rocks", "ks")) returns $(D true).)
|
||||
$(T2 find,
|
||||
$(D find("hello world", "or")) returns $(D "orld") using linear search.
|
||||
(For binary search refer to $(XREF range,sortedRange).))
|
||||
(For binary search refer to $(REF sortedRange, std,range).))
|
||||
$(T2 findAdjacent,
|
||||
$(D findAdjacent([1, 2, 3, 3, 4])) returns the subrange starting with
|
||||
two equal adjacent elements, i.e. $(D [3, 3, 4]).)
|
||||
|
|
@ -398,7 +398,7 @@ $(D takeExactly(r1, n)), where $(D n) is the number of elements in the common
|
|||
prefix of both ranges.
|
||||
|
||||
See_Also:
|
||||
$(XREF range, takeExactly)
|
||||
$(REF takeExactly, std,range)
|
||||
*/
|
||||
auto commonPrefix(alias pred = "a == b", R1, R2)(R1 r1, R2 r2)
|
||||
if (isForwardRange!R1 && isInputRange!R2 &&
|
||||
|
|
@ -1317,7 +1317,7 @@ pred). Performs $(BIGOH walkLength(haystack)) evaluations of $(D
|
|||
pred).
|
||||
|
||||
To _find the last occurrence of $(D needle) in $(D haystack), call $(D
|
||||
find(retro(haystack), needle)). See $(XREF range, retro).
|
||||
find(retro(haystack), needle)). See $(REF retro, std,range).
|
||||
|
||||
Params:
|
||||
|
||||
|
|
|
|||
|
|
@ -72,7 +72,7 @@ Params:
|
|||
otherRanges = Zero or more non-infinite forward ranges
|
||||
|
||||
Returns:
|
||||
A forward range of $(XREF typecons,Tuple) representing elements of the
|
||||
A forward range of $(REF Tuple, std,typecons) representing elements of the
|
||||
cartesian product of the given ranges.
|
||||
*/
|
||||
auto cartesianProduct(R1, R2)(R1 range1, R2 range2)
|
||||
|
|
|
|||
|
|
@ -10,7 +10,7 @@ $(T2 completeSort,
|
|||
$(D completeSort(a, b)) leaves $(D a = [6, 10, 15]) and $(D b = [20,
|
||||
30, 40]).
|
||||
The range $(D a) must be sorted prior to the call, and as a result the
|
||||
combination $(D $(XREF range,chain)(a, b)) is sorted.)
|
||||
combination $(D $(REF chain, std,range)(a, b)) is sorted.)
|
||||
$(T2 isPartitioned,
|
||||
$(D isPartitioned!"a < 0"([-1, -2, 1, 0, 2])) returns $(D true) because
|
||||
the predicate is $(D true) for a portion of the range and $(D false)
|
||||
|
|
@ -594,7 +594,7 @@ Params:
|
|||
pivot = The pivot element.
|
||||
|
||||
Returns:
|
||||
A $(XREF typecons,Tuple) of the three resulting ranges. These ranges are
|
||||
A $(REF Tuple, std,typecons) of the three resulting ranges. These ranges are
|
||||
slices of the original range.
|
||||
|
||||
BUGS: stable $(D partition3) has not been implemented yet.
|
||||
|
|
@ -1084,12 +1084,12 @@ Sorts a random-access range according to the predicate $(D less). Performs
|
|||
$(BIGOH r.length * log(r.length)) evaluations of $(D less). Stable sorting
|
||||
requires $(D hasAssignableElements!Range) to be true.
|
||||
|
||||
$(D sort) returns a $(XREF range, SortedRange) over the original range, which
|
||||
$(D sort) returns a $(REF SortedRange, std,range) over the original range, which
|
||||
functions that can take advantage of sorted data can then use to know that the
|
||||
range is sorted and adjust accordingly. The $(XREF range, SortedRange) is a
|
||||
range is sorted and adjust accordingly. The $(REF SortedRange, std,range) is a
|
||||
wrapper around the original range, so both it and the original range are sorted,
|
||||
but other functions won't know that the original range has been sorted, whereas
|
||||
they $(I can) know that $(XREF range, SortedRange) has been sorted.
|
||||
they $(I can) know that $(REF SortedRange, std,range) has been sorted.
|
||||
|
||||
The predicate is expected to satisfy certain rules in order for $(D sort) to
|
||||
behave as expected - otherwise, the program may fail on certain inputs (but not
|
||||
|
|
@ -1099,7 +1099,7 @@ $(D less(a,c)) (transitivity), and, conversely, $(D !less(a,b) && !less(b,c)) to
|
|||
imply $(D !less(a,c)). Note that the default predicate ($(D "a < b")) does not
|
||||
always satisfy these conditions for floating point types, because the expression
|
||||
will always be $(D false) when either $(D a) or $(D b) is NaN.
|
||||
Use $(XREF math, cmp) instead.
|
||||
Use $(REF cmp, std,math) instead.
|
||||
|
||||
If `less` involves expensive computations on the _sort key, it may be
|
||||
worthwhile to use $(LREF schwartzSort) instead.
|
||||
|
|
@ -1121,10 +1121,10 @@ or more allocations per call. Both algorithms have $(BIGOH n log n) worst-case
|
|||
time complexity.
|
||||
|
||||
See_Also:
|
||||
$(XREF range, assumeSorted)$(BR)
|
||||
$(XREF range, SortedRange)$(BR)
|
||||
$(REF assumeSorted, std,range)$(BR)
|
||||
$(REF SortedRange, std,range)$(BR)
|
||||
$(XREF_PACK algorithm,mutation,SwapStrategy)$(BR)
|
||||
$(XREF functional, binaryFun)
|
||||
$(REF binaryFun, std,functional)
|
||||
*/
|
||||
SortedRange!(Range, less)
|
||||
sort(alias less = "a < b", SwapStrategy ss = SwapStrategy.unstable,
|
||||
|
|
|
|||
|
|
@ -339,7 +339,7 @@ range, which must be a range of tuples (Key, Value). Returns a null associative
|
|||
array reference when given an empty range.
|
||||
Duplicates: Associative arrays have unique keys. If r contains duplicate keys,
|
||||
then the result will contain the value of the last pair for that key in r.
|
||||
See_Also: $(XREF typecons, Tuple)
|
||||
See_Also: $(REF Tuple, std,typecons)
|
||||
*/
|
||||
|
||||
auto assocArray(Range)(Range r)
|
||||
|
|
@ -1247,7 +1247,7 @@ pure nothrow bool sameTail(T)(in T[] lhs, in T[] rhs)
|
|||
/********************************************
|
||||
Returns an array that consists of $(D s) (which must be an input
|
||||
range) repeated $(D n) times. This function allocates, fills, and
|
||||
returns a new array. For a lazy version, refer to $(XREF range, repeat).
|
||||
returns a new array. For a lazy version, refer to $(REF repeat, std,range).
|
||||
*/
|
||||
ElementEncodingType!S[] replicate(S)(S s, size_t n) if (isDynamicArray!S)
|
||||
{
|
||||
|
|
@ -1330,7 +1330,7 @@ See_Also:
|
|||
$(XREF_PACK algorithm,iteration,splitter) for a version that splits using any
|
||||
separator.
|
||||
|
||||
$(XREF regex, splitter) for a version that splits using a regular
|
||||
$(REF splitter, std,regex) for a version that splits using a regular
|
||||
expression defined separator.
|
||||
+/
|
||||
S[] split(S)(S s) @safe pure
|
||||
|
|
|
|||
|
|
@ -632,7 +632,7 @@ public:
|
|||
/**
|
||||
Implements casting to integer types.
|
||||
|
||||
Throws: $(XREF conv,ConvOverflowException) if the number exceeds
|
||||
Throws: $(REF ConvOverflowException, std,conv) if the number exceeds
|
||||
the target type's range.
|
||||
*/
|
||||
T opCast(T:ulong)() /*pure*/ const
|
||||
|
|
|
|||
|
|
@ -108,10 +108,10 @@ struct Complex(T) if (isFloatingPoint!T)
|
|||
/** Converts the complex number to a string representation.
|
||||
|
||||
The second form of this function is usually not called directly;
|
||||
instead, it is used via $(XREF string,format), as shown in the examples
|
||||
instead, it is used via $(REF format, std,string), as shown in the examples
|
||||
below. Supported format characters are 'e', 'f', 'g', 'a', and 's'.
|
||||
|
||||
See the $(MREF std, format) and $(XREF string, format)
|
||||
See the $(MREF std, format) and $(REF format, std,string)
|
||||
documentation for more information.
|
||||
*/
|
||||
string toString() const /* TODO: @safe pure nothrow */
|
||||
|
|
@ -822,7 +822,7 @@ unittest{
|
|||
|
||||
Note:
|
||||
$(D expi) is included here for convenience and for easy migration of code
|
||||
that uses $(XREF math,_expi). Unlike $(XREF math,_expi), which uses the
|
||||
that uses $(REF _expi, std,math). Unlike $(REF _expi, std,math), which uses the
|
||||
x87 $(I fsincos) instruction when possible, this function is no faster
|
||||
than calculating cos(y) and sin(y) separately.
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -259,7 +259,7 @@ class LinkTerminated : Exception
|
|||
|
||||
/**
|
||||
* Thrown if a message was sent to a thread via
|
||||
* $(XREF concurrency, prioritySend) and the receiver does not have a handler
|
||||
* $(REF prioritySend, std,concurrency) and the receiver does not have a handler
|
||||
* for a message of this type.
|
||||
*/
|
||||
class PriorityMessageException : Exception
|
||||
|
|
@ -596,7 +596,7 @@ unittest
|
|||
* Places the values as a message at the back of tid's message queue.
|
||||
*
|
||||
* Sends the supplied value to the thread represented by tid. As with
|
||||
* $(XREF concurrency, spawn), $(D T) must not have unshared aliasing.
|
||||
* $(REF spawn, std,concurrency), $(D T) must not have unshared aliasing.
|
||||
*/
|
||||
void send(T...)( Tid tid, T vals )
|
||||
{
|
||||
|
|
@ -648,10 +648,10 @@ private void _send(T...)( MsgType type, Tid tid, T vals )
|
|||
* specified types are available. This function works by pattern matching
|
||||
* a message against a set of delegates and executing the first match found.
|
||||
*
|
||||
* If a delegate that accepts a $(XREF variant, Variant) is included as
|
||||
* If a delegate that accepts a $(REF Variant, std,variant) is included as
|
||||
* the last argument to $(D receive), it will match any message that was not
|
||||
* matched by an earlier delegate. If more than one argument is sent,
|
||||
* the $(D Variant) will contain a $(XREF typecons, Tuple) of all values
|
||||
* the $(D Variant) will contain a $(REF Tuple, std,typecons) of all values
|
||||
* sent.
|
||||
*
|
||||
* Example:
|
||||
|
|
@ -740,7 +740,7 @@ private template receiveOnlyRet(T...)
|
|||
* is received.
|
||||
*
|
||||
* Returns: The received message. If $(D T.length) is greater than one,
|
||||
* the message will be packed into a $(XREF typecons, Tuple).
|
||||
* the message will be packed into a $(REF Tuple, std,typecons).
|
||||
*
|
||||
* Example:
|
||||
* ---
|
||||
|
|
|
|||
|
|
@ -722,7 +722,7 @@ private struct RBRange(N)
|
|||
* of $(BIGOH lg(n)).
|
||||
*
|
||||
* To use a different comparison than $(D "a < b"), pass a different operator string
|
||||
* that can be used by $(XREF functional, binaryFun), or pass in a
|
||||
* that can be used by $(REF binaryFun, std,functional), or pass in a
|
||||
* function, delegate, functor, or any type where $(D less(a, b)) results in a $(D bool)
|
||||
* value.
|
||||
*
|
||||
|
|
|
|||
|
|
@ -5204,7 +5204,7 @@ unittest
|
|||
(e.g from $(D int) to $(D long)).
|
||||
|
||||
Note that the result is always mutable even if the original type was const
|
||||
or immutable. In order to retain the constness, use $(XREF traits, Unsigned).
|
||||
or immutable. In order to retain the constness, use $(REF Unsigned, std,traits).
|
||||
*/
|
||||
auto unsigned(T)(T x) if (isIntegral!T)
|
||||
{
|
||||
|
|
@ -5278,7 +5278,7 @@ unittest
|
|||
(e.g from $(D uint) to $(D ulong)).
|
||||
|
||||
Note that the result is always mutable even if the original type was const
|
||||
or immutable. In order to retain the constness, use $(XREF traits, Signed).
|
||||
or immutable. In order to retain the constness, use $(REF Signed, std,traits).
|
||||
*/
|
||||
auto signed(T)(T x) if (isIntegral!T)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -388,7 +388,7 @@ unittest
|
|||
|
||||
/**
|
||||
* Checks whether the digest has a $(D blockSize) member, which contains the
|
||||
* digest's internal block size in bits. It is primarily used by $(XREF digest.hmac, HMAC).
|
||||
* digest's internal block size in bits. It is primarily used by $(REF HMAC, std,digest.hmac).
|
||||
*/
|
||||
|
||||
template hasBlockSize(T)
|
||||
|
|
|
|||
|
|
@ -26,7 +26,7 @@ import std.meta : allSatisfy;
|
|||
* information about the block size, it can be supplied explicitly using
|
||||
* the second overload.
|
||||
*
|
||||
* This type conforms to $(XREF digest.digest, isDigest).
|
||||
* This type conforms to $(REF isDigest, std,digest.digest).
|
||||
*/
|
||||
|
||||
version(StdDdoc)
|
||||
|
|
@ -142,7 +142,7 @@ if (hashBlockSize % 8 == 0)
|
|||
|
||||
/**
|
||||
* Feeds a piece of data into the hash computation. This method allows the
|
||||
* type to be used as an $(XREF range, OutputRange).
|
||||
* type to be used as an $(REF OutputRange, std,range).
|
||||
*
|
||||
* Returns:
|
||||
* A reference to the digest for convenient chaining.
|
||||
|
|
|
|||
|
|
@ -2197,7 +2197,7 @@ unittest
|
|||
r = Destination string
|
||||
|
||||
See_Also:
|
||||
$(XREF conv, to)
|
||||
$(REF to, std,conv)
|
||||
*/
|
||||
void transcode(Src,Dst)(immutable(Src)[] s,out immutable(Dst)[] r)
|
||||
in
|
||||
|
|
|
|||
|
|
@ -1748,7 +1748,7 @@ Returns: A wrapper $(D struct) that preserves the range interface of $(D input).
|
|||
|
||||
opSlice:
|
||||
Infinite ranges with slicing support must return an instance of
|
||||
$(XREF range, Take) when sliced with a specific lower and upper
|
||||
$(REF Take, std,range) when sliced with a specific lower and upper
|
||||
bound (see $(XREF_PACK range,primitives,hasSlicing)); $(D handle) deals with
|
||||
this by $(D take)ing 0 from the return value of the handler function and
|
||||
returning that when an exception is caught.
|
||||
|
|
|
|||
|
|
@ -382,7 +382,7 @@ version (linux) @safe unittest
|
|||
}
|
||||
|
||||
/********************************************
|
||||
Read and validates (using $(XREF utf, validate)) a text file. $(D S)
|
||||
Read and validates (using $(REF validate, std,utf)) a text file. $(D S)
|
||||
can be a type of array of characters of any width and constancy. No
|
||||
width conversion is performed; if the width of the characters in file
|
||||
$(D name) is different from the width of elements of $(D S),
|
||||
|
|
@ -442,7 +442,7 @@ Params:
|
|||
|
||||
Throws: $(D FileException) on error.
|
||||
|
||||
See_also: $(XREF stdio,toFile)
|
||||
See_also: $(REF toFile, std,stdio)
|
||||
*/
|
||||
void write(R)(R name, const void[] buffer)
|
||||
if ((isInputRange!R && isSomeChar!(ElementEncodingType!R) || isSomeString!R) &&
|
||||
|
|
@ -2566,7 +2566,7 @@ else version (NetBSD)
|
|||
* Returns the full path of the current executable.
|
||||
*
|
||||
* Throws:
|
||||
* $(XREF object, Exception)
|
||||
* $(REF Exception, std,object)
|
||||
*/
|
||||
@trusted string thisExePath ()
|
||||
{
|
||||
|
|
@ -3903,7 +3903,7 @@ unittest
|
|||
path = The directory to iterate over.
|
||||
pattern = String with wildcards, such as $(RED "*.d"). The supported
|
||||
wildcard strings are described under
|
||||
$(XREF _path, globMatch).
|
||||
$(REF globMatch, std,_path).
|
||||
mode = Whether the directory's sub-directories should be iterated
|
||||
over depth-first ($(D_PARAM depth)), breadth-first
|
||||
($(D_PARAM breadth)), or not at all ($(D_PARAM shallow)).
|
||||
|
|
|
|||
|
|
@ -131,7 +131,7 @@ private alias enforceFmt = enforceEx!FormatException;
|
|||
Params:
|
||||
|
||||
w = Output is sent to this writer. Typical output writers include
|
||||
$(XREF array,Appender!string) and $(XREF stdio,LockingTextWriter).
|
||||
$(REF Appender!string, std,array) and $(REF LockingTextWriter, std,stdio).
|
||||
|
||||
fmt = Format string.
|
||||
|
||||
|
|
@ -6415,7 +6415,7 @@ unittest
|
|||
/*****************************************************
|
||||
* Format arguments into a string.
|
||||
*
|
||||
* Params: fmt = Format string. For detailed specification, see $(XREF _format,formattedWrite).
|
||||
* Params: fmt = Format string. For detailed specification, see $(REF formattedWrite, std,_format).
|
||||
* args = Variadic list of arguments to format into returned string.
|
||||
*/
|
||||
immutable(Char)[] format(Char, Args...)(in Char[] fmt, Args args) if (isSomeChar!Char)
|
||||
|
|
|
|||
|
|
@ -784,7 +784,7 @@ unittest
|
|||
|
||||
/**
|
||||
Takes multiple functions and adjoins them together. The result is a
|
||||
$(XREF typecons, Tuple) with one element per passed-in function. Upon
|
||||
$(REF Tuple, std,typecons) with one element per passed-in function. Upon
|
||||
invocation, the returned tuple is the adjoined results of all
|
||||
functions.
|
||||
|
||||
|
|
|
|||
|
|
@ -700,7 +700,7 @@ struct JSONValue
|
|||
|
||||
/**
|
||||
Parses a serialized string and returns a tree of JSON values.
|
||||
Throws: $(XREF json,JSONException) if the depth exceeds the max depth.
|
||||
Throws: $(REF JSONException, std,json) if the depth exceeds the max depth.
|
||||
Params:
|
||||
json = json-formatted string to parse
|
||||
maxDepth = maximum depth of nesting allowed, -1 disables depth checking
|
||||
|
|
@ -1068,7 +1068,7 @@ unittest
|
|||
|
||||
/**
|
||||
Parses a serialized string and returns a tree of JSON values.
|
||||
Throws: $(XREF json,JSONException) if the depth exceeds the max depth.
|
||||
Throws: $(REF JSONException, std,json) if the depth exceeds the max depth.
|
||||
Params:
|
||||
json = json-formatted string to parse
|
||||
options = enable decoding string representations of NaN/Inf as float values
|
||||
|
|
|
|||
|
|
@ -1975,7 +1975,7 @@ private mixin template Protocol()
|
|||
* theprotocol.netInterface = [ 192, 168, 1, 32 ];
|
||||
* ----
|
||||
*
|
||||
* See: $(XREF socket, InternetAddress)
|
||||
* See: $(REF InternetAddress, std,socket)
|
||||
*/
|
||||
@property void netInterface(const(char)[] i)
|
||||
{
|
||||
|
|
@ -2628,7 +2628,7 @@ struct HTTP
|
|||
* theprotocol.netInterface = [ 192, 168, 1, 32 ];
|
||||
* ----
|
||||
*
|
||||
* See: $(XREF socket, InternetAddress)
|
||||
* See: $(REF InternetAddress, std,socket)
|
||||
*/
|
||||
@property void netInterface(const(char)[] i);
|
||||
|
||||
|
|
@ -3308,7 +3308,7 @@ struct FTP
|
|||
* theprotocol.netInterface = [ 192, 168, 1, 32 ];
|
||||
* ----
|
||||
*
|
||||
* See: $(XREF socket, InternetAddress)
|
||||
* See: $(REF InternetAddress, std,socket)
|
||||
*/
|
||||
@property void netInterface(const(char)[] i);
|
||||
|
||||
|
|
@ -3657,7 +3657,7 @@ struct SMTP
|
|||
* theprotocol.netInterface = [ 192, 168, 1, 32 ];
|
||||
* ----
|
||||
*
|
||||
* See: $(XREF socket, InternetAddress)
|
||||
* See: $(REF InternetAddress, std,socket)
|
||||
*/
|
||||
@property void netInterface(const(char)[] i);
|
||||
|
||||
|
|
|
|||
|
|
@ -1413,7 +1413,7 @@ than that for a Fibonacci search.
|
|||
References:
|
||||
"Algorithms for Minimization without Derivatives", Richard Brent, Prentice-Hall, Inc. (1973)
|
||||
|
||||
See_Also: $(LREF findRoot), $(XREF math, isNormal)
|
||||
See_Also: $(LREF findRoot), $(REF isNormal, std,math)
|
||||
+/
|
||||
Tuple!(T, "x", Unqual!(ReturnType!DF), "y", T, "error")
|
||||
findLocalMin(T, DF)(
|
||||
|
|
|
|||
|
|
@ -322,12 +322,12 @@ class OutBuffer
|
|||
* Formats and writes its arguments in text format to the OutBuffer.
|
||||
*
|
||||
* Params:
|
||||
* fmt = format string as described in $(XREF format, formattedWrite)
|
||||
* fmt = format string as described in $(REF formattedWrite, std,format)
|
||||
* args = arguments to be formatted
|
||||
*
|
||||
* See_Also:
|
||||
* $(XREF stdio, _writef);
|
||||
* $(XREF format, formattedWrite);
|
||||
* $(REF _writef, std,stdio);
|
||||
* $(REF formattedWrite, std,format);
|
||||
*/
|
||||
void writef(Char, A...)(in Char[] fmt, A args)
|
||||
{
|
||||
|
|
@ -348,12 +348,12 @@ class OutBuffer
|
|||
* followed by a newline.
|
||||
*
|
||||
* Params:
|
||||
* fmt = format string as described in $(XREF format, formattedWrite)
|
||||
* fmt = format string as described in $(REF formattedWrite, std,format)
|
||||
* args = arguments to be formatted
|
||||
*
|
||||
* See_Also:
|
||||
* $(XREF stdio, _writefln);
|
||||
* $(XREF format, formattedWrite);
|
||||
* $(REF _writefln, std,stdio);
|
||||
* $(REF formattedWrite, std,format);
|
||||
*/
|
||||
void writefln(Char, A...)(in Char[] fmt, A args)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -414,7 +414,7 @@ meaning that any memory writes made in the thread that executed the $(D Task)
|
|||
are guaranteed to be visible in the calling thread after one of these functions
|
||||
returns.
|
||||
|
||||
The $(XREF parallelism, task) and $(XREF parallelism, scopedTask) functions can
|
||||
The $(REF task, std,parallelism) and $(REF scopedTask, std,parallelism) functions can
|
||||
be used to create an instance of this struct. See $(D task) for usage examples.
|
||||
|
||||
Function results are returned from $(D yieldForce), $(D spinForce) and
|
||||
|
|
@ -733,7 +733,7 @@ struct Task(alias fun, Args...)
|
|||
newly created thread, then terminate the thread. This can be used for
|
||||
future/promise parallelism. An explicit priority may be given
|
||||
to the $(D Task). If one is provided, its value is forwarded to
|
||||
$(D core.thread.Thread.priority). See $(XREF parallelism, task) for
|
||||
$(D core.thread.Thread.priority). See $(REF task, std,parallelism) for
|
||||
usage example.
|
||||
*/
|
||||
void executeInNewThread() @trusted
|
||||
|
|
@ -771,8 +771,8 @@ ReturnType!F run(F, Args...)(F fpOrDelegate, ref Args args)
|
|||
/**
|
||||
Creates a $(D Task) on the GC heap that calls an alias. This may be executed
|
||||
via $(D Task.executeInNewThread) or by submitting to a
|
||||
$(XREF parallelism, TaskPool). A globally accessible instance of
|
||||
$(D TaskPool) is provided by $(XREF parallelism, taskPool).
|
||||
$(REF TaskPool, std,parallelism). A globally accessible instance of
|
||||
$(D TaskPool) is provided by $(REF taskPool, std,parallelism).
|
||||
|
||||
Returns: A pointer to the $(D Task).
|
||||
|
||||
|
|
@ -883,7 +883,7 @@ identical to the non-@safe case, but safety introduces some restrictions:
|
|||
1. $(D fun) must be @safe or @trusted.
|
||||
|
||||
2. $(D F) must not have any unshared aliasing as defined by
|
||||
$(XREF traits, hasUnsharedAliasing). This means it
|
||||
$(REF hasUnsharedAliasing, std,traits). This means it
|
||||
may not be an unshared delegate or a non-shared class or struct
|
||||
with overloaded $(D opCall). This also precludes accepting template
|
||||
alias parameters.
|
||||
|
|
@ -1000,7 +1000,7 @@ thread that executes the $(D Task) at the front of the queue when one is
|
|||
available and sleeps when the queue is empty.
|
||||
|
||||
This class should usually be used via the global instantiation
|
||||
available via the $(XREF parallelism, taskPool) property.
|
||||
available via the $(REF taskPool, std,parallelism) property.
|
||||
Occasionally it is useful to explicitly instantiate a $(D TaskPool):
|
||||
|
||||
1. When you want $(D TaskPool) instances with multiple priorities, for example
|
||||
|
|
@ -3141,7 +3141,7 @@ public:
|
|||
Notes:
|
||||
|
||||
@trusted overloads of this function are called for $(D Task)s if
|
||||
$(XREF traits, hasUnsharedAliasing) is false for the $(D Task)'s
|
||||
$(REF hasUnsharedAliasing, std,traits) is false for the $(D Task)'s
|
||||
return type or the function the $(D Task) executes is $(D pure).
|
||||
$(D Task) objects that meet all other requirements specified in the
|
||||
$(D @trusted) overloads of $(D task) and $(D scopedTask) may be created
|
||||
|
|
|
|||
|
|
@ -10,8 +10,8 @@
|
|||
between a _path that points to a directory and a _path that points to a
|
||||
file, and it does not know whether or not the object pointed to by the
|
||||
_path actually exists in the file system.
|
||||
To differentiate between these cases, use $(XREF file,isDir) and
|
||||
$(XREF file,exists).
|
||||
To differentiate between these cases, use $(REF isDir, std,file) and
|
||||
$(REF exists, std,file).
|
||||
|
||||
Note that on Windows, both the backslash ($(D `\`)) and the slash ($(D `/`))
|
||||
are in principle valid directory separators. This module treats them
|
||||
|
|
@ -3547,7 +3547,7 @@ unittest
|
|||
or is equal to $(D ".") or $(D "..").
|
||||
|
||||
$(B It does $(I not) check whether the _path points to an existing file
|
||||
or directory; use $(XREF file,exists) for this purpose.)
|
||||
or directory; use $(REF exists, std,file) for this purpose.)
|
||||
|
||||
On Windows, some special rules apply:
|
||||
$(UL
|
||||
|
|
|
|||
|
|
@ -225,7 +225,7 @@ wait(spawnProcess("myapp", ["foo" : "bar"], Config.newEnv));
|
|||
|
||||
Standard_streams:
|
||||
The optional arguments $(D stdin), $(D stdout) and $(D stderr) may
|
||||
be used to assign arbitrary $(XREF stdio,File) objects as the standard
|
||||
be used to assign arbitrary $(REF File, std,stdio) objects as the standard
|
||||
input, output and error streams, respectively, of the child process. The
|
||||
former must be opened for reading, while the latter two must be opened for
|
||||
writing. The default is for the child process to inherit the standard
|
||||
|
|
@ -260,14 +260,14 @@ Params:
|
|||
args = An array which contains the program name as the zeroth element
|
||||
and any command-line arguments in the following elements.
|
||||
stdin = The standard input stream of the child process.
|
||||
This can be any $(XREF stdio,File) that is opened for reading.
|
||||
This can be any $(REF File, std,stdio) that is opened for reading.
|
||||
By default the child process inherits the parent's input
|
||||
stream.
|
||||
stdout = The standard output stream of the child process.
|
||||
This can be any $(XREF stdio,File) that is opened for writing.
|
||||
This can be any $(REF File, std,stdio) that is opened for writing.
|
||||
By default the child process inherits the parent's output stream.
|
||||
stderr = The standard error stream of the child process.
|
||||
This can be any $(XREF stdio,File) that is opened for writing.
|
||||
This can be any $(REF File, std,stdio) that is opened for writing.
|
||||
By default the child process inherits the parent's error stream.
|
||||
env = Additional environment variables for the child process.
|
||||
config = Flags that control process creation. See $(LREF Config)
|
||||
|
|
@ -281,7 +281,7 @@ A $(LREF Pid) object that corresponds to the spawned process.
|
|||
|
||||
Throws:
|
||||
$(LREF ProcessException) on failure to start the process.$(BR)
|
||||
$(XREF stdio,StdioException) on failure to pass one of the streams
|
||||
$(REF StdioException, std,stdio) on failure to pass one of the streams
|
||||
to the child process (Windows only).$(BR)
|
||||
$(CXREF exception,RangeError) if $(D args) is empty.
|
||||
*/
|
||||
|
|
@ -1588,7 +1588,7 @@ Returns:
|
|||
A $(LREF Pipe) object that corresponds to the created _pipe.
|
||||
|
||||
Throws:
|
||||
$(XREF stdio,StdioException) on failure.
|
||||
$(REF StdioException, std,stdio) on failure.
|
||||
*/
|
||||
version (Posix)
|
||||
Pipe pipe() @trusted //TODO: @safe
|
||||
|
|
@ -1655,7 +1655,7 @@ struct Pipe
|
|||
/**
|
||||
Closes both ends of the pipe.
|
||||
|
||||
Normally it is not necessary to do this manually, as $(XREF stdio,File)
|
||||
Normally it is not necessary to do this manually, as $(REF File, std,stdio)
|
||||
objects are automatically closed when there are no more references
|
||||
to them.
|
||||
|
||||
|
|
@ -1664,7 +1664,7 @@ struct Pipe
|
|||
child process is platform dependent.)
|
||||
|
||||
Throws:
|
||||
$(XREF exception,ErrnoException) if an error occurs.
|
||||
$(REF ErrnoException, std,exception) if an error occurs.
|
||||
*/
|
||||
void close() @safe
|
||||
{
|
||||
|
|
@ -1729,14 +1729,14 @@ shellPath = The path to the shell to use to run the specified program.
|
|||
By default this is $(LREF nativeShell).
|
||||
|
||||
Returns:
|
||||
A $(LREF ProcessPipes) object which contains $(XREF stdio,File)
|
||||
A $(LREF ProcessPipes) object which contains $(REF File, std,stdio)
|
||||
handles that communicate with the redirected streams of the child
|
||||
process, along with a $(LREF Pid) object that corresponds to the
|
||||
spawned process.
|
||||
|
||||
Throws:
|
||||
$(LREF ProcessException) on failure to start the process.$(BR)
|
||||
$(XREF stdio,StdioException) on failure to redirect any of the streams.$(BR)
|
||||
$(REF StdioException, std,stdio) on failure to redirect any of the streams.$(BR)
|
||||
|
||||
Example:
|
||||
---
|
||||
|
|
@ -2000,7 +2000,7 @@ unittest
|
|||
}
|
||||
|
||||
/**
|
||||
Object which contains $(XREF stdio,File) handles that allow communication
|
||||
Object which contains $(REF File, std,stdio) handles that allow communication
|
||||
with a child process through its standard streams.
|
||||
*/
|
||||
struct ProcessPipes
|
||||
|
|
@ -2013,7 +2013,7 @@ struct ProcessPipes
|
|||
}
|
||||
|
||||
/**
|
||||
An $(XREF stdio,File) that allows writing to the child process'
|
||||
An $(REF File, std,stdio) that allows writing to the child process'
|
||||
standard input stream.
|
||||
|
||||
Throws:
|
||||
|
|
@ -2029,7 +2029,7 @@ struct ProcessPipes
|
|||
}
|
||||
|
||||
/**
|
||||
An $(XREF stdio,File) that allows reading from the child process'
|
||||
An $(REF File, std,stdio) that allows reading from the child process'
|
||||
standard output stream.
|
||||
|
||||
Throws:
|
||||
|
|
@ -2045,7 +2045,7 @@ struct ProcessPipes
|
|||
}
|
||||
|
||||
/**
|
||||
An $(XREF stdio,File) that allows reading from the child process'
|
||||
An $(REF File, std,stdio) that allows reading from the child process'
|
||||
standard error stream.
|
||||
|
||||
Throws:
|
||||
|
|
@ -2122,7 +2122,7 @@ value is the signal number. (See $(LREF wait) for details.)
|
|||
|
||||
Throws:
|
||||
$(LREF ProcessException) on failure to start the process.$(BR)
|
||||
$(XREF stdio,StdioException) on failure to capture output.
|
||||
$(REF StdioException, std,stdio) on failure to capture output.
|
||||
*/
|
||||
auto execute(in char[][] args,
|
||||
const string[string] env = null,
|
||||
|
|
@ -2981,7 +2981,7 @@ static:
|
|||
|
||||
Throws:
|
||||
$(OBJECTREF Exception) if the environment variable does not exist,
|
||||
or $(XREF utf,UTFException) if the variable contains invalid UTF-16
|
||||
or $(REF UTFException, std,utf) if the variable contains invalid UTF-16
|
||||
characters (Windows only).
|
||||
|
||||
See_also:
|
||||
|
|
@ -3016,7 +3016,7 @@ static:
|
|||
---
|
||||
|
||||
Throws:
|
||||
$(XREF utf,UTFException) if the variable contains invalid UTF-16
|
||||
$(REF UTFException, std,utf) if the variable contains invalid UTF-16
|
||||
characters (Windows only).
|
||||
*/
|
||||
string get(in char[] name, string defaultValue = null) @safe
|
||||
|
|
|
|||
|
|
@ -2967,7 +2967,7 @@ Take!(Repeat!T) repeat(T)(T value, size_t n)
|
|||
}
|
||||
|
||||
/**
|
||||
Given callable ($(XREF traits, isCallable)) $(D fun), create as a range
|
||||
Given callable ($(REF isCallable, std,traits)) $(D fun), create as a range
|
||||
whose front is defined by successive calls to $(D fun()).
|
||||
This is especially useful to call function with global side effects (random
|
||||
functions), or to create ranges expressed as a single delegate, rather than
|
||||
|
|
@ -2981,7 +2981,7 @@ The resulting range will call $(D fun()) on every call to $(D front),
|
|||
and only when $(D front) is called, regardless of how the range is
|
||||
iterated.
|
||||
It is advised to compose generate with either
|
||||
$(XREF_PACK algorithm,iteration,cache) or $(XREF array,array), or to use it in a
|
||||
$(XREF_PACK algorithm,iteration,cache) or $(REF array, std,array), or to use it in a
|
||||
foreach loop.
|
||||
A by-value foreach loop means that the loop value is not $(D ref).
|
||||
|
||||
|
|
@ -5370,7 +5370,7 @@ auto iota(B, E)(B begin, E end)
|
|||
}
|
||||
|
||||
/**
|
||||
User-defined types such as $(XREF bigint, BigInt) are also supported, as long
|
||||
User-defined types such as $(REF BigInt, std,bigint) are also supported, as long
|
||||
as they can be incremented with $(D ++) and compared with $(D <) or $(D ==).
|
||||
*/
|
||||
// Issue 6447
|
||||
|
|
@ -7274,7 +7274,7 @@ unittest
|
|||
/**
|
||||
Iterate over $(D range) with an attached index variable.
|
||||
|
||||
Each element is a $(XREF typecons, Tuple) containing the index
|
||||
Each element is a $(REF Tuple, std,typecons) containing the index
|
||||
and the element, in that order, where the index member is named $(D index)
|
||||
and the element member is named $(D value).
|
||||
|
||||
|
|
@ -9222,7 +9222,7 @@ struct NullSink
|
|||
It is important to note that as the resultant range is evaluated lazily,
|
||||
in the case of the version of $(D tee) that takes a function, the function
|
||||
will not actually be executed until the range is "walked" using functions
|
||||
that evaluate ranges, such as $(XREF array,array) or
|
||||
that evaluate ranges, such as $(REF array, std,array) or
|
||||
$(XREF_PACK algorithm,iteration,fold).
|
||||
|
||||
Params:
|
||||
|
|
|
|||
16
std/stdio.d
16
std/stdio.d
|
|
@ -1480,7 +1480,7 @@ Params:
|
|||
buf = Buffer used to store the resulting line data. buf is
|
||||
resized as necessary.
|
||||
terminator = Line terminator (by default, $(D '\n')). Use
|
||||
$(XREF ascii, newline) for portability (unless the file was opened in
|
||||
$(REF newline, std,ascii) for portability (unless the file was opened in
|
||||
text mode).
|
||||
|
||||
Returns:
|
||||
|
|
@ -1668,7 +1668,7 @@ is recommended if you want to process a complete file.
|
|||
/**
|
||||
* Read data from the file according to the specified
|
||||
* $(LINK2 std_format.html#_format-string, format specifier) using
|
||||
* $(XREF _format,formattedRead).
|
||||
* $(REF formattedRead, std,_format).
|
||||
*/
|
||||
uint readf(Data...)(in char[] format, Data data)
|
||||
{
|
||||
|
|
@ -1899,7 +1899,7 @@ Char = Character type for each line, defaulting to $(D char).
|
|||
keepTerminator = Use $(D KeepTerminator.yes) to include the
|
||||
terminator at the end of each line.
|
||||
terminator = Line separator ($(D '\n') by default). Use
|
||||
$(XREF ascii, newline) for portability (unless the file was opened in
|
||||
$(REF newline, std,ascii) for portability (unless the file was opened in
|
||||
text mode).
|
||||
|
||||
Example:
|
||||
|
|
@ -2058,7 +2058,7 @@ Char = Character type for each line, defaulting to $(D immutable char).
|
|||
keepTerminator = Use $(D KeepTerminator.yes) to include the
|
||||
terminator at the end of each line.
|
||||
terminator = Line separator ($(D '\n') by default). Use
|
||||
$(XREF ascii, newline) for portability (unless the file was opened in
|
||||
$(REF newline, std,ascii) for portability (unless the file was opened in
|
||||
text mode).
|
||||
|
||||
Example:
|
||||
|
|
@ -2076,7 +2076,7 @@ void main()
|
|||
}
|
||||
----
|
||||
See_Also:
|
||||
$(XREF file,readText)
|
||||
$(REF readText, std,file)
|
||||
*/
|
||||
auto byLineCopy(Terminator = char, Char = immutable char)
|
||||
(KeepTerminator keepTerminator = KeepTerminator.no,
|
||||
|
|
@ -3568,7 +3568,7 @@ unittest
|
|||
/**
|
||||
* Read data from $(D stdin) according to the specified
|
||||
* $(LINK2 std_format.html#format-string, format specifier) using
|
||||
* $(XREF format,formattedRead).
|
||||
* $(REF formattedRead, std,format).
|
||||
*/
|
||||
uint readf(A...)(in char[] format, A args)
|
||||
{
|
||||
|
|
@ -3632,7 +3632,7 @@ if (isSomeString!S)
|
|||
* $(D size_t) 0 for end of file, otherwise number of characters read
|
||||
* Params:
|
||||
* buf = Buffer used to store the resulting line data. buf is resized as necessary.
|
||||
* terminator = Line terminator (by default, $(D '\n')). Use $(XREF ascii, newline)
|
||||
* terminator = Line terminator (by default, $(D '\n')). Use $(REF newline, std,ascii)
|
||||
* for portability (unless the file was opened in text mode).
|
||||
* Throws:
|
||||
* $(D StdioException) on I/O error, or $(D UnicodeException) on Unicode conversion error.
|
||||
|
|
@ -4173,7 +4173,7 @@ unittest
|
|||
/**
|
||||
Writes an array or range to a file.
|
||||
Shorthand for $(D data.copy(File(fileName, "wb").lockingBinaryWriter)).
|
||||
Similar to $(XREF file,write), strings are written as-is,
|
||||
Similar to $(REF write, std,file), strings are written as-is,
|
||||
rather than encoded according to the $(D File)'s $(WEB
|
||||
en.cppreference.com/w/c/io#Narrow_and_wide_orientation,
|
||||
orientation).
|
||||
|
|
|
|||
44
std/string.d
44
std/string.d
|
|
@ -376,7 +376,7 @@ alias CaseSensitive = Flag!"caseSensitive";
|
|||
|
||||
Throws:
|
||||
If the sequence starting at $(D startIdx) does not represent a well
|
||||
formed codepoint, then a $(XREF utf,UTFException) may be thrown.
|
||||
formed codepoint, then a $(REF UTFException, std,utf) may be thrown.
|
||||
|
||||
+/
|
||||
ptrdiff_t indexOf(Range)(Range s, in dchar c,
|
||||
|
|
@ -699,7 +699,7 @@ unittest
|
|||
|
||||
Throws:
|
||||
If the sequence starting at $(D startIdx) does not represent a well
|
||||
formed codepoint, then a $(XREF utf,UTFException) may be thrown.
|
||||
formed codepoint, then a $(REF UTFException, std,utf) may be thrown.
|
||||
|
||||
Bugs:
|
||||
Does not work with case insensitive strings where the mapping of
|
||||
|
|
@ -971,7 +971,7 @@ unittest
|
|||
|
||||
Throws:
|
||||
If the sequence ending at $(D startIdx) does not represent a well
|
||||
formed codepoint, then a $(XREF utf,UTFException) may be thrown.
|
||||
formed codepoint, then a $(REF UTFException, std,utf) may be thrown.
|
||||
|
||||
$(D cs) indicates whether the comparisons are case sensitive.
|
||||
+/
|
||||
|
|
@ -1157,7 +1157,7 @@ ptrdiff_t lastIndexOf(Char)(const(Char)[] s, in dchar c, in size_t startIdx,
|
|||
|
||||
Throws:
|
||||
If the sequence ending at $(D startIdx) does not represent a well
|
||||
formed codepoint, then a $(XREF utf,UTFException) may be thrown.
|
||||
formed codepoint, then a $(REF UTFException, std,utf) may be thrown.
|
||||
|
||||
$(D cs) indicates whether the comparisons are case sensitive.
|
||||
+/
|
||||
|
|
@ -1538,7 +1538,7 @@ private ptrdiff_t indexOfAnyNeitherImpl(bool forward, bool any, Char, Char2)(
|
|||
then $(D -1) is returned. The $(D startIdx) slices $(D haystack) in the
|
||||
following way $(D haystack[startIdx .. $]). $(D startIdx) represents a
|
||||
codeunit index in $(D haystack). If the sequence ending at $(D startIdx)
|
||||
does not represent a well formed codepoint, then a $(XREF utf,UTFException)
|
||||
does not represent a well formed codepoint, then a $(REF UTFException, std,utf)
|
||||
may be thrown.
|
||||
|
||||
Params:
|
||||
|
|
@ -1707,7 +1707,7 @@ ptrdiff_t indexOfAny(Char,Char2)(const(Char)[] haystack, const(Char2)[] needles,
|
|||
then $(D -1) is returned. The $(D stopIdx) slices $(D haystack) in the
|
||||
following way $(D s[0 .. stopIdx]). $(D stopIdx) represents a codeunit
|
||||
index in $(D haystack). If the sequence ending at $(D startIdx) does not
|
||||
represent a well formed codepoint, then a $(XREF utf,UTFException) may be
|
||||
represent a well formed codepoint, then a $(REF UTFException, std,utf) may be
|
||||
thrown.
|
||||
|
||||
Params:
|
||||
|
|
@ -2281,7 +2281,7 @@ auto representation(Char)(Char[] s) @safe pure nothrow @nogc
|
|||
* The capitalized string.
|
||||
*
|
||||
* See_Also:
|
||||
* $(XREF uni, asCapitalized) for a lazy range version that doesn't allocate memory
|
||||
* $(REF asCapitalized, std,uni) for a lazy range version that doesn't allocate memory
|
||||
*/
|
||||
S capitalize(S)(S input) @trusted pure
|
||||
if (isSomeString!S)
|
||||
|
|
@ -2350,8 +2350,8 @@ auto capitalize(S)(auto ref S s)
|
|||
|
||||
/++
|
||||
Split $(D s) into an array of lines according to the unicode standard using
|
||||
$(D '\r'), $(D '\n'), $(D "\r\n"), $(XREF uni, lineSep),
|
||||
$(XREF uni, paraSep), $(D U+0085) (NEL), $(D '\v') and $(D '\f')
|
||||
$(D '\r'), $(D '\n'), $(D "\r\n"), $(REF lineSep, std,uni),
|
||||
$(REF paraSep, std,uni), $(D U+0085) (NEL), $(D '\v') and $(D '\f')
|
||||
as delimiters. If $(D keepTerm) is set to $(D KeepTerminator.yes), then the
|
||||
delimiter is included in the strings returned.
|
||||
|
||||
|
|
@ -2371,8 +2371,8 @@ auto capitalize(S)(auto ref S s)
|
|||
array of strings, each element is a line that is a slice of $(D s)
|
||||
See_Also:
|
||||
$(LREF lineSplitter)
|
||||
$(XREF algorithm, splitter)
|
||||
$(XREF regex, splitter)
|
||||
$(REF splitter, std,algorithm)
|
||||
$(REF splitter, std,regex)
|
||||
+/
|
||||
alias KeepTerminator = Flag!"keepTerminator";
|
||||
|
||||
|
|
@ -2679,7 +2679,7 @@ public:
|
|||
/***********************************
|
||||
* Split an array or slicable range of characters into a range of lines
|
||||
using $(D '\r'), $(D '\n'), $(D '\v'), $(D '\f'), $(D "\r\n"),
|
||||
$(XREF uni, lineSep), $(XREF uni, paraSep) and $(D '\u0085') (NEL)
|
||||
$(REF lineSep, std,uni), $(REF paraSep, std,uni) and $(D '\u0085') (NEL)
|
||||
as delimiters. If $(D keepTerm) is set to $(D KeepTerminator.yes), then the
|
||||
delimiter is included in the slices returned.
|
||||
|
||||
|
|
@ -2698,8 +2698,8 @@ public:
|
|||
|
||||
See_Also:
|
||||
$(LREF splitLines)
|
||||
$(XREF algorithm, splitter)
|
||||
$(XREF regex, splitter)
|
||||
$(REF splitter, std,algorithm)
|
||||
$(REF splitter, std,regex)
|
||||
*/
|
||||
auto lineSplitter(KeepTerminator keepTerm = KeepTerminator.no, Range)(Range r)
|
||||
if ((hasSlicing!Range && hasLength!Range && isSomeChar!(ElementType!Range) ||
|
||||
|
|
@ -2819,7 +2819,7 @@ unittest
|
|||
}
|
||||
|
||||
/++
|
||||
Strips leading whitespace (as defined by $(XREF uni, isWhite)).
|
||||
Strips leading whitespace (as defined by $(REF isWhite, std,uni)).
|
||||
|
||||
Params:
|
||||
input = string or ForwardRange of characters
|
||||
|
|
@ -2827,7 +2827,7 @@ unittest
|
|||
Returns: $(D input) stripped of leading whitespace.
|
||||
|
||||
Postconditions: $(D input) and the returned value
|
||||
will share the same tail (see $(XREF array, sameTail)).
|
||||
will share the same tail (see $(REF sameTail, std,array)).
|
||||
|
||||
See_Also:
|
||||
Generic stripping on ranges: $(REF _stripLeft, std, algorithm, mutation)
|
||||
|
|
@ -2893,7 +2893,7 @@ unittest
|
|||
}
|
||||
|
||||
/++
|
||||
Strips trailing whitespace (as defined by $(XREF uni, isWhite)).
|
||||
Strips trailing whitespace (as defined by $(REF isWhite, std,uni)).
|
||||
|
||||
Params:
|
||||
str = string or random access range of characters
|
||||
|
|
@ -3055,7 +3055,7 @@ unittest
|
|||
|
||||
/++
|
||||
Strips both leading and trailing whitespace (as defined by
|
||||
$(XREF uni, isWhite)).
|
||||
$(REF isWhite, std,uni)).
|
||||
|
||||
Params:
|
||||
str = string or random access range of characters
|
||||
|
|
@ -3158,7 +3158,7 @@ auto strip(Range)(auto ref Range str)
|
|||
$(D delimiter), then it is returned unchanged.
|
||||
|
||||
If no $(D delimiter) is given, then one trailing $(D '\r'), $(D '\n'),
|
||||
$(D "\r\n"), $(D '\f'), $(D '\v'), $(XREF uni, lineSep), $(XREF uni, paraSep), or $(XREF uni, nelSep)
|
||||
$(D "\r\n"), $(D '\f'), $(D '\v'), $(REF lineSep, std,uni), $(REF paraSep, std,uni), or $(REF nelSep, std,uni)
|
||||
is removed from the end of $(D str). If $(D str) does not end with any of those characters,
|
||||
then it is returned unchanged.
|
||||
|
||||
|
|
@ -4744,7 +4744,7 @@ unittest
|
|||
|
||||
See_Also:
|
||||
$(LREF tr)
|
||||
$(XREF array, replace)
|
||||
$(REF replace, std,array)
|
||||
|
||||
Params:
|
||||
str = The original string.
|
||||
|
|
@ -5012,7 +5012,7 @@ private void translateImpl(C1, T, C2, Buffer)(C1[] str,
|
|||
|
||||
See_Also:
|
||||
$(LREF tr)
|
||||
$(XREF array, replace)
|
||||
$(REF replace, std,array)
|
||||
|
||||
Params:
|
||||
str = The original string.
|
||||
|
|
@ -5447,7 +5447,7 @@ S squeeze(S)(S s, in S pattern = null)
|
|||
/***************************************************************
|
||||
Finds the position $(D_PARAM pos) of the first character in $(D_PARAM
|
||||
s) that does not match $(D_PARAM pattern) (in the terminology used by
|
||||
$(XREF string,inPattern)). Updates $(D_PARAM s =
|
||||
$(REF inPattern, std,string)). Updates $(D_PARAM s =
|
||||
s[pos..$]). Returns the slice from the beginning of the original
|
||||
(before update) string up to, and excluding, $(D_PARAM pos).
|
||||
|
||||
|
|
|
|||
|
|
@ -3330,7 +3330,7 @@ Returns:
|
|||
Note:
|
||||
An enum can have multiple members which have the same value. If you want
|
||||
to use EnumMembers to e.g. generate switch cases at compile-time,
|
||||
you should use the $(XREF typetuple, NoDuplicates) template to avoid
|
||||
you should use the $(REF NoDuplicates, std,typetuple) template to avoid
|
||||
generating duplicate switch cases.
|
||||
|
||||
Note:
|
||||
|
|
|
|||
|
|
@ -310,7 +310,7 @@ for the second, and so on.
|
|||
|
||||
The choice of zero-based indexing instead of one-base indexing was
|
||||
motivated by the ability to use value `Tuple`s with various compile-time
|
||||
loop constructs (e.g. $(XREF meta, AliasSeq) iteration), all of which use
|
||||
loop constructs (e.g. $(REF AliasSeq, std,meta) iteration), all of which use
|
||||
zero-based indexing.
|
||||
|
||||
Params:
|
||||
|
|
@ -6888,7 +6888,7 @@ However, member types in `struct`s or `class`es are not replaced because there
|
|||
are no ways to express the types resulting after replacement.
|
||||
|
||||
This is an advanced type manipulation necessary e.g. for replacing the
|
||||
placeholder type `This` in $(XREF variant, Algebraic).
|
||||
placeholder type `This` in $(REF Algebraic, std,variant).
|
||||
|
||||
Returns: `ReplaceType` aliases itself to the type(s) that result after
|
||||
replacement.
|
||||
|
|
|
|||
|
|
@ -12,7 +12,7 @@ module std.typetuple;
|
|||
public import std.meta;
|
||||
|
||||
/**
|
||||
* Alternate name for $(XREF meta,AliasSeq) for legacy compatibility.
|
||||
* Alternate name for $(REF AliasSeq, std,meta) for legacy compatibility.
|
||||
*/
|
||||
alias TypeTuple = AliasSeq;
|
||||
|
||||
|
|
|
|||
22
std/uni.d
22
std/uni.d
|
|
@ -4,7 +4,7 @@
|
|||
$(P The $(D std.uni) module provides an implementation
|
||||
of fundamental Unicode algorithms and data structures.
|
||||
This doesn't include UTF encoding and decoding primitives,
|
||||
see $(XREF _utf, decode) and $(XREF _utf, encode) in std.utf
|
||||
see $(REF decode, std,_utf) and $(REF encode, std,_utf) in std.utf
|
||||
for this functionality. )
|
||||
|
||||
$(P All primitives listed operate on Unicode characters and
|
||||
|
|
@ -1851,7 +1851,7 @@ public alias CodepointSet = InversionList!GcPolicy;
|
|||
// public alias CodepointInterval = Tuple!(uint, "a", uint, "b");
|
||||
|
||||
/**
|
||||
The recommended type of $(XREF _typecons, Tuple)
|
||||
The recommended type of $(REF Tuple, std,_typecons)
|
||||
to represent [a, b$(RPAREN) intervals of $(CODEPOINTS). As used in $(LREF InversionList).
|
||||
Any interval type should pass $(LREF isIntegralPair) trait.
|
||||
*/
|
||||
|
|
@ -2293,8 +2293,8 @@ public:
|
|||
open-right intervals and feed it to $(D sink).
|
||||
)
|
||||
$(P Used by various standard formatting facilities such as
|
||||
$(XREF _format, formattedWrite), $(XREF _stdio, write),
|
||||
$(XREF _stdio, writef), $(XREF _conv, to) and others.
|
||||
$(REF formattedWrite, std,_format), $(REF write, std,_stdio),
|
||||
$(REF writef, std,_stdio), $(REF to, std,_conv) and others.
|
||||
)
|
||||
Example:
|
||||
---
|
||||
|
|
@ -4322,9 +4322,9 @@ private template buildTrie(Value, Key, Args...)
|
|||
In other words $(LREF mapTrieIndex) should be a
|
||||
monotonically increasing function that maps $(D Key) to an integer.
|
||||
|
||||
See_Also: $(XREF _algorithm, sort),
|
||||
$(XREF _range, SortedRange),
|
||||
$(XREF _algorithm, setUnion).
|
||||
See_Also: $(REF sort, std,_algorithm),
|
||||
$(REF SortedRange, std,_range),
|
||||
$(REF setUnion, std,_algorithm).
|
||||
*/
|
||||
auto buildTrie(Range)(Range range, Value filler=Value.init)
|
||||
if (isInputRange!Range && is(typeof(Range.init.front[0]) : Value)
|
||||
|
|
@ -7116,7 +7116,7 @@ unittest
|
|||
}
|
||||
|
||||
/**
|
||||
* By using $(XREF utf, byUTF) and its aliases, GC allocations via auto-decoding
|
||||
* By using $(REF byUTF, std,utf) and its aliases, GC allocations via auto-decoding
|
||||
* and thrown exceptions can be avoided, making `icmp` `@safe @nogc nothrow pure`.
|
||||
*/
|
||||
@safe @nogc nothrow pure unittest
|
||||
|
|
@ -8203,7 +8203,7 @@ private auto toCaser(alias indexFn, uint maxIdx, alias tableFn, alias asciiConve
|
|||
*
|
||||
* Does not allocate memory.
|
||||
* Characters in UTF-8 or UTF-16 format that cannot be decoded
|
||||
* are treated as $(XREF utf, replacementDchar).
|
||||
* are treated as $(REF replacementDchar, std,utf).
|
||||
*
|
||||
* Params:
|
||||
* str = string or range of characters
|
||||
|
|
@ -8423,7 +8423,7 @@ private auto toCapitalizer(alias indexFnUpper, uint maxIdxUpper, alias tableFnUp
|
|||
*
|
||||
* Does not allocate memory.
|
||||
* Characters in UTF-8 or UTF-16 format that cannot be decoded
|
||||
* are treated as $(XREF utf, replacementDchar).
|
||||
* are treated as $(REF replacementDchar, std,utf).
|
||||
*
|
||||
* Params:
|
||||
* str = string or range of characters
|
||||
|
|
@ -8958,7 +8958,7 @@ unittest
|
|||
to produce an algorithm that can convert a range of characters to upper case
|
||||
without allocating memory.
|
||||
A string can then be produced by using $(XREF_PACK algorithm,mutation,copy)
|
||||
to send it to an $(XREF array, appender).
|
||||
to send it to an $(REF appender, std,array).
|
||||
+/
|
||||
@safe pure nothrow @nogc
|
||||
dchar toUpper(dchar c)
|
||||
|
|
|
|||
|
|
@ -3103,7 +3103,7 @@ enum dchar replacementDchar = '\uFFFD';
|
|||
* Iterate a range of char, wchar, or dchars by code unit.
|
||||
*
|
||||
* The purpose is to bypass the special case decoding that
|
||||
* $(XREF array,front) does to character arrays.
|
||||
* $(REF front, std,array) does to character arrays.
|
||||
* Params:
|
||||
* r = input range of characters, or array of characters
|
||||
* Returns:
|
||||
|
|
|
|||
|
|
@ -161,7 +161,7 @@ public struct UUID
|
|||
* possible to read, compare and use all these Variants, but
|
||||
* UUIDs generated by this module will always be in rfc4122 format.
|
||||
*
|
||||
* Note: Do not confuse this with $(XREF _variant, _Variant).
|
||||
* Note: Do not confuse this with $(REF _Variant, std,_variant).
|
||||
*/
|
||||
enum Variant
|
||||
{
|
||||
|
|
@ -518,7 +518,7 @@ public struct UUID
|
|||
* RFC 4122 defines different internal data layouts for UUIDs.
|
||||
* Returns the format used by this UUID.
|
||||
*
|
||||
* Note: Do not confuse this with $(XREF _variant, _Variant).
|
||||
* Note: Do not confuse this with $(REF _Variant, std,_variant).
|
||||
* The type of this property is $(MYREF3 std.uuid.UUID.Variant, _Variant).
|
||||
*
|
||||
* See_Also:
|
||||
|
|
@ -1208,7 +1208,7 @@ unittest
|
|||
/**
|
||||
* Params:
|
||||
* randomGen = uniform RNG
|
||||
* See_Also: $(XREF random, isUniformRNG)
|
||||
* See_Also: $(REF isUniformRNG, std,random)
|
||||
*/
|
||||
UUID randomUUID(RNG)(ref RNG randomGen)
|
||||
if (isInputRange!RNG && isIntegral!(ElementType!RNG))
|
||||
|
|
|
|||
|
|
@ -155,7 +155,7 @@ final class ArchiveMember
|
|||
|
||||
/**
|
||||
* Set the OS specific file attributes, as obtained by
|
||||
* $(XREF file,getAttributes) or $(XREF file,DirEntry.attributes), for this archive member.
|
||||
* $(REF getAttributes, std,file) or $(REF DirEntry.attributes, std,file), for this archive member.
|
||||
*/
|
||||
@property void fileAttributes(uint attr)
|
||||
{
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue