voile.misc

ref auto assumeAttr(alias fn, alias attrs, Args...)(auto ref Args args)
if(isFunction!fn);
ref auto assumeAttr(alias fn, alias attrs, Args...)(auto ref Args args)
if(__traits(isTemplate, fn) && isCallable!(fn!Args));
auto assumeAttr(alias attrs, Fn)(Fn t)
if(isFunctionPointer!Fn || isDelegate!Fn);

template getFunctionAttributes(T...)

ref auto assumePure(alias fn, Args...)(auto ref Args args);
auto assumePure(T)(T t)
if(isFunctionPointer!T || isDelegate!T);

ref auto assumeNogc(alias fn, Args...)(auto ref Args args);
auto assumeNogc(T)(T t)
if(isFunctionPointer!T || isDelegate!T);

ref auto assumeNothrow(alias fn, Args...)(auto ref Args args);
auto assumeNothrow(T)(T t)
if(isFunctionPointer!T || isDelegate!T);

@property ref auto assumeUnshared(T)(ref T x);

@property ref auto assumeShared(T)(ref T x);

template nogcEnforce(E : Throwable = Exception) if (is(typeof(new E(string.init, string.init, size_t.init)) : Throwable) || is(typeof(new E(string.init, size_t.init)) : Throwable))
@nogc @safe T nogcEnforce(T, Dg, string file = __FILE__, size_t line = __LINE__)(T value, scope Dg dg)
if(isSomeFunction!Dg && is(typeof(dg())) && is(typeof(() { if (!value) { } } )));

template TemplateSpecializedTypeTuple(T)

CommonType!(staticMap!(ReturnType, T)) variantSwitch(T...)(auto ref Variant var, T caseFunctions);

CommonType!(staticMap!(ReturnType, T)) castSwitch(Base, T...)(Base inst, T caseFunctions);

S indent(S)(S s, S indentStr = "\t");

void truncate(ref File f, size_t fileSize = -1);

void addPathAfter(string newpath);

新しいパスを現在のパスの後ろに追加します

void addPathBefore(string newpath);

新しいパスを現在のパスの前に追加します

string fromMBS(in ubyte[] data, uint codePage = 0);

MBS(ZeroNIL)文字列からUTF8に変換

string fromUTF16z(in wchar* data);

UTF16(ZeroNIL)文字列からUTF8に変換

const(char)[] toMBS(in char[] data, uint codePage = 0);

UTF8からMBS(ZeroNIL)文字列に変換

enum MacroType: int;

str

$xxx, ${xxx}

expr

!!!!! UNDEFINED MACRO: "xxx" !!!!!!

T expandMacro(T, Func)(in T str, Func mapFunc)
if(isSomeString!T && isCallable!Func && is(ReturnType!Func : bool) && (ParameterTypeTuple!Func.length >= 1) && is(T : ParameterTypeTuple!Func[0]) && ((ParameterStorageClassTuple!Func[0] & ParameterStorageClass.ref_) == ParameterStorageClass.ref_));
T expandMacro(T, Func)(in T str, Func mapFunc)
if(isSomeString!T && isCallable!Func && is(ReturnType!Func : T) && (ParameterTypeTuple!Func.length >= 1) && is(T : ParameterTypeTuple!Func[0]));
T expandMacro(T, MAP)(in T str, MAP map)
if(isSomeString!T && is(typeof(() { auto p = T.init in map; T tmp = *p; } )));

Expands macro variables contained within a str

T expandVariable(T, MAP)(in T str, MAP map)
if(isSomeString!T && is(typeof(() { auto p = T.init in map; T var = *p; } )));
T expandVariable(T, Func)(in T str, Func mapFunc)
if(isSomeString!T && isCallable!Func && is(ReturnType!Func : T) && (ParameterTypeTuple!Func.length == 1) && is(T : ParameterTypeTuple!Func[0]));

文字列内に含まれる変数を展開します。

aaa%VAR%bbbのVAR変数を展開します。変数が存在しない場合は何もしません。 VARがxxxであれば、aaaxxxbbbとなります。 VARが存在しなければ、aaa%VAR%bbbのままです。

struct RotationSerial(T, T start = T.min + 1, T end = T.max) if (isIntegral!T && isUnsigned!T);

Examples:

// シリアル値。範囲は10～249の間で、ローテーションする
alias SerialNum = RotationSerial!(ubyte, 10, 250);

// シリアル値はインクリメントで値が増加する
auto ser = SerialNum(10);
++ser;
assert(ser > SerialNum(10));
assert(ser == SerialNum(11));

// 値の範囲の終端まで行くとローテーションする
// ローテーションしても、ローテーション前の値よりは大きくなるという判定を行う。
ser = SerialNum(249);
++ser;
assert(ser > SerialNum(249));
assert(ser == SerialNum(10));

enum auto min;

enum auto max;

this(T val);

bool isUninitialized() const;

bool isValid() const;

T value() const;

ref RotationSerial opUnary(string op)()
if(op == "++");

int opCmp(RotationSerial rhs) const;

auto combinationMatrix(R)(R matrix)
if(isInputRange!R && isInputRange!(ElementType!R));
auto combinationMatrix(K, R)(R[K] matrixAA)
if(isInputRange!R);

Create combinations matrix from specified lists of conditional patterns

Parameters:

R matrix	Matrix of conditional patterns. ex; Input [["1", "2"], ["A", "B"]] Results [["1", "A"], ["1", "B"], ["2", "A"], ["2", "B"]]
R[K] matrixAA	Matrix of conditional patterns. For each column, the name is represented by an associative array key. ex; Input ["P1": ["1", "2"], "P2": ["A", "B"]] Results [["P1": "1", "P2": "A"], ["P1": "1", "P2": "B"], ["P1": "2", "P2": "A"], ["P1": "2", "P2": "B"]]

Returns: Matrix of combination

Examples:

assert(combinationMatrix([["a", "b"], ["A", "B", "C"], ["1", "2"]]).equal([
	["a", "A", "1"],
	["a", "A", "2"],
	["a", "B", "1"],
	["a", "B", "2"],
	["a", "C", "1"],
	["a", "C", "2"],
	["b", "A", "1"],
	["b", "A", "2"],
	["b", "B", "1"],
	["b", "B", "2"],
	["b", "C", "1"],
	["b", "C", "2"],
]));

Examples:

assert(combinationMatrix(["P1": ["a", "b"], "P2": ["A", "B", "C"], "P3": ["1", "2"]]).equal([
	["P1": "a", "P2": "A", "P3": "1"],
	["P1": "a", "P2": "A", "P3": "2"],
	["P1": "a", "P2": "B", "P3": "1"],
	["P1": "a", "P2": "B", "P3": "2"],
	["P1": "a", "P2": "C", "P3": "1"],
	["P1": "a", "P2": "C", "P3": "2"],
	["P1": "b", "P2": "A", "P3": "1"],
	["P1": "b", "P2": "A", "P3": "2"],
	["P1": "b", "P2": "B", "P3": "1"],
	["P1": "b", "P2": "B", "P3": "2"],
	["P1": "b", "P2": "C", "P3": "1"],
	["P1": "b", "P2": "C", "P3": "2"],
]));

auto shuffle(R)(R ary)
if(isRandomAccessRange!R);

Shuffle elements of specified range

@trusted T get(T, ST)(ref ST value, lazy T defaultValue = T.init)
if(isSumType!ST);
@trusted const(T) get(T, ST)(in ST value, lazy T defaultValue = T.init)
if(isSumType!ST);

Check if the SumType contains a value

EditOp[] myersdiff(bool calcCollapseSubStitute = false, Range)(Range lhs, Range rhs)
if(isRandomAccessRange!Range || isSomeString!Range);

alias diff = myersdiff(bool calcCollapseSubStitute = false, Range)(Range lhs, Range rhs) if (isRandomAccessRange!Range || isSomeString!Range);

Myers' diff

lhs を rhs に変換する操作列を返す

Parameters:

Range lhs	編集前入力シーケンス
Range rhs	編集後入力シーケンス
calcCollapseSubStitute	trueの場合、戻り値にEditOp.substituteが含まれるようになる

Returns: 編集操作列(EditOpの配列)