std.format

class FormatException: object.Exception;

Сигнализирует о несоответствии между форматом и соответствующим аргументом.

uint formattedWrite(Writer, Char, A...)(Writer w, in Char[] fmt, A args);

Интерпретирует список variadic-аргументов args, форматирует их в соответствии с fmt и отправляет полученные символы в w. Кодировка вывода такая же, как и Char. Тип Writer должен удовлетворять проверке std.range.primitives.isOutputRange!(Writer, Char).

Variadic-аргументы обычно расходуются по порядку. Также поддерживается синтаксис позиционных параметров в стиле POSIX. Каждый аргумент форматируется в последовательность символов в соответствии со спецификацией формата, и символы передаются в w. Используется и форматируется столько аргументов, сколько указано в форматирующей строке. Если аргументов меньше, чем спецификаторов формата, то генерируется исключение FormatException. Если аргументов больше, чем требуется спецификацией формата, они игнорируются, но только если был отформатирован хотя бы один аргумент.

Форматирующая строка поддерживает форматирование массивов и вложенных в массив элементов через группирующие спецификаторы формата % (и %). Каждая пара % (и %) соответствует одному аргументу-массиву. Вложенная форматирующая под-строка применяется к отдельным элементам массива. Конечная часть форматирующей под-строки, следующая за спецификатором преобразования для элемента массива, интерпретируется как разделитель массива и поэтому опускается после последнего элемента массива. Спецификатор %| может использоваться для явного указания начала разделителя, так что идущая до него часть строки будет включена после последнего элемента массива. (Ниже приведены конкретные примеры).

Параметры:

Writer w	Вывод отправляется этому писателю (writer). Типичные писатели вывода включают строку std.array.Appender и std.stdio.LockingTextWriter.
Char[] fmt	Форматирующая строка.
A args	Список variadic-аргументов.

Возвращает:

Отформатированные аргументы.

Исключения:

Несоответствующие друг другу аргументы и форматы приведут к выбрасыванию исключения FormatException.

Форматирующая строка: Форматирующая строка состоит из символов вперемешку со спецификациями формата. Символы просто копируются на выход (например, putc) после любого необходимого преобразования в соответствующую UTF8-последовательность.

Форматирующая строка имеет следующую грамматику (переводы элементов грамматики, представляющих слова и словосочетания, приведены мной в виде комментария – прим.пер.):

FormatString:                                        // Форматирующая строка
    FormatStringItem*                                // Элемент форматирующей строки
FormatStringItem:                                    // Элемент форматирующей строки
    '%%'
    '%' Position Flags Width Precision FormatChar    // Позиция Флаги Ширина Точность ФорматирующийСимвол
    '%(' FormatString '%)'                           // Форматирующая строка
    OtherCharacterExceptPercent                      // Другой символ, за исключением "%"
Position:                                            // Позиция
    empty                                            // пусто
    Integer '$'                                      // Целое число
Flags:                                               // Флаги
    empty                                            // пусто
    '-' Flags
    '+' Flags
    '#' Flags
    '0' Flags
    ' ' Flags
Width:                                               // Ширина
    empty                                            // пусто
    Integer
    '*'                                              // Целое число
Precision:                                           // Точность
    empty                                            // пусто
    '.'
    '.' Integer                                      // Целое число
    '.*'
Integer:                                             // Целое число
    Digit                                            // Цифра
    Digit Integer                                    // Цифра ЦелоеЧисло
Digit:                                               // Цифра
    '0'|'1'|'2'|'3'|'4'|'5'|'6'|'7'|'8'|'9'
FormatChar:                                          // Форматирующий символ
    's'|'c'|'b'|'d'|'o'|'x'|'X'|'e'|'E'|'f'|'F'|'g'|'G'|'a'|'A'

Флаги влияют на форматирование в зависимости от спецификатора следующим образом.

Флаг	Связанные типы	Семантика
'-'	числовой	Левое выравнивание результата в поле. Перекрывает флаг 0.
'+'	числовой	У положительных чисел добавляется префикс в виде символа +. Прекрывает любой пробельный флаг.
'#'	целый ('o')	Добавляется точность при необходимости, чтобы первая цифра восьмеричного форматирования была "0", даже если аргумент и Precision (точность) равны нулю.
'#'	целый ('x', 'X')	При ненулевом аргументе к результату добавляется префикс 0x (0X).
'#'	с плавающей точкой	Всегда вставлять десятичную точку и печать хвостовые нули.
'0'	числовой	Использовать ведущие нули для заполнения вместо пробелов (кроме значений с плавающей точкой, nan и infinity). Игнорируется, если присутсвует Precision (точность).
' '	числовой	Префиксом положительных чисел в знаковом преобразовании будет пробел.

Width (ширина)

Определяет минимальную ширину поля. Если ширина равна *, то в качестве ширины принимается дополнительный аргумент типа int, предшествующий фактическому аргументу. Если ширина отрицательная, считается, что таким образом задан Флаг с символом -.

Precision (точность)

Дает точность для числовых преобразований. Если точность равна *, то в качестве точности принимается дополнительный аргумент типа int, предшествующий фактическому аргументу. Если он отрицательный, это как если бы не было спецификатора Precision.

FormatChar (форматирующий символ)

's'

Соответствующий аргумент форматируется в зависимости от его типа:

bool

Результат равен "true" или "false".

целые типы

Используется формат %d.

типы с плавающей точкой

Используется формат %g.

строковые типы

Результатом является строка, преобразованная в UTF-8. Precision задает максимальное число символов, используемых в результате.

структуры

Если у структуры определён метод toString(), результатом является строка, возвращаемая из этой функции. В противном случае результатом будет StructName(field₀, field₁, ...), где field_n является n-м элементом, отформатированным по умолчанию.

классы, унаследованные от Object

Результатом является строка, возвращаемая методом .toString() экземпляра класса. Precision задаёт максимальное количество символов для использования в результате.

объединения

Если объединение определяет метод toString(), результатом является строка, возвращаемая из этой функции. В противном случае результатом будет имя объединения, без его содержимого.

не-строковые статические и динамические массивы

Результатом является [s₀, s₁, ...], где s_n – это n-й элемент, отформатированный по умолчанию.

ассоциативные массивы

Результат эквивалентен тому, как будет выглядеть инициализатор для содержимого ассоциативного массива, например: ["red" : 10, "blue" : 20].

'c'

Соответствующий аргумент должен быть символьным типом.

'b','d','o','x','X'

Соответствующий аргумент должен быть целым типом, и он форматируется как целое. Если аргумент является знаковым типом, а FormatChar – это d, он преобразуется в строку символов со знаком, иначе он обрабатывается как беззнаковый. Аргумент типа bool форматируется как '1' или '0'. Используется двоичная база для b, восьмеричная для o, десятичная для d и шестнадцатеричная для x или X. Форматы x используют строчные буквы, X используют буквы в верхнем регистре. Если количество результирующих цифр меньше, чем точность, то при необходимости используются ведущие нули. Если Precision равно 0, и число равно 0, цифры не выводятся в результат.

'e','E'

Число с плавающей точкой форматируется как одна цифра перед десятичной точкой, Precision (точность) цифр после, FormatChar, ±, за которыми следует как минимум двухзначное значение порядка: d.dddddde±dd. Если Precision отсутствует, после десятичной точки генерируются шесть цифр. Если Precision равно 0, десятичная точка не формируется.

'f','F'

Число с плавающей точкой форматируется в десятичной нотации. Precision (точность) указывает количество цифр, генерируемых после десятичной точки. По умолчанию оно равно шести. Перед десятичной точкой генерируется как минимум одна цифра. Если Precision равно нулю, десятичная точка не формируется.

'g','G'

Число с плавающей точкой форматируется в формате e или f в случае g; E или F для G. Формат f используется, если порядок для формата e больше -5 и меньше Precision (точность). Precision указывает количество значащих цифр, по умолчанию шесть. Хвостовые нули после десятичной точки удаляются, а если дробная часть равна нулю, тогда десятичная точка не формируется.

'a','A'

Число с плавающей точкой форматируется в шестнадцатеричной экспоненциальной нотации 0xh.hhhhhhp±d. Присутствует одна шестнадцатеричная цифра перед точкой, и столько цифр после неё, сколько указано в параметре Precision (точность). Если Precision равно нулю, десятичная точка не формируется. Если Precision отсутствует, генерируется столько шестнадцатеричных цифр, сколько необходимо для точного представления мантиссы. В порядок записывается как можно меньше цифр, но по крайней мере одна, он является десятичным числом и представляет степень 2, как в h.hhhhhh*2^±d. Порядок для нуля равен нулю. Шестнадцатеричные цифры, символы x и p находятся в верхнем регистре, если FormatChar представлен верхним регистром.

Значение NaN (не-число) для чисел с плавающей точкой форматируется как nan, если FormatChar представлен в нижнем регистре, или NAN, если в верхнем. Значение бесконечности для чисел с плавающей точкой отформатируется как inf или infinity, если FormatChar представлен в нижнем регистре, или INF или INFINITY, если в верхнем.

Пример:

import std.array : appender;
import std.format : formattedWrite;

auto writer = appender!string();
formattedWrite(writer, "%s - это окончательный %s.", 42, "ответ");
assert(writer.data == "42 - это окончательный ответ.");
// Очистить writer
writer = appender!string();
formattedWrite(writer, "Дата: %2$s %1$s", "октября", 5);
assert(writer.data == "Дата: 5 октября");

Позиционные и непозиционные стили можно смешивать в одной форматирующей строке. (POSIX оставляет это поведение неопределенным.) Внутренний счетчик для непозиционных параметров отсчитывает следующий параметр после самого большого позиционного параметра, который уже использован.

Пример использования массива и форматирования вложенных массивов:

import std.stdio;

void main()
{
    writefln("Мои элементы - это %(%s %).", [1,2,3]);
    writefln("Мои элементы - это %(%s, %).", [1,2,3]);
}

Результат:

Мои элементы - это 1 2 3.
Мои элементы - это 1, 2, 3.

Хвостовая часть форматирующей под-строки, следующая за спецификатором для каждого элемента, интерпретируется как разделитель массива и поэтому опускается после последнего элемента массива. Можно использовать спецификатор разделителя %| для указания места, где начинается разделитель, таким образом часть форматирующей строки до него будет сохранена в последнем элементе массива:

import std.stdio;

void main()
{
    writefln("Мои элементы - это %(-%s-%|, %).", [1,2,3]);
}

что даст на выходе:

Мои элементы - это -1-, -2-, -3-.

Эти составные спецификаторы формата можно вставлять в случае аргумента – вложенного массива:

import std.stdio;
void main() {
     auto mat = [[1, 2, 3],
                 [4, 5, 6],
                 [7, 8, 9]];

     writefln("%(%(%d %)\n%)", mat);
     writeln();

     writefln("[%(%(%d %)\n %)]", mat);
     writeln();

     writefln("[%([%(%d %)]%|\n %)]", mat);
     writeln();
}

Выводит:

1 2 3
4 5 6
7 8 9

[1 2 3
 4 5 6
 7 8 9]

[[1 2 3]
 [4 5 6]
 [7 8 9]]

Внутри составного спецификатора формата все строки и символы автоматически экранируются. Чтобы избежать такого поведения, добавьте флаг '-' к "%(".

import std.stdio;

void main()
{
    writefln("Мои друзья - это %s.", ["Джон", "Нэнси"]);
    writefln("Мои друзья - это %(%s, %).", ["Джон", "Нэнси"]);
    writefln("Мои друзья - это %-(%s, %).", ["Джон", "Нэнси"]);
}

что даст на выходе:

Мои друзья - это ["Джон", "Нэнси"].
Мои друзья - это "Джон", "Нэнси".
Мои друзья - это Джон, Нэнси.

uint formattedRead(R, Char, S...)(ref R r, const(Char)[] fmt, S args);

Читает символы из Входного диапазона r, преобразует их в соответствии с fmt и записывает в args.

Параметры:

R r	Диапазон, из которого читать.
const(Char)[] fmt	Формат данных для чтения.
S args	Сток прочитанных данных.

Возвращает:

При успешном выполнении функция возвращает количество заполненных переменных. Этот счетчик может соответствовать ожидаемому количеству или быть меньше, даже быть равным нулю, если произойдет сбой сопоставления.

Примеры:

string s = "hello!124:34.5";
string a;
int b;
double c;
formattedRead(s, "%s!%s:%s", &a, &b, &c);
assert(a == "hello" && b == 124 && c == 34.5);

Переместиться к: DYNAMIC · flDash · flHash · flPlus · flSpace · flZero · indexEnd · indexStart · nested · precision · sep · spec · this · trailing · UNSPECIFIED · width

struct FormatSpec(Char) if (is(Unqual!Char == Char));

Стандартный обработчик для спецификаторов формата в стиле printf. Используется для построения более специфических функций форматирования.

Примеры:

import std.array;
auto a = appender!(string)();
auto fmt = "Number: %2.4e\nString: %s";
auto f = FormatSpec!char(fmt);

f.writeUpToNextSpec(a);

assert(a.data == "Number: ");
assert(f.trailing == "\nString: %s");
assert(f.spec == 'e');
assert(f.width == 2);
assert(f.precision == 4);

f.writeUpToNextSpec(a);

assert(a.data == "Number: \nString: ");
assert(f.trailing == "");
assert(f.spec == 's');

int width;

Минимальная ширина, по умолчанию 0.

int precision;

Точность. Семантика зависит от типа аргумента. Для чисел с плавающей точкой precision определяет количество напечатанных десятичных знаков.

enum int DYNAMIC;

Особое значение для width (ширины) и precision (точности). DYNAMIC width или precision означает, что они были указаны с помощью символа '*' в форматирующей строке и передаются во время выполнения через аргументы.

enum int UNSPECIFIED;

Специальное значение для precision (точности), означающее, что спецификатор формата не содержит точности в явном виде.

char spec;

Фактический спецификатор формата (или, форматирующий символ – прим.пер.), по умолчанию 's'.

ubyte indexStart;

Индекс аргумента для позиционных параметров, от 1 до ubyte.max. (0 означает, что не используется).

ubyte indexEnd;

Индекс последнего аргумента для диапазона позиционных параметров, от 1 до ubyte.max. (0 означает, что не используется).

bool flDash;

Спецификатор формата содержит символ '-' (совместимость с printf).

bool flZero;

Спецификатор формата содержит символ '0' (совместимость с printf).

bool flSpace;

Спецификатор формата содержит символ ' ' (совместимость с printf).

bool flPlus;

Спецификатор формата содержит символ '+' (совместимость с printf).

bool flHash;

Спецификатор формата содержит символ '#' (совместимость с printf).

const(Char)[] nested;

В случае составного спецификатора формата, начинающегося с "%(" и заканчивающегося на "%)", nested содержит строку, содержащуюся между двумя разделителями.

const(Char)[] sep;

В случае составного спецификатора формата sep содержит строку, раположенную после "%|". sep is null означает отсутствие разделителя, в противном случае sep.empty означает разделитель длины 0. sep is null means no separator else sep.empty means 0 length separator.

const(Char)[] trailing;

trailing содержит остаток форматирующей строки.

pure @safe this(in Char[] fmt);

Строит новую структуру FormatSpec, используя форматирующую строку fmt, никакая обработка не выполняется до тех пор, пока это не понадобится.

Почему-то осталась не документированной функция writeUpToNextSpec – прим. пер.

FormatSpec!Char singleSpec(Char)(Char[] fmt);

Вспомогательная функция, которая возвращает FormatSpec для единичного спецификатора, указанного в fmt

Параметры:

Char[] fmt

Спецификатор формата

Возвращает:

Структуру FormatSpec с распознанным спецификатором.

Предписано предоставлять только один спецификатор в функцию. Enforces giving only one specifier to the function.

Примеры:

auto spec = singleSpec("%2.3e");

assert(spec.trailing == "");
assert(spec.spec == 'e');
assert(spec.width == 2);
assert(spec.precision == 3);

assertThrown(singleSpec(""));
assertThrown(singleSpec("2.3e"));
assertThrown(singleSpec("%2.3eTest"));

Переместиться к: 10 · 11 · 12 · 13 · 2 · 3 · 4 · 5 · 6 · 7 · 8 · 9

void formatValue(Writer, T, Char)(Writer w, T obj, ref FormatSpec!Char f)
if (is(BooleanTypeOf!T) && !is(T == enum) && !hasToString!(T, Char));

Типы bool, форматируемые как "true" или "false" со спецификатором %s, и как "1" или "0" со спецификаторами формата, специфичными для целых чисел.

Параметры:

Writer w	Выходной диапазон, в который пишется результат.
T obj	Значение для записи.
FormatSpec!Char f	Структура FormatSpec, определяющая как записывать значение.

Примеры:

import std.array : appender;
auto w = appender!string();
auto spec = singleSpec("%s");
formatValue(w, true, spec);

assert(w.data == "true");

void formatValue(Writer, T, Char)(Writer w, T obj, ref FormatSpec!Char f)
if (is(Unqual!T == typeof(null)) && !is(T == enum) && !hasToString!(T, Char));

Литерал null, форматируемый как "null".

Параметры:

Writer w	Выходной диапазон, в который пишется результат.
T obj	Значение для записи.
FormatSpec!Char f	Структура FormatSpec, определяющая как записывать значение.

Примеры:

import std.array : appender;
auto w = appender!string();
auto spec = singleSpec("%s");
formatValue(w, null, spec);

assert(w.data == "null");

void formatValue(Writer, T, Char)(Writer w, T obj, ref FormatSpec!Char f)
if (is(IntegralTypeOf!T) && !is(T == enum) && !hasToString!(T, Char));

Целые типы, форматируемые как в printf.

Параметры:

Writer w	Выходной диапазон, в который пишется результат.
T obj	Значение для записи.
FormatSpec!Char f	Структура FormatSpec, определяющая как записывать значение.

Примеры:

import std.array : appender;
auto w = appender!string();
auto spec = singleSpec("%d");
formatValue(w, 1337, spec);

assert(w.data == "1337");

void formatValue(Writer, T, Char)(Writer w, T obj, ref FormatSpec!Char f)
if (is(FloatingPointTypeOf!T) && !is(T == enum) && !hasToString!(T, Char));

Типы с плавающей точкой, форматируемые как в printf.

Параметры:

Writer w	Выходной диапазон, в который пишется результат.
T obj	Значение для записи.
FormatSpec!Char f	Структура FormatSpec, определяющая как записывать значение.

Примеры:

import std.array : appender;
auto w = appender!string();
auto spec = singleSpec("%.1f");
formatValue(w, 1337.7, spec);

assert(w.data == "1337.7");

void formatValue(Writer, T, Char)(Writer w, T obj, ref FormatSpec!Char f)
if (is(CharTypeOf!T) && !is(T == enum) && !hasToString!(T, Char));

Отдельные символы (char, wchar, или dchar), форматируемые как символы Unicode с %с, и как целые числа со спецификаторами формата, специфическими для целых чисел.

Параметры:

Writer w	Выходной диапазон, в который пишется результат.
T obj	Значение для записи.
FormatSpec!Char f	Структура FormatSpec, определяющая как записывать значение.

Примеры:

import std.array : appender;
auto w = appender!string();
auto spec = singleSpec("%c");
formatValue(w, 'a', spec);

assert(w.data == "a");

void formatValue(Writer, T, Char)(Writer w, T obj, ref FormatSpec!Char f)
if (is(StringTypeOf!T) && !is(StaticArrayTypeOf!T) && !is(T == enum) && !hasToString!(T, Char));

Строки, форматируемые как в printf.

Параметры:

Writer w	Выходной диапазон, в который пишется результат.
T obj	Значение для записи.
FormatSpec!Char f	Структура FormatSpec, определяющая как записывать значение.

Примеры:

import std.array : appender;
auto w = appender!string();
auto spec = singleSpec("%s");
formatValue(w, "hello", spec);

assert(w.data == "hello");

void formatValue(Writer, T, Char)(Writer w, auto ref T obj, ref FormatSpec!Char f)
if (is(StaticArrayTypeOf!T) && !is(T == enum) && !hasToString!(T, Char));

Статические массивы, форматируемые как динамические массивы.

Параметры:

Writer w	Выходной диапазон, в который пишется результат.
T obj	Значение для записи.
FormatSpec!Char f	Структура FormatSpec, определяющая как записывать значение.

Примеры:

import std.array : appender;
auto w = appender!string();
auto spec = singleSpec("%s");
char[2] two = ['a', 'b'];
formatValue(w, two, spec);

assert(w.data == "ab");

void formatValue(Writer, T, Char)(Writer w, T obj, ref FormatSpec!Char f)
if (is(DynamicArrayTypeOf!T) && !is(StringTypeOf!T) && !is(T == enum) && !hasToString!(T, Char));

Динамические массивы, форматируемые как Входные диапазоны.

Специализации:

• void[] форматируется также, как ubyte[].
• Константный массив преобразуется в диапазон ввода путём удаления его квалификатора.

Параметры:

Writer w	Выходной диапазон, в который пишется результат.
T obj	Значение для записи.
FormatSpec!Char f	Структура FormatSpec, определяющая как записывать значение.

Примеры:

import std.array : appender;
auto w = appender!string();
auto spec = singleSpec("%s");
auto two = [1, 2];
formatValue(w, two, spec);

assert(w.data == "[1, 2]");

void formatValue(Writer, T, Char)(Writer w, T obj, ref FormatSpec!Char f)
if (is(AssocArrayTypeOf!T) && !is(T == enum) && !hasToString!(T, Char));

Ассоциативные массивы, форматируемые с использованием ':' и ", " в качестве разделителей, и заключённые между символами '[' и ']'.

Параметры:

Writer w	Выходной диапазон, в который пишется результат.
T obj	Значение для записи.
FormatSpec!Char f	Структура FormatSpec, определяющая как записывать значение.

Примеры:

import std.array : appender;
auto w = appender!string();
auto spec = singleSpec("%s");
auto aa = ["H":"W"];
formatElement(w, aa, spec);

assert(w.data == "[\"H\":\"W\"]", w.data);

void formatValue(Writer, T, Char)(Writer w, T val, ref FormatSpec!Char f)
if (is(T == class) && !is(T == enum));

void formatValue(Writer, T, Char)(Writer w, T val, ref FormatSpec!Char f)
if (is(T == interface) && (hasToString!(T, Char) || !is(BuiltinTypeOf!T)) && !is(T == enum));

void formatValue(Writer, T, Char)(Writer w, auto ref T val, ref FormatSpec!Char f)
if ((is(T == struct) || is(T == union)) && (hasToString!(T, Char) || !is(BuiltinTypeOf!T)) && !is(T == enum));

Агрегаты (struct, union, class, и interface), обычно форматируемые посредством вызова toString. Метод toString должен иметь одну из следующих сигнатур:

const void toString(scope void delegate(const(char)[]) sink, FormatSpec fmt);
const void toString(scope void delegate(const(char)[]) sink, string fmt);
const void toString(scope void delegate(const(char)[]) sink);
const string toString();

Для объектов классов, имеющих интерфейс Входного диапазона,

• Если экземпляр имеет метод toString, переопределяющий метод Object.toString, используется он.
• В противном случае объекты форматируются как Входной диапазон.

Для структур и объектов объединений, которые не имеют метода toString,

• Если они имеют интерфейс диапазона, форматируются как Входной диапазон.
• В противном случае, они форматируются как Type(field1, filed2, ...).

В противном случае форматируются так же, как имя их типа.

Примеры:

formatValue позволяет повторно использовать существующие спецификаторы формата:

import std.format;

struct Point
{
    int x, y;

    void toString(scope void delegate(const(char)[]) sink,
                  FormatSpec!char fmt) const
    {
        sink("(");
        sink.formatValue(x, fmt);
        sink(",");
        sink.formatValue(y, fmt);
        sink(")");
    }
}

auto p = Point(16,11);
assert(format("%03d", p) == "(016,011)");
assert(format("%02x", p) == "(10,0b)");

Примеры:

Следующий код сравнивает использование formatValue и formattedWrite.

import std.format;
import std.array : appender;

auto writer1 = appender!string();
writer1.formattedWrite("%08b", 42);

auto writer2 = appender!string();
auto f = singleSpec("%08b");
writer2.formatValue(42, f);

assert(writer1.data == writer2.data && writer1.data == "00101010");

void formatValue(Writer, T, Char)(Writer w, T val, ref FormatSpec!Char f)
if (is(T == enum));

enum, форматируемый как его базовое значение.

Параметры:

Writer w	Выходной диапазон, в который пишется результат.
T obj	Значение для записи.
FormatSpec!Char f	Структура FormatSpec, определяющая как записывать значение.

Примеры:

import std.array : appender;
auto w = appender!string();
auto spec = singleSpec("%s");

enum A { first, second, third }

formatElement(w, A.second, spec);

assert(w.data == "second");

void formatValue(Writer, T, Char)(Writer w, T val, ref FormatSpec!Char f)
if (isPointer!T && !is(T == enum) && !hasToString!(T, Char));

Указатели, форматируемые как шестнадцатеричные целые числа.

void formatValue(Writer, T, Char)(Writer w, scope T, ref FormatSpec!Char f)
if (isDelegate!T);

Делегаты, форматируемые как 'ReturnType delegate(Parameters) FunctionAttributes'

Примеры:

import std.conv : to;

int i;

int foo(short k) @nogc
{
    return i + k;
}

@system int delegate(short) @nogc bar() nothrow pure
{
    int* p = new int;
    return &foo;
}

assert(to!string(&bar) == "int delegate(short) @nogc delegate() pure nothrow @system");

Переместиться к: 2 · 3 · 4 · 5 · 6 · 7 · 8

T unformatValue(T, Range, Char)(ref Range input, ref FormatSpec!Char spec)
if (isInputRange!Range && is(Unqual!T == bool));

Читает логическое значение (bool) и возвращает его.

T unformatValue(T, Range, Char)(ref Range input, ref FormatSpec!Char spec)
if (isInputRange!Range && is(T == typeof(null)));

Читает литерал null и возвращает его.

T unformatValue(T, Range, Char)(ref Range input, ref FormatSpec!Char spec)
if (isInputRange!Range && isIntegral!T && !is(T == enum));

Читает целочисленное значение и возвращает его.

T unformatValue(T, Range, Char)(ref Range input, ref FormatSpec!Char spec)
if (isFloatingPoint!T && !is(T == enum));

Читает значение числа с плавающей точкой и возвращает его.

T unformatValue(T, Range, Char)(ref Range input, ref FormatSpec!Char spec)
if (isInputRange!Range && isSomeChar!T && !is(T == enum));

Читает один символ и возвращает его.

T unformatValue(T, Range, Char)(ref Range input, ref FormatSpec!Char spec)
if (isInputRange!Range && is(StringTypeOf!T) && !isAggregateType!T && !is(T == enum));

Читает строку и возвращает её.

T unformatValue(T, Range, Char)(ref Range input, ref FormatSpec!Char spec)
if (isInputRange!Range && isArray!T && !is(StringTypeOf!T) && !isAggregateType!T && !is(T == enum));

Читает массив (за исключением строковых типов) и возвращает его.

T unformatValue(T, Range, Char)(ref Range input, ref FormatSpec!Char spec)
if (isInputRange!Range && isAssociativeArray!T && !is(T == enum));

Читает ассоциативный массив и возвращает его.

immutable(Char)[] format(Char, Args...)(in Char[] fmt, Args args)
if (isSomeChar!Char);

Форматирует аргументы в строку.

Параметры:

Char[] fmt	Форматирующая строка. Подробную информацию смотрите в разделе std.format.formattedWrite.
Args args	Список variadic-аргументов для форматирования в возвращаемую строку.

char[] sformat(Char, Args...)(char[] buf, in Char[] fmt, Args args);

Форматирует аргументы в буфер buf, который должен быть достаточно большим, чтобы содержать результат. Выбрасывает исключение RangeError, если это не так.

Возвращает:

Срез буфера buf, содержащий отформатированную строку.