std.stdio

alias KeepTerminator = std.typecons.Flag!"keepTerminator".Flag;

フラグ KeepTerminatorが KeepTerminator.yesにセットされている場合、区切り文字 が返される文字列に含まれる。

struct File;

FILE* をカプセル化する。 一般にDは、C標準ライブラリの同等の関数の薄いラッパーを提供しようとはしない。 しかし、 の値を直接操作することは、Cの標準ライブラリでは安全ではなく、エラーが発生しやすい。 FILE* の値を直接操作することは、多くの点で安全ではなく、エラーが発生しやすい。 多くの点で安全ではない。しかし File型は、安全な操作、自動ファイルクローズ、多くの利便性を保証する。 ファイルの自動クローズ、そして多くの利便性を保証する。

基礎となるFILE* ハンドルは、参照カウント方式で維持される。 ハンドルは参照カウント方式で維持される。 Fileにバインドされた最後の変数が 与えられたFILE* にバインドされた最後の変数がスコープ外に出るとすぐに、FILE* が自動的にクローズされる。 は自動的に閉じられる。

例:

// test.d
import std.stdio;

void main(string[] args)
{
    auto f = File("test.txt", "w"); // 書き込み可能
    f.write("Hello");
    if (args.length > 1)
    {
        auto g = f; // 今度はgとfが同じファイルに書き込む
                    // 内部参照カウントは2である
        g.write(", ", args[1]);
        // gがスコープを抜けると、参照カウントは1に減少する
    }
    f.writeln("!");
    // fがスコープを抜けると、参照カウントはゼロになり、
    // `FILE*`は閉じられる。
}

% rdmd test.d Jimmy
% cat test.txt
Hello, Jimmy!
% _

@safe this(string name, scope const(char)[] stdioOpenmode = "rb");

this(R1, R2)(R1 name)
if (isSomeFiniteCharInputRange!R1);

this(R1, R2)(R1 name, R2 mode)
if (isSomeFiniteCharInputRange!R1 && isSomeFiniteCharInputRange!R2);

オープンするファイル名とオープン・モードを取るコンストラクタ。

あるFile オブジェクトを別のオブジェクトにコピーすると、2つのオブジェクトは同じファイルを参照することになる。File オブジェクトは同じファイルを参照することになる。

オブジェクトがファイルを参照しなくなると、デストラクタは自動的にファイルを閉じる。File オブジェクトがファイルを参照しなくなった時点で、デストラクタは自動的にファイルを閉じる。

Parameters:

string name	ファイル名を表す範囲または文字列
const(char)[] stdioOpenmode	オープン・モードを表す範囲または文字列 (C標準ライブラリの fopen関数と同じ意味を持つ)

Throws:

ErrnoException ファイルをオープンできなかった場合

ref @safe File opAssign(File rhs) return;

ファイルを別のファイルに代入する。代入対象は、それがアタッチされていたファイルから切り離され、新しいファイルにアタッチされる。 を切り離し、新しいファイルにアタッチする。 ファイルにアタッチする。

@trusted void open(string name, scope const(char)[] stdioOpenmode = "rb");

現在のファイルから切り離し(失敗すると "スロー"される)、次のことを試みる。 ファイルを開く nameを開こうとする。 stdioOpenmode.モードは モードは、C標準ライブラリのfopen関数と同じセマンティクスを持つ。

Throws:

ErrnoException エラーの場合

@trusted void reopen(string name, scope const(char)[] stdioOpenmode = "rb");

File オブジェクトを再利用し、別のファイルを開くか、ファイル・モードを変更する。 ファイル・モードを変更する。もし nameがnull の場合、現在開いている そうでない場合は、新しいファイルが開かれ、C FILE*.この関数は、C標準ライブラリのfreopen関数と同じセマンティクスを持つ。 ライブラリfreopen関数と同じセマンティクスを持つ。

注釈: この関数は、C標準ライブラリのfreopen関数と同じセマンティクスを持つ。 この関数を reopennull は実装されていない。 nameでの呼び出しは での呼び出しは、すべてのCランタイムで実装されているわけではない。

Throws:

ErrnoException エラーの場合

@safe void popen(string command, scope const(char)[] stdioOpenmode = "r");

現在のファイルから切り離し(失敗するとスローされる)、C標準ライブラリ関数popenを呼び出してコマンドを実行する。 C標準ライブラリ関数popenを呼び出す。

Throws:

ErrnoException エラーの場合

@safe void fdopen(int fd, scope const(char)[] stdioOpenmode = "rb");

まずdetach を呼び出し(失敗するとスロー)、次に与えられたファイル記述子を に関連付けようとする。 与えられたファイル記述子をFile に関連付け、ファイル名をnull に設定する。

モードは、ファイル記述子のモードと互換性がなければならない。

Throws:

ErrnoException エラーの場合は

Parameters:

int fd	このFile に関連付けるファイル記述子。
const(char)[] stdioOpenmode	このファイルと関連付けるモード。モードはC標準ライブラリのfdopen関数と同じセマンティクスを持つ。 C標準ライブラリfdopen関数と同じセマンティクスを持つ、 と互換性がなければならない。 fd.

void windowsHandleOpen(HANDLE handle, scope const(char)[] stdioOpenmode);

まずdetach を呼び出し(失敗するとスロー)、次に与えられた Windows と の関連付けを試みる。 与えられたWindowsHANDLE をFile に関連付けようとする。 モードはハンドルのアクセス属性と互換性がなければならない。Windowsのみ。

Throws:

ErrnoException エラーの場合

const pure nothrow @property @safe bool isOpen();

ファイルがオープンされていればtrue を返す。

const pure @property @trusted bool eof();

ファイルが終了している場合はtrue を返す(feof を参照)。

Throws:

Exception ファイルがオープンされていない場合は、 を返す。

const pure nothrow @property @safe string name() return;

File を初期化するために最後に使用された名前があれば、それを返す。

File を作成または初期化するいくつかの関数は、name フィールドをnull に設定する。 例: tmpfile, wrapFileや fdopen.などがある。 詳細はこれらの関数のドキュメントを参照のこと。

Returns:

このファイルを初期化するために最後に使われた名前か、そうでなければnull を返す。

const pure nothrow @property @trusted bool error();

ファイルがクローズされているか、まだオープンされていない場合は、true を返す。それ以外の場合は を返す。

@trusted void detach();

基礎となるファイルからデタッチする。唯一の所有者の場合、close を呼び出す。

Throws:

ErrnoException を呼び出す。

@trusted void close();

ファイルがクローズされているか、まだオープンされていない場合は、空で成功する。そうでなければ fcloseを呼び出して)ファイルを閉じる、 エラーをスローする。例外がスローされても、その後File オブジェクトは空になる。これはdetach と異なり、常にファイルを閉じる。 その結果、同じハンドルを参照する他のすべてのFile その結果、同じハンドルを参照する他のすべての オブジェクトは、以後、クローズされたファイルを見ることになる。

Throws:

ErrnoException エラー時

pure nothrow @safe void clearerr();

ファイルがクローズされているか、まだオープンされていない場合は、空で成功する。そうでない場合は を返す。

@trusted void flush();

CFILE バッファをフラッシュする。

ファイル・ハンドルに対してfflushを呼び出す。

Throws:

Exception ファイルがオープンされていないか、 への呼び出しが失敗した場合。fflush

@trusted void sync();

OSによってバッファリングされたデータを強制的にディスクに書き込む。 この関数を呼び出す前に flushこの関数を呼び出す前に、CFILE バッファをフラッシュする。

この関数は以下を呼び出す。 FlushFileBuffersを呼び出す、 F_FULLFSYNC fcntlを呼び出す。 fsyncPOSIX上のファイルハンドルである。

Throws:

Exception ファイルがオープンされていないか、OSコールが失敗した場合

T[] rawRead(T)(T[] buffer);

に対してfreadを呼び出す。 を呼び出す。読み込む項目の数と各項目のサイズは、それぞれ入力配列のサイズと型から推測される。 各項目のサイズは、それぞれ入力配列のサイズと型から推測される。

Returns:

実際に読み込まれたデータを含む bufferのスライスである。 よりも短くなる。 bufferよりも短くなる。 よりも短くなる。バッファが空の場合は、それが返される。

Throws:

ErrnoException ファイルがオープンされていないか、 への呼び出しが失敗した場合。 fread

rawReadWindowsでは常にバイナリモードで読み込む。

Examples:

static import std.file;

auto testFile = std.file.deleteme();
std.file.write(testFile, "\r\n\n\r\n");
scope(exit) std.file.remove(testFile);

auto f = File(testFile, "r");
auto buf = f.rawRead(new char[5]);
f.close();
writeln(buf); // "\r\n\n\r\n"

void rawWrite(T)(in T[] buffer);

ファイル ハンドルを呼び出す。書き込む項目の数と各項目のサイズは、それぞれ入力配列のサイズと型から推測される。 は、それぞれ入力配列のサイズと型から推測される。バッファに エラーがスローされる。

rawWriteWindowsでは常にバイナリモードで書き込まれる。

Throws:

ErrnoException ファイルがオープンされていないか、 への呼び出しが失敗した場合。fwrite

Examples:

static import std.file;

auto testFile = std.file.deleteme();
auto f = File(testFile, "w");
scope(exit) std.file.remove(testFile);

f.rawWrite("\r\n\n\r\n");
f.close();
writeln(std.file.read(testFile)); // "\r\n\n\r\n"

@trusted void seek(long offset, int origin = SEEK_SET);

fseekを呼び出す を呼び出す。

Parameters:

long offset	バイナリファイル:原点からオフセットするバイト数。 テキストファイル:ゼロまたは tell.
int origin	バイナリファイル:オフセットの基準となる位置。 SEEK_SETのいずれかでなければならない、 SEEK_CURまたは SEEK_ENDのいずれかでなければならない。 テキストファイル:必ず SEEK_SETでなければならない。

Throws:

Exception ファイルがオープンされていない場合。 への呼び出しが失敗した場合。ErrnoException fseek

const @property @trusted ulong tell();

ftellを呼び出す。 を呼び出し、ファイルハンドルの位置インジケータの現在値を返す。 ファイルハンドルの位置インジケータの現在値を返す。

Throws:

Exception ファイルがオープンされていない場合。 の呼び出しが失敗した場合。ErrnoException ftell

Examples:

import std.conv : text;
static import std.file;

auto testFile = std.file.deleteme();
std.file.write(testFile, "abcdefghijklmnopqrstuvwqxyz");
scope(exit) { std.file.remove(testFile); }

auto f = File(testFile);
auto a = new ubyte[4];
f.rawRead(a);
writeln(f.tell); // 4

@safe void rewind();

ファイルハンドルの巻き戻しを呼び出す。

Throws:

Exception ファイルがオープンされていない場合

@trusted void setvbuf(size_t size, int mode = _IOFBF);

ファイルハンドルに対してsetvbufを呼び出す。

Throws:

Exception ファイルがオープンされていない場合 への呼び出しが失敗した場合ErrnoException setvbufの呼び出しが失敗した場合。

@trusted void setvbuf(void[] buf, int mode = _IOFBF);

ファイルハンドルに対してsetvbufを呼び出す。

Throws:

Exception ファイルがオープンされていない場合。 への呼び出しが失敗した場合ErrnoException setvbufの呼び出しが失敗した場合。

void lock(LockType lockType = LockType.readWrite, ulong start = 0, ulong length = 0);

指定されたファイルセグメントをロックする。そのファイルセグメントがすでに他のプロセスによってロックされている場合は されている場合は、そのロックが解除されるまで待つ。 もし startと lengthの両方が 0 の場合、ファイル全体がロックされる。

を使用して作成されたロックは、以下の特性を持つ。 lockとtryLock を使って作成されたロックは、以下のプロパティを持つ:

• すべてのロックは、プロセスの終了時に自動的に解放される。
• ロックは子プロセスに継承されない。
• ファイルを閉じると、そのファイルに関連するすべてのロックが解放される。POSIXの場合、 では、別のFile で取得したロックも解放される。
• すべてのNFS実装がファイル・ロックを正しく実装しているわけではない。

bool tryLock(LockType lockType = LockType.readWrite, ulong start = 0, ulong length = 0);

指定されたファイル・セグメントをロックしようとする。 もし startと lengthがゼロの場合、ファイル全体がロックされる。

Returns:

true false ロックが成功した場合は、ファイル全体がロックされる。 指定されたファイルセグメントがすでにロックされていた場合は

void unlock(ulong start = 0, ulong length = 0);

指定されたファイルセグメントのロックを解除する。

void write(S...)(S args);

引数をテキスト形式でファイルに書き込む。

Throws:

Exception ファイルがオープンされていない場合 ファイルへの書き込みエラーが発生した場合ErrnoException

void writeln(S...)(S args);

引数をテキスト形式でファイルに書き込み、その後に改行する。

Throws:

Exception ファイルがオープンされていない場合 ファイルへの書き込みエラー時ErrnoException

void writef(alias fmt, A...)(A args)
if (isSomeString!(typeof(fmt)));

void writef(Char, A...)(in Char[] fmt, A args);

に従って、引数をテキスト形式でファイルに書き込む。 書式文字列fmtに従って、引数をテキスト形式でファイルに書き込む。

Parameters:

Char[] fmt	フォーマット文字列。 コンパイル時の引数として渡された場合、この文字列は静的にチェックされる。 される。
A args	書き込む項目。

Throws:

Exception ファイルがオープンされていない場合。 ファイルへの書き込みエラーが発生した場合。ErrnoException

void writefln(alias fmt, A...)(A args)
if (isSomeString!(typeof(fmt)));

void writefln(Char, A...)(in Char[] fmt, A args);

に相当するものだ。 file.writef(fmt, args, '\n').

@safe S readln(S = string)(dchar terminator = '\n')
if (isSomeString!S);

ファイルハンドルから行を読み込み、指定した型として返す。

このバージョンは独自の読み込みバッファを管理する。もし 読み込んだデータへの参照を保持しないのであれば File.readln(buf)バージョンを検討すること。 このバージョンの方が、読み込みバッファを再利用できるため、パフォーマンスが向上する可能性がある。

Parameters:

S	テンプレートパラメータ; 割り当てられたバッファの型と、返される型。デフォルトはstring である。
dchar terminator	行終端(デフォルトは'\n' )。

注釈: 文字列の終端はサポートされていない。 以下の readln(buf) との曖昧さのため、文字列の終端はサポートされていない。

Returns:

行終端文字を含む、読み込まれた行。

Throws:

StdioException I/Oエラーの場合は 、Unicode変換エラーの場合は 。 UnicodeException

例:

// `stdin`を読み込み、`stdout`に書き込む。
import std.stdio;

void main()
{
    string line;
    while ((line = stdin.readln()) !is null)
        write(line);
}

@safe size_t readln(C)(ref C[] buf, dchar terminator = '\n')
if (isSomeChar!C && is(Unqual!C == C) && !is(C == enum));

@safe size_t readln(C, R)(ref C[] buf, R terminator)
if (isSomeChar!C && is(Unqual!C == C) && !is(C == enum) && isBidirectionalRange!R && is(typeof(terminator.front == (dchar).init)));

ファイルハンドルから行を読み込み、それを buf[]に書き込む。 に書き込む。

これは、line = File.readln() よりも高速である。 バッファを再利用できるからである。バッファを再利用するということは、次のことを意味する。 をコピーしなければならない。

Parameters:

C[] buf	結果の行データを格納するためのバッファ。 は必要に応じて拡大され、行を正確に含むスライスに設定される。
dchar terminator	行終端(デフォルトは'\n' )。使用する std.ascii.newlineを使用する。 テキスト・モードで開かれた場合を除く)。

Returns:

0はファイルの終わりを表し、それ以外は読み込んだ文字数を表す。 戻り値は常に buf.length.

Throws:

StdioException UnicodeException に等しくなる。 変換エラーである。

例:

// `stdin`から行を読み込み、文字列に格納する
// '#'で始まる行は無視する
// 文字列を`stdout`に書き込む
import std.stdio;

void main()
{
    string output;
    char[] buf;

    while (stdin.readln(buf))
    {
        if (buf[0] == '#')
            continue;

        output ~= buf;
    }

    write(output);
}

この方法は、前の例のものよりも効率的である。 なぜなら stdin.readln(buf)に割り当てられたメモリを(可能であれば)再利用するからだ。 を再利用するからである。 bufline = stdin.readln() に割り当てられたメモリを(可能であれば)再利用するからである。 に割り当てられたメモリを再利用するからだ。

パフォーマンスをさらに向上させるには readln大きなバッファを渡すことで 大きなバッファを渡すことで、メモリの再割り当てを避けることができる。これは によって返される最大のバッファを再利用することによって行うことができる。 readln:

例:" で返される最大のバッファを再利用することで実現できる。

// `stdin`から行を読み、単語数を数える
import std.array, std.stdio;

void main()
{
    char[] buf;
    size_t words = 0;

    while (!stdin.eof)
    {
        char[] line = buf;
        stdin.readln(line);
        if (line.length > buf.length)
            buf = line;

        words += line.split.length;
    }

    writeln(words);
}

これは実際に byLineである。 を使うことをお勧めする。

uint readf(alias format, Data...)(auto ref Data data)
if (isSomeString!(typeof(format)));

uint readf(Data...)(scope const(char)[] format, auto ref Data data);

を使ってファイルからフォーマットされたデータを読み込む。 std.format.formattedRead.

Parameters:

const(char)[] format	フォーマット文字列。 コンパイル時の引数として渡された場合、この文字列は静的にチェックされる。 される。
Data data	読み込まれる項目。

Returns:

formattedRead と同じ:入力された変数の数。入力範囲r が早く終わった場合、この数は提供された変数の数より少なくなる、 この数は、提供された変数の数より少なくなる。

例:

// test.d
void main()
{
    import std.stdio;
    auto f = File("input");
    foreach (_; 0 .. 3)
    {
        int a;
        f.readf!" %d"(a);
        writeln(++a);
    }
}

% echo "1 2 3" > input
% rdmd test.d
2
3
4

Examples:

static import std.file;

auto deleteme = std.file.deleteme();
std.file.write(deleteme, "hello\nworld\ntrue\nfalse\n");
scope(exit) std.file.remove(deleteme);
string s;
auto f = File(deleteme);
f.readf!"%s\n"(s);
writeln(s); // "hello"
f.readf("%s\n", s);
writeln(s); // "world"

bool b1, b2;
f.readf("%s\n%s\n", b1, b2);
assert(b1 == true && b2 == false);

static @safe File tmpfile();

tmpfileを呼び出して一時ファイルを返す。 作成されたファイルには name.

static @safe File wrapFile(FILE* f);

既存のFILE* をラップする安全でない関数である。その結果、File は決して率先してファイルを閉じない。 作成されたファイルには "注釈:"がないことに注意すること。 name

pure @safe FILE* getFP();

このオブジェクトに対応するFILE* を返す。

const @property @trusted fileno_t fileno();

このオブジェクトに対応するファイル番号を返す。

@property HANDLE windowsHandle();

基礎となるオペレーティング・システムHANDLE を返す(Windows のみ)。

auto byLine(Terminator = char, Char = char)(KeepTerminator keepTerminator = No.keepTerminator, Terminator terminator = '\n')
if (isScalarType!Terminator);

auto byLine(Terminator, Char = char)(KeepTerminator keepTerminator, Terminator terminator)
if (is(immutable(ElementEncodingType!Terminator) == immutable(Char)));

入力範囲を返す ファイルハンドルから1行ずつ読み込むように設定された入力範囲を返す。

範囲の要素型はChar[] となる。範囲プリミティブ は、I/Oエラー時にStdioException をスローすることがある。

注釈: 各front は、popFront が呼び出された後は持続しないので、保持が必要な場合は、呼び出し元がその内容を(例えば そのため、呼び出し元は、保持が必要なときにその内容をコピーしなければならない (たとえば、to!string を呼び出す)。呼び出し側が すべての行のコピーを保持する必要がある場合は byLineCopy関数」を使用する。 を使用する。

Parameters:

Char	各行の文字型、デフォルトはchar 。
KeepTerminator keepTerminator	を使う。 Yes.keepTerminatorを使う。 行末にターミネータを含める場合に使用する。
Terminator terminator	行区切り文字(デフォルトは'\n' )。を使用する。 std.ascii.newlineを使用する。 テキスト・モードで開かれた場合を除く)。

例:

import std.algorithm, std.stdio, std.string;
// 範囲を使ってファイル内の単語を数える。
void main()
{
    auto file = File("file.txt"); // 読み取り用に開く
    const wordCount = file.byLine()            // 行を読む
                          .map!split           // 単語に分割する
                          .map!(a => a.length) // 行ごとに単語を数える
                          .sum();              // 総単語数
    writeln(wordCount);
}

"例

import std.range, std.stdio;
// foreachを使って行を読む。
void main()
{
    auto file = File("file.txt"); // 読み込みのために開く
    auto range = file.byLine();
    // 最初の3行を表示する
    foreach (line; range.take(3))
        writeln(line);
    // '#'で始まる残りの行を表示する
    foreach (line; range)
    {
        if (!line.empty && line[0] == '#')
            writeln(line);
    }
}

どちらの例も、対応する が呼び出された後、その行が返す行データにアクセスしていないことに注意されたい。 front popFront によって返される行データにアクセスしていないことに注意されたい。 内容が変更されている可能性があるからだ)。

auto byLineCopy(Terminator = char, Char = immutable(char))(KeepTerminator keepTerminator = No.keepTerminator, Terminator terminator = '\n')
if (isScalarType!Terminator);

auto byLineCopy(Terminator, Char = immutable(char))(KeepTerminator keepTerminator, Terminator terminator)
if (is(immutable(ElementEncodingType!Terminator) == immutable(Char)));

入力範囲を返す ファイルハンドルから1行ずつ読み込むように設定された を返す。各行は新たに確保される。front はその値をキャッシュする。 をキャッシュし、不要な割り当てをせずに繰り返し呼び出せるようにする。

注釈: キャッシュにより、byLineCopyの方が File.byLine.map!idup.

範囲の要素型はChar[] になる。範囲 プリミティブは、I/Oエラー時にStdioException をスローすることがある。

Parameters:

Char	各行の文字型、デフォルトはimmutable char 。
KeepTerminator keepTerminator	を使用する。 Yes.keepTerminatorを使う。 行末にターミネータを含める場合に使用する。
Terminator terminator	行区切り文字(デフォルトは'\n' )。を使用する。 std.ascii.newlineを使用する。 テキスト・モードで開かれた場合を除く)。

例:

import std.algorithm, std.array, std.stdio;
// ファイルのソートされた行を表示する。
void main()
{
    auto sortedLines = File("file.txt")   // 読み込みのために開く
                       .byLineCopy()      // 持続的な行にする
                       .array()           // 配列にする
                       .sort();           // それからソートする
    foreach (line; sortedLines)
        writeln(line);
}

See Also:

std.file.readText

auto byRecord(Fields...)(string format);

入力範囲を作成する ファイルから1行ずつタプルにパースするように設定する。

RangeプリミティブはI/Oエラー時にStdioException 。

Parameters:

string format

タプルレコード形式

Returns:

1行ずつレコード・タプルにパースするように設定された入力範囲。

See Also:

に似ている。 byLineと似ており 形式を使用している。

Examples:

static import std.file;
import std.typecons : tuple;

// テストファイルを準備する
auto testFile = std.file.deleteme();
scope(failure) printf("Failed test at line %d\n", __LINE__);
std.file.write(testFile, "1 2\n4 1\n5 100");
scope(exit) std.file.remove(testFile);

File f = File(testFile);
scope(exit) f.close();

auto expected = [tuple(1, 2), tuple(4, 1), tuple(5, 100)];
uint i;
foreach (e; f.byRecord!(int, int)("%s %s"))
{
    writeln(e); // expected[i++]
}

auto byChunk(size_t chunkSize);

auto byChunk(ubyte[] buffer);

入力範囲を返す ファイルハンドルから一度に1チャンクずつ読み込むように設定されている。

範囲の要素型はubyte[] となる。範囲プリミティブ は、I/Oエラー時にStdioException をスローすることがある。

例:

void main()
{
    // 一度に4KBの標準入力を読む
    foreach (ubyte[] buffer; stdin.byChunk(4096))
    {
        ... use buffer ...
    }
}

パラメータには、各チャンクの大きさを示す数値(上の例)を指定することができる。 である。あるいは byChunkは を受け取ることもできる。

例:

void main()
{
    // 一度に4KBの標準入力を読む
    foreach (ubyte[] buffer; stdin.byChunk(new ubyte[4096]))
    {
        ... use buffer ...
    }
}

どちらの場合でも、バッファの内容は呼び出しにまたがって再利用される。つまり front つまり、popFront が呼び出された後は、バッファの内容は保持されない。 保持が必要な場合、呼び出し元は(例えば buffer.dup).

上記の例:"、 buffer.lengthを除いて、すべての反復で4096である。 である。 buffer.lengthは4096より小さいかもしれない(ただし 常にゼロより大きい)。

前述の制限付き、 byChunk入力範囲と互換性のある 入力範囲と互換性がある。

例:

// 一度に1MBの効率的なファイルコピー
import std.algorithm, std.stdio;
void main()
{
    stdin.byChunk(1024 * 1024).copy(stdout.lockingTextWriter());
}

std.algorithm.iteration.joinerを使えば、チャンクをひとつの範囲にまとめることができる。 を一つの範囲に結合するのに使うことができる。

例:

import std.algorithm, std.stdio;
void main()
{
    //範囲の幅
    static assert(is(typeof(stdin.byChunk(4096).front) == ubyte[]));
    //要素の範囲
    static assert(is(typeof(stdin.byChunk(4096).joiner.front) == ubyte));
}

Returns:

を呼び出すと byChunkを呼び出すとFile オブジェクトと適切なバッファで初期化された範囲を返す。

Throws:

ユーザが指定したサイズが0であるか、ユーザが指定したバッファが空の場合、 をスローする。 が空の場合、Exception をスローする。 I/O エラーの場合、 をスローする。 StdioException.

@safe auto lockingTextWriter();

作成時にファイルをロックし、スコープ外になるとロックを解除する出力範囲。 をスローする。

Returns:

出力範囲 出力範囲は、文字列型、ubyte[] 、個々の文字型、および個々の sを受け付ける。 ubyte 。

注釈: charsまたはubytesの配列を書き込む方が、範囲から各文字を個別に書き込むよりも速い。 sの配列のどちらかを書く方が速い。大容量のデータの場合、 中間の配列を使ってチャンク単位で書き込むと、速度が向上する。 が高速化する。

Throws:

std.utf.UTFException与えられたデータがchar 。 で、不正なUTFデータを含んでいる。

See Also:

byChunkを例に挙げる。

auto lockingBinaryWriter();

ファイルをロックし、そのファイルへの高速書き込みを可能にする出力範囲を返す。

例: マンデルブロ集合のグレースケール画像 のグレースケール画像をバイナリNetpbmフォーマットで標準出力に出力する。

import std.algorithm, std.complex, std.range, std.stdio;

void main()
{
    enum size = 500;
    writef("P5\n%d %d %d\n", size, size, ubyte.max);

    iota(-1, 3, 2.0/size).map!(y =>
        iota(-1.5, 0.5, 2.0/size).map!(x =>
            cast(ubyte)(1+
                recurrence!((a, n) => x + y * complex(0, 1) + a[n-1]^^2)(complex(0))
                .take(ubyte.max)
                .countUntil!(z => z.re^^2 + z.im^^2 > 4))
        )
    )
    .copy(stdout.lockingBinaryWriter);
}

@property @safe ulong size();

ファイルのサイズをバイト数で返し、ファイルが検索できない場合は "ulong.max"、操作に失敗した場合は throws を返す。

例:

import std.stdio, std.file;

void main()
{
    string deleteme = "delete.me";
    auto file_handle = File(deleteme, "w");
    file_handle.write("abc"); //一時ファイルを作成する
    scope(exit) deleteme.remove; //スコープ終了時に一時ファイルを削除する

    assert(file_handle.size() == 3); //ファイルサイズが3バイトかどうかチェックする
}

enum LockType: int;

File.lock およびFile.tryLock のロック型を指定するために使用される。

read

読み取り(共有)ロックを指定する。読み取りロックは、すべてのプロセス ファイルの指定領域への書き込みアクセスを拒否する。 を含むすべてのプロセスの書き込みアクセスを拒否する。すべてのプロセスは を読むことができる。排他ロックがない限り、複数の同時読み取りロックが許される。 排他ロックがない限り、複数の同時読み取りロックが許可される。

readWrite

読み取り/書き込み(排他的)ロックを指定する。読み取り/書き込みロックは 他のプロセスは、ロックされたファイル領域への読み取りと書き込みの両方のアクセスを拒否する。 セグメントが排他ロックを持つ場合、共有ロックや他の排他ロックを持つことはできない。 または他の排他ロックを持つことはできない。

enum auto isFileHandle(T);

T がファイルハンドルであるかどうかを示す。 に暗黙的に変換可能である。 Fileへのポインタであるかどうかを示す。 core.stdc.stdio.FILE.

Returns:

true T がファイルハンドルの場合、それ以外の場合は へのポインタである。false

Examples:

static assert(isFileHandle!(FILE*));
static assert(isFileHandle!(File));

void write(T...)(T args)
if (!is(T[0] : File));

引数をテキスト形式で標準出力に書き出す(末尾に改行は付けない)。

Parameters:

T args

書き込む項目stdout

Throws:

I/Oエラーの場合はStdioException をスローする。

例: stdin stdout を読み込み、引数 カウンタに書き込む。

import std.stdio;

void main()
{
    string line;

    for (size_t count = 0; (line = readln) !is null; count++)
    {
         write("Input ", count, ": ", line, "\n");
    }
}

void writeln(T...)(T args);

以下と同じ。 write(args, '\n'). 呼び出し writeln引数なしで 引数なしの呼び出しは有効で、標準出力に改行を出力するだけである。 を出力する。

Parameters:

T args

書き込む項目stdout

Throws:

I/Oエラーの場合、"スロー"を投げる。 StdioException.

例:" を投げる。 stdin stdout 、引数 カウンターを返す。

import std.stdio;

void main()
{
    string line;

    for (size_t count = 0; (line = readln) !is null; count++)
    {
         writeln("Input ", count, ": ", line);
    }
}

void writef(alias fmt, A...)(A args)
if (isSomeString!(typeof(fmt)));

void writef(Char, A...)(in Char[] fmt, A args);

フォーマットされたデータを(末尾の改行なしで)標準出力に書き込む。

Parameters:

Char[] fmt	フォーマット文字列。 コンパイル時の引数として渡された場合、この文字列は静的にチェックされる。 される。
A args	書き込む項目。

注釈: 古いバージョンの Phobos では、書き込みが可能であった:

writef(stderr, "%s", "message");

stderrこの構文はサポートされなくなり、次の構文に取って代わられた。 に取って代わられた:

stderr.writef("%s", "message");

void writefln(alias fmt, A...)(A args)
if (isSomeString!(typeof(fmt)));

void writefln(Char, A...)(in Char[] fmt, A args);

writef(fmt, args, '\n') に相当する。

uint readf(alias format, A...)(auto ref A args)
if (isSomeString!(typeof(format)));

uint readf(A...)(scope const(char)[] format, auto ref A args);

を使用してstdin からフォーマットされたデータを読み込む。 std.format.formattedRead.

Parameters:

const(char)[] format	フォーマット文字列。 コンパイル時の引数として渡された場合、この文字列は静的にチェックされる。 される。
A args	読み込まれる項目。

Returns:

formattedRead と同じ:入力された変数の数。入力範囲r が早く終わった場合、この数は提供された変数の数より少なくなる、 この数は、提供された変数の数より少なくなる。

"例" : 入力された変数の数。

// test.d
void main()
{
    import std.stdio;
    foreach (_; 0 .. 3)
    {
        int a;
        readf!" %d"(a);
        writeln(++a);
    }
}

% echo "1 2 3" | rdmd test.d
2
3
4

S readln(S = string)(dchar terminator = '\n')
if (isSomeString!S);

stdin から行を読む。

このバージョンは独自のリード・バッファを管理する。もし 読み取りデータへの参照を保持しないのであれば readln(buf)バージョンを検討されたい。 このバージョンの方が、読み込みバッファを再利用できるため、パフォーマンスが向上する可能性がある。

Returns:

行終端文字を含む、読み込まれた行。

Parameters:

S	テンプレートパラメータ;確保されたバッファの型、および返された型。デフォルトはstring である。
dchar terminator	行終端文字(デフォルトは'\n' )。

注釈: 文字列の終端はサポートされていない。 以下の readln(buf) との曖昧さのため、文字列の終端はサポートされていない。

Throws:

StdioException I/Oエラーの場合は、 、Unicode変換エラーの場合は、 。 UnicodeException

例: stdin を読み込み、stdout に書き込む。

import std.stdio;

void main()
{
    string line;
    while ((line = readln()) !is null)
        write(line);
}

size_t readln(C)(ref C[] buf, dchar terminator = '\n')
if (isSomeChar!C && is(Unqual!C == C) && !is(C == enum));

size_t readln(C, R)(ref C[] buf, R terminator)
if (isSomeChar!C && is(Unqual!C == C) && !is(C == enum) && isBidirectionalRange!R && is(typeof(terminator.front == (dchar).init)));

stdin から行を読み込み、終端文字を含めて buf[] に書き込む。

これは、line = readln() よりも高速である。 バッファを再利用できるからである。バッファを再利用するということは、前の内容を保持したければコピーしなければならないということである。 をコピーしなければならない。

Returns:

size_t ファイル終了の場合は0、そうでない場合は読み込んだ文字数

Parameters:

C[] buf	buf は必要に応じてリサイズされる。
dchar terminator	行終端文字(デフォルトは'\n' )。使用する std.ascii.newline を使用する(ファイルがテキスト・モードでオープンされた場合を除く)。

Throws:

StdioException I/Oエラーの場合は 、Unicode変換エラーの場合は 。 UnicodeException

例: stdin を読み込み、stdout に書き込む。

import std.stdio;

void main()
{
    char[] buf;
    while (readln(buf))
        write(buf);
}

nothrow @nogc @trusted FILE* _popen(R1, R2)(R1 name, R2 mode = "r")
if ((isSomeFiniteCharInputRange!R1 || isSomeString!R1) && (isSomeFiniteCharInputRange!R2 || isSomeString!R2));

に転送する便利な関数である。core.sys.posix.stdio.popen に転送する便利な関数である。

struct lines;

foreach を使ってファイルの行を繰り返し処理する。

例:

void main()
{
  foreach (string line; lines(stdin))
  {
    ... use line ...
  }
}

行終端 ( デフォルトでは'\n' ) は読み込まれる文字列の一部である。 ファイルの最終行で欠落している可能性がある)。いくつかの型がサポートされている。 lineの動作がサポートされている。 lines の動作はそれに応じて変化する:

1. line がstring 、wstring 、dstring のいずれかの型を持つ場合、読み出しのたびにそれぞれの型の新しい文字列が割り当てられる。 の新しい文字列が割り当てられる。
2. line の型がchar[],wchar[],dchar[] の場合、その行の内容は、読み取りごとに再利用(上書き)される。 は、読み取りをまたいで再利用(上書き)される。
3. もしline がimmutable(ubyte)[] 型を持つ場合、動作は(1)と同様である。 case(1)に似ているが、入力時にUTFチェックを行わない点が異なる。
4. line が型ubyte[] を持つ場合、動作は(2)と同様である。 入力時にUTFチェックが試みられないことを除けば、(2)の場合と同様である。 入力時にUTFチェックを試みないことを除けば、動作は(2)と同様である。

すべての場合において、2シンボルのバージョンも受け付ける。 その場合、最初のシンボル(積分型、例えばulong やuint )は、現在の行のゼロベースの番号を追跡する。

例:

  foreach (ulong i, string line; lines(stdin))
  {
    ... use line ...
  }

I/Oエラーが発生した場合、StdioException 。

See Also:

byLine

this(File f, dchar terminator = '\n');

コンストラクタ。

Parameters:

File f	行を読み込むファイル。
dchar terminator	行区切り文字(デフォルトは'\n' )。

auto chunks(File f, size_t size);

foreach を使って、一度に一塊ずつファイルを反復処理する。

例:

void main()
{
    foreach (ubyte[] buffer; chunks(stdin, 4096))
    {
        ... use buffer ...
    }
}

buffer の内容は、通話をまたいで再利用される。上記の例では 上記の例では、buffer.length はすべての反復で4096である、 最後の反復を除いては、buffer.length 。 は4096より小さいかもしれない(ただし、常に0より大きい)。

I/Oエラーの場合、StdioException がスローされる。

void toFile(T)(T data, string fileName)
if (is(typeof(copy(data, stdout.lockingBinaryWriter))));

配列または範囲をファイルに書き込む。 data.copy(File(fileName, "wb").lockingBinaryWriter) の省略形である。 と似ている。 std.file.writeと同様、文字列はそのまま書き込まれる、 と同様に、文字列はFile の方向に従ってエンコードされるのではなく、そのまま書き込まれる。

class StdioException: object.Exception;

I/Oエラーが発生した場合にスローされる。

uint errno;

オペレーティングシステムのエラーコード。

@trusted this(string message, uint e = core.stdc.errno.errno);

メッセージとエラーコードで初期化する。

static @safe void opCall(string msg);

static @safe void opCall();

StdioException をスローする便利関数。

alias stdin = makeGlobal!"core.stdc.stdio.stdin".makeGlobal;

標準入力ストリーム。

Returns:

標準入力ストリーム。 File.

注釈: 返された Fileラップ core.stdc.stdio.stdinをラップする。 はスレッド・グローバルである。別の stdinを別の File への再割り当ては、競合状態を避けるために、シングルスレッドまたはロックされたコンテキストで行われなければならない。 で行われなければならない。

からの読み込みはすべて stdinからの読み込みは、自動的にファイルをグローバルにロックする、 そして、read を呼び出す他のすべてのスレッドは、ロックが解除されるまで待つことになる。 を呼び出すすべてのスレッドを待たせることになる。

Examples:

// 標準入力を読み、行を並べ替え、標準出力に書き出す
import std.algorithm.mutation : copy;
import std.algorithm.sorting : sort;
import std.array : array;
import std.typecons : Yes;

void main()
{
    stdin                       // 標準入力から読み込む
    .byLineCopy(Yes.keepTerminator) // 各行をコピーする
    .array()                    // 行の配列に変換する
    .sort()                     // 行をソートする
    .copy(                      // .sortのコピー出力をOutputRangeに出力する
        stdout.lockingTextWriter()); // 出力範囲
}

alias stdout = makeGlobal!"core.stdc.stdio.stdout".makeGlobal;

標準出力ストリーム。

Returns:

標準出力を File.

注釈: 返された Fileラップ core.stdc.stdio.stdoutをラップする。 はスレッド・グローバルである。別の stdoutを別の File への再割り当ては、競合状態を避けるために、シングルスレッドまたはロックされたコンテキストで行われなければならない。 で行われなければならない。

への書き込みはすべて stdoutへの書き込みは自動的にファイルをグローバルにロックする、 そして、write を呼び出す他のすべてのスレッドは、ロックが解除されるまで待つことになる。 を呼び出すすべてのスレッドを待たせることになる。

Examples:

void main()
{
    stdout.writeln("Write a message to stdout.");
}

Examples:

void main()
{
    import std.algorithm.iteration : filter, map, sum;
    import std.format : format;
    import std.range : iota, tee;

    int len;
    const r = 6.iota
              .filter!(a => a % 2) // 1 3 5
              .map!(a => a * 2) // 2 6 10
              .tee!(_ => stdout.writefln("len: %d", len++))
              .sum;

    writeln(r); // 18
}

Examples:

void main()
{
    import std.algorithm.mutation : copy;
    import std.algorithm.iteration : map;
    import std.format : format;
    import std.range : iota;

    10.iota
    .map!(e => "N: %d".format(e))
    .copy(stdout.lockingTextWriter()); // 出力範囲
}

alias stderr = makeGlobal!"core.stdc.stdio.stderr".makeGlobal;

標準エラーストリーム。

Returns:

標準エラーは File.

注釈: 返された Fileラップ core.stdc.stdio.stderrをラップする。 はスレッド・グローバルである。別の stderrを別の File への再割り当ては、競合状態を避けるために、シングルスレッドまたはロックされたコンテキストで行われなければならない。 で行わなければならない。

への書き込みはすべて stderrへの書き込みは自動的にファイルをグローバルにロックする、 そして、write を呼び出す他のすべてのスレッドは、ロックが解除されるまで待つことになる。 を呼び出すすべてのスレッドを待たせることになる。

Examples:

void main()
{
    stderr.writeln("Write a message to stderr.");
}

File openNetwork(string host, ushort port);

ファイル・インターフェースを介した実験的ネットワーク・アクセス

指定されたホストとポートへのTCP接続をオープンし、同じインターフェイスを介して読み取りと書き込みが可能な を返す。 他のファイルと同じインターフェイスで読み込みと書き込みが可能なFile構造体を返す(つまり、writefとbyLine範囲は動作する!)。

Authors:

Adam D. Ruppe

Bugs:

Linuxでのみ動作する