Changeset 1898

Timestamp:

08/19/10 00:53:05 (14 years ago)

Author:

dsimcha

Message:

Bug 4346: More flexible std.array.array. Also improve std.array.array to work better with immutable narrow strings and use emplace() instead of placement new.

Files:

• trunk/docsrc/changelog.dd (modified) (1 diff)
• trunk/phobos/std/array.d (modified) (3 diffs)

trunk/docsrc/changelog.dd

@@ -27 +27 @@
-    $(LI $(BUGZILLA 3312): std.string.count should use const(char)[], not immutable.)
-    $(LI $(BUGZILLA 3348): Documentation for many std.process functions has disappeared)
-    $(LI $(BUGZILLA 3361): code in std.zlib concatenates void[] arrays )
-    $(LI $(BUGZILLA 3877): std.range.chain do not manage infinite ranges correctly)
-    $(LI $(BUGZILLA 3894): std.range.Stride!R requires R.front() and R.back() to return by reference)
-    $(LI $(BUGZILLA 3946): schwartzSort - SwapStrategy always unstable)
-    $(LI $(BUGZILLA 4402): std.range.Zip doesn't work w/ non-lvalue ranges.)
-    $(LI $(BUGZILLA 4408): Ambiguity when using std.algorithm.splitter with generic ranges.)
-    $(LI $(BUGZILLA 4292): CommonType fails for singular alias value.)
-    $(LI $(BUGZILLA 4345): std.range.take!string: "Nonsensical finite range with slicing but no length".)
+    $(LI $(BUGZILLA 4345): More flexible std.array.array.)
-    $(LI $(BUGZILLA 4363): Some phobos ranges are not forward ranges (but should be).)
-    $(LI $(BUGZILLA 4381): Length attribute for std.typecons.Tuple.)
-    $(LI $(BUGZILLA 4387): std.range.Cycle assumes lvalue elements.)
-    $(LI $(BUGZILLA 4388): std.range.Radial assumes lvalue elements.)
-    $(LI $(BUGZILLA 4403): std.range.FrontTransversal assumes lvalue elements.)
-    $(LI $(BUGZILLA 4404): std.range.Transversal assumes lvalue elements.)
-    $(LI $(BUGZILLA 4455): Taking the sqrt of an integer shouldn't require an explicit cast.)
-    $(LI $(BUGZILLA 4464):  std.range.take does not always return Take!R.)
-    )
-)

trunk/phobos/std/array.d

@@ -12 +12 @@
-*/
-module std.array;
-
-import std.c.stdio;
-import core.memory;
-import std.algorithm, std.conv, std.encoding, std.exception, std.range,
-    std.string, std.traits, std.typecons, std.utf;
-version(unittest) private import std.stdio;
-
-/**
-
-
+
+
+
+
-
-Example:
-
-----
-auto a = array([1, 2, 3, 4, 5][]);
-assert(a == [ 1, 2, 3, 4, 5 ]);
-----
- */
-
-
-
+
+
+
+
-    static if (hasLength!Range)
-    {
-        if (r.empty) return null;
-
-        // Determines whether the GC should scan the array.
-        auto blkInfo = (typeid(E).flags & 1) ?
-                       cast(GC.BlkAttr) 0 :
-                       GC.BlkAttr.NO_SCAN;
-
-        auto result = (cast(E*) enforce(GC.malloc(r.length * E.sizeof, blkInfo),
-                text("Out of memory while allocating an array of ", r.length,
-                        " objects of type ", E.stringof)))[0 .. r.length];
-
+
+
-        {
-            // hacky
-&e.opAssign
+e.opAssign(e)
-            {
-                // this should be in-place construction
-
+
+
-            }
-            else
-            {
-e = r.front
+result[i] = e
-            }
-r.popFront
+i++
-        }
-        return result;
-    }
-    else
-    {
-        auto a = appender!(E[])();
-        foreach (e; r)
-        {
-            a.put(e);
-        }
@@ -97 +102 @@
-    //     {
-    //         result[constructedElements] = src;
-    //     }
-    //     ++constructedElements;
-    // }
-    // // 3. Success constructing all elements, type the array and return it
-    // setTypeInfo(typeid(E), result);
-    // return result[0 .. constructedElements];
-}
-
+/**
+Convert a narrow string to an array type that fully supports random access.
+This is handled as a special case and always returns a $(D dchar[]),
+$(D const(dchar)[]), or $(D immutable(dchar)[]) depending on the constness of
+the input.
+*/
+ElementType!String[] array(String)(String str) if(isNarrowString!String)
+{
+    static if(is(typeof(return) == immutable))
+    {
+        return to!(immutable(dchar)[])(str);
+    }
+    else static if(is(typeof(return) == const))
+    {
+        return to!(const(dchar)[])(str);
+    }
+    else
+    {
+        return to!(dchar[])(str);
+    }
+}
+
-version(unittest)
-{
-    struct TestArray { int x; string toString() { return .to!string(x); } }
+
+    struct OpAssign
+    {
+        uint num;
+        this(uint num) { this.num = num; }
+
+        // Templating opAssign to make sure the bugs with opAssign being
+        // templated are fixed.
+        void opAssign(T)(T rhs) { this.num = rhs.num; }
+    }
+
+    struct OpApply
+    {
+        int opApply(int delegate(ref int) dg)
+        {
+            int res;
+            foreach(i; 0..10)
+            {
+                res = dg(i);
+                if(res) break;
+            }
+
+            return res;
+        }
+    }
-}
-
-unittest
-{
-    auto a = array([1, 2, 3, 4, 5][]);
-    //writeln(a);
-    assert(a == [ 1, 2, 3, 4, 5 ]);
-
-    auto b = array([TestArray(1), TestArray(2)][]);
-    //writeln(b);
@@ -123 +175 @@
-        int x;
-        this(int y) { x = y; }
-        override string toString() { return .to!string(x); }
-    }
-    auto c = array([new C(1), new C(2)][]);
-    //writeln(c);
-
-    auto d = array([1., 2.2, 3][]);
-    assert(is(typeof(d) == double[]));
-    //writeln(d);
+
+    auto e = [OpAssign(1), OpAssign(2)];
+    auto f = array(e);
+    assert(e == f);
+
+    assert(array(OpApply.init) == [0,1,2,3,4,5,6,7,8,9]);
+    assert(array("ABC") == "ABC"d);
+    assert(array("ABC".dup) == "ABC"d.dup);
-}
-
-template IndexType(C : T[], T)
-{
-    alias size_t IndexType;
-}
-
-unittest
-{
-    static assert(is(IndexType!(double[]) == size_t));