Mercurial > projects > ldc
view lphobos/std/traits.d @ 310:d20cf0dec9c1 trunk
[svn r331] Fixed, forgot to default initialize the SynchronizedStatement enclosinghandler.
author | lindquist |
---|---|
date | Sat, 28 Jun 2008 11:50:28 +0200 |
parents | 61615fa85940 |
children | 373489eeaf90 |
line wrap: on
line source
// Written in the D programming language. /** * Templates with which to extract information about * types at compile time. * * Macros: * WIKI = Phobos/StdTraits * Copyright: * Public Domain */ /* * Authors: * Walter Bright, Digital Mars, www.digitalmars.com * Tomasz Stachowiak (isStaticArray, isExpressionTuple) */ module std.traits; /*** * Get the type of the return value from a function, * a pointer to function, or a delegate. * Example: * --- * import std.traits; * int foo(); * ReturnType!(foo) x; // x is declared as int * --- */ template ReturnType(alias dg) { alias ReturnType!(typeof(dg)) ReturnType; } /** ditto */ template ReturnType(dg) { static if (is(dg R == return)) alias R ReturnType; else static assert(0, "argument has no return type"); } /*** * Get the types of the paramters to a function, * a pointer to function, or a delegate as a tuple. * Example: * --- * import std.traits; * int foo(int, long); * void bar(ParameterTypeTuple!(foo)); // declares void bar(int, long); * void abc(ParameterTypeTuple!(foo)[1]); // declares void abc(long); * --- */ template ParameterTypeTuple(alias dg) { alias ParameterTypeTuple!(typeof(dg)) ParameterTypeTuple; } /** ditto */ template ParameterTypeTuple(dg) { static if (is(dg P == function)) alias P ParameterTypeTuple; else static if (is(dg P == delegate)) alias ParameterTypeTuple!(P) ParameterTypeTuple; else static if (is(dg P == P*)) alias ParameterTypeTuple!(P) ParameterTypeTuple; else static assert(0, "argument has no parameters"); } /*** * Get the types of the fields of a struct or class. * This consists of the fields that take up memory space, * excluding the hidden fields like the virtual function * table pointer. */ template FieldTypeTuple(S) { static if (is(S == struct) || is(S == class)) alias typeof(S.tupleof) FieldTypeTuple; else static assert(0, "argument is not struct or class"); } /*** * Get a TypeTuple of the base class and base interfaces of * this class or interface. * Example: * --- * import std.traits, std.typetuple, std.stdio; * interface I { } * class A { } * class B : A, I { } * * void main() * { * alias BaseTypeTuple!(B) TL; * writefln(typeid(TL)); // prints: (A,I) * } * --- */ template BaseTypeTuple(A) { static if (is(A P == super)) alias P BaseTypeTuple; else static assert(0, "argument is not a class or interface"); } unittest { interface I { } class A { } class B : A, I { } alias BaseTypeTuple!(B) TL; assert(TL.length == 2); assert(is (TL[0] == A)); assert(is (TL[1] == I)); } /* ******************************************* */ template isStaticArray_impl(T) { const T inst = void; static if (is(typeof(T.length))) { static if (!is(typeof(T) == typeof(T.init))) { // abuses the fact that int[5].init == int static if (is(T == typeof(T[0])[inst.length])) { // sanity check. this check alone isn't enough because dmd complains about dynamic arrays const bool res = true; } else const bool res = false; } else const bool res = false; } else { const bool res = false; } } /** * Detect whether type T is a static array. */ template isStaticArray(T) { const bool isStaticArray = isStaticArray_impl!(T).res; } static assert (isStaticArray!(int[51])); static assert (isStaticArray!(int[][2])); //static assert (isStaticArray!(char[][int][11])); static assert (!isStaticArray!(int[])); //static assert (!isStaticArray!(int[char])); static assert (!isStaticArray!(int[1][])); template isArray(T) { const bool isArray=false; } template isArray(T: T[]) { const bool isArray=true; } /** * Tells whether the tuple T is an expression tuple. */ template isExpressionTuple(T ...) { static if (is(void function(T))) const bool isExpressionTuple = false; else const bool isExpressionTuple = true; }