OSS/tanya
1
0
Fork 0
Code Issues 1 Pull Requests Releases Activity

Remove deprecated traits and queue

Browse Source
This commit is contained in:
Eugen Wissner 2018-04-18 06:34:28 +02:00
parent 3fee712c6c
commit 40c961867e
5 changed files with 47 additions and 480 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
source/tanya/container/package.d
View File

@ -17,7 +17,6 @@ module tanya.container;
public import tanya.container.array; public import tanya.container.array;
public import tanya.container.buffer; public import tanya.container.buffer;
public import tanya.container.list; public import tanya.container.list;
public import tanya.container.queue;
public import tanya.container.set; public import tanya.container.set;
public import tanya.container.string; public import tanya.container.string;

291
source/tanya/container/queue.d
View File

@ -1,291 +0,0 @@
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
/**
* FIFO queue.
*
* Copyright: Eugene Wissner 2016-2018.
* License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
* Mozilla Public License, v. 2.0).
* Authors: $(LINK2 mailto:info@caraus.de, Eugene Wissner)
* Source: $(LINK2 https://github.com/caraus-ecms/tanya/blob/master/source/tanya/container/queue.d,
* tanya/container/queue.d)
*/
deprecated("Use tanya.container.list.DList instead")
module tanya.container.queue;
import tanya.algorithm.mutation;
import tanya.container.entry;
import tanya.exception;
import tanya.memory;
import tanya.meta.trait;
/**
* FIFO queue.
*
* Params:
* T = Content type.
*/
struct Queue(T)
{
/**
* Removes all elements from the queue.
*/
~this()
{
while (!empty)
{
dequeue();
}
}
/**
* Returns how many elements are in the queue. It iterates through the queue
* to count the elements.
*
* Returns: How many elements are in the queue.
*/
size_t length() const
{
size_t len;
for (const(SEntry!T)* i = first; i !is null; i = i.next)
{
++len;
}
return len;
}
///
unittest
{
Queue!int q;
assert(q.length == 0);
q.enqueue(5);
assert(q.length == 1);
q.enqueue(4);
assert(q.length == 2);
q.enqueue(9);
assert(q.length == 3);
q.dequeue();
assert(q.length == 2);
q.dequeue();
assert(q.length == 1);
q.dequeue();
assert(q.length == 0);
}
private void enqueueEntry(ref SEntry!T* entry)
{
if (empty)
{
first = rear = entry;
}
else
{
rear.next = entry;
rear = rear.next;
}
}
private SEntry!T* allocateEntry()
{
auto temp = cast(SEntry!T*) allocator.allocate(SEntry!T.sizeof);
if (temp is null)
{
onOutOfMemoryError();
}
return temp;
}
/**
* Inserts a new element.
*
* Params:
* x = New element.
*/
void enqueue(ref T x)
{
auto temp = allocateEntry();
*temp = SEntry!T.init;
temp.content = x;
enqueueEntry(temp);
}
/// ditto
void enqueue(T x)
{
auto temp = allocateEntry();
moveEmplace(x, (*temp).content);
(*temp).next = null;
enqueueEntry(temp);
}
///
unittest
{
Queue!int q;
assert(q.empty);
q.enqueue(8);
q.enqueue(9);
assert(q.dequeue() == 8);
assert(q.dequeue() == 9);
}
/**
* Returns: $(D_KEYWORD true) if the queue is empty.
*/
@property bool empty() const
{
return first is null;
}
///
unittest
{
Queue!int q;
int value = 7;
assert(q.empty);
q.enqueue(value);
assert(!q.empty);
}
/**
* Move the position to the next element.
*
* Returns: Dequeued element.
*/
T dequeue()
in
{
assert(!empty);
}
do
{
auto n = first.next;
T ret = move(first.content);
allocator.dispose(first);
first = n;
return ret;
}
///
unittest
{
Queue!int q;
q.enqueue(8);
q.enqueue(9);
assert(q.dequeue() == 8);
assert(q.dequeue() == 9);
}
/**
* $(D_KEYWORD foreach) iteration. The elements will be automatically
* dequeued.
*
* Params:
* dg = $(D_KEYWORD foreach) body.
*
* Returns: The value returned from $(D_PARAM dg).
*/
int opApply(scope int delegate(ref size_t i, ref T) @nogc dg)
{
int result;
for (size_t i; !empty; ++i)
{
auto e = dequeue();
if ((result = dg(i, e)) != 0)
{
return result;
}
}
return result;
}
/// ditto
int opApply(scope int delegate(ref T) @nogc dg)
{
int result;
while (!empty)
{
auto e = dequeue();
if ((result = dg(e)) != 0)
{
return result;
}
}
return result;
}
///
unittest
{
Queue!int q;
size_t j;
q.enqueue(5);
q.enqueue(4);
q.enqueue(9);
foreach (i, e; q)
{
assert(i != 2 || e == 9);
assert(i != 1 || e == 4);
assert(i != 0 || e == 5);
++j;
}
assert(j == 3);
assert(q.empty);
j = 0;
q.enqueue(5);
q.enqueue(4);
q.enqueue(9);
foreach (e; q)
{
assert(j != 2 || e == 9);
assert(j != 1 || e == 4);
assert(j != 0 || e == 5);
++j;
}
assert(j == 3);
assert(q.empty);
}
private SEntry!T* first;
private SEntry!T* rear;
mixin DefaultAllocator;
}
///
unittest
{
Queue!int q;
q.enqueue(5);
assert(!q.empty);
q.enqueue(4);
q.enqueue(9);
assert(q.dequeue() == 5);
foreach (i, ref e; q)
{
assert(i != 0 || e == 4);
assert(i != 1 || e == 9);
}
assert(q.empty);
}

54
source/tanya/meta/metafunction.d
View File

@ -44,7 +44,7 @@ import tanya.meta.transform;
* See_Also: $(D_PSYMBOL isLess). * See_Also: $(D_PSYMBOL isLess).
*/ */
template Min(alias pred, Args...) template Min(alias pred, Args...)
if (Args.length > 0 && isTemplate!pred) if (Args.length > 0 && __traits(isTemplate, pred))
{ {
static if (Args.length == 1) static if (Args.length == 1)
{ {
@ -91,7 +91,7 @@ if (Args.length > 0 && isTemplate!pred)
* See_Also: $(D_PSYMBOL isLess). * See_Also: $(D_PSYMBOL isLess).
*/ */
template Max(alias pred, Args...) template Max(alias pred, Args...)
if (Args.length > 0 && isTemplate!pred) if (Args.length > 0 && __traits(isTemplate, pred))
{ {
static if (Args.length == 1) static if (Args.length == 1)
{ {
@ -148,7 +148,7 @@ if (Args.length > 0 && isTemplate!pred)
*/ */
template ZipWith(alias f, Tuples...) template ZipWith(alias f, Tuples...)
if (Tuples.length > 0 if (Tuples.length > 0
&& isTemplate!f && __traits(isTemplate, f)
&& allSatisfy!(ApplyLeft!(isInstanceOf, Tuple), Tuples)) && allSatisfy!(ApplyLeft!(isInstanceOf, Tuple), Tuples))
{ {
private template GetIth(size_t i, Args...) private template GetIth(size_t i, Args...)
@ -448,7 +448,7 @@ if (isInstanceOf!(Set, S1) && isInstanceOf!(Set, S2))
* to $(D_INLINECODE Args[1]), $(D_KEYWORD false) otherwise. * to $(D_INLINECODE Args[1]), $(D_KEYWORD false) otherwise.
*/ */
template isLessEqual(alias cmp, Args...) template isLessEqual(alias cmp, Args...)
if (Args.length == 2 && isTemplate!cmp) if (Args.length == 2 && __traits(isTemplate, cmp))
{ {
private enum result = cmp!(Args[1], Args[0]); private enum result = cmp!(Args[1], Args[0]);
static if (is(typeof(result) == bool)) static if (is(typeof(result) == bool))
@ -495,7 +495,7 @@ if (Args.length == 2 && isTemplate!cmp)
* equal to $(D_INLINECODE Args[1]), $(D_KEYWORD false) otherwise. * equal to $(D_INLINECODE Args[1]), $(D_KEYWORD false) otherwise.
*/ */
template isGreaterEqual(alias cmp, Args...) template isGreaterEqual(alias cmp, Args...)
if (Args.length == 2 && isTemplate!cmp) if (Args.length == 2 && __traits(isTemplate, cmp))
{ {
private enum result = cmp!Args; private enum result = cmp!Args;
static if (is(typeof(result) == bool)) static if (is(typeof(result) == bool))
@ -542,7 +542,7 @@ if (Args.length == 2 && isTemplate!cmp)
* $(D_INLINECODE Args[1]), $(D_KEYWORD false) otherwise. * $(D_INLINECODE Args[1]), $(D_KEYWORD false) otherwise.
*/ */
template isLess(alias cmp, Args...) template isLess(alias cmp, Args...)
if (Args.length == 2 && isTemplate!cmp) if (Args.length == 2 && __traits(isTemplate, cmp))
{ {
private enum result = cmp!Args; private enum result = cmp!Args;
static if (is(typeof(result) == bool)) static if (is(typeof(result) == bool))
@ -589,7 +589,7 @@ if (Args.length == 2 && isTemplate!cmp)
* $(D_INLINECODE Args[1]), $(D_KEYWORD false) otherwise. * $(D_INLINECODE Args[1]), $(D_KEYWORD false) otherwise.
*/ */
template isGreater(alias cmp, Args...) template isGreater(alias cmp, Args...)
if (Args.length == 2 && isTemplate!cmp) if (Args.length == 2 && __traits(isTemplate, cmp))
{ {
private enum result = cmp!Args; private enum result = cmp!Args;
static if (is(typeof(result) == bool)) static if (is(typeof(result) == bool))
@ -637,7 +637,7 @@ if (Args.length == 2)
{ {
static if ((is(typeof(Args[0] == Args[1])) && (Args[0] == Args[1])) static if ((is(typeof(Args[0] == Args[1])) && (Args[0] == Args[1]))
|| (isTypeTuple!Args && is(Args[0] == Args[1])) || (isTypeTuple!Args && is(Args[0] == Args[1]))
|| isSame!Args) || __traits(isSame, Args[0], Args[1]))
{ {
enum bool isEqual = true; enum bool isEqual = true;
} }
@ -804,7 +804,7 @@ alias AliasSeq(Args...) = Args;
* $(D_PARAM F), $(D_KEYWORD false) otherwise. * $(D_PARAM F), $(D_KEYWORD false) otherwise.
*/ */
template allSatisfy(alias F, L...) template allSatisfy(alias F, L...)
if (isTemplate!F) if (__traits(isTemplate, F))
{ {
static if (L.length == 0) static if (L.length == 0)
{ {
@ -842,7 +842,7 @@ if (isTemplate!F)
* $(D_PARAM F), $(D_KEYWORD false) otherwise. * $(D_PARAM F), $(D_KEYWORD false) otherwise.
*/ */
template anySatisfy(alias F, L...) template anySatisfy(alias F, L...)
if (isTemplate!F) if (__traits(isTemplate, F))
{ {
static if (L.length == 0) static if (L.length == 0)
{ {
@ -945,6 +945,32 @@ template canFind(alias T, L...)
static assert(canFind!(3, () {}, uint, 5, 3)); static assert(canFind!(3, () {}, uint, 5, 3));
} }
/*
* Tests whether $(D_PARAM T) is a template.
*
* $(D_PSYMBOL isTemplate) isn't $(D_KEYWORD true) for template instances,
* since the latter already represent some type. Only not instantiated
* templates, i.e. that accept some template parameters, are considered
* templates.
*
* Params:
* T = A symbol.
*
* Returns: $(D_KEYWORD true) if $(D_PARAM T) is a template,
* $(D_KEYWORD false) otherwise.
*/
private enum bool isTemplate(alias T) = __traits(isTemplate, T);
///
@nogc nothrow pure @safe unittest
{
static struct S(T)
{
}
static assert(isTemplate!S);
static assert(!isTemplate!(S!int));
}
/** /**
* Combines multiple templates with logical AND. So $(D_PSYMBOL templateAnd) * Combines multiple templates with logical AND. So $(D_PSYMBOL templateAnd)
* evaluates to $(D_INLINECODE Preds[0] && Preds[1] && Preds[2]) and so on. * evaluates to $(D_INLINECODE Preds[0] && Preds[1] && Preds[2]) and so on.
@ -1049,7 +1075,7 @@ if (allSatisfy!(isTemplate, Preds))
* Returns: Negated $(D_PARAM pred). * Returns: Negated $(D_PARAM pred).
*/ */
template templateNot(alias pred) template templateNot(alias pred)
if (isTemplate!pred) if (__traits(isTemplate, pred))
{ {
enum bool templateNot(T...) = !pred!T; enum bool templateNot(T...) = !pred!T;
} }
@ -1083,7 +1109,7 @@ if (isTemplate!pred)
* if not. * if not.
*/ */
template isSorted(alias cmp, L...) template isSorted(alias cmp, L...)
if (isTemplate!cmp) if (__traits(isTemplate, cmp))
{ {
static if (L.length <= 1) static if (L.length <= 1)
{ {
@ -1359,7 +1385,7 @@ template Reverse(L...)
* Returns: Elements $(D_PARAM T) after applying $(D_PARAM F) to them. * Returns: Elements $(D_PARAM T) after applying $(D_PARAM F) to them.
*/ */
template Map(alias F, T...) template Map(alias F, T...)
if (isTemplate!F) if (__traits(isTemplate, F))
{ {
static if (T.length == 0) static if (T.length == 0)
{ {
@ -1401,7 +1427,7 @@ if (isTemplate!F)
* See_Also: $(LINK2 https://en.wikipedia.org/wiki/Merge_sort, Merge sort). * See_Also: $(LINK2 https://en.wikipedia.org/wiki/Merge_sort, Merge sort).
*/ */
template Sort(alias cmp, L...) template Sort(alias cmp, L...)
if (isTemplate!cmp) if (__traits(isTemplate, cmp))
{ {
private template merge(size_t A, size_t B) private template merge(size_t A, size_t B)
{ {

179
source/tanya/meta/trait.d
View File

@ -150,137 +150,7 @@ enum bool isComplex(T) = is(Unqual!(OriginalType!T) == cfloat)
static assert(!isComplex!real); static assert(!isComplex!real);
} }
/** /*
* POD (Plain Old Data) is a $(D_KEYWORD struct) without constructors,
* destructors and member functions.
*
* Params:
* T = A type.
*
* Returns: $(D_KEYWORD true) if $(D_PARAM T) is a POD type,
* $(D_KEYWORD false) otherwise.
*/
deprecated("Use __traits(isPOD) instead")
enum bool isPOD(T) = __traits(isPOD, T);
///
@nogc nothrow pure @safe unittest
{
struct S1
{
void method()
{
}
}
static assert(!isPOD!S1);
struct S2
{
void function() val; // Function pointer, not a member function.
}
static assert(isPOD!S2);
struct S3
{
this(this)
{
}
}
static assert(!isPOD!S3);
}
/**
* Returns size of the type $(D_PARAM T).
*
* Params:
* T = A type.
*
* Returns: Size of the type $(D_PARAM T).
*/
deprecated("Use T.sizeof instead")
enum size_t sizeOf(T) = T.sizeof;
///
@nogc nothrow pure @safe unittest
{
static assert(sizeOf!(bool function()) == size_t.sizeof);
static assert(sizeOf!bool == 1);
static assert(sizeOf!short == 2);
static assert(sizeOf!int == 4);
static assert(sizeOf!long == 8);
static assert(sizeOf!(void[16]) == 16);
}
/**
* Returns the alignment of the type $(D_PARAM T).
*
* Params:
* T = A type.
*
* Returns: Alignment of the type $(D_PARAM T).
*/
deprecated("Use T.alignof instead")
enum size_t alignOf(T) = T.alignof;
///
@nogc nothrow pure @safe unittest
{
static assert(alignOf!bool == bool.alignof);
static assert(is(typeof(alignOf!bool) == typeof(bool.alignof)));
}
/**
* Tests whether $(D_INLINECODE Args[0]) and $(D_INLINECODE Args[1]) are the
* same symbol.
*
* Params:
* Args = Two symbols to be tested.
*
* Returns: $(D_KEYWORD true) if $(D_PARAM Args) are the same symbol,
* $(D_KEYWORD false) otherwise.
*/
deprecated("Use __traits(isSame) instead")
template isSame(Args...)
if (Args.length == 2)
{
enum bool isSame = __traits(isSame, Args[0], Args[1]);
}
///
@nogc nothrow pure @safe unittest
{
static assert(isSame!("string", "string"));
static assert(!isSame!(string, immutable(char)[]));
}
/**
* Tests whether $(D_PARAM T) is a template.
*
* $(D_PSYMBOL isTemplate) isn't $(D_KEYWORD true) for template instances,
* since the latter already represent some type. Only not instantiated
* templates, i.e. that accept some template parameters, are considered
* templates.
*
* Params:
* T = A symbol.
*
* Returns: $(D_KEYWORD true) if $(D_PARAM T) is a template,
* $(D_KEYWORD false) otherwise.
*/
deprecated("Use __traits(isTemplate) instead")
enum bool isTemplate(alias T) = __traits(isTemplate, T);
///
@nogc nothrow pure @safe unittest
{
static struct S(T)
{
}
static assert(isTemplate!S);
static assert(!isTemplate!(S!int));
}
/**
* Tests whether $(D_PARAM T) is an interface. * Tests whether $(D_PARAM T) is an interface.
* *
* Params: * Params:
@ -289,44 +159,7 @@ enum bool isTemplate(alias T) = __traits(isTemplate, T);
* Returns: $(D_KEYWORD true) if $(D_PARAM T) is an interface, * Returns: $(D_KEYWORD true) if $(D_PARAM T) is an interface,
* $(D_KEYWORD false) otherwise. * $(D_KEYWORD false) otherwise.
*/ */
deprecated("Use is(T == interface) instead") private enum bool isInterface(T) = is(T == interface);
enum bool isInterface(T) = is(T == interface);
/**
* Tests whether $(D_PARAM T) is a class.
*
* Params:
* T = A type.
*
* Returns: $(D_KEYWORD true) if $(D_PARAM T) is a class,
* $(D_KEYWORD false) otherwise.
*/
deprecated("Use is(T == class) instead")
enum bool isClass(T) = is(T == class);
/**
* Tests whether $(D_PARAM T) is a struct.
*
* Params:
* T = A type.
*
* Returns: $(D_KEYWORD true) if $(D_PARAM T) is a struct,
* $(D_KEYWORD false) otherwise.
*/
deprecated("Use is(T == struct) instead")
enum bool isStruct(T) = is(T == struct);
/**
* Tests whether $(D_PARAM T) is a enum.
*
* Params:
* T = A type.
*
* Returns: $(D_KEYWORD true) if $(D_PARAM T) is an enum,
* $(D_KEYWORD false) otherwise.
*/
deprecated("Use is(T == enum) instead")
enum bool isEnum(T) = is(T == enum);
/** /**
* Determines whether $(D_PARAM T) is a polymorphic type, i.e. a * Determines whether $(D_PARAM T) is a polymorphic type, i.e. a
@ -2007,17 +1840,17 @@ alias TemplateOf(alias T : Base!Args, alias Base, Args...) = Base;
static struct S(T) static struct S(T)
{ {
} }
static assert(isSame!(TemplateOf!(S!int), S)); static assert(__traits(isSame, TemplateOf!(S!int), S));
static void func(T)() static void func(T)()
{ {
} }
static assert(isSame!(TemplateOf!(func!int), func)); static assert(__traits(isSame, TemplateOf!(func!int), func));
template T(U) template T(U)
{ {
} }
static assert(isSame!(TemplateOf!(T!int), T)); static assert(__traits(isSame, TemplateOf!(T!int), T));
} }
/** /**
@ -2049,7 +1882,7 @@ template isInstanceOf(alias T, alias I)
{ {
static if (is(typeof(TemplateOf!I))) static if (is(typeof(TemplateOf!I)))
{ {
enum bool isInstanceOf = isSame!(TemplateOf!I, T); enum bool isInstanceOf = __traits(isSame, TemplateOf!I, T);
} }
else else
{ {

2
source/tanya/meta/transform.d
View File

@ -701,7 +701,7 @@ alias TypeOf(T) = T;
/// ditto /// ditto
template TypeOf(alias T) template TypeOf(alias T)
if (isExpressions!T || isTemplate!T) if (isExpressions!T || __traits(isTemplate, T))
{ {
alias TypeOf = typeof(T); alias TypeOf = typeof(T);
} }